npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

copilot-api-node20

v0.49.5

Published

Turn GitHub Copilot or Microsoft Foundry into an OpenAI/Anthropic API compatible server. Usable with Claude Code! (Node v20+ fork)

Readme

copilot-api

npm version downloads Node.js GitHub Closed Source License: MIT

A proxy server that turns a GitHub Copilot subscription into fully compatible OpenAI and Anthropic API endpoints. Use Claude Code, Claude Cowork, Codex CLI, and any tool that speaks the API -- all through the Copilot plan you already pay for, no separate API keys required.

Want Claude Code on GPT and other non-Claude models? Pick one from your Copilot plan, or serve your own Microsoft Foundry / Azure OpenAI deployments with --provider foundry, signing in with an API key or Entra ID. Add --fallback copilot and Copilot answers whenever Foundry throttles, fails or times out. See Microsoft Foundry.

  Clients                        Proxy                         Backends
  ───────                        ─────                         ────────

  Claude Code   ─┐                                        ┌─▶ GitHub Copilot API
  Claude Cowork ─┤  /v1/messages     ┌─────────────┐      │     Messages
  Codex CLI     ─┤───── or ─────────▶│ copilot-api │──────┤     Chat Completions
  OpenAI SDK    ─┤  /v1/chat/        └─────────────┘      │     Responses API
  curl          ─┤  completions                           │     Embeddings
  Any tool      ─┘                                        │     Images
                                                          │     Decisions
                                                          │
                                                          ├─▶ Microsoft Foundry /
                                                          │   Azure OpenAI
                                                          │   (--provider foundry)
                                                          └─▶ Web Search
                                                              (Tavily / Exa)

Table of Contents


Key Features

| Feature | Description | |:--|:--| | Full Claude Code support | All Claude models, streaming, extended thinking, and the complete 1M token context window | | Claude Cowork support | Run Claude's desktop app through Copilot — one-command setup via Tailscale for zero-trust-hassle HTTPS | | Full Codex CLI support | Complete OpenAI Responses API implementation purpose-built for Codex CLI | | Claude Code on non-Claude models | GPT and other models from Copilot or Foundry, translated to the Anthropic API, with tools, streaming and keepalive pings while the model thinks | | Microsoft Foundry / Azure OpenAI | Your own Azure deployments with --provider foundry: API key or Entra ID (az login, managed identity, service principal), no GitHub account needed | | Copilot fallback | --fallback copilot: Copilot answers when Foundry rate-limits, errors or times out, and finishes a Claude Code turn on an OpenAI deployment whose stream fails before any output; then traffic moves back to Foundry | | Web search | Optional web search for Claude Code and Codex sessions, via Tavily and/or Exa with automatic failover | | Image generation & editing | OpenAI Images API on Copilot's GPT Image 2.5 Flare: text-to-image, edits and multi-image composition, exact text rendering, transparent PNGs — see Image Generation | | Decision models | OpenAI Decisions API (/v1/decisions) on Copilot's GPT-6 Luna Decisions: yes/no, choice and score questions about text and images, each answer with a probability — see Decision Models | | Dual API compatibility | OpenAI Chat Completions, Anthropic Messages, and OpenAI Responses APIs side by side | | HTTPS with auto-generated certs | Self-signed TLS certs with configurable SANs -- works across VMs, containers, and LAN | | Zero configuration | Single command to start -- authenticates via GitHub device-code OAuth |


Quick Start

Prerequisites: Node.js 20+ (or Bun) and an active GitHub Copilot subscription.

Claude Code

Start the proxy with Claude Code mode:

npx copilot-api-node20@latest start --claude-code

On first run, you authenticate via GitHub device-code OAuth. Once authenticated, the proxy starts on http://localhost:4141 and prints a ready-to-paste command. In another terminal:

ANTHROPIC_BASE_URL=http://localhost:4141 claude

To skip the interactive model picker, specify models upfront:

npx copilot-api-node20@latest start \
  --claude-code \
  --model claude-opus-4.6-1m \
  --small-model claude-haiku-4.5

