@cdklabs/cdk-cicd-wrapper 2.3.2 → 2.3.3

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.
Files changed (48) hide show
  1. package/.jsii +758 -196
  2. package/API.md +526 -45
  3. package/README.md +11 -0
  4. package/lib/app/DeploymentPipelineApp.js +7 -3
  5. package/lib/app/PipelineApp.js +12 -4
  6. package/lib/appconfig/accessor.js +1 -1
  7. package/lib/config/build-image.d.ts +17 -1
  8. package/lib/config/build-image.js +57 -3
  9. package/lib/config/default-synthesizer-role-arn.d.ts +38 -0
  10. package/lib/config/default-synthesizer-role-arn.js +63 -0
  11. package/lib/config/define.d.ts +50 -1
  12. package/lib/config/define.js +117 -6
  13. package/lib/config/naming.d.ts +7 -2
  14. package/lib/config/naming.js +9 -9
  15. package/lib/config/repository.js +1 -1
  16. package/lib/config/types.d.ts +123 -11
  17. package/lib/config/types.js +6 -2
  18. package/lib/engine/cdkpipelines/CdkPipelinesEngine.d.ts +6 -0
  19. package/lib/engine/cdkpipelines/CdkPipelinesEngine.js +419 -43
  20. package/lib/engine/codepipeline/CodePipelineEngine.d.ts +22 -15
  21. package/lib/engine/codepipeline/CodePipelineEngine.js +681 -127
  22. package/lib/engine/codepipeline/DeploymentPipeline.d.ts +8 -5
  23. package/lib/engine/codepipeline/DeploymentPipeline.js +937 -72
  24. package/lib/engine/external-id-secrets.d.ts +17 -0
  25. package/lib/engine/external-id-secrets.js +53 -0
  26. package/lib/engine/github/GitHubActionsEngine.d.ts +3 -4
  27. package/lib/engine/github/GitHubActionsEngine.js +446 -34
  28. package/lib/index.d.ts +3 -1
  29. package/lib/index.js +6 -2
  30. package/lib/runtime/attach.js +1 -1
  31. package/lib/runtime/inject.d.ts +41 -3
  32. package/lib/runtime/inject.js +259 -22
  33. package/lib/runtime/pipeline-assembler.d.ts +7 -1
  34. package/lib/runtime/pipeline-assembler.js +144 -36
  35. package/lib/runtime/register.js +10 -1
  36. package/lib/support/AccessLogsForBucketAspect.d.ts +14 -8
  37. package/lib/support/AccessLogsForBucketAspect.js +52 -37
  38. package/lib/support/DestroyEncryptionKeysOnDeleteAspect.js +1 -1
  39. package/lib/support/DisablePublicIPAssignmentForEC2Aspect.js +1 -1
  40. package/lib/support/EncryptBucketOnTransitAspect.js +1 -1
  41. package/lib/support/EncryptCloudWatchLogGroupsAspect.js +1 -1
  42. package/lib/support/EncryptSNSTopicOnTransitAspect.js +1 -1
  43. package/lib/support/LambdaDLQAspect.js +1 -1
  44. package/lib/support/LogRetentionAspect.js +1 -1
  45. package/lib/support/RotateEncryptionKeysAspect.js +1 -1
  46. package/lib/support/SupportResources.d.ts +24 -14
  47. package/lib/support/SupportResources.js +42 -24
  48. package/package.json +5 -4
@@ -29,15 +29,19 @@ const region_info_1 = require("aws-cdk-lib/region-info");
29
29
  const cdk_nag_1 = require("cdk-nag");
30
30
  const cdk_pipelines_github_1 = require("cdk-pipelines-github");
31
31
  const constructs_1 = require("constructs");
32
+ const build_image_1 = require("../../config/build-image");
33
+ const default_synthesizer_role_arn_1 = require("../../config/default-synthesizer-role-arn");
32
34
  const repository_1 = require("../../config/repository");
35
+ const types_1 = require("../../config/types");
36
+ const AccessLogsForBucketAspect_1 = require("../../support/AccessLogsForBucketAspect");
37
+ const SupportResources_1 = require("../../support/SupportResources");
33
38
  const CdkPipelinesEngine_1 = require("../cdkpipelines/CdkPipelinesEngine");
34
39
  const ci_commands_1 = require("../ci-commands");
35
40
  /**
36
41
  * A GitHub Actions workflow rendered from an Autopilot config + a stage factory. Reproduces the Blueprint shape: a
37
- * `GitHubActionRole` the workflow assumes over OIDC, a Synth job, and one job (with a GitHub Environment,
38
- * so an environment protection rule set up on GitHub's side gates it) per deployment stage. Manual-approval
39
- * config is NOT translated into a CDK step here -- as in Blueprint, GitHub Environments are the gate; every stage
40
- * gets its own environment regardless of `manualApproval`, and gating is configured in the GitHub UI.
42
+ * `GitHubActionRole` the workflow assumes over OIDC, a Synth job, and one job (with a GitHub Environment)
43
+ * per deployment stage. GitHub owns the environment protection rules, so approval-gated stages are accepted
44
+ * only when config explicitly acknowledges that required reviewers are configured on those environments.
41
45
  */
42
46
  class GitHubActionsEngine extends constructs_1.Construct {
43
47
  constructor(scope, id, props) {
@@ -48,12 +52,25 @@ class GitHubActionsEngine extends constructs_1.Construct {
48
52
  `'${config.repository.repositoryType}'.`);
49
53
  }
50
54
  const options = config.githubActions ?? {};
55
+ assertSupportedSynthesizer(config);
56
+ assertNoDeployRoleExternalIds(config);
57
+ assertEnvironmentProtectionConfigured(config);
51
58
  const stack = aws_cdk_lib_1.Stack.of(this);
59
+ assertConcretePipelineEnvironment(stack);
60
+ assertConcreteDeploymentEnvironments(stack, config);
61
+ const partition = assertSupportedWorkflowPartition(stack, config, options.publishAssetsAuthRegion);
62
+ assertSupportedComplianceLogging(stack, config);
63
+ const buildContainerCredentials = resolveBuildContainerCredentials(config);
64
+ const complianceLogBucket = config.complianceLogBucketName !== undefined
65
+ ? new SupportResources_1.SupportResources(this, 'Support', {
66
+ complianceLogBucketName: config.complianceLogBucketName,
67
+ createComplianceLogBucket: config.createComplianceLogBucket,
68
+ }).complianceLogBucket
69
+ : undefined;
52
70
  const roleName = options.roleName ?? `${config.application ?? 'cdk-cicd'}-github-role`;
53
- const publishAssetsAuthRegion = options.publishAssetsAuthRegion ?? 'us-west-2';
71
+ const publishAssetsAuthRegion = options.publishAssetsAuthRegion ?? stack.region;
54
72
  // A literal ARN, not `this.gitHubActionRole.role.roleArn` (a CDK token): the workflow file is plain
55
73
  // text written at synth time, so only a value known BEFORE synth ends up correctly in it.
56
- const partition = aws_cdk_lib_1.Token.isUnresolved(stack.region) ? 'aws' : (region_info_1.RegionInfo.get(stack.region).partition ?? 'aws');
57
74
  const gitHubActionRoleArn = aws_cdk_lib_1.Arn.format({
58
75
  partition,
59
76
  service: 'iam',
@@ -75,6 +92,35 @@ class GitHubActionsEngine extends constructs_1.Construct {
75
92
  }
76
93
  : {}),
77
94
  });
