@jjrawlins/cdk-diff-pr-github-action 1.1.5 → 1.2.0

package/README.md

@@ -107,9 +107,16 @@ If neither top‑level OIDC defaults nor all per‑stack values are supplied, th
 
 ## Usage: CdkDiffIamTemplate
 
-Emit an example IAM template you can deploy in your account for the Change Set workflow.
+Emit an IAM template you can deploy in your account for the Change Set workflow. Supports two modes:
 
-### With Projen
+1. **External OIDC Role** — Reference an existing GitHub OIDC role (original behavior)
+2. **Self-Contained** — Create the GitHub OIDC provider and role within the same template (new)
+
+### Option 1: Using an Existing OIDC Role (External)
+
+Use this when you already have a GitHub OIDC provider and role set up in your account.
+
+#### With Projen
 
 ```ts
 import { awscdk } from 'projen';
@@ -131,13 +138,7 @@ new CdkDiffIamTemplate({
 project.synth();
 ```
 
-A Projen task is also added:
-
-```bash
-npx projen deploy-cdkdiff-iam-template -- --parameter-overrides GitHubOIDCRoleArn=... # plus any extra AWS CLI args
-```
-
-### Without Projen (Standalone Generator)
+#### Without Projen (Standalone Generator)
 
 ```ts
 import { CdkDiffIamTemplateGenerator } from '@jjrawlins/cdk-diff-pr-github-action';
@@ -150,22 +151,116 @@ const template = CdkDiffIamTemplateGenerator.generateTemplate({
 });
 
 fs.writeFileSync('cdk-diff-iam-template.yaml', template);
+```
 
-// Get the deploy command
-const deployCmd = CdkDiffIamTemplateGenerator.generateDeployCommand('cdk-diff-iam-template.yaml');
-console.log('Deploy with:', deployCmd);
+### Option 2: Self-Contained Template (Create OIDC Role)
+
+Use this when you want a single template that creates everything needed — the GitHub OIDC provider, OIDC role, and changeset role. This simplifies deployment and pairs well with the `CdkDiffStackWorkflow`.
+
+#### With Projen
+
+```ts
+import { awscdk } from 'projen';
+import { CdkDiffIamTemplate } from '@jjrawlins/cdk-diff-pr-github-action';
+
+const project = new awscdk.AwsCdkConstructLibrary({
+  // ...
+});
+
+new CdkDiffIamTemplate({
+  project,
+  roleName: 'CdkChangesetRole',
+  createOidcRole: true,
+  oidcRoleName: 'GitHubOIDCRole',  // Optional, default: 'GitHubOIDCRole'
+  githubOidc: {
+    owner: 'my-org',                          // GitHub org or username
+    repositories: ['infra-repo', 'app-repo'], // Repos allowed to assume roles
+    branches: ['main', 'release/*'],          // Branch patterns (default: ['*'])
+  },
+  // Optional: Skip OIDC provider creation if it already exists
+  // skipOidcProviderCreation: true,
+});
+
+project.synth();
 ```
 
-### What the template defines
+#### Without Projen (Standalone Generator)
 
-- Parameter `GitHubOIDCRoleArn` with a default from `oidcRoleArn` — the ARN of your existing GitHub OIDC role allowed to assume the change set role.
-- IAM role `CdkChangesetRole` with minimal permissions for:
-  - CloudFormation Change Set operations
-  - Access to common CDK bootstrap S3 buckets and SSM parameters
-  - `iam:PassRole` to `cloudformation.amazonaws.com`
-- Outputs exporting the role name and ARN.
+```ts
+import { CdkDiffIamTemplateGenerator } from '@jjrawlins/cdk-diff-pr-github-action';
+import * as fs from 'fs';
+
+const template = CdkDiffIamTemplateGenerator.generateTemplate({
+  roleName: 'CdkChangesetRole',
+  createOidcRole: true,
+  oidcRoleName: 'GitHubOIDCRole',
+  githubOidc: {
+    owner: 'my-org',
+    repositories: ['infra-repo'],
+    branches: ['main'],
+  },
+});
+
+fs.writeFileSync('cdk-diff-iam-template.yaml', template);
+```
+
+#### With Existing OIDC Provider (Skip Creation)
+
+If your account already has a GitHub OIDC provider but you want the template to create the roles:
+
+```ts
+new CdkDiffIamTemplate({
+  project,
+  roleName: 'CdkChangesetRole',
+  createOidcRole: true,
+  skipOidcProviderCreation: true,  // Account already has OIDC provider
+  githubOidc: {
+    owner: 'my-org',
+    repositories: ['*'],  // All repos in org
+  },
+});
+```
+
+### Deploy Task
+
+A Projen task is added for easy deployment:
+
+```bash
+npx projen deploy-cdkdiff-iam-template -- --parameter-overrides GitHubOIDCRoleArn=... # plus any extra AWS CLI args
+```
 
