@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/pi-resource-scanner.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { scanLocalResources, scanGlobalResources, parseFrontmatter, resolvePackages, scanPiResources } from "../pi-resource-scanner.js";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-res-test-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeFile(relPath: string, content: string) {
+  const full = path.join(tmpDir, relPath);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, "utf-8");
+}
+
+describe("parseFrontmatter", () => {
+  it("parses name and description from YAML frontmatter", () => {
+    const content = `---
+name: code-review
+description: Comprehensive code review guidance.
+license: MIT
+---
+
+# Code Review
+
+Instructions here.`;
+    const result = parseFrontmatter(content);
+    expect(result.name).toBe("code-review");
+    expect(result.description).toBe("Comprehensive code review guidance.");
+  });
+
+  it("handles multi-line description with >", () => {
+    const content = `---
+name: my-skill
+description: >
+  Line one
+  line two.
+---
+
+Body`;
+    const result = parseFrontmatter(content);
+    expect(result.name).toBe("my-skill");
+    expect(result.description).toContain("Line one");
+  });
+
+  it("returns empty object for no frontmatter", () => {
+    const result = parseFrontmatter("# Just a heading\n\nSome content.");
+    expect(result.name).toBeUndefined();
+    expect(result.description).toBeUndefined();
+  });
+
+  it("extracts first non-empty line as description fallback", () => {
+    const result = parseFrontmatter("# My Prompt\n\nDo something useful.", true);
+    expect(result.description).toBe("# My Prompt");
+  });
+});
+
+describe("scanLocalResources", () => {
+  it("discovers skills from SKILL.md directories", () => {
+    writeFile(".pi/skills/code-review/SKILL.md", `---
+name: code-review
+description: Review code.
+---
+Instructions`);
+    const result = scanLocalResources(tmpDir);
+    expect(result.skills).toHaveLength(1);
+    expect(result.skills[0].name).toBe("code-review");
+    expect(result.skills[0].description).toBe("Review code.");
+    expect(result.skills[0].type).toBe("skill");
+  });
+
+  it("discovers skills from root .md files", () => {
+    writeFile(".pi/skills/quick-review.md", `---
+name: quick-review
+description: Quick review.
+---
+Body`);
+    const result = scanLocalResources(tmpDir);
+    expect(result.skills).toHaveLength(1);
+    expect(result.skills[0].name).toBe("quick-review");
+  });
+
+  it("discovers extensions from .ts files", () => {
+    writeFile(".pi/extensions/my-ext.ts", "export default function() {}");
+    const result = scanLocalResources(tmpDir);
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0].name).toBe("my-ext");
+    expect(result.extensions[0].type).toBe("extension");
+  });
+
+  it("discovers extensions from subdirectory index.ts", () => {
+    writeFile(".pi/extensions/my-ext/index.ts", "export default function() {}");
+    const result = scanLocalResources(tmpDir);
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0].name).toBe("my-ext");
+  });
+
+  it("discovers prompts from .md files", () => {
+    writeFile(".pi/prompts/review.md", `---
+description: Review staged changes
+---
+Review the staged changes.`);
+    const result = scanLocalResources(tmpDir);
+    expect(result.prompts).toHaveLength(1);
+    expect(result.prompts[0].name).toBe("review");
+    expect(result.prompts[0].description).toBe("Review staged changes");
+    expect(result.prompts[0].type).toBe("prompt");
+  });
+
+  it("returns empty arrays when .pi/ does not exist", () => {
+    const result = scanLocalResources(path.join(tmpDir, "nonexistent"));
+    expect(result.extensions).toEqual([]);
+    expect(result.skills).toEqual([]);
+    expect(result.prompts).toEqual([]);
+  });
+});
+
+describe("scanGlobalResources", () => {
+  it("discovers resources from a global-like directory", () => {
+    const globalDir = path.join(tmpDir, "global-pi");
+    fs.mkdirSync(path.join(globalDir, "skills", "my-skill"), { recursive: true });
+    fs.writeFileSync(path.join(globalDir, "skills", "my-skill", "SKILL.md"), `---
+name: my-skill
+description: A global skill.
+---
+Body`);
+    fs.mkdirSync(path.join(globalDir, "extensions"), { recursive: true });
+    fs.writeFileSync(path.join(globalDir, "extensions", "g-ext.ts"), "export default function() {}");
+    fs.mkdirSync(path.join(globalDir, "prompts"), { recursive: true });
+    fs.writeFileSync(path.join(globalDir, "prompts", "g-prompt.md"), "Do things.");
+
+    const result = scanGlobalResources(globalDir);
+    expect(result.skills).toHaveLength(1);
+    expect(result.skills[0].name).toBe("my-skill");
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0].name).toBe("g-ext");
+    expect(result.prompts).toHaveLength(1);
+    expect(result.prompts[0].name).toBe("g-prompt");
+  });
+
+  it("returns empty when directory does not exist", () => {
+    const result = scanGlobalResources("/nonexistent/path");
+    expect(result.extensions).toEqual([]);
+    expect(result.skills).toEqual([]);
+    expect(result.prompts).toEqual([]);
+  });
+});
+
+describe("resolvePackages", () => {
+  it("resolves a local path package with pi manifest", () => {
+    const pkgDir = path.join(tmpDir, "my-pkg");
+    fs.mkdirSync(path.join(pkgDir, "src"), { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, "src", "bridge.ts"), "export default function() {}");
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "my-pkg",
+        description: "A test package",
+        pi: { extensions: ["./src/bridge.ts"] },
+      }),
+    );
+
+    const result = resolvePackages([pkgDir], path.join(tmpDir, "settings-dir"));
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("my-pkg");
+    expect(result[0].description).toBe("A test package");
+    expect(result[0].resources.extensions).toHaveLength(1);
+    expect(result[0].resources.extensions[0].name).toBe("bridge");
+  });
+
+  it("resolves package with conventional directories (no pi manifest)", () => {
+    const pkgDir = path.join(tmpDir, "conv-pkg");
+    fs.mkdirSync(path.join(pkgDir, "extensions"), { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, "extensions", "ext.ts"), "export default function() {}");
+    fs.mkdirSync(path.join(pkgDir, "skills", "my-skill"), { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, "skills", "my-skill", "SKILL.md"), `---
+name: my-skill
+description: Skill from package.
+---
+Body`);
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({ name: "conv-pkg", description: "Conventional" }),
+    );
+
+    const result = resolvePackages([pkgDir], path.join(tmpDir, "settings-dir"));
+    expect(result).toHaveLength(1);
+    expect(result[0].resources.extensions).toHaveLength(1);
+    expect(result[0].resources.skills).toHaveLength(1);
+  });
+
+  it("skips missing packages silently", () => {
+    const result = resolvePackages(["/nonexistent/package"], tmpDir);
+    expect(result).toEqual([]);
+  });
+
+  it("resolves relative path packages from settings dir", () => {
+    const settingsDir = path.join(tmpDir, "project", ".pi");
+    const pkgDir = path.join(tmpDir, "sibling-pkg");
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({ name: "sibling", description: "Sibling package" }),
+    );
+
+    const result = resolvePackages(["../../sibling-pkg"], settingsDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("sibling");
+  });
+});
+
+describe("scanPiResources (integration)", () => {
+  it("combines local, global, and returns a full result", async () => {
+    writeFile(".pi/skills/local-skill/SKILL.md", `---
+name: local-skill
+description: A local skill.
+---
+Body`);
+    writeFile(".pi/prompts/my-prompt.md", "Do something.");
+
+    // We pass a custom globalDir to avoid depending on ~/.pi/agent
+    const result = await scanPiResources(tmpDir, { globalDir: path.join(tmpDir, "nonexistent-global") });
+    expect(result.local.skills).toHaveLength(1);
+    expect(result.local.prompts).toHaveLength(1);
+    expect(result.global.skills).toEqual([]);
+    expect(result.packages).toEqual([]);
+  });
+});

