codex-copilot-dx 0.4.34 → 0.4.36

package/README.md

@@ -70,7 +70,15 @@ To actively verify the protocol path through an already-running adapter, run:
 codex-copilot-dx doctor --compat
 ```
 
-The compatibility doctor sends a few minimal Copilot requests to check 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.
+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:
+
+```bash
+curl -s http://127.0.0.1:2026/_ccdx/status | jq
+```
+
+The status endpoint is restricted to the socket's real loopback address, even when LAN binding is explicitly enabled. It reports fixed-size request counters, latency totals, admission pressure, memory use, response-history size, image queue state, model cache counts, and token expiry state. It never includes prompts, completions, tool arguments, image content, account names, or token values. API responses and related log lines include the same safe `X-Request-Id`/`request_id` for correlation.
 
 When the saved token is missing, `codex-copilot-dx` first looks for compatible local Copilot GitHub tokens, validates them with GitHub and Copilot, and imports a valid one before starting device login. It checks explicit token sources (`CCDX_GITHUB_TOKEN`, `CCDX_GITHUB_TOKEN_PATH`, `CCDX_GITHUB_TOKEN_PATHS`) plus common local `auth.json` layouts under application config directories. It does not rely on a specific app name. Generic discovery refuses to choose silently when valid tokens for multiple GitHub accounts are found. After an account is selected, automatic `401`/`403` recovery and in-process token rotation accept only the same GitHub account. Concurrent callers share token refresh work without sharing cancellation, and a still-valid Copilot token may be used briefly after a transient refresh failure. Explicit token variables remain the intentional way to switch accounts.
 
@@ -110,12 +118,15 @@ Environment variables:
 | `CCDX_ALLOW_LAN` | unset | Set to `1` to allow non-loopback `ADAPTER_HOST` values such as `0.0.0.0`; exposes your Copilot-backed adapter beyond this machine |
 | `CCDX_MAX_BODY_BYTES` | `67108864` | Maximum compressed/raw request body size |
 | `CCDX_MAX_DECODED_BODY_BYTES` | `134217728` | Maximum decoded request body size after decompression |
+| `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Shared byte budget for admitted request bodies; a larger single request runs exclusively |
+| `CCDX_MAX_QUEUED_REQUESTS` | `16` | Maximum body requests waiting for the shared byte budget |
+| `CCDX_REQUEST_QUEUE_TIMEOUT_MS` | `120000` | Maximum wait for request-body admission before returning `503` |
 | `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Responses body target; larger image payloads are compressed more aggressively before forwarding |
 | `CCDX_MAX_SSE_BUFFER_BYTES` | `8388608` | Maximum buffered bytes for one unterminated upstream SSE line/event |
 | `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
 | `CCDX_STREAM_HANDSHAKE_TIMEOUT_MS` | `120000` | Timeout while waiting for upstream streaming response headers |
 | `CCDX_STREAM_IDLE_TIMEOUT_MS` | `120000` | Maximum idle time between upstream streaming body chunks |
-| `CCDX_UPSTREAM_RETRIES` | `2` | Retries for transient Copilot upstream network errors; capped at `5` |
+| `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_LOG_PATH` | unset | Mirror terminal logs to a file; set to `1` for `~/.local/share/codex-copilot-dx/debug.log` |
@@ -178,4 +189,4 @@ npm run verify
 npm run bench:payload
 ```
 
-`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` is a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.
+`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.

package/bin/cli.mjs

@@ -6,13 +6,13 @@ import { ensureClaudeConfig } from "../src/claude-config.mjs";
 import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey, loadManagedClaudeDesktopApiKey } from "../src/claude-desktop-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
 import { cacheModelEndpoints, listModels, refreshVSCodeVersion } from "../src/copilot.mjs";
-import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.mjs";
+import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, codexAutoReviewModelStatus, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.mjs";
 import { status } from "../src/status.mjs";
 import { configureLogging } from "../src/log.mjs";
 import { flushUsageWrites, printUsageSummary } from "../src/usage.mjs";
 import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 import { runDoctor } from "../src/doctor.mjs";
-import { checkRunningAdapter } from "../src/running-adapter.mjs";
+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";
@@ -105,6 +105,10 @@ async function refreshClaudeDesktopModelDefs() {
       throw new Error(`Copilot models returned HTTP ${httpStatus}`);
     }
     const models = JSON.parse(body);
