@blackbelt-technology/pi-agent-dashboard 0.2.9 → 0.4.0

package/packages/shared/src/__tests__/tool-registry-definitions.test.ts

@@ -0,0 +1,239 @@
+/**
+ * Tests for the standard tool definitions (strategies + registration).
+ *
+ * We inject fake `exists` / `which` / `npmRootGlobal` so tests are
+ * deterministic across platforms and don't depend on the test host's
+ * real filesystem or PATH.
+ */
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import os from "node:os";
+import {
+  ToolRegistry,
+  registerDefaultTools,
+  OverridesStore,
+} from "../tool-registry/index.js";
+
+function freshRegistry(opts: {
+  exists?: (p: string) => boolean;
+  which?: (name: string) => string | null;
+  npmRootGlobal?: () => string;
+  overrides?: Record<string, string>;
+  platform?: NodeJS.Platform;
+}) {
+  const store = new OverridesStore({
+    filePath: path.join(os.tmpdir(), `tool-registry-test-${Math.random()}.json`),
+    warn: () => {},
+  });
+  for (const [k, v] of Object.entries(opts.overrides ?? {})) store.set(k, v);
+
+  const r = new ToolRegistry({
+    overrides: store,
+    platform: opts.platform ?? "linux",
+  });
+  registerDefaultTools(r, {
+    exists: opts.exists ?? (() => false),
+    which: opts.which ?? (() => null),
+    npmRootGlobal: opts.npmRootGlobal ?? (() => ""),
+  });
+  return r;
+}
+
+describe("pi binary definition", () => {
+  it("chain order: override → managed → where", () => {
+    const r = freshRegistry({ which: (n) => (n === "pi" ? "/usr/bin/pi" : null) });
+    const res = r.resolve("pi");
+    expect(res.tried.map((t) => t.strategy)).toEqual([
+      "override",
+      "managed",
+      "where",
+    ]);
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe("/usr/bin/pi");
+    expect(res.source).toBe("system");
+  });
+
+  it("managed wins over system when MANAGED_BIN/pi exists", () => {
+    const managed = path.join(os.homedir(), ".pi-dashboard", "node_modules", ".bin", "pi");
+    const r = freshRegistry({
+      exists: (p) => p === managed,
+      which: () => "/usr/bin/pi",
+      platform: "linux",
+    });
+    const res = r.resolve("pi");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(managed);
+    expect(res.source).toBe("managed");
+  });
+
+  it("picks .cmd extension on Windows", () => {
+    const managed = path.join(os.homedir(), ".pi-dashboard", "node_modules", ".bin", "pi.cmd");
+    const r = freshRegistry({
+      exists: (p) => p === managed,
+      platform: "win32",
+    });
+    const res = r.resolve("pi");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(managed);
+  });
+
+  it("override wins when set and path exists", () => {
+    const custom = "/opt/custom/pi";
+    const r = freshRegistry({
+      overrides: { pi: custom },
+      exists: (p) => p === custom, // validate() passes
+    });
+    const res = r.resolve("pi");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(custom);
+    expect(res.source).toBe("override");
+  });
+
+  it("invalid override falls through to next strategy with 'invalid:' reason", () => {
+    const r = freshRegistry({
+      overrides: { pi: "/does/not/exist" },
+      which: () => "/usr/bin/pi",
+      exists: (p) => p === "/usr/bin/pi", // override path fails validate
+    });
+    const res = r.resolve("pi");
+    expect(res.ok).toBe(true);
+    expect(res.source).toBe("system");
+    expect(res.tried[0].strategy).toBe("override");
+    expect(res.tried[0].result).toMatch(/^invalid:/);
+  });
+});
+
+describe("pi-coding-agent module definition", () => {
+  it("probes both @mariozechner and @oh-my-pi alias names", () => {
+    const r = freshRegistry({ exists: () => false });
+    const res = r.resolve("pi-coding-agent");
+    const names = res.tried.map((t) => t.strategy);
+    // First strategy: override. Then two bare-import (one per alias),
+    // then two managed, then two npm-global.
+    expect(names[0]).toBe("override");
+    expect(names.filter((n) => n === "bare-import").length).toBe(2);
+    expect(names.filter((n) => n === "managed").length).toBe(2);
+    expect(names.filter((n) => n === "npm-global").length).toBe(2);
+  });
+
+  it("managed strategy hits ~/.pi-dashboard/node_modules/<pkg>/dist/index.js", () => {
+    const managed = path.join(
+      os.homedir(), ".pi-dashboard", "node_modules",
+      "@mariozechner", "pi-coding-agent", "dist", "index.js",
+    );
+    const r = freshRegistry({ exists: (p) => p === managed });
+    const res = r.resolve("pi-coding-agent");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(managed);
+    expect(res.source).toBe("managed");
+  });
+
+  it("npm-global strategy uses <npm root -g>/<pkg>/dist/index.js", () => {
+    const npmRoot = "/npm/global/root";
+    const entry = path.join(npmRoot, "@mariozechner", "pi-coding-agent", "dist", "index.js");
+    const r = freshRegistry({
+      exists: (p) => p === entry,
+      npmRootGlobal: () => npmRoot,
+    });
+    const res = r.resolve("pi-coding-agent");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(entry);
+    expect(res.source).toBe("npm-global");
+  });
+
+  it("fails cleanly when no strategy succeeds", () => {
+    const r = freshRegistry({
+      exists: () => false,
+      npmRootGlobal: () => "",
+    });
+    const res = r.resolve("pi-coding-agent");
+    expect(res.ok).toBe(false);
+    expect(res.path).toBeNull();
+    expect(res.source).toBeNull();
+    // Trail should include override + 2 bare-import + 2 managed + 2 npm-global.
+    expect(res.tried.length).toBeGreaterThanOrEqual(5);
+    expect(res.tried.some((t) => t.strategy === "npm-global")).toBe(true);
+  });
+});
+
+describe("openspec binary definition", () => {
+  it("finds openspec.cmd under managed bin on Windows", () => {
+    const managed = path.join(os.homedir(), ".pi-dashboard", "node_modules", ".bin", "openspec.cmd");
+    const r = freshRegistry({ exists: (p) => p === managed, platform: "win32" });
+    const res = r.resolve("openspec");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(managed);
+  });
+
+  it("falls through managed → where on Unix when managed is absent", () => {
+    const r = freshRegistry({
+      exists: () => false,
+      which: (n) => (n === "openspec" ? "/usr/local/bin/openspec" : null),
+      platform: "darwin",
+    });
+    const res = r.resolve("openspec");
+    expect(res.ok).toBe(true);
+    expect(res.source).toBe("system");
+    expect(res.path).toBe("/usr/local/bin/openspec");
+  });
+});
+
+describe("registered tool set", () => {
+  it("registers pi, pi-coding-agent, openspec, npm, node, git, zrok, wt", () => {
+    const r = freshRegistry({});
+    for (const name of ["pi", "pi-coding-agent", "openspec", "npm", "node", "git", "zrok", "wt"]) {
+      expect(r.has(name)).toBe(true);
+    }
+  });
+
+  it("wt resolves via where when found", () => {
+    const r = freshRegistry({
+      platform: "win32",
+      which: (name) => (name === "wt" ? "C:\\WindowsApps\\wt.exe" : null),
+    });
+    const res = r.resolve("wt");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe("C:\\WindowsApps\\wt.exe");
+    expect(res.source).toBe("system");
+  });
+
+  it("wt unavailable returns ok:false without error", () => {
+    const r = freshRegistry({ platform: "win32", which: () => null });
+    const res = r.resolve("wt");
+    expect(res.ok).toBe(false);
+  });
+
+  it("does NOT register tsx (it's a loader, not a spawn target)", () => {
+    const r = freshRegistry({});
+    expect(r.has("tsx")).toBe(false);
+  });
+
+  it("registers Windows-only process utilities on win32, NOT ps/pgrep", () => {
+    const r = freshRegistry({ platform: "win32" });
+    expect(r.has("tasklist")).toBe(true);
+    expect(r.has("taskkill")).toBe(true);
+    expect(r.has("wmic")).toBe(true);
+    expect(r.has("powershell")).toBe(true);
+    // ps/pgrep are POSIX-only; they'd always show "not found" on Windows
+    // and pollute the Tools UI with red rows the code never calls.
+    expect(r.has("ps")).toBe(false);
+    expect(r.has("pgrep")).toBe(false);
+  });
+
+  it("registers POSIX process utilities on linux/darwin, NOT tasklist etc.", () => {
+    for (const platform of ["linux", "darwin"] as NodeJS.Platform[]) {
+      const r = freshRegistry({ platform });
+      expect(r.has("ps")).toBe(true);
+      expect(r.has("pgrep")).toBe(true);
+      expect(r.has("tasklist")).toBe(false);
+      expect(r.has("taskkill")).toBe(false);
+      expect(r.has("wmic")).toBe(false);
+      expect(r.has("powershell")).toBe(false);
+    }
+  });
+
+  it("does NOT register pi-dashboard (it's the package this code is part of)", () => {
+    const r = freshRegistry({});
+    expect(r.has("pi-dashboard")).toBe(false);
+  });
+});

