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

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

@@ -1,55 +0,0 @@
-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__/legacy-pi-cleanup.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import {
-  parseVersion,
-  legacyPathUnder,
-  detectLegacyPiInstalls,
-  uninstallLegacyPi,
-  LEGACY_PI_PACKAGE,
-  type LegacyPiInstall,
-} from "../legacy-pi-cleanup.js";
-
-describe("parseVersion", () => {
-  it("returns version from valid json", () => {
-    expect(parseVersion('{"name":"x","version":"1.2.3"}')).toBe("1.2.3");
-  });
-  it("returns null on parse error", () => {
-    expect(parseVersion("not json")).toBeNull();
-  });
-  it("returns null when version missing", () => {
-    expect(parseVersion('{"name":"x"}')).toBeNull();
-  });
-});
-
-describe("legacyPathUnder", () => {
-  it("joins node_modules with legacy package", () => {
-    const p = legacyPathUnder("/tmp/nm");
-    expect(p.endsWith(path.join("@mariozechner", "pi-coding-agent"))).toBe(true);
-  });
-});
-
-describe("detectLegacyPiInstalls (filesystem)", () => {
-  let tmpHome: string;
-  let origHome: string | undefined;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "legacy-pi-test-"));
-    origHome = process.env.HOME;
-    process.env.HOME = tmpHome;
-  });
-
-  afterEach(() => {
-    if (origHome !== undefined) process.env.HOME = origHome;
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  function plantLegacy(scopeDir: string, version: string): string {
-    const pkgDir = path.join(scopeDir, ...LEGACY_PI_PACKAGE.split("/"));
-    fs.mkdirSync(pkgDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(pkgDir, "package.json"),
-      JSON.stringify({ name: LEGACY_PI_PACKAGE, version }),
-    );
-    return pkgDir;
-  }
-
-  it("returns empty when nothing planted", () => {
-    // Note: this still consults `npm root -g` from the real system; if that
-    // happens to contain @mariozechner/pi-coding-agent the test would
-    // see it. We accept that and only assert npx-cache + managed are empty.
-    const found = detectLegacyPiInstalls();
-    expect(found.filter((f) => f.scope !== "npm-global")).toEqual([]);
-  });
-
-  it("detects npx-cache install", () => {
-    plantLegacy(path.join(tmpHome, ".npm", "_npx", "abc123", "node_modules"), "0.73.1");
-    const found = detectLegacyPiInstalls().filter((f) => f.scope === "npx-cache");
-    expect(found).toHaveLength(1);
-    expect(found[0].version).toBe("0.73.1");
-  });
-
-  it("detects managed install", () => {
-    plantLegacy(path.join(tmpHome, ".pi-dashboard", "node_modules"), "0.70.0");
-    const found = detectLegacyPiInstalls().filter((f) => f.scope === "managed");
-    expect(found).toHaveLength(1);
-    expect(found[0].version).toBe("0.70.0");
-  });
-
-  it("detects multiple npx-cache installs", () => {
-    plantLegacy(path.join(tmpHome, ".npm", "_npx", "h1", "node_modules"), "0.72.0");
-    plantLegacy(path.join(tmpHome, ".npm", "_npx", "h2", "node_modules"), "0.73.0");
-    const found = detectLegacyPiInstalls().filter((f) => f.scope === "npx-cache");
-    expect(found).toHaveLength(2);
-    expect(found.map((f) => f.version).sort()).toEqual(["0.72.0", "0.73.0"]);
-  });
-});
-
-describe("uninstallLegacyPi (filesystem subset)", () => {
-  let tmpHome: string;
-  let origHome: string | undefined;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "legacy-pi-rm-test-"));
-    origHome = process.env.HOME;
-    process.env.HOME = tmpHome;
-  });
-
-  afterEach(() => {
-    if (origHome !== undefined) process.env.HOME = origHome;
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  function plant(scope: "managed" | "npx-cache", version: string): LegacyPiInstall {
-    const base =
-      scope === "managed"
-        ? path.join(tmpHome, ".pi-dashboard", "node_modules")
-        : path.join(tmpHome, ".npm", "_npx", "x1", "node_modules");
-    const pkgDir = path.join(base, ...LEGACY_PI_PACKAGE.split("/"));
-    fs.mkdirSync(pkgDir, { recursive: true });
-    fs.writeFileSync(path.join(pkgDir, "package.json"), JSON.stringify({ version }));
-    return { scope, path: pkgDir, version };
-  }
-
-  it("removes managed install via rm -rf", () => {
-    const install = plant("managed", "0.70.0");
-    expect(fs.existsSync(install.path)).toBe(true);
-    const results = uninstallLegacyPi([install]);
-    expect(results[0]).toEqual({ scope: "managed", path: install.path, removed: true });
-    expect(fs.existsSync(install.path)).toBe(false);
-  });
-
-  it("removes npx-cache install via rm -rf", () => {
-    const install = plant("npx-cache", "0.73.1");
-    const results = uninstallLegacyPi([install]);
-    expect(results[0].removed).toBe(true);
-    expect(fs.existsSync(install.path)).toBe(false);
-  });
-
-  it("returns error result when path does not exist (rm force suppresses, returns removed=true)", () => {
-    // fs.rmSync with force:true treats missing paths as success.
-    const install: LegacyPiInstall = {
-      scope: "managed",
-      path: path.join(tmpHome, "does-not-exist"),
-      version: null,
-    };
-    const results = uninstallLegacyPi([install]);
-    expect(results[0].removed).toBe(true);
-  });
-
-  it("processes multiple installs independently", () => {
-    const a = plant("managed", "0.70.0");
-    const b = plant("npx-cache", "0.73.0");
-    const results = uninstallLegacyPi([a, b]);
-    expect(results.every((r) => r.removed)).toBe(true);
-    expect(fs.existsSync(a.path)).toBe(false);
-    expect(fs.existsSync(b.path)).toBe(false);
-  });
-});