package/packages/server/src/__tests__/preferences-store.test.ts

@@ -0,0 +1,108 @@
+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 { createPreferencesStore } from "../preferences-store.js";
+
+// Mock resolve-path to be a no-op (no symlink resolution in tests)
+vi.mock("../resolve-path.js", () => ({
+  safeRealpathSync: (p: string) => p,
+}));
+
+describe("preferences-store", () => {
+  let tmpDir: string;
+  let filePath: string;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pref-store-test-"));
+    filePath = path.join(tmpDir, "preferences.json");
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should start with empty defaults when file missing", () => {
+    const store = createPreferencesStore(filePath);
+    expect(store.getPinnedDirectories()).toEqual([]);
+    expect(store.getSessionOrder()).toEqual({});
+    store.dispose();
+  });
+
+  it("should load existing preferences", () => {
+    fs.writeFileSync(filePath, JSON.stringify({
+      pinnedDirectories: ["/a", "/b"],
+      sessionOrder: { "/a": ["s1", "s2"] },
+    }));
+    const store = createPreferencesStore(filePath);
+    expect(store.getPinnedDirectories()).toEqual(["/a", "/b"]);
+    expect(store.getSessionOrder()).toEqual({ "/a": ["s1", "s2"] });
+    store.dispose();
+  });
+
+  it("should pin and unpin directories", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.pinDirectory("/b");
+    expect(store.getPinnedDirectories()).toEqual(["/a", "/b"]);
+    store.unpinDirectory("/a");
+    expect(store.getPinnedDirectories()).toEqual(["/b"]);
+    store.dispose();
+  });
+
+  it("should not duplicate pinned directories", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.pinDirectory("/a");
+    expect(store.getPinnedDirectories()).toEqual(["/a"]);
+    store.dispose();
+  });
+
+  it("should reorder pinned directories", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.pinDirectory("/b");
+    store.reorderPinnedDirs(["/b", "/a"]);
+    expect(store.getPinnedDirectories()).toEqual(["/b", "/a"]);
+    store.dispose();
+  });
+
+  it("should set and get session order", () => {
+    const store = createPreferencesStore(filePath);
+    store.setSessionOrder({ "/x": ["s1", "s2"] });
+    expect(store.getSessionOrder()).toEqual({ "/x": ["s1", "s2"] });
+    store.dispose();
+  });
+
+  it("should debounce writes", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.pinDirectory("/b");
+    // Not written yet
+    expect(fs.existsSync(filePath)).toBe(false);
+    vi.advanceTimersByTime(1000);
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    expect(data.pinnedDirectories).toEqual(["/a", "/b"]);
+    store.dispose();
+  });
+
+  it("should flush pending writes", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.flush();
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    expect(data.pinnedDirectories).toEqual(["/a"]);
+    store.dispose();
+  });
+
+  it("should not contain hiddenSessions in output", () => {
+    const store = createPreferencesStore(filePath);
+    store.pinDirectory("/a");
+    store.flush();
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    expect(data.hiddenSessions).toBeUndefined();
+    store.dispose();
+  });
+});

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

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi } from "vitest";
+import { detectPlatform, buildTmuxCommand, buildHeadlessArgs, shellEscape, spawnPiSession, buildSpawnEnv, type SessionOptions } from "../process-manager.js";
+
+describe("Process Manager", () => {
+  describe("detectPlatform", () => {
+    it("should detect macOS", () => {
+      const result = detectPlatform("darwin");
+      expect(result.strategy).toBe("tmux");
+    });
+
+    it("should detect Linux", () => {
+      const result = detectPlatform("linux");
+      expect(result.strategy).toBe("tmux");
+    });
+
+    it("should detect Windows with WSL fallback", () => {
+      const result = detectPlatform("win32");
+      expect(result.strategy).toBe("wsl");
+    });
+  });
+
+  describe("buildTmuxCommand", () => {
+    it("should create new session when no pi-dashboard session exists", () => {
+      const cmd = buildTmuxCommand("/home/user/project", false);
+      expect(cmd).toContain("new-session");
+      expect(cmd).toContain("pi-dashboard");
+    });
+
+    it("should create new window when pi-dashboard session exists", () => {
+      const cmd = buildTmuxCommand("/home/user/project", true);
+      expect(cmd).toContain("new-window");
+    });
+
+    it("should not set PI_DASHBOARD_SPAWNED env var", () => {
+      const cmd = buildTmuxCommand("/home/user/project", false);
+      expect(cmd).not.toContain("PI_DASHBOARD_SPAWNED");
+    });
+
+    it("should shell-escape cwd with spaces", () => {
+      const cmd = buildTmuxCommand("/home/user/my project", false);
+      expect(cmd).toContain("'/home/user/my project'");
+      expect(cmd).not.toContain('cd /home/user/my project &&');
+    });
+
+    it("should shell-escape cwd with semicolons to prevent injection", () => {
+      const cmd = buildTmuxCommand("/tmp/test; rm -rf /", false);
+      expect(cmd).toContain("'/tmp/test; rm -rf /'");
+    });
+
+    it("should shell-escape cwd with backticks to prevent injection", () => {
+      const cmd = buildTmuxCommand("/tmp/`whoami`", false);
+      expect(cmd).toContain("'/tmp/`whoami`'");
+    });
+
+    it("should shell-escape sessionFile with special characters", () => {
+      const cmd = buildTmuxCommand("/home/user/project", true, {
+        sessionFile: "/path/to/my session; cat /etc/passwd",
+        mode: "continue",
+      });
+      expect(cmd).toContain("--session '/path/to/my session; cat /etc/passwd'");
+    });
+
+    it("should not double-quote safe paths", () => {
+      const cmd = buildTmuxCommand("/home/user/project", false);
+      // Safe path should not be wrapped in single quotes
+      expect(cmd).toContain("cd /home/user/project &&");
+    });
+
+    it("should include --session flag for continue mode", () => {
+      const cmd = buildTmuxCommand("/home/user/project", true, {
+        sessionFile: "/path/to/session.jsonl",
+        mode: "continue",
+      });
+      expect(cmd).toContain("--session /path/to/session.jsonl");
+      expect(cmd).not.toContain("--fork");
+    });
+
+    it("should include --fork flag for fork mode", () => {
+      const cmd = buildTmuxCommand("/home/user/project", true, {
+        sessionFile: "/path/to/session.jsonl",
+        mode: "fork",
+      });
+      expect(cmd).toContain("--fork /path/to/session.jsonl");
+      expect(cmd).not.toContain("--session");
+    });
+
+    it("should not include session flags when no options provided", () => {
+      const cmd = buildTmuxCommand("/home/user/project", false);
+      expect(cmd).not.toContain("--session");
+      expect(cmd).not.toContain("--fork");
+    });
+
+    it("should create new session for continue mode when no tmux session exists", () => {
+      const cmd = buildTmuxCommand("/home/user/project", false, {
+        sessionFile: "/path/to/session.jsonl",
+        mode: "continue",
+      });
+      expect(cmd).toContain("new-session");
+      expect(cmd).toContain("--session /path/to/session.jsonl");
+    });
+  });
+
+  describe("buildHeadlessArgs", () => {
+    it("should return --mode rpc for fresh session", () => {
+      const args = buildHeadlessArgs();
+      expect(args).toEqual(["--mode", "rpc"]);
+    });
+
+    it("should include --session for continue mode", () => {
+      const args = buildHeadlessArgs({
+        sessionFile: "/path/to/session.jsonl",
+        mode: "continue",
+      });
+      expect(args).toEqual(["--mode", "rpc", "--session", "/path/to/session.jsonl"]);
+    });
+
+    it("should include --fork for fork mode", () => {
+      const args = buildHeadlessArgs({
+        sessionFile: "/path/to/session.jsonl",
+        mode: "fork",
+      });
+      expect(args).toEqual(["--mode", "rpc", "--fork", "/path/to/session.jsonl"]);
+    });
+
+    it("should not include session flags when no options", () => {
+      const args = buildHeadlessArgs({});
+      expect(args).toEqual(["--mode", "rpc"]);
+    });
+  });
+
+  describe("spawnPiSession", () => {
+    it("should return error for non-existent directory", async () => {
+      const result = await spawnPiSession("/tmp/definitely-does-not-exist-" + Date.now());
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Directory does not exist");
+    });
+  });
+
+  describe("SessionOptions strategy field", () => {
+    it("should accept tmux strategy", () => {
+      const opts: SessionOptions = { strategy: "tmux" };
+      expect(opts.strategy).toBe("tmux");
+    });
+
+    it("should accept headless strategy", () => {
+      const opts: SessionOptions = { strategy: "headless" };
+      expect(opts.strategy).toBe("headless");
+    });
+
+    it("should allow strategy with session file options", () => {
+      const opts: SessionOptions = {
+        strategy: "headless",
+        sessionFile: "/path/to/session.jsonl",
+        mode: "continue",
+      };
+      const args = buildHeadlessArgs(opts);
+      expect(args).toEqual(["--mode", "rpc", "--session", "/path/to/session.jsonl"]);
+    });
+  });
+
+  describe("buildSpawnEnv", () => {
+    it("should prepend managed bin to PATH", () => {
+      const env = buildSpawnEnv({ PATH: "/usr/bin" });
+      expect(env.PATH).toMatch(/\.pi-dashboard.*node_modules.*\.bin/);
+      expect(env.PATH).toContain("/usr/bin");
+    });
+
+    it("should not duplicate managed bin if already present", () => {
+      const managedBin = require("path").join(require("os").homedir(), ".pi-dashboard", "node_modules", ".bin");
+      const env = buildSpawnEnv({ PATH: `${managedBin}:/usr/bin` });
+      expect(env.PATH).toBe(`${managedBin}:/usr/bin`);
+    });
+  });
+
+  describe("electronMode", () => {
+    it("should force headless spawn when electronMode is true", async () => {
+      // electronMode should bypass tmux detection and use headless directly
+      // We test by calling with a non-existent dir to get a quick error without spawning
+      const result = await spawnPiSession("/nonexistent-path-12345", { electronMode: true });
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("does not exist");
+    });
+  });
+});