Codex CLI

Start the proxy with Codex mode:

npx copilot-api-node20@latest start --codex --model gpt-5.6-sol

Configure ~/.codex/config.toml:

model = "gpt-5.6-sol"
model_provider = "local"

[model_providers.local]
name = "Local Server"
base_url = "http://localhost:4141/v1"
wire_api = "responses"
requires_openai_auth = false

[model_providers.local.http_headers]
Authorization = "Bearer dummy"

Then run:

codex

Web Search

Web search tool calls (in both Claude Code and Codex sessions) are served by one or more search providers. Configure providers via environment variables — the proxy operates normally when none are set (web search is simply unavailable).

| Provider | Env var | Free tier | | --- | --- | --- | | Tavily | TAVILY_API_KEY | 1,000 searches/mo | | Exa | EXA_API_KEY | 1,000 searches/mo |

Set one or both — web search works with a single provider, and configuring two enables automatic failover.

TAVILY_API_KEY=<key> EXA_API_KEY=<key> npx copilot-api-node20@latest start --claude-code

When more than one provider is configured, searches run against them in order and fail over to the next provider on error or timeout. Control the order with --web-search-provider (comma-separated, primary first); it defaults to all configured providers, Tavily first:

# Prefer Exa, fall back to Tavily
EXA_API_KEY=<key> TAVILY_API_KEY=<key> \
  npx copilot-api-node20@latest start --claude-code --web-search-provider exa,tavily

The --tavily-api-key flag is deprecated — it still works and is equivalent to TAVILY_API_KEY, but prints a deprecation warning on startup. Prefer the environment variables, which also keep keys out of the process list.

Image Generation

Copilot now serves an image model, GPT Image 2.5 Flare (gpt-image-2.5-flare, preview). The proxy exposes it through the standard OpenAI Images API, so any OpenAI SDK or tool that generates images works unchanged — no extra flags.

Generate an image:

curl -s http://localhost:4141/v1/images/generations \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "A red fox reading a newspaper at a beach cafe, watercolor",
    "size": "1024x1024",
    "quality": "medium"
  }' | jq -r '.data[0].b64_json' | base64 --decode > fox.png

Edit an image (or combine several — repeat image[]). JSON edits with images: [{"image_url": "data:..."}], as Codex sends them, work too:

curl -s http://localhost:4141/v1/images/edits \
  -F model=gpt-image-2.5-flare \
  -F prompt="Give the fox a straw sun hat" \
  -F "image[][email protected]" \
  | jq -r '.data[0].b64_json' | base64 --decode > fox-hat.png

With the OpenAI Python SDK:

import base64
from openai import OpenAI

client = OpenAI(base_url="http://localhost:4141/v1", api_key="dummy")
img = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="A minimalist poster that says 'HELLO WORLD'",
    size="1024x1536",
    quality="high",
)
open("poster.png", "wb").write(base64.b64decode(img.data[0].b64_json))

| Option | Values | |:--|:--| | size | 1024x1024, 1024x1536, 1536x1024, or a custom size up to 3840×2160 (4K): longest edge ≤ 3840, aspect ratio 1:3 to 3:1, both sides divisible by 16 | | quality | low, medium, high (about 8–16 s per image at 1K, up to ~35 s at 4K) | | output_format | png, jpeg (with output_compression) | | background | transparent for PNGs with an alpha channel | | n | Several images per request |

