@blackbelt-technology/pi-agent-dashboard 0.2.8 → 0.3.0

package/packages/server/src/pi-core-updater.ts

@@ -0,0 +1,166 @@
+/**
+ * Pi core package updater.
+ *
+ * Runs `npm update -g <pkg>` for globally-installed packages or
+ * `npm update <pkg>` in `~/.pi-dashboard/` for managed installs.
+ * Coordinates with PackageManagerWrapper's busy-lock so extension
+ * operations and core updates can't run concurrently.
+ */
+import { spawn } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+import { existsSync } from "node:fs";
+import type { PiCorePackage, PiCoreUpdateResult } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+import type { PackageManagerWrapper } from "./package-manager-wrapper.js";
+
+const UPDATE_TIMEOUT_MS = 5 * 60 * 1000; // 5 min per package
+
+const MANAGED_DIR = path.join(os.homedir(), ".pi-dashboard");
+
+export interface UpdateProgressEvent {
+	name: string;
+	phase: "start" | "output" | "complete" | "error";
+	message?: string;
+}
+
+export type UpdateProgressListener = (event: UpdateProgressEvent) => void;
+
+export interface PiCoreUpdaterOptions {
+	packageManagerWrapper: PackageManagerWrapper;
+	/** Test seam: override spawner. */
+	runNpmUpdate?: (pkg: PiCorePackage, onOutput: (line: string) => void) => Promise<void>;
+	/** Optional: called after successful update of at least one package. */
+	onAllComplete?: () => Promise<number>;
+}
+
+/** Default npm-update runner. */
+function defaultRunNpmUpdate(
+	pkg: PiCorePackage,
+	onOutput: (line: string) => void,
+): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const args =
+			pkg.installSource === "global"
+				? ["update", "-g", pkg.name]
+				: ["update", pkg.name];
+		const cwd = pkg.installSource === "managed" ? MANAGED_DIR : process.cwd();
+
+		if (pkg.installSource === "managed" && !existsSync(MANAGED_DIR)) {
+			reject(new Error(`Managed install directory not found: ${MANAGED_DIR}`));
+			return;
+		}
+
+		const child = spawn("npm", args, {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			env: process.env,
+		});
+
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			reject(new Error(`npm update timed out after ${UPDATE_TIMEOUT_MS / 1000}s`));
+		}, UPDATE_TIMEOUT_MS);
+
+		let stderrBuf = "";
+
+		child.stdout?.on("data", (chunk: Buffer) => {
+			const lines = chunk.toString().split("\n").filter((l) => l.trim());
+			for (const line of lines) onOutput(line);
+		});
+
+		child.stderr?.on("data", (chunk: Buffer) => {
+			const text = chunk.toString();
+			stderrBuf += text;
+			const lines = text.split("\n").filter((l) => l.trim());
+			for (const line of lines) onOutput(line);
+		});
+
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) {
+				resolve();
+			} else {
+				const hint =
+					pkg.installSource === "global" && /permission|EACCES|EPERM|EROFS/i.test(stderrBuf)
+						? ` (permission error — try: sudo npm update -g ${pkg.name})`
+						: "";
+				reject(new Error(`npm update exited with code ${code}${hint}`));
+			}
+		});
+	});
+}
+
+export class PiCoreUpdater {
+	private listener: UpdateProgressListener | undefined;
+	private readonly pmWrapper: PackageManagerWrapper;
+	private readonly runNpmUpdate: (
+		pkg: PiCorePackage,
+		onOutput: (line: string) => void,
+	) => Promise<void>;
+	private readonly onAllComplete: (() => Promise<number>) | undefined;
+
+	constructor(opts: PiCoreUpdaterOptions) {
+		this.pmWrapper = opts.packageManagerWrapper;
+		this.runNpmUpdate = opts.runNpmUpdate ?? defaultRunNpmUpdate;
+		this.onAllComplete = opts.onAllComplete;
+	}
+
+	setProgressListener(listener: UpdateProgressListener | undefined): void {
+		this.listener = listener;
+	}
+
+	/**
+	 * Update a set of core packages sequentially. Acquires the shared
+	 * busy-lock via PackageManagerWrapper.runExclusive — will throw
+	 * PackageOperationBusyError if an extension operation is running.
+	 *
+	 * Returns per-package results plus the count of sessions reloaded
+	 * after a successful update.
+	 */
+	async update(
+		packages: PiCorePackage[],
+	): Promise<{ results: PiCoreUpdateResult[]; sessionsReloaded: number }> {
+		return this.pmWrapper.runExclusive(async () => {
+			const results: PiCoreUpdateResult[] = [];
+
+			for (const pkg of packages) {
+				this.emit({ name: pkg.name, phase: "start", message: `Updating ${pkg.name}...` });
+				try {
+					await this.runNpmUpdate(pkg, (line) => {
+						this.emit({ name: pkg.name, phase: "output", message: line });
+					});
+					results.push({ name: pkg.name, success: true });
+					this.emit({ name: pkg.name, phase: "complete", message: `Updated ${pkg.name}` });
+				} catch (err) {
+					const msg = (err as Error).message ?? String(err);
+					results.push({ name: pkg.name, success: false, error: msg });
+					this.emit({ name: pkg.name, phase: "error", message: msg });
+				}
+			}
+
+			let sessionsReloaded = 0;
+			if (results.some((r) => r.success) && this.onAllComplete) {
+				try {
+					sessionsReloaded = await this.onAllComplete();
+				} catch (err) {
+					console.error("[pi-core-updater] session reload failed:", err);
+				}
+			}
+
+			return { results, sessionsReloaded };
+		});
+	}
+
+	private emit(event: UpdateProgressEvent): void {
+		try {
+			this.listener?.(event);
+		} catch (err) {
+			console.error("[pi-core-updater] progress listener error:", err);
+		}
+	}
+}

