@cdklabs/cdk-cicd-wrapper 2.0.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -353,6 +353,18 @@ export interface ResolvedCicdConfig {
353
353
  readonly npmRegistry?: NpmRegistryConfig;
354
354
  /** HTTP(S) proxy every build project routes through, if any. */
355
355
  readonly proxy?: ProxyConfig;
356
+ /**
357
+ * Export per-stage account env vars on a self-mutating engine's synth step: before `cdk synth`, scan
358
+ * SSM Parameter Store under the pipeline's qualifier (`/<qualifier>/`) and export an `ACCOUNT_<STAGE>`
359
+ * env var for every parameter whose name contains `Account` (e.g. `/<qualifier>/AccountDev` ->
360
+ * `ACCOUNT_DEV`). This lets a `cdk.config.ts` that reads `process.env.ACCOUNT_<STAGE>` resolve target
361
+ * accounts at synth time from the values the bootstrap wrote to SSM.
362
+ * Off by default; only read by the self-mutating engines (`CDK_PIPELINES`, `GITHUB_ACTIONS`), whose
363
+ * synth step is the one that re-runs `cdk synth` under the pipeline. When on, the synth step is also
364
+ * granted `ssm:GetParametersByPath` on `/<qualifier>/*`, and fails loud if it finds no `Account*`
365
+ * parameter (a misconfigured qualifier is a hard error, not a silently-empty scan).
366
+ */
367
+ readonly warmAccountsFromSsm?: boolean;
356
368
  /** VPC every CodeBuild project the pipeline creates runs in, if configured (Blueprint `VPCProvider`, migrated). */
357
369
  readonly vpc?: VpcConfig;
358
370
  /**
@@ -66,4 +66,4 @@ var DeployModel;
66
66
  */
67
67
  DeployModel["DEPLOY_TIME_SYNTH"] = "deploy-time-synth";
68
68
  })(DeployModel || (exports.DeployModel = DeployModel = {}));
