copillm 0.2.3 → 0.2.5

package/dist/cli/commands/daemon.js

@@ -0,0 +1,358 @@
+import { spawn } from "node:child_process";
+import { inspectStoredCredential } from "../../auth/credentials.js";
+import { loadConfig } from "../../config/config.js";
+import { clearClaudeGatewayCache } from "../../integrations/claude/cache.js";
+import { inspectLock, releaseLock } from "../../server/lock.js";
+import { buildCodexEnvBundle } from "../agentEnv.js";
+import { ensureAuthenticatedInteractive } from "../auth/ensure.js";
+import { computeUptimeSeconds, stopByPid } from "../daemon/lifecycle.js";
+import { probeHealth, readLiveLock, waitForDaemonReady, warnIfDebugRequestedButInactive } from "../daemon/probes.js";
+import { runDaemon } from "../daemon/runDaemon.js";
+import { daemonSpawnEnv } from "../daemon/spawnEnv.js";
+import { buildClaudeExportCommand } from "../integrations/claudeExport.js";
+import { formatStartBanner, formatStopHumanLine } from "../integrations/banner.js";
+import { refreshCodexHome } from "../integrations/refreshCodex.js";
+import { refreshPiHome } from "../integrations/refreshPi.js";
+import { writeAuthStatusLine } from "../shared/backends.js";
+import { currentDebugLogPath, enableRuntimeDebug, getRootLogger, resolveCopillmDebug } from "../shared/debug.js";
+import { writeCommandOutput, writeHealthOutput } from "../shared/output.js";
+import { buildSelfSpawnCommand } from "../daemon/selfSpawn.js";
+export function register(program) {
+    program
+        .command("start")
+        .description("Start proxy")
+        .option("--detach", "Run in detached mode")
+        .option("--debug", "Enable debug endpoints (e.g. /_debug)")
+        .option("--no-codex", "Skip generating ~/.copillm/codex/ for Codex CLI")
+        .option("--codex-model <id>", "Default Codex model slug")
+        .option("--no-pi", "Skip generating ~/.pi/agent/models.json for pi coding agent")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const debug = resolveCopillmDebug(opts.debug);
+        enableRuntimeDebug(debug);
+        if (opts.detach) {
+            // Fail fast on missing credentials rather than letting the detached
+            // child die silently and surface as a generic "start timed out" error.
+            const authState = await inspectStoredCredential();
+            if (!authState.stored) {
+                throw new Error("Not authenticated. Run `copillm auth login` first, or start without --detach to log in interactively.");
+            }
+            const existingLock = await readLiveLock();
+            if (existingLock) {
+                const activeDebug = await warnIfDebugRequestedButInactive(debug, existingLock.port);
+                const codex = opts.codex === false ? null : await refreshCodexHome(existingLock.port, opts.codexModel ?? null);
+                const pi = opts.pi === false ? null : await refreshPiHome(existingLock.port);
+                const claude = buildClaudeExportCommand(existingLock.port, null);
+                const banner = formatStartBanner({
+                    port: existingLock.port,
+                    pid: existingLock.pid,
+                    mode: "already_running",
+                    debug: activeDebug,
+                    debugLogPath: null,
+                    codex,
+                    pi
+                });
+                writeCommandOutput(opts, banner, {
+                    status: "already_running",
+                    pid: existingLock.pid,
+                    port: existingLock.port,
+                    debug: activeDebug,
+                    url: `http://127.0.0.1:${existingLock.port}`,
+                    codex_home: codex?.outDir ?? null,
+                    codex_export_command: codex?.exportCommand ?? null,
+                    codex_env: codex ? buildCodexEnvBundle(codex.outDir).env : null,
+                    pi_home: pi?.outDir ?? null,
+                    pi_config_path: pi?.configPath ?? null,
+                    pi_mirror_path: pi?.mirrorPath ?? null,
+                    pi_backup_path: pi?.backupPath ?? null,
+                    pi_model_count: pi?.modelCount ?? null,
+                    claude_export_command: claude.command,
+                    claude_env: claude.bundle.env,
+                    claude_defaults: claude.defaults
+                });
+                return;
+            }
+            const daemonCommand = buildSelfSpawnCommand("daemon");
+            if (debug) {
+                daemonCommand.args.push("--debug");
+            }
+            const child = spawn(daemonCommand.command, daemonCommand.args, {
+                detached: true,
+                stdio: "ignore",
+                env: daemonSpawnEnv(debug)
+            });
+            child.unref();
+            const started = await waitForDaemonReady(child.pid ?? null, 8_000);
+            if (!started) {
+                throw new Error("Detached daemon start timed out.");
+            }
+            const codex = opts.codex === false ? null : await refreshCodexHome(started.port, opts.codexModel ?? null);
+            const pi = opts.pi === false ? null : await refreshPiHome(started.port);
+            const claude = buildClaudeExportCommand(started.port, null);
+            const banner = formatStartBanner({
+                port: started.port,
+                pid: started.pid,
+                mode: "detached",
+                debug,
+                debugLogPath: currentDebugLogPath(debug),
+                codex,
+                pi
+            });
+            writeCommandOutput(opts, banner, {
+                status: "ok",
+                mode: "detached",
+                pid: started.pid,
+                port: started.port,
+                debug,
+                debug_log_path: currentDebugLogPath(debug),
+                url: `http://127.0.0.1:${started.port}`,
+                codex_home: codex?.outDir ?? null,
+                codex_export_command: codex?.exportCommand ?? null,
+                codex_env: codex ? buildCodexEnvBundle(codex.outDir).env : null,
+                codex_default_model: codex?.defaultModel ?? null,
+                codex_model_count: codex?.modelCount ?? null,
+                pi_home: pi?.outDir ?? null,
+                pi_config_path: pi?.configPath ?? null,
+                pi_mirror_path: pi?.mirrorPath ?? null,
+                pi_backup_path: pi?.backupPath ?? null,
+                pi_model_count: pi?.modelCount ?? null,
+                claude_export_command: claude.command,
+                claude_env: claude.bundle.env,
+                claude_defaults: claude.defaults
+            });
+            return;
+        }
+        // Foreground path: interactively prompt for login if needed.
+        await ensureAuthenticatedInteractive();
+        const started = await runDaemon({ debug });
+        if (started.kind === "already_running") {
+            const activeDebug = await warnIfDebugRequestedButInactive(debug, started.lock.port);
+            const codex = opts.codex === false ? null : await refreshCodexHome(started.lock.port, opts.codexModel ?? null);
+            const pi = opts.pi === false ? null : await refreshPiHome(started.lock.port);
+            const claude = buildClaudeExportCommand(started.lock.port, null);
+            const banner = formatStartBanner({
+                port: started.lock.port,
+                pid: started.lock.pid,
+                mode: "already_running",
+                debug: activeDebug,
+                debugLogPath: null,
+                codex,
+                pi
+            });
+            writeCommandOutput(opts, banner, {
+                status: "already_running",
+                pid: started.lock.pid,
+                port: started.lock.port,
+                debug: activeDebug,
+                url: `http://127.0.0.1:${started.lock.port}`,
+                codex_home: codex?.outDir ?? null,
+                codex_export_command: codex?.exportCommand ?? null,
+                codex_env: codex ? buildCodexEnvBundle(codex.outDir).env : null,
+                pi_home: pi?.outDir ?? null,
+                pi_config_path: pi?.configPath ?? null,
+                pi_mirror_path: pi?.mirrorPath ?? null,
+                pi_backup_path: pi?.backupPath ?? null,
+                pi_model_count: pi?.modelCount ?? null,
+                claude_export_command: claude.command,
+                claude_env: claude.bundle.env,
+                claude_defaults: claude.defaults
+            });
+            return;
+        }
+        const codex = opts.codex === false ? null : await refreshCodexHome(started.port, opts.codexModel ?? null);
+        const pi = opts.pi === false ? null : await refreshPiHome(started.port);
+        const claude = buildClaudeExportCommand(started.port, started.callerSecret);
+        const banner = formatStartBanner({
+            port: started.port,
+            pid: process.pid,
+            mode: "foreground",
+            debug,
+            debugLogPath: currentDebugLogPath(debug),
+            codex,
+            pi
+        });
+        writeCommandOutput(opts, banner, {
+            status: "ok",
+            mode: "foreground",
+            pid: process.pid,
+            port: started.port,
+            debug,
+            debug_log_path: currentDebugLogPath(debug),
+            url: `http://127.0.0.1:${started.port}`,
+            caller_secret: started.callerSecret,
+            codex_home: codex?.outDir ?? null,
+            codex_export_command: codex?.exportCommand ?? null,
+            codex_env: codex ? buildCodexEnvBundle(codex.outDir).env : null,
+            codex_default_model: codex?.defaultModel ?? null,
+            codex_model_count: codex?.modelCount ?? null,
+            pi_home: pi?.outDir ?? null,
+            pi_config_path: pi?.configPath ?? null,
+            pi_mirror_path: pi?.mirrorPath ?? null,
+            pi_backup_path: pi?.backupPath ?? null,
+            pi_model_count: pi?.modelCount ?? null,
+            claude_export_command: claude.command,
+            claude_env: claude.bundle.env,
+            claude_defaults: claude.defaults
+        });
+    });
+    program
+        .command("daemon")
+        .description("Internal background command")
+        .option("--debug", "Enable debug endpoints")
+        .action(async (opts) => {
+        const debug = resolveCopillmDebug(opts.debug);
+        enableRuntimeDebug(debug);
+        try {
+            const started = await runDaemon({ debug });
+            if (started.kind === "already_running") {
+                process.exit(0);
+            }
+            process.stdout.write(`copillm listening on http://127.0.0.1:${started.port}${debug ? " [debug]" : ""}\n`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            getRootLogger().fatal({ err }, "daemon failed to start");
+            process.stderr.write(`copillm daemon: ${message}\n`);
+            process.exit(1);
+        }
+    });
+    program
+        .command("stop")
+        .description("Stop detached daemon")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const lockState = inspectLock();
+        if (lockState.state === "missing") {
+            const cache = clearClaudeGatewayCache();
+            writeCommandOutput(opts, formatStopHumanLine("Not running.", cache), {
+                status: "not_running",
+                claude_cache: cache
+            });
+            return;
+        }
+        if (lockState.state === "stale") {
+            releaseLock();
+            const cache = clearClaudeGatewayCache();
+            writeCommandOutput(opts, formatStopHumanLine("Removed stale lock.", cache), {
+                status: "stale_lock_removed",
+                reason: lockState.reason,
+                claude_cache: cache
+            });
+            return;
+        }
+        await stopByPid(lockState.lock.pid);
+        const cache = clearClaudeGatewayCache();
+        writeCommandOutput(opts, formatStopHumanLine("Stopped.", cache), {
+            status: "ok",
+            pid: lockState.lock.pid,
+            claude_cache: cache
+        });
+    });
+    program
+        .command("status")
+        .description("Show daemon status")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const config = loadConfig();
+        const lockState = inspectLock();
+        const checkedAtIso = new Date().toISOString();
+        const uptimeSeconds = lockState.state === "running" ? computeUptimeSeconds(lockState.lock.started_at_iso) : null;
+        // inspectStoredCredential never returns the token itself, so it's safe to
+        // include the result in the status payload.
+        let authInfo;
+        try {
+            const info = await inspectStoredCredential();
+            authInfo = { stored: info.stored, backend: info.backend, error: null };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown_error";
+            authInfo = { stored: false, backend: null, error: message };
+        }
+        const status = {
+            running: lockState.state === "running",
+            stale: lockState.state === "stale",
+            pid: lockState.state === "running" ? lockState.lock.pid : null,
+            port: lockState.state === "running" ? lockState.lock.port : null,
+            started_at_iso: lockState.state === "running" ? lockState.lock.started_at_iso : null,
+            uptime_seconds: uptimeSeconds,
+            url: lockState.state === "running" ? `http://127.0.0.1:${lockState.lock.port}` : null,
+            require_caller_secret: config.requireCallerSecret,
+            account_type: config.accountType,
+            selected_models: config.selectedModels,
+            auth: authInfo,
+            bearer_ttl_seconds: null,
+            health_check_status_code: null,
+            health_state: null,
+            health_error: null,
+            health_status: "unknown",
+            checked_at_iso: checkedAtIso,
+            stale_reason: lockState.state === "stale" ? lockState.reason : null
+        };
+        if (lockState.state === "running") {
+            const health = await probeHealth(lockState.lock.port);
+            status.health_status = health.ok ? "ok" : "degraded";
+            status.bearer_ttl_seconds = health.bearerTtlSeconds;
+            status.health_check_status_code = health.statusCode;
+            status.health_state = health.status;
+            status.health_error = health.error;
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(status, null, 2) + "\n");
+            return;
+        }
+        if (lockState.state === "running") {
+            process.stdout.write(`running (pid ${lockState.lock.pid}, port ${lockState.lock.port})\n`);
+            process.stdout.write(`health: ${status.health_status}`);
+            if (status.health_state) {
+                process.stdout.write(` (${status.health_state})`);
+            }
+            if (status.health_check_status_code !== null) {
+                process.stdout.write(` [http ${status.health_check_status_code}]`);
+            }
+            if (status.health_error) {
+                process.stdout.write(` error=${status.health_error}`);
+            }
+            process.stdout.write("\n");
+            if (status.bearer_ttl_seconds !== null) {
+                process.stdout.write(`bearer_ttl_seconds: ${status.bearer_ttl_seconds}\n`);
+            }
+            if (status.uptime_seconds !== null) {
+                process.stdout.write(`uptime_seconds: ${status.uptime_seconds}\n`);
+            }
+            writeAuthStatusLine(authInfo);
+            process.stdout.write(`checked_at: ${status.checked_at_iso}\n`);
+            return;
+        }
+        if (lockState.state === "stale") {
+            process.stdout.write(`stale lock (${lockState.reason})\n`);
+            writeAuthStatusLine(authInfo);
+            return;
+        }
+        process.stdout.write("not running\n");
+        writeAuthStatusLine(authInfo);
+    });
+    program
+        .command("health")
+        .description("Check health endpoint")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const lockState = inspectLock();
+        if (lockState.state !== "running") {
+            const payload = {
+                ok: false,
+                status: lockState.state === "stale" ? "stale_lock" : "not_running",
+                detail: lockState.state === "stale" ? lockState.reason : "Daemon is not running."
+            };
+            writeHealthOutput(opts, payload);
+            process.exitCode = 1;
+            return;
+        }
+        const response = await fetch(`http://127.0.0.1:${lockState.lock.port}/healthz`, { signal: AbortSignal.timeout(2_000) });
+        const payload = (await response.json());
+        const output = { ok: response.ok, status_code: response.status, ...payload };
+        writeHealthOutput(opts, output);
+        if (!response.ok) {
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/env.js

@@ -0,0 +1,135 @@
+import { detectClaudeSettingsConflicts, formatSettingsConflictWarning } from "../../integrations/claude/settingsConflict.js";
+import { inspectLock } from "../../server/lock.js";
+import { buildCodexEnvBundle, buildPiEnvBundle } from "../agentEnv.js";
+import { isShellSyntax, renderEnvBlock } from "../envBlock.js";
+import { buildClaudeExportCommand } from "../integrations/claudeExport.js";
+import { refreshCodexHome } from "../integrations/refreshCodex.js";
+import { refreshPiHome } from "../integrations/refreshPi.js";
+import { parseAgentName } from "../shared/parseAgent.js";
+export function register(program) {
+    program
+        .command("env <agent>")
+        .description("Print env vars to launch codex, claude, or pi against copillm")
+        .option("--shell <shell>", "Shell syntax: sh|fish|powershell", "sh")
+        .option("--json", "JSON output")
+        .option("--inline", "Single-line legacy export form (claude only)")
+        .action(async (agentRaw, opts) => {
+        const agent = parseAgentName(agentRaw);
+        if (!isShellSyntax(opts.shell)) {
+            throw new Error(`Unsupported --shell value: ${opts.shell}. Use sh, fish, or powershell.`);
+        }
+        const shell = opts.shell;
+        const lockState = inspectLock();
+        if (lockState.state !== "running") {
+            const message = lockState.state === "stale"
+                ? `copillm has a stale lock (${lockState.reason}). Run \`copillm stop\` then \`copillm start --detach\`.`
+                : "copillm is not running. Run `copillm start --detach` first.";
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ status: "not_running", agent, error: message }, null, 2) + "\n");
+            }
+            else {
+                process.stderr.write(`${message}\n`);
+            }
+            process.exit(2);
+            return;
+        }
+        if (agent === "codex") {
+            const codex = await refreshCodexHome(lockState.lock.port, null);
+            if (!codex) {
+                throw new Error("Failed to prepare Codex home (see warning above).");
+            }
+            const bundle = buildCodexEnvBundle(codex.outDir);
+            const block = renderEnvBlock({
+                agent: "codex",
+                env: bundle.env,
+                shell,
+                inlineComments: bundle.inlineComments,
+                trailingNotes: bundle.trailingNotes
+            });
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({
+                    agent: "codex",
+                    package: "@openai/codex",
+                    shell,
+                    env: bundle.env,
+                    shell_block: block
+                }, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write(`${block}\n`);
+            }
+            process.exit(0);
+        }
+        if (agent === "pi") {
+            const pi = await refreshPiHome(lockState.lock.port);
+            if (!pi) {
+                throw new Error("Failed to prepare pi models.json (see warning above).");
+            }
+            const bundle = buildPiEnvBundle(pi.outDir);
+            const block = renderEnvBlock({
+                agent: "pi",
+                env: bundle.env,
+                shell,
+                inlineComments: bundle.inlineComments,
+                trailingNotes: bundle.trailingNotes
+            });
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({
+                    agent: "pi",
+                    package: "@earendil-works/pi-coding-agent",
+                    shell,
+                    env: bundle.env,
+                    shell_block: block,
+                    pi_home: pi.outDir,
+                    pi_config_path: pi.configPath,
+                    pi_mirror_path: pi.mirrorPath,
+                    pi_backup_path: pi.backupPath,
+                    pi_model_count: pi.modelCount
+                }, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write(`${block}\n`);
+            }
+            process.exit(0);
+        }
+        const claude = buildClaudeExportCommand(lockState.lock.port, null);
+        const settingsConflicts = detectClaudeSettingsConflicts(claude.bundle.env);
+        if (opts.inline) {
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ agent: "claude", inline: claude.command }, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write(`${claude.command}\n`);
+            }
+            for (const line of formatSettingsConflictWarning(settingsConflicts)) {
+                process.stderr.write(`${line}\n`);
+            }
+            process.exit(0);
+        }
+        const block = renderEnvBlock({
+            agent: "claude",
+            env: claude.bundle.env,
+            shell,
+            inlineComments: claude.bundle.inlineComments,
+            trailingNotes: claude.bundle.trailingNotes
+        });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({
+                agent: "claude",
+                package: "@anthropic-ai/claude-code",
+                shell,
+                env: claude.bundle.env,
+                shell_block: block,
+                defaults: claude.defaults,
+                settings_conflicts: settingsConflicts.conflicts
+            }, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write(`${block}\n`);
+        }
+        for (const line of formatSettingsConflictWarning(settingsConflicts)) {
+            process.stderr.write(`${line}\n`);
+        }
+        process.exit(0);
+    });
+}

