@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/session-api.ts

@@ -0,0 +1,330 @@
+/**
+ * REST API wrappers for session control operations.
+ * These expose WebSocket-only operations as HTTP endpoints
+ * for use by skills, scripts, and external tooling.
+ */
+import type { FastifyInstance } from "fastify";
+import type { SessionManager } from "./memory-session-manager.js";
+import type { PiGateway } from "./pi-gateway.js";
+import type { BrowserGateway } from "./browser-gateway.js";
+import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import { spawnPiSession } from "./process-manager.js";
+import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import type { PendingForkRegistry } from "./pending-fork-registry.js";
+
+export interface SessionApiDeps {
+  sessionManager: SessionManager;
+  piGateway: PiGateway;
+  browserGateway: BrowserGateway;
+  pendingForkRegistry?: PendingForkRegistry;
+  pendingDashboardSpawns?: Map<string, number>;
+}
+
+type IdParams = { Params: { id: string } };
+
+/** Helper: validate session exists, return it or send error response */
+function getSessionOrFail(sessionManager: SessionManager, id: string): { session: any } | { error: ApiResponse } {
+  const session = sessionManager.get(id);
+  if (!session) return { error: { success: false, error: "session not found" } };
+  return { session };
+}
+
+export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDeps) {
+  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns } = deps;
+
+  // POST /api/session/:id/prompt
+  fastify.post<IdParams & { Body: { text?: string; images?: any[] } }>(
+    "/api/session/:id/prompt",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { text, images } = request.body ?? {};
+      if (!text) {
+        reply.code(400);
+        return { success: false, error: "text is required" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const sent = piGateway.sendToSession(id, {
+        type: "send_prompt",
+        sessionId: id,
+        text,
+        images,
+      });
+      if (!sent) {
+        reply.code(502);
+        return { success: false, error: "no bridge connection for session" } satisfies ApiResponse;
+      }
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/abort
+  fastify.post<IdParams>(
+    "/api/session/:id/abort",
+    async (request, reply) => {
+      const { id } = request.params;
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      piGateway.sendToSession(id, { type: "abort", sessionId: id });
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/shutdown
+  fastify.post<IdParams>(
+    "/api/session/:id/shutdown",
+    async (request, reply) => {
+      const { id } = request.params;
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      piGateway.sendToSession(id, { type: "shutdown", sessionId: id });
+      browserGateway.headlessPidRegistry.killBySessionId(id);
+      sessionManager.unregister(id);
+      browserGateway.broadcastSessionRemoved(id);
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/rename
+  fastify.post<IdParams & { Body: { name?: string } }>(
+    "/api/session/:id/rename",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { name } = request.body ?? {};
+      if (name === undefined) {
+        reply.code(400);
+        return { success: false, error: "name is required" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const updates = { name: name || undefined };
+      sessionManager.update(id, updates);
+      browserGateway.broadcastSessionUpdated(id, updates);
+      piGateway.sendToSession(id, { type: "rename_session", sessionId: id, name });
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/hide
+  fastify.post<IdParams>(
+    "/api/session/:id/hide",
+    async (request, reply) => {
+      const { id } = request.params;
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const updates = { hidden: true };
+      sessionManager.update(id, updates);
+      browserGateway.broadcastSessionUpdated(id, updates);
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/unhide
+  fastify.post<IdParams>(
+    "/api/session/:id/unhide",
+    async (request, reply) => {
+      const { id } = request.params;
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const updates = { hidden: false };
+      sessionManager.update(id, updates);
+      browserGateway.broadcastSessionUpdated(id, updates);
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/spawn
+  fastify.post<{ Body: { cwd?: string } }>(
+    "/api/session/spawn",
+    async (request, reply) => {
+      const { cwd } = request.body ?? {};
+      if (!cwd) {
+        reply.code(400);
+        return { success: false, error: "cwd is required" } satisfies ApiResponse;
+      }
+      const config = loadConfig();
+      const spawnResult = await spawnPiSession(cwd, { strategy: config.spawnStrategy });
+      if (spawnResult.process && spawnResult.pid) {
+        browserGateway.headlessPidRegistry.register(spawnResult.pid, cwd, spawnResult.process);
+      }
+      if (spawnResult.dashboardSpawned && spawnResult.success) {
+        pendingDashboardSpawns?.set(cwd, (pendingDashboardSpawns?.get(cwd) ?? 0) + 1);
+      }
+      if (!spawnResult.success) {
+        reply.code(500);
+        return { success: false, error: spawnResult.message } satisfies ApiResponse;
+      }
+      return { success: true, data: { message: spawnResult.message } } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/resume
+  fastify.post<IdParams & { Body: { mode?: string } }>(
+    "/api/session/:id/resume",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { mode } = request.body ?? {};
+      if (mode !== "continue" && mode !== "fork") {
+        reply.code(400);
+        return { success: false, error: "mode must be 'continue' or 'fork'" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const session = result.session;
+      if (!session.sessionFile) {
+        reply.code(400);
+        return { success: false, error: "session file is unknown" } satisfies ApiResponse;
+      }
+      if (mode === "continue" && session.status !== "ended") {
+        reply.code(409);
+        return { success: false, error: "session is already active" } satisfies ApiResponse;
+      }
+      if (session.resuming) {
+        reply.code(409);
+        return { success: false, error: "session is already being resumed" } satisfies ApiResponse;
+      }
+      if (mode === "fork" && pendingForkRegistry) {
+        pendingForkRegistry.recordFork(session.cwd, id);
+      }
+      const config = loadConfig();
+      const spawnResult = await spawnPiSession(session.cwd, {
+        sessionFile: session.sessionFile,
+        mode,
+        strategy: config.spawnStrategy,
+      });
+      if (spawnResult.dashboardSpawned && spawnResult.success) {
+        pendingDashboardSpawns?.set(session.cwd, (pendingDashboardSpawns?.get(session.cwd) ?? 0) + 1);
+      }
+      if (!spawnResult.success) {
+        reply.code(500);
+        return { success: false, error: spawnResult.message } satisfies ApiResponse;
+      }
+      return { success: true, data: { message: spawnResult.message } } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/flow-control
+  fastify.post<IdParams & { Body: { action?: string } }>(
+    "/api/session/:id/flow-control",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { action } = request.body ?? {};
+      if (action !== "abort" && action !== "toggle_autonomous") {
+        reply.code(400);
+        return { success: false, error: "action must be 'abort' or 'toggle_autonomous'" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      piGateway.sendToSession(id, { type: "flow_control", sessionId: id, action });
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/model
+  fastify.post<IdParams & { Body: { provider?: string; modelId?: string } }>(
+    "/api/session/:id/model",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { provider, modelId } = request.body ?? {};
+      if (!provider || !modelId) {
+        reply.code(400);
+        return { success: false, error: "provider and modelId are required" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      piGateway.sendToSession(id, { type: "set_model", sessionId: id, provider, modelId });
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/thinking-level
+  fastify.post<IdParams & { Body: { level?: string } }>(
+    "/api/session/:id/thinking-level",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { level } = request.body ?? {};
+      if (!level) {
+        reply.code(400);
+        return { success: false, error: "level is required" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      piGateway.sendToSession(id, { type: "set_thinking_level", sessionId: id, level });
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/attach-proposal
+  fastify.post<IdParams & { Body: { changeName?: string } }>(
+    "/api/session/:id/attach-proposal",
+    async (request, reply) => {
+      const { id } = request.params;
+      const { changeName } = request.body ?? {};
+      if (!changeName) {
+        reply.code(400);
+        return { success: false, error: "changeName is required" } satisfies ApiResponse;
+      }
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const updates: Record<string, unknown> = { attachedProposal: changeName };
+      const session = result.session;
+      if (!session.name?.trim()) {
+        updates.name = changeName;
+        piGateway.sendToSession(id, { type: "rename_session", sessionId: id, name: changeName });
+      }
+      sessionManager.update(id, updates);
+      browserGateway.broadcastSessionUpdated(id, updates);
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+
+  // POST /api/session/:id/detach-proposal
+  fastify.post<IdParams>(
+    "/api/session/:id/detach-proposal",
+    async (request, reply) => {
+      const { id } = request.params;
+      const result = getSessionOrFail(sessionManager, id);
+      if ("error" in result) {
+        reply.code(404);
+        return result.error;
+      }
+      const updates = { attachedProposal: null, openspecPhase: null, openspecChange: null };
+      sessionManager.update(id, updates);
+      browserGateway.broadcastSessionUpdated(id, updates);
+      return { success: true } satisfies ApiResponse;
+    },
+  );
+}

package/packages/server/src/session-bootstrap.ts

@@ -0,0 +1,80 @@
+/**
+ * Session bootstrap: discovers sessions from known directories and starts OpenSpec polling.
+ * Called during server startup (async, non-blocking).
+ */
+import type { SessionManager } from "./memory-session-manager.js";
+import type { BrowserGateway } from "./browser-gateway.js";
+import type { DirectoryService } from "./directory-service.js";
+import { extractSessionStats } from "./session-stats-reader.js";
+
+export interface SessionBootstrapDeps {
+  sessionManager: SessionManager;
+  browserGateway: BrowserGateway;
+  directoryService: DirectoryService;
+}
+
+/**
+ * Discover sessions from all known directories and broadcast them.
+ * Runs async and does not block server startup.
+ */
+export async function discoverAndBroadcastSessions(deps: SessionBootstrapDeps): Promise<void> {
+  const { sessionManager, browserGateway, directoryService } = deps;
+
+  try {
+    const dirs = directoryService.knownDirectories();
+    for (const cwd of dirs) {
+      const discovered = directoryService.discoverSessions(cwd);
+      for (const hist of discovered) {
+        if (!sessionManager.get(hist.id)) {
+          let contextTokens: number | undefined;
+          let contextWindow: number | undefined;
+          let model: string | undefined;
+          if (hist.sessionFile) {
+            try {
+              const stats = extractSessionStats(hist.sessionFile);
+              if (stats) {
+                contextTokens = stats.lastTotalTokens;
+                contextWindow = stats.contextWindow;
+                model = stats.model;
+              }
+            } catch { /* ignore */ }
+          }
+          sessionManager.restore({
+            id: hist.id,
+            cwd: hist.cwd,
+            name: hist.name,
+            source: "tui",
+            status: "ended",
+            startedAt: hist.startedAt,
+            sessionFile: hist.sessionFile,
+            sessionDir: hist.sessionDir,
+            firstMessage: hist.firstMessage,
+            hidden: true,
+            dataUnavailable: true,
+            model,
+            contextTokens,
+            contextWindow,
+          });
+          const session = sessionManager.get(hist.id);
+          if (session) browserGateway.broadcastSessionAdded(session);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("[dashboard] Session discovery failed:", err);
+  }
+
+  // Start OpenSpec polling, broadcast changes to browsers
+  directoryService.startPolling((cwd, data) => {
+    browserGateway.broadcastToAll({
+      type: "openspec_update",
+      cwd,
+      data,
+    } as any);
+  });
+
+  // Initial OpenSpec poll for all known directories
+  await Promise.all(
+    directoryService.knownDirectories().map((cwd) => directoryService.refreshOpenSpec(cwd)),
+  );
+}

package/packages/server/src/session-diff.ts

@@ -0,0 +1,178 @@
+/**
+ * Session diff extraction — scans session events for file changes
+ * and optionally enriches with git diffs.
+ */
+import { execSync } from "node:child_process";
+import { resolve, relative, isAbsolute } from "node:path";
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type { FileChangeEvent, FileDiffEntry, EditOperation } from "@blackbelt-technology/pi-dashboard-shared/diff-types.js";
+import { isGitRepo } from "./git-operations.js";
+
+const GIT_TIMEOUT = 15_000;
+const MAX_MESSAGE_LENGTH = 120;
+
+const WRITE_EDIT_TOOLS = new Set(["write", "edit"]);
+
+/**
+ * Extract file change events from session events.
+ * Scans tool_execution_start events for Write/Edit tools,
+ * groups by file path, and includes preceding assistant message as context.
+ */
+export function extractFileChanges(events: DashboardEvent[], cwd: string): FileDiffEntry[] {
+  const fileMap = new Map<string, FileChangeEvent[]>();
+  let lastAssistantMessage: string | undefined;
+
+  for (const event of events) {
+    // Track most recent assistant message for context
+    if (event.eventType === "message_end") {
+      const msg = event.data.message as any;
+      if (msg?.role === "assistant") {
+        const content = Array.isArray(msg.content)
+          ? msg.content
+              .filter((c: any) => c?.type === "text")
+              .map((c: any) => c.text)
+              .join("")
+          : typeof msg.content === "string" ? msg.content : "";
+        if (content) {
+          lastAssistantMessage = content.length > MAX_MESSAGE_LENGTH
+            ? content.slice(0, MAX_MESSAGE_LENGTH) + "..."
+            : content;
+        }
+      }
+    }
+
+    if (event.eventType !== "tool_execution_start") continue;
+
+    const toolName = (event.data.toolName as string || "").toLowerCase();
+    if (!WRITE_EDIT_TOOLS.has(toolName)) continue;
+
+    const args = event.data.args as Record<string, unknown> | undefined;
+    if (!args) continue;
+
+    const rawPath = (args.path || args.file_path) as string | undefined;
+    if (!rawPath) continue;
+
+    // Resolve and filter paths outside cwd
+    const filePath = normalizePath(rawPath, cwd);
+    if (!filePath) continue;
+
+    const changeEvent: FileChangeEvent = {
+      type: toolName === "write" ? "write" : "edit",
+      timestamp: event.timestamp,
+      message: lastAssistantMessage,
+    };
+
+    if (toolName === "write") {
+      changeEvent.content = args.content as string | undefined;
+    } else {
+      changeEvent.edits = args.edits as EditOperation[] | undefined;
+    }
+
+    const existing = fileMap.get(filePath);
+    if (existing) {
+      existing.push(changeEvent);
+    } else {
+      fileMap.set(filePath, [changeEvent]);
+    }
+  }
+
+  // Build result, sorted by path, changes sorted by timestamp
+  const result: FileDiffEntry[] = [];
+  for (const [path, changes] of fileMap) {
+    changes.sort((a, b) => a.timestamp - b.timestamp);
+    result.push({ path, changes });
+  }
+  result.sort((a, b) => a.path.localeCompare(b.path));
+
+  return result;
+}
+
+/**
+ * Normalize a file path relative to cwd.
+ * Returns null if the path is outside cwd.
+ */
+function normalizePath(rawPath: string, cwd: string): string | null {
+  let absPath: string;
+  if (isAbsolute(rawPath)) {
+    absPath = rawPath;
+  } else {
+    absPath = resolve(cwd, rawPath);
+  }
+
+  // Check if the resolved path is inside cwd
+  const rel = relative(cwd, absPath);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return null;
+  }
+
+  return rel;
+}
+
+/**
+ * Enrich file entries with git diff output.
+ * Runs `git diff HEAD -- <path>` for each file when in a git repo.
+ * Returns gracefully on any git errors.
+ */
+export function enrichWithGitDiff(
+  cwd: string,
+  files: FileDiffEntry[],
+): { enrichedFiles: FileDiffEntry[]; isGitRepo: boolean } {
+  let gitAvailable = false;
+  try {
+    gitAvailable = isGitRepo(cwd);
+  } catch {
+    return { enrichedFiles: files, isGitRepo: false };
+  }
+
+  if (!gitAvailable) {
+    return { enrichedFiles: files, isGitRepo: false };
+  }
+
+  const enriched = files.map((file) => {
+    try {
+      const diff = execSync(`git diff HEAD -- ${JSON.stringify(file.path)}`, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: GIT_TIMEOUT,
+      }).trim();
+
+      if (diff) {
+        return { ...file, gitDiff: diff };
+      }
+
+      // No diff from HEAD — try untracked (new file)
+      const status = execSync(`git status --porcelain -- ${JSON.stringify(file.path)}`, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: GIT_TIMEOUT,
+      }).trim();
+
+      if (status.startsWith("??") || status.startsWith("A")) {
+        // Untracked or newly added — generate synthetic diff
+        const content = execSync(`cat ${JSON.stringify(resolve(cwd, file.path))}`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: GIT_TIMEOUT,
+        });
+        const lines = content.split("\n");
+        const diffLines = [
+          `diff --git a/${file.path} b/${file.path}`,
+          "new file mode 100644",
+          `--- /dev/null`,
+          `+++ b/${file.path}`,
+          `@@ -0,0 +1,${lines.length} @@`,
+          ...lines.map((l) => `+${l}`),
+        ];
+        return { ...file, gitDiff: diffLines.join("\n") };
+      }
+
+      return file;
+    } catch {
+      return file;
+    }
+  });
+
+  return { enrichedFiles: enriched, isGitRepo: true };
+}