@engineeros/connector 0.11.2 → 0.12.2

package/src/codex-app-server.mjs

@@ -1,218 +1,246 @@
-import { spawn } from "node:child_process";
-import readline from "node:readline";
-
-export async function inspectCodexExecutionProfiles({
-  workspace,
-  command = process.env.CODEX_BIN || (process.platform === "win32" ? "codex.cmd" : "codex"),
-  spawnProcess = spawn,
-  timeoutMs = 15_000,
-}) {
-  const child = spawnProcess(command, ["app-server", "--stdio"], {
-    cwd: workspace,
-    env: process.env,
-    shell: process.platform === "win32",
-    windowsHide: true,
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-  const pending = new Map();
-  let requestId = 0;
-  let stderr = "";
-  const request = (method, params) => new Promise((resolve, reject) => {
-    const id = ++requestId;
-    pending.set(id, { resolve, reject });
-    child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
-  });
-  const lines = readline.createInterface({ input: child.stdout });
-  lines.on("line", (line) => {
-    try {
-      const message = JSON.parse(line);
-      const waiter = pending.get(message.id);
-      if (!waiter) return;
-      pending.delete(message.id);
-      if (message.error) waiter.reject(new Error(message.error.message || "Codex model discovery failed."));
-      else waiter.resolve(message.result);
-    } catch {
-      // Ignore non-protocol output.
-    }
-  });
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk}`.slice(-4_000); });
-  const rejectPending = (message) => {
-    for (const waiter of pending.values()) waiter.reject(new Error(message));
-    pending.clear();
-  };
-  child.once("error", (error) => rejectPending(error.message));
-  child.once("close", (code) => {
-    if (pending.size) rejectPending(`Codex model discovery stopped with code ${code ?? 1}. ${stderr}`.trim());
-  });
-  const timeout = setTimeout(() => {
-    rejectPending("Codex model discovery timed out.");
-    child.kill();
-  }, timeoutMs);
-  try {
-    await request("initialize", {
-      clientInfo: { name: "engineeros-connector", title: "EngineerOS Connector", version: "0.11.0" },
-    });
-    child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
-    const models = [];
-    let cursor = null;
-    do {
-      const result = await request("model/list", { cursor, includeHidden: false });
-      models.push(...(Array.isArray(result?.data) ? result.data : []));
-      cursor = result?.nextCursor || null;
-    } while (cursor);
-    return models.map((item) => ({
-      id: item.model || item.id,
-      name: item.displayName || item.model || item.id,
-      description: item.description || "",
-      is_default: item.isDefault === true,
-      default_reasoning_effort: item.defaultReasoningEffort || null,
-      reasoning_efforts: (item.supportedReasoningEfforts || [])
-        .map((option) => option.reasoningEffort)
-        .filter(Boolean),
-    })).filter((item) => item.id);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${detail}${stderr ? ` ${stderr}` : ""}`.trim());
-  } finally {
-    clearTimeout(timeout);
-    child.kill();
-  }
-}
-
-export function launchCodexAppServer({
-  workspace,
-  prompt,
-  sandbox,
-  profile = {},
-  previousSessionId,
-  callbacks = {},
-  command = process.env.CODEX_BIN || (process.platform === "win32" ? "codex.cmd" : "codex"),
-  spawnProcess = spawn,
-}) {
-  const child = spawnProcess(command, ["app-server", "--stdio"], {
-    cwd: workspace,
-    env: process.env,
-    shell: process.platform === "win32",
-    windowsHide: true,
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-  const pending = new Map();
-  let requestId = 0;
-  let threadId = previousSessionId || "";
-  let turnId = "";
-  let finalMessage = "";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import { normalizeTokenUsage } from "./acp-client.mjs";
+
+export async function inspectCodexExecutionProfiles({
+  workspace,
+  command = process.env.CODEX_BIN || (process.platform === "win32" ? "codex.cmd" : "codex"),
+  spawnProcess = spawn,
+  timeoutMs = 15_000,
+}) {
+  const child = spawnProcess(command, ["app-server", "--stdio"], {
+    cwd: workspace,
+    env: process.env,
+    shell: process.platform === "win32",
+    windowsHide: true,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const pending = new Map();
+  let requestId = 0;
+  let stderr = "";
+  const request = (method, params) => new Promise((resolve, reject) => {
+    const id = ++requestId;
+    pending.set(id, { resolve, reject });
+    child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+  });
+  const lines = readline.createInterface({ input: child.stdout });
+  lines.on("line", (line) => {
+    try {
+      const message = JSON.parse(line);
+      const waiter = pending.get(message.id);
+      if (!waiter) return;
+      pending.delete(message.id);
+      if (message.error) waiter.reject(new Error(message.error.message || "Codex model discovery failed."));
+      else waiter.resolve(message.result);
+    } catch {
+      // Ignore non-protocol output.
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk}`.slice(-4_000); });
+  const rejectPending = (message) => {
+    for (const waiter of pending.values()) waiter.reject(new Error(message));
+    pending.clear();
+  };
+  child.once("error", (error) => rejectPending(error.message));
+  child.once("close", (code) => {
+    if (pending.size) rejectPending(`Codex model discovery stopped with code ${code ?? 1}. ${stderr}`.trim());
+  });
+  const timeout = setTimeout(() => {
+    rejectPending("Codex model discovery timed out.");
+    child.kill();
+  }, timeoutMs);
+  try {
+    await request("initialize", {
+      clientInfo: { name: "engineeros-connector", title: "EngineerOS Connector", version: "0.11.0" },
+    });
+    child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
+    const models = [];
+    let cursor = null;
+    do {
+      const result = await request("model/list", { cursor, includeHidden: false });
+      models.push(...(Array.isArray(result?.data) ? result.data : []));
+      cursor = result?.nextCursor || null;
+    } while (cursor);
+    return models.map((item) => ({
+      id: item.model || item.id,
+      name: item.displayName || item.model || item.id,
+      description: item.description || "",
+      is_default: item.isDefault === true,
+      default_reasoning_effort: item.defaultReasoningEffort || null,
+      reasoning_efforts: (item.supportedReasoningEfforts || [])
+        .map((option) => option.reasoningEffort)
+        .filter(Boolean),
+    })).filter((item) => item.id);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${detail}${stderr ? ` ${stderr}` : ""}`.trim());
+  } finally {
+    clearTimeout(timeout);
+    child.kill();
+  }
+}
+
+export function launchCodexAppServer({
+  workspace,
+  prompt,
+  sandbox,
+  profile = {},
+  previousSessionId,
+  callbacks = {},
+  command = process.env.CODEX_BIN || (process.platform === "win32" ? "codex.cmd" : "codex"),
+  spawnProcess = spawn,
+}) {
+  const child = spawnProcess(command, ["app-server", "--stdio"], {
+    cwd: workspace,
+    env: process.env,
+    shell: process.platform === "win32",
+    windowsHide: true,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const pending = new Map();
+  let requestId = 0;
+  let threadId = previousSessionId || "";
+  let turnId = "";
+  let finalMessage = "";
   let stderr = "";
+  let usage = null;
   let settled = false;
-
-  const request = (method, params) =>
-    new Promise((resolve, reject) => {
-      const id = ++requestId;
-      pending.set(id, { resolve, reject });
-      child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
-    });
-
-  const completed = new Promise((resolve, reject) => {
+  let completionTimer = null;
+
+  const request = (method, params) =>
+    new Promise((resolve, reject) => {
+      const id = ++requestId;
+      pending.set(id, { resolve, reject });
+      child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+    });
+
+  const completed = new Promise((resolve, reject) => {
     const finish = (error) => {
       if (settled) return;
       settled = true;
-      for (const waiter of pending.values()) waiter.reject(error || new Error("Codex app-server stopped."));
-      pending.clear();
-      if (error) reject(error);
-      else resolve({ finalMessage, output: stderr.slice(-20_000), sessionId: threadId });
-    };
-
-    child.once("error", finish);
-    child.once("close", (code) => {
-      if (!settled) finish(new Error(`Codex app-server exited before completing the turn (code ${code ?? 1}). ${stderr}`));
-    });
-
-    const lines = readline.createInterface({ input: child.stdout });
-    lines.on("line", (line) => {
-      let message;
-      try {
-        message = JSON.parse(line);
-      } catch {
-        return;
-      }
-      if (message.id !== undefined) {
-        const waiter = pending.get(message.id);
-        if (!waiter) return;
-        pending.delete(message.id);
-        if (message.error) waiter.reject(new Error(message.error.message || "Codex app-server request failed."));
-        else waiter.resolve(message.result);
-        return;
-      }
-      const params = message.params || {};
-      if (message.method === "item/agentMessage/delta" && typeof params.delta === "string") {
-        finalMessage += params.delta;
-        callbacks.onEvent?.({ type: "codex.agent_message_delta", delta: params.delta });
-      } else if (message.method === "item/started" || message.method === "item/completed") {
-        callbacks.onEvent?.({ type: `codex.${message.method}`, item: params.item });
+      if (completionTimer) clearTimeout(completionTimer);
+      for (const waiter of pending.values()) waiter.reject(error || new Error("Codex app-server stopped."));
+      pending.clear();
+      if (error) reject(error);
+      else resolve({
+        finalMessage,
+        output: stderr.slice(-20_000),
+        model: profile.model || "codex-app-server",
+        sessionId: threadId,
+        usage,
+      });
+    };
+
+    child.once("error", finish);
+    child.once("close", (code) => {
+      if (!settled) finish(new Error(`Codex app-server exited before completing the turn (code ${code ?? 1}). ${stderr}`));
+    });
+
+    const lines = readline.createInterface({ input: child.stdout });
+    lines.on("line", (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (message.id !== undefined) {
+        const waiter = pending.get(message.id);
+        if (!waiter) return;
+        pending.delete(message.id);
+        if (message.error) waiter.reject(new Error(message.error.message || "Codex app-server request failed."));
+        else waiter.resolve(message.result);
+        return;
+      }
+      const params = message.params || {};
+      if (message.method === "item/agentMessage/delta" && typeof params.delta === "string") {
+        finalMessage += params.delta;
+        callbacks.onEvent?.({ type: "codex.agent_message_delta", delta: params.delta });
+      } else if (message.method === "item/started" || message.method === "item/completed") {
+        callbacks.onEvent?.({ type: `codex.${message.method}`, item: params.item });
       } else if (message.method === "thread/tokenUsage/updated") {
+        usage = normalizeTokenUsage(
+          params.last || params.usage || params.tokenUsage?.last || params.tokenUsage || params,
+        );
         callbacks.onEvent?.({ type: "codex.usage", update: params });
+        if (usage && completionTimer) {
+          finish();
+          child.kill();
+        }
       } else if (message.method === "turn/completed" && params.threadId === threadId) {
         const status = params.turn?.status;
-        if (status === "failed") finish(new Error(params.turn?.error?.message || "Codex turn failed."));
-        else if (!finalMessage.trim()) finish(new Error("Codex completed without returning a response."));
-        else finish();
-        child.kill();
-      }
-    });
-
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr = `${stderr}${chunk}`.slice(-20_000);
-    });
-
-    void (async () => {
-      try {
-        await request("initialize", {
-          clientInfo: { name: "engineeros-connector", title: "EngineerOS Connector", version: "0.11.0" },
-        });
-        child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
-        const threadResult = previousSessionId
-          ? await request("thread/resume", {
-              threadId: previousSessionId,
-              cwd: workspace,
-              sandbox,
-              approvalPolicy: "never",
-              model: profile.model || null,
-            })
-          : await request("thread/start", {
-              cwd: workspace,
-              sandbox,
-              approvalPolicy: "never",
-              model: profile.model || null,
-              ephemeral: false,
-            });
-        threadId = threadResult.thread.id;
-        callbacks.onEvent?.({ type: "thread.started", thread_id: threadId });
-        const turnResult = await request("turn/start", {
-          threadId,
-          input: [{ type: "text", text: prompt }],
-          effort: profile.reasoning_effort || null,
-        });
-        turnId = turnResult.turn.id;
-      } catch (error) {
-        child.kill();
-        finish(error instanceof Error ? error : new Error(String(error)));
-      }
-    })();
-  });
-
-  return {
-    child,
-    completed,
-    cancel: async () => {
-      if (threadId && turnId && !settled) {
-        try {
-          await request("turn/interrupt", { threadId, turnId });
-        } catch {
-          // Process termination below is the final cancellation boundary.
+        if (status === "failed") {
+          finish(new Error(params.turn?.error?.message || "Codex turn failed."));
+          child.kill();
+        } else if (!finalMessage.trim()) {
+          finish(new Error("Codex completed without returning a response."));
+          child.kill();
+        } else if (usage) {
+          finish();
+          child.kill();
+        } else if (!completionTimer) {
+          completionTimer = setTimeout(() => {
+            finish();
+            child.kill();
+          }, 250);
         }
       }
-      child.kill();
-    },
-  };
-}
+    });
+
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr = `${stderr}${chunk}`.slice(-20_000);
+    });
+
+    void (async () => {
+      try {
+        await request("initialize", {
+          clientInfo: { name: "engineeros-connector", title: "EngineerOS Connector", version: "0.11.0" },
+        });
+        child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
+        const threadResult = previousSessionId
+          ? await request("thread/resume", {
+              threadId: previousSessionId,
+              cwd: workspace,
+              sandbox,
+              approvalPolicy: "never",
+              model: profile.model || null,
+            })
+          : await request("thread/start", {
+              cwd: workspace,
+              sandbox,
+              approvalPolicy: "never",
+              model: profile.model || null,
+              ephemeral: false,
+            });
+        threadId = threadResult.thread.id;
+        callbacks.onEvent?.({ type: "thread.started", thread_id: threadId });
+        const turnResult = await request("turn/start", {
+          threadId,
+          input: [{ type: "text", text: prompt }],
+          effort: profile.reasoning_effort || null,
+        });
+        turnId = turnResult.turn.id;
+      } catch (error) {
+        child.kill();
+        finish(error instanceof Error ? error : new Error(String(error)));
+      }
+    })();
+  });
+
+  return {
+    child,
+    completed,
+    cancel: async () => {
+      if (threadId && turnId && !settled) {
+        try {
+          await request("turn/interrupt", { threadId, turnId });
+        } catch {
+          // Process termination below is the final cancellation boundary.
+        }
+      }
+      child.kill();
+    },
+  };
+}