@hayasaka7/haya-pet 0.2.0 → 0.2.1

package/packages/daemon-core/test/approval-process-watcher.test.mjs

@@ -0,0 +1,295 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  watchForApprovedProcess,
+  createApprovalWatchCoordinator
+} from "../src/approval-process-watcher.js";
+
+// --- watchForApprovedProcess -------------------------------------------------
+// The watcher's contract is event-based, never time-based: it may only report
+// "approved" because a real NEW process appeared under the client and stayed
+// alive across two consecutive polls. A missed detection is always safe (the
+// pet just keeps showing "waiting"); a false detection would hide a pending
+// approval warning, so the persistence filter errs toward not firing.
+
+function makeWatcher(snapshots, overrides = {}) {
+  // `snapshots` is a queue of process tables the fake lister returns per call.
+  const calls = { cleared: 0 };
+  const watcher = watchForApprovedProcess({
+    rootPid: 100,
+    listProcesses: async () => {
+      if (snapshots.length === 0) {
+        throw new Error("test ran out of snapshots");
+      }
+      const next = snapshots.shift();
+      if (next instanceof Error) {
+        throw next;
+      }
+      return next;
+    },
+    immediate: false,
+    setInterval: () => ({ unref() {} }),
+    clearInterval: () => {
+      calls.cleared += 1;
+    },
+    ...overrides
+  });
+  return { watcher, calls };
+}
+
+const ROOT = { pid: 100, ppid: 1 };
+const BASE_CHILD = { pid: 110, ppid: 100 };
+
+test("approval watcher ignores descendants that existed at baseline", async () => {
+  const approved = [];
+  const { watcher } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick(); // baseline
+  await watcher._tick();
+  await watcher._tick();
+
+  assert.deepEqual(approved, []);
+});
+
+test("approval watcher fires once when a new descendant persists across two polls", async () => {
+  const approved = [];
+  const newChild = { pid: 200, ppid: 100 };
+  const { watcher, calls } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD, newChild],
+      [ROOT, BASE_CHILD, newChild],
+      [ROOT, BASE_CHILD, newChild, { pid: 300, ppid: 100 }]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick(); // baseline
+  await watcher._tick(); // candidate seen once — not yet
+  assert.deepEqual(approved, []);
+  await watcher._tick(); // candidate persisted — fire
+  assert.deepEqual(approved, [{ pid: 200 }]);
+
+  // Fires once and stops itself; later ticks are no-ops.
+  await watcher._tick();
+  assert.equal(approved.length, 1);
+  assert.equal(calls.cleared, 1);
+});
+
+test("approval watcher ignores a short-lived blip (hook spawn)", async () => {
+  const approved = [];
+  const blip = { pid: 200, ppid: 100 };
+  const { watcher } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD, blip],
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick(); // baseline
+  await watcher._tick(); // blip appears
+  await watcher._tick(); // blip gone — must not fire
+  await watcher._tick();
+
+  assert.deepEqual(approved, []);
+});
+
+test("approval watcher detects new grandchildren, not just direct children", async () => {
+  const approved = [];
+  // New process hangs off the pre-existing shell child (root -> shell -> command).
+  const grandchild = { pid: 200, ppid: 110 };
+  const { watcher } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD, grandchild],
+      [ROOT, BASE_CHILD, grandchild]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick();
+  await watcher._tick();
+  await watcher._tick();
+
+  assert.deepEqual(approved, [{ pid: 200 }]);
+});
+
+test("approval watcher does not detect unrelated processes", async () => {
+  const approved = [];
+  const unrelated = { pid: 200, ppid: 999 };
+  const { watcher } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD, unrelated],
+      [ROOT, BASE_CHILD, unrelated]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick();
+  await watcher._tick();
+  await watcher._tick();
+
+  assert.deepEqual(approved, []);
+});
+
+test("approval watcher survives lister errors and keeps working", async () => {
+  const approved = [];
+  const newChild = { pid: 200, ppid: 100 };
+  const { watcher } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      new Error("snapshot failed"),
+      [ROOT, BASE_CHILD, newChild],
+      [ROOT, BASE_CHILD, newChild]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick(); // baseline
+  await watcher._tick(); // error — swallowed
+  await watcher._tick(); // candidate
+  await watcher._tick(); // persisted — fire
+
+  assert.deepEqual(approved, [{ pid: 200 }]);
+});
+
+test("approval watcher stop() prevents any further detection", async () => {
+  const approved = [];
+  const newChild = { pid: 200, ppid: 100 };
+  const { watcher, calls } = makeWatcher(
+    [
+      [ROOT, BASE_CHILD],
+      [ROOT, BASE_CHILD, newChild],
+      [ROOT, BASE_CHILD, newChild]
+    ],
+    { onApproved: (event) => approved.push(event) }
+  );
+
+  await watcher._tick();
+  watcher.stop();
+  await watcher._tick();
+  await watcher._tick();
+
+  assert.deepEqual(approved, []);
+  assert.equal(calls.cleared, 1);
+});
+
+// --- createApprovalWatchCoordinator -------------------------------------------
+// Bridges session state changes to per-session watchers: watch only while a
+// session with a known pid sits in waiting_approval; stop on any other state.
+
+function makeCoordinator(overrides = {}) {
+  const events = { started: [], stopped: [], approved: [] };
+  const watchers = new Map();
+  const coordinator = createApprovalWatchCoordinator({
+    createWatcher: ({ rootPid, onApproved }) => {
+      events.started.push(rootPid);
+      const watcher = {
+        onApproved,
+        stop: () => events.stopped.push(rootPid)
+      };
+      watchers.set(rootPid, watcher);
+      return watcher;
+    },
+    onApproved: (sessionId, event) => events.approved.push({ sessionId, ...event }),
+    ...overrides
+  });
+  return { coordinator, events, watchers };
+}
+
+function session(state, overrides = {}) {
+  return { sessionId: "sess_a", pid: 100, state, ...overrides };
+}
+
+test("coordinator starts a watcher when a session enters waiting_approval", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("thinking"));
+  assert.deepEqual(events.started, []);
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  assert.deepEqual(events.started, [100]);
+});
+
+test("coordinator does not start a duplicate watcher for the same session", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  coordinator.onSessionChanged(session("waiting_approval"));
+
+  assert.deepEqual(events.started, [100]);
+});
+
+test("coordinator stops the watcher when the session leaves waiting_approval", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  coordinator.onSessionChanged(session("thinking"));
+
+  assert.deepEqual(events.stopped, [100]);
+
+  // Re-entering waiting_approval starts a fresh watcher.
+  coordinator.onSessionChanged(session("waiting_approval"));
+  assert.deepEqual(events.started, [100, 100]);
+});
+
+test("coordinator ignores sessions without a pid", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval", { pid: undefined }));
+
+  assert.deepEqual(events.started, []);
+});
+
+test("coordinator ignores undefined session changes", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(undefined);
+
+  assert.deepEqual(events.started, []);
+});
+
+test("coordinator forwards approval with the sessionId and stops tracking", () => {
+  const { coordinator, events, watchers } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  watchers.get(100).onApproved({ pid: 200 });
+
+  assert.deepEqual(events.approved, [{ sessionId: "sess_a", pid: 200 }]);
+
+  // The fired watcher is forgotten — a later waiting_approval starts a new one.
+  coordinator.onSessionChanged(session("waiting_approval"));
+  assert.deepEqual(events.started, [100, 100]);
+});
+
+test("coordinator tracks multiple sessions independently", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  coordinator.onSessionChanged(session("waiting_approval", { sessionId: "sess_b", pid: 300 }));
+  coordinator.onSessionChanged(session("idle"));
+
+  assert.deepEqual(events.started, [100, 300]);
+  assert.deepEqual(events.stopped, [100]);
+});
+
+test("coordinator stopAll stops every active watcher", () => {
+  const { coordinator, events } = makeCoordinator();
+
+  coordinator.onSessionChanged(session("waiting_approval"));
+  coordinator.onSessionChanged(session("waiting_approval", { sessionId: "sess_b", pid: 300 }));
+  coordinator.stopAll();
+
+  assert.deepEqual(events.stopped.sort(), [100, 300]);
+});

