@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.1

package/packages/shared/src/__tests__/bootstrap/families/__snapshots__/g-windows-specifics.test.ts.snap

@@ -7,8 +7,9 @@ source: managed
 path:   <HOME>/.pi-dashboard/node_modules/@mariozechner/pi-coding-agent/dist/cli.js
 tried:
   override     no override set
+  bare-import  cannot resolve @earendil-works/pi-coding-agent/package.json
   bare-import  cannot resolve @mariozechner/pi-coding-agent/package.json
-  bare-import  cannot resolve @oh-my-pi/pi-coding-agent/package.json
+  managed      missing: <HOME>/.pi-dashboard/node_modules/@earendil-works/pi-coding-agent/dist/cli.js
   managed      ok
 argv:
   - C:/Program Files/nodejs/node.exe
@@ -22,10 +23,11 @@ source: npm-global
 path:   <NPM_ROOT>/@mariozechner/pi-coding-agent/dist/cli.js
 tried:
   override     no override set
+  bare-import  cannot resolve @earendil-works/pi-coding-agent/package.json
   bare-import  cannot resolve @mariozechner/pi-coding-agent/package.json
-  bare-import  cannot resolve @oh-my-pi/pi-coding-agent/package.json
+  managed      missing: <HOME>/.pi-dashboard/node_modules/@earendil-works/pi-coding-agent/dist/cli.js
   managed      missing: <HOME>/.pi-dashboard/node_modules/@mariozechner/pi-coding-agent/dist/cli.js
-  managed      missing: <HOME>/.pi-dashboard/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js
+  npm-global   missing: <NPM_ROOT>/@earendil-works/pi-coding-agent/dist/cli.js
   npm-global   ok
 argv:
   - C:/Program Files/nodejs/node.exe
@@ -39,6 +41,7 @@ source: system
 path:   C:/Program Files/nodejs/node.exe
 tried:
   override     no override set
+  managed      missing: <HOME>/.pi-dashboard/node/node.exe
   managed      missing: <HOME>/.pi-dashboard/node_modules/.bin/node.cmd
   where        ok
 argv:

package/packages/shared/src/__tests__/bootstrap/fixtures/dev-monorepo.ts

@@ -3,7 +3,7 @@
  *
  * <root>/
  *   node_modules/
- *     @mariozechner/pi-coding-agent/dist/cli.js
+ *     @earendil-works/pi-coding-agent/dist/cli.js
  *     openspec/dist/cli.js
  *     tsx/dist/cli.mjs
  *   packages/

package/packages/shared/src/__tests__/bootstrap-install-resolve-npm.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Regression: `resolveNpmArgv` from `bootstrap-install.ts` MUST consult
+ * the injected `ToolRegistry` for `npm` before falling back to the
+ * platform `npm` / `npm.cmd` PATH binary.
+ *
+ * The change `embed-managed-node-runtime` adds a managedRuntime
+ * strategy to the npm chain in the registry. If a future refactor
+ * accidentally bypasses the registry inside `resolveNpmArgv`, the
+ * managed Node runtime would stop being preferred for shared bootstrap
+ * spawns \u2014 the user-visible regression class this whole change exists
+ * to prevent.
+ *
+ * See change: embed-managed-node-runtime (task 4.2).
+ */
+import { describe, expect, it } from "vitest";
+import { resolveNpmArgv } from "../bootstrap-install.js";
+import type {
+  Resolution,
+  ToolRegistry,
+} from "../tool-registry/index.js";
+
+function fakeRegistry(opts: {
+  hasNpm?: boolean;
+  resolveResult?: Partial<Resolution>;
+}): ToolRegistry {
+  // Only the methods `resolveNpmArgv` actually calls.
+  return {
+    has: (name: string) => name === "npm" && (opts.hasNpm ?? true),
+    resolve: () =>
+      ({
+        name: "npm",
+        ok: true,
+        path: "/managed/node/bin/npm",
+        source: "managed",
+        tried: [],
+        resolvedAt: Date.now(),
+        ...opts.resolveResult,
+      }) as Resolution,
+  } as unknown as ToolRegistry;
+}
+
+describe("resolveNpmArgv", () => {
+  it("explicit npmArgv wins over registry", () => {
+    const argv = resolveNpmArgv({
+      npmArgv: ["/explicit/node", "/explicit/npm-cli.js"],
+      registry: fakeRegistry({}),
+    });
+    expect(argv).toEqual(["/explicit/node", "/explicit/npm-cli.js"]);
+  });
+
+  it("uses ToolRegistry.resolve('npm') when no explicit argv", () => {
+    const argv = resolveNpmArgv({
+      registry: fakeRegistry({
+        resolveResult: { ok: true, path: "/managed/node/bin/npm" } as Partial<Resolution>,
+      }),
+    });
+    expect(argv).toEqual(["/managed/node/bin/npm"]);
+  });
+
+  it("falls back to npm/npm.cmd on PATH when registry has no entry", () => {
+    const argv = resolveNpmArgv({
+      registry: {
+        has: () => false,
+        resolve: () => {
+          throw new Error("should not be called");
+        },
+      } as unknown as ToolRegistry,
+    });
+    expect(argv).toHaveLength(1);
+    expect(argv[0]).toMatch(/^npm(\.cmd)?$/);
+  });
+});

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

