codex-copilot-dx 0.6.21 → 0.7.1

package/src/adapter.mjs

@@ -1,8 +1,6 @@
 import http from "node:http";
-import { createAnthropicCountTokensHandler, createAnthropicMessagesHandler } from "./anthropic-handler.mjs";
 import { defaultCopilotClient } from "./copilot.mjs";
 import { isValidModelList } from "./model-cache.mjs";
-import { claudeDesktopModelsResponse } from "./models.mjs";
 import {
   ADAPTER_STATUS_PATH,
   classifyAdapterRoute,
@@ -11,11 +9,9 @@ import {
   runtimeStatusPayload,
 } from "./observability.mjs";
 import { createRequestId, runWithRequestContext } from "./request-context.mjs";
-import { createPmStudioRelayHandler, PM_STUDIO_RELAY_PREFIX } from "./pm-studio-relay.mjs";
 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";
@@ -63,17 +59,19 @@ export function requestPath(reqUrl) {
   return new URL(reqUrl || "/", "http://localhost").pathname;
 }
 
-function bearerToken(headers = {}) {
-  const value = headers.authorization || headers.Authorization || "";
-  const match = /^Bearer\s+(.+)$/i.exec(String(value));
-  return match?.[1]?.trim() || "";
-}
-
-export function shouldServeClaudeDesktopModels(req, claudeDesktopApiKey) {
-  if (!claudeDesktopApiKey || claudeDesktopApiKey === "dummy") return false;
-  const token = bearerToken(req.headers);
-  const xApiKey = req.headers?.["x-api-key"] || req.headers?.["X-Api-Key"] || req.headers?.["X-API-Key"] || "";
-  return token === claudeDesktopApiKey || xApiKey === claudeDesktopApiKey;
+function sendRetiredClaudeSurface(res) {
+  res.writeHead(410, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store",
+  });
+  res.end(JSON.stringify({
+    type: "error",
+    error: {
+      type: "not_found_error",
+      code: "ccdx_claude_retired",
+      message: "Claude App and Claude Code support was retired in ccdx 0.7.0.",
+    },
+  }));
 }
 
 function modelListCanUseLastKnownGood(statusCode) {
@@ -93,50 +91,18 @@ function sendLastKnownGoodModels(res, modelRegistry) {
 // Shared request handler. Keeping this separate from the listener makes the
 // complete HTTP routing layer testable without opening a local port.
 export function createAdapterHandler(options = {}) {
-  const claudeDesktopApiKey = options.claudeDesktopApiKey
-    || process.env.CCDX_CLAUDE_DESKTOP_API_KEY
-    || process.env.CCDX_PROXY_API_KEY
-    || "";
   const codexClient = options.codexClient || defaultCopilotClient;
-  const hasExplicitClaudeMode = Object.hasOwn(options, "claudeMode");
-  if (hasExplicitClaudeMode && !["inherited", "isolated"].includes(options.claudeMode)) {
-    throw new Error(`Unsupported Claude mode: ${options.claudeMode}`);
-  }
-  if (options.claudeMode === "isolated"
-    && (!options.claudeClient || options.claudeClient === codexClient)) {
-    throw new Error("Isolated Claude mode requires a distinct Claude client");
-  }
-  if (options.claudeMode === "inherited"
-    && options.claudeClient && options.claudeClient !== codexClient) {
-    throw new Error("Inherited Claude mode requires the Codex client");
-  }
-  const claudeClient = options.claudeClient || codexClient;
-  // chatCompletionsFn is retained as a compatibility injection and continues to
-  // override both surfaces in existing tests and embedders. New dual-profile
-  // callers should pass codexClient/claudeClient instead.
-  const codexChatCompletionsFn = options.codexChatCompletionsFn
+  // Keep the established injection names because Responses may still use the
+  // internal Chat Completions compatibility path for upstream models that need it.
+  const chatCompletionsFn = options.codexChatCompletionsFn
     || options.chatCompletionsFn
     || codexClient.chatCompletions;
-  const claudeChatCompletionsFn = options.claudeChatCompletionsFn
-    || options.chatCompletionsFn
-    || claudeClient.chatCompletions;
   const responsesFn = options.responsesFn || codexClient.responses;
   const responsesCompactFn = options.responsesCompactFn || codexClient.responsesCompact;
   const listModelsFn = options.listModelsFn || codexClient.listModels;
   const getCachedModelEndpointsFn = options.getCachedModelEndpointsFn
     || codexClient.getCachedModelEndpoints;
-  const claudeMode = hasExplicitClaudeMode
-    ? options.claudeMode
-    : claudeClient === codexClient ? "inherited" : "isolated";
-  if (claudeMode === "isolated" && options.chatCompletionsFn) {
-    throw new Error("Isolated Claude mode cannot use the shared chatCompletionsFn override; pass codexChatCompletionsFn or claudeChatCompletionsFn explicitly");
-  }
   const codexModelRegistry = options.codexModelRegistry || options.modelRegistry;
-  const claudeModelRegistry = options.claudeModelRegistry || options.modelRegistry || codexModelRegistry;
-  if (claudeMode === "isolated"
-    && (!options.claudeModelRegistry || claudeModelRegistry === codexModelRegistry)) {
-    throw new Error("Isolated Claude mode requires a distinct Claude model registry");
-  }
   const openAIModelEnv = options.openAIModelEnv || process.env;
   const upstreamTimeoutMs = parsePositiveInteger(options.upstreamTimeoutMs, ADAPTER_RUNTIME_CONFIG.upstreamTimeoutMs);
   const streamHandshakeTimeoutMs = parsePositiveInteger(options.streamHandshakeTimeoutMs, ADAPTER_RUNTIME_CONFIG.streamHandshakeTimeoutMs);
@@ -146,19 +112,10 @@ 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 } : {};
-  };
   const responsesHandler = createResponsesHandler({
     acquireRequest,
     autoReviewModelResolver: options.autoReviewModelResolver,
-    chatCompletionsFn: codexChatCompletionsFn,
+    chatCompletionsFn,
     getCachedModelEndpointsFn,
     imagePressure,
     modelRegistry: codexModelRegistry,
@@ -184,34 +141,6 @@ export function createAdapterHandler(options = {}) {
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
   });
-  const anthropicCountTokensHandler = createAnthropicCountTokensHandler({
-    acquireRequest,
-    requestBodyTimeoutMs,
-    countTokensFn: (body, countOptions) => tokenCounterService.count(body, countOptions),
-  });
-  const anthropicMessagesHandler = createAnthropicMessagesHandler({
-    acquireRequest,
-    chatCompletionsFn: claudeChatCompletionsFn,
-    environment: process.env,
-    modelOptions: claudeDesktopModelOptions,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  });
-  const pmStudioRelayHandler = createPmStudioRelayHandler({
-    acquireRequest,
-    claudeClient,
-    claudeMode,
-    claudeProfile: options.claudeProfile,
-    claudeModelRegistry,
-    fetchImpl: options.pmStudioFetchImpl,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  });
-
   const dispatch = (req, res, pathname) => {
     if (req.method === "GET" && pathname === ADAPTER_STATUS_PATH) {
       if (!isLoopbackAddress(req.socket?.remoteAddress)) {
@@ -227,11 +156,7 @@ export function createAdapterHandler(options = {}) {
         imagePressure,
         modelRegistry: codexModelRegistry,
         codexClient,
-        claudeClient,
         codexModelRegistry,
-        claudeModelRegistry,
-        claudeMode,
-        isClaudeProfileCurrent: options.isClaudeProfileCurrent,
       })));
       return;
     }
@@ -242,10 +167,6 @@ export function createAdapterHandler(options = {}) {
       return;
     }
 
-    if (pathname.startsWith(`${PM_STUDIO_RELAY_PREFIX}/`)) {
-      return pmStudioRelayHandler(req, res, pathname);
-    }
-
     if (req.method === "POST" && pathname === "/v1/responses") {
       return responsesHandler(req, res);
     }
@@ -255,11 +176,6 @@ export function createAdapterHandler(options = {}) {
     }
 
     if (req.method === "GET" && pathname === "/v1/models") {
-      if (shouldServeClaudeDesktopModels(req, claudeDesktopApiKey)) {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(claudeDesktopModelsResponse(process.env, claudeDesktopModelOptions())));
-        return;
-      }
       const abort = createRequestAbort(req, res);
       abort.setTimeout(upstreamTimeoutMs);
       listModelsFn({ signal: abort.signal })
@@ -296,11 +212,11 @@ export function createAdapterHandler(options = {}) {
     }
 
     if (req.method === "POST" && pathname === "/v1/messages/count_tokens") {
-      return anthropicCountTokensHandler(req, res);
+      return sendRetiredClaudeSurface(res);
     }
 
     if (req.method === "POST" && pathname === "/v1/messages") {
-      return anthropicMessagesHandler(req, res);
+      return sendRetiredClaudeSurface(res);
     }
 
     res.writeHead(404, { "Content-Type": "application/json" });
@@ -388,9 +304,6 @@ export function createAdapterHandler(options = {}) {
       containUnexpectedError(error);
     }
   };
-  handler.cleanup = () => {
-    if (ownsTokenCounterService) tokenCounterService.close();
-  };
   return handler;
 }
 
