@hashicorp/kits 0.1.11 → 0.1.14

package/dist/cli/upgrade.js

@@ -4,6 +4,8 @@
  * Checks for and applies primitive upgrades.
  */
 import * as clack from "@clack/prompts";
+import fs from "node:fs/promises";
+import path from "node:path";
 import pc from "picocolors";
 import { ExitCode, } from "./types.js";
 import { readManifest, writeManifest, getManifestPath } from "../manifest/index.js";
@@ -13,8 +15,14 @@ import { writeLockfile } from "../lockfile/write.js";
 import { checkForUpgrades } from "../lockfile/upgrade-check.js";
 import { fetchSource, scanKits, NoFetcherError, SourceParseError, } from "../discovery/index.js";
 import { PrimitivesRegistryLoader } from "../resolution/primitives-registry.js";
+import { resolveRegistryPrimitivePath } from "../resolution/primitive-paths.js";
+import { resolveEnvVarsFromConfig } from "../resolution/index.js";
+import { hashMcpConfig, hashMcpInputSchema } from "../core/mcp-instance.js";
+import { hashHookProgram, hashHookInputSchema } from "../core/hook-instance.js";
+import { buildHookInputDefaults, buildHookDefaultArgMap, buildHookDefaultEnvMap, } from "../core/hook-input.js";
 import { toUpgradeDisplayEntry, selectUpgrades, displayUpgradeCheck, displayNoUpgrades, upgradesToJson, filterUpgradesByHarness, getUpgradeGroups, } from "../tui/upgrade-select.js";
 import { renderUpgradeApplyStart, renderUpgradeApplyResults, renderUpgradeProcessComplete, renderUpgradeError, } from "../tui/upgrade.js";
+import { promptForEnvVars, promptForHookInputs, promptForUpgradeConfigUpdates, } from "../tui/index.js";
 import { globalRegistry } from "../adapters/registry.js";
 import { executeUpgrades } from "../core/upgrade-executor.js";
 import { debugLog, enableDebugLogging, getDebugLogPath, checkDebugLogWritable, } from "../core/debug.js";
@@ -48,6 +56,238 @@ function filterLockfileBySource(lockfile, source) {
     }
     return filtered;
 }
