copillm 0.4.0 → 0.4.2

package/dist/cli/commands/daemon.js

@@ -19,6 +19,8 @@ import { isDevModeActive } from "../shared/devMode.js";
 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";
 export function register(program) {
     program
         .command("start")
@@ -182,6 +184,16 @@ export function register(program) {
         const detectedDebug = lockSnapshot.state === "running" ? await probeDebugEndpoint(lockSnapshot.port) : false;
         const decision = resolveRestartDecision({ lock: lockSnapshot, detectedDebug, forceDebug });
         enableRuntimeDebug(decision.debug);
+        // Self-update to the latest published version before respawning. The old
+        // daemon is still serving here, so an `npm install -g` (which overwrites
+        // the files the new daemon will be spawned from) only updates the code
+        // the *next* daemon runs, never the one currently up. Best-effort: a
+        // failure or offline registry just restarts on the installed version.
+        const selfUpdate = await selfUpdateToLatest(getPackageInfo());
+        const selfUpdateNote = describeSelfUpdate(selfUpdate, getPackageInfo().name);
+        if (selfUpdateNote && !opts.json) {
+            process.stderr.write(`${selfUpdateNote}\n`);
+        }
         if (decision.action === "restart" && decision.previousPid !== null) {
             await stopByPid(decision.previousPid);
         }
@@ -194,7 +206,8 @@ export function register(program) {
         const started = await spawnDetachedDaemon({ debug: decision.debug, forcePort: decision.forcePort });
         await emitDetachedStartOutput(opts, started, decision.debug, "restarted", {
             previousPid: decision.previousPid,
-            claudeCache: cache
+            claudeCache: cache,
+            selfUpdate
         });
     });
     program
@@ -425,6 +438,9 @@ async function emitDetachedStartOutput(opts, started, debug, mode, extra) {
     if (extra?.claudeCache !== undefined) {
         payload.claude_cache = extra.claudeCache;
     }
+    if (extra?.selfUpdate !== undefined) {
+        payload.self_update = extra.selfUpdate;
+    }
     writeCommandOutput(opts, banner, payload);
 }
 /** Narrow the lock inspection down to the shape `resolveRestartDecision` needs. */

package/dist/cli/daemon/selfUpdate.js

@@ -0,0 +1,87 @@
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { fetchLatestNpmVersion, isNewerVersion } from "../updateNotifier.js";
+export async function selfUpdateToLatest(packageInfo, deps = {}) {
+    const env = deps.env ?? process.env;
+    const moduleUrl = deps.moduleUrl ?? import.meta.url;
+    if (!isGlobalNpmRuntime(moduleUrl, packageInfo.name)) {
+        return { status: "skipped", reason: "not-global" };
+    }
+    const fetchLatest = deps.fetchLatest ??
+        ((name) => fetchLatestNpmVersion(name, { registryUrl: env.COPILLM_UPDATE_REGISTRY_URL }));
+    let latest = null;
+    try {
+        latest = await fetchLatest(packageInfo.name);
+    }
+    catch {
+        latest = null;
+    }
+    if (!latest) {
+        return { status: "skipped", reason: "no-latest" };
+    }
+    if (!isNewerVersion(latest, packageInfo.version)) {
+        return { status: "up-to-date", version: packageInfo.version };
+    }
+    const runInstall = deps.runInstall ?? defaultRunInstall;
+    let outcome;
+    try {
+        outcome = runInstall(packageInfo.name, latest);
+    }
+    catch (error) {
+        outcome = { ok: false, detail: error instanceof Error ? error.message : "npm install failed" };
+    }
+    if (!outcome.ok) {
+        return { status: "failed", from: packageInfo.version, to: latest, detail: outcome.detail };
+    }
+    return { status: "updated", from: packageInfo.version, to: latest };
+}
+/** One-line human summary, or null when there's nothing worth printing. */
+export function describeSelfUpdate(result, packageName) {
+    switch (result.status) {
+        case "updated":
+            return `Updated ${packageName} ${result.from} -> ${result.to}.`;
+        case "up-to-date":
+            return `${packageName} is already up to date (${result.version}).`;
+        case "failed":
+            return `Self-update to ${result.to} failed; continuing on ${result.from}. (${result.detail})`;
+        case "skipped":
+            // `no-latest` means the registry was unreachable — worth a quiet note;
+            // `not-global` (dev/dist runs) stays silent.
+            return result.reason === "no-latest"
+                ? "Could not check for updates; continuing on the installed version."
+                : null;
+    }
+}
+function defaultRunInstall(packageName, version) {
+    const isWindows = process.platform === "win32";
+    const result = spawnSync("npm", ["install", "-g", `${packageName}@${version}`], {
+        encoding: "utf8",
+        timeout: 120_000,
+        stdio: ["ignore", "ignore", "pipe"],
+        shell: isWindows
+    });
+    if (result.error) {
+        return { ok: false, detail: result.error.message };
+    }
+    if (result.status === 0) {
+        return { ok: true, detail: "" };
+    }
+    const stderr = (result.stderr ?? "").trim();
+    const tail = stderr ? stderr.split("\n").slice(-2).join(" ") : `npm exited with code ${result.status ?? "null"}`;
+    return { ok: false, detail: tail };
+}
+function isGlobalNpmRuntime(moduleUrl, packageName) {
+    // Prefer a real filesystem path, but fall back to the raw URL when
+    // `fileURLToPath` can't convert it (e.g. a non-Windows-style `file://` URL on
+    // Windows). We only need to scan for the `node_modules/<pkg>` marker, and the
+    // regex handles both `\` and `/` separators so the check is platform-agnostic.
+    let candidate;
+    try {
+        candidate = fileURLToPath(moduleUrl);
+    }
+    catch {
+        candidate = moduleUrl;
+    }
+    const normalized = candidate.replace(/\\/g, "/").toLowerCase();
+    return normalized.includes(`/node_modules/${packageName.toLowerCase()}/`);
+}

package/dist/cli/packageInfo.js

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

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.0",
+  "version": "0.4.2",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",