@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/session-ordering-integration.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Integration tests for session ordering flows.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createSessionOrderManager } from "../session-order-manager.js";
+import { createPendingForkRegistry } from "../pending-fork-registry.js";
+import type { PreferencesStore } from "../preferences-store.js";
+
+function createMockPreferencesStore(): PreferencesStore {
+  let order: Record<string, string[]> = {};
+  return {
+    getSessionOrder: vi.fn(() => order),
+    setSessionOrder: vi.fn((o: Record<string, string[]>) => { order = o; }),
+    getPinnedDirectories: vi.fn(() => []),
+    setPinnedDirectories: vi.fn(),
+    pinDirectory: vi.fn(),
+    unpinDirectory: vi.fn(),
+    reorderPinnedDirs: vi.fn(),
+    flush: vi.fn(),
+    dispose: vi.fn(),
+  };
+}
+
+describe("Session ordering integration", () => {
+  let stateStore: PreferencesStore;
+
+  beforeEach(() => {
+    stateStore = createMockPreferencesStore();
+  });
+
+  it("new session prepends to order", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2");
+    orderMgr.insert("/project", "s3");
+    expect(orderMgr.getOrder("/project")).toEqual(["s3", "s2", "s1"]);
+  });
+
+  it("fork inserts after parent", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+    const forkRegistry = createPendingForkRegistry();
+
+    // Setup: two sessions exist
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2"); // s2 is at front: ["s2", "s1"]
+
+    // User forks s1
+    forkRegistry.recordFork("/project", "s1");
+
+    // New session registers — simulate server checking fork registry
+    const forkParent = forkRegistry.consumeFork("/project");
+    orderMgr.insert("/project", "s3", forkParent ?? undefined);
+
+    // s3 should be after s1: ["s2", "s1", "s3"]
+    expect(orderMgr.getOrder("/project")).toEqual(["s2", "s1", "s3"]);
+  });
+
+  it("reorder replaces order", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2");
+    orderMgr.insert("/project", "s3"); // ["s3", "s2", "s1"]
+
+    orderMgr.reorder("/project", ["s1", "s3", "s2"]);
+    expect(orderMgr.getOrder("/project")).toEqual(["s1", "s3", "s2"]);
+  });
+
+  it("continue preserves position (no re-insert for existing ID)", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2"); // ["s2", "s1"]
+
+    // s1 re-registers (continue) — insert is a no-op because ID already exists
+    orderMgr.insert("/project", "s1");
+    expect(orderMgr.getOrder("/project")).toEqual(["s2", "s1"]);
+  });
+
+  it("getOrder prunes stale IDs", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2");
+    orderMgr.insert("/project", "s3"); // ["s3", "s2", "s1"]
+
+    // s2 no longer exists
+    const validIds = new Set(["s1", "s3"]);
+    expect(orderMgr.getOrder("/project", validIds)).toEqual(["s3", "s1"]);
+  });
+
+  it("concurrent registrations in same cwd maintain correct order", () => {
+    const orderMgr = createSessionOrderManager(stateStore);
+
+    // Simulate rapid concurrent registrations (all synchronous in Node.js)
+    orderMgr.insert("/project", "s1");
+    orderMgr.insert("/project", "s2");
+    orderMgr.insert("/project", "s3");
+    orderMgr.insert("/project", "s4");
+    orderMgr.insert("/project", "s5");
+
+    // All should be in reverse order (most recent first)
+    expect(orderMgr.getOrder("/project")).toEqual(["s5", "s4", "s3", "s2", "s1"]);
+  });
+});

