codex-copilot-dx 0.9.16 → 0.9.17

package/README.md

@@ -62,6 +62,8 @@ The dashboard does not poll in the background; refresh when needed.
   break continuations. Generated images and Codex transcripts are not deleted.
 - Optional image setup/maintenance never blocks the primary service. Disabled
   users get no CCDX image skill or MCP installation.
+- Image API redirects must stay on the same HTTPS origin. Returned images must
+  use public HTTPS URLs; well-known NAT64 mappings follow IPv4 address rules.
 - Keep the adapter on loopback. LAN mode is only for trusted networks; do not
   expose it to the public internet. The dashboard is not an authentication wall
   for the API. Diagnostic errors may contain sensitive upstream text.

package/bin/cli.mjs

@@ -75,11 +75,16 @@ if (CLI.command === "image") {
   }
 }
 if (CLI.command === "usage") {
-  await printUsageSummary({
-    format: CLI.outputFormat || "auto",
-    output: process.stdout,
-  });
-  process.exit(0);
+  try {
+    await printUsageSummary({
+      format: CLI.outputFormat || "auto",
+      output: process.stdout,
+    });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
 }
 if (CLI.command === "cache") {
   try {

package/docs/REFERENCE.md

@@ -203,7 +203,13 @@ ccdx disable-image
 
 `image-status` never prints the API key and performs only a local, non-generating tool-readiness check. Disabling removes the stored provider credential, the CCDX-owned MCP block, and unmodified skill, reference, and helper files; user-modified files are preserved. Cached tool calls then fail closed. The Node helper creates a new file under the task's `output/imagegen` directory by default and reports its absolute path; it never overwrites an existing file or automatically repeats a failed generation. The image endpoint is contacted only by `enable-image` validation and by explicit `generate_image` or `edit_image` tool calls. Ordinary Responses, models, authentication, Fast, Auto-review, compaction, and image-input paths remain on their existing routes.
 
-Generated image downloads must use public HTTPS addresses, do not follow redirects, are DNS-checked against private and reserved addresses, and are capped at 32 MiB. DNS resolution and downloading share one deadline and respond to cancellation; a late DNS result cannot start a cancelled download. The local MCP route accepts calls only from the same device and permits at most two concurrent image operations. It requires `application/json` and rejects browser `Origin` headers; native Codex and Node clients do not send an Origin. The tool supports new-image generation at `1024x1024`, `1536x1024`, or `1024x1536`.
+Generated image downloads must use public HTTPS addresses, do not follow redirects, are DNS-checked against private and reserved addresses, and are capped at 32 MiB. Well-known NAT64 `64:ff9b::/96` addresses apply the same IPv4 public/private rules to the embedded address, without rejecting legitimate public translations. DNS resolution and downloading share one deadline and respond to cancellation; a late DNS result cannot start a cancelled download. The local MCP route accepts calls only from the same device and permits at most two concurrent image operations. Host must name loopback, the actual local socket address (including equivalent IPv6/IPv4-mapped forms), or the explicitly configured bind hostname. Missing Host remains compatible with HTTP/1.0 and in-process clients. It requires `application/json` and rejects browser `Origin` headers; native Codex and Node clients do not send an Origin. The tool supports new-image generation at `1024x1024`, `1536x1024`, or `1024x1536`.
+
+Image API generation/editing requests retain same-origin HTTPS redirects, with Fetch's existing POST/GET rules, a 20-hop limit and one shared timeout/cancellation signal. Cross-origin, HTTPS-to-HTTP, credential-bearing or invalid redirect targets are refused before another request is sent. Use the final API base URL when a service redirects to another origin. Redirect bodies are cancelled; generation failures are not automatically retried. The provider's returned image-download URLs still never follow redirects.
+
+The Chat compatibility bridge ignores repeated complete tool names only when the name is declared and concatenation cannot be a fragment of another declared name. Overlapping fragments, delayed names and ambiguous/undeclared streams retain their existing assembly rules; argument deltas and tool-call IDs are not deduplicated. Native Responses routing and payloads are unchanged.
+
+`ccdx usage` reports genuine log-read failures with the normal error line and exit code 1, without an uncaught exception dump. Missing logs remain a successful empty summary; malformed records are skipped with a warning rather than making usage unavailable.
 
 With `qwen-image-3.0-pro` or `qwen-image-3.0` using either supported protocol, CCDX also exposes `edit_image`. Ask Codex to modify a specific CCDX-generated image; it passes that image's returned `image_id` and the edit instruction to the same configured provider. Each edit returns a new image and ID while preserving the original; omitting `size` retains the source's requested dimensions. The Qwen request contains the source image again on every edit, as required by its [single-turn image editing API](https://help.aliyun.com/zh/model-studio/qwen-image-generation-and-editing-api-reference).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.9.16",
+  "version": "0.9.17",
   "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/adapter.mjs

@@ -215,7 +215,7 @@ export function createAdapterHandler(options = {}) {
     if (pathname === "/mcp/image") {
       if (imageMcpHandler) return imageMcpHandler(req, res);
       return import("./image-mcp.mjs").then(({ createImageMcpHandler }) => {
-        imageMcpHandler ||= createImageMcpHandler();
+        imageMcpHandler ||= createImageMcpHandler({ localHostname: options.imageMcpHostname });
         return imageMcpHandler(req, res);
       });
     }
@@ -460,7 +460,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   const terminalActivity = ownsTerminalActivity
     ? createTerminalActivityIndicator({ theme: options.terminalAnimationTheme })
     : options.terminalActivity;
-  const handler = createAdapterHandler({ ...options, terminalActivity });
+  const handler = createAdapterHandler({ ...options, terminalActivity, imageMcpHostname: host });
   const server = http.createServer(handler);
   const cleanupTerminalActivity = () => {
     if (ownsTerminalActivity) terminalActivity?.cleanup?.();

package/src/image-mcp.mjs

@@ -2,7 +2,8 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { isLoopbackAddress } from "./observability.mjs";
+import { isIP } from "node:net";
+import { isLoopbackAddress, isLoopbackHostHeader } from "./observability.mjs";
 import { generateImage, supportsImageEditing, IMAGE_MAX_BYTES } from "./image-provider.mjs";
 import { readImageProviderConfig } from "./image-provider-config.mjs";
 import { createImageReferenceStore } from "./image-references.mjs";
@@ -49,6 +50,28 @@ function sameHostSocket(socket) {
   return remote && local && remote === local;
 }
 
+function canonicalIpHost(hostname) {
+  const address = hostname.replace(/^\[|\]$/g, "");
+  const mapped = /^::ffff:([a-f0-9]{1,4}):([a-f0-9]{1,4})$/.exec(address);
+  if (!mapped) return address;
+  const high = Number.parseInt(mapped[1], 16);
+  const low = Number.parseInt(mapped[2], 16);
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+
+function ownHostHeader(host, socket, bindHostname) {
+  if (isLoopbackHostHeader(host)) return true;
+  if (typeof host !== "string" || !host || host.includes(",")) return false;
+  try {
+    const url = new URL(`http://${host}`);
+    if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) return false;
+    if (bindHostname && url.hostname === bindHostname) return true;
+    const local = String(socket?.localAddress || "");
+    if (!isIP(local)) return false;
+    return canonicalIpHost(url.hostname) === canonicalIpHost(new URL(`http://${isIP(local) === 6 ? `[${local}]` : local}`).hostname);
+  } catch { return false; }
+}
+
 function writeJson(res, statusCode, body) {
   if (res.destroyed || res.writableEnded) return;
   res.writeHead(statusCode, {
@@ -134,9 +157,14 @@ export function createImageMcpHandler({
   configLoader = () => readImageProviderConfig(),
   generateImageFn = generateImage,
   maxConcurrent = 2,
+  localHostname = "",
   imageReferences = createImageReferenceStore(),
   imageDirectory = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "images"),
 } = {}) {
+  let bindHostname = "";
+  if (localHostname && !isIP(localHostname.replace(/^\[|\]$/g, ""))) {
+    try { bindHostname = new URL(`http://${localHostname}`).hostname; } catch {}
+  }
   let active = 0;
   const metrics = { total: 0, succeeded: 0, failed: 0, busy: 0, cancelled: 0, delivery_failures: 0 };
   const handler = async function imageMcpHandler(req, res) {
@@ -144,6 +172,10 @@ export function createImageMcpHandler({
       writeJson(res, 403, jsonRpcError(null, -32001, "Image MCP is available only on this device"));
       return;
     }
+    if (!ownHostHeader(req.headers?.host, req.socket, bindHostname)) {
+      writeJson(res, 403, jsonRpcError(null, -32001, "Image MCP is available only on this device"));
+      return;
+    }
     if (req.method !== "POST") {
       res.setHeader?.("Allow", "POST");
       writeJson(res, 405, jsonRpcError(null, -32600, "Only POST is supported"));

package/src/image-provider.mjs

@@ -207,10 +207,11 @@ function publicAddress(address) {
   catch { return false; }
   if (lower === "::" || lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd")
     || /^fe[89ab]/.test(lower) || lower.startsWith("ff") || lower.startsWith("2001:db8:")) return false;
-  const mapped = /^::ffff:([a-f0-9]{1,4}):([a-f0-9]{1,4})$/.exec(lower);
+  const mapped = /^::ffff:([a-f0-9]{1,4}):([a-f0-9]{1,4})$/.exec(lower)
+    || /^64:ff9b::(?:([a-f0-9]{1,4}):)?([a-f0-9]{1,4})?$/.exec(lower);
   if (!mapped) return true;
-  const high = Number.parseInt(mapped[1], 16);
-  const low = Number.parseInt(mapped[2], 16);
+  const high = Number.parseInt(mapped[1] || "0", 16);
+  const low = Number.parseInt(mapped[2] || "0", 16);
   return ipv4Public([high >> 8, high & 255, low >> 8, low & 255].join("."));
 }
 
@@ -305,20 +306,36 @@ export async function generateImage(config, {
   const timeout = AbortSignal.timeout(timeoutMs);
   const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
   let response;
-  try {
-    response = await fetchImpl(config.endpoint, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${config.api_key}`,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify(generationBody(config, normalizedPrompt, normalizedSize, normalizedImage)),
-      signal: requestSignal,
-    });
-  } catch (error) {
-    if (requestSignal.aborted) throw providerError("Image generation timed out or was cancelled", "ccdx_image_timeout");
-    throw providerError("Image API could not be reached");
+  let requestUrl = config.endpoint;
+  let method = "POST";
+  let requestBody = JSON.stringify(generationBody(config, normalizedPrompt, normalizedSize, normalizedImage));
+  let headers = { Authorization: `Bearer ${config.api_key}`, "Content-Type": "application/json", Accept: "application/json" };
+  for (let redirects = 0; ; redirects += 1) {
+    try {
+      if (requestSignal.aborted) throw requestSignal.reason;
+      response = await fetchImpl(requestUrl, { method, headers, body: requestBody, signal: requestSignal, redirect: "manual" });
+    } catch (error) {
+      if (requestSignal.aborted) throw providerError("Image generation timed out or was cancelled", "ccdx_image_timeout");
+      throw providerError("Image API could not be reached");
+    }
+    const location = [301, 302, 303, 307, 308].includes(response.status) ? response.headers?.get?.("location") : null;
+    if (location == null) break;
+    await response.body?.cancel?.().catch?.(() => {});
+    let target;
+    try { target = new URL(location, requestUrl); }
+    catch { throw providerError("Image API returned an invalid redirect", "ccdx_image_redirect_unsafe"); }
+    if (target.protocol !== "https:" || target.username || target.password || target.origin !== new URL(requestUrl).origin) {
+      throw providerError("Image API redirect was refused; use a same-origin HTTPS endpoint", "ccdx_image_redirect_unsafe");
+    }
+    if (redirects >= 20) throw providerError("Image API returned too many redirects", "ccdx_image_redirect_limit");
+    // Preserve Fetch's method/body rules for legitimate same-origin redirects.
+    if (((response.status === 301 || response.status === 302) && method === "POST") || (response.status === 303 && method !== "GET")) {
+      method = "GET";
+      requestBody = undefined;
+      headers = { ...headers };
+      delete headers["Content-Type"];
+    }
+    requestUrl = target.href;
   }
   const body = await boundedJson(response);
   if (!response.ok) {

package/src/responses-bridge.mjs

@@ -233,6 +233,9 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   delete chatReq.max_tokens;
   const requestModel = chatReq.model || "unknown";
   let upstreamReq = withChatStreamUsage(chatReq);
+  // Retain names only, not the request's schemas, images or message history.
+  const declaredToolNames = new Set((Array.isArray(upstreamReq.tools) ? upstreamReq.tools : [])
+    .map((tool) => tool?.function?.name).filter((name) => typeof name === "string" && name));
   let {
     abort,
     bodyText,
@@ -450,7 +453,17 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         for (const tc of delta.tool_calls) {
           const { tool, created } = await ensureToolCall(tc);
           if (tc.id) tool.callId = tc.id;
-          if (!created && tc.function?.name) tool.name += tc.function.name;
+          if (!created && tc.function?.name) {
+            const name = tc.function.name;
+            let completeRepeat = name === tool.name && declaredToolNames.has(name);
+            if (completeRepeat) {
+              // An overlap may be a real fragment of a longer declared name.
+              for (const declared of declaredToolNames) {
+                if (declared.startsWith(tool.name + name)) { completeRepeat = false; break; }
+              }
+            }
+            if (!completeRepeat) tool.name += name;
+          }
           const argumentDelta = tc.function?.arguments;
           toolArgumentGuard.observe(tool.outputIndex, argumentDelta);
           if (argumentDelta) {