@opengsd/gsd-pi 1.2.0-dev.d6c5343c → 1.2.0-dev.ddc97c10

package/dist/resources/extensions/gsd/verification-verdict.js

@@ -1,5 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Host-owned verification verdict policy for auto-mode units.
+export const NO_HOST_CHECKS_FAILURE_CONTEXT = "No runnable host-owned verification command was discovered. Add project verification_commands in .gsd/PREFERENCES.md or a runnable task-plan Verify command, then resume with /gsd next.";
 export function decideVerificationVerdict(unitType, result) {
     if (unitType === "execute-task" && result.discoverySource === "task-plan-prose" && result.checks.length === 0) {
         return {
@@ -14,7 +15,7 @@ export function decideVerificationVerdict(unitType, result) {
             passed: false,
             reason: "no-host-checks",
             retryable: false,
-            failureContext: "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+            failureContext: NO_HOST_CHECKS_FAILURE_CONTEXT,
         };
     }
     if (!result.passed) {

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -38,6 +38,22 @@ function compareSemverLocal(a, b) {
 function parseGsdBrowserVersion(output) {
     return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
 }
+function splitCommandLine(commandLine) {
+    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) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/d", "/s", "/c", "gsd-browser", "--version"] };
+    }
+    return { command: "gsd-browser", args: ["--version"] };
+}
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -67,7 +83,8 @@ function resolvePathGsdBrowserVersion(env) {
     if (cachedPathProbeVersion !== undefined)
         return cachedPathProbeVersion;
     try {
-        cachedPathProbeVersion = 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"],
@@ -176,7 +193,8 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
     const explicitArgs = parseJsonEnv(env, "GSD_BROWSER_MCP_ARGS");
     const explicitEnv = parseJsonEnv(env, "GSD_BROWSER_MCP_ENV");
-    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.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
@@ -198,6 +216,7 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
         ? explicitArgs.map(String)
         : [
+            ...explicitCommandArgs,
             ...(bundledCliPath ? [bundledCliPath] : []),
             "mcp",
             "--session",

package/dist/resources/shared/gsd-browser-path-sync.js

@@ -0,0 +1,214 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, copyFileSync, existsSync, lstatSync, readlinkSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, delimiter as pathDelimiter, resolve as resolvePath } from 'node:path';
+import { isPnpmInstall, pathStartsWith } from './package-manager-detection.js';
+function isBunGlobalInstall(argv1, env) {
+    if ('bun' in process.versions)
+        return true;
+    if (!argv1)
+        return false;
+    const bunBinDirs = [];
+    if (env.BUN_INSTALL)
+        bunBinDirs.push(join(env.BUN_INSTALL, 'bin'));
+    bunBinDirs.push(join(homedir(), '.bun', 'bin'));
+    return bunBinDirs.some((dir) => pathStartsWith(argv1, dir));
+}
+function gsdBrowserBinaryName(platform) {
+    return platform === 'win32' ? 'gsd-browser.cmd' : 'gsd-browser';
+}
+function tryResolveFromBinDir(binDir, platform) {
+    const primary = join(binDir, gsdBrowserBinaryName(platform));
+    if (existsSync(primary))
+        return primary;
+    if (platform === 'win32') {
+        const fallback = join(binDir, 'gsd-browser');
+        if (existsSync(fallback))
+            return fallback;
+    }
+    return null;
+}
+function tryResolveFromPackageRoot(rootDir, platform) {
+    const candidate = join(rootDir, '@opengsd', 'gsd-browser', 'bin', gsdBrowserBinaryName(platform));
+    if (existsSync(candidate))
+        return candidate;
+    if (platform === 'win32') {
+        const fallback = join(rootDir, '@opengsd', 'gsd-browser', 'bin', 'gsd-browser');
+        if (existsSync(fallback))
+            return fallback;
+    }
+    return null;
+}
+function tryExecLookup(command, args, env, platform, resolve) {
+    try {
+        const dir = execFileSync(command, args, {
+            encoding: 'utf-8',
+            env,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        }).trim();
+        return resolve(dir, platform);
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePathBinary(env, platform) {
+    if (platform === 'win32') {
+        try {
+            const out = execFileSync('where', ['gsd-browser'], {
+                encoding: 'utf-8',
+                env,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 5000,
+            }).trim();
+            const first = out.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+            return first && existsSync(first) ? first : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    for (const entry of (env.PATH ?? '').split(pathDelimiter)) {
+        if (!entry)
+            continue;
+        const candidate = join(entry, 'gsd-browser');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function resolveRealPath(pathValue) {
+    try {
+        return realpathSync(pathValue);
+    }
+    catch {
+        return resolvePath(pathValue);
+    }
+}
+function resolveSymlinkTarget(pathCli) {
+    try {
+        const stat = lstatSync(pathCli);
+        if (!stat.isSymbolicLink())
+            return pathCli;
+        const target = readlinkSync(pathCli);
+        return isAbsolute(target) ? target : resolvePath(dirname(pathCli), target);
+    }
+    catch {
+        // PATH entry vanished or is inaccessible between resolution and sync.
+        // Fall back to the original path; subsequent sync will surface a useful
+        // error rather than escaping as an unhandled throw.
+        return pathCli;
+    }
+}
+function resolveHomeDir(env) {
+    const fromEnv = env.HOME?.trim() || env.USERPROFILE?.trim();
+    return resolvePath(fromEnv || homedir());
+}
+function canAutoSyncTarget(targetPath, env) {
+    const home = resolveHomeDir(env);
+    const resolved = resolvePath(targetPath);
+    return pathStartsWith(resolved, home);
+}
+function syncBinary(installedCli, targetPath, platform) {
+    const source = resolveRealPath(installedCli);
+    copyFileSync(source, targetPath);
+    if (platform !== 'win32') {
+        chmodSync(targetPath, 0o755);
+    }
+}
+/**
+ * Resolve the gsd-browser binary installed by the active global package manager.
+ */
+export function resolveGlobalGsdBrowserCliPath(options = {}) {
+    const env = options.env ?? process.env;
+    const argv1 = options.argv1 ?? process.argv[1];
+    const platform = options.platform ?? process.platform;
+    if (isBunGlobalInstall(argv1, env)) {
+        return (tryExecLookup('bun', ['pm', 'bin', '-g'], env, platform, tryResolveFromBinDir)
+            ?? (env.BUN_INSTALL ? tryResolveFromBinDir(join(env.BUN_INSTALL, 'bin'), platform) : null)
+            ?? tryResolveFromBinDir(join(homedir(), '.bun', 'bin'), platform));
+    }
+    if (isPnpmInstall(argv1, env)) {
+        return (tryExecLookup('pnpm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+            ?? tryExecLookup('pnpm', ['root', '-g'], env, platform, tryResolveFromPackageRoot));
+    }
+    return (tryExecLookup('npm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+        ?? tryExecLookup('npm', ['root', '-g'], env, platform, tryResolveFromPackageRoot));
+}
+/**
+ * Resolve the gsd-browser binary that wins on PATH (`command -v` / `where`).
+ */
+export function resolveGsdBrowserOnPath(env = process.env, platform = process.platform) {
+    return resolvePathBinary(env, platform);
+}
+/**
+ * After a global gsd-browser install, ensure the PATH-resolved binary matches
+ * the freshly installed global binary when an older copy is shadowing it.
+ */
+export function reconcileGsdBrowserPathAfterInstall(options) {
+    const env = options.env ?? process.env;
+    const argv1 = options.argv1 ?? process.argv[1];
+    const platform = options.platform ?? process.platform;
+    const installedCli = resolveGlobalGsdBrowserCliPath({ env, argv1, platform });
+    if (!installedCli) {
+        return { action: 'none' };
+    }
+    const pathCli = resolveGsdBrowserOnPath(env, platform);
+    const installedReal = resolveRealPath(installedCli);
+    if (pathCli && resolveRealPath(pathCli) === installedReal) {
+        return { action: 'none', pathCli, installedCli };
+    }
+    const pathVersion = options.resolvePathVersion(env);
+    if (pathVersion && options.compareSemver(pathVersion, options.latestVersion) >= 0) {
+        return { action: 'none', pathCli: pathCli ?? undefined, installedCli };
+    }
+    if (!pathCli) {
+        return {
+            action: 'shadowed',
+            installedCli,
+            message: 'Installed gsd-browser globally, but no gsd-browser was found on PATH. Add your package manager global bin directory to PATH.',
+        };
+    }
+    const syncTarget = resolveSymlinkTarget(pathCli);
+    if (!canAutoSyncTarget(syncTarget, env)) {
+        return {
+            action: 'shadowed',
+            pathCli,
+            installedCli,
+            syncTarget,
+            message: `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+                'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+        };
+    }
+    let syncSucceeded = false;
+    try {
+        syncBinary(installedCli, syncTarget, platform);
+        syncSucceeded = true;
+    }
+    catch {
+        // Fall through to shadowed guidance.
+    }
+    if (syncSucceeded) {
+        const refreshedVersion = options.resolvePathVersion(env);
+        const verified = refreshedVersion !== null
+            && options.compareSemver(refreshedVersion, options.latestVersion) >= 0;
+        return {
+            action: 'synced',
+            pathCli,
+            installedCli,
+            syncTarget,
+            message: verified
+                ? `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install.`
+                : `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install. Could not verify the new version on PATH; restart your shell or rerun if it still reports the old version.`,
+        };
+    }
+    return {
+        action: 'shadowed',
+        pathCli,
+        installedCli,
+        syncTarget,
+        message: `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+            'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+    };
+}

package/dist/resources/shared/package-manager-detection.js

@@ -9,7 +9,7 @@ function hasPnpmPath(value) {
         normalized.endsWith('/pnpm.cjs') ||
         normalized.endsWith('/pnpm.js'));
 }
-function pathStartsWith(pathValue, dir) {
+export function pathStartsWith(pathValue, dir) {
     if (!pathValue)
         return false;
     const resolvedPath = resolvePath(pathValue);