@pipeline-builder/pipeline-manager 0.0.1

package/dist/agent/targets.js

@@ -0,0 +1,265 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Deterministic registry of platform deploy targets — the source of truth the
+ * `provision` advisor uses to assemble the EXACT deploy command. The agent is a
+ * thin wrapper over the existing deploy scripts; it never reimplements
+ * deployment, only validates inputs and assembles the command to run.
+ *
+ * Keep this in lock-step with the flags the scripts accept — every target's
+ * operator entrypoint is `bin/setup.sh` (deploy/<target>/bin/setup.sh).
+ */
+import { assertShellSafe, shellQuote } from '../config/cli.constants.js';
+import { resolveAwsRegion } from '../utils/aws-env.js';
+// --- Shared input specs -----------------------------------------------------
+const DOMAIN = { flag: 'domain', key: 'domain', description: 'Fully-qualified domain name (ALB ACM cert + SES DKIM)' };
+const HOSTED_ZONE = { flag: 'hosted-zone-id', key: 'hostedZoneId', description: 'Public Route 53 hosted zone ID authoritative for the domain' };
+const GHCR_TOKEN = { flag: 'ghcr-token', key: 'ghcrToken', description: 'GitHub PAT with read:packages (avoids ghcr.io anonymous rate limits)', secret: true };
+const REGION = { flag: 'region', key: 'region', description: 'AWS region' };
+const DEPLOY_MODE = { flag: 'deploy-mode', key: 'deployMode', description: 'public (internet-facing ALB) or private (internal, default)' };
+const KEY_PAIR = { flag: 'key-pair', key: 'keyPair', description: 'EC2 key pair in the region (break-glass serial console; routine access is SSM)' };
+const INSTANCE_TYPE = { flag: 'instance-type', key: 'instanceType', description: 'EC2 instance type (default t3.2xlarge)' };
+// ec2 deploy/teardown stack name (CloudFormation). The `stackName` param key is also reused
+// by the teardown path as the resource identifier (ec2 stack / eks cluster name).
+const STACK_NAME = { flag: 'stack-name', key: 'stackName', description: 'CloudFormation stack name (default pipeline-builder) — set to run a second ec2 environment' };
+// eks cluster name (eksctl). Set to run a second EKS environment in one account.
+const CLUSTER_NAME = { flag: 'cluster-name', key: 'clusterName', description: 'EKS cluster name (default pipeline-builder)' };
+// Auto-init is ON BY DEFAULT on the AWS targets (ec2 + eks setup.sh default AUTO_INIT=true),
+// so `--no-auto-init` is the load-bearing opt-out and `--auto-init` is a no-op reaffirm —
+// mirrors --email/--no-email. ec2 self-inits on the instance on first boot; eks self-inits in
+// setup.sh's final phase (over a kubectl port-forward). minikube/local run init via provision.
+// NOTE: `--no-auto-init`'s key (noAutoInit) is NOT derivable from its flag the way the other
+// specs' keys are (commander folds --x/--no-x into a single `x` option); provision.ts assembles
+// both keys explicitly — see the param-assembly there.
+const AUTO_INIT = { flag: 'auto-init', key: 'autoInit', description: 'ec2/eks: the deploy self-runs init-platform (register + all loads) — the DEFAULT on AWS', boolean: true };
+const NO_AUTO_INIT = { flag: 'no-auto-init', key: 'noAutoInit', description: 'ec2/eks: skip the deploy-managed auto-init and run init-platform manually instead', boolean: true };
+// ec2 only: LEAN drops the optional observability/admin services so the core stack +
+// mesh fits a t3.xlarge instead of t3.2xlarge. Flows through the CFN `Lean` param into
+// the instance's startup.sh. (minikube reads LEAN as an env var; eks doesn't support it.)
+const LEAN = { flag: 'lean', key: 'lean', description: 'ec2: trim optional observability/admin services so the stack fits a t3.xlarge (pair with --instance-type t3.xlarge)', boolean: true };
+// SES / email family — shared by ec2 + eks. SES is provisioned BY DEFAULT
+// on AWS deploys; `--no-email` is the opt-out (`--email` is a harmless no-op kept
+// for back-compat).
+const EMAIL = [
+    { flag: 'email', key: 'email', description: 'Enable SES transactional email (on by default for AWS)', boolean: true },
+    { flag: 'no-email', key: 'noEmail', description: 'Skip SES (transactional email is provisioned by default)', boolean: true },
+    { flag: 'email-from', key: 'emailFrom', description: 'From address (default noreply@<domain>)' },
+    { flag: 'email-from-name', key: 'emailFromName', description: 'Display name on outbound email' },
+    { flag: 'alert-email', key: 'alertEmail', description: 'Subscribe an address to the bounce/complaint SNS topic' },
+    { flag: 'no-create-ses-identity', key: 'noCreateSesIdentity', description: 'Skip SES identity creation (domain already verified)', boolean: true },
+];
+// --- Targets ----------------------------------------------------------------
+export const TARGETS = {
+    docker: {
+        id: 'docker',
+        label: 'Local (Docker Compose)',
+        dir: 'deploy/local/docker',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/local/docker'],
+        required: [],
+        optional: [],
+        postDeploy: './deploy/bin/init-platform.sh docker',
+        cost: 'Free',
+        bestFor: 'Development',
+        deploys: 'the platform as a Docker Compose stack — an nginx TLS proxy, the API services (platform, plugin, pipeline, message, reporting, compliance, quota, billing, image-registry), the frontend, and postgres + mongo + redis. First run pulls the ghcr.io images and generates a local TLS cert (a few minutes).',
+        destroys: 'stops all containers — data under deploy/local/docker/data persists on disk (delete it manually for a clean slate)',
+        // Mirrors the published ports in deploy/local/docker/docker-compose.yml.
+        hostPorts: [
+            { service: 'nginx — HTTPS gateway (UI/API)', port: 8443 },
+            { service: 'nginx — HTTP redirect', port: 8080 },
+            { service: 'pgAdmin (Postgres UI)', port: 5480 },
+            { service: 'Mongo Express (Mongo UI)', port: 27081 },
+            { service: 'Docker registry', port: 5000 },
+            { service: 'Jaeger (tracing UI)', port: 16686 },
+        ],
+    },
+    minikube: {
+        id: 'minikube',
+        label: 'Minikube (local Kubernetes)',
+        dir: 'deploy/local/minikube',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/local/minikube'],
+        required: [],
+        optional: [],
+        postDeploy: './deploy/bin/init-platform.sh minikube',
+        cost: 'Free',
+        bestFor: 'Local Kubernetes',
+        deploys: 'the platform onto a local Minikube cluster — the same services as Kubernetes Deployments/Services behind an ingress, plus in-cluster postgres + mongo + redis. First run pulls images, builds the cluster, and generates a TLS cert (several minutes).',
+        destroys: 'stops the minikube stack — persistent volumes (PVC data) remain until the cluster is deleted',
+        // Mirrors the kubectl port-forwards started in deploy/local/minikube/bin/setup.sh.
+        hostPorts: [
+            { service: 'nginx — HTTPS gateway (UI/API)', port: 8443 },
+            { service: 'Mongo Express (Mongo UI)', port: 8081 },
+            { service: 'pgAdmin (Postgres UI)', port: 5480 },
+        ],
+    },
+    ec2: {
+        id: 'ec2',
+        label: 'AWS EC2 (single Minikube instance behind an ALB)',
+        dir: 'deploy/aws/ec2',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/aws/ec2'],
+        required: [KEY_PAIR, DOMAIN, HOSTED_ZONE],
+        optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, INSTANCE_TYPE, STACK_NAME, AUTO_INIT, NO_AUTO_INIT, LEAN, ...EMAIL],
+        postDeploy: './deploy/bin/init-platform.sh ec2  # auto-runs on the instance by default; --no-auto-init to do it manually',
+        cost: '~$140-265/mo',
+        bestFor: 'Dev / staging',
+        deploys: 'the platform on a single EC2 instance via CloudFormation — a VPC, the instance (running the Minikube stack), an ALB, a Route 53 record + ACM cert for the domain, and (by default) SES email. The instance pulls images on first boot.',
+        destroys: 'DELETES the CloudFormation stack: the VPC, EC2 instance, and its EBS data volume (databases, registry, plugin builds). Irreversible.',
+        hostPorts: [], // remote (AWS) — binds nothing on the operator's machine
+    },
+    eks: {
+        id: 'eks',
+        label: 'AWS EKS Auto Mode (managed Kubernetes)',
+        dir: 'deploy/aws/eks',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/aws/eks'],
+        required: [DOMAIN, HOSTED_ZONE],
+        optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, CLUSTER_NAME, AUTO_INIT, NO_AUTO_INIT, ...EMAIL],
+        postDeploy: './deploy/bin/init-platform.sh eks  # auto-runs at the end of setup.sh by default; --no-auto-init to do it manually',
+        cost: '~$150-400/mo',
+        bestFor: 'Production',
+        deploys: 'the platform on Amazon EKS Auto Mode — an AWS-managed Kubernetes cluster (Karpenter-scaled EC2 nodes, AWS Load Balancer Controller, EBS/EFS CSI), the same Kubernetes workloads as the other k8s targets, an ALB Ingress + ACM for the domain, and (by default) SES email. Plugin builds run on the in-cluster rootless buildkitd (EC2 nodes allow it).',
+        destroys: 'Runs bin/shutdown.sh: DELETES the EKS cluster + nodes (eksctl), the EFS filesystem, and — when --domain is set — the ACM cert + Route 53 alias. EBS volumes on the Retain StorageClass are NOT auto-deleted (reported at the end). Irreversible.',
+        hostPorts: [], // remote (AWS) — binds nothing on the operator's machine
+    },
+};
+export const TARGET_IDS = ['docker', 'minikube', 'ec2', 'eks'];
+export function isTargetId(value) {
+    return typeof value === 'string' && TARGET_IDS.includes(value);
+}
+// --- Sparse bootstrap paths -------------------------------------------------
+/**
+ * Folders every `--repo` bootstrap needs regardless of target: the orchestration
+ * scripts. Each target's setup.sh + init-platform.sh live in / drive these.
+ * Deliberately minimal — heavier folders (plugins/compliance/samples) are pulled
+ * in only when their post-install option is selected (see LOAD_STEPS).
+ */
+export const COMMON_SPARSE_PATHS = ['deploy/bin'];
+/**
+ * Opt-in post-install load steps. Each maps a provision `--with-*` flag to the
+ * init-platform env var that enables it AND the repo folder(s) it reads — so the
+ * sparse checkout grows exactly with the selected options.
+ */
+export const LOAD_STEPS = [
+    // The plugin build reads deploy/plugins/_base AND deploy/codebuild/bootstrap.
+    { id: 'plugins', flag: 'withPlugins', env: 'LOAD_PLUGINS', paths: ['deploy/plugins', 'deploy/codebuild'] },
+    { id: 'compliance', flag: 'withCompliance', env: 'LOAD_COMPLIANCE', paths: ['deploy/compliance'] },
+    { id: 'samples', flag: 'withSamples', env: 'LOAD_TEMPLATES', paths: ['deploy/samples'] },
+];
+/**
+ * The de-duplicated set of sparse paths for a target plus the enabled load
+ * steps: common base ∪ target folder(s) ∪ each enabled step's folder(s).
+ */
+export function sparsePathsFor(target, enabledLoadIds) {
+    const paths = new Set(COMMON_SPARSE_PATHS);
+    for (const p of TARGETS[target].sparsePaths)
+        paths.add(p);
+    for (const step of LOAD_STEPS) {
+        if (enabledLoadIds.includes(step.id))
+            for (const p of step.paths)
+                paths.add(p);
+    }
+    return [...paths];
+}
+/**
+ * Quote only when the value would otherwise be word-split or mis-parsed by the
+ * shell (whitespace or embedded quotes). `assertShellSafe` already rejects the
+ * dangerous metacharacters, so simple tokens stay unquoted for readability.
+ */
+function maybeShellQuote(value) {
+    return /[\s'"]/.test(value) ? shellQuote(value) : value;
+}
+/**
+ * Assemble the deploy command for a target from the provided params. Pure and
+ * deterministic — no shell, no LLM. Missing required inputs are reported (never
+ * guessed). By default secrets are masked (`***`) for DISPLAY; pass `mask: false`
+ * to build the real command for EXECUTION — that string must never be logged or
+ * shown to the model.
+ */
+export function assembleCommand(target, params, opts = {}) {
+    const mask = opts.mask ?? true;
+    const provided = (spec) => {
+        const v = params[spec.key];
+        return v !== undefined && v !== '' && v !== false;
+    };
+    const missing = target.required.filter((spec) => !provided(spec));
+    const parts = [`cd ${target.dir} && bash ${target.entrypoint}`];
+    for (const spec of [...target.required, ...target.optional]) {
+        if (!provided(spec))
+            continue;
+        if (spec.boolean) {
+            parts.push(`--${spec.flag}`);
+            continue;
+        }
+        const raw = String(params[spec.key]);
+        // The assembled command is executed via a shell (runScript), so a param
+        // value carrying shell metacharacters would be command injection. Validate
+        // the REAL value even when masking for display — the executed command uses
+        // the unmasked value. Redact secrets so the error never echoes a token.
+        assertShellSafe(raw, `--${spec.flag}`, { redactValue: spec.secret });
+        // assertShellSafe still permits spaces and quotes (e.g. --email-from-name
+        // "Pipeline Builder", or O'Brien), which would word-split when emitted bare;
+        // quote those so the value reaches the script as a single argument.
+        const value = spec.secret && mask ? '***' : maybeShellQuote(raw);
+        parts.push(`--${spec.flag} ${value}`);
+    }
+    return { command: parts.join(' \\\n  '), missing };
+}
+/** CloudFormation stack name the EC2 setup.sh defaults to. */
+const DEFAULT_EC2_STACK = 'pipeline-builder';
+/** EKS cluster name eksctl defaults to. */
+const DEFAULT_EKS_CLUSTER = 'pipeline-builder';
+/**
+ * Assemble the teardown command for a target. Pure and deterministic — mirrors
+ * `assembleCommand` for the destroy path. local/minikube STOP the stack
+ * (non-destructive — on-disk / PVC data survives); ec2 DELETEs its CloudFormation
+ * stack and eks DELETEs its cluster (eksctl) — both irreversible. EC2 `delete-stack`
+ * and `eksctl delete cluster` have no native prompt, which is exactly why the agent's
+ * typed-confirmation gate is mandatory there.
+ */
+export function teardownCommand(target, opts = {}) {
+    const region = resolveAwsRegion(opts.region);
+    // Anything flowing unquoted into a shell-executed teardown command is rejected
+    // for shell metacharacters (mirrors assembleCommand).
+    assertShellSafe(region, 'region');
+    if (opts.stackName)
+        assertShellSafe(opts.stackName, 'stack-name');
+    if (opts.clusterName)
+        assertShellSafe(opts.clusterName, 'cluster-name');
+    if (opts.domain)
+        assertShellSafe(opts.domain, 'domain');
+    if (opts.hostedZoneId)
+        assertShellSafe(opts.hostedZoneId, 'hosted-zone-id');
+    switch (target) {
+        case 'docker':
+            return { command: 'cd deploy/local/docker && bash bin/shutdown.sh', destructive: false };
+        case 'minikube':
+            return { command: 'cd deploy/local/minikube && bash bin/shutdown.sh', destructive: false };
+        case 'ec2': {
+            const stack = opts.stackName || DEFAULT_EC2_STACK;
+            return {
+                command: `aws cloudformation delete-stack --stack-name ${stack} --region ${region} && ` +
+                    `aws cloudformation wait stack-delete-complete --stack-name ${stack} --region ${region}`,
+                destructive: true,
+            };
+        }
+        case 'eks': {
+            // eks tears down via bin/shutdown.sh (like local/minikube use bin/shutdown.sh):
+            // it deletes the cluster AND the resources eksctl alone would orphan — the EFS
+            // filesystem and, when --domain is given, the ACM cert + Route 53 alias. The
+            // agent's typed-confirmation gate already ran, so pass --yes to skip the
+            // script's own prompt.
+            const cluster = opts.clusterName || DEFAULT_EKS_CLUSTER;
+            let command = `cd deploy/aws/eks && bash bin/shutdown.sh --cluster-name ${cluster} --region ${region}`;
+            if (opts.domain)
+                command += ` --domain ${opts.domain}`;
+            if (opts.hostedZoneId)
+                command += ` --hosted-zone-id ${opts.hostedZoneId}`;
+            if (opts.assumeYes)
+                command += ' --yes';
+            return { command, destructive: true };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"targets.js","sourceRoot":"","sources":["../../src/agent/targets.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Deterministic registry of platform deploy targets — the source of truth the\n * `provision` advisor uses to assemble the EXACT deploy command. The agent is a\n * thin wrapper over the existing deploy scripts; it never reimplements\n * deployment, only validates inputs and assembles the command to run.\n *\n * Keep this in lock-step with the flags the scripts accept — every target's\n * operator entrypoint is `bin/setup.sh` (deploy/<target>/bin/setup.sh).\n */\n\nimport { assertShellSafe, shellQuote } from '../config/cli.constants.js';\nimport { resolveAwsRegion } from '../utils/aws-env.js';\n\nexport type TargetId = 'docker' | 'minikube' | 'ec2' | 'eks';\n\n/** A single input the underlying deploy script accepts. */\nexport interface InputSpec {\n  /** Flag name passed to the script (without the leading `--`). */\n  readonly flag: string;\n  /** Key on the provision params object. */\n  readonly key: string;\n  /** Human description — shown when a required input is missing. */\n  readonly description: string;\n  /** Secret — never printed in the assembled command (masked as `***`). */\n  readonly secret?: boolean;\n  /** Boolean flag with no value (e.g. `--email`). */\n  readonly boolean?: boolean;\n}\n\nexport interface TargetSpec {\n  readonly id: TargetId;\n  readonly label: string;\n  /** Directory the entrypoint runs from (relative to repo root). */\n  readonly dir: string;\n  /** Entrypoint script (relative to `dir`). */\n  readonly entrypoint: string;\n  /** Inputs the script REQUIRES — the advisor reports any that are missing. */\n  readonly required: readonly InputSpec[];\n  /** Optional inputs, passed through only when provided. */\n  readonly optional: readonly InputSpec[];\n  /**\n   * Repo folder(s) this target's deploy needs, for a sparse `--repo` bootstrap.\n   * Combined with COMMON_SPARSE_PATHS and any selected load steps' paths.\n   */\n  readonly sparsePaths: readonly string[];\n  /** Post-deploy step to surface (registers admin + loads plugins). */\n  readonly postDeploy?: string;\n  /** Rough monthly cost (from docs). */\n  readonly cost: string;\n  /** One-line \"best for\". */\n  readonly bestFor: string;\n  /** What the deploy creates — shown when deploying so \"Deploying\" isn't opaque. */\n  readonly deploys: string;\n  /** What a teardown of this target destroys — shown before a (gated) teardown. */\n  readonly destroys: string;\n  /**\n   * Host ports the deploy binds — a FALLBACK only. The live list is DERIVED from the\n   * cloned deploy source at runtime (ports.ts `discoverHostPorts`): local from\n   * docker-compose.yml's published ports, minikube from setup.sh's port-forwards. This\n   * static copy is used only when that source can't be read. Empty for remote targets\n   * (ec2/eks bind nothing on the operator's machine).\n   */\n  readonly hostPorts: readonly { service: string; port: number }[];\n}\n\n// --- Shared input specs -----------------------------------------------------\n\nconst DOMAIN: InputSpec = { flag: 'domain', key: 'domain', description: 'Fully-qualified domain name (ALB ACM cert + SES DKIM)' };\nconst HOSTED_ZONE: InputSpec = { flag: 'hosted-zone-id', key: 'hostedZoneId', description: 'Public Route 53 hosted zone ID authoritative for the domain' };\nconst GHCR_TOKEN: InputSpec = { flag: 'ghcr-token', key: 'ghcrToken', description: 'GitHub PAT with read:packages (avoids ghcr.io anonymous rate limits)', secret: true };\nconst REGION: InputSpec = { flag: 'region', key: 'region', description: 'AWS region' };\nconst DEPLOY_MODE: InputSpec = { flag: 'deploy-mode', key: 'deployMode', description: 'public (internet-facing ALB) or private (internal, default)' };\nconst KEY_PAIR: InputSpec = { flag: 'key-pair', key: 'keyPair', description: 'EC2 key pair in the region (break-glass serial console; routine access is SSM)' };\nconst INSTANCE_TYPE: InputSpec = { flag: 'instance-type', key: 'instanceType', description: 'EC2 instance type (default t3.2xlarge)' };\n// ec2 deploy/teardown stack name (CloudFormation). The `stackName` param key is also reused\n// by the teardown path as the resource identifier (ec2 stack / eks cluster name).\nconst STACK_NAME: InputSpec = { flag: 'stack-name', key: 'stackName', description: 'CloudFormation stack name (default pipeline-builder) — set to run a second ec2 environment' };\n// eks cluster name (eksctl). Set to run a second EKS environment in one account.\nconst CLUSTER_NAME: InputSpec = { flag: 'cluster-name', key: 'clusterName', description: 'EKS cluster name (default pipeline-builder)' };\n// Auto-init is ON BY DEFAULT on the AWS targets (ec2 + eks setup.sh default AUTO_INIT=true),\n// so `--no-auto-init` is the load-bearing opt-out and `--auto-init` is a no-op reaffirm —\n// mirrors --email/--no-email. ec2 self-inits on the instance on first boot; eks self-inits in\n// setup.sh's final phase (over a kubectl port-forward). minikube/local run init via provision.\n// NOTE: `--no-auto-init`'s key (noAutoInit) is NOT derivable from its flag the way the other\n// specs' keys are (commander folds --x/--no-x into a single `x` option); provision.ts assembles\n// both keys explicitly — see the param-assembly there.\nconst AUTO_INIT: InputSpec = { flag: 'auto-init', key: 'autoInit', description: 'ec2/eks: the deploy self-runs init-platform (register + all loads) — the DEFAULT on AWS', boolean: true };\nconst NO_AUTO_INIT: InputSpec = { flag: 'no-auto-init', key: 'noAutoInit', description: 'ec2/eks: skip the deploy-managed auto-init and run init-platform manually instead', boolean: true };\n// ec2 only: LEAN drops the optional observability/admin services so the core stack +\n// mesh fits a t3.xlarge instead of t3.2xlarge. Flows through the CFN `Lean` param into\n// the instance's startup.sh. (minikube reads LEAN as an env var; eks doesn't support it.)\nconst LEAN: InputSpec = { flag: 'lean', key: 'lean', description: 'ec2: trim optional observability/admin services so the stack fits a t3.xlarge (pair with --instance-type t3.xlarge)', boolean: true };\n\n// SES / email family — shared by ec2 + eks. SES is provisioned BY DEFAULT\n// on AWS deploys; `--no-email` is the opt-out (`--email` is a harmless no-op kept\n// for back-compat).\nconst EMAIL: readonly InputSpec[] = [\n  { flag: 'email', key: 'email', description: 'Enable SES transactional email (on by default for AWS)', boolean: true },\n  { flag: 'no-email', key: 'noEmail', description: 'Skip SES (transactional email is provisioned by default)', boolean: true },\n  { flag: 'email-from', key: 'emailFrom', description: 'From address (default noreply@<domain>)' },\n  { flag: 'email-from-name', key: 'emailFromName', description: 'Display name on outbound email' },\n  { flag: 'alert-email', key: 'alertEmail', description: 'Subscribe an address to the bounce/complaint SNS topic' },\n  { flag: 'no-create-ses-identity', key: 'noCreateSesIdentity', description: 'Skip SES identity creation (domain already verified)', boolean: true },\n];\n\n// --- Targets ----------------------------------------------------------------\n\nexport const TARGETS: Readonly<Record<TargetId, TargetSpec>> = {\n  docker: {\n    id: 'docker',\n    label: 'Local (Docker Compose)',\n    dir: 'deploy/local/docker',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/local/docker'],\n    required: [],\n    optional: [],\n    postDeploy: './deploy/bin/init-platform.sh docker',\n    cost: 'Free',\n    bestFor: 'Development',\n    deploys: 'the platform as a Docker Compose stack — an nginx TLS proxy, the API services (platform, plugin, pipeline, message, reporting, compliance, quota, billing, image-registry), the frontend, and postgres + mongo + redis. First run pulls the ghcr.io images and generates a local TLS cert (a few minutes).',\n    destroys: 'stops all containers — data under deploy/local/docker/data persists on disk (delete it manually for a clean slate)',\n    // Mirrors the published ports in deploy/local/docker/docker-compose.yml.\n    hostPorts: [\n      { service: 'nginx — HTTPS gateway (UI/API)', port: 8443 },\n      { service: 'nginx — HTTP redirect', port: 8080 },\n      { service: 'pgAdmin (Postgres UI)', port: 5480 },\n      { service: 'Mongo Express (Mongo UI)', port: 27081 },\n      { service: 'Docker registry', port: 5000 },\n      { service: 'Jaeger (tracing UI)', port: 16686 },\n    ],\n  },\n  minikube: {\n    id: 'minikube',\n    label: 'Minikube (local Kubernetes)',\n    dir: 'deploy/local/minikube',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/local/minikube'],\n    required: [],\n    optional: [],\n    postDeploy: './deploy/bin/init-platform.sh minikube',\n    cost: 'Free',\n    bestFor: 'Local Kubernetes',\n    deploys: 'the platform onto a local Minikube cluster — the same services as Kubernetes Deployments/Services behind an ingress, plus in-cluster postgres + mongo + redis. First run pulls images, builds the cluster, and generates a TLS cert (several minutes).',\n    destroys: 'stops the minikube stack — persistent volumes (PVC data) remain until the cluster is deleted',\n    // Mirrors the kubectl port-forwards started in deploy/local/minikube/bin/setup.sh.\n    hostPorts: [\n      { service: 'nginx — HTTPS gateway (UI/API)', port: 8443 },\n      { service: 'Mongo Express (Mongo UI)', port: 8081 },\n      { service: 'pgAdmin (Postgres UI)', port: 5480 },\n    ],\n  },\n  ec2: {\n    id: 'ec2',\n    label: 'AWS EC2 (single Minikube instance behind an ALB)',\n    dir: 'deploy/aws/ec2',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/aws/ec2'],\n    required: [KEY_PAIR, DOMAIN, HOSTED_ZONE],\n    optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, INSTANCE_TYPE, STACK_NAME, AUTO_INIT, NO_AUTO_INIT, LEAN, ...EMAIL],\n    postDeploy: './deploy/bin/init-platform.sh ec2  # auto-runs on the instance by default; --no-auto-init to do it manually',\n    cost: '~$140-265/mo',\n    bestFor: 'Dev / staging',\n    deploys: 'the platform on a single EC2 instance via CloudFormation — a VPC, the instance (running the Minikube stack), an ALB, a Route 53 record + ACM cert for the domain, and (by default) SES email. The instance pulls images on first boot.',\n    destroys: 'DELETES the CloudFormation stack: the VPC, EC2 instance, and its EBS data volume (databases, registry, plugin builds). Irreversible.',\n    hostPorts: [], // remote (AWS) — binds nothing on the operator's machine\n  },\n  eks: {\n    id: 'eks',\n    label: 'AWS EKS Auto Mode (managed Kubernetes)',\n    dir: 'deploy/aws/eks',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/aws/eks'],\n    required: [DOMAIN, HOSTED_ZONE],\n    optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, CLUSTER_NAME, AUTO_INIT, NO_AUTO_INIT, ...EMAIL],\n    postDeploy: './deploy/bin/init-platform.sh eks  # auto-runs at the end of setup.sh by default; --no-auto-init to do it manually',\n    cost: '~$150-400/mo',\n    bestFor: 'Production',\n    deploys: 'the platform on Amazon EKS Auto Mode — an AWS-managed Kubernetes cluster (Karpenter-scaled EC2 nodes, AWS Load Balancer Controller, EBS/EFS CSI), the same Kubernetes workloads as the other k8s targets, an ALB Ingress + ACM for the domain, and (by default) SES email. Plugin builds run on the in-cluster rootless buildkitd (EC2 nodes allow it).',\n    destroys: 'Runs bin/shutdown.sh: DELETES the EKS cluster + nodes (eksctl), the EFS filesystem, and — when --domain is set — the ACM cert + Route 53 alias. EBS volumes on the Retain StorageClass are NOT auto-deleted (reported at the end). Irreversible.',\n    hostPorts: [], // remote (AWS) — binds nothing on the operator's machine\n  },\n};\n\nexport const TARGET_IDS: readonly TargetId[] = ['docker', 'minikube', 'ec2', 'eks'];\n\nexport function isTargetId(value: unknown): value is TargetId {\n  return typeof value === 'string' && (TARGET_IDS as readonly string[]).includes(value);\n}\n\n// --- Sparse bootstrap paths -------------------------------------------------\n\n/**\n * Folders every `--repo` bootstrap needs regardless of target: the orchestration\n * scripts. Each target's setup.sh + init-platform.sh live in / drive these.\n * Deliberately minimal — heavier folders (plugins/compliance/samples) are pulled\n * in only when their post-install option is selected (see LOAD_STEPS).\n */\nexport const COMMON_SPARSE_PATHS: readonly string[] = ['deploy/bin'];\n\n/**\n * Opt-in post-install load steps. Each maps a provision `--with-*` flag to the\n * init-platform env var that enables it AND the repo folder(s) it reads — so the\n * sparse checkout grows exactly with the selected options.\n */\nexport const LOAD_STEPS = [\n  // The plugin build reads deploy/plugins/_base AND deploy/codebuild/bootstrap.\n  { id: 'plugins', flag: 'withPlugins', env: 'LOAD_PLUGINS', paths: ['deploy/plugins', 'deploy/codebuild'] },\n  { id: 'compliance', flag: 'withCompliance', env: 'LOAD_COMPLIANCE', paths: ['deploy/compliance'] },\n  { id: 'samples', flag: 'withSamples', env: 'LOAD_TEMPLATES', paths: ['deploy/samples'] },\n] as const;\n\nexport type LoadStepId = (typeof LOAD_STEPS)[number]['id'];\n\n/**\n * The de-duplicated set of sparse paths for a target plus the enabled load\n * steps: common base ∪ target folder(s) ∪ each enabled step's folder(s).\n */\nexport function sparsePathsFor(target: TargetId, enabledLoadIds: readonly string[]): string[] {\n  const paths = new Set<string>(COMMON_SPARSE_PATHS);\n  for (const p of TARGETS[target].sparsePaths) paths.add(p);\n  for (const step of LOAD_STEPS) {\n    if (enabledLoadIds.includes(step.id)) for (const p of step.paths) paths.add(p);\n  }\n  return [...paths];\n}\n\nexport interface AssembleResult {\n  /** The exact command to run — secrets masked as `***`. */\n  readonly command: string;\n  /** Required inputs that were not supplied. */\n  readonly missing: readonly InputSpec[];\n}\n\n/**\n * Quote only when the value would otherwise be word-split or mis-parsed by the\n * shell (whitespace or embedded quotes). `assertShellSafe` already rejects the\n * dangerous metacharacters, so simple tokens stay unquoted for readability.\n */\nfunction maybeShellQuote(value: string): string {\n  return /[\\s'\"]/.test(value) ? shellQuote(value) : value;\n}\n\n/**\n * Assemble the deploy command for a target from the provided params. Pure and\n * deterministic — no shell, no LLM. Missing required inputs are reported (never\n * guessed). By default secrets are masked (`***`) for DISPLAY; pass `mask: false`\n * to build the real command for EXECUTION — that string must never be logged or\n * shown to the model.\n */\nexport function assembleCommand(\n  target: TargetSpec,\n  params: Record<string, unknown>,\n  opts: { mask?: boolean } = {},\n): AssembleResult {\n  const mask = opts.mask ?? true;\n  const provided = (spec: InputSpec): boolean => {\n    const v = params[spec.key];\n    return v !== undefined && v !== '' && v !== false;\n  };\n\n  const missing = target.required.filter((spec) => !provided(spec));\n\n  const parts: string[] = [`cd ${target.dir} && bash ${target.entrypoint}`];\n  for (const spec of [...target.required, ...target.optional]) {\n    if (!provided(spec)) continue;\n    if (spec.boolean) {\n      parts.push(`--${spec.flag}`);\n      continue;\n    }\n    const raw = String(params[spec.key]);\n    // The assembled command is executed via a shell (runScript), so a param\n    // value carrying shell metacharacters would be command injection. Validate\n    // the REAL value even when masking for display — the executed command uses\n    // the unmasked value. Redact secrets so the error never echoes a token.\n    assertShellSafe(raw, `--${spec.flag}`, { redactValue: spec.secret });\n    // assertShellSafe still permits spaces and quotes (e.g. --email-from-name\n    // \"Pipeline Builder\", or O'Brien), which would word-split when emitted bare;\n    // quote those so the value reaches the script as a single argument.\n    const value = spec.secret && mask ? '***' : maybeShellQuote(raw);\n    parts.push(`--${spec.flag} ${value}`);\n  }\n\n  return { command: parts.join(' \\\\\\n  '), missing };\n}\n\nexport interface TeardownResult {\n  /** The exact teardown command to run. */\n  readonly command: string;\n  /** Whether this teardown irreversibly destroys data (AWS targets). */\n  readonly destructive: boolean;\n}\n\n/** CloudFormation stack name the EC2 setup.sh defaults to. */\nconst DEFAULT_EC2_STACK = 'pipeline-builder';\n/** EKS cluster name eksctl defaults to. */\nconst DEFAULT_EKS_CLUSTER = 'pipeline-builder';\n\n/**\n * Assemble the teardown command for a target. Pure and deterministic — mirrors\n * `assembleCommand` for the destroy path. local/minikube STOP the stack\n * (non-destructive — on-disk / PVC data survives); ec2 DELETEs its CloudFormation\n * stack and eks DELETEs its cluster (eksctl) — both irreversible. EC2 `delete-stack`\n * and `eksctl delete cluster` have no native prompt, which is exactly why the agent's\n * typed-confirmation gate is mandatory there.\n */\nexport function teardownCommand(\n  target: TargetId,\n  opts: { stackName?: string; clusterName?: string; region?: string; domain?: string; hostedZoneId?: string; assumeYes?: boolean } = {},\n): TeardownResult {\n  const region = resolveAwsRegion(opts.region);\n  // Anything flowing unquoted into a shell-executed teardown command is rejected\n  // for shell metacharacters (mirrors assembleCommand).\n  assertShellSafe(region, 'region');\n  if (opts.stackName) assertShellSafe(opts.stackName, 'stack-name');\n  if (opts.clusterName) assertShellSafe(opts.clusterName, 'cluster-name');\n  if (opts.domain) assertShellSafe(opts.domain, 'domain');\n  if (opts.hostedZoneId) assertShellSafe(opts.hostedZoneId, 'hosted-zone-id');\n  switch (target) {\n    case 'docker':\n      return { command: 'cd deploy/local/docker && bash bin/shutdown.sh', destructive: false };\n    case 'minikube':\n      return { command: 'cd deploy/local/minikube && bash bin/shutdown.sh', destructive: false };\n    case 'ec2': {\n      const stack = opts.stackName || DEFAULT_EC2_STACK;\n      return {\n        command:\n          `aws cloudformation delete-stack --stack-name ${stack} --region ${region} && ` +\n          `aws cloudformation wait stack-delete-complete --stack-name ${stack} --region ${region}`,\n        destructive: true,\n      };\n    }\n    case 'eks': {\n      // eks tears down via bin/shutdown.sh (like local/minikube use bin/shutdown.sh):\n      // it deletes the cluster AND the resources eksctl alone would orphan — the EFS\n      // filesystem and, when --domain is given, the ACM cert + Route 53 alias. The\n      // agent's typed-confirmation gate already ran, so pass --yes to skip the\n      // script's own prompt.\n      const cluster = opts.clusterName || DEFAULT_EKS_CLUSTER;\n      let command = `cd deploy/aws/eks && bash bin/shutdown.sh --cluster-name ${cluster} --region ${region}`;\n      if (opts.domain) command += ` --domain ${opts.domain}`;\n      if (opts.hostedZoneId) command += ` --hosted-zone-id ${opts.hostedZoneId}`;\n      if (opts.assumeYes) command += ' --yes';\n      return { command, destructive: true };\n    }\n  }\n}\n"]}

package/dist/agent/tools.d.ts

@@ -0,0 +1,13 @@
+/** Cache dir for fetched tool binaries (kept across runs so we fetch once). */
+export declare const TOOLS_DIR: string;
+/** True when `tool` is a single-binary prereq provision knows how to fetch. */
+export declare function isFetchable(tool: string): boolean;
+/**
+ * Download `tool` into {@link TOOLS_DIR} (idempotent — skips if already present)
+ * and mark it executable. Returns true on success. Single-quoted args are
+ * injection-safe; `tool` is only ever a known key from {@link FETCHABLE}.
+ */
+export declare function fetchTool(tool: string): boolean;
+/** Prepend the tools cache dir to PATH so fetched binaries are discoverable. */
+export declare function withToolsOnPath(): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/agent/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/agent/tools.ts"],"names":[],"mappings":"AAgBA,+EAA+E;AAC/E,eAAO,MAAM,SAAS,QAAwD,CAAC;AAwB/E,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AASD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAa/C;AAED,gFAAgF;AAChF,wBAAgB,eAAe,IAAI,IAAI,CAItC"}

package/dist/agent/tools.js

@@ -0,0 +1,75 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * On-demand fetch of single-binary prerequisites (e.g. `yq`) so provision can
+ * satisfy a missing host tool WITHOUT a system install (no brew/apt). The binary
+ * is downloaded into a per-user cache dir; the caller prepends that dir to PATH
+ * so both the prereq checks (`has()` → `command -v`) and the deploy (`bash -lc`,
+ * which inherits process.env.PATH) find it.
+ */
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+/** Cache dir for fetched tool binaries (kept across runs so we fetch once). */
+export const TOOLS_DIR = path.join(os.homedir(), '.pipeline-manager', 'tools');
+/**
+ * Tools that are a single self-contained binary we can fetch on demand, keyed by
+ * the prereq-check name. Each entry builds the release-asset URL for the host's
+ * OS + arch (assets use darwin|linux and arm64|amd64). Builders may resolve a
+ * version first (kubectl) — failures throw and fetchTool() reports them.
+ *
+ * NOT fetchable here (they aren't relocatable single binaries — keep the
+ * system/external install + the prereq block's instruction):
+ *   - git      → Xcode Command Line Tools (`xcode-select --install`) or `brew install git`
+ *   - docker / docker compose → Docker Desktop (external host requirement)
+ *   - aws      → AWS CLI v2 is a pkg/zip installer, not a drop-in binary
+ *   - openssl  → ships with macOS/Linux; install via the system package manager
+ */
+const FETCHABLE = {
+    yq: (osId, arch) => `https://github.com/mikefarah/yq/releases/latest/download/yq_${osId}_${arch}`,
+    minikube: (osId, arch) => `https://storage.googleapis.com/minikube/releases/latest/minikube-${osId}-${arch}`,
+    kubectl: (osId, arch) => {
+        const ver = execSync('curl -fsSL https://dl.k8s.io/release/stable.txt', { timeout: 15000 }).toString().trim();
+        return `https://dl.k8s.io/release/${ver}/bin/${osId}/${arch}/kubectl`;
+    },
+};
+/** True when `tool` is a single-binary prereq provision knows how to fetch. */
+export function isFetchable(tool) {
+    return tool in FETCHABLE;
+}
+/** Host OS + arch in the naming the release assets use. */
+function hostOsArch() {
+    const osId = process.platform === 'darwin' ? 'darwin' : 'linux';
+    const arch = process.arch === 'arm64' ? 'arm64' : 'amd64';
+    return { osId, arch };
+}
+/**
+ * Download `tool` into {@link TOOLS_DIR} (idempotent — skips if already present)
+ * and mark it executable. Returns true on success. Single-quoted args are
+ * injection-safe; `tool` is only ever a known key from {@link FETCHABLE}.
+ */
+export function fetchTool(tool) {
+    const urlFor = FETCHABLE[tool];
+    if (!urlFor)
+        return false;
+    const dest = path.join(TOOLS_DIR, tool);
+    if (existsSync(dest))
+        return true;
+    const { osId, arch } = hostOsArch();
+    try {
+        mkdirSync(TOOLS_DIR, { recursive: true });
+        execSync(`curl -fsSL --output '${dest}' '${urlFor(osId, arch)}' && chmod +x '${dest}'`, { stdio: 'ignore', timeout: 120000 });
+        return existsSync(dest);
+    }
+    catch {
+        return false;
+    }
+}
+/** Prepend the tools cache dir to PATH so fetched binaries are discoverable. */
+export function withToolsOnPath() {
+    if (!process.env.PATH?.split(path.delimiter).includes(TOOLS_DIR)) {
+        process.env.PATH = `${TOOLS_DIR}${path.delimiter}${process.env.PATH ?? ''}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/troubleshoot.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deterministic known-issue matcher for deploy failures. This is the structured,
+ * safe complement to the LLM diagnosis: it recognizes well-known CloudFormation /
+ * deploy signatures and maps them to a concrete cause + suggestion, and — for a
+ * few — a param fix the executor can re-apply for a gated retry. Pattern matching
+ * on output is a script's job, not the model's; the LLM only adds free-form
+ * diagnosis on top.
+ */
+export interface KnownIssue {
+    readonly id: string;
+    /** Plain-English root cause. */
+    readonly cause: string;
+    /** Concrete next step. */
+    readonly suggestion: string;
+    /** Whether a re-run can plausibly resolve it (deploy scripts are idempotent). */
+    readonly retryable: boolean;
+    /** A param the executor can set, then re-run automatically (gated). */
+    readonly paramFix?: {
+        readonly key: string;
+        readonly value: unknown;
+    };
+}
+/** Return every known issue whose signature appears in the failure output. */
+export declare function matchIssues(failureText: string): KnownIssue[];
+/**
+ * Post-deploy guidance to print after a successful deploy that enabled SES.
+ * Surfaces the two things the operator must act on (async DKIM, the sandbox).
+ */
+export declare function sesPostDeployGuidance(): string[];
+//# sourceMappingURL=troubleshoot.d.ts.map

package/dist/agent/troubleshoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"troubleshoot.d.ts","sourceRoot":"","sources":["../../src/agent/troubleshoot.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0BAA0B;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;CACvE;AAwED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,EAAE,CAE7D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAMhD"}

package/dist/agent/troubleshoot.js

@@ -0,0 +1,87 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+const RULES = [
+    {
+        // SES identity already verified in this account/region → reuse it.
+        // CFN phrasings vary: "Email identity … already exists", "SesEmailIdentity … AlreadyExists".
+        match: /(?:email\s*identity|ses[\s\S]{0,40}?identity|:identity\/)[\s\S]{0,160}?(?:already exists|AlreadyExists)/i,
+        issue: {
+            id: 'ses-identity-exists',
+            cause: 'The SES email identity for this domain already exists in the account/region.',
+            suggestion: 'Reuse it with --skip-ses-identity instead of creating a new one.',
+            retryable: true,
+            paramFix: { key: 'noCreateSesIdentity', value: true },
+        },
+    },
+    {
+        // A prior failed attempt left the stack un-updatable.
+        match: /ROLLBACK_COMPLETE|is in ROLLBACK_COMPLETE state and can not be updated/i,
+        issue: {
+            id: 'stack-rollback-complete',
+            cause: 'A previous attempt left the stack in ROLLBACK_COMPLETE — CloudFormation cannot update a stack in that state.',
+            suggestion: 'Delete the failed stack, then re-run. For ec2: `aws cloudformation delete-stack --stack-name <name>`. For eks (eksctl-managed stacks): `eksctl delete cluster --name <cluster>` (or `provision --target eks --teardown`). Destructive — not auto-applied.',
+            retryable: false,
+        },
+    },
+    {
+        match: /toomanyrequests|rate.?limit|HTTP 429|denied: requested access to the resource is denied/i,
+        issue: {
+            id: 'ghcr-rate-limit',
+            cause: 'ghcr.io anonymous pulls are rate-limited (60/hr) and tripped mid-deploy.',
+            suggestion: 'Pass --ghcr-token <GitHub PAT with read:packages>, then re-run.',
+            retryable: false, // needs a token value the agent does not hold
+        },
+    },
+    {
+        match: /ses:SendEmail|FromAddress|MessageRejected|Email address (?:is )?not verified/i,
+        issue: {
+            id: 'ses-from-mismatch',
+            cause: 'SES rejected the sender — the From address is not verified or not covered by the identity.',
+            suggestion: 'Make sure --email-from is on the verified domain; in the SES sandbox, verify the recipient too.',
+            retryable: false,
+        },
+    },
+    {
+        match: /ExpiredToken|InvalidClientTokenId|Unable to locate credentials|security token.*invalid|AuthFailure/i,
+        issue: {
+            id: 'aws-credentials',
+            cause: 'AWS credentials are missing or expired.',
+            suggestion: 'Refresh credentials (aws configure / AWS_PROFILE / SSO login), then re-run.',
+            retryable: false,
+        },
+    },
+    {
+        match: /(?:HostedZone|hosted zone)[\s\S]{0,80}?(?:not found|NoSuchHostedZone|does not exist)/i,
+        issue: {
+            id: 'hosted-zone-not-found',
+            cause: 'The Route 53 hosted zone could not be found.',
+            suggestion: 'Check --hosted-zone-id is the PUBLIC zone ID authoritative for --domain.',
+            retryable: false,
+        },
+    },
+    {
+        match: /Certificate[\s\S]{0,80}?(?:failed|timed out|PENDING_VALIDATION)|CertificateValidation.*(?:FAILED|timed out)/i,
+        issue: {
+            id: 'acm-validation',
+            cause: 'The ACM certificate did not validate in time — DNS validation needs the CNAME in the hosted zone, and propagation can take several minutes.',
+            suggestion: 'Confirm --hosted-zone-id matches --domain, then re-run to resume once DNS propagates.',
+            retryable: true, // a plain re-run can resume
+        },
+    },
+];
+/** Return every known issue whose signature appears in the failure output. */
+export function matchIssues(failureText) {
+    return RULES.filter((r) => r.match.test(failureText)).map((r) => r.issue);
+}
+/**
+ * Post-deploy guidance to print after a successful deploy that enabled SES.
+ * Surfaces the two things the operator must act on (async DKIM, the sandbox).
+ */
+export function sesPostDeployGuidance() {
+    return [
+        'DKIM verification is ASYNCHRONOUS (minutes–hours) — check SES console → Verified identities.',
+        'New SES accounts are SANDBOXED: you can only send to verified recipients (200/day) until you request production access. To smoke-test in sandbox, verify a REAL recipient — never admin@internal.',
+        'Bounces/complaints publish to the stack\'s SNS topic — subscribe to it (or pass --alert-email next time) to get warned before SES throttles you.',
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"troubleshoot.js","sourceRoot":"","sources":["../../src/agent/troubleshoot.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAuBtC,MAAM,KAAK,GAA0E;IACnF;QACE,mEAAmE;QACnE,6FAA6F;QAC7F,KAAK,EAAE,0GAA0G;QACjH,KAAK,EAAE;YACL,EAAE,EAAE,qBAAqB;YACzB,KAAK,EAAE,8EAA8E;YACrF,UAAU,EAAE,kEAAkE;YAC9E,SAAS,EAAE,IAAI;YACf,QAAQ,EAAE,EAAE,GAAG,EAAE,qBAAqB,EAAE,KAAK,EAAE,IAAI,EAAE;SACtD;KACF;IACD;QACE,sDAAsD;QACtD,KAAK,EAAE,yEAAyE;QAChF,KAAK,EAAE;YACL,EAAE,EAAE,yBAAyB;YAC7B,KAAK,EAAE,8GAA8G;YACrH,UAAU,EAAE,2PAA2P;YACvQ,SAAS,EAAE,KAAK;SACjB;KACF;IACD;QACE,KAAK,EAAE,0FAA0F;QACjG,KAAK,EAAE;YACL,EAAE,EAAE,iBAAiB;YACrB,KAAK,EAAE,0EAA0E;YACjF,UAAU,EAAE,iEAAiE;YAC7E,SAAS,EAAE,KAAK,EAAE,8CAA8C;SACjE;KACF;IACD;QACE,KAAK,EAAE,+EAA+E;QACtF,KAAK,EAAE;YACL,EAAE,EAAE,mBAAmB;YACvB,KAAK,EAAE,4FAA4F;YACnG,UAAU,EAAE,iGAAiG;YAC7G,SAAS,EAAE,KAAK;SACjB;KACF;IACD;QACE,KAAK,EAAE,qGAAqG;QAC5G,KAAK,EAAE;YACL,EAAE,EAAE,iBAAiB;YACrB,KAAK,EAAE,yCAAyC;YAChD,UAAU,EAAE,6EAA6E;YACzF,SAAS,EAAE,KAAK;SACjB;KACF;IACD;QACE,KAAK,EAAE,uFAAuF;QAC9F,KAAK,EAAE;YACL,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,8CAA8C;YACrD,UAAU,EAAE,0EAA0E;YACtF,SAAS,EAAE,KAAK;SACjB;KACF;IACD;QACE,KAAK,EAAE,8GAA8G;QACrH,KAAK,EAAE;YACL,EAAE,EAAE,gBAAgB;YACpB,KAAK,EAAE,6IAA6I;YACpJ,UAAU,EAAE,uFAAuF;YACnG,SAAS,EAAE,IAAI,EAAE,4BAA4B;SAC9C;KACF;CACF,CAAC;AAEF,8EAA8E;AAC9E,MAAM,UAAU,WAAW,CAAC,WAAmB;IAC7C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,8FAA8F;QAC9F,mMAAmM;QACnM,kJAAkJ;KACnJ,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Deterministic known-issue matcher for deploy failures. This is the structured,\n * safe complement to the LLM diagnosis: it recognizes well-known CloudFormation /\n * deploy signatures and maps them to a concrete cause + suggestion, and — for a\n * few — a param fix the executor can re-apply for a gated retry. Pattern matching\n * on output is a script's job, not the model's; the LLM only adds free-form\n * diagnosis on top.\n */\n\nexport interface KnownIssue {\n  readonly id: string;\n  /** Plain-English root cause. */\n  readonly cause: string;\n  /** Concrete next step. */\n  readonly suggestion: string;\n  /** Whether a re-run can plausibly resolve it (deploy scripts are idempotent). */\n  readonly retryable: boolean;\n  /** A param the executor can set, then re-run automatically (gated). */\n  readonly paramFix?: { readonly key: string; readonly value: unknown };\n}\n\nconst RULES: ReadonlyArray<{ readonly match: RegExp; readonly issue: KnownIssue }> = [\n  {\n    // SES identity already verified in this account/region → reuse it.\n    // CFN phrasings vary: \"Email identity … already exists\", \"SesEmailIdentity … AlreadyExists\".\n    match: /(?:email\\s*identity|ses[\\s\\S]{0,40}?identity|:identity\\/)[\\s\\S]{0,160}?(?:already exists|AlreadyExists)/i,\n    issue: {\n      id: 'ses-identity-exists',\n      cause: 'The SES email identity for this domain already exists in the account/region.',\n      suggestion: 'Reuse it with --skip-ses-identity instead of creating a new one.',\n      retryable: true,\n      paramFix: { key: 'noCreateSesIdentity', value: true },\n    },\n  },\n  {\n    // A prior failed attempt left the stack un-updatable.\n    match: /ROLLBACK_COMPLETE|is in ROLLBACK_COMPLETE state and can not be updated/i,\n    issue: {\n      id: 'stack-rollback-complete',\n      cause: 'A previous attempt left the stack in ROLLBACK_COMPLETE — CloudFormation cannot update a stack in that state.',\n      suggestion: 'Delete the failed stack, then re-run. For ec2: `aws cloudformation delete-stack --stack-name <name>`. For eks (eksctl-managed stacks): `eksctl delete cluster --name <cluster>` (or `provision --target eks --teardown`). Destructive — not auto-applied.',\n      retryable: false,\n    },\n  },\n  {\n    match: /toomanyrequests|rate.?limit|HTTP 429|denied: requested access to the resource is denied/i,\n    issue: {\n      id: 'ghcr-rate-limit',\n      cause: 'ghcr.io anonymous pulls are rate-limited (60/hr) and tripped mid-deploy.',\n      suggestion: 'Pass --ghcr-token <GitHub PAT with read:packages>, then re-run.',\n      retryable: false, // needs a token value the agent does not hold\n    },\n  },\n  {\n    match: /ses:SendEmail|FromAddress|MessageRejected|Email address (?:is )?not verified/i,\n    issue: {\n      id: 'ses-from-mismatch',\n      cause: 'SES rejected the sender — the From address is not verified or not covered by the identity.',\n      suggestion: 'Make sure --email-from is on the verified domain; in the SES sandbox, verify the recipient too.',\n      retryable: false,\n    },\n  },\n  {\n    match: /ExpiredToken|InvalidClientTokenId|Unable to locate credentials|security token.*invalid|AuthFailure/i,\n    issue: {\n      id: 'aws-credentials',\n      cause: 'AWS credentials are missing or expired.',\n      suggestion: 'Refresh credentials (aws configure / AWS_PROFILE / SSO login), then re-run.',\n      retryable: false,\n    },\n  },\n  {\n    match: /(?:HostedZone|hosted zone)[\\s\\S]{0,80}?(?:not found|NoSuchHostedZone|does not exist)/i,\n    issue: {\n      id: 'hosted-zone-not-found',\n      cause: 'The Route 53 hosted zone could not be found.',\n      suggestion: 'Check --hosted-zone-id is the PUBLIC zone ID authoritative for --domain.',\n      retryable: false,\n    },\n  },\n  {\n    match: /Certificate[\\s\\S]{0,80}?(?:failed|timed out|PENDING_VALIDATION)|CertificateValidation.*(?:FAILED|timed out)/i,\n    issue: {\n      id: 'acm-validation',\n      cause: 'The ACM certificate did not validate in time — DNS validation needs the CNAME in the hosted zone, and propagation can take several minutes.',\n      suggestion: 'Confirm --hosted-zone-id matches --domain, then re-run to resume once DNS propagates.',\n      retryable: true, // a plain re-run can resume\n    },\n  },\n];\n\n/** Return every known issue whose signature appears in the failure output. */\nexport function matchIssues(failureText: string): KnownIssue[] {\n  return RULES.filter((r) => r.match.test(failureText)).map((r) => r.issue);\n}\n\n/**\n * Post-deploy guidance to print after a successful deploy that enabled SES.\n * Surfaces the two things the operator must act on (async DKIM, the sandbox).\n */\nexport function sesPostDeployGuidance(): string[] {\n  return [\n    'DKIM verification is ASYNCHRONOUS (minutes–hours) — check SES console → Verified identities.',\n    'New SES accounts are SANDBOXED: you can only send to verified recipients (200/day) until you request production access. To smoke-test in sandbox, verify a REAL recipient — never admin@internal.',\n    'Bounces/complaints publish to the stack\\'s SNS topic — subscribe to it (or pass --alert-email next time) to get warned before SES throttles you.',\n  ];\n}\n"]}

package/dist/boilerplate.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=boilerplate.d.ts.map

package/dist/boilerplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boilerplate.d.ts","sourceRoot":"","sources":["../src/boilerplate.ts"],"names":[],"mappings":""}