@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/editor-registry.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockedExecSync } = vi.hoisted(() => ({
+  mockedExecSync: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => ({
+  default: { execSync: mockedExecSync },
+  execSync: mockedExecSync,
+}));
+
+import { detectEditors, isProcessRunning, isProcessRunningWin32, EDITORS, type DetectedEditor } from "../editor-registry.js";
+
+describe("editor-registry", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("EDITORS", () => {
+    it("should have entries for zed, vscode, and idea", () => {
+      expect(EDITORS).toHaveLength(3);
+      expect(EDITORS.map((e) => e.id)).toEqual(["zed", "vscode", "idea"]);
+    });
+
+    it("should have win32 patterns for vscode and idea", () => {
+      const vscode = EDITORS.find(e => e.id === "vscode")!;
+      const idea = EDITORS.find(e => e.id === "idea")!;
+      expect(vscode.processPattern.win32).toBe("Code.exe");
+      expect(vscode.winCli).toBe("code.cmd");
+      expect(idea.processPattern.win32).toBe("idea64.exe");
+      expect(idea.winCli).toBe("idea64.exe");
+    });
+
+    it("should not have win32 pattern for zed", () => {
+      const zed = EDITORS.find(e => e.id === "zed")!;
+      expect(zed.processPattern.win32).toBeUndefined();
+    });
+  });
+
+  describe("isProcessRunningWin32", () => {
+    it("returns true when tasklist finds process", () => {
+      mockedExecSync.mockReturnValue("Code.exe                     12345 Console  1  150,000 K");
+      expect(isProcessRunningWin32("Code.exe")).toBe(true);
+    });
+
+    it("returns false when tasklist shows no matching process", () => {
+      mockedExecSync.mockReturnValue("INFO: No tasks are running which match the specified criteria.");
+      expect(isProcessRunningWin32("Code.exe")).toBe(false);
+    });
+  });
+
+  describe("isProcessRunning", () => {
+    it("should return true when pgrep finds matching process", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("12345\n"));
+      expect(isProcessRunning("/Applications/Zed.app")).toBe(true);
+    });
+
+    it("should return false when pgrep finds no match", () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error("exit code 1");
+      });
+      expect(isProcessRunning("/Applications/Zed.app")).toBe(false);
+    });
+
+    it("should return false when pgrep is not available", () => {
+      mockedExecSync.mockImplementation(() => {
+        const err = new Error("command not found") as any;
+        err.status = 127;
+        throw err;
+      });
+      expect(isProcessRunning("/Applications/Zed.app")).toBe(false);
+    });
+  });
+
+  describe("detectEditors", () => {
+    it("should return editor when process is running AND CLI is available", () => {
+      mockedExecSync.mockImplementation((cmd) => {
+        const s = String(cmd);
+        if (s.includes("pgrep")) {
+          // Only Zed is running
+          if (s.includes("Zed")) return Buffer.from("12345\n");
+          throw new Error("not found");
+        }
+        if (s.includes("which")) {
+          if (s.includes("zed")) return Buffer.from("/usr/local/bin/zed\n");
+          throw new Error("not found");
+        }
+        throw new Error("unexpected command");
+      });
+
+      const result = detectEditors("/some/project");
+      expect(result).toEqual([{ id: "zed", name: "Zed" }]);
+    });
+
+    it("should return empty when process not running even if CLI available", () => {
+      mockedExecSync.mockImplementation((cmd) => {
+        const s = String(cmd);
+        if (s.includes("pgrep")) throw new Error("not found");
+        if (s.includes("which")) return Buffer.from("/usr/local/bin/zed\n");
+        throw new Error("unexpected command");
+      });
+
+      const result = detectEditors("/some/project");
+      expect(result).toEqual([]);
+    });
+
+    it("should return empty when process running but CLI not available", () => {
+      mockedExecSync.mockImplementation((cmd) => {
+        const s = String(cmd);
+        if (s.includes("pgrep")) return Buffer.from("12345\n");
+        if (s.includes("which")) throw new Error("not found");
+        throw new Error("unexpected command");
+      });
+
+      const result = detectEditors("/some/project");
+      expect(result).toEqual([]);
+    });
+
+    it("should return multiple editors when multiple are running", () => {
+      mockedExecSync.mockImplementation((cmd) => {
+        const s = String(cmd);
+        if (s.includes("pgrep")) {
+          if (s.includes("Zed") || s.includes("zed")) return Buffer.from("12345\n");
+          if (s.includes("Visual Studio Code") || s.includes("code")) return Buffer.from("67890\n");
+          throw new Error("not found");
+        }
+        if (s.includes("which")) {
+          if (s.includes("zed")) return Buffer.from("/usr/local/bin/zed\n");
+          if (s.includes("code")) return Buffer.from("/usr/local/bin/code\n");
+          throw new Error("not found");
+        }
+        throw new Error("unexpected command");
+      });
+
+      const result = detectEditors("/some/project");
+      expect(result).toEqual([
+        { id: "zed", name: "Zed" },
+        { id: "vscode", name: "VS Code" },
+      ]);
+    });
+
+    it("should return empty when no editors are running", () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error("not found");
+      });
+
+      const result = detectEditors("/some/project");
+      expect(result).toEqual([]);
+    });
+  });
+});

