@anyforge/control 0.2.4 → 0.3.0

package/dist/lib/configPatch.js

@@ -1,524 +0,0 @@
-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);
-    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} via shell rc (${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;
-}
-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 ?? {});
-    // 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
-    // both set re-triggers the auth-conflict warning even though
-    // ANTHROPIC_AUTH_TOKEN is what we actually want Claude Code
-    // to use.
-    delete env.ANTHROPIC_API_KEY;
-    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,
-    };
-}
-/**
- * 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;
-    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 block = [
-        SENTINEL_BEGIN,
-        `ANYFORGE_API_KEY=${opts.apiKey}`,
-        `ANTHROPIC_BASE_URL=${opts.endpoint}/v1/anthropic`,
-        `ANTHROPIC_AUTH_TOKEN=${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() {
-            const path = join(homedir(), '.cursor');
-            const exists = await fileExists(path);
-            return exists ? { path: '.cursor (shell hint)' } : null;
-        },
-        async patch(_found, opts) {
-            await ensureShellRcExports(opts);
-        },
-    },
-    {
-        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 block = [
-        SENTINEL_BEGIN,
-        `export ANYFORGE_API_KEY="${opts.apiKey}"`,
-        `export ANTHROPIC_BASE_URL="${opts.endpoint}/v1/anthropic"`,
-        `export ANTHROPIC_AUTH_TOKEN="${opts.apiKey}"`,
-        `export OPENAI_BASE_URL="${opts.endpoint}/v1/openai"`,
-        `export OPENAI_API_KEY="${opts.apiKey}"`,
-        `unset ANTHROPIC_API_KEY 2>/dev/null || true`,
-        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)) {
-            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;
-    }
-}
-/**
- * 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/dist/lib/credentials.js

@@ -1,40 +0,0 @@
-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 };