opencode-copilot-account-switcher 0.2.4 → 0.2.6

package/dist/copilot-network-retry.js

@@ -1,3 +1,4 @@
+import { appendFileSync } from "node:fs";
 const RETRYABLE_MESSAGES = [
     "load failed",
     "failed to fetch",
@@ -12,12 +13,152 @@ const RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
+const defaultDebugLogFile = (() => {
+    const tmp = process.env.TEMP || process.env.TMP || "/tmp";
+    return `${tmp}/opencode-copilot-retry-debug.log`;
+})();
+function isDebugEnabled() {
+    return process.env.OPENCODE_COPILOT_RETRY_DEBUG === "1";
+}
+function debugLog(message, details) {
+    if (!isDebugEnabled())
+        return;
+    const suffix = details ? ` ${JSON.stringify(details)}` : "";
+    const line = `[copilot-network-retry debug] ${new Date().toISOString()} ${message}${suffix}`;
+    console.warn(line);
+    const filePath = process.env.OPENCODE_COPILOT_RETRY_DEBUG_FILE || defaultDebugLogFile;
+    if (!filePath)
+        return;
+    try {
+        appendFileSync(filePath, `${line}\n`);
+    }
+    catch (error) {
+        console.warn(`[copilot-network-retry debug] failed to write log file ${JSON.stringify({ filePath, error: String(error) })}`);
+    }
+}
 function isAbortError(error) {
     return error instanceof Error && error.name === "AbortError";
 }
 function getErrorMessage(error) {
     return String(error instanceof Error ? error.message : error).toLowerCase();
 }
+function isInputIdTooLongErrorBody(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const error = payload.error;
+    const message = String(error?.message ?? "").toLowerCase();
+    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+}
+function isInputIdTooLongMessage(text) {
+    const message = text.toLowerCase();
+    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+}
+function hasLongInputIds(payload) {
+    const input = payload.input;
+    if (!Array.isArray(input))
+        return false;
+    return input.some((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
+}
+function stripLongInputIds(payload) {
+    const input = payload.input;
+    if (!Array.isArray(input))
+        return payload;
+    let changed = false;
+    const nextInput = input.map((item) => {
+        if (!item || typeof item !== "object")
+            return item;
+        const id = item.id;
+        if (typeof id === "string" && id.length > 64) {
+            changed = true;
+            const clone = { ...item };
+            delete clone.id;
+            return clone;
+        }
+        return item;
+    });
+    if (!changed)
+        return payload;
+    return {
+        ...payload,
+        input: nextInput,
+    };
+}
+function parseJsonBody(init) {
+    if (typeof init?.body !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(init.body);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildRetryInit(init, payload) {
+    const headers = new Headers(init?.headers);
+    if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    return {
+        ...init,
+        headers,
+        body: JSON.stringify(payload),
+    };
+}
+async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
+    if (response.status !== 400)
+        return response;
+    const requestPayload = parseJsonBody(init);
+    if (!requestPayload || !hasLongInputIds(requestPayload)) {
+        debugLog("skip input-id retry: request has no long ids");
+        return response;
+    }
+    debugLog("input-id retry candidate", {
+        status: response.status,
+        contentType: response.headers.get("content-type") ?? undefined,
+    });
+    const responseText = await response
+        .clone()
+        .text()
+        .catch(() => "");
+    if (!responseText) {
+        debugLog("skip input-id retry: empty response body");
+        return response;
+    }
+    let matched = isInputIdTooLongMessage(responseText);
+    if (!matched) {
+        try {
+            const bodyPayload = JSON.parse(responseText);
+            matched = isInputIdTooLongErrorBody(bodyPayload);
+        }
+        catch {
+            matched = false;
+        }
+    }
+    debugLog("input-id retry detection", {
+        matched,
+        bodyPreview: responseText.slice(0, 200),
+    });
+    if (!matched)
+        return response;
+    const sanitized = stripLongInputIds(requestPayload);
+    if (sanitized === requestPayload) {
+        debugLog("skip input-id retry: sanitize made no changes");
+        return response;
+    }
+    debugLog("input-id retry triggered", {
+        removedLongIds: true,
+        hadPreviousResponseId: typeof requestPayload.previous_response_id === "string",
+    });
+    const retried = await baseFetch(request, buildRetryInit(init, sanitized));
+    debugLog("input-id retry response", {
+        status: retried.status,
+        contentType: retried.headers.get("content-type") ?? undefined,
+    });
+    return retried;
+}
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
     const wrapped = new Error(`[copilot-network-retry normalized] ${base.message}`);
@@ -38,6 +179,47 @@ function isCopilotUrl(request) {
         return false;
     }
 }
+function withStreamDebugLogs(response, request) {
+    if (!isDebugEnabled())
+        return response;
+    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (!contentType.includes("text/event-stream") || !response.body)
+        return response;
+    const rawUrl = request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+    const stream = new ReadableStream({
+        start(controller) {
+            const reader = response.body.getReader();
+            const pump = async () => {
+                try {
+                    while (true) {
+                        const next = await reader.read();
+                        if (next.done) {
+                            debugLog("sse stream finished", { url: rawUrl });
+                            controller.close();
+                            break;
+                        }
+                        controller.enqueue(next.value);
+                    }
+                }
+                catch (error) {
+                    const message = getErrorMessage(error);
+                    debugLog("sse stream read error", {
+                        url: rawUrl,
+                        message,
+                        retryableByMessage: RETRYABLE_MESSAGES.some((part) => message.includes(part)),
+                    });
+                    controller.error(error);
+                }
+            };
+            void pump();
+        },
+    });
+    return new Response(stream, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
 export function isRetryableCopilotFetchError(error) {
     if (!error || isAbortError(error))
         return false;
@@ -47,10 +229,27 @@ export function isRetryableCopilotFetchError(error) {
 export function createCopilotRetryingFetch(baseFetch, options) {
     void options;
     return async function retryingFetch(request, init) {
+        debugLog("fetch start", {
+            url: request instanceof Request ? request.url : request instanceof URL ? request.href : String(request),
+            isCopilot: isCopilotUrl(request),
+        });
         try {
-            return await baseFetch(request, init);
+            const response = await baseFetch(request, init);
+            debugLog("fetch resolved", {
+                status: response.status,
+                contentType: response.headers.get("content-type") ?? undefined,
+            });
+            if (isCopilotUrl(request)) {
+                const retried = await maybeRetryInputIdTooLong(request, init, response, baseFetch);
+                return withStreamDebugLogs(retried, request);
+            }
+            return response;
         }
         catch (error) {
+            debugLog("fetch threw", {
+                message: getErrorMessage(error),
+                retryableByMessage: isRetryableCopilotFetchError(error),
+            });
             if (!isCopilotUrl(request) || !isRetryableCopilotFetchError(error)) {
                 throw error;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",