@anyforge/control 0.1.0-beta.0

package/README.md

@@ -0,0 +1,55 @@
+# @anyforge/control
+
+Governed LLM proxy for any agent. Use the AI tools you already use — Claude Code, Cursor, Cline, Continue, or your own SDK — and route every call through AnyForge for cost analytics, audit log, and policy enforcement.
+
+## Install
+
+```bash
+npx @anyforge/control init
+```
+
+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`.
+
+After that, your next LLM call shows up under `Control` on `/usage` within seconds.
+
+## Commands
+
+| | |
+|---|---|
+| `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) |
+
+## Endpoints
+
+The CLI defaults to `https://crew.anyforge.ai`. Override per-invocation with `--endpoint`, or globally with the `ANYFORGE_ENDPOINT` environment variable.
+
+The proxy exposes:
+
+- `POST /v1/anthropic/messages` — drop-in for `https://api.anthropic.com/v1/messages`. Use `Authorization: Bearer sk_anyforge_…` instead of `x-api-key`.
+- `POST /v1/openai/chat/completions` — drop-in for `https://api.openai.com/v1/chat/completions`.
+
+Both validate your AnyForge API key, look up your company's BYOK provider key, forward the request, and stream the response back unchanged. Token counts and cost are logged to your usage dashboard.
+
+## What you get
+
+- **Cost analytics** — per-call, per-company, per-model spend on `/usage`.
+- **Audit log** — hash-chained record of every prompt + response.
+- **BYOK** — your provider keys live in your AnyForge company; the CLI never holds raw provider keys on the local machine.
+- **One key, every agent** — the same `sk_anyforge_…` works for any agent that talks OpenAI- or Anthropic-shape APIs.
+
+## Coming soon
+
+- `anyforge proxy` — local proxy mode for OPA-enforced redaction before requests leave your network.
+- Intent-based routing (rules / regex / embeddings).
+- Portable memory injection.
+- Ollama support for local models.
+
+## License
+
+Apache-2.0

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * @anyforge/control — entrypoint.
+ *
+ * Subcommands:
+ *   init         — browser-based auth flow + config patching
+ *   whoami       — show current identity
+ *   logout       — clear stored credentials
+ *   status       — connectivity + key health check
+ *   apply-patch  — apply a unified diff (file or stdin) via git apply
+ *   proxy        — local proxy mode (Phase 2 — coming soon)
+ *
+ * Each subcommand is a separate module under src/commands/. The
+ * argv parsing here is deliberately tiny — no commander, no yargs.
+ * For three flags and four commands, hand-rolled is shorter than
+ * the lib + plugin chain.
+ */
+import { red, yellow, dim, bold } from 'kleur/colors';
+import { runInit } from './commands/init.js';
+import { runWhoami } from './commands/whoami.js';
+import { runLogout } from './commands/logout.js';
+import { runStatus } from './commands/status.js';
+import { runApplyPatch } from './commands/applyPatch.js';
+function parseArgs(argv) {
+    const a = { positional: [] };
+    for (let i = 0; i < argv.length; i += 1) {
+        const v = argv[i];
+        if (!a.command && !v.startsWith('-')) {
+            a.command = v;
+            continue;
+        }
+        if (v === '--help' || v === '-h')
+            a.help = true;
+        else if (v === '--version' || v === '-V')
+            a.version = true;
+        else if (v === '--endpoint' && argv[i + 1]) {
+            a.endpoint = argv[i + 1];
+            i += 1;
+        }
+        else if (v === '--3way')
+            a.threeWay = true;
+        else if (v === '--dry-run')
+            a.dryRun = true;
+        else if (!v.startsWith('-'))
+            a.positional.push(v);
+    }
+    return a;
+}
+function printHelp() {
+    // eslint-disable-next-line no-console
+    console.log(`
+${bold('AnyForge Control')} — governed LLM proxy for any agent.
+
+${bold('USAGE')}
+  npx @anyforge/control <command> [options]
+
+${bold('COMMANDS')}
+  init           Authorise this device and patch local agent configs
+  whoami         Show the company tied to the saved API key
+  status         Check connectivity to the AnyForge proxy
+  logout         Clear the saved API key and patched configs
+  apply-patch    Apply a unified diff (file path or stdin) via git apply
+
+${bold('OPTIONS')}
+  --endpoint <url>   Override the proxy base URL (default: ${dim('https://crew.anyforge.ai')})
+  --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
+  --version, -V      Print CLI version
+
+${bold('EXAMPLES')}
+  npx @anyforge/control init
+  npx @anyforge/control status
+  npx @anyforge/control apply-patch ./agent-suggestion.diff
+  pbpaste | npx @anyforge/control apply-patch
+  npx @anyforge/control apply-patch ./conflict.diff --3way
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.version) {
+        const pkg = await import('../package.json', { assert: { type: 'json' } });
+        // eslint-disable-next-line no-console
+        console.log(pkg.default.version);
+        return;
+    }
+    if (args.help || !args.command) {
+        printHelp();
+        return;
+    }
+    // The proxy lives at ${endpoint} — same host as Code Studio, Crew,
+    // and the operator console. Override via --endpoint or
+    // ANYFORGE_ENDPOINT for staging.
+    const endpoint = args.endpoint
+        ?? process.env.ANYFORGE_ENDPOINT
+        ?? 'https://crew.anyforge.ai';
+    try {
+        switch (args.command) {
+            case 'init':
+                await runInit({ endpoint });
+                break;
+            case 'whoami':
+                await runWhoami();
+                break;
+            case 'status':
+                await runStatus({ endpoint });
+                break;
+            case 'logout':
+                await runLogout();
+                break;
+            case 'apply-patch':
+                await runApplyPatch({
+                    patchFile: args.positional[0],
+                    threeWay: args.threeWay,
+                    dryRun: args.dryRun,
+                });
+                break;
+            case 'proxy':
+                // eslint-disable-next-line no-console
+                console.log(yellow('Local proxy mode is coming in a future release.'));
+                // eslint-disable-next-line no-console
+                console.log(dim('  Until then, your agents talk directly to the AnyForge proxy.'));
+                break;
+            default:
+                // eslint-disable-next-line no-console
+                console.error(red(`Unknown command: ${args.command}`));
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(red('Error: ') + (err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+}
+void main();

package/dist/commands/applyPatch.js

@@ -0,0 +1,92 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { red, green, yellow, dim, bold } from 'kleur/colors';
+export async function runApplyPatch(opts) {
+    const patchContent = await loadPatch(opts.patchFile);
+    if (!patchContent.trim()) {
+        process.stderr.write(red('Empty patch — nothing to apply.\n'));
+        process.exit(1);
+    }
+    const stats = parseDiffStats(patchContent);
+    process.stderr.write(dim(`Patch: ${stats.files} ${stats.files === 1 ? 'file' : 'files'}, `) +
+        green(`+${stats.added}`) + ' ' + red(`-${stats.removed}`) + '\n');
+    // git apply --check first — never make a partial mess
+    const check = await runGit(['apply', '--check'], patchContent);
+    if (check.code !== 0) {
+        if (opts.threeWay) {
+            const three = await runGit(['apply', '--3way'], patchContent);
+            if (three.code !== 0) {
+                process.stderr.write(red('3-way apply failed:\n') + three.stderr + '\n');
+                process.exit(1);
+            }
+            process.stderr.write(yellow('✓ Applied via 3-way merge — review conflicts before committing.\n'));
+            return;
+        }
+        process.stderr.write(red('Patch does not apply cleanly:\n') + check.stderr + '\n');
+        process.stderr.write(dim('Try ') + bold('--3way') + dim(' to attempt a 3-way merge against the index.\n'));
+        process.exit(1);
+    }
+    if (opts.dryRun) {
+        process.stderr.write(green('✓ Patch would apply cleanly.\n'));
+        return;
+    }
+    const apply = await runGit(['apply'], patchContent);
+    if (apply.code !== 0) {
+        process.stderr.write(red('git apply failed:\n') + apply.stderr + '\n');
+        process.exit(1);
+    }
+    process.stderr.write(green('✓ Applied.\n'));
+    if (stats.files > 0) {
+        process.stderr.write(dim('  Run ') + bold('git diff --stat') + dim(' to review.\n'));
+    }
+}
+async function loadPatch(filePath) {
+    if (filePath) {
+        return await readFile(filePath, 'utf8');
+    }
+    // Read stdin to a single string
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/** Spawn `git <args>`, pipe `stdinData` to its stdin, return code +
+ *  captured streams. No shell — args are passed as a list to spawn. */
+function runGit(args, stdinData) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', d => { stdout += d.toString(); });
+        child.stderr.on('data', d => { stderr += d.toString(); });
+        child.on('error', reject);
+        child.on('close', code => resolve({ code: code ?? 0, stdout, stderr }));
+        child.stdin.write(stdinData);
+        child.stdin.end();
+    });
+}
+/** Quick stats parse off a unified diff — counts file headers and
+ *  +/- lines. Skips diff metadata lines (+++, ---) so the report
+ *  matches `git apply --stat` shape close enough for an inline note. */
+function parseDiffStats(patch) {
+    let files = 0;
+    let added = 0;
+    let removed = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('diff --git'))
+            files += 1;
+        else if (line.startsWith('+++') || line.startsWith('---'))
+            continue;
+        else if (line.startsWith('+'))
+            added += 1;
+        else if (line.startsWith('-'))
+            removed += 1;
+    }
+    if (files === 0 && (added > 0 || removed > 0)) {
+        // Patch had no `diff --git` headers (a hand-rolled fragment);
+        // count filename headers instead.
+        files = (patch.match(/^\+\+\+ /gm) ?? []).length;
+    }
+    return { files, added, removed };
+}

package/dist/commands/init.js

@@ -0,0 +1,104 @@
+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';
+const POLL_INTERVAL_MS = 2_000;
+const POLL_TIMEOUT_MS = 15 * 60 * 1000;
+export async function runInit(opts) {
+    const { endpoint } = opts;
+    // eslint-disable-next-line no-console
+    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' });
+    const init = (await initRes.json());
+    if (!init.ok || !init.data) {
+        throw new Error(`Could not start the authorisation flow: ${init.error ?? 'unknown error'}`);
+    }
+    const { code, authUrl, pollUrl } = init.data;
+    // 2. Open the browser. Some shells (CI, headless) can't open one;
+    //    the URL also prints so the user can copy it manually.
+    // eslint-disable-next-line no-console
+    console.log();
+    // eslint-disable-next-line no-console
+    console.log(`Open this URL in your browser to authorise:`);
+    // eslint-disable-next-line no-console
+    console.log(`  ${cyan(authUrl)}`);
+    // eslint-disable-next-line no-console
+    console.log(dim(`  Code: ${code}`));
+    // eslint-disable-next-line no-console
+    console.log();
+    try {
+        await open(authUrl);
+    }
+    catch {
+        // Headless / CI — the printed URL is fine.
+    }
+    // 3. Poll. Keep the message live so the user sees we're alive.
+    const credentials = await pollForToken({ pollUrl, endpoint });
+    // 4. Save credentials with restrictive perms.
+    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 });
+    if (patches.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log(yellow('No local agent configs detected.'));
+        // 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.'));
+    }
+    else {
+        summarisePatches(patches);
+    }
+    // eslint-disable-next-line no-console
+    console.log();
+    // eslint-disable-next-line no-console
+    console.log(bold('Done.') + ' Visit ' + cyan(`${endpoint}/usage`) + ' to see your traffic.');
+}
+async function pollForToken(args) {
+    const start = Date.now();
+    // eslint-disable-next-line no-console
+    process.stdout.write('Waiting for browser authorisation… ');
+    let dotCount = 0;
+    while (Date.now() - start < POLL_TIMEOUT_MS) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+        process.stdout.write('.');
+        dotCount += 1;
+        if (dotCount > 40) {
+            process.stdout.write('\n');
+            dotCount = 0;
+        }
+        const res = await fetch(args.pollUrl);
+        const body = (await res.json());
+        if (body.status === 'authorized' && body.data) {
+            process.stdout.write(' ' + green('done') + '\n');
+            return {
+                apiKey: body.data.apiKey,
+                companyId: body.data.companyId,
+                endpoint: args.endpoint,
+                savedAt: new Date().toISOString(),
+            };
+        }
+        if (body.status === 'expired' || body.status === 'not_found') {
+            process.stdout.write('\n');
+            throw new Error(`Authorisation ${body.status}. Re-run \`anyforge init\`.`);
+        }
+    }
+    throw new Error('Authorisation timed out (15 min). Re-run `anyforge init`.');
+}
+function summarisePatches(patches) {
+    // eslint-disable-next-line no-console
+    console.log(green('✔') + ' Patched ' + patches.length + ' agent config' + (patches.length === 1 ? '' : 's') + ':');
+    for (const p of patches) {
+        // eslint-disable-next-line no-console
+        console.log(`  ${dim('•')} ${p.label} ${dim('(' + p.path + ')')}`);
+    }
+}
+// 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

