@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/extension/src/__tests__/watchdog.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ConnectionManager } from "../connection.js";
+
+// Mock WebSocket (same pattern as connection.test.ts)
+class MockWebSocket {
+  static instances: MockWebSocket[] = [];
+  readyState = 0;
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onmessage: ((ev: { data: string }) => void) | null = null;
+  onerror: ((ev: unknown) => void) | null = null;
+  sentMessages: string[] = [];
+
+  constructor(public url: string) {
+    MockWebSocket.instances.push(this);
+  }
+
+  send(data: string) {
+    this.sentMessages.push(data);
+  }
+
+  close() {
+    this.readyState = 3;
+    this.onclose?.();
+  }
+
+  simulateOpen() {
+    this.readyState = 1;
+    this.onopen?.();
+  }
+
+  simulateClose() {
+    this.readyState = 3;
+    this.onclose?.();
+  }
+
+  simulateMessage(data: string) {
+    this.onmessage?.({ data });
+  }
+}
+
+describe("ConnectionManager watchdog", () => {
+  beforeEach(() => {
+    MockWebSocket.instances = [];
+    vi.useFakeTimers();
+  });
+
+  it("should force-close when no messages received for watchdogTimeout", () => {
+    const cm = new ConnectionManager({
+      url: "ws://localhost:9999",
+      WebSocketImpl: MockWebSocket as any,
+      watchdogTimeout: 60_000,
+    });
+    cm.connect();
+
+    const ws = MockWebSocket.instances[0];
+    ws.simulateOpen();
+
+    // Advance past watchdog timeout (checked every 15s)
+    vi.advanceTimersByTime(60_000);
+
+    // Watchdog should have triggered — ws should be closed and reconnect scheduled
+    expect(MockWebSocket.instances.length).toBeGreaterThanOrEqual(1);
+    // The connection should have been torn down
+    expect(cm.isConnected).toBe(false);
+
+    cm.disconnect();
+  });
+
+  it("should NOT force-close when messages are received regularly", () => {
+    const cm = new ConnectionManager({
+      url: "ws://localhost:9999",
+      WebSocketImpl: MockWebSocket as any,
+      watchdogTimeout: 60_000,
+    });
+    cm.connect();
+
+    const ws = MockWebSocket.instances[0];
+    ws.simulateOpen();
+
+    // Send messages every 20s to keep watchdog happy
+    for (let i = 0; i < 5; i++) {
+      vi.advanceTimersByTime(20_000);
+      ws.simulateMessage(JSON.stringify({ type: "heartbeat_ack" }));
+    }
+
+    // Should still be connected (100s elapsed, but messages kept coming)
+    expect(cm.isConnected).toBe(true);
+    expect(MockWebSocket.instances).toHaveLength(1);
+
+    cm.disconnect();
+  });
+
+  it("should stop watchdog on disconnect", () => {
+    const cm = new ConnectionManager({
+      url: "ws://localhost:9999",
+      WebSocketImpl: MockWebSocket as any,
+      watchdogTimeout: 60_000,
+    });
+    cm.connect();
+
+    const ws = MockWebSocket.instances[0];
+    ws.simulateOpen();
+
+    // Disconnect before watchdog fires
+    cm.disconnect();
+
+    // Advance past timeout — should not create new connections
+    vi.advanceTimersByTime(120_000);
+    expect(MockWebSocket.instances).toHaveLength(1);
+  });
+
+  it("should be disabled when watchdogTimeout is 0", () => {
+    const cm = new ConnectionManager({
+      url: "ws://localhost:9999",
+      WebSocketImpl: MockWebSocket as any,
+      watchdogTimeout: 0,
+    });
+    cm.connect();
+
+    const ws = MockWebSocket.instances[0];
+    ws.simulateOpen();
+
+    // Advance way past any timeout — should stay connected
+    vi.advanceTimersByTime(300_000);
+    expect(cm.isConnected).toBe(true);
+    expect(MockWebSocket.instances).toHaveLength(1);
+
+    cm.disconnect();
+  });
+
+  it("should reconnect after watchdog triggers", () => {
+    const onReconnect = vi.fn();
+    const cm = new ConnectionManager({
+      url: "ws://localhost:9999",
+      WebSocketImpl: MockWebSocket as any,
+      watchdogTimeout: 60_000,
+      onReconnect,
+    });
+    cm.connect();
+
+    const ws1 = MockWebSocket.instances[0];
+    ws1.simulateOpen();
+
+    // Let watchdog trigger
+    vi.advanceTimersByTime(60_000);
+    expect(cm.isConnected).toBe(false);
+
+    // Reconnect timer fires (1s backoff)
+    vi.advanceTimersByTime(1000);
+    expect(MockWebSocket.instances.length).toBeGreaterThanOrEqual(2);
+
+    // Simulate successful reconnect
+    const ws2 = MockWebSocket.instances[MockWebSocket.instances.length - 1];
+    ws2.simulateOpen();
+    expect(cm.isConnected).toBe(true);
+    expect(onReconnect).toHaveBeenCalled();
+
+    cm.disconnect();
+  });
+});

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