+function upgradeKey(check) {
+    return `${check.harness}:${check.kit}:${check.type}:${check.primitive}`;
+}
+async function loadJsonFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolvePrimitiveConfigPath(registry, type, name, version) {
+    const entry = await registry.getPrimitive(type, name);
+    if (!entry) {
+        return null;
+    }
+    const versionEntry = entry.versions.find((v) => v.version === version);
+    if (!versionEntry) {
+        return null;
+    }
+    let basePath = versionEntry.path;
+    if (!path.isAbsolute(basePath)) {
+        basePath = entry.path
+            ? path.join(registry.getBasePath(), entry.path, basePath)
+            : path.join(registry.getBasePath(), basePath);
+    }
+    const configPath = await resolveRegistryPrimitivePath(type, name, basePath);
+    return { configPath, basePath };
+}
+function detectNewRequiredEnv(oldDefs = {}, newDefs = {}) {
+    const required = [];
+    for (const [name, def] of Object.entries(newDefs)) {
+        if (!def.required || def.sensitive || def.default !== undefined) {
+            continue;
+        }
+        const oldDef = oldDefs[name];
+        const oldRequired = oldDef?.required ?? false;
+        const oldDefault = oldDef?.default;
+        if (!oldDef || !oldRequired || oldDefault !== undefined) {
+            required.push(name);
+        }
+    }
+    return required;
+}
+function buildEnvVarRequirements(resolutions) {
+    const requirements = [];
+    const seen = new Set();
+    for (const resolution of resolutions) {
+        for (const resolved of resolution.resolved) {
+            if (seen.has(resolved.name))
+                continue;
+            seen.add(resolved.name);
+            requirements.push({
+                name: resolved.name,
+                description: resolved.description,
+                required: resolved.required,
+                sensitive: resolved.sensitive,
+                defaultValue: resolved.defaultValue,
+                currentValue: process.env[resolved.name],
+                source: resolution.mcpServer,
+            });
+        }
+    }
+    return requirements;
+}
+function applyPromptResultsToResolutions(resolutions, promptResults) {
+    for (const result of promptResults.variables) {
+        for (const resolution of resolutions) {
+            const resolved = resolution.resolved.find((r) => r.name === result.name);
+            if (!resolved)
+                continue;
+            switch (result.choice) {
+                case "use-existing": {
+                    if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = true;
+                    resolved.source = "environment";
+                    break;
+                }
+                case "use-default": {
+                    if (result.value !== undefined) {
+                        resolved.value = result.value;
+                    }
+                    else if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = false;
+                    resolved.source = "default";
+                    break;
+                }
+                case "enter-new": {
+                    if (result.value !== undefined) {
+                        resolved.value = result.value;
+                    }
+                    else if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = false;
+                    resolved.source = "user-input";
+                    break;
+                }
+                case "skip": {
+                    if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = true;
+                    resolved.source = "passthrough";
+                    break;
+                }
+                default:
+                    break;
+            }
+            const idx = resolution.missingRequired.indexOf(result.name);
+            if (idx !== -1) {
+                resolution.missingRequired.splice(idx, 1);
+            }
+        }
+    }
+}
+async function buildMcpUpgradePlan(check, lockfile, registry) {
+    const kitEntry = lockfile.kits[check.kit];
+    const harnessEntry = kitEntry?.harnesses[check.harness];
+    const installed = harnessEntry?.primitives.mcp?.find((p) => p.name === check.primitive);
+    if (!installed?.instanceRef) {
+        return null;
+    }
+    const instanceRef = installed.instanceRef;
+    const prefix = `${check.harness}:`;
+    const instanceKey = instanceRef.startsWith(prefix) ? instanceRef : `${check.harness}:${instanceRef}`;
+    const instanceName = instanceKey.startsWith(prefix)
+        ? instanceKey.slice(prefix.length)
+        : instanceRef;
+    const existingInstance = lockfile.mcpInstances?.[instanceKey];
+    const oldConfig = existingInstance?.config;
+    const oldInputHash = existingInstance?.inputHash ?? (oldConfig ? hashMcpInputSchema(oldConfig) : undefined);
+    const resolved = await resolvePrimitiveConfigPath(registry, "mcp", check.primitive, check.availableVersion);
+    if (!resolved) {
+        return null;
+    }
+    const config = await loadJsonFile(resolved.configPath);
+    if (!config) {
+        return null;
+    }
+    const inputHash = hashMcpInputSchema(config);
+    const needsUpdate = !oldInputHash || oldInputHash !== inputHash;
+    const requiredInputs = needsUpdate
+        ? detectNewRequiredEnv(oldConfig?.env ?? {}, config.env ?? {})
+        : [];
+    const envResolution = resolveEnvVarsFromConfig(instanceName, config, {});
+    const configHash = hashMcpConfig(config, envResolution.resolved, envResolution.resolvedHeaders);
+    return {
+        kind: "mcp",
+        upgradeKey: upgradeKey(check),
+        harness: check.harness,
+        kit: check.kit,
+        primitive: check.primitive,
+        instanceName,
+        config,
+        envResolution,
+        inputHash,
+        configHash,
+        needsUpdate,
+        requiredInputs,
+    };
+}
+async function buildHookUpgradePlan(check, lockfile, registry) {
+    const kitEntry = lockfile.kits[check.kit];
+    const harnessEntry = kitEntry?.harnesses[check.harness];
+    const installed = harnessEntry?.primitives.hooks?.find((p) => p.name === check.primitive);
+    if (!installed?.instanceRef || !installed.binding) {
+        return null;
+    }
+    const instanceName = installed.instanceRef;
+    const existingInstance = lockfile.hookInstances?.[instanceName];
+    let oldInputHash = existingInstance?.inputHash;
+    if (!oldInputHash) {
+        const oldResolved = await resolvePrimitiveConfigPath(registry, "hooks", check.primitive, check.currentVersion);
+        if (oldResolved) {
+            const oldProgram = await loadJsonFile(oldResolved.configPath);
+            if (oldProgram) {
+                oldInputHash = hashHookInputSchema(oldProgram);
+            }
+        }
+    }
+    const resolved = await resolvePrimitiveConfigPath(registry, "hooks", check.primitive, check.availableVersion);
+    if (!resolved) {
+        return null;
+    }
+    const program = await loadJsonFile(resolved.configPath);
+    if (!program) {
+        return null;
+    }
+    const inputHash = hashHookInputSchema(program);
+    const needsUpdate = !oldInputHash || oldInputHash !== inputHash;
+    const binding = {
+        ...installed.binding,
+        ...(installed.binding.env ? { env: { ...installed.binding.env } } : {}),
+        ...(installed.binding.args ? { args: { ...installed.binding.args } } : {}),
+    };
+    const defaults = buildHookInputDefaults(program, binding);
+    const requiredInputs = needsUpdate ? defaults.missingRequiredEnv : [];
+    const programDir = path.dirname(resolved.configPath);
+    const entryPath = path.join(programDir, program.runtime.entrypoint);
+    let checksum = existingInstance?.checksum ?? "";
+    try {
+        const entryContents = await fs.readFile(entryPath, "utf-8");
+        checksum = hashHookProgram(program, entryContents);
+    }
+    catch {
+        if (!checksum) {
+            checksum = hashHookProgram(program);
+        }
+    }
+    return {
+        kind: "hooks",
+        upgradeKey: upgradeKey(check),
+        harness: check.harness,
+        kit: check.kit,
+        primitive: check.primitive,
+        instanceName,
+        displayName: program.name ?? check.primitive,
+        program,
+        binding,
+        defaults,
+        inputHash,
+        checksum,
+        needsUpdate,
+        requiredInputs,
+    };
+}
 /**
  * Run the upgrade command.
  */
