gsd-pi 2.37.1-dev.d3ace49 → 2.38.0-dev.29edcdc

package/dist/app-paths.js

@@ -1,6 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
-export const appRoot = join(homedir(), '.gsd');
+export const appRoot = process.env.GSD_HOME || join(homedir(), '.gsd');
 export const agentDir = join(appRoot, 'agent');
 export const sessionsDir = join(appRoot, 'sessions');
 export const authFilePath = join(agentDir, 'auth.json');

package/dist/cli.js

@@ -505,6 +505,15 @@ if (enabledModelPatterns && enabledModelPatterns.length > 0) {
         session.setScopedModels(scopedModels);
     }
 }
+// Welcome screen — shown on every fresh interactive session before TUI takes over
+{
+    const { printWelcomeScreen } = await import('./welcome-screen.js');
+    printWelcomeScreen({
+        version: process.env.GSD_VERSION || '0.0.0',
+        modelName: settingsManager.getDefaultModel() || undefined,
+        provider: settingsManager.getDefaultProvider() || undefined,
+    });
+}
 const interactiveMode = new InteractiveMode(session);
 markStartup('InteractiveMode');
 printStartupTimings();

package/dist/extension-discovery.d.ts

@@ -1,9 +1,11 @@
 /**
  * Resolves the entry-point file(s) for a single extension directory.
  *
- * 1. If the directory contains a package.json with a `pi.extensions` array,
- *    each entry is resolved relative to the directory and returned (if it exists).
- * 2. Otherwise falls back to `index.ts` → `index.js`.
+ * 1. If the directory contains a package.json with a `pi` manifest object,
+ *    the manifest is authoritative:
+ *    - `pi.extensions` array → resolve each entry relative to the directory.
+ *    - `pi: {}` (no extensions) → return empty (library opt-out, e.g. cmux).
+ * 2. Only when no `pi` manifest exists does it fall back to `index.ts` → `index.js`.
  */
 export declare function resolveExtensionEntries(dir: string): string[];
 /**

package/dist/extension-discovery.js

@@ -6,24 +6,29 @@ function isExtensionFile(name) {
 /**
  * Resolves the entry-point file(s) for a single extension directory.
  *
- * 1. If the directory contains a package.json with a `pi.extensions` array,
- *    each entry is resolved relative to the directory and returned (if it exists).
- * 2. Otherwise falls back to `index.ts` → `index.js`.
+ * 1. If the directory contains a package.json with a `pi` manifest object,
+ *    the manifest is authoritative:
+ *    - `pi.extensions` array → resolve each entry relative to the directory.
+ *    - `pi: {}` (no extensions) → return empty (library opt-out, e.g. cmux).
+ * 2. Only when no `pi` manifest exists does it fall back to `index.ts` → `index.js`.
  */
 export 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
