copillm 0.4.2 → 0.4.4

package/dist/cli/commands/daemon.js

@@ -20,7 +20,8 @@ import { writeCommandOutput, writeHealthOutput } from "../shared/output.js";
 import { spawnDetachedDaemon } from "../daemon/spawnDetached.js";
 import { resolveRestartDecision } from "../daemon/restart.js";
 import { selfUpdateToLatest, describeSelfUpdate } from "../daemon/selfUpdate.js";
-import { getPackageInfo } from "../packageInfo.js";
+import { computeVersionStatus } from "../daemon/versionStatus.js";
+import { getPackageInfo } from "../../config/packageInfo.js";
 export function register(program) {
     program
         .command("start")
@@ -267,11 +268,13 @@ export function register(program) {
         .command("status")
         .description("Show daemon status")
         .option("--json", "JSON output")
+        .option("--no-registry-check", "Skip the npm registry lookup for latest-version comparison (also via NO_UPDATE_NOTIFIER / COPILLM_UPDATE_CHECK=0)")
         .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;
+        const cliPackageInfo = getPackageInfo();
         // inspectStoredCredential never returns the token itself, so it's safe to
         // include the result in the status payload.
         let authInfo;
@@ -303,6 +306,16 @@ export function register(program) {
             health_state: null,
             health_error: null,
             health_status: "unknown",
+            // Version reporting — populated below. cli_version is always known
+            // (read from this CLI binary). daemon_version is `null` until the
+            // /healthz probe completes; older daemons (predating the field) also
+            // report null. latest_version is best-effort and `null` if the
+            // registry lookup is skipped or fails.
+            daemon_version: null,
+            cli_version: cliPackageInfo.version,
+            latest_version: null,
+            update_available: false,
+            version_hint: null,
             checked_at_iso: checkedAtIso,
             stale_reason: lockState.state === "stale" ? lockState.reason : null
         };
@@ -313,7 +326,19 @@ export function register(program) {
             status.health_check_status_code = health.statusCode;
             status.health_state = health.status;
             status.health_error = health.error;
+            status.daemon_version = health.version;
         }
+        // Commander turns `--no-registry-check` into `opts.registryCheck === false`.
+        const versionStatus = await computeVersionStatus({
+            cliPackageInfo,
+            daemonVersion: status.daemon_version,
+            daemonRunning: status.running,
+            noRegistryCheck: opts.registryCheck === false
+        });
+        status.daemon_version = versionStatus.daemon_version;
+        status.latest_version = versionStatus.latest_version;
+        status.update_available = versionStatus.update_available;
+        status.version_hint = versionStatus.hint;
         if (opts.json) {
             process.stdout.write(JSON.stringify(status, null, 2) + "\n");
             return;
@@ -332,6 +357,7 @@ export function register(program) {
                 process.stdout.write(` error=${status.health_error}`);
             }
             process.stdout.write("\n");
+            writeVersionLine(status);
             if (status.bearer_ttl_seconds !== null) {
                 process.stdout.write(`bearer_ttl_seconds: ${status.bearer_ttl_seconds}\n`);
             }
@@ -344,10 +370,12 @@ export function register(program) {
         }
         if (lockState.state === "stale") {
             process.stdout.write(`stale lock (${lockState.reason})\n`);
+            writeVersionLine(status);
             writeAuthStatusLine(authInfo);
             return;
         }
         process.stdout.write("not running\n");
+        writeVersionLine(status);
         writeAuthStatusLine(authInfo);
     });
     program
@@ -453,6 +481,37 @@ function toDaemonLockState(lockState) {
     }
     return { state: "missing" };
 }
