@blackbelt-technology/pi-agent-dashboard 0.2.9 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-agent-dashboard",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "description": "Web dashboard for monitoring and interacting with pi agent sessions",
   "repository": {
     "type": "git",
@@ -46,22 +46,29 @@
     "LICENSE"
   ],
   "scripts": {
+    "postinstall": "node packages/server/scripts/fix-pty-permissions.cjs",
     "dev": "npm run dev --workspace=@blackbelt-technology/pi-dashboard-web",
     "build": "npm run build --workspace=@blackbelt-technology/pi-dashboard-web",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest run",
+    "test:watch": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest",
+    "test:bootstrap": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest run packages/shared/src/__tests__/bootstrap",
+    "test:bootstrap:watch": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest packages/shared/src/__tests__/bootstrap",
     "lint": "tsc --noEmit",
     "reload": "./scripts/reload-all.sh",
     "reload:check": "./scripts/reload-all.sh --check",
     "electron:dev": "npm run start:dev --workspace=@blackbelt-technology/pi-dashboard-electron",
     "electron:start": "npm run start --workspace=@blackbelt-technology/pi-dashboard-electron",
     "electron:make": "npm run make --workspace=@blackbelt-technology/pi-dashboard-electron",
-    "electron:build": "bash packages/electron/scripts/build-installer.sh"
+    "electron:build": "bash packages/electron/scripts/build-installer.sh",
+    "site:dev": "npm --prefix site run dev",
+    "site:build": "npm --prefix site run build",
+    "site:preview": "npm --prefix site run preview",
+    "screenshots": "npm --prefix site run screenshots"
   },
   "dependencies": {
-    "@blackbelt-technology/pi-dashboard-extension": "*",
-    "@blackbelt-technology/pi-dashboard-server": "*",
-    "@blackbelt-technology/pi-dashboard-web": "*"
+    "@blackbelt-technology/pi-dashboard-extension": "^0.4.0",
+    "@blackbelt-technology/pi-dashboard-server": "^0.4.0",
+    "@blackbelt-technology/pi-dashboard-web": "^0.4.0"
   },
   "devDependencies": {
     "jsdom": "^29.0.2",

package/packages/extension/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-extension",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "description": "Pi bridge extension for pi-dashboard",
   "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "pi": {
     "extensions": [
       "src/bridge.ts"
@@ -16,18 +19,23 @@
     ".pi/skills/pi-dashboard/"
   ],
   "dependencies": {
-    "@blackbelt-technology/pi-dashboard-shared": "*",
+    "@blackbelt-technology/pi-dashboard-shared": "^0.4.0",
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
       "optional": true
+    },
+    "@mariozechner/pi-tui": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@mariozechner/pi-tui": "*",
     "@types/ws": "^8.18.1"
   }
 }

package/packages/extension/src/__tests__/ask-user-tool.test.ts

@@ -7,6 +7,8 @@ vi.mock("@sinclair/typebox", () => ({
     String: vi.fn(() => ({})),
     Optional: vi.fn((x: any) => x),
     Array: vi.fn(() => ({})),
+    Union: vi.fn(() => ({})),
+    Literal: vi.fn(() => ({})),
   },
 }));
 
@@ -100,10 +102,28 @@ describe("registerAskUserTool", () => {
       expect(ctx.ui.select).toHaveBeenCalledWith("Pick", ["A", "B"], undefined);
     });
 
-    it("handles malformed options string gracefully", async () => {
+    it("throws when select reaches execute with unparseable options string", async () => {
       const { tool, ctx } = getToolAndMockCtx();
-      await tool.execute("id", { method: "select", title: "Pick", options: "not json" }, undefined, undefined, ctx);
-      expect(ctx.ui.select).toHaveBeenCalledWith("Pick", [], undefined);
+      await expect(
+        tool.execute("id", { method: "select", title: "Pick", options: "not json" }, undefined, undefined, ctx),
+      ).rejects.toThrow(/options/i);
+      expect(ctx.ui.select).not.toHaveBeenCalled();
+    });
+
+    it("throws when select is invoked with empty options array", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await expect(
+        tool.execute("id", { method: "select", title: "Pick", options: [] }, undefined, undefined, ctx),
+      ).rejects.toThrow(/options.*input/is);
+      expect(ctx.ui.select).not.toHaveBeenCalled();
+    });
+
+    it("throws when multiselect is invoked without options", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await expect(
+        tool.execute("id", { method: "multiselect", title: "Pick" }, undefined, undefined, ctx),
+      ).rejects.toThrow(/options/i);
+      expect(ctx.ui.multiselect).not.toHaveBeenCalled();
     });
   });
 
