@jjrawlins/cdk-diff-pr-github-action 0.0.72 → 1.0.0

package/lib/CdkDiffIamTemplateStackSet.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Which roles to include in the StackSet
+ */
+export declare enum StackSetRoleSelection {
+    /** Include only the changeset role (CdkChangesetRole) */
+    CHANGESET_ONLY = "CHANGESET_ONLY",
+    /** Include only the drift role (CdkDriftRole) */
+    DRIFT_ONLY = "DRIFT_ONLY",
+    /** Include both roles (default) */
+    BOTH = "BOTH"
+}
+/**
+ * Configuration for StackSet auto-deployment
+ */
+export interface StackSetAutoDeployment {
+    /** Enable auto-deployment to new accounts in target OUs (default: true) */
+    readonly enabled?: boolean;
+    /** Retain stacks when account leaves OU (default: false) */
+    readonly retainStacksOnAccountRemoval?: boolean;
+}
+/**
+ * GitHub repository restrictions for OIDC authentication
+ */
+export interface GitHubOidcConfig {
+    /**
+     * GitHub organization or username (e.g., 'my-org' or 'my-username')
+     */
+    readonly owner: string;
+    /**
+     * Repository names allowed to assume the role (e.g., ['repo1', 'repo2'])
+     * Use ['*'] to allow all repos in the organization
+     */
+    readonly repositories: string[];
+    /**
+     * Branch patterns allowed (e.g., ['main', 'release/*'])
+     * Default: ['*'] (all branches)
+     */
+    readonly branches?: string[];
+    /**
+     * Additional subject claims for fine-grained access
+     * e.g., ['pull_request', 'environment:production']
+     */
+    readonly additionalClaims?: string[];
+}
+/**
+ * Props for generating StackSet templates (no Projen dependency)
+ */
+export interface CdkDiffIamTemplateStackSetGeneratorProps {
+    /** GitHub OIDC configuration for repo/branch restrictions */
+    readonly githubOidc: GitHubOidcConfig;
+    /** Name of the GitHub OIDC role (default: 'GitHubOIDCRole') */
+    readonly oidcRoleName?: string;
+    /** Name of the CdkChangesetRole (default: 'CdkChangesetRole') */
+    readonly changesetRoleName?: string;
+    /** Name of the CdkDriftRole (default: 'CdkDriftRole') */
+    readonly driftRoleName?: string;
+    /** Which roles to include (default: BOTH) */
+    readonly roleSelection?: StackSetRoleSelection;
+    /** Description for the StackSet */
+    readonly description?: string;
+    /**
+     * Skip creating the OIDC provider (use existing one).
+     * Set to true if accounts already have a GitHub OIDC provider.
+     * The template will reference the existing provider by ARN.
+     * Default: false
+     */
+    readonly skipOidcProviderCreation?: boolean;
+}
+/**
+ * Props for generating StackSet CLI commands (no Projen dependency)
+ */
+export interface CdkDiffIamTemplateStackSetCommandsProps {
+    /** Name of the StackSet (default: 'cdk-diff-workflow-iam-stackset') */
+    readonly stackSetName?: string;
+    /** Path to the template file (default: 'cdk-diff-workflow-stackset-template.yaml') */
+    readonly templatePath?: string;
+    /** Target OUs for deployment (e.g., ['ou-xxxx-xxxxxxxx', 'r-xxxx']) */
+    readonly targetOrganizationalUnitIds?: string[];
+    /** Target regions for deployment (e.g., ['us-east-1', 'eu-west-1']) */
+    readonly regions?: string[];
+    /** Auto-deployment configuration */
+    readonly autoDeployment?: StackSetAutoDeployment;
+    /**
+     * Whether to use delegated admin mode for StackSet operations.
+     * If true, adds --call-as DELEGATED_ADMIN to commands.
+     * Default: true
+     */
+    readonly delegatedAdmin?: boolean;
+}
+/**
+ * Pure generator class for StackSet templates and commands.
+ * No Projen dependency - can be used in any project.
+ */
+export declare class CdkDiffIamTemplateStackSetGenerator {
+    /**
+     * Generate the CloudFormation StackSet template as a YAML string.
+     */
+    static generateTemplate(props: CdkDiffIamTemplateStackSetGeneratorProps): string;
+    /**
+     * Generate AWS CLI commands for StackSet operations.
+     * Returns a map of command names to shell commands.
+     */
+    static generateCommands(props?: CdkDiffIamTemplateStackSetCommandsProps): Record<string, string>;
+    private static generateTemplateLines;
+    private static generateOidcProviderLines;
+    private static generateOidcRoleLines;
+    private static buildSubjectClaims;
+    private static generateChangesetRoleLines;
+    private static generateDriftRoleLines;
+    private static generateOidcOutputLines;
+    private static generateOidcRoleOutputLines;
+    private static generateChangesetOutputLines;
+    private static generateDriftOutputLines;
+}
+/**
+ * Props for the Projen-integrated StackSet construct
+ */
+export interface CdkDiffIamTemplateStackSetProps extends CdkDiffIamTemplateStackSetGeneratorProps {
+    /** Projen project instance */
+    readonly project: any;
+    /** Name of the StackSet (default: 'cdk-diff-workflow-iam-stackset') */
+    readonly stackSetName?: string;
+    /** Output path for the template file (default: 'cdk-diff-workflow-stackset-template.yaml') */
+    readonly outputPath?: string;
+    /** Target OUs for deployment (e.g., ['ou-xxxx-xxxxxxxx', 'r-xxxx']) */
+    readonly targetOrganizationalUnitIds?: string[];
+    /** Target regions for deployment (e.g., ['us-east-1', 'eu-west-1']) */
+    readonly regions?: string[];
+    /** Auto-deployment configuration */
+    readonly autoDeployment?: StackSetAutoDeployment;
+    /**
+     * Whether to use delegated admin mode for StackSet operations.
+     * If true, adds --call-as DELEGATED_ADMIN to commands.
+     * If false, assumes running from the management account.
+     * Default: true
+     */
+    readonly delegatedAdmin?: boolean;
+}
+/**
+ * Projen construct that creates a CloudFormation StackSet template for org-wide deployment of
+ * GitHub OIDC provider, OIDC role, and CDK Diff/Drift IAM roles.
+ *
+ * This provides a self-contained per-account deployment with no role chaining required.
+ *
+ * For non-Projen projects, use `CdkDiffIamTemplateStackSetGenerator` directly.
+ */
+export declare class CdkDiffIamTemplateStackSet {
+    constructor(props: CdkDiffIamTemplateStackSetProps);
+}

