@blackbelt-technology/pi-agent-dashboard 0.4.1 → 0.4.2

package/packages/shared/src/__tests__/browser-protocol-types.test.ts

@@ -11,13 +11,21 @@ import type {
   BrowserPromptRequestMessage,
   BrowserPromptDismissMessage,
   BrowserPromptCancelMessage,
+  BrowserExtUiDecoratorMessage,
 } from "../browser-protocol.js";
+import type { ExtensionToServerMessage, ExtUiDecoratorMessage } from "../protocol.js";
+import type { DecoratorDescriptor } from "../types.js";
 
 // Type-level assertion: if these types are NOT in the union, this will fail to compile.
 type AssertExtends<T, U> = T extends U ? true : never;
 type _PromptRequestInUnion = AssertExtends<BrowserPromptRequestMessage, ServerToBrowserMessage>;
 type _PromptDismissInUnion = AssertExtends<BrowserPromptDismissMessage, ServerToBrowserMessage>;
 type _PromptCancelInUnion = AssertExtends<BrowserPromptCancelMessage, ServerToBrowserMessage>;
+// Phase-2 (add-extension-ui-decorations): ext_ui_decorator must be a member of
+// BOTH the extension→server union and the server→browser union, otherwise
+// esbuild strips the switch arms in production builds.
+type _ExtUiDecoratorInExtensionUnion = AssertExtends<ExtUiDecoratorMessage, ExtensionToServerMessage>;
+type _ExtUiDecoratorInBrowserUnion   = AssertExtends<BrowserExtUiDecoratorMessage, ServerToBrowserMessage>;
 
 // Runtime verification that the type discriminants are reachable in a switch
 function extractPromptType(msg: ServerToBrowserMessage): string | null {
@@ -60,3 +68,54 @@ describe("ServerToBrowserMessage includes PromptBus messages", () => {
     expect(extractPromptType(msg)).toBe("p1");
   });
 });
+
+// Phase-2: ext_ui_decorator switch-arm reachability.
+function extractDecoratorKey(msg: ServerToBrowserMessage): string | null {
+  switch (msg.type) {
+    case "ext_ui_decorator":
+      return `${msg.descriptor.kind}:${msg.descriptor.namespace}:${msg.descriptor.id}`;
+    default:
+      return null;
+  }
+}
+
+describe("ext_ui_decorator is a member of both protocol unions", () => {
+  const sample: DecoratorDescriptor = {
+    kind: "footer-segment",
+    namespace: "judo",
+    id: "model-state",
+    payload: { text: "3 mut" },
+  };
+
+  it("server→browser ext_ui_decorator is a valid discriminant", () => {
+    const msg: BrowserExtUiDecoratorMessage = {
+      type: "ext_ui_decorator",
+      sessionId: "s1",
+      descriptor: sample,
+    };
+    expect(extractDecoratorKey(msg)).toBe("footer-segment:judo:model-state");
+  });
+
+  it("removed flag round-trips through the union", () => {
+    const msg: BrowserExtUiDecoratorMessage = {
+      type: "ext_ui_decorator",
+      sessionId: "s1",
+      descriptor: sample,
+      removed: true,
+    };
+    expect(extractDecoratorKey(msg)).toBe("footer-segment:judo:model-state");
+    // Round-trip via JSON to confirm `removed` survives serialization.
+    const parsed = JSON.parse(JSON.stringify(msg)) as BrowserExtUiDecoratorMessage;
+    expect(parsed.removed).toBe(true);
+  });
+
+  it("extension→server ext_ui_decorator carries the same shape", () => {
+    const msg: ExtUiDecoratorMessage = {
+      type: "ext_ui_decorator",
+      sessionId: "s1",
+      descriptor: sample,
+    };
+    expect(msg.type).toBe("ext_ui_decorator");
+    expect(msg.descriptor.kind).toBe("footer-segment");
+  });
+});