package/dist/cli/commands/models.js

@@ -0,0 +1,80 @@
+import { loadStoredCredential } from "../../auth/credentials.js";
+import { CopilotTokenManager } from "../../auth/copilotToken.js";
+import { loadConfig, saveConfig } from "../../config/config.js";
+import { listModels, resolveModelSelections } from "../../models/discovery.js";
+import { writeCommandOutput } from "../shared/output.js";
+export function register(program) {
+    const models = program.command("models").description("Model commands");
+    models
+        .command("list")
+        .description("List entitled models")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const config = loadConfig();
+        const creds = await loadStoredCredential();
+        if (!creds) {
+            throw new Error("Not authenticated. Run `copillm login`.");
+        }
+        const tokenManager = new CopilotTokenManager(creds.token);
+        await tokenManager.ensureToken(false);
+        const result = await listModels(config.accountType, creds.token);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({
+                models: result.models,
+                discovery: {
+                    source: result.source,
+                    stale: result.stale,
+                    cache_age_seconds: result.cacheAgeSeconds,
+                    warning: result.warning
+                }
+            }, null, 2) + "\n");
+            return;
+        }
+        process.stdout.write(result.models.map((model) => model.id).join("\n") + "\n");
+        if (result.stale) {
+            process.stdout.write("⚠ using stale model snapshot (upstream discovery unavailable)\n");
+        }
+    });
+    models
+        .command("select")
+        .requiredOption("--models <ids>", "Comma-separated model ids")
+        .description("Select exposed models")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const config = loadConfig();
+        const requested = Array.from(new Set(opts.models
+            .split(",")
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)));
+        if (requested.length === 0) {
+            throw new Error("At least one model must be selected.");
+        }
+        const creds = await loadStoredCredential();
+        if (!creds) {
+            throw new Error("Not authenticated. Run `copillm login`.");
+        }
+        const tokenManager = new CopilotTokenManager(creds.token);
+        await tokenManager.ensureToken(false);
+        const discovery = await listModels(config.accountType, creds.token);
+        const resolution = resolveModelSelections(requested, discovery.models);
+        if (resolution.unresolved.length > 0) {
+            const available = discovery.models.map((model) => model.id).join(", ");
+            throw new Error(`Unknown model selection(s): ${resolution.unresolved.join(", ")}. Available models: ${available}`);
+        }
+        const resolvedSelected = Array.from(new Set(resolution.resolved.map((entry) => entry.resolvedId)));
+        saveConfig({ ...config, selectedModels: resolvedSelected });
+        const usedAlias = resolution.resolved.some((entry) => entry.input !== entry.resolvedId);
+        writeCommandOutput(opts, `Selected ${resolvedSelected.length} model(s)${usedAlias ? " (resolved aliases)." : "."}${discovery.stale ? " Using stale snapshot." : ""}`, {
+            status: "ok",
+            selected_models: resolvedSelected,
+            requested_models: requested,
+            resolutions: resolution.resolved,
+            discovery: {
+                source: discovery.source,
+                stale: discovery.stale,
+                cache_age_seconds: discovery.cacheAgeSeconds,
+                warning: discovery.warning
+            }
+        });
+    });
+}

package/dist/cli/configCommands.js

@@ -23,6 +23,16 @@ body = ""
 # url = "https://api.githubcopilot.com/mcp/"
 # headers = { Authorization = "Bearer \${GITHUB_TOKEN}" }
 
+# Uncomment to control --yolo without typing the flag every launch.
+# Precedence: --yolo flag > COPILLM_YOLO env (1/true/yes or 0/false/no) >
+# profile.yolo.agents.<id> > profile.yolo.enabled > defaults.* > off.
+# [defaults.yolo]
+# enabled = false
+# [defaults.yolo.agents]
+# claude = true        # auto-skip permission prompts for claude
+# codex = false        # still ask for codex
+# pi = false           # pi has no skip-permissions flag; emits a warning if true
+
 [profiles.default]
 `;
 export function registerConfigCommands(program) {