@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.0

package/packages/server/src/__tests__/spawn-register-watchdog.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Tests for SpawnRegisterWatchdog.
+ * Uses vitest fake timers. See change: spawn-failure-diagnostics.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import WebSocket from "ws";
+
+// Silence appendSpawnFailure in unit tests.
+vi.mock("../spawn-failure-log.js", () => ({
+  appendSpawnFailure: vi.fn(),
+}));
+
+import { SpawnRegisterWatchdog } from "../spawn-register-watchdog.js";
+
+function makeMockWs(readyState: number = WebSocket.OPEN): { ws: WebSocket; messages: string[] } {
+  const messages: string[] = [];
+  const ws = {
+    readyState,
+    send: vi.fn((data: string) => messages.push(data)),
+  } as unknown as WebSocket;
+  return { ws, messages };
+}
+
+describe("SpawnRegisterWatchdog", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("clamps timeoutMs below 5000 to 5000", () => {
+    const w = new SpawnRegisterWatchdog(1000);
+    expect(w.timeoutMs).toBe(5000);
+  });
+
+  it("clamps timeoutMs above 120000 to 120000", () => {
+    const w = new SpawnRegisterWatchdog(999999);
+    expect(w.timeoutMs).toBe(120000);
+  });
+
+  it("headless arm + clearByPid cancels watchdog", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ pid: 123, cwd: "/p/x", mechanism: "headless", ws });
+    w.clearByPid(123);
+    vi.advanceTimersByTime(15000);
+    expect(messages).toHaveLength(0);
+  });
+
+  it("headless arm + clearByCwd (pid mismatch) still cancels watchdog", () => {
+    // Regression: Unix headless wraps pi in `sh -c "… | pi"`, so spawnResult.pid
+    // is the sh wrapper while session_register reports pi's real pid. Watchdog
+    // must clear via cwd even when pid was indexed at arm time.
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ pid: 51250, cwd: "/p/x", mechanism: "headless", ws });
+    w.clearByCwd("/p/x");
+    vi.advanceTimersByTime(15000);
+    expect(messages).toHaveLength(0);
+  });
+
+  it("tmux arm + clearByCwd cancels watchdog", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/x", mechanism: "tmux", ws });
+    w.clearByCwd("/p/x");
+    vi.advanceTimersByTime(15000);
+    expect(messages).toHaveLength(0);
+  });
+
+  it("arm without clear fires spawn_register_timeout", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ pid: 42, cwd: "/p/y", mechanism: "headless", ws });
+    vi.advanceTimersByTime(10001);
+    expect(messages).toHaveLength(1);
+    const msg = JSON.parse(messages[0]!);
+    expect(msg.type).toBe("spawn_register_timeout");
+    expect(msg.cwd).toBe("/p/y");
+    expect(msg.pid).toBe(42);
+  });
+
+  it("tmux timeout omits pid", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/z", mechanism: "tmux", ws });
+    vi.advanceTimersByTime(10001);
+    expect(messages).toHaveLength(1);
+    const msg = JSON.parse(messages[0]!);
+    expect(msg.pid).toBeUndefined();
+  });
+
+  it("clear on unknown key is a no-op", () => {
+    const w = new SpawnRegisterWatchdog(10000);
+    expect(() => w.clearByPid(999)).not.toThrow();
+    expect(() => w.clearByCwd("/never/seen")).not.toThrow();
+  });
+
+  it("timeout fires silently when ws is closed", () => {
+    const { ws, messages } = makeMockWs(WebSocket.CLOSED);
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/q", mechanism: "tmux", ws });
+    expect(() => vi.advanceTimersByTime(10001)).not.toThrow();
+    expect(messages).toHaveLength(0);
+  });
+
+  it("late clearByCwd within 60s emits spawn_register_recovered", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/r", mechanism: "tmux", ws });
+
+    // Fire the watchdog.
+    vi.advanceTimersByTime(10001);
+    expect(messages[0]).toContain("spawn_register_timeout");
+
+    // Late registration within 60s.
+    vi.advanceTimersByTime(5000);
+    w.clearByCwd("/p/r");
+
+    expect(messages).toHaveLength(2);
+    const recovery = JSON.parse(messages[1]!);
+    expect(recovery.type).toBe("spawn_register_recovered");
+    expect(recovery.cwd).toBe("/p/r");
+  });
+
+  it("late clear past 60s TTL is silent", () => {
+    const { ws, messages } = makeMockWs();
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/s", mechanism: "tmux", ws });
+
+    vi.advanceTimersByTime(10001);
+    expect(messages).toHaveLength(1);
+
+    // Past 60s TTL.
+    vi.advanceTimersByTime(61000);
+    w.clearByCwd("/p/s");
+
+    // No recovery message.
+    expect(messages).toHaveLength(1);
+  });
+
+  it("recovery skipped when ws closed at recovery time", () => {
+    const messages: string[] = [];
+    // Start with OPEN, then we'll swap to CLOSED.
+    const ws = {
+      readyState: WebSocket.OPEN,
+      send: vi.fn((data: string) => messages.push(data)),
+    } as unknown as WebSocket;
+
+    const w = new SpawnRegisterWatchdog(10000);
+    w.arm({ cwd: "/p/t", mechanism: "tmux", ws });
+    vi.advanceTimersByTime(10001);
+
+    // Close the ws before recovery.
+    (ws as unknown as { readyState: number }).readyState = WebSocket.CLOSED;
+
+    vi.advanceTimersByTime(5000);
+    w.clearByCwd("/p/t");
+
+    // Only the timeout message was sent (before ws was closed).
+    const recoveries = messages.filter((m) => m.includes("spawn_register_recovered"));
+    expect(recoveries).toHaveLength(0);
+  });
+});

