daemon stability wave 1: honest supervision, sacred event loop, trust boundary, bounded fixes

commands/__tests__/daemon-logs-render.test.ts

@@ -0,0 +1,38 @@
+/**
+ * nativeStderrDisplay (showLogs' stale-crash mtime gate).
+ *
+ * daemon-stderr.log is rotated on daemon boot (lib/daemon-logger.ts), but a
+ * leftover file can still predate the *currently running* daemon (e.g. it was
+ * never rotated because the daemon has been up for days). This pins the
+ * show/hide + header decision without needing a live daemon or a real file.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { nativeStderrDisplay } from "../daemon.ts";
+
+const NOW = 1_785_000_000_000;
+
+describe("nativeStderrDisplay", () => {
+ test("hides the block when the file predates the daemon's startedAt", () => {
+ const { show, header } = nativeStderrDisplay(NOW - 10_000, NOW);
+ expect(show).toBe(false);
+ expect(header).toBe("no crash since this daemon started");
+ });
+
+ test("hides the block when the file mtime exactly equals startedAt", () => {
+ const { show } = nativeStderrDisplay(NOW, NOW);
+ expect(show).toBe(false);
+ });
+
+ test("shows the block, with the mtime in the header, when the file postdates startedAt", () => {
+ const mtimeMs = NOW + 5_000;
+ const { show, header } = nativeStderrDisplay(mtimeMs, NOW);
+ expect(show).toBe(true);
+ expect(header).toBe(`native stderr (captured ${new Date(mtimeMs).toISOString()})`);
+ });
+
+ test("fails open (shows) when the daemon's startedAt is unknown (nothing to compare against)", () => {
+ const { show } = nativeStderrDisplay(NOW - 999_999, null);
+ expect(show).toBe(true);
+ });
+});

commands/__tests__/daemon-status-render.test.ts

@@ -71,4 +71,41 @@ describe("statusLines", () => {
  expect(out).toContain("watching: 1 repo");
  expect(out).not.toContain("1 repos");
  });
+
+ // ── Task 10 ──
+
+ test("a parked pid points at the flavor mismatch, not 'not running'", () => {
+ const out = plain({ state: "parked", pid: 42, holderFlavor: "prod" });
+ expect(out).toContain("parked");
+ expect(out).toContain("pid 42");
+ expect(out).toContain("held by: prod");
+ expect(out).not.toContain("installed but not running");
+ });
+
+ test("alive-not-serving names the pid and the stuck detail", () => {
+ const out = plain({ state: "alive-not-serving", pid: 42, detail: "booting" });
+ expect(out).toContain("process 42 is running but not answering rt.sock");
+ expect(out).toContain("still booting");
+ expect(out).not.toContain("installed but not running");
+ });
+
+ test("alive-not-serving wedged/quarantined get their own detail lines", () => {
+ expect(plain({ state: "alive-not-serving", pid: 1, detail: "wedged" })).toContain("deadlocked");
+ expect(plain({ state: "alive-not-serving", pid: 1, detail: "quarantined" })).toContain("recovered from a corrupt db");
+ });
+
+ test("crash-looping surfaces the failure count and the last reason", () => {
+ const out = plain({ state: "crash-looping", failures: 4, reason: "EADDRINUSE" });
+ expect(out).toContain("crash-looping");
+ expect(out).toContain("4 failures");
+ expect(out).toContain("EADDRINUSE");
+ });
+
+ test("boot-failed surfaces the phase and reason, and points at rt daemon start", () => {
+ const out = plain({ state: "boot-failed", reason: "EADDRINUSE", phase: "api" });
+ expect(out).toContain("boot failed");
+ expect(out).toContain("phase: api");
+ expect(out).toContain("EADDRINUSE");
+ expect(out).toContain("rt daemon start");
+ });
 });

commands/__tests__/daemon-uninstall-start.test.ts

@@ -0,0 +1,145 @@
+/**
+ * `rt daemon uninstall`/`start` (the CLI-side liveness guards, Task 14,
+ * S027/S030/S028-CLI). Fakes the tray over a real Bun.serve on
+ * TRAY_SOCK_PATH (same rig as commands/__tests__/settings-dev-mode.test.ts)
+ * and, where a scenario needs "the daemon is live", a real Bun.serve on
+ * DAEMON_SOCK_PATH answering /ping (isDaemonProcessRunning's pid check and
+ * probeSocketHolder/isDaemonRunning's socket ping are both exercised for
+ * real, never mocked module internals).
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { start, uninstall } from "../daemon.ts";
+import {
+ DAEMON_CONFIG_PATH,
+ DAEMON_PID_PATH,
+ DAEMON_SOCK_PATH,
+ RT_DIR,
+ TRAY_SOCK_PATH,
+ markDaemonInstalled,
+} from "../../lib/daemon-config.ts";
+import { resolveIntendedMode } from "../../lib/dev-mode.ts";
+
+let servers: ReturnType<typeof Bun.serve>[] = [];
+let logs: string[] = [];
+const realLog = console.log;
+
+function captureLogs(): void {
+ logs = [];
+ console.log = (...args: unknown[]) => { logs.push(args.map(String).join(" ")); };
+}
+
+function serveTray(handlers: Record<string, () => Response>): void {
+ servers.push(Bun.serve({
+ unix: TRAY_SOCK_PATH,
+ fetch(req) {
+ const url = new URL(req.url);
+ const handler = handlers[url.pathname];
+ return handler ? handler() : new Response("not found", { status: 404 });
+ },
+ }));
+}
+
+/** A real listener on rt.sock that answers /ping (what both isDaemonRunning()
+ * (daemon-client.ts) and probeSocketHolder() (lib/daemon/park.ts) fetch.
+ * Flavor defaults to the CURRENT intended mode (not a hardcoded "prod") so
+ * start()'s post-liveness warnIfWrongFlavor() check never fires a spurious
+ * mismatch when this file runs after another test flips mattstack.mode in
+ * the shared isolated HOME `bun test` uses for the whole process). */
+function serveDaemonPing(body?: Record<string, unknown>): void {
+ const resolvedBody = body ?? { ok: true, pid: 4242, flavor: resolveIntendedMode().mode };
+ servers.push(Bun.serve({
+ unix: DAEMON_SOCK_PATH,
+ fetch(req) {
+ const url = new URL(req.url);
+ if (url.pathname === "/ping") return Response.json(resolvedBody);
+ return new Response("not found", { status: 404 });
+ },
+ }));
+}
+
+afterEach(() => {
+ console.log = realLog;
+ for (const s of servers) { try { s.stop(true); } catch { /* already stopped */ } }
+ servers = [];
+ for (const p of [DAEMON_SOCK_PATH, DAEMON_PID_PATH, TRAY_SOCK_PATH, DAEMON_CONFIG_PATH]) {
+ try { rmSync(p); } catch { /* absent */ }
+ }
+});
+
+describe("uninstall (liveness guard)", () => {
+ test("leaves rt.pid/daemon.json when isDaemonProcessRunning() says the daemon is alive", async () => {
+ mkdirSync(RT_DIR, { recursive: true });
+ markDaemonInstalled();
+ writeFileSync(DAEMON_PID_PATH, String(process.pid)); // this test process is genuinely alive
+ // tray unreachable: trayQuery('/daemon/stop') resolves null (no server on TRAY_SOCK_PATH)
+
+ captureLogs();
+ await uninstall();
+
+ expect(existsSync(DAEMON_PID_PATH)).toBe(true); // cleanupDaemonFiles did NOT run
+ expect(JSON.parse(readFileSync(DAEMON_CONFIG_PATH, "utf8")).installed).toBe(true); // markDaemonUninstalled did NOT run
+ expect(logs.join("\n")).toContain("launchctl bootout");
+ });
+
+ test("leaves rt.sock/daemon.json when probeSocketHolder() finds a live holder (no rt.pid at all)", async () => {
+ mkdirSync(RT_DIR, { recursive: true });
+ markDaemonInstalled();
+ serveDaemonPing();
+
+ captureLogs();
+ await uninstall();
+
+ expect(JSON.parse(readFileSync(DAEMON_CONFIG_PATH, "utf8")).installed).toBe(true);
+ expect(logs.join("\n")).toContain("launchctl bootout");
+ });
+
+ test("cleans up rt.sock/rt.pid/daemon.json when nothing is alive", async () => {
+ mkdirSync(RT_DIR, { recursive: true });
+ markDaemonInstalled();
+ writeFileSync(DAEMON_PID_PATH, "999999"); // no such pid
+ writeFileSync(DAEMON_SOCK_PATH, ""); // stale file, not a real listener (probeSocketHolder's fetch fails)
+
+ captureLogs();
+ await uninstall();
+
+ expect(existsSync(DAEMON_PID_PATH)).toBe(false);
+ expect(JSON.parse(readFileSync(DAEMON_CONFIG_PATH, "utf8")).installed).toBe(false);
+ expect(logs.join("\n")).not.toContain("launchctl bootout");
+ expect(logs.join("\n")).toContain("daemon fully uninstalled");
+ });
+});
+
+describe("start (kickstart escalation)", () => {
+ test("falls back to /daemon/restart when the tray acks /daemon/start but the socket never comes up", async () => {
+ mkdirSync(RT_DIR, { recursive: true });
+ markDaemonInstalled();
+ let restartCalled = false;
+ serveTray({
+ "/daemon/start": () => Response.json({ ok: true }),
+ "/daemon/restart": () => { restartCalled = true; return Response.json({ ok: true }); },
+ });
+
+ captureLogs();
+ await start();
+
+ expect(restartCalled).toBe(true);
+ }, 20_000);
+
+ test("escalation succeeds once /daemon/restart actually brings the socket up", async () => {
+ mkdirSync(RT_DIR, { recursive: true });
+ markDaemonInstalled();
+ serveTray({
+ "/daemon/start": () => Response.json({ ok: true }),
+ "/daemon/restart": () => {
+ serveDaemonPing();
+ return Response.json({ ok: true });
+ },
+ });
+
+ captureLogs();
+ await start();
+
+ expect(logs.join("\n")).toContain("daemon started");
+ }, 20_000);
+});

commands/__tests__/probe-pid-alive.test.ts

@@ -0,0 +1,19 @@
+import { describe, test, expect } from "bun:test";
+import { probePidAlive } from "../daemon.ts";
+import { readSupervisionState } from "../../lib/daemon/supervision-state.ts";
+
+describe("probePidAlive", () => {
+ // Regression: the lsof fallback must exclude the CALLING process itself.
+ // showStatus opens a bun:sqlite handle on state.db (inside RT_DIR) via
+ // readSupervisionState() immediately before this probe runs ... `lsof +D
+ // RT_DIR` then legitimately reports the calling CLI process as a live
+ // holder of the directory, with no daemon involved at all. Without the
+ // process.pid filter this self-matches and a genuinely dead daemon
+ // (no recorded pid, no breadcrumb pid) misclassifies as alive.
+ test("a state.db handle held by THIS process does not self-match as a live daemon", async () => {
+ readSupervisionState(); // opens (and keeps open) the isolated HOME's state.db
+ const result = await probePidAlive(null, undefined);
+ expect(result.alive).toBe(false);
+ expect(result.pid).toBeNull();
+ });
+});