codex-copilot-dx 0.4.44 → 0.5.2

package/README.md

@@ -12,7 +12,7 @@ A single in-process adapter (port `2026`) exposes both APIs over your Copilot su
 
 Supports both HTTP SSE streaming and non-streaming.
 
-Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adapter maps it to Copilot's `gpt-5.5` Responses model by default and logs both model IDs when the mapping is used.
+Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adapter maps it to Copilot's `gpt-5.5` Responses model by default and logs both model IDs when the mapping is used. The target can be changed interactively without reinstalling the package.
 
 ## Prerequisites
 
@@ -30,6 +30,42 @@ ccdx
 The shorter `ccdx` command is the primary launcher. The existing `codex-copilot-dx`
 command remains an equivalent compatibility alias. For a one-off run without a
 global install, use `npx codex-copilot-dx@latest`.
+Both installed commands expose the same options and subcommands; help, version,
+doctor, status, and argument-error output use the command name that was invoked.
+
+To change the model used by Codex Auto-review, run:
+
+```bash
+ccdx auto-review-model
+```
+
+The selector reads the current adapter model list, falling back to the fresh local
+model cache, and offers only enabled models that advertise a Responses endpoint.
+It saves the selection in `~/.config/codex-copilot-dx/config.json` (or under
+`XDG_CONFIG_HOME` when set); choosing `gpt-5.5` clears the override and restores
+the package default. A running 0.5.1+
+adapter reads the setting on the next Auto-review request, so it does not need to
+be restarted. `codex-copilot-dx auto-review-model` is fully equivalent.
+
+To update the globally installed package, choose a source interactively:
+
+```bash
+ccdx update
+```
+
+For scripts or a direct choice, pass the source explicitly:
+
+```bash
+ccdx update npm
+ccdx update github
+```
+
+The npm source installs `codex-copilot-dx@latest` through the registry already
+configured for npm, including a company mirror. The GitHub source installs the
+latest commit from `DaleXiao/codex-copilot-dx` `main`. Both paths use npm's
+global installer without shell interpolation. A currently running adapter keeps
+its loaded version until it is stopped and started again. The
+`codex-copilot-dx update` compatibility command behaves identically.
 
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
@@ -75,7 +111,15 @@ ccdx doctor --compat
 
 The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
 