package/lib/CdkDiffIamTemplateStackSet.js

@@ -0,0 +1,373 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkDiffIamTemplateStackSet = exports.CdkDiffIamTemplateStackSetGenerator = exports.StackSetRoleSelection = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * Which roles to include in the StackSet
+ */
+var StackSetRoleSelection;
+(function (StackSetRoleSelection) {
+    /** Include only the changeset role (CdkChangesetRole) */
+    StackSetRoleSelection["CHANGESET_ONLY"] = "CHANGESET_ONLY";
+    /** Include only the drift role (CdkDriftRole) */
+    StackSetRoleSelection["DRIFT_ONLY"] = "DRIFT_ONLY";
+    /** Include both roles (default) */
+    StackSetRoleSelection["BOTH"] = "BOTH";
+})(StackSetRoleSelection || (exports.StackSetRoleSelection = StackSetRoleSelection = {}));
+/**
+ * Pure generator class for StackSet templates and commands.
+ * No Projen dependency - can be used in any project.
+ */
+class CdkDiffIamTemplateStackSetGenerator {
+    /**
+     * Generate the CloudFormation StackSet template as a YAML string.
+     */
+    static generateTemplate(props) {
+        const oidcRoleName = props.oidcRoleName ?? 'GitHubOIDCRole';
+        const changesetRoleName = props.changesetRoleName ?? 'CdkChangesetRole';
+        const driftRoleName = props.driftRoleName ?? 'CdkDriftRole';
+        const roleSelection = props.roleSelection ?? StackSetRoleSelection.BOTH;
+        const skipOidcProvider = props.skipOidcProviderCreation ?? false;
+        const lines = this.generateTemplateLines(props.githubOidc, oidcRoleName, changesetRoleName, driftRoleName, roleSelection, props.description, skipOidcProvider);
+        return lines.join('\n');
+    }
+    /**
+     * Generate AWS CLI commands for StackSet operations.
+     * Returns a map of command names to shell commands.
+     */
+    static generateCommands(props = {}) {
+        const stackSetName = props.stackSetName ?? 'cdk-diff-workflow-iam-stackset';
+        const templatePath = props.templatePath ?? 'cdk-diff-workflow-stackset-template.yaml';
+        const regions = props.regions ?? ['us-east-1'];
+        const targetOUs = props.targetOrganizationalUnitIds ?? [];
+        const autoDeployEnabled = props.autoDeployment?.enabled ?? true;
+        const retainStacks = props.autoDeployment?.retainStacksOnAccountRemoval ?? false;
+        const delegatedAdmin = props.delegatedAdmin ?? true;
+        const callAs = delegatedAdmin ? ' --call-as DELEGATED_ADMIN' : '';
+        const ouList = targetOUs.length > 0 ? targetOUs.join(',') : '<OU_IDS>';
+        const regionList = regions.join(' ');
+        return {
+            'stackset-create': `aws cloudformation create-stack-set --stack-set-name ${stackSetName} --template-body file://${templatePath} --capabilities CAPABILITY_NAMED_IAM --permission-model SERVICE_MANAGED --auto-deployment Enabled=${autoDeployEnabled},RetainStacksOnAccountRemoval=${retainStacks}${callAs}`,
+            'stackset-update': `aws cloudformation update-stack-set --stack-set-name ${stackSetName} --template-body file://${templatePath} --capabilities CAPABILITY_NAMED_IAM${callAs}`,
+            'stackset-deploy-instances': `aws cloudformation create-stack-instances --stack-set-name ${stackSetName} --deployment-targets OrganizationalUnitIds=${ouList} --regions ${regionList}${callAs}`,
+            'stackset-delete-instances': `aws cloudformation delete-stack-instances --stack-set-name ${stackSetName} --deployment-targets OrganizationalUnitIds=${ouList} --regions ${regionList} --no-retain-stacks${callAs}`,
+            'stackset-delete': `aws cloudformation delete-stack-set --stack-set-name ${stackSetName}${callAs}`,
+            'stackset-describe': `aws cloudformation describe-stack-set --stack-set-name ${stackSetName}${callAs}`,
+            'stackset-list-instances': `aws cloudformation list-stack-instances --stack-set-name ${stackSetName}${callAs}`,
+        };
+    }
+    static generateTemplateLines(githubOidc, oidcRoleName, changesetRoleName, driftRoleName, roleSelection, description, skipOidcProvider = false) {
+        const lines = [];
+        const desc = description ?? 'GitHub OIDC and IAM roles for CDK Diff/Drift workflows (StackSet deployment)';
+        const includeChangeset = roleSelection === StackSetRoleSelection.BOTH || roleSelection === StackSetRoleSelection.CHANGESET_ONLY;
+        const includeDrift = roleSelection === StackSetRoleSelection.BOTH || roleSelection === StackSetRoleSelection.DRIFT_ONLY;
+        // Header
+        lines.push("AWSTemplateFormatVersion: '2010-09-09'");
+        lines.push(`Description: '${desc}'`);
+        lines.push('');
+        // Resources
+        lines.push('Resources:');
+        // OIDC Provider (only if not skipping)
+        if (!skipOidcProvider) {
+            lines.push(...this.generateOidcProviderLines());
+        }
+        // OIDC Role
+        lines.push(...this.generateOidcRoleLines(oidcRoleName, githubOidc, skipOidcProvider));
+        // Changeset/Drift roles
+        if (includeChangeset) {
+            lines.push(...this.generateChangesetRoleLines(changesetRoleName));
+        }
+        if (includeDrift) {
+            lines.push(...this.generateDriftRoleLines(driftRoleName));
+        }
+        // Outputs
+        lines.push('');
+        lines.push('Outputs:');
+        if (!skipOidcProvider) {
+            lines.push(...this.generateOidcOutputLines());
+        }
+        // Always output the OIDC role ARN
+        lines.push(...this.generateOidcRoleOutputLines());
+        if (includeChangeset) {
+            lines.push(...this.generateChangesetOutputLines());
+        }
+        if (includeDrift) {
+            lines.push(...this.generateDriftOutputLines());
+        }
+        return lines;
+    }
+    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 generateChangesetRoleLines(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 generateDriftRoleLines(roleName) {
+        return [
+            '  # CloudFormation Drift Detection Role - minimal permissions for drift detection operations',
+            '  CdkDriftRole:',
+            '    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: CloudFormationDriftAccess',
+            '          PolicyDocument:',
+            "            Version: '2012-10-17'",
+            '            Statement:',
+            '              # CloudFormation drift detection operations',
+            '              - Effect: Allow',
+            '                Action:',
+            '                  - cloudformation:DetectStackDrift',
+            '                  - cloudformation:DescribeStackDriftDetectionStatus',
+            '                  - cloudformation:DescribeStackResourceDrifts',
+            '                  - cloudformation:DescribeStacks',
+            '                  - cloudformation:ListStackResources',
+            '                  - cloudformation:DetectStackResourceDrift',
+            "                Resource: '*'",
+            '',
+        ];
+    }
+    static generateOidcOutputLines() {
+        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'",
+            '',
+        ];
+    }
+    static generateDriftOutputLines() {
+        return [
+            '  CdkDriftRoleArn:',
+            "    Description: 'ARN of the CDK drift detection role'",
+            '    Value: !GetAtt CdkDriftRole.Arn',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-CdkDriftRoleArn'",
+            '',
+            '  CdkDriftRoleName:',
+            "    Description: 'Name of the CDK drift detection role'",
+            '    Value: !Ref CdkDriftRole',
+            '    Export:',
+            "      Name: !Sub '${AWS::StackName}-CdkDriftRoleName'",
+        ];
+    }
+}
+exports.CdkDiffIamTemplateStackSetGenerator = CdkDiffIamTemplateStackSetGenerator;
+_a = JSII_RTTI_SYMBOL_1;
+CdkDiffIamTemplateStackSetGenerator[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplateStackSetGenerator", version: "1.0.0" };
+/**
+ * Projen construct that creates a CloudFormation StackSet template for org-wide deployment of
+ * GitHub OIDC provider, OIDC role, and CDK Diff/Drift IAM roles.
+ *
+ * This provides a self-contained per-account deployment with no role chaining required.
+ *
+ * For non-Projen projects, use `CdkDiffIamTemplateStackSetGenerator` directly.
+ */
+class CdkDiffIamTemplateStackSet {
+    constructor(props) {
+        const outputPath = props.outputPath ?? 'cdk-diff-workflow-stackset-template.yaml';
+        const stackSetName = props.stackSetName ?? 'cdk-diff-workflow-iam-stackset';
+        // Generate template using the generator
+        const template = CdkDiffIamTemplateStackSetGenerator.generateTemplate(props);
+        new projen_1.TextFile(props.project, outputPath, { lines: template.split('\n') });
+        // Generate commands and add as Projen tasks
+        const commands = CdkDiffIamTemplateStackSetGenerator.generateCommands({
+            stackSetName,
+            templatePath: outputPath,
+            targetOrganizationalUnitIds: props.targetOrganizationalUnitIds,
+            regions: props.regions,
+            autoDeployment: props.autoDeployment,
+            delegatedAdmin: props.delegatedAdmin,
+        });
+        const taskDescriptions = {
+            'stackset-create': 'Create the StackSet for org-wide IAM role deployment',
+            'stackset-update': 'Update the StackSet template',
+            'stackset-deploy-instances': 'Deploy stack instances to target OUs and regions (pass --deployment-targets OrganizationalUnitIds=<ou-ids> to override)',
+            'stackset-delete-instances': 'Delete stack instances from target OUs and regions',
+            'stackset-delete': 'Delete the StackSet (requires all instances to be deleted first)',
+            'stackset-describe': 'Describe the StackSet status and configuration',
+            'stackset-list-instances': 'List all stack instances and their statuses',
+        };
+        for (const [taskName, command] of Object.entries(commands)) {
+            props.project.addTask(taskName, {
+                description: taskDescriptions[taskName],
+                receiveArgs: taskName !== 'stackset-delete',
+                exec: command,
+            });
+        }
+    }
+}
+exports.CdkDiffIamTemplateStackSet = CdkDiffIamTemplateStackSet;
+_b = JSII_RTTI_SYMBOL_1;
+CdkDiffIamTemplateStackSet[_b] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplateStackSet", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDiffIamTemplateStackSet.js","sourceRoot":"","sources":["../src/CdkDiffIamTemplateStackSet.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile } from 'projen';\n\n/**\n * Which roles to include in the StackSet\n */\nexport enum StackSetRoleSelection {\n  /** Include only the changeset role (CdkChangesetRole) */\n  CHANGESET_ONLY = 'CHANGESET_ONLY',\n  /** Include only the drift role (CdkDriftRole) */\n  DRIFT_ONLY = 'DRIFT_ONLY',\n  /** Include both roles (default) */\n  BOTH = 'BOTH',\n}\n\n/**\n * Configuration for StackSet auto-deployment\n */\nexport interface StackSetAutoDeployment {\n  /** Enable auto-deployment to new accounts in target OUs (default: true) */\n  readonly enabled?: boolean;\n  /** Retain stacks when account leaves OU (default: false) */\n  readonly retainStacksOnAccountRemoval?: boolean;\n}\n\n/**\n * GitHub repository restrictions for OIDC authentication\n */\nexport interface GitHubOidcConfig {\n  /**\n   * GitHub organization or username (e.g., 'my-org' or 'my-username')\n   */\n  readonly owner: string;\n\n  /**\n   * Repository names allowed to assume the role (e.g., ['repo1', 'repo2'])\n   * Use ['*'] to allow all repos in the organization\n   */\n  readonly repositories: string[];\n\n  /**\n   * Branch patterns allowed (e.g., ['main', 'release/*'])\n   * Default: ['*'] (all branches)\n   */\n  readonly branches?: string[];\n\n  /**\n   * Additional subject claims for fine-grained access\n   * e.g., ['pull_request', 'environment:production']\n   */\n  readonly additionalClaims?: string[];\n}\n\n/**\n * Props for generating StackSet templates (no Projen dependency)\n */\nexport interface CdkDiffIamTemplateStackSetGeneratorProps {\n  /** GitHub OIDC configuration for repo/branch restrictions */\n  readonly githubOidc: GitHubOidcConfig;\n\n  /** Name of the GitHub OIDC role (default: 'GitHubOIDCRole') */\n  readonly oidcRoleName?: string;\n\n  /** Name of the CdkChangesetRole (default: 'CdkChangesetRole') */\n  readonly changesetRoleName?: string;\n\n  /** Name of the CdkDriftRole (default: 'CdkDriftRole') */\n  readonly driftRoleName?: string;\n\n  /** Which roles to include (default: BOTH) */\n  readonly roleSelection?: StackSetRoleSelection;\n\n  /** Description for the StackSet */\n  readonly description?: string;\n\n  /**\n   * Skip creating the OIDC provider (use existing one).\n   * Set to true if accounts already have a GitHub OIDC provider.\n   * The template will reference the existing provider by ARN.\n   * Default: false\n   */\n  readonly skipOidcProviderCreation?: boolean;\n}\n\n/**\n * Props for generating StackSet CLI commands (no Projen dependency)\n */\nexport interface CdkDiffIamTemplateStackSetCommandsProps {\n  /** Name of the StackSet (default: 'cdk-diff-workflow-iam-stackset') */\n  readonly stackSetName?: string;\n\n  /** Path to the template file (default: 'cdk-diff-workflow-stackset-template.yaml') */\n  readonly templatePath?: string;\n\n  /** Target OUs for deployment (e.g., ['ou-xxxx-xxxxxxxx', 'r-xxxx']) */\n  readonly targetOrganizationalUnitIds?: string[];\n\n  /** Target regions for deployment (e.g., ['us-east-1', 'eu-west-1']) */\n  readonly regions?: string[];\n\n  /** Auto-deployment configuration */\n  readonly autoDeployment?: StackSetAutoDeployment;\n\n  /**\n   * Whether to use delegated admin mode for StackSet operations.\n   * If true, adds --call-as DELEGATED_ADMIN to commands.\n   * Default: true\n   */\n  readonly delegatedAdmin?: boolean;\n}\n\n/**\n * Pure generator class for StackSet templates and commands.\n * No Projen dependency - can be used in any project.\n */\nexport class CdkDiffIamTemplateStackSetGenerator {\n  /**\n   * Generate the CloudFormation StackSet template as a YAML string.\n   */\n  static generateTemplate(props: CdkDiffIamTemplateStackSetGeneratorProps): string {\n    const oidcRoleName = props.oidcRoleName ?? 'GitHubOIDCRole';\n    const changesetRoleName = props.changesetRoleName ?? 'CdkChangesetRole';\n    const driftRoleName = props.driftRoleName ?? 'CdkDriftRole';\n    const roleSelection = props.roleSelection ?? StackSetRoleSelection.BOTH;\n    const skipOidcProvider = props.skipOidcProviderCreation ?? false;\n\n    const lines = this.generateTemplateLines(\n      props.githubOidc,\n      oidcRoleName,\n      changesetRoleName,\n      driftRoleName,\n      roleSelection,\n      props.description,\n      skipOidcProvider,\n    );\n\n    return lines.join('\\n');\n  }\n\n  /**\n   * Generate AWS CLI commands for StackSet operations.\n   * Returns a map of command names to shell commands.\n   */\n  static generateCommands(props: CdkDiffIamTemplateStackSetCommandsProps = {}): Record<string, string> {\n    const stackSetName = props.stackSetName ?? 'cdk-diff-workflow-iam-stackset';\n    const templatePath = props.templatePath ?? 'cdk-diff-workflow-stackset-template.yaml';\n    const regions = props.regions ?? ['us-east-1'];\n    const targetOUs = props.targetOrganizationalUnitIds ?? [];\n    const autoDeployEnabled = props.autoDeployment?.enabled ?? true;\n    const retainStacks = props.autoDeployment?.retainStacksOnAccountRemoval ?? false;\n    const delegatedAdmin = props.delegatedAdmin ?? true;\n    const callAs = delegatedAdmin ? ' --call-as DELEGATED_ADMIN' : '';\n\n    const ouList = targetOUs.length > 0 ? targetOUs.join(',') : '<OU_IDS>';\n    const regionList = regions.join(' ');\n\n    return {\n      'stackset-create': `aws cloudformation create-stack-set --stack-set-name ${stackSetName} --template-body file://${templatePath} --capabilities CAPABILITY_NAMED_IAM --permission-model SERVICE_MANAGED --auto-deployment Enabled=${autoDeployEnabled},RetainStacksOnAccountRemoval=${retainStacks}${callAs}`,\n      'stackset-update': `aws cloudformation update-stack-set --stack-set-name ${stackSetName} --template-body file://${templatePath} --capabilities CAPABILITY_NAMED_IAM${callAs}`,\n      'stackset-deploy-instances': `aws cloudformation create-stack-instances --stack-set-name ${stackSetName} --deployment-targets OrganizationalUnitIds=${ouList} --regions ${regionList}${callAs}`,\n      'stackset-delete-instances': `aws cloudformation delete-stack-instances --stack-set-name ${stackSetName} --deployment-targets OrganizationalUnitIds=${ouList} --regions ${regionList} --no-retain-stacks${callAs}`,\n      'stackset-delete': `aws cloudformation delete-stack-set --stack-set-name ${stackSetName}${callAs}`,\n      'stackset-describe': `aws cloudformation describe-stack-set --stack-set-name ${stackSetName}${callAs}`,\n      'stackset-list-instances': `aws cloudformation list-stack-instances --stack-set-name ${stackSetName}${callAs}`,\n    };\n  }\n\n  private static generateTemplateLines(\n    githubOidc: GitHubOidcConfig,\n    oidcRoleName: string,\n    changesetRoleName: string,\n    driftRoleName: string,\n    roleSelection: StackSetRoleSelection,\n    description?: string,\n    skipOidcProvider: boolean = false,\n  ): string[] {\n    const lines: string[] = [];\n    const desc = description ?? 'GitHub OIDC and IAM roles for CDK Diff/Drift workflows (StackSet deployment)';\n\n    const includeChangeset =\n      roleSelection === StackSetRoleSelection.BOTH || roleSelection === StackSetRoleSelection.CHANGESET_ONLY;\n    const includeDrift =\n      roleSelection === StackSetRoleSelection.BOTH || roleSelection === StackSetRoleSelection.DRIFT_ONLY;\n\n    // Header\n    lines.push(\"AWSTemplateFormatVersion: '2010-09-09'\");\n    lines.push(`Description: '${desc}'`);\n    lines.push('');\n\n    // Resources\n    lines.push('Resources:');\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/Drift roles\n    if (includeChangeset) {\n      lines.push(...this.generateChangesetRoleLines(changesetRoleName));\n    }\n\n    if (includeDrift) {\n      lines.push(...this.generateDriftRoleLines(driftRoleName));\n    }\n\n    // Outputs\n    lines.push('');\n    lines.push('Outputs:');\n    if (!skipOidcProvider) {\n      lines.push(...this.generateOidcOutputLines());\n    }\n\n    // Always output the OIDC role ARN\n    lines.push(...this.generateOidcRoleOutputLines());\n\n    if (includeChangeset) {\n      lines.push(...this.generateChangesetOutputLines());\n    }\n\n    if (includeDrift) {\n      lines.push(...this.generateDriftOutputLines());\n    }\n\n    return lines;\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 generateChangesetRoleLines(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 generateDriftRoleLines(roleName: string): string[] {\n    return [\n      '  # CloudFormation Drift Detection Role - minimal permissions for drift detection operations',\n      '  CdkDriftRole:',\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: CloudFormationDriftAccess',\n      '          PolicyDocument:',\n      \"            Version: '2012-10-17'\",\n      '            Statement:',\n      '              # CloudFormation drift detection operations',\n      '              - Effect: Allow',\n      '                Action:',\n      '                  - cloudformation:DetectStackDrift',\n      '                  - cloudformation:DescribeStackDriftDetectionStatus',\n      '                  - cloudformation:DescribeStackResourceDrifts',\n      '                  - cloudformation:DescribeStacks',\n      '                  - cloudformation:ListStackResources',\n      '                  - cloudformation:DetectStackResourceDrift',\n      \"                Resource: '*'\",\n      '',\n    ];\n  }\n\n  private static generateOidcOutputLines(): 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  private static generateDriftOutputLines(): string[] {\n    return [\n      '  CdkDriftRoleArn:',\n      \"    Description: 'ARN of the CDK drift detection role'\",\n      '    Value: !GetAtt CdkDriftRole.Arn',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkDriftRoleArn'\",\n      '',\n      '  CdkDriftRoleName:',\n      \"    Description: 'Name of the CDK drift detection role'\",\n      '    Value: !Ref CdkDriftRole',\n      '    Export:',\n      \"      Name: !Sub '${AWS::StackName}-CdkDriftRoleName'\",\n    ];\n  }\n}\n\n/**\n * Props for the Projen-integrated StackSet construct\n */\nexport interface CdkDiffIamTemplateStackSetProps extends CdkDiffIamTemplateStackSetGeneratorProps {\n  /** Projen project instance */\n  readonly project: any;\n\n  /** Name of the StackSet (default: 'cdk-diff-workflow-iam-stackset') */\n  readonly stackSetName?: string;\n\n  /** Output path for the template file (default: 'cdk-diff-workflow-stackset-template.yaml') */\n  readonly outputPath?: string;\n\n  /** Target OUs for deployment (e.g., ['ou-xxxx-xxxxxxxx', 'r-xxxx']) */\n  readonly targetOrganizationalUnitIds?: string[];\n\n  /** Target regions for deployment (e.g., ['us-east-1', 'eu-west-1']) */\n  readonly regions?: string[];\n\n  /** Auto-deployment configuration */\n  readonly autoDeployment?: StackSetAutoDeployment;\n\n  /**\n   * Whether to use delegated admin mode for StackSet operations.\n   * If true, adds --call-as DELEGATED_ADMIN to commands.\n   * If false, assumes running from the management account.\n   * Default: true\n   */\n  readonly delegatedAdmin?: boolean;\n}\n\n/**\n * Projen construct that creates a CloudFormation StackSet template for org-wide deployment of\n * GitHub OIDC provider, OIDC role, and CDK Diff/Drift IAM roles.\n *\n * This provides a self-contained per-account deployment with no role chaining required.\n *\n * For non-Projen projects, use `CdkDiffIamTemplateStackSetGenerator` directly.\n */\nexport class CdkDiffIamTemplateStackSet {\n  constructor(props: CdkDiffIamTemplateStackSetProps) {\n    const outputPath = props.outputPath ?? 'cdk-diff-workflow-stackset-template.yaml';\n    const stackSetName = props.stackSetName ?? 'cdk-diff-workflow-iam-stackset';\n\n    // Generate template using the generator\n    const template = CdkDiffIamTemplateStackSetGenerator.generateTemplate(props);\n    new TextFile(props.project, outputPath, { lines: template.split('\\n') });\n\n    // Generate commands and add as Projen tasks\n    const commands = CdkDiffIamTemplateStackSetGenerator.generateCommands({\n      stackSetName,\n      templatePath: outputPath,\n      targetOrganizationalUnitIds: props.targetOrganizationalUnitIds,\n      regions: props.regions,\n      autoDeployment: props.autoDeployment,\n      delegatedAdmin: props.delegatedAdmin,\n    });\n\n    const taskDescriptions: Record<string, string> = {\n      'stackset-create': 'Create the StackSet for org-wide IAM role deployment',\n      'stackset-update': 'Update the StackSet template',\n      'stackset-deploy-instances':\n        'Deploy stack instances to target OUs and regions (pass --deployment-targets OrganizationalUnitIds=<ou-ids> to override)',\n      'stackset-delete-instances': 'Delete stack instances from target OUs and regions',\n      'stackset-delete': 'Delete the StackSet (requires all instances to be deleted first)',\n      'stackset-describe': 'Describe the StackSet status and configuration',\n      'stackset-list-instances': 'List all stack instances and their statuses',\n    };\n\n    for (const [taskName, command] of Object.entries(commands)) {\n      props.project.addTask(taskName, {\n        description: taskDescriptions[taskName],\n        receiveArgs: taskName !== 'stackset-delete',\n        exec: command,\n      });\n    }\n  }\n}\n"]}

