gsd-pi 2.9.0 → 2.10.1

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

@@ -16,7 +16,7 @@
  * - Context injection: proactive alerts for crashes and state changes
  *
  * Tools:
- *   bg_shell — start, output, digest, wait_for_ready, send, send_and_wait,
+ *   bg_shell — start, output, digest, wait_for_ready, send, send_and_wait, run,
  *              signal, list, kill, restart, group_status
  *
  * Commands:
@@ -88,7 +88,7 @@ type ProcessStatus =
 	| "exited"
 	| "crashed";
 
-type ProcessType = "server" | "build" | "test" | "watcher" | "generic";
+type ProcessType = "server" | "build" | "test" | "watcher" | "generic" | "shell";
 
 interface ProcessEvent {
 	type:
@@ -164,6 +164,8 @@ 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 */
 	lineDedup: Map<string, number>;
 	/** Total raw lines (before dedup) for token savings calc */
@@ -583,7 +585,9 @@ function startProcess(opts: StartOptions): BgProcess {
 	const env = { ...process.env, ...(opts.env || {}) };
 
 	const { shell, args: shellArgs } = getShellConfig();
-	const proc = spawn(shell, [...shellArgs, sanitizeCommand(opts.command)], {
+	// Shell sessions default to the user's shell if no command specified
+	const command = processType === "shell" && !opts.command ? shell : opts.command;
+	const proc = spawn(shell, [...shellArgs, sanitizeCommand(command)], {
 		cwd: opts.cwd,
 		stdio: ["pipe", "pipe", "pipe"],
 		env,
@@ -592,8 +596,8 @@ function startProcess(opts: StartOptions): BgProcess {
 
 	const bg: BgProcess = {
 		id,
-		label: opts.label || opts.command.slice(0, 60),
-		command: opts.command,
+		label: opts.label || command.slice(0, 60),
+		command,
 		cwd: opts.cwd,
 		startedAt: Date.now(),
 		proc,
@@ -615,14 +619,15 @@ function startProcess(opts: StartOptions): BgProcess {
 		group: opts.group || null,
 		lastErrorCount: 0,
 		lastWarningCount: 0,
+		commandHistory: [],
 		lineDedup: new Map(),
 		totalRawLines: 0,
 		envKeys: Object.keys(opts.env || {}),
 		restartCount: 0,
 		startConfig: {
-			command: opts.command,
+			command,
 			cwd: opts.cwd,
-			label: opts.label || opts.command.slice(0, 60),
+			label: opts.label || command.slice(0, 60),
 			processType,
 			readyPattern: opts.readyPattern || null,
 			readyPort: opts.readyPort || null,
@@ -630,7 +635,7 @@ function startProcess(opts: StartOptions): BgProcess {
 		},
 	};
 
-	addEvent(bg, { type: "started", detail: `Process started: ${opts.command.slice(0, 100)}` });
+	addEvent(bg, { type: "started", detail: `Process started: ${command.slice(0, 100)}` });
 
 	proc.stdout?.on("data", (chunk: Buffer) => {
 		const lines = chunk.toString().split("\n");
@@ -687,6 +692,15 @@ function startProcess(opts: StartOptions): BgProcess {
 		startPortProbing(bg, bg.readyPort);
 	}
 
+	// Shell sessions are ready immediately after spawn
+	if (bg.processType === "shell") {
+		setTimeout(() => {
+			if (bg.alive && bg.status === "starting") {
+				transitionToReady(bg, "Shell session initialized");
+			}
+		}, 200);
+	}
+
 	processes.set(id, bg);
 	return bg;
 }
@@ -876,6 +890,73 @@ async function waitForReady(bg: BgProcess, timeout: number, signal?: AbortSignal
 	return { ready: false, detail: `Timed out after ${timeout}ms waiting for ready signal` };
 }
 
+// ── Query Shell Environment ────────────────────────────────────────────────
+
+async function queryShellEnv(
+	bg: BgProcess,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ cwd: string; env: Record<string, string>; shell: string } | null> {
+	const sentinel = `__GSD_ENV_${randomUUID().slice(0, 8)}__`;
+	const startIndex = bg.output.length;
+
+	const cmd = [
+		`echo "${sentinel}_START"`,
+		`echo "CWD=$(pwd)"`,
+		`echo "SHELL=$SHELL"`,
+		`echo "PATH=$PATH"`,
+		`echo "VIRTUAL_ENV=$VIRTUAL_ENV"`,
+		`echo "NODE_ENV=$NODE_ENV"`,
+		`echo "HOME=$HOME"`,
+		`echo "USER=$USER"`,
+		`echo "NVM_DIR=$NVM_DIR"`,
+		`echo "GOPATH=$GOPATH"`,
+		`echo "CARGO_HOME=$CARGO_HOME"`,
+		`echo "PYTHONPATH=$PYTHONPATH"`,
+		`echo "${sentinel}_END"`,
+	].join(" && ");
+
+	bg.proc.stdin?.write(cmd + "\n");
+
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (signal?.aborted) return null;
+		if (!bg.alive) return null;
+
+		const newEntries = bg.output.slice(startIndex);
+		const endIdx = newEntries.findIndex(e => e.line.includes(`${sentinel}_END`));
+		if (endIdx >= 0) {
+			const startIdx = newEntries.findIndex(e => e.line.includes(`${sentinel}_START`));
+			if (startIdx >= 0) {
+				const envLines = newEntries.slice(startIdx + 1, endIdx);
+				const env: Record<string, string> = {};
+				let cwd = "";
+				let shell = "";
+
+				for (const entry of envLines) {
+					const match = entry.line.match(/^([A-Z_]+)=(.*)$/);
+					if (match) {
+						const [, key, value] = match;
+						if (key === "CWD") {
+							cwd = value;
+						} else if (key === "SHELL") {
+							shell = value;
+						} else if (value) {
+							env[key] = value;
+						}
+					}
+				}
+
+				return { cwd, env, shell };
+			}
+		}
+
+		await new Promise(r => setTimeout(r, 100));
+	}
+
+	return null;
+}
+
 // ── Send and Wait ──────────────────────────────────────────────────────────
 
 async function sendAndWait(
@@ -915,6 +996,92 @@ async function sendAndWait(
 	return { matched: false, output: newEntries.map(e => e.line).join("\n") || "(no output)" };
 }
 
+// ── Run on Session ─────────────────────────────────────────────────────────
+
+async function runOnSession(
+	bg: BgProcess,
+	command: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ exitCode: number; output: string; timedOut: boolean }> {
+	const sentinel = randomUUID().slice(0, 8);
+	const startMarker = `__GSD_SENTINEL_${sentinel}_START__`;
+	const endMarker = `__GSD_SENTINEL_${sentinel}_END__`;
+	const exitVar = `__GSD_EXIT_${sentinel}__`;
+
+	// Snapshot current output buffer position
+	const startIndex = bg.output.length;
+
+	// Write the sentinel-wrapped command to stdin
+	const wrappedCommand = [
+		`echo ${startMarker}`,
+		command,
+		`${exitVar}=$?`,
+		`echo ${endMarker} $${exitVar}`,
+	].join("\n");
+	bg.proc.stdin?.write(wrappedCommand + "\n");
+
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (signal?.aborted) {
+			const newEntries = bg.output.slice(startIndex);
+			return { exitCode: -1, output: newEntries.map(e => e.line).join("\n") || "(cancelled)", timedOut: false };
+		}
+
+		// Process died while waiting
+		if (!bg.alive) {
+			const newEntries = bg.output.slice(startIndex);
+			const lines = newEntries.map(e => e.line);
+			return { exitCode: bg.proc.exitCode ?? -1, output: lines.join("\n") || "(process exited)", timedOut: false };
+		}
+
+		const newEntries = bg.output.slice(startIndex);
+		for (let i = 0; i < newEntries.length; i++) {
+			if (newEntries[i].line.includes(endMarker)) {
+				// Parse exit code from the END sentinel line
+				const endLine = newEntries[i].line;
+				const exitMatch = endLine.match(new RegExp(`${endMarker}\\s+(\\d+)`));
+				const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : -1;
+
+				// Extract output between START and END sentinels
+				const outputLines: string[] = [];
+				let capturing = false;
+				for (let j = 0; j < newEntries.length; j++) {
+					if (newEntries[j].line.includes(startMarker)) {
+						capturing = true;
+						continue;
+					}
+					if (newEntries[j].line.includes(endMarker)) {
+						break;
+					}
+					if (capturing) {
+						outputLines.push(newEntries[j].line);
+					}
+				}
+
+				return { exitCode, output: outputLines.join("\n"), timedOut: false };
+			}
+		}
+
+		await new Promise(r => setTimeout(r, 100));
+	}
+
+	// Timed out
+	const newEntries = bg.output.slice(startIndex);
+	const outputLines: string[] = [];
+	let capturing = false;
+	for (const entry of newEntries) {
+		if (entry.line.includes(startMarker)) {
+			capturing = true;
+			continue;
+		}
+		if (capturing) {
+			outputLines.push(entry.line);
+		}
+	}
+	return { exitCode: -1, output: outputLines.join("\n") || "(no output)", timedOut: true };
+}
+
 // ── Group Operations ───────────────────────────────────────────────────────
 
 function getGroupProcesses(group: string): BgProcess[] {
@@ -1011,8 +1178,11 @@ function formatTimeAgo(timestamp: number): string {
 function pruneDeadProcesses(): void {
 	const now = Date.now();
 	for (const [id, bg] of processes) {
-		if (!bg.alive && now - bg.startedAt > DEAD_PROCESS_TTL) {
-			processes.delete(id);
+		if (!bg.alive) {
+			const ttl = bg.processType === "shell" ? DEAD_PROCESS_TTL * 6 : DEAD_PROCESS_TTL;
+			if (now - bg.startedAt > ttl) {
+				processes.delete(id);
+			}
 		}
 	}
 }
@@ -1175,6 +1345,8 @@ export default function (pi: ExtensionAPI) {
 			"Actions: start (launch with auto-classification & readiness detection), digest (structured summary ~30 tokens vs ~2000 raw), " +
 			"output (raw lines with incremental delivery), wait_for_ready (block until process signals readiness), " +
 			"send (write stdin), send_and_wait (expect-style: send + wait for output pattern), " +
+			"run (execute a command on a persistent shell session, block until done, return output + exit code), " +
+			"env (query shell cwd and environment variables), " +
 			"signal (send OS signal), list (all processes with status), kill (terminate), restart (kill + relaunch), " +
 			"group_status (health of a process group), highlights (significant output lines only).",
 
@@ -1187,10 +1359,13 @@ export default function (pi: ExtensionAPI) {
 			"The 'output' action returns only new output since the last check (incremental). Repeated calls are cheap on context.",
 			"Set type:'server' and ready_port:3000 for dev servers so readiness detection is automatic.",
 			"Set group:'my-stack' on related processes to manage them together with 'group_status'.",
+			"Use 'run' to execute a command on a persistent shell session and block until it completes — returns structured output + exit code. Shell state (env vars, cwd, virtualenvs) persists across runs.",
 			"Use 'send_and_wait' for interactive CLIs: send input and wait for expected output pattern.",
+			"Use 'env' to check the current working directory and active environment variables of a shell session — useful after cd, source, or export commands.",
 			"Use 'restart' to kill and relaunch with the same config — preserves restart count.",
 			"Background processes are auto-classified (server/build/test/watcher) based on the command.",
 			"Process crashes and errors are automatically surfaced as alerts at the start of your next turn — you don't need to poll.",
+			"To create a persistent shell session: bg_shell start with type:'shell'. The session stays alive for interactive use with 'send', 'send_and_wait', or 'run'.",
 		],
 
 		parameters: Type.Object({
@@ -1202,6 +1377,8 @@ export default function (pi: ExtensionAPI) {
 				"wait_for_ready",
 				"send",
 				"send_and_wait",
+				"run",
+				"env",
 				"signal",
 				"list",
 				"kill",
@@ -1209,13 +1386,13 @@ export default function (pi: ExtensionAPI) {
 				"group_status",
 			] as const),
 			command: Type.Optional(
-				Type.String({ description: "Shell command to run (for start)" }),
+				Type.String({ description: "Shell command to run (for start, run)" }),
 			),
 			label: Type.Optional(
 				Type.String({ description: "Short human-readable label for the process (for start)" }),
 			),
 			id: Type.Optional(
-				Type.String({ description: "Process ID (for digest, output, highlights, wait_for_ready, send, send_and_wait, signal, kill, restart)" }),
+				Type.String({ description: "Process ID (for digest, output, highlights, wait_for_ready, send, send_and_wait, run, signal, kill, restart)" }),
 			),
 			stream: Type.Optional(
 				StringEnum(["stdout", "stderr", "both"] as const),
@@ -1236,10 +1413,10 @@ export default function (pi: ExtensionAPI) {
 				Type.String({ description: "OS signal to send, e.g. SIGINT, SIGTERM, SIGHUP (for signal)" }),
 			),
 			timeout: Type.Optional(
-				Type.Number({ description: "Timeout in milliseconds (for wait_for_ready, send_and_wait). Default: 30000" }),
+				Type.Number({ description: "Timeout in milliseconds (for wait_for_ready, send_and_wait, run). Default: 30000 for wait_for_ready/send_and_wait, 120000 for run" }),
 			),
 			type: Type.Optional(
-				StringEnum(["server", "build", "test", "watcher", "generic"] as const),
+				StringEnum(["server", "build", "test", "watcher", "generic", "shell"] as const),
 			),
 			ready_pattern: Type.Optional(
 				Type.String({ description: "Regex pattern that indicates the process is ready (for start)" }),
@@ -1563,6 +1740,105 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
+				// ── run ────────────────────────────────────────────
+				case "run": {
+					if (!params.id) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'id' is required for run" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+					if (!params.command) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'command' is required for run" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const bg = processes.get(params.id);
+					if (!bg) {
+						return {
+							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					if (!bg.alive) {
+						return {
+							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const runTimeout = params.timeout || 120000;
+					const result = await runOnSession(bg, params.command, runTimeout, signal ?? undefined);
+
+					let text: string;
+					if (result.timedOut) {
+						text = `Command timed out after ${runTimeout}ms\nOutput:\n${result.output}`;
+					} else {
+						text = `Exit code: ${result.exitCode}\n${result.output}`;
+					}
+
+					return {
+						content: [{ type: "text" as const, text }],
+						details: { action: "run", process: getInfo(bg), exitCode: result.exitCode, timedOut: result.timedOut },
+					};
+				}
+
+				// ── env ───────────────────────────────────────────
+				case "env": {
+					if (!params.id) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'id' is required for env" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const bg = processes.get(params.id);
+					if (!bg) {
+						return {
+							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					if (!bg.alive) {
+						return {
+							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const timeout = params.timeout || 5000;
+					const envResult = await queryShellEnv(bg, timeout, signal ?? undefined);
+
+					if (!envResult) {
+						return {
+							content: [{ type: "text" as const, text: `Failed to query environment for process ${bg.id} (timed out or process died)` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					let text = `Shell environment for ${bg.id} (${bg.label}):\n`;
+					text += `  cwd: ${envResult.cwd}\n`;
+					text += `  shell: ${envResult.shell}\n`;
+
+					const envEntries = Object.entries(envResult.env);
+					if (envEntries.length > 0) {
+						text += `  environment:\n`;
+						for (const [key, value] of envEntries) {
+							const displayValue = value.length > 100 ? value.slice(0, 97) + "..." : value;
+							text += `    ${key}=${displayValue}\n`;
+						}
+					}
+
+					return {
+						content: [{ type: "text" as const, text: text.trimEnd() }],
+						details: { action: "env", process: getInfo(bg), env: envResult },
+					};
+				}
+
 				// ── signal ─────────────────────────────────────────
 				case "signal": {
 					if (!params.id) {
@@ -1883,6 +2159,40 @@ export default function (pi: ExtensionAPI) {
 					);
 				}
 
+				case "run": {
+					const proc = details.process as BgProcessInfo;
+					const exitCode = details.exitCode as number;
+					const timedOut = details.timedOut as boolean;
+					if (timedOut) {
+						let text = theme.fg("warning", "⏱ Timed out ") + theme.fg("accent", proc.id);
+						if (expanded) {
+							const rawText = result.content[0];
+							if (rawText?.type === "text") {
+								const lines = rawText.text.split("\n").slice(1);
+								for (const line of lines.slice(0, 30)) {
+									text += "\n  " + theme.fg("toolOutput", line);
+								}
+							}
+						}
+						return new Text(text, 0, 0);
+					}
+					const icon = exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
+					let text = `${icon} ${theme.fg("accent", proc.id)} ${theme.fg("dim", `exit:${exitCode}`)}`;
+					if (expanded) {
+						const rawText = result.content[0];
+						if (rawText?.type === "text") {
+							const lines = rawText.text.split("\n").slice(1);
+							for (const line of lines.slice(0, 30)) {
+								text += "\n  " + theme.fg("toolOutput", line);
+							}
+							if (lines.length > 30) {
+								text += `\n  ${theme.fg("dim", `... ${lines.length - 30} more lines`)}`;
+							}
+						}
+					}
+					return new Text(text, 0, 0);
+				}
+
 				case "signal": {
 					const sig = details.signal as string;
 					const proc = details.process as BgProcessInfo;
@@ -1926,6 +2236,25 @@ export default function (pi: ExtensionAPI) {
 					);
 				}
 
+				case "env": {
+					const proc = details.process as BgProcessInfo;
+					const envData = details.env as { cwd: string; shell: string } | undefined;
+					let text = theme.fg("accent", proc.id) + " " + theme.fg("muted", proc.label);
+					if (envData) {
+						text += " " + theme.fg("dim", `cwd: ${envData.cwd}`);
+					}
+					if (expanded) {
+						const rawText = result.content[0];
+						if (rawText?.type === "text") {
+							const lines = rawText.text.split("\n").slice(1);
+							for (const line of lines.slice(0, 15)) {
+								text += "\n  " + theme.fg("dim", line);
+							}
+						}
+					}
+					return new Text(text, 0, 0);
+				}
+
 				case "group_status": {
 					const gs = details.groupStatus as ReturnType<typeof getGroupStatus> | undefined;
 					if (gs) {

package/src/resources/extensions/gsd/git-service.ts

@@ -649,6 +649,18 @@ export class GitServiceImpl {
       this.git(["commit", "-m", "chore: untrack .gsd/ runtime files before merge"], { allowFailure: true });
     }
 
+    // Also untrack runtime files from the slice branch to prevent
+    // modify/delete conflicts during squash-merge (#218)
+    this.git(["checkout", branch]);
+    for (const exclusion of RUNTIME_EXCLUSION_PATHS) {
+      this.git(["rm", "--cached", "-r", "--ignore-unmatch", exclusion], { allowFailure: true });
+    }
+    const branchUntrackDiff = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
+    if (branchUntrackDiff?.trim()) {
+      this.git(["commit", "-m", "chore: untrack .gsd/ runtime files before merge"], { allowFailure: true });
+    }
+    this.git(["checkout", mainBranch]);
+
     // Merge slice branch — strategy is configurable via git.merge_strategy
     // preference. Default: "squash" (preserves existing behavior).
     // "merge" uses --no-ff which is more resilient to conflicts from
@@ -671,7 +683,7 @@ export class GitServiceImpl {
         if (allRuntime) {
           // Runtime-only conflicts: take ours and remove from index
           for (const f of conflictedFiles) {
-            this.git(["checkout", "--ours", "--", f], { allowFailure: true });
+            this.git(["checkout", "--theirs", "--", f], { allowFailure: true });
             this.git(["rm", "--cached", "--ignore-unmatch", f], { allowFailure: true });
           }
           this.git(["add", "-A"], { allowFailure: true });

package/src/resources/extensions/universal-config/discovery.ts

@@ -0,0 +1,78 @@
+/**
+ * Universal Config Discovery — main discovery orchestrator
+ *
+ * Runs all tool scanners in parallel and aggregates results into a
+ * unified DiscoveryResult.
+ */
+
+import { homedir } from "node:os";
+import { TOOLS } from "./tools.js";
+import { SCANNERS } from "./scanners.js";
+import type { DiscoveryResult, DiscoveredItem, ToolDiscoveryResult } from "./types.js";
+
+/**
+ * Run universal config discovery across all supported AI coding tools.
+ *
+ * @param projectRoot - Absolute path to the project root (cwd)
+ * @param home - Home directory override (defaults to os.homedir())
+ * @returns Aggregated discovery result
+ */
+export async function discoverAllConfigs(
+  projectRoot: string,
+  home: string = homedir(),
+): Promise<DiscoveryResult> {
+  const start = Date.now();
+  const allWarnings: string[] = [];
+  const toolResults: ToolDiscoveryResult[] = [];
+
+  // Run all scanners in parallel
+  const results = await Promise.allSettled(
+    TOOLS.map(async (tool) => {
+      const scanner = SCANNERS[tool.id];
+      if (!scanner) return { tool, items: [] as DiscoveredItem[], warnings: [`No scanner for ${tool.id}`] };
+      try {
+        const { items, warnings } = await scanner(projectRoot, home, tool);
+        return { tool, items, warnings };
+      } catch (err) {
+        return {
+          tool,
+          items: [] as DiscoveredItem[],
+          warnings: [`Scanner error for ${tool.name}: ${err instanceof Error ? err.message : String(err)}`],
+        };
+      }
+    }),
+  );
+
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      toolResults.push(result.value);
+      allWarnings.push(...result.value.warnings);
+    } else {
+      allWarnings.push(`Scanner failed: ${result.reason}`);
+    }
+  }
+
+  const allItems = toolResults.flatMap((r) => r.items);
+
+  const mcpServers = allItems.filter((i) => i.type === "mcp-server").length;
+  const rules = allItems.filter((i) => i.type === "rule").length;
+  const contextFiles = allItems.filter((i) => i.type === "context-file").length;
+  const settings = allItems.filter((i) => i.type === "settings").length;
+  const toolsWithConfig = toolResults.filter((r) => r.items.length > 0).length;
+
+  return {
+    tools: toolResults,
+    allItems,
+    summary: {
+      mcpServers,
+      rules,
+      contextFiles,
+      settings,
+      totalItems: allItems.length,
+      toolsScanned: TOOLS.length,
+      toolsWithConfig,
+    },
+    warnings: allWarnings,
+    durationMs: Date.now() - start,
+  };
+}