codex-copilot-dx 0.1.5 → 0.4.0

package/src/copilot.mjs

@@ -0,0 +1,316 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { status } from "./status.mjs";
+
+const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
+export const DEFAULT_API_BASE = "https://api.githubcopilot.com";
+let apiBase = DEFAULT_API_BASE;
+const IMG_MAX_DIM = parseInt(process.env.CCDX_IMG_MAX_DIM || "2048", 10);
+const IMG_QUALITY = parseInt(process.env.CCDX_IMG_QUALITY || "85", 10);
+const IMG_MIN_BYTES = parseInt(process.env.CCDX_IMG_MIN_BYTES || "100000", 10);
+const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
+let sharpImport = null;
+
+export function parseApiBase(data) {
+  return (data && data.endpoints && typeof data.endpoints.api === "string" && data.endpoints.api)
+    ? data.endpoints.api
+    : DEFAULT_API_BASE;
+}
+
+export function getApiBase() {
+  return apiBase;
+}
+
+export function responsesEndpointPath() {
+  return "/responses";
+}
+const GITHUB_API = "https://api.github.com";
+
+async function sharp() {
+  sharpImport ||= import("sharp");
+  const mod = await sharpImport;
+  return mod.default || mod;
+}
+
+export async function optimizeImageDataUrl(dataUrl) {
+  if (IMG_OPT_DISABLED) return dataUrl;
+  if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
+  const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
+  if (!match) return dataUrl;
+  const mime = match[1].toLowerCase();
+  const raw = Buffer.from(match[2], "base64");
+  if (raw.length < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
+
+  try {
+    const resize = await sharp();
+    const out = await resize(raw, { failOn: "none" })
+      .rotate()
+      .resize(IMG_MAX_DIM, IMG_MAX_DIM, { fit: "inside", withoutEnlargement: true })
+      .webp({ quality: IMG_QUALITY, effort: 4 })
+      .toBuffer();
+    const ratio = ((out.length / raw.length) * 100).toFixed(1);
+    console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
+    return `data:image/webp;base64,${out.toString("base64")}`;
+  } catch (e) {
+    console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
+    return dataUrl;
+  }
+}
+
+function visitImageParts(parts, tasks) {
+  if (!Array.isArray(parts)) return;
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.type === "input_image" && typeof part.image_url === "string") {
+      tasks.push((async () => { part.image_url = await optimizeImageDataUrl(part.image_url); })());
+    } else if (part.type === "image" && part.source?.type === "base64" && part.source?.data) {
+      tasks.push((async () => {
+        const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
+        const opt = await optimizeImageDataUrl(dataUrl);
+        const match = /^data:([^;]+);base64,(.+)$/.exec(opt);
+        if (match) {
+          part.source.media_type = match[1];
+          part.source.data = match[2];
+        }
+      })());
+    }
+  }
+}
+
+export async function optimizeImagesInBody(reqBody) {
+  if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
+  const tasks = [];
+
+  for (const item of reqBody.input) {
+    if (!item) continue;
+    if (item.type === "message" && Array.isArray(item.content)) {
+      visitImageParts(item.content, tasks);
+    }
+    if (item.type === "function_call_output") {
+      if (Array.isArray(item.output)) {
+        visitImageParts(item.output, tasks);
+      } else if (typeof item.output === "string") {
+        const trimmed = item.output.trim();
+        if (trimmed.startsWith("[")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+              const before = tasks.length;
+              visitImageParts(parsed, tasks);
+              const localTasks = tasks.slice(before);
+              if (localTasks.length) {
+                tasks.push(Promise.all(localTasks).then(() => {
+                  item.output = JSON.stringify(parsed);
+                }));
+              }
+            }
+          } catch {
+            // Leave non-JSON tool output untouched.
+          }
+        }
+      }
+    }
+  }
+
+  if (tasks.length) await Promise.all(tasks);
+  return reqBody;
+}
+
+export function summarizeReqBody(reqBody) {
+  try {
+    const input = reqBody.input;
+    if (!Array.isArray(input)) return { items: 0, images: 0, biggest: 0, biggestKind: "n/a" };
+    let biggest = 0;
+    let biggestKind = "";
+    let images = 0;
+    const countImages = (parts) => {
+      if (!Array.isArray(parts)) return;
+      for (const part of parts) {
+        if (part?.type === "input_image" || part?.type === "image") images++;
+      }
+    };
+
+    for (const item of input) {
+      const size = JSON.stringify(item).length;
+      if (size > biggest) {
+        biggest = size;
+        biggestKind = item?.type || "?";
+      }
+      if (item?.type === "message") countImages(item.content);
+      if (item?.type === "function_call_output") {
+        if (Array.isArray(item.output)) {
+          countImages(item.output);
+        } else if (typeof item.output === "string" && item.output.trim().startsWith("[")) {
+          try {
+            const parsed = JSON.parse(item.output);
+            if (Array.isArray(parsed)) countImages(parsed);
+          } catch {
+            // Ignore non-JSON tool output.
+          }
+        }
+      }
+    }
+
+    return { items: input.length, images, biggest, biggestKind };
+  } catch {
+    return { items: -1, images: -1, biggest: -1, biggestKind: "err" };
+  }
+}
+
+export function computeInitiator(messages) {
+  const isAgent = Array.isArray(messages)
+    && messages.some((m) => m && ["assistant", "tool"].includes(m.role));
+  return isAgent ? "agent" : "user";
+}
+
+export function computeVision(messages) {
+  return Array.isArray(messages) && messages.some(
+    (m) => m && typeof m.content !== "string"
+      && Array.isArray(m.content)
+      && m.content.some((p) => p && p.type === "image_url"),
+  );
+}
+
+export function buildHeaders({ token, version, initiator, vision }) {
+  const h = {
+    "Authorization": `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Copilot-Integration-Id": "vscode-chat",
+    "Editor-Version": `vscode/${version}`,
+    "Editor-Plugin-Version": "copilot-chat/0.26.7",
+    "User-Agent": "GitHubCopilotChat/0.26.7",
+    "Openai-Intent": "conversation-panel",
+    "X-Github-Api-Version": "2025-04-01",
+    "X-Request-Id": randomUUID(),
+    "X-Vscode-User-Agent-Library-Version": "electron-fetch",
+    "X-Initiator": initiator,
+  };
+  if (vision) h["Copilot-Vision-Request"] = "true";
+  return h;
+}
+
+export const FALLBACK_VSCODE_VERSION = "1.122.1";
+
+let cachedVersion = FALLBACK_VSCODE_VERSION;
+
+export function parseVSCodeVersion(json) {
+  return (json && typeof json.productVersion === "string" && json.productVersion)
+    ? json.productVersion
+    : FALLBACK_VSCODE_VERSION;
+}
+
+export function getVSCodeVersion() {
+  return cachedVersion;
+}
+
+// Refresh the VS Code version asynchronously; keep the fallback on failure.
+export async function refreshVSCodeVersion() {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 5000);
+    const resp = await fetch(
+      "https://update.code.visualstudio.com/api/update/darwin-arm64/stable/latest",
+      { signal: ctrl.signal },
+    );
+    clearTimeout(timer);
+    if (resp.ok) {
+      cachedVersion = parseVSCodeVersion(await resp.json());
+      console.log(status("info", `VS Code version: ${cachedVersion}`));
+    }
+  } catch {
+    // Keep the fallback quietly.
+  }
+  return cachedVersion;
+}
+
+let copilotToken = null;
+let copilotTokenExpiry = 0;
+
+function getGithubToken() {
+  if (!fs.existsSync(GITHUB_TOKEN_PATH)) {
+    throw new Error("GitHub token not found. Run the tool once to log in.");
+  }
+  return fs.readFileSync(GITHUB_TOKEN_PATH, "utf-8").trim();
+}
+
+export async function getCopilotToken() {
+  if (copilotToken && Date.now() < copilotTokenExpiry - 60000) return copilotToken;
+  const ghToken = getGithubToken();
+  const resp = await fetch(`${GITHUB_API}/copilot_internal/v2/token`, {
+    headers: { Authorization: `token ${ghToken}`, Accept: "application/json" },
+  });
+  if (!resp.ok) throw new Error(`Failed to get Copilot token: ${resp.status}`);
+  const data = await resp.json();
+  if (!data.token) throw new Error("Copilot token response missing token field");
+  copilotToken = data.token;
+  apiBase = parseApiBase(data);
+  copilotTokenExpiry = typeof data.expires_at === "number"
+    ? data.expires_at * 1000
+    : Date.now() + 25 * 60 * 1000; // fallback if expires_at absent: refresh in ~25min
+  console.log(status("ok", "Copilot token refreshed"));
+  return copilotToken;
+}
+
+// chatReq is already converted by the adapter. The caller parses the raw Response.
+export async function chatCompletions(chatReq) {
+  const token = await getCopilotToken();
+  const messages = chatReq.messages || [];
+  const headers = buildHeaders({
+    token,
+    version: getVSCodeVersion(),
+    initiator: computeInitiator(messages),
+    vision: computeVision(messages),
+  });
+  return fetch(`${getApiBase()}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(chatReq),
+  });
+}
+
+export async function listModels() {
+  const token = await getCopilotToken();
+  const headers = buildHeaders({
+    token, version: getVSCodeVersion(), initiator: "user", vision: false,
+  });
+  const resp = await fetch(`${getApiBase()}/models`, { headers });
+  return { status: resp.status, body: await resp.text() };
+}
+
+// Responses-only models go directly to Copilot's /responses endpoint.
+export async function responses(reqBody) {
+  const token = await getCopilotToken();
+  const beforeBytes = Buffer.byteLength(JSON.stringify(reqBody));
+  await optimizeImagesInBody(reqBody);
+  const bodyBuf = Buffer.from(JSON.stringify(reqBody), "utf8");
+  const summary = summarizeReqBody(reqBody);
+  console.log(status("info", `responses payload bytes=${bodyBuf.length} was=${beforeBytes} input_items=${summary.items} images=${summary.images} biggest_item=${summary.biggest}b (${summary.biggestKind})`));
+  const headers = buildHeaders({
+    token,
+    version: getVSCodeVersion(),
+    initiator: "user",
+    vision: false,
+  });
+  headers["Content-Type"] = "application/json; charset=utf-8";
+  headers["Content-Length"] = String(bodyBuf.length);
+  headers["Accept"] = reqBody.stream ? "text/event-stream" : "application/json";
+
+  try {
+    return await fetch(`${getApiBase()}${responsesEndpointPath()}`, {
+      method: "POST",
+      headers,
+      body: bodyBuf,
+    });
+  } catch (e) {
+    const cause = e?.cause;
+    const causeText = cause ? ` (${[cause.code, cause.message].filter(Boolean).join(": ")})` : "";
+    throw new Error(`Copilot responses fetch failed: ${e.message}${causeText}`);
+  }
+}
+
+export async function responsesCompact(reqBody) {
+  // GitHub Copilot accepts Codex compact payloads on the regular Responses endpoint.
+  return responses(reqBody);
+}

