@pipeline-builder/pipeline-manager 3.4.70 → 3.4.72

package/dist/agent/targets.js

@@ -0,0 +1,180 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// --- 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)' };
+// SES / email family — shared by ec2 + fargate. 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 = {
+    local: {
+        id: 'local',
+        label: 'Local (Docker Compose)',
+        dir: 'deploy/local',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/local'],
+        required: [],
+        optional: [],
+        postDeploy: './deploy/bin/init-platform.sh local',
+        cost: 'Free',
+        bestFor: 'Development',
+        destroys: 'stops all containers — data under deploy/local/data persists on disk (delete it manually for a clean slate)',
+    },
+    minikube: {
+        id: 'minikube',
+        label: 'Minikube (local Kubernetes)',
+        dir: 'deploy/minikube',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/minikube'],
+        required: [],
+        optional: [],
+        postDeploy: './deploy/bin/init-platform.sh minikube',
+        cost: 'Free',
+        bestFor: 'Local Kubernetes',
+        destroys: 'stops the minikube stack — persistent volumes (PVC data) remain until the cluster is deleted',
+    },
+    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, ...EMAIL],
+        postDeploy: './deploy/bin/init-platform.sh ec2  # from inside the VPC (SSM)',
+        cost: '~$140-265/mo',
+        bestFor: 'Dev / staging',
+        destroys: 'DELETES the CloudFormation stack: the VPC, EC2 instance, and its EBS data volume (databases, registry, plugin builds). Irreversible.',
+    },
+    fargate: {
+        id: 'fargate',
+        label: 'AWS Fargate (serverless ECS, 6 CloudFormation stacks)',
+        dir: 'deploy/aws/fargate',
+        entrypoint: 'bin/setup.sh',
+        sparsePaths: ['deploy/aws/fargate'],
+        required: [DOMAIN, HOSTED_ZONE],
+        optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, ...EMAIL],
+        postDeploy: './deploy/bin/init-platform.sh fargate  # from a VPC-attached host',
+        cost: '~$100-300/mo',
+        bestFor: 'Production',
+        destroys: 'DELETES all pb-* CloudFormation stacks: EFS data, databases, and registry. Secrets Manager entries are NOT auto-deleted. Irreversible.',
+    },
+};
+export const TARGET_IDS = ['local', 'minikube', 'ec2', 'fargate'];
+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_PIPELINES', 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];
+}
+/**
+ * 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 value = spec.secret && mask ? '***' : String(params[spec.key]);
+        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';
+/** Stack prefix the Fargate teardown.sh defaults to. */
+const DEFAULT_FARGATE_PREFIX = 'pb';
+/**
+ * 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/fargate DELETE their
+ * CloudFormation stacks and are irreversible. For Fargate, `assumeYes` forwards
+ * the native script's own `--yes` (the agent runs its own typed confirmation
+ * first, so the script must not also block on stdin); EC2 `delete-stack` has no
+ * native prompt, which is exactly why the agent gate is mandatory there.
+ */
+export function teardownCommand(target, opts = {}) {
+    const region = opts.region || process.env.AWS_REGION || 'us-east-1';
+    switch (target) {
+        case 'local':
+            return { command: 'cd deploy/local && bash bin/shutdown.sh', destructive: false };
+        case 'minikube':
+            return { command: 'cd deploy/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 'fargate': {
+            const prefix = opts.stackName || DEFAULT_FARGATE_PREFIX;
+            return {
+                command: `cd deploy/aws/fargate && bash bin/teardown.sh --stack-prefix ${prefix} --region ${region}` +
+                    (opts.assumeYes ? ' --yes' : ''),
+                destructive: true,
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"targets.js","sourceRoot":"","sources":["../../src/agent/targets.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAsDtC,+EAA+E;AAE/E,MAAM,MAAM,GAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,uDAAuD,EAAE,CAAC;AAClI,MAAM,WAAW,GAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,cAAc,EAAE,WAAW,EAAE,6DAA6D,EAAE,CAAC;AAC3J,MAAM,UAAU,GAAc,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,WAAW,EAAE,sEAAsE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAC1K,MAAM,MAAM,GAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC;AACvF,MAAM,WAAW,GAAc,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,6DAA6D,EAAE,CAAC;AACtJ,MAAM,QAAQ,GAAc,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,WAAW,EAAE,gFAAgF,EAAE,CAAC;AAChK,MAAM,aAAa,GAAc,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,WAAW,EAAE,wCAAwC,EAAE,CAAC;AAEvI,8EAA8E;AAC9E,kFAAkF;AAClF,oBAAoB;AACpB,MAAM,KAAK,GAAyB;IAClC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,wDAAwD,EAAE,OAAO,EAAE,IAAI,EAAE;IACrH,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,WAAW,EAAE,0DAA0D,EAAE,OAAO,EAAE,IAAI,EAAE;IAC5H,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,WAAW,EAAE,yCAAyC,EAAE;IAChG,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,EAAE,eAAe,EAAE,WAAW,EAAE,gCAAgC,EAAE;IAChG,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,wDAAwD,EAAE;IACjH,EAAE,IAAI,EAAE,wBAAwB,EAAE,GAAG,EAAE,qBAAqB,EAAE,WAAW,EAAE,sDAAsD,EAAE,OAAO,EAAE,IAAI,EAAE;CACnJ,CAAC;AAEF,+EAA+E;AAE/E,MAAM,CAAC,MAAM,OAAO,GAA2C;IAC7D,KAAK,EAAE;QACL,EAAE,EAAE,OAAO;QACX,KAAK,EAAE,wBAAwB;QAC/B,GAAG,EAAE,cAAc;QACnB,UAAU,EAAE,cAAc;QAC1B,WAAW,EAAE,CAAC,cAAc,CAAC;QAC7B,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,UAAU,EAAE,qCAAqC;QACjD,IAAI,EAAE,MAAM;QACZ,OAAO,EAAE,aAAa;QACtB,QAAQ,EAAE,6GAA6G;KACxH;IACD,QAAQ,EAAE;QACR,EAAE,EAAE,UAAU;QACd,KAAK,EAAE,6BAA6B;QACpC,GAAG,EAAE,iBAAiB;QACtB,UAAU,EAAE,cAAc;QAC1B,WAAW,EAAE,CAAC,iBAAiB,CAAC;QAChC,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,UAAU,EAAE,wCAAwC;QACpD,IAAI,EAAE,MAAM;QACZ,OAAO,EAAE,kBAAkB;QAC3B,QAAQ,EAAE,8FAA8F;KACzG;IACD,GAAG,EAAE;QACH,EAAE,EAAE,KAAK;QACT,KAAK,EAAE,kDAAkD;QACzD,GAAG,EAAE,gBAAgB;QACrB,UAAU,EAAE,cAAc;QAC1B,WAAW,EAAE,CAAC,gBAAgB,CAAC;QAC/B,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC;QACzC,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC;QACpE,UAAU,EAAE,gEAAgE;QAC5E,IAAI,EAAE,cAAc;QACpB,OAAO,EAAE,eAAe;QACxB,QAAQ,EAAE,sIAAsI;KACjJ;IACD,OAAO,EAAE;QACP,EAAE,EAAE,SAAS;QACb,KAAK,EAAE,uDAAuD;QAC9D,GAAG,EAAE,oBAAoB;QACzB,UAAU,EAAE,cAAc;QAC1B,WAAW,EAAE,CAAC,oBAAoB,CAAC;QACnC,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC;QAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;QACrD,UAAU,EAAE,mEAAmE;QAC/E,IAAI,EAAE,cAAc;QACpB,OAAO,EAAE,YAAY;QACrB,QAAQ,EAAE,wIAAwI;KACnJ;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;AAEvF,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,UAAgC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACxF,CAAC;AAED,+EAA+E;AAE/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAsB,CAAC,YAAY,CAAC,CAAC;AAErE;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,8EAA8E;IAC9E,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,EAAE;IAC1G,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,mBAAmB,CAAC,EAAE;IAClG,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,gBAAgB,CAAC,EAAE;CAChF,CAAC;AAIX;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,MAAgB,EAAE,cAAiC;IAChF,MAAM,KAAK,GAAG,IAAI,GAAG,CAAS,mBAAmB,CAAC,CAAC;IACnD,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW;QAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC1D,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YAAE,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACjF,CAAC;IACD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;AACpB,CAAC;AASD;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAkB,EAClB,MAA+B,EAC/B,OAA2B,EAAE;IAE7B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;IAC/B,MAAM,QAAQ,GAAG,CAAC,IAAe,EAAW,EAAE;QAC5C,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3B,OAAO,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,CAAC;IACpD,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAElE,MAAM,KAAK,GAAa,CAAC,MAAM,MAAM,CAAC,GAAG,YAAY,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;IAC1E,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,SAAS;QAC9B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAC7B,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACrE,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;AACrD,CAAC;AASD,8DAA8D;AAC9D,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAC7C,wDAAwD;AACxD,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAgB,EAChB,OAAqE,EAAE;IAEvE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,WAAW,CAAC;IACpE,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,OAAO;YACV,OAAO,EAAE,OAAO,EAAE,yCAAyC,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;QACpF,KAAK,UAAU;YACb,OAAO,EAAE,OAAO,EAAE,4CAA4C,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;QACvF,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,IAAI,iBAAiB,CAAC;YAClD,OAAO;gBACL,OAAO,EACL,gDAAgD,KAAK,aAAa,MAAM,MAAM;oBAC9E,8DAA8D,KAAK,aAAa,MAAM,EAAE;gBAC1F,WAAW,EAAE,IAAI;aAClB,CAAC;QACJ,CAAC;QACD,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,IAAI,sBAAsB,CAAC;YACxD,OAAO;gBACL,OAAO,EACL,gEAAgE,MAAM,aAAa,MAAM,EAAE;oBAC3F,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClC,WAAW,EAAE,IAAI;aAClB,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC","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\nexport type TargetId = 'local' | 'minikube' | 'ec2' | 'fargate';\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 a teardown of this target destroys — shown before a (gated) teardown. */\n  readonly destroys: string;\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\n// SES / email family — shared by ec2 + fargate. 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  local: {\n    id: 'local',\n    label: 'Local (Docker Compose)',\n    dir: 'deploy/local',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/local'],\n    required: [],\n    optional: [],\n    postDeploy: './deploy/bin/init-platform.sh local',\n    cost: 'Free',\n    bestFor: 'Development',\n    destroys: 'stops all containers — data under deploy/local/data persists on disk (delete it manually for a clean slate)',\n  },\n  minikube: {\n    id: 'minikube',\n    label: 'Minikube (local Kubernetes)',\n    dir: 'deploy/minikube',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/minikube'],\n    required: [],\n    optional: [],\n    postDeploy: './deploy/bin/init-platform.sh minikube',\n    cost: 'Free',\n    bestFor: 'Local Kubernetes',\n    destroys: 'stops the minikube stack — persistent volumes (PVC data) remain until the cluster is deleted',\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, ...EMAIL],\n    postDeploy: './deploy/bin/init-platform.sh ec2  # from inside the VPC (SSM)',\n    cost: '~$140-265/mo',\n    bestFor: 'Dev / staging',\n    destroys: 'DELETES the CloudFormation stack: the VPC, EC2 instance, and its EBS data volume (databases, registry, plugin builds). Irreversible.',\n  },\n  fargate: {\n    id: 'fargate',\n    label: 'AWS Fargate (serverless ECS, 6 CloudFormation stacks)',\n    dir: 'deploy/aws/fargate',\n    entrypoint: 'bin/setup.sh',\n    sparsePaths: ['deploy/aws/fargate'],\n    required: [DOMAIN, HOSTED_ZONE],\n    optional: [REGION, DEPLOY_MODE, GHCR_TOKEN, ...EMAIL],\n    postDeploy: './deploy/bin/init-platform.sh fargate  # from a VPC-attached host',\n    cost: '~$100-300/mo',\n    bestFor: 'Production',\n    destroys: 'DELETES all pb-* CloudFormation stacks: EFS data, databases, and registry. Secrets Manager entries are NOT auto-deleted. Irreversible.',\n  },\n};\n\nexport const TARGET_IDS: readonly TargetId[] = ['local', 'minikube', 'ec2', 'fargate'];\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_PIPELINES', 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 * 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 value = spec.secret && mask ? '***' : String(params[spec.key]);\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/** Stack prefix the Fargate teardown.sh defaults to. */\nconst DEFAULT_FARGATE_PREFIX = 'pb';\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/fargate DELETE their\n * CloudFormation stacks and are irreversible. For Fargate, `assumeYes` forwards\n * the native script's own `--yes` (the agent runs its own typed confirmation\n * first, so the script must not also block on stdin); EC2 `delete-stack` has no\n * native prompt, which is exactly why the agent gate is mandatory there.\n */\nexport function teardownCommand(\n  target: TargetId,\n  opts: { stackName?: string; region?: string; assumeYes?: boolean } = {},\n): TeardownResult {\n  const region = opts.region || process.env.AWS_REGION || 'us-east-1';\n  switch (target) {\n    case 'local':\n      return { command: 'cd deploy/local && bash bin/shutdown.sh', destructive: false };\n    case 'minikube':\n      return { command: 'cd deploy/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 'fargate': {\n      const prefix = opts.stackName || DEFAULT_FARGATE_PREFIX;\n      return {\n        command:\n          `cd deploy/aws/fargate && bash bin/teardown.sh --stack-prefix ${prefix} --region ${region}` +\n          (opts.assumeYes ? ' --yes' : ''),\n        destructive: true,\n      };\n    }\n  }\n}\n"]}

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 (aws cloudformation delete-stack --stack-name <name>), then re-run. 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,6HAA6H;YACzI,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 (aws cloudformation delete-stack --stack-name <name>), then re-run. 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.js

@@ -1,16 +1,11 @@
 #!/usr/bin/env node
-"use strict";
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const pipeline_core_1 = require("@pipeline-builder/pipeline-core");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const picocolors_1 = __importDefault(require("picocolors"));
-const { cyan, green, dim, bold, magenta, red } = picocolors_1.default;
-const app = new aws_cdk_lib_1.App();
+import { PipelineBuilder } from '@pipeline-builder/pipeline-core';
+import { App, Stack } from 'aws-cdk-lib';
+import pico from 'picocolors';
+const { cyan, green, dim, bold, magenta, red } = pico;
+const app = new App();
 /**
  * Parse PIPELINE_PROPS from environment variable (base64-encoded JSON).
  * This is always set by the `synth` or `deploy` command before invoking boilerplate.
@@ -41,8 +36,8 @@ function main() {
         organization: props.organization,
         componentId,
     });
-    const stack = new aws_cdk_lib_1.Stack(app, stackName, {});
-    new pipeline_core_1.PipelineBuilder(stack, componentId, props);
+    const stack = new Stack(app, stackName, {});
+    new PipelineBuilder(stack, componentId, props);
     console.log(green(bold('Success')), green('CDK constructs synthesized successfully'));
 }
 try {
@@ -55,4 +50,4 @@ catch (error) {
     }
     process.exit(1);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAoCA;;GAEG;AACH,UAAU,UAAU;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAwOD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CAyD5D;AAiDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CA0BnD"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAuCA;;GAEG;AACH,UAAU,UAAU;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAyOD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CAyD5D;AAiDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CA0BnD"}