@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

package/dist/workspaces/process-identity.test.js

@@ -1,165 +1,111 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { probePosixProcesses, probeWindowsProcesses, probeWslProcesses, sameProcess, signalOwnedPosixProcessGroup, signalPosixProcesses, signalWindowsProcesses, startedNoLaterThan, } from "./process-identity";
-function result(stdout = "", status = 0, stderr = "") {
-    return { pid: 1, output: [null, stdout, stderr], stdout, stderr, status, signal: null };
-}
-function b64(value) {
-    return Buffer.from(value).toString("base64");
-}
+const output = (stdout = "", status = 0, stderr = "") => ({ pid: 1, output: [null, stdout, stderr], stdout, stderr, status, signal: null });
+const spawn = (stdout, call, status = 0, stderr = "") => ((command, args) => {
+    if (call)
+        Object.assign(call, { command, args, script: command === "powershell.exe" ? args.at(-1) ?? "" : args[args.indexOf("-c") + 1] ?? "" });
+    return output(stdout, status, stderr);
+});
+const b64 = (value) => Buffer.from(value).toString("base64");
+const identity = (startTime = "123456") => ({ pid: 42, parentPid: 1, groupId: 42, startTime, bootId: "boot-a", startOrder: startTime });
 describe("process identity probes", () => {
-    it("parses Linux PID, PGID, and kernel process start ticks", () => {
-        let invocation;
-        const probe = probePosixProcesses(((command, args) => {
-            invocation = { command, args };
-            return result("42|1|42|123456|boot-a|123456\n");
-        }), 25, "linux");
-        assert.equal(invocation?.command, "sh");
-        assert.ok(invocation?.args.includes("codenomad-posix-identity"));
-        assert.equal(probe.ok, true);
-        if (probe.ok) {
-            assert.deepEqual(probe.processes.get(42), {
-                pid: 42,
-                parentPid: 1,
-                groupId: 42,
-                startTime: "123456",
-                bootId: "boot-a",
-                startOrder: "123456",
-            });
-        }
-    });
-    it("uses one process-table query on non-Linux POSIX platforms", () => {
-        let invocation;
-        const probe = probePosixProcesses(((command, args) => {
-            invocation = { command, args };
-            return result("  42     1    42 Fri Jul 10 12:34:56 2026 /usr/bin/opencode serve\n");
-        }), 25, "darwin");
-        assert.equal(invocation?.command, "ps");
-        assert.deepEqual(invocation?.args, ["-axo", "pid=,ppid=,pgid=,lstart=,command="]);
-        assert.equal(probe.ok && probe.processes.get(42)?.startTime, "Fri Jul 10 12:34:56 2026\t/usr/bin/opencode serve");
+    it("parses immutable Linux identities", () => {
+        const call = {};
+        const probe = probePosixProcesses(spawn("42|1|42|123456|boot-a|123456\n", call), 25, "linux");
+        assert.deepEqual([call.command, call.args.includes("codenomad-posix-identity"), call.script.trimEnd().endsWith("exit 0")], ["sh", true, true]);
+        assert.deepEqual(probe.ok && probe.processes.get(42), identity());
     });
-    it("round trips delimiter-heavy non-Linux POSIX command identities", () => {
+    it("uses one delimiter-safe process-table query on portable POSIX", () => {
+        const call = {};
         const command = "/opt/opencode 'pipe|value'\t\"quoted\" café";
         const start = "Fri Jul 10 12:34:56 2026";
-        const probe = probePosixProcesses((() => result(`42 1 42 ${start} ${command}\n`)), 25, "darwin");
+        const probe = probePosixProcesses(spawn(`42 1 42 ${start} ${command}\n`, call), 25, "darwin");
+        assert.deepEqual([call.command, call.args], ["ps", ["-axo", "pid=,ppid=,pgid=,lstart=,comm="]]);
         assert.equal(probe.ok && probe.processes.get(42)?.startTime, `${start}\t${command}`);
     });
-    it("uses delimiter-safe identities during non-Linux POSIX escalation", () => {
-        const command = "/opt/opencode pipe|value\nnext\t'quoted'";
-        const startTime = `Fri Jul 10 12:34:56 2026\t${command}`;
-        const identity = { pid: 42, parentPid: 1, groupId: 42, startTime };
-        const guarded = signalPosixProcesses((() => result(`CODENOMAD_TARGET_B64|42|1|42|${b64("Fri Jul 10 12:34:56 2026")}|${b64(command)}\nCODENOMAD_RESULT|1||1\n`)), { leader: identity, groupId: 42, members: [identity], signal: "SIGKILL" }, 25, "darwin");
-        assert.equal(guarded.ok, true);
-        assert.equal(guarded.ok && guarded.signaled[0]?.startTime, startTime);
+    it("ignores malformed unrelated portable rows but fails for a malformed requested identity", () => {
+        const start = "Fri Jul 10 12:34:56 2026";
+        const unrelated = `77 1 77 malformed identity\n42 1 42 ${start} opencode\n`;
+        const filtered = probePosixProcesses(spawn(unrelated), 25, "darwin", { pids: [42], groupId: 42 });
+        assert.equal(filtered.ok && filtered.processes.get(42)?.startTime, `${start}\topencode`);
+        assert.equal(probePosixProcesses(spawn(unrelated), 25, "darwin", { pids: [77] }).ok, false);
     });
-    it("signals and rescans a still-owned portable POSIX process group", () => {
-        const command = "/opt/opencode pipe|value\nchild";
-        let script = "";
-        const cleanup = signalOwnedPosixProcessGroup(((_command, args) => {
-            script = args[1] ?? "";
-            return result(`CODENOMAD_TARGET_B64|42|1|42|${b64("Fri Jul 10 12:34:56 2026")}|${b64(command)}\n` +
-                "CODENOMAD_RESULT|1||1\n");
-        }), 42, "SIGTERM", 25);
-        assert.equal(cleanup.ok && cleanup.matched, true);
-        assert.equal(cleanup.ok && cleanup.signaled[0]?.startTime, `Fri Jul 10 12:34:56 2026\t${command}`);
-        assert.ok(script.indexOf('kill "-$requested_signal"') < script.lastIndexOf("for current_pid"));
+    it("preserves delimiter-heavy identities through POSIX escalation and rescan", () => {
+        const command = "/opt/opencode pipe|value\nnext\t'quoted'";
+        const row = `CODENOMAD_TARGET_B64|42|1|42|${b64("Fri Jul 10 12:34:56 2026")}|${b64(command)}\nCODENOMAD_RESULT|1||1\n`;
+        const expected = `Fri Jul 10 12:34:56 2026\t${command}`;
+        const guardedCall = {};
+        const guarded = signalPosixProcesses(spawn(row, guardedCall), { leader: identity(expected), groupId: 42, members: [identity(expected)], signal: "SIGKILL" }, 25, "darwin");
+        const call = {};
+        const owned = signalOwnedPosixProcessGroup(spawn(row, call), 42, "SIGTERM", 25);
+        assert.deepEqual([guarded.ok, guarded.ok && guarded.signaled[0]?.startTime], [true, expected]);
+        assert.deepEqual([owned.ok && owned.matched, owned.ok && owned.signaled[0]?.startTime], [true, expected]);
+        assert.ok(call.script.indexOf('kill "-$requested_signal"') < call.script.lastIndexOf("for current_pid"));
+        assert.match(call.script, /group_pids\(\).*pid=,pgid=/);
+        assert.doesNotMatch(call.script, /ps -eo pid=/);
+        assert.match(guardedCall.script, /test "\$current_group" = "\$expected_group"/);
     });
-    it("rejects malformed portable process rows", () => {
-        const probe = probePosixProcesses((() => result("42 malformed process row\n")), 25, "darwin");
-        assert.deepEqual(probe, { ok: false, error: "process identity query returned no parseable processes" });
+    it("marks a retained portable group request for leaderless guarded cleanup", () => {
+        const call = {};
+        const guarded = signalPosixProcesses(spawn("CODENOMAD_RESULT|1||1\n", call), {
+            leader: identity("gone"), groupId: 42, members: [identity("member")], signal: "SIGTERM",
+            allowLeaderlessGroup: true, cleanupToken: "secret-token",
+        }, 25, "darwin");
+        assert.equal(guarded.ok, true);
+        assert.equal(call.args[7], "1");
+        assert.equal(call.args[8], "secret-token");
+        assert.match(call.script, /anchor=0/);
+        assert.match(call.script, /has_cleanup_token/);
     });
-    it("queries WSL identities inside the selected distro", () => {
-        let invocation;
-        const probe = probeWslProcesses(((command, args) => {
-            invocation = { command, args };
-            return result("99|1|99|123456|boot-a|123456\n101|99|99|123460|boot-a|123460\n");
-        }), "Ubuntu Test", 25);
-        assert.equal(invocation?.command, "wsl.exe");
-        assert.deepEqual(invocation?.args.slice(0, 4), ["--distribution", "Ubuntu Test", "--exec", "sh"]);
-        assert.ok(invocation?.args.includes("codenomad-wsl-identity"));
+    it("queries WSL identities in the selected distro", () => {
+        const call = {};
+        const probe = probeWslProcesses(spawn("99|1|99|123456|boot-a|123456\n101|99|99|123460|boot-a|123460\n", call), "Ubuntu Test", 25);
+        assert.deepEqual([call.command, call.args.slice(0, 4), call.args.includes("codenomad-wsl-identity"), call.script.trimEnd().endsWith("exit 0")], ["wsl.exe", ["--distribution", "Ubuntu Test", "--exec", "sh"], true, true]);
         assert.equal(probe.ok && probe.processes.get(101)?.startTime, "123460");
     });
-    it("parses Windows CIM CreationDate as the immutable identity", () => {
-        let script = "";
-        const probe = probeWindowsProcesses(((_command, args) => {
-            script = args.at(-1) ?? "";
-            return result("4242|100|0|20260710123456.123456+000||20260710123456\n");
-        }), 25);
-        assert.match(script, /Get-CimInstance Win32_Process/);
-        assert.match(script, /ProcessId -gt 0/);
+    it("uses Windows CIM CreationDate as the immutable identity", () => {
+        const call = {};
+        const probe = probeWindowsProcesses(spawn("4242|100|0|20260710123456.123456+000||20260710123456\n", call), 25);
+        assert.match(call.script, /Get-CimInstance Win32_Process/);
+        assert.match(call.script, /ProcessId -gt 0/);
         assert.equal(probe.ok && probe.processes.get(4242)?.startTime, "20260710123456.123456+000");
     });
-    it("matches only the same numeric PID and start identity", () => {
-        const original = { pid: 42, parentPid: 1, groupId: 42, startTime: "start-a" };
-        assert.equal(sameProcess(original, { ...original }), true);
-        assert.equal(sameProcess(original, { ...original, startTime: "start-b" }), false);
-        assert.equal(sameProcess(original, { ...original, pid: 43 }), false);
+    it("rejects PID reuse and invalid start ordering", () => {
+        const original = identity("9");
+        for (const [candidate, expected] of [[{ ...original }, true], [{ ...original, startTime: "10" }, false], [{ ...original, pid: 43 }, false]])
+            assert.equal(sameProcess(original, candidate), expected);
+        assert.equal(startedNoLaterThan(original, "10"), true);
+        assert.equal(startedNoLaterThan({ ...original, startOrder: "11" }, "10"), false);
+        assert.equal(startedNoLaterThan({ ...original, startOrder: "Fri Jul 10" }, "10"), false);
     });
-    it("compares Linux start ticks numerically and rejects non-numeric fallbacks", () => {
-        const identity = { pid: 42, parentPid: 1, groupId: 42, startTime: "9", startOrder: "9" };
-        assert.equal(startedNoLaterThan(identity, "10"), true);
-        assert.equal(startedNoLaterThan({ ...identity, startOrder: "11" }, "10"), false);
-        assert.equal(startedNoLaterThan({ ...identity, startOrder: "Fri Jul 10" }, "10"), false);
-    });
-    it("returns mismatch without scheduling a second POSIX signal command", () => {
-        const invocations = [];
-        const identity = {
-            pid: 42,
-            parentPid: 1,
-            groupId: 42,
-            startTime: "123456",
-            bootId: "boot-a",
-            startOrder: "123456",
-        };
-        const guarded = signalPosixProcesses(((command, args) => {
-            invocations.push({ command, args });
-            return result("CODENOMAD_RESULT|0||0\n");
-        }), { leader: identity, groupId: 42, members: [identity], signal: "SIGTERM" }, 25, "linux");
+    it("returns a POSIX mismatch without a second signal command", () => {
+        const call = {};
+        const guarded = signalPosixProcesses(spawn("CODENOMAD_RESULT|0||0\n", call), { leader: identity(), groupId: 42, members: [identity()], signal: "SIGTERM" }, 25, "linux");
         assert.deepEqual(guarded, { ok: true, matched: false, signalSent: false, signaled: [] });
-        assert.equal(invocations.length, 1);
-        assert.equal(invocations[0]?.command, "sh");
-        assert.match(invocations[0]?.args[2] ?? "", /codenomad-guarded-signal/);
-        assert.ok(invocations[0]?.args.includes("123456"));
-        const script = invocations[0]?.args[1] ?? "";
-        assert.ok(script.indexOf('kill "-$requested_signal"') < script.indexOf("uptime=$(cut"));
+        assert.deepEqual([call.command, call.args[2], call.args.includes("123456")], ["sh", "codenomad-guarded-signal", true]);
+        assert.ok(call.script.indexOf('kill "-$requested_signal"') < call.script.indexOf("uptime=$(cut"));
     });
-    it("uses one guarded Windows CIM selection and termination invocation", () => {
-        const invocations = [];
-        const identity = { pid: 4242, parentPid: 1, groupId: 4242, startTime: "created" };
-        const guarded = signalWindowsProcesses(((command, args) => {
-            invocations.push({ command, args });
-            return result("CODENOMAD_TARGET|4242|1|0|created||99\nCODENOMAD_RESULT|1||1\n");
-        }), { leader: identity, groupId: 4242, members: [identity], signal: "SIGKILL" }, 25);
+    it("selects and terminates Windows identities in one guarded CIM invocation", () => {
+        const call = {};
+        const guarded = signalWindowsProcesses(spawn("CODENOMAD_TARGET|4242|1|0|created||99\nCODENOMAD_RESULT|1||1\n", call), { leader: identity("created"), groupId: 42, members: [identity("created")], signal: "SIGKILL" }, 25);
         assert.equal(guarded.ok && guarded.matched, true);
-        assert.equal(invocations.length, 1);
-        assert.equal(invocations[0]?.command, "powershell.exe");
-        const script = invocations[0]?.args.at(-1) ?? "";
-        assert.match(script, /CreationDate/);
-        assert.match(script, /Invoke-CimMethod -InputObject/);
-        assert.equal(script.match(/foreach \(\$process in \$selected\)/g)?.length, 2);
-        assert.ok(script.indexOf("CODENOMAD_TARGET|") < script.indexOf("Invoke-CimMethod"));
-        assert.doesNotMatch(script, /taskkill/i);
+        assert.equal(call.command, "powershell.exe");
+        assert.match(call.script, /CreationDate.*Invoke-CimMethod -InputObject/s);
+        assert.equal(call.script.match(/foreach \(\$process in \$selected\)/g)?.length, 2);
+        assert.ok(call.script.indexOf("CODENOMAD_TARGET|") < call.script.indexOf("Invoke-CimMethod"));
+        assert.doesNotMatch(call.script, /taskkill/i);
     });
-    it("preserves observed Windows targets when guarded termination fails partway", () => {
-        const identity = { pid: 4242, parentPid: 1, groupId: 4242, startTime: "created" };
-        const guarded = signalWindowsProcesses((() => result([
-            "CODENOMAD_TARGET|4242|1|0|created||99",
-            "CODENOMAD_TARGET|4243|4242|0|descendant||100",
-        ].join("\n"), 1, "termination failed")), {
-            leader: identity,
-            groupId: 4242,
-            members: [identity],
-            signal: "SIGTERM",
-        }, 25);
+    it("retains observed Windows identities after partial termination failure", () => {
+        const rows = "CODENOMAD_TARGET|4242|1|0|created||99\nCODENOMAD_TARGET|4243|4242|0|descendant||100";
+        const guarded = signalWindowsProcesses(spawn(rows, undefined, 1, "termination failed"), { leader: identity("created"), groupId: 42, members: [identity("created")], signal: "SIGTERM" }, 25);
         assert.equal(guarded.ok, false);
-        assert.deepEqual(!guarded.ok && guarded.observed?.map((target) => target.pid), [4242, 4243]);
-    });
-    it("reports command failures without fabricating identities", () => {
-        const probe = probeWindowsProcesses((() => result("", 1, "CIM unavailable")), 25);
-        assert.deepEqual(probe, { ok: false, error: "CIM unavailable" });
+        assert.deepEqual(!guarded.ok && guarded.observed?.map(({ pid }) => pid), [4242, 4243]);
     });
-    it("rejects successful commands with unparseable or empty output", () => {
-        const probe = probeWslProcesses((() => result("not an identity")), "Ubuntu", 25);
-        assert.deepEqual(probe, { ok: false, error: "process identity query returned no parseable processes" });
+    it("fails conservatively for command, malformed, and empty probe output", () => {
+        assert.deepEqual(probeWindowsProcesses(spawn("", undefined, 1, "CIM unavailable"), 25), { ok: false, error: "CIM unavailable" });
+        assert.deepEqual(probePosixProcesses(spawn("", undefined, 20, "proc unavailable"), 25, "linux"), { ok: false, error: "proc unavailable" });
+        for (const probe of [probePosixProcesses(spawn("42 malformed process row\n"), 25, "darwin"), probeWslProcesses(spawn("not an identity"), "Ubuntu", 25)])
+            assert.equal(probe.ok, false);
     });
 });