package/packages/server/src/__tests__/subscription-handler.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
-import { handleSubscribe } from "../browser-handlers/subscription-handler.js";
+import { handleSubscribe, replaySessionAssets } from "../browser-handlers/subscription-handler.js";
 import { createMemoryEventStore } from "../memory-event-store.js";
 import { createMemorySessionManager } from "../memory-session-manager.js";
 import type { BrowserHandlerContext } from "../browser-handlers/handler-context.js";
@@ -30,16 +30,18 @@ function createMockContext(overrides: Partial<BrowserHandlerContext> = {}): Brow
 }
 
 describe("handleSubscribe — metadata requests on subscribe", () => {
-  it("sends request_commands, request_models, and request_roles to piGateway", () => {
+  it("sends request_commands, request_models, request_providers, and request_roles to piGateway", () => {
+    // request_providers added by change: replace-hardcoded-provider-lists.
     const ctx = createMockContext();
     const subs = new Set<string>();
     handleSubscribe({ type: "subscribe", sessionId: "s1" }, subs, ctx);
 
     const calls = (ctx.piGateway.sendToSession as any).mock.calls;
-    expect(calls).toHaveLength(3);
+    expect(calls).toHaveLength(4);
     expect(calls[0]).toEqual(["s1", { type: "request_commands", sessionId: "s1" }]);
     expect(calls[1]).toEqual(["s1", { type: "request_models", sessionId: "s1" }]);
-    expect(calls[2]).toEqual(["s1", { type: "request_roles", sessionId: "s1" }]);
+    expect(calls[2]).toEqual(["s1", { type: "request_providers", sessionId: "s1" }]);
+    expect(calls[3]).toEqual(["s1", { type: "request_roles", sessionId: "s1" }]);
   });
 });
 
@@ -107,9 +109,17 @@ describe("handleSubscribe — stale lastSeq detection", () => {
     expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 5); // lastSent = 5
   });
 
-  it("does not mark replaying for fresh subscribe (lastSeq: 0)", async () => {
+  it("marks replaying for fresh subscribe (lastSeq: 0) when events exist", async () => {
+    // Regression: cold subscribe must suppress live events during paginated
+    // replay. Without suppression, a live `event` arriving between batches
+    // bumps the client's maxSeq past the next batch's firstSeq, triggering
+    // the `firstSeq <= maxSeq` reset rule on the client which wipes state
+    // and rebuilds from only the last batch — leaving the chat showing
+    // only the tail messages.
+    // See change: fix-cold-subscribe-replay-interleave.
     const markReplaying = vi.fn();
-    const ctx = createMockContext({ markReplaying });
+    const clearReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying, clearReplaying });
     for (let i = 0; i < 3; i++) ctx.eventStore.insertEvent("s1", makeEvent());
 
     const subs = new Set<string>();
@@ -117,6 +127,20 @@ describe("handleSubscribe — stale lastSeq detection", () => {
 
     await new Promise((r) => setTimeout(r, 50));
 
+    expect(markReplaying).toHaveBeenCalledWith(ctx.ws, "s1");
+    expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 3); // lastSent = 3
+  });
+
+  it("does not mark replaying for fresh subscribe when there are no events", async () => {
+    const markReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying });
+    // No events inserted — hasEvents() returns false; falls through to the
+    // empty-session branch.
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 0 }, subs, ctx);
+
+    await new Promise((r) => setTimeout(r, 50));
+
     expect(markReplaying).not.toHaveBeenCalled();
   });
 