package/packages/server/src/__tests__/event-status-extraction-flow.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { extractSessionUpdates } from "../event-status-extraction.js";
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function makeEvent(eventType: string, data: Record<string, unknown> = {}): DashboardEvent {
+  return { eventType, timestamp: Date.now(), data };
+}
+
+describe("extractSessionUpdates flow events", () => {
+  it("flow_started extracts flow metadata", () => {
+    const updates = extractSessionUpdates(makeEvent("flow_started", {
+      flowName: "research-and-build",
+      steps: [
+        { id: "r", stepType: "agent", agent: "researcher" },
+        { id: "d", stepType: "agent", agent: "developer" },
+        { id: "f1", stepType: "fork", question: "which?" },
+      ],
+    }));
+    expect(updates).toEqual({
+      activeFlowName: "research-and-build",
+      flowAgentsTotal: 2,
+      flowAgentsDone: 0,
+      flowStatus: "running",
+    });
+  });
+
+  it("flow_agent_complete returns sentinel for increment", () => {
+    const updates = extractSessionUpdates(makeEvent("flow_agent_complete", {
+      agentName: "researcher",
+      result: { success: true },
+    }));
+    expect(updates).toEqual({ flowAgentsDone: -1 });
+  });
+
+  it("flow_complete extracts status", () => {
+    const updates = extractSessionUpdates(makeEvent("flow_complete", {
+      status: "error",
+      flowName: "test",
+    }));
+    expect(updates).toEqual({ flowStatus: "error" });
+  });
+
+  it("flow_complete defaults to success", () => {
+    const updates = extractSessionUpdates(makeEvent("flow_complete", {
+      flowName: "test",
+    }));
+    expect(updates).toEqual({ flowStatus: "success" });
+  });
+
+  it("other flow events return null", () => {
+    expect(extractSessionUpdates(makeEvent("flow_tool_call"))).toBeNull();
+    expect(extractSessionUpdates(makeEvent("flow_assistant_text"))).toBeNull();
+    expect(extractSessionUpdates(makeEvent("flow_loop_iteration"))).toBeNull();
+  });
+});

package/packages/server/src/__tests__/event-status-extraction.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { extractSessionUpdates } from "../event-status-extraction.js";
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function makeEvent(eventType: string, data: Record<string, unknown> = {}): DashboardEvent {
+  return { eventType, timestamp: Date.now(), data: { type: eventType, ...data } };
+}
+
+describe("extractSessionUpdates", () => {
+  it("should return streaming status on agent_start", () => {
+    const updates = extractSessionUpdates(makeEvent("agent_start"));
+    expect(updates).toEqual({ status: "streaming", currentTool: null });
+  });
+
+  it("should return idle status on agent_end", () => {
+    const updates = extractSessionUpdates(makeEvent("agent_end"));
+    expect(updates).toEqual({ status: "idle", currentTool: null });
+  });
+
+  it("should return currentTool on tool_execution_start", () => {
+    const updates = extractSessionUpdates(makeEvent("tool_execution_start", { toolName: "Read" }));
+    expect(updates).toEqual({ currentTool: "Read" });
+  });
+
+  it("should clear currentTool on tool_execution_end", () => {
+    const updates = extractSessionUpdates(makeEvent("tool_execution_end", { toolName: "Read" }));
+    expect(updates).toEqual({ currentTool: null });
+  });
+
+  it("should extract model from model_select event", () => {
+    const updates = extractSessionUpdates(
+      makeEvent("model_select", {
+        model: { provider: "anthropic", id: "claude-opus-4-6" },
+      })
+    );
+    expect(updates).toEqual({ model: "anthropic/claude-opus-4-6" });
+  });
+
+  it("should extract model and thinkingLevel from model_select event", () => {
+    const updates = extractSessionUpdates(
+      makeEvent("model_select", {
+        model: { provider: "anthropic", id: "claude-opus-4-6" },
+        thinkingLevel: "high",
+      })
+    );
+    expect(updates).toEqual({ model: "anthropic/claude-opus-4-6", thinkingLevel: "high" });
+  });
+
+  it("should return null for model_select without model data", () => {
+    expect(extractSessionUpdates(makeEvent("model_select"))).toBeNull();
+  });
+
+  it("should return null for unrelated events", () => {
+    expect(extractSessionUpdates(makeEvent("message_update"))).toBeNull();
+    expect(extractSessionUpdates(makeEvent("session_compact"))).toBeNull();
+    expect(extractSessionUpdates(makeEvent("turn_start"))).toBeNull();
+  });
+});