-For live runtime diagnostics, query the running adapter from the same machine:
+For a read-only summary of the running adapter, use:
+
+```bash
+ccdx status
+```
+
+The compatibility alias supports the same command as
+`codex-copilot-dx status`. For the complete machine-readable payload, query the
+loopback endpoint directly:
 
 ```bash
 curl -s http://127.0.0.1:2026/_ccdx/status | jq
@@ -135,7 +179,7 @@ Environment variables:
 | `CCDX_STREAM_IDLE_TIMEOUT_MS` | `120000` | Maximum idle time between upstream streaming body chunks |
 | `CCDX_UPSTREAM_RETRIES` | `2` | Retries for safe requests and clearly pre-connect POST failures; capped at `5` |
 | `CCDX_UPSTREAM_RETRY_DELAY_MS` | `300` | Initial upstream retry backoff in milliseconds; capped at `5000` |
-| `CCDX_AUTO_REVIEW_MODEL` | `gpt-5.5` | Copilot Responses model used for Codex Auto-review requests |
+| `CCDX_AUTO_REVIEW_MODEL` | saved selection or `gpt-5.5` | Copilot Responses model used for Codex Auto-review requests; overrides the interactive selection |
 | `CCDX_LOG_PATH` | unset | Mirror terminal logs to a file; set to `1` for `~/.local/share/codex-copilot-dx/debug.log` |
 | `CCDX_LOG_LEVEL` | `info` | Set to `debug` to include upstream request attempts, status codes, retry causes, and timings |
 | `CCDX_LOG_MAX_BYTES` | `16777216` | Rotate the debug log at this size, retaining one `.1` backup; set to `0` to disable rotation |

package/bin/cli.mjs

@@ -16,23 +16,27 @@ import { adapterBaseUrl, checkRunningAdapter } from "../src/running-adapter.mjs"
 import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
 import { isValidModelList, loadModelCache, saveModelCache } from "../src/model-cache.mjs";
 import { initializeModelRegistry, runInBackground } from "../src/startup.mjs";
-import { cliHelp, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
+import { cliCommandName, cliHelp, parseAdapterProbeOptions, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
+import { formatAdapterStatus, readAdapterStatus } from "../src/cli-status.mjs";
 import { closeHttpServer } from "../src/shutdown.mjs";
+import { runAutoReviewModelCommand } from "../src/auto-review-model.mjs";
+import { autoReviewModelPreference } from "../src/user-settings.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
-const CLI_BANNER = `codex-copilot-dx v${LOCAL_VERSION} by Dale Xiao`;
+const CLI_NAME = cliCommandName();
+const CLI_BANNER = `${CLI_NAME} v${LOCAL_VERSION} by Dale Xiao`;
 
 let CLI;
 try {
   CLI = parseCliArgs(process.argv.slice(2));
 } catch (e) {
   console.error(e.message);
-  console.error("Run ccdx --help for usage.");
+  console.error(`Run ${CLI_NAME} --help for usage.`);
   process.exit(2);
 }
 
 if (CLI.command === "help") {
-  console.log(cliHelp());
+  console.log(cliHelp(CLI_NAME));
   process.exit(0);
 }
 if (CLI.command === "version") {
@@ -43,6 +47,46 @@ if (CLI.command === "usage") {
   await printUsageSummary();
   process.exit(0);
 }
+if (CLI.command === "status") {
+  let probe;
+  try {
+    probe = parseAdapterProbeOptions(process.env);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(2);
+  }
+  try {
+    const snapshot = await readAdapterStatus({
+      host: probe.adapterHost,
+      port: probe.adapterPort,
+      timeoutMs: probe.existingAdapterTimeoutMs,
+    });
+    console.log(formatAdapterStatus(snapshot, { commandName: CLI_NAME, cliVersion: LOCAL_VERSION }));
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
+if (CLI.command === "auto-review-model") {
+  try {
+    await runAutoReviewModelCommand({ commandName: CLI_NAME });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
+if (CLI.command === "update") {
+  try {
+    const { runPackageUpdateCommand } = await import("../src/package-update.mjs");
+    await runPackageUpdateCommand({ commandName: CLI_NAME, source: CLI.updateSource });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
 
 let RUNTIME;
 try {
@@ -105,9 +149,11 @@ async function refreshClaudeDesktopModelDefs() {
       throw new Error(`Copilot models returned HTTP ${httpStatus}`);
     }
     const models = JSON.parse(body);
-    const autoReview = codexAutoReviewModelStatus(models);
+    const autoReview = codexAutoReviewModelStatus(models, process.env, {
+      autoReviewModel: autoReviewModelPreference().model,
+    });
     if (!autoReview.available) {
-      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run ccdx doctor --compat to verify the live path.`));
+      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run ${CLI_NAME} doctor --compat to verify the live path.`));
     }
     const gptModelIds = gptModelIdsFromCopilotModels(models);
     if (gptModelIds.length) {
@@ -169,7 +215,7 @@ async function reuseRunningAdapterIfAvailable() {
   });
   if (running.incompatible) {
     const found = running.data?.version || "unknown";
-    throw new Error(`Adapter ${found} is already running at ${running.baseUrl}, but this CLI is ${LOCAL_VERSION}. Stop the existing process and run ccdx again.`);
+    throw new Error(`Adapter ${found} is already running at ${running.baseUrl}, but this CLI is ${LOCAL_VERSION}. Stop the existing process and run ${CLI_NAME} again.`);
   }
   if (!running.ok) return false;
 
@@ -206,6 +252,7 @@ async function reuseRunningAdapterIfAvailable() {
 
 if (CLI.command === "doctor") {
   const checks = await runDoctor({
+    commandName: CLI_NAME,
     port: ADAPTER_PORT,
     host: ADAPTER_HOST,
     online: CLI.online,
@@ -268,6 +315,7 @@ try {
   activeServer = await startAdapter(ADAPTER_PORT, ADAPTER_HOST, {
     claudeDesktopApiKey,
     claudeDesktopModelDefs,
+    autoReviewModelResolver: () => autoReviewModelPreference().model,
     modelRegistry: MODEL_REGISTRY,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,

package/bin/codex-copilot-dx.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./cli.mjs";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.44",
+  "version": "0.5.2",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
   "bin": {
     "ccdx": "bin/cli.mjs",
-    "codex-copilot-dx": "bin/cli.mjs"
+    "codex-copilot-dx": "bin/codex-copilot-dx.mjs"
   },
   "files": [
     "bin/",

package/src/adapter.mjs

@@ -106,6 +106,7 @@ export function createAdapterHandler(options = {}) {
   };
   const responsesHandler = createResponsesHandler({
     acquireRequest,
+    autoReviewModelResolver: options.autoReviewModelResolver,
     chatCompletionsFn,
     openAIModelEnv,
     responsesPayloadOptions: options.responsesPayloadOptions,
@@ -116,6 +117,7 @@ export function createAdapterHandler(options = {}) {
   });
   const responsesCompactHandler = createResponsesCompactHandler({
     acquireRequest,
+    autoReviewModelResolver: options.autoReviewModelResolver,
     openAIModelEnv,
     responsesCompactFn,
     streamHandshakeTimeoutMs,

package/src/auto-review-model.mjs

@@ -0,0 +1,141 @@
+import os from "node:os";
+import { createInterface } from "node:readline/promises";
+import { loadModelCache } from "./model-cache.mjs";
+import {
+  DEFAULT_CODEX_AUTO_REVIEW_MODEL,
+  responsesModelIdsFromCopilotModels,
+} from "./models.mjs";
+import { parseAdapterProbeOptions } from "./cli-options.mjs";
+import { adapterBaseUrl } from "./running-adapter.mjs";
+import {
+  autoReviewModelPreference,
+  readUserSettings,
+  writeAutoReviewModel,
+} from "./user-settings.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;
+}
+
+function sortedModelIds(modelIds, currentModel) {
+  return [...modelIds].sort((left, right) => {
+    const leftRank = left === currentModel ? 0 : left === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? 1 : 2;
+    const rightRank = right === currentModel ? 0 : right === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? 1 : 2;
+    return leftRank - rightRank || left.localeCompare(right);
+  });
+}
+
+export async function loadAutoReviewModelCatalog({
+  env = process.env,
+  fetchImpl = fetch,
+  home = os.homedir(),
+  loadModelCacheFn = loadModelCache,
+} = {}) {
+  const { adapterHost, adapterPort } = parseAdapterProbeOptions(env);
+  const url = `${adapterBaseUrl(adapterHost, adapterPort)}/v1/models`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), modelFetchTimeout(env));
+  let liveError = "adapter is not running";
+  try {
+    const response = await fetchImpl(url, {
+      headers: { Accept: "application/json" },
+      redirect: "error",
+      signal: ctrl.signal,
+    });
+    if (!response.ok) {
+      liveError = `adapter returned HTTP ${response.status}`;
+    } else {
+      const models = await response.json();
+      const modelIds = responsesModelIdsFromCopilotModels(models);
+      if (modelIds.length) {
+        const fallback = response.headers.get("X-CCDX-Model-Source") === "last-known-good";
+        return { modelIds, source: fallback ? "running adapter cache" : "running adapter" };
+      }
+      liveError = "adapter returned no selectable Responses models";
+    }
+  } catch (error) {
+    liveError = ctrl.signal.aborted
+      ? `adapter model lookup timed out after ${modelFetchTimeout(env)}ms`
+      : error?.message || String(error);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  const cached = loadModelCacheFn({ home });
+  const modelIds = responsesModelIdsFromCopilotModels(cached);
+  if (modelIds.length) return { modelIds, source: "local model cache" };
+  throw new Error(`No selectable Responses models are available (${liveError}). Start ccdx once to refresh the model list.`);
+}
+
+export async function runAutoReviewModelCommand({
+  commandName = "ccdx",
+  env = process.env,
+  fetchImpl = fetch,
+  home = os.homedir(),
+  input = process.stdin,
+  loadCatalog = loadAutoReviewModelCatalog,
+  output = process.stdout,
+  prompt,
+} = {}) {
+  if (!prompt && (!input.isTTY || !output.isTTY)) {
+    throw new Error(`${commandName} auto-review-model requires an interactive terminal`);
+  }
+
+  readUserSettings({ env, home, strict: true });
+  const current = autoReviewModelPreference({ env, home });
+  const catalog = await loadCatalog({ env, fetchImpl, home });
+  const modelIds = sortedModelIds(catalog.modelIds, current.model);
+  if (!modelIds.length) throw new Error("No selectable Responses models are available");
+
+  output.write(`${commandName} auto-review-model\n`);
+  output.write(`Current: ${current.model} (${current.source})\n`);
+  output.write(`Responses models from ${catalog.source}:\n`);
+  modelIds.forEach((model, index) => {
+    const markers = [];
+    if (model === current.model) markers.push("current");
+    if (model === DEFAULT_CODEX_AUTO_REVIEW_MODEL) markers.push("default");
+    output.write(`  ${index + 1}. ${model}${markers.length ? ` [${markers.join(", ")}]` : ""}\n`);
+  });
+
+  let defaultIndex = modelIds.indexOf(current.model);
+  if (defaultIndex < 0) defaultIndex = modelIds.indexOf(DEFAULT_CODEX_AUTO_REVIEW_MODEL);
+  if (defaultIndex < 0) defaultIndex = 0;
+
+  let readline;
+  const ask = prompt || (async (question) => {
+    readline ||= createInterface({ input, output });
+    return readline.question(question);
+  });
+
+  let selectedModel;
+  try {
+    while (!selectedModel) {
+      const answer = String(await ask(`Select a model [${defaultIndex + 1}], or q to cancel: `) || "").trim();
+      if (answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") {
+        output.write("No changes made.\n");
+        return { changed: false, cancelled: true, model: current.model };
+      }
+      const selectedIndex = answer === "" ? defaultIndex : Number(answer) - 1;
+      if (Number.isInteger(selectedIndex) && selectedIndex >= 0 && selectedIndex < modelIds.length) {
+        selectedModel = modelIds[selectedIndex];
+      } else {
+        output.write(`Enter a number from 1 to ${modelIds.length}, or q to cancel.\n`);
+      }
+    }
+  } finally {
+    readline?.close();
+  }
+
+  const savedModel = selectedModel === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? "" : selectedModel;
+  const result = writeAutoReviewModel(savedModel, { env, home });
+  output.write(`${result.changed ? "Saved" : "Kept"} Auto Review model: ${selectedModel}\n`);
+  if (String(env.CCDX_AUTO_REVIEW_MODEL || "").trim()) {
+    output.write(`CCDX_AUTO_REVIEW_MODEL=${current.model} remains the effective override until it is unset.\n`);
+  } else {
+    output.write("The running 0.5.1+ adapter will use this model on the next Auto Review request.\n");
+  }
+  return { ...result, cancelled: false, model: selectedModel };
+}

package/src/cli-options.mjs

@@ -1,6 +1,7 @@
 const HELP_COMMANDS = new Set(["help", "--help", "-h"]);
 const VERSION_COMMANDS = new Set(["version", "--version", "-v"]);
 const START_OPTIONS = new Set(["--configure-claude-desktop", "--show-request-id"]);
+const CLI_COMMANDS = new Set(["ccdx", "codex-copilot-dx"]);
 
 function unexpectedArgs(args) {
   throw new Error(`Unexpected argument${args.length === 1 ? "" : "s"}: ${args.join(" ")}`);
@@ -17,10 +18,33 @@ export function parseCliArgs(args = []) {
     if (rest.length) unexpectedArgs(rest);
     return { command: "version", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
   }
+  if (command === "status" || command === "--status") {
+    if (rest.length) unexpectedArgs(rest);
+    return { command: "status", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
+  }
   if (command === "usage") {
     if (rest.length) unexpectedArgs(rest);
     return { command: "usage", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
   }
+  if (command === "auto-review-model") {
+    if (rest.length) unexpectedArgs(rest);
+    return { command: "auto-review-model", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
+  }
+  if (command === "update") {
+    if (rest.length > 1) unexpectedArgs(rest.slice(1));
+    const source = rest[0];
+    if (source && !new Set(["npm", "github", "gh"]).has(source)) {
+      throw new Error(`Update source must be npm or github: ${source}`);
+    }
+    return {
+      command: "update",
+      configureClaudeDesktop: false,
+      showRequestId: false,
+      online: false,
+      compat: false,
+      updateSource: source === "gh" ? "github" : source,
+    };
+  }
   if (command === "doctor" || command === "--doctor") {
     const supported = new Set(["--online", "--compat"]);
     const invalid = rest.filter((arg) => !supported.has(arg));
@@ -80,13 +104,32 @@ export function parseRuntimeOptions(env = process.env) {
   };
 }
 
-export function cliHelp() {
+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 }),
+  };
+}
+
+export function cliCommandName(executable = process.argv[1]) {
+  const name = String(executable || "").split(/[\\/]/).pop();
+  if (name === "codex-copilot-dx.mjs") return "codex-copilot-dx";
+  return CLI_COMMANDS.has(name) ? name : "ccdx";
+}
+
+export function cliHelp(commandName = "ccdx") {
+  const name = CLI_COMMANDS.has(commandName) ? commandName : "ccdx";
+  const alias = name === "ccdx" ? "codex-copilot-dx" : "ccdx";
   return `Usage:
