@blackbelt-technology/pi-agent-dashboard 0.2.1 → 0.2.3

package/packages/server/src/server.ts

@@ -31,7 +31,7 @@ import { scanAllSessions } from "./session-scanner.js";
 import { needsMigration, runMigration } from "./migrate-persistence.js";
 import { detectZrokBinary, cleanupStaleZrok, createTunnel, deleteTunnel } from "./tunnel.js";
 import { registerAuthPlugin, validateWsUpgrade } from "./auth-plugin.js";
-import { ensureBridgeExtensionRegistered } from "./extension-register.js";
+import { findBundledExtension, registerBridgeExtension } from "@blackbelt-technology/pi-dashboard-shared/bridge-register.js";
 import { createNetworkGuard, isLoopback, isBypassedHost } from "./localhost-guard.js";
 import type { AuthConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { registerSessionApi } from "./session-api.js";
@@ -46,6 +46,7 @@ import { registerProviderRoutes } from "./routes/provider-routes.js";
 import { PackageManagerWrapper } from "./package-manager-wrapper.js";
 import { createEditorManager, type EditorManager } from "./editor-manager.js";
 import { registerEditorRoutes } from "./routes/editor-routes.js";
+import { registerKnownServersRoutes } from "./routes/known-servers-routes.js";
 import { registerEditorProxy, handleEditorUpgrade } from "./editor-proxy.js";
 import { detectCodeServerBinary } from "./editor-detection.js";
 
@@ -83,7 +84,9 @@ export interface DashboardServer {
 export async function createServer(config: ServerConfig): Promise<DashboardServer> {
   // Ensure bridge extension is registered in pi's global settings
   // (needed for bundled installs where pi can't discover it from package.json)
-  ensureBridgeExtensionRegistered();
+  const __serverDir = path.dirname(fileURLToPath(import.meta.url));
+  const extPath = findBundledExtension(path.resolve(__serverDir, "..", ".."));
+  if (extPath) registerBridgeExtension(extPath);
 
   // Run migration from sessions.json + state.json if needed
   if (needsMigration()) {
@@ -131,7 +134,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       cacheRead: session.cacheRead,
       cacheWrite: session.cacheWrite,
       cost: session.cost,
-      contextTokens: session.contextTokens,
+      contextTokens: session.contextTokens ?? undefined,
       contextWindow: session.contextWindow,
       firstMessage: session.firstMessage,
       cachedAt: Date.now(),
@@ -292,7 +295,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   registerGitRoutes(fastify, { networkGuard });
   registerFileRoutes(fastify, { sessionManager, preferencesStore, networkGuard });
   registerOpenSpecRoutes(fastify, { sessionManager, preferencesStore, directoryService, networkGuard });
-  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard });
+  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion });
   // Package management
   const packageManagerWrapper = new PackageManagerWrapper();
 
@@ -340,6 +343,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   registerEditorProxy(fastify, editorManager);
 
   registerProviderAuthRoutes(fastify, { piGateway });
+  registerKnownServersRoutes(fastify, { networkGuard, getPeerServers: () => peerServers });
   registerProviderRoutes(fastify, { networkGuard });
 
   // Serve static files / SPA fallback