69
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;AACtC,EAAE;AACF,mGAAmG;AACnG,sGAAsG;AACtG,mGAAmG;AACnG,wFAAwF;;;AAoBxF,uDAAuD;AACvD,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,0CAA0C;IAC1C,wCAAyB,CAAA;IACzB,2BAA2B;IAC3B,oCAAqB,CAAA;AACvB,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED,oDAAoD;AACpD,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,0DAA0D;IAC1D,sCAAmB,CAAA;IACnB,sDAAsD;IACtD,8CAA2B,CAAA;AAC7B,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B;AAED,+CAA+C;AAC/C,IAAY,UAmBX;AAnBD,WAAY,UAAU;IACpB;;;OAGG;IACH,2CAA6B,CAAA;IAC7B;;;;OAIG;IACH,6CAA+B,CAAA;IAC/B;;;;;OAKG;IACH,+CAAiC,CAAA;AACnC,CAAC,EAnBW,UAAU,0BAAV,UAAU,QAmBrB;AAqCD;;;GAGG;AACH,IAAY,WAcX;AAdD,WAAY,WAAW;IACrB;;;;OAIG;IACH,wDAAyC,CAAA;IACzC;;;;;OAKG;IACH,sDAAuC,CAAA;AACzC,CAAC,EAdW,WAAW,2BAAX,WAAW,QActB","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n//\n// The RESOLVED cicd-config shape -- the union-free, defaults-applied structs `defineCICD` produces\n// and the CLI (exec/synth/deploy) consumes. The flexible INPUT shapes a user writes (single region or\n// many, a stage as a bare name or an object) use TS unions and live in ./define.ts; they are never\n// part of the jsii surface. Only the resolved structs here cross the language boundary.\n\nimport { aws_codebuild as codebuild, aws_ec2 as ec2 } from 'aws-cdk-lib';\nimport { WorkflowTriggers } from 'cdk-pipelines-github';\nimport { BuildImage } from './build-image';\nimport { Repository } from './repository';\n\n/**\n * A security plugin's stable identity (issue #241). Serializable, so it is what `cicd.config.ts`\n * carries (through CDK context) to select a built-in plugin or declare a custom one. A custom\n * plugin's actual `IAspect` instance is supplied separately in `bin/` via `CdkCicd.addPlugin`, since\n * a live object cannot cross the context boundary.\n */\nexport interface PluginRef {\n  /** Stable plugin name. Built-in names are fixed; a custom name must match a `bin/` `addPlugin`. */\n  readonly name: string;\n  /** Plugin version, recorded for inventory and divergence warnings. */\n  readonly version: string;\n}\n\n/** Order in which a stage's regions are rolled out. */\nexport enum RegionOrder {\n  /** One region after another (default). */\n  SEQUENTIAL = 'sequential',\n  /** All regions at once. */\n  PARALLEL = 'parallel',\n}\n\n/** Which stack synthesizer the wrapper installs. */\nexport enum SynthesizerType {\n  /** `DefaultStackSynthesizer` -- the Autopilot default. */\n  DEFAULT = 'default',\n  /** `AppStagingSynthesizer` -- opt-in, still alpha. */\n  APP_STAGING = 'app_staging',\n}\n\n/** Which CI/CD engine renders the pipeline. */\nexport enum EngineType {\n  /**\n   * The lightweight flat engine on raw `aws-cdk-lib/aws-codepipeline` -- the Autopilot default. Its deploy\n   * stages re-invoke the app per stage, so the user's `bin` stays a plain single-stage app.\n   */\n  CODEPIPELINE = 'codepipeline',\n  /**\n   * The Blueprint-compatible self-mutating pipeline on `aws-cdk-lib/pipelines` (Source -> Synth -> Assets ->\n   * one wave per stage). `cdk-cicd exec` assembles it by replaying the plain `bin` once per configured\n   * stage (see runtime/pipeline-assembler), so the user's `bin` still needs no wrapper code.\n   */\n  CDK_PIPELINES = 'cdk-pipelines',\n  /**\n   * Renders a GitHub Actions workflow (`cdk-pipelines-github`) instead of an AWS-hosted pipeline\n   * (Blueprint `GitHubPipelinePlugin`, migrated). Like `CDK_PIPELINES`, it needs every stage built as a `cdk.Stage`\n   * inside one synth, so `cdk-cicd exec` assembles it the same way -- replaying the plain `bin` once per\n   * configured stage.\n   */\n  GITHUB_ACTIONS = 'github-actions',\n}\n\n/**\n * GitHub Actions engine configuration: the OIDC role the workflow assumes plus the workflow file's own\n * identity (Blueprint `GitHubPipelinePluginOptions`, migrated). Only read when `engine` is `GITHUB_ACTIONS`;\n * `repository` must be `Repository.github(...)` in that case (the workflow runs where GitHub already\n * checked the source out, so there is no CodeStar-connection source action to build).\n */\nexport interface GitHubActionsConfig {\n  /**\n   * Name of the OIDC role the workflow assumes to deploy. Must be a literal (not CDK-generated): the\n   * workflow YAML embeds its ARN as plain text, which only works for a name known before synth.\n   * @default `<application>-github-role`\n   */\n  readonly roleName?: string;\n  /**\n   * Subject claims allowed to assume the role, e.g. `['repo:owner/repo:ref:refs/heads/main']`. Defaults\n   * to every ref/environment of `repository`'s `owner/repo` when omitted.\n   */\n  readonly subjectClaims?: string[];\n  /** An existing GitHub OIDC provider's ARN. Omit to have one created (one per account/provider URL). */\n  readonly openIdConnectProviderArn?: string;\n  /** GitHub certificate thumbprints. @default - the built-in, currently-valid set */\n  readonly thumbprints?: string[];\n  /** File path for the generated workflow. @default \".github/workflows/deploy.yml\" */\n  readonly workflowPath?: string;\n  /** Name of the generated workflow. @default \"deploy\" */\n  readonly workflowName?: string;\n  /** GitHub workflow triggers. @default - push to the tracked branch, plus manual dispatch */\n  readonly workflowTriggers?: WorkflowTriggers;\n  /**\n   * Region the workflow assumes the OIDC role in when publishing assets (NOT the region assets publish\n   * to). @default \"us-west-2\"\n   */\n  readonly publishAssetsAuthRegion?: string;\n}\n\n/**\n * How the deployed cloud assembly is produced. See `task.md` D-deploy: two CodePipeline\n * implementations, efficiency first.\n */\nexport enum DeployModel {\n  /**\n   * The default, and what Blueprint did: the CI/build phase synthesizes every stage **once** and keeps\n   * `cdk.out`, which is promoted as the pipeline artifact. Each deploy stage consumes that assembly and\n   * performs no synth of its own -- one synth per pipeline run.\n   */\n  ASSEMBLY_PROMOTION = 'assembly-promotion',\n  /**\n   * Each stage synthesizes at deploy time from code + pinned deps, against that stage's injected config.\n   * The promoted unit is the code, not a baked assembly; CI synth is validation only. Costs one synth per\n   * stage, and is the model to pick when a stage's template must be produced with that stage's\n   * credentials (for example a synth-time lookup that only the target account can resolve).\n   */\n  DEPLOY_TIME_SYNTH = 'deploy-time-synth',\n}\n\n/** Resolved CI configuration: the checks/build steps and which stages CI synthesizes for validation. */\nexport interface CiConfig {\n  /**\n   * Named build steps as shell commands, e.g. `{ lint: 'npx cdk-cicd validate' }`. Empty means the\n   * engine applies its built-in default set.\n   */\n  readonly steps: { [key: string]: string };\n  /**\n   * Which stages CI synthesizes. Empty means the engine's default -- every stage under\n   * `ASSEMBLY_PROMOTION`, one env under `DEPLOY_TIME_SYNTH`. A non-empty list names the stages\n   * explicitly; `defineCICD`'s `'all'` shorthand resolves to the full stage list here.\n   */\n  readonly synthStages: string[];\n  /** Optional CodeBuild image override. */\n  readonly image?: string;\n  /**\n   * Escape hatch (Blueprint `CDKPipelineProps.ciBuildSpec`, migrated): deep-merged into the CI build project's\n   * generated buildspec via `codebuild.mergeBuildSpecs`, augmenting rather than replacing the engine's\n   * own phases. Scoped the same way Blueprint scoped it -- the CI build project only, not self-update or\n   * per-stage deploy projects.\n   */\n  readonly partialBuildSpec?: codebuild.BuildSpec;\n}\n\n/**\n * A private CodeArtifact npm repository the pipeline's builds authenticate against. When set, every\n * build project runs `aws codeartifact login` before `npm ci` and is granted read access to the\n * repository -- which is how a pipeline installs private packages (including the wrapper itself before\n * it is published to the public npm registry).\n */\nexport interface CodeArtifactConfig {\n  /** The CodeArtifact domain. */\n  readonly domain: string;\n  /** The repository within the domain. */\n  readonly repository: string;\n  /** Domain-owning account. Defaults to the pipeline's own account. */\n  readonly account?: string;\n  /** Region the domain lives in. Defaults to the pipeline's own region. */\n  readonly region?: string;\n  /** npm scope to bind to the repository, e.g. `cdklabs` for `@cdklabs/*`. Omit for the default scope. */\n  readonly npmScope?: string;\n}\n\n/**\n * HTTP(S) proxy configuration for the pipeline's CodeBuild projects (Blueprint `IProxyConfig`, migrated).\n * When set, every build project reads proxy credentials from Secrets Manager, exports\n * `HTTP(S)_PROXY` before running its install commands, and curls `proxyTestUrl` to prove the tunnel\n * works before the real install runs.\n */\nexport interface ProxyConfig {\n  /**\n   * ARN of the Secrets Manager secret holding the proxy credentials, as the keys `username`,\n   * `password`, `http_proxy_port`, `https_proxy_port` and `proxy_domain`.\n   */\n  readonly proxySecretArn: string;\n  /**\n   * Hosts that bypass the proxy. Empty means the engine adds its own region's `amazonaws.com`\n   * endpoint, so calls to AWS APIs (e.g. a private-registry `codeartifact login`) skip the proxy.\n   */\n  readonly noProxy: string[];\n  /** URL curl'd (through the proxy) to confirm it works before the install phase's real commands run. */\n  readonly proxyTestUrl: string;\n}\n\n/**\n * A generic private npm registry the pipeline's builds authenticate against with a bearer token\n * (Blueprint `NPMRegistryConfig`, migrated). Unlike `CodeArtifactConfig` (an `aws codeartifact login`), this covers\n * any npm-compatible registry: when set, every build project writes a `.npmrc` -- scoped to `scope` when\n * given, otherwise overriding the default registry -- with an auth token read from Secrets Manager.\n */\nexport interface NpmRegistryConfig {\n  /** The registry URL, e.g. `https://npm.example.com/`. */\n  readonly url: string;\n  /** ARN of the Secrets Manager secret holding the bearer token (the secret's plain `SecretString`). */\n  readonly basicAuthSecretArn: string;\n  /** npm scope to bind to the registry, e.g. `cdklabs` for `@cdklabs/*`. Omit to override the default registry. */\n  readonly scope?: string;\n}\n\n/**\n * VPC configuration for a wrapper-managed VPC (Blueprint `IManagedVpcConfig`, migrated from `VPCProvider`).\n * Every field is optional; an unset field takes Blueprint's original default.\n */\nexport interface ManagedVpcConfig {\n  /** CIDR block for the VPC. @default '172.31.0.0/20' */\n  readonly cidrBlock?: string;\n  /** Subnet CIDR mask. @default 24 */\n  readonly subnetCidrMask?: number;\n  /** Max AZs. @default 2 */\n  readonly maxAzs?: number;\n  /**\n   * The subnets the VPC's CodeBuild projects run in. Defaults to `PRIVATE_ISOLATED` when a `proxy`\n   * is configured (no NAT egress; the CodeBuild VPC endpoints below cover AWS API calls instead) and\n   * `PRIVATE_WITH_EGRESS` otherwise -- the rule Blueprint's `VPCProvider` applied.\n   */\n  readonly subnetType?: ec2.SubnetType;\n  /**\n   * Remove the default inbound/outbound rules from the VPC's default security group.\n   * @default true\n   */\n  readonly restrictDefaultSecurityGroup?: boolean;\n  /** Allow all outbound traffic by default from the security group the wrapper creates. @default true */\n  readonly allowAllOutbound?: boolean;\n  /**\n   * S3 bucket to send VPC flow logs to. Blueprint always used the RES stage's compliance-log bucket\n   * implicitly; Autopilot has not migrated that bucket yet (`m9-migrate-compliance-bucket`), so this is an\n   * explicit prop instead -- omit to skip flow logs.\n   */\n  readonly flowLogsBucketName?: string;\n  /**\n   * Extra CodeBuild VPC interface endpoints beyond the default set (SSM, STS, CloudWatch Logs,\n   * CloudFormation, Secrets Manager, KMS). Only used for the isolated-subnet case (see `subnetType`).\n   */\n  readonly codeBuildVpcInterfaces?: ec2.InterfaceVpcEndpointAwsService[];\n}\n\n/**\n * VPC configuration for the pipeline's own CodeBuild projects (Blueprint `IVpcConfig`, migrated from\n * `VPCProvider`). Set `managedVpc` to have the wrapper create a VPC, or `vpcId` to look up an\n * existing one; setting neither -- the default -- runs every CodeBuild project without a VPC.\n */\nexport interface VpcConfig {\n  /** Create a new VPC with these settings. */\n  readonly managedVpc?: ManagedVpcConfig;\n  /**\n   * Look up an existing VPC by id. A value starting with `resolve:ssm:` is resolved from the named\n   * SSM parameter at synth time instead of being used literally (Blueprint `VPCFromLookUpStack` parity).\n   */\n  readonly vpcId?: string;\n}\n\n/** A resolved stage's target environment. `regions` is always a list, even for a single region. */\nexport interface StageEnvironment {\n  /** Target account. Omitted means environment-agnostic (resolved from ambient creds at deploy). */\n  readonly account?: string;\n  /** Target regions, in order. Never empty for an environment-specific stage. */\n  readonly regions: string[];\n  /** How the regions roll out. */\n  readonly regionOrder: RegionOrder;\n}\n\n/** Forced deployer / CloudFormation-execution roles for a stage. */\nexport interface DeploymentConfig {\n  /** ARN the CLI assumes to deploy (passed as `cdk deploy --role-arn`). */\n  readonly deployRole?: string;\n  /** ARN CloudFormation assumes to execute the change set. */\n  readonly cfnExecutionRole?: string;\n  /**\n   * ExternalId presented when assuming `deployRole` (the `sts:ExternalId` a hardened cross-account\n   * trust policy requires). Overrides the pipeline-level `ResolvedCicdConfig.deployRoleExternalId` for\n   * this stage. A literal, or a `resolve:secretsmanager:<arn>` reference resolved at synth time (the\n   * same `resolve:` convention `VpcConfig.vpcId` uses). Ignored when `deployRole` is unset -- an\n   * ExternalId only applies to a role assumption the wrapper actually performs.\n   */\n  readonly externalId?: string;\n}\n\n/**\n * Names for the CDK Pipelines (Blueprint-compatible `CDK_PIPELINES`) engine's IAM roles -- the parity\n * replacement for Blueprint's `PipelineRoleNameEnforcementPlugin`, which the 1.x assembler-owned\n * pipeline stack gives a consumer no way to reattach. Any field omitted keeps CDK's generated name (no\n * behavior change). Only read when `engine` is `EngineType.CDK_PIPELINES`. The flat engine's roles are a\n * different set -- see `CodePipelineRoleNames`.\n */\nexport interface PipelineRoleNames {\n  /** `RoleName` forced on the CodePipeline pipeline role. */\n  readonly pipeline?: string;\n  /** `RoleName` forced on the CDK Pipelines file-publishing (assets) role. */\n  readonly assetsFile?: string;\n  /** `RoleName` forced on the CDK Pipelines docker-image-publishing (assets) role. */\n  readonly assetsDocker?: string;\n}\n\n/**\n * Names for the flat `CODEPIPELINE` engine's IAM roles. This engine's role set differs from the CDK\n * Pipelines engine (no asset-publishing roles; instead one CodeBuild role per stage), so it takes its\n * own struct. Any field omitted keeps CDK's generated name. Only read when `engine` is\n * `EngineType.CODEPIPELINE`.\n */\nexport interface CodePipelineRoleNames {\n  /** `RoleName` forced on the CodePipeline pipeline role. */\n  readonly pipeline?: string;\n  /**\n   * Prefix for the per-stage CodeBuild project roles: each stage's build role is named\n   * `<buildRolePrefix>-<stage>` (plus the CI/self-update projects, `<buildRolePrefix>-build` /\n   * `<buildRolePrefix>-selfupdate`). Omit to keep CDK-generated names.\n   */\n  readonly buildRolePrefix?: string;\n}\n\n/** A fully resolved deployment stage. */\nexport interface ResolvedStage {\n  /** Stage name, e.g. `dev`, `prod`. */\n  readonly name: string;\n  /** Where this stage deploys. */\n  readonly env: StageEnvironment;\n  /** Whether a manual approval gates this stage. */\n  readonly manualApproval: boolean;\n  /** Forced roles for this stage, if any. */\n  readonly deployment?: DeploymentConfig;\n}\n\n/** The resolved synthesizer choice. */\nexport interface SynthesizerConfig {\n  /** The synthesizer to install. */\n  readonly type: SynthesizerType;\n}\n\n/** The fully resolved pipeline configuration `defineCICD` produces. */\nexport interface ResolvedCicdConfig {\n  /** Application name; drives the bootstrap qualifier and asset naming. */\n  readonly application?: string;\n  /** Bootstrap qualifier (≤10 chars), derived from `application` when not given. */\n  readonly qualifier?: string;\n  /**\n   * CloudFormation stack name for the engine-owned self-mutating pipeline stack (the one the\n   * `CDK_PIPELINES` and `GITHUB_ACTIONS` engines assemble). Only read by those self-mutating engines;\n   * the flat `CODEPIPELINE` engine names its stack from the user's own `bin`.\n   * @default `${application}-pipeline`\n   *\n   * Set this to preserve a pre-1.x (Blueprint) pipeline stack name so an already-deployed,\n   * self-mutating pipeline can update IN PLACE instead of requiring a rename cutover -- the pipeline's\n   * `SelfMutate` step runs `cdk deploy <thisName>`, and a self-mutating pipeline cannot rename its own\n   * root stack. Changes ONLY the CloudFormation `stackName`, never the construct id, so the pipeline's\n   * child logical IDs are unchanged from the default. Same Blueprint-parity family as `pipelineRoleNames`.\n   */\n  readonly pipelineStackName?: string;\n  /** The source repository. */\n  readonly repository: Repository;\n  /** The deployment stages, in order. */\n  readonly stages: ResolvedStage[];\n  /** The synthesizer configuration. */\n  readonly synthesizer: SynthesizerConfig;\n  /** Which engine renders the pipeline. Defaults to CodePipeline. */\n  readonly engine: EngineType;\n  /** GitHub Actions engine configuration. Only read when `engine` is `EngineType.GITHUB_ACTIONS`. */\n  readonly githubActions?: GitHubActionsConfig;\n  /**\n   * Forced IAM role names for the CDK Pipelines (`CDK_PIPELINES`) engine's own roles. Only read when\n   * `engine` is `EngineType.CDK_PIPELINES`; omitted fields keep CDK-generated names.\n   */\n  readonly pipelineRoleNames?: PipelineRoleNames;\n  /**\n   * Forced IAM role names for the flat `CODEPIPELINE` engine's own roles. Only read when `engine` is\n   * `EngineType.CODEPIPELINE`; omitted fields keep CDK-generated names.\n   */\n  readonly codePipelineRoleNames?: CodePipelineRoleNames;\n  /**\n   * Pipeline-level default ExternalId presented when assuming a stage's forced `deployRole`. A stage's\n   * own `DeploymentConfig.externalId` overrides this. A literal or a `resolve:secretsmanager:<arn>`\n   * reference resolved at synth time.\n   */\n  readonly deployRoleExternalId?: string;\n  /** Resolved CI configuration. */\n  readonly ci: CiConfig;\n  /** Private CodeArtifact npm repository the builds authenticate against, if any. */\n  readonly codeArtifact?: CodeArtifactConfig;\n  /** Generic private npm registry the builds authenticate against with a bearer token, if any. */\n  readonly npmRegistry?: NpmRegistryConfig;\n  /** HTTP(S) proxy every build project routes through, if any. */\n  readonly proxy?: ProxyConfig;\n  /** VPC every CodeBuild project the pipeline creates runs in, if configured (Blueprint `VPCProvider`, migrated). */\n  readonly vpc?: VpcConfig;\n  /**\n   * The name of the compliance/access-log destination bucket, if configured (Blueprint\n   * `ComplianceBucketProvider`/`ComplianceLogBucketStack`, migrated). Threaded into\n   * `SupportResources.complianceLogBucket`; see there for the bucket's shape.\n   */\n  readonly complianceLogBucketName?: string;\n  /**\n   * CodeBuild environment overrides -- privileged mode, compute type, environment variables -- applied\n   * to every CodeBuild project the pipeline creates (Blueprint `codeBuildEnvSettings`, migrated from\n   * `CodeBuildFactoryProvider`/`PipelineBlueprint.codeBuildEnvSettings(...)`). Reuses CDK's own\n   * `BuildEnvironment` rather than a bespoke type, so it stays a drop-in for Blueprint callers. `buildImage`\n   * here is a full `IBuildImage` (e.g. an ARM or GPU managed image); it is distinct from the engines'\n   * own `buildImage` constructor prop, which takes a Docker-registry image string -- that prop wins\n   * when both are set.\n   */\n  readonly codeBuildEnvSettings?: codebuild.BuildEnvironment;\n  /** How the deployed cloud assembly is produced. Defaults to `ASSEMBLY_PROMOTION`. */\n  readonly deployModel: DeployModel;\n  /**\n   * Container mode (Repo 1): when set, the pipeline runs CI then builds & pushes a config-agnostic\n   * deployer image to ECR instead of deploying stages. Undefined = the normal deploy pipeline. (Named\n   * `deployerImage`, not `build` -- jsii reserves `build` as a struct member name.)\n   */\n  readonly deployerImage?: BuildImage;\n  /**\n   * Hand the CloudFormation wait to a Lambda instead of holding CodeBuild compute for it (D-deploy-wait).\n   *\n   * Off by default: the build-compute path is what `m4-verify` proves end to end, and this one replaces\n   * how deployment actually executes -- change sets prepared by the build, then executed and polled by a\n   * Lambda -- so it is opt-in until a real run validates it. When on, a deploy stage stops billing build\n   * minutes for the (usually dominant) stretch where CloudFormation is working.\n   */\n  readonly asyncDeploy: boolean;\n  /**\n   * Deploy with **CloudFormation express mode** (`cdk deploy --express`). CloudFormation reports each\n   * stack operation complete as soon as it applies the resource configuration, *without* waiting for\n   * resources to stabilize -- materially faster for stacks whose resources are slow to stabilize.\n   * Express runs with **rollback disabled** (a failed deploy is left in a failed state for inspection);\n   * forcing `--rollback` conflicts with the change-set path for nested stacks, so the CLI does not add\n   * it. AWS does **not** recommend express mode for production -- it targets fast iterative\n   * deployments. Off by default.\n   */\n  readonly express?: boolean;\n  /**\n   * Security plugins (hardening Aspects) to apply tree-wide, by `{ name, version }` (issue #241).\n   * Omitted keeps the default-on set; an empty list opts out of all; a non-empty list COMPLETELY\n   * overrides the defaults. A name that is not a built-in is a custom plugin and MUST be registered\n   * in `bin/` via `CdkCicd.addPlugin` -- the config carries only its identity, not the instance.\n   */\n  readonly plugins?: PluginRef[];\n}\n\n/**\n * A resolved deployment target for container mode (Repo 2): a stage to deploy the pinned image against,\n * with its own environment and optional forced roles. `env` mirrors a `ResolvedStage`'s environment, but a\n * target names the stage it maps to rather than defining it -- the stage's stacks live in the image, not\n * here. `manualApproval` defaults the same way stages do (gated unless `dev`/`res`).\n */\nexport interface ResolvedDeploymentTarget {\n  /** The stage in the image's app to deploy (passed to the in-container `cdk-cicd deploy --stage`). */\n  readonly stage: string;\n  /** Where this target deploys. */\n  readonly env: StageEnvironment;\n  /** Whether a manual approval gates this target. */\n  readonly manualApproval: boolean;\n  /** Forced roles for this target, if any. */\n  readonly deployment?: DeploymentConfig;\n  /**\n   * The deployer image (tag/digest) to run for THIS target, overriding the config-level `image`. This is\n   * how a stage pins its own application version -- bump `dev`'s tag to ship a new version to dev alone,\n   * or set `int`/`prod` to the same tag to promote. When unset, the target uses the config-level `image`.\n   */\n  readonly image?: string;\n}\n\n/**\n * The fully resolved container-mode deployment configuration `defineDeployment` produces (Repo 2 of the\n * two-repo split). It pins one config-agnostic deployer image and lists the targets to run it against;\n * `cdk-cicd deploy --from-image` runs the image per target, synthesizing and deploying in-container.\n */\nexport interface ResolvedDeploymentConfig {\n  /**\n   * The default deployer image to run targets against (an ECR/OCI reference, tag or digest). A target's\n   * own `image` overrides this, so per-stage versions live on the targets; this is the shared fallback.\n   * Optional only because every target may pin its own `image` -- each target must resolve to one or the other.\n   */\n  readonly image?: string;\n  /** The deployment targets, in order. */\n  readonly targets: ResolvedDeploymentTarget[];\n  /**\n   * The config-only source repository the CD pipeline watches (where `deploy.config.ts` lives -- no CDK\n   * code). Optional: when omitted, the config drives only the local `cdk-cicd deploy --from-image`\n   * executor; set it to provision a CD CodePipeline (`cdk-cicd deploy-ci`) whose CodeBuild pulls the image\n   * and deploys each target. This is the deploy-side twin of `ResolvedCicdConfig.repository`.\n   */\n  readonly repository?: Repository;\n  /**\n   * Private CodeArtifact repo the CD build authenticates against before `npm ci` (to install the wrapper\n   * CLI when it is pre-release / not on public npm). Same shape as the pipeline-config `codeArtifact`.\n   */\n  readonly codeArtifact?: CodeArtifactConfig;\n  /**\n   * Generic private npm registry the CD build authenticates against before `npm ci`. Same shape as the\n   * pipeline-config `npmRegistry`.\n   */\n  readonly npmRegistry?: NpmRegistryConfig;\n}\n"]}
69
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;AACtC,EAAE;AACF,mGAAmG;AACnG,sGAAsG;AACtG,mGAAmG;AACnG,wFAAwF;;;AAoBxF,uDAAuD;AACvD,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,0CAA0C;IAC1C,wCAAyB,CAAA;IACzB,2BAA2B;IAC3B,oCAAqB,CAAA;AACvB,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED,oDAAoD;AACpD,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,0DAA0D;IAC1D,sCAAmB,CAAA;IACnB,sDAAsD;IACtD,8CAA2B,CAAA;AAC7B,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B;AAED,+CAA+C;AAC/C,IAAY,UAmBX;AAnBD,WAAY,UAAU;IACpB;;;OAGG;IACH,2CAA6B,CAAA;IAC7B;;;;OAIG;IACH,6CAA+B,CAAA;IAC/B;;;;;OAKG;IACH,+CAAiC,CAAA;AACnC,CAAC,EAnBW,UAAU,0BAAV,UAAU,QAmBrB;AAqCD;;;GAGG;AACH,IAAY,WAcX;AAdD,WAAY,WAAW;IACrB;;;;OAIG;IACH,wDAAyC,CAAA;IACzC;;;;;OAKG;IACH,sDAAuC,CAAA;AACzC,CAAC,EAdW,WAAW,2BAAX,WAAW,QActB","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n//\n// The RESOLVED cicd-config shape -- the union-free, defaults-applied structs `defineCICD` produces\n// and the CLI (exec/synth/deploy) consumes. The flexible INPUT shapes a user writes (single region or\n// many, a stage as a bare name or an object) use TS unions and live in ./define.ts; they are never\n// part of the jsii surface. Only the resolved structs here cross the language boundary.\n\nimport { aws_codebuild as codebuild, aws_ec2 as ec2 } from 'aws-cdk-lib';\nimport { WorkflowTriggers } from 'cdk-pipelines-github';\nimport { BuildImage } from './build-image';\nimport { Repository } from './repository';\n\n/**\n * A security plugin's stable identity (issue #241). Serializable, so it is what `cicd.config.ts`\n * carries (through CDK context) to select a built-in plugin or declare a custom one. A custom\n * plugin's actual `IAspect` instance is supplied separately in `bin/` via `CdkCicd.addPlugin`, since\n * a live object cannot cross the context boundary.\n */\nexport interface PluginRef {\n  /** Stable plugin name. Built-in names are fixed; a custom name must match a `bin/` `addPlugin`. */\n  readonly name: string;\n  /** Plugin version, recorded for inventory and divergence warnings. */\n  readonly version: string;\n}\n\n/** Order in which a stage's regions are rolled out. */\nexport enum RegionOrder {\n  /** One region after another (default). */\n  SEQUENTIAL = 'sequential',\n  /** All regions at once. */\n  PARALLEL = 'parallel',\n}\n\n/** Which stack synthesizer the wrapper installs. */\nexport enum SynthesizerType {\n  /** `DefaultStackSynthesizer` -- the Autopilot default. */\n  DEFAULT = 'default',\n  /** `AppStagingSynthesizer` -- opt-in, still alpha. */\n  APP_STAGING = 'app_staging',\n}\n\n/** Which CI/CD engine renders the pipeline. */\nexport enum EngineType {\n  /**\n   * The lightweight flat engine on raw `aws-cdk-lib/aws-codepipeline` -- the Autopilot default. Its deploy\n   * stages re-invoke the app per stage, so the user's `bin` stays a plain single-stage app.\n   */\n  CODEPIPELINE = 'codepipeline',\n  /**\n   * The Blueprint-compatible self-mutating pipeline on `aws-cdk-lib/pipelines` (Source -> Synth -> Assets ->\n   * one wave per stage). `cdk-cicd exec` assembles it by replaying the plain `bin` once per configured\n   * stage (see runtime/pipeline-assembler), so the user's `bin` still needs no wrapper code.\n   */\n  CDK_PIPELINES = 'cdk-pipelines',\n  /**\n   * Renders a GitHub Actions workflow (`cdk-pipelines-github`) instead of an AWS-hosted pipeline\n   * (Blueprint `GitHubPipelinePlugin`, migrated). Like `CDK_PIPELINES`, it needs every stage built as a `cdk.Stage`\n   * inside one synth, so `cdk-cicd exec` assembles it the same way -- replaying the plain `bin` once per\n   * configured stage.\n   */\n  GITHUB_ACTIONS = 'github-actions',\n}\n\n/**\n * GitHub Actions engine configuration: the OIDC role the workflow assumes plus the workflow file's own\n * identity (Blueprint `GitHubPipelinePluginOptions`, migrated). Only read when `engine` is `GITHUB_ACTIONS`;\n * `repository` must be `Repository.github(...)` in that case (the workflow runs where GitHub already\n * checked the source out, so there is no CodeStar-connection source action to build).\n */\nexport interface GitHubActionsConfig {\n  /**\n   * Name of the OIDC role the workflow assumes to deploy. Must be a literal (not CDK-generated): the\n   * workflow YAML embeds its ARN as plain text, which only works for a name known before synth.\n   * @default `<application>-github-role`\n   */\n  readonly roleName?: string;\n  /**\n   * Subject claims allowed to assume the role, e.g. `['repo:owner/repo:ref:refs/heads/main']`. Defaults\n   * to every ref/environment of `repository`'s `owner/repo` when omitted.\n   */\n  readonly subjectClaims?: string[];\n  /** An existing GitHub OIDC provider's ARN. Omit to have one created (one per account/provider URL). */\n  readonly openIdConnectProviderArn?: string;\n  /** GitHub certificate thumbprints. @default - the built-in, currently-valid set */\n  readonly thumbprints?: string[];\n  /** File path for the generated workflow. @default \".github/workflows/deploy.yml\" */\n  readonly workflowPath?: string;\n  /** Name of the generated workflow. @default \"deploy\" */\n  readonly workflowName?: string;\n  /** GitHub workflow triggers. @default - push to the tracked branch, plus manual dispatch */\n  readonly workflowTriggers?: WorkflowTriggers;\n  /**\n   * Region the workflow assumes the OIDC role in when publishing assets (NOT the region assets publish\n   * to). @default \"us-west-2\"\n   */\n  readonly publishAssetsAuthRegion?: string;\n}\n\n/**\n * How the deployed cloud assembly is produced. See `task.md` D-deploy: two CodePipeline\n * implementations, efficiency first.\n */\nexport enum DeployModel {\n  /**\n   * The default, and what Blueprint did: the CI/build phase synthesizes every stage **once** and keeps\n   * `cdk.out`, which is promoted as the pipeline artifact. Each deploy stage consumes that assembly and\n   * performs no synth of its own -- one synth per pipeline run.\n   */\n  ASSEMBLY_PROMOTION = 'assembly-promotion',\n  /**\n   * Each stage synthesizes at deploy time from code + pinned deps, against that stage's injected config.\n   * The promoted unit is the code, not a baked assembly; CI synth is validation only. Costs one synth per\n   * stage, and is the model to pick when a stage's template must be produced with that stage's\n   * credentials (for example a synth-time lookup that only the target account can resolve).\n   */\n  DEPLOY_TIME_SYNTH = 'deploy-time-synth',\n}\n\n/** Resolved CI configuration: the checks/build steps and which stages CI synthesizes for validation. */\nexport interface CiConfig {\n  /**\n   * Named build steps as shell commands, e.g. `{ lint: 'npx cdk-cicd validate' }`. Empty means the\n   * engine applies its built-in default set.\n   */\n  readonly steps: { [key: string]: string };\n  /**\n   * Which stages CI synthesizes. Empty means the engine's default -- every stage under\n   * `ASSEMBLY_PROMOTION`, one env under `DEPLOY_TIME_SYNTH`. A non-empty list names the stages\n   * explicitly; `defineCICD`'s `'all'` shorthand resolves to the full stage list here.\n   */\n  readonly synthStages: string[];\n  /** Optional CodeBuild image override. */\n  readonly image?: string;\n  /**\n   * Escape hatch (Blueprint `CDKPipelineProps.ciBuildSpec`, migrated): deep-merged into the CI build project's\n   * generated buildspec via `codebuild.mergeBuildSpecs`, augmenting rather than replacing the engine's\n   * own phases. Scoped the same way Blueprint scoped it -- the CI build project only, not self-update or\n   * per-stage deploy projects.\n   */\n  readonly partialBuildSpec?: codebuild.BuildSpec;\n}\n\n/**\n * A private CodeArtifact npm repository the pipeline's builds authenticate against. When set, every\n * build project runs `aws codeartifact login` before `npm ci` and is granted read access to the\n * repository -- which is how a pipeline installs private packages (including the wrapper itself before\n * it is published to the public npm registry).\n */\nexport interface CodeArtifactConfig {\n  /** The CodeArtifact domain. */\n  readonly domain: string;\n  /** The repository within the domain. */\n  readonly repository: string;\n  /** Domain-owning account. Defaults to the pipeline's own account. */\n  readonly account?: string;\n  /** Region the domain lives in. Defaults to the pipeline's own region. */\n  readonly region?: string;\n  /** npm scope to bind to the repository, e.g. `cdklabs` for `@cdklabs/*`. Omit for the default scope. */\n  readonly npmScope?: string;\n}\n\n/**\n * HTTP(S) proxy configuration for the pipeline's CodeBuild projects (Blueprint `IProxyConfig`, migrated).\n * When set, every build project reads proxy credentials from Secrets Manager, exports\n * `HTTP(S)_PROXY` before running its install commands, and curls `proxyTestUrl` to prove the tunnel\n * works before the real install runs.\n */\nexport interface ProxyConfig {\n  /**\n   * ARN of the Secrets Manager secret holding the proxy credentials, as the keys `username`,\n   * `password`, `http_proxy_port`, `https_proxy_port` and `proxy_domain`.\n   */\n  readonly proxySecretArn: string;\n  /**\n   * Hosts that bypass the proxy. Empty means the engine adds its own region's `amazonaws.com`\n   * endpoint, so calls to AWS APIs (e.g. a private-registry `codeartifact login`) skip the proxy.\n   */\n  readonly noProxy: string[];\n  /** URL curl'd (through the proxy) to confirm it works before the install phase's real commands run. */\n  readonly proxyTestUrl: string;\n}\n\n/**\n * A generic private npm registry the pipeline's builds authenticate against with a bearer token\n * (Blueprint `NPMRegistryConfig`, migrated). Unlike `CodeArtifactConfig` (an `aws codeartifact login`), this covers\n * any npm-compatible registry: when set, every build project writes a `.npmrc` -- scoped to `scope` when\n * given, otherwise overriding the default registry -- with an auth token read from Secrets Manager.\n */\nexport interface NpmRegistryConfig {\n  /** The registry URL, e.g. `https://npm.example.com/`. */\n  readonly url: string;\n  /** ARN of the Secrets Manager secret holding the bearer token (the secret's plain `SecretString`). */\n  readonly basicAuthSecretArn: string;\n  /** npm scope to bind to the registry, e.g. `cdklabs` for `@cdklabs/*`. Omit to override the default registry. */\n  readonly scope?: string;\n}\n\n/**\n * VPC configuration for a wrapper-managed VPC (Blueprint `IManagedVpcConfig`, migrated from `VPCProvider`).\n * Every field is optional; an unset field takes Blueprint's original default.\n */\nexport interface ManagedVpcConfig {\n  /** CIDR block for the VPC. @default '172.31.0.0/20' */\n  readonly cidrBlock?: string;\n  /** Subnet CIDR mask. @default 24 */\n  readonly subnetCidrMask?: number;\n  /** Max AZs. @default 2 */\n  readonly maxAzs?: number;\n  /**\n   * The subnets the VPC's CodeBuild projects run in. Defaults to `PRIVATE_ISOLATED` when a `proxy`\n   * is configured (no NAT egress; the CodeBuild VPC endpoints below cover AWS API calls instead) and\n   * `PRIVATE_WITH_EGRESS` otherwise -- the rule Blueprint's `VPCProvider` applied.\n   */\n  readonly subnetType?: ec2.SubnetType;\n  /**\n   * Remove the default inbound/outbound rules from the VPC's default security group.\n   * @default true\n   */\n  readonly restrictDefaultSecurityGroup?: boolean;\n  /** Allow all outbound traffic by default from the security group the wrapper creates. @default true */\n  readonly allowAllOutbound?: boolean;\n  /**\n   * S3 bucket to send VPC flow logs to. Blueprint always used the RES stage's compliance-log bucket\n   * implicitly; Autopilot has not migrated that bucket yet (`m9-migrate-compliance-bucket`), so this is an\n   * explicit prop instead -- omit to skip flow logs.\n   */\n  readonly flowLogsBucketName?: string;\n  /**\n   * Extra CodeBuild VPC interface endpoints beyond the default set (SSM, STS, CloudWatch Logs,\n   * CloudFormation, Secrets Manager, KMS). Only used for the isolated-subnet case (see `subnetType`).\n   */\n  readonly codeBuildVpcInterfaces?: ec2.InterfaceVpcEndpointAwsService[];\n}\n\n/**\n * VPC configuration for the pipeline's own CodeBuild projects (Blueprint `IVpcConfig`, migrated from\n * `VPCProvider`). Set `managedVpc` to have the wrapper create a VPC, or `vpcId` to look up an\n * existing one; setting neither -- the default -- runs every CodeBuild project without a VPC.\n */\nexport interface VpcConfig {\n  /** Create a new VPC with these settings. */\n  readonly managedVpc?: ManagedVpcConfig;\n  /**\n   * Look up an existing VPC by id. A value starting with `resolve:ssm:` is resolved from the named\n   * SSM parameter at synth time instead of being used literally (Blueprint `VPCFromLookUpStack` parity).\n   */\n  readonly vpcId?: string;\n}\n\n/** A resolved stage's target environment. `regions` is always a list, even for a single region. */\nexport interface StageEnvironment {\n  /** Target account. Omitted means environment-agnostic (resolved from ambient creds at deploy). */\n  readonly account?: string;\n  /** Target regions, in order. Never empty for an environment-specific stage. */\n  readonly regions: string[];\n  /** How the regions roll out. */\n  readonly regionOrder: RegionOrder;\n}\n\n/** Forced deployer / CloudFormation-execution roles for a stage. */\nexport interface DeploymentConfig {\n  /** ARN the CLI assumes to deploy (passed as `cdk deploy --role-arn`). */\n  readonly deployRole?: string;\n  /** ARN CloudFormation assumes to execute the change set. */\n  readonly cfnExecutionRole?: string;\n  /**\n   * ExternalId presented when assuming `deployRole` (the `sts:ExternalId` a hardened cross-account\n   * trust policy requires). Overrides the pipeline-level `ResolvedCicdConfig.deployRoleExternalId` for\n   * this stage. A literal, or a `resolve:secretsmanager:<arn>` reference resolved at synth time (the\n   * same `resolve:` convention `VpcConfig.vpcId` uses). Ignored when `deployRole` is unset -- an\n   * ExternalId only applies to a role assumption the wrapper actually performs.\n   */\n  readonly externalId?: string;\n}\n\n/**\n * Names for the CDK Pipelines (Blueprint-compatible `CDK_PIPELINES`) engine's IAM roles -- the parity\n * replacement for Blueprint's `PipelineRoleNameEnforcementPlugin`, which the 1.x assembler-owned\n * pipeline stack gives a consumer no way to reattach. Any field omitted keeps CDK's generated name (no\n * behavior change). Only read when `engine` is `EngineType.CDK_PIPELINES`. The flat engine's roles are a\n * different set -- see `CodePipelineRoleNames`.\n */\nexport interface PipelineRoleNames {\n  /** `RoleName` forced on the CodePipeline pipeline role. */\n  readonly pipeline?: string;\n  /** `RoleName` forced on the CDK Pipelines file-publishing (assets) role. */\n  readonly assetsFile?: string;\n  /** `RoleName` forced on the CDK Pipelines docker-image-publishing (assets) role. */\n  readonly assetsDocker?: string;\n}\n\n/**\n * Names for the flat `CODEPIPELINE` engine's IAM roles. This engine's role set differs from the CDK\n * Pipelines engine (no asset-publishing roles; instead one CodeBuild role per stage), so it takes its\n * own struct. Any field omitted keeps CDK's generated name. Only read when `engine` is\n * `EngineType.CODEPIPELINE`.\n */\nexport interface CodePipelineRoleNames {\n  /** `RoleName` forced on the CodePipeline pipeline role. */\n  readonly pipeline?: string;\n  /**\n   * Prefix for the per-stage CodeBuild project roles: each stage's build role is named\n   * `<buildRolePrefix>-<stage>` (plus the CI/self-update projects, `<buildRolePrefix>-build` /\n   * `<buildRolePrefix>-selfupdate`). Omit to keep CDK-generated names.\n   */\n  readonly buildRolePrefix?: string;\n}\n\n/** A fully resolved deployment stage. */\nexport interface ResolvedStage {\n  /** Stage name, e.g. `dev`, `prod`. */\n  readonly name: string;\n  /** Where this stage deploys. */\n  readonly env: StageEnvironment;\n  /** Whether a manual approval gates this stage. */\n  readonly manualApproval: boolean;\n  /** Forced roles for this stage, if any. */\n  readonly deployment?: DeploymentConfig;\n}\n\n/** The resolved synthesizer choice. */\nexport interface SynthesizerConfig {\n  /** The synthesizer to install. */\n  readonly type: SynthesizerType;\n}\n\n/** The fully resolved pipeline configuration `defineCICD` produces. */\nexport interface ResolvedCicdConfig {\n  /** Application name; drives the bootstrap qualifier and asset naming. */\n  readonly application?: string;\n  /** Bootstrap qualifier (≤10 chars), derived from `application` when not given. */\n  readonly qualifier?: string;\n  /**\n   * CloudFormation stack name for the engine-owned self-mutating pipeline stack (the one the\n   * `CDK_PIPELINES` and `GITHUB_ACTIONS` engines assemble). Only read by those self-mutating engines;\n   * the flat `CODEPIPELINE` engine names its stack from the user's own `bin`.\n   * @default `${application}-pipeline`\n   *\n   * Set this to preserve a pre-1.x (Blueprint) pipeline stack name so an already-deployed,\n   * self-mutating pipeline can update IN PLACE instead of requiring a rename cutover -- the pipeline's\n   * `SelfMutate` step runs `cdk deploy <thisName>`, and a self-mutating pipeline cannot rename its own\n   * root stack. Changes ONLY the CloudFormation `stackName`, never the construct id, so the pipeline's\n   * child logical IDs are unchanged from the default. Same Blueprint-parity family as `pipelineRoleNames`.\n   */\n  readonly pipelineStackName?: string;\n  /** The source repository. */\n  readonly repository: Repository;\n  /** The deployment stages, in order. */\n  readonly stages: ResolvedStage[];\n  /** The synthesizer configuration. */\n  readonly synthesizer: SynthesizerConfig;\n  /** Which engine renders the pipeline. Defaults to CodePipeline. */\n  readonly engine: EngineType;\n  /** GitHub Actions engine configuration. Only read when `engine` is `EngineType.GITHUB_ACTIONS`. */\n  readonly githubActions?: GitHubActionsConfig;\n  /**\n   * Forced IAM role names for the CDK Pipelines (`CDK_PIPELINES`) engine's own roles. Only read when\n   * `engine` is `EngineType.CDK_PIPELINES`; omitted fields keep CDK-generated names.\n   */\n  readonly pipelineRoleNames?: PipelineRoleNames;\n  /**\n   * Forced IAM role names for the flat `CODEPIPELINE` engine's own roles. Only read when `engine` is\n   * `EngineType.CODEPIPELINE`; omitted fields keep CDK-generated names.\n   */\n  readonly codePipelineRoleNames?: CodePipelineRoleNames;\n  /**\n   * Pipeline-level default ExternalId presented when assuming a stage's forced `deployRole`. A stage's\n   * own `DeploymentConfig.externalId` overrides this. A literal or a `resolve:secretsmanager:<arn>`\n   * reference resolved at synth time.\n   */\n  readonly deployRoleExternalId?: string;\n  /** Resolved CI configuration. */\n  readonly ci: CiConfig;\n  /** Private CodeArtifact npm repository the builds authenticate against, if any. */\n  readonly codeArtifact?: CodeArtifactConfig;\n  /** Generic private npm registry the builds authenticate against with a bearer token, if any. */\n  readonly npmRegistry?: NpmRegistryConfig;\n  /** HTTP(S) proxy every build project routes through, if any. */\n  readonly proxy?: ProxyConfig;\n  /**\n   * Export per-stage account env vars on a self-mutating engine's synth step: before `cdk synth`, scan\n   * SSM Parameter Store under the pipeline's qualifier (`/<qualifier>/`) and export an `ACCOUNT_<STAGE>`\n   * env var for every parameter whose name contains `Account` (e.g. `/<qualifier>/AccountDev` ->\n   * `ACCOUNT_DEV`). This lets a `cdk.config.ts` that reads `process.env.ACCOUNT_<STAGE>` resolve target\n   * accounts at synth time from the values the bootstrap wrote to SSM.\n   * Off by default; only read by the self-mutating engines (`CDK_PIPELINES`, `GITHUB_ACTIONS`), whose\n   * synth step is the one that re-runs `cdk synth` under the pipeline. When on, the synth step is also\n   * granted `ssm:GetParametersByPath` on `/<qualifier>/*`, and fails loud if it finds no `Account*`\n   * parameter (a misconfigured qualifier is a hard error, not a silently-empty scan).\n   */\n  readonly warmAccountsFromSsm?: boolean;\n  /** VPC every CodeBuild project the pipeline creates runs in, if configured (Blueprint `VPCProvider`, migrated). */\n  readonly vpc?: VpcConfig;\n  /**\n   * The name of the compliance/access-log destination bucket, if configured (Blueprint\n   * `ComplianceBucketProvider`/`ComplianceLogBucketStack`, migrated). Threaded into\n   * `SupportResources.complianceLogBucket`; see there for the bucket's shape.\n   */\n  readonly complianceLogBucketName?: string;\n  /**\n   * CodeBuild environment overrides -- privileged mode, compute type, environment variables -- applied\n   * to every CodeBuild project the pipeline creates (Blueprint `codeBuildEnvSettings`, migrated from\n   * `CodeBuildFactoryProvider`/`PipelineBlueprint.codeBuildEnvSettings(...)`). Reuses CDK's own\n   * `BuildEnvironment` rather than a bespoke type, so it stays a drop-in for Blueprint callers. `buildImage`\n   * here is a full `IBuildImage` (e.g. an ARM or GPU managed image); it is distinct from the engines'\n   * own `buildImage` constructor prop, which takes a Docker-registry image string -- that prop wins\n   * when both are set.\n   */\n  readonly codeBuildEnvSettings?: codebuild.BuildEnvironment;\n  /** How the deployed cloud assembly is produced. Defaults to `ASSEMBLY_PROMOTION`. */\n  readonly deployModel: DeployModel;\n  /**\n   * Container mode (Repo 1): when set, the pipeline runs CI then builds & pushes a config-agnostic\n   * deployer image to ECR instead of deploying stages. Undefined = the normal deploy pipeline. (Named\n   * `deployerImage`, not `build` -- jsii reserves `build` as a struct member name.)\n   */\n  readonly deployerImage?: BuildImage;\n  /**\n   * Hand the CloudFormation wait to a Lambda instead of holding CodeBuild compute for it (D-deploy-wait).\n   *\n   * Off by default: the build-compute path is what `m4-verify` proves end to end, and this one replaces\n   * how deployment actually executes -- change sets prepared by the build, then executed and polled by a\n   * Lambda -- so it is opt-in until a real run validates it. When on, a deploy stage stops billing build\n   * minutes for the (usually dominant) stretch where CloudFormation is working.\n   */\n  readonly asyncDeploy: boolean;\n  /**\n   * Deploy with **CloudFormation express mode** (`cdk deploy --express`). CloudFormation reports each\n   * stack operation complete as soon as it applies the resource configuration, *without* waiting for\n   * resources to stabilize -- materially faster for stacks whose resources are slow to stabilize.\n   * Express runs with **rollback disabled** (a failed deploy is left in a failed state for inspection);\n   * forcing `--rollback` conflicts with the change-set path for nested stacks, so the CLI does not add\n   * it. AWS does **not** recommend express mode for production -- it targets fast iterative\n   * deployments. Off by default.\n   */\n  readonly express?: boolean;\n  /**\n   * Security plugins (hardening Aspects) to apply tree-wide, by `{ name, version }` (issue #241).\n   * Omitted keeps the default-on set; an empty list opts out of all; a non-empty list COMPLETELY\n   * overrides the defaults. A name that is not a built-in is a custom plugin and MUST be registered\n   * in `bin/` via `CdkCicd.addPlugin` -- the config carries only its identity, not the instance.\n   */\n  readonly plugins?: PluginRef[];\n}\n\n/**\n * A resolved deployment target for container mode (Repo 2): a stage to deploy the pinned image against,\n * with its own environment and optional forced roles. `env` mirrors a `ResolvedStage`'s environment, but a\n * target names the stage it maps to rather than defining it -- the stage's stacks live in the image, not\n * here. `manualApproval` defaults the same way stages do (gated unless `dev`/`res`).\n */\nexport interface ResolvedDeploymentTarget {\n  /** The stage in the image's app to deploy (passed to the in-container `cdk-cicd deploy --stage`). */\n  readonly stage: string;\n  /** Where this target deploys. */\n  readonly env: StageEnvironment;\n  /** Whether a manual approval gates this target. */\n  readonly manualApproval: boolean;\n  /** Forced roles for this target, if any. */\n  readonly deployment?: DeploymentConfig;\n  /**\n   * The deployer image (tag/digest) to run for THIS target, overriding the config-level `image`. This is\n   * how a stage pins its own application version -- bump `dev`'s tag to ship a new version to dev alone,\n   * or set `int`/`prod` to the same tag to promote. When unset, the target uses the config-level `image`.\n   */\n  readonly image?: string;\n}\n\n/**\n * The fully resolved container-mode deployment configuration `defineDeployment` produces (Repo 2 of the\n * two-repo split). It pins one config-agnostic deployer image and lists the targets to run it against;\n * `cdk-cicd deploy --from-image` runs the image per target, synthesizing and deploying in-container.\n */\nexport interface ResolvedDeploymentConfig {\n  /**\n   * The default deployer image to run targets against (an ECR/OCI reference, tag or digest). A target's\n   * own `image` overrides this, so per-stage versions live on the targets; this is the shared fallback.\n   * Optional only because every target may pin its own `image` -- each target must resolve to one or the other.\n   */\n  readonly image?: string;\n  /** The deployment targets, in order. */\n  readonly targets: ResolvedDeploymentTarget[];\n  /**\n   * The config-only source repository the CD pipeline watches (where `deploy.config.ts` lives -- no CDK\n   * code). Optional: when omitted, the config drives only the local `cdk-cicd deploy --from-image`\n   * executor; set it to provision a CD CodePipeline (`cdk-cicd deploy-ci`) whose CodeBuild pulls the image\n   * and deploys each target. This is the deploy-side twin of `ResolvedCicdConfig.repository`.\n   */\n  readonly repository?: Repository;\n  /**\n   * Private CodeArtifact repo the CD build authenticates against before `npm ci` (to install the wrapper\n   * CLI when it is pre-release / not on public npm). Same shape as the pipeline-config `codeArtifact`.\n   */\n  readonly codeArtifact?: CodeArtifactConfig;\n  /**\n   * Generic private npm registry the CD build authenticates against before `npm ci`. Same shape as the\n   * pipeline-config `npmRegistry`.\n   */\n  readonly npmRegistry?: NpmRegistryConfig;\n}\n"]}
@@ -1,4 +1,5 @@
1
- import { Environment, Stage } from 'aws-cdk-lib';
1
+ import { Environment, Stack, Stage } from 'aws-cdk-lib';
2
+ import * as iam from 'aws-cdk-lib/aws-iam';
2
3
  import * as pipelines from 'aws-cdk-lib/pipelines';