package/packages/server/src/__tests__/post-install-openspec-refresh.test.ts

@@ -1,180 +0,0 @@
-/**
- * Unit tests for the post-install OpenSpec + pi-resources force-refresh
- * portion of `runPostInstallRepair`.
- *
- * See change: fix-openspec-buttons-after-bootstrap-install.
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { runPostInstallRepair } from "../server.js";
-
-interface SpyRegistry { rescan: ReturnType<typeof vi.fn>; }
-interface SpyDirSvc {
-  knownDirectories: ReturnType<typeof vi.fn>;
-  getOpenSpecData: ReturnType<typeof vi.fn>;
-  refreshOpenSpec: ReturnType<typeof vi.fn>;
-  refreshPiResources: ReturnType<typeof vi.fn>;
-}
-interface SpyGateway { broadcastToAll: ReturnType<typeof vi.fn>; }
-
-function makeRegistry(): SpyRegistry { return { rescan: vi.fn() }; }
-function makeGateway(): SpyGateway { return { broadcastToAll: vi.fn() }; }
-
-describe("runPostInstallRepair: openspec + pi-resources refresh", () => {
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-  });
-
-  it("calls refreshOpenSpec(cwd) once for every known directory", async () => {
-    const registry = makeRegistry();
-    const cwds = ["/p1", "/p2", "/p3"];
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => cwds),
-      getOpenSpecData: vi.fn(() => ({ initialized: false, changes: [] })),
-      refreshOpenSpec: vi.fn(async () => ({ initialized: true, changes: [{ name: "x" } as never] })),
-      refreshPiResources: vi.fn(async () => ({})),
-    };
-    const browserGateway = makeGateway();
-
-    await runPostInstallRepair({
-      registry: registry as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-
-    expect(directoryService.refreshOpenSpec).toHaveBeenCalledTimes(3);
-    expect(directoryService.refreshOpenSpec).toHaveBeenNthCalledWith(1, "/p1");
-    expect(directoryService.refreshOpenSpec).toHaveBeenNthCalledWith(2, "/p2");
-    expect(directoryService.refreshOpenSpec).toHaveBeenNthCalledWith(3, "/p3");
-  });
-
-  it("broadcasts openspec_update for each cwd whose prior cache was empty/undefined", async () => {
-    const cwds = ["/a", "/b"];
-    const fresh = { initialized: true, changes: [{ name: "c1" } as never] };
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => cwds),
-      // Prior was undefined for /a, empty for /b — both should broadcast.
-      getOpenSpecData: vi.fn((cwd: string) =>
-        cwd === "/a" ? undefined : { initialized: false, changes: [] }
-      ),
-      refreshOpenSpec: vi.fn(async () => fresh),
-      refreshPiResources: vi.fn(async () => ({})),
-    };
-    const browserGateway = makeGateway();
-
-    await runPostInstallRepair({
-      registry: makeRegistry() as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-
-    const broadcasts = browserGateway.broadcastToAll.mock.calls
-      .map((c: unknown[]) => c[0])
-      .filter((m: any) => m?.type === "openspec_update");
-    expect(broadcasts).toHaveLength(2);
-    expect(broadcasts).toContainEqual({ type: "openspec_update", cwd: "/a", data: fresh });
-    expect(broadcasts).toContainEqual({ type: "openspec_update", cwd: "/b", data: fresh });
-  });
-
-  it("does not broadcast openspec_update when refreshed data equals prior data", async () => {
-    const same = { initialized: true, changes: [{ name: "stable" } as never] };
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => ["/p"]),
-      getOpenSpecData: vi.fn(() => same),
-      refreshOpenSpec: vi.fn(async () => same),
-      refreshPiResources: vi.fn(async () => ({})),
-    };
-    const browserGateway = makeGateway();
-
-    await runPostInstallRepair({
-      registry: makeRegistry() as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-
-    const broadcasts = browserGateway.broadcastToAll.mock.calls
-      .map((c: unknown[]) => c[0])
-      .filter((m: any) => m?.type === "openspec_update");
-    expect(broadcasts).toHaveLength(0);
-  });
-
-  it("isolates a per-cwd refresh failure — the other cwd still refreshes and broadcasts", async () => {
-    const cwds = ["/good", "/bad"];
-    const fresh = { initialized: true, changes: [{ name: "ok" } as never] };
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => cwds),
-      getOpenSpecData: vi.fn(() => undefined),
-      refreshOpenSpec: vi.fn(async (cwd: string) => {
-        if (cwd === "/bad") throw new Error("boom");
-        return fresh;
-      }),
-      refreshPiResources: vi.fn(async () => ({})),
-    };
-    const browserGateway = makeGateway();
-
-    await runPostInstallRepair({
-      registry: makeRegistry() as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-
-    // Both cwds attempted.
-    expect(directoryService.refreshOpenSpec).toHaveBeenCalledTimes(2);
-    // Only the good one broadcasts.
-    const broadcasts = browserGateway.broadcastToAll.mock.calls
-      .map((c: unknown[]) => c[0])
-      .filter((m: any) => m?.type === "openspec_update" && m.cwd === "/good");
-    expect(broadcasts).toHaveLength(1);
-    // Failure was logged, not propagated.
-    expect(consoleErrorSpy).toHaveBeenCalled();
-  });
-
-  it("calls refreshPiResources(cwd) once for every known directory", async () => {
-    const cwds = ["/a", "/b", "/c"];
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => cwds),
-      getOpenSpecData: vi.fn(() => undefined),
-      refreshOpenSpec: vi.fn(async () => ({ initialized: false, changes: [] })),
-      refreshPiResources: vi.fn(async () => ({})),
-    };
-
-    await runPostInstallRepair({
-      registry: makeRegistry() as never,
-      directoryService: directoryService as never,
-      browserGateway: makeGateway() as never,
-    });
-
-    expect(directoryService.refreshPiResources).toHaveBeenCalledTimes(3);
-    expect(directoryService.refreshPiResources).toHaveBeenCalledWith("/a");
-    expect(directoryService.refreshPiResources).toHaveBeenCalledWith("/b");
-    expect(directoryService.refreshPiResources).toHaveBeenCalledWith("/c");
-  });
-
-  it("a refreshPiResources failure does not block other cwds or openspec broadcasts", async () => {
-    const cwds = ["/good", "/bad"];
-    const fresh = { initialized: true, changes: [{ name: "ok" } as never] };
-    const directoryService: SpyDirSvc = {
-      knownDirectories: vi.fn(() => cwds),
-      getOpenSpecData: vi.fn(() => undefined),
-      refreshOpenSpec: vi.fn(async () => fresh),
-      refreshPiResources: vi.fn(async (cwd: string) => {
-        if (cwd === "/bad") throw new Error("pi-resources blew up");
-        return {};
-      }),
-    };
-    const browserGateway = makeGateway();
-
-    await runPostInstallRepair({
-      registry: makeRegistry() as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-
-    expect(directoryService.refreshPiResources).toHaveBeenCalledTimes(2);
-    const openSpecBroadcasts = browserGateway.broadcastToAll.mock.calls
-      .map((c: unknown[]) => c[0])
-      .filter((m: any) => m?.type === "openspec_update");
-    expect(openSpecBroadcasts).toHaveLength(2);
-  });
-});

package/packages/server/src/__tests__/post-install-rescan.test.ts

@@ -1,134 +0,0 @@
-/**
- * Unit tests for the centralized post-install rescan hook.
- *
- * Asserts that the helper invoked from the bootstrap-state subscribe
- * callback calls `registry.rescan()` (no arg → full registry invalidate)
- * exactly once on `installing → ready` and never on other transitions.
- *
- * See change: fix-openspec-buttons-after-bootstrap-install.
- */
-import { describe, it, expect, vi } from "vitest";
-import { runPostInstallRepair, makeBootstrapTransitionHandler } from "../server.js";
-
-interface SpyRegistry {
-  rescan: ReturnType<typeof vi.fn>;
-}
-
-interface SpyDirSvc {
-  knownDirectories: ReturnType<typeof vi.fn>;
-  getOpenSpecData: ReturnType<typeof vi.fn>;
-  refreshOpenSpec: ReturnType<typeof vi.fn>;
-  refreshPiResources: ReturnType<typeof vi.fn>;
-}
-
-interface SpyGateway {
-  broadcastToAll: ReturnType<typeof vi.fn>;
-}
-
-function makeRegistry(): SpyRegistry {
-  return { rescan: vi.fn() };
-}
-
-function makeDirSvc(): SpyDirSvc {
-  return {
-    knownDirectories: vi.fn(() => []),
-    getOpenSpecData: vi.fn(() => undefined),
-    refreshOpenSpec: vi.fn(async () => ({ initialized: false, changes: [] })),
-    refreshPiResources: vi.fn(async () => ({ initialized: false, packages: [] })),
-  };
-}
-
-function makeGateway(): SpyGateway {
-  return { broadcastToAll: vi.fn() };
-}
-
-describe("runPostInstallRepair", () => {
-  it("calls registry.rescan() with no argument (full registry)", async () => {
-    const registry = makeRegistry();
-    const directoryService = makeDirSvc();
-    const browserGateway = makeGateway();
-    await runPostInstallRepair({
-      registry: registry as never,
-      directoryService: directoryService as never,
-      browserGateway: browserGateway as never,
-    });
-    expect(registry.rescan).toHaveBeenCalledTimes(1);
-    expect(registry.rescan).toHaveBeenCalledWith();
-  });
-});
-
-describe("makeBootstrapTransitionHandler", () => {
-  it("invokes the post-install repair exactly once on installing → ready", async () => {
-    const repair = vi.fn(async () => undefined);
-    const flushAll = vi.fn(async () => undefined);
-    const handler = makeBootstrapTransitionHandler({
-      onTransitionToReady: repair,
-      flushQueue: flushAll,
-    });
-    handler({ status: "installing" } as never);
-    handler({ status: "ready" } as never);
-    // Wait one microtask tick for the fire-and-forget to fire.
-    await Promise.resolve();
-    expect(repair).toHaveBeenCalledTimes(1);
-    expect(flushAll).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not call repair on ready → ready", async () => {
-    const repair = vi.fn(async () => undefined);
-    const flushAll = vi.fn(async () => undefined);
-    const handler = makeBootstrapTransitionHandler({
-      onTransitionToReady: repair,
-      flushQueue: flushAll,
-    });
-    // Initial state defaults to ready, so first ready-snapshot is a no-op.
-    handler({ status: "ready" } as never);
-    handler({ status: "ready" } as never);
-    await Promise.resolve();
-    expect(repair).not.toHaveBeenCalled();
-    expect(flushAll).not.toHaveBeenCalled();
-  });
-
-  it("does not call repair on installing → failed", async () => {
-    const repair = vi.fn(async () => undefined);
-    const flushAll = vi.fn(async () => undefined);
-    const handler = makeBootstrapTransitionHandler({
-      onTransitionToReady: repair,
-      flushQueue: flushAll,
-    });
-    handler({ status: "installing" } as never);
-    handler({ status: "failed" } as never);
-    await Promise.resolve();
-    expect(repair).not.toHaveBeenCalled();
-    expect(flushAll).not.toHaveBeenCalled();
-  });
-
-  it("does not call repair on the very first subscribe snapshot", async () => {
-    // Bootstrap state defaults to "ready"; the first emitted snapshot
-    // (e.g. from an immediate broadcast) should NOT trigger the hook.
-    const repair = vi.fn(async () => undefined);
-    const flushAll = vi.fn(async () => undefined);
-    const handler = makeBootstrapTransitionHandler({
-      onTransitionToReady: repair,
-      flushQueue: flushAll,
-    });
-    handler({ status: "ready" } as never);
-    await Promise.resolve();
-    expect(repair).not.toHaveBeenCalled();
-  });
-
-  it("calls repair on a second installing → ready cycle (e.g. user retry)", async () => {
-    const repair = vi.fn(async () => undefined);
-    const flushAll = vi.fn(async () => undefined);
-    const handler = makeBootstrapTransitionHandler({
-      onTransitionToReady: repair,
-      flushQueue: flushAll,
-    });
-    handler({ status: "installing" } as never);
-    handler({ status: "ready" } as never);
-    handler({ status: "installing" } as never);
-    handler({ status: "ready" } as never);
-    await Promise.resolve();
-    expect(repair).toHaveBeenCalledTimes(2);
-    expect(flushAll).toHaveBeenCalledTimes(2);
-  });
-});

