copillm 0.3.1 → 0.4.1

package/README.md

@@ -89,6 +89,10 @@ The **default account** is what every agent and the model endpoints use unless
 told otherwise. `copillm auth status` lists each account with its plan type and
 whether a credential is stored; tokens are never printed.
 
+If the daemon is already running when you `auth switch`, copillm reminds you to
+run `copillm restart` so the new default takes effect for the next agent launch.
+(`auth logout` stops the daemon for you, so it needs no restart.)
+
 Different accounts can be entitled to different models, so each account keeps
 its own model list.
 

package/dist/agentconfig/apply.js

@@ -1,4 +1,4 @@
-import { writeFileSecureAtomic } from "../config/fsSecurity.js";
+import { writeFilesSecureAtomic } from "../config/fsSecurity.js";
 import { loadAgentConfig } from "./load.js";
 import { planRender } from "./render.js";
 import { backupIfMismatch } from "./markerBlock.js";
@@ -22,13 +22,15 @@ export function applyAgentConfig(opts) {
         return { active: null, writes: [], envOverlay: {}, cliArgs: [], notes: [], sources: [], yolo: null };
     }
     const rendered = planRender(opts, load);
-    // Phase 2: write. By this point all validation passed and the renderer
-    // produced complete file bodies — failures here are IO errors, not user
-    // input problems.
+    // Phase 2: write. All validation passed and the renderer produced complete
+    // file bodies, so failures here are IO errors. Back up any user-edited
+    // targets first, then commit every file as one two-phase atomic batch: each
+    // file is staged to a temp path before any is renamed into place, so an IO
+    // failure mid-fan-out leaves nothing committed rather than a half-updated set.
     for (const write of rendered.writes) {
         backupIfMismatch(write.path, write.content);
-        writeFileSecureAtomic(write.path, write.content, write.mode);
     }
