copillm 0.4.1 → 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.1"
+    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/dist/server/routes/proxyForward.js

@@ -1,6 +1,6 @@
 import { resolveModelId } from "../../models/discovery.js";
 import { CopilotTokenManagerError } from "../../auth/copilotToken.js";
-import { anthropicToOpenAI } from "../../translation/openaiAnthropic.js";
+import { anthropicToOpenAI, ProtocolTranslationError } from "../../translation/openaiAnthropic.js";
 import { writeAnthropicPrelude } from "../../translation/streamingOpenAIToAnthropic.js";
 import { isBenignSocketError, safeEnd, safeSendJson } from "../requestLifecycle.js";
 import { InvalidRequestShapeError, writeAnthropicSseError } from "../errors.js";
@@ -15,6 +15,9 @@ function translateRequestBody(routeKind, body) {
         return anthropicToOpenAI(body);
     }
     catch (error) {
+        if (error instanceof ProtocolTranslationError) {
+            throw error;
+        }
         if (error instanceof Error) {
             throw new InvalidRequestShapeError(error.message);
         }

package/dist/translation/openaiAnthropic.js

@@ -297,14 +297,68 @@ function translateImageSource(source) {
     }
     throw new ProtocolTranslationError("unsupported_image_source", `Unsupported Anthropic image source type: ${String(source.type)}.`);
 }
+/**
+ * Translate Anthropic `tool_result.content` into the string that goes into the
+ * OpenAI `tool` message's `content` field.
+ *
+ * Anthropic permits a `tool_result.content` array to contain `text` blocks
+ * *and* `image` blocks (and tolerates unknown future block types), but the
+ * OpenAI chat-completions `tool` role only accepts string content. Rather
+ * than reject the whole request — which historically surfaced to Claude Code
+ * as the cryptic `invalid_request_shape: Anthropic tool_result content only
+ * supports text blocks.` 400 whenever a tool (e.g. a screenshot MCP, an image
+ * read) returned an image — we degrade gracefully:
+ *
+ *   - text blocks  → extracted verbatim
+ *   - image blocks → a `[image: <media_type_or_url>]` placeholder so the
+ *                    model at least sees that the tool returned an image
+ *   - other types  → a `[unsupported tool_result content block: type=X]`
+ *                    placeholder
+ *
+ * Full image pass-through (forwarding the image bytes to the model as a
+ * follow-up multi-part user message) is a deliberate non-goal for this
+ * function — it would change the request structure and the upstream contract
+ * for `tool` messages. We can revisit if/when there is a confirmed need.
+ *
+ * Malformed `text` blocks (missing `.text`) still throw — that is a real
+ * client bug, not a content shape we should silently invent text for.
+ */
 function translateToolResultContent(content) {
     if (typeof content === "string") {
         return content;
     }
     if (!Array.isArray(content)) {
-        throw new ProtocolTranslationError("invalid_tool_result_content", "Anthropic tool_result content must be string or text blocks.");
+        throw new ProtocolTranslationError("invalid_tool_result_content", "Anthropic tool_result content must be a string or an array of content blocks.");
+    }
+    return content.map(stringifyToolResultContentBlock).join("\n");
+}
+function stringifyToolResultContentBlock(block) {
+    if (!isObject(block) || typeof block.type !== "string") {
+        throw new ProtocolTranslationError("invalid_tool_result_content", "Anthropic tool_result content blocks must be objects with a string type.");
+    }
+    if (block.type === "text") {
+        if (typeof block.text !== "string") {
+            throw new ProtocolTranslationError("invalid_text_block", "Anthropic text block must include string text.");
+        }
+        return block.text;
+    }
+    if (block.type === "image") {
+        const descriptor = describeImageSource(block.source);
+        return descriptor ? `[image: ${descriptor}]` : "[image]";
+    }
+    return `[unsupported tool_result content block: type=${block.type}]`;
+}
+function describeImageSource(source) {
+    if (!isObject(source) || typeof source.type !== "string") {
+        return null;
+    }
+    if (source.type === "base64" && typeof source.media_type === "string" && source.media_type.length > 0) {
+        return source.media_type;
+    }
+    if (source.type === "url" && typeof source.url === "string" && source.url.length > 0) {
+        return source.url;
     }
-    return joinTextBlocks(content, "Anthropic tool_result content");
+    return null;
 }
 function translateToolDefinition(tool) {
     if (!isObject(tool) || typeof tool.name !== "string" || tool.name.length === 0) {

package/package.json

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