gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

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

@@ -0,0 +1,303 @@
+/**
+ * Shared types, constants, and pattern databases for the bg-shell extension.
+ */
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export type ProcessStatus =
+	| "starting"
+	| "ready"
+	| "error"
+	| "exited"
+	| "crashed";
+
+export type ProcessType = "server" | "build" | "test" | "watcher" | "generic" | "shell";
+
+export interface ProcessEvent {
+	type:
+		| "started"
+		| "ready"
+		| "error_detected"
+		| "recovered"
+		| "exited"
+		| "crashed"
+		| "output"
+		| "port_open"
+		| "pattern_match"
+		| "port_timeout";
+	timestamp: number;
+	detail: string;
+	data?: Record<string, unknown>;
+}
+
+export interface OutputDigest {
+	status: ProcessStatus;
+	uptime: string;
+	errors: string[];
+	warnings: string[];
+	urls: string[];
+	ports: number[];
+	lastActivity: string;
+	outputLines: number;
+	changeSummary: string;
+}
+
+export interface OutputLine {
+	stream: "stdout" | "stderr";
+	line: string;
+	ts: number;
+}
+
+export interface BgProcess {
+	id: string;
+	label: string;
+	command: string;
+	cwd: string;
+	/** Session file that created this process (used for per-session cleanup) */
+	ownerSessionFile: string | null;
+	/** Whether this process should survive a new-session boundary */
+	persistAcrossSessions: boolean;
+	startedAt: number;
+	proc: import("node:child_process").ChildProcess;
+	/** Unified chronologically-interleaved output buffer */
+	output: OutputLine[];
+	exitCode: number | null;
+	signal: string | null;
+	alive: boolean;
+	/** Tracks how many lines in the unified output buffer the LLM has already seen */
+	lastReadIndex: number;
+	/** Process classification */
+	processType: ProcessType;
+	/** Current lifecycle status */
+	status: ProcessStatus;
+	/** Detected ports */
+	ports: number[];
+	/** Detected URLs */
+	urls: string[];
+	/** Accumulated errors since last read */
+	recentErrors: string[];
+	/** Accumulated warnings since last read */
+	recentWarnings: string[];
+	/** Lifecycle events log */
+	events: ProcessEvent[];
+	/** Ready pattern (regex string) */
+	readyPattern: string | null;
+	/** Ready port to probe */
+	readyPort: number | null;
+	/** Whether readiness was ever achieved */
+	wasReady: boolean;
+	/** Group membership */
+	group: string | null;
+	/** Last error count snapshot for diff detection */
+	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 */
+	startConfig: {
+		command: string;
+		cwd: string;
+		label: string;
+		processType: ProcessType;
+		ownerSessionFile: string | null;
+		persistAcrossSessions: boolean;
+		readyPattern: string | null;
+		readyPort: number | null;
+		group: string | null;
+	};
+}
+
+export interface BgProcessInfo {
+	id: string;
+	label: string;
+	command: string;
+	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
+	startedAt: number;
+	alive: boolean;
+	exitCode: number | null;
+	signal: string | null;
+	outputLines: number;
+	stdoutLines: number;
+	stderrLines: number;
+	status: ProcessStatus;
+	processType: ProcessType;
+	ports: number[];
+	urls: string[];
+	group: string | null;
+	restartCount: number;
+	uptime: string;
+	recentErrorCount: number;
+	recentWarningCount: number;
+	eventCount: number;
+}
+
+export interface StartOptions {
+	command: string;
+	cwd: string;
+	ownerSessionFile?: string | null;
+	persistAcrossSessions?: boolean;
+	label?: string;
+	type?: ProcessType;
+	readyPattern?: string;
+	readyPort?: number;
+	readyTimeout?: number;
+	group?: string;
+	env?: Record<string, string>;
+}
+
+export interface GetOutputOptions {
+	stream: "stdout" | "stderr" | "both";
+	tail?: number;
+	filter?: string;
+	incremental?: boolean;
+}
+
+export interface ProcessManifest {
+	id: string;
+	label: string;
+	command: string;
+	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
+	startedAt: number;
+	processType: ProcessType;
+	group: string | null;
+	readyPattern: string | null;
+	readyPort: number | null;
+	pid: number | undefined;
+}
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+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;
+
+// ── Pattern Databases ──────────────────────────────────────────────────────
+
+/** Patterns that indicate a process is ready/listening */
+export const READINESS_PATTERNS: RegExp[] = [
+	// Node/JS servers
+	/listening\s+on\s+(?:port\s+)?(\d+)/i,
+	/server\s+(?:is\s+)?(?:running|started|listening)\s+(?:at|on)\s+/i,
+	/ready\s+(?:in|on|at)\s+/i,
+	/started\s+(?:server\s+)?on\s+/i,
+	// Next.js / Vite / etc
+	/Local:\s*https?:\/\//i,
+	/➜\s+Local:\s*/i,
+	/compiled\s+(?:successfully|client\s+and\s+server)/i,
+	// Python
+	/running\s+on\s+https?:\/\//i,
+	/Uvicorn\s+running/i,
+	/Development\s+server\s+is\s+running/i,
+	// Generic
+	/press\s+ctrl[\-+]c\s+to\s+(?:quit|stop)/i,
+	/watching\s+for\s+(?:file\s+)?changes/i,
+	/build\s+(?:completed|succeeded|finished)/i,
+];
+
+/** Patterns that indicate errors */
+export const ERROR_PATTERNS: RegExp[] = [
+	/\berror\b[\s:[\](]/i,
+	/\bERROR\b/,
+	/\bfailed\b/i,
+	/\bFAILED\b/,
+	/\bfatal\b/i,
+	/\bFATAL\b/,
+	/\bexception\b/i,
+	/\bpanic\b/i,
+	/\bsegmentation\s+fault\b/i,
+	/\bsyntax\s*error\b/i,
+	/\btype\s*error\b/i,
+	/\breference\s*error\b/i,
+	/Cannot\s+find\s+module/i,
+	/Module\s+not\s+found/i,
+	/ENOENT/,
+	/EACCES/,
+	/EADDRINUSE/,
+	/TS\d{4,5}:/,     // TypeScript errors
+	/E\d{4,5}:/,      // Rust errors
+	/\[ERROR\]/,
+	/✖|✗|❌/,          // Common error symbols
+];
+
+/** Patterns that indicate warnings */
+export const WARNING_PATTERNS: RegExp[] = [
+	/\bwarning\b[\s:[\](]/i,
+	/\bWARN(?:ING)?\b/,
+	/\bdeprecated\b/i,
+	/\bDEPRECATED\b/,
+	/⚠️?/,
+	/\[WARN\]/,
+];
+
+/** Patterns to extract URLs */
+export const URL_PATTERN = /https?:\/\/[^\s"'<>)\]]+/gi;
+
+/** Patterns to extract port numbers from "listening" messages */
+export const PORT_PATTERN = /(?:port|listening\s+on|:)\s*(\d{2,5})\b/gi;
+
+/** Patterns indicating test results */
+export const TEST_RESULT_PATTERNS: RegExp[] = [
+	/(\d+)\s+(?:tests?\s+)?passed/i,
+	/(\d+)\s+(?:tests?\s+)?failed/i,
+	/Tests?:\s+(\d+)\s+passed/i,
+	/(\d+)\s+passing/i,
+	/(\d+)\s+failing/i,
+	/PASS|FAIL/,
+];
+
+/** Patterns indicating build completion */
+export const BUILD_COMPLETE_PATTERNS: RegExp[] = [
+	/build\s+(?:completed|succeeded|finished|done)/i,
+	/compiled\s+(?:successfully|with\s+\d+\s+(?:error|warning))/i,
+	/✓\s+Built/i,
+	/webpack\s+\d+\.\d+/i,
+	/bundle\s+(?:is\s+)?ready/i,
+];
+
+// ── Compiled union regexes (single-pass alternatives to .some(p => p.test(line))) ──
+// Built once at module load — eliminates per-line RegExp construction overhead.
+
+export const ERROR_PATTERN_UNION = new RegExp(
+	ERROR_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const WARNING_PATTERN_UNION = new RegExp(
+	WARNING_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const READINESS_PATTERN_UNION = new RegExp(
+	READINESS_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const BUILD_COMPLETE_PATTERN_UNION = new RegExp(
+	BUILD_COMPLETE_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const TEST_RESULT_PATTERN_UNION = new RegExp(
+	TEST_RESULT_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+/** PORT_PATTERN compiled once for reuse in analyzeLine (needs exec, so must be re-created per call with /g) */
+export const PORT_PATTERN_SOURCE = PORT_PATTERN.source;

package/dist/resources/extensions/bg-shell/utilities.ts

@@ -0,0 +1,57 @@
+/**
+ * Utility functions for the bg-shell extension.
+ */
+
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+
+// ── Windows VT Input Restoration ────────────────────────────────────────────
+// Child processes (esp. Git Bash / MSYS2) can strip the ENABLE_VIRTUAL_TERMINAL_INPUT
+// flag from the shared stdin console handle. Re-enable it after each child exits.
+
+let _vtHandles: { GetConsoleMode: Function; SetConsoleMode: Function; handle: unknown } | null = null;
+export function restoreWindowsVTInput(): void {
+	if (process.platform !== "win32") return;
+	try {
+		if (!_vtHandles) {
+			const cjsRequire = createRequire(import.meta.url);
+			const koffi = cjsRequire("koffi");
+			const k32 = koffi.load("kernel32.dll");
+			const GetStdHandle = k32.func("void* __stdcall GetStdHandle(int)");
+			const GetConsoleMode = k32.func("bool __stdcall GetConsoleMode(void*, _Out_ uint32_t*)");
+			const SetConsoleMode = k32.func("bool __stdcall SetConsoleMode(void*, uint32_t)");
+			const handle = GetStdHandle(-10);
+			_vtHandles = { GetConsoleMode, SetConsoleMode, handle };
+		}
+		const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+		const mode = new Uint32Array(1);
+		_vtHandles.GetConsoleMode(_vtHandles.handle, mode);
+		if (!(mode[0] & ENABLE_VIRTUAL_TERMINAL_INPUT)) {
+			_vtHandles.SetConsoleMode(_vtHandles.handle, mode[0] | ENABLE_VIRTUAL_TERMINAL_INPUT);
+		}
+	} catch { /* koffi not available on non-Windows */ }
+}
+
+// ── Time Formatting ────────────────────────────────────────────────────────
+
+import { formatDuration } from "../shared/mod.js";
+
+export const formatUptime = formatDuration;
+
+export function formatTimeAgo(timestamp: number): string {
+	return formatDuration(Date.now() - timestamp) + " ago";
+}
+
+
+export function resolveBgShellPersistenceCwd(
+	cachedCwd: string,
+	liveCwd = process.cwd(),
+	pathExists: (path: string) => boolean = existsSync,
+): string {
+	const cachedIsAutoWorktree = /(?:^|[\\/])\.gsd[\\/]worktrees[\\/]/.test(cachedCwd);
+	if (!cachedIsAutoWorktree) return cachedCwd;
+	if (cachedCwd === liveCwd && pathExists(cachedCwd)) return cachedCwd;
+	if (!pathExists(cachedCwd)) return liveCwd;
+	if (liveCwd !== cachedCwd) return liveCwd;
+	return cachedCwd;
+}

package/dist/resources/extensions/browser-tools/capture.ts

@@ -0,0 +1,199 @@
+/**
+ * browser-tools — page state capture
+ *
+ * Functions for capturing compact page state, screenshots, and summaries.
+ * Used by tool implementations for post-action feedback.
+ */
+
+import type { Frame, Page } from "playwright";
+import sharp from "sharp";
+import type { CompactPageState, CompactSelectorState } from "./state.js";
+import { formatCompactStateSummary } from "./utils.js";
+
+// Anthropic vision: 1568px is the recommended optimal width. Height is capped
+// generously at 8000px so tall full-page screenshots remain readable rather
+// than being squished into a square constraint.
+//
+// Override via environment variables:
+//   SCREENSHOT_MAX_WIDTH=0   → uncap width (use raw resolution)
+//   SCREENSHOT_MAX_HEIGHT=0  → uncap height
+//   SCREENSHOT_FORMAT=png    → lossless PNG for all viewport/fullpage screenshots
+//   SCREENSHOT_QUALITY=100   → max JPEG quality (1-100, default 80)
+const MAX_SCREENSHOT_WIDTH = parseScreenshotDimension(process.env.SCREENSHOT_MAX_WIDTH, 1568);
+const MAX_SCREENSHOT_HEIGHT = parseScreenshotDimension(process.env.SCREENSHOT_MAX_HEIGHT, 8000);
+
+/** Parse a dimension env var: positive int = that value, 0 = Infinity (uncapped), absent/invalid = default. */
+function parseScreenshotDimension(value: string | undefined, fallback: number): number {
+	if (value === undefined || value === "") return fallback;
+	const n = parseInt(value, 10);
+	if (isNaN(n) || n < 0) return fallback;
+	if (n === 0) return Infinity;
+	return n;
+}
+
+/** Return the user-configured screenshot format override, or null for default behavior. */
+export function getScreenshotFormatOverride(): "png" | "jpeg" | null {
+	const fmt = process.env.SCREENSHOT_FORMAT?.toLowerCase();
+	if (fmt === "png") return "png";
+	if (fmt === "jpeg" || fmt === "jpg") return "jpeg";
+	return null;
+}
+
+/** Return the user-configured default JPEG quality, or the provided fallback. */
+export function getScreenshotQualityDefault(fallback: number): number {
+	const q = process.env.SCREENSHOT_QUALITY;
+	if (q === undefined || q === "") return fallback;
+	const n = parseInt(q, 10);
+	if (isNaN(n) || n < 1 || n > 100) return fallback;
+	return n;
+}
+
+// ---------------------------------------------------------------------------
+// Compact page state capture
+// ---------------------------------------------------------------------------
+
+export async function captureCompactPageState(
+	p: Page,
+	options: { selectors?: string[]; includeBodyText?: boolean; target?: Page | Frame } = {},
+): Promise<CompactPageState> {
+	const selectors = Array.from(new Set((options.selectors ?? []).filter(Boolean)));
+	const target = options.target ?? p;
+	const domState = await target.evaluate(({ selectors, includeBodyText }) => {
+		const selectorStates: Record<string, {
+			exists: boolean;
+			visible: boolean;
+			value: string;
+			checked: boolean | null;
+			text: string;
+		}> = {};
+		for (const selector of selectors) {
+			let el: Element | null = null;
+			try {
+				el = document.querySelector(selector);
+			} catch {
+				el = null;
+			}
+			if (!el) {
+				selectorStates[selector] = {
+					exists: false,
+					visible: false,
+					value: "",
+					checked: null,
+					text: "",
+				};
+				continue;
+			}
+			const htmlEl = el as HTMLElement;
+			const style = window.getComputedStyle(htmlEl);
+			const rect = htmlEl.getBoundingClientRect();
+			const visible = style.display !== "none" && style.visibility !== "hidden" && rect.width > 0 && rect.height > 0;
+			const input = el as HTMLInputElement;
+			selectorStates[selector] = {
+				exists: true,
+				visible,
+				value:
+					el instanceof HTMLInputElement ||
+					el instanceof HTMLTextAreaElement ||
+					el instanceof HTMLSelectElement
+						? el.value
+						: htmlEl.getAttribute("value") || "",
+				checked: el instanceof HTMLInputElement && ["checkbox", "radio"].includes(input.type) ? input.checked : null,
+				text: (htmlEl.innerText || htmlEl.textContent || "").trim().replace(/\s+/g, " ").slice(0, 160),
+			};
+		}
+
+		const focused = document.activeElement as HTMLElement | null;
+		const focusedDesc = focused && focused !== document.body && focused !== document.documentElement
+			? `${focused.tagName.toLowerCase()}${focused.id ? '#' + focused.id : ''}${focused.getAttribute('aria-label') ? ' "' + focused.getAttribute('aria-label') + '"' : ''}`
+			: "";
+		const headings = Array.from(document.querySelectorAll('h1,h2,h3')).slice(0, 5).map((h) => (h.textContent || '').trim().replace(/\s+/g, ' ').slice(0, 80));
+		const dialog = document.querySelector('[role="dialog"]:not([hidden]),dialog[open]');
+		const dialogTitle = dialog?.querySelector('[role="heading"],[aria-label]')?.textContent?.trim().slice(0, 80) ?? "";
+		const bodyText = includeBodyText
+			? (document.body?.innerText || document.body?.textContent || "").trim().replace(/\s+/g, ' ').slice(0, 4000)
+			: "";
+		return {
+			url: window.location.href,
+			title: document.title,
+			focus: focusedDesc,
+			headings,
+			bodyText,
+			counts: {
+				landmarks: document.querySelectorAll('[role="main"],[role="banner"],[role="navigation"],[role="contentinfo"],[role="complementary"],[role="search"],[role="form"],[role="dialog"],[role="alert"],main,header,nav,footer,aside,section,form,dialog').length,
+				buttons: document.querySelectorAll('button,[role="button"]').length,
+				links: document.querySelectorAll('a[href]').length,
+				inputs: document.querySelectorAll('input,textarea,select').length,
+			},
+			dialog: {
+				count: document.querySelectorAll('[role="dialog"]:not([hidden]),dialog[open]').length,
+				title: dialogTitle,
+			},
+			selectorStates,
+		};
+	}, { selectors, includeBodyText: options.includeBodyText === true });
+	// URL and title always come from the Page, not the frame
+	return { ...domState, url: p.url(), title: await p.title() };
+}
+
+// ---------------------------------------------------------------------------
+// Post-action summary
+// ---------------------------------------------------------------------------
+
+/** Lightweight page summary after an action. Returns ~50-150 tokens instead of full tree. */
+export async function postActionSummary(p: Page, target?: Page | Frame): Promise<string> {
+	try {
+		const state = await captureCompactPageState(p, { target });
+		return formatCompactStateSummary(state);
+	} catch {
+		return "[summary unavailable]";
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Screenshot helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Constrain screenshot dimensions for the Anthropic vision API.
+ * Width is capped at 1568px (optimal) and height at 8000px, each
+ * independently, using `fit: "inside"` so aspect ratio is preserved.
+ * Small images are never upscaled.
+ *
+ * `page` parameter is retained for ToolDeps signature stability (D008)
+ * but is no longer used — all processing is server-side via sharp.
+ */
+export async function constrainScreenshot(
+	_page: Page,
+	buffer: Buffer,
+	mimeType: string,
+	quality: number,
+): Promise<Buffer> {
+	const meta = await sharp(buffer).metadata();
+	const width = meta.width;
+	const height = meta.height;
+
+	if (width === undefined || height === undefined) return buffer;
+	if (width <= MAX_SCREENSHOT_WIDTH && height <= MAX_SCREENSHOT_HEIGHT) return buffer;
+
+	const resizer = sharp(buffer).resize(MAX_SCREENSHOT_WIDTH, MAX_SCREENSHOT_HEIGHT, {
+		fit: "inside",
+		withoutEnlargement: true,
+	});
+
+	if (mimeType === "image/png") {
+		return Buffer.from(await resizer.png().toBuffer());
+	}
+	return Buffer.from(await resizer.jpeg({ quality }).toBuffer());
+}
+
+/** Capture a JPEG screenshot for error debugging. Returns base64 or null. */
+export async function captureErrorScreenshot(p: Page | null): Promise<{ data: string; mimeType: string } | null> {
+	if (!p) return null;
+	try {
+		let buf = await p.screenshot({ type: "jpeg", quality: 60, scale: "css" });
+		buf = await constrainScreenshot(p, buf, "image/jpeg", 60);
+		return { data: buf.toString("base64"), mimeType: "image/jpeg" };
+	} catch {
+		return null;
+	}
+}