@@ -12,8 +12,13 @@ import type {
   BrowserPromptDismissMessage,
   BrowserPromptCancelMessage,
   BrowserExtUiDecoratorMessage,
+  BrowserAssetRegisterMessage,
 } from "../browser-protocol.js";
-import type { ExtensionToServerMessage, ExtUiDecoratorMessage } from "../protocol.js";
+import type {
+  ExtensionToServerMessage,
+  ExtUiDecoratorMessage,
+  AssetRegisterMessage,
+} 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.
@@ -26,6 +31,11 @@ type _PromptCancelInUnion = AssertExtends<BrowserPromptCancelMessage, ServerToBr
 // esbuild strips the switch arms in production builds.
 type _ExtUiDecoratorInExtensionUnion = AssertExtends<ExtUiDecoratorMessage, ExtensionToServerMessage>;
 type _ExtUiDecoratorInBrowserUnion   = AssertExtends<BrowserExtUiDecoratorMessage, ServerToBrowserMessage>;
+// chat-markdown-local-images-and-math: asset_register must live in BOTH the
+// extension→server union (so the server's switch arm survives esbuild) AND
+// the server→browser union (so the client's reducer arm survives esbuild).
+type _AssetRegisterInExtensionUnion = AssertExtends<AssetRegisterMessage, ExtensionToServerMessage>;
+type _AssetRegisterInBrowserUnion   = AssertExtends<BrowserAssetRegisterMessage, ServerToBrowserMessage>;
 
 // Runtime verification that the type discriminants are reachable in a switch
 function extractPromptType(msg: ServerToBrowserMessage): string | null {
@@ -119,3 +129,39 @@ describe("ext_ui_decorator is a member of both protocol unions", () => {
     expect(msg.descriptor.kind).toBe("footer-segment");
   });
 });
+
+// chat-markdown-local-images-and-math: asset_register switch-arm reachability.
+function extractAssetHash(msg: ServerToBrowserMessage): string | null {
+  switch (msg.type) {
+    case "asset_register":
+      return msg.hash;
+    default:
+      return null;
+  }
+}
+
+describe("asset_register is a member of both protocol unions", () => {
+  it("server→browser asset_register is a valid discriminant", () => {
+    const msg: BrowserAssetRegisterMessage = {
+      type: "asset_register",
+      sessionId: "s1",
+      hash: "abc1234567890123",
+      mimeType: "image/png",
+      data: "iVBORw0KGgo=",
+    };
+    expect(extractAssetHash(msg)).toBe("abc1234567890123");
+  });
+
+  it("extension→server asset_register carries the same shape", () => {
+    const msg: AssetRegisterMessage = {
+      type: "asset_register",
+      sessionId: "s1",
+      hash: "abc1234567890123",
+      mimeType: "image/svg+xml",
+      data: "PHN2Zy8+",
+    };
+    expect(msg.type).toBe("asset_register");
+    expect(msg.hash).toBe("abc1234567890123");
+    expect(msg.mimeType).toBe("image/svg+xml");
+  });
+});