@@ -0,0 +1,63 @@
+/**
+ * Registers the ask_user tool in the bridge extension.
+ *
+ * Called at runtime (session_start) rather than extension load time to avoid
+ * static tool-name conflicts with other extensions (e.g. pi-flows) that also
+ * register ask_user. Runtime registration bypasses detectExtensionConflicts.
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { StringEnum } from "@mariozechner/pi-ai";
+
+export function registerAskUserTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "ask_user",
+    label: "Ask User",
+    description:
+      "Ask the user a question interactively. Use this when you need clarification, confirmation, or a choice from the user before proceeding.",
+    promptSnippet:
+      "Ask the user interactive questions (confirm, select, multiselect, or free text input)",
+    promptGuidelines: [
+      "When you need to ask the user a question, ALWAYS use the ask_user tool instead of writing the question as plain text.",
+      "Use method 'confirm' for yes/no questions, 'select' when offering specific choices, 'multiselect' when the user should pick multiple items from a list, and 'input' for open-ended questions.",
+      "This applies to all workflows including OpenSpec, planning, and any situation where you need user input before proceeding.",
+    ],
+    parameters: Type.Object({
+      method: StringEnum(["confirm", "select", "multiselect", "input"] as const, {
+        description:
+          "Type of question: confirm (yes/no), select (pick from options), multiselect (pick multiple), input (free text)",
+      }),
+      title: Type.String({ description: "The question to ask" }),
+      message: Type.Optional(Type.String({ description: "Additional context or detailed question body (all methods)" })),
+      options: Type.Optional(
+        Type.Array(Type.String(), { description: "Options to choose from (for select)" }),
+      ),
+      placeholder: Type.Optional(Type.String({ description: "Placeholder text (for input)" })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      let result: unknown;
+
+      const msgOpts = params.message ? { message: params.message } : undefined;
+
+      switch (params.method) {
+        case "confirm":
+          result = await ctx.ui.confirm(params.title, params.message ?? "");
+          break;
+        case "select":
+          result = await ctx.ui.select(params.title, params.options ?? [], msgOpts);
+          break;
+        case "multiselect":
+          result = await (ctx.ui as any).multiselect(params.title, params.options ?? [], msgOpts);
+          break;
+        case "input":
+          result = await ctx.ui.input(params.title, params.placeholder, msgOpts);
+          break;
+      }
+
+      return {
+        content: [{ type: "text", text: `User responded: ${JSON.stringify(result)}` }],
+        details: { method: params.method, result },
+      };
+    },
+  });
+}

package/packages/extension/src/bridge-context.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared mutable state for bridge modules.
+ * Avoids passing 14+ closure variables to every extracted function.
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ConnectionManager } from "./connection.js";
+
+export interface BridgeContext {
+  pi: ExtensionAPI;
+  connection: ConnectionManager;
+  /** Current session ID (mutated on session_switch/fork) */
+  sessionId: string;
+  cachedCtx: any;
+  cachedModelRegistry: any;
+  cachedHasUI: boolean | undefined;
+  lastModel: string | undefined;
+  lastThinkingLevel: string | undefined;
+  lastSessionFile: string | undefined;
+  lastSessionDir: string | undefined;
+  lastFirstMessage: string | undefined;
+  lastGitBranch: string | undefined;
+  lastGitPrNumber: number | undefined;
+  lastSessionName: string | undefined;
+}
+
+// Commands that the dashboard handles natively with superior UX.
+// These are filtered from the command list sent to dashboard clients.
+const DASHBOARD_NATIVE_COMMANDS = new Set(["roles"]);
+
+/** Filter out hidden commands (names starting with __) and dashboard-native commands from commands list */
+export function filterHiddenCommands(commands: any[]): any[] {
+  return commands.filter((cmd) =>
+    !cmd.name.startsWith("__") &&
+    !DASHBOARD_NATIVE_COMMANDS.has(cmd.name)
+  );
+}
+
+/** Extract first user message text from session entries */
+export function extractFirstMessage(ctx: any): string | undefined {
+  try {
+    const entries = ctx?.sessionManager?.getEntries?.();
+    if (!entries || !Array.isArray(entries)) return undefined;
+    for (const entry of entries) {
+      if (entry.role === "user" && typeof entry.content === "string") {
+        return entry.content.slice(0, 200);
+      }
+      if (entry.role === "user" && Array.isArray(entry.content)) {
+        for (const part of entry.content) {
+          if (part.type === "text" && typeof part.text === "string") {
+            return part.text.slice(0, 200);
+          }
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return undefined;
+}
+
+/** Get current model string (provider/id) from cached context */
+export function getCurrentModelString(bc: BridgeContext): string | undefined {
+  const model = bc.cachedCtx?.model;
+  if (!model) return undefined;
+  return `${model.provider}/${model.id}`;
+}