codex-copilot-dx 0.5.3 → 0.5.4

package/README.md

@@ -185,6 +185,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 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "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];
+      }
+    },
+  };
+}