+/**
+ * Render the `version: ...` line for `copillm status` human output.
+ *
+ * When the daemon is running and reports the same version as this CLI, the
+ * line is just `version: 0.4.3` — the common, boring case. Mismatches surface
+ * inline so users see immediately whether they need to restart (cli > daemon)
+ * or `npm install -g copillm` (latest > cli). When the daemon is stopped, the
+ * line only reports the CLI's version, since there is no live daemon version
+ * to compare against.
+ */
+function writeVersionLine(status) {
+    let line = "version: ";
+    if (status.running && status.daemon_version !== null) {
+        line += status.daemon_version;
+        if (status.daemon_version !== status.cli_version) {
+            line += ` (cli ${status.cli_version})`;
+        }
+    }
+    else if (status.running && status.daemon_version === null) {
+        // Either an older daemon that predates this field, or a malformed
+        // /healthz response. The version_hint below will prompt a restart.
+        line += `? (cli ${status.cli_version})`;
+    }
+    else {
+        line += `cli ${status.cli_version}`;
+    }
+    if (status.version_hint) {
+        line += ` — ${status.version_hint}`;
+    }
+    process.stdout.write(line + "\n");
+}
 /**
  * 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/probes.js

@@ -94,7 +94,8 @@ export async function probeHealth(port, options) {
                     statusCode: response.status,
                     status: typeof payload.status === "string" ? payload.status : null,
                     error: typeof payload.error === "string" ? payload.error : null,
-                    bearerTtlSeconds: response.ok && typeof payload.bearer_ttl_seconds === "number" ? payload.bearer_ttl_seconds : null
+                    bearerTtlSeconds: response.ok && typeof payload.bearer_ttl_seconds === "number" ? payload.bearer_ttl_seconds : null,
+                    version: typeof payload.version === "string" && payload.version.length > 0 ? payload.version : null
                 },
                 failed: false
             };
@@ -104,7 +105,7 @@ export async function probeHealth(port, options) {
         }
     }, options);
     return result.failed
-        ? { ok: false, bearerTtlSeconds: null, statusCode: null, status: null, error: "health_probe_failed" }
+        ? { ok: false, bearerTtlSeconds: null, statusCode: null, status: null, error: "health_probe_failed", version: null }
         : result.ok;
 }
 export async function readLiveLock() {

package/dist/cli/daemon/versionStatus.js

@@ -0,0 +1,63 @@
+import { fetchLatestNpmVersion, isNewerVersion, parseBooleanOverride } from "../updateNotifier.js";
+const DEFAULT_REGISTRY_TIMEOUT_MS = 1_500;
+/**
+ * Resolve the three version data points (daemon, cli, latest-on-npm) and
+ * compute the `copillm status` actionable hint from them. Pulled out of the
+ * status command so it stays unit-testable end-to-end without spinning up a
+ * real proxy.
+ *
+ * Opt-out precedence (any of these skips the npm lookup):
+ *   - `noRegistryCheck` argument (driven by the `--no-registry-check` flag)
+ *   - `NO_UPDATE_NOTIFIER` env (matches the update-notifier convention)
+ *   - `COPILLM_UPDATE_CHECK=0|false|no|off`
+ *
+ * The registry lookup itself is best-effort: timeouts / network errors
+ * silently yield `latest_version: null`. We do *not* surface a "registry
+ * unreachable" message in status — that would be more noise than signal for
+ * a daemon-status command.
+ */
+export async function computeVersionStatus(options) {
+    const env = options.env ?? process.env;
+    const cliVersion = options.cliPackageInfo.version;
+    const daemonVersion = options.daemonVersion;
+    const registryCheckDisabled = options.noRegistryCheck === true ||
+        "NO_UPDATE_NOTIFIER" in env ||
+        parseBooleanOverride(env.COPILLM_UPDATE_CHECK) === false;
+    let latestVersion = null;
+    if (!registryCheckDisabled) {
+        latestVersion = await fetchLatestNpmVersion(options.cliPackageInfo.name, {
+            fetchImpl: options.fetchImpl,
+            registryUrl: options.registryUrl ?? env.COPILLM_UPDATE_REGISTRY_URL,
+            timeoutMs: options.timeoutMs ?? DEFAULT_REGISTRY_TIMEOUT_MS
+        });
+    }
+    const daemonStale = options.daemonRunning && daemonVersion !== null && isNewerVersion(cliVersion, daemonVersion);
+    const cliStale = latestVersion !== null && isNewerVersion(latestVersion, cliVersion);
+    const daemonReportsNoVersion = options.daemonRunning && daemonVersion === null;
+    return {
+        daemon_version: daemonVersion,
+        cli_version: cliVersion,
+        latest_version: latestVersion,
+        update_available: daemonStale || cliStale,
+        hint: buildVersionHint({ daemonStale, cliStale, daemonReportsNoVersion, cliVersion, latestVersion })
+    };
+}
+/**
+ * Pure helper. Public for direct unit testing of the messaging matrix.
+ */
+export function buildVersionHint(input) {
+    const parts = [];
+    if (input.cliStale && input.latestVersion !== null) {
+        parts.push(`newer version available: v${input.latestVersion} (npm install -g copillm)`);
+    }
+    if (input.daemonStale) {
+        parts.push(`restart to apply cli v${input.cliVersion}`);
+    }
+    if (parts.length === 0 && input.daemonReportsNoVersion) {
+        return "restart to start reporting version";
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("; ");
+}

package/dist/cli/index.js

@@ -11,7 +11,7 @@ import * as piCmd from "./commands/agents/pi.js";
 import * as copilotCmd from "./commands/agents/copilot.js";
 import { setRootLogger, setRootProgram } from "./shared/debug.js";
 import { applyDevModeEnv } from "./shared/devMode.js";
-import { getPackageInfo } from "./packageInfo.js";
+import { getPackageInfo } from "../config/packageInfo.js";
 import { maybeNotifyAboutUpdate } from "./updateNotifier.js";
 const logger = createLogger();
 const program = new Command();

package/dist/cli/updateNotifier.js

@@ -67,6 +67,24 @@ export function distTagsUrl(packageName, registryUrl = DEFAULT_REGISTRY_URL) {
 export function isNewerVersion(candidate, current) {
     return compareSemver(candidate, current) > 0;
 }
+/**
+ * Parse `"1" | "true" | "yes" | "on"` → true, `"0" | "false" | "no" | "off"` → false,
+ * anything else → null. Exposed so the status command can mirror the
+ * `COPILLM_UPDATE_CHECK` opt-out semantics without re-implementing the parsing.
+ */
+export function parseBooleanOverride(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return null;
+}
 function shouldRunUpdateCheck(opts) {
     if (opts.stderr.isTTY !== true)
         return false;
@@ -168,19 +186,6 @@ function notifyIfNewer(stderr, packageInfo, latestVersion) {
 function hasArg(argv, arg) {
     return argv.slice(2).includes(arg);
 }
-function parseBooleanOverride(value) {
-    if (value === undefined) {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (["1", "true", "yes", "on"].includes(normalized)) {
-        return true;
-    }
-    if (["0", "false", "no", "off"].includes(normalized)) {
-        return false;
-    }
-    return null;
-}
 function isTruthyCi(value) {
     if (value === undefined) {
         return false;

package/dist/{cli → config}/packageInfo.js

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

package/dist/server/proxy.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
+import { getPackageInfo } from "../config/packageInfo.js";
 import { singleAccountResolver } from "./accountResolver.js";
 import { attachRequestLifecycle, isBenignSocketError, safeEnd, safeSendJson } from "./requestLifecycle.js";
 import { InvalidRequestShapeError, JsonRequestParseError, RequestBodyTooLargeError } from "./errors.js";
@@ -11,6 +12,7 @@ import { handleProxyForward } from "./routes/proxyForward.js";
 import { isLocalRequest, resolveRoute, safePathname } from "./routes/shared.js";
 export async function startProxyServer(input) {
     const debugEnabled = input.debug === true;
+    const packageVersion = getPackageInfo().version;
     const resolver = input.accountResolver ??
         singleAccountResolver({
             tokenManager: input.tokenManager,
@@ -57,10 +59,10 @@ export async function startProxyServer(input) {
             }
             switch (route.kind) {
                 case "livez":
-                    handleLivez(res);
+                    handleLivez(res, { version: packageVersion });
                     return;
                 case "healthz":
-                    await handleHealthz(res, resolver.default.tokenManager);
+                    await handleHealthz(res, resolver.default.tokenManager, { version: packageVersion });
                     return;
                 case "models":
                     await handleModels(res, route.kind, resolver.default);
@@ -86,7 +88,8 @@ export async function startProxyServer(input) {
                         tokenManager: resolver.default.tokenManager,
                         githubToken: resolver.default.githubToken,
                         port: input.port,
-                        accounts: resolver.describe()
+                        accounts: resolver.describe(),
+                        packageVersion
                     });
                     return;
                 case "not_found":

package/dist/server/routes/debug.js

@@ -35,6 +35,7 @@ export async function handleDebug(res, input) {
             port: input.port,
             pid: process.pid,
             node_version: process.version,
+            version: input.packageVersion ?? null,
             started_at_iso: DAEMON_STARTED_AT_ISO,
             uptime_seconds: uptimeSeconds,
             account_type: input.config.accountType,

package/dist/server/routes/health.js

@@ -1,17 +1,22 @@
 import { healthFailure } from "../errors.js";
 import { safeSendJson } from "../requestLifecycle.js";
 const HEALTH_REFRESH_THRESHOLD_SECONDS = 60;
-export function handleLivez(res) {
-    safeSendJson(res, 200, { status: "ok", uptime_seconds: Math.floor(process.uptime()) });
+export function handleLivez(res, meta) {
+    safeSendJson(res, 200, {
+        status: "ok",
+        uptime_seconds: Math.floor(process.uptime()),
+        version: meta.version
+    });
 }
-export async function handleHealthz(res, tokenManager) {
+export async function handleHealthz(res, tokenManager, meta) {
     const ttl = tokenManager.expiresInSeconds();
     if (ttl !== null && ttl > HEALTH_REFRESH_THRESHOLD_SECONDS) {
         safeSendJson(res, 200, {
             status: "ok",
             token_state: "fresh",
             refresh_threshold_seconds: HEALTH_REFRESH_THRESHOLD_SECONDS,
-            bearer_ttl_seconds: ttl
+            bearer_ttl_seconds: ttl,
+            version: meta.version
         });
         return;
     }
@@ -22,11 +27,12 @@ export async function handleHealthz(res, tokenManager) {
             status: "ok",
             token_state: "refreshed",
             refresh_threshold_seconds: HEALTH_REFRESH_THRESHOLD_SECONDS,
-            bearer_ttl_seconds: refreshedTtl
+            bearer_ttl_seconds: refreshedTtl,
+            version: meta.version
         });
     }
     catch (error) {
         const failed = healthFailure(error);
-        safeSendJson(res, failed.httpStatus, failed.payload);
+        safeSendJson(res, failed.httpStatus, { ...failed.payload, version: meta.version });
     }
 }

package/package.json

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