95
+ hardenGitHubOidcAudience(this.gitHubActionRole);
96
+ for (const statement of (0, CdkPipelinesEngine_1.targetLookupStatements)(stack, config, partition)) {
97
+ this.gitHubActionRole.role.addToPrincipalPolicy(statement);
98
+ }
99
+ const qualifier = (0, default_synthesizer_role_arn_1.resolveDefaultSynthesizerQualifier)(this, config.qualifier);
100
+ const forcedDeployRoles = new Set();
101
+ for (const stage of config.stages) {
102
+ const configuredDeployRole = stage.deployment?.deployRole?.trim();
103
+ const deployRole = configuredDeployRole === undefined || configuredDeployRole.length === 0
104
+ ? aws_cdk_lib_1.DefaultStackSynthesizer.DEFAULT_DEPLOY_ROLE_ARN
105
+ : configuredDeployRole;
106
+ const account = stage.env.account ?? stack.account;
107
+ const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];
108
+ for (const region of regions) {
109
+ const specializedRole = (0, default_synthesizer_role_arn_1.specializeDefaultSynthesizerRoleArn)(deployRole, {
110
+ qualifier,
111
+ account,
112
+ region,
113
+ partition,
114
+ });
115
+ assertStableGitHubDeployRoleArn(specializedRole, stage.name);
116
+ if (configuredDeployRole !== undefined && configuredDeployRole.length > 0) {
117
+ forcedDeployRoles.add(specializedRole);
118
+ }
119
+ }
120
+ }
121
+ if (forcedDeployRoles.size > 0) {
122
+ this.gitHubActionRole.role.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ['sts:AssumeRole'], resources: [...forcedDeployRoles] }));
123
+ }
78
124
  cdk_nag_1.NagSuppressions.addResourceSuppressions(this.gitHubActionRole, [
79
125
  {
80
126
  id: 'AwsSolutions-IAM5',
@@ -87,9 +133,12 @@ class GitHubActionsEngine extends constructs_1.Construct {
87
133
  // The step runs with `CDK_CICD_MODE=pipeline` (set on the step env below), so `cdk.json`'s single
88
134
  // `cdk-cicd exec` entry renders the pipeline -- keeping self-mutation producing the workflow the
89
135
  // "commit the updated workflow file" check compares. Without the mode it synthesizes only app stacks.
136
+ const privateNpm = config.npmRegistry !== undefined || config.codeArtifact !== undefined;
90
137
  const installCommands = [
91
- ...(config.proxy ? proxyInstallCommands(config.proxy) : []),
138
+ ...(privateNpm ? npmConfigSetupCommands() : []),
139
+ ...(config.proxy ? proxyInstallCommands(stack, config.proxy) : []),
92
140
  ...(config.warmAccountsFromSsm ? (0, CdkPipelinesEngine_1.ssmWarmingCommands)(config.qualifier) : []),
141
+ ...(config.npmRegistry ? npmRegistryLoginCommands(config.npmRegistry) : []),
93
142
  ...(config.codeArtifact
94
143
  ? [
95
144
  `aws codeartifact login --tool npm --domain ${config.codeArtifact.domain} ` +
@@ -106,6 +155,23 @@ class GitHubActionsEngine extends constructs_1.Construct {
106
155
  workflowPath: options.workflowPath,
107
156
  workflowName: options.workflowName ?? props.pipelineName,
108
157
  workflowTriggers: options.workflowTriggers,
158
+ postBuildSteps: privateNpm
159
+ ? [
160
+ {
161
+ name: 'Clean up npm credentials',
162
+ if: 'always()',
163
+ run: npmConfigCleanupCommand(),
164
+ },
165
+ ]
166
+ : undefined,
167
+ // cdk-pipelines-github renders buildContainer only on the Build-Synth job, so this is the
168
+ // faithful GitHub Actions equivalent of the CI-only CodeBuild image override.
169
+ buildContainer: config.ci.image !== undefined
170
+ ? {
171
+ image: config.ci.image,
172
+ ...(buildContainerCredentials !== undefined ? { credentials: buildContainerCredentials } : {}),
173
+ }
174
+ : undefined,
109
175
  synth: new pipelines_1.CodeBuildStep('Synth', {
110
176
  installCommands: [],
111
177
  // With no ci.steps, run the default CI (its own `npm ci` first); with ci.steps, those steps ARE
@@ -114,29 +180,23 @@ class GitHubActionsEngine extends constructs_1.Construct {
114
180
  // render THIS pipeline so self-mutation keeps producing the workflow the "commit the updated
115
181
  // workflow file" check compares. A plain `cdk synth` without the mode renders only the app stacks.
116
182
  commands: [...(ciSteps.length > 0 ? ciSteps : (0, ci_commands_1.defaultCiCommands)()), 'npm run cdk synth'],
117
- env: { CDK_CICD_MODE: 'pipeline', ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}) },
183
+ env: {
184
+ CDK_CICD_MODE: 'pipeline',
185
+ CDK_AWS_PARTITION: partition,
186
+ ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}),
187
+ },
118
188
  primaryOutputDirectory: 'cdk.out',
119
189
  }),
120
190
  });
121
- // The Synth job needs AWS credentials of its own only when it talks to an AWS API before `cdk synth`
122
- // (a private CodeArtifact login, or a proxy secret read) -- unlike the per-stage deploy/asset-publish
123
- // jobs, `cdk-pipelines-github` does not inject them into the Synth job automatically (see the Synth
124
- // job's own comment in `pipeline.js`: "does not use the GitHub Action Role on its own"). Patched in
125
- // right after the checkout step (index 1), ahead of the install/build commands that need it -- same
126
- // fixed job/step addressing Blueprint used (the synth step is always named 'Synth', so the job is always
127
- // `Build-Synth`, and checkout is always the first step `cdk-pipelines-github` emits).
128
- // Inserted in order, each patch computed against the array as it will look once the ones before it
129
- // have applied -- so the credential step (when present) always lands ahead of the login step.
130
- const patches = [];
131
- let insertAt = 1;
132
- if (config.codeArtifact !== undefined || config.proxy !== undefined || config.warmAccountsFromSsm) {
133
- const credentialStep = cdk_pipelines_github_1.AwsCredentials.fromOpenIdConnect({
134
- gitHubActionRoleArn,
135
- roleSessionName: 'cdk-cicd-github-actions',
136
- }).credentialSteps(publishAssetsAuthRegion)[0];
137
- patches.push(cdk_pipelines_github_1.JsonPatch.add(`/jobs/Build-Synth/steps/${insertAt}`, credentialStep));
138
- insertAt += 1;
139
- }
191
+ // `cdk-pipelines-github` does not authenticate Build-Synth on its own. Always assume the OIDC role
192
+ // immediately after checkout so the CDK CLI has a concrete account/region during self-mutation and
193
+ // uncached context lookups can assume the target bootstrap lookup roles.
194
+ const credentialStep = cdk_pipelines_github_1.AwsCredentials.fromOpenIdConnect({
195
+ gitHubActionRoleArn,
196
+ roleSessionName: 'cdk-cicd-github-actions',
197
+ }).credentialSteps(publishAssetsAuthRegion)[0];
198
+ const patches = [cdk_pipelines_github_1.JsonPatch.add('/jobs/Build-Synth/steps/1', credentialStep)];
199
+ const insertAt = 2;
140
200
  // The warming scan reads SSM under the qualifier; grant it on the OIDC role the Synth job assumes.
141
201
  // Reuse the shared helper so the grant is scoped to `parameter/<qualifier>/*` (a resolvable
142
202
  // qualifier is guaranteed: resolveCicdConfig rejects warmAccountsFromSsm without one).
@@ -145,40 +205,392 @@ class GitHubActionsEngine extends constructs_1.Construct {
145
205
  this.gitHubActionRole.role.addToPrincipalPolicy(statement);
146
206
  }
147
207
  }
208
+ if (config.codeArtifact !== undefined) {
209
+ for (const statement of codeArtifactReadStatements(stack, config.codeArtifact)) {
210
+ this.gitHubActionRole.role.addToPrincipalPolicy(statement);
211
+ }
212
+ }
213
+ if (config.proxy !== undefined) {
214
+ for (const statement of secretReadStatements(config.proxy.proxySecretArn, config.proxy.encryptionKeyArn)) {
215
+ this.gitHubActionRole.role.addToPrincipalPolicy(statement);
216
+ }
217
+ }
218
+ if (config.npmRegistry !== undefined) {
219
+ for (const statement of secretReadStatements(config.npmRegistry.basicAuthSecretArn, config.npmRegistry.encryptionKeyArn)) {
220
+ this.gitHubActionRole.role.addToPrincipalPolicy(statement);
221
+ }
222
+ }
148
223
  if (installCommands.length > 0) {
149
224
  patches.push(cdk_pipelines_github_1.JsonPatch.add(`/jobs/Build-Synth/steps/${insertAt}`, { name: 'Login', run: installCommands.join('\n') }));
150
225
  }
151
226
  if (patches.length > 0) {
152
227
  this.pipeline.workflowFile.patch(...patches);
153
228
  }
154
- // One job per (stage x region), in config order, each gated by its own GitHub Environment (a manual
155
- // approval, if any, is a protection rule configured on that environment in GitHub -- not a CDK step).
229
+ // One job per (stage x region), each tied to its own GitHub Environment. For manualApproval stages,
230
+ // validation above requires an explicit acknowledgement that required reviewers are configured on
231
+ // these generated environment names. Sequential regions are separate waves; parallel regions share
232
+ // a GitHub wave and therefore have no dependency edge between their deployment jobs.
156
233
  // Unlike `CdkPipelinesEngine`, the account always resolves to a concrete value (defaulting to the
157
234
  // pipeline's own account): the deploy job is a static YAML step, with no CloudFormation-side
158
235
  // mechanism to defer an unresolved account the way an AWS-hosted CodePipeline deploy action can.
159
236
  for (const stage of config.stages) {
160
237
  const account = stage.env.account ?? stack.account;
161
238
  const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];
162
- for (const region of regions) {
239
+ const appStageFor = (region) => {
163
240
  const stageId = regions.length > 1 ? `${stage.name}-${region}` : stage.name;
164
241
  const appStage = new aws_cdk_lib_1.Stage(this, stageId, { env: { account, region } });
242
+ if (config.complianceLogBucketName !== undefined && complianceLogBucket !== undefined) {
243
+ // Aspects do not cross Stage boundaries. Attach directly so the application templates,
244
+ // rather than only this workflow-support stack, receive server-access logging.
245
+ aws_cdk_lib_1.Aspects.of(appStage).add(new AccessLogsForBucketAspect_1.AccessLogsForBucketAspect({
246
+ complianceLogBucketName: config.complianceLogBucketName,
247
+ complianceLogBucketAccount: stack.account,
248
+ complianceLogBucketRegion: stack.region,
249
+ complianceLogBucket,
250
+ }), { priority: aws_cdk_lib_1.AspectPriority.MUTATING });
251
+ }
165
252
  const context = { stageName: stage.name, env: { account, region } };
166
253
  props.stages.stacks(appStage, context);
254
+ return { appStage, stageId };
255
+ };
256
+ if (stage.env.regionOrder === types_1.RegionOrder.PARALLEL && regions.length > 1) {
257
+ const wave = this.pipeline.addGitHubWave(stage.name);
258
+ for (const region of regions) {
259
+ const { appStage, stageId } = appStageFor(region);
260
+ wave.addStageWithGitHubOptions(appStage, { gitHubEnvironment: { name: stageId } });
261
+ }
262
+ continue;
263
+ }
264
+ for (const region of regions) {
265
+ const { appStage, stageId } = appStageFor(region);
167
266
  this.pipeline.addStageWithGitHubOptions(appStage, { gitHubEnvironment: { name: stageId } });
168
267
  }
169
268
  }
269
+ // cdk-pipelines-github resolves deployment placeholders from the ambient CDK_AWS_PARTITION
270
+ // process variable and otherwise hard-codes "aws". Build eagerly under the validated partition,
271
+ // then restore the caller's process environment so local synths and tests remain isolated.
272
+ buildWorkflowForPartition(this.pipeline, partition);
170
273
  }
171
274
  }
172
275
  exports.GitHubActionsEngine = GitHubActionsEngine;
173
276
  _a = JSII_RTTI_SYMBOL_1;
