codex-copilot-dx 0.1.6 → 0.4.0

package/src/anthropic.mjs

@@ -0,0 +1,267 @@
+import { randomUUID } from "node:crypto";
+import { encode } from "gpt-tokenizer";
+
+// Anthropic Messages API to OpenAI chat/completions translation.
+// Pure functions only; network calls stay in adapter.mjs and copilot.mjs.
+
+export function mapStopReason(finishReason) {
+  switch (finishReason) {
+    case "stop": return "end_turn";
+    case "tool_calls": return "tool_use";
+    case "length": return "max_tokens";
+    default: return "end_turn";
+  }
+}
+
+// Convert a string or text-block system field into one system message.
+function systemToText(system) {
+  if (!system) return null;
+  if (typeof system === "string") return system;
+  if (Array.isArray(system)) return system.map((b) => (typeof b === "string" ? b : b.text || "")).join("\n");
+  return null;
+}
+
+// Convert tool_result content into the string payload expected by OpenAI tool messages.
+function toolResultContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => (b.type === "text" ? b.text : typeof b === "string" ? b : JSON.stringify(b))).join("");
+  }
+  return JSON.stringify(content);
+}
+
+// Convert one Anthropic message into zero or more OpenAI messages.
+function convertMessage(msg) {
+  const out = [];
+  const role = msg.role; // "user" | "assistant"
+
+  if (typeof msg.content === "string") {
+    out.push({ role, content: msg.content });
+    return out;
+  }
+  if (!Array.isArray(msg.content)) return out;
+
+  // tool_result blocks must become independent role:"tool" messages.
+  const toolResults = msg.content.filter((b) => b.type === "tool_result");
+  for (const tr of toolResults) {
+    out.push({ role: "tool", tool_call_id: tr.tool_use_id, content: toolResultContent(tr.content) });
+  }
+
+  // Convert remaining text, image, and tool_use blocks.
+  const textImageParts = [];
+  const toolCalls = [];
+  for (const b of msg.content) {
+    if (b.type === "text") {
+      textImageParts.push({ type: "text", text: b.text });
+    } else if (b.type === "image") {
+      const url = b.source?.type === "url"
+        ? b.source.url
+        : `data:${b.source.media_type};base64,${b.source.data}`;
+      textImageParts.push({ type: "image_url", image_url: { url } });
+    } else if (b.type === "tool_use") {
+      toolCalls.push({ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) } });
+    }
+  }
+
+  if (toolCalls.length > 0) {
+    const m = { role, content: null, tool_calls: toolCalls };
+    if (textImageParts.length === 1 && textImageParts[0].type === "text") m.content = textImageParts[0].text;
+    else if (textImageParts.length > 0) m.content = textImageParts;
+    out.push(m);
+  } else if (textImageParts.length > 0) {
+    if (textImageParts.length === 1 && textImageParts[0].type === "text") {
+      out.push({ role, content: textImageParts[0].text });
+    } else {
+      out.push({ role, content: textImageParts });
+    }
+  }
+  return out;
+}
+
+function mapToolChoice(tc) {
+  if (!tc) return undefined;
+  switch (tc.type) {
+    case "auto": return "auto";
+    case "none": return "none";
+    case "any": return "required";
+    case "tool": return { type: "function", function: { name: tc.name } };
+    default: return undefined;
+  }
+}
+
+export function anthropicToChat(body) {
+  const messages = [];
+  const sys = systemToText(body.system);
+  if (sys) messages.push({ role: "system", content: sys });
+  for (const m of body.messages || []) {
+    for (const converted of convertMessage(m)) messages.push(converted);
+  }
+
+  const chatReq = { model: body.model, messages };
+  if (body.max_tokens !== undefined) chatReq.max_tokens = body.max_tokens;
+  if (body.temperature !== undefined) chatReq.temperature = body.temperature;
+  if (body.top_p !== undefined) chatReq.top_p = body.top_p;
+  if (Array.isArray(body.stop_sequences) && body.stop_sequences.length) chatReq.stop = body.stop_sequences;
+
+  if (Array.isArray(body.tools) && body.tools.length) {
+    chatReq.tools = body.tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    }));
+  }
+  const tc = mapToolChoice(body.tool_choice);
+  if (tc !== undefined) chatReq.tool_choice = tc;
+
+  return chatReq;
+}
+
+function uid() { return randomUUID().replace(/-/g, ""); }
+
+export function chatToAnthropic(openaiResp, model) {
+  const choice = openaiResp.choices?.[0];
+  const msg = choice?.message || {};
+  const content = [];
+
+  if (msg.content) content.push({ type: "text", text: msg.content });
+  if (Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      let input = {};
+      try { input = JSON.parse(tc.function.arguments || "{}"); } catch { input = {}; }
+      content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+    }
+  }
+
+  const u = openaiResp.usage || {};
+  const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
+  const usage = {
+    input_tokens: (u.prompt_tokens ?? 0) - cached,
+    output_tokens: u.completion_tokens ?? 0,
+  };
+  if (cached > 0) usage.cache_read_input_tokens = cached;
+
+  return {
+    id: `msg_${uid()}`,
+    type: "message",
+    role: "assistant",
+    model: openaiResp.model || model,
+    content,
+    stop_reason: mapStopReason(choice?.finish_reason),
+    stop_sequence: null,
+    usage,
+  };
+}
+
+// Consume OpenAI chat SSE lines and emit Anthropic SSE events.
+export async function streamAnthropicFromLines(lineIterator, emit, model) {
+  const msgId = `msg_${uid()}`;
+  let started = false;
+  let blockIndex = -1;
+  let textOpen = false;
+  let actualModel = model;
+  let finishReason = null;
+  const toolBlocks = {}; // openaiIndex -> { anthropicIndex }
+  let sawToolUse = false;
+  let outputTokens = 0;
+
+  const ensureStart = () => {
+    if (started) return;
+    started = true;
+    emit("message_start", { type: "message_start", message: {
+      id: msgId, type: "message", role: "assistant", model: actualModel,
+      content: [], stop_reason: null, stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    } });
+  };
+
+  const openText = () => {
+    if (textOpen) return;
+    blockIndex += 1;
+    textOpen = true;
+    emit("content_block_start", { type: "content_block_start", index: blockIndex,
+      content_block: { type: "text", text: "" } });
+  };
+  const closeText = () => {
+    if (!textOpen) return;
+    emit("content_block_stop", { type: "content_block_stop", index: blockIndex });
+    textOpen = false;
+  };
+
+  for await (const line of lineIterator) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    if (data === "[DONE]") break;
+    let parsed;
+    try { parsed = JSON.parse(data); } catch { continue; }
+    if (parsed.model) actualModel = parsed.model;
+    if (parsed.usage?.completion_tokens != null) outputTokens = parsed.usage.completion_tokens;
+    const choice = parsed.choices?.[0];
+    if (!choice) continue;
+    const delta = choice.delta || {};
+    ensureStart();
+
+    if (delta.content && !sawToolUse) {
+      openText();
+      emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
+        delta: { type: "text_delta", text: delta.content } });
+    }
+
+    if (Array.isArray(delta.tool_calls)) {
+      sawToolUse = true;
+      closeText();
+      for (const tc of delta.tool_calls) {
+        const oi = tc.index ?? 0;
+        if (!toolBlocks[oi]) {
+          blockIndex += 1;
+          toolBlocks[oi] = { anthropicIndex: blockIndex };
+          emit("content_block_start", { type: "content_block_start", index: blockIndex,
+            content_block: { type: "tool_use", id: tc.id || `tu_${uid()}`, name: tc.function?.name || "", input: {} } });
+        }
+        if (tc.function?.arguments) {
+          emit("content_block_delta", { type: "content_block_delta", index: toolBlocks[oi].anthropicIndex,
+            delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
+        }
+      }
+    }
+
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+  }
+
+  ensureStart();
+  if (textOpen) closeText();
+  for (const oi of Object.keys(toolBlocks)) {
+    emit("content_block_stop", { type: "content_block_stop", index: toolBlocks[oi].anthropicIndex });
+  }
+
+  const stop_reason = finishReason ? mapStopReason(finishReason) : (sawToolUse ? "tool_use" : "end_turn");
+  emit("message_delta", { type: "message_delta", delta: { stop_reason, stop_sequence: null },
+    usage: { output_tokens: outputTokens } });
+  emit("message_stop", { type: "message_stop" });
+}
+
+// Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
+export function countTokens(body) {
+  const parts = [];
+  const sys = systemToText(body.system);
+  if (sys) parts.push(sys);
+
+  for (const m of body.messages || []) {
+    if (typeof m.content === "string") {
+      parts.push(m.content);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") parts.push(b.text);
+        else if (b.type === "tool_use") parts.push(b.name + JSON.stringify(b.input ?? {}));
+        else if (b.type === "tool_result") parts.push(toolResultContent(b.content));
+      }
+    }
+  }
+
+  if (Array.isArray(body.tools)) {
+    for (const t of body.tools) {
+      parts.push(t.name + (t.description || "") + JSON.stringify(t.input_schema || {}));
+    }
+  }
+
+  const text = parts.join("\n");
+  return { input_tokens: encode(text).length };
+}

