codex-copilot-dx 0.5.3 → 0.5.5

package/README.md

@@ -60,6 +60,8 @@ ccdx update npm
 ccdx update github
 ```
 
+`ccdx update gh` is accepted as a shorthand for the GitHub source.
+
 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` and opts in to Git fetching
@@ -68,6 +70,8 @@ for that command, as required by npm 12. It does not change npm's persistent
 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.
+If a configured npm mirror has not synchronized the current release yet, use
+the GitHub source to install the current `main` revision.
 
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
@@ -185,6 +189,7 @@ Environment variables:
 | `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 |
+| `CCDX_TERMINAL_ANIMATION` | auto | Show a transient comet while an interactive terminal has active requests and no new output for 800ms; set to `0` to disable |
 | `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for image downscaling |
 | `CCDX_IMG_QUALITY` | `82` | Initial WebP quality used when re-encoding images |
 | `CCDX_IMG_MIN_BYTES` | `100000` | In-bounds images smaller than this are left untouched; oversized images are still downscaled |
@@ -193,7 +198,9 @@ Environment variables:
 | `CCDX_IMG_CACHE_MAX_BYTES` | `67108864` | Process-local byte ceiling for cached image optimization results; set to `0` to disable result caching |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
 | `CCDX_CONFIGURE_CLAUDE_DESKTOP` | unset | Set to `1` to write the Claude App 3P gateway profile during startup |
+| `CCDX_AUTO_LAUNCH` | enabled | Set to `0`, `false`, `no`, or `off` to start the adapter without opening Codex or ChatGPT |
 | `CCDX_CLAUDE_DESKTOP_API_KEY` | managed profile or generated for opt-in setup | Explicit bearer key written into the Claude App profile and recognized by the adapter for model discovery |
+| `CCDX_PROXY_API_KEY` | unset | Backward-compatible alias for `CCDX_CLAUDE_DESKTOP_API_KEY`; the Claude-specific variable takes precedence |
 | `CCDX_CLAUDE_MODEL_ALIASES` | built-in Claude aliases | Comma-separated Desktop-to-upstream aliases, for example `claude-sonnet-4-6=claude-sonnet-4.6` |
 | `CCDX_GITHUB_TOKEN` | unset | Explicit GitHub Copilot OAuth token to validate and import before device login |
 | `CCDX_GITHUB_TOKEN_PATH` | unset | Explicit file containing a GitHub Copilot OAuth token to validate and import before device login |
@@ -203,6 +210,7 @@ Environment variables:
 | `CCDX_TOKEN_LOCK_TIMEOUT_MS` | `600000` | Maximum time to wait for another local process to finish GitHub token login/import |
 | `CCDX_TOKEN_LOCK_STALE_MS` | `900000` | Age after which a stale GitHub token lock file can be removed |
 | `CCDX_EXISTING_ADAPTER_TIMEOUT_MS` | `500` | Timeout for detecting an already-running local adapter during startup |
+| `CCDX_MODEL_REFRESH_TIMEOUT_MS` | `5000` | Timeout for a Copilot model metadata refresh or live Auto-review model lookup |
 | `CCDX_MODEL_REFRESH_INTERVAL_MS` | `7200000` | Interval for refreshing Copilot model metadata; successful lists are cached locally as last-known-good data |
 | `CCDX_RESPONSE_HISTORY_MAX_BYTES` | `67108864` | Total in-memory byte budget for locally expanded Responses history |
 | `CCDX_RESPONSE_HISTORY_MAX_ENTRIES` | `4096` | Maximum stored incremental Responses history nodes |
@@ -215,14 +223,14 @@ Environment variables:
 
 The adapter records token usage metadata to `~/.local/share/codex-copilot-dx/usage.jsonl` when upstream responses include usage fields. It logs counts, model names, API surface, and response IDs only; it does not log prompts, completions, tool arguments, or image content.
 
-### Debug logging
-
-Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or set `CCDX_LOG_PATH` to a custom file. Add `CCDX_LOG_LEVEL=debug` to include upstream request attempts, retry causes, status codes, and timings. Debug logs do not include prompts, completions, request bodies, or authorization tokens.
-
 ```bash
 ccdx usage
 ```
 