174
- GitHubActionsEngine[_a] = { fqn: "@cdklabs/cdk-cicd-wrapper.GitHubActionsEngine", version: "2.3.2" };
175
- /** Export the proxy for every later shell command, then prove the tunnel works before install runs. */
176
- function proxyInstallCommands(proxy) {
277
+ GitHubActionsEngine[_a] = { fqn: "@cdklabs/cdk-cicd-wrapper.GitHubActionsEngine", version: "2.3.3" };
278
+ /** The installed alpha synthesizer does not support either CDK Pipelines implementation. */
279
+ function assertSupportedSynthesizer(config) {
280
+ if ((config.synthesizer?.type ?? types_1.SynthesizerType.DEFAULT) === types_1.SynthesizerType.APP_STAGING) {
281
+ throw new Error('cdk-cicd: GITHUB_ACTIONS cannot use SynthesizerType.APP_STAGING: the installed ' +
282
+ '@aws-cdk/app-staging-synthesizer-alpha does not support CDK Pipelines, and Stage replay would ' +
283
+ 'create an invalid cross-Stage dependency on DefaultStagingStack. Use SynthesizerType.DEFAULT ' +
284
+ 'for generated pipelines; APP_STAGING remains available for direct local CDK deployment.');
285
+ }
286
+ }
287
+ /** Workflow YAML needs literal account/region values; CloudFormation tokens cannot be deferred into it. */
288
+ function assertConcretePipelineEnvironment(stack) {
289
+ if (aws_cdk_lib_1.Token.isUnresolved(stack.account) || aws_cdk_lib_1.Token.isUnresolved(stack.region)) {
290
+ throw new Error('cdk-cicd: GITHUB_ACTIONS requires a concrete pipeline stack account and region because the ' +
291
+ 'workflow renders a literal OIDC role ARN.');
292
+ }
293
+ if (region_info_1.RegionInfo.get(stack.region).partition === undefined || region_info_1.RegionInfo.get(stack.region).domainSuffix === undefined) {
294
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS pipeline region '${stack.region}' is not known to this aws-cdk-lib ` +
295
+ 'version. Upgrade the wrapper/CDK before rendering a workflow for that Region.');
296
+ }
297
+ }
298
+ /** GitHub workflow YAML cannot defer target account/Region tokens to CloudFormation. */
299
+ function assertConcreteDeploymentEnvironments(stack, config) {
300
+ for (const stage of config.stages) {
301
+ const account = stage.env.account ?? stack.account;
302
+ const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];
303
+ if (account.length === 0 ||
304
+ aws_cdk_lib_1.Token.isUnresolved(account) ||
305
+ regions.some((region) => region.length === 0 || aws_cdk_lib_1.Token.isUnresolved(region))) {
306
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS stage '${stage.name}' requires concrete account and region values ` +
307
+ 'because the generated workflow contains literal deployment jobs and IAM role ARNs.');
308
+ }
309
+ }
310
+ }
311
+ /**
312
+ * The installed GitHub engine has no OIDC audience option and its deployment renderer reads
313
+ * CDK_AWS_PARTITION from process state. Restrict it to the commercial partition, validate every
314
+ * participating Region, and then build under that exact partition below.
315
+ */
316
+ function assertSupportedWorkflowPartition(stack, config, configuredAuthRegion) {
317
+ const pipelinePartition = partitionForRegion(stack.region, 'GITHUB_ACTIONS pipeline');
318
+ if (pipelinePartition !== 'aws') {
319
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS does not support pipeline partition '${pipelinePartition}' with the ` +
320
+ 'installed cdk-pipelines-github release: its OIDC helper cannot configure a partition-specific ' +
321
+ "audience. Use the CDK_PIPELINES or CODEPIPELINE engine outside the commercial 'aws' partition.");
322
+ }
323
+ for (const stage of config.stages) {
324
+ const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];
325
+ for (const region of regions) {
326
+ const targetPartition = partitionForRegion(region, `GITHUB_ACTIONS stage '${stage.name}'`);
327
+ if (targetPartition !== pipelinePartition) {
328
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS cannot mix AWS partitions: pipeline region '${stack.region}' is in ` +
329
+ `'${pipelinePartition}', but stage '${stage.name}' region '${region}' is in '${targetPartition}'.`);
330
+ }
331
+ }
332
+ }
333
+ if (config.codeArtifact?.region !== undefined) {
334
+ const codeArtifactPartition = partitionForRegion(config.codeArtifact.region, 'GITHUB_ACTIONS CodeArtifact');
335
+ if (codeArtifactPartition !== pipelinePartition) {
336
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS cannot use CodeArtifact region '${config.codeArtifact.region}' in partition ` +
337
+ `'${codeArtifactPartition}' from pipeline partition '${pipelinePartition}'.`);
338
+ }
339
+ }
340
+ const authRegion = configuredAuthRegion ?? stack.region;
341
+ const authPartition = partitionForRegion(authRegion, 'GITHUB_ACTIONS publishAssetsAuthRegion');
342
+ if (authPartition !== pipelinePartition) {
343
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS publishAssetsAuthRegion '${authRegion}' is in partition ` +
344
+ `'${authPartition}', but the pipeline is in '${pipelinePartition}'.`);
345
+ }
346
+ return pipelinePartition;
347
+ }
348
+ function partitionForRegion(region, context) {
349
+ if (region.length === 0 || aws_cdk_lib_1.Token.isUnresolved(region)) {
350
+ throw new Error(`cdk-cicd: ${context} requires a concrete Region so its AWS partition can be verified.`);
351
+ }
352
+ const partition = region_info_1.RegionInfo.get(region).partition;
353
+ if (partition === undefined) {
354
+ throw new Error(`cdk-cicd: ${context} region '${region}' is not known to this aws-cdk-lib version. ` +
355
+ 'Upgrade the wrapper/CDK before using that Region.');
356
+ }
357
+ return partition;
358
+ }
359
+ /**
360
+ * A single destination bucket is deployed with the workflow-support stack. S3 server access logging
361
+ * cannot cross accounts or Regions, so reject any application Stage that could not use that bucket.
362
+ */
363
+ function assertSupportedComplianceLogging(stack, config) {
364
+ if (config.complianceLogBucketName === undefined)
365
+ return;
366
+ for (const stage of config.stages) {
367
+ const account = stage.env.account ?? stack.account;
368
+ const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];
369
+ if (aws_cdk_lib_1.Token.isUnresolved(account) ||
370
+ account !== stack.account ||
371
+ regions.some((region) => aws_cdk_lib_1.Token.isUnresolved(region) || region !== stack.region)) {
372
+ throw new Error(`cdk-cicd: compliance logging cannot target GitHub Actions stage '${stage.name}' from bucket ` +
373
+ `'${config.complianceLogBucketName}' in ${stack.account}/${stack.region}. S3 server access-log ` +
374
+ 'source and destination buckets must be in the same account and region; configure only ' +
375
+ 'co-located stages or omit complianceLogBucketName.');
376
+ }
377
+ }
378
+ }
379
+ /**
380
+ * GitHub pulls a job container before any workflow step can authenticate to private ECR. Recognize
381
+ * canonical, FIPS, dual-stack, and malformed ECR-like hosts so none can fall through as an anonymous
382
+ * external registry. Other external registry strings remain the public/anonymous path.
383
+ */
384
+ function resolveBuildContainerCredentials(config) {
385
+ if (config.ci.codeBuildImageCredentials !== undefined) {
386
+ throw new Error('cdk-cicd: ci.codeBuildImageCredentials is supported only by the CodeBuild engines; ' +
387
+ 'GITHUB_ACTIONS uses githubActions.buildContainerCredentials.');
388
+ }
389
+ const image = config.ci.image;
390
+ const credentials = config.githubActions?.buildContainerCredentials;
391
+ if (image === undefined) {
392
+ if (credentials !== undefined) {
393
+ throw new Error('cdk-cicd: githubActions.buildContainerCredentials requires ci.image.');
394
+ }
395
+ return undefined;
396
+ }
397
+ (0, build_image_1.assertValidCiImageReference)(image);
398
+ if (image.startsWith('aws/codebuild/')) {
399
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS cannot use managed CodeBuild ci.image '${image}'; ` +
400
+ 'aws/codebuild/... is a CodeBuild image ID, not a pullable OCI job-container reference.');
401
+ }
402
+ const registryHost = (0, build_image_1.ciImageRegistryHost)(image);
403
+ if ((0, build_image_1.isPrivateEcrRegistryHost)(registryHost)) {
404
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS cannot use private ECR ci.image '${image}' because GitHub pulls the ` +
405
+ 'job container before the OIDC authentication step. GitHub container credentials do not ' +
406
+ 'implement the AWS ECR authorization-token exchange; use a public external image or a ' +
407
+ 'non-container runner.');
408
+ }
409
+ if (credentials === undefined)
410
+ return undefined;
411
+ return {
412
+ username: githubSecretExpression(credentials.usernameSecretName, 'usernameSecretName'),
413
+ password: githubSecretExpression(credentials.passwordSecretName, 'passwordSecretName'),
414
+ };
415
+ }
416
+ function githubSecretExpression(secretName, field) {
417
+ if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(secretName) || /^GITHUB_/i.test(secretName)) {
418
+ throw new Error(`cdk-cicd: githubActions.buildContainerCredentials.${field} '${secretName}' is not a valid GitHub ` +
419
+ 'secret name. Use letters, numbers, or underscores; do not start with a number or GITHUB_.');
420
+ }
421
+ return `\${{ secrets.${secretName} }}`;
422
+ }
423
+ function buildWorkflowForPartition(pipeline, partition) {
424
+ const previousPartition = process.env.CDK_AWS_PARTITION;
425
+ try {
426
+ process.env.CDK_AWS_PARTITION = partition;
427
+ pipeline.buildPipeline();
428
+ }
429
+ finally {
430
+ if (previousPartition === undefined) {
431
+ delete process.env.CDK_AWS_PARTITION;
432
+ }
433
+ else {
434
+ process.env.CDK_AWS_PARTITION = previousPartition;
435
+ }
436
+ }
437
+ }
438
+ /**
439
+ * The installed cdk-pipelines-github release scopes only the `sub` claim on its trust statement.
440
+ * Add the audience condition directly to that generated Allow so an imported provider with additional
441
+ * client IDs cannot use a non-STS audience to assume the workflow role.
442
+ */
443
+ function hardenGitHubOidcAudience(gitHubActionRole) {
444
+ const roleResource = gitHubActionRole.role.node.defaultChild;
445
+ // cdk-pipelines-github can resolve a second aws-cdk-lib runtime. `instanceof iam.CfnRole` then
446
+ // rejects its otherwise valid generated role; the CloudFormation capability we need is structural.
447
+ if (roleResource === undefined || typeof roleResource.addPropertyOverride !== 'function') {
448
+ throw new Error('cdk-cicd: could not locate the generated GitHub Actions IAM role trust policy.');
449
+ }
450
+ roleResource.addPropertyOverride('AssumeRolePolicyDocument.Statement.0.Condition.StringEquals.token\\.actions\\.githubusercontent\\.com:aud', 'sts.amazonaws.com');
451
+ }
452
+ /** Fail closed until cdk-pipelines-github can forward caller-provided deploy-role ExternalIds. */
453
+ function assertNoDeployRoleExternalIds(config) {
454
+ const unsupportedStages = config.stages
455
+ .filter((stage) => {
456
+ const deployRole = stage.deployment?.deployRole?.trim();
457
+ const externalId = (stage.deployment?.externalId ?? config.deployRoleExternalId)?.trim();
458
+ return deployRole !== undefined && deployRole.length > 0 && externalId !== undefined && externalId.length > 0;
459
+ })
460
+ .map((stage) => stage.name);
461
+ if (unsupportedStages.length > 0) {
462
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS cannot honor deploy-role ExternalIds for stage(s): ` +
463
+ `${unsupportedStages.join(', ')}; the installed engine hardcodes a different ExternalId. ` +
464
+ 'Remove the ExternalId or use the CODEPIPELINE engine.');
465
+ }
466
+ }
467
+ /**
468
+ * The installed cdk-pipelines-github credential provider derives a deployment role by replacing the
469
+ * first literal `cfn-exec` in the manifest ARN with `deploy`. A custom role containing that text
470
+ * would therefore be granted here but never assumed by the generated workflow.
471
+ */
472
+ function assertStableGitHubDeployRoleArn(roleArn, stageName) {
473
+ const rolePathAndName = roleArn.match(/:role\/(.+)$/)?.[1];
474
+ if (rolePathAndName?.includes('cfn-exec')) {
475
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS deployRole for stage '${stageName}' cannot contain literal ` +
476
+ '`cfn-exec` in its role path or name: the installed cdk-pipelines-github release rewrites ' +
477
+ 'that text to `deploy` before assuming the role. Rename the role or use another engine.');
478
+ }
479
+ }
480
+ /**
481
+ * A workflow can reference GitHub Environments but cannot configure their protection rules. Requiring
482
+ * this acknowledgement prevents manualApproval from silently rendering an unprotected deployment job.
483
+ */
484
+ function assertEnvironmentProtectionConfigured(config) {
485
+ const gatedStages = config.stages.filter((stage) => stage.manualApproval).map((stage) => stage.name);
486
+ if (gatedStages.length > 0 && config.githubActions?.environmentProtectionConfigured !== true) {
487
+ throw new Error(`cdk-cicd: GITHUB_ACTIONS stage(s) ${gatedStages.join(', ')} require manual approval, but GitHub ` +
488
+ 'environment protection is not acknowledged. Configure required reviewers on every generated ' +
489
+ 'GitHub Environment, then set githubActions.environmentProtectionConfigured: true.');
490
+ }
491
+ }
492
+ /** Secret read plus an exact CMK decrypt grant when the config identifies one. */
493
+ function secretReadStatements(secretArn, encryptionKeyArn) {
494
+ const statements = [new iam.PolicyStatement({ actions: ['secretsmanager:GetSecretValue'], resources: [secretArn] })];
495
+ if (encryptionKeyArn !== undefined && encryptionKeyArn.trim().length > 0) {
496
+ statements.push(new iam.PolicyStatement({ actions: ['kms:Decrypt'], resources: [encryptionKeyArn] }));
497
+ }
498
+ return statements;
499
+ }
500
+ /** The CodeArtifact read permissions a `codeartifact login` + `npm ci` need. */
501
+ function codeArtifactReadStatements(stack, codeArtifact) {
502
+ const account = codeArtifact.account ?? stack.account;
503
+ const region = codeArtifact.region ?? stack.region;
177
504
  return [
505
+ new iam.PolicyStatement({
506
+ actions: ['codeartifact:GetAuthorizationToken'],
507
+ resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:domain/${codeArtifact.domain}`],
508
+ }),
509
+ new iam.PolicyStatement({
510
+ actions: ['codeartifact:GetRepositoryEndpoint', 'codeartifact:ReadFromRepository'],
511
+ resources: [
512
+ `arn:${stack.partition}:codeartifact:${region}:${account}:repository/${codeArtifact.domain}/${codeArtifact.repository}`,
513
+ ],
514
+ }),
515
+ new iam.PolicyStatement({
516
+ actions: ['sts:GetServiceBearerToken'],
517
+ resources: ['*'],
518
+ conditions: { StringEquals: { 'sts:AWSServiceName': 'codeartifact.amazonaws.com' } },
519
+ }),
520
+ ];
521
+ }
522
+ /**
523
+ * Resolve proxy credentials after OIDC authentication, mask them, and persist the effective proxy
524
+ * environment for every later Build-Synth step through GitHub's environment file.
525
+ */
526
+ function proxyInstallCommands(stack, proxy) {
527
+ const secretRegion = secretsManagerRegion(proxy.proxySecretArn);
528
+ const noProxy = proxy.noProxy.length > 0 ? proxy.noProxy : [`${stack.region}.${region_info_1.RegionInfo.get(stack.region).domainSuffix}`];
529
+ return [
530
+ `PROXY_SECRET_JSON="$(aws secretsmanager get-secret-value --secret-id ${shellQuote(proxy.proxySecretArn)}` +
531
+ `${secretRegion !== undefined ? ` --region ${shellQuote(secretRegion)}` : ''} ` +
532
+ '--query SecretString --output text)"',
533
+ 'if [ -z "$PROXY_SECRET_JSON" ] || [ "$PROXY_SECRET_JSON" = "None" ]; then echo "cdk-cicd: proxy secret is empty" >&2; exit 1; fi',
534
+ 'PROXY_USERNAME="$(printf \'%s\' "$PROXY_SECRET_JSON" | jq -er \'.username\')"',
535
+ 'PROXY_PASSWORD="$(printf \'%s\' "$PROXY_SECRET_JSON" | jq -er \'.password\')"',
536
+ 'HTTP_PROXY_PORT="$(printf \'%s\' "$PROXY_SECRET_JSON" | jq -er \'.http_proxy_port\')"',
537
+ 'HTTPS_PROXY_PORT="$(printf \'%s\' "$PROXY_SECRET_JSON" | jq -er \'.https_proxy_port\')"',
538
+ 'PROXY_DOMAIN="$(printf \'%s\' "$PROXY_SECRET_JSON" | jq -er \'.proxy_domain\')"',
539
+ 'unset PROXY_SECRET_JSON',
540
+ 'echo "::add-mask::$PROXY_USERNAME"',
541
+ 'echo "::add-mask::$PROXY_PASSWORD"',
178
542
  'export HTTP_PROXY="http://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTP_PROXY_PORT"',
179
543
  'export HTTPS_PROXY="https://$PROXY_USERNAME:$PROXY_PASSWORD@$PROXY_DOMAIN:$HTTPS_PROXY_PORT"',
544
+ `export NO_PROXY=${shellQuote(noProxy.join(','))}`,
545
+ 'export AWS_STS_REGIONAL_ENDPOINTS=regional',
546
+ 'echo "HTTP_PROXY=$HTTP_PROXY" >> "$GITHUB_ENV"',
547
+ 'echo "HTTPS_PROXY=$HTTPS_PROXY" >> "$GITHUB_ENV"',
548
+ 'echo "NO_PROXY=$NO_PROXY" >> "$GITHUB_ENV"',
549
+ 'echo "AWS_STS_REGIONAL_ENDPOINTS=$AWS_STS_REGIONAL_ENDPOINTS" >> "$GITHUB_ENV"',
180
550
  'echo "--- Proxy Test ---"',
181
551
  `curl -Is --connect-timeout 5 ${proxy.proxyTestUrl} | grep "HTTP/"`,
182
552
  ];
183
553
  }
184
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubActionsEngine.js","sourceRoot":"","sources":["../../../src/engine/github/GitHubActionsEngine.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 GitHub Actions engine (Blueprint `GitHubPipelinePlugin`/`GitHubPipelineProvider`/`GitHubRepositoryProvider`,\n// migrated). It renders a `.github/workflows/deploy.yml` (via `cdk-pipelines-github`'s `GitHubWorkflow`)\n// instead of an AWS-hosted pipeline -- Autopilot's only other engines (`CodePipelineEngine`/`CdkPipelinesEngine`)\n// both provision a real CodePipeline/CodeBuild footprint; this one deploys nothing of its own except the\n// OIDC role the workflow assumes. It mechanically mirrors `CdkPipelinesEngine`, not the flat engine: GitHub\n// Actions needs every stage built as a `cdk.Stage` inside one synth (the same CDK Pipelines constraint), so\n// it takes the same `stages: IStageProvider` the CDK Pipelines engine does, and `cdk-cicd exec` assembles it\n// the same way (replaying the plain `bin` once per configured stage -- see runtime/pipeline-assembler).\n//\n// Unlike Blueprint, the OIDC role's ARN is never read off the constructed `iam.Role` (a CDK token): the workflow\n// file is a plain-text YAML `cdk-pipelines-github` writes to disk at synth time, NOT a CloudFormation\n// template, so it cannot resolve a token -- only a literal string ends up in the file as-is. `roleName` is\n// therefore always literal (explicit or a derived default). The partition is looked up from the stack's\n// (literal) region via `RegionInfo`, not `stack.partition` -- that getter returns the SAME kind of\n// unresolved `Aws.PARTITION` token unless the (opt-in, not assumed here) `ENABLE_PARTITION_LITERALS`\n// feature flag is set, which would silently break this same literal-ARN requirement.\n\nimport { Arn, Stack, Stage, Token } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CodeBuildStep } from 'aws-cdk-lib/pipelines';\nimport { RegionInfo } from 'aws-cdk-lib/region-info';\nimport { NagSuppressions } from 'cdk-nag';\nimport { AwsCredentials, GitHubActionRole, GitHubWorkflow, JsonPatch } from 'cdk-pipelines-github';\nimport { Construct } from 'constructs';\nimport { RepositorySourceType } from '../../config/repository';\nimport { ProxyConfig, ResolvedCicdConfig } from '../../config/types';\nimport {\n  CdkPipelinesStageContext,\n  IStageProvider,\n  ssmWarmingCommands,\n  ssmWarmingReadStatements,\n} from '../cdkpipelines/CdkPipelinesEngine';\nimport { defaultCiCommands } from '../ci-commands';\n\n/** Props for the GitHub Actions engine. */\nexport interface GitHubActionsEngineProps {\n  /** The resolved pipeline configuration (`defineCICD`); `repository` must be `Repository.github(...)`. */\n  readonly config: ResolvedCicdConfig;\n  /** Builds the app's stacks per stage -- the same `IStageProvider` `CdkPipelinesEngine` takes. */\n  readonly stages: IStageProvider;\n  /**\n   * Falls back to `githubActions.workflowName` when set; otherwise `cdk-pipelines-github` defaults the\n   * workflow to \"deploy\". Named `pipelineName`, not `workflowName`, to keep this prop uniform with\n   * `CdkPipelinesEngineProps` -- there is no separate AWS-side \"pipeline\" resource to name here.\n   */\n  readonly pipelineName?: string;\n}\n\n/**\n * A GitHub Actions workflow rendered from an Autopilot config + a stage factory. Reproduces the Blueprint shape: a\n * `GitHubActionRole` the workflow assumes over OIDC, a Synth job, and one job (with a GitHub Environment,\n * so an environment protection rule set up on GitHub's side gates it) per deployment stage. Manual-approval\n * config is NOT translated into a CDK step here -- as in Blueprint, GitHub Environments are the gate; every stage\n * gets its own environment regardless of `manualApproval`, and gating is configured in the GitHub UI.\n */\nexport class GitHubActionsEngine extends Construct {\n  public readonly pipeline: GitHubWorkflow;\n  public readonly gitHubActionRole: GitHubActionRole;\n\n  constructor(scope: Construct, id: string, props: GitHubActionsEngineProps) {\n    super(scope, id);\n    const config = props.config;\n    if (config.repository.repositoryType !== RepositorySourceType.GITHUB) {\n      throw new Error(\n        `cdk-cicd: the GitHub Actions engine requires 'Repository.github(...)' as the repository -- got ` +\n          `'${config.repository.repositoryType}'.`,\n      );\n    }\n    const options = config.githubActions ?? {};\n    const stack = Stack.of(this);\n    const roleName = options.roleName ?? `${config.application ?? 'cdk-cicd'}-github-role`;\n    const publishAssetsAuthRegion = options.publishAssetsAuthRegion ?? 'us-west-2';\n\n    // A literal ARN, not `this.gitHubActionRole.role.roleArn` (a CDK token): the workflow file is plain\n    // text written at synth time, so only a value known BEFORE synth ends up correctly in it.\n    const partition = Token.isUnresolved(stack.region) ? 'aws' : (RegionInfo.get(stack.region).partition ?? 'aws');\n    const gitHubActionRoleArn = Arn.format({\n      partition,\n      service: 'iam',\n      region: '',\n      account: stack.account,\n      resource: 'role',\n      resourceName: roleName,\n    });\n\n    this.gitHubActionRole = new GitHubActionRole(this, 'GitHubActionRole', {\n      roleName,\n      repos:\n        options.subjectClaims === undefined || options.subjectClaims.length === 0\n          ? [config.repository.name]\n          : undefined,\n      subjectClaims: options.subjectClaims,\n      thumbprints: options.thumbprints,\n      ...(options.openIdConnectProviderArn\n        ? {\n            provider: iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n              this,\n              'OpenIdProvider',\n              options.openIdConnectProviderArn,\n            ),\n          }\n        : {}),\n    });\n    NagSuppressions.addResourceSuppressions(\n      this.gitHubActionRole,\n      [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            'Wildcard required for the GitHubActionRole trust/permission policy (cdk-pipelines-github generated), mirroring Blueprint.',\n        },\n      ],\n      true,\n    );\n\n    // Same install/synth shape as `CdkPipelinesEngine`'s Synth step (proxy exports, then CodeArtifact\n    // login, then the configured CI steps and `npm run cdk synth`) -- GitHub Actions runs this as a\n    // plain job step rather than a CodeBuild project, but the commands themselves are engine-agnostic.\n    // The step runs with `CDK_CICD_MODE=pipeline` (set on the step env below), so `cdk.json`'s single\n    // `cdk-cicd exec` entry renders the pipeline -- keeping self-mutation producing the workflow the\n    // \"commit the updated workflow file\" check compares. Without the mode it synthesizes only app stacks.\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.account} ` +\n              `--repository ${config.codeArtifact.repository} --region ${config.codeArtifact.region ?? stack.region}` +\n              (config.codeArtifact.npmScope ? ` --namespace ${config.codeArtifact.npmScope}` : ''),\n          ]\n        : []),\n    ];\n    const ciSteps = Object.values(config.ci.steps);\n\n    this.pipeline = new GitHubWorkflow(this, 'Workflow', {\n      awsCreds: AwsCredentials.fromOpenIdConnect({ gitHubActionRoleArn, roleSessionName: 'cdk-cicd-github-actions' }),\n      publishAssetsAuthRegion,\n      workflowPath: options.workflowPath,\n      workflowName: options.workflowName ?? props.pipelineName,\n      workflowTriggers: options.workflowTriggers,\n      synth: new CodeBuildStep('Synth', {\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` makes it\n        // render THIS pipeline so self-mutation keeps producing the workflow the \"commit the updated\n        // workflow file\" check compares. A plain `cdk synth` without the mode renders only the app stacks.\n        commands: [...(ciSteps.length > 0 ? ciSteps : defaultCiCommands()), 'npm run cdk synth'],\n        env: { CDK_CICD_MODE: 'pipeline', ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}) },\n        primaryOutputDirectory: 'cdk.out',\n      }),\n    });\n\n    // The Synth job needs AWS credentials of its own only when it talks to an AWS API before `cdk synth`\n    // (a private CodeArtifact login, or a proxy secret read) -- unlike the per-stage deploy/asset-publish\n    // jobs, `cdk-pipelines-github` does not inject them into the Synth job automatically (see the Synth\n    // job's own comment in `pipeline.js`: \"does not use the GitHub Action Role on its own\"). Patched in\n    // right after the checkout step (index 1), ahead of the install/build commands that need it -- same\n    // fixed job/step addressing Blueprint used (the synth step is always named 'Synth', so the job is always\n    // `Build-Synth`, and checkout is always the first step `cdk-pipelines-github` emits).\n    // Inserted in order, each patch computed against the array as it will look once the ones before it\n    // have applied -- so the credential step (when present) always lands ahead of the login step.\n    const patches: JsonPatch[] = [];\n    let insertAt = 1;\n    if (config.codeArtifact !== undefined || config.proxy !== undefined || config.warmAccountsFromSsm) {\n      const credentialStep = AwsCredentials.fromOpenIdConnect({\n        gitHubActionRoleArn,\n        roleSessionName: 'cdk-cicd-github-actions',\n      }).credentialSteps(publishAssetsAuthRegion)[0];\n      patches.push(JsonPatch.add(`/jobs/Build-Synth/steps/${insertAt}`, credentialStep));\n      insertAt += 1;\n    }\n    // The warming scan reads SSM under the qualifier; grant it on the OIDC role the Synth job assumes.\n    // Reuse the shared helper so the grant is scoped to `parameter/<qualifier>/*` (a resolvable\n    // qualifier is guaranteed: resolveCicdConfig rejects warmAccountsFromSsm without one).\n    if (config.warmAccountsFromSsm) {\n      for (const statement of ssmWarmingReadStatements(stack, config.qualifier)) {\n        this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n      }\n    }\n    if (installCommands.length > 0) {\n      patches.push(\n        JsonPatch.add(`/jobs/Build-Synth/steps/${insertAt}`, { name: 'Login', run: installCommands.join('\\n') }),\n      );\n    }\n    if (patches.length > 0) {\n      this.pipeline.workflowFile.patch(...patches);\n    }\n\n    // One job per (stage x region), in config order, each gated by its own GitHub Environment (a manual\n    // approval, if any, is a protection rule configured on that environment in GitHub -- not a CDK step).\n    // Unlike `CdkPipelinesEngine`, the account always resolves to a concrete value (defaulting to the\n    // pipeline's own account): the deploy job is a static YAML step, with no CloudFormation-side\n    // mechanism to defer an unresolved account the way an AWS-hosted CodePipeline deploy action can.\n    for (const stage of config.stages) {\n      const account = stage.env.account ?? stack.account;\n      const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n      for (const region of regions) {\n        const stageId = regions.length > 1 ? `${stage.name}-${region}` : stage.name;\n        const appStage = new Stage(this, stageId, { env: { account, region } });\n        const context: CdkPipelinesStageContext = { stageName: stage.name, env: { account, region } };\n        props.stages.stacks(appStage, context);\n        this.pipeline.addStageWithGitHubOptions(appStage, { gitHubEnvironment: { name: stageId } });\n      }\n    }\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"]}
554
+ /**
555
+ * Resolve a generic npm-registry token only after the Synth job has assumed its OIDC role, mask it
556
+ * before any later command can log it, and persist it solely in the runner's temporary npm config.
557
+ */
558
+ function npmRegistryLoginCommands(npm) {
559
+ const host = npm.url.replace(/^https?:\/\//, '');
560
+ const scope = npm.scope !== undefined && npm.scope.length > 0 ? npm.scope : undefined;
561
+ const scopePrefix = scope !== undefined ? `${scope.startsWith('@') ? scope : `@${scope}`}:` : '';
562
+ const secretRegion = secretsManagerRegion(npm.basicAuthSecretArn);
563
+ return [
564
+ `NPM_AUTH_TOKEN="$(aws secretsmanager get-secret-value --secret-id ${shellQuote(npm.basicAuthSecretArn)}` +
565
+ `${secretRegion !== undefined ? ` --region ${shellQuote(secretRegion)}` : ''} ` +
566
+ '--query SecretString --output text)"',
567
+ 'if [ -z "$NPM_AUTH_TOKEN" ] || [ "$NPM_AUTH_TOKEN" = "None" ]; then echo "cdk-cicd: npm registry secret is empty" >&2; exit 1; fi',
568
+ 'echo "::add-mask::$NPM_AUTH_TOKEN"',
569
+ `echo "${scopePrefix}registry=${npm.url}" > "$NPM_CONFIG_USERCONFIG"`,
570
+ `echo "//${host}:_authToken=$NPM_AUTH_TOKEN" >> "$NPM_CONFIG_USERCONFIG"`,
571
+ 'unset NPM_AUTH_TOKEN',
572
+ ];
573
+ }
574
+ /** Configure npm to use an owner-only credential file outside the checked-out source workspace. */
575
+ function npmConfigSetupCommands() {
576
+ return [
577
+ 'export NPM_CONFIG_USERCONFIG="$RUNNER_TEMP/cdk-cicd-npmrc"',
578
+ 'rm -f "$NPM_CONFIG_USERCONFIG"',
579
+ 'umask 077 && touch "$NPM_CONFIG_USERCONFIG"',
580
+ 'echo "NPM_CONFIG_USERCONFIG=$NPM_CONFIG_USERCONFIG" >> "$GITHUB_ENV"',
581
+ ];
582
+ }
583
+ /** Safe even if an earlier login command failed before exporting the path. */
584
+ function npmConfigCleanupCommand() {
585
+ return 'if [ -n "${NPM_CONFIG_USERCONFIG:-}" ]; then rm -f "$NPM_CONFIG_USERCONFIG"; fi';
586
+ }
587
+ /** Use the secret ARN's region instead of assuming it matches the workflow's OIDC-auth region. */
588
+ function secretsManagerRegion(secretArn) {
589
+ const parts = secretArn.split(':');
590
+ return parts.length > 5 && parts[0] === 'arn' && parts[2] === 'secretsmanager' ? parts[3] : undefined;
591
+ }
592
+ /** Quote a literal for the POSIX shell emitted into the workflow. */
593
+ function shellQuote(value) {
594
+ return `'${value.replace(/'/g, `'\"'\"'`)}'`;
595
+ }
596
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubActionsEngine.js","sourceRoot":"","sources":["../../../src/engine/github/GitHubActionsEngine.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 GitHub Actions engine (Blueprint `GitHubPipelinePlugin`/`GitHubPipelineProvider`/`GitHubRepositoryProvider`,\n// migrated). It renders a `.github/workflows/deploy.yml` (via `cdk-pipelines-github`'s `GitHubWorkflow`)\n// instead of an AWS-hosted pipeline -- Autopilot's only other engines (`CodePipelineEngine`/`CdkPipelinesEngine`)\n// both provision a real CodePipeline/CodeBuild footprint; this one deploys nothing of its own except the\n// OIDC role the workflow assumes. It mechanically mirrors `CdkPipelinesEngine`, not the flat engine: GitHub\n// Actions needs every stage built as a `cdk.Stage` inside one synth (the same CDK Pipelines constraint), so\n// it takes the same `stages: IStageProvider` the CDK Pipelines engine does, and `cdk-cicd exec` assembles it\n// the same way (replaying the plain `bin` once per configured stage -- see runtime/pipeline-assembler).\n//\n// Unlike Blueprint, the OIDC role's ARN is never read off the constructed `iam.Role` (a CDK token): the workflow\n// file is a plain-text YAML `cdk-pipelines-github` writes to disk at synth time, NOT a CloudFormation\n// template, so it cannot resolve a token -- only a literal string ends up in the file as-is. `roleName` is\n// therefore always literal (explicit or a derived default). The partition is looked up from the stack's\n// (literal) region via `RegionInfo`, not `stack.partition` -- that getter returns the SAME kind of\n// unresolved `Aws.PARTITION` token unless the (opt-in, not assumed here) `ENABLE_PARTITION_LITERALS`\n// feature flag is set, which would silently break this same literal-ARN requirement.\n\nimport { Arn, AspectPriority, Aspects, DefaultStackSynthesizer, Stack, Stage, Token } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CodeBuildStep } from 'aws-cdk-lib/pipelines';\nimport { RegionInfo } from 'aws-cdk-lib/region-info';\nimport { NagSuppressions } from 'cdk-nag';\nimport { AwsCredentials, GitHubActionRole, GitHubWorkflow, JsonPatch } from 'cdk-pipelines-github';\nimport { Construct } from 'constructs';\nimport { assertValidCiImageReference, ciImageRegistryHost, isPrivateEcrRegistryHost } from '../../config/build-image';\nimport {\n  resolveDefaultSynthesizerQualifier,\n  specializeDefaultSynthesizerRoleArn,\n} from '../../config/default-synthesizer-role-arn';\nimport { RepositorySourceType } from '../../config/repository';\nimport {\n  CodeArtifactConfig,\n  NpmRegistryConfig,\n  ProxyConfig,\n  RegionOrder,\n  ResolvedCicdConfig,\n  SynthesizerType,\n} from '../../config/types';\nimport { AccessLogsForBucketAspect } from '../../support/AccessLogsForBucketAspect';\nimport { SupportResources } from '../../support/SupportResources';\nimport {\n  CdkPipelinesStageContext,\n  IStageProvider,\n  ssmWarmingCommands,\n  ssmWarmingReadStatements,\n  targetLookupStatements,\n} from '../cdkpipelines/CdkPipelinesEngine';\nimport { defaultCiCommands } from '../ci-commands';\n\n/** Props for the GitHub Actions engine. */\nexport interface GitHubActionsEngineProps {\n  /** The resolved pipeline configuration (`defineCICD`); `repository` must be `Repository.github(...)`. */\n  readonly config: ResolvedCicdConfig;\n  /** Builds the app's stacks per stage -- the same `IStageProvider` `CdkPipelinesEngine` takes. */\n  readonly stages: IStageProvider;\n  /**\n   * Falls back to `githubActions.workflowName` when set; otherwise `cdk-pipelines-github` defaults the\n   * workflow to \"deploy\". Named `pipelineName`, not `workflowName`, to keep this prop uniform with\n   * `CdkPipelinesEngineProps` -- there is no separate AWS-side \"pipeline\" resource to name here.\n   */\n  readonly pipelineName?: string;\n}\n\n/**\n * A GitHub Actions workflow rendered from an Autopilot config + a stage factory. Reproduces the Blueprint shape: a\n * `GitHubActionRole` the workflow assumes over OIDC, a Synth job, and one job (with a GitHub Environment)\n * per deployment stage. GitHub owns the environment protection rules, so approval-gated stages are accepted\n * only when config explicitly acknowledges that required reviewers are configured on those environments.\n */\nexport class GitHubActionsEngine extends Construct {\n  public readonly pipeline: GitHubWorkflow;\n  public readonly gitHubActionRole: GitHubActionRole;\n\n  constructor(scope: Construct, id: string, props: GitHubActionsEngineProps) {\n    super(scope, id);\n    const config = props.config;\n    if (config.repository.repositoryType !== RepositorySourceType.GITHUB) {\n      throw new Error(\n        `cdk-cicd: the GitHub Actions engine requires 'Repository.github(...)' as the repository -- got ` +\n          `'${config.repository.repositoryType}'.`,\n      );\n    }\n    const options = config.githubActions ?? {};\n    assertSupportedSynthesizer(config);\n    assertNoDeployRoleExternalIds(config);\n    assertEnvironmentProtectionConfigured(config);\n    const stack = Stack.of(this);\n    assertConcretePipelineEnvironment(stack);\n    assertConcreteDeploymentEnvironments(stack, config);\n    const partition = assertSupportedWorkflowPartition(stack, config, options.publishAssetsAuthRegion);\n    assertSupportedComplianceLogging(stack, config);\n    const buildContainerCredentials = resolveBuildContainerCredentials(config);\n    const complianceLogBucket =\n      config.complianceLogBucketName !== undefined\n        ? new SupportResources(this, 'Support', {\n            complianceLogBucketName: config.complianceLogBucketName,\n            createComplianceLogBucket: config.createComplianceLogBucket,\n          }).complianceLogBucket\n        : undefined;\n    const roleName = options.roleName ?? `${config.application ?? 'cdk-cicd'}-github-role`;\n    const publishAssetsAuthRegion = options.publishAssetsAuthRegion ?? stack.region;\n\n    // A literal ARN, not `this.gitHubActionRole.role.roleArn` (a CDK token): the workflow file is plain\n    // text written at synth time, so only a value known BEFORE synth ends up correctly in it.\n    const gitHubActionRoleArn = Arn.format({\n      partition,\n      service: 'iam',\n      region: '',\n      account: stack.account,\n      resource: 'role',\n      resourceName: roleName,\n    });\n\n    this.gitHubActionRole = new GitHubActionRole(this, 'GitHubActionRole', {\n      roleName,\n      repos:\n        options.subjectClaims === undefined || options.subjectClaims.length === 0\n          ? [config.repository.name]\n          : undefined,\n      subjectClaims: options.subjectClaims,\n      thumbprints: options.thumbprints,\n      ...(options.openIdConnectProviderArn\n        ? {\n            provider: iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n              this,\n              'OpenIdProvider',\n              options.openIdConnectProviderArn,\n            ),\n          }\n        : {}),\n    });\n    hardenGitHubOidcAudience(this.gitHubActionRole);\n    for (const statement of targetLookupStatements(stack, config, partition)) {\n      this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n    }\n    const qualifier = resolveDefaultSynthesizerQualifier(this, config.qualifier);\n    const forcedDeployRoles = new Set<string>();\n    for (const stage of config.stages) {\n      const configuredDeployRole = stage.deployment?.deployRole?.trim();\n      const deployRole =\n        configuredDeployRole === undefined || configuredDeployRole.length === 0\n          ? DefaultStackSynthesizer.DEFAULT_DEPLOY_ROLE_ARN\n          : configuredDeployRole;\n\n      const account = stage.env.account ?? stack.account;\n      const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n      for (const region of regions) {\n        const specializedRole = specializeDefaultSynthesizerRoleArn(deployRole, {\n          qualifier,\n          account,\n          region,\n          partition,\n        });\n        assertStableGitHubDeployRoleArn(specializedRole, stage.name);\n        if (configuredDeployRole !== undefined && configuredDeployRole.length > 0) {\n          forcedDeployRoles.add(specializedRole);\n        }\n      }\n    }\n    if (forcedDeployRoles.size > 0) {\n      this.gitHubActionRole.role.addToPrincipalPolicy(\n        new iam.PolicyStatement({ actions: ['sts:AssumeRole'], resources: [...forcedDeployRoles] }),\n      );\n    }\n    NagSuppressions.addResourceSuppressions(\n      this.gitHubActionRole,\n      [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            'Wildcard required for the GitHubActionRole trust/permission policy (cdk-pipelines-github generated), mirroring Blueprint.',\n        },\n      ],\n      true,\n    );\n\n    // Same install/synth shape as `CdkPipelinesEngine`'s Synth step (proxy exports, then CodeArtifact\n    // login, then the configured CI steps and `npm run cdk synth`) -- GitHub Actions runs this as a\n    // plain job step rather than a CodeBuild project, but the commands themselves are engine-agnostic.\n    // The step runs with `CDK_CICD_MODE=pipeline` (set on the step env below), so `cdk.json`'s single\n    // `cdk-cicd exec` entry renders the pipeline -- keeping self-mutation producing the workflow the\n    // \"commit the updated workflow file\" check compares. Without the mode it synthesizes only app stacks.\n    const privateNpm = config.npmRegistry !== undefined || config.codeArtifact !== undefined;\n    const installCommands = [\n      ...(privateNpm ? npmConfigSetupCommands() : []),\n      ...(config.proxy ? proxyInstallCommands(stack, config.proxy) : []),\n      ...(config.warmAccountsFromSsm ? ssmWarmingCommands(config.qualifier) : []),\n      ...(config.npmRegistry ? npmRegistryLoginCommands(config.npmRegistry) : []),\n      ...(config.codeArtifact\n        ? [\n            `aws codeartifact login --tool npm --domain ${config.codeArtifact.domain} ` +\n              `--domain-owner ${config.codeArtifact.account ?? stack.account} ` +\n              `--repository ${config.codeArtifact.repository} --region ${config.codeArtifact.region ?? stack.region}` +\n              (config.codeArtifact.npmScope ? ` --namespace ${config.codeArtifact.npmScope}` : ''),\n          ]\n        : []),\n    ];\n    const ciSteps = Object.values(config.ci.steps);\n\n    this.pipeline = new GitHubWorkflow(this, 'Workflow', {\n      awsCreds: AwsCredentials.fromOpenIdConnect({ gitHubActionRoleArn, roleSessionName: 'cdk-cicd-github-actions' }),\n      publishAssetsAuthRegion,\n      workflowPath: options.workflowPath,\n      workflowName: options.workflowName ?? props.pipelineName,\n      workflowTriggers: options.workflowTriggers,\n      postBuildSteps: privateNpm\n        ? [\n            {\n              name: 'Clean up npm credentials',\n              if: 'always()',\n              run: npmConfigCleanupCommand(),\n            },\n          ]\n        : undefined,\n      // cdk-pipelines-github renders buildContainer only on the Build-Synth job, so this is the\n      // faithful GitHub Actions equivalent of the CI-only CodeBuild image override.\n      buildContainer:\n        config.ci.image !== undefined\n          ? {\n              image: config.ci.image,\n              ...(buildContainerCredentials !== undefined ? { credentials: buildContainerCredentials } : {}),\n            }\n          : undefined,\n      synth: new CodeBuildStep('Synth', {\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` makes it\n        // render THIS pipeline so self-mutation keeps producing the workflow the \"commit the updated\n        // workflow file\" check compares. A plain `cdk synth` without the mode renders only the app stacks.\n        commands: [...(ciSteps.length > 0 ? ciSteps : defaultCiCommands()), 'npm run cdk synth'],\n        env: {\n          CDK_CICD_MODE: 'pipeline',\n          CDK_AWS_PARTITION: partition,\n          ...(config.qualifier ? { CDK_QUALIFIER: config.qualifier } : {}),\n        },\n        primaryOutputDirectory: 'cdk.out',\n      }),\n    });\n\n    // `cdk-pipelines-github` does not authenticate Build-Synth on its own. Always assume the OIDC role\n    // immediately after checkout so the CDK CLI has a concrete account/region during self-mutation and\n    // uncached context lookups can assume the target bootstrap lookup roles.\n    const credentialStep = AwsCredentials.fromOpenIdConnect({\n      gitHubActionRoleArn,\n      roleSessionName: 'cdk-cicd-github-actions',\n    }).credentialSteps(publishAssetsAuthRegion)[0];\n    const patches: JsonPatch[] = [JsonPatch.add('/jobs/Build-Synth/steps/1', credentialStep)];\n    const insertAt = 2;\n    // The warming scan reads SSM under the qualifier; grant it on the OIDC role the Synth job assumes.\n    // Reuse the shared helper so the grant is scoped to `parameter/<qualifier>/*` (a resolvable\n    // qualifier is guaranteed: resolveCicdConfig rejects warmAccountsFromSsm without one).\n    if (config.warmAccountsFromSsm) {\n      for (const statement of ssmWarmingReadStatements(stack, config.qualifier)) {\n        this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n      }\n    }\n    if (config.codeArtifact !== undefined) {\n      for (const statement of codeArtifactReadStatements(stack, config.codeArtifact)) {\n        this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n      }\n    }\n    if (config.proxy !== undefined) {\n      for (const statement of secretReadStatements(config.proxy.proxySecretArn, config.proxy.encryptionKeyArn)) {\n        this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n      }\n    }\n    if (config.npmRegistry !== undefined) {\n      for (const statement of secretReadStatements(\n        config.npmRegistry.basicAuthSecretArn,\n        config.npmRegistry.encryptionKeyArn,\n      )) {\n        this.gitHubActionRole.role.addToPrincipalPolicy(statement);\n      }\n    }\n    if (installCommands.length > 0) {\n      patches.push(\n        JsonPatch.add(`/jobs/Build-Synth/steps/${insertAt}`, { name: 'Login', run: installCommands.join('\\n') }),\n      );\n    }\n    if (patches.length > 0) {\n      this.pipeline.workflowFile.patch(...patches);\n    }\n\n    // One job per (stage x region), each tied to its own GitHub Environment. For manualApproval stages,\n    // validation above requires an explicit acknowledgement that required reviewers are configured on\n    // these generated environment names. Sequential regions are separate waves; parallel regions share\n    // a GitHub wave and therefore have no dependency edge between their deployment jobs.\n    // Unlike `CdkPipelinesEngine`, the account always resolves to a concrete value (defaulting to the\n    // pipeline's own account): the deploy job is a static YAML step, with no CloudFormation-side\n    // mechanism to defer an unresolved account the way an AWS-hosted CodePipeline deploy action can.\n    for (const stage of config.stages) {\n      const account = stage.env.account ?? stack.account;\n      const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n      const appStageFor = (region: string): { readonly appStage: Stage; readonly stageId: string } => {\n        const stageId = regions.length > 1 ? `${stage.name}-${region}` : stage.name;\n        const appStage = new Stage(this, stageId, { env: { account, region } });\n        if (config.complianceLogBucketName !== undefined && complianceLogBucket !== undefined) {\n          // Aspects do not cross Stage boundaries. Attach directly so the application templates,\n          // rather than only this workflow-support stack, receive server-access logging.\n          Aspects.of(appStage).add(\n            new AccessLogsForBucketAspect({\n              complianceLogBucketName: config.complianceLogBucketName,\n              complianceLogBucketAccount: stack.account,\n              complianceLogBucketRegion: stack.region,\n              complianceLogBucket,\n            }),\n            { priority: AspectPriority.MUTATING },\n          );\n        }\n        const context: CdkPipelinesStageContext = { stageName: stage.name, env: { account, region } };\n        props.stages.stacks(appStage, context);\n        return { appStage, stageId };\n      };\n\n      if (stage.env.regionOrder === RegionOrder.PARALLEL && regions.length > 1) {\n        const wave = this.pipeline.addGitHubWave(stage.name);\n        for (const region of regions) {\n          const { appStage, stageId } = appStageFor(region);\n          wave.addStageWithGitHubOptions(appStage, { gitHubEnvironment: { name: stageId } });\n        }\n        continue;\n      }\n\n      for (const region of regions) {\n        const { appStage, stageId } = appStageFor(region);\n        this.pipeline.addStageWithGitHubOptions(appStage, { gitHubEnvironment: { name: stageId } });\n      }\n    }\n\n    // cdk-pipelines-github resolves deployment placeholders from the ambient CDK_AWS_PARTITION\n    // process variable and otherwise hard-codes \"aws\". Build eagerly under the validated partition,\n    // then restore the caller's process environment so local synths and tests remain isolated.\n    buildWorkflowForPartition(this.pipeline, partition);\n  }\n}\n\n/** The installed alpha synthesizer does not support either CDK Pipelines implementation. */\nfunction assertSupportedSynthesizer(config: ResolvedCicdConfig): void {\n  if ((config.synthesizer?.type ?? SynthesizerType.DEFAULT) === SynthesizerType.APP_STAGING) {\n    throw new Error(\n      'cdk-cicd: GITHUB_ACTIONS cannot use SynthesizerType.APP_STAGING: the installed ' +\n        '@aws-cdk/app-staging-synthesizer-alpha does not support CDK Pipelines, and Stage replay would ' +\n        'create an invalid cross-Stage dependency on DefaultStagingStack. Use SynthesizerType.DEFAULT ' +\n        'for generated pipelines; APP_STAGING remains available for direct local CDK deployment.',\n    );\n  }\n}\n\n/** Workflow YAML needs literal account/region values; CloudFormation tokens cannot be deferred into it. */\nfunction assertConcretePipelineEnvironment(stack: Stack): void {\n  if (Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region)) {\n    throw new Error(\n      'cdk-cicd: GITHUB_ACTIONS requires a concrete pipeline stack account and region because the ' +\n        'workflow renders a literal OIDC role ARN.',\n    );\n  }\n  if (RegionInfo.get(stack.region).partition === undefined || RegionInfo.get(stack.region).domainSuffix === undefined) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS pipeline region '${stack.region}' is not known to this aws-cdk-lib ` +\n        'version. Upgrade the wrapper/CDK before rendering a workflow for that Region.',\n    );\n  }\n}\n\n/** GitHub workflow YAML cannot defer target account/Region tokens to CloudFormation. */\nfunction assertConcreteDeploymentEnvironments(stack: Stack, config: ResolvedCicdConfig): void {\n  for (const stage of config.stages) {\n    const account = stage.env.account ?? stack.account;\n    const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n    if (\n      account.length === 0 ||\n      Token.isUnresolved(account) ||\n      regions.some((region) => region.length === 0 || Token.isUnresolved(region))\n    ) {\n      throw new Error(\n        `cdk-cicd: GITHUB_ACTIONS stage '${stage.name}' requires concrete account and region values ` +\n          'because the generated workflow contains literal deployment jobs and IAM role ARNs.',\n      );\n    }\n  }\n}\n\n/**\n * The installed GitHub engine has no OIDC audience option and its deployment renderer reads\n * CDK_AWS_PARTITION from process state. Restrict it to the commercial partition, validate every\n * participating Region, and then build under that exact partition below.\n */\nfunction assertSupportedWorkflowPartition(\n  stack: Stack,\n  config: ResolvedCicdConfig,\n  configuredAuthRegion?: string,\n): string {\n  const pipelinePartition = partitionForRegion(stack.region, 'GITHUB_ACTIONS pipeline');\n  if (pipelinePartition !== 'aws') {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS does not support pipeline partition '${pipelinePartition}' with the ` +\n        'installed cdk-pipelines-github release: its OIDC helper cannot configure a partition-specific ' +\n        \"audience. Use the CDK_PIPELINES or CODEPIPELINE engine outside the commercial 'aws' partition.\",\n    );\n  }\n\n  for (const stage of config.stages) {\n    const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n    for (const region of regions) {\n      const targetPartition = partitionForRegion(region, `GITHUB_ACTIONS stage '${stage.name}'`);\n      if (targetPartition !== pipelinePartition) {\n        throw new Error(\n          `cdk-cicd: GITHUB_ACTIONS cannot mix AWS partitions: pipeline region '${stack.region}' is in ` +\n            `'${pipelinePartition}', but stage '${stage.name}' region '${region}' is in '${targetPartition}'.`,\n        );\n      }\n    }\n  }\n\n  if (config.codeArtifact?.region !== undefined) {\n    const codeArtifactPartition = partitionForRegion(config.codeArtifact.region, 'GITHUB_ACTIONS CodeArtifact');\n    if (codeArtifactPartition !== pipelinePartition) {\n      throw new Error(\n        `cdk-cicd: GITHUB_ACTIONS cannot use CodeArtifact region '${config.codeArtifact.region}' in partition ` +\n          `'${codeArtifactPartition}' from pipeline partition '${pipelinePartition}'.`,\n      );\n    }\n  }\n\n  const authRegion = configuredAuthRegion ?? stack.region;\n  const authPartition = partitionForRegion(authRegion, 'GITHUB_ACTIONS publishAssetsAuthRegion');\n  if (authPartition !== pipelinePartition) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS publishAssetsAuthRegion '${authRegion}' is in partition ` +\n        `'${authPartition}', but the pipeline is in '${pipelinePartition}'.`,\n    );\n  }\n\n  return pipelinePartition;\n}\n\nfunction partitionForRegion(region: string, context: string): string {\n  if (region.length === 0 || Token.isUnresolved(region)) {\n    throw new Error(`cdk-cicd: ${context} requires a concrete Region so its AWS partition can be verified.`);\n  }\n  const partition = RegionInfo.get(region).partition;\n  if (partition === undefined) {\n    throw new Error(\n      `cdk-cicd: ${context} region '${region}' is not known to this aws-cdk-lib version. ` +\n        'Upgrade the wrapper/CDK before using that Region.',\n    );\n  }\n  return partition;\n}\n\n/**\n * A single destination bucket is deployed with the workflow-support stack. S3 server access logging\n * cannot cross accounts or Regions, so reject any application Stage that could not use that bucket.\n */\nfunction assertSupportedComplianceLogging(stack: Stack, config: ResolvedCicdConfig): void {\n  if (config.complianceLogBucketName === undefined) return;\n\n  for (const stage of config.stages) {\n    const account = stage.env.account ?? stack.account;\n    const regions = stage.env.regions.length > 0 ? stage.env.regions : [stack.region];\n    if (\n      Token.isUnresolved(account) ||\n      account !== stack.account ||\n      regions.some((region) => Token.isUnresolved(region) || region !== stack.region)\n    ) {\n      throw new Error(\n        `cdk-cicd: compliance logging cannot target GitHub Actions stage '${stage.name}' from bucket ` +\n          `'${config.complianceLogBucketName}' in ${stack.account}/${stack.region}. S3 server access-log ` +\n          'source and destination buckets must be in the same account and region; configure only ' +\n          'co-located stages or omit complianceLogBucketName.',\n      );\n    }\n  }\n}\n\n/**\n * GitHub pulls a job container before any workflow step can authenticate to private ECR. Recognize\n * canonical, FIPS, dual-stack, and malformed ECR-like hosts so none can fall through as an anonymous\n * external registry. Other external registry strings remain the public/anonymous path.\n */\nfunction resolveBuildContainerCredentials(\n  config: ResolvedCicdConfig,\n): { readonly username: string; readonly password: string } | undefined {\n  if (config.ci.codeBuildImageCredentials !== undefined) {\n    throw new Error(\n      'cdk-cicd: ci.codeBuildImageCredentials is supported only by the CodeBuild engines; ' +\n        'GITHUB_ACTIONS uses githubActions.buildContainerCredentials.',\n    );\n  }\n\n  const image = config.ci.image;\n  const credentials = config.githubActions?.buildContainerCredentials;\n  if (image === undefined) {\n    if (credentials !== undefined) {\n      throw new Error('cdk-cicd: githubActions.buildContainerCredentials requires ci.image.');\n    }\n    return undefined;\n  }\n\n  assertValidCiImageReference(image);\n  if (image.startsWith('aws/codebuild/')) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS cannot use managed CodeBuild ci.image '${image}'; ` +\n        'aws/codebuild/... is a CodeBuild image ID, not a pullable OCI job-container reference.',\n    );\n  }\n\n  const registryHost = ciImageRegistryHost(image);\n  if (isPrivateEcrRegistryHost(registryHost)) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS cannot use private ECR ci.image '${image}' because GitHub pulls the ` +\n        'job container before the OIDC authentication step. GitHub container credentials do not ' +\n        'implement the AWS ECR authorization-token exchange; use a public external image or a ' +\n        'non-container runner.',\n    );\n  }\n\n  if (credentials === undefined) return undefined;\n  return {\n    username: githubSecretExpression(credentials.usernameSecretName, 'usernameSecretName'),\n    password: githubSecretExpression(credentials.passwordSecretName, 'passwordSecretName'),\n  };\n}\n\nfunction githubSecretExpression(secretName: string, field: string): string {\n  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(secretName) || /^GITHUB_/i.test(secretName)) {\n    throw new Error(\n      `cdk-cicd: githubActions.buildContainerCredentials.${field} '${secretName}' is not a valid GitHub ` +\n        'secret name. Use letters, numbers, or underscores; do not start with a number or GITHUB_.',\n    );\n  }\n  return `\\${{ secrets.${secretName} }}`;\n}\n\nfunction buildWorkflowForPartition(pipeline: GitHubWorkflow, partition: string): void {\n  const previousPartition = process.env.CDK_AWS_PARTITION;\n  try {\n    process.env.CDK_AWS_PARTITION = partition;\n    pipeline.buildPipeline();\n  } finally {\n    if (previousPartition === undefined) {\n      delete process.env.CDK_AWS_PARTITION;\n    } else {\n      process.env.CDK_AWS_PARTITION = previousPartition;\n    }\n  }\n}\n\n/**\n * The installed cdk-pipelines-github release scopes only the `sub` claim on its trust statement.\n * Add the audience condition directly to that generated Allow so an imported provider with additional\n * client IDs cannot use a non-STS audience to assume the workflow role.\n */\nfunction hardenGitHubOidcAudience(gitHubActionRole: GitHubActionRole): void {\n  const roleResource = gitHubActionRole.role.node.defaultChild;\n  // cdk-pipelines-github can resolve a second aws-cdk-lib runtime. `instanceof iam.CfnRole` then\n  // rejects its otherwise valid generated role; the CloudFormation capability we need is structural.\n  if (roleResource === undefined || typeof (roleResource as iam.CfnRole).addPropertyOverride !== 'function') {\n    throw new Error('cdk-cicd: could not locate the generated GitHub Actions IAM role trust policy.');\n  }\n  (roleResource as iam.CfnRole).addPropertyOverride(\n    'AssumeRolePolicyDocument.Statement.0.Condition.StringEquals.token\\\\.actions\\\\.githubusercontent\\\\.com:aud',\n    'sts.amazonaws.com',\n  );\n}\n\n/** Fail closed until cdk-pipelines-github can forward caller-provided deploy-role ExternalIds. */\nfunction assertNoDeployRoleExternalIds(config: ResolvedCicdConfig): void {\n  const unsupportedStages = config.stages\n    .filter((stage) => {\n      const deployRole = stage.deployment?.deployRole?.trim();\n      const externalId = (stage.deployment?.externalId ?? config.deployRoleExternalId)?.trim();\n      return deployRole !== undefined && deployRole.length > 0 && externalId !== undefined && externalId.length > 0;\n    })\n    .map((stage) => stage.name);\n\n  if (unsupportedStages.length > 0) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS cannot honor deploy-role ExternalIds for stage(s): ` +\n        `${unsupportedStages.join(', ')}; the installed engine hardcodes a different ExternalId. ` +\n        'Remove the ExternalId or use the CODEPIPELINE engine.',\n    );\n  }\n}\n\n/**\n * The installed cdk-pipelines-github credential provider derives a deployment role by replacing the\n * first literal `cfn-exec` in the manifest ARN with `deploy`. A custom role containing that text\n * would therefore be granted here but never assumed by the generated workflow.\n */\nfunction assertStableGitHubDeployRoleArn(roleArn: string, stageName: string): void {\n  const rolePathAndName = roleArn.match(/:role\\/(.+)$/)?.[1];\n  if (rolePathAndName?.includes('cfn-exec')) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS deployRole for stage '${stageName}' cannot contain literal ` +\n        '`cfn-exec` in its role path or name: the installed cdk-pipelines-github release rewrites ' +\n        'that text to `deploy` before assuming the role. Rename the role or use another engine.',\n    );\n  }\n}\n\n/**\n * A workflow can reference GitHub Environments but cannot configure their protection rules. Requiring\n * this acknowledgement prevents manualApproval from silently rendering an unprotected deployment job.\n */\nfunction assertEnvironmentProtectionConfigured(config: ResolvedCicdConfig): void {\n  const gatedStages = config.stages.filter((stage) => stage.manualApproval).map((stage) => stage.name);\n  if (gatedStages.length > 0 && config.githubActions?.environmentProtectionConfigured !== true) {\n    throw new Error(\n      `cdk-cicd: GITHUB_ACTIONS stage(s) ${gatedStages.join(', ')} require manual approval, but GitHub ` +\n        'environment protection is not acknowledged. Configure required reviewers on every generated ' +\n        'GitHub Environment, then set githubActions.environmentProtectionConfigured: true.',\n    );\n  }\n}\n\n/** Secret read plus an exact CMK decrypt grant when the config identifies one. */\nfunction secretReadStatements(secretArn: string, encryptionKeyArn?: string): iam.PolicyStatement[] {\n  const statements = [new iam.PolicyStatement({ actions: ['secretsmanager:GetSecretValue'], resources: [secretArn] })];\n  if (encryptionKeyArn !== undefined && encryptionKeyArn.trim().length > 0) {\n    statements.push(new iam.PolicyStatement({ actions: ['kms:Decrypt'], resources: [encryptionKeyArn] }));\n  }\n  return statements;\n}\n\n/** The CodeArtifact read permissions a `codeartifact login` + `npm ci` need. */\nfunction codeArtifactReadStatements(stack: Stack, codeArtifact: CodeArtifactConfig): iam.PolicyStatement[] {\n  const account = codeArtifact.account ?? stack.account;\n  const region = codeArtifact.region ?? stack.region;\n  return [\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetAuthorizationToken'],\n      resources: [`arn:${stack.partition}:codeartifact:${region}:${account}:domain/${codeArtifact.domain}`],\n    }),\n    new iam.PolicyStatement({\n      actions: ['codeartifact:GetRepositoryEndpoint', 'codeartifact:ReadFromRepository'],\n      resources: [\n        `arn:${stack.partition}:codeartifact:${region}:${account}:repository/${codeArtifact.domain}/${codeArtifact.repository}`,\n      ],\n    }),\n    new iam.PolicyStatement({\n      actions: ['sts:GetServiceBearerToken'],\n      resources: ['*'],\n      conditions: { StringEquals: { 'sts:AWSServiceName': 'codeartifact.amazonaws.com' } },\n    }),\n  ];\n}\n\n/**\n * Resolve proxy credentials after OIDC authentication, mask them, and persist the effective proxy\n * environment for every later Build-Synth step through GitHub's environment file.\n */\nfunction proxyInstallCommands(stack: Stack, proxy: ProxyConfig): string[] {\n  const secretRegion = secretsManagerRegion(proxy.proxySecretArn);\n  const noProxy =\n    proxy.noProxy.length > 0 ? proxy.noProxy : [`${stack.region}.${RegionInfo.get(stack.region).domainSuffix!}`];\n  return [\n    `PROXY_SECRET_JSON=\"$(aws secretsmanager get-secret-value --secret-id ${shellQuote(proxy.proxySecretArn)}` +\n      `${secretRegion !== undefined ? ` --region ${shellQuote(secretRegion)}` : ''} ` +\n      '--query SecretString --output text)\"',\n    'if [ -z \"$PROXY_SECRET_JSON\" ] || [ \"$PROXY_SECRET_JSON\" = \"None\" ]; then echo \"cdk-cicd: proxy secret is empty\" >&2; exit 1; fi',\n    'PROXY_USERNAME=\"$(printf \\'%s\\' \"$PROXY_SECRET_JSON\" | jq -er \\'.username\\')\"',\n    'PROXY_PASSWORD=\"$(printf \\'%s\\' \"$PROXY_SECRET_JSON\" | jq -er \\'.password\\')\"',\n    'HTTP_PROXY_PORT=\"$(printf \\'%s\\' \"$PROXY_SECRET_JSON\" | jq -er \\'.http_proxy_port\\')\"',\n    'HTTPS_PROXY_PORT=\"$(printf \\'%s\\' \"$PROXY_SECRET_JSON\" | jq -er \\'.https_proxy_port\\')\"',\n    'PROXY_DOMAIN=\"$(printf \\'%s\\' \"$PROXY_SECRET_JSON\" | jq -er \\'.proxy_domain\\')\"',\n    'unset PROXY_SECRET_JSON',\n    'echo \"::add-mask::$PROXY_USERNAME\"',\n    'echo \"::add-mask::$PROXY_PASSWORD\"',\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    `export NO_PROXY=${shellQuote(noProxy.join(','))}`,\n    'export AWS_STS_REGIONAL_ENDPOINTS=regional',\n    'echo \"HTTP_PROXY=$HTTP_PROXY\" >> \"$GITHUB_ENV\"',\n    'echo \"HTTPS_PROXY=$HTTPS_PROXY\" >> \"$GITHUB_ENV\"',\n    'echo \"NO_PROXY=$NO_PROXY\" >> \"$GITHUB_ENV\"',\n    'echo \"AWS_STS_REGIONAL_ENDPOINTS=$AWS_STS_REGIONAL_ENDPOINTS\" >> \"$GITHUB_ENV\"',\n    'echo \"--- Proxy Test ---\"',\n    `curl -Is --connect-timeout 5 ${proxy.proxyTestUrl} | grep \"HTTP/\"`,\n  ];\n}\n\n/**\n * Resolve a generic npm-registry token only after the Synth job has assumed its OIDC role, mask it\n * before any later command can log it, and persist it solely in the runner's temporary npm config.\n */\nfunction npmRegistryLoginCommands(npm: NpmRegistryConfig): string[] {\n  const host = npm.url.replace(/^https?:\\/\\//, '');\n  const scope = npm.scope !== undefined && npm.scope.length > 0 ? npm.scope : undefined;\n  const scopePrefix = scope !== undefined ? `${scope.startsWith('@') ? scope : `@${scope}`}:` : '';\n  const secretRegion = secretsManagerRegion(npm.basicAuthSecretArn);\n  return [\n    `NPM_AUTH_TOKEN=\"$(aws secretsmanager get-secret-value --secret-id ${shellQuote(npm.basicAuthSecretArn)}` +\n      `${secretRegion !== undefined ? ` --region ${shellQuote(secretRegion)}` : ''} ` +\n      '--query SecretString --output text)\"',\n    'if [ -z \"$NPM_AUTH_TOKEN\" ] || [ \"$NPM_AUTH_TOKEN\" = \"None\" ]; then echo \"cdk-cicd: npm registry secret is empty\" >&2; exit 1; fi',\n    'echo \"::add-mask::$NPM_AUTH_TOKEN\"',\n    `echo \"${scopePrefix}registry=${npm.url}\" > \"$NPM_CONFIG_USERCONFIG\"`,\n    `echo \"//${host}:_authToken=$NPM_AUTH_TOKEN\" >> \"$NPM_CONFIG_USERCONFIG\"`,\n    'unset NPM_AUTH_TOKEN',\n  ];\n}\n\n/** Configure npm to use an owner-only credential file outside the checked-out source workspace. */\nfunction npmConfigSetupCommands(): string[] {\n  return [\n    'export NPM_CONFIG_USERCONFIG=\"$RUNNER_TEMP/cdk-cicd-npmrc\"',\n    'rm -f \"$NPM_CONFIG_USERCONFIG\"',\n    'umask 077 && touch \"$NPM_CONFIG_USERCONFIG\"',\n    'echo \"NPM_CONFIG_USERCONFIG=$NPM_CONFIG_USERCONFIG\" >> \"$GITHUB_ENV\"',\n  ];\n}\n\n/** Safe even if an earlier login command failed before exporting the path. */\nfunction npmConfigCleanupCommand(): string {\n  return 'if [ -n \"${NPM_CONFIG_USERCONFIG:-}\" ]; then rm -f \"$NPM_CONFIG_USERCONFIG\"; fi';\n}\n\n/** Use the secret ARN's region instead of assuming it matches the workflow's OIDC-auth region. */\nfunction secretsManagerRegion(secretArn: string): string | undefined {\n  const parts = secretArn.split(':');\n  return parts.length > 5 && parts[0] === 'arn' && parts[2] === 'secretsmanager' ? parts[3] : undefined;\n}\n\n/** Quote a literal for the POSIX shell emitted into the workflow. */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\"'\\\"'`)}'`;\n}\n"]}