Good to know:

  • Images are billed by Copilot as AI credits, separately from chat models — roughly 0.6 (low) to 4 (high) credits per 1024×1024 image, and about 10 for a high-quality 4K image.
  • Available on Copilot Pro, Pro+, Business and Enterprise (not Free or Student). Organization admins can turn it off with the model policy.
  • gpt-image-2.5-flare works only on the Images endpoints, not on Chat Completions or Responses. Streaming (stream: true) is not supported by Copilot yet.
  • Edit uploads are limited to 100 MB per request. Image endpoints are Copilot-only (not available with --provider foundry).
  • Under Node, the proxy sees an image client disconnect during the --rate-limit --wait delay or the admission queue wait at once only when the unread body is small (below about 48 KB on Node 20 and about 100 KB on Node 22 and 24). With a larger upload the disconnect does not end the wait. The wait ends as it does for a client that stays, at the latest when the rate-limit window or the queue timeout ends (COPILOT_API_IMAGES_QUEUE_TIMEOUT_MS, default 45 s). When the request is admitted after the wait, the proxy sees the disconnect when it reads the rest of the body. When the wait ends in a 503 (queue timeout or memory pressure), the proxy does not read the body: it drains it in the background, or closes the connection when no drain slot is free. A model-first upload can start its upstream call before that, and the disconnect then cancels the upload. Under Bun the disconnect ends the wait at once for all sizes.
  • Image requests need memory. In a container, give the proxy a memory limit of at least about 600 MB for one image request at a time, and 1.5 GB is recommended. Below about 490 MB, the image budget is too small for some image requests (JSON requests without a Content-Length first, then generations, then all of them below about 470 MB): the proxy logs an error line at startup and at the first image request, and answers those requests with 503 images_unavailable and x-should-retry: false. COPILOT_API_IMAGES_MEMORY_BUDGET_MB sets the image budget directly.

Decision Models

Copilot also serves a decision model, GPT-6 Luna Decisions (gpt-6-luna-decisions). It does not write text. It answers predicate (yes/no), choice and score questions about your input and returns a probability for each answer. The proxy exposes it through the OpenAI Decisions API (POST /v1/decisions). The request goes to Copilot unchanged, so the OpenAI Decisions guide applies, with one change: the guide examples use "model": "gpt-6-luna", but on Copilot that name is a chat model and /v1/decisions rejects it with model_not_supported. Send "model": "gpt-6-luna-decisions". The decision model does not work on /v1/chat/completions, /v1/responses or /v1/messages.

curl -s http://localhost:4141/v1/decisions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna-decisions",
    "input": "I was charged twice for my order.",
    "questions": [
      {"type": "choice", "name": "department", "instructions": "Which team should handle this?",
       "choices": [{"value": "billing"}, {"value": "technical"}]},
      {"type": "predicate", "name": "angry", "instructions": "Is the customer angry?"}
    ]
  }'
# {"answers":[{"type":"choice","name":"department","choice":"billing","confidence":1,...},
#             {"type":"predicate","name":"angry","probability":0.42}],"usage":{...}}

Claude Cowork

Use Claude's desktop app (Cowork) with your Copilot subscription. Requires Tailscale (free for personal use) for a real Let's Encrypt TLS certificate — no self-signed cert headaches.

1. Install Tailscale and sign in. On macOS, use the App Store or .pkg download (not brew). See docs/claude-cowork.md for Linux/Windows.

2. Generate a TLS cert and configure the proxy:

npx copilot-api-node20@latest cowork-setup install
npx copilot-api-node20@latest start --claude-cowork

3. Follow Anthropic's Cowork 3P Installation guide. When prompted for the gateway URL, paste the Tailscale hostname from the startup banner (e.g. https://your-machine.tail12345.ts.net:4141), then restart Cowork.

Run cowork-setup doctor at any time to diagnose issues:

npx copilot-api-node20@latest cowork-setup doctor

See docs/claude-cowork.md for the full setup guide and troubleshooting. For Cowork's own configuration docs, see Claude Cowork 3P Installation.

Microsoft Foundry / Azure OpenAI

Point the proxy at your own Azure resource instead of GitHub Copilot. No GitHub account or Copilot subscription is needed:

export FOUNDRY_ENDPOINT=https://<resource>.openai.azure.com
export FOUNDRY_API_KEY=<key>      # or omit it and `az login` for Entra ID
npx copilot-api-node20@latest start --provider foundry

Then launch Claude Code with a deployment name as the model:

ANTHROPIC_BASE_URL=http://localhost:4141 ANTHROPIC_AUTH_TOKEN=dummy \
  ANTHROPIC_DEFAULT_HAIKU_MODEL=<fast-deployment> \
  claude --model <deployment>