package/packages/shared/src/__tests__/changelog-types.test.ts

@@ -0,0 +1,78 @@
+/**
+ * Type-only assertions for changelog-types. The runtime body is a
+ * single `expect(true).toBe(true)` — the real test is that the
+ * `const x: T = {...}` literal blocks compile under `tsc --noEmit`
+ * during the normal test run.
+ *
+ * See change: pi-update-whats-new-panel.
+ */
+import { describe, it, expect } from "vitest";
+import type {
+  ChangelogBullet,
+  ChangelogRelease,
+  ChangelogResponse,
+} from "../changelog-types.js";
+
+describe("changelog-types", () => {
+  it("ChangelogBullet accepts minimal and full shapes", () => {
+    const minimal: ChangelogBullet = { text: "fix a bug", issues: [] };
+    const full: ChangelogBullet = {
+      text: "fix a bug ([#3588](https://github.com/x/y/issues/3588))",
+      issues: [{ num: 3588, url: "https://github.com/x/y/issues/3588" }],
+    };
+    expect(minimal.text).toBe("fix a bug");
+    expect(full.issues[0].num).toBe(3588);
+  });
+
+  it("ChangelogRelease accepts a fully populated entry", () => {
+    const rel: ChangelogRelease = {
+      version: "0.70.0",
+      date: "2026-04-23",
+      breaking: [{ text: "...", issues: [] }],
+      features: [{ text: "...", issues: [] }],
+      changed: [],
+      fixed: [{ text: "...", issues: [] }],
+      raw: "## [0.70.0] - 2026-04-23\n\n…",
+    };
+    expect(rel.version).toBe("0.70.0");
+  });
+
+  it("ChangelogRelease tolerates null date", () => {
+    const rel: ChangelogRelease = {
+      version: "0.0.1",
+      date: null,
+      breaking: [],
+      features: [],
+      changed: [],
+      fixed: [],
+      raw: "",
+    };
+    expect(rel.date).toBeNull();
+  });
+
+  it("ChangelogResponse wraps a release list", () => {
+    const resp: ChangelogResponse = {
+      pkg: "@mariozechner/pi-coding-agent",
+      from: "0.62.0",
+      to: "0.70.0",
+      releases: [],
+      hasBreaking: false,
+      changelogUrl: null,
+      parsedAt: "2026-05-08T12:00:00.000Z",
+    };
+    expect(resp.releases).toHaveLength(0);
+  });
+
+  it("ChangelogResponse allows null changelogUrl", () => {
+    const resp: ChangelogResponse = {
+      pkg: "x",
+      from: "1.0.0",
+      to: "1.0.1",
+      releases: [],
+      hasBreaking: false,
+      changelogUrl: null,
+      parsedAt: new Date().toISOString(),
+    };
+    expect(resp.changelogUrl).toBeNull();
+  });
+});

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

@@ -471,3 +471,51 @@ describe("loadConfig reattachPlacement", () => {
     expect(content.reattachPlacement).toBeUndefined();
   });
 });
+
+describe("loadConfig spawnRegisterTimeoutMs", () => {
+  let testDir: string;
+  let configFile: string;
+  let origHome: string;
+
+  beforeEach(() => {
+    testDir = path.join(os.tmpdir(), `test-config-srt-${Date.now()}`);
+    fs.mkdirSync(path.join(testDir, ".pi", "dashboard"), { recursive: true });
+    configFile = path.join(testDir, ".pi", "dashboard", "config.json");
+    origHome = process.env.HOME!;
+    process.env.HOME = testDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = origHome;
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true });
+  });
+
+  it("defaults to 30000 when field is omitted", () => {
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+
+  it("preserves in-range value", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 45000 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(45000);
+  });
+
+  it("clamps below-range value to 5000", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 1000 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(5000);
+  });
+
+  it("clamps above-range value to 120000", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 999999 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(120000);
+  });
+
+  it("falls back to default for non-number string", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: "thirty" }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+
+  it("falls back to default for null", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: null }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+});

