fraim 2.0.360 → 2.0.361-next.0

package/dist/src/cli/utils/agent-command-probe.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentProbeFailureMessage = agentProbeFailureMessage;
+exports.agentProbeEnvironment = agentProbeEnvironment;
+exports.agentProbeEnvironmentAsync = agentProbeEnvironmentAsync;
+exports.commandInvocation = commandInvocation;
+exports.selectAgentCommandSync = selectAgentCommandSync;
+exports.selectAgentCommand = selectAgentCommand;
+exports.captureAgentCommand = captureAgentCommand;
+exports.probeAgentProcess = probeAgentProcess;
+const operation_scope_1 = require("./operation-scope");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const background_command_1 = require("./background-command");
+const command_resolution_1 = require("../mcp/command-resolution");
+const managed_agent_paths_1 = require("./managed-agent-paths");
+const win32_cmd_spawn_1 = require("./win32-cmd-spawn");
+function agentProbeFailureMessage(reason) {
+    switch (reason) {
+        case 'access-denied': return 'Windows denied access to the agent launcher. Check installation permissions or use an accessible installation.';
+        case 'policy-blocked': return 'A system policy blocked the agent launcher. Ask your administrator to allow the selected installation.';
+        case 'unsupported-launcher': return 'No supported agent launcher was found. Install the Windows executable or CMD launcher.';
+        case 'timeout': return 'The agent version check timed out. Retry Check; the installation has not been proven broken.';
+        case 'cancelled': return 'The agent check was cancelled. Retry Check.';
+        case 'output-limit': return 'The agent launcher exceeded the output limit. Inspect the installation before retrying.';
+        case 'exit': return 'The agent launcher failed with a nonzero exit. Inspect or repair the installation, then check again.';
+        case 'no-version': return 'The agent launcher returned no version. Inspect its installation and dependencies, then check again.';
+        case 'spawn': return 'The agent launcher could not start. Check its executable and dependencies.';
+        case 'cleanup-failed': return 'The agent check could not terminate its process. Close that process before retrying.';
+        default: return 'No working agent installation was found. Install the agent and check again.';
+    }
+}
+function agentProbeEnvironment(basePath, env = process.env) {
+    const recovered = (0, managed_agent_paths_1.buildRecoveredAgentPath)(basePath ?? env.PATH ?? env.Path);
+    return { ...env, PATH: recovered, Path: recovered };
+}
+async function agentProbeEnvironmentAsync(basePath, env = process.env, options = {}) {
+    const recovered = await (0, managed_agent_paths_1.buildRecoveredAgentPathAsync)(basePath ?? env.PATH ?? env.Path, options);
+    return { ...env, PATH: recovered, Path: recovered };
+}
+function commandInvocation(target, args, env = process.env) {
+    if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(target)) {
+        const invocation = (0, win32_cmd_spawn_1.buildCmdExeArgs)(target, args);
+        return { command: env.ComSpec || env.COMSPEC || invocation.command, args: invocation.args, windowsVerbatimArguments: true };
+    }
+    return { command: target, args, windowsVerbatimArguments: false };
+}
+function candidates(command, env, onFailure) {
+    const possible = (0, command_resolution_1.getSystemCommandCandidates)(command, env.PATH ?? env.Path, env.PATHEXT);
+    if (process.platform === 'win32' && !path_1.default.isAbsolute(command) && !command.includes('.')) {
+        possible.push(...(0, command_resolution_1.getSystemCommandCandidates)(command + '.ps1', env.PATH ?? env.Path));
+    }
+    return [...new Set(possible)].filter(target => {
+        try {
+            if (!fs_1.default.statSync(target).isFile())
+                return false;
+            if (process.platform === 'win32' && !/\.(exe|com|cmd|bat)$/i.test(target)) {
+                onFailure?.('unsupported-launcher');
+                return false;
+            }
+            fs_1.default.accessSync(target, process.platform === 'win32' ? fs_1.default.constants.R_OK : fs_1.default.constants.X_OK);
+            return true;
+        }
+        catch (error) {
+            if (['EACCES', 'EPERM'].includes(error.code || ''))
+                onFailure?.('access-denied');
+            return false;
+        }
+    });
+}
+function selection(target, version, options) {
+    const env = options.env || agentProbeEnvironment();
+    const relative = path_1.default.relative((0, managed_agent_paths_1.getPortableNodeBinPath)(), target);
+    return { target, version, env, cwd: options.cwd,
+        source: relative && !relative.startsWith('..') && !path_1.default.isAbsolute(relative) ? 'managed' : 'system' };
+}
+/** Synchronous compatibility for CLI callers. Server discovery/launch use the async selector. */
+function selectAgentCommandSync(command, options = {}) {
+    const env = options.env || agentProbeEnvironment();
+    const deadline = Date.now() + (options.totalTimeoutMs ?? 30000);
+    for (const target of candidates(command, env, options.onFailure)) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0 || options.signal?.aborted)
+            break;
+        const invocation = commandInvocation(target, ['--version'], env);
+        const result = (0, child_process_1.spawnSync)(invocation.command, invocation.args, {
+            env, cwd: options.cwd, windowsHide: true, windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+            encoding: 'utf8', timeout: Math.min(options.timeoutMs ?? 10000, remaining), maxBuffer: 65536,
+        });
+        const version = result.status === 0 && !result.error ? (0, managed_agent_paths_1.versionFromProbeOutput)(result.stdout, result.stderr) : null;
+        if (version)
+            return selection(target, version, { ...options, env });
+    }
+    return null;
+}
+async function selectAgentCommand(command, options = {}) {
+    try {
+        return await (0, operation_scope_1.withOperation)({ signal: options.signal, timeoutMs: options.totalTimeoutMs }, 30000, async (signal) => {
+            const env = options.env || await agentProbeEnvironmentAsync(undefined, process.env, { signal });
+            for (const target of candidates(command, env, options.onFailure)) {
+                signal.throwIfAborted();
+                const version = await probeTarget(target, { ...options, env, signal, timeoutMs: options.timeoutMs ?? 10000 });
+                signal.throwIfAborted();
+                if (version)
+                    return selection(target, version, { ...options, env });
+            }
+            return null;
+        });
+    }
+    catch (error) {
+        if (options.signal?.aborted || /deadline|abort|cancel/i.test(error instanceof Error ? error.message : String(error))) {
+            options.onFailure?.(options.signal?.aborted ? 'cancelled' : 'timeout');
+            return null;
+        }
+        throw error;
+    }
+}
+function captureAgentCommand(target, args, options) {
+    return probeTarget(target, options, args, true);
+}
+async function probeAgentProcess(target, args, options) {
+    const invocation = commandInvocation(target, args, options.env);
+    return (0, background_command_1.runBackgroundCommand)(invocation.command, invocation.args, { ...options,
+        timeoutMs: options.timeoutMs ?? 10000, maxOutputBytes: 65536,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments });
+}
+async function probeTarget(target, options, args = ['--version'], raw = false) {
+    const result = await probeAgentProcess(target, args, options);
+    if (result.outcome === 'cleanup-failed')
+        throw new Error('Agent probe cleanup failed; refusing another launch');
+    if (result.error || result.status !== 0) {
+        const diagnostic = `${result.stderr}\n${result.error?.message || ''}`;
+        const reason = result.outcome === 'cancelled' ? 'cancelled' : result.outcome === 'timeout' ? 'timeout'
+            : result.outcome === 'output-limit' ? 'output-limit' : result.error ? 'spawn' : 'exit';
+        const classified = /access is denied|permission denied|EACCES|EPERM/i.test(diagnostic) ? 'access-denied'
+            : /blocked by (?:group|system) policy|execution of scripts is disabled/i.test(diagnostic) ? 'policy-blocked' : reason;
+        options.onFailure?.(classified, result.status);
+        return null;
+    }
+    const answer = raw ? result.stdout : (0, managed_agent_paths_1.versionFromProbeOutput)(result.stdout, result.stderr);
+    if (!raw && !answer)
+        options.onFailure?.('no-version', result.status);
+    return answer;
+}