package/packages/server/src/__tests__/extension-register.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// We test the module's exported function
+import { ensureBridgeExtensionRegistered } from "../extension-register.js";
+
+describe("ensureBridgeExtensionRegistered", () => {
+  let tmpDir: string;
+  let settingsPath: string;
+  let origHome: string | undefined;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ext-reg-test-"));
+    settingsPath = path.join(tmpDir, ".pi", "agent", "settings.json");
+    origHome = process.env.HOME;
+    process.env.HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = origHome;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should be a no-op when no bundled extension exists", () => {
+    // In dev mode, the extension directory relative to server/src is the real
+    // packages/extension, but in test context __dirname doesn't point to a bundle.
+    // The function should not crash and should not create settings.json
+    ensureBridgeExtensionRegistered();
+    // No assertion needed — just verify no crash
+  });
+
+  it("should add extension path to empty settings file", () => {
+    // Create a fake bundled extension at the expected relative path
+    // extension-register.ts resolves __dirname/../../../extension relative to server/src
+    // We can't easily test the real path detection, so we test the settings write logic
+    // by directly calling with a mocked path
+
+    // Create settings dir
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, "{}");
+
+    // Since we can't mock __dirname easily, we test the settings logic directly
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(settings.packages).toBeUndefined();
+  });
+
+  it("should not crash on malformed settings.json", () => {
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, "not valid json{{{");
+    ensureBridgeExtensionRegistered();
+    // Should not throw
+  });
+
+  it("should not crash when settings directory does not exist", () => {
+    // HOME points to tmpDir but .pi/agent/ doesn't exist
+    ensureBridgeExtensionRegistered();
+    // Should not throw
+  });
+});

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

@@ -0,0 +1,49 @@
+/**
+ * Tests for the file read endpoint logic.
+ * Uses lightweight path validation tests since integration tests
+ * require a full server (covered by manual testing).
+ */
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+
+/**
+ * Extracted path containment check — same logic used in the endpoint.
+ */
+function isPathContained(cwd: string, relPath: string): boolean {
+  const resolved = path.resolve(cwd, relPath);
+  return resolved.startsWith(cwd + path.sep) || resolved === cwd;
+}
+
+describe("file endpoint path validation", () => {
+  it("should allow a simple relative path", () => {
+    expect(isPathContained("/project", "readme.md")).toBe(true);
+  });
+
+  it("should allow a nested relative path", () => {
+    expect(isPathContained("/project", "openspec/changes/foo/proposal.md")).toBe(true);
+  });
+
+  it("should allow a subdirectory path", () => {
+    expect(isPathContained("/project", "openspec/changes/foo/specs")).toBe(true);
+  });
+
+  it("should reject path traversal with ../", () => {
+    expect(isPathContained("/project", "../../etc/passwd")).toBe(false);
+  });
+
+  it("should reject path traversal that resolves outside cwd", () => {
+    expect(isPathContained("/project/sub", "../other/file.md")).toBe(false);
+  });
+
+  it("should allow path with ../ that stays inside cwd", () => {
+    expect(isPathContained("/project", "a/../b/file.md")).toBe(true);
+  });
+
+  it("should reject absolute path outside cwd", () => {
+    expect(isPathContained("/project", "/etc/passwd")).toBe(false);
+  });
+
+  it("should allow cwd itself", () => {
+    expect(isPathContained("/project", ".")).toBe(true);
+  });
+});