+    writeFilesSecureAtomic(rendered.writes);
     return {
         active: load.active,
         writes: rendered.writes,

package/dist/cli/auth/runAuth.js

@@ -227,10 +227,16 @@ export async function runAuthSwitch(opts, accountId) {
     try {
         assertValidAccountId(accountId);
         const index = switchDefaultAccount(accountId);
-        writeCommandOutput(opts, `Default account is now "${index.defaultAccount}".`, {
+        // A running daemon snapshots the default account at startup, so a switch
+        // only affects new agent launches after the daemon is restarted. (`auth
+        // logout` doesn't need this hint — it already stops the daemon.)
+        const daemonRunning = inspectLock().state === "running";
+        const hint = daemonRunning ? " Restart the daemon for this to take effect: copillm restart." : "";
+        writeCommandOutput(opts, `Default account is now "${index.defaultAccount}".${hint}`, {
             status: "ok",
             action: "switch",
-            default_account: index.defaultAccount
+            default_account: index.defaultAccount,
+            restart_required: daemonRunning
         });
     }
     catch (error) {

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.3.1"
+    version: "0.4.1"
 };
 export function getPackageInfo() {
     const envName = cleanPackageValue(process.env.COPILLM_PACKAGE_NAME);

package/dist/config/fsSecurity.js

@@ -14,6 +14,42 @@ export function writeFileSecureAtomic(filePath, content, mode) {
     replaceFile(tempPath, filePath);
     applyModeIfSupported(filePath, mode);
 }
+/**
+ * Atomically write a batch of files with two-phase commit semantics. Phase 1
+ * stages every file to a temp path; if any staging write throws, all temps
+ * written so far are removed and the error is rethrown, so nothing is
+ * committed. Phase 2 renames each staged temp into place — by then all content
+ * is safely on disk, so a partial commit is far less likely than a mid-write
+ * failure (the failure mode this replaces). Use this when several files must
+ * land together (e.g. an agent config fan-out).
+ */
+export function writeFilesSecureAtomic(writes) {
+    const staged = [];
+    try {
+        for (const write of writes) {
+            ensureSecureDirectory(path.dirname(write.path));
+            const tempPath = `${write.path}.tmp-${process.pid}-${Date.now()}-${staged.length}`;
+            fs.writeFileSync(tempPath, write.content, { mode: write.mode });
+            applyModeIfSupported(tempPath, write.mode);
+            staged.push({ tempPath, finalPath: write.path, mode: write.mode });
+        }
+    }
+    catch (error) {
+        for (const item of staged) {
+            try {
+                fs.unlinkSync(item.tempPath);
+            }
+            catch {
+                // best effort — nothing was committed, leftover temps are harmless
+            }
+        }
+        throw error;
+    }
+    for (const item of staged) {
+        replaceFile(item.tempPath, item.finalPath);
+        applyModeIfSupported(item.finalPath, item.mode);
+    }
+}
 export function applyModeIfSupported(targetPath, mode) {
     if (process.platform === "win32") {
         return;

package/dist/server/errors.js

@@ -12,6 +12,14 @@ export class InvalidRequestShapeError extends Error {
         this.name = "InvalidRequestShapeError";
     }
 }
+export class RequestBodyTooLargeError extends Error {
+    maxBytes;
+    constructor(maxBytes) {
+        super(`Request body exceeds the maximum allowed size of ${maxBytes} bytes.`);
+        this.maxBytes = maxBytes;
+        this.name = "RequestBodyTooLargeError";
+    }
+}
 export async function readUpstreamError(response) {
     const contentType = response.headers.get("content-type");
     let text;

package/dist/server/proxy.js

@@ -2,7 +2,7 @@ import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { singleAccountResolver } from "./accountResolver.js";
 import { attachRequestLifecycle, isBenignSocketError, safeEnd, safeSendJson } from "./requestLifecycle.js";
-import { InvalidRequestShapeError, JsonRequestParseError } from "./errors.js";
+import { InvalidRequestShapeError, JsonRequestParseError, RequestBodyTooLargeError } from "./errors.js";
 import { ProtocolTranslationError } from "../translation/openaiAnthropic.js";
 import { handleHealthz, handleLivez } from "./routes/health.js";
 import { handleModels } from "./routes/models.js";
@@ -119,6 +119,10 @@ export async function startProxyServer(input) {
                 safeSendJson(res, 400, { error: "invalid_request_json", detail: error.message });
                 return;
             }
+            if (error instanceof RequestBodyTooLargeError) {
+                safeSendJson(res, 413, { error: "payload_too_large", detail: error.message });
+                return;
+            }
             if (error instanceof InvalidRequestShapeError) {
                 safeSendJson(res, 400, { error: "invalid_request_shape", detail: error.message });
                 return;

package/dist/server/routes/shared.js

@@ -1,10 +1,37 @@
 import { stripOneMillionAlias } from "../../translation/openaiAnthropic.js";
 import { isValidAccountId } from "../../config/accountId.js";
-import { JsonRequestParseError } from "../errors.js";
-export async function readJson(req) {
+import { JsonRequestParseError, RequestBodyTooLargeError } from "../errors.js";
+/**
+ * Default cap on a single request body. The daemon buffers the whole body in
+ * memory before forwarding, so an unbounded read is an OOM vector even on a
+ * loopback-only socket (a runaway agent or a pathological context). 32 MiB is
+ * far above any real chat/completions payload while still bounding memory.
+ * Override with `COPILLM_MAX_REQUEST_BYTES` (a positive integer count of bytes).
+ */
+export const DEFAULT_MAX_REQUEST_BYTES = 32 * 1024 * 1024;
+export function maxRequestBytes() {
+    const raw = process.env.COPILLM_MAX_REQUEST_BYTES;
+    if (raw === undefined || raw.trim().length === 0) {
+        return DEFAULT_MAX_REQUEST_BYTES;
+    }
+    const parsed = Number(raw.trim());
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return DEFAULT_MAX_REQUEST_BYTES;
+    }
+    return parsed;
+}
+export async function readJson(req, maxBytes = maxRequestBytes()) {
     const chunks = [];
+    let total = 0;
     for await (const chunk of req) {
-        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        total += buffer.length;
+        if (total > maxBytes) {
+            // Stop accumulating immediately so an oversized body can't be buffered
+            // into memory; throwing ends the async iteration and tears down the read.
+            throw new RequestBodyTooLargeError(maxBytes);
+        }
+        chunks.push(buffer);
     }
     if (chunks.length === 0) {
         return {};

package/dist/translation/openaiAnthropic.js

@@ -25,6 +25,14 @@ export function anthropicToOpenAI(body) {
     if (request.temperature !== undefined) {
         translated.temperature = request.temperature;
     }
+    if (request.top_p !== undefined) {
+        translated.top_p = request.top_p;
+    }
+    if (request.stop_sequences !== undefined) {
+        // Anthropic `stop_sequences` (array of strings) maps 1:1 onto OpenAI's
+        // `stop` field, which Copilot's chat/completions endpoint accepts.
+        translated.stop = request.stop_sequences;
+    }
     if (request.stream !== undefined) {
         translated.stream = request.stream;
     }
@@ -102,6 +110,12 @@ function parseAnthropicRequest(body) {
     if (body.temperature !== undefined) {
         parsed.temperature = body.temperature;
     }
+    if (body.top_p !== undefined) {
+        parsed.top_p = body.top_p;
+    }
+    if (body.stop_sequences !== undefined) {
+        parsed.stop_sequences = body.stop_sequences;
+    }
     if (body.stream !== undefined) {
         parsed.stream = body.stream;
     }
@@ -195,11 +209,11 @@ function translateAssistantMessageBlocks(blocks) {
 }
 function translateUserMessageBlocks(blocks) {
     const translated = [];
-    const textSegments = [];
-    const flushText = () => {
-        if (textSegments.length > 0) {
-            translated.push({ role: "user", content: textSegments.join("\n") });
-            textSegments.length = 0;
+    let parts = [];
+    const flushParts = () => {
+        if (parts.length > 0) {
+            translated.push({ role: "user", content: collapseUserParts(parts) });
+            parts = [];
         }
     };
     for (const block of blocks) {
@@ -210,14 +224,18 @@ function translateUserMessageBlocks(blocks) {
             if (typeof block.text !== "string") {
                 throw new ProtocolTranslationError("invalid_text_block", "Anthropic text block must include string text.");
             }
-            textSegments.push(block.text);
+            parts.push({ type: "text", text: block.text });
+            continue;
+        }
+        if (block.type === "image") {
+            parts.push({ type: "image_url", image_url: { url: translateImageSource(block.source) } });
             continue;
         }
         if (block.type === "tool_result") {
             if (typeof block.tool_use_id !== "string" || block.tool_use_id.length === 0) {
                 throw new ProtocolTranslationError("invalid_tool_result", "Anthropic tool_result requires non-empty tool_use_id.");
             }
-            flushText();
+            flushParts();
             const rawContent = translateToolResultContent(block.content);
             const content = block.is_error ? `[tool_error] ${rawContent}` : rawContent;
             translated.push({
@@ -232,12 +250,53 @@ function translateUserMessageBlocks(blocks) {
         }
         throw new ProtocolTranslationError("unsupported_block", `Unsupported Anthropic user block type: ${block.type}.`);
     }
-    flushText();
+    flushParts();
     if (translated.length === 0) {
         translated.push({ role: "user", content: "" });
     }
     return translated;
 }
+/**
+ * Collapse the accumulated content parts into an OpenAI message `content`.
+ * Text-only messages stay a plain newline-joined string (the historical shape
+ * every text request produced); once an image is present we must emit the
+ * OpenAI multi-part content array so the `image_url` parts survive to upstream.
+ */
+function collapseUserParts(parts) {
+    const hasImage = parts.some((part) => part.type === "image_url");
+    if (!hasImage) {
+        return parts.map((part) => (part.type === "text" ? part.text : "")).join("\n");
+    }
+    return parts;
+}
+/**
+ * Translate an Anthropic image `source` into an OpenAI `image_url.url`. A
+ * base64 source becomes a `data:` URL; a url source passes its URL through.
+ * Copilot's chat/completions endpoint accepts both for vision-capable models;
+ * sending an image to a non-vision model surfaces as an upstream error, which
+ * is the correct place for that signal — translation stays capability-agnostic.
+ */
+function translateImageSource(source) {
+    if (!isObject(source) || typeof source.type !== "string") {
+        throw new ProtocolTranslationError("invalid_image_source", "Anthropic image block requires a source object with a type.");
+    }
+    if (source.type === "base64") {
+        if (typeof source.media_type !== "string" || source.media_type.length === 0) {
+            throw new ProtocolTranslationError("invalid_image_source", "Anthropic base64 image source requires a media_type.");
+        }
+        if (typeof source.data !== "string" || source.data.length === 0) {
+            throw new ProtocolTranslationError("invalid_image_source", "Anthropic base64 image source requires data.");
+        }
+        return `data:${source.media_type};base64,${source.data}`;
+    }
+    if (source.type === "url") {
+        if (typeof source.url !== "string" || source.url.length === 0) {
+            throw new ProtocolTranslationError("invalid_image_source", "Anthropic url image source requires a non-empty url.");
+        }
+        return source.url;
+    }
+    throw new ProtocolTranslationError("unsupported_image_source", `Unsupported Anthropic image source type: ${String(source.type)}.`);
+}
 function translateToolResultContent(content) {
     if (typeof content === "string") {
         return content;

package/package.json

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