@anyforge/control 0.2.2 → 0.2.4

package/README.md

@@ -28,13 +28,25 @@ Pick whichever suits the moment — the choices aren't mutually exclusive over t
 
 - Want to add a second repo? Re-run `npx @anyforge/control init` from that repo's root and pick `repo` again.
 - Want to switch to a system-wide install later? Re-run from anywhere and pick `global`.
-- Want to undo a per-repo install? Delete the `# === AnyForge Control ===` block in `<repo>/.env` and the `env` keys in `<repo>/.claude/settings.local.json`. `anyforge logout` clears the saved credential but doesn't touch patched configs.
+- Want to undo a per-repo install? Run `anyforge logout` — it now reverts the patched configs (`~/.claude/settings.json`, `<repo>/.claude/settings.local.json`, the `# === AnyForge Control ===` block in `.env` / your shell rc) and restores any previously-shadowed login.
 
 > The `.env` written in per-repo mode contains a live `ANYFORGE_API_KEY`. The CLI warns if your repo's `.gitignore` doesn't already exclude `.env`. **Add it before committing.**
 
+### Claude Pro / Max subscription users
+
+The inference proxy is **BYOK-only**: it routes Claude Code through your own Anthropic *API key* for metering and governance. It is **incompatible with a Claude Pro/Max (subscription) login** — the `ANTHROPIC_AUTH_TOKEN` it patches out-ranks (Claude Code auth precedence #2) and therefore disables the subscription login (#6), and the proxy has no upstream API key for a subscription user, so Claude Code falls back to "please login".
+
+`anyforge init` detects a subscription login and **skips patching**, steering you to the **AnyForge MCP server** instead — which keeps your subscription for inference and adds AnyForge control (HIL approvals, work items, crews) on top, with no auth conflict:
+
+```bash
+claude mcp add anyforge --env ANYFORGE_API_KEY=<your key> -- npx -y @anyforge/mcp-server
+```
+
+If you really want the metered BYOK proxy, re-run `anyforge init --force` (you'll need an Anthropic API key configured on your company; this disables your subscription in Claude Code until you `anyforge logout`).
+
 ### Why `ANTHROPIC_AUTH_TOKEN`, not `ANTHROPIC_API_KEY`?
 
-Claude Code recognises both, but they behave differently. `ANTHROPIC_API_KEY` is sent as `X-Api-Key` and — when an OAuth Console login is also present — surfaces an "Auth conflict: Using ANTHROPIC_API_KEY instead of Anthropic Console key" warning, and can cascade into a "selected model may not exist" error. `ANTHROPIC_AUTH_TOKEN` is sent as `Authorization: Bearer …`, is documented for "routing through an LLM gateway or proxy", out-ranks the OAuth login cleanly, and matches the bearer-token shape AnyForge expects. We patch the token form, and on every install we explicitly delete any stale `ANTHROPIC_API_KEY` left behind by older versions.
+Claude Code recognises both, but they behave differently. `ANTHROPIC_API_KEY` is sent as `X-Api-Key` and — when an OAuth Console login is also present — surfaces an "Auth conflict: Using ANTHROPIC_API_KEY instead of Anthropic Console key" warning, and can cascade into a "selected model may not exist" error. `ANTHROPIC_AUTH_TOKEN` is sent as `Authorization: Bearer …`, is documented for "routing through an LLM gateway or proxy", and matches the bearer-token shape AnyForge expects. We patch the token form, and on every install we explicitly delete any stale `ANTHROPIC_API_KEY` left behind by older versions. Note that it out-ranks a subscription login (see above) — which is exactly why `init` refuses to patch over a Pro/Max login by default.
 
 ## Commands
 
@@ -43,7 +55,7 @@ Claude Code recognises both, but they behave differently. `ANTHROPIC_API_KEY` is
 | `anyforge init` | Authorise this device and patch local agent configs |
 | `anyforge whoami` | Show the company tied to the saved key |
 | `anyforge status` | Verify the proxy is reachable and your BYOK key is configured |
-| `anyforge logout` | Clear the local credential file (does not revoke server-side) |
+| `anyforge logout` | Clear the local credential file **and revert patched configs** (does not revoke server-side) |
 
 ## Endpoints
 

package/dist/cli.js

@@ -41,6 +41,8 @@ function parseArgs(argv) {
             a.threeWay = true;
         else if (v === '--dry-run')
             a.dryRun = true;
+        else if (v === '--force' || v === '-f')
+            a.force = true;
         else if (!v.startsWith('-'))
             a.positional.push(v);
     }
@@ -63,6 +65,8 @@ ${bold('COMMANDS')}
 
 ${bold('OPTIONS')}
   --endpoint <url>   Override the proxy base URL (default: ${dim('https://crew.anyforge.ai')})
+  --force, -f        init: patch the BYOK proxy even if a Claude subscription
+                     login is present (this disables that subscription in Claude Code)
   --3way             apply-patch: try 3-way merge if the patch doesn't apply cleanly
   --dry-run          apply-patch: only check applicability, don't write
   --help, -h         Show this message
@@ -97,7 +101,7 @@ async function main() {
     try {
         switch (args.command) {
             case 'init':
-                await runInit({ endpoint });
+                await runInit({ endpoint, force: args.force });
                 break;
             case 'whoami':
                 await runWhoami();

package/dist/commands/init.js

@@ -1,11 +1,9 @@
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
+import { execFileSync } from 'child_process';
 import open from 'open';
 import prompts from 'prompts';
 import { green, dim, bold, yellow, cyan } from 'kleur/colors';
 import { saveCredentials } from '../lib/credentials.js';
-import { detectAndPatchConfigs } from '../lib/configPatch.js';
+import { detectAndPatchConfigs, detectClaudeSubscription, patchClaudeTelemetry, } from '../lib/configPatch.js';
 const POLL_INTERVAL_MS = 2_000;
 const POLL_TIMEOUT_MS = 15 * 60 * 1000;
 export async function runInit(opts) {
@@ -14,8 +12,18 @@ export async function runInit(opts) {
     console.log(bold('AnyForge Control — device authorisation'));
     // eslint-disable-next-line no-console
     console.log(dim(`  endpoint: ${endpoint}`));
-    // 1. Issue a one-time code.
-    const initRes = await fetch(`${endpoint}/api/cli/init`, { method: 'POST' });
+    // 1. Issue a one-time code. We detect the git remote up-front when
+    //    running in a repo so it can be attached to the API key later.
+    //    Detection happens before scope-pick so the server has it
+    //    regardless of which scope the operator chooses.
+    const cwd0 = process.cwd();
+    const gitRoot0 = findGitRoot(cwd0);
+    const earlyRepo = gitRoot0 ? detectGitRemoteRepo(gitRoot0) : null;
+    const initRes = await fetch(`${endpoint}/api/cli/init`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ repo: earlyRepo }),
+    });
     const init = (await initRes.json());
     if (!init.ok || !init.data) {
         throw new Error(`Could not start the authorisation flow: ${init.error ?? 'unknown error'}`);
@@ -45,12 +53,25 @@ export async function runInit(opts) {
     await saveCredentials(credentials);
     // eslint-disable-next-line no-console
     console.log(green('✔') + ' API key saved to ' + dim('~/.anyforge/credentials'));
+    // 4b. A Claude Pro/Max subscription login is mutually exclusive with
+    //     the BYOK inference proxy: the ANTHROPIC_AUTH_TOKEN we'd patch
+    //     out-ranks (and thereby disables) the subscription login, and the
+    //     proxy has no upstream Anthropic key for a subscription user. So
+    //     we skip patching and steer them to the MCP server instead — which
+    //     keeps their subscription for inference and adds AnyForge control
+    //     on top. `--force` overrides for users who really do want a
+    //     BYOK-keyed metered proxy.
+    const sub = await detectClaudeSubscription();
+    if (sub.isSubscription && !opts.force) {
+        await guideSubscriptionUser(sub, endpoint, credentials.apiKey);
+        return;
+    }
     // 5. Pick a scope. The repo option only shows when we're sitting
     //    in a git working tree root — that matches the documented
     //    contract and avoids accidentally writing settings into a
     //    subdirectory the operator didn't mean to target.
     const cwd = process.cwd();
-    const repoRoot = (await isGitRepoRoot(cwd)) ? cwd : null;
+    const repoRoot = findGitRoot(cwd);
     const scope = await pickScope(repoRoot);
     // 6. Patch the chosen target. apiKey is inlined into the env map
     //    so Claude Code can read it without a shell restart.
@@ -73,24 +94,17 @@ export async function runInit(opts) {
     }
     // eslint-disable-next-line no-console
     console.log();
-    if (await hasClaudeCodeLogin()) {
-        // Claude Code shows an "Auth conflict" warning when both a /login
-        // credential and an env-token are set — even though the token wins
-        // by precedence (#2 vs #6), the warning is cosmetic-but-loud. The
-        // only way to silence it is to stay logged out: /logout once, then
-        // skip the login prompt on the next launch.
-        // eslint-disable-next-line no-console
-        console.log(yellow('  ⚠ Existing Claude Code login detected (~/.claude/.credentials.json).'));
-        // eslint-disable-next-line no-console
-        console.log(dim('    Claude Code will work, but it will warn that both a token and a'));
+    if (sub.isSubscription && opts.force) {
+        // They overrode the subscription guard. Be explicit about the
+        // trade-off and the one-command way back.
         // eslint-disable-next-line no-console
-        console.log(dim('    /login key are set. To silence the warning:'));
+        console.log(yellow(`  ⚠ --force: your Claude ${sub.plan ?? ''} subscription login is now shadowed`));
         // eslint-disable-next-line no-console
-        console.log(dim('      1) run `claude /logout`,'));
+        console.log(yellow('    by the AnyForge token — Claude Code will use the BYOK proxy, which'));
         // eslint-disable-next-line no-console
-        console.log(dim('      2) on the next launch, skip the login prompt (Esc / Ctrl+C).'));
+        console.log(yellow('    needs an Anthropic API key on your company. Run ') + bold('anyforge logout'));
         // eslint-disable-next-line no-console
-        console.log(dim('    The AnyForge token in settings.local.json is enough on its own.'));
+        console.log(yellow('    to revert and restore your subscription.'));
     }
     if (scope === 'repo') {
         // eslint-disable-next-line no-console
@@ -132,29 +146,90 @@ async function pollForToken(args) {
     }
     throw new Error('Authorisation timed out (15 min). Re-run `anyforge init`.');
 }
-async function hasClaudeCodeLogin() {
-    // Claude Code's docs document the credentials file at
-    // ~/.claude/.credentials.json (Linux/Windows) or the macOS Keychain.
-    // We can only see the file on Linux/Windows. On macOS the keychain
-    // is invisible to us, so this check is best-effort — false negatives
-    // are fine since the warning is just a hint.
-    try {
-        await fs.access(join(homedir(), '.claude', '.credentials.json'));
-        return true;
+/**
+ * Steer a subscription user to the MCP server instead of patching the
+ * BYOK proxy. The MCP server keeps their Claude Pro/Max login for
+ * inference and adds AnyForge control (HIL approvals, work items, crews)
+ * on top, with no auth conflict. Offers to run `claude mcp add` for them,
+ * and to enable OpenTelemetry usage metrics so their spend is still
+ * visible on the AnyForge dashboard even though the proxy isn't in path.
+ */
+async function guideSubscriptionUser(sub, endpoint, apiKey) {
+    const who = sub.email ? ` (${sub.email})` : '';
+    /* eslint-disable no-console */
+    console.log();
+    console.log(yellow(`  ⚠ Claude ${sub.plan ?? ''} subscription login detected${who}.`));
+    console.log();
+    console.log('  AnyForge Control’s inference proxy is ' + bold('BYOK-only') + ' — it routes');
+    console.log('  Claude Code through your own Anthropic API key for metering and');
+    console.log('  governance. Pointing Claude Code at the proxy would ' + bold('override and'));
+    console.log('  ' + bold('disable your subscription login') + ', so we did NOT patch your config.');
+    console.log();
+    console.log('  Instead, use your subscription for inference and add the ' + bold('AnyForge'));
+    console.log('  ' + bold('MCP server') + ' for control (HIL approvals, work items, crews):');
+    console.log();
+    const mcpCmd = `claude mcp add anyforge --env ANYFORGE_API_KEY=${apiKey} -- npx -y @anyforge/mcp-server`;
+    const add = await prompts({
+        type: 'confirm',
+        name: 'go',
+        message: 'Add the AnyForge MCP server to Claude Code now?',
+        initial: true,
+    });
+    if (add.go) {
+        try {
+            execFileSync('claude', ['mcp', 'add', 'anyforge', '--env', `ANYFORGE_API_KEY=${apiKey}`, '--', 'npx', '-y', '@anyforge/mcp-server'], { stdio: 'inherit' });
+            console.log(green('  ✔') + ' AnyForge MCP server added to Claude Code.');
+        }
+        catch {
+            console.log(yellow('  Could not run `claude mcp add` automatically (is the `claude` CLI on PATH?).'));
+            console.log(dim('  Add it manually:'));
+            console.log('    ' + mcpCmd);
+        }
     }
-    catch {
-        return false;
+    else {
+        console.log(dim('  Add it later with:'));
+        console.log('    ' + mcpCmd);
     }
+    // Spend visibility without the proxy: Claude Code exports OpenTelemetry
+    // usage metrics (token counts + estimated cost — no prompt content) that
+    // AnyForge can ingest. Safe alongside the subscription login (no auth
+    // env touched).
+    console.log();
+    const tel = await prompts({
+        type: 'confirm',
+        name: 'go',
+        message: 'Send Claude Code usage to your AnyForge dashboard? (token counts only — no prompt content)',
+        initial: true,
+    });
+    if (tel.go) {
+        const sum = await patchClaudeTelemetry({ endpoint, apiKey });
+        if (sum) {
+            console.log(green('  ✔') + ' Usage telemetry enabled — view it at ' + cyan(`${endpoint}/usage`));
+            console.log(dim('    (written to ' + sum.path + '; `anyforge logout` removes it)'));
+        }
+    }
+    else {
+        console.log(dim('  Skipped — your subscription usage stays local to Claude Code.'));
+    }
+    console.log();
+    console.log(dim('  Want the metered BYOK proxy instead? Re-run with ') + bold('--force') + dim(' using an'));
+    console.log(dim('  Anthropic API key on your company (this disables your subscription in'));
+    console.log(dim('  Claude Code; ') + bold('anyforge logout') + dim(' reverts it).'));
+    console.log();
+    console.log(bold('Done.') + ' Visit ' + cyan(`${endpoint}/usage`) + ' to see your traffic.');
+    /* eslint-enable no-console */
 }
-async function isGitRepoRoot(cwd) {
-    // git worktrees use a `.git` file pointing at the real gitdir, so
-    // accept either a directory or a regular file.
+function findGitRoot(cwd) {
+    // Works from any subdirectory — git walks up the tree to find the root.
     try {
-        const stat = await fs.stat(join(cwd, '.git'));
-        return stat.isDirectory() || stat.isFile();
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
     }
     catch {
-        return false;
+        return null;
     }
 }
 async function pickScope(repoRoot) {
@@ -186,6 +261,36 @@ function summarisePatches(patches) {
         console.log(`  ${dim('•')} ${p.label} ${dim('(' + p.path + ')')}`);
     }
 }
+/**
+ * Read the `origin` remote URL and normalise it to `owner/repo`.
+ * Handles both SSH (`git@github.com:owner/repo.git`) and HTTPS forms.
+ * Returns null when there is no remote, git is unavailable, or the
+ * URL can't be parsed into an owner/repo pair.
+ *
+ * Uses execFileSync (not exec/execSync) so no shell interpolation
+ * occurs — the args array is passed directly to the git binary.
+ */
+function detectGitRemoteRepo(repoRoot) {
+    try {
+        const raw = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        // SSH: git@github.com:owner/repo.git
+        const sshMatch = raw.match(/^git@[\w.-]+:([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+        if (sshMatch)
+            return sshMatch[1];
+        // HTTPS: https://github.com/owner/repo[.git]
+        const httpsMatch = raw.match(/^https?:\/\/[\w.-]+\/([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+        if (httpsMatch)
+            return httpsMatch[1];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // Re-exported so future commands (e.g. status) can reuse the prompt
 // shape without duplicating the question text.
 export { prompts };

package/dist/commands/logout.js

@@ -1,21 +1,34 @@
 import { green, dim, yellow } from 'kleur/colors';
-import { clearCredentials } from '../lib/credentials.js';
+import { clearCredentials, loadCredentials } from '../lib/credentials.js';
+import { revertClaudeCodeConfigs } from '../lib/configPatch.js';
 /**
- * `npx @anyforge/control logout` — wipe the local credential file.
- * Does NOT revoke the key on the server side — that's a separate
- * action on /settings → API keys (server-controlled). This is the
- * "remove from this machine" affordance.
+ * `npx @anyforge/control logout` — wipe the local credential file AND
+ * revert the config patches `init` wrote (so a previously-shadowed
+ * Claude subscription login is restored). Does NOT revoke the key on
+ * the server side — that's a separate action on /settings → API keys.
  */
 export async function runLogout() {
+    // Load before clearing so we know which proxy host we patched in
+    // (matters when the user ran `init --endpoint <staging>`).
+    const creds = await loadCredentials();
     const removed = await clearCredentials();
+    const { reverted } = await revertClaudeCodeConfigs({ endpoint: creds?.endpoint ?? null });
+    /* eslint-disable no-console */
     if (removed) {
-        // eslint-disable-next-line no-console
         console.log(green('✔') + ' Local credentials cleared.');
-        // eslint-disable-next-line no-console
-        console.log(dim('  Revoke the key server-side at /settings → API keys.'));
     }
     else {
-        // eslint-disable-next-line no-console
         console.log(yellow('No credentials were saved on this machine.'));
     }
+    if (reverted.length) {
+        console.log(green('✔') + ' Reverted patched configs:');
+        for (const p of reverted)
+            console.log(`  ${dim('•')} ${p}`);
+        console.log(dim('  Your previous Claude Code login (if any) is restored.'));
+    }
+    else {
+        console.log(dim('  No AnyForge config patches found to revert.'));
+    }
+    console.log(dim('  Revoke the key server-side at /settings → API keys.'));
+    /* eslint-enable no-console */
 }

package/dist/lib/configPatch.js

@@ -1,8 +1,70 @@
 import { promises as fs } from 'fs';
+import { execFileSync } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
 import prompts from 'prompts';
 import { dim, green, yellow } from 'kleur/colors';
+/**
+ * Patch local agent configurations so they route through AnyForge.
+ *
+ * Scope:
+ *   - 'global' → ~/.claude/settings.json, plus optional shell-rc
+ *     hints for Cursor / Cline / Continue (which don't have a
+ *     repo-local config we can target).
+ *   - 'repo'   → <repoRoot>/.claude/settings.local.json (gitignored
+ *     by Claude Code's own conventions) plus <repoRoot>/.env. We
+ *     skip Cursor/Cline shell-rc patches in this scope so the
+ *     install stays scoped to the repo with no global side effects.
+ *
+ * Auth header: Claude Code has two env vars for credentials.
+ *   - ANTHROPIC_API_KEY  → sent as `X-Api-Key`. Triggers an "Auth
+ *     conflict: Using ANTHROPIC_API_KEY instead of Anthropic
+ *     Console key" warning when an OAuth login is also present,
+ *     and (per the docs) can cascade into a "selected model may
+ *     not exist" error.
+ *   - ANTHROPIC_AUTH_TOKEN → sent as `Authorization: Bearer …`.
+ *     Documented for "routing through an LLM gateway or proxy"
+ *     and matches AnyForge's bearer-token shape.
+ * We use ANTHROPIC_AUTH_TOKEN. We also explicitly delete any
+ * stale ANTHROPIC_API_KEY from the env map on every run so users
+ * upgrading from earlier installs don't keep both set.
+ *
+ * IMPORTANT precedence caveat: ANTHROPIC_AUTH_TOKEN (#2 in Claude
+ * Code's auth order) OUT-RANKS a Claude Pro/Max subscription login
+ * (#6). Patching it for a subscription user silently disables their
+ * subscription and points Claude Code at the BYOK-only proxy, which
+ * has no upstream key for them → "please login". The caller
+ * (`init`) therefore gates patching behind `detectClaudeSubscription()`
+ * and steers subscription users to the MCP server instead. We always
+ * write a `.anyforge-bak` before patching so `logout` can revert.
+ *
+ * The actual API key is inlined into the env map. We used to write
+ * a `${ANYFORGE_API_KEY}` placeholder and rely on a shell export,
+ * which (a) needed a fresh shell to take effect and (b) failed
+ * silently when the export never landed because the user only had
+ * Claude Code installed.
+ */
+// Sentinel markers wrapping the block we own in .env / shell-rc files,
+// so re-running replaces in place and `logout` can strip it cleanly.
+const SENTINEL_BEGIN = '# === AnyForge Control — added by `anyforge init` ===';
+const SENTINEL_END = '# === end AnyForge Control ===';
+// Suffix for the pre-patch backup of a Claude Code settings file.
+const BACKUP_SUFFIX = '.anyforge-bak';
+// The Claude.ai subscription org types that an ANTHROPIC_AUTH_TOKEN
+// patch would shadow. A Console (API-key) login does not carry these,
+// so BYOK users are unaffected.
+const SUBSCRIPTION_ORG_TYPES = /claude_(max|pro|team|enterprise)/i;
+// Env keys we set when enabling Claude Code → AnyForge usage telemetry
+// (OpenTelemetry metrics only — no prompt/response content). Removed on
+// `logout` when the OTLP endpoint points at AnyForge.
+const TELEMETRY_KEYS = [
+    'CLAUDE_CODE_ENABLE_TELEMETRY',
+    'OTEL_METRICS_EXPORTER',
+    'OTEL_EXPORTER_OTLP_PROTOCOL',
+    'OTEL_EXPORTER_OTLP_ENDPOINT',
+    'OTEL_EXPORTER_OTLP_HEADERS',
+    'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE',
+];
 export async function detectAndPatchConfigs(opts) {
     const summary = [];
     const cc = await patchClaudeCode(opts);
@@ -64,6 +126,42 @@ async function patchClaudeCode(opts) {
         json = {};
     }
     const env = (json.env ?? {});
+    // Detect an existing local LLM endpoint (Ollama, LM Studio, etc.) and warn
+    // before clobbering it. The AnyForge proxy only routes Anthropic Claude
+    // models — local models (Gemma, Llama, etc.) won't work through it.
+    const existingUrl = env.ANTHROPIC_BASE_URL;
+    const isLocalUrl = existingUrl &&
+        !existingUrl.includes(opts.endpoint) &&
+        (existingUrl.includes('localhost') || existingUrl.includes('127.0.0.1') || existingUrl.includes('0.0.0.0'));
+    if (isLocalUrl) {
+        // eslint-disable-next-line no-console
+        console.log();
+        // eslint-disable-next-line no-console
+        console.log(yellow('  ⚠ Local LLM proxy detected: ') + dim(existingUrl));
+        // eslint-disable-next-line no-console
+        console.log(dim('    AnyForge only routes Anthropic Claude models. Local models (Ollama,'));
+        // eslint-disable-next-line no-console
+        console.log(dim('    LM Studio, etc.) will not work in Claude Code after this patch.'));
+        // eslint-disable-next-line no-console
+        console.log(dim('    To restore: remove ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN'));
+        // eslint-disable-next-line no-console
+        console.log(dim(`    from ${path}`));
+        // eslint-disable-next-line no-console
+        console.log();
+        const overwrite = await prompts({
+            type: 'confirm',
+            name: 'go',
+            message: 'Overwrite existing local LLM proxy config?',
+            initial: false,
+        });
+        if (!overwrite.go)
+            return null;
+    }
+    // Back up the pre-patch file once so `anyforge logout` (or the user)
+    // can restore it verbatim. Only the first patch writes a backup.
+    if ((await fileExists(path)) && !(await fileExists(path + BACKUP_SUFFIX))) {
+        await fs.copyFile(path, path + BACKUP_SUFFIX);
+    }
     env.ANTHROPIC_BASE_URL = `${opts.endpoint}/v1/anthropic`;
     env.ANTHROPIC_AUTH_TOKEN = opts.apiKey;
     // Strip stale ANTHROPIC_API_KEY from prior installs — keeping
@@ -80,6 +178,57 @@ async function patchClaudeCode(opts) {
         path,
     };
 }
+/**
+ * Enable Claude Code → AnyForge usage telemetry by writing the standard
+ * OpenTelemetry env into ~/.claude/settings.json. This does NOT touch
+ * auth (no ANTHROPIC_* keys), so it is safe alongside a Pro/Max
+ * subscription login — it just exports `claude_code.token.usage` /
+ * `claude_code.cost.usage` metrics (counts + estimated cost, no prompt
+ * content) to AnyForge's OTLP collector. Returns null if a non-AnyForge
+ * OTel endpoint is already configured (we never clobber a user's own).
+ */
+export async function patchClaudeTelemetry(opts) {
+    const dir = join(homedir(), '.claude');
+    const path = join(dir, 'settings.json');
+    await fs.mkdir(dir, { recursive: true });
+    const txt = await fs.readFile(path, 'utf8').catch(() => '{}');
+    let json;
+    try {
+        json = JSON.parse(txt);
+    }
+    catch {
+        json = {};
+    }
+    const env = (json.env ?? {});
+    const existing = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    if (existing && !isAnyforgeValue(existing, safeHost(opts.endpoint))) {
+        /* eslint-disable no-console */
+        console.log(yellow('  ⚠ An OpenTelemetry endpoint is already configured: ') + dim(existing));
+        console.log(dim('    Leaving it untouched. To send Claude Code usage to AnyForge, point'));
+        console.log(dim('    OTEL_EXPORTER_OTLP_ENDPOINT at ' + opts.endpoint + '/api/otel'));
+        /* eslint-enable no-console */
+        return null;
+    }
+    // Back up once so `logout` can restore verbatim.
+    if ((await fileExists(path)) && !(await fileExists(path + BACKUP_SUFFIX))) {
+        await fs.copyFile(path, path + BACKUP_SUFFIX);
+    }
+    // Metrics only — we deliberately do NOT set OTEL_LOGS_EXPORTER, which
+    // is the channel that can carry prompt/response content.
+    //   - http/json so our collector can parse the body with req.json()
+    //     and needs no protobuf decoder.
+    //   - delta temporality so each 60s export carries the tokens spent in
+    //     that interval (cumulative would force the collector to diff).
+    env.CLAUDE_CODE_ENABLE_TELEMETRY = '1';
+    env.OTEL_METRICS_EXPORTER = 'otlp';
+    env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/json';
+    env.OTEL_EXPORTER_OTLP_ENDPOINT = `${opts.endpoint}/api/otel`;
+    env.OTEL_EXPORTER_OTLP_HEADERS = `Authorization=Bearer ${opts.apiKey}`;
+    env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE = 'delta';
+    json.env = env;
+    await fs.writeFile(path, JSON.stringify(json, null, 2) + '\n');
+    return { label: 'Claude Code usage telemetry (global)', path };
+}
 async function patchRepoEnv(opts) {
     if (!opts.repoRoot)
         return null;
@@ -92,8 +241,6 @@ async function patchRepoEnv(opts) {
     });
     if (!proceed.go)
         return null;
-    const SENTINEL_BEGIN = '# === AnyForge Control — added by `anyforge init` ===';
-    const SENTINEL_END = '# === end AnyForge Control ===';
     const block = [
         SENTINEL_BEGIN,
         `ANYFORGE_API_KEY=${opts.apiKey}`,
@@ -176,8 +323,6 @@ async function ensureShellRcExports(opts) {
     // Idempotent: re-running the CLI shouldn't append duplicate
     // exports. We tag our block with a sentinel comment so we can
     // detect + replace cleanly on subsequent runs.
-    const SENTINEL_BEGIN = '# === AnyForge Control — added by `anyforge init` ===';
-    const SENTINEL_END = '# === end AnyForge Control ===';
     const block = [
         SENTINEL_BEGIN,
         `export ANYFORGE_API_KEY="${opts.apiKey}"`,
@@ -214,3 +359,166 @@ async function fileExists(p) {
         return false;
     }
 }
+/**
+ * Detect a Claude Pro/Max/Team/Enterprise (subscription) login.
+ *
+ * `~/.claude.json` carries an `oauthAccount` block whenever the user
+ * logged in with a Claude.ai account. It lives in the plain-JSON config
+ * on every platform, so — unlike the token itself, which is in the macOS
+ * Keychain — we can read it without triggering a credential prompt. A
+ * Console (API-key) login does not carry these subscription org types,
+ * so BYOK users are correctly left to proceed.
+ */
+export async function detectClaudeSubscription() {
+    try {
+        const txt = await fs.readFile(join(homedir(), '.claude.json'), 'utf8');
+        const json = JSON.parse(txt);
+        const acct = json.oauthAccount;
+        const orgType = acct?.organizationType ?? '';
+        if (acct && SUBSCRIPTION_ORG_TYPES.test(orgType)) {
+            const plan = /max/i.test(orgType) ? 'Max' :
+                /pro/i.test(orgType) ? 'Pro' :
+                    /enterprise/i.test(orgType) ? 'Enterprise' :
+                        /team/i.test(orgType) ? 'Team' :
+                            orgType;
+            return { isSubscription: true, plan, email: acct.emailAddress ?? null };
+        }
+    }
+    catch {
+        // No config / unreadable / unparseable → assume no subscription.
+    }
+    return { isSubscription: false, plan: null, email: null };
+}
+/**
+ * Undo what `init` patched: strip the proxy env keys from Claude Code's
+ * global + repo settings, and remove the sentinel block from .env and
+ * shell rc files. Only touches keys whose value points at the AnyForge
+ * proxy, so a hand-edited base URL is left alone. Restores any
+ * `.anyforge-bak` cleanup afterwards.
+ */
+export async function revertClaudeCodeConfigs(opts = {}) {
+    const host = opts.endpoint ? safeHost(opts.endpoint) : null;
+    const reverted = [];
+    // Global Claude Code settings + shell-rc exports.
+    const globalSettings = join(homedir(), '.claude', 'settings.json');
+    if (await revertSettingsFile(globalSettings, host))
+        reverted.push(globalSettings);
+    for (const rc of ['.zshrc', '.bashrc']) {
+        const p = join(homedir(), rc);
+        if (await stripSentinelBlock(p))
+            reverted.push(p);
+    }
+    // Repo-scoped settings + .env, when invoked inside a working tree.
+    const repoRoot = opts.repoRoot ?? findGitRootSafe(process.cwd());
+    if (repoRoot) {
+        const localSettings = join(repoRoot, '.claude', 'settings.local.json');
+        if (await revertSettingsFile(localSettings, host))
+            reverted.push(localSettings);
+        const envPath = join(repoRoot, '.env');
+        if (await stripSentinelBlock(envPath))
+            reverted.push(envPath);
+    }
+    return { reverted };
+}
+function isAnyforgeValue(v, host) {
+    if (!v)
+        return false;
+    if (v.includes('anyforge'))
+        return true;
+    return host ? v.includes(host) : false;
+}
+/** Remove the proxy keys we injected from a Claude Code settings JSON,
+ *  preferring a verbatim restore from the `.anyforge-bak` backup when it
+ *  exists. Returns true if the file changed. */
+async function revertSettingsFile(path, host) {
+    if (!(await fileExists(path)))
+        return false;
+    // Prefer a clean restore from the pre-patch backup.
+    if (await fileExists(path + BACKUP_SUFFIX)) {
+        await fs.copyFile(path + BACKUP_SUFFIX, path);
+        await fs.unlink(path + BACKUP_SUFFIX).catch(() => { });
+        return true;
+    }
+    // No backup (e.g. patched by an older CLI): surgically drop our keys.
+    let json;
+    try {
+        json = JSON.parse(await fs.readFile(path, 'utf8'));
+    }
+    catch {
+        return false;
+    }
+    const env = json.env;
+    if (!env)
+        return false;
+    let changed = false;
+    const pairs = [
+        ['ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN'],
+        ['OPENAI_BASE_URL', 'OPENAI_API_KEY'],
+    ];
+    for (const [urlKey, tokenKey] of pairs) {
+        if (isAnyforgeValue(env[urlKey], host)) {
+            delete env[urlKey];
+            delete env[tokenKey];
+            changed = true;
+        }
+    }
+    if (env.ANYFORGE_API_KEY) {
+        delete env.ANYFORGE_API_KEY;
+        changed = true;
+    }
+    // Telemetry we injected — only when the OTLP endpoint is AnyForge's, so
+    // we never strip a user's own OpenTelemetry configuration.
+    if (isAnyforgeValue(env.OTEL_EXPORTER_OTLP_ENDPOINT, host)) {
+        for (const k of TELEMETRY_KEYS) {
+            if (k in env) {
+                delete env[k];
+                changed = true;
+            }
+        }
+    }
+    if (!changed)
+        return false;
+    if (Object.keys(env).length === 0)
+        delete json.env;
+    await fs.writeFile(path, JSON.stringify(json, null, 2) + '\n');
+    return true;
+}
+/** Remove the `# === AnyForge Control === … === end === ` block from a
+ *  .env or shell-rc file. Returns true if the file changed. */
+async function stripSentinelBlock(path) {
+    let txt;
+    try {
+        txt = await fs.readFile(path, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    if (!txt.includes(SENTINEL_BEGIN))
+        return false;
+    const next = txt
+        .replace(new RegExp(`\\n?${escapeRe(SENTINEL_BEGIN)}[\\s\\S]*?${escapeRe(SENTINEL_END)}\\n?`), '\n')
+        .replace(/\n{3,}/g, '\n\n');
+    await fs.writeFile(path, next);
+    return true;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function safeHost(endpoint) {
+    try {
+        return new URL(endpoint).host;
+    }
+    catch {
+        return null;
+    }
+}
+function findGitRootSafe(cwd) {
+    try {
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyforge/control",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "AnyForge Control CLI — governed LLM proxy for Claude Code, Cursor, Cline, and any agent that talks to OpenAI- or Anthropic-shape APIs.",
   "license": "Apache-2.0",
   "homepage": "https://anyforge.ai",