package/packages/shared/src/__tests__/dashboard-starter.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { parseDashboardStarter } from "../dashboard-starter.js";
+
+describe("parseDashboardStarter", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns Standalone when env is empty object", () => {
+    expect(parseDashboardStarter({})).toBe("Standalone");
+  });
+
+  it("returns Standalone when DASHBOARD_STARTER is undefined", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: undefined })).toBe("Standalone");
+  });
+
+  it("returns Standalone when DASHBOARD_STARTER is empty string", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "" })).toBe("Standalone");
+  });
+
+  it("returns Bridge for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Bridge" })).toBe("Bridge");
+  });
+
+  it("returns Standalone for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Standalone" })).toBe("Standalone");
+  });
+
+  it("returns Electron for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Electron" })).toBe("Electron");
+  });
+
+  it("returns Standalone and warns on invalid value", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const result = parseDashboardStarter({ DASHBOARD_STARTER: "bogus" });
+    expect(result).toBe("Standalone");
+    expect(warnSpy).toHaveBeenCalledOnce();
+    expect(warnSpy.mock.calls[0]![0]).toContain("bogus");
+  });
+});

package/packages/shared/src/__tests__/detached-spawn.test.ts

@@ -61,6 +61,30 @@ describe("spawnDetached", () => {
     rmSync(path.dirname(logPath), { recursive: true, force: true });
   });
 
