@blackbelt-technology/pi-agent-dashboard 0.4.5 → 0.5.0

package/packages/shared/src/platform/managed-node-path.ts

@@ -0,0 +1,77 @@
+/**
+ * Prepend the managed Node runtime directory to a child-process `PATH`.
+ *
+ * The managed Node lives at `<managedDir>/node/` (Windows: binaries at
+ * the root; Unix: binaries under `bin/`). When present, every spawn the
+ * dashboard controls SHALL inherit that directory at the front of its
+ * `PATH` so plain `node` / `npm` invocations inside the child process
+ * resolve to the managed runtime.
+ *
+ * Pure helper: never mutates `process.env`, returns a distinct cloned
+ * env object, no-ops when the managed runtime is absent.
+ *
+ * See change: embed-managed-node-runtime (spec: managed-node-runtime,
+ * Requirement: Spawned children inherit managed Node on PATH).
+ */
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { getManagedDir, type ManagedPathsEnv } from "../managed-paths.js";
+
+/**
+ * Resolve the bin directory inside the managed Node tree.
+ *   Windows: `<managedDir>/node`        (node.exe + npm.cmd live at root)
+ *   Unix:    `<managedDir>/node/bin`    (node, npm, npx live under bin/)
+ *
+ * `platform` defaults to `process.platform`; tests inject `"win32"` from
+ * a Linux host to exercise the Windows layout.
+ */
+export function getManagedNodeBinDir(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const root = path.join(getManagedDir(env), "node");
+  return platform === "win32" ? root : path.join(root, "bin");
+}
+
+/** Path to the managed `node` / `node.exe` binary. */
+export function getManagedNodeBinary(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const bin = getManagedNodeBinDir(env, platform);
+  return path.join(bin, platform === "win32" ? "node.exe" : "node");
+}
+
+/** True iff the managed Node runtime is installed (binary exists). */
+export function isManagedNodePresent(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  return existsSync(getManagedNodeBinary(env, platform));
+}
+
+/**
+ * Return a shallow-cloned env with the managed Node bin directory
+ * prepended to `PATH`. No-op (still returns a clone) when the managed
+ * runtime is not installed or its directory is already on PATH.
+ *
+ * Never mutates the input env or `process.env`.
+ */
+export function prependManagedNodeToPath(
+  baseEnv: NodeJS.ProcessEnv = process.env,
+  managedPathsEnv?: ManagedPathsEnv,
+): NodeJS.ProcessEnv {
+  const cloned: NodeJS.ProcessEnv = { ...baseEnv };
+  if (!isManagedNodePresent(managedPathsEnv)) return cloned;
+
+  const dir = getManagedNodeBinDir(managedPathsEnv);
+  const currentPath = cloned.PATH ?? "";
+  // Avoid duplicate prepends when the dir is already at the head; cheap
+  // string contains check matches `buildSpawnEnv` style.
+  if (currentPath.split(path.delimiter).includes(dir)) return cloned;
+
+  cloned.PATH = currentPath
+    ? `${dir}${path.delimiter}${currentPath}`
+    : dir;
+  return cloned;
+}

package/packages/shared/src/protocol.ts

@@ -1,7 +1,7 @@
 /**
  * Extension ↔ Server WebSocket protocol messages.
  */
-import type { DashboardEvent, CommandInfo, FlowInfo, SessionSource, ImageContent, FileEntry, TurnUsage, ContextUsage, ModelInfo, PiSessionInfo, OpenSpecPhase, RoleInfo, ExtensionUiModule, DecoratorDescriptor } from "./types.js";
+import type { DashboardEvent, CommandInfo, FlowInfo, SessionSource, ImageContent, FileEntry, TurnUsage, ContextUsage, ModelInfo, ProviderInfo, PiSessionInfo, OpenSpecPhase, RoleInfo, ExtensionUiModule, DecoratorDescriptor } from "./types.js";
 
 // ── Extension → Server ──────────────────────────────────────────────
 
@@ -130,6 +130,19 @@ export interface GitInfoUpdateMessage {
   gitPrUrl?: string;
 }
 