package/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
   "exports": {

package/packages/shared/src/__tests__/bridge-register.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for the shared bridge-register module.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// We test against a real temp filesystem
+import { findBundledExtension, registerBridgeExtension } from "../bridge-register.js";
+
+describe("shared bridge-register", () => {
+  let tmpDir: string;
+  let settingsPath: string;
+  let origHome: string | undefined;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "shared-bridge-test-"));
+    settingsPath = path.join(tmpDir, ".pi", "agent", "settings.json");
+    origHome = process.env.HOME;
+    process.env.HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = origHome;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeSettings(data: Record<string, unknown>) {
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(data, null, 2));
+  }
+
+  function readSettings(): Record<string, unknown> {
+    return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+  }
+
+  describe("findBundledExtension", () => {
+    it("finds extension in packages/extension/ under base dir", () => {
+      const baseDir = path.join(tmpDir, "server");
+      const extDir = path.join(baseDir, "packages", "extension");
+      fs.mkdirSync(extDir, { recursive: true });
+      fs.writeFileSync(path.join(extDir, "package.json"), '{"name":"test"}');
+
+      expect(findBundledExtension(baseDir)).toBe(extDir);
+    });
+
+    it("returns null when extension dir does not exist", () => {
+      expect(findBundledExtension(tmpDir)).toBeNull();
+    });
+
+    it("returns null when no package.json in extension dir", () => {
+      const extDir = path.join(tmpDir, "packages", "extension");
+      fs.mkdirSync(extDir, { recursive: true });
+      // No package.json
+      expect(findBundledExtension(tmpDir)).toBeNull();
+    });
+
+    it("returns null for AppImage temp mount paths", () => {
+      // We can't easily create a /tmp/.mount_ path, but we can verify
+      // the function handles it via the string check
+      const mockBase = "/tmp/.mount_PI1234/resources/server";
+      // findBundledExtension will check existsSync which returns false for this
+      expect(findBundledExtension(mockBase)).toBeNull();
+    });
+  });
+
+  describe("registerBridgeExtension", () => {
+    it("registers extension path in empty settings", () => {
+      const extPath = "/app/packages/extension";
+      registerBridgeExtension(extPath);
+
+      const settings = readSettings();
+      expect(settings.packages).toContain(extPath);
+    });
+
+    it("is idempotent — does not add duplicates", () => {
+      const extPath = "/app/packages/extension";
+      registerBridgeExtension(extPath);
+      registerBridgeExtension(extPath);
+
+      const settings = readSettings();
+      const count = (settings.packages as string[]).filter(p => p === extPath).length;
+      expect(count).toBe(1);
+    });
+
+    it("preserves existing valid dashboard paths", () => {
+      // Create a valid extension dir
+      const existingExt = path.join(tmpDir, "dev", "pi-agent-dashboard", "ext");
+      fs.mkdirSync(existingExt, { recursive: true });
+      fs.writeFileSync(path.join(existingExt, "package.json"), "{}");
+
+      writeSettings({ packages: [existingExt] });
+
+      const newPath = "/app/new/extension";
+      registerBridgeExtension(newPath);
+
+      const settings = readSettings();
+      const packages = settings.packages as string[];
+      expect(packages).toContain(existingExt); // preserved
+      expect(packages).toContain(newPath); // added
+    });
+
+    it("removes stale (non-existent) dashboard paths", () => {
+      const stalePath = "/old/nonexistent/pi-dashboard/ext";
+      writeSettings({ packages: [stalePath] });
+
+      const newPath = "/app/new/extension";
+      registerBridgeExtension(newPath);
+
+      const settings = readSettings();
+      const packages = settings.packages as string[];
+      expect(packages).not.toContain(stalePath);
+      expect(packages).toContain(newPath);
+    });
+
+    it("preserves non-dashboard paths", () => {
+      writeSettings({ packages: ["/some/other/extension"] });
+
+      registerBridgeExtension("/app/extension");
+
+      const settings = readSettings();
+      const packages = settings.packages as string[];
+      expect(packages).toContain("/some/other/extension");
+      expect(packages).toContain("/app/extension");
+    });
+
+    it("handles missing settings.json gracefully", () => {
+      // No settings dir exists
+      registerBridgeExtension("/app/extension");
+
+      const settings = readSettings();
+      expect(settings.packages).toContain("/app/extension");
+    });
+  });
+});

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

