copillm 0.1.4 → 0.2.0

package/dist/server/proxy.js

@@ -10,6 +10,7 @@ import { translateOpenAIStreamToAnthropic, writeAnthropicPrelude } from "../tran
 import { buildCodexCatalog } from "./codexSchema.js";
 import { getGithubUserSummary, GithubUserFetchError } from "./debugInfo.js";
 import { buildAnthropicModelsResponse } from "./anthropicModelsResponse.js";
+import { attachRequestLifecycle, isBenignSocketError, safeEnd, safeSendJson, safeWrite } from "./requestLifecycle.js";
 const COPILOT_HEADERS = {
     "Content-Type": "application/json",
     "Copilot-Integration-Id": "vscode-chat",
@@ -49,6 +50,7 @@ export async function startProxyServer(input) {
         const requestId = randomUUID();
         const startedAt = Date.now();
         const pathname = safePathname(req.url);
+        const lifecycle = attachRequestLifecycle(req, res, input.logger, requestId);
         res.on("finish", () => {
             input.logger.info({
                 event: "http_request",
@@ -148,6 +150,7 @@ export async function startProxyServer(input) {
                 }
                 await handleDebug(res, {
                     config: input.config,
+                    logger: input.logger,
                     tokenManager: input.tokenManager,
                     githubToken: input.githubToken,
                     port: input.port
@@ -192,6 +195,17 @@ export async function startProxyServer(input) {
                 beginAnthropicSseResponse(res, req);
                 prelude = writeAnthropicPrelude(res, requestedModel ?? "");
             }
+            input.logger.debug({
+                event: "request_prepared",
+                request_id: requestId,
+                route: route.kind,
+                anthro_shape: route.anthroShape,
+                requested_model: requestedModel,
+                upstream_model: readRequestedModel(upstreamBody),
+                model_resolution_rule: resolvedModel?.rule ?? null,
+                upstream_path: upstreamPath,
+                ...summarizeUpstreamPayload(upstreamBody)
+            }, "prepared upstream request");
             try {
                 const upstream = await postToCopilot({
                     tokenManager: input.tokenManager,
@@ -199,11 +213,22 @@ export async function startProxyServer(input) {
                     body: upstreamBody,
                     requestId,
                     logger: input.logger,
-                    upstreamPath
+                    upstreamPath,
+                    signal: lifecycle.signal
+                });
+                await forwardResponse(upstream, route.anthroShape, res, {
+                    requestedModel: requestedModel ?? undefined,
+                    prelude,
+                    logger: input.logger,
+                    requestId
                 });
-                await forwardResponse(upstream, route.anthroShape, res, requestedModel ?? undefined, prelude);
             }
             catch (error) {
+                if (isBenignSocketError(error)) {
+                    input.logger.debug({ event: "upstream_aborted", request_id: requestId, err: error }, "upstream request aborted (client disconnected)");
+                    safeEnd(res);
+                    return;
+                }
                 if (error instanceof CopilotTokenManagerError) {
                     if (prelude) {
                         writeAnthropicSseError(res, prelude, "token_refresh_failed");
@@ -232,8 +257,31 @@ export async function startProxyServer(input) {
                 sendJson(res, 400, { error: error.code, detail: error.message });
                 return;
             }
-            input.logger.error({ err: error }, "request failed");
+            if (isBenignSocketError(error)) {
+                input.logger.debug({ event: "request_client_gone", request_id: requestId, err: error }, "request handler aborted because client disconnected");
+                safeEnd(res);
+                return;
+            }
+            input.logger.error({ err: error, request_id: requestId }, "request failed");
             sendJson(res, 500, { error: "internal_error" });
+            safeEnd(res);
+        }
+    });
+    server.on("clientError", (err, socket) => {
+        input.logger.debug({ event: "client_error", code: err?.code }, "malformed HTTP from client");
+        if (socket.writable) {
+            try {
+                socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+            }
+            catch {
+                // Socket likely already gone — nothing to do.
+            }
+        }
+        try {
+            socket.destroy();
+        }
+        catch {
+            // best effort
         }
     });
     await new Promise((resolve, reject) => {
@@ -256,8 +304,29 @@ async function postToCopilot(input) {
     let forceRefresh = false;
     let authRefreshRetried = false;
     for (let attempt = 1; attempt <= MAX_UPSTREAM_ATTEMPTS; attempt += 1) {
+        if (input.signal?.aborted) {
+            throw abortErrorFromSignal(input.signal);
+        }
         try {
-            const response = await postWithCurrentBearer(input.tokenManager, input.accountType, input.body, forceRefresh, input.requestId, input.upstreamPath);
+            const attemptStartedAt = Date.now();
+            input.logger.debug({
+                event: "upstream_request",
+                request_id: input.requestId,
+                attempt,
+                upstream_path: input.upstreamPath,
+                force_refresh: forceRefresh
+            }, "posting upstream request");
+            const response = await postWithCurrentBearer(input.tokenManager, input.accountType, input.body, forceRefresh, input.requestId, input.upstreamPath, input.signal);
+            input.logger.debug({
+                event: "upstream_response",
+                request_id: input.requestId,
+                attempt,
+                upstream_path: input.upstreamPath,
+                status_code: response.status,
+                duration_ms: Date.now() - attemptStartedAt,
+                content_type: response.headers.get("content-type"),
+                retry_after: response.headers.get("retry-after")
+            }, "received upstream response");
             forceRefresh = false;
             if (response.status === 401 && !authRefreshRetried && attempt < MAX_UPSTREAM_ATTEMPTS) {
                 authRefreshRetried = true;
@@ -275,6 +344,10 @@ async function postToCopilot(input) {
             return response;
         }
         catch (error) {
+            if (isBenignSocketError(error)) {
+                // Client disconnected — propagate so the request handler can clean up.
+                throw error;
+            }
             if (!isRetryableTransportError(error) || attempt >= MAX_UPSTREAM_ATTEMPTS) {
                 throw error;
             }
@@ -284,7 +357,7 @@ async function postToCopilot(input) {
     }
     throw new Error("Upstream retry budget exhausted unexpectedly.");
 }
-async function postWithCurrentBearer(tokenManager, accountType, body, forceRefresh, requestId, upstreamPath) {
+async function postWithCurrentBearer(tokenManager, accountType, body, forceRefresh, requestId, upstreamPath, signal) {
     const bearer = await tokenManager.ensureToken({ forceRefresh });
     return fetch(`${accountBaseUrl(accountType)}${upstreamPath}`, {
         method: "POST",
@@ -293,46 +366,70 @@ async function postWithCurrentBearer(tokenManager, accountType, body, forceRefre
             Authorization: `Bearer ${bearer}`,
             "X-Request-Id": requestId
         },
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        signal
     });
 }
-async function forwardResponse(upstream, anthroShape, res, requestedModel, prelude) {
+function abortErrorFromSignal(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        return reason;
+    }
+    const err = new Error("Request aborted by client");
+    err.name = "AbortError";
+    return err;
+}
+async function forwardResponse(upstream, anthroShape, res, diagnostics) {
     if (!upstream.ok) {
-        await discardUpstreamBody(upstream);
+        const upstreamError = await readUpstreamError(upstream);
+        const category = upstreamStatusCategory(upstream.status);
+        diagnostics.logger.warn({
+            event: "upstream_non_ok",
+            request_id: diagnostics.requestId,
+            status_code: upstream.status,
+            error: category,
+            upstream_content_type: upstreamError.contentType,
+            upstream_error_code: upstreamError.code,
+            upstream_error_type: upstreamError.type,
+            upstream_error_message: upstreamError.message,
+            upstream_response_bytes: upstreamError.responseBytes
+        }, "upstream request failed");
+        const message = formatUpstreamErrorMessage(category, upstreamError);
+        const prelude = diagnostics.prelude ?? null;
         if (prelude) {
-            writeAnthropicSseError(res, prelude, upstreamStatusCategory(upstream.status));
+            writeAnthropicSseError(res, prelude, message);
             return;
         }
-        sendJson(res, upstream.status, { error: upstreamStatusCategory(upstream.status) });
+        sendJson(res, upstream.status, buildUpstreamErrorPayload(category, upstream.status, diagnostics.requestId, upstreamError, anthroShape));
         return;
     }
     if (isEventStream(upstream)) {
         if (anthroShape) {
             if (!upstream.body) {
-                if (prelude) {
-                    writeAnthropicSseError(res, prelude, "invalid_upstream_response");
+                if (diagnostics.prelude) {
+                    writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
                     return;
                 }
                 sendJson(res, 502, { error: "invalid_upstream_response", detail: "Upstream stream body is missing." });
                 return;
             }
-            if (!prelude) {
+            if (!diagnostics.prelude) {
                 beginAnthropicSseResponse(res);
             }
             const upstreamReadable = Readable.fromWeb(upstream.body);
             await translateOpenAIStreamToAnthropic({
                 upstream: upstreamReadable,
                 downstream: res,
-                fallbackModel: requestedModel,
-                preEmittedMessageId: prelude?.messageId
+                fallbackModel: diagnostics.requestedModel,
+                preEmittedMessageId: diagnostics.prelude?.messageId
             });
             return;
         }
         await pipeEventStream(upstream, res);
         return;
     }
-    if (prelude) {
-        writeAnthropicSseError(res, prelude, "invalid_upstream_response");
+    if (diagnostics.prelude) {
+        writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
         return;
     }
     let json;
@@ -386,7 +483,17 @@ async function pipeEventStream(upstream, res) {
     if (res.socket && typeof res.socket.setNoDelay === "function") {
         res.socket.setNoDelay(true);
     }
-    await pipeline(Readable.fromWeb(upstream.body), res);
+    try {
+        await pipeline(Readable.fromWeb(upstream.body), res);
+    }
+    catch (error) {
+        if (isBenignSocketError(error)) {
+            // Client went away mid-stream — normal for SSE consumers (Codex,
+            // Claude Code, pi) that cancel pending responses on user input.
+            return;
+        }
+        throw error;
+    }
 }
 function isEventStream(upstream) {
     const contentType = upstream.headers.get("content-type");
@@ -415,16 +522,16 @@ function beginAnthropicSseResponse(res, req) {
 export function writeAnthropicSseError(res, prelude, code) {
     void prelude;
     try {
-        res.write(`event: message_delta\ndata: ${JSON.stringify({
+        safeWrite(res, `event: message_delta\ndata: ${JSON.stringify({
             type: "message_delta",
             delta: { stop_reason: "end_turn", stop_sequence: null },
             usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 }
         })}\n\n`);
-        res.write(`event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: code } })}\n\n`);
-        res.write(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`);
+        safeWrite(res, `event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: code } })}\n\n`);
+        safeWrite(res, `event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`);
     }
     finally {
-        res.end();
+        safeEnd(res);
     }
 }
 function isLocalRequest(req) {
@@ -455,9 +562,7 @@ async function readJson(req) {
     }
 }
 function sendJson(res, status, payload) {
-    res.statusCode = status;
-    res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify(payload));
+    safeSendJson(res, status, payload);
 }
 function readRequestedModel(payload) {
     if (!payload || typeof payload !== "object") {
@@ -548,7 +653,9 @@ async function handleDebug(res, input) {
             uptime_seconds: uptimeSeconds,
             account_type: input.config.accountType,
             selected_models: input.config.selectedModels,
-            require_caller_secret: input.config.requireCallerSecret
+            require_caller_secret: input.config.requireCallerSecret,
+            log_level: input.logger.level,
+            log_file: process.env.COPILLM_LOG_FILE ?? null
         },
         auth: {
             bearer_ttl_seconds: bearerTtlSeconds,
@@ -656,6 +763,165 @@ function upstreamStatusCategory(status) {
     }
     return "upstream_error";
 }
+async function readUpstreamError(response) {
+    const contentType = response.headers.get("content-type");
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch {
+        return { contentType, code: null, type: null, message: null, responseBytes: null };
+    }
+    const trimmed = text.trim();
+    const responseBytes = Buffer.byteLength(text, "utf8");
+    if (trimmed.length === 0) {
+        return { contentType, code: null, type: null, message: null, responseBytes };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const extracted = extractErrorFields(parsed);
+        if (extracted.message || extracted.code || extracted.type) {
+            return { contentType, responseBytes, ...extracted };
+        }
+    }
+    catch {
+        // Fall through to a plain-text snippet below.
+    }
+    return {
+        contentType,
+        code: null,
+        type: null,
+        message: truncateForDiagnostics(trimmed),
+        responseBytes
+    };
+}
+function extractErrorFields(payload) {
+    if (!payload || typeof payload !== "object") {
+        return { code: null, type: null, message: typeof payload === "string" ? truncateForDiagnostics(payload) : null };
+    }
+    const record = payload;
+    const nested = record.error;
+    if (typeof nested === "string") {
+        return {
+            code: readStringField(record, "code"),
+            type: readStringField(record, "type"),
+            message: truncateForDiagnostics(nested)
+        };
+    }
+    if (nested && typeof nested === "object") {
+        const errorRecord = nested;
+        return {
+            code: readStringField(errorRecord, "code") ?? readStringField(record, "code"),
+            type: readStringField(errorRecord, "type") ?? readStringField(record, "type"),
+            message: readTruncatedStringField(errorRecord, "message") ??
+                readTruncatedStringField(errorRecord, "detail") ??
+                readTruncatedStringField(record, "message") ??
+                readTruncatedStringField(record, "detail")
+        };
+    }
+    return {
+        code: readStringField(record, "code"),
+        type: readStringField(record, "type"),
+        message: readTruncatedStringField(record, "message") ?? readTruncatedStringField(record, "detail")
+    };
+}
+function buildUpstreamErrorPayload(category, statusCode, requestId, upstreamError, anthroShape) {
+    const code = upstreamError.code ?? category;
+    const type = upstreamError.type ?? category;
+    const message = formatUserFacingUpstreamErrorMessage(category, upstreamError);
+    if (anthroShape) {
+        return {
+            type: "error",
+            error: {
+                type,
+                message,
+                code,
+                upstream_status_code: statusCode,
+                request_id: requestId
+            }
+        };
+    }
+    return {
+        error: {
+            type,
+            code,
+            message,
+            upstream_status_code: statusCode,
+            request_id: requestId
+        }
+    };
+}
+function formatUpstreamErrorMessage(category, upstreamError) {
+    const parts = [upstreamError.code, upstreamError.type, upstreamError.message].filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length > 0 ? `${category}: ${parts.join(": ")}` : category;
+}
+function formatUserFacingUpstreamErrorMessage(category, upstreamError) {
+    if (upstreamError.code && upstreamError.message) {
+        return `${upstreamError.code}: ${upstreamError.message}`;
+    }
+    if (upstreamError.message) {
+        return upstreamError.message;
+    }
+    return upstreamError.code ?? upstreamError.type ?? category;
+}
+function readStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readTruncatedStringField(record, key) {
+    const value = readStringField(record, key);
+    return value ? truncateForDiagnostics(value) : null;
+}
+function truncateForDiagnostics(value) {
+    const maxChars = 500;
+    return value.length > maxChars ? `${value.slice(0, maxChars)}...` : value;
+}
+function summarizeUpstreamPayload(payload) {
+    let requestBytes = null;
+    try {
+        requestBytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+    }
+    catch {
+        requestBytes = null;
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return { upstream_request_bytes: requestBytes };
+    }
+    const record = payload;
+    const messages = Array.isArray(record.messages) ? record.messages : null;
+    const input = Array.isArray(record.input) ? record.input : null;
+    return {
+        upstream_request_bytes: requestBytes,
+        stream: record.stream === true,
+        max_tokens: typeof record.max_tokens === "number" ? record.max_tokens : null,
+        message_count: messages?.length ?? null,
+        input_item_count: input?.length ?? null,
+        tool_count: Array.isArray(record.tools) ? record.tools.length : 0,
+        text_characters: sumTextCharacters(payload)
+    };
+}
+function sumTextCharacters(value) {
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (!value || typeof value !== "object") {
+        return 0;
+    }
+    if (Array.isArray(value)) {
+        return value.reduce((total, item) => total + sumTextCharacters(item), 0);
+    }
+    let total = 0;
+    const record = value;
+    for (const [key, nested] of Object.entries(record)) {
+        if (key === "text" || key === "content" || key === "arguments" || key === "input") {
+            total += sumTextCharacters(nested);
+        }
+        else if (nested && typeof nested === "object" && key !== "data" && key !== "image_url" && key !== "source") {
+            total += sumTextCharacters(nested);
+        }
+    }
+    return total;
+}
 function healthFailure(error) {
     if (error instanceof CopilotTokenExchangeError) {
         if (error.statusCode === 401 || error.statusCode === 403) {

package/dist/server/requestLifecycle.js

@@ -0,0 +1,115 @@
+// Node error codes we treat as "client went away, this is normal" — they
+// must never crash the daemon and must not be reported as errors. SSE clients
+// (Codex, Claude Code, pi) abort streams constantly: user types another
+// prompt, hits Esc, switches turns, etc.
+const BENIGN_SOCKET_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "EPIPE",
+    "ERR_STREAM_PREMATURE_CLOSE",
+    "ERR_STREAM_DESTROYED",
+    "ERR_STREAM_WRITE_AFTER_END",
+    "ERR_HTTP_HEADERS_SENT"
+]);
+export function isBenignSocketError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const err = error;
+    if (typeof err.code === "string" && BENIGN_SOCKET_ERROR_CODES.has(err.code)) {
+        return true;
+    }
+    if (err.name === "AbortError") {
+        return true;
+    }
+    if (err.cause && isBenignSocketError(err.cause)) {
+        return true;
+    }
+    return false;
+}
+export function attachRequestLifecycle(req, res, logger, requestId) {
+    const controller = new AbortController();
+    let alive = true;
+    const markGone = (source, err) => {
+        if (!alive) {
+            return;
+        }
+        alive = false;
+        if (err && !isBenignSocketError(err)) {
+            logger.debug({ event: "request_lifecycle_error", request_id: requestId, source, err }, "request stream errored");
+        }
+        else if (source !== "close" || err) {
+            logger.debug({ event: "request_lifecycle_closed", request_id: requestId, source }, "client disconnected");
+        }
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    };
+    res.on("close", () => markGone("close"));
+    res.on("error", (err) => markGone("error", err));
+    req.on("aborted", () => markGone("aborted"));
+    req.on("error", (err) => markGone("error", err));
+    return {
+        signal: controller.signal,
+        isAlive: () => alive && res.writable && !res.writableEnded
+    };
+}
+/**
+ * Writes a JSON response, but is a no-op when the response is already
+ * committed or the socket is gone. This is the safe replacement for
+ * `res.setHeader(...) + res.end(...)` in any path that might run after a
+ * streaming response has started flushing.
+ */
+export function safeSendJson(res, status, payload) {
+    if (res.headersSent || !res.writable || res.writableEnded) {
+        return;
+    }
+    try {
+        res.statusCode = status;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(payload));
+    }
+    catch (error) {
+        if (isBenignSocketError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Best-effort write to a downstream Writable. Returns false when the chunk
+ * could not be delivered (because the stream is destroyed or the write
+ * threw a benign socket error). Non-benign errors are re-thrown so they're
+ * still visible to the caller.
+ */
+export function safeWrite(downstream, chunk) {
+    if (!downstream.writable || downstream.writableEnded || downstream.destroyed) {
+        return false;
+    }
+    try {
+        return downstream.write(chunk);
+    }
+    catch (error) {
+        if (isBenignSocketError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Best-effort end of a downstream Writable. Swallows benign socket errors;
+ * never throws on a destroyed stream.
+ */
+export function safeEnd(downstream) {
+    if (downstream.writableEnded || downstream.destroyed) {
+        return;
+    }
+    try {
+        downstream.end();
+    }
+    catch (error) {
+        if (isBenignSocketError(error)) {
+            return;
+        }
+        throw error;
+    }
+}