@hayasaka7/haya-pet 0.2.0 → 0.2.2

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);
+});

package/packages/session-core/src/bubble-view.js

@@ -1,5 +1,4 @@
 import { mapAiStateToPetAction } from "../../pet-core/src/atlas.js";
-import { getSessionPriorityRank } from "./priority.js";
 import { buildSessionSummary, buildStatusLabel, formatElapsed } from "./summaries.js";
 
 // Collapses the full AI-state vocabulary into the four progress kinds the
@@ -53,17 +52,21 @@ export function buildBubbleViews(sessions, now = Date.now(), options = {}) {
   return sessions
     .filter(Boolean)
     .slice()
-    .sort(compareByPriority)
+    .sort(compareByConnectTime)
     .map((session) => buildBubbleView(session, now, options));
 }
 
-function compareByPriority(left, right) {
-  const rankDelta = getSessionPriorityRank(left) - getSessionPriorityRank(right);
-  if (rankDelta !== 0) {
-    return rankDelta;
+// Bubbles stack by connect time — the newest session on top, the first one at
+// the bottom — and never reshuffle while sessions are in progress. State
+// urgency only drives the collapsed-folder dot and the pet animation, not the
+// list order.
+function compareByConnectTime(left, right) {
+  const startedDelta = numeric(right.startedAt) - numeric(left.startedAt);
+  if (startedDelta !== 0) {
+    return startedDelta;
   }
 
-  return numeric(right.updatedAt) - numeric(left.updatedAt);
+  return String(left.sessionId).localeCompare(String(right.sessionId));
 }
 
 function safePetAction(state) {

package/packages/session-core/test/bubble-view.test.mjs

@@ -28,15 +28,40 @@ test("builds a bubble view model with label, summary, action, and elapsed", () =
   assert.equal(view.elapsedLabel, "1m 4s");
 });
 
-test("orders bubbles by session priority then recency", () => {
+test("stacks bubbles by connect time, newest on top, so they never reshuffle mid-session", () => {
   const sessions = [
-    { ...baseSession, sessionId: "sess_idle", state: "idle", updatedAt: 9_000 },
-    { ...baseSession, sessionId: "sess_wait", state: "waiting_approval", updatedAt: 4_000 },
-    { ...baseSession, sessionId: "sess_run", state: "running_tool", updatedAt: 8_000 }
+    { ...baseSession, sessionId: "sess_third", state: "waiting_approval", startedAt: 3_000, updatedAt: 4_000 },
+    { ...baseSession, sessionId: "sess_first", state: "idle", startedAt: 1_000, updatedAt: 9_000 },
+    { ...baseSession, sessionId: "sess_second", state: "running_tool", startedAt: 2_000, updatedAt: 8_000 }
   ];
 
   const views = buildBubbleViews(sessions, 10_000);
-  assert.deepEqual(views.map((view) => view.sessionId), ["sess_wait", "sess_run", "sess_idle"]);
+  assert.deepEqual(views.map((view) => view.sessionId), ["sess_third", "sess_second", "sess_first"]);
+});
+
+test("keeps bubble order stable when states and activity change", () => {
+  const before = [
+    { ...baseSession, sessionId: "sess_first", state: "running_tool", startedAt: 1_000, updatedAt: 2_000 },
+    { ...baseSession, sessionId: "sess_second", state: "idle", startedAt: 2_000, updatedAt: 2_500 }
+  ];
+  // Later, the second session becomes urgent and more recently active.
+  const after = [
+    { ...baseSession, sessionId: "sess_first", state: "idle", startedAt: 1_000, updatedAt: 3_000 },
+    { ...baseSession, sessionId: "sess_second", state: "waiting_approval", startedAt: 2_000, updatedAt: 9_000 }
+  ];
+
+  const order = (sessions) => buildBubbleViews(sessions, 10_000).map((view) => view.sessionId);
+  assert.deepEqual(order(before), order(after));
+});
+
+test("breaks connect-time ties by session id for a deterministic order", () => {
+  const sessions = [
+    { ...baseSession, sessionId: "sess_b", startedAt: 1_000 },
+    { ...baseSession, sessionId: "sess_a", startedAt: 1_000 }
+  ];
+
+  const views = buildBubbleViews(sessions, 10_000);
+  assert.deepEqual(views.map((view) => view.sessionId), ["sess_a", "sess_b"]);
 });
 
 test("marks the selected/pinned session", () => {