3
4
  import { Construct } from 'constructs';
4
5
  import { ResolvedCicdConfig } from '../../config/types';
@@ -53,3 +54,19 @@ export declare class CdkPipelinesEngine extends Construct {
53
54
  */
54
55
  private suppressGeneratedPipelineNag;
55
56
  }
57
+ /**
58
+ * Before `cdk synth`, scan SSM Parameter Store under the qualifier and export an `ACCOUNT_<STAGE>`
59
+ * env var for EVERY parameter whose name contains `Account` (`/<qualifier>/AccountDev` ->
60
+ * `ACCOUNT_DEV`). Dynamic -- it does NOT hardcode a stage list; whatever `Account*` params the
61
+ * bootstrap wrote become env vars. The qualifier is the config's when set, else the build's own
62
+ * `$CDK_QUALIFIER` (which `CdkPipelinesEngine` already puts on the synth step env).
63
+ *
64
+ * Emitted as POSIX `/bin/sh` (the CodeBuild default shell): the scan writes to a temp file and the
65
+ * `while` reads from it via redirection, so the `export`s land in the SAME shell that then runs
66
+ * `cdk synth` (a `... | while` pipe would export into a subshell and lose them). Fails loud --
67
+ * `exit 1` -- if it finds zero `Account*` params, so a wrong qualifier is a hard error at synth
68
+ * time rather than a silently-empty warm.
69
+ */
70
+ export declare function ssmWarmingCommands(qualifier?: string): string[];
71
+ /** The read grant the SSM warming scan needs: `ssm:GetParametersByPath` on the qualifier's parameter path. */
72
+ export declare function ssmWarmingReadStatements(stack: Stack, qualifier?: string): iam.PolicyStatement[];
@@ -2,6 +2,8 @@
2
2
  var _a;