@@ -193,3 +217,71 @@ describe("handleSubscribe — stale lastSeq detection", () => {
     expect(allEvents).toHaveLength(3);
   });
 });
+
+// chat-markdown-local-images-and-math
+describe("replaySessionAssets — emits one asset_register per Session.assets entry", () => {
+  it("sends nothing when session has no assets", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    replaySessionAssets({} as any, "s1", ctx);
+    expect((ctx.sendTo as any).mock.calls).toHaveLength(0);
+  });
+
+  it("sends one asset_register per asset on the session", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    ctx.sessionManager.update("s1", {
+      assets: {
+        abc: { data: "AAAA", mimeType: "image/png" },
+        def: { data: "BBBB", mimeType: "image/svg+xml" },
+      },
+    } as any);
+    const ws = {} as any;
+    replaySessionAssets(ws, "s1", ctx);
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const assetMsgs = calls.filter(([, m]) => m.type === "asset_register");
+    expect(assetMsgs).toHaveLength(2);
+    const byHash = Object.fromEntries(assetMsgs.map(([, m]: any) => [m.hash, m]));
+    expect(byHash.abc).toMatchObject({ data: "AAAA", mimeType: "image/png", sessionId: "s1" });
+    expect(byHash.def).toMatchObject({ data: "BBBB", mimeType: "image/svg+xml", sessionId: "s1" });
+  });
+
+  it("skips malformed asset entries defensively", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    // Force a malformed entry past the type check.
+    ctx.sessionManager.update("s1", {
+      assets: {
+        good: { data: "AAAA", mimeType: "image/png" },
+        bad: { data: 123, mimeType: "image/png" } as any,
+      },
+    } as any);
+    replaySessionAssets({} as any, "s1", ctx);
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const assetMsgs = calls.filter(([, m]) => m.type === "asset_register");
+    expect(assetMsgs).toHaveLength(1);
+    expect((assetMsgs[0][1] as any).hash).toBe("good");
+  });
+});
+
+describe("handleSubscribe — asset replay precedes events", () => {
+  it("sends asset_register messages before event_replay batches", async () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    ctx.sessionManager.update("s1", {
+      assets: { h1: { data: "AAAA", mimeType: "image/png" } },
+    } as any);
+    ctx.eventStore.insertEvent("s1", makeEvent("message_update"));
+
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 0 }, subs, ctx);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const firstAssetIdx = calls.findIndex(([, m]) => m.type === "asset_register");
+    const firstEventIdx = calls.findIndex(([, m]) => m.type === "event_replay");
+    expect(firstAssetIdx).toBeGreaterThanOrEqual(0);
+    expect(firstEventIdx).toBeGreaterThanOrEqual(0);
+    expect(firstAssetIdx).toBeLessThan(firstEventIdx);
+  });
+});

package/packages/server/src/__tests__/system-routes-reextract.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for POST /api/electron/reextract
+ * See change: simplify-electron-bootstrap-derived-state (task 6.4 / 6.9).
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import { registerSystemRoutes } from "../routes/system-routes.js";
+import type { BootstrapStateStore, BootstrapState } from "../bootstrap-state.js";
+
+function noGuard() {
+  return async () => { /* allow all */ };
+}
+
+function makeBootstrapState(starter: string): BootstrapStateStore {
+  return {
+    get: () => ({
+      status: "ready",
+      starter: starter as any,
+      installable: { total: 0, installed: 0, failed: [] },
+    } as BootstrapState),
+    set: () => {},
+    subscribe: () => () => {},
+  } as unknown as BootstrapStateStore;
+}
+
+function makeNoopDeps(bootstrapState?: BootstrapStateStore) {
+  return {
+    sessionManager: { listActive: () => [], listAll: () => [] } as never,
+    preferencesStore: { flush: () => {} } as never,
+    metaPersistence: { flushAll: () => {} } as never,
+    config: { port: 8000, piPort: 9999, dev: false } as never,
+    networkGuard: noGuard(),
+    bootstrapState,
+  };
+}
+
+describe("POST /api/electron/reextract", () => {
+  let fastify: FastifyInstance;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  it("returns 403 when starter is Bridge", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Bridge"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.error).toBe("reextract_not_allowed");
+    expect(body.starter).toBe("Bridge");
+  });
+
+  it("returns 403 when starter is Standalone", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Standalone"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.error).toBe("reextract_not_allowed");
+    expect(body.starter).toBe("Standalone");
+  });
+
+  it("returns 202 when starter is Electron", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Electron"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(202);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.ok).toBe(true);
+  });
+
+  it("returns 403 when no bootstrapState (defaults to Standalone)", async () => {
+    const deps = makeNoopDeps(undefined);
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+  });
+});

