codex-copilot-dx 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# codex-copilot-dx
+
+Use [Codex Desktop](https://openai.com/codex) app with your **GitHub Copilot** subscription.
+
+## How it works
+
+Codex Desktop uses OpenAI's Responses API (`/v1/responses`), which isn't directly exposed by the GitHub Copilot API proxy. This tool bridges the gap:
+
+- **GPT-5.5, GPT-5.4** and other Responses-only models → proxied directly to `api.githubcopilot.com/v1/responses`
+- **GPT-4o, GPT-4.1** and other chat models → converted from Responses API to Chat Completions format via `copilot-api`
+
+Supports both HTTP SSE streaming and WebSocket connections.
+
+## Prerequisites
+
+- [Codex Desktop](https://openai.com/codex) app installed
+- GitHub Copilot subscription (Individual, Business, or Enterprise)
+- Node.js 18+
+
+## Usage
+
+```bash
+npx codex-copilot-dx
+```
+
+On first run, it will:
+1. Authenticate with GitHub via device flow (if needed)
+2. Start `copilot-api` proxy (port 4141)
+3. Start the Responses API adapter (port 4142)
+4. Configure Codex to use the adapter
+5. Launch Codex Desktop
+
+## Configuration
+
+Environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `COPILOT_API_PORT` | `4141` | Port for copilot-api |
+| `ADAPTER_PORT` | `4142` | Port for the adapter |
+
+## License
+
+MIT

package/bin/cli.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { ensureAuth, startCopilotApi, openCodex } from "../src/launcher.mjs";
+import { ensureCodexConfig } from "../src/config.mjs";
+import { startAdapter } from "../src/adapter.mjs";
+
+const COPILOT_PORT = parseInt(process.env.COPILOT_API_PORT || "4141");
+const ADAPTER_PORT = parseInt(process.env.ADAPTER_PORT || "4142");
+
+console.log(`
+  codex-copilot-dx
+  Use Codex Desktop with GitHub Copilot
+`);
+
+try {
+  // 1. Ensure GitHub auth
+  await ensureAuth();
+
+  // 2. Start copilot-api (for legacy models)
+  const copilotProc = await startCopilotApi(COPILOT_PORT);
+
+  // 3. Start adapter
+  await startAdapter(ADAPTER_PORT);
+
+  // 4. Configure Codex
+  ensureCodexConfig(ADAPTER_PORT);
+
+  // 5. Launch Codex
+  openCodex();
+
+  console.log(`
+  Ready! Codex is using your GitHub Copilot subscription.
+
+  Adapter:     http://localhost:${ADAPTER_PORT}
+  copilot-api: http://localhost:${COPILOT_PORT}
+
+  Press Ctrl+C to stop.
+`);
+
+  // Keep alive
+  process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    copilotProc?.kill();
+    process.exit(0);
+  });
+} catch (e) {
+  console.error(`Error: ${e.message}`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "codex-copilot-dx",
+  "version": "0.1.0",
+  "description": "Use Codex Desktop app with your GitHub Copilot subscription",
+  "type": "module",
+  "bin": {
+    "codex-copilot-dx": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "codex",
+    "copilot",
+    "github",
+    "openai",
+    "proxy",
+    "responses-api"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "copilot-api": "^0.7.0"
+  }
+}

package/src/adapter.mjs

@@ -0,0 +1,371 @@
+import http from "node:http";
+import https from "node:https";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomUUID, createHash } from "node:crypto";
+
+const COPILOT_API_PORT = parseInt(process.env.COPILOT_API_PORT || "4141");
+const COPILOT_API = "https://api.githubcopilot.com";
+const GITHUB_API = "https://api.github.com";
+
+// Models that only support Responses API (not chat/completions)
+const RESPONSES_ONLY = new Set([
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.3-codex",
+  "gpt-5.2-codex",
+]);
+
+// ── Copilot Token ──
+
+let copilotToken = null;
+let copilotTokenExpiry = 0;
+
+function getGithubToken() {
+  const p = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
+  if (!fs.existsSync(p)) throw new Error("GitHub token not found. Run: npx copilot-api auth");
+  return fs.readFileSync(p, "utf-8").trim();
+}
+
+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();
+  copilotToken = data.token;
+  copilotTokenExpiry = data.expires_at * 1000;
+  console.log("[codex-copilot-dx] Copilot token refreshed");
+  return copilotToken;
+}
+
+// ── Direct Copilot Responses API proxy ──
+
+async function proxyCopilotResponses(reqBody, req, res) {
+  const token = await getCopilotToken();
+  const resp = await fetch(`${COPILOT_API}/v1/responses`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Editor-Version": "vscode/1.90.0",
+      "Copilot-Integration-Id": "vscode-chat",
+    },
+    body: JSON.stringify(reqBody),
+  });
+
+  if (reqBody.stream) {
+    res.writeHead(resp.status, {
+      "Content-Type": resp.headers.get("content-type") || "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+    const reader = resp.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) { res.end(); return; }
+      res.write(value);
+    }
+  } else {
+    const data = await resp.text();
+    res.writeHead(resp.status, { "Content-Type": "application/json" });
+    res.end(data);
+  }
+}
+
+async function proxyCopilotResponsesWS(reqBody, wsSend, onDone) {
+  const token = await getCopilotToken();
+  const resp = await fetch(`${COPILOT_API}/v1/responses`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Editor-Version": "vscode/1.90.0",
+      "Copilot-Integration-Id": "vscode-chat",
+    },
+    body: JSON.stringify({ ...reqBody, stream: true }),
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text();
+    wsSend(JSON.stringify({ type: "error", error: { message: err, code: resp.status } }));
+    onDone();
+    return;
+  }
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  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) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") continue;
+      try { wsSend(JSON.stringify(JSON.parse(data))); } catch {}
+    }
+  }
+  onDone();
+}
+
+// ── Chat Completions conversion (for older models via copilot-api) ──
+
+function responsesToChat(body) {
+  const messages = [];
+  if (body.instructions) messages.push({ role: "system", content: body.instructions });
+
+  if (typeof body.input === "string") {
+    messages.push({ role: "user", content: body.input });
+  } else if (Array.isArray(body.input)) {
+    for (const item of body.input) {
+      if (item.type === "message") {
+        const content =
+          typeof item.content === "string"
+            ? item.content
+            : Array.isArray(item.content)
+              ? item.content.map((p) => (p.type === "input_text" || p.type === "text" ? p.text : JSON.stringify(p))).join("")
+              : JSON.stringify(item.content);
+        messages.push({ role: item.role, content });
+      } else if (item.type === "function_call") {
+        messages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [{ id: item.call_id || randomUUID(), type: "function", function: { name: item.name, arguments: item.arguments } }],
+        });
+      } else if (item.type === "function_call_output") {
+        messages.push({ role: "tool", tool_call_id: item.call_id, content: typeof item.output === "string" ? item.output : JSON.stringify(item.output) });
+      }
+    }
+  }
+
+  const chatReq = { model: body.model, messages, stream: true };
+  for (const k of ["temperature", "top_p", "stop", "presence_penalty", "frequency_penalty"]) {
+    if (body[k] !== undefined) chatReq[k] = body[k];
+  }
+  const maxTok = body.max_output_tokens ?? body.max_tokens ?? body.max_completion_tokens;
+  if (maxTok !== undefined) chatReq.max_completion_tokens = maxTok;
+
+  if (body.tools?.length) {
+    chatReq.tools = body.tools
+      .map((t) => (t.type === "function" ? t : { type: "function", function: t }))
+      .filter((t) => t.function?.name);
+    if (!chatReq.tools.length) delete chatReq.tools;
+  }
+  return chatReq;
+}
+
+function uid() { return randomUUID().replace(/-/g, ""); }
+
+function chatToResponses(chatResp, model) {
+  const id = `resp_${uid()}`, choice = chatResp.choices?.[0], msg = choice?.message, output = [];
+  if (msg?.content) output.push({ type: "message", id: `msg_${uid()}`, role: "assistant", status: "completed", content: [{ type: "output_text", text: msg.content }] });
+  if (msg?.tool_calls) for (const tc of msg.tool_calls) output.push({ type: "function_call", id: tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments, status: "completed" });
+  return { id, object: "response", status: "completed", model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
+}
+
+function processStream(upstreamRes, emitEvent, onDone) {
+  const respId = `resp_${uid()}`, itemId = `item_${uid()}`;
+  let actualModel = "unknown";
+
+  emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
+  emitEvent("response.output_item.added", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "in_progress", content: [] } });
+  emitEvent("response.content_part.added", { output_index: 0, content_index: 0, part: { type: "output_text", text: "" } });
+
+  let buf = "", fullText = "", toolCalls = {}, hasToolCalls = false;
+
+  upstreamRes.on("data", (chunk) => {
+    buf += chunk.toString();
+    let lines = buf.split("\n");
+    buf = lines.pop();
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") {
+        if (!hasToolCalls) {
+          emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
+          emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
+        }
+        const output = hasToolCalls
+          ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
+          : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
+        emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
+        onDone();
+        return;
+      }
+      let parsed;
+      try { parsed = JSON.parse(data); } catch { continue; }
+      if (parsed.model) actualModel = parsed.model;
+      const delta = parsed.choices?.[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) { fullText += delta.content; emitEvent("response.output_text.delta", { output_index: 0, content_index: 0, delta: delta.content }); }
+      if (delta.tool_calls) {
+        hasToolCalls = true;
+        for (const tc of delta.tool_calls) {
+          const id = tc.id || Object.keys(toolCalls)[tc.index] || `call_${tc.index}`;
+          if (!toolCalls[id]) { toolCalls[id] = { name: "", arguments: "" }; emitEvent("response.output_item.added", { output_index: Object.keys(toolCalls).length - 1, item: { type: "function_call", id, call_id: id, name: tc.function?.name || "", arguments: "", status: "in_progress" } }); }
+          if (tc.function?.name) toolCalls[id].name += tc.function.name;
+          if (tc.function?.arguments) toolCalls[id].arguments += tc.function.arguments;
+        }
+      }
+    }
+  });
+  upstreamRes.on("end", () => onDone());
+  upstreamRes.on("error", () => onDone());
+}
+
+function forwardToChat(chatReq, emitEvent, onDone, onError) {
+  delete chatReq.max_tokens;
+  const body = JSON.stringify(chatReq);
+  const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: "/v1/chat/completions", method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } };
+  const proxy = http.request(opts, (upRes) => {
+    if (upRes.statusCode !== 200) { let d = ""; upRes.on("data", c => d += c); upRes.on("end", () => onError(upRes.statusCode, d)); return; }
+    processStream(upRes, emitEvent, onDone);
+  });
+  proxy.on("error", (e) => onError(502, e.message));
+  proxy.write(body);
+  proxy.end();
+}
+
+// ── WebSocket (RFC 6455 minimal) ──
+
+function wsRead(socket) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const onData = (data) => {
+      chunks.push(data);
+      const buf = Buffer.concat(chunks);
+      if (buf.length < 2) return;
+      const masked = (buf[1] & 0x80) !== 0;
+      let payloadLen = buf[1] & 0x7f, offset = 2;
+      if (payloadLen === 126) { if (buf.length < 4) return; payloadLen = buf.readUInt16BE(2); offset = 4; }
+      else if (payloadLen === 127) { if (buf.length < 10) return; payloadLen = Number(buf.readBigUInt64BE(2)); offset = 10; }
+      const maskLen = masked ? 4 : 0;
+      if (buf.length < offset + maskLen + payloadLen) return;
+      let payload = buf.slice(offset + maskLen, offset + maskLen + payloadLen);
+      if (masked) { const mask = buf.slice(offset, offset + 4); for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i % 4]; }
+      socket.removeListener("data", onData);
+      const opcode = buf[0] & 0x0f;
+      if (opcode === 0x8) resolve(null);
+      else if (opcode === 0x9) { wsSend(socket, "", 0xa); chunks.length = 0; socket.on("data", onData); }
+      else resolve(payload.toString("utf-8"));
+    };
+    socket.on("data", onData);
+    socket.on("error", reject);
+    socket.on("close", () => resolve(null));
+  });
+}
+
+function wsSend(socket, data, opcode = 0x1) {
+  const payload = typeof data === "string" ? Buffer.from(data) : data;
+  const len = payload.length;
+  let header;
+  if (len < 126) { header = Buffer.alloc(2); header[0] = 0x80 | opcode; header[1] = len; }
+  else if (len < 65536) { header = Buffer.alloc(4); header[0] = 0x80 | opcode; header[1] = 126; header.writeUInt16BE(len, 2); }
+  else { header = Buffer.alloc(10); header[0] = 0x80 | opcode; header[1] = 127; header.writeBigUInt64BE(BigInt(len), 2); }
+  try { socket.write(Buffer.concat([header, payload])); } catch {}
+}
+
+async function handleWebSocket(req, socket) {
+  const key = req.headers["sec-websocket-key"];
+  const accept = createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-5AB9FC6AB199").digest("base64");
+  socket.write("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " + accept + "\r\n\r\n");
+
+  while (true) {
+    const msg = await wsRead(socket);
+    if (msg === null) break;
+    let parsed;
+    try { parsed = JSON.parse(msg); } catch { continue; }
+    let reqBody = parsed;
+    if (parsed.type === "response.create" && parsed.response) reqBody = parsed.response;
+    const model = reqBody.model || "unknown";
+
+    if (RESPONSES_ONLY.has(model)) {
+      proxyCopilotResponsesWS(reqBody, (d) => wsSend(socket, d), () => {}).catch((e) => {
+        wsSend(socket, JSON.stringify({ type: "error", error: { message: e.message, code: 500 } }));
+      });
+    } else {
+      const chatReq = responsesToChat(reqBody);
+      chatReq.stream = true;
+      forwardToChat(chatReq, (event, data) => wsSend(socket, JSON.stringify({ type: event, ...data })), () => {}, (status, errMsg) => {
+        wsSend(socket, JSON.stringify({ type: "error", error: { message: errMsg, code: status } }));
+      });
+    }
+  }
+}
+
+// ── HTTP passthrough ──
+
+function proxyPassthrough(req, res) {
+  const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: req.url, method: req.method, headers: { ...req.headers, host: `localhost:${COPILOT_API_PORT}` } };
+  const proxy = http.request(opts, (upRes) => { res.writeHead(upRes.statusCode, upRes.headers); upRes.pipe(res); });
+  proxy.on("error", () => { if (!res.headersSent) res.writeHead(502); res.end("Bad Gateway"); });
+  req.pipe(proxy);
+}
+
+// ── Export ──
+
+export function startAdapter(port = 4142) {
+  const server = http.createServer((req, res) => {
+    if (req.method === "POST" && req.url?.startsWith("/v1/responses")) {
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", async () => {
+        try {
+          const parsed = JSON.parse(body);
+          const model = parsed.model || "unknown";
+          console.log(`[codex-copilot-dx] ${model} stream=${!!parsed.stream}`);
+          if (RESPONSES_ONLY.has(model)) {
+            await proxyCopilotResponses(parsed, req, res);
+          } else {
+            const chatReq = responsesToChat(parsed);
+            if (parsed.stream) {
+              forwardToChat(chatReq, (event, data) => {
+                if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+                res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+              }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); });
+            } else {
+              chatReq.stream = false;
+              delete chatReq.max_tokens;
+              const reqBody = JSON.stringify(chatReq);
+              const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: "/v1/chat/completions", method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(reqBody) } };
+              const proxy = http.request(opts, (upRes) => {
+                let data = ""; upRes.on("data", (c) => (data += c));
+                upRes.on("end", () => { try { const resp = chatToResponses(JSON.parse(data), model); res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(resp)); } catch { res.writeHead(500).end("Parse error"); } });
+              });
+              proxy.on("error", () => res.writeHead(502).end("Bad Gateway"));
+              proxy.write(reqBody);
+              proxy.end();
+            }
+          }
+        } catch (e) {
+          console.error("[codex-copilot-dx] error:", e.message);
+          if (!res.headersSent) res.writeHead(400);
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      return;
+    }
+    proxyPassthrough(req, res);
+  });
+
+  server.on("upgrade", (req, socket) => {
+    if (req.url?.startsWith("/v1/responses")) {
+      handleWebSocket(req, socket).catch((e) => { console.error("[codex-copilot-dx] WS error:", e.message); socket.destroy(); });
+    } else socket.destroy();
+  });
+
+  return new Promise((resolve) => {
+    server.listen(port, () => {
+      console.log(`[codex-copilot-dx] Adapter listening on http://localhost:${port}`);
+      resolve(server);
+    });
+  });
+}

package/src/config.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
+
+export function ensureCodexConfig(adapterPort = 4142) {
+  const baseUrl = `http://localhost:${adapterPort}/v1`;
+
+  if (!fs.existsSync(CONFIG_PATH)) {
+    // Codex not installed yet, create minimal config
+    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");
+    return;
+  }
+
+  let content = fs.readFileSync(CONFIG_PATH, "utf-8");
+
+  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}"`);
+}

package/src/launcher.mjs

@@ -0,0 +1,88 @@
+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";
+
+const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
+
+function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(true));
+    server.once("listening", () => { server.close(); resolve(false); });
+    server.listen(port);
+  });
+}
+
+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 isPortInUse(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 isPortInUse(port)) {
+      console.log(`[codex-copilot-dx] copilot-api ready on :${port}`);
+      return child;
+    }
+  }
+  throw new Error("copilot-api failed to start");
+}
+
+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");
+    } catch {
+      console.log("[codex-copilot-dx] Codex app not found at /Applications/Codex.app");
+      console.log("  Download 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.");
+  }
+}