The model you ask for is the model you get: the proxy never renames or substitutes one. It routes by model family:

| Model family | Served by | |:--|:--| | Claude | Your resource's native /anthropic/v1/messages, forwarded byte for byte | | OpenAI (gpt-*, o*, codex) | /openai/v1/responses (translated for Claude Code) | | Others (DeepSeek, Grok, …) | /openai/v1/chat/completions |

Sign-in: by default, with FOUNDRY_API_KEY set the proxy uses the key. Without it, it uses Entra ID through the Azure SDK, so az login, a managed identity or a service principal all work (FOUNDRY_AUTH=key|entra picks one explicitly). The identity needs Cognitive Services OpenAI User (GPT) or Azure AI User (Claude) on the resource. See Authentication.

Have a Copilot subscription too? Add --fallback copilot. When Foundry rate-limits (429), fails (408, 500, 502, 503 or 504), times out or drops the connection, Copilot answers the same request. For Claude Code on an OpenAI deployment, a Foundry stream that fails before any text or tool call reaches it is finished by Copilot as well. The model stays on Copilot for Foundry's retry-after (initially 10 seconds without one), then goes back. See Copilot fallback.

Codex works with the usual config.toml (see Codex CLI) with model set to a deployment name. See docs/foundry.md for configuration, routing details, reasoning effort, and troubleshooting (including NODE_EXTRA_CA_CERTS behind TLS-inspecting corporate proxies).

First run & troubleshooting

On a successful start the proxy runs a one-shot self-test generation and prints the result, so you know immediately whether everything works end-to-end — you'll see something like:

Self-test passed — generation works via claude-haiku-4.5 (612ms). Point your client at http://127.0.0.1:4141

If it fails, the line tells you why (e.g. no Copilot entitlement, premium quota exhausted, model not supported on your plan). It spends one generation per boot (preferring a cheap, non-premium model when available); disable it with --no-smoke-test (or COPILOT_API_NO_SMOKE_TEST=1) — e.g. in CI or if you restart frequently.

Stuck? Run the doctor. It checks your token, auth, Copilot entitlement, model catalog, and one real generation, then tells you exactly what to fix:

npx copilot-api-node20@latest doctor

Quick smoke test from another terminal (no client needed):

curl http://localhost:4141/v1/chat/completions \
  -H 'content-type: application/json' \
  -d '{"model":"claude-haiku-4.5","messages":[{"role":"user","content":"ping"}],"max_tokens":1}'

| Symptom | Likely cause | Fix | |:--|:--|:--| | Client connects but nothing happens | Client not pointed at the proxy | Set the base URL (see below); run doctor | | 400 ... model is not supported | Premium model not entitled on your plan | Use claude-haiku-4.5, or check entitled models with doctor | | 402 quota_exceeded | Monthly premium quota used up | Switch to a non-premium model (haiku) or wait for reset | | 404 on /v1/v1/... | Base URL already ends in /v1 | Drop the trailing /v1 from your client's base URL | | Works locally but not from Docker/another machine | Bound to localhost | Start with --hostname 0.0.0.0 |

Client base URLs — Claude Code: ANTHROPIC_BASE_URL=http://localhost:4141; Codex: OPENAI_BASE_URL=http://localhost:4141/v1; OpenAI SDKs: baseURL: "http://localhost:4141/v1". See docs/getting-started.md for the full per-client setup, the entitled-model matrix, and detailed troubleshooting.


API Endpoints

All endpoints are served at http://localhost:4141 by default (https:// when --https or --claude-cowork is used). The server binds to 127.0.0.1 (localhost only) by default. To expose to LAN/network/Docker, pass --hostname 0.0.0.0.