package/packages/shared/src/__tests__/config-plugins.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for plugins config namespace in DashboardConfig.
+ * Verifies round-trip preservation of all keys.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadConfig, getPluginsConfig, getPluginConfig } from "../config.js";
+
+let tmpDir: string;
+let origHome: string | undefined;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "config-plugins-test-"));
+  origHome = process.env.HOME;
+  process.env.HOME = tmpDir;
+});
+
+afterEach(() => {
+  process.env.HOME = origHome;
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeConfig(data: Record<string, unknown>) {
+  const dir = path.join(tmpDir, ".pi", "dashboard");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "config.json"), JSON.stringify(data));
+}
+
+describe("plugins config round-trip", () => {
+  it("preserves all top-level keys including plugins namespace", () => {
+    writeConfig({
+      port: 9000,
+      auth: undefined,
+      openspec: { pollIntervalSeconds: 30 },
+      plugins: { demo: { foo: 1 } },
+    });
+
+    const config = loadConfig();
+    expect(config.port).toBe(9000);
+    // loadConfig normalizes openspec to full object with defaults
+    expect(config.openspec.pollIntervalSeconds).toBe(30);
+    expect(getPluginConfig(config, "demo")).toEqual({ foo: 1 });
+  });
+
+  it("returns empty object for unknown plugin id", () => {
+    writeConfig({ plugins: { demo: { foo: 1 } } });
+    const config = loadConfig();
+    expect(getPluginConfig(config, "nonexistent")).toEqual({});
+  });
+
+  it("returns empty plugins config when plugins key is absent", () => {
+    writeConfig({ port: 8000 });
+    const config = loadConfig();
+    expect(getPluginsConfig(config)).toEqual({});
+  });
+
+  it("getPluginsConfig returns all plugin namespaces", () => {
+    writeConfig({
+      plugins: { demo: { foo: 1 }, openspec: { pollIntervalSeconds: 60 } },
+    });
+    const config = loadConfig();
+    const plugins = getPluginsConfig(config);
+    expect(plugins.demo).toEqual({ foo: 1 });
+    expect(plugins.openspec).toEqual({ pollIntervalSeconds: 60 });
+  });
+});

package/packages/shared/src/__tests__/extension-ui-module-shape.test.ts

