@blackbelt-technology/pi-agent-dashboard 0.5.3 → 0.5.4

package/packages/server/src/__tests__/bootstrap-install-from-list.test.ts

@@ -1,263 +0,0 @@
-/**
- * Integration tests for bootstrapInstallFromList.
- *
- * All file I/O and install calls are injected via opts so no real
- * filesystem or subprocesses are touched.
- *
- * See change: simplify-electron-bootstrap-derived-state.
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createBootstrapState } from "../bootstrap-state.js";
-import {
-  bootstrapInstallFromList,
-  type PackageInstaller,
-} from "../bootstrap-install-from-list.js";
-import type { InstallablePackage, InstallableList } from "@blackbelt-technology/pi-dashboard-shared/installable-list.js";
-
-// ── Helpers ────────────────────────────────────────────────────────────────
-
-function makePackage(overrides: Partial<InstallablePackage> = {}): InstallablePackage {
-  return {
-    name: "test-pkg",
-    version: "1.0.0",
-    required: true,
-    kind: "npm",
-    ...overrides,
-  };
-}
-
-function makeList(packages: InstallablePackage[]): InstallableList {
-  return { version: "1", packages };
-}
-
-/**
- * Build a `bootstrapInstallFromList` opts object that bypasses all real I/O.
- * - `listResult`: the installable list (null = file absent).
- * - `installedNames`: package names that are already installed.
- * - `npmInstall`/`piInstall`: injectable install fns (default: succeed).
- */
-interface FakeOpts {
-  listResult: InstallableList | null;
-  installedNames?: string[];
-  npmInstall?: PackageInstaller;
-  piInstall?: PackageInstaller;
-}
-
-function buildOpts(fake: FakeOpts, extra?: object) {
-  const installedSet = new Set(fake.installedNames ?? []);
-  return {
-    configDir: "/fake/config",
-    managedDir: "/fake/managed",
-    isInstalled: (pkg: InstallablePackage) => installedSet.has(pkg.name),
-    npmInstall: fake.npmInstall ?? (async () => { /* succeed */ }),
-    piInstall: fake.piInstall ?? (async () => { /* succeed */ }),
-    // Override readInstallableList via module mock — done per test via vi.mock
-    // (see below). We instead inject listResult via a wrapping helper.
-    ...extra,
-  };
-}
-
-// We cannot easily mock `readInstallableList` without vi.mock at module level.
-// Instead we factor out a testable inner function and re-export it.
-// Since we cannot easily mock the module import inside bootstrapInstallFromList,
-// we use a different approach: inject a `_readList` seam via opts.
-//
-// However, the current public API doesn't expose that seam. We'll test via
-// the observable side effects (bootstrap state + thrown errors) and fake the
-// injectable installers. For the list itself, we monkey-patch the module.
-//
-// Pragmatic solution: use vi.mock to replace readInstallableList.
-
-vi.mock("@blackbelt-technology/pi-dashboard-shared/installable-list.js", () => ({
-  readInstallableList: vi.fn(),
-}));
-
-import { readInstallableList } from "@blackbelt-technology/pi-dashboard-shared/installable-list.js";
-const mockReadList = vi.mocked(readInstallableList);
-
-// ── Tests ──────────────────────────────────────────────────────────────────
-
-describe("bootstrapInstallFromList", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // ── Test 1: no installable.json (Bridge/Standalone parity) ──────────────
-
-  describe("file-absent path", () => {
-    it("returns immediately without setting installable state or calling any installer", async () => {
-      mockReadList.mockResolvedValue(null);
-      const state = createBootstrapState();
-      const npmInstall = vi.fn();
-      const piInstall = vi.fn();
-
-      await bootstrapInstallFromList(state, {
-        configDir: "/fake/config",
-        managedDir: "/fake/managed",
-        npmInstall,
-        piInstall,
-        isInstalled: () => false,
-      });
-
-      // No installer calls.
-      expect(npmInstall).not.toHaveBeenCalled();
-      expect(piInstall).not.toHaveBeenCalled();
-
-      // installable field NOT set (file was absent — no tracking started).
-      expect(state.get().installable).toBeUndefined();
-
-      // Status remains ready.
-      expect(state.get().status).toBe("ready");
-    });
-  });
-
-  // ── Test 2: synthetic installable.json ──────────────────────────────────
-
-  describe("with installable.json present", () => {
-    it("skips already-installed npm package, installs missing required + optional, final state is correct", async () => {
-      const alreadyInstalled = makePackage({ name: "already-installed-pkg", required: false });
-      const missingRequired = makePackage({ name: "missing-required-pkg", required: true });
-      const missingOptional = makePackage({ name: "missing-optional-pkg", required: false });
-
-      mockReadList.mockResolvedValue(
-        makeList([alreadyInstalled, missingRequired, missingOptional]),
-      );
-
-      const state = createBootstrapState();
-      const npmInstall = vi.fn().mockResolvedValue(undefined);
-
-      await bootstrapInstallFromList(state, {
-        configDir: "/fake/config",
-        managedDir: "/fake/managed",
-        npmInstall,
-        piInstall: vi.fn(),
-        isInstalled: (pkg) => pkg.name === "already-installed-pkg",
-      });
-
-      // Two install calls (already-installed skipped).
-      expect(npmInstall).toHaveBeenCalledTimes(2);
-      expect(npmInstall.mock.calls[0][0].name).toBe("missing-required-pkg");
-      expect(npmInstall.mock.calls[1][0].name).toBe("missing-optional-pkg");
-
-      // Final state: installed=3 (1 pre-installed + 2 freshly installed), failed=0.
-      const installable = state.get().installable;
-      expect(installable).toBeDefined();
-      expect(installable!.total).toBe(3);
-      expect(installable!.installed).toBe(3);
-      expect(installable!.failed).toHaveLength(0);
-
-      // Status remains ready (no error).
-      expect(state.get().status).toBe("ready");
-    });
-
-    it("installs pi-extension packages via piInstall", async () => {
-      const pkg = makePackage({ name: "my-extension", kind: "pi-extension", required: true });
-      mockReadList.mockResolvedValue(makeList([pkg]));
-
-      const state = createBootstrapState();
-      const piInstall = vi.fn().mockResolvedValue(undefined);
-      const npmInstall = vi.fn();
-
-      await bootstrapInstallFromList(state, {
-        configDir: "/fake/config",
-        managedDir: "/fake/managed",
-        npmInstall,
-        piInstall,
-        isInstalled: () => false,
-      });
-
-      expect(piInstall).toHaveBeenCalledOnce();
-      expect(npmInstall).not.toHaveBeenCalled();
-      expect(piInstall.mock.calls[0][0].name).toBe("my-extension");
-    });
-
-    it("optional package failure is recorded in failed[] but does not throw", async () => {
-      const optionalFail = makePackage({ name: "optional-bad", required: false });
-      mockReadList.mockResolvedValue(makeList([optionalFail]));
-
-      const state = createBootstrapState();
-      const npmInstall = vi.fn().mockRejectedValue(new Error("network error"));
-
-      await expect(
-        bootstrapInstallFromList(state, {
-          configDir: "/fake/config",
-          managedDir: "/fake/managed",
-          npmInstall,
-          piInstall: vi.fn(),
-          isInstalled: () => false,
-        }),
-      ).resolves.toBeUndefined();
-
-      const installable = state.get().installable;
-      expect(installable!.failed).toEqual(["optional-bad"]);
-      expect(installable!.installed).toBe(0);
-      expect(state.get().status).toBe("ready");
-    });
-
-    it("required package failure sets status=failed and throws", async () => {
-      const requiredFail = makePackage({ name: "required-bad", required: true });
-      mockReadList.mockResolvedValue(makeList([requiredFail]));
-
-      const state = createBootstrapState();
-      const npmInstall = vi.fn().mockRejectedValue(new Error("disk full"));
-
-      await expect(
-        bootstrapInstallFromList(state, {
-          configDir: "/fake/config",
-          managedDir: "/fake/managed",
-          npmInstall,
-          piInstall: vi.fn(),
-          isInstalled: () => false,
-        }),
-      ).rejects.toThrow('Required package "required-bad" failed to install');
-
-      expect(state.get().status).toBe("failed");
-      expect(state.get().error?.message).toContain("required-bad");
-    });
-
-    it("deprecated and defaultOff packages are skipped entirely", async () => {
-      const deprecated = makePackage({ name: "old-pkg", deprecated: true });
-      const defaultOff = makePackage({ name: "opt-pkg", defaultOff: true });
-      const normal = makePackage({ name: "normal-pkg", required: true });
-      mockReadList.mockResolvedValue(makeList([deprecated, defaultOff, normal]));
-
-      const state = createBootstrapState();
-      const npmInstall = vi.fn().mockResolvedValue(undefined);
-
-      await bootstrapInstallFromList(state, {
-        configDir: "/fake/config",
-        managedDir: "/fake/managed",
-        npmInstall,
-        piInstall: vi.fn(),
-        isInstalled: () => false,
-      });
-
-      // Only "normal-pkg" is processed (total=1, not 3).
-      expect(npmInstall).toHaveBeenCalledOnce();
-      expect(state.get().installable!.total).toBe(1);
-    });
-
-    it("emits progress steps during install", async () => {
-      const pkg = makePackage({ name: "tracked-pkg" });
-      mockReadList.mockResolvedValue(makeList([pkg]));
-
-      const state = createBootstrapState();
-      const progressSteps: string[] = [];
-      state.subscribe((s) => {
-        if (s.progress) progressSteps.push(s.progress.step);
-      });
-
-      const npmInstall = vi.fn().mockResolvedValue(undefined);
-
-      await bootstrapInstallFromList(state, {
-        configDir: "/fake/config",
-        managedDir: "/fake/managed",
-        npmInstall,
-        piInstall: vi.fn(),
-        isInstalled: () => false,
-      });
-
-      expect(progressSteps).toContain("tracked-pkg");
-    });
-  });
-});