-  ccdx [--configure-claude-desktop] [--show-request-id]
-  ccdx doctor [--online] [--compat]
-  ccdx usage
-  ccdx --version
-  ccdx --help
+  ${name} [--configure-claude-desktop] [--show-request-id]
+  ${name} doctor [--online] [--compat]
+  ${name} status
+  ${name} usage
+  ${name} auto-review-model
+  ${name} update [npm|github]
+  ${name} --version
+  ${name} --help
 
-Compatibility alias: codex-copilot-dx`;
+Equivalent command: ${alias}`;
 }

package/src/cli-status.mjs

@@ -0,0 +1,122 @@
+import { ADAPTER_STATUS_PATH, adapterBaseUrl } from "./running-adapter.mjs";
+import { status } from "./status.mjs";
+
+function finiteNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function count(value) {
+  const number = finiteNumber(value);
+  return number === null ? "n/a" : String(Math.max(0, Math.round(number)));
+}
+
+function duration(value) {
+  const milliseconds = finiteNumber(value);
+  if (milliseconds === null) return "n/a";
+  const seconds = Math.max(0, Math.round(milliseconds / 1000));
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainder = seconds % 60;
+  if (days) return `${days}d ${hours}h`;
+  if (hours) return `${hours}h ${minutes}m`;
+  if (minutes) return `${minutes}m ${remainder}s`;
+  return `${remainder}s`;
+}
+
+function latency(value) {
+  const milliseconds = finiteNumber(value);
+  if (milliseconds === null) return "n/a";
+  if (milliseconds >= 1000) return `${(milliseconds / 1000).toFixed(2)}s`;
+  return `${milliseconds.toFixed(1)}ms`;
+}
+
+function mebibytes(value) {
+  const bytes = finiteNumber(value);
+  return bytes === null ? "n/a" : `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+}
+
+function tpot(metric) {
+  const average = finiteNumber(metric?.avg);
+  if (average === null) return "n/a";
+  const milliseconds = metric?.unit === "us" ? average / 1000 : average;
+  return `${milliseconds.toFixed(2)}ms/token`;
+}
+
+function cacheHitRate(cache = {}) {
+  const hits = finiteNumber(cache.cache_hits);
+  const misses = finiteNumber(cache.cache_misses);
+  if (hits === null || misses === null || hits + misses <= 0) return "n/a";
+  return `${((hits / (hits + misses)) * 100).toFixed(1)}%`;
+}
+
+export async function readAdapterStatus({
+  host = "127.0.0.1",
+  port = 2026,
+  timeoutMs = 500,
+  fetchImpl = fetch,
+} = {}) {
+  const baseUrl = adapterBaseUrl(host, port);
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(`${baseUrl}${ADAPTER_STATUS_PATH}`, {
+      headers: { Accept: "application/json" },
+      redirect: "error",
+      signal: ctrl.signal,
+    });
+    if (!response.ok) throw new Error(`returned HTTP ${response.status}`);
+
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new Error("returned invalid JSON");
+    }
+    if (data?.ok !== true
+      || data?.name !== "codex-copilot-dx"
+      || typeof data.version !== "string"
+      || !Number.isInteger(data.pid)) {
+      throw new Error("returned an incompatible status payload");
+    }
+    return { baseUrl, data };
+  } catch (error) {
+    const reason = ctrl.signal.aborted
+      ? `timed out after ${timeoutMs}ms`
+      : error?.cause?.code === "ECONNREFUSED"
+        ? "adapter is not running"
+        : error?.message || String(error);
+    throw new Error(`Could not read adapter status at ${baseUrl}: ${reason}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", cliVersion = data.version } = {}) {
+  const requests = data.requests || {};
+  const performance = data.stream_performance?.by_route?.responses || {};
+  const admission = data.admission || {};
+  const history = data.response_history || {};
+  const images = data.image_optimization || {};
+  const models = data.models || {};
+  const copilot = data.copilot || {};
+  const limits = data.limits || {};
+  const processStats = data.process || {};
+  const adapterLine = data.version === cliVersion
+    ? 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 [
+    `${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`),
+    status("info", `Responses stream: TTFT avg ${latency(performance.ttft_ms?.avg)} (${count(performance.ttft_ms?.samples)} samples), TPOT avg ${tpot(performance.tpot_us)}`),
+    status("info", `Admission: ${count(admission.activeRequests)} active, ${count(admission.queued)} queued, ${count(admission.rejected)} rejected, ${count(admission.timedOut)} timed out, wait avg ${latency(admission.waitMsAvg)}`),
+    status("info", `Memory: RSS ${mebibytes(processStats.rss_bytes)}, heap ${mebibytes(processStats.heap_used_bytes)}`),
+    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");
+}