-Use the created role ARN as `changesetRoleToAssumeArn` in `CdkDiffStackWorkflow`.
+### CdkDiffIamTemplate Props
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `roleName` | `string` | Name for the changeset IAM role (required) |
+| `oidcRoleArn` | `string?` | ARN of existing GitHub OIDC role. Required when `createOidcRole` is false. |
+| `oidcRegion` | `string?` | Region for OIDC trust condition. Required when `createOidcRole` is false. |
+| `createOidcRole` | `boolean?` | Create OIDC role within template (default: false) |
+| `oidcRoleName` | `string?` | Name of OIDC role to create (default: 'GitHubOIDCRole') |
+| `githubOidc` | `GitHubOidcConfig?` | GitHub OIDC config. Required when `createOidcRole` is true. |
+| `skipOidcProviderCreation` | `boolean?` | Skip OIDC provider if it exists (default: false) |
+| `outputPath` | `string?` | Template output path (default: 'cdk-diff-workflow-iam-template.yaml') |
+
+### What the Template Creates
+
+**External OIDC Role mode:**
+- Parameter `GitHubOIDCRoleArn` — ARN of your existing GitHub OIDC role
+- IAM role `CdkChangesetRole` with minimal permissions for change set operations
+- Outputs: `CdkChangesetRoleArn`, `CdkChangesetRoleName`
+
+**Self-Contained mode (`createOidcRole: true`):**
+- GitHub OIDC Provider (unless `skipOidcProviderCreation: true`)
+- IAM role `GitHubOIDCRole` with trust policy for GitHub Actions
+- IAM role `CdkChangesetRole` with minimal permissions (trusts the OIDC role)
+- Outputs: `GitHubOIDCProviderArn`, `GitHubOIDCRoleArn`, `GitHubOIDCRoleName`, `CdkChangesetRoleArn`, `CdkChangesetRoleName`
+
+**Changeset Role Permissions:**
+- CloudFormation Change Set operations
+- Access to CDK bootstrap S3 buckets and SSM parameters
+- `iam:PassRole` to `cloudformation.amazonaws.com`
+
+Use the created changeset role ARN as `changesetRoleToAssumeArn` in `CdkDiffStackWorkflow`.
 
 ---
 

package/lib/CdkDiffIamTemplate.d.ts

@@ -1,13 +1,44 @@
+import { GitHubOidcConfig } from './CdkDiffIamTemplateStackSet';
 /**
  * Props for generating CDK Diff IAM templates (no Projen dependency)
  */
 export interface CdkDiffIamTemplateGeneratorProps {
-    /** Name for the IAM role */
+    /** Name for the changeset IAM role */
     readonly roleName: string;
-    /** ARN of the existing GitHub OIDC role that can assume this changeset role */
-    readonly oidcRoleArn: string;
-    /** Region for the OIDC trust condition */
-    readonly oidcRegion: string;
+    /**
+     * ARN of the existing GitHub OIDC role that can assume this changeset role.
+     * Required when createOidcRole is false or undefined.
+     */
+    readonly oidcRoleArn?: string;
+    /**
+     * Region for the OIDC trust condition.
+     * Only used when oidcRoleArn is provided (external OIDC role).
+     */
+    readonly oidcRegion?: string;
+    /**
+     * Create a GitHub OIDC role within this template instead of using an existing one.
+     * When true, githubOidc configuration is required and oidcRoleArn is ignored.
+     * Default: false
+     */
+    readonly createOidcRole?: boolean;
+    /**
+     * Name of the GitHub OIDC role to create.
+     * Only used when createOidcRole is true.
+     * Default: 'GitHubOIDCRole'
+     */
+    readonly oidcRoleName?: string;
+    /**
+     * GitHub OIDC configuration for repo/branch restrictions.
+     * Required when createOidcRole is true.
+     */
+    readonly githubOidc?: GitHubOidcConfig;
+    /**
+     * Skip creating the OIDC provider (use existing one).
+     * Set to true if the account already has a GitHub OIDC provider.
+     * Only used when createOidcRole is true.
+     * Default: false
+     */
+    readonly skipOidcProviderCreation?: boolean;
 }
 /**
  * Pure generator class for CDK Diff IAM templates.
@@ -22,6 +53,21 @@ export declare class CdkDiffIamTemplateGenerator {
      * Generate the AWS CLI deploy command for the IAM template.
      */
     static generateDeployCommand(templatePath?: string): string;
