@draht/coding-agent 2026.3.14 → 2026.3.25-1

package/dist/core/package-manager.js

@@ -7,7 +7,9 @@ import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { getProjectConfigDir } from "../config.js";
 import { parseGitUrl } from "../utils/git.js";
+import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
+const UPDATE_CHECK_CONCURRENCY = 4;
 function isOfflineModeEnabled() {
     const value = process.env.DRAHT_OFFLINE ?? process.env.PI_OFFLINE;
     if (!value)
@@ -25,6 +27,9 @@ const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
 function toPosixPath(p) {
     return p.split(sep).join("/");
 }
+function getHomeDir() {
+    return process.env.HOME || homedir();
+}
 function prefixIgnorePattern(line, prefix) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -383,43 +388,50 @@ function collectResourceFiles(dir, resourceType) {
     return collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
 function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
     const parentName = isSkillFile ? basename(parentDir) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
+        const normalizedPattern = toPosixPath(pattern);
+        if (minimatch(rel, normalizedPattern) ||
+            minimatch(name, normalizedPattern) ||
+            minimatch(filePathPosix, normalizedPattern)) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return minimatch(parentRel, pattern) || minimatch(parentName, pattern) || minimatch(parentDir, pattern);
+        return (minimatch(parentRel, normalizedPattern) ||
+            minimatch(parentName, normalizedPattern) ||
+            minimatch(parentDirPosix, normalizedPattern));
     });
 }
 function normalizeExactPattern(pattern) {
-    if (pattern.startsWith("./") || pattern.startsWith(".\\")) {
-        return pattern.slice(2);
-    }
-    return pattern;
+    const normalized = pattern.startsWith("./") || pattern.startsWith(".\\") ? pattern.slice(2) : pattern;
+    return toPosixPath(normalized);
 }
 function matchesAnyExactPattern(filePath, patterns, baseDir) {
     if (patterns.length === 0)
         return false;
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
         const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
+        if (normalized === rel || normalized === filePathPosix) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return normalized === parentRel || normalized === parentDir;
+        return normalized === parentRel || normalized === parentDirPosix;
     });
 }
 function getOverridePatterns(entries) {
@@ -500,6 +512,7 @@ export class DefaultPackageManager {
     agentDir;
     settingsManager;
     globalNpmRoot;
+    globalNpmRootCommandKey;
     progressCallback;
     constructor(options) {
         this.cwd = options.cwd;
@@ -662,18 +675,27 @@ export class DefaultPackageManager {
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
         const identity = source ? this.getPackageIdentity(source) : undefined;
+        let matched = false;
         for (const pkg of globalSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "user") !== identity)
                 continue;
+            matched = true;
             await this.updateSourceForScope(sourceStr, "user");
         }
         for (const pkg of projectSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "project") !== identity)
                 continue;
+            matched = true;
             await this.updateSourceForScope(sourceStr, "project");
         }
+        if (source && !matched) {
+            throw new Error(this.buildNoMatchingPackageMessage(source, [
+                ...(globalSettings.packages ?? []),
+                ...(projectSettings.packages ?? []),
+            ]));
+        }
     }
     async updateSourceForScope(source, scope) {
         if (isOfflineModeEnabled()) {
@@ -684,7 +706,10 @@ export class DefaultPackageManager {
             if (parsed.pinned)
                 return;
             await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.installNpm(parsed, scope, false);
+                await this.installNpm({
+                    ...parsed,
+                    spec: `${parsed.name}@latest`,
+                }, scope, false);
             });
             return;
         }
@@ -697,6 +722,62 @@ export class DefaultPackageManager {
             return;
         }
     }
