copillm 0.3.0 → 0.3.1

package/dist/cli/commands/daemon.js

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { inspectStoredCredential } from "../../auth/credentials.js";
 import { loadConfig } from "../../config/config.js";
 import { getCopillmHome } from "../../config/home.js";
@@ -8,9 +7,8 @@ import { inspectLock, releaseLock } from "../../server/lock.js";
 import { buildCodexEnvBundle } from "../agentEnv.js";
 import { ensureAuthenticatedInteractive } from "../auth/ensure.js";
 import { computeUptimeSeconds, formatUptime, stopByPid } from "../daemon/lifecycle.js";
-import { probeHealth, readLiveLock, waitForDaemonReady, warnIfDebugRequestedButInactive } from "../daemon/probes.js";
+import { probeDebugEndpoint, probeHealth, readLiveLock, 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, displayHomePath } from "../integrations/banner.js";
 import { refreshCodexHome } from "../integrations/refreshCodex.js";
@@ -19,7 +17,8 @@ import { writeAuthStatusLine } from "../shared/backends.js";
 import { currentDebugLogPath, enableRuntimeDebug, getRootLogger, resolveCopillmDebug } from "../shared/debug.js";
 import { isDevModeActive } from "../shared/devMode.js";
 import { writeCommandOutput, writeHealthOutput } from "../shared/output.js";
-import { buildSelfSpawnCommand } from "../daemon/selfSpawn.js";
+import { spawnDetachedDaemon } from "../daemon/spawnDetached.js";
+import { resolveRestartDecision } from "../daemon/restart.js";
 export function register(program) {
     program
         .command("start")
@@ -79,55 +78,8 @@ export function register(program) {
                 });
                 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 sharedDetached = await loadSharedStartContextIfNeeded(opts);
-            const codex = opts.codex === false ? null : await refreshCodexHome(started.port, opts.codexModel ?? null, sharedDetached);
-            const pi = opts.pi === false ? null : await refreshPiHome(started.port, sharedDetached);
-            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
-            });
+            const started = await spawnDetachedDaemon({ debug });
+            await emitDetachedStartOutput(opts, started, debug, "detached");
             return;
         }
         // Foreground path: interactively prompt for login if needed.
@@ -205,6 +157,46 @@ export function register(program) {
             claude_defaults: claude.defaults
         });
     });
+    program
+        .command("restart")
+        .description("Restart the daemon, preserving its current port and debug mode")
+        .option("--debug", "Force debug endpoints on for the restarted daemon")
+        .option("--no-codex", "Skip generating ~/.copillm/codex/ for Codex CLI")
+        .option("--codex-model <id>", "Default Codex model slug")
+        .option("--no-pi", "Skip generating the copillm-owned pi models.json for pi coding agent")
+        .option("--json", "JSON output")
+        .action(async (opts) => {
+        const forceDebug = resolveCopillmDebug(opts.debug);
+        if (isDevModeActive()) {
+            process.stderr.write(`dev mode: isolated COPILLM_HOME ${displayHomePath(getCopillmHome())}\n`);
+        }
+        // Restart always brings the daemon back up detached, so fail fast on
+        // missing credentials rather than letting the detached child die silently.
+        const authState = await inspectStoredCredential();
+        if (!authState.stored) {
+            throw new Error("Not authenticated. Run `copillm auth login` first.");
+        }
+        // Detect the running daemon's debug mode *before* stopping it — `/_debug`
+        // is only reachable while the daemon is up.
+        const lockSnapshot = toDaemonLockState(inspectLock());
+        const detectedDebug = lockSnapshot.state === "running" ? await probeDebugEndpoint(lockSnapshot.port) : false;
+        const decision = resolveRestartDecision({ lock: lockSnapshot, detectedDebug, forceDebug });
+        enableRuntimeDebug(decision.debug);
+        if (decision.action === "restart" && decision.previousPid !== null) {
+            await stopByPid(decision.previousPid);
+        }
+        else if (decision.clearStaleLock) {
+            releaseLock();
+        }
+        // Mirror `stop`: clearing the Claude gateway cache on the way down keeps
+        // Claude Code from pinning a stale model picker across the restart.
+        const cache = clearClaudeGatewayCache();
+        const started = await spawnDetachedDaemon({ debug: decision.debug, forcePort: decision.forcePort });
+        await emitDetachedStartOutput(opts, started, decision.debug, "restarted", {
+            previousPid: decision.previousPid,
+            claudeCache: cache
+        });
+    });
     program
         .command("daemon")
         .description("Internal background command")
@@ -384,6 +376,67 @@ export function register(program) {
         }
     });
 }
