@pipeline-builder/pipeline-manager 3.4.69 → 3.4.71

package/dist/commands/provision.js

@@ -0,0 +1,362 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { readFileSync } from 'fs';
+import * as readline from 'node:readline/promises';
+import { Command } from 'commander';
+import { diagnoseFailure, isAiConfigured, parseGoal } from '../agent/ai.js';
+import { entrypointExists, executionBlocked, runScript } from '../agent/executor.js';
+import { deriveHealthUrl, waitHealthy } from '../agent/health.js';
+import { checkPrereqs, prereqsSatisfied } from '../agent/prereqs.js';
+import { assembleCommand, isTargetId, TARGETS, TARGET_IDS, teardownCommand, } from '../agent/targets.js';
+import { matchIssues, sesPostDeployGuidance } from '../agent/troubleshoot.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';
+/**
+ * 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';
+}
+/**
+ * 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 advisor that helps deploy the Pipeline
+ * Builder PLATFORM (local/minikube/EC2/Fargate). Phase 1 is READ-ONLY: it checks
+ * prerequisites, parses a natural-language goal (when an AI key is configured),
+ * assembles the exact deploy command, and can diagnose a failure — but it never
+ * executes anything (gated execution lands in a later phase).
+ *
+ * @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/Fargate): advise, --execute to deploy, 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/Fargate)')
+        .option('--domain <domain>', 'Fully-qualified domain name (EC2/Fargate)')
+        .option('--hosted-zone-id <id>', 'Public Route 53 hosted zone ID (EC2/Fargate)')
+        .option('--deploy-mode <mode>', 'public | private (EC2/Fargate)')
+        .option('--key-pair <name>', 'EC2 key pair (EC2)')
+        .option('--instance-type <type>', 'EC2 instance type (EC2)')
+        .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 the execution approval prompt (for CI / non-interactive)', false)
+        .option('--execute', 'Run the deploy (gated: needs approval, refuses on failed prereqs / missing inputs)', 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>', 'Stack name (EC2) / stack prefix (Fargate) to tear down — defaults to the deploy default')
+        .option('--force', 'Skip the teardown typed-confirmation (DANGEROUS — for CI/automation only)', false)
+        .option('--no-init', 'Skip the post-deploy init-platform step (local/minikube)')
+        .option('--json', 'Output the plan as JSON (never executes)', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Provision (advisor)');
+        try {
+            // 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,
+                ghcrToken: options.ghcrToken,
+                // Commander tri-states `email`: undefined (neither), true (--email),
+                // false (--no-email). SES is on by default, so only --no-email is
+                // load-bearing (it emits `--no-email` into the deploy command).
+                email: options.email === true,
+                noEmail: options.email === false,
+                emailFrom: options.emailFrom,
+                emailFromName: options.emailFromName,
+                alertEmail: options.alertEmail,
+                noCreateSesIdentity: options.skipSesIdentity,
+            };
+            const aiOpts = { provider: options.aiProvider, model: options.model };
+            // 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 {
+                    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).');
+                }
+            }
+            // 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).');
+                }
+                if (!target)
+                    return;
+            }
+            // 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];
+            const cwd = process.cwd();
+            // 4b. Teardown mode — the destroy counterpart of provisioning. Gated harder
+            // than deploy: AWS targets are irreversible, so we require the operator to
+            // TYPE the target id (--force bypasses for CI; --yes alone does NOT).
+            if (options.teardown) {
+                const { command: downCommand, destructive } = teardownCommand(target, {
+                    stackName: options.stackName,
+                    region: options.region,
+                    // Our typed gate IS the confirmation — forward --yes so the native
+                    // script (Fargate) doesn't also block on stdin we're inheriting.
+                    assumeYes: true,
+                });
+                if (options.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 (!options.execute) {
+                    printWarning('\nAdvisor mode — nothing was executed. Re-run with --execute to tear down.');
+                    return;
+                }
+                if (destructive && !options.force) {
+                    const token = await ask(`\nThis is IRREVERSIBLE. Type "${target}" to confirm teardown: `);
+                    if (token !== target) {
+                        printWarning('Confirmation did not match — aborted. Nothing was destroyed.');
+                        return;
+                    }
+                }
+                else if (!destructive && !options.force && !(await confirm('\nProceed with teardown (stops the stack; on-disk data persists)?', options.yes))) {
+                    printWarning('Aborted — nothing was executed.');
+                    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.');
+                return;
+            }
+            const prereqs = checkPrereqs(target);
+            const { command, missing } = assembleCommand(spec, params);
+            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 })),
+                    command,
+                    postDeploy: spec.postDeploy ?? null,
+                }, null, 2));
+                return;
+            }
+            // 5. Print the plan (shared by advisor + execute).
+            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})`);
+            }
+            printSection('Command to run');
+            printInfo(command);
+            // 6. Advisor mode (default) — stop here, nothing executed.
+            if (!options.execute) {
+                if (spec.postDeploy) {
+                    printInfo('\nThen initialize the platform (register admin + load plugins):');
+                    printInfo(`  ${spec.postDeploy}`);
+                }
+                printWarning('\nAdvisor mode — nothing was executed. Re-run with --execute to deploy (gated by approval).');
+                return;
+            }
+            // 7. Gated execution.
+            if (!entrypointExists(spec, cwd)) {
+                printError(`Cannot find ${spec.dir}/${spec.entrypoint} from here. Run --execute from the pipeline-builder repo root.`);
+                process.exitCode = 1;
+                return;
+            }
+            const blocked = executionBlocked(prereqs, missing);
+            if (blocked) {
+                printError(`Refusing to execute — ${blocked}.`);
+                process.exitCode = 1;
+                return;
+            }
+            if (!(await confirm('\nProceed with this deploy?', options.yes))) {
+                printWarning('Aborted — nothing was executed.');
+                return;
+            }
+            // 7a. Run the deploy out-of-loop (real command, 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.
+            const maxAttempts = 1 + Math.max(0, parseInt(options.retries, 10) || 0);
+            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}`);
+                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}`, options.yes)) {
+                    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 (it is idempotent and will resume)?', options.yes)) {
+                    continue;
+                }
+                break;
+            }
+            if (!succeeded) {
+                process.exitCode = 1;
+                return;
+            }
+            printSuccess('Deploy command completed.');
+            // 7b. SES post-deploy guidance (async DKIM + sandbox + bounce topic).
+            // SES is provisioned BY DEFAULT on AWS deploys, so surface the guidance
+            // for ec2/fargate unless the operator opted out with --no-email.
+            const sesProvisioned = (target === 'ec2' || target === 'fargate') && runParams.noEmail !== true;
+            if (sesProvisioned) {
+                printSection('SES — next steps');
+                for (const line of sesPostDeployGuidance())
+                    printInfo(`• ${line}`);
+            }
+            // 7c. Verify health (CREATE_COMPLETE != serving).
+            const url = deriveHealthUrl(target, runParams);
+            if (url) {
+                printSection('Verifying health');
+                printInfo(`Polling ${url}/health …`);
+                const health = await waitHealthy(url, { onTick: (m) => printInfo(m) });
+                (health.healthy ? printSuccess : printWarning)(`${health.url} — ${health.detail}`);
+            }
+            // 7d. Initialize the platform (register admin + load plugins).
+            if (options.init === false) {
+                printInfo('\nSkipped init-platform (--no-init). Run it later to register admin + load plugins.');
+            }
+            else if (target === 'local' || target === 'minikube') {
+                if (await confirm('\nRun init-platform now (register admin + load plugins)?', options.yes)) {
+                    printSection('Initializing platform');
+                    await runScript(`./deploy/bin/init-platform.sh ${target}`, cwd);
+                }
+                else {
+                    printInfo(`\nLater: ./deploy/bin/init-platform.sh ${target}`);
+                }
+            }
+            else {
+                // EC2/Fargate: init must run from inside the VPC, not the operator machine.
+                printInfo('\nNext (from inside the VPC): register admin + load plugins —');
+                printInfo(`  ${spec.postDeploy}`);
+            }
+        }
+        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 } from 'fs';\nimport * as readline from 'node:readline/promises';\nimport { Command } from 'commander';\nimport { diagnoseFailure, isAiConfigured, parseGoal } from '../agent/ai.js';\nimport { entrypointExists, executionBlocked, runScript } from '../agent/executor.js';\nimport { deriveHealthUrl, waitHealthy } from '../agent/health.js';\nimport { checkPrereqs, prereqsSatisfied } from '../agent/prereqs.js';\nimport {\n  assembleCommand,\n  isTargetId,\n  TARGETS,\n  TARGET_IDS,\n  teardownCommand,\n  type TargetId,\n  type TargetSpec,\n} from '../agent/targets.js';\nimport { matchIssues, sesPostDeployGuidance } from '../agent/troubleshoot.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 * 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/**\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 advisor that helps deploy the Pipeline\n * Builder PLATFORM (local/minikube/EC2/Fargate). Phase 1 is READ-ONLY: it checks\n * prerequisites, parses a natural-language goal (when an AI key is configured),\n * assembles the exact deploy command, and can diagnose a failure — but it never\n * executes anything (gated execution lands in a later phase).\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/Fargate): advise, --execute to deploy, 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/Fargate)')\n    .option('--domain <domain>', 'Fully-qualified domain name (EC2/Fargate)')\n    .option('--hosted-zone-id <id>', 'Public Route 53 hosted zone ID (EC2/Fargate)')\n    .option('--deploy-mode <mode>', 'public | private (EC2/Fargate)')\n    .option('--key-pair <name>', 'EC2 key pair (EC2)')\n    .option('--instance-type <type>', 'EC2 instance type (EC2)')\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 the execution approval prompt (for CI / non-interactive)', false)\n    .option('--execute', 'Run the deploy (gated: needs approval, refuses on failed prereqs / missing inputs)', 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>', 'Stack name (EC2) / stack prefix (Fargate) to tear down — defaults to the deploy default')\n    .option('--force', 'Skip the teardown typed-confirmation (DANGEROUS — for CI/automation only)', false)\n    .option('--no-init', 'Skip the post-deploy init-platform step (local/minikube)')\n    .option('--json', 'Output the plan as JSON (never executes)', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Provision (advisor)');\n\n      try {\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          ghcrToken: options.ghcrToken,\n          // Commander tri-states `email`: undefined (neither), true (--email),\n          // false (--no-email). SES is on by default, so only --no-email is\n          // load-bearing (it emits `--no-email` into the deploy command).\n          email: options.email === true,\n          noEmail: options.email === false,\n          emailFrom: options.emailFrom,\n          emailFromName: options.emailFromName,\n          alertEmail: options.alertEmail,\n          noCreateSesIdentity: options.skipSesIdentity,\n        };\n        const aiOpts = { provider: options.aiProvider, model: options.model };\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 {\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        // 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          if (!target) return;\n        }\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        const cwd = process.cwd();\n\n        // 4b. Teardown mode — the destroy counterpart of provisioning. Gated harder\n        // than deploy: AWS targets are irreversible, so we require the operator to\n        // TYPE the target id (--force bypasses for CI; --yes alone does NOT).\n        if (options.teardown) {\n          const { command: downCommand, destructive } = teardownCommand(target, {\n            stackName: options.stackName,\n            region: options.region,\n            // Our typed gate IS the confirmation — forward --yes so the native\n            // script (Fargate) doesn't also block on stdin we're inheriting.\n            assumeYes: true,\n          });\n\n          if (options.json) {\n            console.log(JSON.stringify({ success: true, executionId, target, teardown: true, destructive, destroys: spec.destroys, command: downCommand }, null, 2));\n            return;\n          }\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\n          if (!options.execute) {\n            printWarning('\\nAdvisor mode — nothing was executed. Re-run with --execute to tear down.');\n            return;\n          }\n\n          if (destructive && !options.force) {\n            const token = await ask(`\\nThis is IRREVERSIBLE. Type \"${target}\" to confirm teardown: `);\n            if (token !== target) {\n              printWarning('Confirmation did not match — aborted. Nothing was destroyed.');\n              return;\n            }\n          } else if (!destructive && !options.force && !(await confirm('\\nProceed with teardown (stops the stack; on-disk data persists)?', options.yes))) {\n            printWarning('Aborted — nothing was executed.');\n            return;\n          }\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          return;\n        }\n\n        const prereqs = checkPrereqs(target);\n        const { command, missing } = assembleCommand(spec, params);\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            command,\n            postDeploy: spec.postDeploy ?? null,\n          }, null, 2));\n          return;\n        }\n\n        // 5. Print the plan (shared by advisor + execute).\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        printSection('Command to run');\n        printInfo(command);\n\n        // 6. Advisor mode (default) — stop here, nothing executed.\n        if (!options.execute) {\n          if (spec.postDeploy) {\n            printInfo('\\nThen initialize the platform (register admin + load plugins):');\n            printInfo(`  ${spec.postDeploy}`);\n          }\n          printWarning('\\nAdvisor mode — nothing was executed. Re-run with --execute to deploy (gated by approval).');\n          return;\n        }\n\n        // 7. Gated execution.\n        if (!entrypointExists(spec, cwd)) {\n          printError(`Cannot find ${spec.dir}/${spec.entrypoint} from here. Run --execute from the pipeline-builder repo root.`);\n          process.exitCode = 1;\n          return;\n        }\n        const blocked = executionBlocked(prereqs, missing);\n        if (blocked) {\n          printError(`Refusing to execute — ${blocked}.`);\n          process.exitCode = 1;\n          return;\n        }\n        if (!(await confirm('\\nProceed with this deploy?', options.yes))) {\n          printWarning('Aborted — nothing was executed.');\n          return;\n        }\n\n        // 7a. Run the deploy out-of-loop (real command, secrets unmasked, streamed +\n        // captured), with a bounded auto-fix + retry loop — the deploy scripts are\n        // idempotent, so a fixed re-run resumes rather than starting over.\n        const maxAttempts = 1 + Math.max(0, parseInt(options.retries, 10) || 0);\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          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}`, options.yes)) {\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 (it is idempotent and will resume)?', options.yes)) {\n            continue;\n          }\n          break;\n        }\n        if (!succeeded) { process.exitCode = 1; return; }\n        printSuccess('Deploy command completed.');\n\n        // 7b. 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/fargate unless the operator opted out with --no-email.\n        const sesProvisioned = (target === 'ec2' || target === 'fargate') && runParams.noEmail !== true;\n        if (sesProvisioned) {\n          printSection('SES — next steps');\n          for (const line of sesPostDeployGuidance()) printInfo(`• ${line}`);\n        }\n\n        // 7c. Verify health (CREATE_COMPLETE != serving).\n        const url = deriveHealthUrl(target, runParams);\n        if (url) {\n          printSection('Verifying health');\n          printInfo(`Polling ${url}/health …`);\n          const health = await waitHealthy(url, { onTick: (m) => printInfo(m) });\n          (health.healthy ? printSuccess : printWarning)(`${health.url} — ${health.detail}`);\n        }\n\n        // 7d. Initialize the platform (register admin + load plugins).\n        if (options.init === false) {\n          printInfo('\\nSkipped init-platform (--no-init). Run it later to register admin + load plugins.');\n        } else if (target === 'local' || target === 'minikube') {\n          if (await confirm('\\nRun init-platform now (register admin + load plugins)?', options.yes)) {\n            printSection('Initializing platform');\n            await runScript(`./deploy/bin/init-platform.sh ${target}`, cwd);\n          } else {\n            printInfo(`\\nLater: ./deploy/bin/init-platform.sh ${target}`);\n          }\n        } else {\n          // EC2/Fargate: init must run from inside the VPC, not the operator machine.\n          printInfo('\\nNext (from inside the VPC): register admin + load plugins —');\n          printInfo(`  ${spec.postDeploy}`);\n        }\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"]}