package/src/auth.mjs

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { status } from "./status.mjs";
+
+const CLIENT_ID = "Iv1.b507a08c87ecfe98"; // Public GitHub Copilot client ID.
+const SCOPE = "read:user";
+const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
+
+// Map GitHub polling responses to a small local state machine.
+export function interpretPoll(data) {
+  if (typeof data.access_token === "string" && data.access_token) return { state: "done", token: data.access_token };
+  switch (data.error) {
+    case "authorization_pending": return { state: "wait" };
+    case "slow_down": return { state: "slow" };
+    default: return { state: "fail", error: data.error || "unknown" };
+  }
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+// On macOS, copy the user code and open the verification page. Fail quietly.
+function openAndCopy(userCode, verificationUri) {
+  if (process.platform !== "darwin") return;
+  try {
+    const pb = spawn("pbcopy");
+    pb.on("error", () => {});
+    pb.stdin.on("error", () => {});
+    pb.on("close", (code) => {
+      if (code === 0) console.log(status("ok", "Device code copied to the clipboard"));
+    });
+    pb.stdin.write(userCode);
+    pb.stdin.end();
+  } catch {}
+  try {
+    const op = spawn("open", [verificationUri], { detached: true, stdio: "ignore" });
+    op.on("error", () => {});
+  } catch {}
+}
+
+export async function ensureAuth() {
+  if (fs.existsSync(GITHUB_TOKEN_PATH)) {
+    console.log(status("ok", "GitHub token found"));
+    return;
+  }
+  console.log(status("wait", "No GitHub token found. Starting device login..."));
+
+  // Request a device code.
+  const codeResp = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID, scope: SCOPE }),
+  });
+  if (!codeResp.ok) throw new Error(`device code request failed: ${codeResp.status}`);
+  const { device_code, user_code, verification_uri, interval } = await codeResp.json();
+
+  // Prompt the user.
+  console.log(`\n${status("info", `Open ${verification_uri}`)}\n${status("info", `Enter code: ${user_code}`)}\n`);
+  openAndCopy(user_code, verification_uri);
+
+  // Poll until GitHub completes the device flow.
+  let waitMs = (interval || 5) * 1000;
+  while (true) {
+    await sleep(waitMs);
+    const pollResp = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    });
+    if (!pollResp.ok) {
+      // Treat transient network/server errors as pending and retry.
+      continue;
+    }
+    const data = await pollResp.json();
+    const r = interpretPoll(data);
+    if (r.state === "done") {
+      writeToken(r.token);
+      console.log(status("ok", "Login successful"));
+      return;
+    }
+    if (r.state === "slow") { waitMs += 5000; continue; }
+    if (r.state === "fail") throw new Error(`Login failed: ${r.error}`);
+    // wait: continue polling.
+  }
+}
+
+function writeToken(token) {
+  fs.mkdirSync(path.dirname(GITHUB_TOKEN_PATH), { recursive: true });
+  fs.writeFileSync(GITHUB_TOKEN_PATH, token, { mode: 0o600 });
+}

