@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/provision.js

@@ -0,0 +1,867 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { readFileSync, existsSync } from 'fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline/promises';
+import { Command } from 'commander';
+import { diagnoseFailure, isAiConfigured, parseGoal } from '../agent/ai.js';
+import { bootstrapCommand, resolveBootstrap } from '../agent/bootstrap.js';
+import { createEnvFile, envFileMissing } from '../agent/env-file.js';
+import { entrypointExists, executionBlocked, runScript } from '../agent/executor.js';
+import { deriveHealthUrl, waitHealthy, ensureMinikubeGateway } from '../agent/health.js';
+import { checkHostPorts, discoverHostPorts, stackRunning } from '../agent/ports.js';
+import { resolvePostSteps } from '../agent/post-steps.js';
+import { checkPrereqs, gitAvailable, gitSupportsSparseCheckout, prereqsSatisfied } from '../agent/prereqs.js';
+import { assembleCommand, isTargetId, LOAD_STEPS, sparsePathsFor, TARGETS, TARGET_IDS, teardownCommand, } from '../agent/targets.js';
+import { TOOLS_DIR, fetchTool, isFetchable, withToolsOnPath } from '../agent/tools.js';
+import { matchIssues, sesPostDeployGuidance } from '../agent/troubleshoot.js';
+import { shellQuote } from '../config/cli.constants.js';
+import { printCommandHeader } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printSection, printKeyValue, printInfo, printWarning, printError, printSuccess } from '../utils/output-utils.js';
+const INIT_MODES = ['auto', 'manual', 'skip'];
+/**
+ * Resolve the init mode from the new `--init <mode>` flag, falling back to the DEPRECATED
+ * aliases (`--no-init` → skip, `--auto-init` → auto, `--no-auto-init` → manual), then the
+ * default (`auto`). Returns `null` when `--init` was given an invalid value (caller errors).
+ */
+export function resolveInitMode(options) {
+    if (typeof options.init === 'string') { // --init <mode>
+        const m = options.init.toLowerCase();
+        return INIT_MODES.includes(m) ? m : null;
+    }
+    if (options.init === false)
+        return 'skip'; // deprecated --no-init
+    if (options.autoInit === true)
+        return 'auto'; // deprecated --auto-init
+    if (options.autoInit === false)
+        return 'manual'; // deprecated --no-auto-init
+    return 'auto'; // default
+}
+/**
+ * Read one line of trimmed input from the terminal, owning the readline
+ * lifecycle. Used directly for the destructive teardown gate (a y/N is too easy
+ * to fat-finger, so we require the operator to TYPE the target id back), and as
+ * the basis for `confirm`. Deliberately has no auto-accept.
+ */
+async function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Interactive y/N confirmation; auto-true when `autoYes` (the `--yes` flag). */
+async function confirm(question, autoYes) {
+    if (autoYes)
+        return true;
+    const answer = (await ask(`${question} [y/N] `)).toLowerCase();
+    return answer === 'y' || answer === 'yes';
+}
+/** Commander collector: accumulate repeated `--post-step` values in order. */
+function collectStep(value, acc) {
+    return [...acc, value];
+}
+/**
+ * Host-port pre-flight (local/minikube). Ports are DERIVED from the target's cloned
+ * deploy source (compose / setup.sh) so the list can't drift — hence this runs AFTER
+ * the clone. A taken port makes a container/forward fail to bind mid-deploy (for the
+ * gateway, a silent unreachable hang). Prints a ✓/✗ summary and returns false ONLY
+ * when the caller must ABORT (a fatal local conflict). minikube ports are managed
+ * forwards (setup.sh pkills/restarts them), so a conflict there warns but proceeds.
+ * Remote targets (ec2/eks) bind nothing locally → returns true.
+ */
+export async function preflightPorts(spec, target, cwd) {
+    const ports = discoverHostPorts(target, cwd, spec);
+    if (ports.length === 0)
+        return true;
+    const portChecks = await checkHostPorts(ports);
+    const taken = portChecks.filter((c) => !c.available);
+    printSection('Port availability');
+    for (const c of portChecks)
+        printInfo(`${c.available ? '✓' : '✗'} ${String(c.port).padEnd(5)} — ${c.service}`);
+    if (taken.length === 0)
+        return true;
+    // local PUBLISHES these ports at `docker compose up` time, so a conflict is fatal.
+    // minikube's are kubectl port-forwards setup.sh pkills + restarts (and
+    // ensureMinikubeGateway recovers), so a stale forward must NOT block a re-run.
+    const fatal = target === 'docker';
+    // …UNLESS the local stack is already running: those ports are held by YOUR OWN
+    // stack, and `docker compose up` no-ops them — this is exactly how you re-run to
+    // add loads/options. Don't block (the would-be conflict is a self-conflict).
+    if (fatal && stackRunning(target, cwd, spec)) {
+        printWarning(`\n${taken.length} port(s) are held by your already-running ${spec.label} stack — re-running just resumes it (no real conflict), so continuing.`);
+        return true;
+    }
+    const lead = `${taken.length} required port(s) already in use: ${taken.map((c) => c.port).join(', ')}`;
+    (fatal ? printError : printWarning)(fatal
+        ? `\n${lead} — the deploy can't bind them and would fail mid-way. Free them and re-run:`
+        : `\n${lead} — on minikube these are usually a previous run's port-forwards (setup.sh restarts them). Free any NON-minikube holder if the gateway stays unreachable:`);
+    for (const c of taken)
+        printInfo(`  • port ${c.port} (${c.service}) — find the holder:  lsof -i :${c.port}`);
+    if (taken.some((c) => c.port === 5000)) {
+        printInfo('  Note: on macOS, port 5000 is usually AirPlay Receiver — System Settings → General → AirDrop & Handoff → AirPlay Receiver (off).');
+    }
+    return !fatal;
+}
+/**
+ * Teardown mode — the destroy counterpart of provisioning, gated HARDER than deploy:
+ * AWS targets are irreversible, so the operator must TYPE the target id (--force
+ * bypasses for CI; --yes alone does NOT). Terminal: owns its output + exitCode.
+ */
+export async function runTeardown(spec, target, cwd, executionId, opts) {
+    const { command: downCommand, destructive } = teardownCommand(target, {
+        stackName: opts.stackName,
+        clusterName: opts.clusterName,
+        region: opts.region,
+        // eks teardown (bin/shutdown.sh) also cleans up the ACM cert + Route 53 alias for
+        // the domain, so forward them when present.
+        domain: opts.domain,
+        hostedZoneId: opts.hostedZoneId,
+        // Our typed gate IS the confirmation — assumeYes forwards a native `--yes` to any
+        // script-based teardown (ec2 delete-stack has no prompt; eks shutdown.sh skips its own).
+        assumeYes: true,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, executionId, target, teardown: true, destructive, destroys: spec.destroys, command: downCommand }, null, 2));
+        return;
+    }
+    printSection(`Teardown plan — ${spec.label}`);
+    printKeyValue({ 'Target': target, 'Destroys': spec.destroys, 'Stops cost': spec.cost });
+    printSection('Command to run');
+    printInfo(downCommand);
+    if (destructive && !opts.force) {
+        // Bind the confirmation to the resource actually destroyed: a custom name (ec2
+        // --stack-name / eks --cluster-name) must be typed verbatim so a wrong name can't be
+        // confirmed by habit; otherwise the target id.
+        const resourceName = target === 'eks' ? opts.clusterName : opts.stackName;
+        const confirmToken = resourceName ?? target;
+        const noun = target === 'eks' ? (opts.clusterName ? 'cluster name' : 'target id') : (opts.stackName ? 'stack name' : 'target id');
+        const token = await ask(`\nThis is IRREVERSIBLE. Type "${confirmToken}" to confirm teardown: `);
+        if (token !== confirmToken) {
+            printWarning(`That didn't match, so nothing was destroyed — you have to type the exact ${noun} to confirm.`);
+            return;
+        }
+    }
+    else if (!destructive && !opts.force && !(await confirm('\nProceed with teardown (stops the stack; on-disk data persists)?', opts.yes ?? false))) {
+        printWarning('No problem — nothing was changed.');
+        return;
+    }
+    printSection('Tearing down');
+    const { code: downCode } = await runScript(downCommand, cwd, { capture: false });
+    if (downCode !== 0) {
+        printError(`\nTeardown failed (exit ${downCode}). Inspect the stack/containers and retry.`);
+        process.exitCode = 1;
+        return;
+    }
+    printSuccess('Teardown complete.');
+}
+/**
+ * Run the deploy command (real, secrets unmasked, streamed + captured) with a
+ * bounded auto-fix + retry loop — the deploy scripts are idempotent, so a fixed
+ * re-run resumes rather than starting over. Returns whether it succeeded plus the
+ * (possibly fix-adjusted) params, which the caller needs for SES guidance.
+ */
+export async function runDeployWithRetry(spec, url, cwd, params, aiOpts, opts) {
+    // Bound retries so an unattended `--yes` run can't auto-re-run a 15–30 min
+    // deploy an unbounded number of times on a persistently-retryable signature.
+    const MAX_RETRIES = 5;
+    const requestedRetries = Math.max(0, parseInt(opts.retries ?? '', 10) || 0);
+    const maxAttempts = 1 + Math.min(requestedRetries, MAX_RETRIES);
+    let runParams = params;
+    let succeeded = false;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const realCommand = assembleCommand(spec, runParams, { mask: false }).command;
+        printSection(attempt === 1 ? 'Deploying' : `Deploying — retry ${attempt - 1}`);
+        if (attempt === 1) {
+            printInfo(`Deploying ${spec.label} → ${url}`);
+            printInfo(spec.deploys);
+            printInfo('Streaming the deploy below — first run is the slow one (image pulls + cert generation).');
+        }
+        const { code, tail } = await runScript(realCommand, cwd, { capture: true });
+        if (code === 0) {
+            succeeded = true;
+            break;
+        }
+        printError(`\nDeploy failed (exit ${code}).`);
+        const issues = matchIssues(tail);
+        if (issues.length > 0) {
+            printSection('Likely cause');
+            for (const i of issues)
+                printInfo(`• ${i.cause}\n  → ${i.suggestion}`);
+        }
+        if (isAiConfigured(aiOpts)) {
+            const diagnosis = await diagnoseFailure(redactSecrets(tail, spec, runParams), aiOpts);
+            if (diagnosis) {
+                printSection('Diagnosis');
+                printInfo(diagnosis);
+            }
+        }
+        if (attempt >= maxAttempts)
+            break;
+        // Auto-fix: a retryable issue with a param we haven't already applied.
+        const fix = issues.find((i) => i.retryable && i.paramFix && runParams[i.paramFix.key] !== i.paramFix.value);
+        if (fix?.paramFix && await confirm(`\nApply fix and retry — ${fix.suggestion}`, opts.yes ?? false)) {
+            runParams = { ...runParams, [fix.paramFix.key]: fix.paramFix.value };
+            continue;
+        }
+        // Retryable but no param change (e.g. ACM DNS propagation) — offer a plain re-run.
+        if (!fix && issues.some((i) => i.retryable) && await confirm('\nRetry the deploy (safe to re-run — it resumes where it left off)?', opts.yes ?? false)) {
+            continue;
+        }
+        break;
+    }
+    return { succeeded, runParams };
+}
+/**
+ * Execute the post-install steps (register → loads → smoke → events → custom). On
+ * EC2/EKS the register step + the events bundle (store-token → setup-events) are
+ * SURFACED as ordered manual next-steps instead of auto-run: ec2 register must run
+ * ON the box (the minikube user owns the cluster), and the events bundle needs a
+ * registered platform + AWS creds. (eks register itself port-forwards, so it runs
+ * from anywhere with kubectl access.) Sets exitCode on a step failure.
+ */
+export async function runPostSteps(postSteps, skippedSteps, target, cwd, adminEnv, opts) {
+    // AWS targets with `--init auto`: the deploy self-runs init-platform, so there's no
+    // register/loads step to surface here — confirm it and point at where to watch.
+    if (opts.autoInit && target === 'ec2') {
+        printInfo('\n✓ Init mode: auto — the instance runs init-platform itself on first boot');
+        printInfo('  (register admin + build bootstrap image + load plugins/compliance/samples).');
+        printInfo('  It takes ~30-60 min; watch progress:');
+        printInfo('    aws ssm start-session --target <InstanceId>   # InstanceId stack output');
+        printInfo('    sudo tail -f /var/log/user-data.log');
+    }
+    else if (opts.autoInit && target === 'eks') {
+        printInfo('\n✓ Init mode: auto — setup.sh runs init-platform in its final phase');
+        printInfo('  (register admin + build bootstrap image + load plugins/compliance/samples,');
+        printInfo('  over a kubectl port-forward). Pass --init manual to run it yourself instead.');
+    }
+    if (postSteps.length === 0)
+        return;
+    for (const s of skippedSteps)
+        printWarning(`Skipped post-step ${s.id}: ${s.reason}`);
+    const isRemote = (id) => (target === 'ec2' || target === 'eks') && (id === 'register' || id.startsWith('store-token') || id === 'events');
+    const runnable = postSteps.filter((s) => !isRemote(s.id));
+    const remote = postSteps.filter((s) => isRemote(s.id));
+    if (remote.length > 0) {
+        if (target === 'ec2') {
+            // EC2 runs the platform as a dedicated `minikube` user inside the instance: the
+            // cluster, its kubeconfig, and the jwt-secret all belong to that user, and the
+            // register step builds+pushes images against it. So it MUST run on the box as
+            // `minikube` — print the exact landing sequence rather than a bare command.
+            printInfo('\nNext — finish setup ON the instance (it builds images + reads the cluster, so it');
+            printInfo('cannot run from here). Land on the box, become the `minikube` user, then run it:');
+            printInfo('  aws ssm start-session --target <InstanceId>      # InstanceId stack output');
+            printInfo('  sudo -iu minikube                                # owns the cluster + docker');
+            printInfo('  cd /opt/pipeline/pipeline-builder                # the deployed checkout');
+            for (const s of remote)
+                printInfo(`  ${s.command}`);
+        }
+        else {
+            // eks: init-platform port-forwards to svc/nginx, so register runs from anywhere with
+            // kubectl access — no in-VPC requirement and no waiting on the ALB/DNS. (A --with-events
+            // bundle, if present, additionally needs AWS creds + a registered platform.)
+            printInfo('\nNext — run with kubectl access to the cluster (in this order):');
+            for (const s of remote)
+                printInfo(`  • ${s.label} — ${s.command}`);
+        }
+    }
+    if (runnable.length === 0)
+        return;
+    // When the loads were picked interactively (autoRun), the user already opted in — skip
+    // the redundant second confirm. Flag-driven / non-interactive runs still gate here.
+    if (opts.autoRun || await confirm(`\nRun ${runnable.length} post-install step(s) now?`, opts.yes ?? false)) {
+        if (opts.autoRun)
+            printInfo(`\nRunning the ${runnable.length} post-install step(s) you selected…`);
+        for (const s of runnable) {
+            printSection(`Post-step: ${s.label}`);
+            // register (local/minikube) logs into the platform, so it needs the admin creds
+            // (PLATFORM_IDENTIFIER / PLATFORM_PASSWORD) on top of its step env.
+            const needsCreds = s.id === 'register' || s.id.startsWith('store-token');
+            const env = needsCreds ? { ...s.env, ...adminEnv } : s.env;
+            // Loads/smoke are noisy + non-interactive → run QUIET (capture, show only on
+            // failure). Exception: a register with no admin creds prompts, so it must stream.
+            const interactiveRegister = s.id === 'register' && !adminEnv.PLATFORM_IDENTIFIER;
+            const quiet = !interactiveRegister;
+            if (quiet)
+                printInfo(`${s.command}\n  …running (output shown only if it fails)`);
+            else
+                printInfo(s.command);
+            const { code, tail } = await runScript(s.command, cwd, { quiet, capture: false, env });
+            if (code !== 0) {
+                if (quiet && tail) {
+                    printError('\n--- last output ---');
+                    printInfo(tail);
+                }
+                printError(`\nPost-step '${s.id}' failed (exit ${code}). The platform is deployed; fix and re-run the step manually.`);
+                process.exitCode = 1;
+                break;
+            }
+            printSuccess(`${s.id} ✓`);
+        }
+    }
+    else {
+        printInfo('\nSkipped post-install steps. Run the commands above manually when ready.');
+    }
+}
+/**
+ * Sparse-clone the platform repo (when --repo, or accepted via the interactive
+ * offer), repoint cwd into it, and verify the deploy entrypoint exists. Owns the
+ * cwd/bootstrapped state. Sets exitCode on a hard failure (clone error / missing
+ * entrypoint), matching the old inline behavior; a plain decline leaves exitCode
+ * untouched. Returns ok:false when the caller must abort.
+ */
+export async function bootstrapAndLocate(spec, bootstrap, bootstrapCmd, sparsePaths, startCwd, opts) {
+    let cwd = startCwd;
+    let bootstrapped = false;
+    // Shared by `--repo` and the interactive offer. Repoints cwd + sets bootstrapped;
+    // `bootstrapped` records whether we created the clone (vs. an existing checkout) —
+    // only then can the caller additively sparse-fetch load folders.
+    const bootstrapClone = async () => {
+        const cmd = bootstrapCommand(bootstrap);
+        printSection('Bootstrap');
+        printInfo(cmd);
+        const { code } = await runScript(cmd, cwd, { capture: false });
+        if (code !== 0) {
+            printError(`\nThe clone didn't finish (exit ${code}). Double-check the repo URL / ref (or your network) and give it another go.`);
+            process.exitCode = 1;
+            return false;
+        }
+        cwd = path.resolve(cwd, bootstrap.workdir);
+        bootstrapped = true;
+        printSuccess(`Repo is ready — continuing from ${cwd}`);
+        const absent = sparsePaths.filter((p) => !existsSync(path.join(cwd, p)));
+        if (absent.length > 0) {
+            printError(`\nThe sparse clone is missing ${absent.join(', ')} — that ref may not have those folders. Try a different --ref.`);
+            process.exitCode = 1;
+            return false;
+        }
+        return true;
+    };
+    // `--repo`: clone up front (must precede the entrypoint check).
+    if (bootstrapCmd) {
+        printInfo(`\nBootstrap → clone ${bootstrap.repo} @ ${bootstrap.ref} into ${bootstrap.workdir} (sparse).`);
+        if (!(await confirm('Go ahead with the clone?', opts.yes ?? false))) {
+            printWarning('No problem — nothing was changed. Re-run whenever you\'re ready.');
+            return { cwd, bootstrapped, ok: false };
+        }
+        if (!(await bootstrapClone()))
+            return { cwd, bootstrapped, ok: false };
+    }
+    // The deploy entrypoint must exist relative to cwd. If it doesn't and we haven't
+    // bootstrapped, gracefully OFFER to clone (interactive only) so a fresh machine can
+    // proceed without re-running with --repo.
+    if (!entrypointExists(spec, cwd)) {
+        const interactive = Boolean(process.stdin.isTTY) && !opts.yes;
+        if (!bootstrapCmd && interactive && gitAvailable()) {
+            printInfo(`\nLooks like you're not inside a pipeline-builder checkout, so the ${spec.label} deploy scripts aren't here yet.`);
+            if (await confirm(`Want me to sparse-clone them into ${bootstrap.workdir} and keep going?`, false)) {
+                if (!(await bootstrapClone()))
+                    return { cwd, bootstrapped, ok: false };
+            }
+        }
+        if (!entrypointExists(spec, cwd)) {
+            printWarning(`\nI couldn't find ${spec.dir}/${spec.entrypoint} from ${cwd}.`);
+            printInfo('Two easy ways forward:');
+            printInfo('  • cd into your pipeline-builder checkout and re-run, or');
+            printInfo(`  • add --repo and I'll bootstrap a fresh sparse clone for you${gitAvailable() ? '.' : ' (once git is installed).'}`);
+            process.exitCode = 1;
+            return { cwd, bootstrapped, ok: false };
+        }
+    }
+    return { cwd, bootstrapped, ok: true };
+}
+/**
+ * Interactive opt-in loads, offered AFTER the clone (so we only ask once the operator
+ * has agreed to proceed). Prompts per load, additively sparse-fetches the picked
+ * folders into a bootstrapped sparse clone, then re-resolves the post-install steps
+ * with the selections. Returns the chosen ids + the recomputed steps.
+ */
+export async function resolveLoadsInteractively(target, url, region, cwd, bootstrapped, bootstrap, postStepFlags) {
+    const prompts = {
+        plugins: 'Load plugins?',
+        samples: 'Load sample pipeline templates?',
+        compliance: 'Load compliance rules?',
+    };
+    printSection('Optional post-install loads');
+    const chosen = [];
+    for (const s of LOAD_STEPS) {
+        if (await confirm(prompts[s.id] ?? `Load ${s.id}?`, false))
+            chosen.push(s.id);
+    }
+    // Additive sparse re-sync: materialize ONLY the picked loads' folders (the partial
+    // clone fetches their blobs on demand). Only when we created a SPARSE clone — a
+    // normal checkout already has every folder, and the git<2.27 full-clone fallback
+    // (bootstrap.full) is non-sparse, where `sparse-checkout add` would switch it to
+    // cone mode and PRUNE the already-materialized deploy folders.
+    if (bootstrapped && !bootstrap.full) {
+        const absent = sparsePathsFor(target, chosen).filter((p) => !existsSync(path.join(cwd, p)));
+        if (absent.length > 0) {
+            printSection('Fetching selected load folders');
+            const addCmd = `git sparse-checkout add ${absent.map((p) => `'${p}'`).join(' ')} && git checkout ${shellQuote(bootstrap.ref)}`;
+            printInfo(addCmd);
+            const { code } = await runScript(addCmd, cwd, { capture: false });
+            if (code !== 0) {
+                printWarning(`Couldn't fetch ${absent.join(', ')} — the matching load step(s) may fail. Re-run with --repo to refresh the clone.`);
+            }
+        }
+    }
+    const resolved = resolvePostSteps({
+        target,
+        url,
+        region,
+        enabledLoadIds: chosen,
+        ...postStepFlags,
+        buildBootstrap: postStepFlags.buildBootstrap || chosen.includes('plugins'),
+    });
+    return { enabledLoadIds: chosen, steps: resolved.steps, skipped: resolved.skipped };
+}
+/**
+ * Redact secret param values (e.g. the ghcr token) from captured deploy output
+ * before it is sent to the LLM for diagnosis. The deploy runs with secrets
+ * unmasked, so although the current scripts don't echo them, this keeps a future
+ * script's stray echo (or a verbose sub-tool) from crossing the third-party-LLM
+ * boundary.
+ */
+function redactSecrets(text, spec, params) {
+    let out = text;
+    for (const input of [...spec.required, ...spec.optional]) {
+        if (!input.secret)
+            continue;
+        const value = params[input.key];
+        if (typeof value === 'string' && value.length >= 4)
+            out = out.split(value).join('***');
+    }
+    return out;
+}
+/**
+ * Registers the `provision` command — an AI-assisted installer for the Pipeline
+ * Builder PLATFORM (local/minikube/EC2/EKS). It prints the assembled plan
+ * (prereq checks, NL-goal parsing, command assembly) and then DEPLOYS, gated by
+ * confirmation prompts (`--yes` to auto-accept; `--json` is the only non-executing
+ * mode, printing the plan for tooling). With `--repo` it can bootstrap a fresh
+ * machine by sparsely cloning only the deploy folders the selected target +
+ * options need, then runs post-install steps (register admin, opt-in loads,
+ * smoke test, custom commands). `--teardown` removes a deployment instead.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export function provision(program) {
+    program
+        .command('provision')
+        .description('AI-assisted installer for the platform (local/minikube/EC2/EKS): deploys it (gated by confirmation prompts), or --teardown to remove')
+        .option('-t, --target <target>', `Deploy target: ${TARGET_IDS.join(' | ')}`)
+        .option('-p, --prompt <text>', 'Natural-language goal (parsed into params when an AI key is set)')
+        .option('--region <region>', 'AWS region (EC2/EKS)')
+        .option('--domain <domain>', 'Fully-qualified domain name (EC2/EKS)')
+        .option('--hosted-zone-id <id>', 'Public Route 53 hosted zone ID (EC2/EKS)')
+        .option('--deploy-mode <mode>', 'public | private (EC2/EKS)')
+        .option('--key-pair <name>', 'EC2 key pair (EC2)')
+        .option('--instance-type <type>', 'EC2 instance type (EC2)')
+        .option('--lean', 'EC2: trim optional observability/admin services so the core stack + mesh fits a t3.xlarge (pair with --instance-type t3.xlarge)')
+        .option('--ghcr-token <token>', 'GitHub PAT (read:packages) — masked in output')
+        .option('--email', 'Enable SES transactional email (on by default for AWS)')
+        .option('--no-email', 'Skip SES (transactional email is provisioned by default on AWS)')
+        .option('--email-from <addr>', 'SES From address')
+        .option('--email-from-name <name>', 'SES From display name')
+        .option('--alert-email <addr>', 'Subscribe an address to the bounce/complaint SNS topic')
+        .option('--skip-ses-identity', 'Skip SES identity creation (domain already verified)')
+        .option('--ai-provider <provider>', 'AI provider (anthropic|openai|google|xai|bedrock)')
+        .option('--model <model>', 'AI model id')
+        .option('--diagnose <file>', 'Diagnose a CloudFormation/deploy failure from a file (needs an AI key)')
+        .option('-y, --yes', 'Auto-accept all confirmation prompts (for CI / non-interactive)', false)
+        .option('--retries <n>', 'Auto-fix + retry attempts after a failure (deploy scripts are idempotent)', '1')
+        .option('--teardown', 'Tear down an existing deployment instead of creating one (gated; AWS targets require a typed confirmation)', false)
+        .option('--stack-name <name>', 'CloudFormation stack name (EC2) for the deploy AND teardown — defaults to pipeline-builder (set it to run a second environment)')
+        .option('--cluster-name <name>', 'EKS cluster name for the deploy AND teardown — defaults to pipeline-builder')
+        .option('--force', 'Skip the teardown typed-confirmation (DANGEROUS — for CI/automation only)', false)
+        .option('--init <mode>', 'Post-deploy initialization: auto (DEFAULT — register admin + load plugins/compliance/samples; on ec2 the instance does it itself on first boot), manual (don\'t self-init — surface the step for you to run, e.g. to set real admin creds), or skip (do nothing). local/minikube/eks run init via provision unless skip.')
+        // Deprecated aliases — kept working for back-compat; --init is the documented form.
+        .option('--no-init', '[deprecated] alias for --init skip')
+        .option('--auto-init', '[deprecated] alias for --init auto')
+        .option('--no-auto-init', '[deprecated] alias for --init manual')
+        // Bootstrap (sparse clone) — provision a fresh machine in one command.
+        .option('--repo [url]', 'Bootstrap: git-clone the platform repo first (sparse — only the needed deploy folders), then run from it (no value = the upstream default)')
+        .option('--ref <ref>', 'Git branch/tag to check out when bootstrapping (default: main)')
+        .option('--workdir <dir>', 'Directory to clone into / run from when bootstrapping (default: pipeline-builder)')
+        // Post-install loads — each opt-in step also adds its deploy folder to the sparse clone.
+        .option('--with-plugins', 'Post-install: build + load plugins (adds deploy/plugins, deploy/codebuild)', false)
+        .option('--with-compliance', 'Post-install: load sample compliance rules/policies (adds deploy/compliance)', false)
+        .option('--with-samples', 'Post-install: load sample pipeline templates (adds deploy/samples)', false)
+        .option('--with-all', 'Post-install: plugins + compliance + samples', false)
+        .option('--build-bootstrap', 'Build + publish the CodeBuild bootstrap image during register (adds deploy/codebuild)', false)
+        .option('--with-smoke-test', 'Post-install: read-only API reachability check', false)
+        .option('--with-events', 'Post-install (AWS): event ingestion bundle — store-token (JWT → Secrets Manager) then setup-events (EventBridge/Lambda)', false)
+        .option('--post-step <cmd>', 'Run an extra command after the loads (repeatable, in order)', collectStep, [])
+        .option('--admin-email <addr>', 'Admin email for non-interactive register (sets PLATFORM_IDENTIFIER)')
+        .option('--admin-password <pw>', 'Admin password for non-interactive register (sets PLATFORM_PASSWORD)')
+        .option('--json', 'Print the plan as JSON and exit WITHOUT running (the only non-executing mode — for tooling/CI inspection)', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Provision');
+        try {
+            // Resolve the single post-deploy init mode (auto|manual|skip) from --init or its
+            // deprecated aliases. Two internal signals derive from it: whether init happens at
+            // all, and whether the DEPLOY self-runs it (vs. we surface it).
+            const initMode = resolveInitMode(options);
+            if (initMode === null) {
+                printError(`Invalid --init value '${String(options.init)}'. Use one of: ${INIT_MODES.join(' | ')}.`);
+                process.exitCode = 1;
+                return;
+            }
+            const initEnabled = initMode !== 'skip'; // skip → no register/loads at all
+            const selfInit = initMode === 'auto'; // auto → the deploy initializes itself
+            // 1. Assemble params from explicit flags (flags always win over NL parse).
+            const params = {
+                region: options.region,
+                domain: options.domain,
+                hostedZoneId: options.hostedZoneId,
+                deployMode: options.deployMode,
+                keyPair: options.keyPair,
+                instanceType: options.instanceType,
+                // ec2 LEAN mode (boolean) → assembleCommand emits `--lean`, which setup.sh
+                // forwards to the CFN `Lean` param. Only ec2's spec lists it; other targets ignore it.
+                lean: options.lean === true,
+                // Deploy-time resource identity: ec2 emits --stack-name (key stackName), eks emits
+                // --cluster-name (key clusterName). Both also drive teardown. Undefined → defaults.
+                stackName: options.stackName,
+                clusterName: options.clusterName,
+                ghcrToken: options.ghcrToken,
+                // email/noEmail are coerced AFTER the NL merge below — parseGoal can return
+                // `email`, so pre-coercing here (never-undefined) would let the merge's
+                // `=== undefined` guard silently drop an AI-parsed email choice. Left out of
+                // this literal on purpose; resolved a few lines down.
+                emailFrom: options.emailFrom,
+                emailFromName: options.emailFromName,
+                alertEmail: options.alertEmail,
+                noCreateSesIdentity: options.skipSesIdentity,
+                // The AWS deploys self-init by default (ec2 on first boot, eks in setup.sh's final
+                // phase), so we emit the load-bearing `--no-auto-init` when the mode is NOT auto
+                // (manual/skip = "don't let the deploy init itself"). `--auto-init` (a no-op reaffirm)
+                // is never emitted. Only ec2/eks carry these flags in their spec; other targets ignore it.
+                noAutoInit: !selfInit,
+            };
+            const aiOpts = { provider: options.aiProvider, model: options.model };
+            // Bootstrap (sparse clone) + post-install selections.
+            const wantBootstrap = options.repo !== undefined && options.repo !== false;
+            const withAll = options.withAll === true;
+            const anyLoadFlag = withAll || LOAD_STEPS.some((s) => options[s.flag] === true);
+            let enabledLoadIds = LOAD_STEPS.filter((s) => withAll || options[s.flag] === true).map((s) => s.id);
+            // With no --with-* flags, an interactive run offers each load — but AFTER the
+            // clone, so the questions come once you've agreed to proceed (not up front).
+            // Each picked load's folder is then fetched via an additive sparse re-sync.
+            // Flags / --yes / --json / non-interactive shells skip the prompts.
+            let willPromptLoads = !options.yes && !options.json && Boolean(process.stdin.isTTY) && !anyLoadFlag;
+            const postStepFlags = {
+                init: initEnabled,
+                // selfInit (mode auto) drops the surfaced register step on the AWS targets in
+                // resolvePostSteps, so a self-initializing ec2/eks deploy doesn't also print a manual
+                // register step. For manual mode (or local/minikube) the register step is surfaced.
+                autoInit: selfInit,
+                buildBootstrap: options.buildBootstrap === true || enabledLoadIds.includes('plugins'),
+                smokeTest: options.withSmokeTest === true,
+                events: options.withEvents === true,
+                steps: (options.postStep ?? []),
+            };
+            // Admin credentials forwarded as env so register runs non-interactively.
+            const adminEnv = {};
+            if (typeof options.adminEmail === 'string')
+                adminEnv.PLATFORM_IDENTIFIER = options.adminEmail;
+            if (typeof options.adminPassword === 'string')
+                adminEnv.PLATFORM_PASSWORD = options.adminPassword;
+            // 2. Optionally parse a natural-language goal to fill any GAPS (best-effort).
+            let target = isTargetId(options.target) ? options.target : undefined;
+            if (options.prompt) {
+                if (isAiConfigured(aiOpts)) {
+                    const parsed = await parseGoal(options.prompt, aiOpts);
+                    if (parsed) {
+                        if (!target && isTargetId(parsed.target))
+                            target = parsed.target;
+                        for (const [k, v] of Object.entries(parsed)) {
+                            if (k !== 'target' && params[k] === undefined && v !== undefined)
+                                params[k] = v;
+                        }
+                    }
+                }
+                else if (!options.json) {
+                    // Don't print human text before a --json plan (it would corrupt the stream).
+                    printWarning('A --prompt was given but no AI key is set — ignoring it and using flags only. Set ANTHROPIC_API_KEY (or --ai-provider + its key).');
+                }
+            }
+            // Resolve email NOW (after the NL merge): an explicit --email/--no-email flag wins,
+            // else an AI-parsed `email` (merged into params.email above) decides, else default-on.
+            // Coerce to the two load-bearing keys assembleCommand emits.
+            const emailChoice = options.email !== undefined
+                ? options.email
+                : (typeof params.email === 'boolean' ? params.email : undefined);
+            params.email = emailChoice === true;
+            params.noEmail = emailChoice === false;
+            // 3. Optional failure diagnosis (independent of a deploy plan).
+            if (options.diagnose) {
+                let failureText;
+                try {
+                    failureText = readFileSync(options.diagnose, 'utf-8');
+                }
+                catch {
+                    printError(`Cannot read --diagnose file: ${options.diagnose}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const diagnosis = isAiConfigured(aiOpts) ? await diagnoseFailure(failureText, aiOpts) : null;
+                // With --json, the diagnosis IS the machine-readable output — emit it
+                // alone (don't also print text, which would corrupt the JSON stream).
+                if (options.json) {
+                    console.log(JSON.stringify({ success: true, executionId, diagnosis }, null, 2));
+                    return;
+                }
+                if (diagnosis) {
+                    printSection('Failure diagnosis');
+                    printInfo(diagnosis);
+                }
+                else {
+                    printWarning('Diagnosis unavailable (no AI key configured or the model could not be reached).');
+                }
+                // --diagnose is a read-only inspection mode: return whether or not a target was
+                // given, so it never falls through into a (possibly --yes) deploy.
+                return;
+            }
+            // With `--init auto` (the default) the EC2 instance loads plugins/compliance/samples
+            // itself on the box (bootstrap.sh hardcodes LOAD_*=y), so the local load picker — and
+            // the load-folder fetch it triggers — is pointless. Skip both (the instance has its
+            // own checkout).
+            if (selfInit && target === 'ec2') {
+                willPromptLoads = false;
+                enabledLoadIds = [];
+            }
+            else if (selfInit && target === 'eks' && !anyLoadFlag) {
+                // `--init auto` on eks initializes like ec2: NO interactive picker — default to
+                // loading ALL of plugins + compliance + samples (setup.sh's final phase hardcodes
+                // LOAD_*=y). setup.sh runs the loads itself (over a kubectl port-forward), but we
+                // still resolve them here so the sparse clone fetches the folders setup.sh builds
+                // from. Explicit `--with-*` flags override; `--init manual` / `--init skip` opt out.
+                willPromptLoads = false;
+                enabledLoadIds = LOAD_STEPS.map((s) => s.id);
+                postStepFlags.buildBootstrap = options.buildBootstrap === true || enabledLoadIds.includes('plugins');
+            }
+            // minikube/local keep the interactive picker (local-dev; no `--init auto` load parity).
+            // 4. Need a target to assemble a plan.
+            if (!target) {
+                printError(`No target specified. Pass --target <${TARGET_IDS.join('|')}> or describe the goal with --prompt.`);
+                process.exitCode = 1;
+                return;
+            }
+            const spec = TARGETS[target];
+            let cwd = process.cwd();
+            // 4b. Teardown mode — the destroy counterpart of provisioning (see runTeardown).
+            if (options.teardown) {
+                await runTeardown(spec, target, cwd, executionId, options);
+                return;
+            }
+            // Make previously-fetched single-binary tools (e.g. yq) visible to the
+            // prereq checks + the deploy — they live in the tools cache, not on the
+            // system PATH. (Both `has()` and the deploy's `bash -lc` inherit this.)
+            withToolsOnPath();
+            // Hard-require plugin prereqs (e.g. yq on minikube) only when plugins is EXPLICITLY
+            // selected — NOT on the willPromptLoads guess, which would block/prompt before the
+            // user has even been asked whether they want plugins. If they pick plugins in the
+            // interactive prompt, we re-check + offer to fetch right after that selection (below).
+            let prereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: enabledLoadIds.includes('plugins') });
+            const { command, missing } = assembleCommand(spec, params);
+            const url = deriveHealthUrl(target, params);
+            // Sparse bootstrap clone command (common base + target + selected loads).
+            // Interactive loads are chosen AFTER the clone, so the clone stays minimal —
+            // each picked load's folder is fetched then via an additive sparse re-sync.
+            const sparsePaths = sparsePathsFor(target, enabledLoadIds);
+            const bootstrap = resolveBootstrap({ repo: typeof options.repo === 'string' ? options.repo : undefined, ref: options.ref, workdir: options.workdir, full: !gitSupportsSparseCheckout() }, sparsePaths);
+            const bootstrapCmd = wantBootstrap ? bootstrapCommand(bootstrap) : null;
+            // Resolve post-install steps (register → smoke → events → custom). Re-resolved
+            // after the post-clone load prompts (see below) when those run interactively.
+            let { steps: postSteps, skipped: skippedSteps } = resolvePostSteps({
+                target,
+                url,
+                region: typeof params.region === 'string' ? params.region : undefined,
+                enabledLoadIds,
+                ...postStepFlags,
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: true,
+                    executionId,
+                    target,
+                    prereqs,
+                    prereqsSatisfied: prereqsSatisfied(prereqs),
+                    missingInputs: missing.map((m) => ({ flag: m.flag, description: m.description })),
+                    bootstrap: bootstrapCmd,
+                    sparsePaths: wantBootstrap ? sparsePaths : null,
+                    command,
+                    postSteps: postSteps.map((s) => ({ id: s.id, label: s.label, command: s.command })),
+                    skippedPostSteps: skippedSteps,
+                }, null, 2));
+                return;
+            }
+            // 5. Print the plan (shown before the gated execution below).
+            printSection(`Provision plan — ${spec.label}`);
+            printKeyValue({ 'Target': target, 'Best for': spec.bestFor, 'Cost': spec.cost });
+            printSection('Prerequisites');
+            for (const c of prereqs)
+                printInfo(`${c.ok ? '✓' : '✗'} ${c.name} — ${c.detail}`);
+            if (!prereqsSatisfied(prereqs))
+                printWarning('Resolve the failing prerequisites above before deploying.');
+            if (missing.length > 0) {
+                printSection('Missing required inputs');
+                for (const m of missing)
+                    printInfo(`  --${m.flag}  (${m.description})`);
+            }
+            if (bootstrapCmd) {
+                printSection('Bootstrap (sparse git clone, runs first)');
+                printInfo(`Clone ${bootstrap.repo} @ ${bootstrap.ref} → ${bootstrap.workdir}; folders: ${sparsePaths.join(', ')}`);
+                printInfo(bootstrapCmd);
+            }
+            printSection('Command to run');
+            printInfo(command);
+            if (postSteps.length > 0 || skippedSteps.length > 0) {
+                printSection('Post-install steps');
+                for (const s of postSteps)
+                    printInfo(`• ${s.label}\n    ${s.command}`);
+                for (const s of skippedSteps)
+                    printWarning(`Skipped ${s.id}: ${s.reason}`);
+            }
+            // 6. Any missing required prereq that's a single static binary (e.g. yq)
+            // can be fetched into the tools cache instead of a system install — no
+            // brew/apt. Offer it, then re-check (the cache dir is already on PATH).
+            const fetchable = prereqs.filter((c) => !c.ok && c.required && isFetchable(c.name));
+            if (fetchable.length > 0) {
+                const names = fetchable.map((c) => c.name).join(', ');
+                if (await confirm(`\n${names} not installed — fetch the official static binary into ${TOOLS_DIR} (no system install)?`, options.yes)) {
+                    for (const c of fetchable) {
+                        printInfo(`Fetching ${c.name}…`);
+                        if (!fetchTool(c.name))
+                            printWarning(`Couldn't fetch ${c.name} — install it manually and re-run.`);
+                    }
+                    prereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: enabledLoadIds.includes('plugins') });
+                }
+            }
+            // 7b. Gated execution. Check prereqs / required inputs first — this also
+            // catches a missing `git` when bootstrapping.
+            const blocked = executionBlocked(prereqs, missing);
+            if (blocked) {
+                printError(`Can't start just yet — ${blocked}. Resolve that and re-run.`);
+                process.exitCode = 1;
+                return;
+            }
+            // Commit gate — confirm BEFORE any side effect (clone, .env, deploy) so a "No"
+            // leaves nothing behind. The port check + optional loads + .env below are part of
+            // executing the agreed-to plan.
+            if (!(await confirm(`\nProceed with provisioning ${spec.label}?`, options.yes))) {
+                printWarning('No problem — nothing was changed.');
+                return;
+            }
+            // 7a/7b. Sparse-clone (if --repo or accepted interactively) + locate the deploy
+            // entrypoint, repointing cwd into the clone. See bootstrapAndLocate.
+            const located = await bootstrapAndLocate(spec, bootstrap, bootstrapCmd, sparsePaths, cwd, options);
+            cwd = located.cwd;
+            const bootstrapped = located.bootstrapped;
+            if (!located.ok)
+                return;
+            // Host-port pre-flight — now that the deploy source is on disk (post-clone),
+            // derive the ports from it (compose / setup.sh) and stop on a fatal conflict
+            // before deploying. See preflightPorts.
+            if (!(await preflightPorts(spec, target, cwd))) {
+                process.exitCode = 1;
+                return;
+            }
+            // Opt-in loads — offered AFTER the clone (see resolveLoadsInteractively); it
+            // prompts, additively sparse-fetches the picked folders, and re-resolves the
+            // post-install steps with the selections.
+            if (willPromptLoads) {
+                const loaded = await resolveLoadsInteractively(target, url, typeof params.region === 'string' ? params.region : undefined, cwd, bootstrapped, bootstrap, postStepFlags);
+                enabledLoadIds = loaded.enabledLoadIds;
+                postSteps = loaded.steps;
+                skippedSteps = loaded.skipped;
+                // Now that plugins may have been picked, re-check the plugin-specific prereqs we
+                // deliberately didn't hard-require up front (e.g. yq for minikube plugin builds).
+                // Offer to fetch any fetchable one; warn (don't block — the platform still deploys)
+                // if it can't be resolved, so the later plugin build doesn't fail opaquely.
+                if (enabledLoadIds.includes('plugins')) {
+                    const pluginPrereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: true });
+                    const pluginGaps = pluginPrereqs.filter((c) => !c.ok && c.required && !prereqs.some((p) => p.name === c.name));
+                    for (const c of pluginGaps) {
+                        if (isFetchable(c.name) && await confirm(`\n${c.name} is needed to build plugins but isn't installed — fetch the static binary into ${TOOLS_DIR}?`, options.yes)) {
+                            printInfo(`Fetching ${c.name}…`);
+                            if (!fetchTool(c.name))
+                                printWarning(`Couldn't fetch ${c.name} — install it before the plugin build runs.`);
+                        }
+                        else {
+                            printWarning(`${c.name} missing — the plugin load/build step may fail. ${c.detail}`);
+                        }
+                    }
+                }
+            }
+            // local/minikube's setup.sh REQUIRES a `.env` and aborts without it — create
+            // it from .env.example with generated secrets so the deploy is non-interactive.
+            // ec2 and eks don't have provision generate a local `.env`: ec2 bootstraps its
+            // secrets on the instance, and eks's setup.sh creates the k8s secrets itself
+            // (a deploy/aws/eks/.env.example + secret step is a setup.sh TODO).
+            if ((target === 'docker' || target === 'minikube') && envFileMissing(cwd, spec.dir)) {
+                if (await confirm(`\n${spec.dir}/.env not found — create it from .env.example (generates secrets; edit later for optional integrations like OAuth)?`, options.yes)) {
+                    const n = createEnvFile(cwd, spec.dir);
+                    printSuccess(`Created ${spec.dir}/.env — ${n} secret(s) generated.`);
+                }
+                else {
+                    printWarning('Continuing without .env — setup.sh will abort if it stays missing.');
+                }
+            }
+            // 7c. Run the deploy with a bounded auto-fix + retry loop (see runDeployWithRetry).
+            const { succeeded, runParams } = await runDeployWithRetry(spec, url, cwd, params, aiOpts, options);
+            if (!succeeded) {
+                process.exitCode = 1;
+                return;
+            }
+            printSuccess('Deploy command completed.');
+            // 7d. SES post-deploy guidance (async DKIM + sandbox + bounce topic).
+            // SES is provisioned BY DEFAULT on AWS deploys, so surface the guidance
+            // for ec2/eks unless the operator opted out with --no-email.
+            const sesProvisioned = (target === 'ec2' || target === 'eks') && runParams.noEmail !== true;
+            if (sesProvisioned) {
+                printSection('SES — next steps');
+                for (const line of sesPostDeployGuidance())
+                    printInfo(`• ${line}`);
+            }
+            // 7e. Verify health (CREATE_COMPLETE != serving).
+            if (url) {
+                printSection('Verifying health');
+                // Minikube reaches the gateway via a kubectl port-forward that setup.sh
+                // backgrounds and that can die/fail to bind — (re)start it before polling
+                // so we don't sit at the gate on a dead forward while the pods are fine.
+                if (target === 'minikube') {
+                    await ensureMinikubeGateway(url, { onInfo: (m) => printInfo(m) });
+                }
+                printInfo(`Polling ${url}/health …`);
+                // Fresh EKS legitimately needs longer than the 300s default: Karpenter provisions
+                // nodes, ~10 services cold-pull images, the ALB provisions (~2-3 min), and the
+                // Route 53 alias propagates. Give it 15 min before surfacing the not-reachable note.
+                const healthTimeoutMs = target === 'eks' ? 900_000 : undefined;
+                const health = await waitHealthy(url, { timeoutMs: healthTimeoutMs, onTick: (m) => printInfo(m) });
+                // Green only when fully ready; a "health OK but /ready never came" proceed-
+                // anyway state is healthy:true but degraded → warn so it doesn't read as done.
+                (health.healthy && health.ready ? printSuccess : printWarning)(`${health.url} — ${health.detail}`);
+            }
+            // 7f. Post-install steps (register + opt-in loads, smoke test, events, custom).
+            // See runPostSteps — it surfaces register + the events bundle as manual in-VPC
+            // next-steps on EC2/EKS instead of auto-running (and failing) them locally.
+            // autoRun (skip the second confirm) only when the user actually PICKED a load in the
+            // interactive prompt — declining every load shouldn't silently run register unprompted.
+            const autoRanLoads = willPromptLoads && enabledLoadIds.length > 0;
+            await runPostSteps(postSteps, skippedSteps, target, cwd, adminEnv, { yes: options.yes, autoRun: autoRanLoads, autoInit: postStepFlags.autoInit });
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'provision', executionId },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../src/commands/provision.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { readFileSync, existsSync } from 'fs';\nimport * as path from 'node:path';\nimport * as readline from 'node:readline/promises';\nimport { Command } from 'commander';\nimport { diagnoseFailure, isAiConfigured, parseGoal } from '../agent/ai.js';\nimport { bootstrapCommand, resolveBootstrap, type BootstrapSpec } from '../agent/bootstrap.js';\nimport { createEnvFile, envFileMissing } from '../agent/env-file.js';\nimport { entrypointExists, executionBlocked, runScript } from '../agent/executor.js';\nimport { deriveHealthUrl, waitHealthy, ensureMinikubeGateway } from '../agent/health.js';\nimport { checkHostPorts, discoverHostPorts, stackRunning } from '../agent/ports.js';\nimport { resolvePostSteps, type PostStep, type SkippedStep } from '../agent/post-steps.js';\nimport { checkPrereqs, gitAvailable, gitSupportsSparseCheckout, prereqsSatisfied } from '../agent/prereqs.js';\nimport {\n  assembleCommand,\n  isTargetId,\n  LOAD_STEPS,\n  sparsePathsFor,\n  TARGETS,\n  TARGET_IDS,\n  teardownCommand,\n  type TargetId,\n  type TargetSpec,\n} from '../agent/targets.js';\nimport { TOOLS_DIR, fetchTool, isFetchable, withToolsOnPath } from '../agent/tools.js';\nimport { matchIssues, sesPostDeployGuidance } from '../agent/troubleshoot.js';\nimport { shellQuote } from '../config/cli.constants.js';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printSection, printKeyValue, printInfo, printWarning, printError, printSuccess } from '../utils/output-utils.js';\n\n/**\n * Post-deploy initialization mode (the single `--init <mode>` flag):\n *   - `auto`   — init-platform runs once the platform is up (register admin + load plugins/\n *                compliance/samples). On ec2 the instance does it itself on first boot; on\n *                local/minikube/eks `provision` runs it for you. This is the DEFAULT.\n *   - `manual` — don't self-init; surface the exact step for you to run yourself.\n *   - `skip`   — don't initialize at all (no register, no loads).\n */\nexport type InitMode = 'auto' | 'manual' | 'skip';\nconst INIT_MODES: readonly InitMode[] = ['auto', 'manual', 'skip'];\n\n/**\n * Resolve the init mode from the new `--init <mode>` flag, falling back to the DEPRECATED\n * aliases (`--no-init` → skip, `--auto-init` → auto, `--no-auto-init` → manual), then the\n * default (`auto`). Returns `null` when `--init` was given an invalid value (caller errors).\n */\nexport function resolveInitMode(options: { init?: unknown; autoInit?: unknown }): InitMode | null {\n  if (typeof options.init === 'string') { // --init <mode>\n    const m = options.init.toLowerCase() as InitMode;\n    return INIT_MODES.includes(m) ? m : null;\n  }\n  if (options.init === false) return 'skip'; // deprecated --no-init\n  if (options.autoInit === true) return 'auto'; // deprecated --auto-init\n  if (options.autoInit === false) return 'manual'; // deprecated --no-auto-init\n  return 'auto'; // default\n}\n\n/**\n * Read one line of trimmed input from the terminal, owning the readline\n * lifecycle. Used directly for the destructive teardown gate (a y/N is too easy\n * to fat-finger, so we require the operator to TYPE the target id back), and as\n * the basis for `confirm`. Deliberately has no auto-accept.\n */\nasync function ask(question: string): Promise<string> {\n  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });\n  try {\n    return (await rl.question(question)).trim();\n  } finally {\n    rl.close();\n  }\n}\n\n/** Interactive y/N confirmation; auto-true when `autoYes` (the `--yes` flag). */\nasync function confirm(question: string, autoYes: boolean): Promise<boolean> {\n  if (autoYes) return true;\n  const answer = (await ask(`${question} [y/N] `)).toLowerCase();\n  return answer === 'y' || answer === 'yes';\n}\n\n/** Commander collector: accumulate repeated `--post-step` values in order. */\nfunction collectStep(value: string, acc: string[]): string[] {\n  return [...acc, value];\n}\n\n/**\n * Host-port pre-flight (local/minikube). Ports are DERIVED from the target's cloned\n * deploy source (compose / setup.sh) so the list can't drift — hence this runs AFTER\n * the clone. A taken port makes a container/forward fail to bind mid-deploy (for the\n * gateway, a silent unreachable hang). Prints a ✓/✗ summary and returns false ONLY\n * when the caller must ABORT (a fatal local conflict). minikube ports are managed\n * forwards (setup.sh pkills/restarts them), so a conflict there warns but proceeds.\n * Remote targets (ec2/eks) bind nothing locally → returns true.\n */\nexport async function preflightPorts(spec: TargetSpec, target: TargetId, cwd: string): Promise<boolean> {\n  const ports = discoverHostPorts(target, cwd, spec);\n  if (ports.length === 0) return true;\n  const portChecks = await checkHostPorts(ports);\n  const taken = portChecks.filter((c) => !c.available);\n  printSection('Port availability');\n  for (const c of portChecks) printInfo(`${c.available ? '✓' : '✗'} ${String(c.port).padEnd(5)} — ${c.service}`);\n  if (taken.length === 0) return true;\n  // local PUBLISHES these ports at `docker compose up` time, so a conflict is fatal.\n  // minikube's are kubectl port-forwards setup.sh pkills + restarts (and\n  // ensureMinikubeGateway recovers), so a stale forward must NOT block a re-run.\n  const fatal = target === 'docker';\n  // …UNLESS the local stack is already running: those ports are held by YOUR OWN\n  // stack, and `docker compose up` no-ops them — this is exactly how you re-run to\n  // add loads/options. Don't block (the would-be conflict is a self-conflict).\n  if (fatal && stackRunning(target, cwd, spec)) {\n    printWarning(`\\n${taken.length} port(s) are held by your already-running ${spec.label} stack — re-running just resumes it (no real conflict), so continuing.`);\n    return true;\n  }\n  const lead = `${taken.length} required port(s) already in use: ${taken.map((c) => c.port).join(', ')}`;\n  (fatal ? printError : printWarning)(fatal\n    ? `\\n${lead} — the deploy can't bind them and would fail mid-way. Free them and re-run:`\n    : `\\n${lead} — on minikube these are usually a previous run's port-forwards (setup.sh restarts them). Free any NON-minikube holder if the gateway stays unreachable:`);\n  for (const c of taken) printInfo(`  • port ${c.port} (${c.service}) — find the holder:  lsof -i :${c.port}`);\n  if (taken.some((c) => c.port === 5000)) {\n    printInfo('  Note: on macOS, port 5000 is usually AirPlay Receiver — System Settings → General → AirDrop & Handoff → AirPlay Receiver (off).');\n  }\n  return !fatal;\n}\n\n/**\n * Teardown mode — the destroy counterpart of provisioning, gated HARDER than deploy:\n * AWS targets are irreversible, so the operator must TYPE the target id (--force\n * bypasses for CI; --yes alone does NOT). Terminal: owns its output + exitCode.\n */\nexport async function runTeardown(\n  spec: TargetSpec,\n  target: TargetId,\n  cwd: string,\n  executionId: string,\n  opts: { stackName?: string; clusterName?: string; region?: string; domain?: string; hostedZoneId?: string; force?: boolean; yes?: boolean; json?: boolean },\n): Promise<void> {\n  const { command: downCommand, destructive } = teardownCommand(target, {\n    stackName: opts.stackName,\n    clusterName: opts.clusterName,\n    region: opts.region,\n    // eks teardown (bin/shutdown.sh) also cleans up the ACM cert + Route 53 alias for\n    // the domain, so forward them when present.\n    domain: opts.domain,\n    hostedZoneId: opts.hostedZoneId,\n    // Our typed gate IS the confirmation — assumeYes forwards a native `--yes` to any\n    // script-based teardown (ec2 delete-stack has no prompt; eks shutdown.sh skips its own).\n    assumeYes: true,\n  });\n  if (opts.json) {\n    console.log(JSON.stringify({ success: true, executionId, target, teardown: true, destructive, destroys: spec.destroys, command: downCommand }, null, 2));\n    return;\n  }\n  printSection(`Teardown plan — ${spec.label}`);\n  printKeyValue({ 'Target': target, 'Destroys': spec.destroys, 'Stops cost': spec.cost });\n  printSection('Command to run');\n  printInfo(downCommand);\n  if (destructive && !opts.force) {\n    // Bind the confirmation to the resource actually destroyed: a custom name (ec2\n    // --stack-name / eks --cluster-name) must be typed verbatim so a wrong name can't be\n    // confirmed by habit; otherwise the target id.\n    const resourceName = target === 'eks' ? opts.clusterName : opts.stackName;\n    const confirmToken = resourceName ?? target;\n    const noun = target === 'eks' ? (opts.clusterName ? 'cluster name' : 'target id') : (opts.stackName ? 'stack name' : 'target id');\n    const token = await ask(`\\nThis is IRREVERSIBLE. Type \"${confirmToken}\" to confirm teardown: `);\n    if (token !== confirmToken) {\n      printWarning(`That didn't match, so nothing was destroyed — you have to type the exact ${noun} to confirm.`);\n      return;\n    }\n  } else if (!destructive && !opts.force && !(await confirm('\\nProceed with teardown (stops the stack; on-disk data persists)?', opts.yes ?? false))) {\n    printWarning('No problem — nothing was changed.');\n    return;\n  }\n  printSection('Tearing down');\n  const { code: downCode } = await runScript(downCommand, cwd, { capture: false });\n  if (downCode !== 0) {\n    printError(`\\nTeardown failed (exit ${downCode}). Inspect the stack/containers and retry.`);\n    process.exitCode = 1;\n    return;\n  }\n  printSuccess('Teardown complete.');\n}\n\n/**\n * Run the deploy command (real, secrets unmasked, streamed + captured) with a\n * bounded auto-fix + retry loop — the deploy scripts are idempotent, so a fixed\n * re-run resumes rather than starting over. Returns whether it succeeded plus the\n * (possibly fix-adjusted) params, which the caller needs for SES guidance.\n */\nexport async function runDeployWithRetry(\n  spec: TargetSpec,\n  url: string | null,\n  cwd: string,\n  params: Record<string, unknown>,\n  aiOpts: { provider?: string; model?: string },\n  opts: { retries?: string; yes?: boolean },\n): Promise<{ succeeded: boolean; runParams: Record<string, unknown> }> {\n  // Bound retries so an unattended `--yes` run can't auto-re-run a 15–30 min\n  // deploy an unbounded number of times on a persistently-retryable signature.\n  const MAX_RETRIES = 5;\n  const requestedRetries = Math.max(0, parseInt(opts.retries ?? '', 10) || 0);\n  const maxAttempts = 1 + Math.min(requestedRetries, MAX_RETRIES);\n  let runParams: Record<string, unknown> = params;\n  let succeeded = false;\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    const realCommand = assembleCommand(spec, runParams, { mask: false }).command;\n    printSection(attempt === 1 ? 'Deploying' : `Deploying — retry ${attempt - 1}`);\n    if (attempt === 1) {\n      printInfo(`Deploying ${spec.label} → ${url}`);\n      printInfo(spec.deploys);\n      printInfo('Streaming the deploy below — first run is the slow one (image pulls + cert generation).');\n    }\n    const { code, tail } = await runScript(realCommand, cwd, { capture: true });\n    if (code === 0) { succeeded = true; break; }\n\n    printError(`\\nDeploy failed (exit ${code}).`);\n    const issues = matchIssues(tail);\n    if (issues.length > 0) {\n      printSection('Likely cause');\n      for (const i of issues) printInfo(`• ${i.cause}\\n  → ${i.suggestion}`);\n    }\n    if (isAiConfigured(aiOpts)) {\n      const diagnosis = await diagnoseFailure(redactSecrets(tail, spec, runParams), aiOpts);\n      if (diagnosis) { printSection('Diagnosis'); printInfo(diagnosis); }\n    }\n    if (attempt >= maxAttempts) break;\n\n    // Auto-fix: a retryable issue with a param we haven't already applied.\n    const fix = issues.find((i) => i.retryable && i.paramFix && runParams[i.paramFix.key] !== i.paramFix.value);\n    if (fix?.paramFix && await confirm(`\\nApply fix and retry — ${fix.suggestion}`, opts.yes ?? false)) {\n      runParams = { ...runParams, [fix.paramFix.key]: fix.paramFix.value };\n      continue;\n    }\n    // Retryable but no param change (e.g. ACM DNS propagation) — offer a plain re-run.\n    if (!fix && issues.some((i) => i.retryable) && await confirm('\\nRetry the deploy (safe to re-run — it resumes where it left off)?', opts.yes ?? false)) {\n      continue;\n    }\n    break;\n  }\n  return { succeeded, runParams };\n}\n\n/**\n * Execute the post-install steps (register → loads → smoke → events → custom). On\n * EC2/EKS the register step + the events bundle (store-token → setup-events) are\n * SURFACED as ordered manual next-steps instead of auto-run: ec2 register must run\n * ON the box (the minikube user owns the cluster), and the events bundle needs a\n * registered platform + AWS creds. (eks register itself port-forwards, so it runs\n * from anywhere with kubectl access.) Sets exitCode on a step failure.\n */\nexport async function runPostSteps(\n  postSteps: PostStep[],\n  skippedSteps: SkippedStep[],\n  target: TargetId,\n  cwd: string,\n  adminEnv: Record<string, string>,\n  opts: { yes?: boolean; autoRun?: boolean; autoInit?: boolean },\n): Promise<void> {\n  // AWS targets with `--init auto`: the deploy self-runs init-platform, so there's no\n  // register/loads step to surface here — confirm it and point at where to watch.\n  if (opts.autoInit && target === 'ec2') {\n    printInfo('\\n✓ Init mode: auto — the instance runs init-platform itself on first boot');\n    printInfo('  (register admin + build bootstrap image + load plugins/compliance/samples).');\n    printInfo('  It takes ~30-60 min; watch progress:');\n    printInfo('    aws ssm start-session --target <InstanceId>   # InstanceId stack output');\n    printInfo('    sudo tail -f /var/log/user-data.log');\n  } else if (opts.autoInit && target === 'eks') {\n    printInfo('\\n✓ Init mode: auto — setup.sh runs init-platform in its final phase');\n    printInfo('  (register admin + build bootstrap image + load plugins/compliance/samples,');\n    printInfo('  over a kubectl port-forward). Pass --init manual to run it yourself instead.');\n  }\n  if (postSteps.length === 0) return;\n  for (const s of skippedSteps) printWarning(`Skipped post-step ${s.id}: ${s.reason}`);\n  const isRemote = (id: string): boolean =>\n    (target === 'ec2' || target === 'eks') && (id === 'register' || id.startsWith('store-token') || id === 'events');\n  const runnable = postSteps.filter((s) => !isRemote(s.id));\n  const remote = postSteps.filter((s) => isRemote(s.id));\n  if (remote.length > 0) {\n    if (target === 'ec2') {\n      // EC2 runs the platform as a dedicated `minikube` user inside the instance: the\n      // cluster, its kubeconfig, and the jwt-secret all belong to that user, and the\n      // register step builds+pushes images against it. So it MUST run on the box as\n      // `minikube` — print the exact landing sequence rather than a bare command.\n      printInfo('\\nNext — finish setup ON the instance (it builds images + reads the cluster, so it');\n      printInfo('cannot run from here). Land on the box, become the `minikube` user, then run it:');\n      printInfo('  aws ssm start-session --target <InstanceId>      # InstanceId stack output');\n      printInfo('  sudo -iu minikube                                # owns the cluster + docker');\n      printInfo('  cd /opt/pipeline/pipeline-builder                # the deployed checkout');\n      for (const s of remote) printInfo(`  ${s.command}`);\n    } else {\n      // eks: init-platform port-forwards to svc/nginx, so register runs from anywhere with\n      // kubectl access — no in-VPC requirement and no waiting on the ALB/DNS. (A --with-events\n      // bundle, if present, additionally needs AWS creds + a registered platform.)\n      printInfo('\\nNext — run with kubectl access to the cluster (in this order):');\n      for (const s of remote) printInfo(`  • ${s.label} — ${s.command}`);\n    }\n  }\n  if (runnable.length === 0) return;\n  // When the loads were picked interactively (autoRun), the user already opted in — skip\n  // the redundant second confirm. Flag-driven / non-interactive runs still gate here.\n  if (opts.autoRun || await confirm(`\\nRun ${runnable.length} post-install step(s) now?`, opts.yes ?? false)) {\n    if (opts.autoRun) printInfo(`\\nRunning the ${runnable.length} post-install step(s) you selected…`);\n    for (const s of runnable) {\n      printSection(`Post-step: ${s.label}`);\n      // register (local/minikube) logs into the platform, so it needs the admin creds\n      // (PLATFORM_IDENTIFIER / PLATFORM_PASSWORD) on top of its step env.\n      const needsCreds = s.id === 'register' || s.id.startsWith('store-token');\n      const env = needsCreds ? { ...s.env, ...adminEnv } : s.env;\n      // Loads/smoke are noisy + non-interactive → run QUIET (capture, show only on\n      // failure). Exception: a register with no admin creds prompts, so it must stream.\n      const interactiveRegister = s.id === 'register' && !adminEnv.PLATFORM_IDENTIFIER;\n      const quiet = !interactiveRegister;\n      if (quiet) printInfo(`${s.command}\\n  …running (output shown only if it fails)`);\n      else printInfo(s.command);\n      const { code, tail } = await runScript(s.command, cwd, { quiet, capture: false, env });\n      if (code !== 0) {\n        if (quiet && tail) { printError('\\n--- last output ---'); printInfo(tail); }\n        printError(`\\nPost-step '${s.id}' failed (exit ${code}). The platform is deployed; fix and re-run the step manually.`);\n        process.exitCode = 1;\n        break;\n      }\n      printSuccess(`${s.id} ✓`);\n    }\n  } else {\n    printInfo('\\nSkipped post-install steps. Run the commands above manually when ready.');\n  }\n}\n\n/**\n * Sparse-clone the platform repo (when --repo, or accepted via the interactive\n * offer), repoint cwd into it, and verify the deploy entrypoint exists. Owns the\n * cwd/bootstrapped state. Sets exitCode on a hard failure (clone error / missing\n * entrypoint), matching the old inline behavior; a plain decline leaves exitCode\n * untouched. Returns ok:false when the caller must abort.\n */\nexport async function bootstrapAndLocate(\n  spec: TargetSpec,\n  bootstrap: BootstrapSpec,\n  bootstrapCmd: string | null,\n  sparsePaths: readonly string[],\n  startCwd: string,\n  opts: { yes?: boolean },\n): Promise<{ cwd: string; bootstrapped: boolean; ok: boolean }> {\n  let cwd = startCwd;\n  let bootstrapped = false;\n  // Shared by `--repo` and the interactive offer. Repoints cwd + sets bootstrapped;\n  // `bootstrapped` records whether we created the clone (vs. an existing checkout) —\n  // only then can the caller additively sparse-fetch load folders.\n  const bootstrapClone = async (): Promise<boolean> => {\n    const cmd = bootstrapCommand(bootstrap);\n    printSection('Bootstrap');\n    printInfo(cmd);\n    const { code } = await runScript(cmd, cwd, { capture: false });\n    if (code !== 0) {\n      printError(`\\nThe clone didn't finish (exit ${code}). Double-check the repo URL / ref (or your network) and give it another go.`);\n      process.exitCode = 1;\n      return false;\n    }\n    cwd = path.resolve(cwd, bootstrap.workdir);\n    bootstrapped = true;\n    printSuccess(`Repo is ready — continuing from ${cwd}`);\n    const absent = sparsePaths.filter((p) => !existsSync(path.join(cwd, p)));\n    if (absent.length > 0) {\n      printError(`\\nThe sparse clone is missing ${absent.join(', ')} — that ref may not have those folders. Try a different --ref.`);\n      process.exitCode = 1;\n      return false;\n    }\n    return true;\n  };\n\n  // `--repo`: clone up front (must precede the entrypoint check).\n  if (bootstrapCmd) {\n    printInfo(`\\nBootstrap → clone ${bootstrap.repo} @ ${bootstrap.ref} into ${bootstrap.workdir} (sparse).`);\n    if (!(await confirm('Go ahead with the clone?', opts.yes ?? false))) {\n      printWarning('No problem — nothing was changed. Re-run whenever you\\'re ready.');\n      return { cwd, bootstrapped, ok: false };\n    }\n    if (!(await bootstrapClone())) return { cwd, bootstrapped, ok: false };\n  }\n\n  // The deploy entrypoint must exist relative to cwd. If it doesn't and we haven't\n  // bootstrapped, gracefully OFFER to clone (interactive only) so a fresh machine can\n  // proceed without re-running with --repo.\n  if (!entrypointExists(spec, cwd)) {\n    const interactive = Boolean(process.stdin.isTTY) && !opts.yes;\n    if (!bootstrapCmd && interactive && gitAvailable()) {\n      printInfo(`\\nLooks like you're not inside a pipeline-builder checkout, so the ${spec.label} deploy scripts aren't here yet.`);\n      if (await confirm(`Want me to sparse-clone them into ${bootstrap.workdir} and keep going?`, false)) {\n        if (!(await bootstrapClone())) return { cwd, bootstrapped, ok: false };\n      }\n    }\n    if (!entrypointExists(spec, cwd)) {\n      printWarning(`\\nI couldn't find ${spec.dir}/${spec.entrypoint} from ${cwd}.`);\n      printInfo('Two easy ways forward:');\n      printInfo('  • cd into your pipeline-builder checkout and re-run, or');\n      printInfo(`  • add --repo and I'll bootstrap a fresh sparse clone for you${gitAvailable() ? '.' : ' (once git is installed).'}`);\n      process.exitCode = 1;\n      return { cwd, bootstrapped, ok: false };\n    }\n  }\n  return { cwd, bootstrapped, ok: true };\n}\n\n/**\n * Interactive opt-in loads, offered AFTER the clone (so we only ask once the operator\n * has agreed to proceed). Prompts per load, additively sparse-fetches the picked\n * folders into a bootstrapped sparse clone, then re-resolves the post-install steps\n * with the selections. Returns the chosen ids + the recomputed steps.\n */\nexport async function resolveLoadsInteractively(\n  target: TargetId,\n  url: string | null,\n  region: string | undefined,\n  cwd: string,\n  bootstrapped: boolean,\n  bootstrap: BootstrapSpec,\n  postStepFlags: { init: boolean; autoInit: boolean; buildBootstrap: boolean; smokeTest: boolean; events: boolean; steps: string[] },\n): Promise<{ enabledLoadIds: string[]; steps: PostStep[]; skipped: SkippedStep[] }> {\n  const prompts: Record<string, string> = {\n    plugins: 'Load plugins?',\n    samples: 'Load sample pipeline templates?',\n    compliance: 'Load compliance rules?',\n  };\n  printSection('Optional post-install loads');\n  const chosen: string[] = [];\n  for (const s of LOAD_STEPS) {\n    if (await confirm(prompts[s.id] ?? `Load ${s.id}?`, false)) chosen.push(s.id);\n  }\n  // Additive sparse re-sync: materialize ONLY the picked loads' folders (the partial\n  // clone fetches their blobs on demand). Only when we created a SPARSE clone — a\n  // normal checkout already has every folder, and the git<2.27 full-clone fallback\n  // (bootstrap.full) is non-sparse, where `sparse-checkout add` would switch it to\n  // cone mode and PRUNE the already-materialized deploy folders.\n  if (bootstrapped && !bootstrap.full) {\n    const absent = sparsePathsFor(target, chosen).filter((p) => !existsSync(path.join(cwd, p)));\n    if (absent.length > 0) {\n      printSection('Fetching selected load folders');\n      const addCmd = `git sparse-checkout add ${absent.map((p) => `'${p}'`).join(' ')} && git checkout ${shellQuote(bootstrap.ref)}`;\n      printInfo(addCmd);\n      const { code } = await runScript(addCmd, cwd, { capture: false });\n      if (code !== 0) {\n        printWarning(`Couldn't fetch ${absent.join(', ')} — the matching load step(s) may fail. Re-run with --repo to refresh the clone.`);\n      }\n    }\n  }\n  const resolved = resolvePostSteps({\n    target,\n    url,\n    region,\n    enabledLoadIds: chosen,\n    ...postStepFlags,\n    buildBootstrap: postStepFlags.buildBootstrap || chosen.includes('plugins'),\n  });\n  return { enabledLoadIds: chosen, steps: resolved.steps, skipped: resolved.skipped };\n}\n\n/**\n * Redact secret param values (e.g. the ghcr token) from captured deploy output\n * before it is sent to the LLM for diagnosis. The deploy runs with secrets\n * unmasked, so although the current scripts don't echo them, this keeps a future\n * script's stray echo (or a verbose sub-tool) from crossing the third-party-LLM\n * boundary.\n */\nfunction redactSecrets(text: string, spec: TargetSpec, params: Record<string, unknown>): string {\n  let out = text;\n  for (const input of [...spec.required, ...spec.optional]) {\n    if (!input.secret) continue;\n    const value = params[input.key];\n    if (typeof value === 'string' && value.length >= 4) out = out.split(value).join('***');\n  }\n  return out;\n}\n\n/**\n * Registers the `provision` command — an AI-assisted installer for the Pipeline\n * Builder PLATFORM (local/minikube/EC2/EKS). It prints the assembled plan\n * (prereq checks, NL-goal parsing, command assembly) and then DEPLOYS, gated by\n * confirmation prompts (`--yes` to auto-accept; `--json` is the only non-executing\n * mode, printing the plan for tooling). With `--repo` it can bootstrap a fresh\n * machine by sparsely cloning only the deploy folders the selected target +\n * options need, then runs post-install steps (register admin, opt-in loads,\n * smoke test, custom commands). `--teardown` removes a deployment instead.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function provision(program: Command): void {\n  program\n    .command('provision')\n    .description('AI-assisted installer for the platform (local/minikube/EC2/EKS): deploys it (gated by confirmation prompts), or --teardown to remove')\n    .option('-t, --target <target>', `Deploy target: ${TARGET_IDS.join(' | ')}`)\n    .option('-p, --prompt <text>', 'Natural-language goal (parsed into params when an AI key is set)')\n    .option('--region <region>', 'AWS region (EC2/EKS)')\n    .option('--domain <domain>', 'Fully-qualified domain name (EC2/EKS)')\n    .option('--hosted-zone-id <id>', 'Public Route 53 hosted zone ID (EC2/EKS)')\n    .option('--deploy-mode <mode>', 'public | private (EC2/EKS)')\n    .option('--key-pair <name>', 'EC2 key pair (EC2)')\n    .option('--instance-type <type>', 'EC2 instance type (EC2)')\n    .option('--lean', 'EC2: trim optional observability/admin services so the core stack + mesh fits a t3.xlarge (pair with --instance-type t3.xlarge)')\n    .option('--ghcr-token <token>', 'GitHub PAT (read:packages) — masked in output')\n    .option('--email', 'Enable SES transactional email (on by default for AWS)')\n    .option('--no-email', 'Skip SES (transactional email is provisioned by default on AWS)')\n    .option('--email-from <addr>', 'SES From address')\n    .option('--email-from-name <name>', 'SES From display name')\n    .option('--alert-email <addr>', 'Subscribe an address to the bounce/complaint SNS topic')\n    .option('--skip-ses-identity', 'Skip SES identity creation (domain already verified)')\n    .option('--ai-provider <provider>', 'AI provider (anthropic|openai|google|xai|bedrock)')\n    .option('--model <model>', 'AI model id')\n    .option('--diagnose <file>', 'Diagnose a CloudFormation/deploy failure from a file (needs an AI key)')\n    .option('-y, --yes', 'Auto-accept all confirmation prompts (for CI / non-interactive)', false)\n    .option('--retries <n>', 'Auto-fix + retry attempts after a failure (deploy scripts are idempotent)', '1')\n    .option('--teardown', 'Tear down an existing deployment instead of creating one (gated; AWS targets require a typed confirmation)', false)\n    .option('--stack-name <name>', 'CloudFormation stack name (EC2) for the deploy AND teardown — defaults to pipeline-builder (set it to run a second environment)')\n    .option('--cluster-name <name>', 'EKS cluster name for the deploy AND teardown — defaults to pipeline-builder')\n    .option('--force', 'Skip the teardown typed-confirmation (DANGEROUS — for CI/automation only)', false)\n    .option('--init <mode>', 'Post-deploy initialization: auto (DEFAULT — register admin + load plugins/compliance/samples; on ec2 the instance does it itself on first boot), manual (don\\'t self-init — surface the step for you to run, e.g. to set real admin creds), or skip (do nothing). local/minikube/eks run init via provision unless skip.')\n    // Deprecated aliases — kept working for back-compat; --init is the documented form.\n    .option('--no-init', '[deprecated] alias for --init skip')\n    .option('--auto-init', '[deprecated] alias for --init auto')\n    .option('--no-auto-init', '[deprecated] alias for --init manual')\n    // Bootstrap (sparse clone) — provision a fresh machine in one command.\n    .option('--repo [url]', 'Bootstrap: git-clone the platform repo first (sparse — only the needed deploy folders), then run from it (no value = the upstream default)')\n    .option('--ref <ref>', 'Git branch/tag to check out when bootstrapping (default: main)')\n    .option('--workdir <dir>', 'Directory to clone into / run from when bootstrapping (default: pipeline-builder)')\n    // Post-install loads — each opt-in step also adds its deploy folder to the sparse clone.\n    .option('--with-plugins', 'Post-install: build + load plugins (adds deploy/plugins, deploy/codebuild)', false)\n    .option('--with-compliance', 'Post-install: load sample compliance rules/policies (adds deploy/compliance)', false)\n    .option('--with-samples', 'Post-install: load sample pipeline templates (adds deploy/samples)', false)\n    .option('--with-all', 'Post-install: plugins + compliance + samples', false)\n    .option('--build-bootstrap', 'Build + publish the CodeBuild bootstrap image during register (adds deploy/codebuild)', false)\n    .option('--with-smoke-test', 'Post-install: read-only API reachability check', false)\n    .option('--with-events', 'Post-install (AWS): event ingestion bundle — store-token (JWT → Secrets Manager) then setup-events (EventBridge/Lambda)', false)\n    .option('--post-step <cmd>', 'Run an extra command after the loads (repeatable, in order)', collectStep, [])\n    .option('--admin-email <addr>', 'Admin email for non-interactive register (sets PLATFORM_IDENTIFIER)')\n    .option('--admin-password <pw>', 'Admin password for non-interactive register (sets PLATFORM_PASSWORD)')\n    .option('--json', 'Print the plan as JSON and exit WITHOUT running (the only non-executing mode — for tooling/CI inspection)', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Provision');\n\n      try {\n        // Resolve the single post-deploy init mode (auto|manual|skip) from --init or its\n        // deprecated aliases. Two internal signals derive from it: whether init happens at\n        // all, and whether the DEPLOY self-runs it (vs. we surface it).\n        const initMode = resolveInitMode(options);\n        if (initMode === null) {\n          printError(`Invalid --init value '${String(options.init)}'. Use one of: ${INIT_MODES.join(' | ')}.`);\n          process.exitCode = 1;\n          return;\n        }\n        const initEnabled = initMode !== 'skip'; // skip → no register/loads at all\n        const selfInit = initMode === 'auto'; // auto → the deploy initializes itself\n\n        // 1. Assemble params from explicit flags (flags always win over NL parse).\n        const params: Record<string, unknown> = {\n          region: options.region,\n          domain: options.domain,\n          hostedZoneId: options.hostedZoneId,\n          deployMode: options.deployMode,\n          keyPair: options.keyPair,\n          instanceType: options.instanceType,\n          // ec2 LEAN mode (boolean) → assembleCommand emits `--lean`, which setup.sh\n          // forwards to the CFN `Lean` param. Only ec2's spec lists it; other targets ignore it.\n          lean: options.lean === true,\n          // Deploy-time resource identity: ec2 emits --stack-name (key stackName), eks emits\n          // --cluster-name (key clusterName). Both also drive teardown. Undefined → defaults.\n          stackName: options.stackName,\n          clusterName: options.clusterName,\n          ghcrToken: options.ghcrToken,\n          // email/noEmail are coerced AFTER the NL merge below — parseGoal can return\n          // `email`, so pre-coercing here (never-undefined) would let the merge's\n          // `=== undefined` guard silently drop an AI-parsed email choice. Left out of\n          // this literal on purpose; resolved a few lines down.\n          emailFrom: options.emailFrom,\n          emailFromName: options.emailFromName,\n          alertEmail: options.alertEmail,\n          noCreateSesIdentity: options.skipSesIdentity,\n          // The AWS deploys self-init by default (ec2 on first boot, eks in setup.sh's final\n          // phase), so we emit the load-bearing `--no-auto-init` when the mode is NOT auto\n          // (manual/skip = \"don't let the deploy init itself\"). `--auto-init` (a no-op reaffirm)\n          // is never emitted. Only ec2/eks carry these flags in their spec; other targets ignore it.\n          noAutoInit: !selfInit,\n        };\n        const aiOpts = { provider: options.aiProvider, model: options.model };\n\n        // Bootstrap (sparse clone) + post-install selections.\n        const wantBootstrap = options.repo !== undefined && options.repo !== false;\n        const withAll = options.withAll === true;\n        const anyLoadFlag = withAll || LOAD_STEPS.some((s) => options[s.flag] === true);\n        let enabledLoadIds: string[] = LOAD_STEPS.filter((s) => withAll || options[s.flag] === true).map((s) => s.id);\n        // With no --with-* flags, an interactive run offers each load — but AFTER the\n        // clone, so the questions come once you've agreed to proceed (not up front).\n        // Each picked load's folder is then fetched via an additive sparse re-sync.\n        // Flags / --yes / --json / non-interactive shells skip the prompts.\n        let willPromptLoads = !options.yes && !options.json && Boolean(process.stdin.isTTY) && !anyLoadFlag;\n        const postStepFlags = {\n          init: initEnabled,\n          // selfInit (mode auto) drops the surfaced register step on the AWS targets in\n          // resolvePostSteps, so a self-initializing ec2/eks deploy doesn't also print a manual\n          // register step. For manual mode (or local/minikube) the register step is surfaced.\n          autoInit: selfInit,\n          buildBootstrap: options.buildBootstrap === true || enabledLoadIds.includes('plugins'),\n          smokeTest: options.withSmokeTest === true,\n          events: options.withEvents === true,\n          steps: (options.postStep ?? []) as string[],\n        };\n        // Admin credentials forwarded as env so register runs non-interactively.\n        const adminEnv: Record<string, string> = {};\n        if (typeof options.adminEmail === 'string') adminEnv.PLATFORM_IDENTIFIER = options.adminEmail;\n        if (typeof options.adminPassword === 'string') adminEnv.PLATFORM_PASSWORD = options.adminPassword;\n\n        // 2. Optionally parse a natural-language goal to fill any GAPS (best-effort).\n        let target: TargetId | undefined = isTargetId(options.target) ? options.target : undefined;\n        if (options.prompt) {\n          if (isAiConfigured(aiOpts)) {\n            const parsed = await parseGoal(options.prompt, aiOpts);\n            if (parsed) {\n              if (!target && isTargetId(parsed.target)) target = parsed.target;\n              for (const [k, v] of Object.entries(parsed)) {\n                if (k !== 'target' && params[k] === undefined && v !== undefined) params[k] = v;\n              }\n            }\n          } else if (!options.json) {\n            // Don't print human text before a --json plan (it would corrupt the stream).\n            printWarning('A --prompt was given but no AI key is set — ignoring it and using flags only. Set ANTHROPIC_API_KEY (or --ai-provider + its key).');\n          }\n        }\n\n        // Resolve email NOW (after the NL merge): an explicit --email/--no-email flag wins,\n        // else an AI-parsed `email` (merged into params.email above) decides, else default-on.\n        // Coerce to the two load-bearing keys assembleCommand emits.\n        const emailChoice = options.email !== undefined\n          ? options.email\n          : (typeof params.email === 'boolean' ? params.email : undefined);\n        params.email = emailChoice === true;\n        params.noEmail = emailChoice === false;\n\n        // 3. Optional failure diagnosis (independent of a deploy plan).\n        if (options.diagnose) {\n          let failureText: string;\n          try {\n            failureText = readFileSync(options.diagnose, 'utf-8');\n          } catch {\n            printError(`Cannot read --diagnose file: ${options.diagnose}`);\n            process.exitCode = 1;\n            return;\n          }\n          const diagnosis = isAiConfigured(aiOpts) ? await diagnoseFailure(failureText, aiOpts) : null;\n          // With --json, the diagnosis IS the machine-readable output — emit it\n          // alone (don't also print text, which would corrupt the JSON stream).\n          if (options.json) {\n            console.log(JSON.stringify({ success: true, executionId, diagnosis }, null, 2));\n            return;\n          }\n          if (diagnosis) {\n            printSection('Failure diagnosis');\n            printInfo(diagnosis);\n          } else {\n            printWarning('Diagnosis unavailable (no AI key configured or the model could not be reached).');\n          }\n          // --diagnose is a read-only inspection mode: return whether or not a target was\n          // given, so it never falls through into a (possibly --yes) deploy.\n          return;\n        }\n\n        // With `--init auto` (the default) the EC2 instance loads plugins/compliance/samples\n        // itself on the box (bootstrap.sh hardcodes LOAD_*=y), so the local load picker — and\n        // the load-folder fetch it triggers — is pointless. Skip both (the instance has its\n        // own checkout).\n        if (selfInit && target === 'ec2') {\n          willPromptLoads = false;\n          enabledLoadIds = [];\n        } else if (selfInit && target === 'eks' && !anyLoadFlag) {\n          // `--init auto` on eks initializes like ec2: NO interactive picker — default to\n          // loading ALL of plugins + compliance + samples (setup.sh's final phase hardcodes\n          // LOAD_*=y). setup.sh runs the loads itself (over a kubectl port-forward), but we\n          // still resolve them here so the sparse clone fetches the folders setup.sh builds\n          // from. Explicit `--with-*` flags override; `--init manual` / `--init skip` opt out.\n          willPromptLoads = false;\n          enabledLoadIds = LOAD_STEPS.map((s) => s.id);\n          postStepFlags.buildBootstrap = options.buildBootstrap === true || enabledLoadIds.includes('plugins');\n        }\n        // minikube/local keep the interactive picker (local-dev; no `--init auto` load parity).\n\n        // 4. Need a target to assemble a plan.\n        if (!target) {\n          printError(`No target specified. Pass --target <${TARGET_IDS.join('|')}> or describe the goal with --prompt.`);\n          process.exitCode = 1;\n          return;\n        }\n\n        const spec = TARGETS[target];\n        let cwd = process.cwd();\n\n        // 4b. Teardown mode — the destroy counterpart of provisioning (see runTeardown).\n        if (options.teardown) {\n          await runTeardown(spec, target, cwd, executionId, options);\n          return;\n        }\n\n        // Make previously-fetched single-binary tools (e.g. yq) visible to the\n        // prereq checks + the deploy — they live in the tools cache, not on the\n        // system PATH. (Both `has()` and the deploy's `bash -lc` inherit this.)\n        withToolsOnPath();\n        // Hard-require plugin prereqs (e.g. yq on minikube) only when plugins is EXPLICITLY\n        // selected — NOT on the willPromptLoads guess, which would block/prompt before the\n        // user has even been asked whether they want plugins. If they pick plugins in the\n        // interactive prompt, we re-check + offer to fetch right after that selection (below).\n        let prereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: enabledLoadIds.includes('plugins') });\n        const { command, missing } = assembleCommand(spec, params);\n        const url = deriveHealthUrl(target, params);\n\n        // Sparse bootstrap clone command (common base + target + selected loads).\n        // Interactive loads are chosen AFTER the clone, so the clone stays minimal —\n        // each picked load's folder is fetched then via an additive sparse re-sync.\n        const sparsePaths = sparsePathsFor(target, enabledLoadIds);\n        const bootstrap = resolveBootstrap(\n          { repo: typeof options.repo === 'string' ? options.repo : undefined, ref: options.ref, workdir: options.workdir, full: !gitSupportsSparseCheckout() },\n          sparsePaths,\n        );\n        const bootstrapCmd = wantBootstrap ? bootstrapCommand(bootstrap) : null;\n\n        // Resolve post-install steps (register → smoke → events → custom). Re-resolved\n        // after the post-clone load prompts (see below) when those run interactively.\n        let { steps: postSteps, skipped: skippedSteps } = resolvePostSteps({\n          target,\n          url,\n          region: typeof params.region === 'string' ? params.region : undefined,\n          enabledLoadIds,\n          ...postStepFlags,\n        });\n\n        if (options.json) {\n          console.log(JSON.stringify({\n            success: true,\n            executionId,\n            target,\n            prereqs,\n            prereqsSatisfied: prereqsSatisfied(prereqs),\n            missingInputs: missing.map((m) => ({ flag: m.flag, description: m.description })),\n            bootstrap: bootstrapCmd,\n            sparsePaths: wantBootstrap ? sparsePaths : null,\n            command,\n            postSteps: postSteps.map((s) => ({ id: s.id, label: s.label, command: s.command })),\n            skippedPostSteps: skippedSteps,\n          }, null, 2));\n          return;\n        }\n\n        // 5. Print the plan (shown before the gated execution below).\n        printSection(`Provision plan — ${spec.label}`);\n        printKeyValue({ 'Target': target, 'Best for': spec.bestFor, 'Cost': spec.cost });\n\n        printSection('Prerequisites');\n        for (const c of prereqs) printInfo(`${c.ok ? '✓' : '✗'} ${c.name} — ${c.detail}`);\n        if (!prereqsSatisfied(prereqs)) printWarning('Resolve the failing prerequisites above before deploying.');\n\n        if (missing.length > 0) {\n          printSection('Missing required inputs');\n          for (const m of missing) printInfo(`  --${m.flag}  (${m.description})`);\n        }\n\n        if (bootstrapCmd) {\n          printSection('Bootstrap (sparse git clone, runs first)');\n          printInfo(`Clone ${bootstrap.repo} @ ${bootstrap.ref} → ${bootstrap.workdir}; folders: ${sparsePaths.join(', ')}`);\n          printInfo(bootstrapCmd);\n        }\n\n        printSection('Command to run');\n        printInfo(command);\n\n        if (postSteps.length > 0 || skippedSteps.length > 0) {\n          printSection('Post-install steps');\n          for (const s of postSteps) printInfo(`• ${s.label}\\n    ${s.command}`);\n          for (const s of skippedSteps) printWarning(`Skipped ${s.id}: ${s.reason}`);\n        }\n\n        // 6. Any missing required prereq that's a single static binary (e.g. yq)\n        // can be fetched into the tools cache instead of a system install — no\n        // brew/apt. Offer it, then re-check (the cache dir is already on PATH).\n        const fetchable = prereqs.filter((c) => !c.ok && c.required && isFetchable(c.name));\n        if (fetchable.length > 0) {\n          const names = fetchable.map((c) => c.name).join(', ');\n          if (await confirm(`\\n${names} not installed — fetch the official static binary into ${TOOLS_DIR} (no system install)?`, options.yes)) {\n            for (const c of fetchable) {\n              printInfo(`Fetching ${c.name}…`);\n              if (!fetchTool(c.name)) printWarning(`Couldn't fetch ${c.name} — install it manually and re-run.`);\n            }\n            prereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: enabledLoadIds.includes('plugins') });\n          }\n        }\n\n        // 7b. Gated execution. Check prereqs / required inputs first — this also\n        // catches a missing `git` when bootstrapping.\n        const blocked = executionBlocked(prereqs, missing);\n        if (blocked) {\n          printError(`Can't start just yet — ${blocked}. Resolve that and re-run.`);\n          process.exitCode = 1;\n          return;\n        }\n\n        // Commit gate — confirm BEFORE any side effect (clone, .env, deploy) so a \"No\"\n        // leaves nothing behind. The port check + optional loads + .env below are part of\n        // executing the agreed-to plan.\n        if (!(await confirm(`\\nProceed with provisioning ${spec.label}?`, options.yes))) {\n          printWarning('No problem — nothing was changed.');\n          return;\n        }\n\n        // 7a/7b. Sparse-clone (if --repo or accepted interactively) + locate the deploy\n        // entrypoint, repointing cwd into the clone. See bootstrapAndLocate.\n        const located = await bootstrapAndLocate(spec, bootstrap, bootstrapCmd, sparsePaths, cwd, options);\n        cwd = located.cwd;\n        const bootstrapped = located.bootstrapped;\n        if (!located.ok) return;\n\n        // Host-port pre-flight — now that the deploy source is on disk (post-clone),\n        // derive the ports from it (compose / setup.sh) and stop on a fatal conflict\n        // before deploying. See preflightPorts.\n        if (!(await preflightPorts(spec, target, cwd))) {\n          process.exitCode = 1;\n          return;\n        }\n\n        // Opt-in loads — offered AFTER the clone (see resolveLoadsInteractively); it\n        // prompts, additively sparse-fetches the picked folders, and re-resolves the\n        // post-install steps with the selections.\n        if (willPromptLoads) {\n          const loaded = await resolveLoadsInteractively(\n            target,\n            url,\n            typeof params.region === 'string' ? params.region : undefined,\n            cwd,\n            bootstrapped,\n            bootstrap,\n            postStepFlags,\n          );\n          enabledLoadIds = loaded.enabledLoadIds;\n          postSteps = loaded.steps;\n          skippedSteps = loaded.skipped;\n          // Now that plugins may have been picked, re-check the plugin-specific prereqs we\n          // deliberately didn't hard-require up front (e.g. yq for minikube plugin builds).\n          // Offer to fetch any fetchable one; warn (don't block — the platform still deploys)\n          // if it can't be resolved, so the later plugin build doesn't fail opaquely.\n          if (enabledLoadIds.includes('plugins')) {\n            const pluginPrereqs = checkPrereqs(target, { bootstrap: wantBootstrap, withPlugins: true });\n            const pluginGaps = pluginPrereqs.filter((c) => !c.ok && c.required && !prereqs.some((p) => p.name === c.name));\n            for (const c of pluginGaps) {\n              if (isFetchable(c.name) && await confirm(`\\n${c.name} is needed to build plugins but isn't installed — fetch the static binary into ${TOOLS_DIR}?`, options.yes)) {\n                printInfo(`Fetching ${c.name}…`);\n                if (!fetchTool(c.name)) printWarning(`Couldn't fetch ${c.name} — install it before the plugin build runs.`);\n              } else {\n                printWarning(`${c.name} missing — the plugin load/build step may fail. ${c.detail}`);\n              }\n            }\n          }\n        }\n        // local/minikube's setup.sh REQUIRES a `.env` and aborts without it — create\n        // it from .env.example with generated secrets so the deploy is non-interactive.\n        // ec2 and eks don't have provision generate a local `.env`: ec2 bootstraps its\n        // secrets on the instance, and eks's setup.sh creates the k8s secrets itself\n        // (a deploy/aws/eks/.env.example + secret step is a setup.sh TODO).\n        if ((target === 'docker' || target === 'minikube') && envFileMissing(cwd, spec.dir)) {\n          if (await confirm(`\\n${spec.dir}/.env not found — create it from .env.example (generates secrets; edit later for optional integrations like OAuth)?`, options.yes)) {\n            const n = createEnvFile(cwd, spec.dir);\n            printSuccess(`Created ${spec.dir}/.env — ${n} secret(s) generated.`);\n          } else {\n            printWarning('Continuing without .env — setup.sh will abort if it stays missing.');\n          }\n        }\n        // 7c. Run the deploy with a bounded auto-fix + retry loop (see runDeployWithRetry).\n        const { succeeded, runParams } = await runDeployWithRetry(spec, url, cwd, params, aiOpts, options);\n        if (!succeeded) { process.exitCode = 1; return; }\n        printSuccess('Deploy command completed.');\n\n        // 7d. SES post-deploy guidance (async DKIM + sandbox + bounce topic).\n        // SES is provisioned BY DEFAULT on AWS deploys, so surface the guidance\n        // for ec2/eks unless the operator opted out with --no-email.\n        const sesProvisioned = (target === 'ec2' || target === 'eks') && runParams.noEmail !== true;\n        if (sesProvisioned) {\n          printSection('SES — next steps');\n          for (const line of sesPostDeployGuidance()) printInfo(`• ${line}`);\n        }\n\n        // 7e. Verify health (CREATE_COMPLETE != serving).\n        if (url) {\n          printSection('Verifying health');\n          // Minikube reaches the gateway via a kubectl port-forward that setup.sh\n          // backgrounds and that can die/fail to bind — (re)start it before polling\n          // so we don't sit at the gate on a dead forward while the pods are fine.\n          if (target === 'minikube') {\n            await ensureMinikubeGateway(url, { onInfo: (m) => printInfo(m) });\n          }\n          printInfo(`Polling ${url}/health …`);\n          // Fresh EKS legitimately needs longer than the 300s default: Karpenter provisions\n          // nodes, ~10 services cold-pull images, the ALB provisions (~2-3 min), and the\n          // Route 53 alias propagates. Give it 15 min before surfacing the not-reachable note.\n          const healthTimeoutMs = target === 'eks' ? 900_000 : undefined;\n          const health = await waitHealthy(url, { timeoutMs: healthTimeoutMs, onTick: (m) => printInfo(m) });\n          // Green only when fully ready; a \"health OK but /ready never came\" proceed-\n          // anyway state is healthy:true but degraded → warn so it doesn't read as done.\n          (health.healthy && health.ready ? printSuccess : printWarning)(`${health.url} — ${health.detail}`);\n        }\n\n        // 7f. Post-install steps (register + opt-in loads, smoke test, events, custom).\n        // See runPostSteps — it surfaces register + the events bundle as manual in-VPC\n        // next-steps on EC2/EKS instead of auto-running (and failing) them locally.\n        // autoRun (skip the second confirm) only when the user actually PICKED a load in the\n        // interactive prompt — declining every load shouldn't silently run register unprompted.\n        const autoRanLoads = willPromptLoads && enabledLoadIds.length > 0;\n        await runPostSteps(postSteps, skippedSteps, target, cwd, adminEnv, { yes: options.yes, autoRun: autoRanLoads, autoInit: postStepFlags.autoInit });\n      } catch (error) {\n        handleError(error, ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'provision', executionId },\n        });\n      }\n    });\n}\n"]}