@anyforge/control 0.1.0 → 0.2.0

package/README.md

@@ -12,10 +12,26 @@ The CLI:
 
 1. Issues a one-time auth code, opens your browser to authorise it.
 2. Stores the resulting API key at `~/.anyforge/credentials` (chmod 600).
-3. Detects local agent configs (Claude Code, Cursor, Cline, Continue) and offers to patch them so existing tools route through `https://crew.anyforge.ai/v1/anthropic` and `…/v1/openai`.
+3. Asks whether to install **globally** (`~/.claude/settings.json`) or **per-repo** (the per-repo option only appears when you run the command at the root of a git working tree).
+4. Patches the chosen target so Claude Code routes through `https://crew.anyforge.ai/v1/anthropic` and `…/v1/openai`. The actual API key is **inlined** into the patched config — no `${ANYFORGE_API_KEY}` indirection, no shell restart required.
 
 After that, your next LLM call shows up under `Control` on `/usage` within seconds.
 
+### Install scope
+
+| Choice | Files written | Effect |
+|---|---|---|
+| `global` | `~/.claude/settings.json` (+ optional shell-rc hints for Cursor / Cline if installed) | Every Claude Code session on this machine routes through AnyForge |
+| `repo` | `<repo>/.claude/settings.local.json` and `<repo>/.env` | Only Claude Code sessions inside this repo are routed; no global side effects |
+
+Pick whichever suits the moment — the choices aren't mutually exclusive over time:
+
+- 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.
+
+> 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.**
+
 ## Commands
 
 | | |

package/dist/commands/init.js

@@ -1,3 +1,5 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
 import open from 'open';
 import prompts from 'prompts';
 import { green, dim, bold, yellow, cyan } from 'kleur/colors';
@@ -42,21 +44,40 @@ export async function runInit(opts) {
     await saveCredentials(credentials);
     // eslint-disable-next-line no-console
     console.log(green('✔') + ' API key saved to ' + dim('~/.anyforge/credentials'));
-    // 5. Patch local agent configs (interactive — operator confirms each).
-    const patches = await detectAndPatchConfigs({ endpoint });
+    // 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 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.
+    const patches = await detectAndPatchConfigs({
+        endpoint,
+        apiKey: credentials.apiKey,
+        scope,
+        repoRoot,
+    });
     if (patches.length === 0) {
         // eslint-disable-next-line no-console
-        console.log(yellow('No local agent configs detected.'));
+        console.log(yellow('No agent configs were patched.'));
         // eslint-disable-next-line no-console
         console.log(dim('  Set ANTHROPIC_BASE_URL=' + endpoint + '/v1/anthropic and'));
         // eslint-disable-next-line no-console
-        console.log(dim('  OPENAI_BASE_URL=' + endpoint + '/v1/openai in your shell when ready.'));
+        console.log(dim('  ANTHROPIC_API_KEY=<your AnyForge key> manually if needed.'));
     }
     else {
         summarisePatches(patches);
     }
     // eslint-disable-next-line no-console
     console.log();
+    if (scope === 'repo') {
+        // eslint-disable-next-line no-console
+        console.log(dim('  Re-run this command in another repo to patch it too,'));
+        // eslint-disable-next-line no-console
+        console.log(dim('  or run from any directory and choose "global" to install system-wide.'));
+    }
     // eslint-disable-next-line no-console
     console.log(bold('Done.') + ' Visit ' + cyan(`${endpoint}/usage`) + ' to see your traffic.');
 }
@@ -91,6 +112,38 @@ async function pollForToken(args) {
     }
     throw new Error('Authorisation timed out (15 min). Re-run `anyforge init`.');
 }