package/packages/server/src/__tests__/bootstrap-queue.test.ts

@@ -1,120 +0,0 @@
-/**
- * Unit tests for the in-memory bootstrap ticket queue.
- *
- * See change: unified-bootstrap-install.
- */
-import { describe, it, expect } from "vitest";
-import { createBootstrapQueue } from "../bootstrap-queue.js";
-
-describe("bootstrap-queue", () => {
-  it("enqueue returns a unique ticketId + pending result", () => {
-    const q = createBootstrapQueue();
-    const a = q.enqueue(async () => "A");
-    const b = q.enqueue(async () => "B");
-    expect(a.ticketId).not.toBe(b.ticketId);
-    expect(q.size()).toBe(2);
-  });
-
-  it("flushAll runs handlers in enqueue order and resolves results", async () => {
-    const q = createBootstrapQueue();
-    const order: string[] = [];
-    const a = q.enqueue(async () => {
-      order.push("a");
-      return "A";
-    });
-    const b = q.enqueue(async () => {
-      order.push("b");
-      return "B";
-    });
-    await q.flushAll();
-    expect(order).toEqual(["a", "b"]);
-    await expect(a.result).resolves.toBe("A");
-    await expect(b.result).resolves.toBe("B");
-    expect(q.size()).toBe(0);
-  });
-
-  it("handler exceptions reject the ticket promise", async () => {
-    const q = createBootstrapQueue();
-    const t = q.enqueue(async () => {
-      throw new Error("boom");
-    });
-    await q.flushAll();
-    await expect(t.result).rejects.toThrow("boom");
-  });
-
-  it("onTicketComplete fires success=true for resolved handlers", async () => {
-    const q = createBootstrapQueue();
-    const events: Array<{ ticketId: string; success: boolean; error?: string }> = [];
-    q.onTicketComplete((e) => events.push(e));
-    const t = q.enqueue(async () => 42);
-    await q.flushAll();
-    await t.result;
-    expect(events).toEqual([{ ticketId: t.ticketId, success: true }]);
-  });
-
-  it("onTicketComplete fires success=false with error message on rejection", async () => {
-    const q = createBootstrapQueue();
-    const events: Array<{ ticketId: string; success: boolean; error?: string }> = [];
-    q.onTicketComplete((e) => events.push(e));
-    const t = q.enqueue(async () => {
-      throw new Error("oh no");
-    });
-    await q.flushAll();
-    await t.result.catch(() => undefined);
-    expect(events).toEqual([
-      { ticketId: t.ticketId, success: false, error: "oh no" },
-    ]);
-  });
-
-  it("onTicketComplete returns an unsubscribe function", async () => {
-    const q = createBootstrapQueue();
-    const events: unknown[] = [];
-    const off = q.onTicketComplete((e) => events.push(e));
-    off();
-    q.enqueue(async () => "x");
-    await q.flushAll();
-    expect(events).toEqual([]);
-  });
-
-  it("clear drops pending tickets with an error result and broadcasts completion", async () => {
-    const q = createBootstrapQueue();
-    const events: Array<{ ticketId: string; success: boolean; error?: string }> = [];
-    q.onTicketComplete((e) => events.push(e));
-    const t = q.enqueue(async () => "never runs");
-    q.clear("server shutting down");
-    await t.result.catch(() => undefined);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
-      ticketId: t.ticketId,
-      success: false,
-      error: "server shutting down",
-    });
-    expect(q.size()).toBe(0);
-  });
-
-  it("multiple listeners all receive the completion event", async () => {
-    const q = createBootstrapQueue();
-    const a: unknown[] = [];
-    const b: unknown[] = [];
-    q.onTicketComplete((e) => a.push(e));
-    q.onTicketComplete((e) => b.push(e));
-    const t = q.enqueue(async () => "ok");
-    await q.flushAll();
-    await t.result;
-    expect(a).toHaveLength(1);
-    expect(b).toHaveLength(1);
-  });
-
-  it("a listener that throws does not block other listeners", async () => {
-    const q = createBootstrapQueue();
-    const seen: unknown[] = [];
-    q.onTicketComplete(() => {
-      throw new Error("listener crash");
-    });
-    q.onTicketComplete((e) => seen.push(e));
-    const t = q.enqueue(async () => "ok");
-    await q.flushAll();
-    await t.result;
-    expect(seen).toHaveLength(1);
-  });
-});

