gsd-pi 2.35.0-dev.cd3b7ea → 2.36.0-dev.d612764

package/src/resources/extensions/bg-shell/output-formatter.ts

@@ -22,7 +22,6 @@ import {
 	READINESS_PATTERNS,
 	BUILD_COMPLETE_PATTERNS,
 	TEST_RESULT_PATTERNS,
-	LINE_DEDUP_MAX,
 } from "./types.js";
 import { addEvent, pushAlert } from "./process-manager.js";
 import { transitionToReady } from "./readiness-detector.js";
@@ -106,22 +105,6 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 	}
 
-	// Dedup tracking — evict oldest entry when map exceeds LINE_DEDUP_MAX (LRU via Map insertion order)
-	bg.totalRawLines++;
-	const lineHash = line.trim().slice(0, 100);
-	const existing = bg.lineDedup.get(lineHash);
-	if (existing !== undefined) {
-		// Re-insert to update insertion order (move to tail = most recent)
-		bg.lineDedup.delete(lineHash);
-		bg.lineDedup.set(lineHash, existing + 1);
-	} else {
-		if (bg.lineDedup.size >= LINE_DEDUP_MAX) {
-			// Evict oldest entry (Map iteration order = insertion order = LRU at head)
-			const oldest = bg.lineDedup.keys().next().value;
-			if (oldest !== undefined) bg.lineDedup.delete(oldest);
-		}
-		bg.lineDedup.set(lineHash, 1);
-	}
 }
 
 // ── Digest Generation ──────────────────────────────────────────────────────

package/src/resources/extensions/bg-shell/process-manager.ts

