@sagentlab/navarch-runtime 0.1.98 → 0.1.99

package/dist/session-processes.cjs

@@ -11,6 +11,7 @@ exports.sessionIdsInUse = sessionIdsInUse;
 exports.terminateProcesses = terminateProcesses;
 exports.reapSessionProcesses = reapSessionProcesses;
 exports.reapOrphanedSessionProcesses = reapOrphanedSessionProcesses;
+exports.sessionDirectoryMissing = sessionDirectoryMissing;
 const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -205,6 +206,28 @@ async function terminateProcesses(pids, deps = {}) {
     }
     return signalled;
 }
+/**
+ * Stops the selected processes, then lists again to verify none remain. A
+ * second round catches anything spawned during the grace period; whatever
+ * survives that is logged, since it needs a person.
+ */
+async function stopUntilGone(label, select, deps) {
+    const stopped = new Set();
+    let processes = await listProcesses(deps);
+    let pids = await select(processes);
+    for (let round = 0; round < 2 && pids.length > 0; round += 1) {
+        for (const pid of await terminateProcesses(pids, deps))
+            stopped.add(pid);
+        processes = await listProcesses(deps);
+        pids = await select(processes);
+    }
+    if (pids.length > 0) {
+        const survivors = processes.filter((entry) => pids.includes(entry.pid))
+            .map((entry) => `${entry.pid} ${entry.command.slice(0, 120)}`);
+        log.warn(`processes left by ${label} survived SIGKILL: ${survivors.join("; ")}`);
+    }
+    return [...stopped].sort((a, b) => a - b);
+}
 async function spellings(root) {
     const resolved = node_path_1.default.resolve(root);
     const real = await node_fs_1.promises.realpath(resolved).catch(() => resolved);
@@ -216,9 +239,8 @@ async function spellings(root) {
  */
 async function reapSessionProcesses(sessionRoot, deps = {}) {
     try {
-        const processes = await listProcesses(deps);
-        const pids = sessionProcessIds(processes, await spellings(sessionRoot), deps.selfPid ?? process.pid);
-        const stopped = await terminateProcesses(pids, deps);
+        const roots = await spellings(sessionRoot);
+        const stopped = await stopUntilGone(node_path_1.default.basename(sessionRoot), async (processes) => sessionProcessIds(processes, roots, deps.selfPid ?? process.pid), deps);
         if (stopped.length > 0) {
             log.info(`stopped ${stopped.length} process(es) left running by ${node_path_1.default.basename(sessionRoot)}: ${stopped.join(" ")}`);
         }
@@ -230,31 +252,33 @@ async function reapSessionProcesses(sessionRoot, deps = {}) {
     }
 }
 /**
- * Stops processes of sessions that no longer exist: not active in this
- * runtime and with no directory on disk. Those are left over from a runtime
- * that crashed, or from an older runtime that never stopped them. A session
- * directory that still exists belongs to the janitor's age rules, which may
- * be protecting another runtime's live session. Processes on a terminal are
- * left alone here: by then they are more likely a person's than an agent's.
+ * Stops processes of sessions that have ended: not active in this runtime,
+ * and `hasEnded` agrees. By default that means the directory is gone; the
+ * janitor also counts a directory whose runtime crashed (its activity marker
+ * names a runtime pid that no longer exists), because a crash skips the
+ * session's own cleanup and leaves the directory behind. A directory that
+ * may still belong to another live runtime stays under the janitor's age
+ * rules. Processes on a terminal are left alone here: by then they are more
+ * likely a person's than an agent's.
  */
 async function reapOrphanedSessionProcesses(sessionsRoot, isSessionActive, deps = {}) {
+    const hasEnded = deps.hasEnded ?? sessionDirectoryMissing;
     try {
-        const processes = await listProcesses(deps);
-        const inUse = sessionIdsInUse(processes, await spellings(sessionsRoot));
-        const orphanRoots = [];
-        for (const [sessionId, roots] of inUse) {
-            if (isSessionActive(sessionId))
-                continue;
-            const exists = await node_fs_1.promises.stat(node_path_1.default.join(sessionsRoot, sessionId)).then(() => true, () => false);
-            if (!exists)
-                orphanRoots.push(...roots);
-        }
-        if (orphanRoots.length === 0)
-            return [];
-        const pids = sessionProcessIds(processes, orphanRoots, deps.selfPid ?? process.pid, { skipInteractive: true });
-        const stopped = await terminateProcesses(pids, deps);
+        const sessionsRoots = await spellings(sessionsRoot);
+        const stopped = await stopUntilGone("ended sessions", async (processes) => {
+            const orphanRoots = [];
+            for (const [sessionId, roots] of sessionIdsInUse(processes, sessionsRoots)) {
+                if (isSessionActive(sessionId))
+                    continue;
+                if (await hasEnded(sessionId, node_path_1.default.join(sessionsRoot, sessionId)))
+                    orphanRoots.push(...roots);
+            }
+            if (orphanRoots.length === 0)
+                return [];
+            return sessionProcessIds(processes, orphanRoots, deps.selfPid ?? process.pid, { skipInteractive: true });
+        }, deps);
         if (stopped.length > 0) {
-            log.info(`stopped ${stopped.length} process(es) left by deleted sessions: ${stopped.join(" ")}`);
+            log.info(`stopped ${stopped.length} process(es) left by ended sessions: ${stopped.join(" ")}`);
         }
         return stopped;
     }
@@ -263,3 +287,6 @@ async function reapOrphanedSessionProcesses(sessionsRoot, isSessionActive, deps
         return [];
     }
 }
+async function sessionDirectoryMissing(_sessionId, sessionRoot) {
+    return node_fs_1.promises.stat(sessionRoot).then(() => false, () => true);
+}

package/dist/worktree-janitor.cjs

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorktreeJanitor = exports.SESSION_RECOVERY_FILENAME = exports.SESSION_ACTIVITY_FILENAME = void 0;
 exports.markSessionWorkspaceActive = markSessionWorkspaceActive;
+exports.sessionOwnerPid = sessionOwnerPid;
+exports.sessionHasEnded = sessionHasEnded;
 exports.hasRecoveryMarker = hasRecoveryMarker;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = require("node:fs");
@@ -16,15 +18,48 @@ exports.SESSION_ACTIVITY_FILENAME = ".navarch-active";
 exports.SESSION_RECOVERY_FILENAME = ".navarch-recovery-required";
 const defaultProcessReaper = {
     reapSession: (sessionRoot) => (0, session_processes_cjs_1.reapSessionProcesses)(sessionRoot),
-    reapOrphans: (sessionsRoot, isSessionActive) => (0, session_processes_cjs_1.reapOrphanedSessionProcesses)(sessionsRoot, isSessionActive),
+    reapOrphans: (sessionsRoot, isSessionActive) => (0, session_processes_cjs_1.reapOrphanedSessionProcesses)(sessionsRoot, isSessionActive, { hasEnded: sessionHasEnded }),
 };
 /**
  * Refreshes the durable activity marker used by janitors in other runtime
- * processes that happen to share a workspace root.
+ * processes that happen to share a workspace root. It names the owning
+ * runtime pid so a restarted runtime can tell its crashed predecessor's
+ * sessions from another live runtime's.
  */
-async function markSessionWorkspaceActive(sessionRoot) {
+async function markSessionWorkspaceActive(sessionRoot, ownerPid = process.pid) {
     await node_fs_1.promises.mkdir(sessionRoot, { recursive: true });
-    await node_fs_1.promises.writeFile(node_path_1.default.join(sessionRoot, exports.SESSION_ACTIVITY_FILENAME), `${new Date().toISOString()}\n`, "utf8");
+    await node_fs_1.promises.writeFile(node_path_1.default.join(sessionRoot, exports.SESSION_ACTIVITY_FILENAME), `${new Date().toISOString()}\npid=${ownerPid}\n`, "utf8");
+}
+/** The runtime pid an activity marker names, or null for older markers. */
+async function sessionOwnerPid(sessionRoot) {
+    const marker = await node_fs_1.promises.readFile(node_path_1.default.join(sessionRoot, exports.SESSION_ACTIVITY_FILENAME), "utf8").catch(() => "");
+    const match = /^pid=(\d+)$/m.exec(marker);
+    return match ? Number(match[1]) : null;
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: alive, but another user's.
+        return error instanceof Error && "code" in error && error.code === "EPERM";
+    }
+}
+/**
+ * A session the janitor's caller has already found inactive has ended when
+ * its directory is gone, or when its marker names this runtime (so it
+ * finished here) or a runtime that no longer exists (it crashed, which skips
+ * the session's own process cleanup). A live other owner, or a marker from
+ * before owners were recorded, leaves it to the age rules.
+ */
+async function sessionHasEnded(sessionId, sessionRoot, alive = isPidAlive) {
+    if (await (0, session_processes_cjs_1.sessionDirectoryMissing)(sessionId, sessionRoot))
+        return true;
+    const owner = await sessionOwnerPid(sessionRoot);
+    if (owner === null)
+        return false;
+    return owner === process.pid || !alive(owner);
 }
 /**
  * Periodically removes session worktrees left behind by SIGKILL, a host
@@ -134,8 +169,8 @@ class WorktreeJanitor {
                 log.warn(`could not clean abandoned session ${sessionId}: ${String(error)}`);
             }
         }
-        // Processes can outlive their session directory: a runtime that crashed
-        // before stopping them, or a runtime older than 0.1.98.
+        // Processes can outlive their session: a runtime that crashed before
+        // stopping them, or a runtime older than 0.1.98.
         await this.processReaper.reapOrphans(sessionsRoot, (sessionId) => this.options.isSessionActive?.(sessionId) ?? false);
         return summary;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.98",
+  "version": "0.1.99",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",