gsd-pi 2.28.0 → 2.29.0-dev.7612840

package/dist/remote-questions-config.js

@@ -8,10 +8,15 @@
  * JS to uncompiled .ts fail at runtime (#592).
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { getGlobalGSDPreferencesPath } from "./resources/extensions/gsd/preferences.js";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+// Inlined from preferences.ts to avoid crossing the compiled/uncompiled
+// boundary — this file is compiled by tsc, but preferences.ts is loaded
+// via jiti at runtime. Importing it as .js fails because no .js exists
+// in dist/. See #592, #1110.
+const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
 export function saveRemoteQuestionsConfig(channel, channelId) {
-    const prefsPath = getGlobalGSDPreferencesPath();
+    const prefsPath = GLOBAL_PREFERENCES_PATH;
     const block = [
         "remote_questions:",
         `  channel: ${channel}`,

package/dist/resource-loader.d.ts

@@ -1,5 +1,5 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
-export declare function discoverExtensionEntryPaths(extensionsDir: string): string[];
+export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export declare function readManagedResourceVersion(agentDir: string): string | null;
 export declare function getNewerManagedResourceVersion(agentDir: string, currentVersion: string): string | null;
 /**
@@ -18,9 +18,4 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
 export declare function initResources(agentDir: string): void;
-/**
- * Constructs a DefaultResourceLoader that loads extensions from both
- * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
- * This allows users to use extensions from either location.
- */
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -1,9 +1,11 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
+import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
+import { discoverExtensionEntryPaths } from './extension-discovery.js';
 // Resolve resources directory — prefer dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree, changes with git branch).
 //
@@ -18,56 +20,7 @@ const srcResources = join(packageRoot, 'src', 'resources');
 const resourcesDir = existsSync(distResources) ? distResources : srcResources;
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 const resourceVersionManifestName = 'managed-resources.json';
-function isExtensionFile(name) {
-    return name.endsWith('.ts') || name.endsWith('.js');
-}
-function resolveExtensionEntries(dir) {
-    const packageJsonPath = join(dir, 'package.json');
-    if (existsSync(packageJsonPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const declared = pkg?.pi?.extensions;
-            if (Array.isArray(declared)) {
-                const resolved = declared
-                    .filter((entry) => typeof entry === 'string')
-                    .map((entry) => resolve(dir, entry))
-                    .filter((entry) => existsSync(entry));
-                if (resolved.length > 0) {
-                    return resolved;
-                }
-            }
-        }
-        catch {
-            // Ignore malformed manifests and fall back to index.ts/index.js discovery.
-        }
-    }
-    const indexTs = join(dir, 'index.ts');
-    if (existsSync(indexTs)) {
-        return [indexTs];
-    }
-    const indexJs = join(dir, 'index.js');
-    if (existsSync(indexJs)) {
-        return [indexJs];
-    }
-    return [];
-}
-export function discoverExtensionEntryPaths(extensionsDir) {
-    if (!existsSync(extensionsDir)) {
-        return [];
-    }
-    const discovered = [];
-    for (const entry of readdirSync(extensionsDir, { withFileTypes: true })) {
-        const entryPath = join(extensionsDir, entry.name);
-        if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-            discovered.push(entryPath);
-            continue;
-        }
-        if (entry.isDirectory() || entry.isSymbolicLink()) {
-            discovered.push(...resolveExtensionEntries(entryPath));
-        }
-    }
-    return discovered;
-}
+export { discoverExtensionEntryPaths } from './extension-discovery.js';
 function getExtensionKey(entryPath, extensionsDir) {
     const relPath = relative(extensionsDir, entryPath);
     return relPath.split(/[\\/]/)[0];
@@ -76,16 +29,24 @@ function getManagedResourceManifestPath(agentDir) {
     return join(agentDir, resourceVersionManifestName);
 }
 function getBundledGsdVersion() {
+    // Prefer GSD_VERSION env var (set once by loader.ts) to avoid re-reading package.json
+    if (process.env.GSD_VERSION && process.env.GSD_VERSION !== '0.0.0') {
+        return process.env.GSD_VERSION;
+    }
     try {
         const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf-8'));
         return typeof pkg?.version === 'string' ? pkg.version : '0.0.0';
     }
     catch {
-        return process.env.GSD_VERSION || '0.0.0';
+        return '0.0.0';
     }
 }
 function writeManagedResourceManifest(agentDir) {
-    const manifest = { gsdVersion: getBundledGsdVersion(), syncedAt: Date.now() };
+    const manifest = {
+        gsdVersion: getBundledGsdVersion(),
+        syncedAt: Date.now(),
+        contentHash: computeResourceFingerprint(),
+    };
     writeFileSync(getManagedResourceManifestPath(agentDir), JSON.stringify(manifest));
 }
 export function readManagedResourceVersion(agentDir) {
@@ -97,6 +58,44 @@ export function readManagedResourceVersion(agentDir) {
         return null;
     }
 }
+function readManagedResourceManifest(agentDir) {
+    try {
+        return JSON.parse(readFileSync(getManagedResourceManifestPath(agentDir), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Computes a lightweight content fingerprint of the bundled resources directory.
+ *
+ * Walks all files under resourcesDir and hashes their relative paths + sizes.
+ * This catches same-version content changes (npm link dev workflow, hotfixes
+ * within a release) without the cost of reading every file's contents.
+ *
+ * ~1ms for a typical resources tree (~100 files) — just stat calls, no reads.
+ */
+function computeResourceFingerprint() {
+    const entries = [];
+    collectFileEntries(resourcesDir, resourcesDir, entries);
+    entries.sort();
+    return createHash('sha256').update(entries.join('\n')).digest('hex').slice(0, 16);
+}
+function collectFileEntries(dir, root, out) {
+    if (!existsSync(dir))
+        return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectFileEntries(fullPath, root, out);
+        }
+        else {
+            const rel = relative(root, fullPath);
+            const size = statSync(fullPath).size;
+            out.push(`${rel}:${size}`);
+        }
+    }
+}
 export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     const managedVersion = readManagedResourceVersion(agentDir);
     if (!managedVersion) {
@@ -136,6 +135,53 @@ function makeTreeWritable(dirPath) {
         }
     }
 }
+/**
+ * Syncs a single bundled resource directory into the agent directory.
+ *
+ * 1. Makes the destination writable (handles Nix store read-only copies).
+ * 2. Removes destination subdirs that exist in source to clear stale files,
+ *    while preserving user-created directories.
+ * 3. Copies source into destination.
+ * 4. Makes the result writable for the next upgrade cycle.
+ */
+function syncResourceDir(srcDir, destDir) {
+    makeTreeWritable(destDir);
+    if (existsSync(srcDir)) {
+        for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destDir, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
+        try {
+            cpSync(srcDir, destDir, { recursive: true, force: true });
+        }
+        catch {
+            // Fallback for Windows paths with non-ASCII characters where cpSync
+            // fails with the \\?\ extended-length prefix (#1178).
+            copyDirRecursive(srcDir, destDir);
+        }
+        makeTreeWritable(destDir);
+    }
+}
+/**
+ * Recursive directory copy using copyFileSync — workaround for cpSync failures
+ * on Windows paths containing non-ASCII characters (#1178).
+ */
+function copyDirRecursive(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src, { withFileTypes: true })) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            copyFileSync(srcPath, destPath);
+        }
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -153,50 +199,24 @@ function makeTreeWritable(dirPath) {
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
-    // Sync extensions — clean bundled subdirs first to remove stale leftover files,
-    // then overwrite so updates land on next launch. Only bundled subdirs are removed;
-    // user-created extension directories are preserved.
-    const destExtensions = join(agentDir, 'extensions');
-    makeTreeWritable(destExtensions);
-    for (const entry of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-            const target = join(destExtensions, entry.name);
-            if (existsSync(target))
-                rmSync(target, { recursive: true, force: true });
-        }
-    }
-    cpSync(bundledExtensionsDir, destExtensions, { recursive: true, force: true });
-    makeTreeWritable(destExtensions);
-    // Sync agents
-    const destAgents = join(agentDir, 'agents');
-    const srcAgents = join(resourcesDir, 'agents');
-    if (existsSync(srcAgents)) {
-        makeTreeWritable(destAgents);
-        for (const entry of readdirSync(srcAgents, { withFileTypes: true })) {
-            if (entry.isDirectory()) {
-                const target = join(destAgents, entry.name);
-                if (existsSync(target))
-                    rmSync(target, { recursive: true, force: true });
-            }
-        }
-        cpSync(srcAgents, destAgents, { recursive: true, force: true });
-        makeTreeWritable(destAgents);
-    }
-    // Sync skills
-    const destSkills = join(agentDir, 'skills');
-    const srcSkills = join(resourcesDir, 'skills');
-    if (existsSync(srcSkills)) {
-        makeTreeWritable(destSkills);
-        for (const entry of readdirSync(srcSkills, { withFileTypes: true })) {
-            if (entry.isDirectory()) {
-                const target = join(destSkills, entry.name);
-                if (existsSync(target))
-                    rmSync(target, { recursive: true, force: true });
-            }
+    // Skip the full copy when both version AND content fingerprint match.
+    // Version-only checks miss same-version content changes (npm link dev workflow,
+    // hotfixes within a release). The content hash catches those at ~1ms cost.
+    const currentVersion = getBundledGsdVersion();
+    const manifest = readManagedResourceManifest(agentDir);
+    if (manifest && manifest.gsdVersion === currentVersion) {
+        // Version matches — check content fingerprint for same-version staleness.
+        const currentHash = computeResourceFingerprint();
+        if (manifest.contentHash && manifest.contentHash === currentHash) {
+            return;
         }
-        cpSync(srcSkills, destSkills, { recursive: true, force: true });
-        makeTreeWritable(destSkills);
     }
+    syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
+    syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
+    syncResourceDir(join(resourcesDir, 'skills'), join(agentDir, 'skills'));
+    // Ensure all newly copied files are owner-writable so the next run can
+    // overwrite them (covers extensions, agents, and skills in one walk).
+    makeTreeWritable(agentDir);
     writeManagedResourceManifest(agentDir);
 }
 /**
@@ -204,10 +224,19 @@ export function initResources(agentDir) {
  * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
  * This allows users to use extensions from either location.
  */
+// Cache bundled extension keys at module load — avoids re-scanning the extensions
+// directory in buildResourceLoader() (already scanned by loader.ts for env var).
+let _bundledExtensionKeys = null;
+function getBundledExtensionKeys() {
+    if (!_bundledExtensionKeys) {
+        _bundledExtensionKeys = new Set(discoverExtensionEntryPaths(bundledExtensionsDir).map((entryPath) => getExtensionKey(entryPath, bundledExtensionsDir)));
+    }
+    return _bundledExtensionKeys;
+}
 export function buildResourceLoader(agentDir) {
     const piAgentDir = join(homedir(), '.pi', 'agent');
     const piExtensionsDir = join(piAgentDir, 'extensions');
-    const bundledKeys = new Set(discoverExtensionEntryPaths(bundledExtensionsDir).map((entryPath) => getExtensionKey(entryPath, bundledExtensionsDir)));
+    const bundledKeys = getBundledExtensionKeys();
     const piExtensionPaths = discoverExtensionEntryPaths(piExtensionsDir).filter((entryPath) => !bundledKeys.has(getExtensionKey(entryPath, piExtensionsDir)));
     return new DefaultResourceLoader({
         agentDir,

package/dist/resources/extensions/ask-user-questions.ts

@@ -10,6 +10,7 @@
  */
 
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { sanitizeError } from "./shared/sanitize.js";
 import { Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import {
@@ -17,7 +18,7 @@ import {
 	type Question,
 	type QuestionOption,
 	type RoundResult,
-} from "./shared/interview-ui.js";
+} from "./shared/mod.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -80,7 +81,7 @@ function errorResult(
 	questions: Question[] = [],
 ): { content: { type: "text"; text: string }[]; details: AskUserQuestionsDetails } {
 	return {
-		content: [{ type: "text", text: message }],
+		content: [{ type: "text", text: sanitizeError(message) }],
 		details: { questions, response: null, cancelled: true },
 	};
 }

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

@@ -0,0 +1,219 @@
+/**
+ * /bg slash command registration — interactive process manager overlay and CLI subcommands.
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { Key } from "@gsd/pi-tui";
+import { shortcutDesc } from "../shared/terminal.js";
+
+import {
+	processes,
+	killProcess,
+	getGroupStatus,
+	cleanupAll,
+} from "./process-manager.js";
+import {
+	generateDigest,
+	getOutput,
+	formatDigestText,
+} from "./output-formatter.js";
+import { formatUptime } from "./utilities.js";
+import { BgManagerOverlay } from "./overlay.js";
+
+import type { BgShellSharedState } from "./index.js";
+
+export function registerBgShellCommand(pi: ExtensionAPI, state: BgShellSharedState): void {
+	pi.registerCommand("bg", {
+		description: "Manage background processes: /bg [list|output|kill|killall|groups] [id]",
+
+		getArgumentCompletions: (prefix: string) => {
+			const subcommands = ["list", "output", "kill", "killall", "groups", "digest"];
+			const parts = prefix.trim().split(/\s+/);
+
+			if (parts.length <= 1) {
+				return subcommands
+					.filter(cmd => cmd.startsWith(parts[0] ?? ""))
+					.map(cmd => ({ value: cmd, label: cmd }));
+			}
+
+			if (parts[0] === "output" || parts[0] === "kill" || parts[0] === "digest") {
+				const idPrefix = parts[1] ?? "";
+				return Array.from(processes.values())
+					.filter(p => p.id.startsWith(idPrefix))
+					.map(p => ({
+						value: `${parts[0]} ${p.id}`,
+						label: `${p.id} — ${p.label}`,
+					}));
+			}
+
+			return [];
+		},
+
+		handler: async (args, ctx) => {
+			const parts = args.trim().split(/\s+/);
+			const sub = parts[0] || "list";
+
+			if (sub === "list" || sub === "") {
+				if (processes.size === 0) {
+					ctx.ui.notify("No background processes.", "info");
+					return;
+				}
+
+				if (!ctx.hasUI) {
+					const lines = Array.from(processes.values()).map(p => {
+						const statusIcon = p.alive
+							? (p.status === "ready" ? "✓" : p.status === "error" ? "✗" : "⋯")
+							: "○";
+						const uptime = formatUptime(Date.now() - p.startedAt);
+						const portInfo = p.ports.length > 0 ? ` :${p.ports.join(",")}` : "";
+						return `${p.id}  ${statusIcon} ${p.status}  ${uptime}  ${p.label}  [${p.processType}]${portInfo}`;
+					});
+					ctx.ui.notify(lines.join("\n"), "info");
+					return;
+				}
+
+				await ctx.ui.custom<void>(
+					(tui, theme, _kb, done) => {
+						return new BgManagerOverlay(tui, theme, () => {
+							done();
+							state.refreshWidget();
+						});
+					},
+					{
+						overlay: true,
+						overlayOptions: {
+							width: "60%",
+							minWidth: 50,
+							maxHeight: "70%",
+							anchor: "center",
+						},
+					},
+				);
+				return;
+			}
+
+			if (sub === "output" || sub === "digest") {
+				const id = parts[1];
+				if (!id) {
+					ctx.ui.notify(`Usage: /bg ${sub} <id>`, "error");
+					return;
+				}
+				const bg = processes.get(id);
+				if (!bg) {
+					ctx.ui.notify(`No process with id '${id}'`, "error");
+					return;
+				}
+
+				if (!ctx.hasUI) {
+					if (sub === "digest") {
+						const digest = generateDigest(bg);
+						ctx.ui.notify(formatDigestText(bg, digest), "info");
+					} else {
+						const output = getOutput(bg, { stream: "both", tail: 50 });
+						ctx.ui.notify(output || "(no output)", "info");
+					}
+					return;
+				}
+
+				await ctx.ui.custom<void>(
+					(tui, theme, _kb, done) => {
+						const overlay = new BgManagerOverlay(tui, theme, () => {
+							done();
+							state.refreshWidget();
+						});
+						const procs = Array.from(processes.values());
+						const idx = procs.findIndex(p => p.id === id);
+						if (idx >= 0) overlay.selectAndView(idx);
+						return overlay;
+					},
+					{
+						overlay: true,
+						overlayOptions: {
+							width: "60%",
+							minWidth: 50,
+							maxHeight: "70%",
+							anchor: "center",
+						},
+					},
+				);
+				return;
+			}
+
+			if (sub === "kill") {
+				const id = parts[1];
+				if (!id) {
+					ctx.ui.notify("Usage: /bg kill <id>", "error");
+					return;
+				}
+				const bg = processes.get(id);
+				if (!bg) {
+					ctx.ui.notify(`No process with id '${id}'`, "error");
+					return;
+				}
+				killProcess(id, "SIGTERM");
+				await new Promise(r => setTimeout(r, 300));
+				if (bg.alive) {
+					killProcess(id, "SIGKILL");
+					await new Promise(r => setTimeout(r, 200));
+				}
+				if (!bg.alive) processes.delete(id);
+				ctx.ui.notify(`Killed process ${id} (${bg.label})`, "info");
+				return;
+			}
+
+			if (sub === "killall") {
+				const count = processes.size;
+				cleanupAll();
+				ctx.ui.notify(`Killed ${count} background process(es)`, "info");
+				return;
+			}
+
+			if (sub === "groups") {
+				const groups = new Set<string>();
+				for (const p of processes.values()) {
+					if (p.group) groups.add(p.group);
+				}
+				if (groups.size === 0) {
+					ctx.ui.notify("No process groups defined.", "info");
+					return;
+				}
+				const lines = Array.from(groups).map(g => {
+					const gs = getGroupStatus(g);
+					const icon = gs.healthy ? "✓" : "✗";
+					const procs = gs.processes.map(p => `${p.id}(${p.status})`).join(", ");
+					return `${icon} ${g}: ${procs}`;
+				});
+				ctx.ui.notify(lines.join("\n"), "info");
+				return;
+			}
+
+			ctx.ui.notify("Usage: /bg [list|output|digest|kill|killall|groups] [id]", "info");
+		},
+	});
+
+	// ── Ctrl+Alt+B shortcut ──────────────────────────────────────────────
+
+	pi.registerShortcut(Key.ctrlAlt("b"), {
+		description: shortcutDesc("Open background process manager", "/bg"),
+		handler: async (ctx) => {
+			state.latestCtx = ctx;
+			await ctx.ui.custom<void>(
+				(tui, theme, _kb, done) => {
+					return new BgManagerOverlay(tui, theme, () => {
+						done();
+						state.refreshWidget();
+					});
+				},
+				{
+					overlay: true,
+					overlayOptions: {
+						width: "60%",
+						minWidth: 50,
+						maxHeight: "70%",
+						anchor: "center",
+					},
+				},
+			);
+		},
+	});
+}