chatroom-cli 1.91.1 → 1.91.3

package/dist/index.js

@@ -29879,6 +29879,60 @@ function resolveCodexSdkPackageJson(chatroomCliRoot) {
     throw new CodexSdkPackageError(`Could not locate @openai/codex-sdk package.json from ${chatroomCliRoot}. ${REINSTALL_HINT2}`);
   }
 }
+function resolveTargetTriple() {
+  const { platform, arch } = process;
+  if (platform === "linux" && arch === "x64")
+    return "x86_64-unknown-linux-musl";
+  if (platform === "linux" && arch === "arm64")
+    return "aarch64-unknown-linux-musl";
+  if (platform === "darwin" && arch === "x64")
+    return "x86_64-apple-darwin";
+  if (platform === "darwin" && arch === "arm64")
+    return "aarch64-apple-darwin";
+  if (platform === "win32" && arch === "x64")
+    return "x86_64-pc-windows-msvc";
+  if (platform === "win32" && arch === "arm64")
+    return "aarch64-pc-windows-msvc";
+  throw new CodexSdkPackageError(`Unsupported platform for ${CODEX_NPM_NAME}: ${platform}-${arch}. ${REINSTALL_HINT2}`);
+}
+function resolvePlatformPackageName2(targetTriple) {
+  const pkg = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+  if (!pkg) {
+    throw new CodexSdkPackageError(`Unsupported platform for ${CODEX_NPM_NAME}: ${targetTriple}. ${REINSTALL_HINT2}`);
+  }
+  return pkg;
+}
+function resolveCodexExecutablePath(moduleRef = import.meta.url) {
+  if (cachedExecutablePath2)
+    return cachedExecutablePath2;
+  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
+  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
+  try {
+    require3.resolve(`${CODEX_NPM_NAME}/package.json`, { paths: [chatroomCliRoot] });
+  } catch {
+    throw new CodexSdkPackageError(`${CODEX_NPM_NAME} is not installed. Ensure chatroom-cli was installed with optional dependencies. ${REINSTALL_HINT2}`);
+  }
+  const targetTriple = resolveTargetTriple();
+  const platformPkg = resolvePlatformPackageName2(targetTriple);
+  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+  let platformPkgDir;
+  try {
+    platformPkgDir = dirname3(require3.resolve(`${platformPkg}/package.json`, { paths: [chatroomCliRoot] }));
+  } catch {
+    throw new CodexSdkPackageError(`Native Codex CLI package ${platformPkg} is not installed. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies. ${REINSTALL_HINT2}`);
+  }
+  const packageBinaryPath = join8(platformPkgDir, "vendor", targetTriple, "bin", codexBinaryName);
+  const legacyBinaryPath = join8(platformPkgDir, "vendor", targetTriple, "codex", codexBinaryName);
+  if (existsSync2(packageBinaryPath)) {
+    cachedExecutablePath2 = packageBinaryPath;
+    return cachedExecutablePath2;
+  }
+  if (existsSync2(legacyBinaryPath)) {
+    cachedExecutablePath2 = legacyBinaryPath;
+    return cachedExecutablePath2;
+  }
+  throw new CodexSdkPackageError(`Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies. ${REINSTALL_HINT2}`);
+}
 async function importBundledCodexSdk(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
   const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
@@ -29887,11 +29941,11 @@ async function importBundledCodexSdk(moduleRef = import.meta.url) {
   if (installedVersion !== pinnedVersion) {
     throw new CodexSdkPackageError(`@openai/codex-sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT2}`);
   }
-  const entryPath = join8(dirname3(packageJsonPath), "dist", "index.js");
-  if (!existsSync2(entryPath)) {
-    throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT2}`);
+  const distEntryPath = join8(dirname3(packageJsonPath), "dist", "index.js");
+  if (!existsSync2(distEntryPath)) {
+    throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${distEntryPath}. ${REINSTALL_HINT2}`);
   }
