@blackbelt-technology/pi-agent-dashboard 0.4.0 → 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-hardcoded-node-modules-paths.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Repo-level invariant: build-time scripts (CI workflows, Dockerfiles,
+ * shell scripts, root-level CJS helpers) MUST NOT hardcode
+ * `node_modules/electron` or `node_modules/node-pty` paths. Instead, they
+ * MUST resolve through the tool registry — either via the shared shell
+ * wrapper at `packages/shared/bin/pi-dashboard-resolve-tool.cjs`, or
+ * (for postinstall paths that run before the shared package is built)
+ * via `require.resolve("<pkg>/package.json")` matching the registry's
+ * `bare-import` strategy semantics.
+ *
+ * This invariant exists because npm workspace hoisting moves these
+ * packages between `packages/<workspace>/node_modules/<pkg>/` (nested)
+ * and `<repoRoot>/node_modules/<pkg>/` (hoisted) depending on the
+ * workspaces config and npm version. The v0.4.0 release crisis was
+ * caused exactly by this: `cd packages/electron/node_modules/electron`
+ * stopped working after `f51e352` switched workspace cross-refs to
+ * plain semver.
+ *
+ * If this test fails, replace the offending substring with one of:
+ *
+ *   # Shell / YAML / Dockerfile (build-time, has access to repo source):
+ *   ELECTRON_DIR=$(node packages/shared/bin/pi-dashboard-resolve-tool.cjs electron)
+ *   cd "$ELECTRON_DIR" && ...
+ *
+ *   # CJS root postinstall (runs DURING npm install — must inline):
+ *   const ptyPkg = require.resolve("node-pty/package.json");
+ *   const prebuildsDir = path.join(path.dirname(ptyPkg), "prebuilds");
+ *
+ * See change: register-build-time-tools.
+ */
+import { describe, expect, it } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+
+/** Banned substrings (after comment-stripping). */
+const PATTERNS: readonly { re: RegExp; suggestion: string }[] = [
+  {
+    re: /node_modules\/electron(?:\/|\b)/,
+    suggestion:
+      "Use `node packages/shared/bin/pi-dashboard-resolve-tool.cjs electron`",
+  },
+  {
+    re: /node_modules\/node-pty(?:\/|\b)/,
+    suggestion:
+      'Use `require.resolve("node-pty/package.json")` (mirrors the registry\'s bare-import strategy)',
+  },
+];
+
+/**
+ * Files explicitly allowed to contain the banned substrings. Each entry
+ * is a repo-relative path matched exactly. Add an entry only when the
+ * substring appears as a non-path token (e.g. an argument to
+ * `require.resolve`, a comment quoting an example, or this lint file
+ * itself). Document the reason inline.
+ */
+const ALLOWLIST: readonly string[] = [
+  // The lint file itself contains every banned substring as test data.
+  "packages/shared/src/__tests__/no-hardcoded-node-modules-paths.test.ts",
+  // Root postinstall — uses `require.resolve("node-pty/package.json")`,
+  // which contains "node-pty" as an argument string but not as a
+  // hardcoded path. Allowlisted because it must run before the shared
+  // package is unpacked. See file header for full reasoning.
+  "scripts/fix-pty-permissions.cjs",
+  // Sister postinstall script (workspace-scoped) — same rationale.
+  "packages/server/scripts/fix-pty-permissions.cjs",
+];
+
+/**
+ * Repo-relative file list to scan.
+ *
+ * The scope is intentionally narrow: only the build-time sites that the
+ * `register-build-time-tools` change migrated, plus the postinstall
+ * scripts that mirror the registry's `bare-import` semantics. Bundle /
+ * Docker entrypoint scripts (`bundle-server.sh`, `docker-make.sh`,
+ * `test-electron-install-inner.sh`, etc.) are NOT in scope: those
+ * operate on a known WORKDIR with deterministic node_modules layout
+ * inside the build image and are not affected by host-side hoisting.
+ */
+const SCAN_FILES: readonly string[] = [
+  ".github/workflows/publish.yml",
+  ".github/workflows/ci.yml",
+  "packages/electron/scripts/Dockerfile.build",
+  "scripts/fix-pty-permissions.cjs",
+  "packages/server/scripts/fix-pty-permissions.cjs",
+];
+
+interface Violation {
+  file: string;
+  line: number;
+  col: number;
+  text: string;
+  suggestion: string;
+}
+
+/**
+ * Strip a single line's trailing comment for YAML / shell / JS-style
+ * line comments. Preserves substring matches inside strings as actual
+ * content (we don't try to parse string literals — keeping it simple).
+ *
+ * Specifically:
+ *   - `# ...` (YAML, shell): everything from a `#` not preceded by a
+ *     non-space alphanumeric is dropped. Matches GitHub Actions /
+ *     bash conventions.
+ *   - `// ...` (JS): everything from `//` to end of line is dropped.
+ *
+ * This is intentionally simple. False positives only matter if a banned
+ * pattern appears INSIDE a string literal (which would still be the
+ * bug we want to catch); false negatives only matter for inline
+ * comments (`echo foo  # comment node_modules/electron`), which we
+ * exclude correctly.
+ */
+function stripLineComment(line: string): string {
+  // JS-style first.
+  const jsIdx = line.indexOf("//");
+  if (jsIdx >= 0) line = line.slice(0, jsIdx);
+  // Shell/YAML `#` — only when preceded by whitespace or start-of-line.
+  const hashMatch = line.match(/(^|\s)#/);
+  if (hashMatch && typeof hashMatch.index === "number") {
+    line = line.slice(0, hashMatch.index);
+  }
+  return line;
+}
+
+describe("no hardcoded node_modules/<dep> paths in build-time files", () => {
+  it("only allowlisted files reference node_modules/electron or node_modules/node-pty", () => {
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const repoRoot = path.resolve(here, "..", "..", "..", "..");
+
+    const violations: Violation[] = [];
+    const allowSet = new Set(
+      ALLOWLIST.map((p) => path.resolve(repoRoot, p).replace(/\\/g, "/")),
+    );
+
+    for (const rel of SCAN_FILES) {
+      const file = path.resolve(repoRoot, rel);
+      if (!fs.existsSync(file)) continue;
+      const normalized = file.replace(/\\/g, "/");
+      if (allowSet.has(normalized)) continue;
+
+      const content = fs.readFileSync(file, "utf-8");
+      const lines = content.split(/\r?\n/);
+
+      lines.forEach((rawLine, idx) => {
+        const stripped = stripLineComment(rawLine);
+        for (const { re, suggestion } of PATTERNS) {
+          const m = stripped.match(re);
+          if (!m) continue;
+          const col = rawLine.indexOf(m[0]);
+          violations.push({
+            file: path.relative(repoRoot, file),
+            line: idx + 1,
+            col: col >= 0 ? col + 1 : 1,
+            text: rawLine.trim(),
+            suggestion,
+          });
+        }
+      });
+    }
+
+    if (violations.length > 0) {
+      const msg =
+        `Hardcoded \`node_modules/<dep>\` path(s) found in build-time files.\n` +
+        `These break under npm workspace hoisting changes (see v0.4.0 release crisis).\n` +
+        `Use the tool registry instead. See change: register-build-time-tools.\n\n` +
+        `Offenders (${violations.length}):\n` +
+        violations
+          .map(
+            (v) =>
+              `  ${v.file}:${v.line}:${v.col}  ${v.text}\n      → ${v.suggestion}`,
+          )
+          .join("\n");
+      expect(violations, msg).toEqual([]);
+    }
+  });
+});