+async function isGitRepoRoot(cwd) {
+    // git worktrees use a `.git` file pointing at the real gitdir, so
+    // accept either a directory or a regular file.
+    try {
+        const stat = await fs.stat(join(cwd, '.git'));
+        return stat.isDirectory() || stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function pickScope(repoRoot) {
+    if (!repoRoot) {
+        // eslint-disable-next-line no-console
+        console.log(dim('  Not a git repo root — installing globally.'));
+        // eslint-disable-next-line no-console
+        console.log(dim('  Run this from a repo root if you want a per-repo install instead.'));
+        return 'global';
+    }
+    const choice = await prompts({
+        type: 'select',
+        name: 'scope',
+        message: 'Where should AnyForge patch Claude Code?',
+        choices: [
+            { title: `This repo only (${repoRoot}/.claude/settings.local.json + .env)`, value: 'repo' },
+            { title: 'Globally (~/.claude/settings.json)', value: 'global' },
+        ],
+        initial: 0,
+    });
+    // prompts returns {} on cancel — default to repo since they were given the choice.
+    return choice.scope ?? 'repo';
+}
 function summarisePatches(patches) {
     // eslint-disable-next-line no-console
     console.log(green('✔') + ' Patched ' + patches.length + ' agent config' + (patches.length === 1 ? '' : 's') + ':');

package/dist/lib/configPatch.js

@@ -2,20 +2,28 @@ import { promises as fs } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import prompts from 'prompts';
-import { dim, green } from 'kleur/colors';
+import { dim, green, yellow } from 'kleur/colors';
 export async function detectAndPatchConfigs(opts) {
     const summary = [];
-    // Each detector is independent so a missing config never blocks
-    // the others. Prompts batched at the end isn't worth it — the
-    // operator wants to see what we found before approving.
-    for (const detector of DETECTORS) {
+    const cc = await patchClaudeCode(opts);
+    if (cc)
+        summary.push(cc);
+    if (opts.scope === 'repo') {
+        const env = await patchRepoEnv(opts);
+        if (env)
+            summary.push(env);
+        return summary;
+    }
+    // Global scope only — Cursor / Cline have no per-repo config we
+    // can usefully target, so we leave them out of the repo flow.
+    for (const detector of OPTIONAL_GLOBAL_DETECTORS) {
         const found = await detector.detect();
         if (!found)
             continue;
         const proceed = await prompts({
             type: 'confirm',
             name: 'go',
-            message: `Patch ${detector.label} config at ${dim(found.path)} ?`,
+            message: `Patch ${detector.label} via shell rc (${dim(found.path)}) ?`,
             initial: true,
         });
         if (!proceed.go)
@@ -33,44 +41,109 @@ export async function detectAndPatchConfigs(opts) {
     }
     return summary;
 }
-const DETECTORS = [
-    // Claude Code keeps user-level settings at ~/.claude/settings.json
-    // and reads ANTHROPIC_BASE_URL / ANTHROPIC_API_KEY from the
-    // process env or its `env` block. We patch the `env` block in the
-    // settings file so the change persists across shell restarts.
-    {
-        label: 'Claude Code',
-        async detect() {
-            const path = join(homedir(), '.claude', 'settings.json');
-            const exists = await fileExists(path);
-            return exists ? { path } : null;
-        },
-        async patch(found, opts) {
-            const txt = await fs.readFile(found.path, 'utf8').catch(() => '{}');
-            let json;
-            try {
-                json = JSON.parse(txt);
-            }
-            catch {
-                json = {};
-            }
-            const env = (json.env ?? {});
-            env.ANTHROPIC_BASE_URL = `${opts.endpoint}/v1/anthropic`;
-            // ANTHROPIC_API_KEY references the saved credential. Claude Code
-            // expands `$` env vars so we use ANYFORGE_API_KEY which the user
-            // exports separately, keeping the actual secret out of the json.
-            env.ANTHROPIC_API_KEY = '${ANYFORGE_API_KEY}';
-            json.env = env;
-            await fs.writeFile(found.path, JSON.stringify(json, null, 2));
-            // Drop a hint into the user's shell-rc so ANYFORGE_API_KEY is
-            // exported next time they open a terminal. We never cat the
-            // key into the file — they exported the credentials when they
-            // ran `init`, the credentials reader will surface it.
-        },
-    },
-    // Cursor reads cursor.config.json or its in-app Settings. We don't
-    // patch those today (they're product-managed) — but we leave a
-    // hint about ANTHROPIC_BASE_URL via shell rc.
+async function patchClaudeCode(opts) {
+    const target = opts.scope === 'repo' && opts.repoRoot
+        ? { dir: join(opts.repoRoot, '.claude'), file: 'settings.local.json' }
+        : { dir: join(homedir(), '.claude'), file: 'settings.json' };
+    const path = join(target.dir, target.file);
+    const proceed = await prompts({
+        type: 'confirm',
+        name: 'go',
+        message: `Patch Claude Code config at ${dim(path)} ?`,
+        initial: true,
+    });
+    if (!proceed.go)
+        return null;
+    await fs.mkdir(target.dir, { recursive: true });
+    const txt = await fs.readFile(path, 'utf8').catch(() => '{}');
+    let json;
+    try {
+        json = JSON.parse(txt);
+    }
+    catch {
+        json = {};
+    }
+    const env = (json.env ?? {});
+    env.ANTHROPIC_BASE_URL = `${opts.endpoint}/v1/anthropic`;
+    env.ANTHROPIC_API_KEY = opts.apiKey;
+    json.env = env;
+    await fs.writeFile(path, JSON.stringify(json, null, 2) + '\n');
+    // eslint-disable-next-line no-console
+    console.log(green('  ✔') + ' Claude Code');
+    return {
+        label: opts.scope === 'repo' ? 'Claude Code (repo)' : 'Claude Code (global)',
+        path,
+    };
+}
+async function patchRepoEnv(opts) {
+    if (!opts.repoRoot)
+        return null;
+    const envPath = join(opts.repoRoot, '.env');
+    const proceed = await prompts({
+        type: 'confirm',
+        name: 'go',
+        message: `Write AnyForge env block to ${dim(envPath)} ?`,
+        initial: true,
+    });
+    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}`,
+        `ANTHROPIC_BASE_URL=${opts.endpoint}/v1/anthropic`,
+        `ANTHROPIC_API_KEY=${opts.apiKey}`,
+        `OPENAI_BASE_URL=${opts.endpoint}/v1/openai`,
+        `OPENAI_API_KEY=${opts.apiKey}`,
+        SENTINEL_END,
+        '',
+    ].join('\n');
+    let cur = '';
+    try {
+        cur = await fs.readFile(envPath, 'utf8');
+    }
+    catch { /* missing is fine */ }
+    let next;
+    if (cur.includes(SENTINEL_BEGIN)) {
+        // Idempotent: re-running replaces the existing block in place.
+        next = cur.replace(new RegExp(`${SENTINEL_BEGIN}[\\s\\S]*?${SENTINEL_END}\\n?`), block);
+    }
+    else if (cur.length === 0) {
+        next = block;
+    }
+    else {
+        next = cur.endsWith('\n') ? `${cur}${block}` : `${cur}\n${block}`;
+    }
+    if (next !== cur)
+        await fs.writeFile(envPath, next);
+    // The .env contains a live API key — flag it if it isn't gitignored.
+    await warnIfNotGitignored(opts.repoRoot);
+    // eslint-disable-next-line no-console
+    console.log(green('  ✔') + ' .env');
+    return { label: '.env (repo)', path: envPath };
+}
+async function warnIfNotGitignored(repoRoot) {
+    const gi = join(repoRoot, '.gitignore');
+    try {
+        const txt = await fs.readFile(gi, 'utf8');
+        const lines = txt.split('\n').map(l => l.trim());
+        const ignored = lines.some(l => l === '.env' || l === '/.env' || l === '*.env');
+        if (!ignored) {
+            // eslint-disable-next-line no-console
+            console.log(yellow('  ⚠ .env is not in .gitignore — add it before committing.'));
+        }
+    }
+    catch {
+        // eslint-disable-next-line no-console
+        console.log(yellow('  ⚠ No .gitignore found — make sure .env is excluded before committing.'));
+    }
+}
+// Optional best-effort detectors for tools that don't expose a config
+// file we can patch directly. They just append exports to the user's
+// shell rc; the API key is inlined so a brand-new shell picks it up
+// without depending on jq or the credentials file being readable.
+const OPTIONAL_GLOBAL_DETECTORS = [
     {
         label: 'Cursor (shell hint)',
         async detect() {
@@ -82,8 +155,6 @@ const DETECTORS = [
             await ensureShellRcExports(opts);
         },
     },
-    // Cline / Continue reads OPENAI_BASE_URL by default. Same shell
-    // rc patch as the Cursor case.
     {
         label: 'Cline / Continue (shell hint)',
         async detect() {
@@ -104,10 +175,11 @@ async function ensureShellRcExports(opts) {
     const SENTINEL_END = '# === end AnyForge Control ===';
     const block = [
         SENTINEL_BEGIN,
-        `export ANYFORGE_API_KEY="$(jq -r '.apiKey' ~/.anyforge/credentials 2>/dev/null)"`,
+        `export ANYFORGE_API_KEY="${opts.apiKey}"`,
         `export ANTHROPIC_BASE_URL="${opts.endpoint}/v1/anthropic"`,
+        `export ANTHROPIC_API_KEY="${opts.apiKey}"`,
         `export OPENAI_BASE_URL="${opts.endpoint}/v1/openai"`,
-        `export OPENAI_API_KEY="$ANYFORGE_API_KEY"`,
+        `export OPENAI_API_KEY="${opts.apiKey}"`,
         SENTINEL_END,
         '',
     ].join('\n');
@@ -118,7 +190,6 @@ async function ensureShellRcExports(opts) {
         const cur = await fs.readFile(path, 'utf8');
         let next;
         if (cur.includes(SENTINEL_BEGIN)) {
-            // Replace the existing block in place so re-runs stay clean.
             next = cur.replace(new RegExp(`${SENTINEL_BEGIN}[\\s\\S]*?${SENTINEL_END}\\n?`), block);
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyforge/control",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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",