+  // See change: fix-electron-extracted-jiti-and-stdio-capture.
+  it("redirects BOTH stdout and stderr to logFd when provided", async () => {
+    const logPath = tmpLog();
+    const fd = openSync(logPath, "a");
+    try {
+      const r = await spawnDetached({
+        cmd: process.execPath,
+        args: [
+          "-e",
+          "console.log('STDOUT-LINE'); process.stderr.write('STDERR-LINE'); setTimeout(() => process.exit(0), 100)",
+        ],
+        logFd: fd,
+      });
+      expect(r.ok).toBe(true);
+      await new Promise((res) => r.process!.once("exit", res));
+    } finally {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+    const content = readFileSync(logPath, "utf-8");
+    expect(content).toContain("STDOUT-LINE");
+    expect(content).toContain("STDERR-LINE");
+    rmSync(path.dirname(logPath), { recursive: true, force: true });
+  });
+
   it("does not keep parent event loop alive (unref)", async () => {
     // Can only check behaviour indirectly: the returned pid/process exist
     // and the child is running detached. Lifecycle survival is covered by

package/packages/shared/src/__tests__/doctor-core.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Doctor core — section assignment, suggestion taxonomy, and the
+ * Decision-8 lint (every non-ok check has non-empty
+ * message/detail/suggestion). See change: doctor-rich-output.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  SECTION_OF,
+  SUGGESTIONS,
+  stampSectionsAndSuggestions,
+  type DoctorCheck,
+  type DoctorStatus,
+} from "../doctor-core.js";
+
+const ALL_CHECK_NAMES = Object.keys(SECTION_OF);
+
+describe("SECTION_OF", () => {
+  it("maps every canonical check name to one of the five sections", () => {
+    const allowed = new Set(["runtime", "pi-tooling", "server", "setup", "diagnostics"]);
+    for (const name of ALL_CHECK_NAMES) {
+      expect(allowed.has(SECTION_OF[name])).toBe(true);
+    }
+  });
+
+  it("covers all five sections (none empty)", () => {
+    const sections = new Set(Object.values(SECTION_OF));
+    for (const s of ["runtime", "pi-tooling", "server", "setup", "diagnostics"]) {
+      expect(sections.has(s as never)).toBe(true);
+    }
+  });
+});
+
+describe("SUGGESTIONS", () => {
+  it("returns undefined for status=ok across every check name", () => {
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      expect(fn).toBeDefined();
+      expect(fn?.("ok")).toBeUndefined();
+    }
+  });
+
+  it("returns a non-empty string for status=error or warning when defined", () => {
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      // Electron is the only one that returns undefined even for non-ok
+      // (because today it never fails). Skip it.
+      if (name === "Electron") continue;
+      const w = fn?.("warning");
+      const e = fn?.("error");
+      expect(typeof w === "string" && w.length > 0).toBe(true);
+      expect(typeof e === "string" && e.length > 0).toBe(true);
+    }
+  });
+
+  it("constrains suggestion text to the allowed Markdown subset", () => {
+    // Allowed: **bold**, single-backtick code, [text](url). Disallow: tables,
+    // headings, fenced blocks, raw HTML.
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      const candidates: (string | undefined)[] = [
+        fn?.("warning"),
+        fn?.("error"),
+        fn?.("error", undefined, "not-found"),
+        fn?.("error", undefined, "permission-denied"),
+        fn?.("error", undefined, "timeout"),
+        fn?.("error", undefined, "non-zero-exit"),
+      ];
+      for (const s of candidates) {
+        if (!s) continue;
+        // No fenced code blocks.
+        expect(/```/.test(s)).toBe(false);
+        // No headings at line start.
+        expect(/^#{1,6}\s/m.test(s)).toBe(false);
+        // No raw HTML tags (closing, self-closing, or with attributes).
+        // Plain `<placeholder>` text is allowed (used as prose).
+        expect(/<\/[a-zA-Z]|<[a-zA-Z][^>]*\s+[^>]+>|<[a-zA-Z][^>]*\/>/.test(s)).toBe(false);
+        // Triple-asterisk or underline for bold not allowed.
+        expect(/\*\*\*|___/.test(s)).toBe(false);
+      }
+    }
+  });
+});
+
+describe("stampSectionsAndSuggestions (Decision 8 lint)", () => {
+  it("stamps section + suggestion on non-ok rows by name", () => {
+    const checks: DoctorCheck[] = [
+      { name: "pi CLI", section: undefined as unknown as never, status: "error", message: "Not found", detail: "Searched PATH" },
+      { name: "System Node.js", section: undefined as unknown as never, status: "ok", message: "v22 at /usr/bin/node" },
+    ];
+    const out = stampSectionsAndSuggestions(checks);
+    expect(out[0].section).toBe("pi-tooling");
+    expect(out[0].suggestion).toBeDefined();
+    expect(out[1].section).toBe("runtime");
+    expect(out[1].suggestion).toBeUndefined();
+  });
+
+  it("every non-ok row produced through stamping has non-empty message + detail + suggestion", () => {
+    const statuses: DoctorStatus[] = ["warning", "error"];
+    for (const name of ALL_CHECK_NAMES) {
+      // Electron suggestion is always undefined (decision-by-design); skip.
+      if (name === "Electron") continue;
+      for (const status of statuses) {
+        const checks: DoctorCheck[] = [
+          {
+            name,
+            section: undefined as unknown as never,
+            status,
+            message: "synthetic message",
+            detail: "synthetic detail",
+          },
+        ];
+        const [stamped] = stampSectionsAndSuggestions(checks);
+        expect(stamped.message.length).toBeGreaterThan(0);
+        expect((stamped.detail ?? "").length).toBeGreaterThan(0);
+        expect((stamped.suggestion ?? "").length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it("does not overwrite an existing suggestion", () => {
+    const checks: DoctorCheck[] = [
+      {
+        name: "pi CLI",
+        section: "pi-tooling",
+        status: "error",
+        message: "x",
+        detail: "y",
+        suggestion: "custom",
+      },
+    ];
+    const out = stampSectionsAndSuggestions(checks);
+    expect(out[0].suggestion).toBe("custom");
+  });
+});