package/packages/server/src/__tests__/session-scanner.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { scanAllSessions } from "../session-scanner.js";
+import { metaPath, writeSessionMeta } from "@blackbelt-technology/pi-dashboard-shared/session-meta.js";
+
+// Mock extractSessionStats to avoid needing real JSONL content with usage data
+vi.mock("../session-stats-reader.js", () => ({
+  extractSessionStats: vi.fn(() => ({
+    tokensIn: 10,
+    tokensOut: 20,
+    cacheRead: 30,
+    cacheWrite: 40,
+    cost: 0.5,
+    lastTotalTokens: 1000,
+    contextWindow: 200000,
+    model: "anthropic/claude-sonnet-4-20250514",
+    thinkingLevel: "medium",
+  })),
+}));
+
+describe("session-scanner", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "scanner-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createSessionDir(cwdEncoded: string): string {
+    const dir = path.join(tmpDir, cwdEncoded);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  function createJsonl(dir: string, filename: string, header?: { id: string; cwd: string }): string {
+    const filePath = path.join(dir, filename);
+    const h = header ?? { id: "test-id", cwd: "/test/cwd" };
+    const lines = [
+      JSON.stringify({ type: "session", id: h.id, cwd: h.cwd, timestamp: "2026-03-30T21:39:43.034Z" }),
+      JSON.stringify({ type: "message", message: { role: "user", content: "Hello world" } }),
+    ];
+    fs.writeFileSync(filePath, lines.join("\n") + "\n");
+    return filePath;
+  }
+
+  it("should return empty for non-existent directory", () => {
+    const result = scanAllSessions("/non/existent/path");
+    expect(result.sessions).toEqual([]);
+    expect(result.cacheUpdates).toBe(0);
+  });
+
+  it("should return empty for empty sessions directory", () => {
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toEqual([]);
+  });
+
+  it("should discover session from .meta.json with cached data", () => {
+    const dir = createSessionDir("--test-cwd--");
+    const sf = createJsonl(dir, "2026-03-30T21-39-43-034Z_abc-123.jsonl", { id: "abc-123", cwd: "/test/cwd" });
+    writeSessionMeta(sf, {
+      cwd: "/test/cwd",
+      name: "My Session",
+      source: "dashboard",
+      status: "ended",
+      startedAt: 1000,
+      cost: 5.0,
+      tokensIn: 100,
+      tokensOut: 200,
+      cachedAt: Date.now() + 10000, // far future = fresh cache
+    });
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(1);
+    expect(result.sessions[0].id).toBe("abc-123");
+    expect(result.sessions[0].cwd).toBe("/test/cwd");
+    expect(result.sessions[0].name).toBe("My Session");
+    expect(result.sessions[0].cost).toBe(5.0);
+    expect(result.cacheUpdates).toBe(0); // no re-extraction needed
+  });
+
+  it("should fall back to .jsonl parsing when no .meta.json exists", () => {
+    const dir = createSessionDir("--test-cwd--");
+    createJsonl(dir, "2026-03-30T21-39-43-034Z_def-456.jsonl", { id: "def-456", cwd: "/fallback/cwd" });
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(1);
+    expect(result.sessions[0].id).toBe("def-456");
+    expect(result.sessions[0].cwd).toBe("/fallback/cwd");
+    expect(result.sessions[0].firstMessage).toBe("Hello world");
+    expect(result.cacheUpdates).toBe(1); // wrote new .meta.json
+  });
+
+  it("should write .meta.json for uncached sessions", () => {
+    const dir = createSessionDir("--test-cwd--");
+    const sf = createJsonl(dir, "2026-03-30T21-39-43-034Z_ghi-789.jsonl", { id: "ghi-789", cwd: "/new/cwd" });
+
+    scanAllSessions(tmpDir);
+
+    // .meta.json should now exist
+    expect(fs.existsSync(metaPath(sf))).toBe(true);
+    const meta = JSON.parse(fs.readFileSync(metaPath(sf), "utf-8"));
+    expect(meta.cwd).toBe("/new/cwd");
+    expect(meta.cachedAt).toBeGreaterThan(0);
+  });
+
+  it("should ignore orphaned .meta.json without .jsonl", () => {
+    const dir = createSessionDir("--test-cwd--");
+    // Write .meta.json without a corresponding .jsonl
+    const orphanedMeta = path.join(dir, "2026-03-30T21-39-43-034Z_orphan-id.meta.json");
+    fs.writeFileSync(orphanedMeta, JSON.stringify({ cwd: "/ghost", source: "dashboard" }));
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(0);
+  });
+
+  it("should extract session ID from filename", () => {
+    const dir = createSessionDir("--test-cwd--");
+    createJsonl(dir, "2026-03-30T21-39-43-034Z_c7ab4be9-78d1-4764-8197-dbf74fea8bf4.jsonl", {
+      id: "c7ab4be9-78d1-4764-8197-dbf74fea8bf4",
+      cwd: "/test",
+    });
+    writeSessionMeta(
+      path.join(dir, "2026-03-30T21-39-43-034Z_c7ab4be9-78d1-4764-8197-dbf74fea8bf4.jsonl"),
+      { cwd: "/test", cachedAt: Date.now() + 10000 },
+    );
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions[0].id).toBe("c7ab4be9-78d1-4764-8197-dbf74fea8bf4");
+  });
+
+  it("should re-extract stats when .jsonl is newer than cachedAt", () => {
+    const dir = createSessionDir("--test-cwd--");
+    const sf = createJsonl(dir, "2026-03-30T21-39-43-034Z_stale-id.jsonl", { id: "stale-id", cwd: "/stale" });
+
+    // Write meta with old cachedAt
+    writeSessionMeta(sf, {
+      cwd: "/stale",
+      cost: 1.0,
+      cachedAt: 1000, // very old
+    });
+
+    // Touch the .jsonl to make it newer
+    const now = new Date();
+    fs.utimesSync(sf, now, now);
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(1);
+    // Stats should come from mock extractSessionStats (cost=0.5), not cached (cost=1.0)
+    expect(result.sessions[0].cost).toBe(0.5);
+    expect(result.cacheUpdates).toBe(1);
+  });
+
+  it("should scan multiple cwd directories", () => {
+    const dir1 = createSessionDir("--project-a--");
+    const dir2 = createSessionDir("--project-b--");
+    createJsonl(dir1, "2026-03-30T21-39-43-034Z_id-a.jsonl", { id: "id-a", cwd: "/project/a" });
+    createJsonl(dir2, "2026-03-30T21-39-43-034Z_id-b.jsonl", { id: "id-b", cwd: "/project/b" });
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(2);
+    const ids = result.sessions.map((s) => s.id).sort();
+    expect(ids).toEqual(["id-a", "id-b"]);
+  });
+
+  it("should preserve existing meta fields when falling back to .jsonl", () => {
+    const dir = createSessionDir("--test-cwd--");
+    const sf = createJsonl(dir, "2026-03-30T21-39-43-034Z_preserve-id.jsonl", { id: "preserve-id", cwd: "/test" });
+
+    // Write partial meta (source only, no cwd — triggers fallback)
+    writeSessionMeta(sf, { source: "dashboard" });
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions).toHaveLength(1);
+    expect(result.sessions[0].source).toBe("dashboard");
+
+    // Check the written meta preserved source
+    const meta = JSON.parse(fs.readFileSync(metaPath(sf), "utf-8"));
+    expect(meta.source).toBe("dashboard");
+    expect(meta.cwd).toBe("/test");
+  });
+
+  it("should set hidden from meta", () => {
+    const dir = createSessionDir("--test-cwd--");
+    const sf = createJsonl(dir, "2026-03-30T21-39-43-034Z_hidden-id.jsonl", { id: "hidden-id", cwd: "/test" });
+    writeSessionMeta(sf, {
+      cwd: "/test",
+      hidden: true,
+      cachedAt: Date.now() + 10000,
+    });
+
+    const result = scanAllSessions(tmpDir);
+    expect(result.sessions[0].hidden).toBe(true);
+  });
+});