package/packages/server/src/__tests__/system-routes-spawn-failures.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Tests for GET /api/spawn-failures endpoint.
+ * See change: spawn-failure-diagnostics.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import { registerSystemRoutes } from "../routes/system-routes.js";
+
+// Mock the spawn-failure-log module.
+vi.mock("../spawn-failure-log.js", () => ({
+  readSpawnFailures: vi.fn().mockReturnValue([]),
+  appendSpawnFailure: vi.fn(),
+  SpawnFailureEntry: undefined,
+}));
+
+import { readSpawnFailures } from "../spawn-failure-log.js";
+
+const mockReadSpawnFailures = vi.mocked(readSpawnFailures);
+
+function makeNoopDeps() {
+  return {
+    sessionManager: {} as never,
+    preferencesStore: { flush: () => {} } as never,
+    metaPersistence: { flushAll: () => {} } as never,
+    config: { port: 8000, piPort: 9999, dev: false } as never,
+    directoryService: {} as never,
+    piGateway: {
+      broadcast: vi.fn(),
+      announceRestart: vi.fn(),
+    } as never,
+    idleTimer: {} as never,
+    serverVersion: "test",
+    localhostGuard: () => async () => {},
+    tunnelStatus: () => ({ active: false }),
+    serverConfig: { dev: false } as never,
+    pluginStatusStore: { getAll: () => [] } as never,
+  };
+}
+
+describe("GET /api/spawn-failures", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    app = Fastify({ logger: false });
+    registerSystemRoutes(app, makeNoopDeps() as never);
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it("returns empty entries when no log exists", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    const res = await app.inject({ method: "GET", url: "/api/spawn-failures" });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body).toHaveProperty("entries");
+    expect(body.entries).toEqual([]);
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(50);
+  });
+
+  it("passes custom limit", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    await app.inject({ method: "GET", url: "/api/spawn-failures?limit=10" });
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(10);
+  });
+
+  it("falls back to default limit on NaN", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    await app.inject({ method: "GET", url: "/api/spawn-failures?limit=abc" });
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(50);
+  });
+
+  it("returns entries from the log", async () => {
+    const entry = { ts: "2026-01-01T00:00:00Z", cwd: "/p/x", strategy: "headless", code: "PI_CRASHED", message: "crashed" };
+    mockReadSpawnFailures.mockReturnValue([entry] as never);
+    const res = await app.inject({ method: "GET", url: "/api/spawn-failures" });
+    const body = JSON.parse(res.body);
+    expect(body.entries).toHaveLength(1);
+    expect(body.entries[0].code).toBe("PI_CRASHED");
+  });
+});

package/packages/server/src/__tests__/terminal-manager.test.ts

@@ -242,6 +242,51 @@ describe("TerminalManager", () => {
       handlers.message(resizeMsg, false);
       expect(mockPtyResize).toHaveBeenCalledWith(120, 40);
     });
+
+    // Resize floor — see change: fix-terminal-half-height-dual-mount.
+    // PTYs at <2 cols/rows are non-functional for every supported shell
+    // and the most common cause is a transient display:none container
+    // measured by FitAddon during a route transition.
+    describe("resize floor", () => {
+      function attachAndSendResize(cols: number, rows: number) {
+        const session = manager.spawn("/tmp");
+        const handlers: Record<string, Function> = {};
+        const mockWs = {
+          send: vi.fn(),
+          on: vi.fn((event: string, cb: any) => { handlers[event] = cb; }),
+          readyState: 1,
+          OPEN: 1,
+        } as any;
+        manager.attach(session.id, mockWs);
+        const msg = Buffer.from(JSON.stringify({ type: "resize", cols, rows }));
+        handlers.message(msg, false);
+      }
+
+      it("ignores resize with cols below floor (cols=1)", () => {
+        attachAndSendResize(1, 24);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("ignores resize with rows below floor (rows=0)", () => {
+        attachAndSendResize(80, 0);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("ignores resize with both dimensions below floor", () => {
+        attachAndSendResize(1, 1);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("accepts resize at the floor (cols=2, rows=2)", () => {
+        attachAndSendResize(2, 2);
+        expect(mockPtyResize).toHaveBeenCalledWith(2, 2);
+      });
+
+      it("accepts a normal resize", () => {
+        attachAndSendResize(80, 24);
+        expect(mockPtyResize).toHaveBeenCalledWith(80, 24);
+      });
+    });
   });
 
   describe("PTY exit", () => {