-  return import(pathToFileURL2(entryPath).href);
+  return import(pathToFileURL2(distEntryPath).href);
 }
 function getBundledCodexSdkVersion(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
@@ -29908,12 +29962,28 @@ function formatCodexSdkError(err) {
 }
 function formatCodexSdkLoadError(err) {
   if (err instanceof CodexSdkPackageError) {
-    return err.message;
+    const message2 = err.message;
+    if ((message2.includes("Codex CLI") || message2.includes("optional dependencies")) && !message2.includes(REINSTALL_HINT2)) {
+      return `${message2} ${REINSTALL_HINT2}`;
+    }
+    return message2;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("Codex CLI") || message.includes("optional dependencies")) {
+    return `${message} ${REINSTALL_HINT2}`;
   }
   return formatCodexSdkError(err);
 }
-var REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CodexSdkPackageError;
+var REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CODEX_NPM_NAME = "@openai/codex", PLATFORM_PACKAGE_BY_TARGET, CodexSdkPackageError, cachedExecutablePath2;
 var init_codex_sdk_package = __esm(() => {
+  PLATFORM_PACKAGE_BY_TARGET = {
+    "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+    "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+    "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+    "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+    "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+    "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
+  };
   CodexSdkPackageError = class CodexSdkPackageError extends Error {
     code = "CODEX_SDK_PACKAGE_INCOMPLETE";
     constructor(message) {
@@ -30354,6 +30424,7 @@ var init_codex_sdk_agent_service = __esm(() => {
     async isInstalled() {
       try {
         await loadSdk2();
+        resolveCodexExecutablePath();
         return true;
       } catch (err) {
         console.warn(`[codex-sdk] unavailable: ${formatCodexSdkLoadError(err)}`);
@@ -30697,7 +30768,11 @@ ${options.prompt}`;
       let thread;
       try {
         const { Codex } = await loadSdk2();
-        codex = new Codex({ env: buildCodexEnv(options.resolvedConvexUrl) });
+        const codexPath = resolveCodexExecutablePath();
+        codex = new Codex({
+          codexPathOverride: codexPath,
+          env: buildCodexEnv(options.resolvedConvexUrl)
+        });
         thread = codex.startThread(buildThreadOptions(options.workingDir, variant));
       } catch (err) {
         writeSpawnError2(buildAgentLogPrefix("codex-sdk", context5), err);
@@ -30724,7 +30799,11 @@ ${options.prompt}`;
         const pid = keeper.pid;
         const variant = decodeCodexVariant(options.model ?? stored.model);
         const { Codex } = await loadSdk2();
-        const codex = new Codex({ env: buildCodexEnv(options.resolvedConvexUrl) });
+        const codexPath = resolveCodexExecutablePath();
+        const codex = new Codex({
+          codexPathOverride: codexPath,
+          env: buildCodexEnv(options.resolvedConvexUrl)
+        });
         const thread = codex.resumeThread(stored.harnessSessionId, buildThreadOptions(stored.workingDir, variant));
         return this.startRunningSession({
           pid,
@@ -108117,7 +108196,7 @@ var init_start_subscriptions = __esm(() => {
 });
 
 // src/daemon/entry/enhancer/constants.ts
-var ENHANCER_AGENT_ROLE = "enhancer", ENHANCER_AGENT_END_GRACE_MS = 3000, ENHANCER_JOB_POLL_INTERVAL_MS = 500;
+var ENHANCER_AGENT_ROLE = "enhancer", ENHANCER_AGENT_END_GRACE_MS = 3000;
 
 // src/daemon/entry/enhancer/enhancer-log.ts
 function formatEnhancerLogLine(message) {
@@ -108132,100 +108211,143 @@ function writeEnhancerLog(message) {
 }
 var ENHANCER_LOG_PREFIX = "[enhancer]";
 
+// src/daemon/entry/enhancer/job-outcome-subscription.ts
+function subscribeToEnhancerJobOutcome(args2) {
+  let currentState = null;
+  let resolveOutcome = null;
+  let rejectOutcome = null;
+  let stopped = false;
+  const outcome = new Promise((resolve5, reject) => {
+    resolveOutcome = resolve5;
+    rejectOutcome = reject;
+  });
+  const unsub = args2.wsClient.onUpdate(api.web.enhancer.index.getJobOutcome, {
+    sessionId: args2.sessionId,
+    chatroomId: args2.chatroomId,
+    jobId: args2.jobId
+  }, (state) => {
+    if (stopped)
+      return;
+    if (!state) {
+      rejectOutcome?.(new Error("Enhancer job not found"));
+      resolveOutcome = null;
+      rejectOutcome = null;
+      return;
+    }
+    currentState = state;
+    if (state.status === "complete" || state.status === "failed" || state.status === "cancelled") {
+      resolveOutcome?.(state);
+      resolveOutcome = null;
+      rejectOutcome = null;
+    }
+  }, (error51) => {
+    if (stopped)
+      return;
+    rejectOutcome?.(error51);
+    resolveOutcome = null;
+    rejectOutcome = null;
+  });
+  return {
+    outcome,
+    getCurrentState: () => currentState,
+    stop: () => {
+      if (stopped)
+        return;
+      stopped = true;
+      unsub();
+      resolveOutcome = null;
+      rejectOutcome = null;
+    }
+  };
+}
+var init_job_outcome_subscription = __esm(() => {
+  init_api3();
+});
+
 // src/daemon/entry/enhancer/wait-for-enhancer-job.ts
 async function waitForEnhancerJobResolution(params) {
-  const { sessionId, chatroomId, jobId, backend: backend2, onFailure, onSalvageComplete } = params;
+  const { sessionId, chatroomId, jobId, wsClient: wsClient2, onFailure, onSalvageComplete } = params;
   let outcome = null;
   let salvagedText = "";
-  const pollInterval = setInterval(async () => {
+  let agentEndTimer = null;
+  let resolveWait = null;
+  const waitPromise = new Promise((resolve5) => {
+    resolveWait = resolve5;
+  });
+  const subscription = subscribeToEnhancerJobOutcome({
+    wsClient: wsClient2,
+    sessionId,
+    chatroomId,
+    jobId
+  });
+  const finish = (resolution) => {
     if (outcome)
       return;
-    try {
-      const status3 = await backend2.query(api.web.enhancer.index.getJob, {
-        sessionId,
-        chatroomId,
-        jobId
-      });
-      if (status3?.status === "complete") {
-        outcome = "complete";
-        writeEnhancerLog(`completed job=${jobId}`);
-      }
-    } catch {}
-  }, ENHANCER_JOB_POLL_INTERVAL_MS);
+    outcome = resolution;
+    resolveWait?.();
+    resolveWait = null;
+  };
+  const failAfterAgentEnd = () => {
+    writeEnhancerLog("agent_end: turn ended without complete — failing terminal");
+    onFailure("Agent exited without completing enhancer job", true);
+    finish("failed");
+  };
+  subscription.outcome.then((state) => {
+    if (outcome)
+      return;
+    const resolution = state.status === "complete" ? "complete" : "failed";
+    if (resolution === "complete")
+      writeEnhancerLog(`completed job=${jobId}`);
+    finish(resolution);
+  }).catch((error51) => {
+    if (outcome)
+      return;
+    writeEnhancerLog(`enhancer outcome subscription failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    onFailure("Enhancer job outcome subscription failed", false);
+    finish("failed");
+  });
   params.onAssistantText?.((text) => {
     salvagedText += text;
   });
   params.onAgentEnd?.(() => {
     if (outcome)
       return;
-    const check4 = () => {
+    agentEndTimer = setTimeout(() => {
       if (outcome)
         return;
-      backend2.query(api.web.enhancer.index.getJob, {
-        sessionId,
-        chatroomId,
-        jobId
-      }).then((status3) => {
-        if (outcome)
-          return;
-        if (status3?.status === "complete") {
-          outcome = "complete";
-          return;
-        }
-        if (status3?.status === "running") {
-          const trimmed = salvagedText.trim();
-          if (trimmed && onSalvageComplete) {
-            onSalvageComplete(trimmed).then(() => {
-              if (outcome)
-                return;
-              backend2.query(api.web.enhancer.index.getJob, {
-                sessionId,
-                chatroomId,
-                jobId
-              }).then((afterSalvage) => {
-                if (afterSalvage?.status === "complete") {
-                  outcome = "complete";
-                  writeEnhancerLog("agent_end: salvaged assistant text via complete");
-                  return;
-                }
-                outcome = "failed";
-                writeEnhancerLog("agent_end: turn ended without complete — failing terminal");
-                onFailure("Agent exited without completing enhancer job", true);
-              });
-            }).catch(() => {
-              outcome = "failed";
-              writeEnhancerLog("agent_end: turn ended without complete — failing terminal");
-              onFailure("Agent exited without completing enhancer job", true);
-            });
-          } else {
-            outcome = "failed";
-            writeEnhancerLog("agent_end: turn ended without complete — failing terminal");
-            onFailure("Agent exited without completing enhancer job", true);
-          }
-        }
+      const state = subscription.getCurrentState();
+      if (state?.status === "complete") {
+        finish("complete");
+        return;
+      }
+      if (state?.status !== "running") {
+        failAfterAgentEnd();
+        return;
+      }
+      const trimmed = salvagedText.trim();
+      if (!trimmed || !onSalvageComplete) {
+        failAfterAgentEnd();
+        return;
+      }
+      onSalvageComplete(trimmed).catch(() => {
+        failAfterAgentEnd();
       });
-    };
-    setTimeout(check4, ENHANCER_AGENT_END_GRACE_MS);
+    }, ENHANCER_AGENT_END_GRACE_MS);
   });
   params.onExit(() => {
     if (outcome)
       return;
-    outcome = "failed";
     onFailure("Agent process exited without completing enhancer job", false);
+    finish("failed");
   });
-  await new Promise((resolve5) => {
-    const check4 = setInterval(() => {
-      if (outcome) {
-        clearInterval(check4);
-        resolve5();
-      }
-    }, 100);
-  });
-  clearInterval(pollInterval);
+  await waitPromise;
+  if (agentEndTimer)
+    clearTimeout(agentEndTimer);
+  subscription.stop();
   return outcome ?? "failed";
 }
 var init_wait_for_enhancer_job = __esm(() => {
-  init_api3();
+  init_job_outcome_subscription();
 });
 
 // src/daemon/entry/enhancer-inbound-registry.ts
@@ -108242,7 +108364,7 @@ async function dispatchEnhancerInboundEvent(event) {
 var handler3;
 
 // src/daemon/entry/enhancer/job-subscriber.ts
-async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, backend2, agentServices, job, inFlight2) {
+async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, job, inFlight2) {
   if (inFlight2.has(job.jobId))
     return;
   inFlight2.add(job.jobId);
@@ -108298,7 +108420,7 @@ async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, backe
       sessionId,
       chatroomId: payload.chatroomId,
       jobId: payload.jobId,
-      backend: backend2,
+      wsClient: wsClient2,
       onAssistantText: spawned.onAssistantText ? (cb) => spawned.onAssistantText?.(cb) : undefined,
       onAgentEnd: spawned.onAgentEnd ? (cb) => spawned.onAgentEnd?.(cb) : undefined,
       onExit: (cb) => spawned.onExit(() => cb()),
@@ -108340,30 +108462,30 @@ async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, backe
     }
   }
 }
-function processEnhancerJobs(sessionId, machineId, convexUrl, backend2, agentServices, jobs, inFlight2) {
+function processEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, jobs, inFlight2) {
   for (const job of jobs ?? []) {
-    processEnhancerJobForSpawn(sessionId, machineId, convexUrl, backend2, agentServices, job, inFlight2);
+    processEnhancerJobForSpawn(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, job, inFlight2);
   }
 }
-async function drainPendingEnhancerJobs(sessionId, machineId, convexUrl, backend2, agentServices, inFlight2) {
+async function drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2) {
   const jobs = await backend2.query(api.daemon.enhancer.index.pendingForMachine, {
     sessionId,
     machineId
   });
   if (!jobs?.length)
     return;
-  processEnhancerJobs(sessionId, machineId, convexUrl, backend2, agentServices, jobs, inFlight2);
+  processEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, jobs, inFlight2);
 }
-function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, agentServices) {
+function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices) {
   const inFlight2 = new Set;
   registerEnhancerInboundHandler(async () => {
-    await drainPendingEnhancerJobs(sessionId, machineId, convexUrl, backend2, agentServices, inFlight2);
+    await drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2);
   });
   return {
     stop: () => {
       unregisterEnhancerInboundHandler();
     },
-    drainPendingEnhancerJobs: () => drainPendingEnhancerJobs(sessionId, machineId, convexUrl, backend2, agentServices, inFlight2)
+    drainPendingEnhancerJobs: () => drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2)
   };
 }
 var init_job_subscriber = __esm(() => {
@@ -108372,8 +108494,8 @@ var init_job_subscriber = __esm(() => {
 });
 
 // src/daemon/entry/enhancer/start-subscriptions.ts
-function startEnhancerSubscriptions(sessionId, machineId, convexUrl, backend2, agentServices) {
-  return startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, agentServices);
+function startEnhancerSubscriptions(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices) {
+  return startEnhancerJobSubscriber(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices);
 }
 var init_start_subscriptions2 = __esm(() => {
   init_job_subscriber();
@@ -114660,7 +114782,7 @@ function createDaemonRuntime(deps) {
         backend: session2.backend,
         convexUrl: session2.convexUrl
       }, activeSessions, harnesses);
-      enhancerWorkerHandle = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, session2.backend, session2.agentServices);
+      enhancerWorkerHandle = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, deps.wsClient, session2.backend, session2.agentServices);
     }
     console.log(`
 Listening for commands...`);
@@ -117671,4 +117793,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D279A4D8F6CF2F1C64756E2164756E21
+//# debugId=7232F20998B29AC964756E2164756E21