@delt/claude-alarm 1.3.0 → 1.4.1

package/dist/codex/main.js

@@ -357,7 +357,7 @@ var HubClient = class {
 };
 
 // src/codex/transport.ts
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import fs3 from "fs";
 import path3 from "path";
 import { Duplex } from "stream";
@@ -387,14 +387,144 @@ function findCodex(command, platform = process.platform, env = process.env) {
   ];
   return candidates.find((file) => !!file && fs3.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()}`));
@@ -421,10 +551,12 @@ function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIM
   const ws = new WebSocket3("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);
@@ -432,8 +564,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})`)));
@@ -444,6 +575,7 @@ 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 });
     });
   });
@@ -653,6 +785,8 @@ var CodexAdapter = class {
     this.link = new CodexHubLink(opts.hub, { id: randomUUID2(), host: this.hostName }, (call) => this.onCall(call), opts.linkReconnectMs);
   }
   conn;
+  connecting;
+  closing = /* @__PURE__ */ new Set();
   rpc;
   threads = /* @__PURE__ */ new Map();
   approvals = /* @__PURE__ */ new Map();
@@ -668,22 +802,29 @@ var CodexAdapter = class {
   start() {
     this.stopped = false;
     this.link.connect();
-    void this.connect();
+    this.connecting = this.connect();
   }
-  stop() {
+  async stop() {
     this.stopped = true;
     this.link.disconnect();
     if (this.retryTimer) clearTimeout(this.retryTimer);
     this.retryTimer = void 0;
     for (const id of [...this.threads.keys()]) this.drop(id);
-    this.conn?.close();
+    this.closeConn(this.conn);
+    await this.connecting;
+    await Promise.all(this.closing);
+  }
+  closeConn(conn) {
+    if (!conn) return;
+    const closing = conn.close().finally(() => this.closing.delete(closing));
+    this.closing.add(closing);
   }
   async connect() {
     let rpc;
     try {
       const conn = await connectProxy(this.opts.command, this.opts.spawnFn);
       if (this.stopped) {
-        conn.close();
+        this.closeConn(conn);
         return;
       }
       const live = new RpcClient(conn.ws, this.opts.rpcTimeoutMs);
@@ -715,7 +856,7 @@ var CodexAdapter = class {
       });
       if (rpc && this.rpc === rpc) {
         this.rpc = void 0;
-        this.conn?.close();
+        this.closeConn(this.conn);
         this.conn = void 0;
       }
       for (const id of [...this.threads.keys()]) this.drop(id);
@@ -725,7 +866,7 @@ var CodexAdapter = class {
   onDaemonLost() {
     this.setReady(false);
     this.rpc = void 0;
-    this.conn?.close();
+    this.closeConn(this.conn);
     this.conn = void 0;
     for (const id of [...this.threads.keys()]) this.drop(id);
     if (!this.stopped) logger.warn("Codex daemon connection lost");
@@ -735,7 +876,7 @@ var CodexAdapter = class {
     if (this.stopped || this.retryTimer) return;
     this.retryTimer = setTimeout(() => {
       this.retryTimer = void 0;
-      void this.connect();
+      this.connecting = this.connect();
     }, this.delay);
     this.delay = Math.min(this.delay * 2, this.opts.reconnectMaxMs ?? 6e4);
   }
@@ -1028,9 +1169,9 @@ var CodexAdapter = class {
   }
   onHubMessage(threadId, msg) {
     if (msg.type === "message_to_session") {
-      this.enqueue(threadId, async () => textInput(msg.content, msg.source));
+      this.enqueue(threadId, async () => textInput(msg.content, msg.source), msg.source);
     } else if (msg.type === "image_to_session") {
-      this.enqueue(threadId, () => imageInput(msg.imagePath, msg.mimeType, msg.content, msg.source));
+      this.enqueue(threadId, () => imageInput(msg.imagePath, msg.mimeType, msg.content, msg.source), msg.source);
     } else if (msg.type === "permission_response") {
       this.answer(threadId, msg.requestId, msg.choiceId);
     } else if (msg.type === "codex_close") {
@@ -1038,16 +1179,16 @@ var CodexAdapter = class {
     }
   }
   // One message at a time per conversation, so a message right behind another sees the turn the first one started.
-  enqueue(threadId, build) {
+  enqueue(threadId, build, source) {
     const t = this.threads.get(threadId);
     if (!t) return;
-    t.sending = t.sending.then(() => this.deliver(t, build)).catch((err) => logger.warn(`Codex delivery for ${threadId} failed: ${err.message}`));
+    t.sending = t.sending.then(() => this.deliver(t, build, source)).catch((err) => logger.warn(`Codex delivery for ${threadId} failed: ${err.message}`));
   }
-  async deliver(t, build) {
+  async deliver(t, build, source) {
     const threadId = t.thread.id;
     if (this.threads.get(threadId) !== t) return;
-    if (hubStatus(t.thread.status) === "waiting_input") {
-      this.notify(threadId, "Not delivered", "Codex is waiting for an approval or input. Answer it first, then send the message again.", "warning");
+    if (this.waitingForAnswer(t)) {
+      this.refuseWhileWaiting(threadId);
       return;
     }
     let input;
@@ -1068,20 +1209,37 @@ var CodexAdapter = class {
       const unsubscribed = !t.subscribed;
       const running = await this.runningTurn(rpc, threadId);
       if (this.threads.get(threadId) !== t) return;
+      if (this.waitingForAnswer(t)) {
+        this.abandonDelivery(t, wasUnrelayed);
+        this.refuseWhileWaiting(threadId);
+        return;
+      }
       if (unsubscribed) t.unrelayed = true;
       if (running) {
         await rpc.request("turn/steer", { threadId, expectedTurnId: running, input });
-        this.notify(threadId, "Queued", "Queued: Codex will read it after its current step.", "info");
+        this.notify(threadId, "Queued", "Queued: Codex will read it after its current step.", "info", source);
         return;
       }
       await rpc.request("turn/start", { threadId, input });
     } catch (err) {
-      t.pendingTurn = false;
-      t.unrelayed = wasUnrelayed;
-      this.releaseLater(t);
+      this.abandonDelivery(t, wasUnrelayed);
       this.notify(threadId, "Not delivered", `Codex rejected the message: ${err.message}`, "warning");
     }
   }
+  abandonDelivery(t, wasUnrelayed) {
+    t.pendingTurn = false;
+    t.unrelayed = wasUnrelayed;
+    this.releaseLater(t);
+  }
+  // The approval request itself can arrive before the status broadcast that marks the thread as waiting.
+  waitingForAnswer(t) {
+    if (hubStatus(t.thread.status) === "waiting_input") return true;
+    for (const a of this.approvals.values()) if (a.threadId === t.thread.id && !a.answered) return true;
+    return false;
+  }
+  refuseWhileWaiting(threadId) {
+    this.notify(threadId, "Not delivered", "Codex is waiting for an approval or input. Answer it first, then send the message again.", "warning");
+  }
   // The list is unavailable before a new conversation's first turn; starting a turn is safe then, since turn/start steers a running turn.
   async runningTurn(rpc, threadId) {
     try {
@@ -1161,11 +1319,36 @@ var CodexAdapter = class {
     this.approvals.delete(requestId);
     this.threads.get(a.threadId)?.hub.send({ type: "permission_resolved", sessionId: codexSessionId(a.threadId), requestId, state });
   }
-  notify(threadId, title, message, level) {
-    this.threads.get(threadId)?.hub.send({ type: "notify", sessionId: codexSessionId(threadId), title, message, level });
+  notify(threadId, title, message, level, to) {
+    this.threads.get(threadId)?.hub.send({ type: "notify", sessionId: codexSessionId(threadId), title, message, level, ...to ? { to } : {} });
   }
 };
 
+// src/codex/shutdown.ts
+var ADAPTER_SHUTDOWN_MS = 25e3;
+function createAdapterShutdown(opts) {
+  let exiting = false;
+  const shutdown2 = () => {
+    if (exiting) return;
+    exiting = true;
+    const timer = setTimeout(() => {
+      logger.warn(`Codex adapter shutdown did not finish within ${ADAPTER_SHUTDOWN_MS}ms; exiting`);
+      opts.exit();
+    }, ADAPTER_SHUTDOWN_MS);
+    const stopped = Promise.resolve().then(opts.stop);
+    const released = Promise.resolve().then(opts.release);
+    void Promise.allSettled([stopped, released]).then(() => {
+      clearTimeout(timer);
+      opts.exit();
+    });
+  };
+  opts.signals.on("SIGINT", shutdown2);
+  opts.signals.on("SIGTERM", shutdown2);
+  opts.stdin?.on("end", shutdown2);
+  opts.stdin?.on("close", shutdown2);
+  return shutdown2;
+}
+
 // src/shared/hub-url.ts
 import net from "net";
 function hubUrlHost(host) {
@@ -1388,23 +1571,14 @@ var supervised = process.argv.includes("--watch-stdin");
 var endpoint = controlEndpoint(CONFIG_DIR);
 var adapter;
 var release;
-var exiting = false;
-var shutdown = () => {
-  if (exiting) return;
-  exiting = true;
-  adapter?.stop();
-  const exit = () => process.exit(0);
-  setTimeout(exit, 3e3).unref();
-  if (release) release().then(exit, exit);
-  else exit();
-};
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-if (supervised) {
-  process.stdin.on("end", shutdown);
-  process.stdin.on("close", shutdown);
-  process.stdin.resume();
-}
+var shutdown = createAdapterShutdown({
+  signals: process,
+  stdin: supervised ? process.stdin : void 0,
+  stop: () => adapter?.stop(),
+  release: () => release?.(),
+  exit: () => process.exit(0)
+});
+if (supervised) process.stdin.resume();
 function send(message, then) {
   if (!process.send || !process.connected) {
     then?.();