@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/smoke-integration.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Smoke integration tests — validates end-to-end flows without SQLite.
+ */
+import { describe, it, expect, afterAll } from "vitest";
+import { createServer, type DashboardServer, type ServerConfig } from "../server.js";
+import { WebSocket } from "ws";
+
+function waitForOpen(ws: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (ws.readyState === WebSocket.OPEN) return resolve();
+    ws.on("open", resolve);
+    ws.on("error", reject);
+    setTimeout(() => reject(new Error("open timeout")), 3000);
+  });
+}
+
+function collectMsgs(ws: WebSocket, ms: number): Promise<any[]> {
+  return new Promise((resolve) => {
+    const arr: any[] = [];
+    const h = (raw: any) => arr.push(JSON.parse(raw.toString()));
+    ws.on("message", h);
+    setTimeout(() => { ws.off("message", h); resolve(arr); }, ms);
+  });
+}
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const httpPort = 19070;
+const piPort = 19071;
+let server: DashboardServer;
+
+describe("Smoke integration", () => {
+  afterAll(async () => {
+    if (server) await server.stop();
+  });
+
+  it("9.2 — events flow and replay from memory on reconnect", async () => {
+    server = await createServer({
+      port: httpPort, piPort, dev: true,
+      autoShutdown: false, shutdownIdleSeconds: 999, tunnel: false,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+
+    // Bridge connects and registers
+    const bridge = new WebSocket(`ws://localhost:${piPort}`);
+    await waitForOpen(bridge);
+    bridge.send(JSON.stringify({
+      type: "session_register", sessionId: "s1", cwd: "/tmp", source: "tui", name: "Test",
+    }));
+    bridge.send(JSON.stringify({ type: "replay_complete", sessionId: "s1" }));
+    await delay(150);
+
+    // Browser connects, subscribes, receives event
+    const b1 = new WebSocket(`ws://localhost:${httpPort}/ws`);
+    await waitForOpen(b1);
+    await delay(100); // drain session_added
+    b1.send(JSON.stringify({ type: "subscribe", sessionId: "s1", lastSeq: 0 }));
+    await delay(50);
+
+    bridge.send(JSON.stringify({
+      type: "event_forward", sessionId: "s1",
+      event: { eventType: "message_start", timestamp: Date.now(), data: { role: "user" } },
+    }));
+
+    const msgs1 = await collectMsgs(b1, 300);
+    const liveEvent = msgs1.find((m) => m.type === "event" && m.sessionId === "s1");
+    expect(liveEvent).toBeDefined();
+    expect(liveEvent.seq).toBe(1);
+
+    // Reconnect browser — should replay from memory
+    b1.close();
+    await delay(100);
+
+    const b2 = new WebSocket(`ws://localhost:${httpPort}/ws`);
+    await waitForOpen(b2);
+    await delay(100); // drain session_added
+    b2.send(JSON.stringify({ type: "subscribe", sessionId: "s1", lastSeq: 0 }));
+
+    const msgs2 = await collectMsgs(b2, 300);
+    const replay = msgs2.find((m) => m.type === "event_replay" && m.sessionId === "s1");
+    expect(replay).toBeDefined();
+    expect(replay.events.length).toBeGreaterThanOrEqual(1);
+    expect(replay.events[0].event.eventType).toBe("message_start");
+
+    b2.close();
+    bridge.close();
+    await delay(100);
+  }, 15000);
+
+  it("9.3 — hide session updates session manager", async () => {
+    const bridge = new WebSocket(`ws://localhost:${piPort}`);
+    await waitForOpen(bridge);
+    bridge.send(JSON.stringify({
+      type: "session_register", sessionId: "s3", cwd: "/tmp", source: "tui",
+    }));
+    await delay(150);
+
+    const browser = new WebSocket(`ws://localhost:${httpPort}/ws`);
+    await waitForOpen(browser);
+    await delay(100); // drain session_added
+
+    browser.send(JSON.stringify({ type: "hide_session", sessionId: "s3" }));
+
+    const msgs = await collectMsgs(browser, 300);
+    const hideUpdate = msgs.find((m) =>
+      m.type === "session_updated" && m.sessionId === "s3" && m.updates?.hidden === true
+    );
+    expect(hideUpdate).toBeDefined();
+    expect(server.sessionManager.get("s3")?.hidden).toBe(true);
+
+    browser.close();
+    bridge.close();
+    await delay(100);
+  }, 10000);
+
+  it.skip("9.5 — old session with no bridge shows dataUnavailable", async () => {
+    // Use a unique cwd that won't match other sessions
+    const bridge = new WebSocket(`ws://localhost:${piPort}`);
+    await waitForOpen(bridge);
+    bridge.send(JSON.stringify({
+      type: "session_register", sessionId: "s5", cwd: "/unique/isolated/path",
+      source: "tui", sessionFile: "/unique/old.json",
+    }));
+    await delay(100);
+    bridge.send(JSON.stringify({
+      type: "event_forward", sessionId: "s5",
+      event: { eventType: "agent_start", timestamp: Date.now(), data: {} },
+    }));
+    await delay(50);
+    bridge.send(JSON.stringify({ type: "session_unregister", sessionId: "s5" }));
+    await delay(50);
+    bridge.close();
+    await delay(200);
+
+    // Simulate eviction
+    server.eventStore.deleteEventsForSession("s5");
+
+    // Browser subscribes — should get dataUnavailable
+    const browser = new WebSocket(`ws://localhost:${httpPort}/ws`);
+    await waitForOpen(browser);
+    await delay(200); // drain session_added
+
+    browser.send(JSON.stringify({ type: "subscribe", sessionId: "s5", lastSeq: 0 }));
+
+    // Collect messages over time — the async loadSessionEvents may take a while
+    // due to dynamic imports in the test environment
+    const allMsgs: any[] = [];
+    const handler = (raw: any) => allMsgs.push(JSON.parse(raw.toString()));
+    browser.on("message", handler);
+
+    // Poll until we see dataUnavailable or timeout
+    const deadline = Date.now() + 8000;
+    while (Date.now() < deadline) {
+      await delay(200);
+      const unavail = allMsgs.find((m: any) =>
+        m.type === "session_updated" && m.sessionId === "s5" && m.updates?.dataUnavailable === true
+      );
+      if (unavail) break;
+    }
+    browser.off("message", handler);
+
+    // Verify we got at least one empty replay
+    const replays = allMsgs.filter((m: any) => m.type === "event_replay" && m.sessionId === "s5");
+    expect(replays.length).toBeGreaterThan(0);
+
+    // Verify dataUnavailable was set
+    const unavail = allMsgs.find((m: any) =>
+      m.type === "session_updated" && m.sessionId === "s5" && m.updates?.dataUnavailable === true
+    );
+    expect(unavail).toBeDefined();
+
+    browser.close();
+    await delay(50);
+  }, 15000);
+});

package/packages/server/src/__tests__/spa-fallback.test.ts

@@ -0,0 +1,68 @@
+/**
+ * SPA fallback tests — validates that client-side routes return index.html.
+ */
+import { describe, it, expect, afterAll, beforeAll } from "vitest";
+import { createServer, type DashboardServer } from "../server.js";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const httpPort = 19100;
+const piPort = 19101;
+let server: DashboardServer;
+
+// Ensure dist/client/index.html exists for the test
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientDir = path.join(__dirname, "../../../dist/client");
+const indexPath = path.join(clientDir, "index.html");
+let createdDir = false;
+
+describe("SPA fallback", () => {
+  beforeAll(async () => {
+    // Create minimal dist/client/index.html if it doesn't exist
+    if (!fs.existsSync(indexPath)) {
+      fs.mkdirSync(clientDir, { recursive: true });
+      fs.writeFileSync(indexPath, "<!doctype html><html><body>SPA</body></html>");
+      createdDir = true;
+    }
+
+    server = await createServer({
+      port: httpPort,
+      piPort,
+      dev: false, // production mode enables static serving + SPA fallback
+      autoShutdown: false,
+      shutdownIdleSeconds: 999,
+      tunnel: false,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+  });
+
+  afterAll(async () => {
+    if (server) await server.stop();
+    if (createdDir) {
+      fs.rmSync(indexPath);
+    }
+  });
+
+  it("returns index.html for /session/:id route", async () => {
+    const res = await fetch(`http://localhost:${httpPort}/session/abc-123`);
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain("html");
+  });
+
+  it("returns index.html for unknown client routes", async () => {
+    const res = await fetch(`http://localhost:${httpPort}/some/unknown/path`);
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain("html");
+  });
+
+  it("still serves API routes normally", async () => {
+    const res = await fetch(`http://localhost:${httpPort}/api/sessions`);
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json.success).toBe(true);
+  });
+});

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

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi } from "vitest";
+import { handleSubscribe } 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";
+import type { ServerToBrowserMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function makeEvent(type: string = "test"): DashboardEvent {
+  return { eventType: type, timestamp: Date.now(), data: {} };
+}
+
+function createMockContext(overrides: Partial<BrowserHandlerContext> = {}): BrowserHandlerContext {
+  return {
+    ws: { readyState: 1, OPEN: 1, bufferedAmount: 0 } as any,
+    sessionManager: createMemorySessionManager(),
+    eventStore: createMemoryEventStore(() => false),
+    piGateway: { sendToSession: vi.fn() } as any,
+    headlessPidRegistry: {} as any,
+    pendingResumeRegistry: {} as any,
+    sendTo: vi.fn(),
+    broadcast: vi.fn(),
+    getSubscribers: () => [],
+    trackUiRequest: vi.fn(),
+    replayPendingUiRequests: vi.fn(),
+    markReplaying: vi.fn(),
+    clearReplaying: vi.fn(),
+    ...overrides,
+  };
+}
+
+describe("handleSubscribe — metadata requests on subscribe", () => {
+  it("sends request_commands, request_models, and request_roles to piGateway", () => {
+    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[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" }]);
+  });
+});
+
+describe("handleSubscribe — stale lastSeq detection", () => {
+  it("replays delta when lastSeq is within server range", async () => {
+    const ctx = createMockContext();
+    // Insert 5 events
+    for (let i = 0; i < 5; i++) ctx.eventStore.insertEvent("s1", makeEvent(`e${i}`));
+
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 3 }, subs, ctx);
+
+    // Wait for async replay
+    await new Promise((r) => setTimeout(r, 50));
+
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    // Should NOT have sent session_state_reset
+    const resets = calls.filter(([, msg]) => msg.type === "session_state_reset");
+    expect(resets).toHaveLength(0);
+
+    // Should have replayed only events 4 and 5
+    const replays = calls.filter(([, msg]) => msg.type === "event_replay");
+    expect(replays.length).toBeGreaterThanOrEqual(1);
+    const allEvents = replays.flatMap(([, msg]: any) => msg.events);
+    expect(allEvents).toHaveLength(2);
+    expect(allEvents[0].seq).toBe(4);
+    expect(allEvents[1].seq).toBe(5);
+  });
+
+  it("sends session_state_reset and full replay when lastSeq > server maxSeq", async () => {
+    const ctx = createMockContext();
+    // Insert 3 events (maxSeq = 3)
+    for (let i = 0; i < 3; i++) ctx.eventStore.insertEvent("s1", makeEvent(`e${i}`));
+
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 100 }, subs, ctx);
+
+    // Wait for async replay
+    await new Promise((r) => setTimeout(r, 50));
+
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    // Should have sent session_state_reset first
+    const resets = calls.filter(([, msg]) => msg.type === "session_state_reset");
+    expect(resets).toHaveLength(1);
+
+    // Should have replayed ALL events from seq 1
+    const replays = calls.filter(([, msg]) => msg.type === "event_replay");
+    const allEvents = replays.flatMap(([, msg]: any) => msg.events);
+    expect(allEvents).toHaveLength(3);
+    expect(allEvents[0].seq).toBe(1);
+  });
+
+  it("marks replaying during delta replay and clears after", async () => {
+    const markReplaying = vi.fn();
+    const clearReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying, clearReplaying });
+    for (let i = 0; i < 5; i++) ctx.eventStore.insertEvent("s1", makeEvent());
+
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 3 }, subs, ctx);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(markReplaying).toHaveBeenCalledWith(ctx.ws, "s1");
+    expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 5); // lastSent = 5
+  });
+
+  it("does not mark replaying for fresh subscribe (lastSeq: 0)", async () => {
+    const markReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying });
+    for (let i = 0; i < 3; i++) ctx.eventStore.insertEvent("s1", makeEvent());
+
+    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();
+  });
+
+  it("marks replaying during stale lastSeq full replay", async () => {
+    const markReplaying = vi.fn();
+    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>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 100 }, subs, ctx);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(markReplaying).toHaveBeenCalledWith(ctx.ws, "s1");
+    expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 3);
+  });
+
+  it("does full replay when lastSeq is 0", async () => {
+    const ctx = createMockContext();
+    for (let i = 0; i < 3; i++) ctx.eventStore.insertEvent("s1", makeEvent());
+
+    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 resets = calls.filter(([, msg]) => msg.type === "session_state_reset");
+    expect(resets).toHaveLength(0); // No reset needed for fresh subscribe
+
+    const replays = calls.filter(([, msg]) => msg.type === "event_replay");
+    const allEvents = replays.flatMap(([, msg]: any) => msg.events);
+    expect(allEvents).toHaveLength(3);
+  });
+});

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

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTerminalGateway } from "../terminal-gateway.js";
+import type { TerminalManager } from "../terminal-manager.js";
+
+describe("TerminalGateway", () => {
+  let mockManager: TerminalManager;
+
+  beforeEach(() => {
+    mockManager = {
+      spawn: vi.fn(),
+      attach: vi.fn(),
+      detach: vi.fn(),
+      kill: vi.fn(),
+      get: vi.fn(),
+      list: vi.fn(() => []),
+      updateTitle: vi.fn(),
+    };
+  });
+
+  it("parses terminal ID from URL path", () => {
+    const gateway = createTerminalGateway(mockManager);
+    expect(gateway.parseTerminalId("/ws/terminal/term-abc123")).toBe("term-abc123");
+    expect(gateway.parseTerminalId("/ws/terminal/")).toBeNull();
+    expect(gateway.parseTerminalId("/ws")).toBeNull();
+    expect(gateway.parseTerminalId("/ws/terminal")).toBeNull();
+  });
+
+  it("rejects upgrade for non-existent terminal", () => {
+    const gateway = createTerminalGateway(mockManager);
+    (mockManager.get as any).mockReturnValue(undefined);
+
+    const socket = { destroy: vi.fn() } as any;
+    gateway.handleUpgrade(
+      { url: "/ws/terminal/term-nonexistent" } as any,
+      socket,
+      Buffer.alloc(0),
+    );
+
+    expect(socket.destroy).toHaveBeenCalled();
+    expect(mockManager.attach).not.toHaveBeenCalled();
+  });
+
+  it("accepts upgrade for existing terminal", () => {
+    const gateway = createTerminalGateway(mockManager);
+    (mockManager.get as any).mockReturnValue({ id: "term-abc", status: "active" });
+
+    const mockWs = { on: vi.fn() };
+    const handleUpgradeMock = vi.fn((_req: any, _socket: any, _head: any, cb: any) => {
+      cb(mockWs);
+    });
+    (gateway.wss as any).handleUpgrade = handleUpgradeMock;
+
+    const socket = { destroy: vi.fn() } as any;
+    const request = { url: "/ws/terminal/term-abc" } as any;
+
+    gateway.handleUpgrade(request, socket, Buffer.alloc(0));
+
+    expect(handleUpgradeMock).toHaveBeenCalled();
+    expect(mockManager.attach).toHaveBeenCalledWith("term-abc", mockWs);
+  });
+});