@sagentlab/navarch-runtime 0.1.97 → 0.1.99

package/dist/session-processes.cjs

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProcesses = listProcesses;
+exports.parsePsOutput = parsePsOutput;
+exports.parseLsofCwds = parseLsofCwds;
+exports.sessionProcessIds = sessionProcessIds;
+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"));
+const logger_cjs_1 = require("./logger.cjs");
+const sandbox_cjs_1 = require("./sandbox.cjs");
+const log = (0, logger_cjs_1.createLogger)("session-processes");
+const DEFAULT_GRACE_MS = 3_000;
+const POLL_MS = 200;
+/** Every process this user owns, with its working directory where readable. */
+async function listProcesses(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    if (platform === "win32")
+        return [];
+    const runner = deps.runner ?? sandbox_cjs_1.nodeCommandRunner;
+    const listing = await runner.run("ps", ["axww", "-o", "pid=,ppid=,tty=,command="], { timeoutMs: 10_000 });
+    if (listing.code !== 0)
+        return [];
+    const processes = parsePsOutput(listing.stdout);
+    const cwds = platform === "linux"
+        ? await linuxCwds(processes, deps.readProcCwd ?? readProcCwd)
+        : await lsofCwds(runner, deps.uid ?? node_os_1.default.userInfo().uid);
+    for (const entry of processes)
+        entry.cwd = cwds.get(entry.pid);
+    return processes;
+}
+function parsePsOutput(stdout) {
+    const processes = [];
+    for (const line of stdout.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+        if (!match)
+            continue;
+        processes.push({ pid: Number(match[1]), ppid: Number(match[2]), tty: match[3], command: match[4] ?? "" });
+    }
+    return processes;
+}
+/** `lsof -F pn` output: a `p<pid>` line opens each process, `n<path>` is its cwd. */
+function parseLsofCwds(stdout) {
+    const cwds = new Map();
+    let pid = null;
+    for (const line of stdout.split("\n")) {
+        if (line.startsWith("p"))
+            pid = Number(line.slice(1));
+        else if (line.startsWith("n") && pid !== null && Number.isFinite(pid))
+            cwds.set(pid, line.slice(1));
+    }
+    return cwds;
+}
+async function lsofCwds(runner, uid) {
+    // lsof exits 1 when some processes could not be read; the rest is still valid.
+    const result = await runner
+        .run("lsof", ["-nP", "-a", "-u", String(uid), "-d", "cwd", "-F", "pn"], { timeoutMs: 15_000 })
+        .catch(() => null);
+    return result ? parseLsofCwds(result.stdout) : new Map();
+}
+async function linuxCwds(processes, read) {
+    const cwds = new Map();
+    await Promise.all(processes.map(async ({ pid }) => {
+        const cwd = await read(pid);
+        if (cwd)
+            cwds.set(pid, cwd);
+    }));
+    return cwds;
+}
+async function readProcCwd(pid) {
+    return node_fs_1.promises.readlink(`/proc/${pid}/cwd`).then((cwd) => cwd.replace(/ \(deleted\)$/, ""), () => undefined);
+}
+/** A process on a terminal is a person's, e.g. a shell left in a deleted session directory. */
+function isInteractive(entry) {
+    return entry.tty !== undefined && entry.tty !== "??" && entry.tty !== "?" && entry.tty !== "-";
+}
+function within(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${node_path_1.default.sep}`);
+}
+function namesPathIn(command, root) {
+    let index = command.indexOf(root);
+    while (index !== -1) {
+        const before = index === 0 ? " " : command[index - 1];
+        const after = command[index + root.length];
+        if ((before === " " || before === "=" || before === "'" || before === '"') &&
+            (after === undefined || after === node_path_1.default.sep || after === " " || after === "'" || after === '"')) {
+            return true;
+        }
+        index = command.indexOf(root, index + 1);
+    }
+    return false;
+}
+/** The runtime and every ancestor up to init: never a session's process. */
+function protectedPids(processes, selfPid) {
+    const parentOf = new Map(processes.map((entry) => [entry.pid, entry.ppid]));
+    const protectedSet = new Set([selfPid, 0, 1]);
+    let current = parentOf.get(selfPid);
+    while (current !== undefined && !protectedSet.has(current)) {
+        protectedSet.add(current);
+        current = parentOf.get(current);
+    }
+    return protectedSet;
+}
+/**
+ * Pids tied to any of `roots` (the same directory under its spellings, e.g.
+ * /var and /private/var), with their descendants. The runtime and its
+ * ancestors are never included.
+ */
+function sessionProcessIds(processes, roots, selfPid, options = {}) {
+    const guarded = protectedPids(processes, selfPid);
+    if (options.skipInteractive) {
+        for (const entry of processes)
+            if (isInteractive(entry))
+                guarded.add(entry.pid);
+    }
+    const childrenOf = new Map();
+    for (const entry of processes) {
+        const siblings = childrenOf.get(entry.ppid) ?? [];
+        siblings.push(entry.pid);
+        childrenOf.set(entry.ppid, siblings);
+    }
+    const selected = new Set();
+    const visit = (pid) => {
+        if (guarded.has(pid) || selected.has(pid))
+            return;
+        selected.add(pid);
+        for (const child of childrenOf.get(pid) ?? [])
+            visit(child);
+    };
+    for (const entry of processes) {
+        const tied = roots.some((root) => namesPathIn(entry.command, root) || (entry.cwd !== undefined && within(entry.cwd, root)));
+        if (tied)
+            visit(entry.pid);
+    }
+    return [...selected].sort((a, b) => a - b);
+}
+/**
+ * Session ids named by processes under `sessionsRoots`, keyed to the
+ * spellings of that session's root that matched.
+ */
+function sessionIdsInUse(processes, sessionsRoots) {
+    const found = new Map();
+    for (const sessionsRoot of sessionsRoots) {
+        const prefix = `${sessionsRoot}${node_path_1.default.sep}`;
+        for (const entry of processes) {
+            for (const text of [entry.command, entry.cwd ?? ""]) {
+                let index = text.indexOf(prefix);
+                while (index !== -1) {
+                    const rest = text.slice(index + prefix.length);
+                    const sessionId = /^[A-Za-z0-9._-]+/.exec(rest)?.[0];
+                    if (sessionId && sessionId !== "." && sessionId !== "..") {
+                        const roots = found.get(sessionId) ?? new Set();
+                        roots.add(node_path_1.default.join(sessionsRoot, sessionId));
+                        found.set(sessionId, roots);
+                    }
+                    index = text.indexOf(prefix, index + 1);
+                }
+            }
+        }
+    }
+    return found;
+}
+/** SIGTERM, a grace period, then SIGKILL for anything still running. */
+async function terminateProcesses(pids, deps = {}) {
+    if (pids.length === 0)
+        return [];
+    const kill = deps.kill ?? ((pid, signal) => process.kill(pid, signal));
+    const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const alive = (pid) => {
+        try {
+            kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const signalled = pids.filter((pid) => {
+        try {
+            kill(pid, "SIGTERM");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const graceMs = deps.graceMs ?? DEFAULT_GRACE_MS;
+    let remaining = signalled;
+    for (let waited = 0; remaining.length > 0 && waited < graceMs; waited += POLL_MS) {
+        await sleep(POLL_MS);
+        remaining = remaining.filter(alive);
+    }
+    for (const pid of remaining) {
+        try {
+            kill(pid, "SIGKILL");
+        }
+        catch { /* Exited between the check and the kill. */ }
+    }
+    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);
+    return real === resolved ? [resolved] : [resolved, real];
+}
+/**
+ * Stops every process still tied to a finished session's directory. Never
+ * throws: a failed listing must not block worktree cleanup.
+ */
+async function reapSessionProcesses(sessionRoot, deps = {}) {
+    try {
+        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(" ")}`);
+        }
+        return stopped;
+    }
+    catch (error) {
+        log.warn(`could not stop processes left by ${node_path_1.default.basename(sessionRoot)}: ${String(error)}`);
+        return [];
+    }
+}
+/**
+ * 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 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 ended sessions: ${stopped.join(" ")}`);
+        }
+        return stopped;
+    }
+    catch (error) {
+        log.warn(`orphaned session process sweep failed: ${String(error)}`);
+        return [];
+    }
+}
+async function sessionDirectoryMissing(_sessionId, sessionRoot) {
+    return node_fs_1.promises.stat(sessionRoot).then(() => false, () => true);
+}

package/dist/session.cjs

@@ -21,6 +21,7 @@ const mcp_config_cjs_1 = require("./mcp-config.cjs");
 const logger_cjs_1 = require("./logger.cjs");
 const git_worktree_cjs_1 = require("./git-worktree.cjs");
 const worktree_janitor_cjs_1 = require("./worktree-janitor.cjs");
+const session_processes_cjs_1 = require("./session-processes.cjs");
 const github_pr_cjs_1 = require("./github-pr.cjs");
 const delivery_cjs_1 = require("./delivery.cjs");
 const worktree_guard_cjs_1 = require("./worktree-guard.cjs");
@@ -904,6 +905,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         catch (stopErr) {
             log.warn(`sandbox stop failed during teardown: ${String(stopErr)}`);
         }
+        // Dev servers the agent started detached outlive its process group. Stop
+        // them before the worktree goes, or they run on against a deleted repo.
+        await (0, session_processes_cjs_1.reapSessionProcesses)(workDir);
         if (retainWorktree) {
             await gitWorktree.retainForRecovery().catch((error) => log.error(`Recovery worktree retained at ${gitWorktree.worktreePath}, but retention setup or credential cleanup failed: ${String(error)}`));
         }

package/dist/worktree-janitor.cjs

@@ -5,21 +5,61 @@ 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");
 const logger_cjs_1 = require("./logger.cjs");
 const sandbox_cjs_1 = require("./sandbox.cjs");
+const session_processes_cjs_1 = require("./session-processes.cjs");
 const log = (0, logger_cjs_1.createLogger)("worktree-janitor");
 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, { 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
@@ -33,12 +73,14 @@ class WorktreeJanitor {
     options;
     runner;
     now;
+    processReaper;
     timer = null;
     sweepInFlight = null;
     constructor(options) {
         this.options = options;
         this.runner = options.runner ?? sandbox_cjs_1.nodeCommandRunner;
         this.now = options.now ?? Date.now;
+        this.processReaper = options.processReaper ?? defaultProcessReaper;
     }
     start() {
         if (this.timer)
@@ -118,6 +160,7 @@ class WorktreeJanitor {
                     summary.skippedActive += 1;
                     continue;
                 }
+                await this.processReaper.reapSession(sessionRoot);
                 await this.removeSessionWorktree(sessionRoot);
                 summary.removed += 1;
             }
@@ -126,6 +169,9 @@ class WorktreeJanitor {
                 log.warn(`could not clean abandoned session ${sessionId}: ${String(error)}`);
             }
         }
+        // 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;
     }
     async lastActivityAt(sessionRoot) {

package/package.json

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