| Method | Path | Purpose | |:--|:--|:--| | GET | / | Basic server-running response | | GET | /health | Proxy, token, and upstream health status | | POST | /v1/chat/completions | OpenAI Chat Completions | | POST | /chat/completions | OpenAI Chat Completions without the /v1 prefix | | POST | /v1/responses | OpenAI Responses API | | POST | /responses | OpenAI Responses API without the /v1 prefix | | POST | /v1/responses/input_tokens, /responses/input_tokens | OpenAI Responses token count: a local estimate of the instructions, input, function and custom tools and a json_schema output format (no upstream call; images, files, audio and server-side context such as previous_response_id are not counted) | | POST | /v1/messages | Anthropic Messages | | POST | /v1/messages/count_tokens | Anthropic Token Counting | | POST | /v1/embeddings | OpenAI Embeddings | | POST | /embeddings | OpenAI Embeddings without the /v1 prefix | | POST | /v1/images/generations | OpenAI Images: generate (for example gpt-image-2.5-flare) | | POST | /v1/images/edits | OpenAI Images: edit (multipart/form-data, 100 MB body limit) | | POST | /images/generations, /images/edits | OpenAI Images without the /v1 prefix | | POST | /v1/decisions | OpenAI Decisions API (for example gpt-6-luna-decisions) | | POST | /decisions | OpenAI Decisions API without the /v1 prefix | | GET | /v1/models | OpenAI Models | | GET | /models | OpenAI Models without the /v1 prefix | | GET | /usage | GitHub Copilot usage and quota information | | GET | /token | Copilot token debug endpoint; disabled unless started with --show-token |


CLI Reference

Commands

| Command | Description | |:--|:--| | copilot-api start | Start the proxy server | | copilot-api auth | Authenticate with GitHub | | copilot-api check-usage | Display Copilot usage quota (credits, spend, burn rate) | | copilot-api check-usage --watch | Same, refreshed on an interval (--interval <seconds>, default 60, min 10) | | copilot-api doctor | Diagnose your setup end-to-end (token, auth, entitlement, models, one real generation) and print exact fixes | | copilot-api debug | Print diagnostic information | | copilot-api cowork-setup | Manage Claude Cowork OS-level setup |

start Flags

--claude-code and --codex are mutually exclusive.

| Flag | Alias | Default | Description | |:--|:--|:--|:--| | --provider | | copilot | Upstream: copilot, or foundry for Microsoft Foundry / Azure OpenAI (reads FOUNDRY_ENDPOINT, plus FOUNDRY_API_KEY or an Entra ID login; see docs/foundry.md). Also COPILOT_API_PROVIDER | | --fallback | | | With --provider foundry: copilot answers from GitHub Copilot when Foundry rate-limits, fails or times out (and, for Claude Code on an OpenAI deployment, when a Foundry stream fails before any output), and keeps that model there for Foundry's retry-after, or initially 10 s without one (see docs/foundry.md). Also COPILOT_API_FALLBACK | | --port | -p | 4141 | Port to listen on | | --hostname | -H | 127.0.0.1 | Hostname/IP to bind to. Use 0.0.0.0 for LAN/Docker exposure | | --claude-code | -c | | Enable Claude Code compatibility mode | | --codex | | | Enable Codex CLI compatibility mode | | --model | -m | | Primary model to use | | --small-model | -s | | Lightweight model for fast tasks (Claude Code) | | --manual | | false | Require manual approval before forwarding requests | | --rate-limit | -r | | Minimum seconds between requests | | --wait | -w | false | Wait instead of returning an error when the configured rate limit is hit | | --timeout | -t | 600000 | Request timeout in ms (default 10 min). A streamed Claude Code turn on a non-Claude model waits at most 4 min for the upstream to start answering | | --connect-timeout | | 15000 | Connectivity probe timeout in ms for one probe cycle; overrides COPILOT_CONNECT_TIMEOUT_MS. The probe endpoints divide it equally (3 endpoints: one third each, 333 ms each at the 1000 ms minimum). A value above the default also raises the limit of the Copilot token exchange, which is 15000 ms otherwise | | --account-type | -a | individual | individual, business, or enterprise | | --github-token | -g | | Provide a GitHub token directly (skips OAuth) | | --show-token | | | Display tokens on fetch and refresh, and enable the local /token debug endpoint | | --error-reporting | | true | Send sanitized server-error reports. Disable with --no-error-reporting or COPILOT_API_ERROR_REPORTING=0 | | --smoke-test | | true | Run one self-test generation after startup and print PASS/FAIL. Disable with --no-smoke-test or COPILOT_API_NO_SMOKE_TEST=1 | | --tavily-api-key | | | Deprecated — prefer TAVILY_API_KEY env var. Tavily API key for web search | | --web-search-provider | | | Web search providers in primary→fallback order, e.g. exa,tavily (keys via TAVILY_API_KEY / EXA_API_KEY) | | --verbose | -v | | Enable debug-level logging | | --https | | | Serve over HTTPS using a self-signed cert | | --https-cert | | | Path to a PEM-encoded TLS certificate (use with --https-key) | | --https-key | | | Path to a PEM-encoded TLS private key (use with --https-cert) | | --https-hosts | | | Extra hostnames or IPs to include in the cert's SANs (comma-separated) | | --claude-cowork | | | Auto-detect Tailscale cert and enable HTTPS for Cowork. Run cowork-setup install first. See docs/claude-cowork.md |