@@ -0,0 +1,62 @@
+/**
+ * Type-level tests ensuring PromptBus messages are included in ServerToBrowserMessage.
+ *
+ * These tests prevent the regression where `case "prompt_request" as any:` etc.
+ * in switch statements were dead-code eliminated by esbuild because the message
+ * types were not in the ServerToBrowserMessage union.
+ */
+import { describe, it, expect } from "vitest";
+import type {
+  ServerToBrowserMessage,
+  BrowserPromptRequestMessage,
+  BrowserPromptDismissMessage,
+  BrowserPromptCancelMessage,
+} from "../browser-protocol.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>;
+
+// Runtime verification that the type discriminants are reachable in a switch
+function extractPromptType(msg: ServerToBrowserMessage): string | null {
+  switch (msg.type) {
+    case "prompt_request": return msg.promptId;
+    case "prompt_dismiss": return msg.promptId;
+    case "prompt_cancel": return msg.promptId;
+    default: return null;
+  }
+}
+
+describe("ServerToBrowserMessage includes PromptBus messages", () => {
+  it("prompt_request is a valid discriminant", () => {
+    const msg: BrowserPromptRequestMessage = {
+      type: "prompt_request",
+      sessionId: "s1",
+      promptId: "p1",
+      prompt: { question: "Q?", type: "input" },
+      component: { type: "generic-dialog", props: {} },
+      placement: "inline",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+
+  it("prompt_dismiss is a valid discriminant", () => {
+    const msg: BrowserPromptDismissMessage = {
+      type: "prompt_dismiss",
+      sessionId: "s1",
+      promptId: "p1",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+
+  it("prompt_cancel is a valid discriminant", () => {
+    const msg: BrowserPromptCancelMessage = {
+      type: "prompt_cancel",
+      sessionId: "s1",
+      promptId: "p1",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+});

package/packages/shared/src/__tests__/tool-resolver.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Unit tests for ToolResolver.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "node:path";
+import os from "node:os";
+
+const { mockExecSync, mockExistsSync } = vi.hoisted(() => ({
+  mockExecSync: vi.fn(),
+  mockExistsSync: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => ({ execSync: mockExecSync }));
+vi.mock("node:fs", () => ({ existsSync: mockExistsSync }));
+
+import { ToolResolver } from "../tool-resolver.js";
+
+const MANAGED_BIN = path.join(os.homedir(), ".pi-dashboard", "node_modules", ".bin");
+
+describe("ToolResolver", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExistsSync.mockReturnValue(false);
+    mockExecSync.mockImplementation(() => { throw new Error("not found"); });
+  });
+
+  describe("which()", () => {
+    it("finds binary in managed bin first", () => {
+      const managedPi = path.join(MANAGED_BIN, "pi");
+      mockExistsSync.mockImplementation((p: string) => p === managedPi);
+
+      const resolver = new ToolResolver();
+      expect(resolver.which("pi")).toBe(managedPi);
+    });
+
+    it("finds binary in extra bin dirs before system PATH", () => {
+      const extraDir = "/custom/bin";
+      const extraPi = path.join(extraDir, "pi");
+      mockExistsSync.mockImplementation((p: string) => p === extraPi);
+
+      const resolver = new ToolResolver({ extraBinDirs: [extraDir] });
+      expect(resolver.which("pi")).toBe(extraPi);
+    });
+
+    it("falls back to system PATH via which", () => {
+      mockExecSync.mockImplementation((cmd: string) => {
+        if (typeof cmd === "string" && cmd.includes("which pi")) return "/usr/bin/pi\n";
+        throw new Error("not found");
+      });
+
+      const resolver = new ToolResolver();
+      expect(resolver.which("pi")).toBe("/usr/bin/pi");
+    });
+
+    it("tries login shell when enabled and PATH fails", () => {
+      // Regular which fails
+      mockExecSync.mockImplementation((cmd: string) => {
+        if (typeof cmd === "string" && cmd.includes("-ilc")) return "/nvm/bin/pi\n";
+        throw new Error("not found");
+      });
+
+      const resolver = new ToolResolver({ useLoginShell: true });
+      // On win32 login shell is skipped — test on non-win32 only
+      if (process.platform !== "win32") {
+        expect(resolver.which("pi")).toBe("/nvm/bin/pi");
+      }
+    });
+
+    it("returns null when binary not found anywhere", () => {
+      const resolver = new ToolResolver();
+      expect(resolver.which("nonexistent")).toBeNull();
+    });
+  });
+
+  describe("resolvePi()", () => {
+    it("returns [path] for Unix managed pi", () => {
+      const managedPi = path.join(MANAGED_BIN, "pi");
+      mockExistsSync.mockImplementation((p: string) => p === managedPi);
+
+      const resolver = new ToolResolver();
+      if (process.platform !== "win32") {
+        expect(resolver.resolvePi()).toEqual([managedPi]);
+      }
+    });
+
+    it("returns null when pi not found", () => {
+      const resolver = new ToolResolver();
+      expect(resolver.resolvePi()).toBeNull();
+    });
+  });
+
+  describe("resolveTsx()", () => {
+    it("returns [path] for managed tsx", () => {
+      const managedTsx = path.join(MANAGED_BIN, "tsx");
+      mockExistsSync.mockImplementation((p: string) => p === managedTsx);
+
+      const resolver = new ToolResolver();
+      if (process.platform !== "win32") {
+        expect(resolver.resolveTsx()).toEqual([managedTsx]);
+      }
+    });
+
+    it("returns null when tsx not found", () => {
+      const resolver = new ToolResolver();
+      expect(resolver.resolveTsx()).toBeNull();
+    });
+  });
+
+  describe("resolveNode()", () => {
+    it("returns processExecPath when provided", () => {
+      const resolver = new ToolResolver({ processExecPath: "/usr/bin/node" });
+      expect(resolver.resolveNode()).toBe("/usr/bin/node");
+    });
+
+    it("finds node in extra bin dirs", () => {
+      const extraDir = "/bundled/bin";
+      const nodeName = process.platform === "win32" ? "node.exe" : "node";
+      const nodePath = path.join(extraDir, nodeName);
+      mockExistsSync.mockImplementation((p: string) => p === nodePath);
+
+      const resolver = new ToolResolver({ extraBinDirs: [extraDir] });
+      expect(resolver.resolveNode()).toBe(nodePath);
+    });
+
+    it("falls back to which(node) when no context paths", () => {
+      const managedNode = path.join(MANAGED_BIN, "node");
+      mockExistsSync.mockImplementation((p: string) => p === managedNode);
+
+      const resolver = new ToolResolver();
+      expect(resolver.resolveNode()).toBe(managedNode);
+    });
+  });
+
+  describe("buildSpawnEnv()", () => {
+    it("prepends managed bin to PATH", () => {
+      const resolver = new ToolResolver();
+      const env = resolver.buildSpawnEnv({ PATH: "/usr/bin" });
+      expect(env.PATH).toContain(MANAGED_BIN);
+      expect(env.PATH).toContain("/usr/bin");
+      // Managed bin should come before /usr/bin
+      expect(env.PATH!.indexOf(MANAGED_BIN)).toBeLessThan(env.PATH!.indexOf("/usr/bin"));
+    });
+
+    it("does not duplicate managed bin if already present", () => {
+      const resolver = new ToolResolver();
+      const env = resolver.buildSpawnEnv({ PATH: `${MANAGED_BIN}:/usr/bin` });
+      const count = env.PATH!.split(path.delimiter).filter(p => p === MANAGED_BIN).length;
+      expect(count).toBe(1);
+    });
+
+    it("includes processExecPath dir", () => {
+      const resolver = new ToolResolver({ processExecPath: "/custom/node/bin/node" });
+      const env = resolver.buildSpawnEnv({ PATH: "/usr/bin" });
+      expect(env.PATH).toContain("/custom/node/bin");
+    });
+
+    it("includes extra bin dirs", () => {
+      const resolver = new ToolResolver({ extraBinDirs: ["/extra/one", "/extra/two"] });
+      const env = resolver.buildSpawnEnv({ PATH: "/usr/bin" });
+      expect(env.PATH).toContain("/extra/one");
+      expect(env.PATH).toContain("/extra/two");
+    });
+  });
+});

package/packages/shared/src/bridge-register.ts

@@ -0,0 +1,95 @@
+/**
+ * Shared bridge extension registration for pi's settings.json.
+ * Used by both the server and Electron app to register the dashboard
+ * bridge extension so pi sessions can discover and load it.
+ *
+ * Single source of truth — replaces the near-identical implementations
+ * in packages/server/src/extension-register.ts and
+ * packages/electron/src/lib/bridge-register.ts.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+/**
+ * Find the bundled extension directory relative to a base directory.
+ * Looks for `packages/extension/` (monorepo layout) under baseDir.
+ *
+ * Returns null if:
+ * - Directory not found
+ * - No package.json in the directory
+ * - Path is under /tmp/.mount_* (unstable AppImage mount)
+ */
+export function findBundledExtension(baseDir: string): string | null {
+  const candidate = path.resolve(baseDir, "packages", "extension");
+  if (!fs.existsSync(candidate) || !fs.existsSync(path.join(candidate, "package.json"))) {
+    return null;
+  }
+
+  // Reject unstable AppImage temp mount paths
+  if (candidate.includes("/tmp/.mount_")) {
+    console.warn("[dashboard] AppImage detected — extension path is temporary, skipping registration:", candidate);
+    return null;
+  }
+
+  return candidate;
+}
+
+/**
+ * Register an extension path in pi's settings.json packages array.
+ *
+ * Non-destructive cleanup: only removes dashboard-related paths
+ * that point to non-existent directories or directories without package.json.
+ * Existing valid registrations (dev, global, other bundled) are preserved.
+ *
+ * No-op if the path is already registered.
+ */
+export function registerBridgeExtension(extensionPath: string): void {
+  // Compute at call time so tests can override HOME
+  const settingsPath = path.join(
+    process.env.HOME || process.env.USERPROFILE || os.homedir(),
+    ".pi", "agent", "settings.json",
+  );
+  const settingsDir = path.dirname(settingsPath);
+  fs.mkdirSync(settingsDir, { recursive: true });
+
+  let settings: Record<string, unknown> = {};
+  try {
+    if (fs.existsSync(settingsPath)) {
+      const raw = fs.readFileSync(settingsPath, "utf-8").trim();
+      if (raw) settings = JSON.parse(raw);
+    }
+  } catch { /* start fresh */ }
+
+  const packages = Array.isArray(settings.packages) ? settings.packages as string[] : [];
+
+  // Already registered?
+  if (packages.includes(extensionPath)) return;
+
+  // Non-destructive cleanup: only remove broken dashboard paths
+  const cleaned = packages.filter((p) => {
+    if (typeof p !== "string") return true;
+    const isLocalPath = p.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(p);
+    if (!isLocalPath) return true;
+    // Only consider dashboard-related paths for cleanup
+    if (!p.includes("pi-dashboard") && !p.includes("pi-agent-dashboard")) return true;
+    // Keep paths that point to existing directories with a package.json
+    try {
+      return fs.existsSync(p) && fs.existsSync(path.join(p, "package.json"));
+    } catch {
+      return false; // Can't check — treat as stale
+    }
+  });
+
+  cleaned.push(extensionPath);
+  settings.packages = cleaned;
+
+  try {
+    const tmp = settingsPath + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+    fs.renameSync(tmp, settingsPath);
+    console.log(`[dashboard] Registered bridge extension in pi settings: ${extensionPath}`);
+  } catch (err) {
+    console.error("[dashboard] Failed to register bridge extension:", err);
+  }
+}

package/packages/shared/src/browser-protocol.ts

@@ -162,6 +162,39 @@ export interface EditorStatusMessage {
   status: EditorInstanceStatus;
 }
 
+// ── PromptBus protocol (Server → Browser) ───────────────────────────
+
+export interface BrowserPromptRequestMessage {
+  type: "prompt_request";
+  sessionId: string;
+  promptId: string;
+  prompt: {
+    question: string;
+    type: string;
+    options?: string[];
+    defaultValue?: string;
+    pipeline?: string;
+    metadata?: Record<string, unknown>;
+  };
+  component: {
+    type: string;
+    props: Record<string, unknown>;
+  };
+  placement: string;
+}
+
+export interface BrowserPromptDismissMessage {
+  type: "prompt_dismiss";
+  sessionId: string;
+  promptId: string;
+}
+
+export interface BrowserPromptCancelMessage {
+  type: "prompt_cancel";
+  sessionId: string;
+  promptId: string;
+}
+
 /** Progress event streamed during a package install/remove/update operation. */
 export interface PackageProgressMessage {
   type: "package_progress";
@@ -216,7 +249,10 @@ export type ServerToBrowserMessage =
   | BrowserRolesListMessage
   | ProcessListUpdateMessage
   | ServersDiscoveredMessage
-  | ServersUpdatedMessage;
+  | ServersUpdatedMessage
+  | BrowserPromptRequestMessage
+  | BrowserPromptDismissMessage
+  | BrowserPromptCancelMessage;
 
 // ── Browser → Server ────────────────────────────────────────────────
 
@@ -462,6 +498,15 @@ export interface ArchitectPromptResponseBrowserMessage {
   cancelled?: boolean;
 }
 
+export interface PromptResponseBrowserMessage {
+  type: "prompt_response";
+  sessionId: string;
+  promptId: string;
+  answer?: string;
+  cancelled?: boolean;
+  source: string;
+}
+
 export interface RoleSetBrowserMessage {
   type: "role_set";
   sessionId: string;
@@ -526,6 +571,7 @@ export type BrowserToServerMessage =
   | ForceKillBrowserMessage
   | FlowManagementBrowserMessage
   | ArchitectPromptResponseBrowserMessage
+  | PromptResponseBrowserMessage
   | RoleSetBrowserMessage
   | RolePresetLoadBrowserMessage
   | RolePresetSaveBrowserMessage

package/packages/shared/src/config.ts

@@ -55,6 +55,13 @@ export const DEFAULT_EDITOR_CONFIG: EditorConfig = {
   maxInstances: 3,
 };
 
+export interface KnownServer {
+  host: string;
+  port: number;
+  label?: string;
+  addedAt: string; // ISO timestamp
+}
+
 export interface DashboardConfig {
   port: number;
   piPort: number;
@@ -78,6 +85,8 @@ export interface DashboardConfig {
   lastServer?: string;
   /** Whether the server was launched by the Electron app */
   electronMode: boolean;
+  /** Persisted list of known remote servers */
+  knownServers: KnownServer[];
 }
 
 export interface CorsConfig {
@@ -103,6 +112,7 @@ const DEFAULTS: DashboardConfig = {
   resolvedTrustedNetworks: [],
   cors: { allowedOrigins: [] },
   electronMode: false,
+  knownServers: [],
 };
 
 /**
@@ -156,6 +166,18 @@ function parseMemoryLimits(raw: any): MemoryLimitsConfig {
   };
 }
 
+function parseKnownServers(raw: any): KnownServer[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .filter((entry: any) => entry && typeof entry === "object" && typeof entry.host === "string" && typeof entry.port === "number")
+    .map((entry: any) => ({
+      host: entry.host,
+      port: entry.port,
+      ...(typeof entry.label === "string" ? { label: entry.label } : {}),
+      addedAt: typeof entry.addedAt === "string" ? entry.addedAt : new Date().toISOString(),
+    }));
+}
+
 function parseTrustedNetworks(raw: any): string[] {
   if (!Array.isArray(raw)) return [];
   return raw.filter((entry: unknown) => typeof entry === "string" && entry.length > 0);
@@ -204,6 +226,7 @@ export function loadConfig(): DashboardConfig {
       },
       ...(typeof parsed.lastServer === "string" ? { lastServer: parsed.lastServer } : {}),
       electronMode: parsed.electronMode === true,
+      knownServers: parseKnownServers(parsed.knownServers),
     };
 
     // Compute resolvedTrustedNetworks: merge trustedNetworks + auth.bypassHosts

package/packages/shared/src/managed-paths.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared constants for the managed install directory (~/.pi-dashboard/).
+ * Single source of truth — all packages import from here.
+ */
+import path from "node:path";
+import os from "node:os";
+
+/** Root directory for managed installs (pi, openspec, tsx). */
+export const MANAGED_DIR = path.join(os.homedir(), ".pi-dashboard");
+
+/** Bin directory for managed install executables. */
+export const MANAGED_BIN = path.join(MANAGED_DIR, "node_modules", ".bin");
+
+/** Path to pi's global settings file. */
+export const PI_SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");

package/packages/shared/src/mdns-discovery.ts

@@ -64,7 +64,7 @@ export function advertiseDashboard(port: number, piPort: number): void {
  */
 export function stopAdvertising(): void {
   if (publishedService) {
-    publishedService.stop(() => {});
+    publishedService.stop?.(() => {});
     publishedService = null;
   }
   if (bonjourInstance) {