@@ -131,5 +151,282 @@ describe("registerAskUserTool", () => {
       const result = tool.prepareArguments({ method: "select", title: "Pick", options: "not json" });
       expect(result.options).toBe("not json");
     });
+
+    it("unwraps stringified params wrapper", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "select",
+        params: '{"title":"X","options":["a","b"]}',
+      });
+      expect(result.method).toBe("select");
+      expect(result.title).toBe("X");
+      expect(result.options).toEqual(["a", "b"]);
+      expect(result.params).toBeUndefined();
+    });
+
+    it("unwraps object-form params wrapper", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "select",
+        params: { title: "X", options: ["a", "b"] },
+      });
+      expect(result.method).toBe("select");
+      expect(result.title).toBe("X");
+      expect(result.options).toEqual(["a", "b"]);
+      expect(result.params).toBeUndefined();
+    });
+
+    it("copies question into title when title is absent", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({ method: "input", question: "Your name?" });
+      expect(result.title).toBe("Your name?");
+    });
+
+    it("does not overwrite explicit title with question", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({ method: "input", title: "T", question: "Q" });
+      expect(result.title).toBe("T");
+    });
+
+    it("top-level fields win over params wrapper", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "select",
+        title: "OuterTitle",
+        params: { title: "InnerTitle", options: ["a", "b"] },
+      });
+      expect(result.title).toBe("OuterTitle");
+      expect(result.options).toEqual(["a", "b"]);
+    });
+
+    it("rescues options JSON string inside params wrapper", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "select",
+        params: '{"title":"X","options":"[\\"a\\",\\"b\\"]"}',
+      });
+      expect(result.options).toEqual(["a", "b"]);
+    });
+
+    // ── batch rescue ────────────────────────────────────────────────
+
+    it("parses stringified questions array and synthesizes method=batch", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        questions:
+          '[{"title":"Pick","method":"select","options":["a","b"]}]',
+      });
+      expect(result.method).toBe("batch");
+      expect(Array.isArray(result.questions)).toBe(true);
+      expect(result.questions).toHaveLength(1);
+      expect(result.title).toBe("Pick");
+    });
+
+    it("backfills missing outer title on explicit method=batch call", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "batch",
+        questions: [
+          { method: "confirm", question: "Proceed?" },
+          { method: "select", question: "Scope?", options: ["A", "B"] },
+        ],
+      });
+      expect(result.title).toBe("Proceed?");
+      expect(result.questions[0].title).toBe("Proceed?"); // sub-question rename also fired
+      expect(result.questions[1].title).toBe("Scope?");
+    });
+
+    it("bare questions array with no method synthesizes method=batch and pulls title", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        questions: [{ method: "confirm", title: "Proceed?" }],
+      });
+      expect(result.method).toBe("batch");
+      expect(result.title).toBe("Proceed?");
+    });
+
+    it("pulls title from question or header if sub-question lacks title", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        questions: [{ method: "input", question: "Your name?" }],
+      });
+      expect(result.method).toBe("batch");
+      expect(result.title).toBe("Your name?");
+    });
+
+    it("flattens input_type wrapper inside a sub-question", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "batch",
+        title: "T",
+        questions: [
+          {
+            title: "Pick",
+            input_type: { method: "select", options: ["a", "b"] },
+          },
+        ],
+      });
+      const sq = result.questions[0];
+      expect(sq.method).toBe("select");
+      expect(sq.options).toEqual(["a", "b"]);
+      expect(sq.input_type).toBeUndefined();
+    });
+
+    it("converts {label, value} options to labels and records a warning", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "batch",
+        title: "T",
+        questions: [
+          {
+            method: "select",
+            title: "Pick",
+            options: [
+              { label: "Sync now", value: "sync" },
+              { label: "Skip", value: "skip" },
+            ],
+          },
+        ],
+      });
+      expect(result.questions[0].options).toEqual(["Sync now", "Skip"]);
+      const warnings = (result as any).__normalizations as string[];
+      expect(warnings).toBeDefined();
+      expect(warnings.length).toBeGreaterThan(0);
+      expect(warnings[0]).toMatch(/label.*value/);
+    });
+
+    it("renames sub-question header to title", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({
+        method: "batch",
+        title: "T",
+        questions: [{ method: "input", header: "Enter name" }],
+      });
+      expect(result.questions[0].title).toBe("Enter name");
+    });
+  });
+
+  describe("batch execution", () => {
+    function getToolAndMockCtx() {
+      const pi = createMockPi();
+      registerAskUserTool(pi as any);
+      const tool = pi.registerTool.mock.calls[0][0];
+      const ctx = {
+        ui: {
+          confirm: vi.fn().mockResolvedValue(true),
+          select: vi.fn().mockResolvedValue("A"),
+          input: vi.fn().mockResolvedValue("hello"),
+          multiselect: vi.fn().mockResolvedValue(["A"]),
+        },
+      };
+      return { tool, ctx };
+    }
+
+    it("invokes ctx.ui primitives sequentially for each sub-question", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      const result = await tool.execute(
+        "id",
+        {
+          method: "batch",
+          title: "Setup",
+          questions: [
+            { method: "input", title: "Name?" },
+            { method: "select", title: "Lang?", options: ["TS", "Py"] },
+            { method: "confirm", title: "Init git?" },
+          ],
+        },
+        undefined,
+        undefined,
+        ctx,
+      );
+      expect(ctx.ui.input).toHaveBeenCalledTimes(1);
+      expect(ctx.ui.select).toHaveBeenCalledTimes(1);
+      expect(ctx.ui.confirm).toHaveBeenCalledTimes(1);
+      expect(result.details.method).toBe("batch");
+      expect(result.details.results).toEqual(["hello", "A", true]);
+      expect(result.details.cancelled).toBe(false);
+    });
+
+    it("prepends batch title to sub-question titles", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await tool.execute(
+        "id",
+        {
+          method: "batch",
+          title: "Setup",
+          questions: [{ method: "input", title: "Name?" }],
+        },
+        undefined,
+        undefined,
+        ctx,
+      );
+      const firstCallTitle = ctx.ui.input.mock.calls[0][0];
+      expect(firstCallTitle).toContain("Setup");
+      expect(firstCallTitle).toContain("Name?");
+    });
+
+    it("stops on cancellation and returns partial results with cancelled=true", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      // First sub-question returns a value; second cancels (undefined); third should not be called.
+      ctx.ui.input.mockResolvedValueOnce("first");
+      ctx.ui.select.mockResolvedValueOnce(undefined); // cancel
+      const result = await tool.execute(
+        "id",
+        {
+          method: "batch",
+          title: "T",
+          questions: [
+            { method: "input", title: "Q1" },
+            { method: "select", title: "Q2", options: ["a", "b"] },
+            { method: "confirm", title: "Q3" },
+          ],
+        },
+        undefined,
+        undefined,
+        ctx,
+      );
+      expect(result.details.cancelled).toBe(true);
+      expect(result.details.results).toEqual(["first", null]);
+      expect(ctx.ui.confirm).not.toHaveBeenCalled();
+    });
+
+    it("surfaces __normalizations warnings in details.warnings", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      const prepared = tool.prepareArguments({
+        method: "batch",
+        title: "T",
+        questions: [
+          {
+            method: "select",
+            title: "Pick",
+            options: [
+              { label: "A", value: "a" },
+              { label: "B", value: "b" },
+            ],
+          },
+        ],
+      });
+      const result = await tool.execute("id", prepared, undefined, undefined, ctx);
+      expect(result.details.warnings).toBeDefined();
+      expect(result.details.warnings.length).toBeGreaterThan(0);
+      expect(result.details.warnings[0]).toMatch(/label.*value/);
+    });
+
+    it("throws if a batch sub-question is select with empty options", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await expect(
+        tool.execute(
+          "id",
+          {
+            method: "batch",
+            title: "T",
+            questions: [{ method: "select", title: "Pick", options: [] }],
+          },
+          undefined,
+          undefined,
+          ctx,
+        ),
+      ).rejects.toThrow(/options/i);
+    });
   });
 });