@@ -162,12 +162,8 @@ export function startProcess(opts: StartOptions): BgProcess {
 		group: opts.group || null,
 		lastErrorCount: 0,
 		lastWarningCount: 0,
-		commandHistory: [],
-		lineDedup: new Map(),
-		totalRawLines: 0,
 		stdoutLineCount: 0,
 		stderrLineCount: 0,
-		envKeys: Object.keys(opts.env || {}),
 		restartCount: 0,
 		startConfig: {
 			command,

package/src/resources/extensions/bg-shell/types.ts

@@ -21,9 +21,7 @@ export interface ProcessEvent {
 		| "recovered"
 		| "exited"
 		| "crashed"
-		| "output"
 		| "port_open"
-		| "pattern_match"
 		| "port_timeout";
 	timestamp: number;
 	detail: string;
@@ -92,18 +90,10 @@ export interface BgProcess {
 	lastErrorCount: number;
 	/** Last warning count snapshot for diff detection */
 	lastWarningCount: number;
-	/** Command history for shell-type sessions */
-	commandHistory: string[];
-	/** Dedup tracker: hash → count of repeated lines (capped at LINE_DEDUP_MAX entries) */
-	lineDedup: Map<string, number>;
-	/** Total raw lines (before dedup) for token savings calc */
-	totalRawLines: number;
 	/** Tracked stdout line count (incremented in addOutputLine, avoids O(n) filter) */
 	stdoutLineCount: number;
 	/** Tracked stderr line count (incremented in addOutputLine, avoids O(n) filter) */
 	stderrLineCount: number;
-	/** Env snapshot (keys only, no values for security) */
-	envKeys: string[];
 	/** Restart count */
 	restartCount: number;
 	/** Original start config for restart */
@@ -187,8 +177,6 @@ export interface ProcessManifest {
 export const MAX_BUFFER_LINES = 5000;
 export const MAX_EVENTS = 200;
 export const DEAD_PROCESS_TTL = 10 * 60 * 1000;
-/** Maximum unique entries in the per-process lineDedup Map before LRU eviction. */
-export const LINE_DEDUP_MAX = 500;
 export const PORT_PROBE_TIMEOUT = 500;
 export const READY_POLL_INTERVAL = 250;
 export const DEFAULT_READY_TIMEOUT = 30000;

package/src/resources/extensions/cmux/index.ts

@@ -0,0 +1,384 @@
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { promisify } from "node:util";
+import type { GSDPreferences } from "../gsd/preferences.js";
+import type { GSDState, Phase } from "../gsd/types.js";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_SOCKET_PATH = "/tmp/cmux.sock";
+const STATUS_KEY = "gsd";
+const lastSidebarSnapshots = new Map<string, string>();
+let cmuxPromptedThisSession = false;
+let cachedCliAvailability: boolean | null = null;
+
+export interface CmuxEnvironment {
+  available: boolean;
+  cliAvailable: boolean;
+  socketPath: string;
+  workspaceId?: string;
+  surfaceId?: string;
+}
+
+export interface ResolvedCmuxConfig extends CmuxEnvironment {
+  enabled: boolean;
+  notifications: boolean;
+  sidebar: boolean;
+  splits: boolean;
+  browser: boolean;
+}
+
+export interface CmuxSidebarProgress {
+  value: number;
+  label: string;
+}
+
+export type CmuxLogLevel = "info" | "progress" | "success" | "warning" | "error";
+
+export function detectCmuxEnvironment(
+  env: NodeJS.ProcessEnv = process.env,
+  socketExists: (path: string) => boolean = existsSync,
+  cliAvailable: () => boolean = isCmuxCliAvailable,
+): CmuxEnvironment {
+  const socketPath = env.CMUX_SOCKET_PATH ?? DEFAULT_SOCKET_PATH;
+  const workspaceId = env.CMUX_WORKSPACE_ID?.trim() || undefined;
+  const surfaceId = env.CMUX_SURFACE_ID?.trim() || undefined;
+  const available = Boolean(workspaceId && surfaceId && socketExists(socketPath));
+  return {
+    available,
+    cliAvailable: cliAvailable(),
+    socketPath,
+    workspaceId,
+    surfaceId,
+  };
+}
+
+export function resolveCmuxConfig(
+  preferences: GSDPreferences | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+  socketExists: (path: string) => boolean = existsSync,
+  cliAvailable: () => boolean = isCmuxCliAvailable,
+): ResolvedCmuxConfig {
+  const detected = detectCmuxEnvironment(env, socketExists, cliAvailable);
+  const cmux = preferences?.cmux ?? {};
+  const enabled = detected.available && cmux.enabled === true;
+  return {
+    ...detected,
+    enabled,
+    notifications: enabled && cmux.notifications !== false,
+    sidebar: enabled && cmux.sidebar !== false,
+    splits: enabled && cmux.splits === true,
+    browser: enabled && cmux.browser === true,
+  };
+}
+
+export function shouldPromptToEnableCmux(
+  preferences: GSDPreferences | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+  socketExists: (path: string) => boolean = existsSync,
+  cliAvailable: () => boolean = isCmuxCliAvailable,
+): boolean {
+  if (cmuxPromptedThisSession) return false;
+  const detected = detectCmuxEnvironment(env, socketExists, cliAvailable);
+  if (!detected.available) return false;
+  return preferences?.cmux?.enabled === undefined;
+}
+
+export function markCmuxPromptShown(): void {
+  cmuxPromptedThisSession = true;
+}
+
+export function resetCmuxPromptState(): void {
+  cmuxPromptedThisSession = false;
+}
+
+export function isCmuxCliAvailable(): boolean {
+  if (cachedCliAvailability !== null) return cachedCliAvailability;
+  try {
+    execFileSync("cmux", ["--help"], { stdio: "ignore", timeout: 1000 });
+    cachedCliAvailability = true;
+  } catch {
+    cachedCliAvailability = false;
+  }
+  return cachedCliAvailability;
+}
+
+export function supportsOsc777Notifications(env: NodeJS.ProcessEnv = process.env): boolean {
+  const termProgram = env.TERM_PROGRAM?.toLowerCase() ?? "";
+  return termProgram === "ghostty" || termProgram === "wezterm" || termProgram === "iterm.app";
+}
+
+export function emitOsc777Notification(title: string, body: string): void {
+  if (!supportsOsc777Notifications()) return;
+  const safeTitle = normalizeNotificationText(title).replace(/;/g, ",");
+  const safeBody = normalizeNotificationText(body).replace(/;/g, ",");
+  process.stdout.write(`\x1b]777;notify;${safeTitle};${safeBody}\x07`);
+}
+
+export function buildCmuxStatusLabel(state: GSDState): string {
+  const parts: string[] = [];
+  if (state.activeMilestone) parts.push(state.activeMilestone.id);
+  if (state.activeSlice) parts.push(state.activeSlice.id);
+  if (state.activeTask) {
+    const prev = parts.pop();
+    parts.push(prev ? `${prev}/${state.activeTask.id}` : state.activeTask.id);
+  }
+  if (parts.length === 0) return state.phase;
+  return `${parts.join(" ")} · ${state.phase}`;
+}
+
+export function buildCmuxProgress(state: GSDState): CmuxSidebarProgress | null {
+  const progress = state.progress;
+  if (!progress) return null;
+
+  const choose = (done: number, total: number, label: string): CmuxSidebarProgress | null => {
+    if (total <= 0) return null;
+    return { value: Math.max(0, Math.min(1, done / total)), label: `${done}/${total} ${label}` };
+  };
+
+  return choose(progress.tasks?.done ?? 0, progress.tasks?.total ?? 0, "tasks")
+    ?? choose(progress.slices?.done ?? 0, progress.slices?.total ?? 0, "slices")
+    ?? choose(progress.milestones.done, progress.milestones.total, "milestones");
+}
+
+function phaseVisuals(phase: Phase): { icon: string; color: string } {
+  switch (phase) {
+    case "blocked":
+      return { icon: "triangle-alert", color: "#ef4444" };
+    case "paused":
+      return { icon: "pause", color: "#f59e0b" };
+    case "complete":
+    case "completing-milestone":
+      return { icon: "check", color: "#22c55e" };
+    case "planning":
+    case "researching":
+    case "replanning-slice":
+      return { icon: "compass", color: "#3b82f6" };
+    case "validating-milestone":
+    case "verifying":
+      return { icon: "shield-check", color: "#06b6d4" };
+    default:
+      return { icon: "rocket", color: "#4ade80" };
+  }
+}
+
+function sidebarSnapshotKey(config: ResolvedCmuxConfig): string {
+  return config.workspaceId ?? "default";
+}
+
+export class CmuxClient {
+  private readonly config: ResolvedCmuxConfig;
+
+  constructor(config: ResolvedCmuxConfig) {
+    this.config = config;
+  }
+
+  static fromPreferences(preferences: GSDPreferences | undefined): CmuxClient {
+    return new CmuxClient(resolveCmuxConfig(preferences));
+  }
+
+  getConfig(): ResolvedCmuxConfig {
+    return this.config;
+  }
+
+  private canRun(): boolean {
+    return this.config.available && this.config.cliAvailable;
+  }
+
+  private appendWorkspace(args: string[]): string[] {
+    return this.config.workspaceId ? [...args, "--workspace", this.config.workspaceId] : args;
+  }
+
+  private appendSurface(args: string[], surfaceId?: string): string[] {
+    return surfaceId ? [...args, "--surface", surfaceId] : args;
+  }
+
+  private runSync(args: string[]): string | null {
+    if (!this.canRun()) return null;
+    try {
+      return execFileSync("cmux", args, {
+        encoding: "utf-8",
+        timeout: 3000,
+        env: process.env,
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  private async runAsync(args: string[]): Promise<string | null> {
+    if (!this.canRun()) return null;
+    try {
+      const result = await execFileAsync("cmux", args, {
+        encoding: "utf-8",
+        timeout: 5000,
+        env: process.env,
+      });
+      return result.stdout;
+    } catch {
+      return null;
+    }
+  }
+
+  getCapabilities(): unknown | null {
+    const stdout = this.runSync(["capabilities", "--json"]);
+    return stdout ? parseJson(stdout) : null;
+  }
+
+  identify(): unknown | null {
+    const stdout = this.runSync(["identify", "--json"]);
+    return stdout ? parseJson(stdout) : null;
+  }
+
+  setStatus(label: string, phase: Phase): void {
+    if (!this.config.sidebar) return;
+    const visuals = phaseVisuals(phase);
+    this.runSync(this.appendWorkspace([
+      "set-status",
+      STATUS_KEY,
+      label,
+      "--icon",
+      visuals.icon,
+      "--color",
+      visuals.color,
+    ]));
+  }
+
+  clearStatus(): void {
+    if (!this.config.sidebar) return;
+    this.runSync(this.appendWorkspace(["clear-status", STATUS_KEY]));
+  }
+
+  setProgress(progress: CmuxSidebarProgress | null): void {
+    if (!this.config.sidebar) return;
+    if (!progress) {
+      this.runSync(this.appendWorkspace(["clear-progress"]));
+      return;
+    }
+    this.runSync(this.appendWorkspace([
+      "set-progress",
+      progress.value.toFixed(3),
+      "--label",
+      progress.label,
+    ]));
+  }
+
+  log(message: string, level: CmuxLogLevel = "info", source = "gsd"): void {
+    if (!this.config.sidebar) return;
+    this.runSync(this.appendWorkspace([
+      "log",
+      "--level",
+      level,
+      "--source",
+      source,
+      "--",
+      message,
+    ]));
+  }
+
+  notify(title: string, body: string, subtitle?: string): boolean {
+    if (!this.config.notifications) return false;
+    const args = ["notify", "--title", title, "--body", body];
+    if (subtitle) args.push("--subtitle", subtitle);
+    return this.runSync(args) !== null;
+  }
+
+  async listSurfaceIds(): Promise<string[]> {
+    const stdout = await this.runAsync(this.appendWorkspace(["list-surfaces", "--json", "--id-format", "both"]));
+    const parsed = stdout ? parseJson(stdout) : null;
+    return extractSurfaceIds(parsed);
+  }
+
+  async createSplit(direction: "right" | "down" | "left" | "up"): Promise<string | null> {
+    if (!this.config.splits) return null;
+    const before = new Set(await this.listSurfaceIds());
+    const args = ["new-split", direction];
+    const scopedArgs = this.appendSurface(this.appendWorkspace(args), this.config.surfaceId);
+    await this.runAsync(scopedArgs);
+    const after = await this.listSurfaceIds();
+    for (const id of after) {
+      if (!before.has(id)) return id;
+    }
+    return null;
+  }
+
+  async sendSurface(surfaceId: string, text: string): Promise<boolean> {
+    const payload = text.endsWith("\n") ? text : `${text}\n`;
+    const stdout = await this.runAsync(["send-surface", "--surface", surfaceId, payload]);
+    return stdout !== null;
+  }
+}
+
+export function syncCmuxSidebar(preferences: GSDPreferences | undefined, state: GSDState): void {
+  const client = CmuxClient.fromPreferences(preferences);
+  const config = client.getConfig();
+  if (!config.sidebar) return;
+
+  const label = buildCmuxStatusLabel(state);
+  const progress = buildCmuxProgress(state);
+  const snapshot = JSON.stringify({ label, progress, phase: state.phase });
+  const key = sidebarSnapshotKey(config);
+  if (lastSidebarSnapshots.get(key) === snapshot) return;
+
+  client.setStatus(label, state.phase);
+  client.setProgress(progress);
+  lastSidebarSnapshots.set(key, snapshot);
+}
+
+export function clearCmuxSidebar(preferences: GSDPreferences | undefined): void {
+  const config = resolveCmuxConfig(preferences);
+  if (!config.available || !config.cliAvailable) return;
+  const client = new CmuxClient({ ...config, enabled: true, sidebar: true });
+  const key = sidebarSnapshotKey(config);
+  client.clearStatus();
+  client.setProgress(null);
+  lastSidebarSnapshots.delete(key);
+}
+
+export function logCmuxEvent(
+  preferences: GSDPreferences | undefined,
+  message: string,
+  level: CmuxLogLevel = "info",
+): void {
+  CmuxClient.fromPreferences(preferences).log(message, level);
+}
+
+export function shellEscape(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeNotificationText(value: string): string {
+  return value.replace(/\r?\n/g, " ").trim();
+}
+
+function parseJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function extractSurfaceIds(value: unknown): string[] {
+  const found = new Set<string>();
+
+  const visit = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+
+    for (const [key, child] of Object.entries(node as Record<string, unknown>)) {
+      if (
+        typeof child === "string"
+        && (key === "surface_id" || key === "surface" || (key === "id" && child.includes("surface")))
+      ) {
+        found.add(child);
+      }
+      visit(child);
+    }
+  };
+
+  visit(value);
+  return Array.from(found);
+}

package/src/resources/extensions/context7/index.ts

@@ -414,6 +414,13 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── Session cleanup ─────────────────────────────────────────────────────
+
+	pi.on("session_shutdown", async () => {
+		searchCache.clear();
+		docCache.clear();
+	});
+
 	// ── Startup notification ─────────────────────────────────────────────────
 
 	pi.on("session_start", async (_event, ctx) => {

package/src/resources/extensions/get-secrets-from-user.ts

@@ -11,9 +11,9 @@ import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
 import type { ExtensionAPI, Theme } from "@gsd/pi-coding-agent";
-import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { makeUI, type ProgressStatus } from "./shared/mod.js";
+import { makeUI, maskEditorLine, type ProgressStatus } from "./shared/mod.js";
 import { parseSecretsManifest, formatSecretsManifest } from "./gsd/files.js";
 import { resolveMilestoneFile } from "./gsd/paths.js";
 import type { SecretsManifestEntry } from "./gsd/types.js";
@@ -42,39 +42,6 @@ function maskPreview(value: string): string {
 	return `${value.slice(0, 4)}${"*".repeat(Math.max(4, value.length - 8))}${value.slice(-4)}`;
 }
 
-/**
- * Replace editor visible text with masked characters while preserving ANSI cursor/sequencer codes.
- */
-function maskEditorLine(line: string): string {
-	// Keep border / metadata lines readable.
-	if (line.startsWith("─")) {
-		return line;
-	}
-
-	let output = "";
-	let i = 0;
-	while (i < line.length) {
-		if (line.startsWith(CURSOR_MARKER, i)) {
-			output += CURSOR_MARKER;
-			i += CURSOR_MARKER.length;
-			continue;
-		}
-
-		const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
-		if (ansiMatch) {
-			output += ansiMatch[0];
-			i += ansiMatch[0].length;
-			continue;
-		}
-
-		const ch = line[i] as string;
-		output += ch === " " ? " " : "*";
-		i += 1;
-	}
-
-	return output;
-}
-
 function shellEscapeSingle(value: string): string {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }

package/src/resources/extensions/google-search/index.ts

@@ -411,6 +411,13 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── Session cleanup ─────────────────────────────────────────────────────
+
+	pi.on("session_shutdown", async () => {
+		resultCache.clear();
+		client = null;
+	});
+
 	// ── Startup notification ─────────────────────────────────────────────────
 
 	pi.on("session_start", async (_event, ctx) => {