+            if (pkg?.pi && typeof pkg.pi === 'object') {
+                // When a pi manifest exists, it is authoritative — don't fall through
+                // to index.ts/index.js auto-detection. This allows library directories
+                // (like cmux) to opt out by declaring "pi": {} with no extensions.
+                const declared = pkg.pi.extensions;
+                if (!Array.isArray(declared) || declared.length === 0) {
+                    return [];
+                }
+                return declared
                     .filter((entry) => typeof entry === 'string')
                     .map((entry) => resolve(dir, entry))
                     .filter((entry) => existsSync(entry));
-                if (resolved.length > 0) {
-                    return resolved;
-                }
             }
         }
         catch {

package/dist/extension-registry.js

@@ -6,7 +6,7 @@
  * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { appRoot } from "./app-paths.js";
 import { dirname, join } from "node:path";
 // ─── Validation ─────────────────────────────────────────────────────────────
 function isRegistry(data) {
@@ -26,7 +26,7 @@ function isManifest(data) {
 }
 // ─── Registry Path ──────────────────────────────────────────────────────────
 export function getRegistryPath() {
-    return join(homedir(), ".gsd", "extensions", "registry.json");
+    return join(appRoot, "extensions", "registry.json");
 }
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function defaultRegistry() {

package/dist/remote-questions-config.js

@@ -9,12 +9,12 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { appRoot } from "./app-paths.js";
 // 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");
+const GLOBAL_PREFERENCES_PATH = join(appRoot, "preferences.md");
 export function saveRemoteQuestionsConfig(channel, channelId) {
     const prefsPath = GLOBAL_PREFERENCES_PATH;
     const block = [

package/dist/resource-loader.js

@@ -1,7 +1,7 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -217,6 +217,35 @@ function copyDirRecursive(src, dest) {
         }
     }
 }
+/**
+ * Creates (or updates) a symlink at agentDir/node_modules pointing to GSD's
+ * own node_modules directory.
+ *
+ * Native ESM `import()` ignores NODE_PATH — it resolves packages by walking
+ * up the directory tree from the importing file. Extension files synced to
+ * ~/.gsd/agent/extensions/ have no ancestor node_modules, so imports of
+ * @gsd/* packages fail. The symlink makes Node's standard resolution find
+ * them without requiring every call site to use jiti.
+ */
+function ensureNodeModulesSymlink(agentDir) {
+    const agentNodeModules = join(agentDir, 'node_modules');
+    const gsdNodeModules = join(packageRoot, 'node_modules');
+    try {
+        const existing = readlinkSync(agentNodeModules);
+        if (existing === gsdNodeModules)
+            return; // already correct
+        unlinkSync(agentNodeModules);
+    }
+    catch {
+        // readlinkSync throws if path doesn't exist or isn't a symlink — both are fine
+    }
+    try {
+        symlinkSync(gsdNodeModules, agentNodeModules, 'junction');
+    }
+    catch {
+        // Non-fatal — worst case, extensions fall back to NODE_PATH via jiti
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -262,6 +291,10 @@ export function initResources(agentDir) {
     // 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);
+    // Ensure ~/.gsd/agent/node_modules symlinks to GSD's node_modules so that
+    // native ESM import() calls from synced extension files can resolve @gsd/*
+    // packages via ancestor directory lookup. NODE_PATH only applies to CJS/jiti.
+    ensureNodeModulesSymlink(agentDir);
     writeManagedResourceManifest(agentDir);
     ensureRegistryEntries(join(agentDir, 'extensions'));
 }

package/dist/resources/extensions/browser-tools/package.json

@@ -7,7 +7,9 @@
     "test": "node --test tests/*.test.mjs"
   },
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.js"
+    ]
   },
   "peerDependencies": {
     "playwright": ">=1.40.0",

package/dist/resources/extensions/cmux/index.js

@@ -237,11 +237,14 @@ export class CmuxClient {
         return extractSurfaceIds(parsed);
     }
     async createSplit(direction) {
+        return this.createSplitFrom(this.config.surfaceId, direction);
+    }
+    async createSplitFrom(sourceSurfaceId, direction) {
         if (!this.config.splits)
             return null;
         const before = new Set(await this.listSurfaceIds());
         const args = ["new-split", direction];
-        const scopedArgs = this.appendSurface(this.appendWorkspace(args), this.config.surfaceId);
+        const scopedArgs = this.appendSurface(this.appendWorkspace(args), sourceSurfaceId);
         await this.runAsync(scopedArgs);
         const after = await this.listSurfaceIds();
         for (const id of after) {
@@ -250,6 +253,57 @@ export class CmuxClient {
         }
         return null;
     }
+    /**
+     * Create a grid of surfaces for parallel agent execution.
+     *
+     * Layout strategy (gsd stays in the original surface):
+     *   1 agent:  [gsd | A]
+     *   2 agents: [gsd | A]
+     *             [    | B]
+     *   3 agents: [gsd | A]
+     *             [ C  | B]
+     *   4 agents: [gsd | A]
+     *             [ C  | B]  (D splits from B downward)
+     *             [    | D]
+     *
+     * Returns surface IDs in order, or empty array on failure.
+     */
+    async createGridLayout(count) {
+        if (!this.config.splits || count <= 0)
+            return [];
+        const surfaces = [];
+        // First split: create right column from the gsd surface
+        const rightCol = await this.createSplitFrom(this.config.surfaceId, "right");
+        if (!rightCol)
+            return [];
+        surfaces.push(rightCol);
+        if (count === 1)
+            return surfaces;
+        // Second split: split right column down → bottom-right
+        const bottomRight = await this.createSplitFrom(rightCol, "down");
+        if (!bottomRight)
+            return surfaces;
+        surfaces.push(bottomRight);
+        if (count === 2)
+            return surfaces;
+        // Third split: split gsd surface down → bottom-left
+        const bottomLeft = await this.createSplitFrom(this.config.surfaceId, "down");
+        if (!bottomLeft)
+            return surfaces;
+        surfaces.push(bottomLeft);
+        if (count === 3)
+            return surfaces;
+        // Fourth+: split subsequent surfaces down from the last created
+        let lastSurface = bottomRight;
+        for (let i = 3; i < count; i++) {
+            const next = await this.createSplitFrom(lastSurface, "down");
+            if (!next)
+                break;
+            surfaces.push(next);
+            lastSurface = next;
+        }
+        return surfaces;
+    }
     async sendSurface(surfaceId, text) {
         const payload = text.endsWith("\n") ? text : `${text}\n`;
         const stdout = await this.runAsync(["send-surface", "--surface", surfaceId, payload]);

package/dist/resources/extensions/context7/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }

package/dist/resources/extensions/env-utils.js

@@ -0,0 +1,29 @@
+// GSD Extension — Environment variable utilities
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+//
+// Pure utility for checking existing env keys in .env files and process.env.
+// Extracted from get-secrets-from-user.ts to avoid pulling in @gsd/pi-tui
+// when only env-checking is needed (e.g. from files.ts during report generation).
+import { readFile } from "node:fs/promises";
+/**
+ * Check which keys already exist in a .env file or process.env.
+ * Returns the subset of `keys` that are already set.
+ */
+export async function checkExistingEnvKeys(keys, envFilePath) {
+    let fileContent = "";
+    try {
+        fileContent = await readFile(envFilePath, "utf8");
+    }
+    catch {
+        // ENOENT or other read error — proceed with empty content
+    }
+    const existing = [];
+    for (const key of keys) {
+        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\s*=`, "m");
+        if (regex.test(fileContent) || key in process.env) {
+            existing.push(key);
+        }
+    }
+    return existing;
+}

package/dist/resources/extensions/get-secrets-from-user.js

@@ -46,30 +46,11 @@ async function writeEnvKey(filePath, key, value) {
     await writeFile(filePath, content, "utf8");
 }
 // ─── Exported utilities ───────────────────────────────────────────────────────
-/**
- * Check which keys already exist in the .env file or process.env.
- * Returns the subset of `keys` that are already set.
- * Handles ENOENT gracefully (still checks process.env).
- * Empty-string values count as existing.
- */
-export async function checkExistingEnvKeys(keys, envFilePath) {
-    let fileContent = "";
-    try {
-        fileContent = await readFile(envFilePath, "utf8");
-    }
-    catch {
-        // ENOENT or other read error — proceed with empty content
-    }
-    const existing = [];
-    for (const key of keys) {
-        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const regex = new RegExp(`^${escaped}\\s*=`, "m");
-        if (regex.test(fileContent) || key in process.env) {
-            existing.push(key);
-        }
-    }
-    return existing;
-}
+// Re-export from env-utils.ts so existing consumers still work.
+// The implementation lives in env-utils.ts to avoid pulling @gsd/pi-tui
+// into modules that only need env-checking (e.g. files.ts during reports).
+import { checkExistingEnvKeys } from "./env-utils.js";
+export { checkExistingEnvKeys };
 /**
  * Detect the write destination based on project files in basePath.
  * Priority: vercel.json → convex/ dir → fallback "dotenv".

package/dist/resources/extensions/github-sync/cli.js

@@ -0,0 +1,284 @@
+/**
+ * Thin wrapper around the `gh` CLI.
+ *
+ * Every public function returns `GhResult<T>` — never throws.
+ * Uses `execFileSync` (not `execSync`) for safety.
+ */
+import { execFileSync } from "node:child_process";
+function ok(data) {
+    return { ok: true, data };
+}
+function fail(error) {
+    return { ok: false, error };
+}
+// ─── gh Availability ────────────────────────────────────────────────────────
+let _ghAvailable = null;
+export function ghIsAvailable() {
+    if (_ghAvailable !== null)
+        return _ghAvailable;
+    try {
+        execFileSync("gh", ["--version"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5_000,
+        });
+        _ghAvailable = true;
+    }
+    catch {
+        _ghAvailable = false;
+    }
+    return _ghAvailable;
+}
+/** Reset cached availability (for testing). */
+export function _resetGhCache() {
+    _ghAvailable = null;
+}
+// ─── Rate Limit Check ───────────────────────────────────────────────────────
+let _rateLimitCheckedAt = 0;
+let _rateLimitOk = true;
+const RATE_LIMIT_CHECK_INTERVAL_MS = 300_000; // 5 minutes
+export function ghHasRateLimit(cwd) {
+    const now = Date.now();
+    if (now - _rateLimitCheckedAt < RATE_LIMIT_CHECK_INTERVAL_MS)
+        return _rateLimitOk;
+    _rateLimitCheckedAt = now;
+    try {
+        const raw = execFileSync("gh", ["api", "rate_limit", "--jq", ".rate.remaining"], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 10_000,
+        }).trim();
+        const remaining = parseInt(raw, 10);
+        _rateLimitOk = Number.isFinite(remaining) && remaining >= 100;
+    }
+    catch {
+        // Can't check — assume OK so we don't silently disable sync
+        _rateLimitOk = true;
+    }
+    return _rateLimitOk;
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const GH_TIMEOUT = 15_000;
+const MAX_BODY_LENGTH = 65_000;
+function truncateBody(body) {
+    if (body.length <= MAX_BODY_LENGTH)
+        return body;
+    return body.slice(0, MAX_BODY_LENGTH) + "\n\n---\n*Body truncated (exceeded 65K characters)*";
+}
+function runGh(args, cwd) {
+    try {
+        const stdout = execFileSync("gh", args, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: GH_TIMEOUT,
+        }).trim();
+        return ok(stdout);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return fail(msg);
+    }
+}
+function runGhJson(args, cwd) {
+    const result = runGh(args, cwd);
+    if (!result.ok)
+        return fail(result.error);
+    try {
+        return ok(JSON.parse(result.data));
+    }
+    catch {
+        return fail(`Failed to parse JSON: ${result.data}`);
+    }
+}
+// ─── Repo Detection ─────────────────────────────────────────────────────────
+export function ghDetectRepo(cwd) {
+    const result = runGh(["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    const repo = result.data.trim();
+    if (!repo || !repo.includes("/"))
+        return fail("Could not detect repo");
+    return ok(repo);
+}
+export function ghCreateIssue(cwd, opts) {
+    const args = [
+        "issue", "create",
+        "--repo", opts.repo,
+        "--title", opts.title,
+        "--body", truncateBody(opts.body),
+    ];
+    if (opts.labels?.length) {
+        args.push("--label", opts.labels.join(","));
+    }
+    if (opts.milestone) {
+        args.push("--milestone", String(opts.milestone));
+    }
+    const result = runGh(args, cwd);
+    if (!result.ok)
+        return fail(result.error);
+    // gh issue create returns the URL; extract issue number
+    const match = result.data.match(/\/issues\/(\d+)/);
+    if (!match)
+        return fail(`Could not parse issue number from: ${result.data}`);
+    const issueNumber = parseInt(match[1], 10);
+    // If parent specified, add as sub-issue via GraphQL
+    if (opts.parentIssue) {
+        ghAddSubIssue(cwd, opts.repo, opts.parentIssue, issueNumber);
+    }
+    return ok(issueNumber);
+}
+export function ghCloseIssue(cwd, repo, issueNumber, comment) {
+    if (comment) {
+        ghAddComment(cwd, repo, issueNumber, comment);
+    }
+    const result = runGh(["issue", "close", String(issueNumber), "--repo", repo], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(undefined);
+}
+export function ghAddComment(cwd, repo, issueNumber, body) {
+    const result = runGh(["issue", "comment", String(issueNumber), "--repo", repo, "--body", truncateBody(body)], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(undefined);
+}
+// ─── Sub-Issues (GraphQL) ───────────────────────────────────────────────────
+function ghAddSubIssue(cwd, repo, parentNumber, childNumber) {
+    // Get node IDs for both issues
+    const parentResult = runGhJson(["api", `repos/${repo}/issues/${parentNumber}`, "--jq", "{id: .node_id}"], cwd);
+    const childResult = runGhJson(["api", `repos/${repo}/issues/${childNumber}`, "--jq", "{id: .node_id}"], cwd);
+    if (!parentResult.ok || !childResult.ok) {
+        return fail("Could not resolve issue node IDs for sub-issue linking");
+    }
+    const mutation = `mutation { addSubIssue(input: { issueId: "${parentResult.data.id}", subIssueId: "${childResult.data.id}" }) { issue { id } } }`;
+    return runGh(["api", "graphql", "-f", `query=${mutation}`], cwd);
+}
+// ─── Milestones ─────────────────────────────────────────────────────────────
+export function ghCreateMilestone(cwd, repo, title, description) {
+    const result = runGhJson([
+        "api", `repos/${repo}/milestones`,
+        "-X", "POST",
+        "-f", `title=${title}`,
+        "-f", `description=${truncateBody(description)}`,
+        "-f", "state=open",
+        "--jq", "{number: .number}",
+    ], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(result.data.number);
+}
+export function ghCloseMilestone(cwd, repo, milestoneNumber) {
+    const result = runGh([
+        "api", `repos/${repo}/milestones/${milestoneNumber}`,
+        "-X", "PATCH",
+        "-f", "state=closed",
+    ], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(undefined);
+}
+export function ghCreatePR(cwd, opts) {
+    const args = [
+        "pr", "create",
+        "--repo", opts.repo,
+        "--base", opts.base,
+        "--head", opts.head,
+        "--title", opts.title,
+        "--body", truncateBody(opts.body),
+    ];
+    if (opts.draft)
+        args.push("--draft");
+    const result = runGh(args, cwd);
+    if (!result.ok)
+        return fail(result.error);
+    const match = result.data.match(/\/pull\/(\d+)/);
+    if (!match)
+        return fail(`Could not parse PR number from: ${result.data}`);
+    return ok(parseInt(match[1], 10));
+}
+export function ghMarkPRReady(cwd, repo, prNumber) {
+    const result = runGh(["pr", "ready", String(prNumber), "--repo", repo], cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(undefined);
+}
+export function ghMergePR(cwd, repo, prNumber, strategy = "squash") {
+    const args = [
+        "pr", "merge", String(prNumber),
+        "--repo", repo,
+        strategy === "squash" ? "--squash" : "--merge",
+        "--delete-branch",
+    ];
+    const result = runGh(args, cwd);
+    if (!result.ok)
+        return fail(result.error);
+    return ok(undefined);
+}
+// ─── Projects v2 ────────────────────────────────────────────────────────────
+export function ghAddToProject(cwd, repo, projectNumber, issueNumber) {
+    // Get the issue's node ID first
+    const issueResult = runGhJson(["api", `repos/${repo}/issues/${issueNumber}`, "--jq", "{id: .node_id}"], cwd);
+    if (!issueResult.ok)
+        return fail(issueResult.error);
+    // Get the project's node ID
+    const [owner] = repo.split("/");
+    const projectResult = runGhJson([
+        "api", "graphql",
+        "-f", `query=query { user(login: "${owner}") { projectV2(number: ${projectNumber}) { id } } }`,
+        "--jq", ".data.user.projectV2.id",
+    ], cwd);
+    // Try org if user fails
+    let projectId;
+    if (projectResult.ok && projectResult.data?.id) {
+        projectId = projectResult.data.id;
+    }
+    else {
+        const orgResult = runGhJson([
+            "api", "graphql",
+            "-f", `query=query { organization(login: "${owner}") { projectV2(number: ${projectNumber}) { id } } }`,
+            "--jq", ".data.organization.projectV2.id",
+        ], cwd);
+        if (orgResult.ok)
+            projectId = orgResult.data?.id;
+    }
+    if (!projectId)
+        return fail("Could not find project");
+    const mutation = `mutation { addProjectV2ItemById(input: { projectId: "${projectId}", contentId: "${issueResult.data.id}" }) { item { id } } }`;
+    return runGh(["api", "graphql", "-f", `query=${mutation}`], cwd);
+}
+// ─── Branch Operations ──────────────────────────────────────────────────────
+export function ghPushBranch(cwd, branch, setUpstream = true) {
+    const args = ["git", "push"];
+    if (setUpstream)
+        args.push("-u", "origin", branch);
+    else
+        args.push("origin", branch);
+    try {
+        execFileSync(args[0], args.slice(1), {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 30_000,
+        });
+        return ok(undefined);
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+}
+export function ghCreateBranch(cwd, branch, from) {
+    try {
+        execFileSync("git", ["branch", branch, from], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 10_000,
+        });
+        return ok(undefined);
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+}