package/packages/server/src/__tests__/bootstrap-routes.test.ts

@@ -1,125 +0,0 @@
-/**
- * Route tests for `/api/bootstrap/*`.
- *
- * Spins up a minimal Fastify instance with the bootstrap routes wired
- * to a fresh state store and a pair of spy triggers. No real network
- * access, no real subprocesses.
- *
- * See change: unified-bootstrap-install.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Fastify, { type FastifyInstance } from "fastify";
-import { createBootstrapState, type BootstrapStateStore } from "../bootstrap-state.js";
-import { registerBootstrapRoutes } from "../routes/bootstrap-routes.js";
-
-const noopGuard = async () => {
-  /* allow all requests in tests */
-};
-
-interface Harness {
-  app: FastifyInstance;
-  state: BootstrapStateStore;
-  upgradeCalls: string[];
-  retryCalls: string[];
-}
-
-async function makeHarness(): Promise<Harness> {
-  const app = Fastify({ logger: false });
-  const state = createBootstrapState();
-  const upgradeCalls: string[] = [];
-  const retryCalls: string[] = [];
-
-  registerBootstrapRoutes(app, {
-    bootstrapState: state,
-    networkGuard: noopGuard,
-    triggerUpgradePi: async (ticketId) => {
-      upgradeCalls.push(ticketId);
-    },
-    triggerRetry: async (ticketId) => {
-      retryCalls.push(ticketId);
-    },
-  });
-
-  await app.ready();
-  return { app, state, upgradeCalls, retryCalls };
-}
-
-describe("bootstrap-routes", () => {
-  let h: Harness;
-
-  beforeEach(async () => {
-    h = await makeHarness();
-  });
-
-  afterEach(async () => {
-    await h.app.close();
-  });
-
-  describe("GET /api/bootstrap/status", () => {
-    it("returns the current state (default ready)", async () => {
-      const res = await h.app.inject({ method: "GET", url: "/api/bootstrap/status" });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual({ status: "ready" });
-    });
-
-    it("reflects subsequent state changes", async () => {
-      h.state.set({ status: "installing", progress: { step: "pi" } });
-      const res = await h.app.inject({ method: "GET", url: "/api/bootstrap/status" });
-      expect(res.json()).toMatchObject({
-        status: "installing",
-        progress: { step: "pi" },
-      });
-    });
-  });
-
-  describe("POST /api/bootstrap/upgrade-pi", () => {
-    it("returns 202 with a ticketId and invokes the trigger", async () => {
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/upgrade-pi" });
-      expect(res.statusCode).toBe(202);
-      const body = res.json() as { ticketId: string; status: string };
-      expect(body.status).toBe("accepted");
-      expect(typeof body.ticketId).toBe("string");
-      expect(body.ticketId.length).toBeGreaterThan(0);
-      // Trigger runs async — await a microtask.
-      await new Promise((r) => setImmediate(r));
-      expect(h.upgradeCalls).toEqual([body.ticketId]);
-    });
-
-    it("returns 409 when an install is already in progress", async () => {
-      h.state.set({ status: "installing" });
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/upgrade-pi" });
-      expect(res.statusCode).toBe(409);
-      expect(h.upgradeCalls).toEqual([]);
-    });
-
-    it("is allowed when status is failed (to upgrade after a previous failure)", async () => {
-      h.state.set({ status: "failed", error: { message: "network" } });
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/upgrade-pi" });
-      expect(res.statusCode).toBe(202);
-    });
-  });
-
-  describe("POST /api/bootstrap/retry", () => {
-    it("returns 409 when status is ready", async () => {
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/retry" });
-      expect(res.statusCode).toBe(409);
-      expect(h.retryCalls).toEqual([]);
-    });
-
-    it("returns 409 when status is installing", async () => {
-      h.state.set({ status: "installing" });
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/retry" });
-      expect(res.statusCode).toBe(409);
-      expect(h.retryCalls).toEqual([]);
-    });
-
-    it("returns 202 when status is failed and invokes the trigger", async () => {
-      h.state.set({ status: "failed", error: { message: "network" } });
-      const res = await h.app.inject({ method: "POST", url: "/api/bootstrap/retry" });
-      expect(res.statusCode).toBe(202);
-      const body = res.json() as { ticketId: string };
-      await new Promise((r) => setImmediate(r));
-      expect(h.retryCalls).toEqual([body.ticketId]);
-    });
-  });
-});