+/**
+ * Emit the human banner + JSON payload for a daemon that was just brought up in
+ * the background. Shared by `copillm start --detach` (`mode: "detached"`) and
+ * `copillm restart` (`mode: "restarted"`), so both surface the same codex/pi/
+ * claude wiring. `extra` carries restart-only fields (`previous_pid`, the
+ * Claude cache-clear result).
+ */
+async function emitDetachedStartOutput(opts, started, debug, mode, extra) {
+    const shared = await loadSharedStartContextIfNeeded(opts);
+    const codex = opts.codex === false ? null : await refreshCodexHome(started.port, opts.codexModel ?? null, shared);
+    const pi = opts.pi === false ? null : await refreshPiHome(started.port, shared);
+    const claude = buildClaudeExportCommand(started.port, null);
+    const banner = formatStartBanner({
+        port: started.port,
+        pid: started.pid,
+        mode,
+        debug,
+        debugLogPath: currentDebugLogPath(debug),
+        codex,
+        pi
+    });
+    const payload = {
+        status: "ok",
+        mode,
+        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
+    };
+    if (extra?.previousPid !== undefined) {
+        payload.previous_pid = extra.previousPid;
+    }
+    if (extra?.claudeCache !== undefined) {
+        payload.claude_cache = extra.claudeCache;
+    }
+    writeCommandOutput(opts, banner, payload);
+}
+/** Narrow the lock inspection down to the shape `resolveRestartDecision` needs. */
+function toDaemonLockState(lockState) {
+    if (lockState.state === "running") {
+        return { state: "running", pid: lockState.lock.pid, port: lockState.lock.port };
+    }
+    if (lockState.state === "stale") {
+        return { state: "stale" };
+    }
+    return { state: "missing" };
+}
 /**
  * Load the shared credential/config/discovery context for `copillm start`'s
  * codex + pi init steps, ONLY when at least one of them is going to run.

package/dist/cli/daemon/restart.js

@@ -0,0 +1,35 @@
+/**
+ * Pure decision logic for `copillm restart`.
+ *
+ * `restart` brings the daemon back up on the settings it is *actually* running
+ * on — its port and its debug mode — without persisting anything to disk. Port
+ * comes straight from the live lock; debug mode is detected at runtime by
+ * probing `/_debug` (only mounted when debug is on). The home/dev scope is
+ * inherent: the lock is per-`COPILLM_HOME`, so `copillm --dev restart` only
+ * ever touches the dev daemon.
+ *
+ * Keeping the decision pure (no I/O) makes every branch — running, stale,
+ * missing, debug-detected, debug-forced — trivially unit-testable.
+ */
+export function resolveRestartDecision(input) {
+    const { lock, detectedDebug, forceDebug } = input;
+    if (lock.state === "running") {
+        return {
+            action: "restart",
+            previousPid: lock.pid,
+            forcePort: lock.port,
+            clearStaleLock: false,
+            // `--debug` forces it on; otherwise preserve whatever the running daemon had.
+            debug: forceDebug || detectedDebug
+        };
+    }
+    return {
+        action: "start_fresh",
+        previousPid: null,
+        forcePort: null,
+        clearStaleLock: lock.state === "stale",
+        // Nothing was running, so there is no debug state to preserve — only the
+        // explicit `--debug` request can turn it on.
+        debug: forceDebug
+    };
+}

package/dist/cli/daemon/spawnDetached.js

@@ -0,0 +1,27 @@
+import { spawn } from "node:child_process";
+import { waitForDaemonReady } from "./probes.js";
+import { buildSelfSpawnCommand } from "./selfSpawn.js";
+import { daemonSpawnEnv } from "./spawnEnv.js";
+/**
+ * Spawn the daemon as a detached background process and wait until it is
+ * reachable. Shared by `copillm start --detach` and `copillm restart` so the
+ * two paths can never drift in how they launch the background daemon.
+ *
+ * `forcePort` pins the daemon back onto a specific port (used by `restart` to
+ * rebind the port the previous daemon was running on); when null the daemon
+ * falls back to the normal configured-port scan.
+ */
+export async function spawnDetachedDaemon(input) {
+    const daemonCommand = buildSelfSpawnCommand("daemon", input.debug ? ["--debug"] : []);
+    const child = spawn(daemonCommand.command, daemonCommand.args, {
+        detached: true,
+        stdio: "ignore",
+        env: daemonSpawnEnv(input.debug, { port: input.forcePort ?? null })
+    });
+    child.unref();
+    const started = await waitForDaemonReady(child.pid ?? null, 8_000);
+    if (!started) {
+        throw new Error("Detached daemon start timed out.");
+    }
+    return started;
+}

package/dist/cli/daemon/spawnEnv.js

@@ -1,12 +1,18 @@
 import { debugLogPath } from "../../config/home.js";
 import { currentDebugLogPath } from "../shared/debug.js";
-export function daemonSpawnEnv(debug) {
-    if (!debug) {
-        return process.env;
+export function daemonSpawnEnv(debug, options) {
+    // Always return a fresh object so callers that inject a port (e.g. `restart`
+    // pinning the daemon back onto its previous port) never mutate the live
+    // `process.env`.
+    const env = debug
+        ? {
+            ...process.env,
+            COPILLM_LOG_LEVEL: "debug",
+            COPILLM_LOG_FILE: currentDebugLogPath(true) ?? debugLogPath()
+        }
+        : { ...process.env };
+    if (options?.port != null) {
+        env.COPILLM_PORT = String(options.port);
     }
-    return {
-        ...process.env,
-        COPILLM_LOG_LEVEL: "debug",
-        COPILLM_LOG_FILE: currentDebugLogPath(true) ?? debugLogPath()
-    };
+    return env;
 }

package/dist/cli/integrations/banner.js

@@ -6,7 +6,7 @@ export function displayHomePath(p) {
     return p;
 }
 export function formatStartBanner(input) {
-    const verb = input.mode === "foreground" ? "listening on" : "running on";
+    const verb = input.mode === "foreground" ? "listening on" : input.mode === "restarted" ? "restarted on" : "running on";
     const lines = [];
     const debugSuffix = input.debug ? " [debug]" : "";
     const modeSuffix = input.mode === "already_running" ? " (already running)" : "";

package/dist/cli/packageInfo.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 const FALLBACK_PACKAGE_INFO = {
     name: "copillm",
-    version: "0.3.0"
+    version: "0.3.1"
 };
 export function getPackageInfo() {
     const envName = cleanPackageValue(process.env.COPILLM_PACKAGE_NAME);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",