package/packages/platform-core/src/process-snapshot.js

@@ -0,0 +1,88 @@
+// Cross-OS process-table snapshots: every lister resolves to the full process
+// list as [{ pid, ppid }], so consumers (the approval watcher) never branch on
+// platform. Returns undefined on platforms we don't support — callers treat
+// that as "feature unavailable", never as an error.
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import { readdir as readdirFs, readFile as readFileFs } from "node:fs/promises";
+
+const execFileAsync = promisify(execFileCb);
+
+// One pid+ppid pair per line, whitespace-separated — both `ps` and our
+// PowerShell query are shaped to emit exactly this.
+function parsePidTable(stdout) {
+  const table = [];
+  for (const line of String(stdout).split("\n")) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length !== 2) {
+      continue;
+    }
+    const pid = Number.parseInt(parts[0], 10);
+    const ppid = Number.parseInt(parts[1], 10);
+    if (Number.isInteger(pid) && Number.isInteger(ppid)) {
+      table.push({ pid, ppid });
+    }
+  }
+  return table;
+}
+
+export function createProcessSnapshotLister(options = {}) {
+  const {
+    platform = process.platform,
+    execFile = execFileAsync,
+    readdir = readdirFs,
+    readFile = readFileFs
+  } = options;
+
+  if (platform === "win32") {
+    // CIM query via PowerShell (wmic is removed on current Windows 11). Output
+    // is forced to bare "pid ppid" lines to keep parsing trivial.
+    const script =
+      "Get-CimInstance -ClassName Win32_Process | ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }";
+    return async () => {
+      const { stdout } = await execFile(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-Command", script],
+        { windowsHide: true }
+      );
+      return parsePidTable(stdout);
+    };
+  }
+
+  if (platform === "darwin") {
+    return async () => {
+      const { stdout } = await execFile("ps", ["-axo", "pid=,ppid="]);
+      return parsePidTable(stdout);
+    };
+  }
+
+  if (platform === "linux") {
+    // Read /proc directly — no subprocess at all. stat field 4 is ppid, but the
+    // comm field (2) is parenthesised and may contain spaces/parens, so parse
+    // from AFTER the last ')'.
+    return async () => {
+      const entries = await readdir("/proc");
+      const table = [];
+      for (const entry of entries) {
+        if (!/^\d+$/.test(entry)) {
+          continue;
+        }
+        let stat;
+        try {
+          stat = String(await readFile(`/proc/${entry}/stat`, "utf8"));
+        } catch {
+          continue; // process exited mid-scan
+        }
+        const afterComm = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+        const ppid = Number.parseInt(afterComm[1], 10);
+        const pid = Number.parseInt(entry, 10);
+        if (Number.isInteger(pid) && Number.isInteger(ppid)) {
+          table.push({ pid, ppid });
+        }
+      }
+      return table;
+    };
+  }
+
+  return undefined;
+}

