codex-copilot-dx 0.7.7 → 0.7.8

package/src/copilot-responses-compat.mjs

@@ -33,8 +33,29 @@ const RETRY_POLICIES = Object.freeze([
   }),
 ]);
 
+export function selectCopilotResponseRetry(
+  reqContext,
+  statusCode,
+  errorText,
+  usedPolicies = new Set(),
+) {
+  for (const policy of RETRY_POLICIES) {
+    if (usedPolicies.has(policy.id) || !policy.matches(statusCode, errorText)) continue;
+    const candidate = policy.apply(reqContext);
+    if (!candidate) continue;
+    usedPolicies.add(policy.id);
+    return {
+      reqContext: candidate,
+      policyId: policy.id,
+      warning: policy.warning,
+      usedPolicies,
+    };
+  }
+  return null;
+}
+
 export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
-  const usedPolicies = new Set();
+  const usedPolicies = options.usedRetryPolicies || new Set();
   let payloadPrepared = false;
   for (let attempt = 0; attempt <= RETRY_POLICIES.length; attempt += 1) {
     options.assertPrepareActive?.();
@@ -49,7 +70,7 @@ export async function openCopilotResponse(reqContext, upstream = copilotResponse
     payloadPrepared = true;
     if (resp.ok) {
       reqContext = finalizeEncryptedHistoryRebase(reqContext);
-      return { resp, reqContext };
+      return { resp, reqContext, usedRetryPolicies: usedPolicies };
     }
 
     const errorText = await readBoundedResponseText(resp, {
@@ -57,24 +78,13 @@ export async function openCopilotResponse(reqContext, upstream = copilotResponse
       label: "Copilot Responses error body",
     });
     options.assertPrepareActive?.();
-    let retryPolicy = null;
-    let retryContext = null;
-    for (const policy of RETRY_POLICIES) {
-      if (usedPolicies.has(policy.id) || !policy.matches(resp.status, errorText)) continue;
-      const candidate = policy.apply(reqContext);
-      if (candidate) {
-        retryPolicy = policy;
-        retryContext = candidate;
-        break;
-      }
-    }
-    if (retryPolicy && retryContext) {
-      usedPolicies.add(retryPolicy.id);
-      reqContext = retryContext;
-      console.warn(status("warn", retryPolicy.warning));
+    const retry = selectCopilotResponseRetry(reqContext, resp.status, errorText, usedPolicies);
+    if (retry) {
+      reqContext = retry.reqContext;
+      console.warn(status("warn", retry.warning));
       continue;
     }
-    return { resp, reqContext, errorText };
+    return { resp, reqContext, errorText, usedRetryPolicies: usedPolicies };
   }
   throw httpError("Responses compatibility retry limit exceeded", 502);
 }

package/src/image-mcp.mjs

@@ -0,0 +1,169 @@
+import { isLoopbackAddress } from "./observability.mjs";
+import { generateImage } from "./image-provider.mjs";
+import { readImageProviderConfig } from "./image-provider-config.mjs";
+
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+const MCP_PROTOCOL_VERSIONS = new Set(["2025-06-18", "2025-03-26", "2024-11-05"]);
+const MCP_MAX_BODY_BYTES = 256 * 1024;
+const IMAGE_TOOL_NAME = "generate_image";
+
+function sameHostSocket(socket) {
+  const remote = String(socket?.remoteAddress || "").replace(/^::ffff:/, "");
+  const local = String(socket?.localAddress || "").replace(/^::ffff:/, "");
+  return remote && local && remote === local;
+}
+
+function writeJson(res, statusCode, body) {
+  if (res.destroyed || res.writableEnded) return;
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store",
+  });
+  res.end(body === undefined ? undefined : JSON.stringify(body));
+}
+
+function jsonRpcError(id, code, message) {
+  return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
+}
+
+async function readBody(req) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    total += chunk.length;
+    if (total > MCP_MAX_BODY_BYTES) throw Object.assign(new Error("MCP request body is too large"), { statusCode: 413 });
+    chunks.push(chunk);
+  }
+  try { return JSON.parse(Buffer.concat(chunks, total).toString("utf8")); }
+  catch { throw Object.assign(new Error("Invalid JSON"), { parseError: true }); }
+}
+
+function imageTool() {
+  return {
+    name: IMAGE_TOOL_NAME,
+    title: "Generate image",
+    description: "Generate a new image from a detailed text prompt. Use this when the user asks to create, draw, render, or generate an image. This tool does not edit an existing image.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "A detailed, standalone description of the image to generate." },
+        size: {
+          type: "string",
+          enum: ["1024x1024", "1536x1024", "1024x1536"],
+          default: "1024x1024",
+          description: "Output dimensions: square, landscape, or portrait.",
+        },
+      },
+      required: ["prompt"],
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  };
+}
+
+function safeToolError(error, apiKey) {
+  if (typeof error?.message === "string" && error.message) {
+    let message = error.message.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ");
+    if (apiKey) message = message.split(apiKey).join("[redacted]");
+    return message.slice(0, 1000);
+  }
+  return "Image generation failed";
+}
+
+export function createImageMcpHandler({
+  configLoader = () => readImageProviderConfig(),
+  generateImageFn = generateImage,
+  maxConcurrent = 2,
+} = {}) {
+  let active = 0;
+  return async function imageMcpHandler(req, res) {
+    if (!isLoopbackAddress(req.socket?.remoteAddress) && !sameHostSocket(req.socket)) {
+      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"));
+      return;
+    }
+
+    let request;
+    try { request = await readBody(req); }
+    catch (error) {
+      writeJson(res, error.statusCode || 400, jsonRpcError(null, error.parseError ? -32700 : -32600, error.message));
+      return;
+    }
+    if (!request || typeof request !== "object" || Array.isArray(request) || request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+      writeJson(res, 400, jsonRpcError(request?.id, -32600, "Invalid JSON-RPC request"));
+      return;
+    }
+    if (request.id === undefined) {
+      writeJson(res, 202);
+      return;
+    }
+    const reply = (result) => writeJson(res, 200, { jsonrpc: "2.0", id: request.id, result });
+    if (request.method === "initialize") {
+      const requestedVersion = String(request.params?.protocolVersion || "");
+      reply({
+        protocolVersion: MCP_PROTOCOL_VERSIONS.has(requestedVersion) ? requestedVersion : MCP_PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: "ccdx-image", version: "1" },
+        instructions: "Use generate_image only when the user asks to create a new image.",
+      });
+      return;
+    }
+    if (request.method === "ping") {
+      reply({});
+      return;
+    }
+    if (request.method === "tools/list") {
+      const config = configLoader();
+      reply({ tools: config ? [imageTool()] : [] });
+      return;
+    }
+    if (request.method !== "tools/call") {
+      writeJson(res, 200, jsonRpcError(request.id, -32601, "Method not found"));
+      return;
+    }
+    if (request.params?.name !== IMAGE_TOOL_NAME) {
+      writeJson(res, 200, jsonRpcError(request.id, -32602, "Unknown image tool"));
+      return;
+    }
+    const config = configLoader();
+    if (!config) {
+      reply({ content: [{ type: "text", text: "Image generation is disabled. Run ccdx enable-image first." }], isError: true });
+      return;
+    }
+    if (active >= maxConcurrent) {
+      reply({ content: [{ type: "text", text: "Image generation is busy. Try again after the current request finishes." }], isError: true });
+      return;
+    }
+    active += 1;
+    const abort = new AbortController();
+    const cancel = () => abort.abort(new Error("Image request was cancelled"));
+    req.once?.("aborted", cancel);
+    res.once?.("close", cancel);
+    try {
+      const image = await generateImageFn(config, request.params?.arguments || {}, { signal: abort.signal });
+      reply({
+        content: [
+          { type: "image", data: image.data, mimeType: image.mimeType },
+          { type: "text", text: `Generated ${image.width || ""}${image.width && image.height ? "×" : ""}${image.height || image.size} image with ${image.model}.` },
+        ],
+      });
+    } catch (error) {
+      if (!res.destroyed && !res.writableEnded) {
+        reply({ content: [{ type: "text", text: safeToolError(error, config.api_key) }], isError: true });
+      }
+    } finally {
+      active -= 1;
+      req.off?.("aborted", cancel);
+      res.off?.("close", cancel);
+    }
+  };
+}