package/src/claude-config.mjs

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { status } from "./status.mjs";
+
+const SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+
+// Return an updated settings object without mutating the input.
+export function computeUpdatedSettings(settings, port) {
+  const target = `http://localhost:${port}`;
+  const current = settings?.env?.ANTHROPIC_BASE_URL;
+  const currentToken = settings?.env?.ANTHROPIC_AUTH_TOKEN;
+  const changed = current !== target || currentToken !== "dummy";
+  const json = {
+    ...settings,
+    env: {
+      ...(settings?.env || {}),
+      ANTHROPIC_BASE_URL: target,
+      ANTHROPIC_AUTH_TOKEN: "dummy",
+    },
+  };
+  return { json, changed };
+}
+
+// Point Claude Code at the adapter by updating ~/.claude/settings.json.
+export function ensureClaudeConfig(port = 2026) {
+  const target = `http://localhost:${port}`;
+
+  if (!fs.existsSync(SETTINGS_PATH)) {
+    fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+    const { json } = computeUpdatedSettings({}, port);
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(json, null, 2) + "\n");
+    console.log(status("ok", `Created ~/.claude/settings.json for Claude Code at ${target}`));
+    return;
+  }
+
+  let raw, settings;
+  try {
+    raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+    settings = JSON.parse(raw);
+  } catch (e) {
+    console.log(status("warn", `Could not parse ~/.claude/settings.json: ${e.message}`));
+    console.log(status("info", "Fix the JSON file and rerun codex-copilot-dx to configure Claude Code automatically."));
+    return;
+  }
+
+  const { json, changed } = computeUpdatedSettings(settings, port);
+  if (!changed) {
+    console.log(status("ok", `Claude Code already points to ${target}`));
+    return;
+  }
+
+  fs.writeFileSync(`${SETTINGS_PATH}.bak`, raw);
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(json, null, 2) + "\n");
+  console.log(status("ok", `Configured Claude Code ANTHROPIC_BASE_URL="${target}" and backed up settings.json.bak`));
+}

