@indigoai-us/hq-cli 5.345.33 → 5.345.35

package/dist/lib/mesh/live/daemon/install.d.ts

@@ -55,6 +55,8 @@ export interface InstallPaths {
      * host has no conhost (the task then runs node directly).
      */
     windowsHeadlessLauncher?: string;
+    /** Windows command processor used to execute the stable npm .cmd shim. */
+    windowsCommandProcessor?: string;
     /** When true, render the root/ec2-user system unit instead of user unit. */
     systemUser?: string;
     /** Verified HQ root to persist and pass to the installed service. */
@@ -102,7 +104,6 @@ export declare function restartDaemonServiceIfInstalled(opts?: {
     env?: NodeJS.ProcessEnv;
     existsSync?: typeof fs.existsSync;
     readFileSync?: typeof fs.readFileSync;
-    writeFileSync?: typeof fs.writeFileSync;
     run?: (command: string, args: string[]) => {
         status: number | null;
         stdout?: string;
@@ -119,7 +120,7 @@ export declare function detectPlatform(platform?: NodeJS.Platform): DaemonInstal
  * dies with MODULE_NOT_FOUND on the next restart. Prefer the live npm-global
  * binary when both exist.
  */
-export declare function preferStableHqBinary(entry: string): string;
+export declare function preferStableHqBinary(entry: string, platform?: DaemonInstallPlatform, existsSync?: typeof fs.existsSync): string;
 /**
  * Absolute path of the CLI entry that is executing this process.
  * realpath of argv[1] only — never a PATH lookup of `hq`.
@@ -153,7 +154,6 @@ export declare function installDaemonIfStale(opts: {
     run?: RunCommand;
     uid?: number;
     sleep?: SleepFn;
-    writeFileSync?: typeof fs.writeFileSync;
     mkdirSync?: typeof fs.mkdirSync;
     reloadSystemd?: () => {
         status: number | null;
@@ -193,6 +193,10 @@ export declare function buildInstallPaths(opts: {
     windowsUser?: string;
     /** Windows headless launcher override (tests); defaults to %SystemRoot%\System32\conhost.exe when present. */
     windowsHeadlessLauncher?: string | null;
+    /** Platform override for unit path and command rendering tests. */
+    platform?: DaemonInstallPlatform;
+    /** Filesystem seam for stable hq shim resolution tests. */
+    existsSync?: typeof fs.existsSync;
 }): InstallPaths;
 /** `DOMAIN\user` for the current account, as Task Scheduler expects. */
 export declare function resolveWindowsUser(env?: NodeJS.ProcessEnv): string;
@@ -277,7 +281,6 @@ export declare function installDaemonService(opts: {
     paths?: InstallPaths;
     /** When set, write the system unit template (does not sudo-install). */
     systemUser?: string;
-    writeFileSync?: typeof fs.writeFileSync;
     mkdirSync?: typeof fs.mkdirSync;
     /** Optional: actually load the service (disabled in tests). */
     activate?: (platform: DaemonInstallPlatform, dest: string) => void;

package/dist/lib/mesh/live/daemon/install.js

@@ -16,6 +16,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import semver from "semver";
+import { atomicWrite } from "../../../index-render/shared.js";
 import { resolveDaemonAssetDir } from "./log.js";
 import { LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, } from "./paths.js";
 import { isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, verifyHqRoot } from "./config.js";
@@ -123,17 +124,25 @@ function migrateLegacyDaemonUnit(opts) {
         // The rendered command only has to name a binary; install already resolved one.
     }
     if (platform === "darwin") {
-        opts.writeFileSync(unitPath, renderLaunchdPlist(paths), { mode: 0o600 });
+        replaceUnitFile(unitPath, renderLaunchdPlist(paths), 0o600, () => {
+            activateLaunchd(unitPath, asRunCommand(opts.run), opts.uid, { sleep: opts.sleep });
+        });
         return;
     }
     if (platform === "linux") {
-        opts.writeFileSync(unitPath, renderSystemdUserUnit(paths), { mode: 0o600 });
-        opts.run("systemctl", ["--user", "daemon-reload"]);
+        replaceUnitFile(unitPath, renderSystemdUserUnit(paths), 0o600, () => {
+            const result = opts.run("systemctl", ["--user", "daemon-reload"]);
+            if (result.status !== 0)
+                throw new Error("systemctl --user daemon-reload failed while repairing the mesh unit");
+        });
         return;
     }
     const rendered = renderWindowsTaskXml(paths);
-    opts.writeFileSync(unitPath, encodeWindowsTaskXml(rendered));
-    opts.run("schtasks.exe", ["/Create", "/TN", WINDOWS_TASK_NAME, "/XML", unitPath, "/F"]);
+    replaceUnitFile(unitPath, encodeWindowsTaskXml(rendered), 0o600, () => {
+        const result = opts.run("schtasks.exe", ["/Create", "/TN", WINDOWS_TASK_NAME, "/XML", unitPath, "/F"]);
+        if (result.status !== 0)
+            throw new Error("schtasks /Create failed while repairing the mesh unit");
+    });
 }
 /**
  * Restart the installed user daemon after a CLI upgrade. This is deliberately
@@ -155,7 +164,6 @@ export function restartDaemonServiceIfInstalled(opts = {}) {
     const home = opts.home ?? os.homedir();
     const existsSync = opts.existsSync ?? fs.existsSync;
     const readFileSync = opts.readFileSync ?? fs.readFileSync;
-    const writeFileSync = opts.writeFileSync ?? fs.writeFileSync;
     const run = opts.run ?? ((command, args) => {
         const result = spawnSync(command, args, { encoding: "utf8" });
         return {
@@ -165,7 +173,17 @@ export function restartDaemonServiceIfInstalled(opts = {}) {
         };
     });
     try {
-        migrateLegacyDaemonUnit({ platform, home, hqRoot: opts.hqRoot, env: opts.env, existsSync, readFileSync, writeFileSync, run });
+        migrateLegacyDaemonUnit({
+            platform,
+            home,
+            hqRoot: opts.hqRoot,
+            env: opts.env,
+            existsSync,
+            readFileSync,
+            run,
+            uid: opts.uid,
+            sleep: opts.sleep,
+        });
         if (platform === "darwin") {
             const plist = path.join(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
             if (!existsSync(plist))
@@ -239,14 +257,46 @@ export function detectPlatform(platform = process.platform) {
  * dies with MODULE_NOT_FOUND on the next restart. Prefer the live npm-global
  * binary when both exist.
  */
-export function preferStableHqBinary(entry) {
-    const stale = `${path.sep}toolchain${path.sep}node${path.sep}bin${path.sep}`;
-    const stable = `${path.sep}toolchain${path.sep}npm-global${path.sep}bin${path.sep}`;
-    if (!entry.includes(stale))
-        return entry;
-    const candidate = entry.replace(stale, stable);
-    if (candidate !== entry && fs.existsSync(candidate))
-        return path.resolve(candidate);
+export function preferStableHqBinary(entry, platform = detectPlatform(), existsSync = fs.existsSync) {
+    const api = platform === "win32" ? path.win32 : path;
+    const sep = api.sep;
+    const stale = `${sep}toolchain${sep}node${sep}bin${sep}`;
+    const stable = `${sep}toolchain${sep}npm-global${sep}bin${sep}`;
+    if (entry.includes(stale)) {
+        const candidate = entry.replace(stale, stable);
+        if (candidate !== entry && existsSync(candidate))
+            return api.resolve(candidate);
+    }
+    const normalized = entry.replace(/\\/g, "/");
+    const parts = normalized.split("/").filter(Boolean);
+    let packageAt = -1;
+    for (let i = 0; i < parts.length - 2; i += 1) {
+        if (parts[i]?.toLowerCase() === "node_modules"
+            && parts[i + 1]?.toLowerCase() === "@indigoai-us"
+            && parts[i + 2]?.toLowerCase() === "hq-cli") {
+            packageAt = i;
+            break;
+        }
+    }
+    if (packageAt >= 0) {
+        const prefixParts = parts.slice(0, packageAt);
+        let prefix;
+        if (platform === "win32") {
+            const root = path.win32.parse(entry).root;
+            const rootParts = root.replace(/\\+$/, "").split(/[\\/]+/).filter(Boolean);
+            prefix = path.win32.resolve(root, ...prefixParts.slice(rootParts.length));
+        }
+        else {
+            if (prefixParts.at(-1) === "lib")
+                prefixParts.pop();
+            prefix = path.posix.resolve(`/${prefixParts.join("/")}`);
+        }
+        const shim = platform === "win32"
+            ? path.win32.join(prefix, "hq.cmd")
+            : path.posix.join(prefix, "bin", "hq");
+        if (existsSync(shim))
+            return api.resolve(shim);
+    }
     return entry;
 }
 /**
@@ -346,7 +396,6 @@ export function installDaemonIfStale(opts) {
         platform,
         paths: opts.paths,
         systemUser: opts.systemUser,
-        writeFileSync: opts.writeFileSync,
         mkdirSync: opts.mkdirSync,
         reloadSystemd: opts.reloadSystemd,
         schtasks: opts.schtasks,
@@ -357,9 +406,6 @@ export function installDaemonIfStale(opts) {
         uid: opts.uid,
         sleep: opts.sleep,
     });
-    if (platform === "linux" && !opts.systemUser && !opts.paths.systemUser) {
-        activateSystemd(SYSTEMD_UNIT_NAME, run);
-    }
     return {
         reinstalled: true,
         message: `${installed.message} Restarted with ${opts.paths.nodeBinary} ${opts.paths.hqBinary}.`,
@@ -413,7 +459,8 @@ export function buildInstallPaths(opts) {
     const home = opts.home ?? os.homedir();
     const env = opts.env ?? process.env;
     const ddir = daemonDir(opts.meshRoot, home, env);
-    const hqBinary = opts.hqBinary ?? resolveHqBinary(opts.argv, env);
+    const platform = opts.platform ?? detectPlatform();
+    const hqBinary = preferStableHqBinary(opts.hqBinary ?? resolveHqBinary(opts.argv, env), platform, opts.existsSync ?? fs.existsSync);
     const nodeBinary = opts.nodeBinary ?? resolveNodeBinary(opts.execPath, env);
     return {
         home,
@@ -430,6 +477,7 @@ export function buildInstallPaths(opts) {
         windowsHeadlessLauncher: opts.windowsHeadlessLauncher === undefined
             ? resolveWindowsHeadlessLauncher(env)
             : (opts.windowsHeadlessLauncher ?? undefined),
+        windowsCommandProcessor: path.win32.join(env.SystemRoot ?? "C:\\Windows", "System32", "cmd.exe"),
         systemUser: opts.systemUser,
         hqRoot: opts.hqRoot,
         hqRootSource: opts.hqRootSource,
@@ -480,7 +528,12 @@ export function windowsLogonNotice(paths) {
 function describeWindowsLaunchMode(paths) {
     return windowsLaunchMode(paths) === "conhost-headless"
         ? `mode: conhost --headless via ${paths.windowsHeadlessLauncher}`
-        : "mode: direct node (conhost --headless unavailable on this host; a console window may appear at logon)";
+        : isWindowsCommandShim(paths.hqBinary)
+            ? "mode: direct command processor (conhost --headless unavailable on this host; a console window may appear at logon)"
+            : "mode: direct node (conhost --headless unavailable on this host; a console window may appear at logon)";
+}
+function isWindowsCommandShim(file) {
+    return path.win32.extname(file).toLowerCase() === ".cmd";
 }
 function safeUsername() {
     try {
@@ -601,13 +654,19 @@ WantedBy=multi-user.target
  */
 export function renderWindowsTaskXml(paths) {
     const user = escapeXml(paths.windowsUser);
-    const nodeArg = windowsArgQuote(paths.nodeBinary);
+    const stableShim = isWindowsCommandShim(paths.hqBinary);
     const hqArg = windowsArgQuote(paths.hqBinary);
-    const command = paths.windowsHeadlessLauncher ?? paths.nodeBinary;
+    const commandProcessor = paths.windowsCommandProcessor ?? path.win32.join("C:\\Windows", "System32", "cmd.exe");
+    const command = stableShim ? (paths.windowsHeadlessLauncher ?? commandProcessor) : (paths.windowsHeadlessLauncher ?? paths.nodeBinary);
     const rootArgs = paths.hqRoot ? ` --hq-root ${windowsArgQuote(paths.hqRoot)}` : "";
-    const args = paths.windowsHeadlessLauncher
-        ? `--headless ${nodeArg} ${hqArg} mesh daemon run${rootArgs}`
-        : `${hqArg} mesh daemon run${rootArgs}`;
+    const commandLine = `${hqArg} mesh daemon run${rootArgs}`;
+    const args = stableShim
+        ? paths.windowsHeadlessLauncher
+            ? `--headless ${windowsArgQuote(commandProcessor)} /d /s /c "${commandLine}"`
+            : `/d /s /c "${commandLine}"`
+        : paths.windowsHeadlessLauncher
+            ? `--headless ${windowsArgQuote(paths.nodeBinary)} ${hqArg} mesh daemon run${rootArgs}`
+            : `${hqArg} mesh daemon run${rootArgs}`;
     return `<?xml version="1.0" encoding="UTF-16"?>
 <Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <RegistrationInfo>
@@ -769,7 +828,7 @@ export function parseWindowsTaskHqRoot(xml) {
     if (quoted)
         return quoted[1].replace(/\\"/g, '"');
     const bare = /--hq-root (\S+)/.exec(args);
-    return bare ? bare[1] : null;
+    return bare ? bare[1].replace(/"+$/, "") : null;
 }
 /**
  * The HQ root the installed Windows task actually carries: the task XML on
@@ -812,11 +871,40 @@ function shellQuote(value) {
         return value;
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function replaceUnitFile(file, content, mode, reload) {
+    let previous = null;
+    let previousMode = mode;
+    try {
+        previous = fs.readFileSync(file);
+        previousMode = fs.statSync(file).mode & 0o777;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    try {
+        atomicWrite(file, content, { mode });
+        reload?.();
+    }
+    catch (error) {
+        try {
+            if (previous) {
+                atomicWrite(file, previous, { mode: previousMode });
+            }
+            else {
+                fs.rmSync(file, { force: true });
+            }
+        }
+        catch (rollbackError) {
+            throw new AggregateError([error, rollbackError], `Unit replacement and rollback failed: ${file}`);
+        }
+        throw error;
+    }
+}
 export function installDaemonService(opts) {
     const platform = opts.platform ?? detectPlatform();
     const paths = opts.paths ??
         buildInstallPaths({ systemUser: opts.systemUser });
-    const writeFileSync = opts.writeFileSync ?? fs.writeFileSync;
     const mkdirSync = opts.mkdirSync ?? fs.mkdirSync;
     mkdirSync(paths.daemonDir, { recursive: true, mode: 0o700 });
     registerTrustedHqRoot(paths.daemonDir, paths.hqRoot);
@@ -832,13 +920,12 @@ export function installDaemonService(opts) {
     if (platform === "darwin") {
         const rendered = renderLaunchdPlist(paths);
         mkdirSync(paths.launchAgentsDir, { recursive: true });
-        writeFileSync(paths.plistPath, rendered, { mode: 0o600 });
-        if (opts.run) {
-            activateLaunchd(paths.plistPath, opts.run, opts.uid, { sleep: opts.sleep });
-        }
-        else {
-            opts.activate?.(platform, paths.plistPath);
-        }
+        replaceUnitFile(paths.plistPath, rendered, 0o600, () => {
+            if (opts.run)
+                activateLaunchd(paths.plistPath, opts.run, opts.uid, { sleep: opts.sleep });
+            else
+                opts.activate?.(platform, paths.plistPath);
+        });
         return {
             platform,
             action: "install",
@@ -856,7 +943,7 @@ export function installDaemonService(opts) {
             });
             // Write under daemon dir as a template the operator can sudo-install.
             const dest = path.join(paths.daemonDir, SYSTEMD_UNIT_NAME);
-            writeFileSync(dest, rendered, { mode: 0o644 });
+            replaceUnitFile(dest, rendered, 0o644);
             return {
                 platform,
                 action: "install",
@@ -870,9 +957,18 @@ export function installDaemonService(opts) {
         }
         const rendered = renderSystemdUserUnit(paths);
         mkdirSync(paths.systemdUserDir, { recursive: true });
-        writeFileSync(paths.systemdUnitPath, rendered, { mode: 0o600 });
-        (opts.reloadSystemd ?? (() => spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" })))();
-        opts.activate?.(platform, paths.systemdUnitPath);
+        replaceUnitFile(paths.systemdUnitPath, rendered, 0o600, () => {
+            const result = (opts.reloadSystemd ?? (() => {
+                const reload = spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+                return { status: reload.status };
+            }))();
+            if (result.status !== 0)
+                throw new Error("systemctl --user daemon-reload failed while installing the mesh unit");
+            if (opts.run)
+                activateSystemd(SYSTEMD_UNIT_NAME, opts.run);
+            else
+                opts.activate?.(platform, paths.systemdUnitPath);
+        });
         return {
             platform,
             action: "install",
@@ -885,14 +981,15 @@ export function installDaemonService(opts) {
     if (platform === "win32") {
         const schtasks = opts.schtasks ?? defaultSchtasks;
         const rendered = renderWindowsTaskXml(paths);
-        writeFileSync(paths.windowsTaskXmlPath, encodeWindowsTaskXml(rendered), { mode: 0o600 });
-        const created = schtasks([
-            "/Create", "/TN", WINDOWS_TASK_NAME, "/XML", paths.windowsTaskXmlPath, "/F",
-        ]);
-        if (created.status !== 0) {
-            throw new Error(`schtasks /Create failed for ${WINDOWS_TASK_NAME} (exit ${created.status ?? "signal"}): ` +
-                `${(created.stderr || created.stdout).trim()}`);
-        }
+        replaceUnitFile(paths.windowsTaskXmlPath, encodeWindowsTaskXml(rendered), 0o600, () => {
+            const created = schtasks([
+                "/Create", "/TN", WINDOWS_TASK_NAME, "/XML", paths.windowsTaskXmlPath, "/F",
+            ]);
+            if (created.status !== 0) {
+                throw new Error(`schtasks /Create failed for ${WINDOWS_TASK_NAME} (exit ${created.status ?? "signal"}): ` +
+                    `${(created.stderr || created.stdout).trim()}`);
+            }
+        });
         // /F replaced any previous registration without ending its instance; stop
         // the recorded daemon so the fresh task instance can take the pid lock.
         schtasks(["/End", "/TN", WINDOWS_TASK_NAME]);

package/dist/utils/self-update.d.ts

@@ -58,7 +58,7 @@
  */
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
-import { type RunningInstall, type UpdateResult } from "./version-gate.js";
+import { probePnpmVersion, type RunningInstall, type UpdateResult } from "./version-gate.js";
 import { type RestartDaemonResult } from "../lib/mesh/live/daemon/install.js";
 /**
  * Set on the re-exec'd child so it can never self-update (and re-exec) again.
@@ -116,7 +116,7 @@ export declare function buildSelfUpdatePlan(install: RunningInstall): {
  * to stdout. Progress is summarised on stderr by the caller instead; captured
  * stderr is kept only to explain a failure.
  */
-export declare function runUpdateQuiet(cmd: string, args: string[], env?: NodeJS.ProcessEnv): UpdateResult;
+export declare function runUpdateQuiet(cmd: string, args: string[], env?: NodeJS.ProcessEnv, cwd?: string): UpdateResult;
 /**
  * Serialize self-updates across concurrent `hq` processes AND the hq-sync
  * menubar app. Without this, a machine running several HQ agents can fire many
@@ -144,7 +144,8 @@ export interface SelfUpdateDeps {
     homeDir?: string;
     /** Same-filesystem install rename, injectable for rollback tests. */
     renamePath?: typeof fs.renameSync;
-    runner?: (cmd: string, args: string[], env?: NodeJS.ProcessEnv) => UpdateResult;
+    runner?: (cmd: string, args: string[], env?: NodeJS.ProcessEnv, cwd?: string) => UpdateResult;
+    probePnpmVersion?: typeof probePnpmVersion;
     /** Delay between bounded npm retries when the just-published target is not visible yet. */
     sleep?: (ms: number) => Promise<void>;
     reexec?: (argv: string[], env: NodeJS.ProcessEnv) => number | null;

package/dist/utils/self-update.js

@@ -65,7 +65,7 @@ import chalk from "chalk";
 import { Sentry } from "../sentry.js";
 import { isCliTelemetryDisabled } from "./cli-telemetry.js";
 import { CLI_NAME, CLI_VERSION } from "../cli-version.js";
-import { buildBunInstallArgv, buildPnpmInstallArgv, buildPrefixedInstallArgv, buildSpawnPlan, canWriteNpmInstall, captureNonWritableNpmPrefixNotice, claimNonWritableNpmPrefixNotice, checkUpdateConvergence, derivePnpmHome, detachUpdateSupervisor, isBunManagedPackageDir, isLocalDependencyInstall, isPnpmManagedPackageDir, nonWritablePrefixNote, openInstallOutput, pnpmUpdateEnv, resolveRunningInstall, runUpdateCommand, runSupervisedUpdateCommand, UPDATE_RECURSION_GUARD_ENV, } from "./version-gate.js";
+import { buildBunInstallArgv, buildPnpmInstallArgv, buildPrefixedInstallArgv, buildSpawnPlan, canWriteNpmInstall, captureNonWritableNpmPrefixNotice, claimNonWritableNpmPrefixNotice, checkUpdateConvergence, derivePnpmHome, detachUpdateSupervisor, isBunManagedPackageDir, isLocalDependencyInstall, isPnpmManagedPackageDir, nonWritablePrefixNote, openInstallOutput, pnpmUpdateEnv, pnpmInstalledVersion, performPnpmUpdate, resolveRunningInstall, runUpdateCommand, runSupervisedUpdateCommand, UPDATE_RECURSION_GUARD_ENV, } from "./version-gate.js";
 import { canStageInstall, stagedNpmInstall } from "./staged-install.js";
 import { acquireUpdateLock as acquireSharedUpdateLock } from "./update-lock.js";
 import { markLatestIneffective } from "./version-check.js";
@@ -548,8 +548,12 @@ async function fetchLatestVersion() {
  * through the resolved prefix so the copy that is actually running is replaced.
  */
 export function buildSelfUpdatePlan(install) {
-    if (install.manager === "pnpm")
-        return { cmd: "pnpm", args: buildPnpmInstallArgv(install) };
+    if (install.manager === "pnpm") {
+        const version = pnpmInstalledVersion(install);
+        return version
+            ? { cmd: "corepack", args: [`pnpm@${version}`, ...buildPnpmInstallArgv(install)] }
+            : { cmd: "pnpm", args: buildPnpmInstallArgv(install) };
+    }
     if (install.manager === "bun")
         return { cmd: "bun", args: buildBunInstallArgv() };
     if (install.prefix)
@@ -563,12 +567,12 @@ export function buildSelfUpdatePlan(install) {
  * to stdout. Progress is summarised on stderr by the caller instead; captured
  * stderr is kept only to explain a failure.
  */
-export function runUpdateQuiet(cmd, args, env) {
+export function runUpdateQuiet(cmd, args, env, cwd) {
     // File sinks rather than pipes: a pipe dies with this process and would take
     // the installer down with it mid-write. See `openInstallOutput`.
     const output = openInstallOutput(false);
     try {
-        return runSupervisedUpdateCommand(cmd, args, output, env);
+        return runSupervisedUpdateCommand(cmd, args, output, env, cwd);
     }
     finally {
         output.dispose();
@@ -826,6 +830,9 @@ async function updateAndReexec(argv, flavor, known, deps) {
             if (staged) {
                 return stagedNpmInstall(install, latestValid, { run: runner, env, rename: renamePath });
             }
+            if (install.manager === "pnpm") {
+                return performPnpmUpdate(install, runner, updateEnv ?? env, deps.probePnpmVersion);
+            }
             return updateEnv === undefined
                 ? runner(plan.cmd, plan.args)
                 : runner(plan.cmd, plan.args, updateEnv);

package/dist/utils/version-gate.d.ts

@@ -229,9 +229,19 @@ export declare function buildPnpmInstallArgv(install?: RunningInstall): string[]
  * forward the paths recorded for the install it is replacing.
  */
 export declare function pnpmInstallDirs(install: RunningInstall): {
+    globalDir: string;
     storeDir: string;
     virtualStoreDir: string;
 } | null;
+/** Version recorded by pnpm for the global install that owns this package. */
+export declare function pnpmInstalledVersion(install: RunningInstall): string | null;
+/**
+ * Resolve a bounded pnpm executable probe. pnpm 10 and older reject
+ * --virtual-store-dir for global installs; pnpm 11+ accepts the flag.
+ */
+export declare function probePnpmVersion(cmd: string, args: string[], env: NodeJS.ProcessEnv, cwd: string): string | null;
+/** Run the install-owned pnpm first; use PATH only if that version cannot run. */
+export declare function performPnpmUpdate(install: RunningInstall, runner?: UpdateRunner, env?: NodeJS.ProcessEnv, probe?: typeof probePnpmVersion): UpdateResult;
 /** Argv for updating a Bun-managed global install. */
 export declare function buildBunInstallArgv(): string[];
 /**
@@ -278,11 +288,12 @@ export type UpdateResult = {
     ok: boolean;
     detail?: string;
     code?: string;
+    stdout?: string;
     /** Sanitized installer error code for diagnostics; never drives retry or exit behavior. */
     diagnosticCode?: string;
     failureKind?: "package_manager_exit";
 };
-type UpdateRunner = (cmd: string, args: string[], env?: NodeJS.ProcessEnv) => UpdateResult;
+type UpdateRunner = (cmd: string, args: string[], env?: NodeJS.ProcessEnv, cwd?: string) => UpdateResult;
 export { buildSpawnPlan, quoteForWindowsShell };
 /**
  * Add `detached` to a **synchronous** spawn's options.
@@ -366,9 +377,9 @@ export interface InstallOutput {
     dispose: () => void;
 }
 export declare function openInstallOutput(verbose: boolean, isTty?: boolean): InstallOutput;
-export declare function runSupervisedUpdateCommand(cmd: string, args: string[], output: InstallOutput, env?: NodeJS.ProcessEnv): UpdateResult;
-export declare function runUpdateCommand(cmd: string, args: string[], env?: NodeJS.ProcessEnv): UpdateResult;
-declare function performUpdateCommand(cmd: string, args: string[], runner?: UpdateRunner, env?: NodeJS.ProcessEnv): UpdateResult;
+export declare function runSupervisedUpdateCommand(cmd: string, args: string[], output: InstallOutput, env?: NodeJS.ProcessEnv, cwd?: string): UpdateResult;
+export declare function runUpdateCommand(cmd: string, args: string[], env?: NodeJS.ProcessEnv, cwd?: string): UpdateResult;
+declare function performUpdateCommand(cmd: string, args: string[], runner?: UpdateRunner, env?: NodeJS.ProcessEnv, cwd?: string): UpdateResult;
 declare function performUpdate(command: string, runner?: UpdateRunner): UpdateResult;
 /**
  * Soft notify when the server says we're below `latestVersion` but still ≥
@@ -434,6 +445,7 @@ export declare function checkUpdateConvergence(targetVersion: string, deps?: {
 /** Injectable surface for {@link enforceUpdateRequired} (unit tests). */
 interface EnforceUpdateDeps {
     performUpdateString?: (command: string) => UpdateResult;
+    probePnpmVersion?: typeof probePnpmVersion;
     resolveInstall?: () => RunningInstall;
     canWriteNpmInstall?: (install: RunningInstall) => boolean;
     homeDir?: string;
@@ -518,6 +530,10 @@ export declare const __test__: {
     enforceUpdateRequired: typeof enforceUpdateRequired;
     isBunManagedPackageDir: typeof isBunManagedPackageDir;
     pnpmUpdateEnv: typeof pnpmUpdateEnv;
+    pnpmInstallDirs: typeof pnpmInstallDirs;
+    pnpmInstalledVersion: typeof pnpmInstalledVersion;
+    performPnpmUpdate: typeof performPnpmUpdate;
+    probePnpmVersion: typeof probePnpmVersion;
     isLocalDependencyInstall: typeof isLocalDependencyInstall;
     isLocalDependencyPackageDir: typeof isLocalDependencyPackageDir;
     isNewerVersion: typeof isNewerVersion;