codex-copilot-dx 0.5.5 → 0.6.0

package/src/copilot.mjs

@@ -1,26 +1,7 @@
-import fs from "node:fs";
-import os from "node:os";
 import { randomUUID } from "node:crypto";
 import { status } from "./status.mjs";
 import { debugLog } from "./log.mjs";
-import {
-  fetchGithubIdentity,
-  githubReauthMessage,
-  githubTokenPath,
-  importDiscoveredGithubToken,
-  readGithubTokenMetadata,
-  writeGithubTokenMetadata,
-} from "./auth.mjs";
-import {
-  githubIdentitiesEqual,
-  githubIdentityLabel,
-  githubTokenFingerprint,
-  normalizeGithubIdentity,
-} from "./github-identity.mjs";
-import { prepareResponsesPayload, summarizeReqBody } from "./image-optimization.mjs";
-import { enforceResponsesPayloadByteBudget } from "./responses-byte-budget.mjs";
-import { withChatStreamUsage } from "./stream-contract.mjs";
-import { markUpstreamStarted } from "./stream-performance.mjs";
+import { createCopilotClientRuntime } from "./copilot-client.mjs";
 
 export {
   optimizeImageDataUrl,
@@ -33,35 +14,6 @@ export {
 } from "./image-optimization.mjs";
 
 export const DEFAULT_API_BASE = "https://api.githubcopilot.com";
-let apiBase = DEFAULT_API_BASE;
-
-// Cache of model id -> supported_endpoints, populated from listModels(). Used to
-// route requests to /responses vs /chat/completions based on real model metadata.
-let modelEndpointCache = new Map();
-
-export function cacheModelEndpoints(models) {
-  const data = Array.isArray(models) ? models : models?.data;
-  if (!Array.isArray(data)) return false;
-  const next = new Map();
-  for (const model of data) {
-    const id = String(model?.id || "").trim();
-    if (id && Array.isArray(model?.supported_endpoints)) {
-      next.set(id, [...model.supported_endpoints]);
-    }
-  }
-  if (!next.size) return false;
-  modelEndpointCache = next;
-  return true;
-}
-
-// Returns the cached supported_endpoints for a model id, or null if unknown.
-export function getCachedModelEndpoints(modelId) {
-  return modelEndpointCache.get(String(modelId || "").trim()) || null;
-}
-
-export function resetModelEndpointCacheForTests() {
-  modelEndpointCache.clear();
-}
 const DEFAULT_UPSTREAM_RETRIES = 2;
 const MAX_UPSTREAM_RETRIES = 5;
 const DEFAULT_UPSTREAM_RETRY_DELAY_MS = 300;
@@ -85,14 +37,9 @@ export function parseApiBase(data) {
     : DEFAULT_API_BASE;
 }
 
-export function getApiBase() {
-  return apiBase;
-}
-
 export function responsesEndpointPath() {
   return "/responses";
 }
-const GITHUB_API = "https://api.github.com";
 const RETRYABLE_UPSTREAM_ERROR_CODES = new Set([
   "UND_ERR_CONNECT_TIMEOUT",
   "UND_ERR_HEADERS_TIMEOUT",
@@ -292,359 +239,70 @@ export async function refreshVSCodeVersion() {
   return cachedVersion;
 }
 
-let copilotToken = null;
-let copilotTokenExpiry = 0;
-let copilotTokenRefresh = null;
-let copilotTokenSourceKey = null;
-let copilotTokenGithubFingerprint = "";
-let copilotTokenGithubIdentity = null;
-let copilotTokenRefreshRetryAt = 0;
-const modelListFlights = new Map();
+// Stateful Copilot data lives inside per-profile clients. These module-level
+// wrappers preserve every existing export as the default Codex compatibility
+// layer while allowing the adapter to use isolated Codex and Claude clients.
+export function createCopilotClient(options = {}) {
+  return createCopilotClientRuntime({
+    ...options,
+    defaultApiBase: DEFAULT_API_BASE,
+    parseApiBase,
+    fetchCopilotUpstream,
+    buildHeaders,
+    getVSCodeVersion,
+    computeInitiator,
+    computeVision,
+    responsesEndpointPath,
+  });
+}
 
-export function copilotRuntimeStatus(now = Date.now()) {
-  let upstreamHost = "unknown";
-  try { upstreamHost = new URL(apiBase).hostname; } catch {}
-  return {
-    token_cached: Boolean(copilotToken),
-    token_expires_in_ms: copilotToken ? Math.max(0, copilotTokenExpiry - now) : null,
-    token_refresh_in_flight: Boolean(copilotTokenRefresh),
-    token_refresh_backoff_ms: Math.max(0, copilotTokenRefreshRetryAt - now),
-    account_bound: Boolean(copilotTokenGithubIdentity),
-    upstream_host: upstreamHost,
-    model_endpoint_cache_entries: modelEndpointCache.size,
-    model_list_flights: modelListFlights.size,
-  };
+export const defaultCopilotClient = createCopilotClient({ profile: "codex" });
+
+export function cacheModelEndpoints(models) {
+  return defaultCopilotClient.cacheModelEndpoints(models);
 }
 
-function getGithubToken({ home = os.homedir() } = {}) {
-  const GITHUB_TOKEN_PATH = githubTokenPath(home);
-  if (!fs.existsSync(GITHUB_TOKEN_PATH)) {
-    throw new Error("GitHub token not found. Run ccdx again to log in.");
-  }
-  const token = fs.readFileSync(GITHUB_TOKEN_PATH, "utf-8").trim();
-  if (!token) throw new Error(githubReauthMessage("GitHub token file is empty."));
-  return token;
-}
-
-function requestCopilotToken(ghToken, { fetchImpl = fetch, signal, retryOptions } = {}) {
-  return fetchCopilotUpstream(`${GITHUB_API}/copilot_internal/v2/token`, {
-    headers: { Authorization: `token ${ghToken}`, Accept: "application/json" },
-    signal,
-  }, { fetchImpl, ...retryOptions });
-}
-
-function cacheCopilotTokenData(data, {
-  sourceKey,
-  githubToken,
-  githubIdentity,
-  allowAccountSwitch = false,
-} = {}) {
-  if (!data.token) throw new Error("Copilot token response missing token field");
-  const fingerprint = githubTokenFingerprint(githubToken);
-  const identity = normalizeGithubIdentity(githubIdentity);
-  const tokenChanged = Boolean(copilotTokenGithubFingerprint && fingerprint !== copilotTokenGithubFingerprint);
-  if (!allowAccountSwitch && copilotTokenGithubIdentity && identity
-    && !githubIdentitiesEqual(copilotTokenGithubIdentity, identity)) {
-    throw new Error(`Refusing to switch GitHub Copilot account from ${githubIdentityLabel(copilotTokenGithubIdentity)} to ${githubIdentityLabel(identity)} while the adapter is running. Restart ccdx to switch accounts intentionally.`);
-  }
-  if (!allowAccountSwitch && copilotTokenGithubIdentity && tokenChanged && !identity) {
-    const error = new Error("The saved GitHub token changed, but its account could not be verified. Keeping the running adapter bound to the existing GitHub account.");
-    error.transient = true;
-    throw error;
-  }
-  copilotToken = data.token;
-  apiBase = parseApiBase(data);
-  copilotTokenExpiry = typeof data.expires_at === "number"
-    ? data.expires_at * 1000
-    : Date.now() + 25 * 60 * 1000; // fallback if expires_at absent: refresh in ~25min
-  copilotTokenSourceKey = sourceKey || copilotTokenSourceKey;
-  copilotTokenGithubFingerprint = fingerprint;
-  if (identity) copilotTokenGithubIdentity = identity;
-  copilotTokenRefreshRetryAt = 0;
-  console.log(status("ok", "Copilot token refreshed"));
-  return copilotToken;
-}
-
-async function githubIdentityForToken(token, { home, fetchImpl, signal }) {
-  const cached = readGithubTokenMetadata(home, token);
-  if (cached) return cached;
-  const identity = await fetchGithubIdentity(token, { fetchImpl, signal });
-  return identity.ok ? identity : null;
-}
-
-function tokenRefreshError(message, { statusCode, transient = false } = {}) {
-  const error = new Error(message);
-  if (statusCode) error.statusCode = statusCode;
-  if (transient) error.transient = true;
-  return error;
-}
-
-async function refreshCopilotToken({
-  signal,
-  home = os.homedir(),
-  env = process.env,
-  fetchImpl = fetch,
-  tokenRetryOptions,
-} = {}) {
-  const ghToken = getGithubToken({ home });
-  const sourceKey = githubTokenPath(home);
-  let resp;
-  try {
-    resp = await requestCopilotToken(ghToken, {
-      fetchImpl,
-      signal,
-      retryOptions: tokenRetryOptions,
-    });
-  } catch (e) {
-    if (!isAbortError(e, signal)) e.transient = true;
-    throw e;
-  }
-  if (!resp.ok) {
-    if (resp.status === 401 || resp.status === 403) {
-      const imported = await importDiscoveredGithubToken({
-        home,
-        env,
-        fetchImpl,
-        signal,
-        excludeTokens: [ghToken],
-        validateSavedToken: true,
-      });
-      if (imported?.validation?.copilotTokenData?.token) {
-        const explicitSource = imported.source?.type === "env" || imported.source?.type === "token-file";
-        return cacheCopilotTokenData(imported.validation.copilotTokenData, {
-          sourceKey,
-          githubToken: imported.token,
-          githubIdentity: imported.validation,
-          allowAccountSwitch: explicitSource,
-        });
-      }
-      throw new Error(githubReauthMessage(`Failed to get Copilot token: ${resp.status}. The saved GitHub token may be expired, revoked, or missing Copilot access.`));
-    }
-    throw tokenRefreshError(`Failed to get Copilot token: ${resp.status}`, {
-      statusCode: resp.status,
-      transient: resp.status === 408 || resp.status === 425 || resp.status === 429 || resp.status >= 500,
-    });
-  }
-  const data = await resp.json();
-  const identity = await githubIdentityForToken(ghToken, { home, fetchImpl, signal });
-  const token = cacheCopilotTokenData(data, {
-    sourceKey,
-    githubToken: ghToken,
-    githubIdentity: identity,
-  });
-  if (identity) writeGithubTokenMetadata(identity, home, ghToken);
-  return token;
+export function getCachedModelEndpoints(modelId) {
+  return defaultCopilotClient.getCachedModelEndpoints(modelId);
 }
 
-function canUseCachedToken(sourceKey, now = Date.now(), allowCurrentProcessToken = false) {
-  const sameSource = copilotTokenSourceKey === sourceKey || allowCurrentProcessToken;
-  return Boolean(copilotToken && sameSource && now < copilotTokenExpiry);
+export function resetModelEndpointCacheForTests() {
+  return defaultCopilotClient.resetModelEndpointCacheForTests();
 }
 
-export function getCopilotToken(options = {}) {
-  const home = options.home || os.homedir();
-  const sourceKey = githubTokenPath(home);
-  const now = Date.now();
-  const allowCurrentProcessToken = options.home === undefined;
-  if (canUseCachedToken(sourceKey, now, allowCurrentProcessToken) && now < copilotTokenExpiry - 60000) {
-    return Promise.resolve(copilotToken);
-  }
-  if (canUseCachedToken(sourceKey, now, allowCurrentProcessToken) && now < copilotTokenRefreshRetryAt) {
-    return Promise.resolve(copilotToken);
-  }
-  if (options.signal?.aborted) return Promise.reject(abortError(options.signal));
+export function getApiBase() {
+  return defaultCopilotClient.getApiBase();
+}
 
-  let flight = copilotTokenRefresh?.key === sourceKey ? copilotTokenRefresh : null;
-  if (flight?.controller.signal.aborted) {
-    if (copilotTokenRefresh === flight) copilotTokenRefresh = null;
-    flight = null;
-  }
+export function copilotRuntimeStatus(now = Date.now()) {
+  return defaultCopilotClient.runtimeStatus(now);
+}
 
-  if (!flight) {
-    const controller = new AbortController();
-    const tokenRetryOptions = options.tokenRetryOptions
-      ?? (canUseCachedToken(sourceKey, now, allowCurrentProcessToken) ? { retries: 0 } : undefined);
-    flight = { key: sourceKey, controller, waiters: 0, settled: false, promise: null };
-    flight.promise = refreshCopilotToken({
-      ...options,
-      home,
-      signal: controller.signal,
-      tokenRetryOptions,
-    })
-      .catch((error) => {
-        const fallbackNow = Date.now();
-        if (error?.transient && canUseCachedToken(sourceKey, fallbackNow)) {
-          copilotTokenRefreshRetryAt = Math.min(copilotTokenExpiry, fallbackNow + 5000);
-          console.warn(status("warn", `Copilot token refresh failed temporarily; using the existing token until ${new Date(copilotTokenExpiry).toISOString()} (${error.message})`));
-          return copilotToken;
-        }
-        throw error;
-      })
-      .finally(() => {
-        flight.settled = true;
-        if (copilotTokenRefresh === flight) copilotTokenRefresh = null;
-      });
-    copilotTokenRefresh = flight;
-  }
-  return waitForSingleflight(flight, options.signal);
+export function getCopilotToken(options = {}) {
+  return defaultCopilotClient.getCopilotToken(options);
 }
 
 export function resetCopilotTokenForTests() {
-  copilotTokenRefresh?.controller.abort();
-  copilotToken = null;
-  copilotTokenExpiry = 0;
-  copilotTokenRefresh = null;
-  copilotTokenSourceKey = null;
-  copilotTokenGithubFingerprint = "";
-  copilotTokenGithubIdentity = null;
-  copilotTokenRefreshRetryAt = 0;
-  apiBase = DEFAULT_API_BASE;
-  resetModelListSingleflightForTests();
-}
-
-// chatReq is already converted by the adapter. The caller parses the raw Response.
-export async function chatCompletions(chatReq, {
-  signal,
-  fetchImpl,
-  retryOptions,
-  bodyText,
-} = {}) {
-  const token = await getCopilotToken({ signal });
-  const upstreamReq = chatReq.stream === true ? withChatStreamUsage(chatReq) : chatReq;
-  const messages = upstreamReq.messages || [];
-  const serializedBody = typeof bodyText === "string" && upstreamReq === chatReq
-    ? bodyText
-    : JSON.stringify(upstreamReq);
-  const headers = buildHeaders({
-    token,
-    version: getVSCodeVersion(),
-    initiator: computeInitiator(messages),
-    vision: computeVision(messages),
-  });
-  headers["Content-Length"] = String(Buffer.byteLength(serializedBody));
-  if (upstreamReq.stream === true) markUpstreamStarted();
-  return fetchCopilotUpstream(`${getApiBase()}/chat/completions`, {
-    method: "POST",
-    headers,
-    body: serializedBody,
-    signal,
-  }, { fetchImpl, ...retryOptions });
-}
-
-async function fetchModels({ signal, fetchImpl, retryOptions }) {
-  const token = await getCopilotToken({ signal });
-  const headers = buildHeaders({
-    token, version: getVSCodeVersion(), initiator: "user", vision: false,
-  });
-  const resp = await fetchCopilotUpstream(`${getApiBase()}/models`, { headers, signal }, { fetchImpl, ...retryOptions });
-  const body = await resp.text();
-  if (resp.ok) {
-    try { cacheModelEndpoints(JSON.parse(body)); } catch {}
-  }
-  return { status: resp.status, body };
+  defaultCopilotClient.resetTokenForTests();
+  defaultCopilotClient.resetModelListSingleflightForTests();
 }
 
-function waitForSingleflight(flight, signal) {
-  if (signal?.aborted) return Promise.reject(abortError(signal));
-  flight.waiters += 1;
-
-  return new Promise((resolve, reject) => {
-    let finished = false;
-    const finish = (handler, value) => {
-      if (finished) return;
-      finished = true;
-      signal?.removeEventListener("abort", onAbort);
-      flight.waiters -= 1;
-      if (!flight.settled && flight.waiters === 0) flight.controller.abort();
-      handler(value);
-    };
-    const onAbort = () => finish(reject, abortError(signal));
-    signal?.addEventListener("abort", onAbort, { once: true });
-    if (signal?.aborted) onAbort();
-    flight.promise.then(
-      (value) => finish(resolve, value),
-      (error) => finish(reject, error),
-    );
-  });
+export function chatCompletions(chatReq, options = {}) {
+  return defaultCopilotClient.chatCompletions(chatReq, options);
 }
 
-export function listModels({ signal, fetchImpl = fetch, retryOptions } = {}) {
-  if (signal?.aborted) return Promise.reject(abortError(signal));
-  let flight = modelListFlights.get(fetchImpl);
-  if (flight?.controller.signal.aborted) {
-    modelListFlights.delete(fetchImpl);
-    flight = null;
-  }
-
-  if (!flight) {
-    const controller = new AbortController();
-    flight = { controller, waiters: 0, settled: false, promise: null };
-    flight.promise = fetchModels({ signal: controller.signal, fetchImpl, retryOptions })
-      .finally(() => {
-        flight.settled = true;
-        if (modelListFlights.get(fetchImpl) === flight) modelListFlights.delete(fetchImpl);
-      });
-    modelListFlights.set(fetchImpl, flight);
-  }
-
-  return waitForSingleflight(flight, signal);
+export function listModels(options = {}) {
+  return defaultCopilotClient.listModels(options);
 }
 
 export function resetModelListSingleflightForTests() {
-  for (const flight of modelListFlights.values()) flight.controller.abort();
-  modelListFlights.clear();
-}
-
-// Responses-only models go directly to Copilot's /responses endpoint.
-export async function responses(reqBody, {
-  signal,
-  fetchImpl,
-  retryOptions,
-  currentInputStart = 0,
-  payloadPrepared = false,
-  payloadOptions = {},
-} = {}) {
-  const token = await getCopilotToken({ signal });
-  const preparedPayload = await prepareResponsesPayload(reqBody, {
-    ...payloadOptions,
-    currentInputStart,
-    profiles: payloadPrepared ? [] : payloadOptions.profiles,
-    skipInitialOptimization: payloadPrepared || payloadOptions.skipInitialOptimization,
-    signal,
-  });
-  const finalizedPayload = enforceResponsesPayloadByteBudget(reqBody, preparedPayload);
-  const { bodyText, bodyBytes, stage, adapted } = finalizedPayload;
-  const summary = finalizedPayload.stage === preparedPayload.stage
-    ? preparedPayload.summary
-    : summarizeReqBody(reqBody);
-  console.log(status("info", `responses payload bytes=${bodyBytes} input_items=${summary.items} images=${summary.images}`));
-  if (adapted) debugLog(`responses payload adapted stage=${stage} bytes=${bodyBytes}/${preparedPayload.targetBytes}`);
-  const headers = buildHeaders({
-    token,
-    version: getVSCodeVersion(),
-    initiator: "user",
-    vision: false,
-  });
-  headers["Content-Type"] = "application/json; charset=utf-8";
-  headers["Content-Length"] = String(bodyBytes);
-  headers["Accept"] = reqBody.stream ? "text/event-stream" : "application/json";
+  return defaultCopilotClient.resetModelListSingleflightForTests();
+}
 
-  try {
-    if (reqBody.stream === true) markUpstreamStarted();
-    return await fetchCopilotUpstream(`${getApiBase()}${responsesEndpointPath()}`, {
-      method: "POST",
-      headers,
-      body: bodyText,
-      signal,
-    }, { fetchImpl, ...retryOptions });
-  } catch (e) {
-    const cause = e?.cause;
-    const causeText = cause ? ` (${[cause.code, cause.message].filter(Boolean).join(": ")})` : "";
-    throw new Error(`Copilot responses fetch failed: ${e.message}${causeText}`);
-  }
+export function responses(reqBody, options = {}) {
+  return defaultCopilotClient.responses(reqBody, options);
 }
 
-export async function responsesCompact(reqBody, options = {}) {
-  // GitHub Copilot accepts Codex compact payloads on the regular Responses endpoint.
-  return responses(reqBody, options);
+export function responsesCompact(reqBody, options = {}) {
+  return defaultCopilotClient.responsesCompact(reqBody, options);
 }