+/**
+ * Bridge → server: jj workspace state for the session's cwd.
+ * Sent only when the bridge's VCS probe finds `.jj/` AND `jj` resolves
+ * via the tool registry. Cleared (sent with `jjState: null`) when the
+ * session leaves a jj repo (e.g. cwd switch). See change: add-jj-workspace-plugin.
+ */
+export interface JjStateUpdateMessage {
+  type: "jj_state_update";
+  sessionId: string;
+  /** `null` clears the session's `jjState` field on the server. */
+  jjState: import("./types.js").JjState | null;
+}
+
 // OpenSpecUpdateMessage removed — server polls directly via DirectoryService
 
 export interface ModelsListMessage {
@@ -138,6 +151,17 @@ export interface ModelsListMessage {
   models: ModelInfo[];
 }
 
+/**
+ * Bridge -> server: pi's live provider catalogue derived from
+ * `modelRegistry.authStorage` + `modelRegistry.getProviderDisplayName`.
+ * Sent alongside ModelsListMessage. See change: replace-hardcoded-provider-lists.
+ */
+export interface ProvidersListMessage {
+  type: "providers_list";
+  sessionId: string;
+  providers: ProviderInfo[];
+}
+
 export interface SessionNameUpdateMessage {
   type: "session_name_update";
   sessionId: string;
@@ -273,6 +297,27 @@ export interface ExtUiDecoratorMessage {
   removed?: boolean;
 }
 
+// ── Markdown asset inlining (chat-markdown-local-images-and-math) ──
+//
+// Bridge → server: register a base64-encoded image asset under a content
+// hash. Emitted by the bridge BEFORE the `message_update` / `message_end`
+// event whose text references `pi-asset:<hash>`. Bytes ride exactly once
+// per (session, hash) pair — subsequent references in later events emit
+// no further `asset_register`. Persisted in `events.jsonl` alongside the
+// referencing message events so reconnect/replay rebuilds the per-session
+// asset registry deterministically. See change:
+// chat-markdown-local-images-and-math.
+export interface AssetRegisterMessage {
+  type: "asset_register";
+  sessionId: string;
+  /** Content hash (sha256 truncated to 16 hex chars). */
+  hash: string;
+  /** MIME type (one of the bridge's image allowlist). */
+  mimeType: string;
+  /** Base64-encoded file bytes. */
+  data: string;
+}
+
 export type ExtensionToServerMessage =
   | SessionRegisterMessage
   | SessionUnregisterMessage
@@ -283,8 +328,10 @@ export type ExtensionToServerMessage =
   | ExtensionUiRequestMessage
   | FilesListMessage
   | GitInfoUpdateMessage
+  | JjStateUpdateMessage
   | SessionNameUpdateMessage
   | ModelsListMessage
+  | ProvidersListMessage
   | ModelUpdateMessage
   | SessionsListExtensionMessage
   | ExtensionUiDismissMessage
@@ -298,7 +345,8 @@ export type ExtensionToServerMessage =
   | ProcessListMessage
   | UiModulesListMessage
   | UiDataListMessage
-  | ExtUiDecoratorMessage;
+  | ExtUiDecoratorMessage
+  | AssetRegisterMessage;
 
 // ── Server → Extension ──────────────────────────────────────────────
 
@@ -343,6 +391,15 @@ export interface RequestModelsMessage {
   sessionId: string;
 }
 
+/**
+ * Server -> bridge: ask the bridge to push a fresh providers_list.
+ * See change: replace-hardcoded-provider-lists.
+ */
+export interface RequestProvidersMessage {
+  type: "request_providers";
+  sessionId: string;
+}
+
 export interface SetThinkingLevelMessage {
   type: "set_thinking_level";
   sessionId: string;
@@ -500,6 +557,7 @@ export type ServerToExtensionMessage =
   | ListFilesMessage
   | RenameSessionExtensionMessage
   | RequestModelsMessage
+  | RequestProvidersMessage
   | SetThinkingLevelMessage
   | ListSessionsExtensionMessage
   | SetModelMessage

package/packages/shared/src/rest-api.ts

@@ -255,6 +255,10 @@ export interface ProviderAuthStatus {
   authenticated: boolean;
   expires?: number;
   maskedKey?: string;
+  /** Name of the env var pi-ai consults for this provider (api-key rows only). */
+  envVar?: string;
+  /** True when configured via ambient credential chain (AWS profile / GCP ADC). */
+  ambient?: boolean;
 }
 
 export interface AuthorizeResponse {

package/packages/shared/src/skill-block-parser.ts

@@ -0,0 +1,115 @@
+/**
+ * Skill block parser & builder.
+ *
+ * Pi's `_expandSkillCommand` (in `@mariozechner/pi-coding-agent`) wraps skill
+ * expansions in a `<skill name="..." location="...">…</skill>\n\nargs` envelope.
+ * The dashboard's bridge expander (`packages/extension/src/prompt-expander.ts`)
+ * aligns to the same byte format. This module is the single source of truth for
+ * both producing and recovering that envelope.
+ *
+ * See change: render-skill-invocations-collapsibly.
+ */
+
+export interface SkillBlock {
+  /** Bare skill name (no `skill:` prefix), e.g. `"openspec-explore"`. */
+  name: string;
+  /** Absolute path to `SKILL.md`. */
+  location: string;
+  /**
+   * Skill body with the `References are relative to <baseDir>.\n\n` preamble
+   * stripped — what users see in the card. The preamble is bridge-internal
+   * orientation for the LLM and is not interesting to users.
+   *
+   * Pi's own `parseSkillBlock` returns the unstripped form (calls it `content`).
+   * We strip here so the renderer doesn't have to. If the preamble shape ever
+   * changes upstream and stripping fails, `body` falls back to the captured
+   * content verbatim.
+   */
+  body: string;
+  /** User text after the skill name. `undefined` when no args were typed. */
+  args: string | undefined;
+  /** Slash-command form: `"/skill:" + name + (args ? " " + args : "")`. */
+  condensed: string;
+}
+
+/**
+ * Anchored, non-greedy match of a wrapped skill block.
+ *
+ * Why anchored: prevents a literal `<skill>` substring elsewhere in user text
+ * from matching. Why non-greedy + optional trailing args at end-of-string:
+ * forces the regex engine to extend the body to the last valid
+ * `\n</skill>(\n\nargs)?$` boundary, so SKILL.md bodies that document the
+ * `<skill>` tag (e.g. include the literal text in code samples) do not
+ * terminate the match prematurely.
+ */
+const SKILL_BLOCK_RE =
+  /^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/;
+
+/**
+ * Parse a skill block from message text. Returns `null` when the input is not
+ * a well-formed skill envelope.
+ */
+/**
+ * Strip the `References are relative to <baseDir>.\n\n` preamble from a captured
+ * `<skill>` content block. Returns the stripped body, or the input unchanged if
+ * the preamble shape doesn't match.
+ */
+function stripReferencesPreamble(content: string): string {
+  const m = content.match(/^References are relative to [^\n]+\.\n\n([\s\S]*)$/);
+  return m ? m[1] : content;
+}
+
+export function parseSkillBlock(text: string): SkillBlock | null {
+  const m = text.match(SKILL_BLOCK_RE);
+  if (!m) return null;
+  const name = m[1];
+  const location = m[2];
+  const body = stripReferencesPreamble(m[3]);
+  const args = m[4];
+  const condensed = `/skill:${name}${args ? " " + args : ""}`;
+  return { name, location, body, args, condensed };
+}
+
+export interface BuildSkillBlockArgs {
+  /** Bare skill name (no `skill:` prefix). */
+  name: string;
+  /** Absolute path to `SKILL.md`. */
+  filePath: string;
+  /** Skill base directory — `dirname(filePath)`. */
+  baseDir: string;
+  /** Skill body, frontmatter already stripped. Should be `.trim()`-ed. */
+  body: string;
+  /** Optional user-typed args appended after the closing tag. */
+  userArgs?: string;
+}
+
+/**
+ * Build a skill block in the exact byte format pi's `_expandSkillCommand`
+ * produces. The output is byte-identical to pi's output for the same inputs;
+ * `parseSkillBlock(buildSkillBlock(x))` round-trips for `name`, `body`, `args`.
+ */
+export function buildSkillBlock(input: BuildSkillBlockArgs): string {
+  const wrapper =
+    `<skill name="${input.name}" location="${input.filePath}">\n` +
+    `References are relative to ${input.baseDir}.\n\n` +
+    `${input.body}\n` +
+    `</skill>`;
+  return input.userArgs ? `${wrapper}\n\n${input.userArgs}` : wrapper;
+}
+
+/**
+ * Condense a user-message content string for `firstMessage` / display purposes.
+ *
+ * If `text` parses as a `<skill>` envelope, returns the slash-command form
+ * (`/skill:name args`) truncated to `maxLen` chars. Otherwise returns
+ * `text.slice(0, maxLen)`. Used by session-scanner / session-discovery so the
+ * 200-char `firstMessage` shows the recognisable slash form instead of the
+ * front of an opaque wrapper.
+ *
+ * See change: render-skill-invocations-collapsibly.
+ */
+export function condenseForFirstMessage(text: string, maxLen: number): string {
+  const block = parseSkillBlock(text);
+  if (block) return block.condensed.slice(0, maxLen);
+  return text.slice(0, maxLen);
+}

package/packages/shared/src/tool-registry/__tests__/managed-runtime-strategy.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Chain-order tests for the managed-Node runtime strategy.
+ *
+ * After change `embed-managed-node-runtime`, the `node` and `npm`
+ * strategy chains gain a `managedRuntimeStrategy` between
+ * `overrideStrategy` and the existing PATH/where lookup. These tests
+ * pin the precedence:
+ *
+ *   1. override (tool-overrides.json)        — wins
+ *   2. managed runtime (<managedDir>/node/)  — preferred over PATH
+ *   3. where / PATH                          — fallback
+ *
+ * `exists` is injected so no real filesystem is touched.
+ *
+ * See change: embed-managed-node-runtime (task 3.3).
+ */
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  ToolRegistry,
+  registerDefaultTools,
+  OverridesStore,
+} from "../index.js";
+
+function freshRegistry(opts: {
+  exists?: (p: string) => boolean;
+  which?: (name: string) => string | null;
+  overrides?: Record<string, string>;
+  platform?: NodeJS.Platform;
+}) {
+  const store = new OverridesStore({
+    filePath: path.join(os.tmpdir(), `mr-test-${Math.random()}.json`),
+    warn: () => {},
+  });
+  for (const [k, v] of Object.entries(opts.overrides ?? {})) store.set(k, v);
+
+  const r = new ToolRegistry({
+    overrides: store,
+    platform: opts.platform ?? "linux",
+  });
+  registerDefaultTools(r, {
+    exists: opts.exists ?? (() => false),
+    which: opts.which ?? (() => null),
+    npmRootGlobal: () => "",
+  });
+  return r;
+}
+
+const HOME = os.homedir();
+const MANAGED_NODE_UNIX = path.join(HOME, ".pi-dashboard", "node", "bin", "node");
+const MANAGED_NPM_UNIX = path.join(HOME, ".pi-dashboard", "node", "bin", "npm");
+const MANAGED_NODE_WIN = path.join(HOME, ".pi-dashboard", "node", "node.exe");
+const MANAGED_NPM_WIN = path.join(HOME, ".pi-dashboard", "node", "npm.cmd");
+
+describe("node: managed-runtime strategy precedence", () => {
+  it("managed runtime present → returned over PATH (Unix)", () => {
+    const r = freshRegistry({
+      platform: "linux",
+      exists: (p) => p === MANAGED_NODE_UNIX,
+      which: () => "/usr/bin/node",
+    });
+    const res = r.resolve("node");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(MANAGED_NODE_UNIX);
+    expect(res.source).toBe("managed");
+  });
+
+  it("managed runtime present → returned over PATH (Windows)", () => {
+    const r = freshRegistry({
+      platform: "win32",
+      exists: (p) => p === MANAGED_NODE_WIN,
+      which: () => "C:\\node\\node.exe",
+    });
+    const res = r.resolve("node");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(MANAGED_NODE_WIN);
+    expect(res.source).toBe("managed");
+  });
+
+  it("override wins over managed runtime", () => {
+    const custom = "/opt/custom/node";
+    const r = freshRegistry({
+      platform: "linux",
+      overrides: { node: custom },
+      exists: (p) => p === custom || p === MANAGED_NODE_UNIX,
+    });
+    const res = r.resolve("node");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(custom);
+    expect(res.source).toBe("override");
+  });
+
+  it("both absent → falls through to PATH lookup", () => {
+    const r = freshRegistry({
+      platform: "linux",
+      exists: () => false,
+      which: (name) => (name === "node" ? "/usr/bin/node" : null),
+    });
+    const res = r.resolve("node");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe("/usr/bin/node");
+    expect(res.source).toBe("system");
+  });
+
+  it("nothing present → ok:false with diagnostic trail", () => {
+    const r = freshRegistry({ platform: "linux", exists: () => false, which: () => null });
+    const res = r.resolve("node");
+    expect(res.ok).toBe(false);
+    const trailNames = res.tried.map((t) => t.strategy);
+    expect(trailNames).toContain("override");
+    expect(trailNames).toContain("managed");
+    expect(trailNames).toContain("where");
+  });
+});
+
+describe("npm: managed-runtime strategy precedence", () => {
+  it("managed npm present → returned over PATH (Unix)", () => {
+    const r = freshRegistry({
+      platform: "linux",
+      exists: (p) => p === MANAGED_NPM_UNIX,
+      which: () => "/usr/bin/npm",
+    });
+    const res = r.resolve("npm");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(MANAGED_NPM_UNIX);
+    expect(res.source).toBe("managed");
+  });
+
+  it("managed npm present → returned over PATH (Windows)", () => {
+    const r = freshRegistry({
+      platform: "win32",
+      exists: (p) => p === MANAGED_NPM_WIN,
+      which: () => "C:\\node\\npm.cmd",
+    });
+    const res = r.resolve("npm");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(MANAGED_NPM_WIN);
+    expect(res.source).toBe("managed");
+  });
+
+  it("override wins over managed npm", () => {
+    const custom = "/opt/custom/npm";
+    const r = freshRegistry({
+      platform: "linux",
+      overrides: { npm: custom },
+      exists: (p) => p === custom || p === MANAGED_NPM_UNIX,
+    });
+    const res = r.resolve("npm");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(custom);
+    expect(res.source).toBe("override");
+  });
+
+  it("npm: managed absent + PATH present → falls through (Unix)", () => {
+    const r = freshRegistry({
+      platform: "linux",
+      exists: () => false,
+      which: (name) => (name === "npm" ? "/usr/bin/npm" : null),
+    });
+    const res = r.resolve("npm");
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe("/usr/bin/npm");
+    expect(res.source).toBe("system");
+  });
+});

package/packages/shared/src/tool-registry/definitions.ts

@@ -18,6 +18,7 @@ import {
   bareImportStrategy,
   managedBinStrategy,
   managedModuleStrategy,
+  managedRuntimeStrategy,
   npmGlobalStrategy,
   overrideStrategy,
   whereStrategy,
@@ -39,14 +40,20 @@ function classify(strategyName: string): Source {
 // ── Binary definitions ──────────────────────────────────────────────────────
 
 function binaryDef(binaryName: string, deps?: StrategyDeps): ToolDefinition {
+  // The `node` binary gets the managed-Node runtime strategy prepended
+  // (after override) so the persistent <managedDir>/node/ install wins
+  // over PATH lookup. See change: embed-managed-node-runtime.
+  const isNode = binaryName === "node";
+  const strategies = [
+    overrideStrategy(binaryName, deps),
+    ...(isNode ? [managedRuntimeStrategy("node", deps)] : []),
+    managedBinStrategy(binaryName, deps),
+    whereStrategy(binaryName, deps),
+  ];
   return {
     name: binaryName,
     kind: "binary",
-    strategies: [
-      overrideStrategy(binaryName, deps),
-      managedBinStrategy(binaryName, deps),
-      whereStrategy(binaryName, deps),
-    ],
+    strategies,
     classify,
   };
 }
@@ -283,14 +290,20 @@ function npmExecutorDef(deps?: StrategyDeps): ToolDefinition {
     },
   };
 
+  // Managed-Node runtime: prefer <managedDir>/node/{npm.cmd,bin/npm}
+  // when the runtime is installed. See change: embed-managed-node-runtime.
+  const managedNpm = managedRuntimeStrategy("npm", deps);
+
   const winStrategies = [
     overrideStrategy("npm", deps),
+    managedNpm,
     npmCliBesideNodeStrategy,
     whereStrategy("npm", deps),
   ];
 
   const unixStrategies = [
     overrideStrategy("npm", deps),
+    managedNpm,
     whereStrategy("npm", deps),
   ];
 
@@ -354,6 +367,7 @@ export function registerDefaultTools(registry: ToolRegistry, deps?: StrategyDeps
   // Native binaries — no interpreter needed.
   registry.register(binaryDef("node", deps));
   registry.register(binaryDef("git", deps));
+  registry.register(binaryDef("jj", deps));
   registry.register(binaryDef("zrok", deps));
 
   // Platform-conditional process-inspection utilities. These are only

package/packages/shared/src/tool-registry/strategies.ts

@@ -13,6 +13,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { ToolResolver, isAppImageSelfHit } from "../platform/binary-lookup.js";
 import { getManagedBin, getManagedDir } from "../managed-paths.js";
+import { getManagedNodeBinDir } from "../platform/managed-node-path.js";
 import * as npm from "../platform/npm.js";
 import type { Strategy, StrategyCtx, StrategyResult } from "./types.js";
 
@@ -86,6 +87,47 @@ export function overrideStrategy(toolName: string, deps?: StrategyDeps): Strateg
   };
 }
 
+/**
+ * Managed Node runtime: `<managedDir>/node/{node.exe,npm.cmd,npx.cmd}`
+ * on Windows or `<managedDir>/node/bin/{node,npm,npx}` on Unix.
+ *
+ * Lets `ToolRegistry.resolve("node")` and `resolve("npm")` prefer the
+ * persistent runtime under `~/.pi-dashboard/node/` (installed by
+ * `installManagedNode`) over the system PATH lookup, while still
+ * deferring to `tool-overrides.json`.
+ *
+ * Returns `null` when the managed Node runtime is not present, so the
+ * standalone-CLI / no-Electron-resources case falls through cleanly to
+ * the existing `where`/PATH strategy.
+ *
+ * See change: embed-managed-node-runtime (spec: managed-node-runtime,
+ * Requirement: ToolRegistry resolves managed runtime first).
+ */
+export function managedRuntimeStrategy(
+  toolName: "node" | "npm" | "npx",
+  deps?: StrategyDeps,
+): Strategy {
+  const { exists } = d(deps);
+  return {
+    name: "managed",
+    run(ctx): StrategyResult {
+      const dir = getManagedNodeBinDir(ctx.env, ctx.platform);
+      const isWin = ctx.platform === "win32";
+      const fileName =
+        toolName === "node"
+          ? isWin
+            ? "node.exe"
+            : "node"
+          : isWin
+            ? `${toolName}.cmd`
+            : toolName;
+      const candidate = path.join(dir, fileName);
+      if (exists(candidate)) return { ok: true, path: candidate };
+      return { ok: false, reason: `missing: ${candidate}` };
+    },
+  };
+}
+
 /**
  * Managed install: `~/.pi-dashboard/node_modules/.bin/<name>(.cmd)` for
  * binaries, or any explicit relative path under `MANAGED_DIR` for