@@ -0,0 +1,265 @@
+/**
+ * Type-shape and union-membership tests for the Extension UI System Phase-1
+ * schema and protocol additions. See change: add-extension-ui-modal.
+ *
+ * The point of these tests is twofold:
+ *
+ * 1.  **Compile-time shape validation.** Constructing concrete
+ *     `ExtensionUiModule` instances with the canonical view kinds (`table`,
+ *     `grid`, `form`) and `UiAction` confirm-polish flag forces the type
+ *     system to enforce the field shapes from the design.
+ *
+ * 2.  **Union membership.** The new wire-protocol messages
+ *     (`ui_modules_list`, `ui_data_list`, `ui_management`) are dropped by
+ *     esbuild in production if they are not members of the
+ *     `ServerToBrowserMessage` / `BrowserToServerMessage` /
+ *     `ExtensionToServerMessage` / `ServerToExtensionMessage` unions. The
+ *     `AssertExtends` guards below fail at compile time if any union loses
+ *     its new member.
+ */
+import { describe, it, expect } from "vitest";
+import type {
+  ExtensionUiModule,
+  UiAction,
+  UiField,
+  UiSection,
+  UiView,
+} from "../types.js";
+import type {
+  ExtensionToServerMessage,
+  ServerToExtensionMessage,
+  UiModulesListMessage,
+  UiDataListMessage,
+  UiManagementMessage,
+} from "../protocol.js";
+import type {
+  ServerToBrowserMessage,
+  BrowserToServerMessage,
+  BrowserUiModulesListMessage,
+  BrowserUiDataListMessage,
+  UiManagementBrowserMessage,
+} from "../browser-protocol.js";
+
+// ── Compile-time union-membership assertions ───────────────────────
+type AssertExtends<T, U> = T extends U ? true : never;
+
+// Bridge ↔ Server leg
+type _UiModulesListInExt = AssertExtends<UiModulesListMessage, ExtensionToServerMessage>;
+type _UiDataListInExt = AssertExtends<UiDataListMessage, ExtensionToServerMessage>;
+type _UiManagementInServer = AssertExtends<UiManagementMessage, ServerToExtensionMessage>;
+
+// Server ↔ Browser leg
+type _BrowserUiModulesInUnion = AssertExtends<BrowserUiModulesListMessage, ServerToBrowserMessage>;
+type _BrowserUiDataInUnion = AssertExtends<BrowserUiDataListMessage, ServerToBrowserMessage>;
+type _UiManagementInBrowser = AssertExtends<UiManagementBrowserMessage, BrowserToServerMessage>;
+
+// Sentinel — referenced so tsc keeps the assertions live.
+const _typeSentinel: Array<true> = [
+  true as _UiModulesListInExt,
+  true as _UiDataListInExt,
+  true as _UiManagementInServer,
+  true as _BrowserUiModulesInUnion,
+  true as _BrowserUiDataInUnion,
+  true as _UiManagementInBrowser,
+];
+
+describe("ExtensionUiModule shape", () => {
+  it("accepts a table view with dataEvent and rowActions", () => {
+    const tableModule: ExtensionUiModule = {
+      kind: "management-modal",
+      id: "judo-status",
+      command: "/judo:status",
+      title: "Judo Status",
+      description: "Show pending status rows",
+      icon: "mdiTableLarge",
+      category: "judo",
+      view: {
+        kind: "table",
+        dataEvent: "judo:status-rows",
+        rowKey: "id",
+        fields: [
+          { key: "id", label: "ID", kind: "text", width: 80 },
+          { key: "name", label: "Name", kind: "text" },
+          { key: "score", label: "Score", kind: "number" },
+        ],
+        rowActions: [
+          {
+            id: "delete",
+            label: "Delete",
+            icon: "mdiDelete",
+            variant: "danger",
+            event: "judo:delete-row",
+            confirm: "Delete this entry?",
+          },
+        ],
+        emptyState: "No rows yet.",
+        actions: [
+          {
+            id: "refresh",
+            label: "Refresh",
+            icon: "mdiRefresh",
+            variant: "secondary",
+            event: "judo:refresh",
+          },
+        ],
+      },
+    };
+
+    expect(tableModule.kind).toBe("management-modal");
+    expect(tableModule.view.kind).toBe("table");
+    expect(tableModule.view.dataEvent).toBe("judo:status-rows");
+    expect(tableModule.view.rowActions?.[0]?.confirm).toBe("Delete this entry?");
+  });
+
+  it("accepts a form view with sections grouping fields", () => {
+    const sections: UiSection[] = [
+      {
+        id: "general",
+        title: "General",
+        fields: [
+          { key: "name", label: "Name", kind: "text", required: true },
+          { key: "enabled", label: "Enabled", kind: "boolean" },
+        ],
+      },
+      {
+        id: "advanced",
+        title: "Advanced",
+        description: "Optional knobs.",
+        fields: [
+          { key: "code", label: "Hook", kind: "code", language: "javascript" },
+          { key: "notes", label: "Notes", kind: "textarea" },
+        ],
+      },
+    ];
+
+    const formModule: ExtensionUiModule = {
+      kind: "management-modal",
+      id: "judo-config",
+      command: "/judo:config",
+      title: "Judo Config",
+      view: {
+        kind: "form",
+        sections,
+        actions: [
+          {
+            id: "save",
+            label: "Save",
+            icon: "mdiContentSave",
+            variant: "primary",
+            event: "judo:save-config",
+          },
+        ],
+      },
+    };
+
+    expect(formModule.view.kind).toBe("form");
+    expect(formModule.view.sections).toHaveLength(2);
+    expect(formModule.view.sections?.[1]?.fields[0]?.kind).toBe("code");
+    expect(formModule.view.sections?.[1]?.fields[0]?.language).toBe("javascript");
+  });
+
+  it("accepts a grid view (same lifecycle as table) and select-kind fields", () => {
+    const fields: UiField[] = [
+      { key: "id", label: "ID", kind: "text" },
+      { key: "tier", label: "Tier", kind: "select", options: ["bronze", "silver", "gold"] },
+      { key: "joinedAt", label: "Joined", kind: "datetime" },
+    ];
+
+    const gridModule: ExtensionUiModule = {
+      kind: "management-modal",
+      id: "judo-members",
+      command: "/judo:members",
+      title: "Members",
+      view: {
+        kind: "grid",
+        dataEvent: "judo:members-list",
+        fields,
+      },
+    };
+
+    expect(gridModule.view.kind).toBe("grid");
+    expect(gridModule.view.fields?.[1]?.options).toEqual(["bronze", "silver", "gold"]);
+  });
+
+  it("UiAction supports confirm polish for destructive actions", () => {
+    const dangerAction: UiAction = {
+      id: "wipe",
+      label: "Wipe All",
+      variant: "danger",
+      event: "judo:wipe",
+      confirm: "Wipe all members? This cannot be undone.",
+    };
+
+    expect(dangerAction.confirm).toContain("cannot be undone");
+    expect(dangerAction.variant).toBe("danger");
+  });
+
+  it("UiView with table kind requires neither sections nor actions", () => {
+    const minimal: UiView = {
+      kind: "table",
+      dataEvent: "x:list",
+      fields: [{ key: "id", label: "ID", kind: "text" }],
+    };
+    expect(minimal.kind).toBe("table");
+    expect(minimal.actions).toBeUndefined();
+    expect(minimal.sections).toBeUndefined();
+  });
+});
+
+describe("Phase-1 wire protocol", () => {
+  it("constructs each message with discriminated literal types", () => {
+    const modulesList: UiModulesListMessage = {
+      type: "ui_modules_list",
+      sessionId: "s1",
+      modules: [],
+    };
+    const dataList: UiDataListMessage = {
+      type: "ui_data_list",
+      sessionId: "s1",
+      event: "judo:status-rows",
+      items: [{ id: 1 }, { id: 2 }],
+    };
+    const browserModules: BrowserUiModulesListMessage = {
+      type: "ui_modules_list",
+      sessionId: "s1",
+      modules: [],
+    };
+    const browserData: BrowserUiDataListMessage = {
+      type: "ui_data_list",
+      sessionId: "s1",
+      event: "judo:status-rows",
+      items: [],
+    };
+    const mgmt: UiManagementBrowserMessage = {
+      type: "ui_management",
+      sessionId: "s1",
+      action: "list",
+      event: "judo:status-rows",
+      params: { since: 0 },
+    };
+
+    expect(modulesList.type).toBe("ui_modules_list");
+    expect(dataList.type).toBe("ui_data_list");
+    expect(browserModules.type).toBe("ui_modules_list");
+    expect(browserData.type).toBe("ui_data_list");
+    expect(mgmt.type).toBe("ui_management");
+  });
+
+  it("type discriminants are reachable in a switch (esbuild safety)", () => {
+    function classify(msg: ServerToBrowserMessage): string | null {
+      switch (msg.type) {
+        case "ui_modules_list":
+          return `modules:${msg.modules.length}`;
+        case "ui_data_list":
+          return `data:${msg.event}:${msg.items.length}`;
+        default:
+          return null;
+      }
+    }
+
+    expect(classify({ type: "ui_modules_list", sessionId: "s", modules: [] })).toBe("modules:0");
+    expect(
+      classify({ type: "ui_data_list", sessionId: "s", event: "x", items: [1, 2, 3] }),
+    ).toBe("data:x:3");
+  });
+});

