@delt/claude-alarm 1.3.0 → 1.4.1

package/dist/cli.js

@@ -146,6 +146,52 @@ var init_logger = __esm({
   }
 });
 
+// src/codex/shutdown.ts
+async function closeWithinLimit(close) {
+  let timer;
+  try {
+    await Promise.race([
+      Promise.resolve().then(close),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("Codex proxy cleanup timed out")), RUN_CLOSE_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function exitAfterFlush(code, stdout, stderr, exit = process.exit) {
+  let exited2 = false;
+  let remaining = 2;
+  const finish = () => {
+    if (exited2) return;
+    exited2 = true;
+    clearTimeout(timer);
+    exit(code);
+  };
+  const timer = setTimeout(finish, CLI_EXIT_FLUSH_MS);
+  const flushed = () => {
+    if (--remaining === 0) finish();
+  };
+  for (const stream of [stdout, stderr]) {
+    try {
+      stream.write("", flushed);
+    } catch {
+      flushed();
+    }
+  }
+}
+var RUN_CLOSE_MS, SUPERVISOR_STOP_GRACE_MS, CLI_EXIT_FLUSH_MS;
+var init_shutdown = __esm({
+  "src/codex/shutdown.ts"() {
+    "use strict";
+    init_logger();
+    RUN_CLOSE_MS = 15e3;
+    SUPERVISOR_STOP_GRACE_MS = 3e4;
+    CLI_EXIT_FLUSH_MS = 1e3;
+  }
+});
+
 // src/shared/crash-guard.ts
 import fs3 from "fs";
 function appendToLog(text) {
@@ -301,7 +347,7 @@ var init_session_manager = __esm({
 
 // src/hub/notifier.ts
 import notifier from "node-notifier";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 var Notifier;
 var init_notifier = __esm({
   "src/hub/notifier.ts"() {
@@ -362,7 +408,7 @@ var init_notifier = __esm({
       }
       checkWindowsNotifications() {
         return new Promise((resolve) => {
-          execFile(
+          execFile2(
             "powershell",
             ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
             { windowsHide: true },
@@ -383,7 +429,7 @@ var init_notifier = __esm({
         logger.warn("Windows notifications are disabled. Opening notification settings...");
         logger.warn("Please enable notifications for this app, then try again.");
         if (process.platform === "win32") {
-          execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
+          execFile2("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
         }
         setTimeout(() => {
           this.notificationSettingsOpened = false;
@@ -445,7 +491,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 function visibleLength(html) {
   return html.replace(/<[^>]*>/g, "").replace(/&(?:amp|lt|gt);/g, "&").length;
 }
-var TELEGRAM_API, MAX_CHOICE_MESSAGES, MAX_SELECTIONS, MAX_VISIBLE_CHARS, TRUNCATED, MAX_PHOTO_BYTES, TelegramBot;
+var TELEGRAM_API, MAX_CHOICE_MESSAGES, MAX_SELECTIONS, MAX_VISIBLE_CHARS, TRUNCATED, MAX_PHOTO_BYTES, NO_LONGER_CONNECTED, TelegramBot;
 var init_telegram = __esm({
   "src/hub/telegram.ts"() {
     "use strict";
@@ -459,6 +505,7 @@ var init_telegram = __esm({
     MAX_VISIBLE_CHARS = 4e3;
     TRUNCATED = "\u2026(truncated)";
     MAX_PHOTO_BYTES = 10 * 1024 * 1024;
+    NO_LONGER_CONNECTED = "the session is no longer connected";
     TelegramBot = class _TelegramBot {
       config;
       offset = 0;
@@ -629,13 +676,7 @@ ${TRUNCATED}`);
               this.selections.delete(latest);
               const session = this.pendingSession(pending, parseInt(selectMatch[1], 10) - 1);
               if (session) {
-                let delivered = true;
-                if (pending.photoFileId) {
-                  delivered = await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
-                } else if (pending.text) {
-                  this.deliverToSession(session.id, pending.text);
-                }
-                if (delivered) this.sendMessage(`Sent to [${this.getLabel(session)}]`);
+                if (await this.deliverPending(session.id, pending)) this.sendMessage(`Sent to [${this.getLabel(session)}]`);
               } else {
                 this.sendMessage("Invalid session number.");
               }
@@ -677,9 +718,13 @@ ${TRUNCATED}`);
         this.sendMessage("Multiple sessions active. Select one:", void 0, { inline_keyboard: rows });
       }
       deliverToSession(sessionId2, content) {
-        if (this.onMessageToSession) {
-          this.onMessageToSession(sessionId2, content);
-        }
+        const delivered = this.onMessageToSession?.(sessionId2, content) === true;
+        if (!delivered) void this.sendMessage(`Not delivered: ${NO_LONGER_CONNECTED}`);
+        return delivered;
+      }
+      async deliverPending(sessionId2, pending) {
+        if (pending.photoFileId) return this.deliverPhotoToSessionByFileId(sessionId2, pending.photoFileId, pending.caption);
+        return pending.text ? this.deliverToSession(sessionId2, pending.text) : false;
       }
       async deliverPhotoToSession(sessionId2, photos, caption) {
         const largest = photos[photos.length - 1];
@@ -711,8 +756,19 @@ ${TRUNCATED}`);
           const filePath = path6.join(UPLOADS_DIR, filename);
           fs5.writeFileSync(filePath, buffer);
           logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
-          if (this.onImageToSession) {
-            this.onImageToSession(sessionId2, filePath, mimeType, caption);
+          let accepted = false;
+          try {
+            accepted = this.onImageToSession?.(sessionId2, filePath, mimeType, caption) === true;
+          } catch (err) {
+            logger.warn(`Telegram photo hand-off failed: ${err.message}`);
+          }
+          if (!accepted) {
+            try {
+              fs5.unlinkSync(filePath);
+            } catch {
+            }
+            this.photoNotDelivered(NO_LONGER_CONNECTED);
+            return false;
           }
           setTimeout(() => {
             try {
@@ -720,7 +776,7 @@ ${TRUNCATED}`);
             } catch {
             }
           }, 5 * 60 * 1e3).unref();
-          return this.onImageToSession !== void 0;
+          return true;
         } catch (err) {
           logger.warn(`Telegram photo download failed: ${err.message}`);
           this.photoNotDelivered("the download failed");
@@ -915,15 +971,10 @@ ${label}`);
           return;
         }
         this.selections.delete(selectionId);
-        if (pending.photoFileId) {
-          const delivered = await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
-          if (!delivered) {
-            await this.answerCallbackQuery(query.id, "Photo not delivered");
-            if (query.message) await this.removeButtons(query.message.chat.id, query.message.message_id);
-            return;
-          }
-        } else if (pending.text) {
-          this.deliverToSession(session.id, pending.text);
+        if (!await this.deliverPending(session.id, pending)) {
+          await this.answerCallbackQuery(query.id, pending.photoFileId ? "Photo not delivered" : "Not delivered");
+          if (query.message) await this.removeButtons(query.message.chat.id, query.message.message_id);
+          return;
         }
         await this.answerCallbackQuery(query.id, `Sent to ${this.getLabel(session)}`);
         if (query.message) {
@@ -1063,6 +1114,7 @@ var init_codex_supervisor = __esm({
   "src/hub/codex-supervisor.ts"() {
     "use strict";
     init_logger();
+    init_shutdown();
     HEALTHY_RUN_MS = 6e4;
     CodexSupervisor = class {
       constructor(script, opts = {}) {
@@ -1070,7 +1122,7 @@ var init_codex_supervisor = __esm({
         this.spawnFn = opts.spawnFn ?? spawn2;
         this.minDelayMs = opts.minDelayMs ?? 2e3;
         this.maxDelayMs = opts.maxDelayMs ?? 6e4;
-        this.stopGraceMs = opts.stopGraceMs ?? 3e3;
+        this.stopGraceMs = opts.stopGraceMs ?? SUPERVISOR_STOP_GRACE_MS;
         this.env = opts.env;
         this.delay = this.minDelayMs;
       }
@@ -1093,11 +1145,22 @@ var init_codex_supervisor = __esm({
         this.timer = void 0;
         const child = this.child;
         this.child = void 0;
-        if (!child) return;
-        child.stdin?.end();
-        const force = setTimeout(() => child.kill(), this.stopGraceMs);
-        force.unref();
-        child.once("exit", () => clearTimeout(force));
+        if (!child) return Promise.resolve();
+        return new Promise((resolve) => {
+          const done = () => {
+            clearTimeout(force);
+            child.removeListener("exit", done);
+            resolve();
+          };
+          const force = setTimeout(() => {
+            logger.warn(`Codex adapter did not exit within ${this.stopGraceMs}ms of stop; killing it`);
+            child.kill();
+            done();
+          }, this.stopGraceMs);
+          force.unref();
+          child.once("exit", done);
+          child.stdin?.end();
+        });
       }
       launch() {
         const startedAt = Date.now();
@@ -1346,9 +1409,9 @@ var init_server = __esm({
         });
       }
       stop() {
-        return new Promise((resolve) => {
-          this.codexSupervisor?.stop();
-          this.codexSupervisor = void 0;
+        const adapterStopped = this.codexSupervisor?.stop();
+        this.codexSupervisor = void 0;
+        const serverStopped = new Promise((resolve) => {
           if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
           if (this.telegramBot) this.telegramBot.stopPolling();
           for (const ws of this.channelSockets.values()) ws.terminate();
@@ -1368,6 +1431,8 @@ var init_server = __esm({
             resolve();
           }, 3e3);
         });
+        return Promise.all([serverStopped, adapterStopped]).then(() => {
+        });
       }
       // --- HTTP Handler ---
       handleHttp(req, res) {
@@ -1624,7 +1689,16 @@ var init_server = __esm({
             this.sessions.updateActivity(msg.sessionId);
             const notifySession = this.sessions.get(msg.sessionId);
             const notifyLabel = this.getSessionLabel(notifySession);
-            this.notifier.notifyWithSession(msg.sessionId, notifyLabel, `[${notifyLabel}] ${msg.title}`, msg.message, msg.level ?? "info");
+            const notifyTitle = `[${notifyLabel}] ${msg.title}`;
+            if (msg.to === "api") {
+              logger.info(`${notifyTitle}: ${msg.message}`);
+              break;
+            }
+            if (msg.to === "telegram") {
+              void this.telegramBot?.sendNotification(msg.sessionId, notifyLabel, notifyTitle, msg.message);
+              break;
+            }
+            if (msg.to !== "dashboard") this.notifier.notifyWithSession(msg.sessionId, notifyLabel, notifyTitle, msg.message, msg.level ?? "info");
             this.broadcastToDashboards({
               type: "notification",
               sessionId: msg.sessionId,
@@ -1826,6 +1900,11 @@ var init_server = __esm({
               const channelWs = this.channelSockets.get(msg.sessionId);
               if (channelWs?.readyState === WebSocket2.OPEN) {
                 channelWs.send(JSON.stringify({ ...msg, source: "dashboard" }));
+              } else {
+                const reason = "the session is not connected";
+                logger.warn(`Message rejected for ${msg.sessionId}: ${reason}`);
+                const rejected = { type: "message_rejected", sessionId: msg.sessionId, reason };
+                if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify(rejected));
               }
             } else if (msg.type === "image_upload") {
               this.handleImageUpload(ws, msg);
@@ -1951,19 +2030,25 @@ var init_server = __esm({
         this.telegramBot.getSessions = () => this.sessions.getAll();
         this.telegramBot.onMessageToSession = (sessionId2, content) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket2.OPEN) {
-            const msg = { type: "message_to_session", sessionId: sessionId2, content, source: "telegram" };
-            channelWs.send(JSON.stringify(msg));
-            logger.info(`Telegram message forwarded to session: ${sessionId2}`);
+          if (channelWs?.readyState !== WebSocket2.OPEN) {
+            logger.warn(`Telegram message not delivered to ${sessionId2}: the session is not connected`);
+            return false;
           }
+          const msg = { type: "message_to_session", sessionId: sessionId2, content, source: "telegram" };
+          channelWs.send(JSON.stringify(msg));
+          logger.info(`Telegram message forwarded to session: ${sessionId2}`);
+          return true;
         };
         this.telegramBot.onImageToSession = (sessionId2, imagePath, mimeType, caption) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket2.OPEN) {
-            const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption, source: "telegram" };
-            channelWs.send(JSON.stringify(msg));
-            logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
+          if (channelWs?.readyState !== WebSocket2.OPEN) {
+            logger.warn(`Telegram photo not delivered to ${sessionId2}: the session is not connected`);
+            return false;
           }
+          const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption, source: "telegram" };
+          channelWs.send(JSON.stringify(msg));
+          logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
+          return true;
         };
         this.telegramBot.onPermissionVerdict = (sessionId2, requestId, behavior) => {
           if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, behavior })) {
@@ -2627,7 +2712,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/codex/transport.ts
 init_logger();
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import fs2 from "fs";
 import path3 from "path";
 import { Duplex } from "stream";
@@ -2657,14 +2742,144 @@ function findCodex(command, platform = process.platform, env = process.env) {
   ];
   return candidates.find((file) => !!file && fs2.existsSync(file));
 }
+var shellSpawns = /* @__PURE__ */ new WeakSet();
+var spawnedThroughShell = (child) => shellSpawns.has(child);
 var defaultSpawn = (command, args) => {
   const { file, shell } = resolveCommand(command);
-  if (shell) return spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
-  return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  if (!shell) return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  const child = spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
+  shellSpawns.add(child);
+  return child;
+};
+var POWERSHELL_TIMEOUT_MS = 5e3;
+var powershell = (script, env) => new Promise((resolve, reject) => {
+  execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { windowsHide: true, timeout: POWERSHELL_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024, env }, (err, stdout) => {
+    if (err) reject(err);
+    else resolve(stdout);
+  });
+});
+var QUERY_SCRIPT = "@(Get-CimInstance Win32_Process | Where-Object CreationDate | Select-Object @{ n = 'pid'; e = { [int]$_.ProcessId } }, @{ n = 'parentPid'; e = { [int]$_.ParentProcessId } }, @{ n = 'creationTime'; e = { $_.CreationDate.ToUniversalTime().ToString('o') } }) | ConvertTo-Json -Compress";
+var processQuery = (prelude = "") => async () => {
+  const rows = JSON.parse(await powershell(prelude + QUERY_SCRIPT));
+  if (!Array.isArray(rows) || rows.some((row) => !Number.isInteger(row.pid) || !Number.isInteger(row.parentPid) || typeof row.creationTime !== "string")) {
+    throw new Error("invalid process snapshot");
+  }
+  return rows;
 };
+var queryProcesses = processQuery();
+var END_SCRIPT = [
+  "foreach ($t in ($env:CLAUDE_ALARM_END_TARGETS | ConvertFrom-Json)) {",
+  "  $p = Get-Process -Id $t.pid -ErrorAction SilentlyContinue",
+  // Reading Handle opens the process once, and StartTime, Stop-Process and Wait-Process then use that handle; a getter that throws reads as $null.
+  '  if ($null -eq $p -or $null -eq $p.Handle) { "$($t.pid) is gone or cannot be opened"; continue }',
+  "  $start = $p.StartTime",
+  '  if ($null -eq $start) { "$($t.pid) has no readable creation time"; continue }',
+  "  $start = $start.ToUniversalTime()",
+  // Win32_Process creation dates stop at microseconds.
+  `  if ($start.AddTicks(-($start.Ticks % 10)).ToString('o') -ne $t.creationTime) { "$($t.pid) now belongs to another process"; continue }`,
+  '  try { Stop-Process -InputObject $p -Force -ErrorAction Stop } catch { "$($t.pid) not ended: $($_.FullyQualifiedErrorId)" }',
+  // A refused termination usually means the process is already exiting, so it is waited for all the same.
+  '  try { Wait-Process -InputObject $p -Timeout 1 -ErrorAction Stop } catch { "$($t.pid) has not exited yet" }',
+  "}"
+].join("\n");
+var processEnder = (prelude = "") => async (targets) => {
+  await Promise.all(targets.map(async (target) => {
+    try {
+      const notes = await powershell(prelude + END_SCRIPT, { ...process.env, CLAUDE_ALARM_END_TARGETS: JSON.stringify([target]) });
+      for (const note of notes.split(/\r?\n/)) if (note) logger.debug(`codex process ${note}`);
+    } catch (err) {
+      logger.debug(`ending codex process ${target.pid} failed: ${err.killed ? "timed out" : String(err)}`);
+    }
+  }));
+};
+var endProcesses = processEnder();
+function descendantsOf(rootPid, rows) {
+  const root = rows.find((row) => row.pid === rootPid);
+  if (!root) return void 0;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set([root.pid]);
+  let level = [root];
+  for (let depth = 1; level.length; depth++) {
+    const next = [];
+    for (const parent of level) {
+      for (const row of rows) {
+        if (row.parentPid !== parent.pid || seen.has(row.pid) || row.creationTime < parent.creationTime) continue;
+        seen.add(row.pid);
+        next.push(row);
+        found.push({ ...row, depth });
+      }
+    }
+    level = next;
+  }
+  return found;
+}
+var exited = (child) => child.exitCode !== null || child.signalCode !== null;
+var SHELL_EXIT_WAIT_MS = 1e3;
+var PROXY_TREE_CLOSE_BUDGET_MS = 2 * POWERSHELL_TIMEOUT_MS + SHELL_EXIT_WAIT_MS;
+var exitOf = (child) => new Promise((resolve) => {
+  if (exited(child)) {
+    resolve();
+    return;
+  }
+  const timer = setTimeout(() => {
+    logger.debug(`codex proxy shell ${child.pid} has not exited yet`);
+    resolve();
+  }, SHELL_EXIT_WAIT_MS);
+  child.once("exit", () => {
+    clearTimeout(timer);
+    resolve();
+  });
+});
+var merged = (before, found) => [...before, ...found.filter((d) => !before.some((b) => b.pid === d.pid && b.creationTime === d.creationTime))];
+function treeKiller(platform = process.platform, end = endProcesses, query = queryProcesses, throughShell = spawnedThroughShell) {
+  const recorded = /* @__PURE__ */ new WeakMap();
+  const endByIdentity = async (descendants) => {
+    if (!descendants.length) return;
+    try {
+      await end([...descendants].sort((a, b) => b.depth - a.depth).map(({ depth, ...identity }) => identity));
+    } catch (err) {
+      logger.debug(`ending codex processes failed: ${String(err)}`);
+    }
+  };
+  const snapshot = async () => {
+    try {
+      return await query();
+    } catch (err) {
+      logger.debug(`codex process query failed: ${String(err)}`);
+      return void 0;
+    }
+  };
+  const isShellTree = (child) => platform === "win32" && child.pid !== void 0 && throughShell(child);
+  const killer = async (child) => {
+    if (!isShellTree(child)) {
+      if (!exited(child)) child.kill();
+      return;
+    }
+    const [rows, before] = await Promise.all([exited(child) ? void 0 : snapshot(), recorded.get(child)]);
+    const found = rows && !exited(child) ? descendantsOf(child.pid, rows) ?? [] : [];
+    await endByIdentity(merged(before ?? [], found));
+    if (exited(child)) return;
+    child.kill();
+    await exitOf(child);
+  };
+  killer.track = async (child) => {
+    if (!isShellTree(child) || exited(child)) return;
+    const earlier = recorded.get(child);
+    const latest = (async () => {
+      const rows = await snapshot();
+      const found = rows && !exited(child) ? descendantsOf(child.pid, rows) ?? [] : [];
+      return merged(await earlier ?? [], found);
+    })();
+    recorded.set(child, latest);
+    await latest;
+  };
+  return killer;
+}
+var killTree = treeKiller();
 var HANDSHAKE_TIMEOUT_MS = 1e4;
-function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIMEOUT_MS) {
+function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIMEOUT_MS, killTreeFn = killTree) {
   const child = spawnFn(command, ["app-server", "proxy"]);
+  void killTreeFn.track?.(child);
   child.stdin?.on("error", () => {
   });
   child.stderr?.on("data", (d) => logger.debug(`codex proxy: ${String(d).trim()}`));
@@ -2691,10 +2906,12 @@ function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIM
   const ws = new WebSocket("ws://localhost/", {
     createConnection: (() => stream)
   });
-  const close = () => {
+  let closing;
+  const close = () => closing ??= (async () => {
     ws.terminate();
-    child.kill();
-  };
+    child.stdin?.end();
+    await killTreeFn(child);
+  })();
   return new Promise((resolve, reject) => {
     let settled = false;
     const timer = setTimeout(() => fail(new Error(`codex daemon did not answer within ${timeoutMs / 1e3}s`)), timeoutMs);
@@ -2702,8 +2919,7 @@ function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIM
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      close();
-      reject(err);
+      void close().then(() => reject(err), () => reject(err));
     };
     child.on("error", fail);
     child.once("exit", (code) => fail(new Error(`codex proxy exited (code ${code})`)));
@@ -2714,12 +2930,14 @@ function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIM
       clearTimeout(timer);
       child.on("error", (err) => logger.warn(`codex proxy error: ${err.message}`));
       ws.on("error", (err) => logger.warn(`codex daemon socket error: ${err.message}`));
+      void killTreeFn.track?.(child);
       resolve({ ws, close });
     });
   });
 }
 
 // src/codex/run.ts
+init_shutdown();
 import path4 from "path";
 
 // src/codex/rpc.ts
@@ -3005,7 +3223,14 @@ async function runCodexTask(opts) {
     };
   } finally {
     for (const t of timers) clearTimeout(t);
-    conn.close();
+    try {
+      await closeWithinLimit(() => conn.close());
+    } catch (err) {
+      try {
+        progress(`warning: Codex proxy cleanup failed: ${err.message}`);
+      } catch {
+      }
+    }
   }
 }
 var VALUE_FLAGS = {
@@ -3078,6 +3303,7 @@ async function runFromCli(argv, io) {
 }
 
 // src/cli.ts
+init_shutdown();
 init_constants();
 init_logger();
 init_crash_guard();
@@ -3496,19 +3722,19 @@ async function hubStart(daemon) {
       process.exit(1);
     }
     fs9.writeFileSync(PID_FILE, String(pid), "utf-8");
-    let exited = false;
+    let exited2 = false;
     child.once("exit", () => {
-      exited = true;
+      exited2 = true;
     });
     child.unref();
     const startup = await waitForHub({
       url: `http://${displayHost}:${port}/api/status`,
       token: config2.hub.token,
       pid,
-      isAlive: () => !exited
+      isAlive: () => !exited2
     });
     if (startup !== "ready") {
-      if (!exited) child.kill();
+      if (!exited2) child.kill();
       if (fs9.existsSync(PID_FILE)) fs9.unlinkSync(PID_FILE);
       console.error(startup === "exited" ? `Hub exited during startup. See ${LOG_FILE}` : `Hub did not answer at http://${displayHost}:${port} within ${HUB_START_TIMEOUT_MS / 1e3}s and was stopped. See ${LOG_FILE}`);
       process.exit(1);
@@ -3829,8 +4055,10 @@ async function main2() {
     else if (sub === "start") await codexStart();
     else if (sub === "stop") process.exitCode = await stopAdapter(controlDeps(), loadConfig().codex?.enabled === true);
     else if (sub === "status") process.exitCode = await adapterStatus(controlDeps(), loadConfig().codex?.enabled === true);
-    else if (sub === "run") process.exitCode = await codexRun(args.slice(2));
-    else {
+    else if (sub === "run") {
+      const code = await codexRun(args.slice(2));
+      exitAfterFlush(code, process.stdout, process.stderr);
+    } else {
       console.error(`Unknown codex command: ${sub}`);
       printUsage();
       process.exit(1);