package/packages/platform-core/test/process-snapshot.test.mjs

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createProcessSnapshotLister } from "../src/process-snapshot.js";
+
+// Each platform lister returns the same shape — the full process table as
+// [{ pid, ppid }] — so the approval watcher core stays platform-agnostic.
+
+test("windows lister parses the PowerShell pid/ppid table", async () => {
+  const invocations = [];
+  const lister = createProcessSnapshotLister({
+    platform: "win32",
+    execFile: async (file, args) => {
+      invocations.push({ file, args });
+      return { stdout: "4 0\r\n100 4\r\n2332 100\r\n\r\n" };
+    }
+  });
+
+  const table = await lister();
+
+  assert.deepEqual(table, [
+    { pid: 4, ppid: 0 },
+    { pid: 100, ppid: 4 },
+    { pid: 2332, ppid: 100 }
+  ]);
+  assert.equal(invocations.length, 1);
+  assert.equal(invocations[0].file, "powershell.exe");
+  // Must never load the user's profile or prompt interactively.
+  assert.ok(invocations[0].args.includes("-NoProfile"));
+  assert.ok(invocations[0].args.includes("-NonInteractive"));
+});
+
+test("darwin lister parses ps output with ragged spacing", async () => {
+  const lister = createProcessSnapshotLister({
+    platform: "darwin",
+    execFile: async (file, args) => {
+      assert.equal(file, "ps");
+      assert.deepEqual(args, ["-axo", "pid=,ppid="]);
+      return { stdout: "    1     0\n  455     1\n12034   455\n" };
+    }
+  });
+
+  assert.deepEqual(await lister(), [
+    { pid: 1, ppid: 0 },
+    { pid: 455, ppid: 1 },
+    { pid: 12034, ppid: 455 }
+  ]);
+});
+
+test("linux lister reads /proc stat files, handling names with spaces and parens", async () => {
+  const files = {
+    "/proc/1/stat": "1 (systemd) S 0 1 1 0 -1 4194560",
+    "/proc/455/stat": "455 (my (weird) name) S 1 455 455 0 -1 0",
+    "/proc/9999/stat": "9999 (node) R 455 9999 9999 0 -1 0"
+  };
+  const lister = createProcessSnapshotLister({
+    platform: "linux",
+    readdir: async (dir) => {
+      assert.equal(dir, "/proc");
+      return ["1", "455", "9999", "self", "acpi", "cpuinfo"];
+    },
+    readFile: async (path) => {
+      if (!(path in files)) {
+        throw new Error(`unexpected read: ${path}`);
+      }
+      return files[path];
+    }
+  });
+
+  assert.deepEqual(await lister(), [
+    { pid: 1, ppid: 0 },
+    { pid: 455, ppid: 1 },
+    { pid: 9999, ppid: 455 }
+  ]);
+});
+
+test("linux lister skips processes that vanish mid-scan", async () => {
+  const lister = createProcessSnapshotLister({
+    platform: "linux",
+    readdir: async () => ["1", "2"],
+    readFile: async (path) => {
+      if (path === "/proc/2/stat") {
+        throw new Error("ENOENT: gone");
+      }
+      return "1 (init) S 0 1 1 0 -1 0";
+    }
+  });
+
+  assert.deepEqual(await lister(), [{ pid: 1, ppid: 0 }]);
+});
+
+test("listers skip malformed lines instead of failing", async () => {
+  const lister = createProcessSnapshotLister({
+    platform: "win32",
+    execFile: async () => ({ stdout: "4 0\nnot numbers\n77\n100 4\n" })
+  });
+
+  assert.deepEqual(await lister(), [
+    { pid: 4, ppid: 0 },
+    { pid: 100, ppid: 4 }
+  ]);
+});
+
+test("unsupported platforms yield no lister", () => {
+  assert.equal(createProcessSnapshotLister({ platform: "sunos" }), undefined);
+});