package/packages/shared/src/__tests__/no-raw-openspec-status-in-skills.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Repo-level invariant: OpenSpec workflow skills (.pi/skills/openspec-*)
+ * MUST invoke `.pi/skills/openspec-shared/scripts/effective-status.sh`
+ * instead of calling `openspec status --json` directly. The wrapper
+ * applies the dashboard's local-design-evidence override (R1/R2/R3) so
+ * skill-driven prompts and dashboard session-card buttons cannot
+ * disagree about a change's next-ready artifact.
+ *
+ * If this test fails: replace the offending `openspec status ... --json`
+ * line with:
+ *
+ *   .pi/skills/openspec-shared/scripts/effective-status.sh "<name>"
+ *
+ * See change: fix-openspec-design-detection.
+ */
+import { describe, it, expect } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import url from "node:url";
+
+/**
+ * Regex catches `openspec status ... --json` invocations. We deliberately
+ * accept whitespace flexibility but reject only the `--json` flavor (the
+ * human-readable `openspec status --change "<name>"` form is allowed
+ * because it doesn't drive logic).
+ */
+const RAW_STATUS_RE = /\bopenspec\s+status\b[^\n]*--json\b/;
+
+/** Per-line opt-out marker. */
+const OPT_OUT_MARKER = "ban:openspec-status-ok";
+
+/** Skills the wrapper exists to serve — these MUST go through it. */
+const GOVERNED_SKILLS = [
+  "openspec-continue-change",
+  "openspec-ff-change",
+  "openspec-apply-change",
+  "openspec-verify-change",
+];
+
+describe("OpenSpec workflow skills must use effective-status.sh", () => {
+  it("no raw `openspec status --json` outside the wrapper script", async () => {
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const repoRoot = path.resolve(here, "..", "..", "..", "..");
+    const skillsRoot = path.resolve(repoRoot, ".pi", "skills");
+
+    const violations: Array<{ file: string; line: number; text: string }> = [];
+
+    for (const skill of GOVERNED_SKILLS) {
+      const skillFile = path.join(skillsRoot, skill, "SKILL.md");
+      let content: string;
+      try {
+        content = await fs.readFile(skillFile, "utf-8");
+      } catch {
+        // Skill not present in this checkout — fine, skip.
+        continue;
+      }
+      const lines = content.split(/\r?\n/);
+      lines.forEach((line, idx) => {
+        if (!RAW_STATUS_RE.test(line)) return;
+        if (line.includes(OPT_OUT_MARKER)) return;
+        violations.push({
+          file: path.relative(repoRoot, skillFile),
+          line: idx + 1,
+          text: line.trim(),
+        });
+      });
+    }
+
+    if (violations.length > 0) {
+      const msg =
+        `Raw \`openspec status --json\` invocations found in OpenSpec skills.\n` +
+        `Replace each with the wrapper that applies the dashboard's design override:\n` +
+        `  .pi/skills/openspec-shared/scripts/effective-status.sh "<name>"\n\n` +
+        `Offenders (${violations.length}):\n` +
+        violations
+          .map((v) => `  ${v.file}:${v.line}  ${v.text}`)
+          .join("\n");
+      expect(violations, msg).toEqual([]);
+    }
+  });
+});