copillm 0.1.0

package/dist/auth/interactivePrompt.js

@@ -0,0 +1,135 @@
+// Minimal interactive prompt helpers for the CLI. Reads stdin in raw mode
+// when attached to a TTY; falls back to line mode otherwise. Always restores
+// stdin state on completion (success, error, or abort) via try/finally.
+//
+// These helpers are intended for very short interactions (single-keypress
+// y/n confirmation, single-keypress menu choice). Anything longer should use
+// readline directly.
+const CTRL_C = "\u0003";
+const CTRL_D = "\u0004";
+function getStdin() {
+    // Cast through unknown — node's stream types are wider than what we need.
+    return process.stdin;
+}
+function getStdout() {
+    return process.stdout;
+}
+async function readSingleKey() {
+    const stdin = getStdin();
+    if (!stdin.isTTY) {
+        throw new Error("Cannot read interactive input: stdin is not a TTY.");
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onData = (chunk) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            stdin.off("data", onData);
+            try {
+                stdin.setRawMode?.(false);
+                stdin.pause();
+            }
+            catch (error) {
+                reject(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            resolve(chunk);
+        };
+        try {
+            stdin.setEncoding("utf8");
+            stdin.setRawMode?.(true);
+            stdin.resume();
+            stdin.once("data", onData);
+        }
+        catch (error) {
+            stdin.off("data", onData);
+            try {
+                stdin.setRawMode?.(false);
+                stdin.pause();
+            }
+            catch {
+                // best-effort restoration
+            }
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+function isAbortKey(key) {
+    return key === CTRL_C || key === CTRL_D;
+}
+/**
+ * Prompt the user with a y/n question. Returns true for y/Y, false for n/N.
+ * Throws if the user sends Ctrl+C / Ctrl+D, or if stdin is not a TTY.
+ */
+export async function confirm(message) {
+    const stdout = getStdout();
+    stdout.write(`${message} [y/N] `);
+    let answer = "";
+    try {
+        answer = await readSingleKey();
+    }
+    catch (error) {
+        stdout.write("\n");
+        throw error;
+    }
+    const first = answer.charAt(0);
+    if (isAbortKey(first)) {
+        stdout.write("\n");
+        throw new Error("Interactive prompt aborted by user.");
+    }
+    const lowered = first.toLowerCase();
+    const isYes = lowered === "y";
+    stdout.write(`${isYes ? "y" : "n"}\n`);
+    return isYes;
+}
+/**
+ * Prompt the user with a single-keypress menu. Each option has a one-character
+ * `key` (case-insensitive match) shown in parens before its label.
+ *
+ * Throws if the user sends Ctrl+C / Ctrl+D, or if stdin is not a TTY. Retries
+ * silently on unrecognised keypresses (up to `maxAttempts` times).
+ */
+export async function choose(message, options, maxAttempts = 5) {
+    if (options.length === 0) {
+        throw new Error("choose() requires at least one option.");
+    }
+    const seenKeys = new Set();
+    for (const opt of options) {
+        if (opt.key.length !== 1) {
+            throw new Error(`choose() option keys must be a single character (got '${opt.key}').`);
+        }
+        const lowered = opt.key.toLowerCase();
+        if (seenKeys.has(lowered)) {
+            throw new Error(`choose() option keys must be unique (duplicate '${opt.key}').`);
+        }
+        seenKeys.add(lowered);
+    }
+    const stdout = getStdout();
+    const rendered = options.map((opt) => `(${opt.key.toLowerCase()})${opt.label}`).join(" / ");
+    stdout.write(`${message}\n  ${rendered}: `);
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        let key = "";
+        try {
+            key = await readSingleKey();
+        }
+        catch (error) {
+            stdout.write("\n");
+            throw error;
+        }
+        const first = key.charAt(0);
+        if (isAbortKey(first)) {
+            stdout.write("\n");
+            throw new Error("Interactive prompt aborted by user.");
+        }
+        const match = options.find((opt) => opt.key.toLowerCase() === first.toLowerCase());
+        if (match) {
+            stdout.write(`${match.key.toLowerCase()}  (${match.label})\n`);
+            return match.value;
+        }
+        stdout.write("\n  invalid choice — try again: ");
+    }
+    stdout.write("\n");
+    throw new Error(`No valid choice after ${maxAttempts} attempts.`);
+}

package/dist/claude/cache.js

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function claudeGatewayCachePath() {
+    return path.join(os.homedir(), ".claude", "cache", "gateway-models.json");
+}
+export function clearClaudeGatewayCache() {
+    const target = claudeGatewayCachePath();
+    if (!fs.existsSync(target)) {
+        return { cleared: false, path: target, reason: "not_present" };
+    }
+    try {
+        fs.unlinkSync(target);
+        return { cleared: true, path: target, reason: null };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : "unknown_error";
+        return { cleared: false, path: target, reason: detail };
+    }
+}

package/dist/claude/settingsConflict.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function claudeSettingsPath() {
+    return path.join(os.homedir(), ".claude", "settings.json");
+}
+export function detectClaudeSettingsConflicts(launcherEnv, settingsPathOverride) {
+    const settingsPath = settingsPathOverride ?? claudeSettingsPath();
+    const empty = { settingsPath, exists: false, parseError: null, conflicts: [] };
+    let raw;
+    try {
+        raw = fs.readFileSync(settingsPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return empty;
+        }
+        return { ...empty, exists: true, parseError: errMessage(error) };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return { settingsPath, exists: true, parseError: errMessage(error), conflicts: [] };
+    }
+    const env = readEnvBlock(parsed);
+    if (!env) {
+        return { settingsPath, exists: true, parseError: null, conflicts: [] };
+    }
+    const conflicts = [];
+    for (const [key, launcherValue] of Object.entries(launcherEnv)) {
+        const settingsValue = env[key];
+        if (typeof settingsValue !== "string")
+            continue;
+        if (settingsValue === launcherValue)
+            continue;
+        conflicts.push({ key, settingsValue, launcherValue });
+    }
+    return { settingsPath, exists: true, parseError: null, conflicts };
+}
+export function formatSettingsConflictWarning(result) {
+    if (result.parseError !== null) {
+        return [
+            "",
+            "⚠ copillm could not inspect Claude Code's settings.json for env overrides.",
+            `  File: ${result.settingsPath}`,
+            `  Reason: ${result.parseError}`,
+            "  If the file exists and sets `env` keys like ANTHROPIC_BASE_URL or ANTHROPIC_AUTH_TOKEN,",
+            "  Claude Code will silently override copillm's values once launched. Inspect the file",
+            "  manually (or fix the read/parse error above) so this check can run.",
+            ""
+        ];
+    }
+    if (result.conflicts.length === 0)
+        return [];
+    const lines = [];
+    lines.push("");
+    lines.push("⚠ Claude Code settings.json overrides copillm's env vars.");
+    lines.push(`  File: ${result.settingsPath}`);
+    lines.push("  Claude Code exports its settings.json `env` block into its own process environment,");
+    lines.push("  which takes precedence over values supplied by `copillm claude` or your shell.");
+    lines.push("  The following keys will silently override copillm's values:");
+    for (const conflict of result.conflicts) {
+        lines.push(`    • ${conflict.key}`);
+        lines.push(`        settings.json: ${conflict.settingsValue}`);
+        lines.push(`        copillm value: ${conflict.launcherValue}`);
+    }
+    lines.push("  Fix: remove these keys from the `env` block in the file above, then re-run.");
+    lines.push("");
+    return lines;
+}
+function readEnvBlock(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const env = parsed.env;
+    if (!env || typeof env !== "object" || Array.isArray(env))
+        return null;
+    return env;
+}
+function errMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

package/dist/cli/agentEnv.js

@@ -0,0 +1,56 @@
+import { computeAnthropicDefaults, readModelIdsFromCache } from "../models/anthropicDefaults.js";
+export function buildClaudeEnvBundle(input) {
+    const defaults = input.defaults ?? computeAnthropicDefaults(readModelIdsFromCache());
+    const enableGateway = input.enableGatewayDiscovery !== false;
+    const env = {
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${input.port}/anthropic`,
+        ANTHROPIC_AUTH_TOKEN: input.callerSecret ?? "copillm-local"
+    };
+    const trailingNotes = [];
+    if (defaults.opus) {
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL = defaults.opus;
+    }
+    else {
+        trailingNotes.push("no opus variant detected — set ANTHROPIC_DEFAULT_OPUS_MODEL manually");
+    }
+    if (defaults.sonnet) {
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL = defaults.sonnet;
+    }
+    else {
+        trailingNotes.push("no sonnet variant detected — set ANTHROPIC_DEFAULT_SONNET_MODEL manually");
+    }
+    if (defaults.haiku) {
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = defaults.haiku;
+    }
+    else {
+        trailingNotes.push("no haiku variant detected — set ANTHROPIC_DEFAULT_HAIKU_MODEL manually");
+    }
+    if (enableGateway) {
+        env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+    }
+    return { env, inlineComments: {}, trailingNotes, defaults };
+}
+export function buildCodexEnvBundle(absHomeDir) {
+    return {
+        env: { CODEX_HOME: absHomeDir },
+        inlineComments: {},
+        trailingNotes: []
+    };
+}
+/**
+ * Pi has no environment-variable override for its config directory; it reads
+ * `~/.pi/agent/models.json` unconditionally. So this bundle is intentionally
+ * empty — the real configuration work happens in `generatePiHome()` writing
+ * that file. We expose the helper for symmetry with the other agents and to
+ * carry a trailing note explaining what to look at when debugging.
+ */
+export function buildPiEnvBundle(absMirrorDir) {
+    return {
+        env: {},
+        inlineComments: {},
+        trailingNotes: [
+            `pi reads ~/.pi/agent/models.json directly (no env var override).`,
+            `copillm regenerated it on \`copillm start\` and mirrored it at ${absMirrorDir}/models.json.`
+        ]
+    };
+}

package/dist/cli/configCommands.js

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { getCopillmHome } from "../config/home.js";
+import { ensureSecureDirectory, writeFileSecureAtomic } from "../config/fsSecurity.js";
+import { AgentConfigError, loadAgentConfig } from "../agentconfig/load.js";
+import { applyAgentConfig, formatApplyNotes } from "../agentconfig/apply.js";
+const SCAFFOLD_TOML = `# copillm agent config — one source of truth for instructions and MCP servers
+# fanned out to each coding agent on \`copillm <agent>\` launch.
+# See: https://github.com/jcjc-dev/copillm (plans/unified-booping-mango.md)
+
+active_profile = "default"
+
+[defaults.instructions]
+body = ""
+
+# Uncomment to add an MCP server visible to every profile:
+# [defaults.mcp.servers.github]
+# transport = "http"
+# url = "https://api.githubcopilot.com/mcp/"
+# headers = { Authorization = "Bearer \${GITHUB_TOKEN}" }
+
+[profiles.default]
+`;
+export function registerConfigCommands(program) {
+    const config = program.command("config").description("Manage ~/.copillm/agent.toml (unified agent config)");
+    config
+        .command("init")
+        .description("Scaffold ~/.copillm/agent.toml with an empty default profile")
+        .option("--force", "Overwrite an existing agent.toml", false)
+        .action((opts) => {
+        const target = path.join(getCopillmHome(), "agent.toml");
+        if (fs.existsSync(target) && !opts.force) {
+            process.stderr.write(`${target} already exists; pass --force to overwrite.\n`);
+            process.exit(1);
+        }
+        ensureSecureDirectory(path.dirname(target));
+        writeFileSecureAtomic(target, SCAFFOLD_TOML, 0o600);
+        process.stdout.write(`Scaffolded ${target}\n`);
+    });
+    config
+        .command("show")
+        .description("Print the resolved profile (post-merge, post-env-expansion)")
+        .option("--profile <name>", "Resolve a specific profile instead of the active one")
+        .action((opts) => {
+        try {
+            const result = loadAgentConfig({ cwd: process.cwd(), profileOverride: opts.profile ?? null });
+            if (!result) {
+                process.stdout.write("No ~/.copillm/agent.toml or ./.copillm/agent.toml found.\n");
+                return;
+            }
+            process.stdout.write(`active profile: ${result.active}\n`);
+            process.stdout.write(`sources:\n`);
+            for (const src of result.sources) {
+                process.stdout.write(`  - ${src.scope}: ${src.path}\n`);
+            }
+            process.stdout.write(`\nresolved:\n${JSON.stringify(result.resolved, null, 2)}\n`);
+        }
+        catch (error) {
+            handleAgentConfigError(error);
+        }
+    });
+    const profile = config.command("profile").description("Profile management");
+    profile
+        .command("list")
+        .description("List all profiles in the global agent.toml")
+        .action(() => {
+        const target = path.join(getCopillmHome(), "agent.toml");
+        if (!fs.existsSync(target)) {
+            process.stdout.write("No global agent.toml. Run `copillm config init` first.\n");
+            return;
+        }
+        try {
+            const parsed = parseToml(fs.readFileSync(target, "utf8"));
+            const active = parsed.active_profile ?? "default";
+            const names = Object.keys(parsed.profiles ?? {});
+            if (names.length === 0) {
+                process.stdout.write("No profiles defined. Add [profiles.<name>] to agent.toml.\n");
+                return;
+            }
+            for (const name of names) {
+                process.stdout.write(`${name === active ? "* " : "  "}${name}\n`);
+            }
+        }
+        catch (error) {
+            handleAgentConfigError(error);
+        }
+    });
+    profile
+        .command("use <name>")
+        .description("Set active_profile in the global agent.toml")
+        .action((name) => {
+        const target = path.join(getCopillmHome(), "agent.toml");
+        if (!fs.existsSync(target)) {
+            process.stderr.write("No global agent.toml. Run `copillm config init` first.\n");
+            process.exit(1);
+        }
+        try {
+            const raw = fs.readFileSync(target, "utf8");
+            const parsed = parseToml(raw);
+            if (!parsed.profiles || !(name in parsed.profiles)) {
+                process.stderr.write(`Profile "${name}" not found. Existing: ${Object.keys(parsed.profiles ?? {}).join(", ") || "(none)"}\n`);
+                process.exit(1);
+            }
+            parsed.active_profile = name;
+            writeFileSecureAtomic(target, stringifyToml(parsed), 0o600);
+            process.stdout.write(`active_profile = "${name}"\n`);
+        }
+        catch (error) {
+            handleAgentConfigError(error);
+        }
+    });
+    config
+        .command("sync")
+        .description("Run fan-out without launching an agent (debug aid)")
+        .requiredOption("--agent <kind>", "codex | claude | pi | copilot")
+        .option("--profile <name>", "Override active profile for this run")
+        .action((opts) => {
+        const agent = opts.agent;
+        if (!["codex", "claude", "pi", "copilot"].includes(agent)) {
+            process.stderr.write(`Unknown agent kind "${opts.agent}".\n`);
+            process.exit(1);
+        }
+        try {
+            const result = applyAgentConfig({
+                agent,
+                cwd: process.cwd(),
+                profileOverride: opts.profile ?? null,
+                codexHomeDir: agent === "codex" ? path.join(getCopillmHome(), "codex") : undefined
+            });
+            for (const line of formatApplyNotes(result, agent)) {
+                process.stdout.write(`${line}\n`);
+            }
+            if (result.active === null) {
+                process.stdout.write("(no agent.toml — nothing to do)\n");
+            }
+        }
+        catch (error) {
+            handleAgentConfigError(error);
+        }
+    });
+}
+function handleAgentConfigError(error) {
+    if (error instanceof AgentConfigError) {
+        process.stderr.write(`copillm config: ${error.message}\n`);
+        process.exit(1);
+    }
+    throw error;
+}

package/dist/cli/envBlock.js

@@ -0,0 +1,43 @@
+export const AGENT_DISPLAY_NAMES = {
+    codex: "Codex CLI",
+    claude: "Claude Code",
+    pi: "pi coding agent"
+};
+export function renderEnvBlock(input) {
+    const lines = [];
+    lines.push(`# ${AGENT_DISPLAY_NAMES[input.agent]} \u2192 copillm`);
+    for (const [key, value] of Object.entries(input.env)) {
+        const line = renderEnvLine(key, value, input.shell);
+        const comment = input.inlineComments?.[key];
+        lines.push(comment ? `${line}    # ${comment}` : line);
+    }
+    if (input.trailingNotes) {
+        for (const note of input.trailingNotes) {
+            lines.push(`# ${note}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function renderEnvLine(key, value, shell) {
+    switch (shell) {
+        case "sh":
+            return `export ${key}="${escapeForDoubleQuotes(value)}"`;
+        case "fish":
+            return `set -gx ${key} "${escapeForDoubleQuotes(value)}"`;
+        case "powershell":
+            return `$env:${key} = "${escapeForPowerShellDoubleQuotes(value)}"`;
+    }
+}
+export function isShellSyntax(value) {
+    return value === "sh" || value === "fish" || value === "powershell";
+}
+function escapeForDoubleQuotes(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, "\\$")
+        .replace(/`/g, "\\`");
+}
+function escapeForPowerShellDoubleQuotes(value) {
+    return value.replace(/`/g, "``").replace(/"/g, '`"').replace(/\$/g, "`$");
+}

package/dist/cli/launchAgent.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { resolveAgent } from "./resolveAgent.js";
+export async function launchAgent(opts) {
+    const log = opts.log ?? ((line) => process.stderr.write(`${line}\n`));
+    let resolved;
+    try {
+        resolved = await resolveAgent(opts.agent, { pinnedSpec: opts.pinnedSpec, log });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(message);
+        log(installHint(opts.agent));
+        return 127;
+    }
+    log(resolved.displayLine);
+    const childEnv = { ...process.env, ...opts.env };
+    const useShell = process.platform === "win32" && /\.(cmd|bat)$/i.test(resolved.binPath);
+    const child = spawn(resolved.binPath, opts.args, {
+        stdio: "inherit",
+        env: childEnv,
+        shell: useShell
+    });
+    return new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (signal) {
+                try {
+                    process.kill(process.pid, signal);
+                }
+                catch {
+                    // fall through
+                }
+                resolve(128);
+                return;
+            }
+            resolve(code ?? 0);
+        });
+    });
+}
+function installHint(agent) {
+    if (agent === "codex") {
+        return [
+            "Hint: install Codex CLI manually with one of:",
+            "    brew install codex",
+            "    npm i -g @openai/codex",
+            "    https://github.com/openai/codex/releases"
+        ].join("\n");
+    }
+    if (agent === "pi") {
+        return [
+            "Hint: install pi coding agent manually with:",
+            "    npm i -g @earendil-works/pi-coding-agent"
+        ].join("\n");
+    }
+    return [
+        "Hint: install Claude Code manually with:",
+        "    npm i -g @anthropic-ai/claude-code"
+    ].join("\n");
+}