package/packages/server/src/__tests__/bootstrap-state.test.ts

@@ -1,119 +0,0 @@
-/**
- * Unit tests for the in-memory bootstrap state store.
- *
- * See change: unified-bootstrap-install.
- */
-import { describe, it, expect } from "vitest";
-import { createBootstrapState } from "../bootstrap-state.js";
-
-describe("bootstrap-state", () => {
-  it("defaults to status=ready", () => {
-    const s = createBootstrapState();
-    expect(s.get()).toEqual({ status: "ready" });
-  });
-
-  it("applies initial overrides", () => {
-    const s = createBootstrapState({
-      status: "installing",
-      progress: { step: "pi", output: "starting" },
-    });
-    const state = s.get();
-    expect(state.status).toBe("installing");
-    expect(state.progress).toEqual({ step: "pi", output: "starting" });
-  });
-
-  it("set merges partial into state", () => {
-    const s = createBootstrapState();
-    s.set({ status: "installing", progress: { step: "pi" } });
-    expect(s.get().status).toBe("installing");
-    s.set({ progress: { step: "openspec" } });
-    expect(s.get().progress).toEqual({ step: "openspec" });
-    expect(s.get().status).toBe("installing");
-  });
-
-  it("set with undefined explicitly clears a key", () => {
-    const s = createBootstrapState({ progress: { step: "pi" } });
-    expect(s.get().progress).toBeDefined();
-    s.set({ progress: undefined });
-    expect(s.get().progress).toBeUndefined();
-  });
-
-  it("notifies subscribers on set", () => {
-    const s = createBootstrapState();
-    const calls: string[] = [];
-    s.subscribe((st) => calls.push(st.status));
-    s.set({ status: "installing" });
-    s.set({ status: "ready" });
-    expect(calls).toEqual(["installing", "ready"]);
-  });
-
-  it("subscribe returns an unsubscribe function", () => {
-    const s = createBootstrapState();
-    const calls: string[] = [];
-    const off = s.subscribe((st) => calls.push(st.status));
-    s.set({ status: "installing" });
-    off();
-    s.set({ status: "ready" });
-    expect(calls).toEqual(["installing"]);
-  });
-
-  it("listener errors do not stop other listeners", () => {
-    const s = createBootstrapState();
-    const calls: string[] = [];
-    s.subscribe(() => {
-      throw new Error("boom");
-    });
-    s.subscribe((st) => calls.push(st.status));
-    s.set({ status: "installing" });
-    expect(calls).toEqual(["installing"]);
-  });
-
-  it("dispose clears all listeners", () => {
-    const s = createBootstrapState();
-    const calls: string[] = [];
-    s.subscribe((st) => calls.push(st.status));
-    s.dispose();
-    s.set({ status: "installing" });
-    expect(calls).toEqual([]);
-  });
-
-  it("get returns a fresh snapshot (external mutation does not affect store)", () => {
-    const s = createBootstrapState({ progress: { step: "pi" } });
-    const snap = s.get();
-    snap.status = "failed";
-    expect(s.get().status).toBe("ready");
-  });
-
-  describe("lastInstallPackages", () => {
-    it("defaults to an empty array", () => {
-      const s = createBootstrapState();
-      expect(s.getLastInstallPackages()).toEqual([]);
-    });
-
-    it("records and returns a fresh copy", () => {
-      const s = createBootstrapState();
-      s.setLastInstallPackages(["pi", "openspec"]);
-      const got = s.getLastInstallPackages();
-      expect(got).toEqual(["pi", "openspec"]);
-      // External mutation does not affect the stored value.
-      got.push("tsx");
-      expect(s.getLastInstallPackages()).toEqual(["pi", "openspec"]);
-    });
-
-    it("accepts a readonly input without type error", () => {
-      const s = createBootstrapState();
-      const readonlyInput: readonly string[] = ["a", "b"];
-      s.setLastInstallPackages(readonlyInput);
-      expect(s.getLastInstallPackages()).toEqual(["a", "b"]);
-    });
-
-    it("is independent of status broadcast (not part of snapshot)", () => {
-      const s = createBootstrapState();
-      const seen: string[] = [];
-      s.subscribe((st) => seen.push(st.status));
-      s.setLastInstallPackages(["pi"]);
-      // setLastInstallPackages MUST NOT trigger a listener.
-      expect(seen).toEqual([]);
-    });
-  });
-});