package/src/doctor.mjs

@@ -455,7 +455,7 @@ export async function collectDoctorChecks({
 export async function runDoctor(options = {}) {
   const log = options.log || console.log;
   const flags = [options.online ? "--online" : "", options.compat ? "--compat" : ""].filter(Boolean);
-  log(`ccdx doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
+  log(`${options.commandName || "ccdx"} doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
   const checks = await collectDoctorChecks(options);
   for (const check of checks) log(status(check.kind, check.message));
   return checks;

package/src/models.mjs

@@ -158,6 +158,17 @@ export function gptModelIdsFromCopilotModels(models) {
   });
 }
 
+export function responsesModelIdsFromCopilotModels(models) {
+  return uniqueIds(copilotModelData(models), (model) => {
+    const id = String(model?.id || "").trim();
+    const endpoints = modelEndpoints(model);
+    return id !== CODEX_AUTO_REVIEW_MODEL
+      && /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/.test(id)
+      && model?.model_picker_enabled !== false
+      && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
+  });
+}
+
 export function claudeDesktopModelDefsFromCopilotModels(models) {
   const data = copilotModelData(models);
 
@@ -212,21 +223,21 @@ export function resolveAnthropicModel(model, env = process.env, options = {}) {
   };
 }
 
-export function resolveOpenAIModel(model, env = process.env) {
+export function resolveOpenAIModel(model, env = process.env, options = {}) {
   const requestedModel = String(model || "");
   if (requestedModel !== CODEX_AUTO_REVIEW_MODEL) {
     return { requestedModel, upstreamModel: requestedModel };
   }
 
-  const configuredModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  const configuredModel = String(env.CCDX_AUTO_REVIEW_MODEL || options.autoReviewModel || "").trim();
   return {
     requestedModel,
     upstreamModel: configuredModel || DEFAULT_CODEX_AUTO_REVIEW_MODEL,
   };
 }
 
-export function codexAutoReviewModelStatus(models, env = process.env) {
-  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env);
+export function codexAutoReviewModelStatus(models, env = process.env, options = {}) {
+  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env, options);
   const model = copilotModelData(models).find((entry) => String(entry?.id || "").trim() === upstreamModel);
   if (!model) return { available: false, upstreamModel, reason: "model is not advertised" };
   const endpoints = modelEndpoints(model);

package/src/observability.mjs

@@ -1,11 +1,11 @@
 import { isIP } from "node:net";
-import { adapterHealthPayload } from "./running-adapter.mjs";
+import { ADAPTER_STATUS_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { copilotRuntimeStatus } from "./copilot.mjs";
 import { imageOptimizationStats } from "./image-optimization.mjs";
 import { responseHistoryStats } from "./response-history.mjs";
 import { loadRuntimeConfig } from "./runtime-config.mjs";
 
-export const ADAPTER_STATUS_PATH = "/_ccdx/status";
+export { ADAPTER_STATUS_PATH };
 const OBSERVABILITY_RUNTIME_CONFIG = loadRuntimeConfig();
 
 const ROUTE_NAMES = Object.freeze([

package/src/package-update.mjs

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+
+const PACKAGE_NAME = "codex-copilot-dx";
+const UPDATE_SPECS = {
+  npm: `${PACKAGE_NAME}@latest`,
+  github: "github:DaleXiao/codex-copilot-dx#main",
+};
+
+export function normalizeUpdateSource(value) {
+  const source = String(value || "").trim().toLowerCase();
+  if (source === "gh") return "github";
+  return Object.hasOwn(UPDATE_SPECS, source) ? source : "";
+}
+
+export function globalUpdateCommand(source, { platform = process.platform } = {}) {
+  const normalized = normalizeUpdateSource(source);
+  if (!normalized) throw new Error(`Update source must be npm or github: ${source}`);
+  return {
+    command: platform === "win32" ? "npm.cmd" : "npm",
+    args: ["install", "--global", UPDATE_SPECS[normalized]],
+    source: normalized,
+  };
+}
+
+function waitForExit(child) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (handler, value) => {
+      if (settled) return;
+      settled = true;
+      handler(value);
+    };
+    child.once("error", (error) => finish(reject, error));
+    child.once("exit", (code, signal) => {
+      if (signal) finish(reject, new Error(`npm update was interrupted by ${signal}`));
+      else if (code !== 0) finish(reject, new Error(`npm update exited with status ${code}`));
+      else finish(resolve);
+    });
+  });
+}
+
+export async function runPackageUpdateCommand({
+  commandName = "ccdx",
+  env = process.env,
+  input = process.stdin,
+  output = process.stdout,
+  platform = process.platform,
+  prompt,
+  source,
+  spawnImpl = spawn,
+} = {}) {
+  let selectedSource = normalizeUpdateSource(source);
+  if (source && !selectedSource) throw new Error(`Update source must be npm or github: ${source}`);
+
+  if (!selectedSource) {
+    if (!prompt && (!input.isTTY || !output.isTTY)) {
+      throw new Error(`Choose a source with ${commandName} update npm or ${commandName} update github`);
+    }
+
+    output.write(`${commandName} update\n`);
+    output.write("  1. npm registry [default]\n");
+    output.write("  2. GitHub main\n");
+
+    let readline;
+    const ask = prompt || (async (question) => {
+      readline ||= createInterface({ input, output });
+      return readline.question(question);
+    });
+    try {
+      while (!selectedSource) {
+        const answer = String(await ask("Select update source [1], or q to cancel: ") || "").trim().toLowerCase();
+        if (answer === "q" || answer === "quit") {
+          output.write("No changes made.\n");
+          return { cancelled: true, source: "" };
+        }
+        if (answer === "" || answer === "1" || answer === "npm") selectedSource = "npm";
+        else if (answer === "2" || answer === "github" || answer === "gh") selectedSource = "github";
+        else output.write("Enter 1 for npm, 2 for GitHub, or q to cancel.\n");
+      }
+    } finally {
+      readline?.close();
+    }
+  }
+
+  const update = globalUpdateCommand(selectedSource, { platform });
+  const sourceLabel = selectedSource === "npm" ? "npm registry" : "GitHub main";
+  output.write(`Updating ${PACKAGE_NAME} from ${sourceLabel}...\n`);
+  const child = spawnImpl(update.command, update.args, {
+    env,
+    shell: false,
+    stdio: "inherit",
+  });
+  await waitForExit(child);
+  output.write(`Updated ${PACKAGE_NAME} from ${sourceLabel}. Restart the running adapter to use the new version.\n`);
+  return { cancelled: false, source: selectedSource };
+}

package/src/responses-handler.mjs

@@ -66,9 +66,17 @@ function unsupportedCustomToolsError(model) {
   return error;
 }
 
+function resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver) {
+  const options = model === CODEX_AUTO_REVIEW_MODEL && typeof autoReviewModelResolver === "function"
+    ? { autoReviewModel: autoReviewModelResolver() }
+    : {};
+  return resolveOpenAIModel(model, openAIModelEnv, options);
+}
+
 export function createResponsesHandler(options) {
   const {
     acquireRequest,
+    autoReviewModelResolver,
     chatCompletionsFn,
     openAIModelEnv,
     responsesPayloadOptions,
@@ -91,7 +99,7 @@ export function createResponsesHandler(options) {
       const prepared = prepareResponsesRequest(parsed, { mutate: true });
       prepared.surface = "responses";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
+      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
@@ -186,6 +194,7 @@ export function createResponsesHandler(options) {
 export function createResponsesCompactHandler(options) {
   const {
     acquireRequest,
+    autoReviewModelResolver,
     openAIModelEnv,
     responsesCompactFn,
     upstreamTimeoutMs,
@@ -203,7 +212,7 @@ export function createResponsesCompactHandler(options) {
       );
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
+      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));

package/src/running-adapter.mjs

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { localPackageVersion } from "./version.mjs";
 
 export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
+export const ADAPTER_STATUS_PATH = "/_ccdx/status";
 export const ADAPTER_PROTOCOL_VERSION = 2;
 export const ADAPTER_VERSION = localPackageVersion();
 const ADAPTER_INSTANCE_ID = randomUUID();

package/src/user-settings.mjs

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
+
+const AUTO_REVIEW_MODEL_KEY = "auto_review_model";
+
+export function userSettingsPath({ env = process.env, home = os.homedir() } = {}) {
+  const xdgConfigHome = String(env.XDG_CONFIG_HOME || "").trim();
+  const configRoot = xdgConfigHome || path.join(home, ".config");
+  return path.join(configRoot, "codex-copilot-dx", "config.json");
+}
+
+function invalidSettings(filePath, reason) {
+  return new Error(`Invalid ccdx settings at ${filePath}: ${reason}`);
+}
+
+export function readUserSettings({ env = process.env, home = os.homedir(), strict = false } = {}) {
+  const filePath = userSettingsPath({ env, home });
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw invalidSettings(filePath, "expected a JSON object");
+    }
+    if (Object.hasOwn(parsed, AUTO_REVIEW_MODEL_KEY)) {
+      const value = parsed[AUTO_REVIEW_MODEL_KEY];
+      if (typeof value !== "string" || !value.trim()) {
+        throw invalidSettings(filePath, `${AUTO_REVIEW_MODEL_KEY} must be a non-empty string`);
+      }
+    }
+    return parsed;
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    if (strict) {
+      if (String(error?.message || "").startsWith("Invalid ccdx settings")) throw error;
+      throw invalidSettings(filePath, error?.message || String(error));
+    }
+    return {};
+  }
+}
+
+export function savedAutoReviewModel(options = {}) {
+  const settings = readUserSettings(options);
+  return String(settings[AUTO_REVIEW_MODEL_KEY] || "").trim();
+}
+
+export function autoReviewModelPreference({ env = process.env, home = os.homedir() } = {}) {
+  const environmentModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  if (environmentModel) return { model: environmentModel, source: "environment" };
+
+  const savedModel = savedAutoReviewModel({ env, home });
+  if (savedModel) return { model: savedModel, source: "settings" };
+  return { model: DEFAULT_CODEX_AUTO_REVIEW_MODEL, source: "default" };
+}
+
+export function writeAutoReviewModel(model, { env = process.env, home = os.homedir() } = {}) {
+  const filePath = userSettingsPath({ env, home });
+  const settings = readUserSettings({ env, home, strict: true });
+  const value = String(model || "").trim();
+  const next = { ...settings };
+  if (value) next[AUTO_REVIEW_MODEL_KEY] = value;
+  else delete next[AUTO_REVIEW_MODEL_KEY];
+
+  const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };
+}