@@ -221,7 +461,7 @@ export async function runUpgrade(options) {
         const kitVersionsBySource = new Map();
         const registryBySource = new Map();
         const checkSourceMap = new Map();
-        const checkKey = (check) => `${check.harness}:${check.kit}:${check.type}:${check.primitive}`;
+        const checkKey = upgradeKey;
         const fetchSpinner = isInteractive ? clack.spinner() : undefined;
         const fetchedSources = [];
         if (fetchSpinner) {
@@ -552,12 +792,208 @@ export async function runUpgrade(options) {
             existing.push(check);
             upgradesBySelectedSource.set(sourceKey, existing);
         }
+        const configPlans = [];
+        const configPlansByKey = new Map();
+        const configPlanErrors = [];
+        for (const check of selectedChecks) {
+            if (check.type !== "mcp" && check.type !== "hooks") {
+                continue;
+            }
+            const sourceKey = checkSourceMap.get(checkKey(check)) ?? options.source;
+            if (!sourceKey) {
+                continue;
+            }
+            const registryLoader = registryBySource.get(sourceKey);
+            if (!registryLoader) {
+                continue;
+            }
+            if (check.type === "mcp") {
+                const plan = await buildMcpUpgradePlan(check, lockfile, registryLoader);
+                if (!plan) {
+                    configPlanErrors.push(`Unable to resolve MCP configuration for ${check.primitive} (${check.kit})`);
+                    continue;
+                }
+                configPlans.push(plan);
+                configPlansByKey.set(plan.upgradeKey, plan);
+            }
+            else if (check.type === "hooks") {
+                const plan = await buildHookUpgradePlan(check, lockfile, registryLoader);
+                if (!plan) {
+                    configPlanErrors.push(`Unable to resolve hook configuration for ${check.primitive} (${check.kit})`);
+                    continue;
+                }
+                configPlans.push(plan);
+                configPlansByKey.set(plan.upgradeKey, plan);
+            }
+        }
+        if (configPlanErrors.length > 0) {
+            const message = configPlanErrors.join("; ");
+            if (isInteractive) {
+                clack.log.error(message);
+                clack.outro(pc.red("Upgrade failed"));
+            }
+            else if (options.json) {
+                console.log(JSON.stringify({ success: false, error: message }));
+            }
+            else {
+                console.error(message);
+            }
+            return { success: false, exitCode: ExitCode.InstallationFailed, error: message };
+        }
+        const plansNeedingUpdate = configPlans.filter((plan) => plan.needsUpdate);
+        if (plansNeedingUpdate.length > 0) {
+            const mcpNames = Array.from(new Set(plansNeedingUpdate
+                .filter((plan) => plan.kind === "mcp")
+                .map((plan) => plan.instanceName)));
+            const hookNames = Array.from(new Set(plansNeedingUpdate
+                .filter((plan) => plan.kind === "hooks")
+                .map((plan) => plan.displayName)));
+            const hasRequiredUpdates = plansNeedingUpdate.some((plan) => plan.requiredInputs.length > 0);
+            if (isInteractive) {
+                const configPrompt = await promptForUpgradeConfigUpdates({
+                    mcpServers: mcpNames,
+                    hooks: hookNames,
+                    requireUpdate: hasRequiredUpdates,
+                });
+                if (configPrompt.cancelled) {
+                    clack.outro(pc.yellow("Upgrade cancelled"));
+                    return { success: true, exitCode: ExitCode.UserCancelled };
+                }
+                const shouldConfigure = hasRequiredUpdates || configPrompt.configure;
+                if (shouldConfigure) {
+                    const mcpResolutions = plansNeedingUpdate
+                        .filter((plan) => plan.kind === "mcp")
+                        .map((plan) => plan.envResolution);
+                    if (mcpResolutions.length > 0) {
+                        const requirements = buildEnvVarRequirements(mcpResolutions);
+                        if (requirements.length > 0) {
+                            const promptResults = await promptForEnvVars(requirements);
+                            if (promptResults.cancelled) {
+                                clack.outro(pc.yellow("Upgrade cancelled"));
+                                return { success: true, exitCode: ExitCode.UserCancelled };
+                            }
+                            applyPromptResultsToResolutions(mcpResolutions, promptResults);
+                        }
+                    }
+                    const hookPlans = plansNeedingUpdate.filter((plan) => plan.kind === "hooks");
+                    if (hookPlans.length > 0) {
+                        const hookRequests = hookPlans.map((plan) => ({
+                            key: plan.upgradeKey,
+                            hookName: plan.displayName,
+                            kitName: plan.kit,
+                            defaults: plan.defaults,
+                        }));
+                        const promptResults = await promptForHookInputs(hookRequests);
+                        if (promptResults.cancelled) {
+                            clack.outro(pc.yellow("Upgrade cancelled"));
+                            return { success: true, exitCode: ExitCode.UserCancelled };
+                        }
+                        for (const plan of hookPlans) {
+                            const overrides = promptResults.results.get(plan.upgradeKey);
+                            const resolvedEnv = overrides?.env ?? buildHookDefaultEnvMap(plan.defaults);
+                            const resolvedArgs = overrides?.args ?? buildHookDefaultArgMap(plan.defaults);
+                            const nextBinding = { ...plan.binding };
+                            if (plan.defaults.env.length > 0) {
+                                if (Object.keys(resolvedEnv).length > 0) {
+                                    nextBinding.env = resolvedEnv;
+                                }
+                                else {
+                                    delete nextBinding.env;
+                                }
+                            }
+                            if (plan.defaults.args.length > 0) {
+                                nextBinding.args = resolvedArgs;
+                            }
+                            plan.binding = nextBinding;
+                        }
+                    }
+                }
+                else {
+                    for (const plan of plansNeedingUpdate) {
+                        if (plan.kind !== "hooks") {
+                            continue;
+                        }
+                        const resolvedEnv = buildHookDefaultEnvMap(plan.defaults);
+                        const resolvedArgs = buildHookDefaultArgMap(plan.defaults);
+                        const nextBinding = { ...plan.binding };
+                        if (plan.defaults.env.length > 0) {
+                            if (Object.keys(resolvedEnv).length > 0) {
+                                nextBinding.env = resolvedEnv;
+                            }
+                            else {
+                                delete nextBinding.env;
+                            }
+                        }
+                        if (plan.defaults.args.length > 0) {
+                            nextBinding.args = resolvedArgs;
+                        }
+                        plan.binding = nextBinding;
+                    }
+                }
+            }
+            else if (hasRequiredUpdates) {
+                const details = plansNeedingUpdate
+                    .map((plan) => {
+                    const label = plan.kind === "mcp" ? plan.instanceName : plan.displayName;
+                    return `${label}: ${plan.requiredInputs.join(", ")}`;
+                })
+                    .join("; ");
+                const message = `Configuration updates required for upgraded primitives: ${details}. ` +
+                    "Run without -y to configure updated inputs.";
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: message }));
+                }
+                else {
+                    console.error(message);
+                }
+                return { success: false, exitCode: ExitCode.EnvVarRequired, error: message };
+            }
+            else {
+                for (const plan of plansNeedingUpdate) {
+                    if (plan.kind !== "hooks") {
+                        continue;
+                    }
+                    const resolvedEnv = buildHookDefaultEnvMap(plan.defaults);
+                    const resolvedArgs = buildHookDefaultArgMap(plan.defaults);
+                    const nextBinding = { ...plan.binding };
+                    if (plan.defaults.env.length > 0) {
+                        if (Object.keys(resolvedEnv).length > 0) {
+                            nextBinding.env = resolvedEnv;
+                        }
+                        else {
+                            delete nextBinding.env;
+                        }
+                    }
+                    if (plan.defaults.args.length > 0) {
+                        nextBinding.args = resolvedArgs;
+                    }
+                    plan.binding = nextBinding;
+                }
+            }
+            for (const plan of plansNeedingUpdate) {
+                if (plan.kind === "mcp") {
+                    plan.configHash = hashMcpConfig(plan.config, plan.envResolution.resolved, plan.envResolution.resolvedHeaders);
+                }
+            }
+        }
+        const configOverrides = new Map();
+        for (const plan of configPlans) {
+            if (plan.kind === "mcp") {
+                configOverrides.set(plan.upgradeKey, {
+                    envResolutions: [plan.envResolution],
+                });
+            }
+            else if (plan.kind === "hooks") {
+                configOverrides.set(plan.upgradeKey, { hookBinding: plan.binding });
+            }
+        }
         const aggregateResult = {
             success: true,
             upgraded: [],
             failed: [],
             backupPaths: [],
         };
