codex-copilot-dx 0.5.5 → 0.6.0

package/src/cli-options.mjs

@@ -7,6 +7,38 @@ function unexpectedArgs(args) {
   throw new Error(`Unexpected argument${args.length === 1 ? "" : "s"}: ${args.join(" ")}`);
 }
 
+function parseOptions(args, schema) {
+  const parsed = {};
+  const seen = new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const option = args[index];
+    const kind = schema.get(option);
+    if (!kind || seen.has(option)) unexpectedArgs([option]);
+    seen.add(option);
+    if (kind === "flag") {
+      parsed[option] = true;
+      continue;
+    }
+
+    const value = args[index + 1];
+    if (value === undefined || !String(value).trim() || String(value).startsWith("-")) {
+      throw new Error(`Missing value for ${option}`);
+    }
+    parsed[option] = value;
+    index += 1;
+  }
+  return parsed;
+}
+
+function checkedProfile(value, { allowAll = false } = {}) {
+  const profile = value || "codex";
+  const allowed = allowAll ? new Set(["codex", "claude", "all"]) : new Set(["codex", "claude"]);
+  if (!allowed.has(profile)) {
+    throw new Error(`Profile must be ${allowAll ? "codex, claude, or all" : "codex or claude"}: ${profile}`);
+  }
+  return profile;
+}
+
 export function parseCliArgs(args = []) {
   const [command, ...rest] = args;
   if (!command) return { command: "start", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
@@ -26,6 +58,56 @@ export function parseCliArgs(args = []) {
     if (rest.length) unexpectedArgs(rest);
     return { command: "usage", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
   }
+  if (command === "models") {
+    const options = parseOptions(rest, new Map([["--profile", "value"]]));
+    return {
+      command: "models",
+      configureClaudeDesktop: false,
+      showRequestId: false,
+      online: false,
+      compat: false,
+      profile: checkedProfile(options["--profile"]),
+    };
+  }
+  if (command === "auth") {
+    const [action, ...authArgs] = rest;
+    if (!action) throw new Error("Missing auth action: expected status or login");
+    if (action === "status") {
+      const options = parseOptions(authArgs, new Map([["--online", "flag"]]));
+      return {
+        command: "auth",
+        action: "status",
+        profile: "",
+        configureClaudeDesktop: false,
+        showRequestId: false,
+        online: Boolean(options["--online"]),
+        compat: false,
+        expectedLogin: "",
+        reauth: false,
+      };
+    }
+    if (action === "login") {
+      const [profile, ...loginArgs] = authArgs;
+      if (!profile) throw new Error("Missing auth login profile: expected claude");
+      if (profile !== "claude") throw new Error(`Auth login profile must be claude: ${profile}`);
+      const options = parseOptions(loginArgs, new Map([
+        ["--github-login", "value"],
+        ["--reauth", "flag"],
+      ]));
+      return {
+        command: "auth",
+        action: "login",
+        profile: "claude",
+        configureClaudeDesktop: false,
+        showRequestId: false,
+        online: false,
+        compat: false,
+        expectedLogin: options["--github-login"] || "",
+        reauth: Boolean(options["--reauth"]),
+      };
+    }
+    throw new Error(`Unknown auth action: ${action}`);
+  }
   if (command === "auto-review-model") {
     if (rest.length) unexpectedArgs(rest);
     return { command: "auto-review-model", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
@@ -46,18 +128,18 @@ export function parseCliArgs(args = []) {
     };
   }
   if (command === "doctor" || command === "--doctor") {
-    const supported = new Set(["--online", "--compat"]);
-    const invalid = rest.filter((arg) => !supported.has(arg));
-    if (invalid.length) unexpectedArgs(invalid);
-    for (const option of supported) {
-      if (rest.filter((arg) => arg === option).length > 1) unexpectedArgs([option]);
-    }
+    const options = parseOptions(rest, new Map([
+      ["--online", "flag"],
+      ["--compat", "flag"],
+      ["--profile", "value"],
+    ]));
     return {
       command: "doctor",
       configureClaudeDesktop: false,
       showRequestId: false,
-      online: rest.includes("--online"),
-      compat: rest.includes("--compat"),
+      online: Boolean(options["--online"]),
+      compat: Boolean(options["--compat"]),
+      profile: checkedProfile(options["--profile"], { allowAll: true }),
     };
   }
   if (START_OPTIONS.has(command)) {
@@ -123,8 +205,11 @@ export function cliHelp(commandName = "ccdx") {
   const alias = name === "ccdx" ? "codex-copilot-dx" : "ccdx";
   return `Usage:
   ${name} [--configure-claude-desktop] [--show-request-id]
-  ${name} doctor [--online] [--compat]
+  ${name} auth status [--online]
+  ${name} auth login claude [--github-login <login>] [--reauth]
+  ${name} doctor [--online] [--compat] [--profile codex|claude|all]
   ${name} status
+  ${name} models [--profile codex|claude]
   ${name} usage
   ${name} auto-review-model
   ${name} update [npm|github]

package/src/cli-status.mjs

@@ -51,6 +51,25 @@ function cacheHitRate(cache = {}) {
   return `${((hits / (hits + misses)) * 100).toFixed(1)}%`;
 }
 
+function profileSummary(label, profile = {}) {
+  const client = profile.client || {};
+  const models = profile.models || {};
+  const mode = ["legacy", "inherited", "isolated"].includes(profile.mode)
+    ? profile.mode
+    : "unknown";
+  const source = typeof models.source === "string" && models.source ? models.source : "unknown";
+  const token = client.token_cached
+    ? `token cached (${duration(client.token_expires_in_ms)} remaining)`
+    : "token not cached";
+  return `${label} ${mode}: ${token}, ${count(models.models)} total/${count(models.claude_models)} Claude models (${source})`;
+}
+
+function routingTarget(value) {
+  if (value === "codex") return "Codex";
+  if (value === "claude") return "Claude";
+  return "unknown";
+}
+
 export async function readAdapterStatus({
   host = "127.0.0.1",
   port = 2026,
@@ -107,7 +126,7 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
     ? status("ok", `Adapter ${data.version} is running at ${baseUrl} (PID ${data.pid}, uptime ${duration(data.uptime_ms)})`)
     : status("warn", `Adapter ${data.version} is running at ${baseUrl}, but this CLI is ${cliVersion}; stop the running adapter before switching versions`);
 
-  return [
+  const lines = [
     `${commandName} status`,
     adapterLine,
     status("info", `Requests: ${count(requests.completed)}/${count(requests.total)} completed, ${count(requests.active)} active, ${count(requests.status_4xx)} 4xx, ${count(requests.status_5xx)} 5xx, ${count(requests.aborted)} aborted`),
@@ -117,6 +136,13 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
     status("info", `History: ${mebibytes(history.bytes)} / ${mebibytes(limits.response_history_max_bytes)}, ${count(history.entries)} entries, ${count(history.evicted)} evicted`),
     status("info", `Image cache: ${count(images.cache_entries)} entries, ${cacheHitRate(images)} hits, ${mebibytes(images.cache_bytes)} / ${mebibytes(images.cache_max_bytes)}`),
     status("info", `Models: ${count(models.models)} total, ${count(models.claude_models)} Claude; Copilot token ${copilot.token_cached ? `cached (${duration(copilot.token_expires_in_ms)} remaining)` : "not cached"}`),
-    status("info", `Limits: request body ${mebibytes(limits.max_body_bytes)}, decoded body ${mebibytes(limits.max_decoded_body_bytes)}`),
-  ].join("\n");
+  ];
+  if (data.profiles?.codex || data.profiles?.claude) {
+    lines.push(status("info", `Profiles: ${profileSummary("Codex", data.profiles?.codex)}; ${profileSummary("Claude", data.profiles?.claude)}`));
+  }
+  if (data.routing) {
+    lines.push(status("info", `Routing: /v1/responses -> ${routingTarget(data.routing.responses)}; /v1/messages -> ${routingTarget(data.routing.messages)}`));
+  }
+  lines.push(status("info", `Limits: request body ${mebibytes(limits.max_body_bytes)}, decoded body ${mebibytes(limits.max_decoded_body_bytes)}`));
+  return lines.join("\n");
 }

package/src/copilot-client.mjs

@@ -0,0 +1,226 @@
+import { createCopilotTokenSession } from "./copilot-token-session.mjs";
+import { prepareResponsesPayload, summarizeReqBody } from "./image-optimization.mjs";
+import { debugLog } from "./log.mjs";
+import { enforceResponsesPayloadByteBudget } from "./responses-byte-budget.mjs";
+import { status } from "./status.mjs";
+import { withChatStreamUsage } from "./stream-contract.mjs";
+import { markUpstreamStarted } from "./stream-performance.mjs";
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  error.code = "ABORT_ERR";
+  return error;
+}
+
+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 createCopilotClientRuntime({
+  profile = "codex",
+  defaultApiBase,
+  parseApiBase,
+  fetchCopilotUpstream,
+  buildHeaders,
+  getVSCodeVersion,
+  computeInitiator,
+  computeVision,
+  responsesEndpointPath,
+  ...sessionOptions
+} = {}) {
+  const tokenSession = createCopilotTokenSession({
+    ...sessionOptions,
+    profile,
+    defaultApiBase,
+    parseApiBase,
+    fetchCopilotUpstream,
+  });
+  let modelEndpointCache = new Map();
+  const modelListFlights = new Map();
+
+  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;
+  }
+
+  function getCachedModelEndpoints(modelId) {
+    return modelEndpointCache.get(String(modelId || "").trim()) || null;
+  }
+
+  function resetModelEndpointCacheForTests() {
+    modelEndpointCache.clear();
+  }
+
+  async function chatCompletions(chatReq, {
+    signal,
+    fetchImpl,
+    retryOptions,
+    bodyText,
+  } = {}) {
+    const token = await tokenSession.getToken({ 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(`${tokenSession.getApiBase()}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: serializedBody,
+      signal,
+    }, { fetchImpl, ...retryOptions });
+  }
+
+  async function fetchModels({ signal, fetchImpl, retryOptions }) {
+    const token = await tokenSession.getToken({ signal });
+    const headers = buildHeaders({ token, version: getVSCodeVersion(), initiator: "user", vision: false });
+    const response = await fetchCopilotUpstream(`${tokenSession.getApiBase()}/models`, {
+      headers,
+      signal,
+    }, { fetchImpl, ...retryOptions });
+    const body = await response.text();
+    if (response.ok) {
+      try { cacheModelEndpoints(JSON.parse(body)); } catch {}
+    }
+    return { status: response.status, body };
+  }
+
+  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);
+  }
+
+  function resetModelListSingleflightForTests() {
+    for (const flight of modelListFlights.values()) flight.controller.abort();
+    modelListFlights.clear();
+  }
+
+  async function responses(reqBody, {
+    signal,
+    fetchImpl,
+    retryOptions,
+    currentInputStart = 0,
+    payloadPrepared = false,
+    payloadOptions = {},
+  } = {}) {
+    const token = await tokenSession.getToken({ 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";
+    try {
+      if (reqBody.stream === true) markUpstreamStarted();
+      return await fetchCopilotUpstream(`${tokenSession.getApiBase()}${responsesEndpointPath()}`, {
+        method: "POST",
+        headers,
+        body: bodyText,
+        signal,
+      }, { fetchImpl, ...retryOptions });
+    } catch (error) {
+      const cause = error?.cause;
+      const causeText = cause ? ` (${[cause.code, cause.message].filter(Boolean).join(": ")})` : "";
+      throw new Error(`Copilot responses fetch failed: ${error.message}${causeText}`);
+    }
+  }
+
+  function responsesCompact(reqBody, options = {}) {
+    return responses(reqBody, options);
+  }
+
+  function runtimeStatus(now = Date.now()) {
+    return {
+      ...tokenSession.runtimeStatus(now),
+      model_endpoint_cache_entries: modelEndpointCache.size,
+      model_list_flights: modelListFlights.size,
+    };
+  }
+
+  function resetForTests() {
+    tokenSession.resetForTests();
+    resetModelEndpointCacheForTests();
+    resetModelListSingleflightForTests();
+  }
+
+  return Object.freeze({
+    profile,
+    cacheModelEndpoints,
+    getCachedModelEndpoints,
+    resetModelEndpointCacheForTests,
+    getApiBase: tokenSession.getApiBase,
+    runtimeStatus,
+    getCopilotToken: tokenSession.getToken,
+    resetTokenForTests: tokenSession.resetForTests,
+    chatCompletions,
+    listModels,
+    resetModelListSingleflightForTests,
+    responses,
+    responsesCompact,
+    resetForTests,
+  });
+}