package/src/config.mjs

@@ -1,33 +1,93 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { status } from "./status.mjs";
 
 const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 
-export function ensureCodexConfig(adapterPort = 4142) {
+function setTomlKey(lines, sectionName, key, value) {
+  const sectionLine = `[${sectionName}]`;
+  const start = lines.findIndex((line) => line.trim() === sectionLine);
+  if (start === -1) return false;
+
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+
+  const nextLine = `${key} = "${value}"`;
+  const keyRe = new RegExp(`^\\s*${key}\\s*=`);
+  for (let i = start + 1; i < end; i++) {
+    if (keyRe.test(lines[i])) {
+      const changed = lines[i] !== nextLine;
+      lines[i] = nextLine;
+      return changed;
+    }
+  }
+
+  lines.splice(end, 0, nextLine);
+  return true;
+}
+
+export function computeUpdatedCodexConfig(content, adapterPort = 2026) {
+  const baseUrl = `http://localhost:${adapterPort}/v1`;
+  const anthropicBaseUrl = `http://localhost:${adapterPort}`;
+  const hadTrailingNewline = content.endsWith("\n");
+  const lines = content.split("\n");
+  if (hadTrailingNewline) lines.pop();
+
+  let changed = false;
+  const openaiLine = `openai_base_url = "${baseUrl}"`;
+  const openaiIndex = lines.findIndex((line) => /^openai_base_url\s*=/.test(line));
+  if (openaiIndex === -1) {
+    lines.unshift(openaiLine);
+    changed = true;
+  } else if (lines[openaiIndex] !== openaiLine) {
+    lines[openaiIndex] = openaiLine;
+    changed = true;
+  }
+
+  changed = setTomlKey(lines, "shell_environment_policy.set", "ANTHROPIC_AUTH_TOKEN", "dummy") || changed;
+  changed = setTomlKey(lines, "shell_environment_policy.set", "ANTHROPIC_BASE_URL", anthropicBaseUrl) || changed;
+  changed = setTomlKey(lines, "shell_environment_policy.set", "OPENAI_BASE_URL", baseUrl) || changed;
+  changed = setTomlKey(lines, "shell_environment_policy.set", "OPENAI_API_KEY", "dummy") || changed;
+
+  return { content: lines.join("\n") + (hadTrailingNewline ? "\n" : ""), changed };
+}
+
+function initialCodexConfig(adapterPort) {
+  const baseUrl = `http://localhost:${adapterPort}/v1`;
+  const anthropicBaseUrl = `http://localhost:${adapterPort}`;
+  return `openai_base_url = "${baseUrl}"
+
+[shell_environment_policy]
+inherit = "core"
+
+[shell_environment_policy.set]
+ANTHROPIC_AUTH_TOKEN = "dummy"
+ANTHROPIC_BASE_URL = "${anthropicBaseUrl}"
+OPENAI_BASE_URL = "${baseUrl}"
+OPENAI_API_KEY = "dummy"
+`;
+}
+
+export function ensureCodexConfig(adapterPort = 2026) {
   const baseUrl = `http://localhost:${adapterPort}/v1`;
 
   if (!fs.existsSync(CONFIG_PATH)) {
-    // Codex not installed yet, create minimal config
+    // Codex config does not exist yet; create the local proxy defaults.
     fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
-    fs.writeFileSync(CONFIG_PATH, `openai_base_url = "${baseUrl}"\n`);
-    console.log("[codex-copilot-dx] Created ~/.codex/config.toml");
+    fs.writeFileSync(CONFIG_PATH, initialCodexConfig(adapterPort));
+    console.log(status("ok", "Created ~/.codex/config.toml"));
     return;
   }
 
   let content = fs.readFileSync(CONFIG_PATH, "utf-8");
+  const updated = computeUpdatedCodexConfig(content, adapterPort);
 
-  if (content.includes("openai_base_url")) {
-    // Update existing
-    content = content.replace(
-      /openai_base_url\s*=\s*"[^"]*"/,
-      `openai_base_url = "${baseUrl}"`,
-    );
-  } else {
-    // Add at top of file
-    content = `openai_base_url = "${baseUrl}"\n` + content;
-  }
-
-  fs.writeFileSync(CONFIG_PATH, content);
-  console.log(`[codex-copilot-dx] Configured openai_base_url = "${baseUrl}"`);
+  fs.writeFileSync(CONFIG_PATH, updated.content);
+  console.log(status("ok", `Configured Codex base URL: ${baseUrl}`));
 }