package/packages/server/src/__tests__/force-kill-handler.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Tests for handleForceKill in session-action-handler.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handleForceKill } from "../browser-handlers/session-action-handler.js";
+import type { BrowserHandlerContext } from "../browser-handlers/handler-context.js";
+
+function createMockContext(sessionOverrides?: Record<string, any>): BrowserHandlerContext & { sent: any[]; broadcasts: any[] } {
+  const sent: any[] = [];
+  const broadcasts: any[] = [];
+  return {
+    ws: {} as any,
+    sessionManager: {
+      get: vi.fn().mockReturnValue({
+        id: "sess-1",
+        cwd: "/test",
+        status: "streaming",
+        pid: 99999,
+        ...sessionOverrides,
+      }),
+      update: vi.fn(),
+    } as any,
+    eventStore: {} as any,
+    piGateway: {
+      closeSession: vi.fn().mockReturnValue(true),
+      sendToSession: vi.fn().mockReturnValue(true),
+    } as any,
+    pendingForkRegistry: undefined,
+    headlessPidRegistry: {
+      killBySessionId: vi.fn().mockReturnValue(false),
+    } as any,
+    pendingResumeRegistry: {} as any,
+    sendTo: vi.fn((_ws, msg) => sent.push(msg)),
+    broadcast: vi.fn((msg) => broadcasts.push(msg)),
+    getSubscribers: vi.fn().mockReturnValue([]),
+    trackUiRequest: vi.fn(),
+    replayPendingUiRequests: vi.fn(),
+    markReplaying: vi.fn(),
+    clearReplaying: vi.fn(),
+    sent,
+    broadcasts,
+  } as any;
+}
+
+describe("handleForceKill", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should close bridge WebSocket and mark session ended when no PID", async () => {
+    const ctx = createMockContext({ pid: undefined });
+
+    await handleForceKill({ type: "force_kill", sessionId: "sess-1" }, ctx);
+
+    expect(ctx.piGateway.closeSession).toHaveBeenCalledWith("sess-1");
+    expect(ctx.sessionManager.update).toHaveBeenCalledWith("sess-1", expect.objectContaining({ status: "ended" }));
+    
+    const result = ctx.sent.find((m: any) => m.type === "force_kill_result");
+    expect(result).toBeDefined();
+    expect(result.success).toBe(true);
+    expect(result.message).toContain("no PID");
+  });
+
+  it("should send SIGTERM and mark session ended for valid PID", async () => {
+    // Use a PID that doesn't exist so SIGTERM throws
+    const ctx = createMockContext({ pid: 2147483647 });
+
+    await handleForceKill({ type: "force_kill", sessionId: "sess-1" }, ctx);
+
+    expect(ctx.piGateway.closeSession).toHaveBeenCalledWith("sess-1");
+    expect(ctx.sessionManager.update).toHaveBeenCalledWith("sess-1", expect.objectContaining({ status: "ended" }));
+    
+    const result = ctx.sent.find((m: any) => m.type === "force_kill_result");
+    expect(result).toBeDefined();
+    expect(result.success).toBe(true);
+    expect(result.message).toContain("already exited");
+  });
+
+  it("should broadcast session_updated with ended status", async () => {
+    const ctx = createMockContext({ pid: undefined });
+
+    await handleForceKill({ type: "force_kill", sessionId: "sess-1" }, ctx);
+
+    const update = ctx.broadcasts.find((m: any) => m.type === "session_updated");
+    expect(update).toBeDefined();
+    expect(update.updates.status).toBe("ended");
+  });
+
+  it("should always close the bridge WebSocket", async () => {
+    const ctx = createMockContext({ pid: 12345 });
+
+    await handleForceKill({ type: "force_kill", sessionId: "sess-1" }, ctx);
+
+    expect(ctx.piGateway.closeSession).toHaveBeenCalledWith("sess-1");
+  });
+
+  it("should return success: false when session not found", async () => {
+    const ctx = createMockContext();
+    (ctx.sessionManager.get as any).mockReturnValue(undefined);
+
+    await handleForceKill({ type: "force_kill", sessionId: "unknown" }, ctx);
+
+    const result = ctx.sent.find((m: any) => m.type === "force_kill_result");
+    expect(result).toBeDefined();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("not found");
+    expect(ctx.piGateway.closeSession).not.toHaveBeenCalled();
+  });
+});