+        let configUpdatesApplied = false;
         if (isInteractive) {
             renderUpgradeApplyStart(selectedGroups.length);
         }
@@ -599,6 +1035,7 @@ export async function runUpgrade(options) {
                     }
                 },
                 scope,
+                configOverrides,
                 ...(scope === "project" && projectRoot ? { projectRoot } : {}),
             };
             const result = await executeUpgrades(checks, adapterMap, registryLoader, lockfile, upgradeOptions);
@@ -619,6 +1056,41 @@ export async function runUpgrade(options) {
             aggregateResult.upgraded.push(...result.upgraded);
             aggregateResult.failed.push(...result.failed);
             aggregateResult.backupPaths.push(...result.backupPaths);
+            for (const upgraded of result.upgraded) {
+                const key = `${upgraded.harness}:${upgraded.kit}:${upgraded.type}:${upgraded.primitive}`;
+                const plan = configPlansByKey.get(key);
+                if (!plan) {
+                    continue;
+                }
+                if (plan.kind === "mcp") {
+                    const instanceKey = `${plan.harness}:${plan.instanceName}`;
+                    const existing = lockfile.mcpInstances?.[instanceKey];
+                    if (existing) {
+                        existing.config = plan.config;
+                        existing.configHash = plan.configHash;
+                        existing.inputHash = plan.inputHash;
+                        existing.version = upgraded.newVersion;
+                        existing.installedAt = new Date().toISOString();
+                        configUpdatesApplied = true;
+                    }
+                }
+                else if (plan.kind === "hooks") {
+                    const existing = lockfile.hookInstances?.[plan.instanceName];
+                    if (existing) {
+                        existing.checksum = plan.checksum;
+                        existing.inputHash = plan.inputHash;
+                        existing.version = upgraded.newVersion;
+                        configUpdatesApplied = true;
+                    }
+                    const kitEntry = lockfile.kits[plan.kit];
+                    const harnessEntry = kitEntry?.harnesses[plan.harness];
+                    const hookEntry = harnessEntry?.primitives.hooks?.find((entry) => entry.name === plan.primitive);
+                    if (hookEntry) {
+                        hookEntry.binding = plan.binding;
+                        configUpdatesApplied = true;
+                    }
+                }
+            }
         }
         void debugLog({
             level: "info",
@@ -662,6 +1134,9 @@ export async function runUpgrade(options) {
                 await writeLockfile(lockfile, scope, scope === "project" ? projectRoot : undefined);
             }
         }
+        if (configUpdatesApplied) {
+            await writeLockfile(lockfile, scope, scope === "project" ? projectRoot : undefined);
+        }
         // Display results
         if (isInteractive) {
             const failuresByGroup = new Map();