package/lib/CdkDiffStackWorkflow.js

@@ -138,6 +138,6 @@ class CdkDiffStackWorkflow {
 }
 exports.CdkDiffStackWorkflow = CdkDiffStackWorkflow;
 _a = JSII_RTTI_SYMBOL_1;
-CdkDiffStackWorkflow[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffStackWorkflow", version: "0.0.72" };
+CdkDiffStackWorkflow[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDiffStackWorkflow", version: "1.0.0" };
 CdkDiffStackWorkflow.scriptCreated = false;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDiffStackWorkflow.js","sourceRoot":"","sources":["../src/CdkDiffStackWorkflow.ts"],"names":[],"mappings":";;;;;AAAA,8CAA2D;AAC3D,uEAAkE;AAClE,qEAAgE;AAEhE,MAAM,kCAAkC,GAAG,IAAI,CAAC;AAChD,MAAM,4BAA4B,GAAG,IAAI,CAAC;AAC1C,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAmB3C,MAAa,oBAAoB;IAG/B,YAAY,KAAgC;QAC1C,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,IAAI,KAAK,CAAC;QACrD,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,IAAI,MAAM,CAAC;QAChD,MAAM,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,IAAI,qDAAqD,CAAC;QAEzG,8BAA8B;QAC9B,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC;QAEtC,4DAA4D;QAC5D,IAAI,CAAC,oBAAoB,CAAC,aAAa,EAAE,CAAC;YACxC,IAAI,yCAAkB,CAAC;gBACrB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,UAAU,EAAE,gBAAgB;aAC7B,CAAC,CAAC;YACH,oBAAoB,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5C,CAAC;QAED,4CAA4C;QAC5C,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,YAAY,GAAG,QAAQ,KAAK,CAAC,SAAS,EAAE,CAAC;YAC/C,MAAM,EAAE,GAAI,KAAa,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,eAAM,CAAE,KAAa,CAAC,OAAO,CAAC,CAAC;YAC/E,MAAM,kBAAkB,GAAG,IAAI,uBAAc,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,QAAQ,EAAE,GAAG,YAAY,MAAM,EAAE,CAAC,CAAC;YAErG,IAAI,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,gBAAgB,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7I,CAAC;IACH,CAAC;IAEO,yBAAyB,CAAC,KAAgC;QAChE,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC;QAC/C,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;QAEhD,wDAAwD;QACxD,MAAM,qBAAqB,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC/E,MAAM,uBAAuB,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAEhF,iFAAiF;QACjF,IAAI,CAAC,kBAAkB,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;QAC9F,CAAC;QAED,IAAI,CAAC,oBAAoB,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;QAC5F,CAAC;IACH,CAAC;IAEO,sBAAsB,CAC5B,QAAwB,EACxB,KAAmB,EACnB,cAAsB,EACtB,WAAmB,EACnB,gBAAwB,EACxB,kBAA0B,EAC1B,iBAAyB;QAEzB,QAAQ,CAAC,EAAE,CAAC;YACV,WAAW,EAAE;gBACX,KAAK,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,CAAC;aAC7C;SACF,CAAC,CAAC;QACH,QAAQ,CAAC,OAAO,CAAC;YACf,IAAI,EAAE;gBACJ,MAAM,EAAE,CAAC,eAAe,CAAC;gBACzB,WAAW,EAAE;oBACX,OAAO,EAAE,+BAAa,CAAC,KAAK;oBAC5B,QAAQ,EAAE,+BAAa,CAAC,IAAI;oBAC5B,MAAM,EAAE,+BAAa,CAAC,KAAK;oBAC3B,YAAY,EAAE,+BAAa,CAAC,KAAK;oBACjC,QAAQ,EAAE,+BAAa,CAAC,IAAI;iBAC7B;gBACD,GAAG,EAAE;oBACH,YAAY,EAAE,6BAA6B;iBAC5C;gBACD,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,oBAAoB,4BAA4B,EAAE;qBACzD;oBACD;wBACE,IAAI,EAAE,sBAAsB,6BAA6B,EAAE;wBAC3D,IAAI,EAAE;4BACJ,cAAc,EAAE,WAAW;4BAC3B,cAAc,EAAE,4BAA4B;4BAC5C,OAAO,EAAE,iCAAiC;4BAC1C,OAAO,EAAE,6BAA6B;yBACvC;qBACF;oBACD;wBACE,GAAG,EAAE,gCAAgC;wBACrC,GAAG,EAAE;4BACH,eAAe,EAAE,6BAA6B;yBAC/C;qBACF;oBACD;wBACE,IAAI,EAAE,yCAAyC,kCAAkC,EAAE;wBACnF,IAAI,EAAE;4BACJ,gBAAgB,EAAE,KAAK,CAAC,WAAW,IAAI,kBAAkB;4BACzD,YAAY,EAAE,KAAK,CAAC,UAAU,IAAI,iBAAiB;yBACpD;qBACF;oBACD;wBACE,IAAI,EAAE,wBAAwB,KAAK,CAAC,SAAS,EAAE;wBAC/C,GAAG,EAAE,QAAQ,cAAc,WAAW,KAAK,CAAC,SAAS,mCAAmC,KAAK,CAAC,SAAS,2BAA2B;qBACnI;oBACD;wBACE,EAAE,EAAE,OAAO;wBACX,IAAI,EAAE,yCAAyC,kCAAkC,EAAE;wBACnF,IAAI,EAAE;4BACJ,gBAAgB,EAAE,KAAK,CAAC,WAAW,IAAI,kBAAkB;4BACzD,YAAY,EAAE,KAAK,CAAC,UAAU,IAAI,iBAAiB;yBACpD;qBACF;oBACD;wBACE,IAAI,EAAE,sCAAsC;wBAC5C,EAAE,EAAE,gBAAgB;wBACpB,IAAI,EAAE,yCAAyC,kCAAkC,EAAE;wBACnF,IAAI,EAAE;4BACJ,gBAAgB,EAAE,KAAK,CAAC,wBAAwB;4BAChD,eAAe,EAAE,IAAI;4BACrB,2BAA2B,EAAE,IAAI;4BACjC,YAAY,EAAE,KAAK,CAAC,2BAA2B;4BAC/C,mBAAmB,EAAE,8CAA8C;4BACnE,uBAAuB,EAAE,kDAAkD;4BAC3E,mBAAmB,EAAE,8CAA8C;yBACpE;qBACF;oBACD;wBACE,IAAI,EAAE,2BAA2B,KAAK,CAAC,SAAS,EAAE;wBAClD,GAAG,EAAE,eAAe,gBAAgB,EAAE;wBACtC,GAAG,EAAE;4BACH,UAAU,EAAE,KAAK,CAAC,SAAS;4BAC3B,eAAe,EAAE,KAAK,CAAC,SAAS;4BAChC,kBAAkB,EAAE,+CAA+C;4BACnE,YAAY,EAAE,6BAA6B;yBAC5C;qBACF;oBACD;wBACE,IAAI,EAAE,wBAAwB,KAAK,CAAC,SAAS,EAAE;wBAC/C,GAAG,EAAE,0DAA0D,KAAK,CAAC,SAAS,iBAAiB,KAAK,CAAC,SAAS,aAAa,KAAK,CAAC,2BAA2B,EAAE;qBAC/J;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;;AAhJH,oDAiJC;;;AAhJgB,kCAAa,GAAG,KAAK,CAAC","sourcesContent":["import { GitHub, GithubWorkflow } from 'projen/lib/github';\nimport { JobPermission } from 'projen/lib/github/workflows-model';\nimport { CdkChangesetScript } from './bin/cdk-changeset-script';\n\nconst githubActionsAwsCredentialsVersion = 'v4';\nconst githubActionsCheckoutVersion = 'v4';\nconst githubActionsSetupNodeVersion = 'v4';\n\nexport interface CdkDiffStack {\n  readonly stackName: string;\n  readonly changesetRoleToAssumeArn: string;\n  readonly changesetRoleToAssumeRegion: string;\n  readonly oidcRoleArn?: string; // Optional override for OIDC role\n  readonly oidcRegion?: string; // Optional override for OIDC region\n}\n\nexport interface CdkDiffStackWorkflowProps {\n  readonly project: any; // avoid exporting projen types in public API\n  readonly stacks: CdkDiffStack[];\n  readonly oidcRoleArn: string; // Required OIDC role ARN for all stacks (or each stack must have its own)\n  readonly oidcRegion: string; // Required OIDC region for all stacks (or each stack must have its own)\n  readonly nodeVersion?: string;\n  readonly cdkYarnCommand?: string;\n  readonly scriptOutputPath?: string;\n}\nexport class CdkDiffStackWorkflow {\n  private static scriptCreated = false;\n\n  constructor(props: CdkDiffStackWorkflowProps) {\n    const cdkYarnCommand = props.cdkYarnCommand ?? 'cdk';\n    const nodeVersion = props.nodeVersion ?? '24.x';\n    const scriptOutputPath = props.scriptOutputPath ?? '.github/workflows/scripts/describe-cfn-changeset.ts';\n\n    // Validate OIDC configuration\n    this.validateOidcConfiguration(props);\n\n    // Only create the changeset script once to avoid collisions\n    if (!CdkDiffStackWorkflow.scriptCreated) {\n      new CdkChangesetScript({\n        project: props.project,\n        outputPath: scriptOutputPath,\n      });\n      CdkDiffStackWorkflow.scriptCreated = true;\n    }\n\n    // Create a separate workflow for each stack\n    for (const stack of props.stacks) {\n      const workflowName = `diff-${stack.stackName}`;\n      const gh = (props as any).project.github ?? new GitHub((props as any).project);\n      const diffDeployWorkflow = new GithubWorkflow(gh, workflowName, { fileName: `${workflowName}.yml` });\n\n      this.createWorkflowForStack(diffDeployWorkflow, stack, cdkYarnCommand, nodeVersion, scriptOutputPath, props.oidcRoleArn, props.oidcRegion);\n    }\n  }\n\n  private validateOidcConfiguration(props: CdkDiffStackWorkflowProps): void {\n    const hasDefaultOidcRole = !!props.oidcRoleArn;\n    const hasDefaultOidcRegion = !!props.oidcRegion;\n\n    // Check if all stacks have their own OIDC configuration\n    const allStacksHaveOidcRole = props.stacks.every(stack => !!stack.oidcRoleArn);\n    const allStacksHaveOidcRegion = props.stacks.every(stack => !!stack.oidcRegion);\n\n    // Either defaults must be provided OR all stacks must have their own OIDC config\n    if (!hasDefaultOidcRole && !allStacksHaveOidcRole) {\n      throw new Error('Either provide default oidcRoleArn or specify oidcRoleArn for each stack');\n    }\n\n    if (!hasDefaultOidcRegion && !allStacksHaveOidcRegion) {\n      throw new Error('Either provide default oidcRegion or specify oidcRegion for each stack');\n    }\n  }\n\n  private createWorkflowForStack(\n    workflow: GithubWorkflow,\n    stack: CdkDiffStack,\n    cdkYarnCommand: string,\n    nodeVersion: string,\n    scriptOutputPath: string,\n    defaultOidcRoleArn: string,\n    defaultOidcRegion: string,\n  ) {\n    workflow.on({\n      pullRequest: {\n        types: ['opened', 'synchronize', 'reopened'],\n      },\n    });\n    workflow.addJobs({\n      diff: {\n        runsOn: ['ubuntu-latest'],\n        permissions: {\n          idToken: JobPermission.WRITE,\n          contents: JobPermission.READ,\n          issues: JobPermission.WRITE,\n          pullRequests: JobPermission.WRITE,\n          packages: JobPermission.READ,\n        },\n        env: {\n          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n        },\n        steps: [\n          {\n            uses: `actions/checkout@${githubActionsCheckoutVersion}`,\n          },\n          {\n            uses: `actions/setup-node@${githubActionsSetupNodeVersion}`,\n            with: {\n              'node-version': nodeVersion,\n              'registry-url': 'https://npm.pkg.github.com',\n              'scope': '@${{ github.repository_owner }}',\n              'token': '${{ secrets.GITHUB_TOKEN }}',\n            },\n          },\n          {\n            run: 'yarn install --frozen-lockfile',\n            env: {\n              NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n            },\n          },\n          {\n            uses: `aws-actions/configure-aws-credentials@${githubActionsAwsCredentialsVersion}`,\n            with: {\n              'role-to-assume': stack.oidcRoleArn ?? defaultOidcRoleArn,\n              'aws-region': stack.oidcRegion ?? defaultOidcRegion,\n            },\n          },\n          {\n            name: `Create Changeset for ${stack.stackName}`,\n            run: `yarn ${cdkYarnCommand} deploy ${stack.stackName} --no-execute --change-set-name ${stack.stackName} --require-approval never`,\n          },\n          {\n            id: 'creds',\n            uses: `aws-actions/configure-aws-credentials@${githubActionsAwsCredentialsVersion}`,\n            with: {\n              'role-to-assume': stack.oidcRoleArn ?? defaultOidcRoleArn,\n              'aws-region': stack.oidcRegion ?? defaultOidcRegion,\n            },\n          },\n          {\n            name: 'Assume CloudFormation Changeset Role',\n            id: 'changeset-role',\n            uses: `aws-actions/configure-aws-credentials@${githubActionsAwsCredentialsVersion}`,\n            with: {\n              'role-to-assume': stack.changesetRoleToAssumeArn,\n              'role-chaining': true,\n              'role-skip-session-tagging': true,\n              'aws-region': stack.changesetRoleToAssumeRegion,\n              'aws-access-key-id': '${{ steps.creds.outputs.aws-access-key-id }}',\n              'aws-secret-access-key': '${{ steps.creds.outputs.aws-secret-access-key }}',\n              'aws-session-token': '${{ steps.creds.outputs.aws-session-token }}',\n            },\n          },\n          {\n            name: `Describe change set for ${stack.stackName}`,\n            run: `npx ts-node ${scriptOutputPath}`,\n            env: {\n              STACK_NAME: stack.stackName,\n              CHANGE_SET_NAME: stack.stackName,\n              GITHUB_COMMENT_URL: '${{ github.event.pull_request.comments_url }}',\n              GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n            },\n          },\n          {\n            name: `Delete changeset for ${stack.stackName}`,\n            run: `aws cloudformation delete-change-set --change-set-name ${stack.stackName} --stack-name ${stack.stackName} --region ${stack.changesetRoleToAssumeRegion}`,\n          },\n        ],\n      },\n    });\n  }\n}\n"]}