+    const autoReview = codexAutoReviewModelStatus(models);
+    if (!autoReview.available) {
+      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run codex-copilot-dx doctor --compat to verify the live path.`));
+    }
     const gptModelIds = gptModelIdsFromCopilotModels(models);
     if (gptModelIds.length) {
       console.log(status("ok", `Refreshed GPT models from GitHub Copilot: ${gptModelIds.join(", ")}`));
@@ -152,8 +156,8 @@ async function reuseRunningAdapterIfAvailable() {
   if (!running.ok) return false;
 
   console.log(status("ok", `Using existing adapter at ${running.baseUrl}`));
-  ensureCodexConfig(ADAPTER_PORT);
-  ensureClaudeConfig(ADAPTER_PORT);
+  ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
+  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
 
   if (CONFIGURE_CLAUDE_DESKTOP) {
     const claudeDesktopApiKey = currentClaudeDesktopApiKey();
@@ -252,8 +256,8 @@ try {
   });
 
   // Point Codex and Claude Code at the adapter.
-  ensureCodexConfig(ADAPTER_PORT);
-  ensureClaudeConfig(ADAPTER_PORT);
+  ensureCodexConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
+  ensureClaudeConfig(ADAPTER_PORT, { host: ADAPTER_HOST });
   if (CONFIGURE_CLAUDE_DESKTOP) {
     const result = applyClaudeDesktopConfig({
       port: ADAPTER_PORT,
@@ -283,7 +287,7 @@ try {
   console.log(`
   ${status("ok", "Ready, Claude Code, Claude App and Codex App are now ready to use")}
 
-  Adapter: http://${ADAPTER_HOST}:${ADAPTER_PORT}
+  Adapter: ${adapterBaseUrl(ADAPTER_HOST, ADAPTER_PORT)}
 
   Press Ctrl+C to stop.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.34",
+  "version": "0.4.36",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
@@ -44,8 +44,9 @@
     "test:e2e": "bash test/e2e.sh",
     "bench": "node scripts/benchmark.mjs",
     "bench:payload": "node scripts/benchmark.mjs --large-payload",
+    "bench:check": "node scripts/benchmark.mjs --check",
     "pack:check": "npm pack --dry-run --json",
-    "verify": "npm test && npm run test:smoke && npm run pack:check",
+    "verify": "npm test && npm run test:smoke && npm run bench:check && npm run pack:check",
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {

package/scripts/benchmark.mjs

@@ -72,12 +72,14 @@ function largePayloadProbe(targetMiB, concurrency) {
     const result = runProbe(`
       import fs from "node:fs";
       import { prepareResponsesRequest } from "./src/adapter.mjs";
-      import { readJsonBody } from "./src/http-transport.mjs";
+      import { createRequestAdmission, readJsonBody } from "./src/http-transport.mjs";
       import { prepareResponsesPayload } from "./src/image-optimization.mjs";
 
       const fixtureFiles = ${JSON.stringify(fixtureFiles)};
+      const acquireRequest = createRequestAdmission();
       const memoryFields = ["rss", "heapUsed", "external", "arrayBuffers"];
       const peak = {};
+      let admissionMaxActiveBytes = 0;
       const sample = () => {
         const memory = process.memoryUsage();
         for (const field of memoryFields) peak[field] = Math.max(peak[field] || 0, memory[field] || 0);
@@ -90,15 +92,23 @@ function largePayloadProbe(targetMiB, concurrency) {
 
       async function processRequest(filePath) {
         const inputBytes = fs.statSync(filePath).size;
+        const headers = { "content-length": String(inputBytes), "content-encoding": "identity" };
+        const releaseRequest = await acquireRequest({ headers });
+        admissionMaxActiveBytes = Math.max(admissionMaxActiveBytes, acquireRequest.stats().activeBytes);
         const req = fs.createReadStream(filePath);
-        req.headers = { "content-length": String(inputBytes), "content-encoding": "identity" };
-        const parsed = await readJsonBody(req);
-        req.destroy();
-        sample();
-        const prepared = prepareResponsesRequest(parsed, { mutate: true });
-        const result = await prepareResponsesPayload(prepared.body);
-        sample();
-        return { inputBytes, outputBytes: result.bodyBytes };
+        req.headers = headers;
+        try {
+          const parsed = await readJsonBody(req);
+          req.destroy();
+          sample();
+          const prepared = prepareResponsesRequest(parsed, { mutate: true });
+          const result = await prepareResponsesPayload(prepared.body);
+          sample();
+          return { inputBytes, outputBytes: result.bodyBytes };
+        } finally {
+          req.destroy();
+          releaseRequest();
+        }
       }
 
       const originalLog = console.log;
@@ -130,6 +140,8 @@ function largePayloadProbe(targetMiB, concurrency) {
         input_body_mib: results.map((entry) => mib(entry.inputBytes)),
         output_body_mib: results.map((entry) => mib(entry.outputBytes)),
         output_body_kib: results.map((entry) => +(entry.outputBytes / 1024).toFixed(1)),
+        admission_max_active_mib: mib(admissionMaxActiveBytes),
+        admission_budget_mib: mib(acquireRequest.stats().maxBytes),
         memory,
       }));
     `);
@@ -140,6 +152,30 @@ function largePayloadProbe(targetMiB, concurrency) {
   }
 }
 
+function largeTokenCountProbe(mode) {
+  return runProbe(`
+    const text = "a ".repeat(2 * 1024 * 1024);
+    const started = performance.now();
+    let tokens;
+    if (${JSON.stringify(mode)} === "proxy") {
+      const { countTokens } = await import("./src/anthropic.mjs");
+      tokens = (await countTokens({ messages: [{ role: "user", content: text }] })).input_tokens;
+    } else {
+      const { encode } = await import("gpt-tokenizer");
+      const encoded = encode(text);
+      tokens = encoded.length;
+    }
+    const memory = process.memoryUsage();
+    process.stdout.write(JSON.stringify({
+      input_mib: +(Buffer.byteLength(text) / 1048576).toFixed(1),
+      tokens,
+      elapsed_ms: +(performance.now() - started).toFixed(1),
+      rss_mib: +(memory.rss / 1048576).toFixed(1),
+      heap_used_mib: +(memory.heapUsed / 1048576).toFixed(1),
+    }));
+  `);
+}
+
 const adapterImport = runProbe(`
   const started = performance.now();
   await import("./src/adapter.mjs");
@@ -237,15 +273,28 @@ try {
   console.warn = originalWarn;
 }
 
+const checkMode = process.argv.includes("--check");
 const report = {
-  note: "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
+  note: checkMode
+    ? "Relative performance and resource checks; absolute timings vary by machine."
+    : "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
   adapter_import: adapterImport,
   token_count_100kb: tokenCount,
   duplicate_images: duplicateImages,
   oversized_payload: oversizedPayload,
 };
 
-if (process.argv.includes("--large-payload")) {
+if (checkMode) {
+  report.large_token_count = {
+    proxy: largeTokenCountProbe("proxy"),
+    materialized_array: largeTokenCountProbe("array"),
+  };
+  report.large_payload_peak = [
+    largePayloadProbe(5, 4),
+    largePayloadProbe(30, 1),
+    largePayloadProbe(30, 2),
+  ];
+} else if (process.argv.includes("--large-payload")) {
   report.large_payload_peak = [
     largePayloadProbe(5, 1),
     largePayloadProbe(5, 4),
@@ -256,3 +305,30 @@ if (process.argv.includes("--large-payload")) {
 }
 
 console.log(JSON.stringify(report, null, 2));
+
+if (checkMode) {
+  const failures = [];
+  const proxy = report.large_token_count.proxy;
+  const array = report.large_token_count.materialized_array;
+  if (proxy.tokens !== array.tokens) failures.push(`token counts differ: proxy=${proxy.tokens} array=${array.tokens}`);
+  if (proxy.elapsed_ms > array.elapsed_ms * 1.25) {
+    failures.push(`token counter is materially slower: proxy=${proxy.elapsed_ms}ms array=${array.elapsed_ms}ms`);
+  }
+  if (proxy.rss_mib > array.rss_mib * 0.9) {
+    failures.push(`token counter RSS regression: proxy=${proxy.rss_mib}MiB array=${array.rss_mib}MiB`);
+  }
+  if (proxy.heap_used_mib > array.heap_used_mib * 0.75) {
+    failures.push(`token counter heap regression: proxy=${proxy.heap_used_mib}MiB array=${array.heap_used_mib}MiB`);
+  }
+  for (const payload of report.large_payload_peak) {
+    if (payload.admission_max_active_mib > payload.admission_budget_mib) {
+      failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);
+    }
+  }
+  if (failures.length) {
+    for (const failure of failures) console.error(`[FAIL] ${failure}`);
+    process.exitCode = 1;
+  } else {
+    console.error("[OK] Performance and resource checks passed");
+  }
+}