@hagicode/hagiscript 0.1.6 → 0.1.8

package/dist/runtime/runtime-manager.js

@@ -0,0 +1,651 @@
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { tmpdir } from "node:os";
+import { installNodeRuntime, resolveManagedNodeRuntime } from "./node-installer.js";
+import { verifyNodeRuntime } from "./node-verify.js";
+import { syncNpmGlobals } from "./npm-sync.js";
+import { executeRuntimeScript, writeRuntimeLog } from "./runtime-executor.js";
+import { loadRuntimeManifest } from "./runtime-manifest.js";
+import { getComponentConfigDirectory, getComponentLogsDirectory, getComponentManagedRoot, getComponentPm2Home, getComponentRuntimeDataHome, isPathInsideRuntimeRoot, resolveRuntimePaths } from "./runtime-paths.js";
+import { mergeRuntimeState, readRuntimeState, writeRuntimeState } from "./runtime-state.js";
+export class RuntimeLifecycleError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "RuntimeLifecycleError";
+    }
+}
+export async function installRuntime(options = {}) {
+    return runRuntimeLifecycle("install", options);
+}
+export async function removeRuntime(options = {}) {
+    return runRuntimeLifecycle("remove", options);
+}
+export async function updateRuntime(options = {}) {
+    return runRuntimeLifecycle("update", options);
+}
+export async function runRuntimeLifecycle(phase, options = {}) {
+    const manifest = await loadRuntimeManifest({ manifestPath: options.manifestPath });
+    const paths = resolveRuntimePaths(manifest, { runtimeRoot: options.runtimeRoot });
+    const existingState = await readRuntimeState(paths.stateFile);
+    const state = mergeRuntimeState(manifest, paths, existingState);
+    const { plan, skipped } = planRuntimeLifecycle(phase, manifest, state, options);
+    const now = options.now ?? (() => new Date());
+    const logger = options.logger ?? (() => undefined);
+    if (options.dryRun || (phase === "update" && options.checkOnly)) {
+        for (const action of plan) {
+            logger(`Plan: ${phase} ${action.componentName} (${action.strategy}${action.reason ? `: ${action.reason}` : ""})`);
+        }
+        for (const item of skipped) {
+            logger(`Skip: ${item.componentName} (${item.reason})`);
+        }
+        return {
+            manifest,
+            paths,
+            state,
+            plan,
+            skipped,
+            changedComponents: []
+        };
+    }
+    await ensureManagedDirectories(paths);
+    const logFilePath = join(paths.logs, `${phase}-${now().toISOString().replaceAll(":", "-")}.log`);
+    const operationState = {
+        phase,
+        status: "success",
+        selectedComponents: plan.map((item) => item.componentName),
+        completedComponents: [],
+        startedAt: now().toISOString(),
+        finishedAt: now().toISOString(),
+        logFile: logFilePath
+    };
+    const changedComponents = [];
+    await writeRuntimeLog(logFilePath, `Runtime ${phase} starting with managed root ${paths.root}`);
+    try {
+        for (const action of plan) {
+            const component = manifest.componentMap.get(action.componentName);
+            if (!component) {
+                throw new RuntimeLifecycleError(`Unknown runtime component ${action.componentName}`);
+            }
+            logger(`Running ${phase}: ${component.name}`);
+            try {
+                const componentState = await executeRuntimeAction(action, component, manifest, paths, options, logFilePath);
+                state.components[component.name] = componentState;
+                changedComponents.push(component.name);
+                operationState.completedComponents.push(component.name);
+            }
+            catch (error) {
+                state.components[component.name] = {
+                    name: component.name,
+                    type: component.type,
+                    status: "failed",
+                    version: state.components[component.name]?.version ?? null,
+                    managedProgramPaths: [getComponentManagedRoot(paths, component.name)],
+                    managedDataPaths: [
+                        getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir),
+                        getComponentConfigDirectory(paths, component.name, component.runtimeDataDir),
+                        getComponentLogsDirectory(paths, component.name, component.runtimeDataDir),
+                        ...(component.pm2
+                            ? [
+                                getComponentPm2Home(paths, component.name, component.runtimeDataDir, component.pm2.pm2Home)
+                            ]
+                            : [])
+                    ],
+                    managedPaths: [
+                        getComponentManagedRoot(paths, component.name),
+                        getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir),
+                        getComponentConfigDirectory(paths, component.name, component.runtimeDataDir),
+                        getComponentLogsDirectory(paths, component.name, component.runtimeDataDir),
+                        ...(component.pm2
+                            ? [
+                                getComponentPm2Home(paths, component.name, component.runtimeDataDir, component.pm2.pm2Home)
+                            ]
+                            : [])
+                    ],
+                    lastAction: phase,
+                    lastUpdatedAt: now().toISOString(),
+                    logFile: logFilePath,
+                    details: {
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                };
+                throw new RuntimeLifecycleError(`${phase} failed for component ${component.name}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? { cause: error } : undefined);
+            }
+        }
+        operationState.finishedAt = now().toISOString();
+        state.lastOperation = operationState;
+        await writeRuntimeState(paths.stateFile, state);
+        return {
+            manifest,
+            paths,
+            state,
+            plan,
+            skipped,
+            changedComponents,
+            logFilePath
+        };
+    }
+    catch (error) {
+        operationState.status = "failed";
+        operationState.finishedAt = now().toISOString();
+        operationState.message = error instanceof Error ? error.message : String(error);
+        state.lastOperation = operationState;
+        await writeRuntimeLog(logFilePath, `Failure: ${operationState.message}`);
+        await writeRuntimeState(paths.stateFile, state);
+        throw error;
+    }
+}
+export async function queryRuntimeState(options) {
+    const manifest = await loadRuntimeManifest({ manifestPath: options.manifestPath });
+    const paths = resolveRuntimePaths(manifest, { runtimeRoot: options.runtimeRoot });
+    const state = mergeRuntimeState(manifest, paths, await readRuntimeState(paths.stateFile));
+    const components = manifest.components.map((component) => {
+        const entry = state.components[component.name];
+        const fallbackProgramPaths = [getComponentManagedRoot(paths, component.name)];
+        const runtimeDataHome = component.name === "npm-packages"
+            ? null
+            : getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir);
+        const pm2Home = component.pm2
+            ? getComponentPm2Home(paths, component.name, component.runtimeDataDir, component.pm2.pm2Home)
+            : null;
+        const fallbackDataPaths = component.name === "npm-packages" || !runtimeDataHome
+            ? []
+            : [
+                runtimeDataHome,
+                getComponentConfigDirectory(paths, component.name, component.runtimeDataDir),
+                getComponentLogsDirectory(paths, component.name, component.runtimeDataDir),
+                ...(pm2Home ? [pm2Home] : [])
+            ];
+        const programPaths = entry?.managedProgramPaths ?? fallbackProgramPaths;
+        const externalDataPaths = entry?.managedDataPaths ?? fallbackDataPaths;
+        return {
+            name: component.name,
+            type: component.type,
+            status: entry?.status ?? "not-installed",
+            version: entry?.version ?? null,
+            runtimeDataHome,
+            pm2Home,
+            programPaths,
+            externalDataPaths,
+            managedPaths: entry?.managedPaths ?? [...programPaths, ...externalDataPaths]
+        };
+    });
+    const programRoots = [
+        paths.runtimeHome,
+        paths.bin,
+        paths.componentsRoot,
+        paths.npmPrefix
+    ];
+    const externalDataRoots = [
+        paths.runtimeDataRoot,
+        paths.config,
+        paths.logs,
+        paths.data,
+        paths.componentDataRoot
+    ];
+    return {
+        runtime: state.runtime,
+        managedRoot: state.managedRoot,
+        managedPaths: state.managedPaths,
+        layout: {
+            separated: paths.runtimeHome !== paths.runtimeDataRoot,
+            runtimeHome: paths.runtimeHome,
+            runtimeDataRoot: paths.runtimeDataRoot,
+            programRoots,
+            externalDataRoots
+        },
+        ready: components.every((component) => component.status === "installed"),
+        components,
+        lastOperation: state.lastOperation
+    };
+}
+export function renderRuntimeStateText(report) {
+    const lines = [
+        `Runtime: ${report.runtime.name} ${report.runtime.version}`,
+        `Manifest: ${report.runtime.manifestPath}`,
+        `Managed root: ${report.managedRoot}`,
+        `Runtime home: ${report.layout.runtimeHome}`,
+        `Runtime data root: ${report.layout.runtimeDataRoot}`,
+        `Bin: ${report.managedPaths.bin}`,
+        `State file: ${report.managedPaths.stateFile}`,
+        `Program roots: ${report.layout.programRoots.join(", ")}`,
+        `External data roots: ${report.layout.externalDataRoots.join(", ")}`,
+        `Separated layout: ${report.layout.separated ? "yes" : "no"}`,
+        `Ready: ${report.ready ? "yes" : "no"}`
+    ];
+    for (const component of report.components) {
+        lines.push(`- ${component.name}: ${component.status} version=${component.version ?? "n/a"} program=${component.programPaths.join("|") || "n/a"} data=${component.externalDataPaths.join("|") || "n/a"}`);
+        if (component.runtimeDataHome) {
+            lines.push(`  runtime-data-home=${component.runtimeDataHome}`);
+        }
+        if (component.pm2Home) {
+            lines.push(`  pm2-home=${component.pm2Home}`);
+        }
+    }
+    if (report.lastOperation) {
+        lines.push(`Last operation: ${report.lastOperation.phase} ${report.lastOperation.status} (${report.lastOperation.completedComponents.length}/${report.lastOperation.selectedComponents.length})`);
+    }
+    return lines.join("\n");
+}
+export function planRuntimeLifecycle(phase, manifest, state, options = {}) {
+    const requestedSet = selectRequestedComponents(manifest, options.components);
+    const orderedComponentNames = orderedPhaseComponents(manifest, phase).filter((name) => requestedSet.has(name));
+    const plan = [];
+    const skipped = [];
+    for (const componentName of orderedComponentNames) {
+        const component = manifest.componentMap.get(componentName);
+        if (!component) {
+            throw new RuntimeLifecycleError(`Unknown runtime component ${componentName}`);
+        }
+        if (phase === "update" && !options.force) {
+            const currentState = state.components[component.name];
+            if (currentState?.status === "installed" && !componentNeedsUpdate(component, currentState)) {
+                skipped.push({
+                    componentName: component.name,
+                    reason: "already up to date"
+                });
+                continue;
+            }
+        }
+        plan.push(resolveRuntimeAction(component, phase));
+    }
+    return { plan, skipped };
+}
+async function executeRuntimeAction(action, component, manifest, paths, options, logFilePath) {
+    const componentRoot = getComponentManagedRoot(paths, component.name);
+    const componentConfigDir = getComponentConfigDirectory(paths, component.name, component.runtimeDataDir);
+    switch (component.name) {
+        case "node":
+            return executeNodeComponent(action.phase, component, paths, logFilePath);
+        case "npm-packages":
+            return executeNpmPackagesComponent(action.phase, component, manifest, paths, options, logFilePath);
+        default:
+            return executeScriptComponent(action, component, manifest, paths, componentRoot, componentConfigDir, options, logFilePath);
+    }
+}
+async function executeNodeComponent(phase, component, paths, logFilePath) {
+    await mkdir(dirname(paths.nodeRuntime), { recursive: true });
+    if (phase === "remove") {
+        await rm(paths.nodeRuntime, { recursive: true, force: true });
+        await removeWrapper(paths.bin, "node");
+        await removeWrapper(paths.bin, "npm");
+        await writeRuntimeLog(logFilePath, "Removed managed node runtime directories");
+        return {
+            name: component.name,
+            type: component.type,
+            status: "removed",
+            version: null,
+            managedProgramPaths: [paths.nodeRuntime],
+            managedDataPaths: [],
+            managedPaths: [paths.nodeRuntime],
+            lastAction: phase,
+            lastUpdatedAt: new Date().toISOString(),
+            logFile: logFilePath
+        };
+    }
+    const desiredVersion = component.version ?? component.channelVersion;
+    const currentVerification = await verifyNodeRuntime(paths.nodeRuntime);
+    const normalizedCurrentVersion = normalizeVersion(currentVerification.nodeVersion);
+    const normalizedDesiredVersion = normalizeVersion(desiredVersion);
+    if (!currentVerification.valid) {
+        await rm(paths.nodeRuntime, { recursive: true, force: true });
+    }
+    if (phase === "update" &&
+        currentVerification.valid &&
+        normalizedDesiredVersion &&
+        normalizedCurrentVersion &&
+        normalizedDesiredVersion !== normalizedCurrentVersion) {
+        await rm(paths.nodeRuntime, { recursive: true, force: true });
+    }
+    const resolvedRuntime = await resolveNodeRuntimeForPhase(phase, paths.nodeRuntime, desiredVersion, currentVerification);
+    const wrappers = await materializeNodeWrappers(paths.bin, {
+        nodePath: resolvedRuntime.nodePath,
+        npmPath: resolvedRuntime.npmPath
+    });
+    await writeRuntimeLog(logFilePath, `Node runtime ready: ${resolvedRuntime.targetDirectory} (${resolvedRuntime.nodeVersion})`);
+    return {
+        name: component.name,
+        type: component.type,
+        status: "installed",
+        version: normalizeVersion(resolvedRuntime.nodeVersion),
+        managedProgramPaths: [paths.nodeRuntime, ...wrappers],
+        managedDataPaths: [],
+        managedPaths: [paths.nodeRuntime, ...wrappers],
+        lastAction: phase,
+        lastUpdatedAt: new Date().toISOString(),
+        logFile: logFilePath
+    };
+}
+async function executeNpmPackagesComponent(phase, component, manifest, paths, options, logFilePath) {
+    if (phase === "remove") {
+        await rm(paths.npmPrefix, { recursive: true, force: true });
+        await writeRuntimeLog(logFilePath, `Removed managed npm prefix ${paths.npmPrefix}`);
+        return {
+            name: component.name,
+            type: component.type,
+            status: "removed",
+            version: null,
+            managedProgramPaths: [paths.npmPrefix],
+            managedDataPaths: [],
+            managedPaths: [paths.npmPrefix],
+            lastAction: phase,
+            lastUpdatedAt: new Date().toISOString(),
+            logFile: logFilePath
+        };
+    }
+    await resolveManagedNodeRuntime({
+        targetDirectory: paths.nodeRuntime,
+        versionSelector: manifest.componentMap.get("node")?.version ?? "22"
+    });
+    const scratchDirectory = await mkdtemp(join(tmpdir(), "hagiscript-runtime-npm-"));
+    const manifestPath = join(scratchDirectory, "npm-sync-manifest.json");
+    const npmManifest = {
+        packages: Object.fromEntries(component.packageCatalog.map((entry) => [
+            entry.packageName,
+            toNpmSyncManifestEntry(entry.packageName, entry.installSpec)
+        ]))
+    };
+    try {
+        await writeFile(manifestPath, `${JSON.stringify(npmManifest, null, 2)}\n`, "utf8");
+        const summary = await syncNpmGlobals({
+            runtimePath: paths.nodeRuntime,
+            manifestPath,
+            force: options.force,
+            npmOptions: {
+                prefix: paths.npmPrefix
+            },
+            onLog: (event) => appendNpmSyncLog(logFilePath, event)
+        });
+        await writeRuntimeLog(logFilePath, `Managed npm prefix ready: ${paths.npmPrefix} changed=${summary.changedCount}`);
+    }
+    finally {
+        await rm(scratchDirectory, { recursive: true, force: true });
+    }
+    return {
+        name: component.name,
+        type: component.type,
+        status: "installed",
+        version: computePackageCatalogFingerprint(component),
+        managedProgramPaths: [paths.npmPrefix],
+        managedDataPaths: [],
+        managedPaths: [paths.npmPrefix],
+        lastAction: phase,
+        lastUpdatedAt: new Date().toISOString(),
+        logFile: logFilePath,
+        details: {
+            packageCount: component.packageCatalog.length
+        }
+    };
+}
+async function executeScriptComponent(action, component, manifest, paths, componentRoot, componentConfigDir, options, logFilePath) {
+    await mkdir(componentRoot, { recursive: true });
+    await mkdir(componentConfigDir, { recursive: true });
+    const scriptPath = resolveScriptForAction(action, component);
+    if (scriptPath) {
+        await executeRuntimeScript(scriptPath, {
+            component,
+            phase: action.phase,
+            manifest,
+            paths,
+            componentRoot,
+            componentConfigDir,
+            logFilePath,
+            purge: options.purge,
+            verbose: options.verbose
+        });
+        if (action.phase !== "remove" && component.scripts.configure) {
+            await executeRuntimeScript(component.scripts.configure, {
+                component,
+                phase: action.phase,
+                manifest,
+                paths,
+                componentRoot,
+                componentConfigDir,
+                logFilePath,
+                purge: options.purge,
+                verbose: options.verbose
+            });
+        }
+        if (action.phase !== "remove" && component.scripts.verify) {
+            await executeRuntimeScript(component.scripts.verify, {
+                component,
+                phase: action.phase,
+                manifest,
+                paths,
+                componentRoot,
+                componentConfigDir,
+                logFilePath,
+                purge: options.purge,
+                verbose: options.verbose
+            });
+        }
+    }
+    else {
+        const componentDataHome = getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir);
+        await cleanupManagedComponent([paths.root, paths.runtimeHome, paths.runtimeDataRoot], componentRoot, ...(options.purge ? [componentDataHome] : []));
+    }
+    const isRemoval = action.phase === "remove";
+    const managedProgramPaths = [componentRoot];
+    const componentDataHome = getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir);
+    const componentLogsDir = getComponentLogsDirectory(paths, component.name, component.runtimeDataDir);
+    const componentPm2Home = component.pm2
+        ? getComponentPm2Home(paths, component.name, component.runtimeDataDir, component.pm2.pm2Home)
+        : null;
+    const managedDataPaths = options.purge || !isRemoval
+        ? [
+            componentDataHome,
+            componentConfigDir,
+            componentLogsDir,
+            ...(componentPm2Home ? [componentPm2Home] : [])
+        ]
+        : [];
+    return {
+        name: component.name,
+        type: component.type,
+        status: isRemoval ? "removed" : "installed",
+        version: isRemoval ? null : component.version ?? component.channelVersion ?? null,
+        managedProgramPaths,
+        managedDataPaths,
+        managedPaths: [...managedProgramPaths, ...managedDataPaths],
+        lastAction: action.phase,
+        lastUpdatedAt: new Date().toISOString(),
+        logFile: logFilePath
+    };
+}
+function selectRequestedComponents(manifest, requestedComponents) {
+    if (!requestedComponents || requestedComponents.length === 0) {
+        return new Set(manifest.components.map((component) => component.name));
+    }
+    const requestedSet = new Set();
+    for (const value of requestedComponents) {
+        if (!manifest.componentMap.has(value)) {
+            throw new RuntimeLifecycleError(`Unknown runtime component: ${value}`);
+        }
+        requestedSet.add(value);
+    }
+    return requestedSet;
+}
+function orderedPhaseComponents(manifest, phase) {
+    const definition = manifest.phases[phase];
+    const ordered = [...definition.order];
+    return definition.reverse ? ordered.reverse() : ordered;
+}
+function resolveRuntimeAction(component, phase) {
+    if (component.name === "node" || component.name === "npm-packages") {
+        return {
+            componentName: component.name,
+            phase,
+            strategy: "builtin"
+        };
+    }
+    if (phase === "install") {
+        return {
+            componentName: component.name,
+            phase,
+            strategy: "script",
+            scriptPath: component.scripts.install
+        };
+    }
+    if (phase === "update") {
+        if (component.scripts.update) {
+            return {
+                componentName: component.name,
+                phase,
+                strategy: "script",
+                scriptPath: component.scripts.update
+            };
+        }
+        return {
+            componentName: component.name,
+            phase,
+            strategy: "fallback-install",
+            scriptPath: component.scripts.install,
+            reason: "update hook missing; reusing install hook"
+        };
+    }
+    if (component.scripts.remove) {
+        return {
+            componentName: component.name,
+            phase,
+            strategy: "script",
+            scriptPath: component.scripts.remove
+        };
+    }
+    return {
+        componentName: component.name,
+        phase,
+        strategy: "fallback-cleanup",
+        reason: "remove hook missing; cleaning managed paths only"
+    };
+}
+function componentNeedsUpdate(component, state) {
+    if (state.status !== "installed") {
+        return true;
+    }
+    if (component.name === "npm-packages") {
+        return state.version !== computePackageCatalogFingerprint(component);
+    }
+    const desiredVersion = component.version ?? component.channelVersion ?? null;
+    return desiredVersion !== state.version;
+}
+function resolveScriptForAction(action, component) {
+    switch (action.strategy) {
+        case "script":
+        case "fallback-install":
+            return action.scriptPath ?? component.scripts.install;
+        case "builtin":
+        case "fallback-cleanup":
+            return null;
+    }
+}
+function toNpmSyncManifestEntry(packageName, installSpec) {
+    const trimmed = installSpec.trim();
+    const scopedPrefix = `${packageName}@`;
+    if (trimmed === packageName) {
+        return {
+            version: "*"
+        };
+    }
+    if (trimmed.startsWith(scopedPrefix)) {
+        const selector = trimmed.slice(scopedPrefix.length).trim();
+        return {
+            version: selector || "*",
+            target: selector || undefined
+        };
+    }
+    return {
+        version: "*",
+        target: trimmed
+    };
+}
+function computePackageCatalogFingerprint(component) {
+    return createHash("sha256")
+        .update(JSON.stringify(component.packageCatalog))
+        .digest("hex")
+        .slice(0, 12);
+}
+async function ensureManagedDirectories(paths) {
+    await Promise.all([
+        mkdir(paths.root, { recursive: true }),
+        mkdir(paths.runtimeHome, { recursive: true }),
+        mkdir(paths.runtimeDataRoot, { recursive: true }),
+        mkdir(paths.bin, { recursive: true }),
+        mkdir(paths.config, { recursive: true }),
+        mkdir(paths.logs, { recursive: true }),
+        mkdir(paths.data, { recursive: true }),
+        mkdir(paths.componentsRoot, { recursive: true }),
+        mkdir(paths.componentDataRoot, { recursive: true }),
+        mkdir(paths.vendoredRoot, { recursive: true })
+    ]);
+}
+async function appendNpmSyncLog(logFilePath, event) {
+    await writeRuntimeLog(logFilePath, `npm-sync:${event.type} ${JSON.stringify(event)}`);
+}
+async function cleanupManagedComponent(allowedRoots, ...paths) {
+    for (const pathValue of paths) {
+        if (!allowedRoots.some((rootPath) => isPathInsideRuntimeRoot(rootPath, pathValue))) {
+            throw new RuntimeLifecycleError(`Refusing to clean path outside managed runtime root: ${pathValue}`);
+        }
+        await rm(pathValue, { recursive: true, force: true });
+    }
+}
+async function materializeNodeWrappers(binDirectory, executables) {
+    await mkdir(binDirectory, { recursive: true });
+    return Promise.all([
+        writeExecutableWrapper(binDirectory, "node", executables.nodePath),
+        writeExecutableWrapper(binDirectory, "npm", executables.npmPath)
+    ]);
+}
+async function writeExecutableWrapper(binDirectory, commandName, targetPath) {
+    const wrapperPath = process.platform === "win32"
+        ? join(binDirectory, `${commandName}.cmd`)
+        : join(binDirectory, commandName);
+    const relativeTarget = relative(binDirectory, targetPath);
+    await writeFile(wrapperPath, process.platform === "win32"
+        ? `@echo off\r\n"%~dp0\\${relativeTarget.replaceAll("/", "\\")}" %*\r\n`
+        : `#!/usr/bin/env sh\nexec "$(dirname "$0")/${relativeTarget.replaceAll("\\", "/")}" "$@"\n`, "utf8");
+    return wrapperPath;
+}
+async function removeWrapper(binDirectory, commandName) {
+    const wrapperPath = process.platform === "win32"
+        ? join(binDirectory, `${commandName}.cmd`)
+        : join(binDirectory, commandName);
+    await rm(wrapperPath, { force: true });
+}
+function normalizeVersion(value) {
+    if (!value) {
+        return null;
+    }
+    return value.replace(/^v/u, "");
+}
+async function resolveNodeRuntimeForPhase(phase, targetDirectory, desiredVersion, currentVerification) {
+    if (phase === "update" &&
+        currentVerification.valid &&
+        normalizeVersion(currentVerification.nodeVersion) === normalizeVersion(desiredVersion)) {
+        return {
+            targetDirectory: currentVerification.targetDirectory,
+            nodePath: currentVerification.nodePath ?? "",
+            npmPath: currentVerification.npmPath ?? "",
+            nodeVersion: currentVerification.nodeVersion ?? "",
+            npmVersion: currentVerification.npmVersion ?? ""
+        };
+    }
+    if (phase === "update") {
+        const installed = await installNodeRuntime({
+            targetDirectory,
+            versionSelector: desiredVersion
+        });
+        return {
+            targetDirectory: installed.targetDirectory,
+            nodePath: installed.nodePath,
+            npmPath: installed.npmPath,
+            nodeVersion: installed.version,
+            npmVersion: installed.npmVersion
+        };
+    }
+    return resolveManagedNodeRuntime({
+        targetDirectory,
+        versionSelector: desiredVersion
+    });
+}
+//# sourceMappingURL=runtime-manager.js.map