package/packages/server/src/__tests__/shutdown-endpoint.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Tests for POST /api/shutdown endpoint.
+ */
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { createServer, type DashboardServer } from "../server.js";
+
+const httpPort = 19080;
+const piPort = 19081;
+let server: DashboardServer;
+
+// Mock process.exit to prevent actually exiting
+const mockExit = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+describe("POST /api/shutdown", () => {
+  afterEach(async () => {
+    mockExit.mockClear();
+    if (server) {
+      try { await server.stop(); } catch { /* already stopped */ }
+    }
+  });
+
+  it("should respond with { ok: true }", async () => {
+    server = await createServer({
+      port: httpPort, piPort, dev: true,
+      autoShutdown: false, shutdownIdleSeconds: 999, tunnel: false,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+
+    const res = await fetch(`http://localhost:${httpPort}/api/shutdown`, {
+      method: "POST",
+    });
+
+    expect(res.ok).toBe(true);
+    const body = await res.json();
+    expect(body).toEqual({ ok: true });
+
+    // Give the setTimeout a chance to fire
+    await new Promise((r) => setTimeout(r, 200));
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+});

package/packages/server/src/__tests__/skip-wipe.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Tests for bridge reconnect skip-wipe logic in event-wiring.
+ * When bridge sends eventCount matching server's stored count, skip the event wipe.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { createMemoryEventStore } from "../memory-event-store.js";
+import { createMemorySessionManager } from "../memory-session-manager.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: {} };
+}
+
+/**
+ * Minimal simulation of the session_register path in event-wiring.ts.
+ * We test the skip-wipe decision logic in isolation.
+ */
+function simulateSessionRegister(opts: {
+  eventStore: ReturnType<typeof createMemoryEventStore>;
+  sessionId: string;
+  previousSessionId?: string;
+  eventCount?: number;
+}) {
+  const { eventStore, sessionId, previousSessionId, eventCount } = opts;
+  const wiped = { value: false };
+  const resetSent = { value: false };
+
+  // Decision logic matching event-wiring.ts
+  const sameSession = !previousSessionId || previousSessionId === sessionId;
+  const serverEventCount = eventStore.getEvents(sessionId, 1).length;
+  const canSkipWipe = sameSession && eventCount !== undefined && eventCount === serverEventCount;
+
+  if (!canSkipWipe) {
+    eventStore.deleteEventsForSession(sessionId);
+    wiped.value = true;
+    resetSent.value = true;
+  }
+
+  return { wiped: wiped.value, resetSent: resetSent.value };
+}
+
+describe("skip-wipe on bridge reconnect", () => {
+  it("skips wipe when eventCount matches server event count", () => {
+    const store = createMemoryEventStore(() => false);
+    store.insertEvent("s1", makeEvent("a"));
+    store.insertEvent("s1", makeEvent("b"));
+    store.insertEvent("s1", makeEvent("c"));
+
+    const result = simulateSessionRegister({
+      eventStore: store,
+      sessionId: "s1",
+      previousSessionId: "s1",
+      eventCount: 3,
+    });
+
+    expect(result.wiped).toBe(false);
+    expect(result.resetSent).toBe(false);
+    // Events preserved
+    expect(store.getEvents("s1", 1)).toHaveLength(3);
+  });
+
+  it("wipes when eventCount mismatches", () => {
+    const store = createMemoryEventStore(() => false);
+    store.insertEvent("s1", makeEvent("a"));
+    store.insertEvent("s1", makeEvent("b"));
+
+    const result = simulateSessionRegister({
+      eventStore: store,
+      sessionId: "s1",
+      previousSessionId: "s1",
+      eventCount: 5, // mismatch
+    });
+
+    expect(result.wiped).toBe(true);
+    expect(result.resetSent).toBe(true);
+    expect(store.getEvents("s1", 1)).toHaveLength(0);
+  });
+
+  it("wipes when eventCount is not provided (backward compat)", () => {
+    const store = createMemoryEventStore(() => false);
+    store.insertEvent("s1", makeEvent("a"));
+
+    const result = simulateSessionRegister({
+      eventStore: store,
+      sessionId: "s1",
+      previousSessionId: "s1",
+      eventCount: undefined,
+    });
+
+    expect(result.wiped).toBe(true);
+    expect(result.resetSent).toBe(true);
+  });
+
+  it("wipes when session ID changed", () => {
+    const store = createMemoryEventStore(() => false);
+    store.insertEvent("s1", makeEvent("a"));
+    store.insertEvent("s1", makeEvent("b"));
+
+    const result = simulateSessionRegister({
+      eventStore: store,
+      sessionId: "s2", // different session
+      previousSessionId: "s1",
+      eventCount: 2,
+    });
+
+    expect(result.wiped).toBe(true);
+    expect(result.resetSent).toBe(true);
+  });
+
+  it("wipes when no previous session (first connect)", () => {
+    const store = createMemoryEventStore(() => false);
+
+    const result = simulateSessionRegister({
+      eventStore: store,
+      sessionId: "s1",
+      previousSessionId: undefined,
+      eventCount: 5,
+    });
+
+    // No previous session = can't verify, so wipe
+    expect(result.wiped).toBe(true);
+  });
+});

package/packages/server/src/__tests__/sleep-aware-heartbeat.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Tests for sleep-aware heartbeat in pi-gateway.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { createPiGateway } from "../pi-gateway.js";
+import { createMemorySessionManager } from "../memory-session-manager.js";
+import { WebSocket } from "ws";
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+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 makeTempSessionManager() {
+  return createMemorySessionManager();
+}
+
+// Use a short heartbeat for fast tests
+const SHORT_HB = 300; // 300ms
+let portCounter = 19390;
+
+describe("Sleep-aware heartbeat", () => {
+  let gateway: ReturnType<typeof createPiGateway>;
+
+  afterEach(() => {
+    gateway?.stop();
+  });
+
+  it("should unregister session after normal heartbeat timeout", async () => {
+    const sessionManager = makeTempSessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: SHORT_HB });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "s1", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+    expect(sessionManager.get("s1")!.status).toBe("active");
+
+    // Close without unregister
+    ws.close();
+    await delay(100);
+
+    // Wait for heartbeat timeout
+    await delay(SHORT_HB + 200);
+
+    expect(sessionManager.get("s1")!.status).toBe("ended");
+  }, 10000);
+
+  it("should call onEmpty after heartbeat timeout", async () => {
+    const sessionManager = makeTempSessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: SHORT_HB });
+    const port = portCounter++;
+    gateway.start(port);
+
+    let emptyCalled = false;
+    gateway.onEmpty = () => { emptyCalled = true; };
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "s2", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+
+    ws.close();
+    await delay(SHORT_HB + 200);
+
+    expect(emptyCalled).toBe(true);
+  }, 10000);
+
+  it("should retry once when sleep is detected (simulated via Date.now override)", async () => {
+    const sessionManager = makeTempSessionManager();
+    // Use a longer timeout so we can manipulate Date.now between calls
+    const HB = 500;
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: HB });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "s3", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+    expect(sessionManager.get("s3")!.status).toBe("active");
+
+    // Close connection
+    ws.close();
+    await delay(50);
+
+    // Simulate sleep: make Date.now() jump forward far beyond 2× timeout
+    const realNow = Date.now.bind(Date);
+    let offset = 0;
+    Date.now = () => realNow() + offset;
+
+    // Jump time forward to simulate sleep (10× timeout = clearly > 2×)
+    offset = HB * 10;
+
+    // Wait for the heartbeat timer to fire (it uses real setTimeout)
+    await delay(HB + 200);
+
+    // Session should still be active (sleep detected, one retry granted)
+    expect(sessionManager.get("s3")!.status).toBe("active");
+
+    // Reset time back to normal
+    offset = 0;
+
+    // Wait for the retry heartbeat to fire
+    await delay(HB + 200);
+
+    // Now it should be ended (second timeout, no sleep detected)
+    expect(sessionManager.get("s3")!.status).toBe("ended");
+
+    Date.now = realNow;
+  }, 10000);
+});