@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

package/src/resources/extensions/shared/gsd-browser-cli.ts

@@ -55,6 +55,32 @@ function parseGsdBrowserVersion(output: string): string | null {
   return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
 }
 
+function splitCommandLine(commandLine: string): string[] {
+  const parts = commandLine.match(/(?:"[^"]*"|'[^']*'|[^\s"']+)/g) ?? [];
+  return parts.map((part) => {
+    const quote = part[0];
+    if ((quote === '"' || quote === "'") && part.endsWith(quote)) {
+      return part.slice(1, -1);
+    }
+    return part;
+  });
+}
+
+function buildPathGsdBrowserVersionInvocation(platform: NodeJS.Platform): { command: string; args: string[] } {
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/d", "/s", "/c", "gsd-browser", "--version"] };
+  }
+  return { command: "gsd-browser", args: ["--version"] };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function resolveExplicitGsdBrowserCliPath(env: NodeJS.ProcessEnv): string | undefined {
+  return env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim() || undefined;
+}
+
 function resolveBundledGsdBrowserPackageVersion(): string | null {
   try {
     const requireFromHere = createRequire(import.meta.url);
@@ -66,20 +92,29 @@ function resolveBundledGsdBrowserPackageVersion(): string | null {
   }
 }
 
+// The `gsd-browser --version` subprocess result cannot change mid-session (the
+// engine-switch guard forbids restarting with a different engine), and both the
+// availability probe and the launch-config resolution ask for it at session
+// start — memoize so the up-to-2s spawn happens once per process.
+let cachedPathProbeVersion: string | null | undefined;
+
 function resolvePathGsdBrowserVersion(env: NodeJS.ProcessEnv): string | null {
   const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
   if (explicit) return parseGsdBrowserVersion(explicit);
+  if (cachedPathProbeVersion !== undefined) return cachedPathProbeVersion;
 
   try {
-    return parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+    const invocation = buildPathGsdBrowserVersionInvocation(process.platform);
+    cachedPathProbeVersion = parseGsdBrowserVersion(execFileSync(invocation.command, invocation.args, {
       encoding: "utf-8",
       env,
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 2000,
     }));
   } catch {
-    return null;
+    cachedPathProbeVersion = null;
   }
+  return cachedPathProbeVersion;
 }
 
 function shouldPreferPathGsdBrowser(env: NodeJS.ProcessEnv): boolean {
@@ -91,7 +126,7 @@ function shouldPreferPathGsdBrowser(env: NodeJS.ProcessEnv): boolean {
 }
 
 export function resolveBundledGsdBrowserCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
-  const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+  const explicit = resolveExplicitGsdBrowserCliPath(env);
   if (explicit) return explicit;
 
   try {
@@ -115,6 +150,45 @@ export function resolveBundledGsdBrowserCliPath(env: NodeJS.ProcessEnv = process
   return null;
 }
 
+export type GsdBrowserCliAvailability =
+  | { available: true; via: "explicit-env" | "bundled" | "path"; detail: string }
+  | { available: false; detail: string };
+
+/**
+ * Cheap availability probe for the gsd-browser CLI: explicit env overrides,
+ * then the bundled @opengsd/gsd-browser binary (filesystem checks only), then
+ * a PATH lookup (one short subprocess, memoized). Used by Browser Automation
+ * Engine resolution to decide whether the managed engine is provable before
+ * preferring it over legacy Playwright. `via` names the provable source, not
+ * necessarily the launch source — resolveGsdBrowserMcpLaunchConfig may still
+ * prefer a newer PATH CLI over the bundled one.
+ */
+export function resolveGsdBrowserCliAvailability(env: NodeJS.ProcessEnv = process.env): GsdBrowserCliAvailability {
+  const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+  if (explicitCommand) {
+    return { available: true, via: "explicit-env", detail: `GSD_BROWSER_MCP_COMMAND=${explicitCommand}` };
+  }
+
+  const explicitCliPath = resolveExplicitGsdBrowserCliPath(env);
+  if (explicitCliPath) {
+    return existsSync(explicitCliPath)
+      ? { available: true, via: "explicit-env", detail: `CLI at ${explicitCliPath}` }
+      : { available: false, detail: `configured gsd-browser CLI path does not exist: ${explicitCliPath}` };
+  }
+
+  const bundledCliPath = resolveBundledGsdBrowserCliPath(env);
+  if (bundledCliPath) {
+    return { available: true, via: "bundled", detail: `bundled CLI at ${bundledCliPath}` };
+  }
+
+  const pathVersion = resolvePathGsdBrowserVersion(env);
+  if (pathVersion) {
+    return { available: true, via: "path", detail: `gsd-browser ${pathVersion} on PATH` };
+  }
+
+  return { available: false, detail: "no bundled or PATH gsd-browser CLI found" };
+}
+
 export function buildGsdBrowserSessionName(projectRoot: string, suffix?: string): string {
   const resolvedProjectRoot = resolve(projectRoot);
   const base = sanitizeSessionSegment(basename(resolvedProjectRoot)) || "project";
@@ -123,6 +197,35 @@ export function buildGsdBrowserSessionName(projectRoot: string, suffix?: string)
   return cleanSuffix ? `gsd-${base}-${hash}-${cleanSuffix}` : `gsd-${base}-${hash}`;
 }
 
+/**
+ * Recognize an MCP server config (from .mcp.json / Claude settings) as a
+ * gsd-browser server. Paired with resolveGsdBrowserMcpLaunchConfig: this module
+ * writes the config shape, so it also owns recognizing it. New launch shapes
+ * are taught here, in one place.
+ */
+export function isGsdBrowserMcpServerConfig(config: unknown): boolean {
+  if (!isRecord(config)) return false;
+
+  const command = typeof config.command === "string" ? config.command : "";
+  if (command.includes("gsd-browser") || command.includes("@opengsd/gsd-browser")) {
+    return true;
+  }
+
+  if (isRecord(config.env)) {
+    const env = config.env;
+    if (
+      typeof env.GSD_BROWSER_CLI_PATH === "string"
+      || typeof env.GSD_BROWSER_BIN_PATH === "string"
+      || typeof env.GSD_BROWSER_MCP_COMMAND === "string"
+    ) {
+      return true;
+    }
+  }
+
+  const args = Array.isArray(config.args) ? config.args.filter((arg): arg is string => typeof arg === "string") : [];
+  return args.some((arg) => arg.includes("gsd-browser") || arg.includes("@opengsd/gsd-browser"));
+}
+
 export function resolveGsdBrowserMcpLaunchConfig(
   projectRoot: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -132,8 +235,9 @@ export function resolveGsdBrowserMcpLaunchConfig(
   const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
   const explicitArgs = parseJsonEnv<unknown>(env, "GSD_BROWSER_MCP_ARGS");
   const explicitEnv = parseJsonEnv<Record<string, string>>(env, "GSD_BROWSER_MCP_ENV");
-  const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
-  const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+  const explicitCommandLine = env.GSD_BROWSER_MCP_COMMAND?.trim();
+  const [explicitCommand, ...explicitCommandArgs] = explicitCommandLine ? splitCommandLine(explicitCommandLine) : [];
+  const explicitCliPath = resolveExplicitGsdBrowserCliPath(env);
   const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
   const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
     ? resolveBundledGsdBrowserCliPath(env)
@@ -144,6 +248,10 @@ export function resolveGsdBrowserMcpLaunchConfig(
   // profile/cookies persist across pi sessions for the same project. gsd-browser
   // rejects --identity-scope unless --identity-key is also supplied.
   const identityKey = env.GSD_BROWSER_IDENTITY_KEY?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
+  // identity-project must be a safe identifier (no path separators); full paths
+  // cause daemon startup to fail with "invalid name".
+  const identityProject =
+    env.GSD_BROWSER_IDENTITY_PROJECT?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
   const command =
     explicitCommand
     || explicitCliPath
@@ -153,6 +261,7 @@ export function resolveGsdBrowserMcpLaunchConfig(
   const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
     ? explicitArgs.map(String)
     : [
+        ...explicitCommandArgs,
         ...(bundledCliPath ? [bundledCliPath] : []),
         "mcp",
         "--session",
@@ -162,7 +271,7 @@ export function resolveGsdBrowserMcpLaunchConfig(
         "--identity-key",
         identityKey,
         "--identity-project",
-        resolvedProjectRoot,
+        identityProject,
       ];
   const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
 
@@ -176,3 +285,29 @@ export function resolveGsdBrowserMcpLaunchConfig(
     sessionName,
   };
 }
+
+/**
+ * CLI invocation that starts the gsd-browser session daemon with the same
+ * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
+ * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ */
+export function resolveGsdBrowserDaemonStartInvocation(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+  options: GsdBrowserMcpLaunchOptions = {},
+): Pick<GsdBrowserMcpLaunchConfig, "command" | "args" | "cwd" | "env"> {
+  const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env, options);
+  const mcpIndex = launch.args.indexOf("mcp");
+  if (mcpIndex < 0) {
+    throw new Error("gsd-browser launch config is missing mcp subcommand");
+  }
+
+  const prefix = launch.args.slice(0, mcpIndex);
+  const sessionFlags = launch.args.slice(mcpIndex + 1);
+  return {
+    command: launch.command,
+    args: [...prefix, "daemon", "start", ...sessionFlags],
+    cwd: launch.cwd,
+    ...(launch.env ? { env: launch.env } : {}),
+  };
+}

package/src/resources/extensions/shared/interview-ui.ts

@@ -62,6 +62,13 @@ export interface RoundResult {
 	/** Always false — end is handled by showWrapUpScreen, not per-question */
 	endInterview: false;
 	answers: Record<string, { selected: string | string[]; notes: string }>;
+	/**
+	 * Set to true only when the round ended because the external AbortSignal
+	 * fired (e.g. a system/host teardown), as distinct from a deliberate user
+	 * dismissal. Consumers use this to avoid laundering a system teardown into a
+	 * clean user-declined cancel. Additive/optional — native consumers ignore it.
+	 */
+	interrupted?: boolean;
 }
 
 export interface WrapUpResult {
@@ -97,6 +104,12 @@ export interface InterviewRoundOptions {
 	 * Defaults to "end interview".
 	 */
 	exitLabel?: string;
+	/**
+	 * Render as a floating overlay instead of replacing the editor. Use when the
+	 * interview must stay visible during an in-flight agent stream (e.g. claude-code-cli
+	 * MCP elicitation).
+	 */
+	overlay?: boolean;
 }
 
 export interface WrapUpOptions {
@@ -240,7 +253,7 @@ export async function showInterviewRound(
 
 		// External cancellation (e.g. remote channel won the race)
 		if (opts.signal) {
-			const onAbort = () => finish({ endInterview: false, answers: {} });
+			const onAbort = () => finish({ endInterview: false, answers: {}, interrupted: true });
 			if (opts.signal.aborted) { onAbort(); }
 			else {
 				opts.signal.addEventListener("abort", onAbort, { once: true });
@@ -845,5 +858,5 @@ export async function showInterviewRound(
 			invalidate: () => { cachedLines = undefined; },
 			handleInput,
 		};
-	});
+	}, opts.overlay ? { overlay: true } : undefined);
 }

package/src/resources/shared/claude-runtime-floor.ts

@@ -0,0 +1,248 @@
+import { execFileSync as nodeExecFileSync } from 'node:child_process'
+import { existsSync as nodeExistsSync, realpathSync as nodeRealpathSync, readFileSync as nodeReadFileSync } from 'node:fs'
+import { delimiter, dirname, extname, join, resolve as resolvePath } from 'node:path'
+
+export const CLAUDE_CODE_RUNTIME_FLOOR = '2.1.168'
+export const CLAUDE_CODE_PROVIDER = 'claude-code'
+export const CLAUDE_CODE_PACKAGE = '@anthropic-ai/claude-code'
+
+interface ClaudeRuntimeSettings {
+  defaultProvider?: string
+  defaultModel?: string
+}
+
+interface FileDeps {
+  existsSync?: typeof nodeExistsSync
+  readFileSync?: typeof nodeReadFileSync
+  realpathSync?: typeof nodeRealpathSync
+}
+
+type ExecFileSyncLike = (
+  command: string,
+  args?: readonly string[],
+  options?: Parameters<typeof nodeExecFileSync>[2],
+) => Buffer | string
+
+export interface ClaudeRuntimeFloorOptions extends FileDeps {
+  agentDir: string
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  execFileSync?: ExecFileSyncLike
+  platform?: NodeJS.Platform
+}
+
+export interface ClaudeRuntimeProbe {
+  command: string
+  displayPath: string | null
+  realPath: string | null
+  version: string
+}
+
+interface UpgradeCommandInfo {
+  command: string | null
+  source: 'npm' | 'pnpm' | 'bun' | 'homebrew' | 'winget' | 'native' | 'unknown'
+}
+
+const VERSION_TIMEOUT_MS = 5_000
+
+function compareVersionTriplets(a: string, b: string): number {
+  const left = a.split('.').map(Number)
+  const right = b.split('.').map(Number)
+  for (let index = 0; index < Math.max(left.length, right.length); index++) {
+    const leftValue = left[index] || 0
+    const rightValue = right[index] || 0
+    if (leftValue > rightValue) return 1
+    if (leftValue < rightValue) return -1
+  }
+  return 0
+}
+
+export function parseClaudeRuntimeVersion(output: string): string | null {
+  return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null
+}
+
+export function isClaudeCodeConfigured(settings: ClaudeRuntimeSettings): boolean {
+  if (settings.defaultProvider === CLAUDE_CODE_PROVIDER) return true
+  return settings.defaultModel?.startsWith(`${CLAUDE_CODE_PROVIDER}/`) ?? false
+}
+
+function readSettingsFile(path: string, deps: Required<Pick<FileDeps, 'existsSync' | 'readFileSync'>>): ClaudeRuntimeSettings {
+  try {
+    if (!deps.existsSync(path)) return {}
+    const raw = JSON.parse(deps.readFileSync(path, 'utf-8') as string) as ClaudeRuntimeSettings
+    return {
+      ...(typeof raw.defaultProvider === 'string' ? { defaultProvider: raw.defaultProvider } : {}),
+      ...(typeof raw.defaultModel === 'string' ? { defaultModel: raw.defaultModel } : {}),
+    }
+  } catch {
+    return {}
+  }
+}
+
+export function loadClaudeRuntimeSettings(options: Pick<ClaudeRuntimeFloorOptions, 'agentDir' | 'cwd' | 'existsSync' | 'readFileSync'>): ClaudeRuntimeSettings {
+  const deps = {
+    existsSync: options.existsSync ?? nodeExistsSync,
+    readFileSync: options.readFileSync ?? nodeReadFileSync,
+  }
+  const globalSettings = readSettingsFile(join(options.agentDir, 'settings.json'), deps)
+  const projectSettings = options.cwd
+    ? readSettingsFile(join(options.cwd, '.gsd', 'settings.json'), deps)
+    : {}
+
+  return {
+    ...globalSettings,
+    ...projectSettings,
+  }
+}
+
+export function buildClaudeSpawnInvocation(
+  command: string,
+  args: string[],
+  platform: NodeJS.Platform = process.platform,
+): { command: string; args: string[] } {
+  if (platform === 'win32') {
+    return { command: 'cmd', args: ['/c', command, ...args] }
+  }
+  return { command, args }
+}
+
+export function getClaudeRuntimeCommandCandidates(platform: NodeJS.Platform = process.platform): string[] {
+  return platform === 'win32' ? ['claude.cmd', 'claude.exe', 'claude'] : ['claude']
+}
+
+function pathEntries(env: NodeJS.ProcessEnv): string[] {
+  return (env.PATH ?? '')
+    .split(delimiter)
+    .map(entry => entry.trim())
+    .filter(Boolean)
+}
+
+function executableNames(command: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string[] {
+  if (platform !== 'win32' || extname(command)) return [command]
+  const extensions = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+    .split(';')
+    .map(value => value.trim().toLowerCase())
+    .filter(Boolean)
+  return [command, ...extensions.map(extension => `${command}${extension}`)]
+}
+
+export function resolveExecutablePath(
+  command: string,
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+  existsSync: typeof nodeExistsSync = nodeExistsSync,
+): string | null {
+  if (dirname(command) !== '.') {
+    return existsSync(command) ? resolvePath(command) : null
+  }
+
+  for (const entry of pathEntries(env)) {
+    for (const name of executableNames(command, env, platform)) {
+      const candidate = join(entry, name)
+      if (existsSync(candidate)) return resolvePath(candidate)
+    }
+  }
+  return null
+}
+
+function realpathOrNull(path: string | null, realpathSync: typeof nodeRealpathSync): string | null {
+  if (!path) return null
+  try {
+    return realpathSync(path)
+  } catch {
+    return path
+  }
+}
+
+export function probeClaudeRuntime(options: Omit<ClaudeRuntimeFloorOptions, 'agentDir' | 'cwd'> = {}): ClaudeRuntimeProbe | null {
+  const env = options.env ?? process.env
+  const platform = options.platform ?? process.platform
+  const execFileSync = options.execFileSync ?? nodeExecFileSync
+  const existsSync = options.existsSync ?? nodeExistsSync
+  const realpathSync = options.realpathSync ?? nodeRealpathSync
+
+  for (const command of getClaudeRuntimeCommandCandidates(platform)) {
+    try {
+      const invocation = buildClaudeSpawnInvocation(command, ['--version'], platform)
+      const output = execFileSync(invocation.command, invocation.args, {
+        encoding: 'utf-8',
+        env,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: VERSION_TIMEOUT_MS,
+      })
+      const version = parseClaudeRuntimeVersion(String(output))
+      if (!version) continue
+
+      const displayPath = resolveExecutablePath(command, env, platform, existsSync)
+      return {
+        command,
+        displayPath,
+        realPath: realpathOrNull(displayPath, realpathSync),
+        version,
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+function normalizedPath(value: string | null | undefined): string {
+  return (value ?? '').replace(/\\/g, '/').toLowerCase()
+}
+
+export function inferClaudeRuntimeUpgradeCommand(probe: Pick<ClaudeRuntimeProbe, 'displayPath' | 'realPath'>, platform: NodeJS.Platform = process.platform): UpgradeCommandInfo {
+  const combined = `${normalizedPath(probe.displayPath)}\n${normalizedPath(probe.realPath)}`
+
+  if (combined.includes('/.pnpm/') && combined.includes('@anthropic-ai+claude-code@')) {
+    return { command: `pnpm add -g ${CLAUDE_CODE_PACKAGE}@latest`, source: 'pnpm' }
+  }
+  if (combined.includes('/node_modules/') && combined.includes('/@anthropic-ai/claude-code/')) {
+    return { command: `npm install -g ${CLAUDE_CODE_PACKAGE}@latest`, source: 'npm' }
+  }
+  if (combined.includes('/.bun/') || combined.includes('/bun/install/global/')) {
+    return { command: `bun add -g ${CLAUDE_CODE_PACKAGE}@latest`, source: 'bun' }
+  }
+  if (combined.includes('/homebrew/') || combined.includes('/caskroom/claude-code')) {
+    return { command: 'brew upgrade claude-code', source: 'homebrew' }
+  }
+  if (platform === 'win32' && (combined.includes('/winget/') || combined.includes('/anthropic.claudecode'))) {
+    return { command: 'winget upgrade Anthropic.ClaudeCode', source: 'winget' }
+  }
+  if (combined.includes('claude code.app') || combined.includes('/anthropic/claude')) {
+    return { command: null, source: 'native' }
+  }
+  return { command: null, source: 'unknown' }
+}
+
+export function formatClaudeRuntimeFloorAdvisory(
+  probe: ClaudeRuntimeProbe,
+  floor: string = CLAUDE_CODE_RUNTIME_FLOOR,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const upgrade = inferClaudeRuntimeUpgradeCommand(probe, platform)
+  const pathText = probe.displayPath ? ` at ${probe.displayPath}` : ''
+  const base =
+    `Warning: Claude Code Runtime is below GSD's validated floor: detected v${probe.version}, expected >= v${floor}. ` +
+    'GSD can still update, but older Claude Code may silently reduce output quality or miss model/runtime features.'
+
+  if (upgrade.command) {
+    return `${base} Upgrade the claude binary${pathText} with: ${upgrade.command}`
+  }
+  return (
+    `${base} Upgrade the claude binary${pathText} using the method you installed it with. ` +
+    'See docs/user-docs/claude-code-subscription.md#upgrade-claude-code.'
+  )
+}
+
+export function buildClaudeRuntimeFloorAdvisory(options: ClaudeRuntimeFloorOptions): string | null {
+  const settings = loadClaudeRuntimeSettings(options)
+  if (!isClaudeCodeConfigured(settings)) return null
+
+  const probe = probeClaudeRuntime(options)
+  if (!probe) return null
+  if (compareVersionTriplets(probe.version, CLAUDE_CODE_RUNTIME_FLOOR) >= 0) return null
+
+  return formatClaudeRuntimeFloorAdvisory(probe, CLAUDE_CODE_RUNTIME_FLOOR, options.platform)
+}