@@ -0,0 +1,21 @@
+import { green, dim, yellow } from 'kleur/colors';
+import { clearCredentials } from '../lib/credentials.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.
+ */
+export async function runLogout() {
+    const removed = await clearCredentials();
+    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.'));
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,58 @@
+import { green, red, yellow, dim } from 'kleur/colors';
+import { loadCredentials } from '../lib/credentials.js';
+export async function runStatus(opts) {
+    const c = await loadCredentials();
+    if (!c) {
+        // eslint-disable-next-line no-console
+        console.log(yellow('Not logged in.') + ' Run ' + dim('npx @anyforge/control init') + ' first.');
+        return;
+    }
+    const endpoint = opts.endpoint || c.endpoint;
+    // eslint-disable-next-line no-console
+    console.log(`Endpoint:  ${endpoint}`);
+    // eslint-disable-next-line no-console
+    console.log(`Company:   ${c.companyId}`);
+    // We don't have a dedicated /v1/health endpoint yet — the cheapest
+    // probe is a 1-token Anthropic Messages call. Costs ~$0.0001, fine.
+    const probeBody = {
+        model: 'claude-3-5-haiku-20241022',
+        max_tokens: 1,
+        messages: [{ role: 'user', content: 'Hi' }],
+    };
+    let res;
+    try {
+        res = await fetch(`${endpoint}/v1/anthropic/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'anthropic-version': '2023-06-01',
+                Authorization: `Bearer ${c.apiKey}`,
+            },
+            body: JSON.stringify(probeBody),
+        });
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.log(red('✗ Proxy unreachable: ') + err.message);
+        process.exit(1);
+    }
+    if (res.status === 401) {
+        // eslint-disable-next-line no-console
+        console.log(red('✗ API key rejected.') + ' Re-run ' + dim('npx @anyforge/control init') + '.');
+        process.exit(1);
+    }
+    if (res.status === 502) {
+        // eslint-disable-next-line no-console
+        console.log(red('✗ No BYOK Anthropic key configured for your company.'));
+        // eslint-disable-next-line no-console
+        console.log(dim('  Add one at ') + endpoint + dim('/settings → API keys.'));
+        process.exit(1);
+    }
+    if (!res.ok) {
+        // eslint-disable-next-line no-console
+        console.log(red(`✗ Proxy returned ${res.status}: `) + (await res.text()).slice(0, 200));
+        process.exit(1);
+    }
+    // eslint-disable-next-line no-console
+    console.log(green('✔ Proxy reachable, key valid, BYOK configured.'));
+}

package/dist/commands/whoami.js

@@ -0,0 +1,23 @@
+import { dim, yellow } from 'kleur/colors';
+import { loadCredentials } from '../lib/credentials.js';
+/**
+ * `npx @anyforge/control whoami` — show the company id tied to the
+ * currently saved credential. Useful for verifying the right device
+ * is configured before running long agent sessions.
+ */
+export async function runWhoami() {
+    const c = await loadCredentials();
+    if (!c) {
+        // eslint-disable-next-line no-console
+        console.log(yellow('Not logged in.') + ' Run ' + dim('npx @anyforge/control init') + ' first.');
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(`Company:  ${c.companyId}`);
+    // eslint-disable-next-line no-console
+    console.log(`Endpoint: ${c.endpoint}`);
+    // eslint-disable-next-line no-console
+    console.log(`Saved:    ${new Date(c.savedAt).toLocaleString()}`);
+    // eslint-disable-next-line no-console
+    console.log(`Key tail: ${dim('…' + c.apiKey.slice(-4))}`);
+}

package/dist/lib/configPatch.js

@@ -0,0 +1,139 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import prompts from 'prompts';
+import { dim, green } 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 found = await detector.detect();
+        if (!found)
+            continue;
+        const proceed = await prompts({
+            type: 'confirm',
+            name: 'go',
+            message: `Patch ${detector.label} config at ${dim(found.path)} ?`,
+            initial: true,
+        });
+        if (!proceed.go)
+            continue;
+        try {
+            await detector.patch(found, opts);
+            summary.push({ label: detector.label, path: found.path });
+            // eslint-disable-next-line no-console
+            console.log(green('  ✔') + ' ' + detector.label);
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('  ⚠ Skipped ' + detector.label + ': ' + err.message);
+        }
+    }
+    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.
+    {
+        label: 'Cursor (shell hint)',
+        async detect() {
+            const path = join(homedir(), '.cursor');
+            const exists = await fileExists(path);
+            return exists ? { path: '.cursor (shell hint)' } : null;
+        },
+        async patch(_found, opts) {
+            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() {
+            const a = await fileExists(join(homedir(), '.cline'));
+            const b = await fileExists(join(homedir(), '.continue'));
+            return a || b ? { path: '~/.cline or ~/.continue (shell hint)' } : null;
+        },
+        async patch(_found, opts) {
+            await ensureShellRcExports(opts);
+        },
+    },
+];
+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="$(jq -r '.apiKey' ~/.anyforge/credentials 2>/dev/null)"`,
+        `export ANTHROPIC_BASE_URL="${opts.endpoint}/v1/anthropic"`,
+        `export OPENAI_BASE_URL="${opts.endpoint}/v1/openai"`,
+        `export OPENAI_API_KEY="$ANYFORGE_API_KEY"`,
+        SENTINEL_END,
+        '',
+    ].join('\n');
+    for (const rc of ['.zshrc', '.bashrc']) {
+        const path = join(homedir(), rc);
+        if (!(await fileExists(path)))
+            continue;
+        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 {
+            next = cur.endsWith('\n') ? `${cur}\n${block}` : `${cur}\n\n${block}`;
+        }
+        if (next !== cur)
+            await fs.writeFile(path, next);
+    }
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/credentials.js

@@ -0,0 +1,40 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+const DIR = join(homedir(), '.anyforge');
+const FILE = join(DIR, 'credentials');
+export async function saveCredentials(c) {
+    await fs.mkdir(DIR, { recursive: true, mode: 0o700 });
+    await fs.writeFile(FILE, JSON.stringify(c, null, 2), { mode: 0o600 });
+}
+export async function loadCredentials() {
+    try {
+        const text = await fs.readFile(FILE, 'utf8');
+        return JSON.parse(text);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+export async function clearCredentials() {
+    try {
+        await fs.unlink(FILE);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+export function credentialsPath() {
+    return FILE;
+}
+export function credentialsDir() {
+    return DIR;
+}
+// Exported so test code can stub this at the module boundary if
+// needed without monkey-patching node's `fs`.
+export const __internal = { DIR, FILE, dirname };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@anyforge/control",
+  "version": "0.1.0-beta.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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pootonline/sovereign-engineering.git",
+    "directory": "packages/control/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "anyforge": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run build",
+    "publish:beta": "npm publish --access public --tag beta",
+    "publish:stable": "npm publish --access public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "kleur": "^4.1.5",
+    "open": "^10.0.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/prompts": "^2.4.9",
+    "tsx": "^4.7.0",
+    "typescript": "^5.5.3"
+  }
+}