copillm 0.2.8 → 0.3.0-beta.1

package/dist/server/routes/shared.js

@@ -1,4 +1,5 @@
 import { stripOneMillionAlias } from "../../translation/openaiAnthropic.js";
+import { isValidAccountId } from "../../config/accountId.js";
 import { JsonRequestParseError } from "../errors.js";
 export async function readJson(req) {
     const chunks = [];
@@ -119,43 +120,87 @@ export function safePathname(rawUrl) {
         return "/";
     }
 }
-export function resolveRoute(method, rawUrl) {
-    if (!method || !rawUrl) {
-        return { kind: "not_found", anthroShape: false };
-    }
-    let pathname;
-    try {
-        pathname = new URL(rawUrl, "http://127.0.0.1").pathname;
-    }
-    catch {
-        return { kind: "not_found", anthroShape: false };
-    }
+// First path segments that belong to real routes and must never be mistaken
+// for an account prefix. (Direct matching already wins for these, so this is
+// belt-and-suspenders against contrived nested paths.)
+const RESERVED_FIRST_SEGMENTS = new Set([
+    "livez",
+    "healthz",
+    "models",
+    "v1",
+    "codex",
+    "anthropic",
+    "_debug"
+]);
+// Only these routes may be addressed with an `/<account>` prefix. The generic
+// `/models` discovery route and all health/debug routes stay global.
+const PREFIXABLE_KINDS = new Set([
+    "codex_models",
+    "anthropic_models",
+    "codex_responses",
+    "openai",
+    "anthropic"
+]);
+function matchRoute(method, pathname) {
     if (method === "GET" && pathname === "/livez") {
-        return { kind: "livez", anthroShape: false };
+        return { kind: "livez", anthroShape: false, accountId: null };
     }
     if (method === "GET" && pathname === "/healthz") {
-        return { kind: "healthz", anthroShape: false };
+        return { kind: "healthz", anthroShape: false, accountId: null };
     }
     if (method === "GET" && (pathname === "/models" || pathname === "/v1/models")) {
-        return { kind: "models", anthroShape: false };
+        return { kind: "models", anthroShape: false, accountId: null };
     }
     if (method === "GET" && pathname === "/codex/v1/models") {
-        return { kind: "codex_models", anthroShape: false };
+        return { kind: "codex_models", anthroShape: false, accountId: null };
     }
     if (method === "GET" && pathname === "/anthropic/v1/models") {
-        return { kind: "anthropic_models", anthroShape: false };
+        return { kind: "anthropic_models", anthroShape: false, accountId: null };
     }
     if (method === "POST" && pathname === "/codex/v1/responses") {
-        return { kind: "codex_responses", anthroShape: false };
+        return { kind: "codex_responses", anthroShape: false, accountId: null };
     }
     if (method === "GET" && pathname === "/_debug") {
-        return { kind: "debug", anthroShape: false };
+        return { kind: "debug", anthroShape: false, accountId: null };
     }
     if (method === "POST" && pathname === "/v1/chat/completions") {
-        return { kind: "openai", anthroShape: false };
+        return { kind: "openai", anthroShape: false, accountId: null };
     }
     if (method === "POST" && (pathname === "/anthropic/v1/messages" || pathname === "/v1/messages")) {
-        return { kind: "anthropic", anthroShape: true };
+        return { kind: "anthropic", anthroShape: true, accountId: null };
+    }
+    return null;
+}
+export function resolveRoute(method, rawUrl) {
+    if (!method || !rawUrl) {
+        return { kind: "not_found", anthroShape: false, accountId: null };
+    }
+    let pathname;
+    try {
+        pathname = new URL(rawUrl, "http://127.0.0.1").pathname;
+    }
+    catch {
+        return { kind: "not_found", anthroShape: false, accountId: null };
+    }
+    // Try the path as-is first. This keeps every existing (unprefixed) route
+    // working unchanged and ensures a reserved first segment like `/codex/...`
+    // is always interpreted as a route, never as an account named "codex".
+    const direct = matchRoute(method, pathname);
+    if (direct) {
+        return direct;
+    }
+    // Otherwise, peel an optional leading `/<account>` segment and re-match the
+    // remainder against the prefixable routes.
+    const prefixMatch = pathname.match(/^\/([^/]+)(\/.*)$/);
+    if (prefixMatch) {
+        const candidate = prefixMatch[1];
+        const rest = prefixMatch[2];
+        if (isValidAccountId(candidate) && !RESERVED_FIRST_SEGMENTS.has(candidate)) {
+            const sub = matchRoute(method, rest);
+            if (sub && PREFIXABLE_KINDS.has(sub.kind)) {
+                return { ...sub, accountId: candidate };
+            }
+        }
     }
-    return { kind: "not_found", anthroShape: false };
+    return { kind: "not_found", anthroShape: false, accountId: null };
 }

package/dist/server/upstream/copilotClient.js

@@ -1,6 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { accountBaseUrl } from "../../models/discovery.js";
 import { isBenignSocketError } from "../requestLifecycle.js";
+import { isRetryableStatus, isRetryableTransportError, retryDelayMs } from "./retryPolicy.js";
 const COPILOT_HEADERS = {
     "Content-Type": "application/json",
     "Copilot-Integration-Id": "vscode-chat",
@@ -17,9 +18,7 @@ const COPILOT_HEADERS = {
     // flow through immediately.
     "Accept-Encoding": "identity"
 };
-const RETRYABLE_UPSTREAM_STATUSES = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
 const MAX_UPSTREAM_ATTEMPTS = 3;
-const BASE_BACKOFF_MS = 200;
 export async function postToCopilot(input) {
     let forceRefresh = false;
     let authRefreshRetried = false;
@@ -99,34 +98,6 @@ function abortErrorFromSignal(signal) {
     err.name = "AbortError";
     return err;
 }
-function isRetryableStatus(status) {
-    return RETRYABLE_UPSTREAM_STATUSES.has(status);
-}
-function retryDelayMs(attempt) {
-    return BASE_BACKOFF_MS * Math.pow(2, Math.max(0, attempt - 1));
-}
-function isRetryableTransportError(error) {
-    if (!error || typeof error !== "object") {
-        return false;
-    }
-    const typedError = error;
-    const directCode = typedError.code?.toUpperCase();
-    const causeCode = typedError.cause?.code?.toUpperCase();
-    if (directCode === "ECONNRESET" || directCode === "ECONNREFUSED" || directCode === "ETIMEDOUT") {
-        return true;
-    }
-    if (causeCode === "ECONNRESET" || causeCode === "ECONNREFUSED" || causeCode === "ETIMEDOUT") {
-        return true;
-    }
-    if (!(typedError instanceof Error)) {
-        return false;
-    }
-    const message = typedError.message.toLowerCase();
-    if (message.includes("timed out") || message.includes("timeout")) {
-        return true;
-    }
-    return message.includes("econnreset") || message.includes("econnrefused") || message.includes("enotfound");
-}
 async function discardUpstreamBody(response) {
     try {
         await response.arrayBuffer();

package/dist/server/upstream/retryPolicy.js

@@ -0,0 +1,99 @@
+// Shared retry primitives for upstream HTTP calls.
+//
+// Originally lived inline in `copilotClient.ts` only. Extracted so that
+// other upstream-facing fetch sites (token exchange in `auth/copilotToken.ts`,
+// future device-flow / model-discovery sites) can share the same policy
+// instead of each rolling its own slightly-different version. The numerical
+// constants and the retryable-status set must match `copilotClient.ts`'s
+// previous behaviour exactly so existing tests and production semantics
+// don't drift.
+/**
+ * HTTP statuses that warrant a retry: transient server-side congestion /
+ * upstream outages. 401 is NOT here — auth failures are handled by a
+ * separate caller-driven "force refresh once" path in `copilotClient.ts`,
+ * and by `CopilotTokenManager.exchange()` as a terminal "bad credentials"
+ * signal.
+ */
+export const RETRYABLE_UPSTREAM_STATUSES = new Set([
+    408, 409, 425, 429, 500, 502, 503, 504
+]);
+export function isRetryableStatus(status) {
+    return RETRYABLE_UPSTREAM_STATUSES.has(status);
+}
+/** Base exponential backoff: 200ms × 2^(attempt-1). */
+export const BASE_BACKOFF_MS = 200;
+export function retryDelayMs(attempt) {
+    return BASE_BACKOFF_MS * Math.pow(2, Math.max(0, attempt - 1));
+}
+/**
+ * Node `fetch` / undici transport error codes worth retrying. Excludes
+ * permanent errors like EACCES, ENOSPC, certificate failures. Both the
+ * direct `error.code` and the wrapped `error.cause.code` are checked
+ * because undici wraps the underlying socket error in a `TypeError:
+ * fetch failed` whose `.cause` carries the real code.
+ *
+ * EAI_AGAIN, EHOSTUNREACH, ENETUNREACH catch the common transient DNS
+ * and routing failures (home networks, corp VPN flaps, macOS wake-from-
+ * sleep). UND_ERR_* are undici's own timeouts and socket errors.
+ */
+const RETRYABLE_TRANSPORT_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EPIPE",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT"
+]);
+const RETRYABLE_TRANSPORT_MESSAGE_SUBSTRINGS = [
+    "timed out",
+    "timeout",
+    "econnreset",
+    "econnrefused",
+    "enotfound",
+    "eai_again",
+    "ehostunreach",
+    "enetunreach",
+    "socket hang up",
+    "other side closed",
+    "fetch failed"
+];
+export function isRetryableTransportError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const typedError = error;
+    if (matchesRetryableCode(typedError.code)) {
+        return true;
+    }
+    // Recurse into .cause to handle undici's `TypeError: fetch failed` wrapper
+    // (and any other wrapper layers); bounded depth so a self-referential
+    // cause chain can't run away.
+    if (causeHasRetryableCode(typedError.cause, 0)) {
+        return true;
+    }
+    if (!(typedError instanceof Error)) {
+        return false;
+    }
+    const message = typedError.message.toLowerCase();
+    return RETRYABLE_TRANSPORT_MESSAGE_SUBSTRINGS.some((needle) => message.includes(needle));
+}
+function matchesRetryableCode(code) {
+    if (typeof code !== "string")
+        return false;
+    return RETRYABLE_TRANSPORT_CODES.has(code.toUpperCase());
+}
+function causeHasRetryableCode(cause, depth) {
+    if (!cause || typeof cause !== "object" || depth > 5) {
+        return false;
+    }
+    const inner = cause;
+    if (matchesRetryableCode(inner.code)) {
+        return true;
+    }
+    return causeHasRetryableCode(inner.cause, depth + 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.2.8",
+  "version": "0.3.0-beta.1",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",
@@ -26,6 +26,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/cli.ts",
+    "dev:start": "npm run build && node dist/cli.js --dev start",
+    "dev:stop": "npm run build && node dist/cli.js --dev stop",
+    "dev:status": "node dist/cli.js --dev status",
     "lint": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json --noEmit && eslint src",
     "lint:boundaries": "eslint src",
     "test": "vitest run",