@blackbelt-technology/pi-agent-dashboard 0.4.1 → 0.4.2

package/packages/server/src/event-wiring.ts

@@ -16,6 +16,7 @@ import { writeSessionMeta } from "@blackbelt-technology/pi-dashboard-shared/sess
 import type { DashboardSession } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import { detectOpenSpecActivity } from "@blackbelt-technology/pi-dashboard-shared/openspec-activity-detector.js";
 import { extractTurnStats } from "@blackbelt-technology/pi-dashboard-shared/stats-extractor.js";
+import { attachRenameTarget, isNameAutoSetFromAttachment } from "./proposal-attach-naming.js";
 
 export interface EventWiringDeps {
   sessionManager: SessionManager;
@@ -27,6 +28,12 @@ export interface EventWiringDeps {
   directoryService: DirectoryService;
   knownSessionIds: Set<string>;
   pendingDashboardSpawns: Map<string, number>;
+  /**
+   * Optional pending-attach registry. When provided, the wiring consumes a
+   * pending intent on each `session_register` and applies the attach +
+   * auto-rename. See change: add-folder-task-checker-and-spawn-attach.
+   */
+  pendingAttachRegistry?: import("./pending-attach-registry.js").PendingAttachRegistry;
 }
 
 /**
@@ -44,6 +51,7 @@ export function wireEvents(deps: EventWiringDeps): void {
     directoryService,
     knownSessionIds,
     pendingDashboardSpawns,
+    pendingAttachRegistry,
   } = deps;
 
   // Broadcast placeholder session to browsers when auto-created from early events
@@ -54,6 +62,28 @@ export function wireEvents(deps: EventWiringDeps): void {
     }
   };
 
+  // Consume any pending spawn-with-attach intent for the registering session.
+  // See change: add-folder-task-checker-and-spawn-attach.
+  piGateway.onSessionRegistered = (sessionId, cwd) => {
+    if (!pendingAttachRegistry) return;
+    const changeName = pendingAttachRegistry.consume(cwd);
+    if (!changeName) return;
+    // Lazy import to avoid a circular type dep at module load.
+    void import("./browser-handlers/session-meta-handler.js").then(({ applyAttachProposal }) => {
+      applyAttachProposal(sessionId, changeName, {
+        sessionManager,
+        piGateway,
+        broadcast: (msg) => {
+          // applyAttachProposal only emits `session_updated`; route via the
+          // browser gateway's typed helper to match the rest of this file.
+          if (msg.type === "session_updated") {
+            browserGateway.broadcastSessionUpdated(msg.sessionId, msg.updates);
+          }
+        },
+      });
+    });
+  };
+
   // Broadcast session ended to browsers when sessions are unregistered
   sessionManager.onUnregister = (sessionId) => {
     const session = sessionManager.get(sessionId);
@@ -66,6 +96,11 @@ export function wireEvents(deps: EventWiringDeps): void {
     }
   };
 
+  // Per-event cap for `Session.uiDataMap[event]`. Phase-1 spec contract:
+  // last-write-wins on overflow; oldest items are discarded.
+  // See change: add-extension-ui-modal, design.md §5.
+  const UI_DATA_PER_EVENT_CAP = 1000;
+
   // Track sessions replaying history — suppress status broadcasts to avoid card flicker
   const replayingSessions = new Set<string>();
   // Sessions whose replay should be discarded (canSkipWipe was true — events already in store)
@@ -139,17 +174,30 @@ export function wireEvents(deps: EventWiringDeps): void {
             // (write/CLI). Reads are passive (browsing/analysis) and don't trigger attach.
             // Phase is optional — skills loaded via prompt templates don't emit a SKILL.md read event.
             const attachUpdates: Partial<DashboardSession> = {};
-            if (updatedSession?.openspecChange && !updatedSession.attachedProposal && detected.isActive) {
-              attachUpdates.attachedProposal = updatedSession.openspecChange;
-              if (!updatedSession.name?.trim()) {
-                attachUpdates.name = updatedSession.openspecChange;
-                piGateway.sendToSession(sessionId, {
-                  type: "rename_session",
-                  sessionId,
-                  name: updatedSession.openspecChange,
-                });
+            // Auto-detect parallel path — see change: fix-mobile-attach-proposal-display
+            // (design.md §"Auto-detect parallel path"). Mirrors the witness rule in
+            // session-meta-handler.ts: re-attach when the previous attachment was
+            // auto-tracked (name === attachedProposal) AND a different changeName
+            // is now detected. Inner rename guard reuses attachRenameTarget.
+            if (updatedSession?.openspecChange && detected.isActive) {
+              const attachmentWasAutoTracked =
+                !updatedSession.attachedProposal ||
+                isNameAutoSetFromAttachment(updatedSession);
+              const differentChangeDetected =
+                updatedSession.attachedProposal !== updatedSession.openspecChange;
+              if (attachmentWasAutoTracked && differentChangeDetected) {
+                attachUpdates.attachedProposal = updatedSession.openspecChange;
+                const newName = attachRenameTarget(updatedSession, updatedSession.openspecChange);
+                if (newName !== undefined) {
+                  attachUpdates.name = newName;
+                  piGateway.sendToSession(sessionId, {
+                    type: "rename_session",
+                    sessionId,
+                    name: newName,
+                  });
+                }
+                sessionManager.update(sessionId, attachUpdates);
               }
-              sessionManager.update(sessionId, attachUpdates);
             }
             if (!replayingSessions.has(sessionId)) {
               browserGateway.broadcastSessionUpdated(sessionId, {
@@ -523,6 +571,59 @@ export function wireEvents(deps: EventWiringDeps): void {
       browserGateway.sendToSubscribers(sessionId, msg as any);
     }
 
+    // ── Extension UI System (Phase 1): cache + broadcast ──
+    // See change: add-extension-ui-modal.
+    if (msg.type === "ui_modules_list") {
+      sessionManager.update(sessionId, { uiModules: msg.modules });
+      browserGateway.sendToSubscribers(sessionId, {
+        type: "ui_modules_list",
+        sessionId,
+        modules: msg.modules,
+      } as any);
+    }
+
+    if (msg.type === "ui_data_list") {
+      const session = sessionManager.get(sessionId);
+      const dataMap = { ...(session?.uiDataMap ?? {}) };
+      // Per-event item cap (default N = 1000). Last-write-wins on overflow.
+      const items = Array.isArray(msg.items) ? msg.items : [];
+      const capped = items.length > UI_DATA_PER_EVENT_CAP
+        ? items.slice(items.length - UI_DATA_PER_EVENT_CAP)
+        : items;
+      dataMap[msg.event] = capped;
+      sessionManager.update(sessionId, { uiDataMap: dataMap });
+      browserGateway.sendToSubscribers(sessionId, {
+        type: "ui_data_list",
+        sessionId,
+        event: msg.event,
+        items: capped,
+      } as any);
+    }
+
+    // ── Extension UI System (Phase 2): live decorator cache + broadcast ──
+    // See change: add-extension-ui-decorations.
+    if (msg.type === "ext_ui_decorator") {
+      const session = sessionManager.get(sessionId);
+      if (session) {
+        const descriptor = msg.descriptor;
+        if (descriptor && typeof descriptor.kind === "string" && typeof descriptor.namespace === "string" && typeof descriptor.id === "string") {
+          const key = `${descriptor.kind}:${descriptor.namespace}:${descriptor.id}`;
+          const next = { ...(session.uiDecorators ?? {}) };
+          if (msg.removed === true) delete next[key];
+          else next[key] = descriptor;
+          sessionManager.update(sessionId, { uiDecorators: next });
+        }
+      }
+      // Broadcast verbatim regardless of whether the session is known — mirrors
+      // the Phase-1 contract for `ui_modules_list` / `ui_data_list`.
+      browserGateway.sendToSubscribers(sessionId, {
+        type: "ext_ui_decorator",
+        sessionId,
+        descriptor: msg.descriptor,
+        ...(msg.removed === true ? { removed: true } : {}),
+      } as any);
+    }
+
     if (msg.type === "session_name_update") {
       const nameUpdates = { name: msg.name || undefined };
       sessionManager.update(sessionId, nameUpdates);

package/packages/server/src/installed-package-enricher.ts

@@ -0,0 +1,143 @@
+/**
+ * Enrich rows returned by `packageManagerWrapper.listInstalled()` with
+ * version, description, displayName, isRecommended, and isBundled fields.
+ *
+ * The raw rows from pi's `DefaultPackageManager.listConfiguredPackages()`
+ * carry only `{ source, scope, filtered, installedPath }`. The Settings
+ * Packages tab needs more to render a friendly identity and badges
+ * without a second fetch.
+ *
+ * Pure helpers (`extractBasenameFromSource`, `computeIsBundled`) are
+ * exported for unit tests; the I/O-bearing enricher (`enrichInstalled`)
+ * reads the on-disk `package.json` for each row.
+ *
+ * See change: consolidate-packages-settings-ui.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import {
+	RECOMMENDED_EXTENSIONS,
+	BUNDLED_EXTENSION_IDS,
+	type RecommendedExtension,
+} from "@blackbelt-technology/pi-dashboard-shared/recommended-extensions.js";
+import { sourcesMatch } from "@blackbelt-technology/pi-dashboard-shared/source-matching.js";
+import type { InstalledPackage } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+
+/** Raw row shape returned by pi's listConfiguredPackages(). */
+export interface RawInstalledRow {
+	source: string;
+	scope: "user" | "project";
+	filtered: boolean;
+	installedPath?: string;
+}
+
+/** Read package.json#version and #description from a directory.
+ * Swallows all errors and returns `{}` on any failure. Exported for tests. */
+export function readPackageJsonMeta(installedPath: string | undefined): {
+	version?: string;
+	description?: string;
+} {
+	if (!installedPath) return {};
+	try {
+		const pj = path.join(installedPath, "package.json");
+		if (!fs.existsSync(pj)) return {};
+		const raw = fs.readFileSync(pj, "utf-8");
+		const parsed = JSON.parse(raw);
+		const version = typeof parsed?.version === "string" ? parsed.version : undefined;
+		const description = typeof parsed?.description === "string" ? parsed.description : undefined;
+		return { version, description };
+	} catch {
+		return {};
+	}
+}
+
+/** Pull a friendly basename out of a raw source string when no
+ * RECOMMENDED_EXTENSIONS match is available. Pure. */
+export function extractBasenameFromSource(source: string): string {
+	// npm:<name>[@<ver>]
+	const npmMatch = source.match(/^npm:(@?[^@]+)(?:@.*)?$/);
+	if (npmMatch) return npmMatch[1];
+
+	// git: strip .git suffix and trailing slash, take last path segment
+	const gitMatch = source.match(/[/:]([^/:]+?)(?:\.git)?\/?$/);
+	if (gitMatch) return gitMatch[1];
+
+	// local file:// or path: take last path segment
+	const localMatch = source.match(/[/\\]([^/\\]+)\/?$/);
+	if (localMatch) return localMatch[1];
+
+	return source;
+}
+
+/** Find the recommended manifest entry whose source matches the row.
+ * Pure. */
+export function matchRecommendedEntry(
+	source: string,
+	manifest: readonly RecommendedExtension[] = RECOMMENDED_EXTENSIONS,
+): RecommendedExtension | undefined {
+	return manifest.find((entry) => sourcesMatch(entry.source, source));
+}
+
+/** Compute isBundled. Pure (takes injected resourcesPath + existsSync).
+ * Outside Electron (no resourcesPath), always false. */
+export function computeIsBundled(
+	id: string,
+	resourcesPath: string | undefined,
+	existsFn: (p: string) => boolean = fs.existsSync,
+	bundledIds: readonly string[] = BUNDLED_EXTENSION_IDS,
+): boolean {
+	if (!resourcesPath) return false;
+	if (!bundledIds.includes(id)) return false;
+	const dir = path.join(resourcesPath, "bundled-extensions", id);
+	return existsFn(dir);
+}
+
+/** Enrich a single raw row. Pure dependency injection for tests. */
+export function enrichInstalledRow(
+	row: RawInstalledRow,
+	opts: {
+		resourcesPath?: string;
+		manifest?: readonly RecommendedExtension[];
+		bundledIds?: readonly string[];
+		readMeta?: (p: string | undefined) => { version?: string; description?: string };
+		existsFn?: (p: string) => boolean;
+	} = {},
+): InstalledPackage {
+	const readMeta = opts.readMeta ?? readPackageJsonMeta;
+	const existsFn = opts.existsFn ?? fs.existsSync;
+	const manifest = opts.manifest ?? RECOMMENDED_EXTENSIONS;
+	const bundledIds = opts.bundledIds ?? BUNDLED_EXTENSION_IDS;
+
+	const meta = readMeta(row.installedPath);
+	const recommended = matchRecommendedEntry(row.source, manifest);
+
+	const displayName =
+		recommended?.displayName ?? extractBasenameFromSource(row.source);
+	const description = recommended?.fallbackDescription ?? meta.description;
+	const isRecommended = !!recommended;
+	const isBundled = recommended
+		? computeIsBundled(recommended.id, opts.resourcesPath, existsFn, bundledIds)
+		: false;
+
+	return {
+		source: row.source,
+		scope: row.scope,
+		filtered: row.filtered,
+		installedPath: row.installedPath,
+		version: meta.version,
+		description,
+		displayName,
+		isRecommended,
+		isBundled,
+	};
+}
+
+/** Enrich a list of raw rows. Reads the Electron resourcesPath at
+ * runtime (or undefined in CLI mode). */
+export function enrichInstalledRows(
+	rows: RawInstalledRow[],
+	resourcesPath: string | undefined = (process as { resourcesPath?: string })
+		.resourcesPath,
+): InstalledPackage[] {
+	return rows.map((row) => enrichInstalledRow(row, { resourcesPath }));
+}