package/src/image-provider-config.mjs

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { atomicWriteFileSync } from "./atomic-file.mjs";
+
+export const IMAGE_PROVIDER_PROTOCOLS = new Set(["openai-images", "qwen-messages"]);
+export const IMAGE_PROVIDER_TIMEOUT_MS = 15_000;
+
+export function imageProviderConfigPath({ 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", "image-provider.json");
+}
+
+function invalidConfig(filePath, reason) {
+  return new Error(`Invalid ccdx image provider at ${filePath}: ${reason}`);
+}
+
+export function normalizeImageEndpoint(value) {
+  let url;
+  try {
+    url = new URL(String(value || "").trim());
+  } catch {
+    throw new Error("Image API endpoint must be a valid HTTPS URL");
+  }
+  if (url.protocol !== "https:"
+    || !url.hostname
+    || url.username
+    || url.password
+    || url.search
+    || url.hash) {
+    throw new Error("Image API endpoint must be an HTTPS URL without credentials, query, or fragment");
+  }
+  const pathname = url.pathname.replace(/\/+$/, "");
+  if (!pathname.endsWith("/images/generations")) {
+    throw new Error("Image API endpoint path must end with /images/generations");
+  }
+  return `${url.origin}${pathname}`;
+}
+
+export function imageModelsEndpoint(endpoint) {
+  const normalized = normalizeImageEndpoint(endpoint);
+  return normalized.replace(/\/images\/generations$/, "/models");
+}
+
+function checkedApiKey(value) {
+  const key = String(value || "").trim();
+  if (!key) throw new Error("Image API key is required");
+  if (key.length > 8192 || /[\u0000-\u001f\u007f-\u009f]/.test(key)) throw new Error("Image API key is invalid");
+  return key;
+}
+
+export function validateImageProviderConfig(value, { filePath = "image-provider.json" } = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidConfig(filePath, "expected a JSON object");
+  }
+  let endpoint;
+  let apiKey;
+  try {
+    endpoint = normalizeImageEndpoint(value.endpoint);
+    apiKey = checkedApiKey(value.api_key);
+  } catch (error) {
+    throw invalidConfig(filePath, error.message);
+  }
+  const model = String(value.model || "").trim();
+  if (!model || model.length > 256 || /[\u0000-\u001f\u007f-\u009f]/.test(model)) {
+    throw invalidConfig(filePath, "model must be a non-empty string");
+  }
+  const protocol = String(value.protocol || "").trim();
+  if (!IMAGE_PROVIDER_PROTOCOLS.has(protocol)) {
+    throw invalidConfig(filePath, `protocol must be one of: ${[...IMAGE_PROVIDER_PROTOCOLS].join(", ")}`);
+  }
+  return { enabled: true, endpoint, api_key: apiKey, model, protocol };
+}
+
+export function readImageProviderConfig({ env = process.env, home = os.homedir(), strict = false } = {}) {
+  const filePath = imageProviderConfigPath({ env, home });
+  try {
+    return validateImageProviderConfig(JSON.parse(fs.readFileSync(filePath, "utf8")), { filePath });
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    if (strict) {
+      if (String(error?.message || "").startsWith("Invalid ccdx image provider")) throw error;
+      throw invalidConfig(filePath, error?.message || String(error));
+    }
+    return null;
+  }
+}
+
+export function writeImageProviderConfig(config, { env = process.env, home = os.homedir() } = {}) {
+  const filePath = imageProviderConfigPath({ env, home });
+  const normalized = validateImageProviderConfig(config, { filePath });
+  atomicWriteFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, {
+    mode: 0o600,
+    preserveMode: false,
+  });
+  return { filePath, config: normalized };
+}
+
+async function limitedText(response, maxBytes = 1024 * 1024) {
+  const declared = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) throw new Error("Image API response was too large");
+  if (!response.body?.getReader) {
+    const text = await response.text();
+    if (Buffer.byteLength(text) > maxBytes) throw new Error("Image API response was too large");
+    return text;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => {});
+        throw new Error("Image API response was too large");
+      }
+      chunks.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total).toString("utf8");
+}
+
+function errorMessage(value) {
+  if (!value || typeof value !== "object") return "";
+  return String(value.message || value.error?.message || value.error || value.reason || "");
+}
+
+function imageModelIds(body) {
+  if (!body || !Array.isArray(body.data)) return [];
+  const candidates = body.data
+    .map((model) => ({
+      id: String(model?.id || "").trim(),
+      imageCapable: /image|dall[-_.]?e/i.test(String(model?.id || ""))
+        || [model?.capabilities, model?.supported_generation_methods, model?.output_modalities]
+          .flatMap((value) => Array.isArray(value) ? value : [])
+          .some((value) => /image/i.test(String(value))),
+    }))
+    .filter(({ id }) => id
+      && id.length <= 256
+      && !/[\u0000-\u001f\u007f-\u009f]/.test(id));
+  const imageIds = candidates.filter(({ imageCapable }) => imageCapable).map(({ id }) => id);
+  return [...new Set(imageIds.length ? imageIds : candidates.length === 1 ? [candidates[0].id] : [])];
+}
+
+function detectProtocol(statusCode, body) {
+  if (statusCode < 400) return null;
+  const text = `${errorMessage(body)} ${JSON.stringify(body)}`.toLowerCase();
+  if (text.includes("input.messages")) return "qwen-messages";
+  if (/(?:field|required|missing|provide)[^\n]{0,80}\bprompt\b|\bprompt\b[^\n]{0,80}(?:required|missing)/i.test(text)) {
+    return "openai-images";
+  }
+  return null;
+}
+
+async function fetchJson(url, init, { fetchImpl, timeoutMs }) {
+  const response = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  const text = await limitedText(response);
+  let body;
+  try { body = JSON.parse(text); } catch { throw new Error("Image API returned invalid JSON"); }
+  return { response, body };
+}
+
+export async function inspectImageProvider({
+  endpoint,
+  apiKey,
+  fetchImpl = fetch,
+  timeoutMs = IMAGE_PROVIDER_TIMEOUT_MS,
+} = {}) {
+  const normalizedEndpoint = normalizeImageEndpoint(endpoint);
+  const normalizedKey = checkedApiKey(apiKey);
+  const headers = { Authorization: `Bearer ${normalizedKey}`, Accept: "application/json" };
+  const models = await fetchJson(imageModelsEndpoint(normalizedEndpoint), { headers }, { fetchImpl, timeoutMs });
+  if (!models.response.ok) throw new Error(`Image API model lookup failed with HTTP ${models.response.status}`);
+  const modelIds = imageModelIds(models.body);
+  if (!modelIds.length) throw new Error("Image API model lookup returned no image models");
+
+  const probe = await fetchJson(normalizedEndpoint, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({ model: modelIds[0] }),
+  }, { fetchImpl, timeoutMs });
+  const protocol = detectProtocol(probe.response.status, probe.body);
+  if (!protocol) throw new Error("Image API protocol is unsupported or could not be detected safely");
+  return { endpoint: normalizedEndpoint, modelIds, protocol };
+}