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

package/packages/server/src/__tests__/installed-package-enricher.test.ts

@@ -35,11 +35,11 @@ const FAKE_MANIFEST: readonly RecommendedExtension[] = [
 		toolsRegistered: [],
 	},
 	{
-		id: "@tintinweb/pi-subagents",
-		source: "npm:@tintinweb/pi-subagents",
-		displayName: "@tintinweb/pi-subagents",
+		id: "pi-dashboard-subagents",
+		source: "npm:pi-dashboard-subagents",
+		displayName: "pi-dashboard-subagents",
 		fallbackDescription: "Sub-agents for pi.",
-		status: "strongly-suggested",
+		status: "optional",
 		unlocks: [],
 		toolsRegistered: [],
 	},
@@ -49,7 +49,7 @@ describe("extractBasenameFromSource", () => {
 	it("strips npm: prefix and version pin", () => {
 		expect(extractBasenameFromSource("npm:pi-agent-browser")).toBe("pi-agent-browser");
 		expect(extractBasenameFromSource("npm:pi-agent-browser@1.2.3")).toBe("pi-agent-browser");
-		expect(extractBasenameFromSource("npm:@tintinweb/pi-subagents")).toBe("@tintinweb/pi-subagents");
+		expect(extractBasenameFromSource("npm:@scope/example-pkg")).toBe("@scope/example-pkg"); // generic scoped-name parsing
 	});
 
 	it("strips .git suffix from git URLs", () => {
@@ -70,8 +70,8 @@ describe("extractBasenameFromSource", () => {
 describe("matchRecommendedEntry", () => {
 	it("matches by exact source", () => {
 		expect(
-			matchRecommendedEntry("npm:@tintinweb/pi-subagents", FAKE_MANIFEST)?.id,
-		).toBe("@tintinweb/pi-subagents");
+			matchRecommendedEntry("npm:pi-dashboard-subagents", FAKE_MANIFEST)?.id,
+		).toBe("pi-dashboard-subagents");
 	});
 
 	it("matches git source regardless of trailing slash / case", () => {
@@ -115,21 +115,21 @@ describe("enrichInstalledRow", () => {
 
 	it("enriches a recommended npm row with displayName and description from manifest", () => {
 		const row: RawInstalledRow = {
-			source: "npm:@tintinweb/pi-subagents",
+			source: "npm:pi-dashboard-subagents",
 			scope: "user",
 			filtered: false,
 			installedPath: "/fake/path",
 		};
 		const out = enrichInstalledRow(row, {
 			...baseDeps,
-			readMeta: () => ({ version: "0.6.1", description: "Live npm desc" }),
+			readMeta: () => ({ version: "0.1.1", description: "Live npm desc" }),
 			existsFn: () => false,
 			resourcesPath: "/res",
 		});
-		expect(out.displayName).toBe("@tintinweb/pi-subagents");
+		expect(out.displayName).toBe("pi-dashboard-subagents");
 		// Recommended manifest description wins over package.json description.
 		expect(out.description).toBe("Sub-agents for pi.");
-		expect(out.version).toBe("0.6.1");
+		expect(out.version).toBe("0.1.1");
 		expect(out.isRecommended).toBe(true);
 		expect(out.isBundled).toBe(false);
 	});
@@ -173,7 +173,7 @@ describe("enrichInstalledRow", () => {
 
 	it("handles missing installedPath silently", () => {
 		const row: RawInstalledRow = {
-			source: "npm:@tintinweb/pi-subagents",
+			source: "npm:pi-dashboard-subagents",
 			scope: "user",
 			filtered: false,
 		};

package/packages/server/src/__tests__/is-activity-event.test.ts

@@ -17,13 +17,10 @@ describe("isActivityEvent", () => {
       "agent_start",
       "agent_end",
       "bash_output",
-      "flow_started",
-      "flow_complete",
-      "flow_agent_started",
-      "flow_agent_complete",
-      "architect_started",
-      "architect_complete",
-      "architect_cancelled",
+      // Flow / architect events removed: per change
+      // pluginize-flows-via-registry the shell carries no flow
+      // knowledge. lastActivityAt for flow-only sessions is bumped
+      // by the constituent tool/agent events the flow generates.
     ];
 
     for (const t of included) {

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

@@ -112,14 +112,18 @@ describe("package-routes", () => {
 
     it("matches a row to RECOMMENDED_EXTENSIONS by source", async () => {
       wrapper.listInstalled.mockReturnValueOnce([
-        { source: "npm:@tintinweb/pi-subagents", scope: "user", filtered: false },
+        {
+          source: "https://github.com/BlackBeltTechnology/pi-dashboard-subagents.git",
+          scope: "user",
+          filtered: false,
+        },
       ]);
       const res = await app.inject({ method: "GET", url: "/api/packages/installed?scope=global" });
       const body = JSON.parse(res.body);
       const row = body.data[0];
       expect(row.isRecommended).toBe(true);
       // displayName comes from the recommended manifest.
-      expect(row.displayName).toBe("@tintinweb/pi-subagents");
+      expect(row.displayName).toBe("pi-dashboard-subagents");
     });
 
     it("missing installedPath does not break enrichment", async () => {

package/packages/server/src/__tests__/pi-changelog-routes.test.ts

@@ -168,19 +168,16 @@ describe("pi-changelog-routes", () => {
     expect(res.statusCode).toBe(400);
   });
 
-  it("returns 503 when bootstrap is not ready", async () => {
-    await app.close();
-    bootstrapState.get = () => ({ status: "installing" as const });
-    app = Fastify({ logger: false });
-    registerPiChangelogRoutes(app, { bootstrapState });
-    await app.ready();
-    const res = await app.inject({
-      method: "GET",
-      url: "/api/pi-core/changelog?pkg=@mariozechner/pi-coding-agent&from=0.68.0&to=0.70.0",
-    });
-    expect(res.statusCode).toBe(503);
-    expect(res.json().bootstrap).toBe("installing");
-  });
+  // NOTE: "returns 503 when bootstrap is not ready" test removed.
+  // The bootstrap gate on this route was deliberately removed in change
+  // `eliminate-electron-runtime-install` (task 3.5, 2026-05-23). The
+  // route file's own docstring confirms it: "Bootstrap gate removed
+  // under change: eliminate-electron-runtime-install (task 3.5)". The
+  // `PiChangelogRouteDeps` interface comment also says the field was
+  // removed; the route is unconditionally available. This test was
+  // documented as deferred to a "Phase 3.9 sweep" in
+  // eliminate-electron-runtime-install/tasks.md task 5.9; this is that
+  // sweep.
 
   it("returns no releases when from === to", async () => {
     makeManagedPkg("@mariozechner/pi-coding-agent", {

package/packages/server/src/__tests__/pi-core-checker.test.ts

@@ -20,7 +20,7 @@ describe("PiCoreChecker._internal.looksLikePiEcosystem", () => {
 	});
 
 	it("rejects scoped pi-* packages that are NOT in the whitelist", () => {
-		expect(_internal.looksLikePiEcosystem("@tintinweb/pi-subagents")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("@scope/pi-fake")).toBe(false);
 		expect(_internal.looksLikePiEcosystem("@benvargas/pi-claude-code-use")).toBe(false);
 	});
 
@@ -105,7 +105,7 @@ describe("PiCoreChecker.getStatus", () => {
 					dependencies: {
 						"pi-agent-browser": { version: "0.1.0" },
 						"pi-web-access": { version: "0.10.6" },
-						"@tintinweb/pi-subagents": { version: "0.6.1" },
+						"pi-dashboard-subagents": { version: "0.1.1" },
 					},
 				}),
 			fetchLatest: async () => null,

package/packages/server/src/__tests__/pi-version-skew.test.ts

@@ -15,13 +15,14 @@ import {
   readPiCompatibility,
   readCurrentPiVersion,
   computeCompatibility,
-  _resetVersionSkewCache,
 } from "../pi-version-skew.js";
 import type { ToolRegistry, Resolution } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
 
 describe("pi-version-skew", () => {
   beforeEach(() => {
-    _resetVersionSkewCache();
+    // Cache (formerly `_resetVersionSkewCache`) removed under change:
+    // eliminate-electron-runtime-install (task 3.6) along with
+    // updateBootstrapCompatibility. Tests now exercise pure helpers only.
   });
 
   describe("parseVersion", () => {

package/packages/server/src/__tests__/plugin-activation-routes.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Route tests for `GET /api/plugins` and `POST /api/plugins/:id/toggle`.
+ *
+ * See change: add-plugin-activation-ui.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { registerPluginActivationRoutes } from "../routes/plugin-activation-routes.js";
+import {
+  clearDiscoveryCache,
+  clearStatusStore,
+  discoverPlugins,
+  getPluginStatusStore,
+} from "@blackbelt-technology/dashboard-plugin-runtime/server";
+
+const HOME_OVERRIDE = path.join(os.tmpdir(), "pi-dashboard-activation-test-" + process.pid);
+
+function makeRepoRootWithPlugin(id: string, displayName: string, opts: { enabledInConfig?: boolean } = {}) {
+  const repoRoot = path.join(os.tmpdir(), `activation-routes-test-${id}-${Date.now()}`);
+  const pkgDir = path.join(repoRoot, "packages", id);
+  fs.mkdirSync(pkgDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(pkgDir, "package.json"),
+    JSON.stringify({
+      name: `@test/${id}`,
+      version: "0.0.0",
+      "pi-dashboard-plugin": { id, displayName, claims: [] },
+    }),
+  );
+
+  if (opts.enabledInConfig !== undefined) {
+    fs.mkdirSync(path.join(HOME_OVERRIDE, ".pi", "dashboard"), { recursive: true });
+    fs.writeFileSync(
+      path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json"),
+      JSON.stringify({ plugins: { [id]: { enabled: opts.enabledInConfig } } }, null, 2),
+    );
+  }
+  return repoRoot;
+}
+
+function makeRepoRootWithPluginPair(
+  rootSuffix: string,
+  a: { id: string; displayName: string; enabledInConfig?: boolean },
+  b: { id: string; displayName: string; dependsOn: string[]; enabledInConfig?: boolean },
+) {
+  const repoRoot = path.join(os.tmpdir(), `activation-routes-test-${rootSuffix}-${Date.now()}`);
+  for (const p of [a, b]) {
+    const pkgDir = path.join(repoRoot, "packages", p.id);
+    fs.mkdirSync(pkgDir, { recursive: true });
+    const manifest: Record<string, unknown> = { id: p.id, displayName: p.displayName, claims: [] };
+    if ("dependsOn" in p && p.dependsOn) manifest.dependsOn = p.dependsOn;
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: `@test/${p.id}`,
+        version: "0.0.0",
+        "pi-dashboard-plugin": manifest,
+      }),
+    );
+  }
+  const cfgPlugins: Record<string, { enabled: boolean }> = {};
+  if (a.enabledInConfig !== undefined) cfgPlugins[a.id] = { enabled: a.enabledInConfig };
+  if (b.enabledInConfig !== undefined) cfgPlugins[b.id] = { enabled: b.enabledInConfig };
+  if (Object.keys(cfgPlugins).length > 0) {
+    fs.mkdirSync(path.join(HOME_OVERRIDE, ".pi", "dashboard"), { recursive: true });
+    fs.writeFileSync(
+      path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json"),
+      JSON.stringify({ plugins: cfgPlugins }, null, 2),
+    );
+  }
+  return repoRoot;
+}
+
+let originalHome: string | undefined;
+async function makeApp(repoRoot: string, broadcasts: unknown[] = []): Promise<FastifyInstance> {
+  const app = Fastify({ logger: false });
+  registerPluginActivationRoutes(app, {
+    networkGuard: async () => undefined,
+    broadcast: (m) => broadcasts.push(m),
+    repoRoot,
+  });
+  await app.ready();
+  return app;
+}
+
+describe("/api/plugins", () => {
+  let app: FastifyInstance;
+  beforeEach(() => {
+    clearDiscoveryCache();
+    clearStatusStore();
+    fs.rmSync(HOME_OVERRIDE, { recursive: true, force: true });
+    originalHome = process.env.HOME;
+    process.env.HOME = HOME_OVERRIDE;
+  });
+  afterEach(async () => {
+    await app?.close();
+    if (originalHome !== undefined) process.env.HOME = originalHome;
+    else delete process.env.HOME;
+    fs.rmSync(HOME_OVERRIDE, { recursive: true, force: true });
+  });
+
+  it("returns every discovered plugin with manifest summary + status", async () => {
+    const repoRoot = makeRepoRootWithPlugin("act-a", "Act A");
+    // Seed status so the row carries the runtime view too.
+    getPluginStatusStore().setStatus({
+      id: "act-a",
+      displayName: "Act A",
+      enabled: true,
+      loaded: true,
+      claims: 0,
+    });
+    app = await makeApp(repoRoot);
+
+    const res = await app.inject({ method: "GET", url: "/api/plugins" });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as { success: boolean; plugins: any[] };
+    expect(body.success).toBe(true);
+    expect(body.plugins).toHaveLength(1);
+    expect(body.plugins[0].id).toBe("act-a");
+    expect(body.plugins[0].displayName).toBe("Act A");
+    expect(body.plugins[0].status.enabled).toBe(true);
+  });
+});
+
+describe("POST /api/plugins/:id/toggle", () => {
+  let app: FastifyInstance;
+  let broadcasts: unknown[];
+  beforeEach(() => {
+    clearDiscoveryCache();
+    clearStatusStore();
+    fs.rmSync(HOME_OVERRIDE, { recursive: true, force: true });
+    originalHome = process.env.HOME;
+    process.env.HOME = HOME_OVERRIDE;
+    broadcasts = [];
+  });
+  afterEach(async () => {
+    await app?.close();
+    if (originalHome !== undefined) process.env.HOME = originalHome;
+    else delete process.env.HOME;
+    fs.rmSync(HOME_OVERRIDE, { recursive: true, force: true });
+  });
+
+  it("persists enabled=false to config.json and broadcasts plugin_config_update", async () => {
+    const repoRoot = makeRepoRootWithPlugin("act-b", "Act B");
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/act-b/toggle",
+      payload: { enabled: false },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as { success: boolean; restartRequired: boolean };
+    expect(body.restartRequired).toBe(true);
+
+    const cfgPath = path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json");
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    expect(cfg.plugins["act-b"].enabled).toBe(false);
+
+    expect(broadcasts).toHaveLength(1);
+    expect((broadcasts[0] as any).type).toBe("plugin_config_update");
+    expect((broadcasts[0] as any).id).toBe("act-b");
+  });
+
+  it("returns 404 for unknown plugin id", async () => {
+    const repoRoot = makeRepoRootWithPlugin("act-c", "Act C");
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/no-such/toggle",
+      payload: { enabled: false },
+    });
+    expect(res.statusCode).toBe(404);
+    // config.json should not have been created
+    const cfgPath = path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json");
+    expect(fs.existsSync(cfgPath)).toBe(false);
+  });
+
+  it("returns 400 when body.enabled is not a boolean", async () => {
+    const repoRoot = makeRepoRootWithPlugin("act-d", "Act D");
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/act-d/toggle",
+      payload: { enabled: "yes" },
+    });
+    expect(res.statusCode).toBe(400);
+  });
+
+  // ---- Dependency-graph cascade tests (Robert's Layer 2 spec) ------------
+
+  it("enabling a plugin with a missing dep returns 409 + blockers", async () => {
+    const repoRoot = makeRepoRootWithPluginPair(
+      "cascade-blocker",
+      { id: "orphan-a", displayName: "Orphan A" },
+      { id: "orphan-b", displayName: "Orphan B", dependsOn: ["missing-x"], enabledInConfig: false },
+    );
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/orphan-b/toggle",
+      payload: { enabled: true },
+    });
+    expect(res.statusCode).toBe(409);
+    const body = res.json() as { success: boolean; reason: string; blockers: string[] };
+    expect(body.reason).toBe("blockers");
+    expect(body.blockers).toEqual(["missing-x"]);
+  });
+
+  it("enabling cascades disabled deps and writes atomically", async () => {
+    const repoRoot = makeRepoRootWithPluginPair(
+      "cascade-enable",
+      { id: "cas-a", displayName: "Cas A", enabledInConfig: false },
+      { id: "cas-b", displayName: "Cas B", dependsOn: ["cas-a"], enabledInConfig: false },
+    );
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/cas-b/toggle",
+      payload: { enabled: true },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as { success: boolean; cascade: { enable: string[] } };
+    expect(body.cascade.enable).toEqual(["cas-a"]);
+
+    const cfg = JSON.parse(
+      fs.readFileSync(path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json"), "utf-8"),
+    );
+    expect(cfg.plugins["cas-a"].enabled).toBe(true);
+    expect(cfg.plugins["cas-b"].enabled).toBe(true);
+
+    // Two broadcasts, one per affected id.
+    const ids = broadcasts.map((m) => (m as { id: string }).id).sort();
+    expect(ids).toEqual(["cas-a", "cas-b"]);
+  });
+
+  it("disabling cascades enabled dependents and writes atomically", async () => {
+    const repoRoot = makeRepoRootWithPluginPair(
+      "cascade-disable",
+      { id: "dis-a", displayName: "Dis A", enabledInConfig: true },
+      { id: "dis-b", displayName: "Dis B", dependsOn: ["dis-a"], enabledInConfig: true },
+    );
+    app = await makeApp(repoRoot, broadcasts);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/plugins/dis-a/toggle",
+      payload: { enabled: false },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as { success: boolean; cascade: { disable: string[] } };
+    expect(body.cascade.disable).toEqual(["dis-b"]);
+
+    const cfg = JSON.parse(
+      fs.readFileSync(path.join(HOME_OVERRIDE, ".pi", "dashboard", "config.json"), "utf-8"),
+    );
+    expect(cfg.plugins["dis-a"].enabled).toBe(false);
+    expect(cfg.plugins["dis-b"].enabled).toBe(false);
+  });
+});

package/packages/server/src/__tests__/plugin-intent-cache.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Tests for PluginIntentCache — server-side replay store for plugin intents.
+ *
+ * See change: adopt-server-driven-intent-rendering.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { PluginIntentCache } from "../plugin-intent-cache.js";
+import type { IntentNode } from "@blackbelt-technology/pi-dashboard-shared/dashboard-plugin/intent-types.js";
+
+const sampleIntent: IntentNode = {
+  primitive: "ui:action-list",
+  props: { actions: [{ label: "Run X" }] },
+};
+
+describe("PluginIntentCache", () => {
+  let cache: PluginIntentCache;
+
+  beforeEach(() => {
+    cache = new PluginIntentCache();
+  });
+
+  it("set + getForSession returns the cached intent", () => {
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    const entries = cache.getForSession("abc");
+    expect(entries).toHaveLength(1);
+    expect(entries[0].pluginId).toBe("flows");
+    expect(entries[0].intent).toEqual(sampleIntent);
+  });
+
+  it("setting null intent clears the slot", () => {
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    cache.set("flows", "abc", "session-card-action-bar", null);
+    const entries = cache.getForSession("abc");
+    expect(entries).toHaveLength(0);
+  });
+
+  it("clearForSession removes only entries for that session", () => {
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    cache.set("flows", "xyz", "session-card-action-bar", sampleIntent);
+    cache.clearForSession("abc");
+    expect(cache.getForSession("abc")).toHaveLength(0);
+    expect(cache.getForSession("xyz")).toHaveLength(1);
+  });
+
+  it("supports global slots with sessionId=null", () => {
+    cache.set("honcho", null, "settings-section", sampleIntent);
+    const entries = cache.getForSession(null);
+    expect(entries).toHaveLength(1);
+    expect(entries[0].sessionId).toBeNull();
+  });
+
+  it("two plugins can occupy the same slot for the same session", () => {
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    cache.set("jj", "abc", "session-card-action-bar", sampleIntent);
+    const entries = cache.getForSession("abc");
+    expect(entries).toHaveLength(2);
+    expect(new Set(entries.map((e) => e.pluginId))).toEqual(new Set(["flows", "jj"]));
+  });
+
+  it("same (pluginId, sessionId, slot) overwrites", () => {
+    const newer: IntentNode = { primitive: "ui:status-pill", props: { text: "updated" } };
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    cache.set("flows", "abc", "session-card-action-bar", newer);
+    const entries = cache.getForSession("abc");
+    expect(entries).toHaveLength(1);
+    expect(entries[0].intent).toEqual(newer);
+  });
+
+  it("reset clears everything", () => {
+    cache.set("flows", "abc", "session-card-action-bar", sampleIntent);
+    cache.set("honcho", null, "settings-section", sampleIntent);
+    cache.reset();
+    expect(cache.getAll()).toHaveLength(0);
+  });
+});