@delt/claude-alarm 1.3.0 → 1.4.0

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,116 @@ 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 queryProcesses = () => new Promise((resolve, reject) => {
+  const script = "@(Get-CimInstance Win32_Process | ForEach-Object { [pscustomobject]@{ pid = [int]$_.ProcessId; parentPid = [int]$_.ParentProcessId; creationTime = $_.CreationDate.ToUniversalTime().ToString('o') } }) | ConvertTo-Json -Compress";
+  execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { windowsHide: true, timeout: 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    try {
+      const rows = JSON.parse(stdout);
+      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");
+      }
+      resolve(rows);
+    } catch (error) {
+      reject(error);
+    }
+  });
+});
+var runFile = (file, args, options, callback) => {
+  execFile(file, args, options, (err) => callback(err));
+};
+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;
+function treeKiller(platform = process.platform, run = runFile, query = queryProcesses, throughShell = spawnedThroughShell) {
+  const recorded = /* @__PURE__ */ new WeakMap();
+  const stop = (pid) => new Promise((resolve) => {
+    run("taskkill", ["/PID", String(pid), "/F"], { windowsHide: true }, (err) => {
+      if (err) logger.debug(`taskkill ${pid} failed: ${err.message}`);
+      resolve();
+    });
+  });
+  const stopDeepestFirst = async (descendants) => {
+    for (const descendant of [...descendants].sort((a, b) => b.depth - a.depth)) await stop(descendant.pid);
+  };
+  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;
+    }
+    if (!exited(child)) {
+      const rows = await snapshot();
+      if (!exited(child)) {
+        const descendants2 = rows && descendantsOf(child.pid, rows);
+        if (descendants2) await stopDeepestFirst(descendants2);
+        child.kill();
+        return;
+      }
+    }
+    const descendants = await recorded.get(child) ?? [];
+    if (!descendants.length) return;
+    const current = await snapshot();
+    if (!current) return;
+    await stopDeepestFirst(descendants.filter((d) => current.some((row) => row.pid === d.pid && row.creationTime === d.creationTime)));
+  };
+  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) ?? [] : [];
+      const before = await earlier ?? [];
+      return [...before, ...found.filter((d) => !before.some((b) => b.pid === d.pid && b.creationTime === d.creationTime))];
+    })();
+    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 +523,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 +536,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 +547,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 +757,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 +774,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 +828,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 +838,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 +848,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 +1141,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 +1151,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 +1181,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,8 +1291,8 @@ 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 } : {} });
   }
 };
 
@@ -1392,11 +1522,10 @@ var exiting = false;
 var shutdown = () => {
   if (exiting) return;
   exiting = true;
-  adapter?.stop();
+  const stopped = adapter?.stop();
   const exit = () => process.exit(0);
   setTimeout(exit, 3e3).unref();
-  if (release) release().then(exit, exit);
-  else exit();
+  Promise.all([stopped, release?.()]).then(exit, exit);
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);