@sema-agent/core 1.433.0 → 1.434.0

package/dist/engine/execution-env/kill-tree.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 const DEFAULT_GRACE_MS = 3000;
@@ -25,8 +25,18 @@ export function killProcessTree(pid, opts) {
         return;
     }
     const graceMs = normalizeGraceMs(opts?.graceMs);
-    signalProcessTreeUnix(pid, "SIGTERM", useGroupKill);
+    const termDescendants = signalProcessTreeUnix(pid, "SIGTERM", useGroupKill);
     setTimeout(() => {
+        const rediscovered = enumerateDescendantsSync(pid);
+        const verifiedCarriedForward = new Map();
+        for (const [p, originalEtime] of termDescendants) {
+            const currentEtime = rediscovered.etimeOf.get(p);
+            if (currentEtime !== undefined && verifyStillSameProcess(originalEtime, currentEtime)) {
+                verifiedCarriedForward.set(p, currentEtime);
+            }
+        }
+        const knownDescendants = new Map([...verifiedCarriedForward, ...rediscovered.descendants]);
+        killEach(knownDescendants.keys(), "SIGKILL");
         if (escalationCancelled(opts?.stillRunning)) {
             if (useGroupKill && isProcessAlive(-pid)) {
                 try {
@@ -43,7 +53,19 @@ export function killProcessTree(pid, opts) {
         if (!stillAlive) {
             return;
         }
-        signalProcessTreeUnix(pid, "SIGKILL", useGroupKill);
+        if (useGroupKill) {
+            try {
+                process.kill(-pid, "SIGKILL");
+                return;
+            }
+            catch {
+            }
+        }
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+        }
     }, graceMs).unref();
 }
 function escalationCancelled(stillRunning) {
@@ -82,19 +104,107 @@ function isProcessAlive(pid) {
     }
 }
 function signalProcessTreeUnix(pid, signal, useGroupKill) {
+    const descendants = enumerateDescendantsSync(pid).descendants;
     if (useGroupKill) {
         try {
             process.kill(-pid, signal);
-            return;
         }
         catch {
+            try {
+                process.kill(pid, signal);
+            }
+            catch {
+            }
         }
+        killEach(descendants.keys(), signal);
+        return descendants;
     }
     try {
         process.kill(pid, signal);
     }
     catch {
     }
+    killEach(descendants.keys(), signal);
+    return descendants;
+}
+function killEach(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+        }
+    }
+}
+const PS_ENUMERATION_TIMEOUT_MS = 500;
+const EMPTY_SNAPSHOT = { descendants: new Map(), etimeOf: new Map() };
+function enumerateDescendantsSync(rootPid) {
+    if (process.platform === "win32")
+        return EMPTY_SNAPSHOT;
+    let out;
+    try {
+        const result = spawnSync("ps", ["-A", "-o", "pid=", "-o", "ppid=", "-o", "etime="], {
+            timeout: PS_ENUMERATION_TIMEOUT_MS,
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        if (result.error || typeof result.stdout !== "string")
+            return EMPTY_SNAPSHOT;
+        out = result.stdout;
+    }
+    catch {
+        return EMPTY_SNAPSHOT;
+    }
+    const childrenOf = new Map();
+    const etimeOf = new Map();
+    for (const line of out.split("\n")) {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+        if (!m)
+            continue;
+        const p = Number(m[1]);
+        const pp = Number(m[2]);
+        etimeOf.set(p, m[3]);
+        const list = childrenOf.get(pp);
+        if (list)
+            list.push(p);
+        else
+            childrenOf.set(pp, [p]);
+    }
+    const seen = new Set();
+    const queue = [rootPid];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        for (const kid of childrenOf.get(cur) ?? []) {
+            if (kid <= 1 || kid === rootPid || seen.has(kid))
+                continue;
+            seen.add(kid);
+            queue.push(kid);
+        }
+    }
+    const descendants = new Map();
+    for (const p of seen) {
+        const et = etimeOf.get(p);
+        if (et !== undefined)
+            descendants.set(p, et);
+    }
+    return { descendants, etimeOf };
+}
+function verifyStillSameProcess(originalEtime, currentEtime) {
+    const orig = parseEtimeSeconds(originalEtime);
+    const cur = parseEtimeSeconds(currentEtime);
+    if (orig === undefined || cur === undefined)
+        return false;
+    return cur >= orig;
+}
+function parseEtimeSeconds(etime) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
+    if (!m)
+        return undefined;
+    const days = m[1] !== undefined ? Number(m[1]) : 0;
+    const hours = m[2] !== undefined ? Number(m[2]) : 0;
+    const minutes = Number(m[3]);
+    const seconds = Number(m[4]);
+    return days * 86400 + hours * 3600 + minutes * 60 + seconds;
 }
 function runTaskkill(args) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "1.433.0",
+  "version": "1.434.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",