+    /**
+     * Generate template that creates OIDC provider and role (self-contained)
+     */
+    private static generateTemplateWithOidcRole;
+    /**
+     * Generate template that uses an external OIDC role (original behavior)
+     */
+    private static generateTemplateWithExternalOidcRole;
+    private static generateOidcProviderLines;
+    private static generateOidcRoleLines;
+    private static buildSubjectClaims;
+    private static generateChangesetRoleWithOidcRef;
+    private static generateOidcProviderOutputLines;
+    private static generateOidcRoleOutputLines;
+    private static generateChangesetOutputLines;
 }
 /**
  * Props for the Projen-integrated CDK Diff IAM template construct

package/lib/CdkDiffIamTemplate.js

@@ -13,6 +13,69 @@ class CdkDiffIamTemplateGenerator {
      * Generate the CloudFormation IAM template as a YAML string.
      */
     static generateTemplate(props) {
+        const createOidcRole = props.createOidcRole ?? false;
+        // Validate props
+        if (createOidcRole) {
+            if (!props.githubOidc) {
+                throw new Error('githubOidc configuration is required when createOidcRole is true');
+            }
+        }
+        else {
+            if (!props.oidcRoleArn) {
+                throw new Error('oidcRoleArn is required when createOidcRole is false');
+            }
+            if (!props.oidcRegion) {
+                throw new Error('oidcRegion is required when createOidcRole is false');
+            }
+        }
+        if (createOidcRole) {
+            return this.generateTemplateWithOidcRole(props);
+        }
+        else {
+            return this.generateTemplateWithExternalOidcRole(props);
+        }
+    }
+    /**
+     * Generate the AWS CLI deploy command for the IAM template.
+     */
+    static generateDeployCommand(templatePath = 'cdk-diff-workflow-iam-template.yaml') {
+        return `aws cloudformation deploy --template-file ${templatePath} --stack-name cdk-diff-workflow-iam-role --capabilities CAPABILITY_NAMED_IAM`;
+    }
+    /**
+     * Generate template that creates OIDC provider and role (self-contained)
+     */
+    static generateTemplateWithOidcRole(props) {
+        const oidcRoleName = props.oidcRoleName ?? 'GitHubOIDCRole';
+        const skipOidcProvider = props.skipOidcProviderCreation ?? false;
+        const githubOidc = props.githubOidc;
+        const lines = [
+            "AWSTemplateFormatVersion: '2010-09-09'",
+            "Description: 'GitHub OIDC and IAM roles for CDK Diff Stack Workflow construct'",
+            '',
+            'Resources:',
+        ];
+        // OIDC Provider (only if not skipping)
+        if (!skipOidcProvider) {
+            lines.push(...this.generateOidcProviderLines());
+        }
+        // OIDC Role
+        lines.push(...this.generateOidcRoleLines(oidcRoleName, githubOidc, skipOidcProvider));
+        // Changeset Role (trusts the created OIDC role)
+        lines.push(...this.generateChangesetRoleWithOidcRef(props.roleName));
+        // Outputs
+        lines.push('');
+        lines.push('Outputs:');
+        if (!skipOidcProvider) {
+            lines.push(...this.generateOidcProviderOutputLines());
+        }
+        lines.push(...this.generateOidcRoleOutputLines());
+        lines.push(...this.generateChangesetOutputLines());
+        return lines.join('\n');
+    }
+    /**
+     * Generate template that uses an external OIDC role (original behavior)
+     */
+    static generateTemplateWithExternalOidcRole(props) {
         const lines = [
             "AWSTemplateFormatVersion: '2010-09-09'",
             "Description: 'IAM role for CDK Diff Stack Workflow construct'",
@@ -94,16 +157,184 @@ class CdkDiffIamTemplateGenerator {
         ];
         return lines.join('\n');
     }
-    /**
-     * Generate the AWS CLI deploy command for the IAM template.
-     */
-    static generateDeployCommand(templatePath = 'cdk-diff-workflow-iam-template.yaml') {
-        return `aws cloudformation deploy --template-file ${templatePath} --stack-name cdk-diff-workflow-iam-role --capabilities CAPABILITY_NAMED_IAM`;
+    static generateOidcProviderLines() {
+        return [
+            '  # GitHub OIDC Provider',
+            '  GitHubOIDCProvider:',
+            '    Type: AWS::IAM::OIDCProvider',
+            '    Properties:',
+            '      Url: https://token.actions.githubusercontent.com',
+            '      ClientIdList:',
+            '        - sts.amazonaws.com',
+            '      ThumbprintList:',
+            '        - 6938fd4d98bab03faadb97b34396831e3780aea1',
+            '        - 1c58a3a8518e8759bf075b76b750d4f2df264fcd',
+            '',
+        ];
+    }
+    static generateOidcRoleLines(roleName, githubOidc, skipOidcProvider = false) {
+        const subjectClaims = this.buildSubjectClaims(githubOidc);
+        const lines = [
+            '  # GitHub OIDC Role - authenticates GitHub Actions workflows',
+            '  GitHubOIDCRole:',
+            '    Type: AWS::IAM::Role',
+        ];
+        // Only add DependsOn if we're creating the provider
+        if (!skipOidcProvider) {
+            lines.push('    DependsOn: GitHubOIDCProvider');
+        }
+        lines.push('    Properties:', "      RoleName: '" + roleName + "'", '      AssumeRolePolicyDocument:', "        Version: '2012-10-17'", '        Statement:', '          - Effect: Allow', '            Principal:', "              Federated: !Sub 'arn:aws:iam::${AWS::AccountId}:oidc-provider/token.actions.githubusercontent.com'", '            Action: sts:AssumeRoleWithWebIdentity', '            Condition:', '              StringEquals:', "                'token.actions.githubusercontent.com:aud': 'sts.amazonaws.com'", '              StringLike:', "                'token.actions.githubusercontent.com:sub':");
+        // Add subject claims
+        for (const claim of subjectClaims) {
+            lines.push(`                  - '${claim}'`);
+        }
+        lines.push('');
+        return lines;
+    }
+    static buildSubjectClaims(githubOidc) {
+        const claims = [];
+        const branches = githubOidc.branches ?? ['*'];
+        for (const repo of githubOidc.repositories) {
+            if (repo === '*') {
+                // Wildcard repo - allow all repos with branch restrictions
+                for (const branch of branches) {
+                    if (branch === '*') {
+                        claims.push(`repo:${githubOidc.owner}/*`);
+                    }
+                    else {
+                        claims.push(`repo:${githubOidc.owner}/*:ref:refs/heads/${branch}`);
+                    }
+                }
+            }
+            else {
+                // Specific repo
+                for (const branch of branches) {
+                    if (branch === '*') {
+                        claims.push(`repo:${githubOidc.owner}/${repo}:*`);
+                    }
+                    else {
+                        claims.push(`repo:${githubOidc.owner}/${repo}:ref:refs/heads/${branch}`);
+                    }
+                }
+            }
+        }
+        // Add any additional claims
+        if (githubOidc.additionalClaims) {
+            for (const claim of githubOidc.additionalClaims) {
+                for (const repo of githubOidc.repositories) {
+                    if (repo === '*') {
+                        claims.push(`repo:${githubOidc.owner}/*:${claim}`);
+                    }
+                    else {
+                        claims.push(`repo:${githubOidc.owner}/${repo}:${claim}`);
+                    }
+                }
+            }
+        }
+        return claims;
+    }
+    static generateChangesetRoleWithOidcRef(roleName) {
+        return [
+            '  # CloudFormation ChangeSet Role - minimal permissions for changeset operations',
+            '  CdkChangesetRole:',
+            '    Type: AWS::IAM::Role',
+            '    DependsOn: GitHubOIDCRole',
+            '    Properties:',
+            "      RoleName: '" + roleName + "'",
+            '      AssumeRolePolicyDocument:',
+            "        Version: '2012-10-17'",
+            '        Statement:',
+            '          - Effect: Allow',
+            '            Principal:',
+            '              AWS: !GetAtt GitHubOIDCRole.Arn',
+            '            Action: sts:AssumeRole',
+            '      Policies:',
+            '        - PolicyName: CloudFormationChangeSetAccess',
+            '          PolicyDocument:',
+            "            Version: '2012-10-17'",
+            '            Statement:',
+            '              # CloudFormation changeset operations',
+            '              - Effect: Allow',
+            '                Action:',
+            '                  - cloudformation:CreateChangeSet',
+            '                  - cloudformation:DescribeChangeSet',
+            '                  - cloudformation:DeleteChangeSet',
+            '                  - cloudformation:ListChangeSets',
+            '                  - cloudformation:DescribeStacks',
+            "                Resource: '*'",
+            '              # CDK bootstrap bucket access (for changeset creation)',
+            '              - Effect: Allow',
+            '                Action:',
+            '                  - s3:GetObject',
+            '                  - s3:PutObject',
+            '                  - s3:DeleteObject',
+            '                  - s3:ListBucket',
+            '                Resource:',
+            "                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*'",
+            "                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*/*'",
+            '              # CDK bootstrap parameter access',
+            '              - Effect: Allow',
+            '                Action:',
+            '                  - ssm:GetParameter',
+            '                  - ssm:GetParameters',
+            '                  - ssm:GetParametersByPath',
+            "                Resource: !Sub 'arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter/cdk-bootstrap/*'",
+            '              # IAM PassRole for CDK operations',
+            '              - Effect: Allow',
+            '                Action:',
+            '                  - iam:PassRole',
+            "                Resource: '*'",
+            '                Condition:',
+            '                  StringEquals:',
+            "                    'iam:PassedToService': 'cloudformation.amazonaws.com'",
+            '',
+        ];
+    }
+    static generateOidcProviderOutputLines() {
+        return [
+            '  GitHubOIDCProviderArn:',
+            "    Description: 'ARN of the GitHub OIDC provider'",
+            '    Value: !GetAtt GitHubOIDCProvider.Arn',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-GitHubOIDCProviderArn'",
+            '',
+        ];
+    }
+    static generateOidcRoleOutputLines() {
+        return [
+            '  GitHubOIDCRoleArn:',
+            "    Description: 'ARN of the GitHub OIDC role'",
+            '    Value: !GetAtt GitHubOIDCRole.Arn',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-GitHubOIDCRoleArn'",
+            '',
+            '  GitHubOIDCRoleName:',
+            "    Description: 'Name of the GitHub OIDC role'",
+            '    Value: !Ref GitHubOIDCRole',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-GitHubOIDCRoleName'",
+            '',
+        ];
+    }
+    static generateChangesetOutputLines() {
+        return [
+            '  CdkChangesetRoleArn:',
+            "    Description: 'ARN of the CDK changeset role'",
+            '    Value: !GetAtt CdkChangesetRole.Arn',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-CdkChangesetRoleArn'",
+            '',
+            '  CdkChangesetRoleName:',
+            "    Description: 'Name of the CDK changeset role'",
+            '    Value: !Ref CdkChangesetRole',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-CdkChangesetRoleName'",
+        ];
     }
 }
 exports.CdkDiffIamTemplateGenerator = CdkDiffIamTemplateGenerator;
 _a = JSII_RTTI_SYMBOL_1;
-CdkDiffIamTemplateGenerator[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplateGenerator", version: "1.1.5" };
+CdkDiffIamTemplateGenerator[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplateGenerator", version: "1.2.0" };
 /**
  * Projen construct that emits a CloudFormation template with minimal IAM permissions
  * for the CDK Diff Stack Workflow.
@@ -126,5 +357,5 @@ class CdkDiffIamTemplate {
 }
 exports.CdkDiffIamTemplate = CdkDiffIamTemplate;
 _b = JSII_RTTI_SYMBOL_1;
-CdkDiffIamTemplate[_b] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplate", version: "1.1.5" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDiffIamTemplate.js","sourceRoot":"","sources":["../src/CdkDiffIamTemplate.ts"],"names":[],"mappings":";;;;;AAAA,mCAAkC;AAclC;;;GAGG;AACH,MAAa,2BAA2B;IACtC;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAuC;QAC7D,MAAM,KAAK,GAAG;YACZ,wCAAwC;YACxC,+DAA+D;YAC/D,EAAE;YACF,aAAa;YACb,sBAAsB;YACtB,kBAAkB;YAClB,6FAA6F;YAC7F,iBAAiB,KAAK,CAAC,WAAW,GAAG;YACrC,EAAE;YACF,YAAY;YACZ,kFAAkF;YAClF,qBAAqB;YACrB,0BAA0B;YAC1B,iBAAiB;YACjB,mBAAmB,GAAG,KAAK,CAAC,QAAQ,GAAG,GAAG;YAC1C,iCAAiC;YACjC,+BAA+B;YAC/B,oBAAoB;YACpB,2BAA2B;YAC3B,wBAAwB;YACxB,2CAA2C;YAC3C,oCAAoC;YACpC,wBAAwB;YACxB,6BAA6B;YAC7B,wCAAwC,GAAG,KAAK,CAAC,UAAU,GAAG,GAAG;YACjE,iBAAiB;YACjB,qDAAqD;YACrD,2BAA2B;YAC3B,mCAAmC;YACnC,wBAAwB;YACxB,qDAAqD;YACrD,+BAA+B;YAC/B,yBAAyB;YACzB,oDAAoD;YACpD,sDAAsD;YACtD,oDAAoD;YACpD,mDAAmD;YACnD,mDAAmD;YACnD,+BAA+B;YAC/B,sEAAsE;YACtE,+BAA+B;YAC/B,yBAAyB;YACzB,kCAAkC;YAClC,kCAAkC;YAClC,qCAAqC;YACrC,mCAAmC;YACnC,2BAA2B;YAC3B,gFAAgF;YAChF,kFAAkF;YAClF,gDAAgD;YAChD,+BAA+B;YAC/B,yBAAyB;YACzB,sCAAsC;YACtC,uCAAuC;YACvC,6CAA6C;YAC7C,yGAAyG;YACzG,iDAAiD;YACjD,+BAA+B;YAC/B,yBAAyB;YACzB,kCAAkC;YAClC,+BAA+B;YAC/B,4BAA4B;YAC5B,iCAAiC;YACjC,2EAA2E;YAC3E,EAAE;YACF,UAAU;YACV,wBAAwB;YACxB,kDAAkD;YAClD,yCAAyC;YACzC,aAAa;YACb,0DAA0D;YAC1D,EAAE;YACF,yBAAyB;YACzB,mDAAmD;YACnD,kCAAkC;YAClC,aAAa;YACb,2DAA2D;SAC5D,CAAC;QAEF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,eAAuB,qCAAqC;QACvF,OAAO,6CAA6C,YAAY,8EAA8E,CAAC;IACjJ,CAAC;;AA7FH,kEA8FC;;;AAYD;;;;;GAKG;AACH,MAAa,kBAAkB;IAC7B,YAAY,KAA8B;QACxC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,qCAAqC,CAAC;QAE7E,wCAAwC;QACxC,MAAM,QAAQ,GAAG,2BAA2B,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACrE,IAAI,iBAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEzE,kBAAkB;QAClB,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,6BAA6B,EAAE;YACnD,WAAW,EACT,4HAA4H;YAC9H,WAAW,EAAE,IAAI;YACjB,IAAI,EAAE,2BAA2B,CAAC,qBAAqB,CAAC,UAAU,CAAC;SACpE,CAAC,CAAC;IACL,CAAC;;AAfH,gDAgBC","sourcesContent":["import { TextFile } from 'projen';\n\n/**\n * Props for generating CDK Diff IAM templates (no Projen dependency)\n */\nexport interface CdkDiffIamTemplateGeneratorProps {\n  /** Name for the IAM role */\n  readonly roleName: string;\n  /** ARN of the existing GitHub OIDC role that can assume this changeset role */\n  readonly oidcRoleArn: string;\n  /** Region for the OIDC trust condition */\n  readonly oidcRegion: string;\n}\n\n/**\n * Pure generator class for CDK Diff IAM templates.\n * No Projen dependency - can be used in any project.\n */\nexport class CdkDiffIamTemplateGenerator {\n  /**\n   * Generate the CloudFormation IAM template as a YAML string.\n   */\n  static generateTemplate(props: CdkDiffIamTemplateGeneratorProps): string {\n    const lines = [\n      \"AWSTemplateFormatVersion: '2010-09-09'\",\n      \"Description: 'IAM role for CDK Diff Stack Workflow construct'\",\n      '',\n      'Parameters:',\n      '  GitHubOIDCRoleArn:',\n      '    Type: String',\n      \"    Description: 'ARN of the existing GitHub OIDC role that can assume this changeset role'\",\n      `    Default: '${props.oidcRoleArn}'`,\n      '',\n      'Resources:',\n      '  # CloudFormation ChangeSet Role - minimal permissions for changeset operations',\n      '  CdkChangesetRole:',\n      '    Type: AWS::IAM::Role',\n      '    Properties:',\n      \"      RoleName: '\" + props.roleName + \"'\",\n      '      AssumeRolePolicyDocument:',\n      \"        Version: '2012-10-17'\",\n      '        Statement:',\n      '          - Effect: Allow',\n      '            Principal:',\n      '              AWS: !Ref GitHubOIDCRoleArn',\n      '            Action: sts:AssumeRole',\n      '            Condition:',\n      '              StringEquals:',\n      \"                aws:RequestedRegion: '\" + props.oidcRegion + \"'\",\n      '      Policies:',\n      '        - PolicyName: CloudFormationChangeSetAccess',\n      '          PolicyDocument:',\n      \"            Version: '2012-10-17'\",\n      '            Statement:',\n      '              # CloudFormation changeset operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - cloudformation:CreateChangeSet',\n      '                  - cloudformation:DescribeChangeSet',\n      '                  - cloudformation:DeleteChangeSet',\n      '                  - cloudformation:ListChangeSets',\n      '                  - cloudformation:DescribeStacks',\n      \"                Resource: '*'\",\n      '              # CDK bootstrap bucket access (for changeset creation)',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - s3:GetObject',\n      '                  - s3:PutObject',\n      '                  - s3:DeleteObject',\n      '                  - s3:ListBucket',\n      '                Resource:',\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*'\",\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*/*'\",\n      '              # CDK bootstrap parameter access',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - ssm:GetParameter',\n      '                  - ssm:GetParameters',\n      '                  - ssm:GetParametersByPath',\n      \"                Resource: !Sub 'arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter/cdk-bootstrap/*'\",\n      '              # IAM PassRole for CDK operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - iam:PassRole',\n      \"                Resource: '*'\",\n      '                Condition:',\n      '                  StringEquals:',\n      \"                    'iam:PassedToService': 'cloudformation.amazonaws.com'\",\n      '',\n      'Outputs:',\n      '  CdkChangesetRoleArn:',\n      \"    Description: 'ARN of the CDK changeset role'\",\n      '    Value: !GetAtt CdkChangesetRole.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleArn'\",\n      '',\n      '  CdkChangesetRoleName:',\n      \"    Description: 'Name of the CDK changeset role'\",\n      '    Value: !Ref CdkChangesetRole',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleName'\",\n    ];\n\n    return lines.join('\\n');\n  }\n\n  /**\n   * Generate the AWS CLI deploy command for the IAM template.\n   */\n  static generateDeployCommand(templatePath: string = 'cdk-diff-workflow-iam-template.yaml'): string {\n    return `aws cloudformation deploy --template-file ${templatePath} --stack-name cdk-diff-workflow-iam-role --capabilities CAPABILITY_NAMED_IAM`;\n  }\n}\n\n/**\n * Props for the Projen-integrated CDK Diff IAM template construct\n */\nexport interface CdkDiffIamTemplateProps extends CdkDiffIamTemplateGeneratorProps {\n  /** Projen project instance */\n  readonly project: any;\n  /** Output path for the template file (default: 'cdk-diff-workflow-iam-template.yaml') */\n  readonly outputPath?: string;\n}\n\n/**\n * Projen construct that emits a CloudFormation template with minimal IAM permissions\n * for the CDK Diff Stack Workflow.\n *\n * For non-Projen projects, use `CdkDiffIamTemplateGenerator` directly.\n */\nexport class CdkDiffIamTemplate {\n  constructor(props: CdkDiffIamTemplateProps) {\n    const outputPath = props.outputPath ?? 'cdk-diff-workflow-iam-template.yaml';\n\n    // Generate template using the generator\n    const template = CdkDiffIamTemplateGenerator.generateTemplate(props);\n    new TextFile(props.project, outputPath, { lines: template.split('\\n') });\n\n    // Add deploy task\n    props.project.addTask('deploy-cdkdiff-iam-template', {\n      description:\n        'Deploy the CDK Diff IAM template via CloudFormation (accepts extra AWS CLI args, e.g., --parameter-overrides Key=Value...)',\n      receiveArgs: true,\n      exec: CdkDiffIamTemplateGenerator.generateDeployCommand(outputPath),\n    });\n  }\n}\n"]}
+CdkDiffIamTemplate[_b] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplate", version: "1.2.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDiffIamTemplate.js","sourceRoot":"","sources":["../src/CdkDiffIamTemplate.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile } from 'projen';\nimport { GitHubOidcConfig } from './CdkDiffIamTemplateStackSet';\n\n/**\n * Props for generating CDK Diff IAM templates (no Projen dependency)\n */\nexport interface CdkDiffIamTemplateGeneratorProps {\n  /** Name for the changeset IAM role */\n  readonly roleName: string;\n\n  /**\n   * ARN of the existing GitHub OIDC role that can assume this changeset role.\n   * Required when createOidcRole is false or undefined.\n   */\n  readonly oidcRoleArn?: string;\n\n  /**\n   * Region for the OIDC trust condition.\n   * Only used when oidcRoleArn is provided (external OIDC role).\n   */\n  readonly oidcRegion?: string;\n\n  /**\n   * Create a GitHub OIDC role within this template instead of using an existing one.\n   * When true, githubOidc configuration is required and oidcRoleArn is ignored.\n   * Default: false\n   */\n  readonly createOidcRole?: boolean;\n\n  /**\n   * Name of the GitHub OIDC role to create.\n   * Only used when createOidcRole is true.\n   * Default: 'GitHubOIDCRole'\n   */\n  readonly oidcRoleName?: string;\n\n  /**\n   * GitHub OIDC configuration for repo/branch restrictions.\n   * Required when createOidcRole is true.\n   */\n  readonly githubOidc?: GitHubOidcConfig;\n\n  /**\n   * Skip creating the OIDC provider (use existing one).\n   * Set to true if the account already has a GitHub OIDC provider.\n   * Only used when createOidcRole is true.\n   * Default: false\n   */\n  readonly skipOidcProviderCreation?: boolean;\n}\n\n/**\n * Pure generator class for CDK Diff IAM templates.\n * No Projen dependency - can be used in any project.\n */\nexport class CdkDiffIamTemplateGenerator {\n  /**\n   * Generate the CloudFormation IAM template as a YAML string.\n   */\n  static generateTemplate(props: CdkDiffIamTemplateGeneratorProps): string {\n    const createOidcRole = props.createOidcRole ?? false;\n\n    // Validate props\n    if (createOidcRole) {\n      if (!props.githubOidc) {\n        throw new Error('githubOidc configuration is required when createOidcRole is true');\n      }\n    } else {\n      if (!props.oidcRoleArn) {\n        throw new Error('oidcRoleArn is required when createOidcRole is false');\n      }\n      if (!props.oidcRegion) {\n        throw new Error('oidcRegion is required when createOidcRole is false');\n      }\n    }\n\n    if (createOidcRole) {\n      return this.generateTemplateWithOidcRole(props);\n    } else {\n      return this.generateTemplateWithExternalOidcRole(props);\n    }\n  }\n\n  /**\n   * Generate the AWS CLI deploy command for the IAM template.\n   */\n  static generateDeployCommand(templatePath: string = 'cdk-diff-workflow-iam-template.yaml'): string {\n    return `aws cloudformation deploy --template-file ${templatePath} --stack-name cdk-diff-workflow-iam-role --capabilities CAPABILITY_NAMED_IAM`;\n  }\n\n  /**\n   * Generate template that creates OIDC provider and role (self-contained)\n   */\n  private static generateTemplateWithOidcRole(props: CdkDiffIamTemplateGeneratorProps): string {\n    const oidcRoleName = props.oidcRoleName ?? 'GitHubOIDCRole';\n    const skipOidcProvider = props.skipOidcProviderCreation ?? false;\n    const githubOidc = props.githubOidc!;\n\n    const lines: string[] = [\n      \"AWSTemplateFormatVersion: '2010-09-09'\",\n      \"Description: 'GitHub OIDC and IAM roles for CDK Diff Stack Workflow construct'\",\n      '',\n      'Resources:',\n    ];\n\n    // OIDC Provider (only if not skipping)\n    if (!skipOidcProvider) {\n      lines.push(...this.generateOidcProviderLines());\n    }\n\n    // OIDC Role\n    lines.push(...this.generateOidcRoleLines(oidcRoleName, githubOidc, skipOidcProvider));\n\n    // Changeset Role (trusts the created OIDC role)\n    lines.push(...this.generateChangesetRoleWithOidcRef(props.roleName));\n\n    // Outputs\n    lines.push('');\n    lines.push('Outputs:');\n\n    if (!skipOidcProvider) {\n      lines.push(...this.generateOidcProviderOutputLines());\n    }\n\n    lines.push(...this.generateOidcRoleOutputLines());\n    lines.push(...this.generateChangesetOutputLines());\n\n    return lines.join('\\n');\n  }\n\n  /**\n   * Generate template that uses an external OIDC role (original behavior)\n   */\n  private static generateTemplateWithExternalOidcRole(props: CdkDiffIamTemplateGeneratorProps): string {\n    const lines = [\n      \"AWSTemplateFormatVersion: '2010-09-09'\",\n      \"Description: 'IAM role for CDK Diff Stack Workflow construct'\",\n      '',\n      'Parameters:',\n      '  GitHubOIDCRoleArn:',\n      '    Type: String',\n      \"    Description: 'ARN of the existing GitHub OIDC role that can assume this changeset role'\",\n      `    Default: '${props.oidcRoleArn}'`,\n      '',\n      'Resources:',\n      '  # CloudFormation ChangeSet Role - minimal permissions for changeset operations',\n      '  CdkChangesetRole:',\n      '    Type: AWS::IAM::Role',\n      '    Properties:',\n      \"      RoleName: '\" + props.roleName + \"'\",\n      '      AssumeRolePolicyDocument:',\n      \"        Version: '2012-10-17'\",\n      '        Statement:',\n      '          - Effect: Allow',\n      '            Principal:',\n      '              AWS: !Ref GitHubOIDCRoleArn',\n      '            Action: sts:AssumeRole',\n      '            Condition:',\n      '              StringEquals:',\n      \"                aws:RequestedRegion: '\" + props.oidcRegion + \"'\",\n      '      Policies:',\n      '        - PolicyName: CloudFormationChangeSetAccess',\n      '          PolicyDocument:',\n      \"            Version: '2012-10-17'\",\n      '            Statement:',\n      '              # CloudFormation changeset operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - cloudformation:CreateChangeSet',\n      '                  - cloudformation:DescribeChangeSet',\n      '                  - cloudformation:DeleteChangeSet',\n      '                  - cloudformation:ListChangeSets',\n      '                  - cloudformation:DescribeStacks',\n      \"                Resource: '*'\",\n      '              # CDK bootstrap bucket access (for changeset creation)',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - s3:GetObject',\n      '                  - s3:PutObject',\n      '                  - s3:DeleteObject',\n      '                  - s3:ListBucket',\n      '                Resource:',\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*'\",\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*/*'\",\n      '              # CDK bootstrap parameter access',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - ssm:GetParameter',\n      '                  - ssm:GetParameters',\n      '                  - ssm:GetParametersByPath',\n      \"                Resource: !Sub 'arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter/cdk-bootstrap/*'\",\n      '              # IAM PassRole for CDK operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - iam:PassRole',\n      \"                Resource: '*'\",\n      '                Condition:',\n      '                  StringEquals:',\n      \"                    'iam:PassedToService': 'cloudformation.amazonaws.com'\",\n      '',\n      'Outputs:',\n      '  CdkChangesetRoleArn:',\n      \"    Description: 'ARN of the CDK changeset role'\",\n      '    Value: !GetAtt CdkChangesetRole.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleArn'\",\n      '',\n      '  CdkChangesetRoleName:',\n      \"    Description: 'Name of the CDK changeset role'\",\n      '    Value: !Ref CdkChangesetRole',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleName'\",\n    ];\n\n    return lines.join('\\n');\n  }\n\n  private static generateOidcProviderLines(): string[] {\n    return [\n      '  # GitHub OIDC Provider',\n      '  GitHubOIDCProvider:',\n      '    Type: AWS::IAM::OIDCProvider',\n      '    Properties:',\n      '      Url: https://token.actions.githubusercontent.com',\n      '      ClientIdList:',\n      '        - sts.amazonaws.com',\n      '      ThumbprintList:',\n      '        - 6938fd4d98bab03faadb97b34396831e3780aea1',\n      '        - 1c58a3a8518e8759bf075b76b750d4f2df264fcd',\n      '',\n    ];\n  }\n\n  private static generateOidcRoleLines(\n    roleName: string,\n    githubOidc: GitHubOidcConfig,\n    skipOidcProvider: boolean = false,\n  ): string[] {\n    const subjectClaims = this.buildSubjectClaims(githubOidc);\n\n    const lines = [\n      '  # GitHub OIDC Role - authenticates GitHub Actions workflows',\n      '  GitHubOIDCRole:',\n      '    Type: AWS::IAM::Role',\n    ];\n\n    // Only add DependsOn if we're creating the provider\n    if (!skipOidcProvider) {\n      lines.push('    DependsOn: GitHubOIDCProvider');\n    }\n\n    lines.push(\n      '    Properties:',\n      \"      RoleName: '\" + roleName + \"'\",\n      '      AssumeRolePolicyDocument:',\n      \"        Version: '2012-10-17'\",\n      '        Statement:',\n      '          - Effect: Allow',\n      '            Principal:',\n      \"              Federated: !Sub 'arn:aws:iam::${AWS::AccountId}:oidc-provider/token.actions.githubusercontent.com'\",\n      '            Action: sts:AssumeRoleWithWebIdentity',\n      '            Condition:',\n      '              StringEquals:',\n      \"                'token.actions.githubusercontent.com:aud': 'sts.amazonaws.com'\",\n      '              StringLike:',\n      \"                'token.actions.githubusercontent.com:sub':\",\n    );\n\n    // Add subject claims\n    for (const claim of subjectClaims) {\n      lines.push(`                  - '${claim}'`);\n    }\n\n    lines.push('');\n    return lines;\n  }\n\n  private static buildSubjectClaims(githubOidc: GitHubOidcConfig): string[] {\n    const claims: string[] = [];\n    const branches = githubOidc.branches ?? ['*'];\n\n    for (const repo of githubOidc.repositories) {\n      if (repo === '*') {\n        // Wildcard repo - allow all repos with branch restrictions\n        for (const branch of branches) {\n          if (branch === '*') {\n            claims.push(`repo:${githubOidc.owner}/*`);\n          } else {\n            claims.push(`repo:${githubOidc.owner}/*:ref:refs/heads/${branch}`);\n          }\n        }\n      } else {\n        // Specific repo\n        for (const branch of branches) {\n          if (branch === '*') {\n            claims.push(`repo:${githubOidc.owner}/${repo}:*`);\n          } else {\n            claims.push(`repo:${githubOidc.owner}/${repo}:ref:refs/heads/${branch}`);\n          }\n        }\n      }\n    }\n\n    // Add any additional claims\n    if (githubOidc.additionalClaims) {\n      for (const claim of githubOidc.additionalClaims) {\n        for (const repo of githubOidc.repositories) {\n          if (repo === '*') {\n            claims.push(`repo:${githubOidc.owner}/*:${claim}`);\n          } else {\n            claims.push(`repo:${githubOidc.owner}/${repo}:${claim}`);\n          }\n        }\n      }\n    }\n\n    return claims;\n  }\n\n  private static generateChangesetRoleWithOidcRef(roleName: string): string[] {\n    return [\n      '  # CloudFormation ChangeSet Role - minimal permissions for changeset operations',\n      '  CdkChangesetRole:',\n      '    Type: AWS::IAM::Role',\n      '    DependsOn: GitHubOIDCRole',\n      '    Properties:',\n      \"      RoleName: '\" + roleName + \"'\",\n      '      AssumeRolePolicyDocument:',\n      \"        Version: '2012-10-17'\",\n      '        Statement:',\n      '          - Effect: Allow',\n      '            Principal:',\n      '              AWS: !GetAtt GitHubOIDCRole.Arn',\n      '            Action: sts:AssumeRole',\n      '      Policies:',\n      '        - PolicyName: CloudFormationChangeSetAccess',\n      '          PolicyDocument:',\n      \"            Version: '2012-10-17'\",\n      '            Statement:',\n      '              # CloudFormation changeset operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - cloudformation:CreateChangeSet',\n      '                  - cloudformation:DescribeChangeSet',\n      '                  - cloudformation:DeleteChangeSet',\n      '                  - cloudformation:ListChangeSets',\n      '                  - cloudformation:DescribeStacks',\n      \"                Resource: '*'\",\n      '              # CDK bootstrap bucket access (for changeset creation)',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - s3:GetObject',\n      '                  - s3:PutObject',\n      '                  - s3:DeleteObject',\n      '                  - s3:ListBucket',\n      '                Resource:',\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*'\",\n      \"                  - !Sub 'arn:aws:s3:::cdk-${AWS::AccountId}-${AWS::Region}-*/*'\",\n      '              # CDK bootstrap parameter access',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - ssm:GetParameter',\n      '                  - ssm:GetParameters',\n      '                  - ssm:GetParametersByPath',\n      \"                Resource: !Sub 'arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter/cdk-bootstrap/*'\",\n      '              # IAM PassRole for CDK operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - iam:PassRole',\n      \"                Resource: '*'\",\n      '                Condition:',\n      '                  StringEquals:',\n      \"                    'iam:PassedToService': 'cloudformation.amazonaws.com'\",\n      '',\n    ];\n  }\n\n  private static generateOidcProviderOutputLines(): string[] {\n    return [\n      '  GitHubOIDCProviderArn:',\n      \"    Description: 'ARN of the GitHub OIDC provider'\",\n      '    Value: !GetAtt GitHubOIDCProvider.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-GitHubOIDCProviderArn'\",\n      '',\n    ];\n  }\n\n  private static generateOidcRoleOutputLines(): string[] {\n    return [\n      '  GitHubOIDCRoleArn:',\n      \"    Description: 'ARN of the GitHub OIDC role'\",\n      '    Value: !GetAtt GitHubOIDCRole.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-GitHubOIDCRoleArn'\",\n      '',\n      '  GitHubOIDCRoleName:',\n      \"    Description: 'Name of the GitHub OIDC role'\",\n      '    Value: !Ref GitHubOIDCRole',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-GitHubOIDCRoleName'\",\n      '',\n    ];\n  }\n\n  private static generateChangesetOutputLines(): string[] {\n    return [\n      '  CdkChangesetRoleArn:',\n      \"    Description: 'ARN of the CDK changeset role'\",\n      '    Value: !GetAtt CdkChangesetRole.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleArn'\",\n      '',\n      '  CdkChangesetRoleName:',\n      \"    Description: 'Name of the CDK changeset role'\",\n      '    Value: !Ref CdkChangesetRole',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkChangesetRoleName'\",\n    ];\n  }\n}\n\n/**\n * Props for the Projen-integrated CDK Diff IAM template construct\n */\nexport interface CdkDiffIamTemplateProps extends CdkDiffIamTemplateGeneratorProps {\n  /** Projen project instance */\n  readonly project: any;\n  /** Output path for the template file (default: 'cdk-diff-workflow-iam-template.yaml') */\n  readonly outputPath?: string;\n}\n\n/**\n * Projen construct that emits a CloudFormation template with minimal IAM permissions\n * for the CDK Diff Stack Workflow.\n *\n * For non-Projen projects, use `CdkDiffIamTemplateGenerator` directly.\n */\nexport class CdkDiffIamTemplate {\n  constructor(props: CdkDiffIamTemplateProps) {\n    const outputPath = props.outputPath ?? 'cdk-diff-workflow-iam-template.yaml';\n\n    // Generate template using the generator\n    const template = CdkDiffIamTemplateGenerator.generateTemplate(props);\n    new TextFile(props.project, outputPath, { lines: template.split('\\n') });\n\n    // Add deploy task\n    props.project.addTask('deploy-cdkdiff-iam-template', {\n      description:\n        'Deploy the CDK Diff IAM template via CloudFormation (accepts extra AWS CLI args, e.g., --parameter-overrides Key=Value...)',\n      receiveArgs: true,\n      exec: CdkDiffIamTemplateGenerator.generateDeployCommand(outputPath),\n    });\n  }\n}\n"]}