codex-copilot-dx 0.6.18 → 0.6.20

package/README.md

@@ -378,6 +378,8 @@ Environment variables:
 | `CCDX_MAX_BODY_BYTES` | `67108864` | Maximum compressed/raw request body size |
 | `CCDX_MAX_DECODED_BODY_BYTES` | `134217728` | Maximum decoded request body size after decompression |
 | `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Per-pool byte budget for raw bodies, decoded bodies, and materialized response history; a larger item runs exclusively in its pool |
+| `CCDX_MAX_UPSTREAM_CHAT_RESPONSE_BYTES` | `67108864` | Maximum buffered successful Chat Completions response used by Responses, Anthropic, and PM Studio conversion paths |
+| `CCDX_MAX_UPSTREAM_RESPONSES_RESPONSE_BYTES` | `268435456` | Maximum buffered successful native Responses or compact response; streaming Responses are forwarded with bounded backpressure instead |
 | `CCDX_MAX_QUEUED_REQUESTS` | `16` | Maximum body requests waiting for the shared byte budget |
 | `CCDX_REQUEST_QUEUE_TIMEOUT_MS` | `120000` | Maximum wait for request-body admission before returning `503` |
 | `CCDX_REQUEST_BODY_TIMEOUT_MS` | `120000` | Maximum time to receive and decode one request body before returning `408` |

package/bin/cli.mjs

@@ -17,6 +17,7 @@ import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
 import { runInBackground } from "../src/startup.mjs";
 import { cliCommandName, cliHelp, parseAdapterProbeOptions, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
 import { formatAdapterStatus, readAdapterStatus } from "../src/cli-status.mjs";
+import { formatCliError } from "../src/cli-error.mjs";
 import { closeHttpServer } from "../src/shutdown.mjs";
 import { runAutoReviewModelCommand } from "../src/auto-review-model.mjs";
 import { autoReviewModelPreference } from "../src/user-settings.mjs";
@@ -152,7 +153,7 @@ if (CLI.command === "pms") {
     await runPmStudioSetup({ commandName: CLI_NAME });
     process.exit(0);
   } catch (e) {
-    console.error(status("err", e.message));
+    console.error(formatCliError(e));
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/adapter.mjs

@@ -15,6 +15,7 @@ import { createPmStudioRelayHandler, PM_STUDIO_RELAY_PREFIX } from "./pm-studio-
 import { createStreamPerformanceMetrics } from "./stream-performance.mjs";
 import { status } from "./status.mjs";
 import { createTerminalActivityIndicator } from "./terminal-activity.mjs";
+import { createTokenCounterService } from "./token-counter-service.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { createResponsesCompactHandler, createResponsesHandler } from "./responses-handler.mjs";
 import { createResponsesImagePressureController } from "./responses-image-pressure.mjs";
@@ -145,6 +146,11 @@ export function createAdapterHandler(options = {}) {
   const requestMetrics = options.requestMetrics || createRequestMetrics();
   const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
   const imagePressure = options.imagePressure || createResponsesImagePressureController();
+  const ownsTokenCounterService = !options.tokenCounterService;
+  const tokenCounterService = options.tokenCounterService || createTokenCounterService({
+    timeoutMs: options.countTokensTimeoutMs,
+    maxQueued: options.countTokensMaxQueued,
+  });
   const claudeDesktopModelOptions = () => {
     const modelDefs = claudeModelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
@@ -178,7 +184,11 @@ export function createAdapterHandler(options = {}) {
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
-  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({ acquireRequest, requestBodyTimeoutMs });
+  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({
+    acquireRequest,
+    requestBodyTimeoutMs,
+    countTokensFn: (body, countOptions) => tokenCounterService.count(body, countOptions),
+  });
   const anthropicMessagesHandler = createAnthropicMessagesHandler({
     acquireRequest,
     chatCompletionsFn: claudeChatCompletionsFn,
@@ -300,7 +310,7 @@ export function createAdapterHandler(options = {}) {
     ? options.dispatchRequestForTests
     : dispatch;
 
-  return (req, res) => {
+  const handler = (req, res) => {
     const requestId = createRequestId();
     if (typeof res.setHeader === "function") {
       res.setHeader("X-Request-Id", requestId);
@@ -378,6 +388,10 @@ export function createAdapterHandler(options = {}) {
       containUnexpectedError(error);
     }
   };
+  handler.cleanup = () => {
+    if (ownsTokenCounterService) tokenCounterService.close();
+  };
+  return handler;
 }
 
 // Public server entry point.
@@ -385,9 +399,11 @@ export function createAdapterHandler(options = {}) {
 export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   const ownsTerminalActivity = !Object.hasOwn(options, "terminalActivity");
   const terminalActivity = ownsTerminalActivity ? createTerminalActivityIndicator() : options.terminalActivity;
-  const server = http.createServer(createAdapterHandler({ ...options, terminalActivity }));
+  const handler = createAdapterHandler({ ...options, terminalActivity });
+  const server = http.createServer(handler);
   const cleanupTerminalActivity = () => {
     if (ownsTerminalActivity) terminalActivity?.cleanup?.();
+    handler.cleanup?.();
   };
   server.once("close", cleanupTerminalActivity);
 

package/src/anthropic-handler.mjs

@@ -7,6 +7,7 @@ import {
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
   MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
   readBoundedResponseText,
@@ -60,7 +61,7 @@ function sendAnthropicUpstreamError(res, response, text) {
 }
 
 export function createAnthropicCountTokensHandler(options) {
-  const { acquireRequest, requestBodyTimeoutMs } = options;
+  const { acquireRequest, requestBodyTimeoutMs, countTokensFn = countTokens } = options;
 
   return async function handleAnthropicCountTokens(req, res) {
     const abort = createRequestAbort(req, res);
@@ -70,12 +71,12 @@ export function createAnthropicCountTokensHandler(options) {
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
       abort.clearTimeout();
-      const result = await countTokens(parsed);
+      const result = await countTokensFn(parsed, { signal: abort.signal });
       releaseRequest();
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
     } catch (error) {
-      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 400);
+      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 500);
     } finally {
       releaseRequest();
       abort.cleanup();
@@ -157,7 +158,11 @@ export function createAnthropicMessagesHandler(options) {
         const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
         releaseRequest();
         const data = upstream.ok
-          ? await upstream.text()
+          ? await readBoundedResponseText(upstream, {
+            maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
+            label: "Copilot Chat success body",
+            signal: abort.signal,
+          })
           : await readBoundedResponseText(upstream, {
             maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
             label: "Copilot Chat error body",

package/src/anthropic.mjs

@@ -350,8 +350,7 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   await emit("message_stop", { type: "message_stop" });
 }
 
-// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
-export async function countTokens(body) {
+export function anthropicTokenText(body) {
   const parts = [];
   const sys = systemToText(body.system);
   if (sys) parts.push(sys);
@@ -374,7 +373,15 @@ export async function countTokens(body) {
     }
   }
 
-  const text = parts.join("\n");
+  return parts.join("\n");
+}
+
+export async function countTokenText(text) {
   const count = await tokenCounter();
   return { input_tokens: count(text) };
 }
+
+// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
+export async function countTokens(body) {
+  return countTokenText(anthropicTokenText(body));
+}

package/src/auth-profile.mjs

@@ -12,7 +12,7 @@ import {
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
 import { withFileLock } from "./lock.mjs";
-import { parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
+import { parseSafePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
 export const AUTH_PROFILE_CODEX = "codex";
 export const AUTH_PROFILE_CLAUDE = "claude";
@@ -117,8 +117,8 @@ export function readAuthProfileCredentials(profile, { home = os.homedir() } = {}
 
 function lockOptions(env = process.env) {
   return {
-    timeoutMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
-    staleMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
+    timeoutMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
+    staleMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
   };
 }
 

package/src/auth.mjs

@@ -8,7 +8,7 @@ import {
   githubTokenFingerprint,
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
-import { parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
+import { parseSafePositiveInteger, parseTimerMs, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
 import { withFileLock } from "./lock.mjs";
 
@@ -20,6 +20,7 @@ const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
 const DEFAULT_DEVICE_INTERVAL_SECONDS = 5;
 const DEFAULT_DEVICE_EXPIRES_SECONDS = 900;
 const DEFAULT_DEVICE_CODE_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_GITHUB_IDENTITY_TIMEOUT_MS = 30 * 1000;
 const MAX_DEVICE_FLOW_JSON_BYTES = 64 * 1024;
 const DISABLE_TOKEN_DISCOVERY_VALUES = new Set(["1", "true", "yes"]);
 const MAX_AUTH_JSON_BYTES = 1024 * 1024;
@@ -258,8 +259,8 @@ function isTokenDiscoveryDisabled(env = process.env) {
 
 function tokenLockOptions(env = process.env) {
   return {
-    timeoutMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
-    staleMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
+    timeoutMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
+    staleMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
   };
 }
 
@@ -425,19 +426,47 @@ function expectedGithubIdentity(home, env, token) {
   return token ? readGithubTokenMetadata(home, token) : null;
 }
 
-export async function fetchGithubIdentity(token, { fetchImpl = fetch, signal } = {}) {
+function githubIdentityTimeoutError(timeoutMs) {
+  const error = new Error(`GitHub identity request timed out after ${timeoutMs}ms`);
+  error.code = "CCDX_GITHUB_IDENTITY_TIMEOUT";
+  return error;
+}
+
+export async function fetchGithubIdentity(token, {
+  fetchImpl = fetch,
+  signal,
+  timeoutMs = DEFAULT_GITHUB_IDENTITY_TIMEOUT_MS,
+} = {}) {
   if (typeof token !== "string" || !token.trim()) return { ok: false, reason: "empty_token" };
+  const deadlineMs = parseTimerMs(timeoutMs, DEFAULT_GITHUB_IDENTITY_TIMEOUT_MS);
+  const controller = new AbortController();
+  const onCallerAbort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", onCallerAbort, { once: true });
+  if (signal?.aborted) onCallerAbort();
+  const timer = setTimeout(() => controller.abort(githubIdentityTimeoutError(deadlineMs)), deadlineMs);
+  let resp;
   try {
-    const resp = await fetchImpl(`${GITHUB_API}/user`, {
+    resp = await awaitWithSignal(() => fetchImpl(`${GITHUB_API}/user`, {
       headers: { Authorization: `token ${token.trim()}`, Accept: "application/json" },
-      signal,
-    });
+      signal: controller.signal,
+    }), controller.signal);
     if (!resp.ok) return { ok: false, status: resp.status, reason: "github_user_failed" };
-    const data = await resp.json();
+    const data = await awaitWithSignal(() => resp.json(), controller.signal);
     const identity = normalizeGithubIdentity(data);
     return identity ? { ok: true, ...identity } : { ok: false, reason: "github_identity_missing" };
   } catch (error) {
-    return { ok: false, transient: true, reason: "github_user_request_failed", error };
+    cancelResponseBody(resp);
+    const timedOut = controller.signal.aborted && !signal?.aborted
+      && controller.signal.reason?.code === "CCDX_GITHUB_IDENTITY_TIMEOUT";
+    return {
+      ok: false,
+      transient: true,
+      reason: timedOut ? "github_user_timeout" : "github_user_request_failed",
+      error,
+    };
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onCallerAbort);
   }
 }
 
@@ -661,6 +690,7 @@ export async function ensureAuth({
   log = console.log,
   openAndCopyFn = openAndCopy,
   deviceCodeTimeoutMs = DEFAULT_DEVICE_CODE_TIMEOUT_MS,
+  githubIdentityTimeoutMs = DEFAULT_GITHUB_IDENTITY_TIMEOUT_MS,
   sleepImpl = sleep,
   now = Date.now,
 } = {}) {
@@ -720,7 +750,11 @@ export async function ensureAuth({
       now,
     });
     if (result.state === "done") {
-      const identity = await fetchGithubIdentity(result.token, { fetchImpl, signal });
+      const identity = await fetchGithubIdentity(result.token, {
+        fetchImpl,
+        signal,
+        timeoutMs: githubIdentityTimeoutMs,
+      });
       writeToken(result.token, home, identity.ok ? identity : null);
       log(status("ok", "Login successful"));
       return;

package/src/auto-review-model.mjs

@@ -12,12 +12,12 @@ import {
   readUserSettings,
   writeAutoReviewModel,
 } from "./user-settings.mjs";
+import { parseTimerMs } from "./runtime-config.mjs";
 
 const DEFAULT_MODEL_FETCH_TIMEOUT_MS = 5000;
 
 function modelFetchTimeout(env) {
-  const value = Number(env.CCDX_MODEL_REFRESH_TIMEOUT_MS);
-  return Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_MODEL_FETCH_TIMEOUT_MS;
+  return parseTimerMs(env.CCDX_MODEL_REFRESH_TIMEOUT_MS, DEFAULT_MODEL_FETCH_TIMEOUT_MS);
 }
 
 function sortedModelIds(modelIds, currentModel) {

package/src/cli-auth.mjs

@@ -15,12 +15,16 @@ import {
   withAuthProfileLock,
   writeClaudeAuthProfile,
 } from "./auth-profile.mjs";
-import { buildHeaders, DEFAULT_API_BASE, FALLBACK_VSCODE_VERSION } from "./copilot.mjs";
+import { buildHeaders, FALLBACK_VSCODE_VERSION, parseApiBase } from "./copilot.mjs";
 import {
   githubIdentitiesEqual,
   githubTokenFingerprint,
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
+import {
+  MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+  readBoundedResponseText,
+} from "./http-transport.mjs";
 import { saveModelCache } from "./model-cache.mjs";
 import { isClaudeCopilotModel } from "./models.mjs";
 import { profileRouting } from "./profile-routing.mjs";
@@ -32,6 +36,8 @@ import {
   terminalCell,
 } from "./cli-table.mjs";
 
+const DEFAULT_COPILOT_CATALOG_TIMEOUT_MS = 30 * 1000;
+
 function openAndCopy(userCode, verificationUri) {
   if (process.platform !== "darwin") return;
   try {
@@ -50,6 +56,44 @@ function responseDetail(value) {
   return String(value || "").replace(/\s+/g, " ").trim().slice(0, 240);
 }
 
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function cancelResponseBody(response) {
+  try { Promise.resolve(response?.body?.cancel?.()).catch(() => {}); } catch {}
+}
+
+function fetchWithSignal(operation, signal) {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return false;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      callback(value);
+      return true;
+    };
+    const onAbort = () => finish(reject, abortError(signal));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve()
+      .then(operation)
+      .then((response) => {
+        if (!finish(resolve, response)) cancelResponseBody(response);
+      }, (error) => finish(reject, error));
+  });
+}
+
+function catalogTimeoutError(label, timeoutMs) {
+  const error = new Error(`${label} model catalog timed out after ${timeoutMs}ms`);
+  error.code = "CCDX_COPILOT_CATALOG_TIMEOUT";
+  return error;
+}
+
 async function jsonResponse({ response, data, jsonError }, label) {
   if (!response.ok) {
     throw new Error(`${label} failed with HTTP ${response.status}`);
@@ -121,33 +165,58 @@ async function fetchCopilotCatalog(tokenData, {
   signal,
   vscodeVersion = FALLBACK_VSCODE_VERSION,
   label = "Copilot",
+  timeoutMs = DEFAULT_COPILOT_CATALOG_TIMEOUT_MS,
 } = {}) {
-  const apiBase = tokenData?.endpoints?.api || DEFAULT_API_BASE;
-  const headers = buildHeaders({
-    token: tokenData.token,
-    version: vscodeVersion,
-    initiator: "user",
-    vision: false,
-  });
-  const modelResponse = await fetchImpl(`${apiBase}/models`, {
-    headers,
-    redirect: "error",
-    signal,
-  });
-  const modelText = await modelResponse.text();
-  if (!modelResponse.ok) {
-    const detail = responseDetail(modelText);
-    throw new Error(`${label} model catalog failed with HTTP ${modelResponse.status}${detail ? `: ${detail}` : ""}`);
-  }
-
-  let catalog;
+  const parsedTimeout = Number(timeoutMs);
+  const deadlineMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0
+    ? parsedTimeout
+    : DEFAULT_COPILOT_CATALOG_TIMEOUT_MS;
+  const controller = new AbortController();
+  const onCallerAbort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", onCallerAbort, { once: true });
+  if (signal?.aborted) onCallerAbort();
+  const timer = setTimeout(() => controller.abort(catalogTimeoutError(label, deadlineMs)), deadlineMs);
+  let modelResponse;
   try {
-    catalog = JSON.parse(modelText);
-  } catch {
-    throw new Error(`${label} model catalog returned invalid JSON`);
+    const apiBase = parseApiBase(tokenData);
+    const headers = buildHeaders({
+      token: tokenData.token,
+      version: vscodeVersion,
+      initiator: "user",
+      vision: false,
+    });
+    modelResponse = await fetchWithSignal(() => fetchImpl(`${apiBase}/models`, {
+      headers,
+      redirect: "error",
+      signal: controller.signal,
+    }), controller.signal);
+    const modelText = await readBoundedResponseText(modelResponse, {
+      maxBytes: MAX_UPSTREAM_MODEL_CATALOG_BYTES,
+      label: `${label} model catalog`,
+      signal: controller.signal,
+    });
+    if (!modelResponse.ok) {
+      const detail = responseDetail(modelText);
+      throw new Error(`${label} model catalog failed with HTTP ${modelResponse.status}${detail ? `: ${detail}` : ""}`);
+    }
+
+    let catalog;
+    try {
+      catalog = JSON.parse(modelText);
+    } catch {
+      throw new Error(`${label} model catalog returned invalid JSON`);
+    }
+    catalogModels(catalog);
+    return { catalog, apiBase };
+  } catch (error) {
+    if (signal?.aborted) throw abortError(signal);
+    if (controller.signal.aborted) throw abortError(controller.signal);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onCallerAbort);
+    if (controller.signal.aborted) cancelResponseBody(modelResponse);
   }
-  catalogModels(catalog);
-  return { catalog, apiBase };
 }
 
 export async function validateClaudeCandidate(githubToken, {
@@ -156,6 +225,7 @@ export async function validateClaudeCandidate(githubToken, {
   fetchImpl = fetch,
   signal,
   vscodeVersion = FALLBACK_VSCODE_VERSION,
+  catalogTimeoutMs,
 } = {}) {
   const validation = await validateGithubToken(githubToken, { fetchImpl, signal });
   if (!validation.ok) {
@@ -180,6 +250,7 @@ export async function validateClaudeCandidate(githubToken, {
     signal,
     vscodeVersion,
     label: "Claude account",
+    timeoutMs: catalogTimeoutMs,
   });
   const models = claudeModels(catalog);
   if (!models.length) {
@@ -205,6 +276,7 @@ export async function authorizeClaudeProfile({
   log = console.log,
   openAndCopyFn = openAndCopy,
   deviceCodeTimeoutMs,
+  catalogTimeoutMs,
   sleepImpl,
   now = Date.now,
   saveModelCacheFn = saveModelCache,
@@ -268,6 +340,7 @@ export async function authorizeClaudeProfile({
       expectedLogin,
       fetchImpl,
       signal,
+      catalogTimeoutMs,
     });
     await withAuthProfileLock(AUTH_PROFILE_CODEX, () => {
       const currentCodex = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });

package/src/cli-error.mjs

@@ -0,0 +1,50 @@
+import { terminalCell } from "./cli-table.mjs";
+import { status } from "./status.mjs";
+
+const MAX_MESSAGE_CHARACTERS = 1024;
+const MAX_DETAIL_CHARACTERS = 512;
+const MAX_DETAILS = 16;
+
+function redactSensitiveValues(value) {
+  return value
+    .replace(/\b(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s,;]+/gi, "$1[REDACTED]")
+    .replace(/\bbearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
+    .replace(/\b((?:api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|password|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[REDACTED]")
+    .replace(/\b(?:github_pat_[A-Za-z0-9_]{8,}|gh[pousr]_[A-Za-z0-9_]{8,}|sk-[A-Za-z0-9_-]{8,})\b/g, "[REDACTED]");
+}
+
+function boundedTerminalText(value, fallback, maxCharacters) {
+  try {
+    return redactSensitiveValues(terminalCell(value, { fallback })).slice(0, maxCharacters);
+  } catch {
+    return fallback;
+  }
+}
+
+export function formatCliError(error) {
+  let rawMessage;
+  try {
+    rawMessage = error?.message;
+  } catch {
+    rawMessage = undefined;
+  }
+  const message = boundedTerminalText(rawMessage, "Command failed", MAX_MESSAGE_CHARACTERS);
+  let details;
+  try {
+    details = error?.details;
+  } catch {
+    details = undefined;
+  }
+  const values = details === undefined
+    ? []
+    : Array.isArray(details) ? details : [details];
+  const visible = values.slice(0, MAX_DETAILS);
+  const lines = [status("err", message)];
+  for (const detail of visible) {
+    lines.push(status("info", boundedTerminalText(detail, "Detail unavailable", MAX_DETAIL_CHARACTERS)));
+  }
+  if (values.length > visible.length) {
+    lines.push(status("info", `${values.length - visible.length} additional detail(s) omitted`));
+  }
+  return lines.join("\n");
+}

package/src/cli-models.mjs

@@ -5,7 +5,7 @@ import {
   AUTH_PROFILE_CODEX,
   readAuthProfileCredentials,
 } from "./auth-profile.mjs";
-import { buildHeaders, DEFAULT_API_BASE, FALLBACK_VSCODE_VERSION } from "./copilot.mjs";
+import { buildHeaders, FALLBACK_VSCODE_VERSION, parseApiBase } from "./copilot.mjs";
 import {
   isClaudeCopilotCatalogEntry,
   isClaudeCopilotModel,
@@ -134,7 +134,7 @@ export async function fetchLiveCopilotModels({
     if (!validation.ok) throw new Error(validationFailure(validation));
 
     const tokenData = validation.copilotTokenData;
-    const apiBase = tokenData.endpoints?.api || DEFAULT_API_BASE;
+    const apiBase = parseApiBase(tokenData);
     const headers = buildHeaders({
       token: tokenData.token,
       version: vscodeVersion,

package/src/cli-options.mjs

@@ -1,3 +1,5 @@
+import { MAX_TIMER_DELAY_MS } from "./runtime-config.mjs";
+
 const HELP_COMMANDS = new Set(["help", "--help", "-h"]);
 const VERSION_COMMANDS = new Set(["version", "--version", "-v"]);
 const START_OPTIONS = new Map([
@@ -262,13 +264,13 @@ export function parseRuntimeOptions(env = process.env) {
   return {
     adapterPort: integerEnv(env, "ADAPTER_PORT", 2026, { min: 1, max: 65535 }),
     adapterHost: String(env.ADAPTER_HOST || "127.0.0.1").trim() || "127.0.0.1",
-    modelRefreshTimeoutMs: integerEnv(env, "CCDX_MODEL_REFRESH_TIMEOUT_MS", 5000, { min: 1 }),
-    existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1 }),
-    modelRefreshIntervalMs: integerEnv(env, "CCDX_MODEL_REFRESH_INTERVAL_MS", 2 * 60 * 60 * 1000, { min: 0 }),
-    upstreamTimeoutMs: integerEnv(env, "CCDX_UPSTREAM_TIMEOUT_MS", 120000, { min: 1 }),
-    streamHandshakeTimeoutMs: integerEnv(env, "CCDX_STREAM_HANDSHAKE_TIMEOUT_MS", 120000, { min: 1 }),
-    streamIdleTimeoutMs: integerEnv(env, "CCDX_STREAM_IDLE_TIMEOUT_MS", 120000, { min: 1 }),
-    shutdownTimeoutMs: integerEnv(env, "CCDX_SHUTDOWN_TIMEOUT_MS", 5000, { min: 1 }),
+    modelRefreshTimeoutMs: integerEnv(env, "CCDX_MODEL_REFRESH_TIMEOUT_MS", 5000, { min: 1, max: MAX_TIMER_DELAY_MS }),
+    existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1, max: MAX_TIMER_DELAY_MS }),
+    modelRefreshIntervalMs: integerEnv(env, "CCDX_MODEL_REFRESH_INTERVAL_MS", 2 * 60 * 60 * 1000, { min: 0, max: MAX_TIMER_DELAY_MS }),
+    upstreamTimeoutMs: integerEnv(env, "CCDX_UPSTREAM_TIMEOUT_MS", 120000, { min: 1, max: MAX_TIMER_DELAY_MS }),
+    streamHandshakeTimeoutMs: integerEnv(env, "CCDX_STREAM_HANDSHAKE_TIMEOUT_MS", 120000, { min: 1, max: MAX_TIMER_DELAY_MS }),
+    streamIdleTimeoutMs: integerEnv(env, "CCDX_STREAM_IDLE_TIMEOUT_MS", 120000, { min: 1, max: MAX_TIMER_DELAY_MS }),
+    shutdownTimeoutMs: integerEnv(env, "CCDX_SHUTDOWN_TIMEOUT_MS", 5000, { min: 1, max: MAX_TIMER_DELAY_MS }),
   };
 }
 
@@ -276,7 +278,7 @@ export function parseAdapterProbeOptions(env = process.env) {
   return {
     adapterPort: integerEnv(env, "ADAPTER_PORT", 2026, { min: 1, max: 65535 }),
     adapterHost: String(env.ADAPTER_HOST || "127.0.0.1").trim() || "127.0.0.1",
-    existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1 }),
+    existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1, max: MAX_TIMER_DELAY_MS }),
   };
 }
 

package/src/copilot-token-session.mjs

@@ -60,6 +60,20 @@ function refreshError(message, { statusCode, transient = false } = {}) {
   return error;
 }
 
+function transientRefreshError(error) {
+  let message = "Copilot token request failed";
+  try {
+    if (typeof error?.message === "string" && error.message) message = error.message;
+  } catch {}
+  const wrapped = new Error(message, { cause: error });
+  try {
+    if (typeof error?.code === "string") wrapped.code = error.code;
+    if (Number.isInteger(error?.statusCode)) wrapped.statusCode = error.statusCode;
+  } catch {}
+  wrapped.transient = true;
+  return wrapped;
+}
+
 function copilotProfileLabel(profile) {
   if (profile === "codex") return "Copilot";
   const name = String(profile || "profile");
@@ -189,6 +203,7 @@ export function createCopilotTokenSession({
     allowAccountSwitch = false,
   }) {
     if (!data.token) throw new Error("Copilot token response missing token field");
+    const nextApiBase = parseApiBase(data);
     const fingerprint = githubTokenFingerprint(githubToken);
     const normalizedIdentity = normalizeGithubIdentity(identity);
     const tokenChanged = Boolean(githubFingerprint && fingerprint !== githubFingerprint);
@@ -204,7 +219,7 @@ export function createCopilotTokenSession({
       throw error;
     }
     copilotToken = data.token;
-    apiBase = parseApiBase(data);
+    apiBase = nextApiBase;
     copilotTokenExpiry = typeof data.expires_at === "number"
       ? data.expires_at * 1000
       : Date.now() + 25 * 60 * 1000;
@@ -232,7 +247,7 @@ export function createCopilotTokenSession({
         signal,
       }, { fetchImpl, ...tokenRetryOptions });
     } catch (error) {
-      if (!isAbortError(error, signal)) error.transient = true;
+      if (!isAbortError(error, signal)) throw transientRefreshError(error);
       throw error;
     }
     if (!response.ok) {