3
3
  Object.defineProperty(exports, "__esModule", { value: true });
4
4
  exports.CdkPipelinesEngine = void 0;
5
+ exports.ssmWarmingCommands = ssmWarmingCommands;
6
+ exports.ssmWarmingReadStatements = ssmWarmingReadStatements;
5
7
  const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
6
8
  // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
7
9
  // SPDX-License-Identifier: Apache-2.0
@@ -68,11 +70,15 @@ class CdkPipelinesEngine extends constructs_1.Construct {
68
70
  const name = props.pipelineName ?? `${config.application ?? 'cdk-cicd'}-pipeline`;
69
71
  const region = aws_cdk_lib_1.Stack.of(this).region;
70
72
  // The Synth step: install (proxy exports, then CodeArtifact login for private/pre-release deps)
71
- // then `cdk synth`, which re-runs the caller's bin -- the same app that built this pipeline -- so
72
- // self-mutation works. The proxy's exports run FIRST: NO_PROXY is what lets the AWS-API-bound
73
- // `codeartifact login` skip the proxy while `npm ci` against public npm goes through it.
73
+ // then `npm run cdk synth`, run with `CDK_CICD_MODE=pipeline` on the step env (below) so
74
+ // `cdk.json`'s single `cdk-cicd exec` entry renders THIS pipeline -- so CDK Pipelines self-mutation,
75
+ // which reruns this step and redeploys the pipeline stack from the fresh assembly, still sees itself.
76
+ // Without the mode set, that same entry synthesizes only the application stacks. The proxy's exports
77
+ // run FIRST: NO_PROXY is what lets the AWS-API-bound `codeartifact login` skip the proxy while
78
+ // `npm ci` against public npm goes through it.
74
79
  const installCommands = [
75
80
  ...(config.proxy ? proxyInstallCommands(config.proxy) : []),
81
+ ...(config.warmAccountsFromSsm ? ssmWarmingCommands(config.qualifier) : []),
76
82
  ...(config.codeArtifact
77
83
  ? [
78
84
  `aws codeartifact login --tool npm --domain ${config.codeArtifact.domain} ` +
@@ -106,10 +112,14 @@ class CdkPipelinesEngine extends constructs_1.Construct {
106
112
  input: sourceFor(this, config.repository),
107
113
  installCommands,
108
114
  // With no ci.steps, run the default CI (its own `npm ci` first); with ci.steps, those steps ARE
109
- // the build phase verbatim -- the engine injects nothing, not even `npm ci`. Then synth via
110
- // `npm run cdk` so the project's pinned aws-cdk is used, not whatever `npx` resolves.
115
+ // the build phase verbatim -- the engine injects nothing, not even `npm ci`. Then `npm run cdk
116
+ // synth`, which runs `cdk.json`'s single `cdk-cicd exec` entry. `CDK_CICD_MODE=pipeline` (below)
117
+ // makes that entry render THIS pipeline, so CDK Pipelines self-mutation re-renders itself; a plain
118
+ // `cdk synth` without the mode set renders only the application stacks.
111
119
  commands: [...(ciSteps.length > 0 ? ciSteps : (0, ci_commands_1.defaultCiCommands)()), 'npm run cdk synth'],
112
120
  env: {
121
+ // Render the pipeline (not the app stacks) from the single cdk.json entry during self-mutation.
122
+ CDK_CICD_MODE: 'pipeline',
113
123
  ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}),
114
124
  AWS_REGION: region,
115
125
  ...(config.proxy ? proxyEnvVariables(aws_cdk_lib_1.Stack.of(this), config.proxy) : {}),
@@ -124,6 +134,7 @@ class CdkPipelinesEngine extends constructs_1.Construct {
124
134
  rolePolicyStatements: [
125
135
  ...(config.codeArtifact ? codeArtifactReadStatements(aws_cdk_lib_1.Stack.of(this), config.codeArtifact) : []),
126
136
  ...(config.proxy ? proxySecretReadStatements(aws_cdk_lib_1.Stack.of(this), config.proxy) : []),
137
+ ...(config.warmAccountsFromSsm ? ssmWarmingReadStatements(aws_cdk_lib_1.Stack.of(this), config.qualifier) : []),
127
138
  ],
128
139
  }),
129
140
  });
@@ -247,7 +258,7 @@ class CdkPipelinesEngine extends constructs_1.Construct {
247
258
  }
248
259
  exports.CdkPipelinesEngine = CdkPipelinesEngine;
249
260
  _a = JSII_RTTI_SYMBOL_1;
250
- CdkPipelinesEngine[_a] = { fqn: "@cdklabs/cdk-cicd-wrapper.CdkPipelinesEngine", version: "2.0.0" };
261
+ CdkPipelinesEngine[_a] = { fqn: "@cdklabs/cdk-cicd-wrapper.CdkPipelinesEngine", version: "2.2.0" };
251
262
  /** The CodeArtifact read permissions a `codeartifact login` + `npm ci` need (mirrors the flat engine). */
252
263
  function codeArtifactReadStatements(stack, ca) {
253
264
  const account = ca.account ?? stack.account;
@@ -301,6 +312,66 @@ function proxyInstallCommands(proxy) {
301
312
  `curl -Is --connect-timeout 5 ${proxy.proxyTestUrl} | grep "HTTP/"`,
302
313
  ];
303
314
  }
315
+ /**
316
+ * Before `cdk synth`, scan SSM Parameter Store under the qualifier and export an `ACCOUNT_<STAGE>`
317
+ * env var for EVERY parameter whose name contains `Account` (`/<qualifier>/AccountDev` ->
318
+ * `ACCOUNT_DEV`). Dynamic -- it does NOT hardcode a stage list; whatever `Account*` params the
319
+ * bootstrap wrote become env vars. The qualifier is the config's when set, else the build's own
320
+ * `$CDK_QUALIFIER` (which `CdkPipelinesEngine` already puts on the synth step env).
321
+ *
322
+ * Emitted as POSIX `/bin/sh` (the CodeBuild default shell): the scan writes to a temp file and the
323
+ * `while` reads from it via redirection, so the `export`s land in the SAME shell that then runs
324
+ * `cdk synth` (a `... | while` pipe would export into a subshell and lose them). Fails loud --
325
+ * `exit 1` -- if it finds zero `Account*` params, so a wrong qualifier is a hard error at synth
326
+ * time rather than a silently-empty warm.
327
+ */
328
+ function ssmWarmingCommands(qualifier) {
329
+ const qualifierExpr = qualifier !== undefined ? qualifier : '$CDK_QUALIFIER';
330
+ return [
331
+ `echo "Warming ACCOUNT_<STAGE> env vars from SSM parameters under /${qualifierExpr}/"`,
332
+ '_warm_tmp="$(mktemp)"',
333
+ `aws ssm get-parameters-by-path --path "/${qualifierExpr}/" --query "Parameters[].[Name, Value]" --output text > "$_warm_tmp"`,
334
+ '_warm_found=0',
335
+ // `|| [ -n "$_warm_name" ]` processes a final row that has no trailing newline (POSIX `read`
336
+ // returns non-zero on EOF-without-newline but still populates the vars), so the last Account*
337
+ // param is never silently dropped.
338
+ 'while IFS="$(printf \'\\t\')" read -r _warm_name _warm_value || [ -n "$_warm_name" ]; do',
339
+ ' [ -z "$_warm_name" ] && continue',
340
+ ' case "$_warm_name" in',
341
+ ' *Account*)',
342
+ " _warm_stage=\"$(printf '%s' \"${_warm_name##*Account}\" | tr '[:lower:]' '[:upper:]' | tr -cd '[:alnum:]_')\"",
343
+ // Skip a param whose suffix is not a valid shell identifier (empty, or leading digit) instead of
344
+ // letting `export` fail silently -- warn so a misnamed parameter is visible, not lost.
345
+ ' case "$_warm_stage" in',
346
+ " ''|[0-9]*)",
347
+ ' echo "cdk-cicd: warmAccountsFromSsm skipping \\"${_warm_name}\\" -- yields no valid ACCOUNT_<STAGE> identifier" >&2',
348
+ ' continue ;;',
349
+ ' esac',
350
+ ' export "ACCOUNT_${_warm_stage}=${_warm_value}"',
351
+ ' echo "ACCOUNT_${_warm_stage} set"',
352
+ ' _warm_found=1',
353
+ ' ;;',
354
+ ' esac',
355
+ 'done < "$_warm_tmp"',
356
+ 'rm -f "$_warm_tmp"',
357
+ `if [ "$_warm_found" -eq 0 ]; then echo "cdk-cicd: warmAccountsFromSsm found no *Account* parameters under /${qualifierExpr}/ -- is the qualifier correct and the account bootstrapped?" >&2; exit 1; fi`,
358
+ ];
359
+ }
360
+ /** The read grant the SSM warming scan needs: `ssm:GetParametersByPath` on the qualifier's parameter path. */
361
+ function ssmWarmingReadStatements(stack, qualifier) {
362
+ // The grant must be scoped to a literal `parameter/<qualifier>/*`. A resolvable qualifier is required
363
+ // when warming is enabled (enforced in resolveCicdConfig) -- guard here too so this helper can never
364
+ // emit an over-broad `parameter/*/*` grant.
365
+ if (qualifier === undefined) {
366
+ throw new Error('cdk-cicd: ssmWarmingReadStatements needs a qualifier to scope the ssm:GetParametersByPath grant.');
367
+ }
368
+ return [
369
+ new iam.PolicyStatement({
370
+ actions: ['ssm:GetParametersByPath'],
371
+ resources: [`arn:${stack.partition}:ssm:${stack.region}:${stack.account}:parameter/${qualifier}/*`],
372
+ }),
373
+ ];
374
+ }
304
375
  /** The read grant the proxy secret needs, plus cross-account KMS decrypt when the secret lives elsewhere. */
305
376
  function proxySecretReadStatements(stack, proxy) {
306
377
  const secretArn = aws_cdk_lib_1.Arn.split(proxy.proxySecretArn, aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME);
@@ -315,4 +386,4 @@ function proxySecretReadStatements(stack, proxy) {
315
386
  }
316
387
  return statements;
317
388
  }
318
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkPipelinesEngine.js","sourceRoot":"","sources":["../../../src/engine/cdkpipelines/CdkPipelinesEngine.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n//\n// The Blueprint-compatible CD engine: builds the pipeline with **CDK Pipelines** (`aws-cdk-lib/pipelines`), the\n// same construct Blueprint's PipelineBlueprint used. It produces a pipeline that looks like Blueprint's -- a self-\n// mutating CodePipeline with a Synth step, an Assets stage, and one wave per deployment stage (with\n// optional pre-approval) -- so a team migrating from Blueprint gets a familiar shape.\n//\n// It sits ALONGSIDE the flat CodePipelineEngine (raw aws-codepipeline), not instead of it: the flat\n// engine is the lightweight default; this one is the opt-in for Blueprint parity. Because CDK Pipelines needs\n// the application's stacks IN the pipeline's own synth (it wraps them as `cdk.Stage`s and self-mutates),\n// this engine cannot be zero-touch like the flat one -- the caller supplies a `stages` factory that\n// builds the app's stacks for a given stage, exactly as Blueprint's `.addStack(...)` did. So it is used from an\n// explicit `bin/` (the documented opt-in path), not the `deploy-ci` zero-touch flow.\n\nimport { Arn, ArnFormat, AspectPriority, Aspects, Environment, Stack, Stage } from 'aws-cdk-lib';\nimport * as codebuild from 'aws-cdk-lib/aws-codebuild';\nimport * as codecommit from 'aws-cdk-lib/aws-codecommit';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as pipelines from 'aws-cdk-lib/pipelines';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\nimport { Repository, RepositorySourceType } from '../../config/repository';\nimport { CodeArtifactConfig, PipelineRoleNames, ProxyConfig, ResolvedCicdConfig } from '../../config/types';\nimport { AccessLogsForBucketAspect } from '../../support/AccessLogsForBucketAspect';\nimport { SupportResources } from '../../support/SupportResources';\nimport { resolveVpcNetworking } from '../../support/Vpc';\nimport { defaultCiCommands } from '../ci-commands';\n\n/** Context passed to the stage factory for one deployment stage. */\nexport interface CdkPipelinesStageContext {\n  /** The stage name from the config (e.g. `DEVFRA`). */\n  readonly stageName: string;\n  /** The stage's target environment (account + primary region). */\n  readonly env: Environment;\n}\n\n/**\n * Builds the application's stacks for one deployment stage into the given `cdk.Stage`. This is the Blueprint\n * `IStackProvider` equivalent: CDK Pipelines deploys whatever stacks the provider adds to the stage. A\n * behavioural interface (not a bare function) so it crosses the jsii boundary like Blueprint's providers did.\n */\nexport interface IStageProvider {\n  /** Add the app's stacks for `context.stageName` into `stage`. */\n  stacks(stage: Stage, context: CdkPipelinesStageContext): void;\n}\n\n/** Props for the CDK Pipelines (Blueprint-compatible) engine. */\nexport interface CdkPipelinesEngineProps {\n  /** The resolved pipeline configuration (`defineCICD`). */\n  readonly config: ResolvedCicdConfig;\n  /** Builds the app's stacks per stage (the Blueprint-compat opt-in — CDK Pipelines needs the stacks in-synth). */\n  readonly stages: IStageProvider;\n  /** Pipeline name; defaults to `<application>-pipeline`. */\n  readonly pipelineName?: string;\n}\n\n/** Map a resolved `Repository` to the CDK Pipelines source the Synth step reads from. */\nfunction sourceFor(scope: Construct, repository: Repository): pipelines.CodePipelineSource {\n  switch (repository.repositoryType) {\n    case RepositorySourceType.CODECOMMIT:\n      return pipelines.CodePipelineSource.codeCommit(\n        codecommit.Repository.fromRepositoryName(scope, 'SourceRepo', repository.name),\n        repository.branch,\n      );\n    case RepositorySourceType.GITHUB:\n    case RepositorySourceType.CODESTAR_CONNECTION:\n      // Both need a CodeStar (CodeConnections) connection ARN to read the git provider.\n      if (repository.connectionArn === undefined) {\n        throw new Error(\n          `cdk-cicd: a CodeStar connection ARN is required for a ${repository.repositoryType} source -- ` +\n            'use Repository.codestarConnection(name, connectionArn)',\n        );\n      }\n      return pipelines.CodePipelineSource.connection(repository.name, repository.branch, {\n        connectionArn: repository.connectionArn,\n      });\n    case RepositorySourceType.S3: {\n      // `name` is `bucket/key`; a bucket-only name defaults the key to source.zip (matches the flat engine).\n      const slash = repository.name.indexOf('/');\n      const bucketName = slash >= 0 ? repository.name.slice(0, slash) : repository.name;\n      const objectKey = slash >= 0 ? repository.name.slice(slash + 1) : 'source.zip';\n      return pipelines.CodePipelineSource.s3(s3.Bucket.fromBucketName(scope, 'SourceBucket', bucketName), objectKey);\n    }\n    default:\n      throw new Error(\n        `cdk-cicd: unsupported repository type for the CDK Pipelines engine: ${repository.repositoryType}`,\n      );\n  }\n}\n\n/**\n * A CDK Pipelines pipeline rendered from an Autopilot config + a stage factory. Reproduces the Blueprint shape:\n * Source -> Synth (self-mutating) -> Assets -> one wave per stage (with a pre-approval when the stage is\n * gated). Cross-account keys are on (Blueprint default) so multi-account stages work.\n */\nexport class CdkPipelinesEngine extends Construct {\n  public readonly pipeline: pipelines.CodePipeline;\n\n  constructor(scope: Construct, id: string, props: CdkPipelinesEngineProps) {\n    super(scope, id);\n    const config = props.config;\n    const name = props.pipelineName ?? `${config.application ?? 'cdk-cicd'}-pipeline`;\n    const region = Stack.of(this).region;\n\n    // The Synth step: install (proxy exports, then CodeArtifact login for private/pre-release deps)\n    // then `cdk synth`, which re-runs the caller's bin -- the same app that built this pipeline -- so\n    // self-mutation works. The proxy's exports run FIRST: NO_PROXY is what lets the AWS-API-bound\n    // `codeartifact login` skip the proxy while `npm ci` against public npm goes through it.\n    const installCommands = [\n      ...(config.proxy ? proxyInstallCommands(config.proxy) : []),\n      ...(config.codeArtifact\n        ? [\n            `aws codeartifact login --tool npm --domain ${config.codeArtifact.domain} ` +\n              `--domain-owner ${config.codeArtifact.account ?? Stack.of(this).account} ` +\n              `--repository ${config.codeArtifact.repository} --region ${config.codeArtifact.region ?? region}` +\n              (config.codeArtifact.npmScope ? ` --namespace ${config.codeArtifact.npmScope}` : ''),\n          ]\n        : []),\n    ];\n    const ciSteps = Object.values(config.ci.steps);\n    // Blueprint `VPCProvider`, applied by CDK Pipelines itself to EVERY CodeBuild project it creates (synth,\n    // self-mutation, asset publishing) -- the uniform application Blueprint had.\n    const vpcNetworking = resolveVpcNetworking(this, config.vpc, config.proxy !== undefined);\n\n    this.pipeline = new pipelines.CodePipeline(this, 'Pipeline', {\n      pipelineName: name,\n      crossAccountKeys: true,\n      enableKeyRotation: true,\n      // Blueprint `codeBuildEnvSettings` (privileged mode, compute type, environment variables --\n      // `CodeBuildFactoryProvider` parity) + `vpc` above, both applied by CDK Pipelines itself to EVERY\n      // CodeBuild project it creates (synth, self-mutation, asset publishing) -- the uniform application\n      // Blueprint had.\n      codeBuildDefaults:\n        config.codeBuildEnvSettings !== undefined || vpcNetworking !== undefined\n          ? {\n              buildEnvironment: config.codeBuildEnvSettings,\n              vpc: vpcNetworking?.vpc,\n              securityGroups: vpcNetworking?.securityGroups,\n              subnetSelection: vpcNetworking?.subnetSelection,\n            }\n          : undefined,\n      synth: new pipelines.CodeBuildStep('Synth', {\n        input: sourceFor(this, config.repository),\n        installCommands,\n        // With no ci.steps, run the default CI (its own `npm ci` first); with ci.steps, those steps ARE\n        // the build phase verbatim -- the engine injects nothing, not even `npm ci`. Then synth via\n        // `npm run cdk` so the project's pinned aws-cdk is used, not whatever `npx` resolves.\n        commands: [...(ciSteps.length > 0 ? ciSteps : defaultCiCommands()), 'npm run cdk synth'],\n        env: {\n          ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}),\n          AWS_REGION: region,\n          ...(config.proxy ? proxyEnvVariables(Stack.of(this), config.proxy) : {}),\n        },\n        // The proxy credentials/ports live in Secrets Manager, not in plain env vars.\n        partialBuildSpec: config.proxy\n          ? codebuild.BuildSpec.fromObject({ env: { 'secrets-manager': proxySecretsManagerVars(config.proxy) } })\n          : undefined,\n        // Grant the synth build the CodeArtifact/proxy-secret read permissions its\n        // `codeartifact login`/`export`s need (the CodeBuildStep role has only logs/artifacts by\n        // default) -- else they fail AccessDenied.\n        rolePolicyStatements: [\n          ...(config.codeArtifact ? codeArtifactReadStatements(Stack.of(this), config.codeArtifact) : []),\n          ...(config.proxy ? proxySecretReadStatements(Stack.of(this), config.proxy) : []),\n        ],\n      }),\n    });\n\n    // One wave per (stage x region), in config order, wrapping the app stacks the provider builds. A gated\n    // stage gets a manual-approval step ahead of its FIRST region -- the fail-closed promotion gate Blueprint had.\n    // A multi-region stage becomes one wave per region (Blueprint deployed each region), not a single dropped one.\n    for (const stage of config.stages) {\n      const regions = stage.env.regions.length > 0 ? stage.env.regions : [region];\n      regions.forEach((stageRegion, i) => {\n        const env: Environment = { account: stage.env.account, region: stageRegion };\n        const stageId = regions.length > 1 ? `${stage.name}-${stageRegion}` : stage.name;\n        const appStage = new Stage(this, stageId, { env });\n        props.stages.stacks(appStage, { stageName: stage.name, env });\n        this.pipeline.addStage(appStage, {\n          pre:\n            stage.manualApproval && i === 0 ? [new pipelines.ManualApprovalStep(`Approve-${stage.name}`)] : undefined,\n        });\n      });\n    }\n\n    // Force the pipeline's construction now (CDK Pipelines builds it lazily at synth) so its generated\n    // roles/buckets exist to annotate below, before the AwsSolutionsChecks aspect visits at synth time.\n    this.pipeline.buildPipeline();\n    this.suppressGeneratedPipelineNag();\n\n    // Parity with Blueprint's PipelineRoleNameEnforcementPlugin: force deterministic RoleNames on the\n    // pipeline's own roles so external cross-account trust policies / SCPs / permission boundaries that\n    // reference fixed names keep working. The assembler owns the pipeline stack, so this must live here --\n    // a consumer's replayed bin has no handle on these roles. Omitted names keep CDK's generated value.\n    if (config.pipelineRoleNames !== undefined) {\n      this.enforceRoleNames(config.pipelineRoleNames);\n    }\n\n    // Compliance/access-log bucket, at parity with the flat CodePipelineEngine: provision it when a name\n    // is configured, and attach the per-region name-substituting access-logs aspect so secondary-region\n    // stacks log to the region-substituted bucket name (Blueprint's AccessLogsForBucketPlugin behavior).\n    if (config.complianceLogBucketName !== undefined) {\n      const support = new SupportResources(this, 'Support', {\n        complianceLogBucketName: config.complianceLogBucketName,\n      });\n      // Force-read the lazy getter so the bucket is provisioned by merely configuring the name (Blueprint's\n      // ComplianceBucketProvider was default-on, not behind a separate opt-in).\n      void support.complianceLogBucket;\n      // MUTATING priority so the aspect sets each bucket's L1 loggingConfiguration BEFORE the readonly\n      // AwsSolutionsChecks (added in pipeline-assembler) visits -- otherwise AwsSolutions-S1 false-fails\n      // because nag sees the bucket before the logging config is applied. No S1 suppression is added.\n      Aspects.of(this).add(\n        new AccessLogsForBucketAspect({\n          complianceLogBucketName: config.complianceLogBucketName,\n          mainRegion: region,\n        }),\n        { priority: AspectPriority.MUTATING },\n      );\n    }\n  }\n\n  /**\n   * Force `RoleName` on the pipeline's own IAM roles (Blueprint `PipelineRoleNameEnforcementPlugin`\n   * parity). Matches on `iam.CfnRole` under this engine's construct scope rather than a hard-coded leaf\n   * id: the CodePipeline role is the pipeline construct's own role, and the file/docker asset-publishing\n   * roles live under the CDK Pipelines-generated `Assets` scope. The asset roles are distinguished by\n   * their node path segment (`FileRole` / `DockerRole`), which is stable across the aws-cdk-lib/pipelines\n   * versions the wrapper supports; run against the real synthesized tree in tests to pin them.\n   */\n  private enforceRoleNames(names: PipelineRoleNames): void {\n    const setRoleName = (role: iam.CfnRole | undefined, roleName?: string): void => {\n      if (role !== undefined && roleName !== undefined && roleName.length > 0) {\n        role.roleName = roleName;\n      }\n    };\n\n    // The CodePipeline pipeline role: the role directly on the underlying Pipeline construct.\n    const pipelineRole = this.pipeline.pipeline.role.node.defaultChild as iam.CfnRole | undefined;\n    setRoleName(pipelineRole, names.pipeline);\n\n    // The asset-publishing roles: CfnRoles whose node path carries the CDK Pipelines asset-role segment.\n    for (const cfnRole of this.node.findAll().filter((c): c is iam.CfnRole => c instanceof iam.CfnRole)) {\n      const path = cfnRole.node.path;\n      if (/FileRole/.test(path)) {\n        setRoleName(cfnRole, names.assetsFile);\n      } else if (/DockerRole/.test(path)) {\n        setRoleName(cfnRole, names.assetsDocker);\n      }\n    }\n  }\n\n  /**\n   * Suppress the cdk-nag findings on the infrastructure **CDK Pipelines generates for itself** -- the\n   * pipeline/synth/self-mutation/assets roles' unavoidable wildcards and the internal artifact and\n   * cross-region replication buckets. This engine runs `AwsSolutionsChecks` (as Blueprint did) so the\n   * user's app stacks are still judged on their own merits; only the wrapper-owned pipeline plumbing is\n   * exempted here, with evidence, mirroring Blueprint's `CDKPipeline` suppressions.\n   */\n  private suppressGeneratedPipelineNag(): void {\n    // The pipeline construct is entirely wrapper-generated plumbing; its roles read/write the pipeline's\n    // own KMS-encrypted artifact bucket and source object, actions CDK issues with wildcards it cannot\n    // resource-scope. The app stages are siblings under this engine (not under `pipeline`), so this stays\n    // off them.\n    NagSuppressions.addResourceSuppressions(\n      this.pipeline,\n      [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            \"CDK Pipelines' own pipeline/synth/self-mutation/assets roles: S3 multipart + KMS envelope grants on the pipeline's own artifact store and the CDK bootstrap-role assumes it needs to deploy -- wildcards CDK generates for its plumbing, scoped to the pipeline's own resources. Includes the wrapper's own condition-scoped sts:GetServiceBearerToken on the synth role (the CodeArtifact token endpoint is not resource-scopable), and, when a VPC is configured, the CodeBuild-managed network-interface permissions CDK adds to every VPC-attached project's role.\",\n        },\n      ],\n      true,\n    );\n\n    const pipeline = this.pipeline.pipeline;\n    // The internal artifact store: transient build outputs, already KMS-encrypted/SSL-enforced/public-access\n    // blocked. Access logging would provision a second bucket just to record the pipeline's own reads.\n    NagSuppressions.addResourceSuppressions(pipeline.artifactBucket, [\n      {\n        id: 'AwsSolutions-S1',\n        reason: \"The pipeline's internal artifact store, not a data bucket; already KMS-encrypted and non-public.\",\n      },\n    ]);\n\n    // A stage in a region other than the pipeline's gets a CDK-generated cross-region *support stack* (a\n    // separate stack) holding a replication bucket + its KMS key. Suppress the same S1/IAM5 there.\n    for (const support of Object.values(pipeline.crossRegionSupport)) {\n      NagSuppressions.addResourceSuppressions(support.replicationBucket, [\n        {\n          id: 'AwsSolutions-S1',\n          reason:\n            \"CDK Pipelines' cross-region artifact replication bucket; internal store, KMS-encrypted and non-public.\",\n        },\n      ]);\n      NagSuppressions.addStackSuppressions(support.stack, [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            \"CDK-generated KMS key policy for the cross-region replication bucket; wildcards are on the pipeline's own key.\",\n        },\n      ]);\n    }\n  }\n}\n\n/** The CodeArtifact read permissions a `codeartifact login` + `npm ci` need (mirrors the flat engine). */\nfunction codeArtifactReadStatements(stack: Stack, ca: CodeArtifactConfig): iam.PolicyStatement[] {\n  const account = ca.account ?? stack.account;\n  const region = ca.region ?? stack.region;\n  return [\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetAuthorizationToken'],\n      resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:domain/${ca.domain}`],\n    }),\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetRepositoryEndpoint', 'codeartifact:ReadFromRepository'],\n      resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:repository/${ca.domain}/${ca.repository}`],\n    }),\n    // The npm token is minted through STS on CodeArtifact's behalf; scoped to that service, not blanket.\n    new iam.PolicyStatement({\n      actions: ['sts:GetServiceBearerToken'],\n      resources: ['*'],\n      conditions: { StringEquals: { 'sts:AWSServiceName': 'codeartifact.amazonaws.com' } },\n    }),\n  ];\n}\n\n/**\n * Plain (non-secret) proxy env vars the Synth step needs (mirrors the flat engine). An empty\n * `noProxy` defaults to the pipeline's own region's AWS endpoint, so AWS API calls (like\n * `codeartifact login`) bypass the proxy while `npm ci` against public npm goes through it.\n */\nfunction proxyEnvVariables(stack: Stack, proxy: ProxyConfig): Record<string, string> {\n  const noProxy = proxy.noProxy.length > 0 ? proxy.noProxy : [`${stack.region}.amazonaws.com`];\n  return {\n    AWS_STS_REGIONAL_ENDPOINTS: 'regional',\n    NO_PROXY: noProxy.join(','),\n    PROXY_SECRET_ARN: proxy.proxySecretArn,\n  };\n}\n\n/** The secret's fields, referenced by `<arn>:<jsonKey>` so CodeBuild resolves them at container start. */\nfunction proxySecretsManagerVars(proxy: ProxyConfig): Record<string, string> {\n  return {\n    PROXY_USERNAME: `${proxy.proxySecretArn}:username`,\n    PROXY_PASSWORD: `${proxy.proxySecretArn}:password`,\n    HTTP_PROXY_PORT: `${proxy.proxySecretArn}:http_proxy_port`,\n    HTTPS_PROXY_PORT: `${proxy.proxySecretArn}:https_proxy_port`,\n    PROXY_DOMAIN: `${proxy.proxySecretArn}:proxy_domain`,\n  };\n}\n\n/** Export the proxy for every later shell command, then prove the tunnel works before install runs. */\nfunction proxyInstallCommands(proxy: ProxyConfig): string[] {\n  return [\n    'export HTTP_PROXY=\"http://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTP_PROXY_PORT\"',\n    'export HTTPS_PROXY=\"https://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTPS_PROXY_PORT\"',\n    'echo \"--- Proxy Test ---\"',\n    `curl -Is --connect-timeout 5 ${proxy.proxyTestUrl} | grep \"HTTP/\"`,\n  ];\n}\n\n/** The read grant the proxy secret needs, plus cross-account KMS decrypt when the secret lives elsewhere. */\nfunction proxySecretReadStatements(stack: Stack, proxy: ProxyConfig): iam.PolicyStatement[] {\n  const secretArn = Arn.split(proxy.proxySecretArn, ArnFormat.SLASH_RESOURCE_NAME);\n  const statements = [\n    new iam.PolicyStatement({ actions: ['secretsmanager:GetSecretValue'], resources: [proxy.proxySecretArn] }),\n  ];\n  if (secretArn.account !== undefined && secretArn.account !== stack.account) {\n    statements.push(\n      new iam.PolicyStatement({\n        actions: ['kms:Decrypt', 'kms:DescribeKey', 'kms:Encrypt', 'kms:GenerateDataKey*', 'kms:ReEncrypt*'],\n        resources: [`arn:${stack.partition}:kms:${secretArn.region}:${secretArn.account}:key/*`],\n      }),\n    );\n  }\n  return statements;\n}\n\n// NOTE: the old `cdkPipelinesApp(config, factory)` explicit-factory entry has been RETIRED. The single\n// entry is now `cdk-cicd exec bin/app.ts` for both engines (engine chosen in cicd.config): for\n// CDK_PIPELINES it replays the plain bin per stage via runtime/pipeline-assembler, so no factory or\n// pipeline-specific bin is needed. `CdkPipelinesEngine` (above) remains the construct that renders the\n// pipeline; the assembler drives it with a replay-based IStageProvider.\n"]}
389
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkPipelinesEngine.js","sourceRoot":"","sources":["../../../src/engine/cdkpipelines/CdkPipelinesEngine.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n//\n// The Blueprint-compatible CD engine: builds the pipeline with **CDK Pipelines** (`aws-cdk-lib/pipelines`), the\n// same construct Blueprint's PipelineBlueprint used. It produces a pipeline that looks like Blueprint's -- a self-\n// mutating CodePipeline with a Synth step, an Assets stage, and one wave per deployment stage (with\n// optional pre-approval) -- so a team migrating from Blueprint gets a familiar shape.\n//\n// It sits ALONGSIDE the flat CodePipelineEngine (raw aws-codepipeline), not instead of it: the flat\n// engine is the lightweight default; this one is the opt-in for Blueprint parity. Because CDK Pipelines needs\n// the application's stacks IN the pipeline's own synth (it wraps them as `cdk.Stage`s and self-mutates),\n// this engine cannot be zero-touch like the flat one -- the caller supplies a `stages` factory that\n// builds the app's stacks for a given stage, exactly as Blueprint's `.addStack(...)` did. So it is used from an\n// explicit `bin/` (the documented opt-in path), not the `deploy-ci` zero-touch flow.\n\nimport { Arn, ArnFormat, AspectPriority, Aspects, Environment, Stack, Stage } from 'aws-cdk-lib';\nimport * as codebuild from 'aws-cdk-lib/aws-codebuild';\nimport * as codecommit from 'aws-cdk-lib/aws-codecommit';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as pipelines from 'aws-cdk-lib/pipelines';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\nimport { Repository, RepositorySourceType } from '../../config/repository';\nimport { CodeArtifactConfig, PipelineRoleNames, ProxyConfig, ResolvedCicdConfig } from '../../config/types';\nimport { AccessLogsForBucketAspect } from '../../support/AccessLogsForBucketAspect';\nimport { SupportResources } from '../../support/SupportResources';\nimport { resolveVpcNetworking } from '../../support/Vpc';\nimport { defaultCiCommands } from '../ci-commands';\n\n/** Context passed to the stage factory for one deployment stage. */\nexport interface CdkPipelinesStageContext {\n  /** The stage name from the config (e.g. `DEVFRA`). */\n  readonly stageName: string;\n  /** The stage's target environment (account + primary region). */\n  readonly env: Environment;\n}\n\n/**\n * Builds the application's stacks for one deployment stage into the given `cdk.Stage`. This is the Blueprint\n * `IStackProvider` equivalent: CDK Pipelines deploys whatever stacks the provider adds to the stage. A\n * behavioural interface (not a bare function) so it crosses the jsii boundary like Blueprint's providers did.\n */\nexport interface IStageProvider {\n  /** Add the app's stacks for `context.stageName` into `stage`. */\n  stacks(stage: Stage, context: CdkPipelinesStageContext): void;\n}\n\n/** Props for the CDK Pipelines (Blueprint-compatible) engine. */\nexport interface CdkPipelinesEngineProps {\n  /** The resolved pipeline configuration (`defineCICD`). */\n  readonly config: ResolvedCicdConfig;\n  /** Builds the app's stacks per stage (the Blueprint-compat opt-in — CDK Pipelines needs the stacks in-synth). */\n  readonly stages: IStageProvider;\n  /** Pipeline name; defaults to `<application>-pipeline`. */\n  readonly pipelineName?: string;\n}\n\n/** Map a resolved `Repository` to the CDK Pipelines source the Synth step reads from. */\nfunction sourceFor(scope: Construct, repository: Repository): pipelines.CodePipelineSource {\n  switch (repository.repositoryType) {\n    case RepositorySourceType.CODECOMMIT:\n      return pipelines.CodePipelineSource.codeCommit(\n        codecommit.Repository.fromRepositoryName(scope, 'SourceRepo', repository.name),\n        repository.branch,\n      );\n    case RepositorySourceType.GITHUB:\n    case RepositorySourceType.CODESTAR_CONNECTION:\n      // Both need a CodeStar (CodeConnections) connection ARN to read the git provider.\n      if (repository.connectionArn === undefined) {\n        throw new Error(\n          `cdk-cicd: a CodeStar connection ARN is required for a ${repository.repositoryType} source -- ` +\n            'use Repository.codestarConnection(name, connectionArn)',\n        );\n      }\n      return pipelines.CodePipelineSource.connection(repository.name, repository.branch, {\n        connectionArn: repository.connectionArn,\n      });\n    case RepositorySourceType.S3: {\n      // `name` is `bucket/key`; a bucket-only name defaults the key to source.zip (matches the flat engine).\n      const slash = repository.name.indexOf('/');\n      const bucketName = slash >= 0 ? repository.name.slice(0, slash) : repository.name;\n      const objectKey = slash >= 0 ? repository.name.slice(slash + 1) : 'source.zip';\n      return pipelines.CodePipelineSource.s3(s3.Bucket.fromBucketName(scope, 'SourceBucket', bucketName), objectKey);\n    }\n    default:\n      throw new Error(\n        `cdk-cicd: unsupported repository type for the CDK Pipelines engine: ${repository.repositoryType}`,\n      );\n  }\n}\n\n/**\n * A CDK Pipelines pipeline rendered from an Autopilot config + a stage factory. Reproduces the Blueprint shape:\n * Source -> Synth (self-mutating) -> Assets -> one wave per stage (with a pre-approval when the stage is\n * gated). Cross-account keys are on (Blueprint default) so multi-account stages work.\n */\nexport class CdkPipelinesEngine extends Construct {\n  public readonly pipeline: pipelines.CodePipeline;\n\n  constructor(scope: Construct, id: string, props: CdkPipelinesEngineProps) {\n    super(scope, id);\n    const config = props.config;\n    const name = props.pipelineName ?? `${config.application ?? 'cdk-cicd'}-pipeline`;\n    const region = Stack.of(this).region;\n\n    // The Synth step: install (proxy exports, then CodeArtifact login for private/pre-release deps)\n    // then `npm run cdk synth`, run with `CDK_CICD_MODE=pipeline` on the step env (below) so\n    // `cdk.json`'s single `cdk-cicd exec` entry renders THIS pipeline -- so CDK Pipelines self-mutation,\n    // which reruns this step and redeploys the pipeline stack from the fresh assembly, still sees itself.\n    // Without the mode set, that same entry synthesizes only the application stacks. The proxy's exports\n    // run FIRST: NO_PROXY is what lets the AWS-API-bound `codeartifact login` skip the proxy while\n    // `npm ci` against public npm goes through it.\n    const installCommands = [\n      ...(config.proxy ? proxyInstallCommands(config.proxy) : []),\n      ...(config.warmAccountsFromSsm ? ssmWarmingCommands(config.qualifier) : []),\n      ...(config.codeArtifact\n        ? [\n            `aws codeartifact login --tool npm --domain ${config.codeArtifact.domain} ` +\n              `--domain-owner ${config.codeArtifact.account ?? Stack.of(this).account} ` +\n              `--repository ${config.codeArtifact.repository} --region ${config.codeArtifact.region ?? region}` +\n              (config.codeArtifact.npmScope ? ` --namespace ${config.codeArtifact.npmScope}` : ''),\n          ]\n        : []),\n    ];\n    const ciSteps = Object.values(config.ci.steps);\n    // Blueprint `VPCProvider`, applied by CDK Pipelines itself to EVERY CodeBuild project it creates (synth,\n    // self-mutation, asset publishing) -- the uniform application Blueprint had.\n    const vpcNetworking = resolveVpcNetworking(this, config.vpc, config.proxy !== undefined);\n\n    this.pipeline = new pipelines.CodePipeline(this, 'Pipeline', {\n      pipelineName: name,\n      crossAccountKeys: true,\n      enableKeyRotation: true,\n      // Blueprint `codeBuildEnvSettings` (privileged mode, compute type, environment variables --\n      // `CodeBuildFactoryProvider` parity) + `vpc` above, both applied by CDK Pipelines itself to EVERY\n      // CodeBuild project it creates (synth, self-mutation, asset publishing) -- the uniform application\n      // Blueprint had.\n      codeBuildDefaults:\n        config.codeBuildEnvSettings !== undefined || vpcNetworking !== undefined\n          ? {\n              buildEnvironment: config.codeBuildEnvSettings,\n              vpc: vpcNetworking?.vpc,\n              securityGroups: vpcNetworking?.securityGroups,\n              subnetSelection: vpcNetworking?.subnetSelection,\n            }\n          : undefined,\n      synth: new pipelines.CodeBuildStep('Synth', {\n        input: sourceFor(this, config.repository),\n        installCommands,\n        // With no ci.steps, run the default CI (its own `npm ci` first); with ci.steps, those steps ARE\n        // the build phase verbatim -- the engine injects nothing, not even `npm ci`. Then `npm run cdk\n        // synth`, which runs `cdk.json`'s single `cdk-cicd exec` entry. `CDK_CICD_MODE=pipeline` (below)\n        // makes that entry render THIS pipeline, so CDK Pipelines self-mutation re-renders itself; a plain\n        // `cdk synth` without the mode set renders only the application stacks.\n        commands: [...(ciSteps.length > 0 ? ciSteps : defaultCiCommands()), 'npm run cdk synth'],\n        env: {\n          // Render the pipeline (not the app stacks) from the single cdk.json entry during self-mutation.\n          CDK_CICD_MODE: 'pipeline',\n          ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}),\n          AWS_REGION: region,\n          ...(config.proxy ? proxyEnvVariables(Stack.of(this), config.proxy) : {}),\n        },\n        // The proxy credentials/ports live in Secrets Manager, not in plain env vars.\n        partialBuildSpec: config.proxy\n          ? codebuild.BuildSpec.fromObject({ env: { 'secrets-manager': proxySecretsManagerVars(config.proxy) } })\n          : undefined,\n        // Grant the synth build the CodeArtifact/proxy-secret read permissions its\n        // `codeartifact login`/`export`s need (the CodeBuildStep role has only logs/artifacts by\n        // default) -- else they fail AccessDenied.\n        rolePolicyStatements: [\n          ...(config.codeArtifact ? codeArtifactReadStatements(Stack.of(this), config.codeArtifact) : []),\n          ...(config.proxy ? proxySecretReadStatements(Stack.of(this), config.proxy) : []),\n          ...(config.warmAccountsFromSsm ? ssmWarmingReadStatements(Stack.of(this), config.qualifier) : []),\n        ],\n      }),\n    });\n\n    // One wave per (stage x region), in config order, wrapping the app stacks the provider builds. A gated\n    // stage gets a manual-approval step ahead of its FIRST region -- the fail-closed promotion gate Blueprint had.\n    // A multi-region stage becomes one wave per region (Blueprint deployed each region), not a single dropped one.\n    for (const stage of config.stages) {\n      const regions = stage.env.regions.length > 0 ? stage.env.regions : [region];\n      regions.forEach((stageRegion, i) => {\n        const env: Environment = { account: stage.env.account, region: stageRegion };\n        const stageId = regions.length > 1 ? `${stage.name}-${stageRegion}` : stage.name;\n        const appStage = new Stage(this, stageId, { env });\n        props.stages.stacks(appStage, { stageName: stage.name, env });\n        this.pipeline.addStage(appStage, {\n          pre:\n            stage.manualApproval && i === 0 ? [new pipelines.ManualApprovalStep(`Approve-${stage.name}`)] : undefined,\n        });\n      });\n    }\n\n    // Force the pipeline's construction now (CDK Pipelines builds it lazily at synth) so its generated\n    // roles/buckets exist to annotate below, before the AwsSolutionsChecks aspect visits at synth time.\n    this.pipeline.buildPipeline();\n    this.suppressGeneratedPipelineNag();\n\n    // Parity with Blueprint's PipelineRoleNameEnforcementPlugin: force deterministic RoleNames on the\n    // pipeline's own roles so external cross-account trust policies / SCPs / permission boundaries that\n    // reference fixed names keep working. The assembler owns the pipeline stack, so this must live here --\n    // a consumer's replayed bin has no handle on these roles. Omitted names keep CDK's generated value.\n    if (config.pipelineRoleNames !== undefined) {\n      this.enforceRoleNames(config.pipelineRoleNames);\n    }\n\n    // Compliance/access-log bucket, at parity with the flat CodePipelineEngine: provision it when a name\n    // is configured, and attach the per-region name-substituting access-logs aspect so secondary-region\n    // stacks log to the region-substituted bucket name (Blueprint's AccessLogsForBucketPlugin behavior).\n    if (config.complianceLogBucketName !== undefined) {\n      const support = new SupportResources(this, 'Support', {\n        complianceLogBucketName: config.complianceLogBucketName,\n      });\n      // Force-read the lazy getter so the bucket is provisioned by merely configuring the name (Blueprint's\n      // ComplianceBucketProvider was default-on, not behind a separate opt-in).\n      void support.complianceLogBucket;\n      // MUTATING priority so the aspect sets each bucket's L1 loggingConfiguration BEFORE the readonly\n      // AwsSolutionsChecks (added in pipeline-assembler) visits -- otherwise AwsSolutions-S1 false-fails\n      // because nag sees the bucket before the logging config is applied. No S1 suppression is added.\n      Aspects.of(this).add(\n        new AccessLogsForBucketAspect({\n          complianceLogBucketName: config.complianceLogBucketName,\n          mainRegion: region,\n        }),\n        { priority: AspectPriority.MUTATING },\n      );\n    }\n  }\n\n  /**\n   * Force `RoleName` on the pipeline's own IAM roles (Blueprint `PipelineRoleNameEnforcementPlugin`\n   * parity). Matches on `iam.CfnRole` under this engine's construct scope rather than a hard-coded leaf\n   * id: the CodePipeline role is the pipeline construct's own role, and the file/docker asset-publishing\n   * roles live under the CDK Pipelines-generated `Assets` scope. The asset roles are distinguished by\n   * their node path segment (`FileRole` / `DockerRole`), which is stable across the aws-cdk-lib/pipelines\n   * versions the wrapper supports; run against the real synthesized tree in tests to pin them.\n   */\n  private enforceRoleNames(names: PipelineRoleNames): void {\n    const setRoleName = (role: iam.CfnRole | undefined, roleName?: string): void => {\n      if (role !== undefined && roleName !== undefined && roleName.length > 0) {\n        role.roleName = roleName;\n      }\n    };\n\n    // The CodePipeline pipeline role: the role directly on the underlying Pipeline construct.\n    const pipelineRole = this.pipeline.pipeline.role.node.defaultChild as iam.CfnRole | undefined;\n    setRoleName(pipelineRole, names.pipeline);\n\n    // The asset-publishing roles: CfnRoles whose node path carries the CDK Pipelines asset-role segment.\n    for (const cfnRole of this.node.findAll().filter((c): c is iam.CfnRole => c instanceof iam.CfnRole)) {\n      const path = cfnRole.node.path;\n      if (/FileRole/.test(path)) {\n        setRoleName(cfnRole, names.assetsFile);\n      } else if (/DockerRole/.test(path)) {\n        setRoleName(cfnRole, names.assetsDocker);\n      }\n    }\n  }\n\n  /**\n   * Suppress the cdk-nag findings on the infrastructure **CDK Pipelines generates for itself** -- the\n   * pipeline/synth/self-mutation/assets roles' unavoidable wildcards and the internal artifact and\n   * cross-region replication buckets. This engine runs `AwsSolutionsChecks` (as Blueprint did) so the\n   * user's app stacks are still judged on their own merits; only the wrapper-owned pipeline plumbing is\n   * exempted here, with evidence, mirroring Blueprint's `CDKPipeline` suppressions.\n   */\n  private suppressGeneratedPipelineNag(): void {\n    // The pipeline construct is entirely wrapper-generated plumbing; its roles read/write the pipeline's\n    // own KMS-encrypted artifact bucket and source object, actions CDK issues with wildcards it cannot\n    // resource-scope. The app stages are siblings under this engine (not under `pipeline`), so this stays\n    // off them.\n    NagSuppressions.addResourceSuppressions(\n      this.pipeline,\n      [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            \"CDK Pipelines' own pipeline/synth/self-mutation/assets roles: S3 multipart + KMS envelope grants on the pipeline's own artifact store and the CDK bootstrap-role assumes it needs to deploy -- wildcards CDK generates for its plumbing, scoped to the pipeline's own resources. Includes the wrapper's own condition-scoped sts:GetServiceBearerToken on the synth role (the CodeArtifact token endpoint is not resource-scopable), and, when a VPC is configured, the CodeBuild-managed network-interface permissions CDK adds to every VPC-attached project's role.\",\n        },\n      ],\n      true,\n    );\n\n    const pipeline = this.pipeline.pipeline;\n    // The internal artifact store: transient build outputs, already KMS-encrypted/SSL-enforced/public-access\n    // blocked. Access logging would provision a second bucket just to record the pipeline's own reads.\n    NagSuppressions.addResourceSuppressions(pipeline.artifactBucket, [\n      {\n        id: 'AwsSolutions-S1',\n        reason: \"The pipeline's internal artifact store, not a data bucket; already KMS-encrypted and non-public.\",\n      },\n    ]);\n\n    // A stage in a region other than the pipeline's gets a CDK-generated cross-region *support stack* (a\n    // separate stack) holding a replication bucket + its KMS key. Suppress the same S1/IAM5 there.\n    for (const support of Object.values(pipeline.crossRegionSupport)) {\n      NagSuppressions.addResourceSuppressions(support.replicationBucket, [\n        {\n          id: 'AwsSolutions-S1',\n          reason:\n            \"CDK Pipelines' cross-region artifact replication bucket; internal store, KMS-encrypted and non-public.\",\n        },\n      ]);\n      NagSuppressions.addStackSuppressions(support.stack, [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            \"CDK-generated KMS key policy for the cross-region replication bucket; wildcards are on the pipeline's own key.\",\n        },\n      ]);\n    }\n  }\n}\n\n/** The CodeArtifact read permissions a `codeartifact login` + `npm ci` need (mirrors the flat engine). */\nfunction codeArtifactReadStatements(stack: Stack, ca: CodeArtifactConfig): iam.PolicyStatement[] {\n  const account = ca.account ?? stack.account;\n  const region = ca.region ?? stack.region;\n  return [\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetAuthorizationToken'],\n      resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:domain/${ca.domain}`],\n    }),\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetRepositoryEndpoint', 'codeartifact:ReadFromRepository'],\n      resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:repository/${ca.domain}/${ca.repository}`],\n    }),\n    // The npm token is minted through STS on CodeArtifact's behalf; scoped to that service, not blanket.\n    new iam.PolicyStatement({\n      actions: ['sts:GetServiceBearerToken'],\n      resources: ['*'],\n      conditions: { StringEquals: { 'sts:AWSServiceName': 'codeartifact.amazonaws.com' } },\n    }),\n  ];\n}\n\n/**\n * Plain (non-secret) proxy env vars the Synth step needs (mirrors the flat engine). An empty\n * `noProxy` defaults to the pipeline's own region's AWS endpoint, so AWS API calls (like\n * `codeartifact login`) bypass the proxy while `npm ci` against public npm goes through it.\n */\nfunction proxyEnvVariables(stack: Stack, proxy: ProxyConfig): Record<string, string> {\n  const noProxy = proxy.noProxy.length > 0 ? proxy.noProxy : [`${stack.region}.amazonaws.com`];\n  return {\n    AWS_STS_REGIONAL_ENDPOINTS: 'regional',\n    NO_PROXY: noProxy.join(','),\n    PROXY_SECRET_ARN: proxy.proxySecretArn,\n  };\n}\n\n/** The secret's fields, referenced by `<arn>:<jsonKey>` so CodeBuild resolves them at container start. */\nfunction proxySecretsManagerVars(proxy: ProxyConfig): Record<string, string> {\n  return {\n    PROXY_USERNAME: `${proxy.proxySecretArn}:username`,\n    PROXY_PASSWORD: `${proxy.proxySecretArn}:password`,\n    HTTP_PROXY_PORT: `${proxy.proxySecretArn}:http_proxy_port`,\n    HTTPS_PROXY_PORT: `${proxy.proxySecretArn}:https_proxy_port`,\n    PROXY_DOMAIN: `${proxy.proxySecretArn}:proxy_domain`,\n  };\n}\n\n/** Export the proxy for every later shell command, then prove the tunnel works before install runs. */\nfunction proxyInstallCommands(proxy: ProxyConfig): string[] {\n  return [\n    'export HTTP_PROXY=\"http://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTP_PROXY_PORT\"',\n    'export HTTPS_PROXY=\"https://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTPS_PROXY_PORT\"',\n    'echo \"--- Proxy Test ---\"',\n    `curl -Is --connect-timeout 5 ${proxy.proxyTestUrl} | grep \"HTTP/\"`,\n  ];\n}\n\n/**\n * Before `cdk synth`, scan SSM Parameter Store under the qualifier and export an `ACCOUNT_<STAGE>`\n * env var for EVERY parameter whose name contains `Account` (`/<qualifier>/AccountDev` ->\n * `ACCOUNT_DEV`). Dynamic -- it does NOT hardcode a stage list; whatever `Account*` params the\n * bootstrap wrote become env vars. The qualifier is the config's when set, else the build's own\n * `$CDK_QUALIFIER` (which `CdkPipelinesEngine` already puts on the synth step env).\n *\n * Emitted as POSIX `/bin/sh` (the CodeBuild default shell): the scan writes to a temp file and the\n * `while` reads from it via redirection, so the `export`s land in the SAME shell that then runs\n * `cdk synth` (a `... | while` pipe would export into a subshell and lose them). Fails loud --\n * `exit 1` -- if it finds zero `Account*` params, so a wrong qualifier is a hard error at synth\n * time rather than a silently-empty warm.\n */\nexport function ssmWarmingCommands(qualifier?: string): string[] {\n  const qualifierExpr = qualifier !== undefined ? qualifier : '$CDK_QUALIFIER';\n  return [\n    `echo \"Warming ACCOUNT_<STAGE> env vars from SSM parameters under /${qualifierExpr}/\"`,\n    '_warm_tmp=\"$(mktemp)\"',\n    `aws ssm get-parameters-by-path --path \"/${qualifierExpr}/\" --query \"Parameters[].[Name, Value]\" --output text > \"$_warm_tmp\"`,\n    '_warm_found=0',\n    // `|| [ -n \"$_warm_name\" ]` processes a final row that has no trailing newline (POSIX `read`\n    // returns non-zero on EOF-without-newline but still populates the vars), so the last Account*\n    // param is never silently dropped.\n    'while IFS=\"$(printf \\'\\\\t\\')\" read -r _warm_name _warm_value || [ -n \"$_warm_name\" ]; do',\n    '  [ -z \"$_warm_name\" ] && continue',\n    '  case \"$_warm_name\" in',\n    '    *Account*)',\n    \"      _warm_stage=\\\"$(printf '%s' \\\"${_warm_name##*Account}\\\" | tr '[:lower:]' '[:upper:]' | tr -cd '[:alnum:]_')\\\"\",\n    // Skip a param whose suffix is not a valid shell identifier (empty, or leading digit) instead of\n    // letting `export` fail silently -- warn so a misnamed parameter is visible, not lost.\n    '      case \"$_warm_stage\" in',\n    \"        ''|[0-9]*)\",\n    '          echo \"cdk-cicd: warmAccountsFromSsm skipping \\\\\"${_warm_name}\\\\\" -- yields no valid ACCOUNT_<STAGE> identifier\" >&2',\n    '          continue ;;',\n    '      esac',\n    '      export \"ACCOUNT_${_warm_stage}=${_warm_value}\"',\n    '      echo \"ACCOUNT_${_warm_stage} set\"',\n    '      _warm_found=1',\n    '      ;;',\n    '  esac',\n    'done < \"$_warm_tmp\"',\n    'rm -f \"$_warm_tmp\"',\n    `if [ \"$_warm_found\" -eq 0 ]; then echo \"cdk-cicd: warmAccountsFromSsm found no *Account* parameters under /${qualifierExpr}/ -- is the qualifier correct and the account bootstrapped?\" >&2; exit 1; fi`,\n  ];\n}\n\n/** The read grant the SSM warming scan needs: `ssm:GetParametersByPath` on the qualifier's parameter path. */\nexport function ssmWarmingReadStatements(stack: Stack, qualifier?: string): iam.PolicyStatement[] {\n  // The grant must be scoped to a literal `parameter/<qualifier>/*`. A resolvable qualifier is required\n  // when warming is enabled (enforced in resolveCicdConfig) -- guard here too so this helper can never\n  // emit an over-broad `parameter/*/*` grant.\n  if (qualifier === undefined) {\n    throw new Error('cdk-cicd: ssmWarmingReadStatements needs a qualifier to scope the ssm:GetParametersByPath grant.');\n  }\n  return [\n    new iam.PolicyStatement({\n      actions: ['ssm:GetParametersByPath'],\n      resources: [`arn:${stack.partition}:ssm:${stack.region}:${stack.account}:parameter/${qualifier}/*`],\n    }),\n  ];\n}\n\n/** The read grant the proxy secret needs, plus cross-account KMS decrypt when the secret lives elsewhere. */\nfunction proxySecretReadStatements(stack: Stack, proxy: ProxyConfig): iam.PolicyStatement[] {\n  const secretArn = Arn.split(proxy.proxySecretArn, ArnFormat.SLASH_RESOURCE_NAME);\n  const statements = [\n    new iam.PolicyStatement({ actions: ['secretsmanager:GetSecretValue'], resources: [proxy.proxySecretArn] }),\n  ];\n  if (secretArn.account !== undefined && secretArn.account !== stack.account) {\n    statements.push(\n      new iam.PolicyStatement({\n        actions: ['kms:Decrypt', 'kms:DescribeKey', 'kms:Encrypt', 'kms:GenerateDataKey*', 'kms:ReEncrypt*'],\n        resources: [`arn:${stack.partition}:kms:${secretArn.region}:${secretArn.account}:key/*`],\n      }),\n    );\n  }\n  return statements;\n}\n\n// NOTE: the old `cdkPipelinesApp(config, factory)` explicit-factory entry has been RETIRED. The single\n// entry is now `cdk-cicd exec bin/app.ts` for both engines (engine chosen in cicd.config): for\n// CDK_PIPELINES it replays the plain bin per stage via runtime/pipeline-assembler, so no factory or\n// pipeline-specific bin is needed. `CdkPipelinesEngine` (above) remains the construct that renders the\n// pipeline; the assembler drives it with a replay-based IStageProvider.\n"]}