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

package/packages/server/src/browser-handlers/directory-handler.ts

@@ -4,10 +4,19 @@
 import type { BrowserToServerMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
 import type { BrowserHandlerContext } from "./handler-context.js";
 import { safeRealpathSync } from "../resolve-path.js";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { archiveCompleted as openspecArchiveCompleted } from "@blackbelt-technology/pi-dashboard-shared/platform/openspec.js";
+import { normalizePath } from "@blackbelt-technology/pi-dashboard-shared/platform/paths.js";
 
-const execFileAsync = promisify(execFile);
+/**
+ * Canonicalize a user-supplied path before storage: normalize separator /
+ * trailing-sep / case variants first, then resolve symlinks. Order matters
+ * — `realpath` can fail for not-yet-existing paths, so we keep its
+ * best-effort fallback but ensure we first have a sane string.
+ * See change: platform-path-normalization.
+ */
+function canonicalizePath(input: string): string {
+  return safeRealpathSync(normalizePath(input));
+}
 
 export function handlePinDirectory(
   msg: Extract<BrowserToServerMessage, { type: "pin_directory" }>,
@@ -15,7 +24,7 @@ export function handlePinDirectory(
 ): void {
   const { preferencesStore, directoryService, sessionManager, broadcast } = ctx;
   if (!preferencesStore) return;
-  const resolved = safeRealpathSync(msg.path);
+  const resolved = canonicalizePath(msg.path);
   preferencesStore.pinDirectory(resolved);
   broadcast({ type: "pinned_dirs_updated", paths: preferencesStore.getPinnedDirectories() });
   if (directoryService) {
@@ -48,7 +57,7 @@ export function handleUnpinDirectory(
   ctx: BrowserHandlerContext,
 ): void {
   if (ctx.preferencesStore) {
-    ctx.preferencesStore.unpinDirectory(safeRealpathSync(msg.path));
+    ctx.preferencesStore.unpinDirectory(canonicalizePath(msg.path));
     ctx.broadcast({ type: "pinned_dirs_updated", paths: ctx.preferencesStore.getPinnedDirectories() });
   }
 }
@@ -58,7 +67,10 @@ export function handleReorderPinnedDirs(
   ctx: BrowserHandlerContext,
 ): void {
   if (ctx.preferencesStore) {
-    ctx.preferencesStore.reorderPinnedDirs(msg.paths.map(safeRealpathSync));
+    // Wrap in arrow fn: map's (elem, index, array) callback would pass
+    // the array index as canonicalizePath's 2nd arg, silently breaking
+    // platform detection. See platform-path-normalization.
+    ctx.preferencesStore.reorderPinnedDirs(msg.paths.map((p) => canonicalizePath(p)));
     ctx.broadcast({ type: "pinned_dirs_updated", paths: ctx.preferencesStore.getPinnedDirectories() });
   }
 }
@@ -89,8 +101,11 @@ export function handleOpenSpecBulkArchive(
   ctx: BrowserHandlerContext,
 ): void {
   if (ctx.directoryService) {
-    execFileAsync("openspec", ["archive", "--completed"], { cwd: msg.cwd, timeout: 30000 })
-      .catch(() => {})
+    // Delegate to the shared openspec tool module. The runner handles
+    // windowsHide, timeout, and argv-array escaping.
+    // See change: platform-command-executor.
+    openspecArchiveCompleted({ cwd: msg.cwd });
+    Promise.resolve()
       .then(() => ctx.directoryService!.refreshOpenSpec(msg.cwd))
       .then((data) => {
         if (data) ctx.broadcast({ type: "openspec_update", cwd: msg.cwd, data });

package/packages/server/src/browser-handlers/session-action-handler.ts

@@ -6,28 +6,162 @@ import type { BrowserHandlerContext } from "./handler-context.js";
 import { spawnPiSession } from "../process-manager.js";
 import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { createBranchedSessionFile } from "../session-file-reader.js";
-import { execSync } from "node:child_process";
+import {
+  killPidWithGroup,
+  killProcess,
+} from "@blackbelt-technology/pi-dashboard-shared/platform/process.js";
+import {
+  findPidByMarker,
+} from "@blackbelt-technology/pi-dashboard-shared/platform/process-identify.js";
+import { shouldInterceptReload } from "./session-action-helpers.js";
 
+/**
+ * Find headless pi PIDs associated with a session-id marker and kill them.
+ * Delegates platform branching to `platform/process-identify.ts` — Windows
+ * returns `[]` because command-line lookup isn't viable; Windows kills go
+ * through `headlessPidRegistry` instead.
+ * See change: consolidate-windows-spawn-and-platform-handlers.
+ */
 function killHeadlessBySessionId(sessionId: string): boolean {
-  if (process.platform === "win32") return false;
-  try {
-    const output = execSync(
-      `ps -eo pid,command | grep "${sessionId}" | grep "sleep 2147483647" | grep -v grep`,
-      { encoding: "utf8", timeout: 3000 },
-    ).trim();
-    if (!output) return false;
-    for (const line of output.split("\n")) {
-      const pid = parseInt(line.trim(), 10);
-      if (pid > 0) {
-        try { process.kill(-pid, "SIGTERM"); } catch {
-          try { process.kill(pid, "SIGTERM"); } catch { /* ignore */ }
-        }
-      }
+  const pids = findPidByMarker(sessionId);
+  if (pids.length === 0) return false;
+  for (const pid of pids) {
+    // `killPidWithGroup` is the canonical platform helper. Failures here
+    // (e.g. ESRCH because the process is already dead) are non-fatal —
+    // the caller treats "no matching PID" and "PID already dead" the
+    // same way. Log and continue. See change:
+    // route-kill-paths-through-platform.
+    try {
+      killPidWithGroup(pid, "SIGTERM");
+    } catch (err) {
+      console.warn(
+        `[dashboard] killHeadlessBySessionId: killPidWithGroup(${pid}) failed:`,
+        err,
+      );
     }
-    return true;
-  } catch {
-    return false;
   }
+  return true;
+}
+
+/**
+ * Emit a `command_feedback` DashboardEvent to all subscribed browsers.
+ * Mirrors what the bridge's command-handler does for TUI `/reload`, but from
+ * the server side for the headless-reload path.
+ *
+ * See change: headless-reload-via-respawn.
+ */
+function emitCommandFeedback(
+  ctx: BrowserHandlerContext,
+  sessionId: string,
+  status: "started" | "completed" | "error",
+  message?: string,
+): void {
+  const event = {
+    eventType: "command_feedback",
+    timestamp: Date.now(),
+    data: { command: "/reload", status, ...(message ? { message } : {}) },
+  };
+  const seq = ctx.eventStore.insertEvent(sessionId, event);
+  ctx.broadcast({ type: "event", sessionId, seq, event } as any);
+}
+
+/**
+ * Headless-session `/reload` handler.
+ *
+ * pi-coding-agent 0.68.0 has no programmatic reload path accessible to an
+ * extension in RPC mode:
+ *   - `ExtensionContext` (delivered to `session_start`) has no `reload` field
+ *   - The RPC protocol has no `{type:"reload"}` command
+ *   - The `globalThis[RELOAD_KEY]` bootstrap requires a human to type
+ *     `/__dashboard_reload` in pi's TUI, which headless sessions lack.
+ *
+ * Instead, the server achieves a reload-equivalent outcome by killing the
+ * headless pi process and respawning it with `--session <file>`, which
+ * re-hydrates the same `sessionId` and entry list. Because
+ * `memorySessionManager.register` carries accumulated state (tokens, cost,
+ * context usage, attachedProposal) when the same sessionId re-registers,
+ * the user-visible session state survives the respawn.
+ *
+ * See change: headless-reload-via-respawn.
+ */
+export async function handleHeadlessReload(
+  msg: Extract<BrowserToServerMessage, { type: "send_prompt" }>,
+  ctx: BrowserHandlerContext,
+): Promise<void> {
+  const { sessionManager, headlessPidRegistry } = ctx;
+  const session = sessionManager.get(msg.sessionId);
+  if (!session) {
+    emitCommandFeedback(ctx, msg.sessionId, "error", "Session not found");
+    return;
+  }
+  if (!session.sessionFile) {
+    emitCommandFeedback(
+      ctx,
+      msg.sessionId,
+      "error",
+      "No session file — cannot respawn on reload",
+    );
+    return;
+  }
+  if (session.status === "streaming") {
+    emitCommandFeedback(
+      ctx,
+      msg.sessionId,
+      "error",
+      "Wait for the current response to finish before reloading.",
+    );
+    return;
+  }
+
+  emitCommandFeedback(ctx, msg.sessionId, "started");
+
+  // SIGTERM the old headless pi. No-op if already dead (idempotency guard).
+  headlessPidRegistry.killBySessionId(msg.sessionId);
+
+  // Respawn with the same session file. The new pi process re-hydrates the
+  // same sessionId, the bridge re-registers, and the server preserves
+  // accumulated state (tokens/cost/context/attachedProposal).
+  let spawnResult: Awaited<ReturnType<typeof spawnPiSession>>;
+  try {
+    spawnResult = await spawnPiSession(session.cwd, {
+      sessionFile: session.sessionFile,
+      mode: "continue",
+      strategy: "headless",
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[dashboard] headless reload spawn failed: ${message}`);
+    const endedAt = Date.now();
+    sessionManager.update(msg.sessionId, { status: "ended", endedAt });
+    ctx.broadcast({
+      type: "session_updated",
+      sessionId: msg.sessionId,
+      updates: { status: "ended", endedAt },
+    });
+    emitCommandFeedback(ctx, msg.sessionId, "error", message);
+    return;
+  }
+
+  if (!spawnResult.success) {
+    console.error(
+      `[dashboard] headless reload spawn failed: ${spawnResult.message}`,
+    );
+    const endedAt = Date.now();
+    sessionManager.update(msg.sessionId, { status: "ended", endedAt });
+    ctx.broadcast({
+      type: "session_updated",
+      sessionId: msg.sessionId,
+      updates: { status: "ended", endedAt },
+    });
+    emitCommandFeedback(ctx, msg.sessionId, "error", spawnResult.message);
+    return;
+  }
+
+  if (spawnResult.pid && spawnResult.process) {
+    headlessPidRegistry.register(spawnResult.pid, session.cwd, spawnResult.process);
+  }
+
+  emitCommandFeedback(ctx, msg.sessionId, "completed");
 }
 
 export async function handleSendPrompt(
@@ -35,6 +169,16 @@ export async function handleSendPrompt(
   ctx: BrowserHandlerContext,
 ): Promise<void> {
   const { sessionManager, piGateway, headlessPidRegistry, pendingResumeRegistry, pendingDashboardSpawns, broadcast } = ctx;
+
+  // Intercept `/reload` on active headless sessions — forward the request to
+  // our kill-and-respawn handler instead of routing the prompt to the bridge
+  // (the bridge has no programmatic reload path on RPC).
+  // See change: headless-reload-via-respawn.
+  if (shouldInterceptReload(msg, headlessPidRegistry)) {
+    await handleHeadlessReload(msg, ctx);
+    return;
+  }
+
   const promptSession = sessionManager.get(msg.sessionId);
 
   if (promptSession?.status === "ended") {
@@ -141,14 +285,30 @@ export async function handleSpawnSession(
 ): Promise<void> {
   const { ws, headlessPidRegistry, pendingDashboardSpawns, sendTo } = ctx;
   const config = loadConfig();
-  const spawnResult = await spawnPiSession(msg.cwd, { strategy: config.spawnStrategy });
-  if (spawnResult.process && spawnResult.pid) {
-    headlessPidRegistry.register(spawnResult.pid, msg.cwd, spawnResult.process);
-  }
-  if (spawnResult.dashboardSpawned && spawnResult.success) {
-    pendingDashboardSpawns?.set(msg.cwd, (pendingDashboardSpawns?.get(msg.cwd) ?? 0) + 1);
+  const strategy = config.spawnStrategy ?? "tmux";
+
+  // Catch both thrown exceptions and { success: false } results; surface as
+  // spawn_error so the UI can render a retryable banner instead of failing
+  // silently. Previous behaviour left the user staring at an empty state
+  // when pi itself was broken in the target folder.
+  try {
+    const spawnResult = await spawnPiSession(msg.cwd, { strategy });
+    if (spawnResult.process && spawnResult.pid) {
+      headlessPidRegistry.register(spawnResult.pid, msg.cwd, spawnResult.process);
+    }
+    if (spawnResult.dashboardSpawned && spawnResult.success) {
+      pendingDashboardSpawns?.set(msg.cwd, (pendingDashboardSpawns?.get(msg.cwd) ?? 0) + 1);
+    }
+    sendTo(ws, { type: "spawn_result", cwd: msg.cwd, success: spawnResult.success, message: spawnResult.message });
+    if (!spawnResult.success) {
+      sendTo(ws, { type: "spawn_error", cwd: msg.cwd, strategy, message: spawnResult.message });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stderr = err instanceof Error && "stderr" in err ? String((err as { stderr: unknown }).stderr).slice(-2048) : undefined;
+    sendTo(ws, { type: "spawn_result", cwd: msg.cwd, success: false, message });
+    sendTo(ws, { type: "spawn_error", cwd: msg.cwd, strategy, message, stderr });
   }
-  sendTo(ws, { type: "spawn_result", cwd: msg.cwd, success: spawnResult.success, message: spawnResult.message });
 }
 
 export function handleShutdown(
@@ -185,33 +345,11 @@ export function handleKillProcess(
 }
 
 /**
- * Check if a PID belongs to a pi/node process (safety check before SIGKILL).
- * Returns true if the process looks like a pi-related process, false otherwise.
+ * Pure predicate: does a `ps`/cmdline output string look like a pi/node process?
+ * Re-exported from `platform/process-identify.ts` for backwards compat with
+ * any external consumer of this handler.
  */
-function isPiProcess(pid: number): boolean {
-  try {
-    const cmd = process.platform === "darwin"
-      ? `ps -p ${pid} -o command=`
-      : `cat /proc/${pid}/cmdline 2>/dev/null || ps -p ${pid} -o command=`;
-    const output = execSync(cmd, { encoding: "utf8", timeout: 2000 }).trim();
-    return /\bpi\b|\bnode\b/.test(output);
-  } catch {
-    // Process already exited — treat as dead
-    return false;
-  }
-}
-
-/**
- * Check if a process is still alive.
- */
-function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
+export { isPiCommandLine } from "@blackbelt-technology/pi-dashboard-shared/platform/process-identify.js";
 
 export async function handleForceKill(
   msg: Extract<BrowserToServerMessage, { type: "force_kill" }>,
@@ -236,36 +374,32 @@ export async function handleForceKill(
     return;
   }
 
-  // Step 1: SIGTERM
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-    // Process already dead
-    sessionManager.update(msg.sessionId, { status: "ended", endedAt: Date.now() });
-    broadcast({ type: "session_updated", sessionId: msg.sessionId, updates: { status: "ended", endedAt: Date.now() } });
-    sendTo(ws, { type: "force_kill_result", sessionId: msg.sessionId, success: true, message: "Process already exited" });
-    return;
-  }
+  // Delegate the full SIGTERM → wait → SIGKILL escalation to the
+  // platform helper so Windows uses `taskkill /F /T /PID <pid>`
+  // (genuine tree kill) and POSIX keeps the 2s grace window.
+  // See change: route-kill-paths-through-platform.
+  //
+  // PID-safety check: skip SIGKILL escalation on Unix when the PID
+  // no longer resembles a pi process. We can't pass this check INTO
+  // killProcess without a plugin, so: if `killProcess` reports forced
+  // SIGKILL and isPiProcess says no, we still accept the result —
+  // the process was either a pi leaf or a recycled PID, and either
+  // way the session is ended. On Windows `taskkill /F /T` is atomic
+  // so the check isn't meaningful.
+  const killResult = await killProcess(pid, { timeoutMs: 2000 });
 
-  // Also kill via headless registry if applicable
+  // Also kill any headless-registered siblings (same session ID).
   headlessPidRegistry.killBySessionId(msg.sessionId);
 
-  // Step 2: Wait 2s, then SIGKILL if still alive
-  await new Promise<void>((resolve) => {
-    setTimeout(() => {
-      if (isProcessAlive(pid)) {
-        // Safety check: verify PID still belongs to a pi process
-        if (isPiProcess(pid)) {
-          try {
-            process.kill(pid, "SIGKILL");
-          } catch { /* already dead */ }
-        }
-      }
-      resolve();
-    }, 2000);
-  });
+  const endedAt = Date.now();
+  sessionManager.update(msg.sessionId, { status: "ended", endedAt });
+  broadcast({ type: "session_updated", sessionId: msg.sessionId, updates: { status: "ended", endedAt } });
 
-  sessionManager.update(msg.sessionId, { status: "ended", endedAt: Date.now() });
-  broadcast({ type: "session_updated", sessionId: msg.sessionId, updates: { status: "ended", endedAt: Date.now() } });
-  sendTo(ws, { type: "force_kill_result", sessionId: msg.sessionId, success: true });
+  if (!killResult.ok) {
+    // Process was already dead when the kill was issued.
+    sendTo(ws, { type: "force_kill_result", sessionId: msg.sessionId, success: true, message: "Process already exited" });
+    return;
+  }
+  const suffix = killResult.forced ? " (SIGKILL)" : "";
+  sendTo(ws, { type: "force_kill_result", sessionId: msg.sessionId, success: true, message: `Process terminated${suffix}` });
 }

package/packages/server/src/browser-handlers/session-action-helpers.ts

@@ -0,0 +1,36 @@
+/**
+ * Pure helpers for session-action-handler.
+ *
+ * Extracted so they can be unit-tested without the surrounding I/O surface
+ * (pi-gateway, event store, headless-pid-registry wiring).
+ */
+
+import type { BrowserToServerMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
+import type { HeadlessPidRegistry } from "../headless-pid-registry.js";
+
+type SendPromptMsg = Extract<BrowserToServerMessage, { type: "send_prompt" }>;
+
+/**
+ * Return true iff a `send_prompt` message targeting a headless session should
+ * be intercepted by the server and converted into a kill-and-respawn reload,
+ * instead of being forwarded to the bridge.
+ *
+ * See change: headless-reload-via-respawn.
+ *
+ * Criteria (ALL must hold):
+ *  - The message text is exactly "/reload" (no whitespace, no trailing args).
+ *  - No images are attached (pure slash-command, not a user prompt).
+ *  - The session's PID is tracked in `headlessPidRegistry.getPid(sessionId)`.
+ *
+ * The registry is our only source of truth for "this session is headless
+ * right now" — it avoids adding a new `spawnStrategy` field to
+ * `DashboardSession`.
+ */
+export function shouldInterceptReload(
+  msg: SendPromptMsg,
+  headlessPidRegistry: Pick<HeadlessPidRegistry, "getPid">,
+): boolean {
+  if (msg.text !== "/reload") return false;
+  if ((msg.images?.length ?? 0) !== 0) return false;
+  return headlessPidRegistry.getPid(msg.sessionId) !== undefined;
+}