package/packages/extension/src/__tests__/enrich-model-metadata.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for enrichModelMetadata — the pure helper that resolves a discovered
+ * custom-provider model id against a catalog probe (typically backed by pi's
+ * `modelRegistry.find(provider, id)`) and falls back to api-appropriate
+ * defaults when the probe has no match.
+ *
+ * The helper takes an optional `probe` parameter so unit tests can supply a
+ * fake catalog without needing `@mariozechner/pi-ai` installed — in
+ * production, registerEntry() injects `modelRegistry.find` as the probe.
+ *
+ * Spec: openspec/changes/enrich-custom-provider-model-metadata/specs/provider-auth-bridge/spec.md
+ */
+
+import { describe, it, expect } from "vitest";
+import { enrichModelMetadata, type CatalogProbe } from "../provider-register.js";
+
+// Minimal fake catalog mirroring a subset of pi-ai's real MODELS export.
+// Keys are `${provider}|${id}` so our probe is a single Map lookup.
+const FAKE_CATALOG = new Map<string, any>([
+  [
+    "anthropic|claude-opus-4-7",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-sonnet-4-6",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-haiku-4-5",
+    {
+      contextWindow: 200_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "openai|gpt-5",
+    {
+      contextWindow: 400_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "opencode|claude-opus-4-7",
+    {
+      // Deliberately different values so tests can prove the candidate-
+      // provider probe order is deterministic (anthropic checked first).
+      contextWindow: 999,
+      maxTokens: 1,
+      reasoning: true,
+      cost: { input: 9, output: 9, cacheRead: 9, cacheWrite: 9 },
+      input: ["text"],
+    },
+  ],
+]);
+
+const fakeProbe: CatalogProbe = (provider, id) =>
+  FAKE_CATALOG.get(`${provider}|${id}`) ?? null;
+
+describe("enrichModelMetadata — catalog matches via probe", () => {
+  it("resolves `cc/claude-opus-4-7` + anthropic-messages to Opus 4.7 catalog entry (1M ctx)", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost).toEqual({
+      input: 5,
+      output: 25,
+      cacheRead: 0.5,
+      cacheWrite: 6.25,
+    });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("resolves bare `claude-sonnet-4-6` + anthropic-messages to Sonnet 4.6 (1M ctx)", () => {
+    const result = enrichModelMetadata("claude-sonnet-4-6", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.reasoning).toBe(true);
+  });
+
+  it("resolves `anthropic/claude-opus-4-7` prefix to Opus 4.7 (1M ctx)", () => {
+    const result = enrichModelMetadata("anthropic/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("resolves `claude-haiku-4-5` + anthropic-messages to Haiku 4.5 (200k ctx — verifies we don't over-claim)", () => {
+    const result = enrichModelMetadata("claude-haiku-4-5", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost.input).toBe(1);
+    expect(result.cost.output).toBe(5);
+  });
+
+  it("resolves `openrouter/openai/gpt-5` prefix to gpt-5 via openai-completions candidates", () => {
+    const result = enrichModelMetadata("openrouter/openai/gpt-5", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(400_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+  });
+});
+
+describe("enrichModelMetadata — fallback defaults (no probe or no match)", () => {
+  it("no probe supplied → falls back to api-appropriate default", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages");
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+  });
+
+  it("unknown id + anthropic-messages returns 200k / 64k / no reasoning / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-anthropic-model", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + openai-completions returns 128k / 16k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-openai-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + google-generative-ai returns 1M / 65k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-gemini-model", "google-generative-ai", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(65_536);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("prefixed unknown + openai-completions falls back (both prefixed and bare miss)", () => {
+    const result = enrichModelMetadata("minimax/custom-private-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.cost.input).toBe(0);
+  });
+
+  it("no api argument + no probe defaults to openai-completions fallback", () => {
+    const result = enrichModelMetadata("some-unknown-model");
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown api string + probe still probes openai-completions candidates", () => {
+    const result = enrichModelMetadata("some-unknown-model", "some-weird-api", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+  });
+
+  it("probe that throws is tolerated (falls through to fallback)", () => {
+    const throwingProbe: CatalogProbe = () => {
+      throw new Error("registry not ready");
+    };
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", throwingProbe);
+    expect(result.contextWindow).toBe(200_000); // anthropic-messages fallback
+  });
+});
+
+describe("enrichModelMetadata — probe order determinism", () => {
+  it("prefers `anthropic` over `opencode` for anthropic-messages (first in candidate list wins)", () => {
+    // The fake catalog has `claude-opus-4-7` under BOTH `anthropic` (1M) and
+    // `opencode` (999). With api=anthropic-messages, candidates = ["anthropic", "opencode"]
+    // so the anthropic entry must win.
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("multi-segment prefix `openrouter/anthropic/claude-opus-4-7` resolves via bare-id lookup", () => {
+    // After stripping the last segment, `claude-opus-4-7` matches `anthropic` (1M).
+    const result = enrichModelMetadata(
+      "openrouter/anthropic/claude-opus-4-7",
+      "anthropic-messages",
+      fakeProbe,
+    );
+    expect(result.contextWindow).toBe(1_000_000);
+  });
+});