package/dist/src/cli/utils/background-command.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killBackgroundProcessTree = killBackgroundProcessTree;
+exports.terminateOwnedChild = terminateOwnedChild;
+exports.runBackgroundCommand = runBackgroundCommand;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+function killBackgroundProcessTree(pid, signal = 'SIGTERM', callback = () => undefined) {
+    if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) {
+        callback(new Error('Refusing invalid or current process termination'));
+        return;
+    }
+    if (process.platform === 'win32') {
+        (0, child_process_1.execFile)(path_1.default.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'taskkill.exe'), ['/PID', String(pid), '/T', '/F'], { windowsHide: true, timeout: 5000 }, callback);
+    }
+    else
+        (0, tree_kill_1.default)(pid, signal, callback);
+}
+/** Wait for both tree termination and pipe closure, with a finite cleanup ceiling. */
+function terminateOwnedChild(child, cleanupMs = 5000) {
+    if (!child.pid)
+        return Promise.resolve(true);
+    return new Promise(resolve => {
+        let closed = false, killed = false, failed = false, finished = false;
+        const finish = (success) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            child.removeListener('close', onClose);
+            resolve(success);
+        };
+        const check = () => { if (closed && killed)
+            finish(!failed); };
+        const onClose = () => { closed = true; check(); };
+        const timer = setTimeout(() => {
+            // Never interpret an unconfirmed cleanup as permission to start another process.
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* report the failed cleanup below */ }
+            finish(false);
+        }, cleanupMs);
+        child.once('close', onClose);
+        killBackgroundProcessTree(child.pid, 'SIGKILL', error => {
+            killed = true;
+            failed = Boolean(error && !closed && child.exitCode === null);
+            check();
+        });
+    });
+}
+/** Own a captured child until close and tree cleanup have both completed. */
+function runBackgroundCommand(command, args, options = {}) {
+    if (options.signal?.aborted)
+        return Promise.resolve({ status: null, stdout: '', stderr: '', outcome: 'cancelled', error: new Error('Command cancelled') });
+    return new Promise(resolve => {
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(command, args, { env: options.env ?? process.env, cwd: options.cwd,
+                windowsHide: true, windowsVerbatimArguments: options.windowsVerbatimArguments, stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (failure) {
+            resolve({ status: null, stdout: '', stderr: '', outcome: 'spawn-error', error: failure });
+            return;
+        }
+        let stdout = '', stderr = '', bytes = 0;
+        let error, outcome;
+        let termination;
+        let finished = false;
+        const finish = (status, childSignal) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', abort);
+            resolve({ status: error ? null : status, stdout, stderr, error,
+                outcome: outcome ?? (status === 0 ? 'success' : childSignal ? 'terminated' : 'nonzero-exit') });
+        };
+        const terminate = (reason) => {
+            if (termination)
+                return;
+            outcome = reason;
+            error = new Error(reason === 'timeout' ? 'Background command exceeded its deadline' : `Command ${reason}`);
+            if (!child.pid)
+                return;
+            termination = terminateOwnedChild(child).then(cleaned => {
+                if (!cleaned) {
+                    outcome = 'cleanup-failed';
+                    error = new Error('Command tree cleanup failed');
+                    finish(null);
+                }
+            });
+        };
+        const abort = () => terminate('cancelled');
+        const timer = setTimeout(() => terminate('timeout'), options.timeoutMs ?? 15000);
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        const capture = (chunk, channel) => {
+            bytes += chunk.length;
+            if (bytes > (options.maxOutputBytes ?? 1024 * 1024)) {
+                terminate('output-limit');
+                return;
+            }
+            if (channel === 'stdout')
+                stdout += chunk.toString();
+            else
+                stderr += chunk.toString();
+        };
+        child.stdout?.on('data', chunk => capture(chunk, 'stdout'));
+        child.stderr?.on('data', chunk => capture(chunk, 'stderr'));
+        child.once('error', failure => { error = failure; outcome = 'spawn-error'; });
+        child.once('close', async (status, signal) => {
+            await termination;
+            finish(status, signal);
+        });
+    });
+}

package/dist/src/cli/utils/machine-path.js

@@ -7,6 +7,7 @@ exports.parseRegQueryPathValue = parseRegQueryPathValue;
 exports.expandWindowsEnvRefs = expandWindowsEnvRefs;
 exports.composeMachinePath = composeMachinePath;
 exports.resolveMachinePathCached = resolveMachinePathCached;
+exports.resolveMachinePathCachedAsync = resolveMachinePathCachedAsync;
 exports.clearMachinePathCache = clearMachinePathCache;
 exports.setMachinePathResolver = setMachinePathResolver;
 exports.readWindowsEnvVarScopes = readWindowsEnvVarScopes;
@@ -161,7 +162,33 @@ function resolveMachinePathCached(nowMs = Date.now()) {
     cachedMachinePathAtMs = nowMs;
     return cachedMachinePath;
 }
+/** Populate the shared recovery cache without blocking the Hub event loop on registry reads. */
+let machinePathGeneration = 0;
+async function resolveMachinePathCachedAsync(signal) {
+    signal?.throwIfAborted();
+    if (cachedMachinePath !== undefined && Date.now() - cachedMachinePathAtMs < MACHINE_PATH_CACHE_TTL_MS)
+        return cachedMachinePath;
+    if (machinePathResolverOverride || process.platform !== 'win32' || process.env.FRAIM_TEST_SANDBOX === '1')
+        return resolveMachinePathCached();
+    const generation = machinePathGeneration;
+    const { captureAgentCommand } = require('./agent-command-probe');
+    const results = await Promise.allSettled(WINDOWS_PATH_REGISTRY_KEYS.map(async ([key, value]) => {
+        const output = await captureAgentCommand(resolveRegExePath(), ['query', key, '/v', value], { env: { ...process.env }, signal, timeoutMs: MACHINE_PATH_TIMEOUT_MS });
+        return output === null ? null : parseRegQueryPathValue(output);
+    }));
+    signal?.throwIfAborted();
+    for (const result of results)
+        if (result.status === 'rejected')
+            throw result.reason;
+    const value = composeMachinePath(results.map(result => result.value));
+    if (generation === machinePathGeneration) {
+        cachedMachinePath = value;
+        cachedMachinePathAtMs = Date.now();
+    }
+    return value;
+}
 function clearMachinePathCache() {
+    machinePathGeneration++;
     cachedMachinePath = undefined;
     cachedMachinePathAtMs = 0;
 }

package/dist/src/cli/utils/managed-agent-install.js

@@ -3,11 +3,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyInstalledAgentCommand = verifyInstalledAgentCommand;
+exports.runAgentInstallCommand = runAgentInstallCommand;
 exports.installManagedAgent = installManagedAgent;
 const fs_1 = __importDefault(require("fs"));
+const agent_command_probe_1 = require("./agent-command-probe");
+const background_command_1 = require("./background-command");
 const persist_shell_path_1 = require("./persist-shell-path");
 const path_1 = __importDefault(require("path"));
+const command_resolution_1 = require("../mcp/command-resolution");
 const managed_agent_paths_1 = require("./managed-agent-paths");
+/** Verify the exact installed target without blocking cancellation or recovering another launcher. */
+async function verifyInstalledAgentCommand(command, _extraBinDirs, basePath, options = {}) {
+    const env = { ...process.env, PATH: basePath ?? process.env.PATH, Path: basePath ?? process.env.Path };
+    const selected = await (0, agent_command_probe_1.selectAgentCommand)(command, { env, signal: options.signal, totalTimeoutMs: options.timeoutMs });
+    options.signal?.throwIfAborted();
+    return selected?.version ?? null;
+}
+async function runAgentInstallCommand(command, args, env, options = {}) {
+    const childEnv = { ...process.env };
+    for (const [key, value] of Object.entries(env || {})) {
+        if (value === undefined)
+            delete childEnv[key];
+        else
+            childEnv[key] = value;
+    }
+    const target = (0, command_resolution_1.getSystemCommandPath)(command, childEnv.PATH || childEnv.Path) || command;
+    const invocation = (0, agent_command_probe_1.commandInvocation)(target, args, childEnv);
+    const result = await (0, background_command_1.runBackgroundCommand)(invocation.command, invocation.args, {
+        ...options, env: childEnv, timeoutMs: options.timeoutMs ?? 90000, maxOutputBytes: 65536,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+    });
+    options.signal?.throwIfAborted();
+    if (result.error || result.status !== 0)
+        throw Object.assign(result.error || new Error('Agent installation command failed'), {
+            code: result.outcome === 'cleanup-failed' ? result.outcome : /\bEEXIST\b/.test(result.stderr) ? 'EEXIST' : result.outcome,
+            stderr: result.stderr,
+        });
+    return { stdout: result.stdout, stderr: result.stderr };
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : 'Unknown error';
 }
@@ -66,7 +100,9 @@ function cleanupManagedInstallArtifacts(option, prefix) {
     }
     const removed = [];
     for (const candidate of candidates) {
-        if (!isInsideDirectory(resolvedPrefix, candidate) || !fs_1.default.existsSync(candidate))
+        if (!isInsideDirectory(resolvedPrefix, candidate) || !fs_1.default.existsSync(candidate)
+            || !(0, managed_agent_paths_1.isOwnedManagedAgentTarget)(candidate)
+            || !isInsideDirectory(fs_1.default.realpathSync(resolvedPrefix), fs_1.default.realpathSync(candidate)))
             continue;
         fs_1.default.rmSync(candidate, { recursive: true, force: true });
         removed.push(candidate);
@@ -79,6 +115,7 @@ async function runInstallWithStaleCleanupRetry(option, prefix, runInstall) {
         return;
     }
     catch (error) {
+        option.signal?.throwIfAborted();
         if (!isStaleNpmInstallError(error))
             throw error;
         const removed = cleanupManagedInstallArtifacts(option, prefix);
@@ -104,50 +141,52 @@ async function runInstallWithStaleCleanupRetry(option, prefix, runInstall) {
 // lives in one place. Callers are responsible for the "already installed"
 // check before invoking this — it only covers the install-then-fallback path.
 async function installManagedAgent(option, systemPath, deps) {
+    option.signal?.throwIfAborted();
     let standardInstallError = null;
     const portableBin = (0, managed_agent_paths_1.getPortableNodeBinPath)();
-    // npm writes Windows shims at the prefix root, but POSIX executables in prefix/bin.
     const prefix = process.platform === 'win32' ? portableBin : path_1.default.dirname(portableBin);
-    try {
-        await deps.runProcess('npm', ['install', '-g', option.installPackage], {
-            PATH: systemPath,
-            npm_config_prefix: undefined,
-            NPM_CONFIG_PREFIX: undefined,
-        });
-        const standardVersion = deps.commandVersion(option.launchCommand, undefined, systemPath);
-        // Only look up npm global bin dirs when the CLI was NOT already runnable: that lookup
-        // is a blocking npm-prefix subprocess, and on the success path there is nothing to find.
-        // (Commit 16cea56ac made this unconditional so the caller could persist the directory onto
-        // process.env.PATH; issue #1748 removed that in-process PATH write, so the unconditional
-        // lookup has no consumer and only costs the happy path a blocking subprocess.)
-        const npmGlobalBinDirs = standardVersion
-            ? []
-            : (0, managed_agent_paths_1.resolveNpmGlobalBinDirs)(systemPath, {
-                npm_config_prefix: undefined,
-                NPM_CONFIG_PREFIX: undefined,
-            });
-        const standardVersionWithNpmBin = standardVersion
-            || (npmGlobalBinDirs.length > 0
-                ? deps.commandVersion(option.launchCommand, npmGlobalBinDirs, systemPath)
-                : null);
-        if (standardVersionWithNpmBin) {
+    const npm = option.npmPath || (0, command_resolution_1.getSystemCommandPath)('npm', systemPath) || 'npm';
+    const env = { PATH: systemPath, Path: systemPath, npm_config_prefix: undefined, NPM_CONFIG_PREFIX: undefined };
+    const verifyPrefix = async (destination) => {
+        const bin = process.platform === 'win32' ? destination : path_1.default.join(destination, 'bin');
+        const target = (0, command_resolution_1.getSystemCommandPath)(option.launchCommand, bin);
+        const version = target ? await deps.commandVersion(target, undefined, systemPath, { signal: option.signal, timeoutMs: 30000 }) : null;
+        option.signal?.throwIfAborted();
+        return version;
+    };
+    if (!option.managedOnly) {
+        try {
+            const response = await deps.runProcess(npm, ['prefix', '-g'], env, { signal: option.signal, timeoutMs: 10000 });
+            option.signal?.throwIfAborted();
+            const destination = response.stdout.trim();
+            if (!path_1.default.isAbsolute(destination))
+                throw new Error('npm did not report an absolute installation prefix.');
+            await deps.runProcess(npm, ['install', '-g', option.installPackage], {
+                ...env, npm_config_prefix: destination, NPM_CONFIG_PREFIX: destination,
+            }, { signal: option.signal });
+            option.signal?.throwIfAborted();
+            if (!(await verifyPrefix(destination)))
+                throw new Error(option.label + ' installed target failed verification.');
+            (0, managed_agent_paths_1.invalidateAgentCommandRecovery)();
             return { outcome: 'standard' };
         }
-        standardInstallError = `${option.label} standard install completed, but the CLI is not runnable from the user PATH.`;
-    }
-    catch (error) {
-        if (isStaleNpmInstallError(error))
-            cleanupManagedInstallArtifacts(option, prefix);
-        standardInstallError = errorMessage(error);
+        catch (error) {
+            option.signal?.throwIfAborted();
+            if (error?.code === 'cleanup-failed')
+                throw error;
+            if (isStaleNpmInstallError(error))
+                cleanupManagedInstallArtifacts(option, prefix);
+            standardInstallError = errorMessage(error);
+        }
     }
-    // Defect A fix: co-locate npm-global shims with the node.exe/npm.cmd that
-    // actually runs the install, instead of the flat legacy directory.
     fs_1.default.mkdirSync(prefix, { recursive: true });
-    await runInstallWithStaleCleanupRetry(option, prefix, () => deps.runProcess('npm', ['install', '-g', option.installPackage], { npm_config_prefix: prefix }).then(() => undefined));
-    const ver = deps.commandVersion(option.launchCommand, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
-    if (!ver) {
-        throw new Error(`${option.label} install completed, but the CLI is not runnable from FRAIM's managed PATH. Standard install failure: ${standardInstallError}`);
+    await runInstallWithStaleCleanupRetry(option, prefix, () => deps.runProcess(npm, ['install', '-g', option.installPackage], {
+        ...env, npm_config_prefix: prefix, NPM_CONFIG_PREFIX: prefix,
+    }, { signal: option.signal }).then(() => { option.signal?.throwIfAborted(); }));
+    if (!(await verifyPrefix(prefix))) {
+        throw new Error(option.label + ' managed installed target failed verification. Standard install: ' + (standardInstallError || 'not requested'));
     }
     (0, persist_shell_path_1.persistShellPath)();
+    (0, managed_agent_paths_1.invalidateAgentCommandRecovery)();
     return { outcome: 'managed' };
 }