# Open-ClaudeCode: a reconstructed Claude Code source archive you run with node

> LING71671/Open-ClaudeCode republishes Claude Code source recovered from npm source maps, plus a runnable CLI and 13 official plugins. It is a research archive, and its licence file is the first thing to read.

**LING71671/Open-ClaudeCode** — Research archive of Claude Code source and runtime artifacts reconstructed from published npm source maps.

- Repository: https://github.com/LING71671/Open-ClaudeCode
- Stars: 958 · Forks: 1,219
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ling71671-open-claudecode

## What Open-ClaudeCode actually is, and who it is for

Anthropic publishes Claude Code as an npm package. That package shipped with source maps attached, and the README of this repository says the source was recovered from those maps. The result is a snapshot of a real, shipping AI coding assistant: 1,902 TypeScript files under src/, a compiled CLI at package/cli.js, 13 plugins under plugins/, and example settings under examples/settings/. The README quotes a line attributed to Anthropic acknowledging that shipping the map files was a mistake.

That origin defines the audience. This is not a fork with a roadmap. It is reading material for engineers who want to see how a terminal coding agent is put together: 30-plus tool implementations in src/tools/, 50-plus slash commands in src/commands/, React components rendered through a bundled copy of Ink in src/ink/, and service code for API calls, MCP and OAuth in src/services/. If your question is "how would I structure a tool-calling agent that edits files on disk", the answer is sitting in those directories.

The secondary audience is people who want to run the binary. The repository ships a working CLI, and the README documents pointing it at a third-party Anthropic-compatible endpoint. That is a practical use, but it is downstream of the archive's purpose, not the point of it.

## How the recovered source is laid out

The split between package/ and src/ is the important structural fact. package/ holds what you execute: cli.js at 12.5MB, its 57MB source map, a Bun lockfile, SDK type definitions, and vendor/ with native binaries for audio capture and ripgrep across six platforms. src/ holds the human-readable reconstruction, organised by role rather than by build output. src/utils/ alone is 564 files, which tells you how much of an agent's behaviour lives in small helpers rather than in the headline loop.

The plugins are a separate axis. Each directory under plugins/ is a self-contained capability: code-review, commit-commands, feature-dev, frontend-design, hookify, learning-output-style, pr-review-toolkit, security-guidance, agent-sdk-dev, plugin-dev, explanatory-output-style, ralph-wiggum, and claude-opus-4-5-migration. The CLI loads them with a repeated --plugin-dir flag, so the plugin boundary is a directory, not a registry entry.

What the README does not describe is the recovery process itself. There is no script documented for regenerating src/ from a source map, and no statement of which Claude Code version the 1,902 files correspond to, beyond the CLI reporting 2.1.88. Treat src/ as a fixed artefact, not a pipeline you can re-run against a newer npm release.

## Installing and running the CLI for the first time

The README asks for Node.js 18 or newer and gives no build step: you clone the repository and run the checked-in compiled CLI directly. Verify the runtime and the build before anything else, because the version check is the fastest way to confirm the archive is intact.

```bash
git clone https://github.com/LING71671/Open-ClaudeCode.git
cd Open-ClaudeCode
node --version
node package/cli.js --version
```

The README says node --version should report 18.0.0 or higher, and node package/cli.js --version should print 2.1.88. If that number is anything else, the compiled CLI on disk is not the build the documentation describes. Running node package/cli.js with no arguments starts the interactive session, where the README lists /help, /clear, /compact, /model and /theme as slash commands and Ctrl+C as the interrupt.

## Pointing it at an endpoint

