@wei-shaw/cvm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CVM Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,353 @@
+[English](README.md) | [中文](README_CN.md)
+
+# CVM - Claude Code Version Manager
+
+Manage multiple versions of [Claude Code](https://docs.anthropic.com/en/docs/claude-code) with ease. Install, switch, and patch — like [nvm](https://github.com/nvm-sh/nvm) for Claude Code.
+
+## Why CVM?
+
+Claude Code releases frequently — sometimes multiple times a day. You might need to:
+
+- **Pin a known-good version** while a new release is validated
+- **Test across versions** to verify behavior changes
+- **Patch the CLI** to route API traffic through a reverse proxy (for restricted network environments)
+
+CVM makes all of this a single command.
+
+## Uninstall Official Claude Code First
+
+CVM manages its own `claude` binary via shim. To avoid conflicts, **you must uninstall the official Claude Code before using CVM**.
+
+<details>
+<summary><strong>npm (global install)</strong></summary>
+
+```bash
+npm uninstall -g @anthropic-ai/claude-code
+```
+</details>
+
+<details>
+<summary><strong>macOS (Homebrew)</strong></summary>
+
+```bash
+brew uninstall claude-code
+```
+</details>
+
+<details>
+<summary><strong>Linux (native binary / standalone install)</strong></summary>
+
+```bash
+# If installed via the official install script
+rm -f /usr/local/bin/claude
+
+# If installed to ~/.local/bin
+rm -f ~/.local/bin/claude
+```
+
+If you're unsure where `claude` is installed:
+
+```bash
+which claude
+```
+</details>
+
+After uninstalling, verify that `claude` is no longer available:
+
+```bash
+which claude  # should return nothing or "not found"
+```
+
+## Quick Start
+
+```bash
+# Install CVM
+npm install -g @wei-shaw/cvm
+
+# Initialize
+cvm setup
+
+# Add to your shell profile (~/.bashrc or ~/.zshrc)
+export PATH="$HOME/.cvm/bin:$PATH"
+
+# Install and use Claude Code
+cvm install latest
+cvm use latest
+claude --version
+```
+
+## Installation
+
+### Prerequisites
+
+- **Node.js** >= 18.0.0
+- **npm** (comes with Node.js)
+
+### From npm (recommended)
+
+```bash
+npm install -g @wei-shaw/cvm
+```
+
+### From Source
+
+```bash
+git clone https://github.com/Wei-Shaw/cvm.git && cd cvm
+pnpm install
+pnpm build
+npm link        # makes `cvm` available globally
+```
+
+### Verify
+
+```bash
+cvm --version
+cvm setup
+```
+
+After running `setup`, add the PATH line it prints to your shell profile and restart your shell (or `source ~/.bashrc`).
+
+## Commands
+
+### `cvm setup`
+
+Initialize the CVM directory structure and install the `claude` shim.
+
+```bash
+cvm setup
+```
+
+Creates `~/.cvm/` with the required directory layout and generates platform-specific shim scripts that intercept the `claude` command.
+
+---
+
+### `cvm install <version>`
+
+Install a Claude Code version.
+
+```bash
+cvm install latest          # latest release
+cvm install stable          # stable release
+cvm install 2.1.87          # exact version
+cvm install 2.1.87 --force  # reinstall even if exists
+```
+
+The first version installed is automatically activated. Each version is isolated in its own directory under `~/.cvm/versions/`.
+
+---
+
+### `cvm uninstall <version>`
+
+Remove an installed version.
+
+```bash
+cvm uninstall 2.1.81
+cvm uninstall 2.1.81 --force  # remove even if active or patched
+```
+
+---
+
+### `cvm use <version>`
+
+Switch the active Claude Code version.
+
+```bash
+cvm use 2.1.87
+```
+
+This updates the `~/.cvm/active` symlink and regenerates the `claude` shim with the correct entry point for that version.
+
+---
+
+### `cvm current`
+
+Print the active version. Useful in scripts.
+
+```bash
+$ cvm current
+2.1.87
+```
+
+---
+
+### `cvm list`
+
+List installed versions. The active version is marked with `*`.
+
+```bash
+$ cvm list
+ * 2.1.81
+   2.1.87 [patched]
+```
+
+List available versions from the npm registry:
+
+```bash
+$ cvm list --remote
+$ cvm list --remote --last 50   # show last 50 versions (default: 20)
+```
+
+---
+
+### `cvm patch proxy <url>`
+
+Replace all Anthropic API domains in the active version's CLI bundle with a custom proxy URL. This is the core feature for environments that cannot reach Anthropic's API directly.
+
+```bash
+cvm patch proxy https://your-proxy.example.com
+```
+
+What gets replaced:
+
+| Original Domain | Description |
+|---|---|
+| `https://api.anthropic.com` | Main API endpoint |
+| `https://api-staging.anthropic.com` | Staging API endpoint |
+| `https://platform.claude.com` | OAuth / platform endpoint |
+| `https://mcp-proxy.anthropic.com` | MCP proxy endpoint |
+
+Additionally, an internal domain validation check is bypassed so the SDK treats the proxy URL as a first-party endpoint.
+
+**Options:**
+
+```bash
+cvm patch proxy <url> -V 2.1.81    # patch a specific version (default: active)
+```
+
+**Key behaviors:**
+
+- **Idempotent** — re-running always patches from the original backup, so you can change the URL freely
+- **Safe** — a `.bak` file is created before the first patch; the original is never lost
+- **Version-specific** — patches are tracked per version; switching versions does not carry patches over
+
+---
+
+### `cvm patch revert`
+
+Restore the original, unpatched CLI.
+
+```bash
+cvm patch revert
+cvm patch revert -V 2.1.81
+```
+
+---
+
+### `cvm patch status`
+
+Check patch state and verify effectiveness.
+
+```bash
+$ cvm patch status
+v2.1.81: patched → https://your-proxy.example.com (2026-03-31T06:44:48.141Z)
+
+  Remaining original domains:
+    api-staging.anthropic.com        0 (clean)
+    api.anthropic.com                0 (clean)
+    platform.claude.com              0 (clean)
+    mcp-proxy.anthropic.com          0 (clean)
+```
+
+## How It Works
+
+### Directory Layout
+
+```
+~/.cvm/
+├── versions/                  # isolated version installs
+│   ├── 2.1.81/
+│   │   └── node_modules/@anthropic-ai/claude-code/
+│   └── 2.1.87/
+│       └── node_modules/@anthropic-ai/claude-code/
+├── active → versions/2.1.87/node_modules/@anthropic-ai/claude-code
+├── bin/
+│   ├── claude                 # bash shim (Linux/macOS)
+│   ├── claude.cmd             # CMD shim (Windows)
+│   └── claude.ps1             # PowerShell shim (Windows)
+└── config.json
+```
+
+### Shim Mechanism
+
+When you run `claude`, the shim script in `~/.cvm/bin/` resolves the `active` symlink and executes `node <active-version>/cli.js` with all arguments forwarded. This adds zero overhead — no config parsing or version resolution at runtime.
+
+The entry point (`cli.js` vs `start.js`) is read from each version's `package.json` at `cvm use` time and baked into the shim, so it adapts to structural changes across Claude Code versions.
+
+### Reverse Proxy Strategy
+
+In certain restricted network environments (e.g., corporate firewalls, regional network policies), direct access to Anthropic's API endpoints may be unavailable. The proxy patching feature provides a **reverse proxy strategy** to address this — it redirects API traffic through a user-controlled reverse proxy server so that Claude Code can function normally under these constraints.
+
+The patch works by performing literal string replacement on the bundled CLI file (`cli.js`, ~7 MB), swapping hardcoded Anthropic domain strings with your reverse proxy URL. This approach is:
+
+- **Version-stable** — URL strings don't change with minification; they're the same across all versions
+- **Non-destructive** — the original file is backed up before any modification and can be restored at any time via `cvm patch revert`
+- **Idempotent** — patches are always applied from the pristine backup, never stacked
+
+## Platform Support
+
+| Platform | Status | Notes |
+|---|---|---|
+| Linux | Fully supported | Bash shim, symlinks |
+| macOS | Fully supported | Bash shim, symlinks |
+| Windows | Supported | CMD + PowerShell shims, NTFS junctions (no admin required) |
+| WSL/WSL2 | Fully supported | Treated as Linux |
+
+## Configuration
+
+CVM respects the following environment variable:
+
+| Variable | Default | Description |
+|---|---|---|
+| `CVM_DIR` | `~/.cvm` | Override the CVM home directory |
+
+### Registry
+
+CVM auto-detects your npm registry from `npm config get registry`. To override:
+
+```bash
+# In ~/.cvm/config.json
+{
+  "registry": "https://registry.npmmirror.com"
+}
+```
+
+## Development
+
+```bash
+git clone https://github.com/Wei-Shaw/cvm.git && cd cvm
+pnpm install
+pnpm build          # one-time build
+pnpm dev            # watch mode
+```
+
+### Project Structure
+
+```
+src/
+├── bin.ts           # entry point
+├── cli.ts           # command definitions (commander)
+├── types.ts         # shared interfaces
+├── util.ts          # spawn, semver, colors, spinner
+└── core/
+    ├── config.ts    # config.json read/write
+    ├── paths.ts     # directory constants
+    ├── patcher.ts   # proxy patch engine
+    ├── registry.ts  # npm registry client
+    ├── shim.ts      # cross-platform shim generation
+    └── versions.ts  # install/uninstall/switch logic
+```
+
+**Design principles:**
+
+- Single runtime dependency (`commander`)
+- 20 KB compiled output
+- Cross-platform from day one (POSIX + Windows)
+- No abstractions beyond what the feature set requires
+
+## Contributing
+
+Contributions are welcome. Please open an issue first to discuss what you'd like to change.
+
+## License
+
+MIT

package/dist/bin.js

@@ -0,0 +1,677 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { execSync } from "child_process";
+
+// src/core/paths.ts
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+var CVM_DIR = process.env.CVM_DIR || join(homedir(), ".cvm");
+var VERSIONS_DIR = join(CVM_DIR, "versions");
+var BIN_DIR = join(CVM_DIR, "bin");
+var ACTIVE_LINK = join(CVM_DIR, "active");
+var CONFIG_FILE = join(CVM_DIR, "config.json");
+var SHIM_PATH = join(BIN_DIR, "claude");
+var PACKAGE_NAME = "@anthropic-ai/claude-code";
+function versionDir(version) {
+  return join(VERSIONS_DIR, version);
+}
+function versionPackageDir(version) {
+  return join(VERSIONS_DIR, version, "node_modules", "@anthropic-ai", "claude-code");
+}
+function ensureDirs() {
+  for (const dir of [VERSIONS_DIR, BIN_DIR]) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/core/versions.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  rmSync,
+  readdirSync,
+  symlinkSync,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/core/config.ts
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync } from "fs";
+var DEFAULT_CONFIG = {
+  active: null,
+  registry: null,
+  patches: []
+};
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG, patches: [] };
+  let raw;
+  try {
+    const parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    raw = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    raw = {};
+  }
+  return {
+    active: typeof raw.active === "string" ? raw.active : null,
+    registry: typeof raw.registry === "string" ? raw.registry : null,
+    patches: Array.isArray(raw.patches) ? raw.patches : []
+  };
+}
+function writeConfig(config) {
+  const tmp = CONFIG_FILE + ".tmp";
+  const data = JSON.stringify(config, null, 2) + "\n";
+  writeFileSync(tmp, data);
+  try {
+    renameSync(tmp, CONFIG_FILE);
+  } catch {
+    writeFileSync(CONFIG_FILE, data);
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function updateConfig(fn) {
+  const config = readConfig();
+  fn(config);
+  writeConfig(config);
+}
+
+// src/util.ts
+import { spawn as cpSpawn } from "child_process";
+var IS_WIN = process.platform === "win32";
+var esc = (code) => (s) => `\x1B[${code}m${s}\x1B[0m`;
+var bold = esc("1");
+var dim = esc("2");
+var green = esc("32");
+var red = esc("31");
+var cyan = esc("36");
+var yellow = esc("33");
+function spawn(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = cpSpawn(cmd, args, {
+      cwd: opts?.cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: IS_WIN
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout?.on("data", (d) => stdout.push(d.toString()));
+    child.stderr?.on("data", (d) => stderr.push(d.toString()));
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout: stdout.join(""), stderr: stderr.join("") }));
+  });
+}
+function spawnLive(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = cpSpawn(cmd, args, {
+      cwd: opts?.cwd,
+      stdio: "inherit",
+      shell: IS_WIN
+    });
+    const sigHandler = (sig) => {
+      child.kill(sig);
+    };
+    process.on("SIGINT", sigHandler);
+    process.on("SIGTERM", sigHandler);
+    child.on("error", reject);
+    child.on("close", (code) => {
+      process.removeListener("SIGINT", sigHandler);
+      process.removeListener("SIGTERM", sigHandler);
+      resolve(code ?? 1);
+    });
+  });
+}
+function semverCompare(a, b) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-", 2);
+    return { parts: core.split(".").map(Number), pre: pre ?? null };
+  };
+  const sa = parse(a);
+  const sb = parse(b);
+  for (let i = 0; i < Math.max(sa.parts.length, sb.parts.length); i++) {
+    const diff = (sa.parts[i] ?? 0) - (sb.parts[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  if (sa.pre && !sb.pre) return -1;
+  if (!sa.pre && sb.pre) return 1;
+  if (sa.pre && sb.pre) return sa.pre.localeCompare(sb.pre);
+  return 0;
+}
+
+// src/core/registry.ts
+var _registryUrl = null;
+async function resolveRegistry() {
+  if (_registryUrl) return _registryUrl;
+  const config = readConfig();
+  if (config.registry) {
+    _registryUrl = config.registry;
+    return _registryUrl;
+  }
+  try {
+    const result = await spawn("npm", ["config", "get", "registry"]);
+    const url = result.stdout.trim().replace(/\/+$/, "");
+    _registryUrl = url || "https://registry.npmjs.org";
+  } catch {
+    _registryUrl = "https://registry.npmjs.org";
+  }
+  return _registryUrl;
+}
+var _packageInfoCache = null;
+async function fetchPackageInfo() {
+  if (_packageInfoCache) return _packageInfoCache;
+  const registry = await resolveRegistry();
+  const url = `${registry}/${PACKAGE_NAME}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/vnd.npm.install-v1+json" },
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) throw new Error(`Registry request failed: ${res.status} ${res.statusText}`);
+  const data = await res.json();
+  _packageInfoCache = {
+    versions: Object.keys(data.versions ?? {}),
+    tags: data["dist-tags"] ?? {}
+  };
+  return _packageInfoCache;
+}
+async function fetchDistTags() {
+  return (await fetchPackageInfo()).tags;
+}
+async function resolveVersion(input) {
+  if (/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(input)) return input;
+  const tags = await fetchDistTags();
+  const resolved = tags[input];
+  if (!resolved) {
+    throw new Error(`Unknown version alias "${input}". Available tags: ${Object.keys(tags).join(", ")}`);
+  }
+  return resolved;
+}
+
+// src/core/shim.ts
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, chmodSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+function resolveEntryPoint(packageDir) {
+  const pkgPath = join2(packageDir, "package.json");
+  if (existsSync2(pkgPath)) {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const bin = pkg.bin;
+    let entry;
+    if (typeof bin === "string") {
+      entry = bin;
+    } else if (bin && typeof bin === "object") {
+      entry = bin.claude ?? Object.values(bin)[0];
+    }
+    if (entry) return entry.replace(/^\.\//, "");
+  }
+  return "cli.js";
+}
+function generateBashShim(entryPoint) {
+  return `#!/bin/bash
+# CVM shim - Claude Code Version Manager
+CVM_DIR="\${CVM_DIR:-${CVM_DIR}}"
+ACTIVE="$CVM_DIR/active"
+
+if [ ! -L "$ACTIVE" ] && [ ! -d "$ACTIVE" ]; then
+  echo "cvm: no active Claude Code version. Run: cvm install latest" >&2
+  exit 1
+fi
+
+exec node "$ACTIVE/${entryPoint}" "$@"
+`;
+}
+function generateCmdShim(entryPoint) {
+  return `@echo off\r
+rem CVM shim - Claude Code Version Manager\r
+if defined CVM_DIR (set "CVM_RESOLVED=%CVM_DIR%") else (set "CVM_RESOLVED=%USERPROFILE%\\.cvm")\r
+set "ACTIVE=%CVM_RESOLVED%\\active"\r
+if not exist "%ACTIVE%" (\r
+  echo cvm: no active Claude Code version. Run: cvm install latest >&2\r
+  exit /b 1\r
+)\r
+node "%ACTIVE%\\${entryPoint}" %*\r
+`;
+}
+function generatePs1Shim(entryPoint) {
+  return `# CVM shim - Claude Code Version Manager
+$cvmDir = if ($env:CVM_DIR) { $env:CVM_DIR } else { Join-Path $HOME ".cvm" }
+$active = Join-Path $cvmDir "active"
+
+if (-not (Test-Path $active)) {
+  Write-Error "cvm: no active Claude Code version. Run: cvm install latest"
+  exit 1
+}
+
+& node (Join-Path $active "${entryPoint}") @args
+`;
+}
+function installShim(entryPoint) {
+  mkdirSync2(BIN_DIR, { recursive: true });
+  if (!entryPoint) {
+    const activePkg = join2(ACTIVE_LINK, "package.json");
+    if (existsSync2(activePkg)) {
+      entryPoint = resolveEntryPoint(ACTIVE_LINK);
+    } else {
+      entryPoint = "cli.js";
+    }
+  }
+  writeFileSync2(SHIM_PATH, generateBashShim(entryPoint));
+  if (!IS_WIN) {
+    chmodSync(SHIM_PATH, 493);
+  }
+  if (IS_WIN) {
+    writeFileSync2(SHIM_PATH + ".cmd", generateCmdShim(entryPoint));
+    writeFileSync2(SHIM_PATH + ".ps1", generatePs1Shim(entryPoint));
+  }
+}
+function getPathInstruction() {
+  if (IS_WIN) {
+    return `$env:Path = "$HOME\\.cvm\\bin;" + $env:Path  # PowerShell (session)
+# To persist: [Environment]::SetEnvironmentVariable("Path", "$HOME\\.cvm\\bin;" + [Environment]::GetEnvironmentVariable("Path", "User"), "User")`;
+  }
+  return `export PATH="$HOME/.cvm/bin:$PATH"`;
+}
+function getShellProfileHint() {
+  if (IS_WIN) return "your PowerShell profile ($PROFILE)";
+  return "~/.bashrc or ~/.zshrc";
+}
+
+// src/core/versions.ts
+var INSTALLING_MARKER = ".installing";
+function unlinkSafe(path) {
+  try {
+    unlinkSync2(path);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function rmSafe(path) {
+  rmSync(path, { recursive: true, force: true });
+}
+function createActiveLink(target) {
+  unlinkSafe(ACTIVE_LINK);
+  if (IS_WIN) {
+    symlinkSync(target, ACTIVE_LINK, "junction");
+  } else {
+    symlinkSync(target, ACTIVE_LINK);
+  }
+}
+function isValidInstall(version) {
+  return existsSync3(join3(versionPackageDir(version), "package.json"));
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureClaudeSettings() {
+  const claudeDir = join3(homedir2(), ".claude");
+  const settingsPath = join3(claudeDir, "settings.json");
+  mkdirSync3(claudeDir, { recursive: true });
+  let settings = {};
+  if (existsSync3(settingsPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        settings = parsed;
+      }
+    } catch {
+    }
+  }
+  if (!settings.env || typeof settings.env !== "object" || Array.isArray(settings.env)) {
+    settings.env = {};
+  }
+  if (settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC === "1") return;
+  settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+  writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  console.log(dim("Set CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 in ~/.claude/settings.json"));
+}
+function cleanupStaleInstalls() {
+  if (!existsSync3(VERSIONS_DIR)) return;
+  for (const name of readdirSync(VERSIONS_DIR)) {
+    const marker = join3(versionDir(name), INSTALLING_MARKER);
+    if (!existsSync3(marker)) continue;
+    let pid = 0;
+    try {
+      pid = parseInt(readFileSync3(marker, "utf-8").trim(), 10);
+    } catch {
+    }
+    if (pid > 0 && isProcessAlive(pid)) continue;
+    console.log(yellow(`Cleaning up interrupted install: ${name}`));
+    rmSafe(versionDir(name));
+  }
+}
+async function install(versionInput, force = false) {
+  ensureDirs();
+  cleanupStaleInstalls();
+  const version = await resolveVersion(versionInput);
+  const dir = versionDir(version);
+  if (!force && isValidInstall(version)) {
+    console.log(`Version ${bold(version)} is already installed.`);
+    return;
+  }
+  if (force && existsSync3(dir)) {
+    rmSafe(dir);
+  }
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(join3(dir, INSTALLING_MARKER), String(process.pid));
+  writeFileSync3(join3(dir, "package.json"), JSON.stringify({ name: `cvm-v-${version}`, private: true }));
+  console.log(`Installing ${PACKAGE_NAME}@${bold(version)}...`);
+  const code = await spawnLive("npm", ["install", `${PACKAGE_NAME}@${version}`, "--no-package-lock"], { cwd: dir });
+  if (code !== 0) {
+    rmSafe(dir);
+    throw new Error(`npm install failed with exit code ${code}`);
+  }
+  if (!isValidInstall(version)) {
+    rmSafe(dir);
+    throw new Error("Installation verification failed: package not found after install");
+  }
+  rmSafe(join3(dir, INSTALLING_MARKER));
+  ensureClaudeSettings();
+  console.log(green(`\u2713 Installed ${version}`));
+  const config = readConfig();
+  if (!config.active) {
+    use(version);
+  }
+}
+function uninstall(version, force = false) {
+  const dir = versionDir(version);
+  if (!existsSync3(dir)) {
+    throw new Error(`Version ${version} is not installed.`);
+  }
+  const config = readConfig();
+  if (config.active === version && !force) {
+    throw new Error(`Version ${version} is currently active. Switch to another version first, or use --force.`);
+  }
+  const appliedPatches = config.patches.filter((p) => p.version === version);
+  if (appliedPatches.length > 0 && !force) {
+    throw new Error(
+      `Version ${version} has patches applied. Use --force to remove anyway.`
+    );
+  }
+  updateConfig((c) => {
+    if (c.active === version) {
+      c.active = null;
+      unlinkSafe(ACTIVE_LINK);
+    }
+    c.patches = c.patches.filter((p) => p.version !== version);
+  });
+  rmSafe(dir);
+  console.log(green(`\u2713 Uninstalled ${version}`));
+}
+function use(version) {
+  if (!isValidInstall(version)) {
+    throw new Error(`Version ${version} is not installed. Run: cvm install ${version}`);
+  }
+  const pkgDir = versionPackageDir(version);
+  createActiveLink(pkgDir);
+  const entry = resolveEntryPoint(pkgDir);
+  installShim(entry);
+  updateConfig((c) => {
+    c.active = version;
+  });
+  console.log(green(`\u2713 Now using Claude Code ${bold(version)} (entry: ${entry})`));
+}
+function current() {
+  return readConfig().active;
+}
+function listInstalled() {
+  if (!existsSync3(VERSIONS_DIR)) return [];
+  const config = readConfig();
+  const patchedVersions = new Set(config.patches.map((p) => p.version));
+  return readdirSync(VERSIONS_DIR).filter((name) => isValidInstall(name)).sort(semverCompare).map((version) => ({
+    version,
+    active: config.active === version,
+    patched: patchedVersions.has(version)
+  }));
+}
+
+// src/core/patcher.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, copyFileSync, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+var TARGET_FILE = "cli.js";
+var DOMAIN_REPLACEMENTS = [
+  { search: "https://api-staging.anthropic.com", label: "api-staging.anthropic.com" },
+  { search: "https://api.anthropic.com", label: "api.anthropic.com" },
+  { search: "https://platform.claude.com", label: "platform.claude.com" },
+  { search: "https://mcp-proxy.anthropic.com", label: "mcp-proxy.anthropic.com" }
+];
+var DOMAIN_CHECK_SEARCH = '=function(){return this.baseURL!=="https://api.anthropic.com"}';
+var DOMAIN_CHECK_REPLACE = "=function(){return false}";
+function replaceAndCount(content, search, replace) {
+  let count = 0;
+  const result = content.replaceAll(search, () => {
+    count++;
+    return replace;
+  });
+  return { result, count };
+}
+function applyProxy(baseUrl, version) {
+  const v = version ?? current();
+  if (!v) throw new Error('No active version. Run "cvm use <version>" first.');
+  const url = baseUrl.replace(/\/+$/, "");
+  try {
+    new URL(url);
+  } catch {
+    throw new Error(`Invalid proxy URL: "${baseUrl}". Must be a valid URL (e.g., https://proxy.example.com).`);
+  }
+  const pkgDir = versionPackageDir(v);
+  const targetPath = join4(pkgDir, TARGET_FILE);
+  const backupPath = targetPath + ".bak";
+  if (!existsSync4(targetPath)) {
+    throw new Error(`${TARGET_FILE} not found at: ${targetPath}`);
+  }
+  const config = readConfig();
+  const existingPatch = config.patches.find((p) => p.version === v);
+  if (existsSync4(backupPath)) {
+    copyFileSync(backupPath, targetPath);
+  } else if (existingPatch) {
+    throw new Error(
+      `Backup file missing but version ${v} is recorded as patched. The original ${TARGET_FILE} cannot be recovered. Run "cvm install ${v} --force" to reinstall a clean copy.`
+    );
+  } else {
+    copyFileSync(targetPath, backupPath);
+  }
+  let content = readFileSync4(targetPath, "utf-8");
+  const stats = [];
+  {
+    const { result, count } = replaceAndCount(content, DOMAIN_CHECK_SEARCH, DOMAIN_CHECK_REPLACE);
+    content = result;
+    stats.push({ label: "Domain check bypass", count });
+  }
+  for (const { search, label } of DOMAIN_REPLACEMENTS) {
+    const { result, count } = replaceAndCount(content, search, url);
+    content = result;
+    stats.push({ label, count });
+  }
+  writeFileSync4(targetPath, content);
+  updateConfig((c) => {
+    c.patches = c.patches.filter((p) => p.version !== v);
+    c.patches.push({ version: v, proxyUrl: url, appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  console.log(`
+${green("\u2713")} Proxy patch applied to v${bold(v)} \u2192 ${bold(url)}
+`);
+  for (const s of stats) {
+    const status = s.count > 0 ? `${s.count} replacement(s)` : dim("not found (skipped)");
+    console.log(`  ${s.label.padEnd(32)} ${status}`);
+  }
+  console.log();
+}
+function revertPatch(version) {
+  const v = version ?? current();
+  if (!v) throw new Error("No active version.");
+  const config = readConfig();
+  const record = config.patches.find((p) => p.version === v);
+  if (!record) throw new Error(`No patch applied to version ${v}.`);
+  const pkgDir = versionPackageDir(v);
+  const backupPath = join4(pkgDir, TARGET_FILE + ".bak");
+  if (!existsSync4(backupPath)) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  copyFileSync(backupPath, join4(pkgDir, TARGET_FILE));
+  updateConfig((c) => {
+    c.patches = c.patches.filter((p) => p.version !== v);
+  });
+  console.log(green(`\u2713 Reverted patch on v${v}`));
+}
+function patchStatus(version) {
+  const v = version ?? current();
+  if (!v) {
+    console.log(dim("No active version."));
+    return;
+  }
+  const config = readConfig();
+  const record = config.patches.find((p) => p.version === v);
+  if (!record) {
+    console.log(`v${v}: ${dim("no patch applied")}`);
+    return;
+  }
+  const pkgDir = versionPackageDir(v);
+  const filePath = join4(pkgDir, TARGET_FILE);
+  if (!existsSync4(filePath)) {
+    console.log(yellow(`v${v}: target file missing (version may have been removed)`));
+    return;
+  }
+  const content = readFileSync4(filePath, "utf-8");
+  const remaining = [];
+  for (const { search, label } of DOMAIN_REPLACEMENTS) {
+    const count = content.split(search).length - 1;
+    remaining.push({ label, count });
+  }
+  console.log(`v${v}: patched \u2192 ${bold(record.proxyUrl)} (${dim(record.appliedAt)})
+`);
+  console.log("  Remaining original domains:");
+  for (const r of remaining) {
+    const status = r.count === 0 ? green("0 (clean)") : yellow(`${r.count} remaining`);
+    console.log(`    ${r.label.padEnd(32)} ${status}`);
+  }
+  console.log();
+}
+
+// src/cli.ts
+function handleError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(red(`Error: ${msg}`));
+  process.exit(1);
+}
+function findExistingClaude() {
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0] || null;
+  } catch {
+    return null;
+  }
+}
+function run(argv) {
+  const program = new Command();
+  program.name("cvm").version("0.1.0").description("Claude Code Version Manager");
+  program.command("setup").description("Initialize CVM directories and install the claude shim").action(() => {
+    try {
+      ensureDirs();
+      installShim();
+      console.log(green("\u2713 CVM initialized"));
+      console.log();
+      console.log(`  CVM home:  ${CVM_DIR}`);
+      console.log(`  Shim:      ${SHIM_PATH}`);
+      console.log();
+      console.log(`Add this to ${getShellProfileHint()}:`);
+      console.log();
+      console.log(`  ${bold(getPathInstruction())}`);
+      console.log();
+      const existing = findExistingClaude();
+      if (existing) {
+        console.log(yellow(`Note: existing ${existing} found. The CVM shim will take priority once PATH is configured.`));
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  program.command("install <version>").description('Install a Claude Code version (e.g., "latest", "2.1.87")').option("-f, --force", "Reinstall even if already installed").action(async (version, opts) => {
+    try {
+      await install(version, opts.force);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  program.command("uninstall <version>").description("Remove an installed version").option("-f, --force", "Remove even if active or has patches").action((version, opts) => {
+    try {
+      uninstall(version, opts.force);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  program.command("use <version>").description("Switch to an installed version").action((version) => {
+    try {
+      use(version);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  program.command("current").description("Show the active version").action(() => {
+    const v = current();
+    if (v) console.log(v);
+    else console.log(dim("No active version"));
+  });
+  program.command("list").alias("ls").description("List installed versions").option("-r, --remote", "List available versions from the registry").option("-l, --last <n>", "Show only the last N remote versions", "20").action(async (opts) => {
+    try {
+      if (opts.remote) {
+        const { versions, tags } = await fetchPackageInfo();
+        const tagMap = new Map(Object.entries(tags).map(([k, v]) => [v, k]));
+        const sorted = versions.sort(semverCompare);
+        const last = parseInt(opts.last, 10) || 20;
+        const shown = sorted.slice(-last);
+        console.log(`Showing last ${shown.length} of ${sorted.length} versions:
+`);
+        for (const v of shown) {
+          const tag = tagMap.get(v);
+          console.log(`  ${v}${tag ? cyan(` (${tag})`) : ""}`);
+        }
+        console.log();
+      } else {
+        const installed = listInstalled();
+        if (installed.length === 0) {
+          console.log(dim("No versions installed. Run: cvm install latest"));
+          return;
+        }
+        for (const v of installed) {
+          const marker = v.active ? green(" * ") : "   ";
+          const patch2 = v.patched ? yellow(" [patched]") : "";
+          console.log(`${marker}${v.version}${patch2}`);
+        }
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  const patch = program.command("patch").description("Manage proxy patches for installed versions");
+  patch.command("proxy <url>").description("Replace all Anthropic API domains with a proxy URL").option("-V, --version <version>", "Target version (default: active)").action((url, opts) => {
+    try {
+      applyProxy(url, opts.version);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  patch.command("revert").description("Revert patch and restore original files").option("-V, --version <version>", "Target version (default: active)").action((opts) => {
+    try {
+      revertPatch(opts.version);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+  patch.command("status").description("Show patch status for a version").option("-V, --version <version>", "Target version (default: active)").action((opts) => {
+    patchStatus(opts.version);
+  });
+  program.parse(argv);
+}
+
+// src/bin.ts
+run(process.argv);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@wei-shaw/cvm",
+  "version": "0.1.0",
+  "description": "Claude Code Version Manager",
+  "type": "module",
+  "bin": {
+    "cvm": "dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Wei-Shaw/cvm"
+  },
+  "packageManager": "pnpm@10.32.1",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}