cowork-setup

Manage Tailscale-based HTTPS for Claude Cowork.

| Subcommand | Description | |:--|:--| | cowork-setup doctor | Diagnose Tailscale + cert status | | cowork-setup install | Generate a Tailscale TLS certificate for Cowork | | cowork-setup revert | Remove the generated cert files |

Requires Tailscale installed and connected (tailscale up). See docs/claude-cowork.md.

Platform support: macOS, Linux, Windows — anywhere Tailscale runs.


HTTP/2 runtime compatibility

COPILOT_H2=1 enables the Copilot HTTP/2 pool on Node 20.18.1 or later and Bun 1.4.0 or later. Bun versions before 1.4.0 report an incorrect peer stream identifier in GOAWAY events. For those versions, the proxy uses HTTP/1.1 and shows one compatibility warning. It also disables HTTP/2 keepalive and reports the effective transport as HTTP/1.1. The checks cover Bun 1.3.11, 1.3.14, 1.4.0, and 1.4.4. Unknown Bun version formats also use HTTP/1.1 with the warning. Foundry continues to use its existing HTTP/1.1 policy.

Telemetry

This tool collects anonymous usage telemetry via OpenTelemetry. Only operational metrics are collected -- request counts, latency, model usage, and error rates. No prompts, completions, or personal information is ever collected.

When a server-side error occurs, an anonymous, sanitized error report (error type, status code, model, route, and runtime/version metadata -- never prompts, completions, headers, or tokens) is automatically sent to help diagnose and fix bugs. Disable it with --no-error-reporting or COPILOT_API_ERROR_REPORTING=0.

The startup banner's "Recent Posts" list is refreshed in the background at most once a day from https://barazany.dev/posts.json (a plain GET, nothing sent). It never delays startup and falls back to a cached or bundled list when offline. Disable it with COPILOT_API_NO_BLOG=1 (COPILOT_API_SKIP_UPDATE_CHECK=1 also disables it).

By using copilot-api, you agree to this telemetry data collection.


Closed Source

The source code is not publicly available.

This fork represents ~9 months of sustained engineering work -- bug fixes, new features, and hardening that go well beyond the original project. Keeping it closed-source protects that investment and ensures a single, well-maintained distribution.

The original open-source project is available at ericc-ch/copilot-api.


Notices

This project relies on reverse-engineered, undocumented GitHub APIs. It is not affiliated with or endorsed by GitHub, Microsoft, Anthropic, or OpenAI and may break without notice.


Attribution

Originally created by Erick Christian -- ericc-ch/copilot-api. His work built the foundation: authentication flow, API translation layer, and streaming implementation.

This fork has diverged significantly over ~9 months with extensive bug fixes and major new features -- Anthropic Messages API, OpenAI Responses API, Claude Code mode, Codex CLI support, web search integration, usage telemetry, and more. It is maintained as a separate project by johnib.


License

MIT