package/packages/server/src/__tests__/system-routes-reextract.test.ts

@@ -1,91 +0,0 @@
-/**
- * Tests for POST /api/electron/reextract
- * See change: simplify-electron-bootstrap-derived-state (task 6.4 / 6.9).
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Fastify, { type FastifyInstance } from "fastify";
-import { registerSystemRoutes } from "../routes/system-routes.js";
-import type { BootstrapStateStore, BootstrapState } from "../bootstrap-state.js";
-
-function noGuard() {
-  return async () => { /* allow all */ };
-}
-
-function makeBootstrapState(starter: string): BootstrapStateStore {
-  return {
-    get: () => ({
-      status: "ready",
-      starter: starter as any,
-      installable: { total: 0, installed: 0, failed: [] },
-    } as BootstrapState),
-    set: () => {},
-    subscribe: () => () => {},
-  } as unknown as BootstrapStateStore;
-}
-
-function makeNoopDeps(bootstrapState?: BootstrapStateStore) {
-  return {
-    sessionManager: { listActive: () => [], listAll: () => [] } as never,
-    preferencesStore: { flush: () => {} } as never,
-    metaPersistence: { flushAll: () => {} } as never,
-    config: { port: 8000, piPort: 9999, dev: false } as never,
-    networkGuard: noGuard(),
-    bootstrapState,
-  };
-}
-
-describe("POST /api/electron/reextract", () => {
-  let fastify: FastifyInstance;
-
-  beforeEach(async () => {
-    fastify = Fastify();
-  });
-
-  afterEach(async () => {
-    await fastify.close();
-  });
-
-  it("returns 403 when starter is Bridge", async () => {
-    const deps = makeNoopDeps(makeBootstrapState("Bridge"));
-    registerSystemRoutes(fastify, deps);
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
-    expect(res.statusCode).toBe(403);
-    const body = res.json() as Record<string, unknown>;
-    expect(body.error).toBe("reextract_not_allowed");
-    expect(body.starter).toBe("Bridge");
-  });
-
-  it("returns 403 when starter is Standalone", async () => {
-    const deps = makeNoopDeps(makeBootstrapState("Standalone"));
-    registerSystemRoutes(fastify, deps);
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
-    expect(res.statusCode).toBe(403);
-    const body = res.json() as Record<string, unknown>;
-    expect(body.error).toBe("reextract_not_allowed");
-    expect(body.starter).toBe("Standalone");
-  });
-
-  it("returns 202 when starter is Electron", async () => {
-    const deps = makeNoopDeps(makeBootstrapState("Electron"));
-    registerSystemRoutes(fastify, deps);
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
-    expect(res.statusCode).toBe(202);
-    const body = res.json() as Record<string, unknown>;
-    expect(body.ok).toBe(true);
-  });
-
-  it("returns 403 when no bootstrapState (defaults to Standalone)", async () => {
-    const deps = makeNoopDeps(undefined);
-    registerSystemRoutes(fastify, deps);
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
-    expect(res.statusCode).toBe(403);
-  });
-});