+    async checkForAvailableUpdates() {
+        if (isOfflineModeEnabled()) {
+            return [];
+        }
+        const globalSettings = this.settingsManager.getGlobalSettings();
+        const projectSettings = this.settingsManager.getProjectSettings();
+        const allPackages = [];
+        for (const pkg of projectSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "project" });
+        }
+        for (const pkg of globalSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "user" });
+        }
+        const packageSources = this.dedupePackages(allPackages);
+        const checks = packageSources
+            .filter((entry) => entry.scope !== "temporary")
+            .map((entry) => async () => {
+            const source = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
+            const parsed = this.parseSource(source);
+            if (parsed.type === "local" || parsed.pinned) {
+                return undefined;
+            }
+            if (parsed.type === "npm") {
+                const installedPath = this.getNpmInstallPath(parsed, entry.scope);
+                if (!existsSync(installedPath)) {
+                    return undefined;
+                }
+                const hasUpdate = await this.npmHasAvailableUpdate(parsed, installedPath);
+                if (!hasUpdate) {
+                    return undefined;
+                }
+                return {
+                    source,
+                    displayName: parsed.name,
+                    type: "npm",
+                    scope: entry.scope,
+                };
+            }
+            const installedPath = this.getGitInstallPath(parsed, entry.scope);
+            if (!existsSync(installedPath)) {
+                return undefined;
+            }
+            const hasUpdate = await this.gitHasAvailableUpdate(installedPath);
+            if (!hasUpdate) {
+                return undefined;
+            }
+            return {
+                source,
+                displayName: `${parsed.host}/${parsed.path}`,
+                type: "git",
+                scope: entry.scope,
+            };
+        });
+        const results = await this.runWithConcurrency(checks, UPDATE_CHECK_CONCURRENCY);
+        return results.filter((result) => result !== undefined);
+    }
     async resolvePackageSources(sources, accumulator, onMissing) {
         for (const { pkg, scope } of sources) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
@@ -726,7 +807,8 @@ export class DefaultPackageManager {
             };
             if (parsed.type === "npm") {
                 const installedPath = this.getNpmInstallPath(parsed, scope);
-                const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+                const needsInstall = !existsSync(installedPath) ||
+                    (parsed.pinned && !(await this.installedNpmMatchesPinnedVersion(parsed, installedPath)));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
@@ -809,6 +891,35 @@ export class DefaultPackageManager {
         const baseDir = this.getBaseDirForScope(scope);
         return `local:${this.resolvePathFromBase(parsed.path, baseDir)}`;
     }
+    buildNoMatchingPackageMessage(source, configuredPackages) {
+        const suggestion = this.findSuggestedConfiguredSource(source, configuredPackages);
+        if (!suggestion) {
+            return `No matching package found for ${source}`;
+        }
+        return `No matching package found for ${source}. Did you mean ${suggestion}?`;
+    }
+    findSuggestedConfiguredSource(source, configuredPackages) {
+        const trimmedSource = source.trim();
+        const suggestions = new Set();
+        for (const pkg of configuredPackages) {
+            const sourceStr = this.getPackageSourceString(pkg);
+            const parsed = this.parseSource(sourceStr);
+            if (parsed.type === "npm") {
+                if (trimmedSource === parsed.name || trimmedSource === parsed.spec) {
+                    suggestions.add(sourceStr);
+                }
+                continue;
+            }
+            if (parsed.type === "git") {
+                const shorthand = `${parsed.host}/${parsed.path}`;
+                const shorthandWithRef = parsed.ref ? `${shorthand}@${parsed.ref}` : undefined;
+                if (trimmedSource === shorthand || (shorthandWithRef && trimmedSource === shorthandWithRef)) {
+                    suggestions.add(sourceStr);
+                }
+            }
+        }
+        return suggestions.values().next().value;
+    }
     packageSourcesMatch(existing, inputSource, scope) {
         const left = this.getSourceMatchKeyForSettings(this.getPackageSourceString(existing), scope);
         const right = this.getSourceMatchKeyForInput(inputSource);
@@ -852,30 +963,30 @@ export class DefaultPackageManager {
         }
         return { type: "local", path: source };
     }
-    /**
-     * Check if an npm package needs to be updated.
-     * - For unpinned packages: check if registry has a newer version
-     * - For pinned packages: check if installed version matches the pinned version
-     */
-    async npmNeedsUpdate(source, installedPath) {
+    async installedNpmMatchesPinnedVersion(source, installedPath) {
+        const installedVersion = this.getInstalledNpmVersion(installedPath);
+        if (!installedVersion) {
+            return false;
+        }
+        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
+        if (!pinnedVersion) {
+            return true;
+        }
+        return installedVersion === pinnedVersion;
+    }
+    async npmHasAvailableUpdate(source, installedPath) {
         if (isOfflineModeEnabled()) {
             return false;
         }
         const installedVersion = this.getInstalledNpmVersion(installedPath);
-        if (!installedVersion)
-            return true;
-        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
-        if (pinnedVersion) {
-            // Pinned: check if installed matches pinned (exact match for now)
-            return installedVersion !== pinnedVersion;
+        if (!installedVersion) {
+            return false;
         }
-        // Unpinned: check registry for latest version
         try {
             const latestVersion = await this.getLatestNpmVersion(source.name);
             return latestVersion !== installedVersion;
         }
         catch {
-            // If we can't check registry, assume it's fine
             return false;
         }
     }
@@ -901,6 +1012,145 @@ export class DefaultPackageManager {
         const data = (await response.json());
         return data.version;
     }
+    async gitHasAvailableUpdate(installedPath) {
+        if (isOfflineModeEnabled()) {
+            return false;
+        }
+        try {
+            const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const remoteHead = await this.getRemoteGitHead(installedPath);
+            return localHead.trim() !== remoteHead.trim();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getRemoteGitHead(installedPath) {
+        const upstreamRef = await this.getGitUpstreamRef(installedPath);
+        if (upstreamRef) {
+            const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", upstreamRef]);
+            const match = remoteHead.match(/^([0-9a-f]{40})\s+/m);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", "HEAD"]);
+        const match = remoteHead.match(/^([0-9a-f]{40})\s+HEAD$/m);
+        if (!match?.[1]) {
+            throw new Error("Failed to determine remote HEAD");
+        }
+        return match[1];
+    }
+    async getLocalGitUpdateTarget(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmedUpstream = upstream.trim();
+            if (!trimmedUpstream.startsWith("origin/")) {
+                throw new Error(`Unsupported upstream remote: ${trimmedUpstream}`);
+            }
+            const branch = trimmedUpstream.slice("origin/".length);
+            if (!branch) {
+                throw new Error("Missing upstream branch name");
+            }
+            const head = await this.runCommandCapture("git", ["rev-parse", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            return {
+                ref: "@{upstream}",
+                head,
+                fetchArgs: [
+                    "fetch",
+                    "--prune",
+                    "--no-tags",
+                    "origin",
+                    `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                ],
+            };
+        }
+        catch {
+            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: installedPath }).catch(() => { });
+            const head = await this.runCommandCapture("git", ["rev-parse", "origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const originHeadRef = await this.runCommandCapture("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            }).catch(() => "");
+            const branch = originHeadRef.trim().replace(/^refs\/remotes\/origin\//, "");
+            if (branch) {
+                return {
+                    ref: "origin/HEAD",
+                    head,
+                    fetchArgs: [
+                        "fetch",
+                        "--prune",
+                        "--no-tags",
+                        "origin",
+                        `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                    ],
+                };
+            }
+            return {
+                ref: "origin/HEAD",
+                head,
+                fetchArgs: ["fetch", "--prune", "--no-tags", "origin", "+HEAD:refs/remotes/origin/HEAD"],
+            };
+        }
+    }
+    async getGitUpstreamRef(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmed = upstream.trim();
+            if (!trimmed.startsWith("origin/")) {
+                return undefined;
+            }
+            const branch = trimmed.slice("origin/".length);
+            return branch ? `refs/heads/${branch}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    runGitRemoteCommand(installedPath, args) {
+        return this.runCommandCapture("git", args, {
+            cwd: installedPath,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+            env: {
+                GIT_TERMINAL_PROMPT: "0",
+            },
+        });
+    }
+    async runWithConcurrency(tasks, limit) {
+        if (tasks.length === 0) {
+            return [];
+        }
+        const results = new Array(tasks.length);
+        let nextIndex = 0;
+        const workerCount = Math.max(1, Math.min(limit, tasks.length));
+        const worker = async () => {
+            while (true) {
+                const index = nextIndex;
+                nextIndex += 1;
+                if (index >= tasks.length) {
+                    return;
+                }
+                results[index] = await tasks[index]();
+            }
+        };
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        return results;
+    }
     /**
      * Get a unique identity for a package, ignoring version/ref.
      * Used to detect when the same package is in both global and project settings.
@@ -953,25 +1203,44 @@ export class DefaultPackageManager {
         const version = match[2];
         return { name, version };
     }
+    getNpmCommand() {
+        const configuredCommand = this.settingsManager.getNpmCommand();
+        if (!configuredCommand || configuredCommand.length === 0) {
+            return { command: "npm", args: [] };
+        }
+        const [command, ...args] = configuredCommand;
+        if (!command) {
+            throw new Error("Invalid npmCommand: first array entry must be a non-empty command");
+        }
+        return { command, args };
+    }
+    async runNpmCommand(args, options) {
+        const npmCommand = this.getNpmCommand();
+        await this.runCommand(npmCommand.command, [...npmCommand.args, ...args], options);
+    }
+    runNpmCommandSync(args) {
+        const npmCommand = this.getNpmCommand();
+        return this.runCommandSync(npmCommand.command, [...npmCommand.args, ...args]);
+    }
     async installNpm(source, scope, temporary) {
         if (scope === "user" && !temporary) {
-            await this.runCommand("npm", ["install", "-g", source.spec]);
+            await this.runNpmCommand(["install", "-g", source.spec]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, temporary);
         this.ensureNpmProject(installRoot);
-        await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
+        await this.runNpmCommand(["install", source.spec, "--prefix", installRoot]);
     }
     async uninstallNpm(source, scope) {
         if (scope === "user") {
-            await this.runCommand("npm", ["uninstall", "-g", source.name]);
+            await this.runNpmCommand(["uninstall", "-g", source.name]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, false);
         if (!existsSync(installRoot)) {
             return;
         }
-        await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
+        await this.runNpmCommand(["uninstall", source.name, "--prefix", installRoot]);
     }
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
@@ -989,7 +1258,7 @@ export class DefaultPackageManager {
         }
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(["install"], { cwd: targetDir });
         }
     }
     async updateGit(source, scope) {
@@ -998,21 +1267,26 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
-        // Fetch latest from remote (handles force-push by getting new history)
-        await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
-        // Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.
-        try {
-            await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
-        }
-        catch {
-            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir }).catch(() => { });
-            await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir });
+        const target = await this.getLocalGitUpdateTarget(targetDir);
+        // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
+        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
+        const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        if (localHead.trim() === refreshedTargetHead.trim()) {
+            return;
         }
+        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(["install"], { cwd: targetDir });
         }
     }
     async refreshTemporaryGitSource(source, sourceStr) {
@@ -1088,11 +1362,14 @@ export class DefaultPackageManager {
         return join(this.getGlobalNpmRoot(), "..");
     }
     getGlobalNpmRoot() {
-        if (this.globalNpmRoot) {
+        const npmCommand = this.getNpmCommand();
+        const commandKey = [npmCommand.command, ...npmCommand.args].join("\0");
+        if (this.globalNpmRoot && this.globalNpmRootCommandKey === commandKey) {
             return this.globalNpmRoot;
         }
-        const result = this.runCommandSync("npm", ["root", "-g"]);
+        const result = this.runNpmCommandSync(["root", "-g"]);
         this.globalNpmRoot = result.trim();
+        this.globalNpmRootCommandKey = commandKey;
         return this.globalNpmRoot;
     }
     getNpmInstallPath(source, scope) {
@@ -1141,21 +1418,21 @@ export class DefaultPackageManager {
     resolvePath(input) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(this.cwd, trimmed);
     }
     resolvePathFromBase(input, baseDir) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(baseDir, trimmed);
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
@@ -1329,7 +1606,7 @@ export class DefaultPackageManager {
             prompts: join(projectBaseDir, "prompts"),
             themes: join(projectBaseDir, "themes"),
         };
-        const userAgentsSkillsDir = join(homedir(), ".agents", "skills");
+        const userAgentsSkillsDir = join(getHomeDir(), ".agents", "skills");
         const projectAgentsSkillDirs = collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve(dir) !== resolve(userAgentsSkillsDir));
         const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
             const target = this.getTargetMap(accumulator, resourceType);
@@ -1414,11 +1691,54 @@ export class DefaultPackageManager {
             themes: toResolved(accumulator.themes),
         };
     }
+    runCommandCapture(command, args, options) {
+        return new Promise((resolvePromise, reject) => {
+            const child = spawn(command, args, {
+                cwd: options?.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: process.platform === "win32",
+                env: options?.env ? { ...process.env, ...options.env } : process.env,
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = typeof options?.timeoutMs === "number"
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, options.timeoutMs)
+                : undefined;
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            child.on("error", (error) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(error);
+            });
+            child.on("exit", (code) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                if (timedOut) {
+                    reject(new Error(`${command} ${args.join(" ")} timed out after ${options?.timeoutMs}ms`));
+                    return;
+                }
+                if (code === 0) {
+                    resolvePromise(stdout.trim());
+                    return;
+                }
+                reject(new Error(`${command} ${args.join(" ")} failed with code ${code}: ${stderr || stdout}`));
+            });
+        });
+    }
     runCommand(command, args, options) {
         return new Promise((resolvePromise, reject) => {
             const child = spawn(command, args, {
                 cwd: options?.cwd,
-                stdio: "inherit",
+                stdio: isStdoutTakenOver() ? ["ignore", 2, 2] : "inherit",
                 shell: process.platform === "win32",
             });
             child.on("error", reject);