package/packages/shared/src/__tests__/tool-registry-overrides.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for OverridesStore (packages/shared/src/tool-registry/overrides.ts).
+ *
+ * Covered scenarios:
+ *   - Absent file → empty map
+ *   - Malformed file → warn + empty map
+ *   - set/clear round-trip with atomic write
+ *   - File schema shape (version + overrides[name].path)
+ *   - invalidate() forces reload from disk
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { OverridesStore } from "../tool-registry/overrides.js";
+
+function freshPath(): string {
+  return path.join(
+    os.tmpdir(),
+    `tool-overrides-unit-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`,
+  );
+}
+
+describe("OverridesStore.list", () => {
+  it("returns empty map when file is absent", () => {
+    const fp = freshPath();
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    expect(s.list()).toEqual({});
+    expect(fs.existsSync(fp)).toBe(false);
+  });
+
+  it("returns empty map and warns when file is malformed JSON", () => {
+    const fp = freshPath();
+    fs.writeFileSync(fp, "{ this is not json");
+    const warnings: string[] = [];
+    const s = new OverridesStore({ filePath: fp, warn: (m) => warnings.push(m) });
+    expect(s.list()).toEqual({});
+    expect(warnings.length).toBe(1);
+    expect(warnings[0]).toMatch(/failed to read/);
+    fs.unlinkSync(fp);
+  });
+
+  it("returns empty map when file has valid JSON but wrong schema", () => {
+    const fp = freshPath();
+    fs.writeFileSync(fp, JSON.stringify({ version: 1 })); // no overrides key
+    const warnings: string[] = [];
+    const s = new OverridesStore({ filePath: fp, warn: (m) => warnings.push(m) });
+    expect(s.list()).toEqual({});
+    expect(warnings[0]).toMatch(/malformed/);
+    fs.unlinkSync(fp);
+  });
+
+  it("skips individual entries with wrong shape but keeps well-formed ones", () => {
+    const fp = freshPath();
+    fs.writeFileSync(fp, JSON.stringify({
+      version: 1,
+      overrides: {
+        good: { path: "/x" },
+        bad1: "string not object",
+        bad2: { wrong: "field" },
+      },
+    }));
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    expect(s.list()).toEqual({ good: "/x" });
+    fs.unlinkSync(fp);
+  });
+});
+
+describe("OverridesStore.set / clear", () => {
+  let fp: string;
+  beforeEach(() => {
+    fp = freshPath();
+  });
+
+  it("set writes the file with the documented schema", () => {
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    s.set("pi", "/custom/pi");
+    const raw = fs.readFileSync(fp, "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed).toEqual({
+      version: 1,
+      overrides: { pi: { path: "/custom/pi" } },
+    });
+    fs.unlinkSync(fp);
+  });
+
+  it("set + list round-trips", () => {
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    s.set("pi", "/a");
+    s.set("openspec", "/b");
+    expect(s.list()).toEqual({ pi: "/a", openspec: "/b" });
+    fs.unlinkSync(fp);
+  });
+
+  it("clear removes an entry and persists", () => {
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    s.set("pi", "/a");
+    s.set("openspec", "/b");
+    s.clear("pi");
+    expect(s.list()).toEqual({ openspec: "/b" });
+    const parsed = JSON.parse(fs.readFileSync(fp, "utf-8"));
+    expect(parsed.overrides).toEqual({ openspec: { path: "/b" } });
+    fs.unlinkSync(fp);
+  });
+
+  it("clear is a no-op when the name is absent", () => {
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    s.clear("pi"); // nothing to clear; must not throw
+    expect(s.list()).toEqual({});
+    expect(fs.existsSync(fp)).toBe(false);
+  });
+
+  it("writes are atomic (tmp file renamed, not left behind)", () => {
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    s.set("pi", "/a");
+    expect(fs.existsSync(fp)).toBe(true);
+    expect(fs.existsSync(fp + ".tmp")).toBe(false);
+    fs.unlinkSync(fp);
+  });
+});
+
+describe("OverridesStore.invalidate", () => {
+  it("forces a reload from disk on next list()", () => {
+    const fp = freshPath();
+    fs.writeFileSync(fp, JSON.stringify({ version: 1, overrides: { pi: { path: "/a" } } }));
+    const s = new OverridesStore({ filePath: fp, warn: () => {} });
+    expect(s.list()).toEqual({ pi: "/a" });
+
+    // Mutate the file underneath.
+    fs.writeFileSync(fp, JSON.stringify({ version: 1, overrides: { pi: { path: "/b" } } }));
+    expect(s.list()).toEqual({ pi: "/a" }); // still cached
+
+    s.invalidate();
+    expect(s.list()).toEqual({ pi: "/b" }); // reloaded
+    fs.unlinkSync(fp);
+  });
+});