package/packages/server/src/__tests__/cli-bootstrap.test.ts

@@ -1,36 +0,0 @@
-/**
- * Regression test: the local `registry.rescan(...)` call in
- * `packages/server/src/cli.ts` was removed and ownership of the
- * post-install rescan moved to the centralized
- * `bootstrapState.subscribe` hook in `server.ts`.
- *
- * This test reads `cli.ts` as text and asserts no direct rescan call
- * remains, plus a forwarding comment is present.
- *
- * See change: fix-openspec-buttons-after-bootstrap-install.
- */
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const cliPath = path.resolve(here, "..", "cli.ts");
-
-describe("cli.ts post-install rescan ownership", () => {
-  const source = readFileSync(cliPath, "utf8");
-
-  it("does not contain a direct registry.rescan(...) call", () => {
-    // Allow comments mentioning rescan, but disallow real call expressions.
-    // Strip line comments and block comments first.
-    const stripped = source
-      .replace(/\/\/[^\n]*/g, "")
-      .replace(/\/\*[\s\S]*?\*\//g, "");
-    expect(stripped).not.toMatch(/\.rescan\s*\(/);
-    expect(stripped).not.toMatch(/\bRescannable\b/);
-  });
-
-  it("contains a comment forwarding to the centralized server.ts hook", () => {
-    expect(source).toMatch(/fix-openspec-buttons-after-bootstrap-install/);
-  });
-});