package/src/launcher.mjs

@@ -1,90 +1,19 @@
-import { spawn, execSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import net from "node:net";
+import { spawn } from "node:child_process";
+import { status } from "./status.mjs";
 
-const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
-
-function isPortAccepting(port) {
-  return new Promise((resolve) => {
-    const sock = net.connect(port, "127.0.0.1");
-    let done = false;
-    const finish = (v) => { if (done) return; done = true; sock.destroy(); resolve(v); };
-    sock.once("connect", () => finish(true));
-    sock.once("error", () => finish(false));
-    sock.setTimeout(1000, () => finish(false));
-  });
-}
-
-export async function ensureAuth() {
-  if (fs.existsSync(GITHUB_TOKEN_PATH)) {
-    console.log("[codex-copilot-dx] GitHub token found");
-    return;
-  }
-  console.log("[codex-copilot-dx] No GitHub token. Running auth...");
-  const copilotApiBin = findCopilotApi();
-  execSync(`${copilotApiBin} auth`, { stdio: "inherit" });
-}
-
-function findCopilotApi() {
-  try {
-    return execSync("which copilot-api", { encoding: "utf-8" }).trim();
-  } catch {
-    // Try npx path
-    const npxPath = path.join(os.homedir(), ".npm/_npx");
-    if (fs.existsSync(npxPath)) {
-      for (const dir of fs.readdirSync(npxPath)) {
-        const bin = path.join(npxPath, dir, "node_modules/.bin/copilot-api");
-        if (fs.existsSync(bin)) return bin;
-      }
-    }
-    return "npx copilot-api";
-  }
-}
-
-export async function startCopilotApi(port = 4141) {
-  if (await isPortAccepting(port)) {
-    console.log(`[codex-copilot-dx] copilot-api already running on :${port}`);
-    return null;
-  }
-  console.log(`[codex-copilot-dx] Starting copilot-api on :${port}...`);
-  const copilotApiBin = findCopilotApi();
-  const child = spawn(copilotApiBin, ["start", "--port", String(port)], {
-    stdio: "pipe",
-    detached: false,
-  });
-  child.stdout?.on("data", (d) => {
-    const line = d.toString().trim();
-    if (line) console.log(`[copilot-api] ${line}`);
-  });
-  child.stderr?.on("data", (d) => {
-    const line = d.toString().trim();
-    if (line) console.log(`[copilot-api] ${line}`);
-  });
-
-  // Wait for it to be ready
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    if (await isPortAccepting(port)) {
-      console.log(`[codex-copilot-dx] copilot-api ready on :${port}`);
-      return child;
-    }
-  }
-  throw new Error("copilot-api failed to start");
-}
+export { ensureAuth } from "./auth.mjs";
 
 export function openCodex() {
   if (process.platform === "darwin") {
     try {
       spawn("open", ["/Applications/Codex.app"], { detached: true, stdio: "ignore" });
-      console.log("[codex-copilot-dx] Codex app launched");
+      console.log(status("ok", "Codex app launched"));
     } catch {
-      console.log("[codex-copilot-dx] Codex app not found at /Applications/Codex.app");
-      console.log("  Download from: https://openai.com/codex");
+      console.log(status("warn", "Codex app not found at /Applications/Codex.app"));
+      console.log(status("info", "Download Codex from https://openai.com/codex"));
     }
   } else {
-    console.log("[codex-copilot-dx] Auto-launch not supported on this platform.");
-    console.log("  Open Codex manually, it will connect to the adapter.");
+    console.log(status("warn", "Auto-launch is not supported on this platform"));
+    console.log(status("info", "Open Codex manually; it will connect to the adapter."));
   }
 }

package/src/status.mjs

@@ -0,0 +1,11 @@
+const LABELS = {
+  info: "[INFO]",
+  ok: "[OK]",
+  wait: "[WAIT]",
+  warn: "[WARN]",
+  err: "[ERR]",
+};
+
+export function status(kind, message) {
+  return `${LABELS[kind] || LABELS.info} ${message}`;
+}

package/src/stream.mjs

@@ -0,0 +1,22 @@
+// Yield fetch Response body lines while preserving SSE semantics for callers.
+// Strip CRLF tails and release the reader if iteration stops early.
+export async function* webStreamLines(response) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop();
+      for (const line of lines) yield line.replace(/\r$/, "");
+    }
+    buf += decoder.decode();
+    if (buf.length > 0) yield buf.replace(/\r$/, "");
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}