Authentication has three documented paths: the Anthropic API, a third-party proxy, or an OAuth login against a Claude subscription. The proxy path is the one the README spends the most space on, and it works by writing a settings file that the CLI loads with --settings. The env block accepts ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN.

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://your-proxy-address",
    "ANTHROPIC_AUTH_TOKEN": "sk-your-key"
  }
}
```

Save that as settings.json and pass it at launch. The README notes that if both an environment variable and a settings file set the same key, the environment variable wins, and it warns against committing a file that contains a key. Claude Code also reads ~/.claude/settings.json automatically, so a global configuration removes the need for the flag.

For one-off prompts the CLI has a non-interactive mode. The README shows -p for a prompt, --output-format json for machine-readable output, and --model with the aliases sonnet, opus and haiku, or a full model name such as claude-sonnet-4-6. Permission behaviour is controlled by --permission-mode acceptEdits or, in a sandbox only, --dangerously-skip-permissions. Sessions can be resumed with -c for the most recent conversation in the current directory, or -r with a session id.

## The licence is the real constraint

The repository's licence field is NOASSERTION, and the README describes the code as being for learning and research only. Those two facts point the same way: nobody has attached a standard, recognisable licence to this code, and the stated intent is study rather than reuse. If you are evaluating Open-ClaudeCode for anything that ships to users, that is the blocker, not the technical quality of the reconstruction.

There is a second layer. The source originates from Anthropic's published npm artefacts, and the README's acknowledgement section frames the publication of the map files as an error on Anthropic's part. Redistribution terms for recovered source are not something this repository resolves. Read LICENSE yourself and take your own advice on it; the README does not tell you what you may do with the code, and it does not document any rollback or takedown process if the upstream position changes.

For evaluation purposes the licence question is answerable quickly. For anything else it is a decision you make with a lawyer, not with a README.

## Where Open-ClaudeCode is the wrong tool

The archive is a snapshot. The last push was on 2026-07-22, and there is no release history in the repository metadata, so there is no upgrade path to speak of: no versioned releases, no migration notes beyond a CHANGELOG.md, and no documented way to re-derive src/ from a newer Claude Code npm package. If you need the newest model support or the newest tool behaviour, this is the wrong place to look, because the reconstruction is anchored to a specific build.

The compiled CLI is also a single 12.5MB artefact with a 57MB source map beside it. That is fine for running locally and awkward for anything that needs a small, auditable dependency. And because the project ships the CLI as a checked-in file rather than building from src/, you cannot easily patch a behaviour and have it take effect: the file you run and the file you read are different artefacts.

Finally, if your goal is simply to use an AI coding assistant, this is a detour. You are running a research archive and taking on its licence ambiguity to get a tool that exists in supported form elsewhere.

## How it compares to OpenCode

OpenCode is the obvious comparison, and the difference is in what each one is. OpenCode is an independently built coding agent with its own codebase and its own release cadence; you adopt it, you get updates, and the provenance of every file is the project's own. Open-ClaudeCode is a reconstruction of someone else's agent, frozen at the version whose source maps happened to be published. One is a product, the other is a specimen.

That distinction changes what you can do with each. With OpenCode, a bug you find is a bug you can report and expect to see fixed. With Open-ClaudeCode, a bug in the recovered source is a fact about Claude Code at that version, and the fix is whatever the upstream project does next. The archive is more valuable precisely because it is not maintained: it is a stable record. But stability is not the same as support, and anyone choosing between the two should be clear about which of those they need.

## What to check before you commit to it

Three things are worth confirming before you invest time. First, read LICENSE and decide whether the NOASSERTION status is acceptable for your use. Second, run node package/cli.js --version and confirm it prints 2.1.88, which is the build the README describes; a mismatch means the archive is not what the documentation says it is. Third, decide which half of the project you actually want. If you want to read an agent's architecture, start in src/tools/ and src/services/, where the tool surface and the API and MCP plumbing live. If you want to run something, stay in package/ and accept that you are running a binary you did not build and cannot easily patch.

The upgrade cost is the part that is easy to underestimate. There is no release channel, so moving to a newer Claude Code means waiting for someone to publish a new reconstruction, or doing the recovery yourself from a fresh npm package. Nothing in the README describes that workflow. Budget for it as a manual, one-off exercise rather than an update you apply.

## Conclusion

Use Open-ClaudeCode if you want to read how a production AI coding assistant is structured, or if you need a CLI you can point at a third-party Anthropic-compatible endpoint with --settings settings.json. Do not adopt it as the base of a product: the licence is NOASSERTION, the code is recovered from source maps rather than released by its author, and the README itself frames the project as being for study. Before anything else, open the LICENSE file and read what it actually grants, then run node package/cli.js --version to confirm you are on the 2.1.88 build the README describes.

## FAQ

### What is Open-ClaudeCode?

It is a research archive of Claude Code source and runtime artefacts, reconstructed from source maps published in Anthropic's npm package. It contains a runnable CLI, 1,902 recovered TypeScript files, 13 official plugins and example settings. The README describes it as being for learning and research.

### How do I use Open-ClaudeCode?

Clone the repository, confirm Node.js 18 or newer, then run node package/cli.js. For a third-party endpoint, create a settings.json with an env block containing ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN, and launch with node package/cli.js --settings settings.json.

### Can I use Open-ClaudeCode inside VS Code?

The README documents only a terminal CLI, run as node package/cli.js, plus a desktop/ directory in the repository tree. It does not describe a VS Code extension or an editor integration, so terminal use is the only documented path.

### Is Open-ClaudeCode an alternative to Claude Code?

It is a reconstruction of Claude Code rather than a separate implementation, recovered from the source maps of Anthropic's npm package. The README presents it as a study copy and describes the code as being for learning and research only, so it is not positioned as a maintained replacement.

## Sources

- [Issues](https://github.com/LING71671/Open-ClaudeCode/issues)
- [LING71671/Open-ClaudeCode on GitHub](https://github.com/LING71671/Open-ClaudeCode)
- [README](https://github.com/LING71671/Open-ClaudeCode/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ling71671-open-claudecode