package/packages/server/src/pi-gateway.ts

@@ -17,6 +17,8 @@ export interface PiGatewayOptions {
 export interface PiGateway {
   start(port: number): void;
   stop(): void;
+  /** Resolved listening port after start() (useful when start(0) is used). Returns null if not started or closed. */
+  address(): number | null;
   sendToSession(sessionId: string, msg: ServerToExtensionMessage): boolean;
   broadcast(msg: ServerToExtensionMessage): void;
   connectionCount(): number;
@@ -172,6 +174,11 @@ export function createPiGateway(
       onSessionCreated = handler;
     },
 
+    address() {
+      const addr = wss?.address();
+      if (addr && typeof addr === "object") return addr.port;
+      return null;
+    },
     start(port: number) {
       wss = new WebSocketServer({ port });
 

package/packages/server/src/process-manager.ts

@@ -150,7 +150,7 @@ async function spawnHeadlessWindows(
 
   child.unref();
   (child.stdin as any)?.unref();
-  child.stderr?.unref();
+  (child.stderr as any)?.unref();
 
   // Guard: if pid is undefined, spawn failed synchronously
   if (!child.pid) {

package/packages/server/src/routes/file-routes.ts

@@ -6,7 +6,7 @@ import type { SessionManager } from "../memory-session-manager.js";
 import type { PreferencesStore } from "../preferences-store.js";
 import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { NetworkGuard } from "./route-deps.js";
-import { listDirectories } from "../browse.js";
+import { listDirectories, createDirectory } from "../browse.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 
@@ -21,12 +21,15 @@ export function registerFileRoutes(
   const { sessionManager, preferencesStore, networkGuard } = deps;
 
   // Directory browse endpoint
-  fastify.get<{ Querystring: { path?: string } }>(
+  fastify.get<{ Querystring: { path?: string; q?: string } }>(
     "/api/browse",
     { preHandler: networkGuard },
     async (request) => {
       try {
-        const result = await listDirectories(request.query.path || undefined);
+        const result = await listDirectories(
+          request.query.path || undefined,
+          request.query.q || undefined,
+        );
         return { success: true, data: result } satisfies ApiResponse;
       } catch {
         return { success: false, error: "directory not found" } satisfies ApiResponse;
@@ -34,6 +37,30 @@ export function registerFileRoutes(
     },
   );
 
+  // Directory create endpoint
+  fastify.post<{ Body: { parent?: unknown; name?: unknown } }>(
+    "/api/browse/mkdir",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const body = request.body ?? {};
+      const parent = typeof body.parent === "string" ? body.parent : "";
+      const name = typeof body.name === "string" ? body.name : "";
+      try {
+        const newPath = await createDirectory(parent, name);
+        return { success: true, data: { path: newPath } } satisfies ApiResponse;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "mkdir failed";
+        // Map known errors to status codes; unknown → 500
+        if (msg === "invalid name") reply.code(400);
+        else if (msg === "parent not found") reply.code(404);
+        else if (msg === "parent is not a directory") reply.code(400);
+        else if (msg === "already exists") reply.code(409);
+        else reply.code(500);
+        return { success: false, error: msg } satisfies ApiResponse;
+      }
+    },
+  );
+
   // File read endpoint — read file content or list directory
   fastify.get<{ Querystring: { cwd?: string; path?: string } }>(
     "/api/file",

package/packages/server/src/routes/openspec-routes.ts

@@ -8,9 +8,19 @@ import type { DirectoryService } from "../directory-service.js";
 import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { NetworkGuard } from "./route-deps.js";
 import { scanOpenSpecArchive } from "../openspec-archive.js";
+import {
+  readTasks,
+  toggleTask,
+  NotFoundError,
+  LineMismatchError,
+  NotACheckboxError,
+} from "../openspec-tasks.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 
+/** Callback to broadcast an openspec_update after a successful toggle. */
+export type OpenSpecBroadcaster = (cwd: string) => void;
+
 export function registerOpenSpecRoutes(
   fastify: FastifyInstance,
   deps: {
@@ -18,9 +28,11 @@ export function registerOpenSpecRoutes(
     preferencesStore: PreferencesStore;
     directoryService: DirectoryService;
     networkGuard: NetworkGuard;
+    /** Optional — called after a successful toggle to trigger openspec_update. */
+    onOpenSpecChanged?: OpenSpecBroadcaster;
   },
 ) {
-  const { sessionManager, preferencesStore, directoryService, networkGuard } = deps;
+  const { sessionManager, preferencesStore, directoryService, networkGuard, onOpenSpecChanged } = deps;
 
   // OpenSpec archive listing endpoint
   fastify.get<{ Querystring: { cwd?: string } }>(
@@ -96,4 +108,74 @@ export function registerOpenSpecRoutes(
       }
     },
   );
+
+  // --- Tasks.md list + toggle ---
+
+  fastify.get<{ Querystring: { cwd?: string; change?: string } }>(
+    "/api/openspec/tasks",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { cwd, change } = request.query;
+      if (!cwd || !change) {
+        reply.code(400);
+        return { success: false, error: "cwd and change query params required" } satisfies ApiResponse;
+      }
+      try {
+        const tasks = await readTasks(cwd, change);
+        const groups = Array.from(new Set(tasks.map((t) => t.group).filter((g) => g.length > 0)));
+        return { success: true, data: { tasks, groups } } satisfies ApiResponse;
+      } catch (err: any) {
+        if (err instanceof NotFoundError) {
+          reply.code(404);
+          return { success: false, error: "tasks.md not found" } satisfies ApiResponse;
+        }
+        reply.code(500);
+        return { success: false, error: err?.message ?? "read error" } satisfies ApiResponse;
+      }
+    },
+  );
+
+  fastify.post<{
+    Body: { cwd?: string; change?: string; id?: string; done?: boolean; line?: number };
+  }>(
+    "/api/openspec/tasks/toggle",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const body = request.body ?? {};
+      const { cwd, change, id, done, line } = body;
+      if (
+        typeof cwd !== "string" ||
+        typeof change !== "string" ||
+        typeof id !== "string" ||
+        typeof done !== "boolean" ||
+        typeof line !== "number"
+      ) {
+        reply.code(400);
+        return { success: false, error: "invalid body" } satisfies ApiResponse;
+      }
+      try {
+        const task = await toggleTask(cwd, change, id, done, line);
+        // Fire-and-forget: refresh cache + broadcast openspec_update.
+        directoryService.refreshOpenSpec(cwd).then(() => {
+          onOpenSpecChanged?.(cwd);
+        }).catch(() => {});
+        return { success: true, data: { task } } satisfies ApiResponse;
+      } catch (err: any) {
+        if (err instanceof NotFoundError) {
+          reply.code(404);
+          return { success: false, error: "tasks.md not found" } satisfies ApiResponse;
+        }
+        if (err instanceof LineMismatchError) {
+          reply.code(409);
+          return { success: false, error: "line mismatch" } satisfies ApiResponse;
+        }
+        if (err instanceof NotACheckboxError) {
+          reply.code(400);
+          return { success: false, error: "target line is not a checkbox" } satisfies ApiResponse;
+        }
+        reply.code(500);
+        return { success: false, error: err?.message ?? "toggle error" } satisfies ApiResponse;
+      }
+    },
+  );
 }

package/packages/server/src/routes/pi-core-routes.ts

@@ -0,0 +1,117 @@
+/**
+ * REST routes for pi core version check and update.
+ *
+ *   GET  /api/pi-core/versions[?refresh=true]
+ *   POST /api/pi-core/update                 { packages?: string[] }
+ *
+ * Complements /api/packages/* (extension management): this endpoint covers
+ * globally-installed pi CLI packages like @mariozechner/pi-coding-agent,
+ * pi-dashboard itself, pi-model-proxy, etc.
+ */
+import type { FastifyInstance } from "fastify";
+import type {
+	ApiResponse,
+	PiCoreStatus,
+	PiCoreUpdateRequest,
+	PiCoreUpdateResponse,
+} from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+import type { PiCoreChecker } from "../pi-core-checker.js";
+import type { PiCoreUpdater } from "../pi-core-updater.js";
+import { PackageOperationBusyError } from "../package-manager-wrapper.js";
+
+export interface PiCoreRouteDeps {
+	piCoreChecker: PiCoreChecker;
+	piCoreUpdater: PiCoreUpdater;
+	/**
+	 * Called after the updater finishes a batch (success or per-package failure).
+	 * The server wires this to broadcast a `pi_core_update_complete` WS message
+	 * so listeners (PiUpdateBadge, PiCoreVersionsSection, usePiCoreVersions
+	 * hook instances in other open tabs) refetch their state.
+	 */
+	onUpdateComplete?: (payload: {
+		results: Array<{ name: string; success: boolean; error?: string }>;
+		sessionsReloaded: number;
+	}) => void;
+}
+
+export function registerPiCoreRoutes(
+	fastify: FastifyInstance,
+	deps: PiCoreRouteDeps,
+): void {
+	const { piCoreChecker, piCoreUpdater } = deps;
+
+	// ── GET /api/pi-core/versions ──────────────────────────────────
+
+	fastify.get<{ Querystring: { refresh?: string } }>(
+		"/api/pi-core/versions",
+		async (request) => {
+			const refresh = request.query.refresh === "true";
+			try {
+				const status = await piCoreChecker.getStatus(refresh);
+				return { success: true, data: status } satisfies ApiResponse<PiCoreStatus>;
+			} catch (err: any) {
+				return { success: false, error: err?.message ?? String(err) } satisfies ApiResponse;
+			}
+		},
+	);
+
+	// ── POST /api/pi-core/update ───────────────────────────────────
+
+	fastify.post<{ Body: PiCoreUpdateRequest }>(
+		"/api/pi-core/update",
+		async (request, reply) => {
+			const requested = request.body?.packages ?? [];
+
+			// Load current status to determine install source and eligibility.
+			const status = await piCoreChecker.getStatus();
+			const allByName = new Map(status.packages.map((p) => [p.name, p]));
+
+			const targetNames =
+				requested.length > 0
+					? requested
+					: status.packages.filter((p) => p.updateAvailable).map((p) => p.name);
+
+			const resolved = [];
+			const unknown: string[] = [];
+			for (const name of targetNames) {
+				const pkg = allByName.get(name);
+				if (!pkg) {
+					unknown.push(name);
+					continue;
+				}
+				resolved.push(pkg);
+			}
+
+			if (unknown.length > 0) {
+				reply.code(400);
+				return {
+					success: false,
+					error: `Unknown package(s): ${unknown.join(", ")}`,
+				} satisfies ApiResponse;
+			}
+
+			if (resolved.length === 0) {
+				return {
+					success: true,
+					data: { results: [], sessionsReloaded: 0 },
+				} satisfies ApiResponse<PiCoreUpdateResponse>;
+			}
+
+			try {
+				const out = await piCoreUpdater.update(resolved);
+				// Invalidate cache so next version check reflects new versions.
+				piCoreChecker.invalidate();
+				// Notify other browser tabs / the header badge hook instance so
+				// their independent usePiCoreVersions state refetches.
+				deps.onUpdateComplete?.(out);
+				return { success: true, data: out } satisfies ApiResponse<PiCoreUpdateResponse>;
+			} catch (err: any) {
+				if (err instanceof PackageOperationBusyError) {
+					reply.code(409);
+					return { success: false, error: err.message } satisfies ApiResponse;
+				}
+				return { success: false, error: err?.message ?? String(err) } satisfies ApiResponse;
+			}
+		},
+	);
+}

package/packages/server/src/routes/provider-auth-routes.ts

@@ -21,6 +21,7 @@ import {
 } from "../provider-auth-storage.js";
 import { startCallbackServer } from "../oauth-callback-server.js";
 import type { PiGateway } from "../pi-gateway.js";
+import type { BrowserGateway } from "../browser-gateway.js";
 
 // ── In-memory flow store (short-lived PKCE + device code state) ──────────────
 
@@ -81,12 +82,13 @@ function openInBrowser(url: string): void {
 
 export function registerProviderAuthRoutes(
   fastify: FastifyInstance,
-  deps: { piGateway: PiGateway },
+  deps: { piGateway: PiGateway; browserGateway: BrowserGateway },
 ) {
-  const { piGateway } = deps;
+  const { piGateway, browserGateway } = deps;
 
   function notifyBridges() {
     piGateway.broadcast({ type: "credentials_updated" });
+    browserGateway.broadcastToAll({ type: "models_refreshed" });
   }
 
   // List OAuth providers

package/packages/server/src/routes/provider-routes.ts

@@ -6,6 +6,8 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import type { NetworkGuard } from "./route-deps.js";
+import type { PiGateway } from "../pi-gateway.js";
+import type { BrowserGateway } from "../browser-gateway.js";
 
 const REDACTED = "***";
 const CONFIG_PATH = join(homedir(), ".pi", "agent", "providers.json");
@@ -44,8 +46,8 @@ function redactProviders(
   return redacted;
 }
 
-export function registerProviderRoutes(fastify: FastifyInstance, deps: { networkGuard: NetworkGuard }): void {
-  const { networkGuard } = deps;
+export function registerProviderRoutes(fastify: FastifyInstance, deps: { networkGuard: NetworkGuard; piGateway?: PiGateway; browserGateway?: BrowserGateway }): void {
+  const { networkGuard, piGateway } = deps;
   fastify.get(
     "/api/providers",
     { preHandler: networkGuard },
@@ -95,6 +97,14 @@ export function registerProviderRoutes(fastify: FastifyInstance, deps: { network
       mkdirSync(dir, { recursive: true });
       writeFileSync(CONFIG_PATH, JSON.stringify(fileData, null, 2) + "\n", "utf-8");
 
+      // Broadcast credentials_updated so all sessions refresh their model registries
+      if (piGateway) {
+        piGateway.broadcast({ type: "credentials_updated" });
+      }
+      if (deps.browserGateway) {
+        deps.browserGateway.broadcastToAll({ type: "models_refreshed" });
+      }
+
       return { success: true };
     },
   );