@@ -398,7 +311,9 @@ 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 terminalActivity = ownsTerminalActivity
+    ? createTerminalActivityIndicator({ theme: options.terminalAnimationTheme })
+    : options.terminalActivity;
   const handler = createAdapterHandler({ ...options, terminalActivity });
   const server = http.createServer(handler);
   const cleanupTerminalActivity = () => {

package/src/auth-profile.mjs

@@ -1,7 +1,5 @@
 import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
-import { atomicWriteFilePairSync, atomicWriteFileSync } from "./atomic-file.mjs";
 import {
   githubTokenLockPath,
   githubTokenMetadataPath,
@@ -11,172 +9,62 @@ import {
   githubTokenFingerprint,
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
-import { withFileLock } from "./lock.mjs";
-import { parseSafePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
 export const AUTH_PROFILE_CODEX = "codex";
-export const AUTH_PROFILE_CLAUDE = "claude";
-
-const AUTH_PROFILES = new Set([AUTH_PROFILE_CODEX, AUTH_PROFILE_CLAUDE]);
 
 function checkedProfile(profile) {
   const value = String(profile || "").trim().toLowerCase();
-  if (!AUTH_PROFILES.has(value)) throw new Error(`Unsupported authentication profile: ${profile}`);
+  if (value !== AUTH_PROFILE_CODEX) {
+    throw new Error(`Unsupported authentication profile: ${profile}`);
+  }
   return value;
 }
 
 export function authProfilePaths(profile, { home = os.homedir() } = {}) {
   const name = checkedProfile(profile);
-  if (name === AUTH_PROFILE_CODEX) {
-    return {
-      profile: name,
-      tokenPath: githubTokenPath(home),
-      metadataPath: githubTokenMetadataPath(home),
-      lockPath: githubTokenLockPath(home),
-    };
-  }
-
-  const directory = path.join(home, ".local", "share", "copilot-api", "profiles", AUTH_PROFILE_CLAUDE);
-  const tokenPath = path.join(directory, "github_token");
   return {
     profile: name,
-    tokenPath,
-    metadataPath: `${tokenPath}.account.json`,
-    lockPath: `${tokenPath}.lock`,
+    tokenPath: githubTokenPath(home),
+    metadataPath: githubTokenMetadataPath(home),
+    lockPath: githubTokenLockPath(home),
   };
 }
 
 function readOptionalFile(filePath) {
   try {
-    return { exists: true, data: fs.readFileSync(filePath), mode: fs.statSync(filePath).mode & 0o777 };
+    return { exists: true, data: fs.readFileSync(filePath) };
   } catch (error) {
-    if (error?.code === "ENOENT") return { exists: false, data: null, mode: 0o600 };
+    if (error?.code === "ENOENT") return { exists: false, data: null };
     throw error;
   }
 }
 
 function parsedMetadata(snapshot) {
-  if (!snapshot.exists) return { value: null, malformed: false };
+  if (!snapshot.exists) return null;
   try {
-    return { value: JSON.parse(snapshot.data.toString("utf8")), malformed: false };
+    return JSON.parse(snapshot.data.toString("utf8"));
   } catch {
-    return { value: null, malformed: true };
+    return null;
   }
 }
 
 export function readAuthProfileCredentials(profile, { home = os.homedir() } = {}) {
   const paths = authProfilePaths(profile, { home });
   const tokenSnapshot = readOptionalFile(paths.tokenPath);
-  const metadataSnapshot = readOptionalFile(paths.metadataPath);
   const token = tokenSnapshot.exists ? tokenSnapshot.data.toString("utf8").trim() : "";
-  const metadataResult = parsedMetadata(metadataSnapshot);
-  const metadataFingerprint = metadataResult.value?.token_fingerprint;
+  const metadata = parsedMetadata(readOptionalFile(paths.metadataPath));
   const metadataMatchesToken = Boolean(token)
-    && Boolean(metadataFingerprint)
-    && metadataFingerprint === githubTokenFingerprint(token);
-  const metadataIdentity = normalizeGithubIdentity(metadataResult.value);
-  const identity = metadataMatchesToken ? metadataIdentity : null;
-
-  if (paths.profile === AUTH_PROFILE_CODEX) {
-    const configured = tokenSnapshot.exists;
-    return {
-      profile: paths.profile,
-      configured,
-      valid: configured && Boolean(token),
-      reason: !configured ? "unconfigured" : token ? "" : "empty_token",
-      token,
-      identity,
-      metadata: metadataResult.value,
-      paths,
-    };
-  }
-
-  // Metadata is written last, but any credential artifact reserves the Claude
-  // profile. A partial write must fail closed instead of borrowing Codex.
-  const configured = metadataSnapshot.exists || tokenSnapshot.exists;
-  let reason = "";
-  if (!configured) reason = "unconfigured";
-  else if (!metadataSnapshot.exists) reason = "missing_metadata";
-  else if (metadataResult.malformed) reason = "metadata_malformed";
-  else if (!tokenSnapshot.exists) reason = "missing_token";
-  else if (!token) reason = "empty_token";
-  else if (!metadataIdentity) reason = "metadata_identity_missing";
-  else if (!metadataFingerprint || metadataFingerprint !== githubTokenFingerprint(token)) reason = "token_metadata_mismatch";
+    && Boolean(metadata?.token_fingerprint)
+    && metadata.token_fingerprint === githubTokenFingerprint(token);
 
   return {
     profile: paths.profile,
-    configured,
-    valid: configured && !reason,
-    reason,
+    configured: tokenSnapshot.exists,
+    valid: tokenSnapshot.exists && Boolean(token),
+    reason: !tokenSnapshot.exists ? "unconfigured" : token ? "" : "empty_token",
     token,
-    identity,
-    metadata: metadataResult.value,
-    paths,
-  };
-}
-
-function lockOptions(env = process.env) {
-  return {
-    timeoutMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
-    staleMs: parseSafePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
-  };
-}
-
-export function withAuthProfileLock(profile, fn, {
-  home = os.homedir(),
-  env = process.env,
-  ...options
-} = {}) {
-  const { lockPath } = authProfilePaths(profile, { home });
-  return withFileLock(lockPath, fn, { ...lockOptions(env), ...options });
-}
-
-export function writeClaudeAuthProfile(token, identity, {
-  home = os.homedir(),
-  now = () => new Date(),
-  writeFile = atomicWriteFileSync,
-  unlinkFile = fs.unlinkSync,
-} = {}) {
-  const cleanToken = String(token || "").trim();
-  const normalizedIdentity = normalizeGithubIdentity(identity);
-  if (!cleanToken) throw new Error("Claude GitHub token is empty");
-  if (!normalizedIdentity) throw new Error("Claude GitHub account identity is missing");
-
-  const paths = authProfilePaths(AUTH_PROFILE_CLAUDE, { home });
-  const directory = path.dirname(paths.tokenPath);
-  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-  fs.chmodSync(directory, 0o700);
-
-  const timestamp = now();
-  const updatedAt = timestamp instanceof Date ? timestamp.toISOString() : new Date(timestamp).toISOString();
-  const metadata = `${JSON.stringify({
-    profile: AUTH_PROFILE_CLAUDE,
-    ...normalizedIdentity,
-    token_fingerprint: githubTokenFingerprint(cleanToken),
-    updated_at: updatedAt,
-  }, null, 2)}\n`;
-
-  // Commit the activation marker last. Readers never observe a configured
-  // Claude profile unless the token and its fingerprint agree.
-  atomicWriteFilePairSync(
-    paths.tokenPath,
-    cleanToken,
-    paths.metadataPath,
+    identity: metadataMatchesToken ? normalizeGithubIdentity(metadata) : null,
     metadata,
-    { mode: 0o600, writeFile, unlinkFile },
-  );
-
-  return {
-    profile: AUTH_PROFILE_CLAUDE,
-    identity: normalizedIdentity,
     paths,
   };
 }
-
-export function profileReauthMessage(profile, { home = os.homedir() } = {}) {
-  const name = checkedProfile(profile);
-  if (name === AUTH_PROFILE_CLAUDE) {
-    return "Claude authentication is unavailable. Run `ccdx auth login claude --reauth`, then restart ccdx.";
-  }
-  return `Codex authentication is unavailable at ${authProfilePaths(name, { home }).tokenPath}. Run ccdx again to log in.`;
-}

package/src/cli-animation.mjs

@@ -0,0 +1,108 @@
+import os from "node:os";
+import { createInterface } from "node:readline/promises";
+import {
+  DEFAULT_TERMINAL_ANIMATION_THEME,
+  playTerminalAnimationPreview,
+  renderTerminalAnimationFrame,
+  TERMINAL_ANIMATION_THEMES,
+} from "./terminal-animation.mjs";
+import {
+  readUserSettings,
+  terminalAnimationPreference,
+  writeTerminalAnimationTheme,
+} from "./user-settings.mjs";
+
+const DISABLED_ENV_VALUES = new Set(["0", "false", "no", "off"]);
+
+function markers(theme, currentTheme) {
+  const values = [];
+  if (theme.id === DEFAULT_TERMINAL_ANIMATION_THEME) values.push("default");
+  if (theme.id === currentTheme) values.push("current");
+  return values.length ? ` [${values.join(", ")}]` : "";
+}
+
+function disabledEnvironmentValue(env) {
+  const value = String(env.CCDX_TERMINAL_ANIMATION || "").trim();
+  return DISABLED_ENV_VALUES.has(value.toLowerCase()) ? value : "";
+}
+
+export async function runAnimationCommand({
+  commandName = "ccdx",
+  env = process.env,
+  home = os.homedir(),
+  input = process.stdin,
+  output = process.stdout,
+  prompt,
+  preview = playTerminalAnimationPreview,
+} = {}) {
+  if (!prompt && (!input.isTTY || !output.isTTY)) {
+    throw new Error(`${commandName} animation requires an interactive terminal`);
+  }
+
+  readUserSettings({ env, home, strict: true });
+  const current = terminalAnimationPreference({ env, home });
+  const currentIndex = TERMINAL_ANIMATION_THEMES.findIndex(({ id }) => id === current.theme);
+
+  output.write(`${commandName} animation\n`);
+  output.write(`Current: ${TERMINAL_ANIMATION_THEMES[currentIndex].label} (${current.source})\n\n`);
+  TERMINAL_ANIMATION_THEMES.forEach((theme, index) => {
+    const staticPreview = theme.id === DEFAULT_TERMINAL_ANIMATION_THEME
+      ? `  ${renderTerminalAnimationFrame(theme.id, 10)}`
+      : "";
+    output.write(`  ${index + 1}. ${theme.label}${markers(theme, current.theme)}${staticPreview}\n`);
+  });
+
+  let readline;
+  const ask = prompt || (async (question) => {
+    readline ||= createInterface({ input, output });
+    return readline.question(question);
+  });
+
+  let selectedTheme = current.theme;
+  let keepCurrent = false;
+  try {
+    while (true) {
+      const answer = String(await ask(`Select [${currentIndex + 1}], or q to cancel: `) || "").trim();
+      if (answer.toLowerCase() === "q") {
+        output.write("No changes made.\n");
+        return { changed: false, cancelled: true, theme: current.theme };
+      }
+      if (answer === "") {
+        keepCurrent = true;
+        break;
+      }
+      const selectedIndex = Number(answer) - 1;
+      if (Number.isInteger(selectedIndex)
+          && selectedIndex >= 0
+          && selectedIndex < TERMINAL_ANIMATION_THEMES.length) {
+        selectedTheme = TERMINAL_ANIMATION_THEMES[selectedIndex].id;
+        break;
+      }
+      output.write(`Enter a number from 1 to ${TERMINAL_ANIMATION_THEMES.length}, or q to cancel.\n`);
+    }
+  } finally {
+    readline?.close();
+  }
+
+  const result = keepCurrent
+    ? { changed: false, theme: current.theme }
+    : writeTerminalAnimationTheme(selectedTheme, { env, home });
+  const disabledValue = disabledEnvironmentValue(env);
+  if (!disabledValue) {
+    try {
+      await preview(selectedTheme, { output });
+    } catch {
+      output.write("[WARN] Preview unavailable; the terminal animation setting was still applied.\n");
+    }
+  }
+
+  const selected = TERMINAL_ANIMATION_THEMES.find(({ id }) => id === selectedTheme);
+  output.write(`${result.changed ? "Saved" : "Kept"} terminal animation: ${selected.label}\n`);
+  if (disabledValue) {
+    output.write(`CCDX_TERMINAL_ANIMATION=${disabledValue} remains effective until it is unset; terminal animation stays disabled.\n`);
+    output.write("The saved animation will be used on the next ccdx start after the override is unset.\n");
+  } else {
+    output.write("The next ccdx start will use this animation.\n");
+  }
+  return { ...result, cancelled: false, theme: selectedTheme };
+}