package/packages/server/src/__tests__/provider-auth-handlers.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import {
+  generatePKCE,
+  generateState,
+  getProviderHandler,
+  getAllHandlers,
+  type AuthCodeHandler,
+} from "../provider-auth-handlers.js";
+
+describe("provider-auth-handlers", () => {
+  describe("PKCE", () => {
+    it("generates verifier and challenge", async () => {
+      const pkce = await generatePKCE();
+      expect(pkce.verifier).toBeTruthy();
+      expect(pkce.challenge).toBeTruthy();
+      expect(pkce.verifier).not.toBe(pkce.challenge);
+    });
+
+    it("generates different pairs each time", async () => {
+      const a = await generatePKCE();
+      const b = await generatePKCE();
+      expect(a.verifier).not.toBe(b.verifier);
+    });
+  });
+
+  describe("generateState", () => {
+    it("returns a hex string", () => {
+      const state = generateState();
+      expect(state).toMatch(/^[0-9a-f]+$/);
+      expect(state.length).toBe(32);
+    });
+  });
+
+  describe("registry", () => {
+    it("has all 5 providers", () => {
+      const handlers = getAllHandlers();
+      expect(handlers.length).toBe(5);
+    });
+
+    it("gets anthropic handler", () => {
+      const h = getProviderHandler("anthropic");
+      expect(h).toBeDefined();
+      expect(h!.flowType).toBe("auth_code");
+      expect(h!.providerId).toBe("anthropic");
+    });
+
+    it("gets github-copilot as device_code", () => {
+      const h = getProviderHandler("github-copilot");
+      expect(h).toBeDefined();
+      expect(h!.flowType).toBe("device_code");
+    });
+
+    it("returns undefined for unknown provider", () => {
+      expect(getProviderHandler("unknown")).toBeUndefined();
+    });
+  });
+
+  describe("auth URL builders", () => {
+    const dummyPkce = { verifier: "v", challenge: "c" };
+
+    it("anthropic builds correct auth URL", () => {
+      const h = getProviderHandler("anthropic") as AuthCodeHandler;
+      const url = h.buildAuthUrl("http://localhost:9998/callback", "test-state", dummyPkce);
+      expect(url).toContain("claude.ai/oauth/authorize");
+      expect(url).toContain("code_challenge=c");
+      expect(url).toContain("state=test-state");
+      expect(url).toContain("redirect_uri=");
+    });
+
+    it("openai-codex builds correct auth URL", () => {
+      const h = getProviderHandler("openai-codex") as AuthCodeHandler;
+      const url = h.buildAuthUrl("http://localhost:9998/callback", "s", dummyPkce);
+      expect(url).toContain("auth.openai.com/oauth/authorize");
+      expect(url).toContain("codex_cli_simplified_flow=true");
+    });
+
+    it("google-gemini-cli builds Google auth URL", () => {
+      const h = getProviderHandler("google-gemini-cli") as AuthCodeHandler;
+      const url = h.buildAuthUrl("http://localhost:9998/callback", "s", dummyPkce);
+      expect(url).toContain("accounts.google.com");
+      expect(url).toContain("cloud-platform");
+      expect(url).toContain("access_type=offline");
+    });
+
+    it("google-antigravity builds Google auth URL with extra scopes", () => {
+      const h = getProviderHandler("google-antigravity") as AuthCodeHandler;
+      const url = h.buildAuthUrl("http://localhost:9998/callback", "s", dummyPkce);
+      expect(url).toContain("accounts.google.com");
+      expect(url).toContain("cclog");
+      expect(url).toContain("experimentsandconfigs");
+    });
+  });
+});