+### Debug logging
+
+Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or set `CCDX_LOG_PATH` to a custom file. Add `CCDX_LOG_LEVEL=debug` to include upstream request attempts, retry causes, status codes, and timings. Debug logs do not include prompts, completions, request bodies, or authorization tokens.
+
 ### Image optimization
 
 Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, and GitHub Copilot's `/responses` endpoint can reject oversized requests with `408 Request Timeout` while reading the body or `413 Payload Too Large`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/adapter.mjs

@@ -13,6 +13,7 @@ import {
 import { createRequestId, runWithRequestContext } from "./request-context.mjs";
 import { createStreamPerformanceMetrics } from "./stream-performance.mjs";
 import { status } from "./status.mjs";
+import { createTerminalActivityIndicator } from "./terminal-activity.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { createResponsesCompactHandler, createResponsesHandler } from "./responses-handler.mjs";
 import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
@@ -232,9 +233,20 @@ export function createAdapterHandler(options = {}) {
     const routeName = classifyAdapterRoute(req.method, pathname);
     const complete = trackRequest ? requestMetrics.begin(routeName) : () => {};
     const streamPerformance = trackRequest ? streamPerformanceMetrics.begin(routeName) : null;
+    let finishTerminalActivity = () => {};
+    if (trackRequest) {
+      try {
+        const finish = options.terminalActivity?.beginRequest?.();
+        if (typeof finish === "function") finishTerminalActivity = finish;
+      } catch {}
+    }
+    let requestFinished = false;
     const finishRequest = ({ statusCode = 0, aborted = false } = {}) => {
+      if (requestFinished) return;
+      requestFinished = true;
       complete({ statusCode, aborted });
       streamPerformance?.finish({ failed: aborted || statusCode >= 400 });
+      try { finishTerminalActivity(); } catch {}
     };
     if (trackRequest && typeof res.once === "function") {
       res.once("finish", () => finishRequest({ statusCode: res.statusCode }));
@@ -268,7 +280,13 @@ export function createAdapterHandler(options = {}) {
 // Public server entry point.
 
 export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
-  const server = http.createServer(createAdapterHandler(options));
+  const ownsTerminalActivity = !Object.hasOwn(options, "terminalActivity");
+  const terminalActivity = ownsTerminalActivity ? createTerminalActivityIndicator() : options.terminalActivity;
+  const server = http.createServer(createAdapterHandler({ ...options, terminalActivity }));
+  const cleanupTerminalActivity = () => {
+    if (ownsTerminalActivity) terminalActivity?.cleanup?.();
+  };
+  server.once("close", cleanupTerminalActivity);
 
   server.on("upgrade", (req, socket) => {
     // Codex Desktop 0.130+ negotiates a "responses_websockets" server-push
@@ -282,6 +300,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
 
   return new Promise((resolve, reject) => {
     const onListenError = (e) => {
+      cleanupTerminalActivity();
       if (e?.code === "EADDRINUSE") {
         reject(new Error(`Adapter address http://${host}:${port} is already in use. Stop the existing ccdx process or set ADAPTER_PORT to another port.`));
         return;

package/src/terminal-activity.mjs

@@ -0,0 +1,170 @@
+const ESC = "\u001b";
+const ERASE_LINE = `\r${ESC}[2K`;
+const HIDE_CURSOR = `${ESC}[?25l`;
+const SHOW_CURSOR = `${ESC}[?25h`;
+
+const TRACK_WIDTH = 20;
+const TAIL_LENGTH = 7;
+const IDLE_DELAY_MS = 800;
+const FRAME_DELAY_MS = 45;
+const LOOP_PAUSE_MS = 200;
+const TAIL_COLORS = [159, 123, 87, 51, 45, 39, 33];
+
+function envFlagEnabled(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return normalized !== "" && !["0", "false", "no", "off"].includes(normalized);
+}
+
+function terminalActivityEnabled({ env, output, errorOutput }) {
+  const animationSetting = String(env.CCDX_TERMINAL_ANIMATION || "").trim().toLowerCase();
+  if (["0", "false", "no", "off"].includes(animationSetting)) return false;
+  if (envFlagEnabled(env.CI) || String(env.TERM || "").toLowerCase() === "dumb") return false;
+  if (output?.isTTY !== true || errorOutput?.isTTY !== true) return false;
+  const columns = Number(output.columns);
+  return !Number.isFinite(columns) || columns <= 0 || columns >= TRACK_WIDTH + 2;
+}
+
+export function renderCometFrame(position) {
+  let track = "";
+  for (let column = 0; column < TRACK_WIDTH; column += 1) {
+    const distance = position - column;
+    if (distance === 0) {
+      track += `${ESC}[97m:${ESC}[0m`;
+    } else if (distance > 0 && distance <= TAIL_LENGTH) {
+      track += `${ESC}[38;5;${TAIL_COLORS[distance - 1]}m:${ESC}[0m`;
+    } else {
+      track += " ";
+    }
+  }
+  return `[${track}]`;
+}
+
+function disabledIndicator() {
+  return {
+    enabled: false,
+    beginRequest() { return () => {}; },
+    cleanup() {},
+  };
+}
+
+export function createTerminalActivityIndicator({
+  env = process.env,
+  output = process.stdout,
+  errorOutput = process.stderr,
+  consoleObj = console,
+  timers = { setTimeout, clearTimeout },
+} = {}) {
+  if (!terminalActivityEnabled({ env, output, errorOutput })) return disabledIndicator();
+
+  const methods = ["log", "warn", "error", "debug"];
+  const originals = Object.fromEntries(methods.map((method) => [method, consoleObj[method]]));
+  const wrappers = {};
+  let activeRequests = 0;
+  let idleTimer = null;
+  let frameTimer = null;
+  let framePosition = 0;
+  let cursorHidden = false;
+  let frameVisible = false;
+  let cleaned = false;
+
+  const schedule = (callback, delay) => {
+    const timer = timers.setTimeout(callback, delay);
+    timer?.unref?.();
+    return timer;
+  };
+
+  const clearTimer = (timer) => {
+    if (timer) timers.clearTimeout(timer);
+  };
+
+  const clearAnimation = () => {
+    clearTimer(frameTimer);
+    frameTimer = null;
+    framePosition = 0;
+    if (cursorHidden || frameVisible) output.write(`${ERASE_LINE}${SHOW_CURSOR}`);
+    cursorHidden = false;
+    frameVisible = false;
+  };
+
+  const cancelPendingOutput = () => {
+    clearTimer(idleTimer);
+    idleTimer = null;
+    clearAnimation();
+  };
+
+  const drawNextFrame = () => {
+    frameTimer = null;
+    if (cleaned || activeRequests === 0) {
+      clearAnimation();
+      return;
+    }
+    if (framePosition >= TRACK_WIDTH + TAIL_LENGTH) {
+      output.write(ERASE_LINE);
+      frameVisible = false;
+      framePosition = 0;
+      frameTimer = schedule(drawNextFrame, LOOP_PAUSE_MS);
+      return;
+    }
+
+    const prefix = cursorHidden ? "" : HIDE_CURSOR;
+    cursorHidden = true;
+    frameVisible = true;
+    output.write(`${prefix}${ERASE_LINE}${renderCometFrame(framePosition)}`);
+    framePosition += 1;
+    frameTimer = schedule(drawNextFrame, FRAME_DELAY_MS);
+  };
+
+  const scheduleAfterIdle = () => {
+    clearTimer(idleTimer);
+    idleTimer = null;
+    if (cleaned || activeRequests === 0) return;
+    idleTimer = schedule(() => {
+      idleTimer = null;
+      drawNextFrame();
+    }, IDLE_DELAY_MS);
+  };
+
+  for (const method of methods) {
+    const original = typeof originals[method] === "function" ? originals[method] : () => {};
+    wrappers[method] = (...args) => {
+      cancelPendingOutput();
+      try {
+        return original.apply(consoleObj, args);
+      } finally {
+        scheduleAfterIdle();
+      }
+    };
+    consoleObj[method] = wrappers[method];
+  }
+
+  return {
+    enabled: true,
+    beginRequest() {
+      if (cleaned) return () => {};
+      activeRequests += 1;
+      if (activeRequests === 1 && !idleTimer && !frameTimer) scheduleAfterIdle();
+      let finished = false;
+      return () => {
+        if (finished) return;
+        finished = true;
+        activeRequests = Math.max(0, activeRequests - 1);
+        if (activeRequests === 0) {
+          clearTimer(idleTimer);
+          idleTimer = null;
+          clearAnimation();
+        }
+      };
+    },
+    cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      activeRequests = 0;
+      clearTimer(idleTimer);
+      idleTimer = null;
+      clearAnimation();
+      for (const method of methods) {
+        if (consoleObj[method] === wrappers[method]) consoleObj[method] = originals[method];
+      }
+    },
+  };
+}