@jjrawlins/cdk-diff-pr-github-action 1.3.12 → 1.4.0

package/lib/CdkDriftIamTemplate.js

@@ -79,7 +79,7 @@ class CdkDriftIamTemplateGenerator {
 }
 exports.CdkDriftIamTemplateGenerator = CdkDriftIamTemplateGenerator;
 _a = JSII_RTTI_SYMBOL_1;
-CdkDriftIamTemplateGenerator[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplateGenerator", version: "1.3.12" };
+CdkDriftIamTemplateGenerator[_a] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplateGenerator", version: "1.4.0" };
 /**
  * Projen construct that emits a CloudFormation template with minimal IAM permissions
  * for the CDK Drift Detection Workflow.
@@ -102,5 +102,5 @@ class CdkDriftIamTemplate {
 }
 exports.CdkDriftIamTemplate = CdkDriftIamTemplate;
 _b = JSII_RTTI_SYMBOL_1;
-CdkDriftIamTemplate[_b] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplate", version: "1.3.12" };
+CdkDriftIamTemplate[_b] = { fqn: "@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplate", version: "1.4.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDriftIamTemplate.js","sourceRoot":"","sources":["../src/CdkDriftIamTemplate.ts"],"names":[],"mappings":";;;;;AAAA,mCAAkC;AAclC;;;GAGG;AACH,MAAa,4BAA4B;IACvC;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAwC;QAC9D,MAAM,KAAK,GAAG;YACZ,wCAAwC;YACxC,0DAA0D;YAC1D,EAAE;YACF,aAAa;YACb,sBAAsB;YACtB,kBAAkB;YAClB,yFAAyF;YACzF,iBAAiB,KAAK,CAAC,WAAW,GAAG;YACrC,EAAE;YACF,YAAY;YACZ,8FAA8F;YAC9F,iBAAiB;YACjB,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,iDAAiD;YACjD,2BAA2B;YAC3B,mCAAmC;YACnC,wBAAwB;YACxB,2DAA2D;YAC3D,+BAA+B;YAC/B,yBAAyB;YACzB,qDAAqD;YACrD,sEAAsE;YACtE,gEAAgE;YAChE,mDAAmD;YACnD,uDAAuD;YACvD,6DAA6D;YAC7D,+BAA+B;YAC/B,EAAE;YACF,UAAU;YACV,oBAAoB;YACpB,wDAAwD;YACxD,qCAAqC;YACrC,aAAa;YACb,sDAAsD;YACtD,EAAE;YACF,qBAAqB;YACrB,yDAAyD;YACzD,8BAA8B;YAC9B,aAAa;YACb,uDAAuD;SACxD,CAAC;QAEF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,eAAuB,sCAAsC;QACxF,OAAO,6CAA6C,YAAY,+EAA+E,CAAC;IAClJ,CAAC;;AArEH,oEAsEC;;;AAYD;;;;;GAKG;AACH,MAAa,mBAAmB;IAC9B,YAAY,KAA+B;QACzC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,sCAAsC,CAAC;QAE9E,wCAAwC;QACxC,MAAM,QAAQ,GAAG,4BAA4B,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACtE,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,8BAA8B,EAAE;YACpD,WAAW,EACT,uIAAuI;YACzI,WAAW,EAAE,IAAI;YACjB,IAAI,EAAE,4BAA4B,CAAC,qBAAqB,CAAC,UAAU,CAAC;SACrE,CAAC,CAAC;IACL,CAAC;;AAfH,kDAgBC","sourcesContent":["import { TextFile } from 'projen';\n\n/**\n * Props for generating CDK Drift IAM templates (no Projen dependency)\n */\nexport interface CdkDriftIamTemplateGeneratorProps {\n  /** Name for the IAM role */\n  readonly roleName: string;\n  /** ARN of the existing GitHub OIDC role that can assume this drift 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 Drift IAM templates.\n * No Projen dependency - can be used in any project.\n */\nexport class CdkDriftIamTemplateGenerator {\n  /**\n   * Generate the CloudFormation IAM template as a YAML string.\n   */\n  static generateTemplate(props: CdkDriftIamTemplateGeneratorProps): string {\n    const lines = [\n      \"AWSTemplateFormatVersion: '2010-09-09'\",\n      \"Description: 'IAM role for CDK Drift Detection Workflow'\",\n      '',\n      'Parameters:',\n      '  GitHubOIDCRoleArn:',\n      '    Type: String',\n      \"    Description: 'ARN of the existing GitHub OIDC role that can assume this drift role'\",\n      `    Default: '${props.oidcRoleArn}'`,\n      '',\n      'Resources:',\n      '  # CloudFormation Drift Detection Role - minimal permissions for drift detection operations',\n      '  CdkDriftRole:',\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: 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      'Outputs:',\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    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-drift-workflow-iam-template.yaml'): string {\n    return `aws cloudformation deploy --template-file ${templatePath} --stack-name cdk-drift-workflow-iam-role --capabilities CAPABILITY_NAMED_IAM`;\n  }\n}\n\n/**\n * Props for the Projen-integrated CDK Drift IAM template construct\n */\nexport interface CdkDriftIamTemplateProps extends CdkDriftIamTemplateGeneratorProps {\n  /** Projen project instance */\n  readonly project: any;\n  /** Output path for the template file (default: 'cdk-drift-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 Drift Detection Workflow.\n *\n * For non-Projen projects, use `CdkDriftIamTemplateGenerator` directly.\n */\nexport class CdkDriftIamTemplate {\n  constructor(props: CdkDriftIamTemplateProps) {\n    const outputPath = props.outputPath ?? 'cdk-drift-workflow-iam-template.yaml';\n\n    // Generate template using the generator\n    const template = CdkDriftIamTemplateGenerator.generateTemplate(props);\n    new TextFile(props.project, outputPath, { lines: template.split('\\n') });\n\n    // Add deploy task\n    props.project.addTask('deploy-cdkdrift-iam-template', {\n      description:\n        'Deploy the CDK Drift Detection IAM template via CloudFormation (accepts extra AWS CLI args, e.g., --parameter-overrides Key=Value...)',\n      receiveArgs: true,\n      exec: CdkDriftIamTemplateGenerator.generateDeployCommand(outputPath),\n    });\n  }\n}\n"]}

package/lib/bin/cdk-changeset-script.js

@@ -8,7 +8,7 @@ class CdkChangesetScript {
         new projen_1.TextFile(props.project, outputPath, {
             lines: [
                 "import { appendFile } from 'fs/promises';",
-                "import { CloudFormationClient, DescribeChangeSetCommand } from '@aws-sdk/client-cloudformation';",
+                "import { CloudFormationClient, DescribeChangeSetCommand, DescribeStacksCommand, DescribeStackResourceDriftsCommand } from '@aws-sdk/client-cloudformation';",
                 '',
                 '/**',
                 ' * Small sleep helper.',
@@ -175,20 +175,81 @@ class CdkChangesetScript {
                 "  throw new Error('Timed out waiting for change set to reach a terminal status.');",
                 '}',
                 '',
-                'async function postGithubComment(url: string, token: string, body: string): Promise<void> {',
-                '  const res = await fetch(url, {',
-                "    method: 'POST',",
-                '    headers: {',
-                "      'Authorization': `token ${token}`,",
-                "      'Content-Type': 'application/json',",
-                "      'Accept': 'application/vnd.github+json',",
-                '    },',
-                '    body: JSON.stringify({ body }),',
-                '  });',
+                '/**',
+                ' * Parse the Link header from GitHub API responses for pagination.',
+                ' */',
+                'function parseLinkHeader(header: string | null): Record<string, string> {',
+                '  const links: Record<string, string> = {};',
+                '  if (!header) return links;',
+                "  for (const part of header.split(',')) {",
+                '    const match = part.match(/<([^>]+)>;\\s*rel="([^"]+)"/);',
+                '    if (match) links[match[2]] = match[1];',
+                '  }',
+                '  return links;',
+                '}',
+                '',
+                '/**',
+                ' * Search existing PR comments for one containing the given marker.',
+                ' * Returns the comment ID if found, null otherwise.',
+                ' */',
+                'async function findExistingComment(commentsUrl: string, token: string, marker: string): Promise<number | null> {',
+                '  let url: string | undefined = `${commentsUrl}?per_page=100`;',
+                '  while (url) {',
+                '    const res = await fetch(url, {',
+                '      headers: {',
+                "        'Authorization': `token ${token}`,",
+                "        'Accept': 'application/vnd.github+json',",
+                '      },',
+                '    });',
+                '    if (!res.ok) return null;',
+                '    const comments: any[] = await res.json();',
+                '    for (const c of comments) {',
+                "      if (typeof c.body === 'string' && c.body.includes(marker)) {",
+                '        return c.id;',
+                '      }',
+                '    }',
+                "    const links = parseLinkHeader(res.headers.get('link'));",
+                '    url = links.next;',
+                '  }',
+                '  return null;',
+                '}',
+                '',
+                '/**',
+                ' * Create or update a PR comment. Uses an HTML marker to find existing comments.',
+                ' * If found, PATCHes the existing comment; otherwise POSTs a new one.',
+                ' */',
+                'async function upsertGithubComment(commentsUrl: string, token: string, body: string, marker: string): Promise<void> {',
+                '  const markedBody = `${marker}\\n${body}`;',
+                '  const existingId = await findExistingComment(commentsUrl, token, marker);',
+                '',
+                '  let res: Response;',
+                '  if (existingId) {',
+                "    const baseUrl = commentsUrl.substring(0, commentsUrl.indexOf('/issues/'));",
+                '    const patchUrl = `${baseUrl}/issues/comments/${existingId}`;',
+                '    res = await fetch(patchUrl, {',
+                "      method: 'PATCH',",
+                '      headers: {',
+                "        'Authorization': `token ${token}`,",
+                "        'Content-Type': 'application/json',",
+                "        'Accept': 'application/vnd.github+json',",
+                '      },',
+                '      body: JSON.stringify({ body: markedBody }),',
+                '    });',
+                '  } else {',
+                '    res = await fetch(commentsUrl, {',
+                "      method: 'POST',",
+                '      headers: {',
+                "        'Authorization': `token ${token}`,",
+                "        'Content-Type': 'application/json',",
+                "        'Accept': 'application/vnd.github+json',",
+                '      },',
+                '      body: JSON.stringify({ body: markedBody }),',
+                '    });',
+                '  }',
                 '',
                 '  if (!res.ok) {',
                 "    const text = await res.text().catch(() => '');",
-                '    throw new Error(`Failed to post GitHub comment: ${res.status} ${res.statusText} ${text}`);',
+                "    throw new Error(`Failed to ${existingId ? 'update' : 'post'} GitHub comment: ${res.status} ${res.statusText} ${text}`);",
                 '  }',
                 '}',
                 '',
@@ -196,6 +257,69 @@ class CdkChangesetScript {
                 "  await appendFile(summaryPath, `${content}\\n`, { encoding: 'utf8' });",
                 '}',
                 '',
+                '/**',
+                ' * Check cached drift status for the stack and return an HTML banner.',
+                ' * Non-fatal: returns empty string on any error.',
+                ' */',
+                'async function getDriftBannerHtml(client: CloudFormationClient, stackName: string): Promise<string> {',
+                '  const stackResp = await client.send(new DescribeStacksCommand({ StackName: stackName }));',
+                '  const stack = stackResp.Stacks?.[0];',
+                "  if (!stack) return '';",
+                '',
+                '  const driftInfo = stack.DriftInformation;',
+                '  const driftStatus = driftInfo?.StackDriftStatus;',
+                '  const lastChecked = driftInfo?.LastCheckTimestamp;',
+                '',
+                "  if (driftStatus === 'IN_SYNC') return '';",
+                '',
+                "  if (driftStatus === 'NOT_CHECKED') {",
+                "    return '<blockquote><p>ℹ️ Drift detection has not been run for this stack.</p></blockquote>';",
+                '  }',
+                '',
+                "  if (driftStatus === 'DETECTION_IN_PROGRESS') {",
+                "    return '<blockquote><p>⏳ Drift detection is currently in progress.</p></blockquote>';",
+                '  }',
+                '',
+                "  if (driftStatus === 'DRIFTED') {",
+                "    let banner = '<blockquote>';",
+                '',
+                '    try {',
+                '      const driftsResp = await client.send(new DescribeStackResourceDriftsCommand({',
+                '        StackName: stackName,',
+                "        StackResourceDriftStatusFilters: ['MODIFIED', 'DELETED'],",
+                '      }));',
+                '      const drifts = driftsResp.StackResourceDrifts ?? [];',
+                '      const count = drifts.length;',
+                "      const ts = lastChecked ? lastChecked.toISOString() : 'unknown';",
+                '',
+                "      banner += `<h3>⚠️ Stack has drifted (${count} resource${count !== 1 ? 's' : ''} out of sync)</h3>`;",
+                '      banner += `<p>Last drift check: <em>${ts}</em></p>`;',
+                '',
+                '      if (count > 0) {',
+                "        banner += '<details><summary>View drifted resources</summary>';",
+                "        banner += '<table><tr><th>Resource</th><th>Type</th><th>Drift Status</th></tr>';",
+                '        for (const d of drifts) {',
+                "          const logicalId = d.LogicalResourceId ?? '-';",
+                "          const resourceType = d.ResourceType ?? '-';",
+                "          const status = d.StackResourceDriftStatus ?? '-';",
+                '          banner += `<tr><td>${logicalId}</td><td>${resourceType}</td><td>${status}</td></tr>`;',
+                '        }',
+                "        banner += '</table></details>';",
+                '      }',
+                '    } catch (e: any) {',
+                "      const ts = lastChecked ? lastChecked.toISOString() : 'unknown';",
+                "      banner += '<h3>⚠️ Stack has drifted</h3>';",
+                '      banner += `<p>Last drift check: <em>${ts}</em></p>`;',
+                "      banner += `<p><em>Could not retrieve drift details: ${e?.message ?? 'unknown error'}</em></p>`;",
+                '    }',
+                '',
+                "    banner += '</blockquote>';",
+                '    return banner;',
+                '  }',
+                '',
+                "  return '';",
+                '}',
+                '',
                 'async function main() {',
                 '  const {',
                 '    STACK_NAME,',
@@ -217,6 +341,7 @@ class CdkChangesetScript {
                 '  }',
                 '',
                 '  const changeSetName = CHANGE_SET_NAME || STACK_NAME;',
+                '  const marker = `<!-- cdk-diff:stack:${STACK_NAME} -->`;',
                 '',
                 '  const client = new CloudFormationClient({ region });',
                 '',
@@ -254,27 +379,35 @@ class CdkChangesetScript {
                 '  // Build HTML exactly like pretty_format.py logic (table when there are changes; "no change." otherwise).',
                 '  const html = buildHtml(STACK_NAME, filteredChanges);',
                 '',
+                '  // Check cached drift status (non-fatal)',
+                "  let driftBanner = '';",
+                '  try {',
+                '    driftBanner = await getDriftBannerHtml(client, STACK_NAME);',
+                '  } catch (e: any) {',
+                "    console.error('Drift check failed:', e?.message || e);",
+                '  }',
+                '  const fullHtml = driftBanner + html;',
+                '',
                 '  // Print to stdout',
-                '  // This allows capturing output or redirecting to a file if needed.',
-                '  console.log(html);',
+                '  console.log(fullHtml);',
                 '',
                 '  // Optionally append to GitHub Step Summary',
                 '  if (GITHUB_STEP_SUMMARY) {',
                 '    try {',
-                '      await appendStepSummary(GITHUB_STEP_SUMMARY, html);',
+                '      await appendStepSummary(GITHUB_STEP_SUMMARY, fullHtml);',
                 '      console.error(`Appended HTML to GITHUB_STEP_SUMMARY: ${GITHUB_STEP_SUMMARY}`);',
                 '    } catch (e: any) {',
                 "      console.error('Failed to append to GITHUB_STEP_SUMMARY:', e?.message || e);",
                 '    }',
                 '  }',
                 '',
-                '  // Optionally post a PR comment',
+                '  // Upsert PR comment (find existing by marker, update or create)',
                 '  if (GITHUB_TOKEN && GITHUB_COMMENT_URL) {',
                 '    try {',
-                '      await postGithubComment(GITHUB_COMMENT_URL, GITHUB_TOKEN, html);',
-                "      console.error('Posted HTML as a GitHub PR comment.');",
+                '      await upsertGithubComment(GITHUB_COMMENT_URL, GITHUB_TOKEN, fullHtml, marker);',
+                "      console.error('Upserted GitHub PR comment.');",
                 '    } catch (e: any) {',
-                "      console.error('Failed to post GitHub PR comment:', e?.message || e);",
+                "      console.error('Failed to upsert GitHub PR comment:', e?.message || e);",
                 '      // Do not fail the whole script just for comment posting',
                 '    }',
                 '  }',
@@ -294,4 +427,4 @@ class CdkChangesetScript {
     }
 }
 exports.CdkChangesetScript = CdkChangesetScript;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-changeset-script.js","sourceRoot":"","sources":["../../src/bin/cdk-changeset-script.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile } from 'projen';\nimport { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\n\ninterface CdkChangesetScriptProps {\n  project: AwsCdkTypeScriptApp;\n  outputPath?: string;\n}\n\nexport class CdkChangesetScript {\n  constructor(props: CdkChangesetScriptProps) {\n    const outputPath = props.outputPath ?? 'projenrc/describe-cfn-changeset.ts';\n\n    new TextFile(props.project, outputPath, {\n      lines: [\n        \"import { appendFile } from 'fs/promises';\",\n        \"import { CloudFormationClient, DescribeChangeSetCommand } from '@aws-sdk/client-cloudformation';\",\n        '',\n        '/**',\n        ' * Small sleep helper.',\n        ' */',\n        'const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));',\n        '',\n        '/**',\n        ' * Build the HTML color chip for an action.',\n        ' * Modify=blue, Add=green, Remove=red (match pretty_format.py).',\n        ' */',\n        'function actionChip(action?: string): string {',\n        '  // Use emoji instead of external images for reliability',\n        '  const emojiMap: Record<string, string> = {',\n        \"    Modify: '🔵',\",\n        \"    Add: '🟢',\",\n        \"    Remove: '🔴',\",\n        '  };',\n        \"  const mark = action ? (emojiMap[action] ?? '⚪') : '⚪';\",\n        \"  return `${mark} ${action ?? '-'}`;\",\n        '}',\n        '',\n        '/**',\n        ' * Escape HTML special characters.',\n        ' */',\n        'function escapeHtml(str: string): string {',\n        \"  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\",\n        '}',\n        '',\n        '/**',\n        ' * Format a before→after change.',\n        ' */',\n        'function formatChange(name: string, changeType: string | undefined, before: string | undefined, after: string | undefined): string {',\n        \"  const changeEmoji = changeType === 'Add' ? '🟢' : changeType === 'Remove' ? '🔴' : '🔵';\",\n        '  ',\n        '  // If both values exist and are large, use a more compact format',\n        '  const beforeLen = before?.length ?? 0;',\n        '  const afterLen = after?.length ?? 0;',\n        '  const isLarge = beforeLen > 80 || afterLen > 80;',\n        '  ',\n        '  if (before && after) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (modified)</summary><strong>Before:</strong><pre>${escapeHtml(before)}</pre><strong>After:</strong><pre>${escapeHtml(after)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <code>${escapeHtml(before)}</code> → <code>${escapeHtml(after)}</code>`;',\n        '  } else if (after) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (added)</summary><pre>${escapeHtml(after)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <code>${escapeHtml(after)}</code>`;',\n        '  } else if (before) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (removed)</summary><pre>${escapeHtml(before)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <s><code>${escapeHtml(before)}</code></s>`;',\n        '  }',\n        '  // Fallback: no values available (API did not return them)',\n        '  return `${changeEmoji} <strong>${escapeHtml(name)}</strong>`;',\n        '}',\n        '',\n        '/**',\n        ' * Extract changed properties/tags/attributes with before/after values.',\n        ' */',\n        'function changedPropertiesHTML(change: any): string {',\n        '  const details = change?.ResourceChange?.Details ?? [];',\n        '  const props: string[] = [];',\n        '  for (const d of details) {',\n        '    const attr = d?.Target?.Attribute;',\n        '    // Use property name if available, otherwise use attribute type',\n        \"    const name = d?.Target?.Name ?? attr ?? 'unknown';\",\n        '    const changeType = d?.Target?.AttributeChangeType;',\n        '    const before = d?.Target?.BeforeValue;',\n        '    const after = d?.Target?.AfterValue;',\n        '    props.push(formatChange(name, changeType, before, after));',\n        '  }',\n        \"  return props.join('<br>');\",\n        '}',\n        '',\n        '/**',\n        ' * Determine if a change should be ignored based on logical IDs and/or resource types.',\n        \" * - IGNORE_LOGICAL_IDS: comma-separated list of logical IDs to ignore (default includes 'CDKMetadata')\",\n        \" * - IGNORE_RESOURCE_TYPES: comma-separated list of resource types to ignore (e.g., 'AWS::CDK::Metadata')\",\n        ' */',\n        'function shouldIgnoreChange(change: any, ignoreIds: Set<string>, ignoreTypes: Set<string>): boolean {',\n        '  const rc = change?.ResourceChange ?? {};',\n        '  const logicalId = rc?.LogicalResourceId as string | undefined;',\n        '  const resourceType = rc?.ResourceType as string | undefined;',\n        '  if (logicalId && ignoreIds.has(logicalId)) return true;',\n        '  if (resourceType && ignoreTypes.has(resourceType)) return true;',\n        '  return false;',\n        '}',\n        '',\n        '/**',\n        ' * Generate the HTML body similar to pretty_format.py',\n        ' */',\n        'function buildHtml(stackName: string, changes: any[]): string {',\n        '  let body = `<h1>Change set</h1><h2>Stack Name: ${stackName}</h2><br>`;',\n        '  if ((changes?.length ?? 0) > 0) {',\n        \"    body += '<table><tr><th>Action&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</th><th>ID</th><th>Type</th><th>Replacement</th><th>Details</th></tr>';\",\n        '    for (const c of changes) {',\n        '      const rc = c?.ResourceChange ?? {};',\n        '      const action = actionChip(rc?.Action);',\n        \"      const logicalId = rc?.LogicalResourceId ?? '-';\",\n        \"      const type = rc?.ResourceType ?? '-';\",\n        \"      const replacement = rc?.Replacement ?? '-';\",\n        '      const details = changedPropertiesHTML(c);',\n        '',\n        \"      body += '<tr>';\",\n        '      body += `<td>${action}</td>`;',\n        '      body += `<td>${logicalId}</td>`;',\n        '      body += `<td>${type}</td>`;',\n        '      body += `<td>${replacement}</td>`;',\n        '      body += `<td>${details}</td>`;',\n        \"      body += '</tr>';\",\n        '    }',\n        \"    body += '</table>';\",\n        '  } else {',\n        \"    body += 'no change.';\",\n        '  }',\n        '  return body;',\n        '}',\n        '',\n        '/**',\n        ' * Poll DescribeChangeSet until a terminal status, then paginate to retrieve all Changes.',\n        ' */',\n        'async function getTerminalChangeSet(',\n        '  client: CloudFormationClient,',\n        '  stackName: string,',\n        '  changeSetName: string,',\n        '  maxAttempts = 60,',\n        '  delayMs = 3000,',\n        '): Promise<{ status?: string; statusReason?: string; changes: any[] }> {',\n        '  for (let attempt = 1; attempt <= maxAttempts; attempt++) {',\n        '    const resp = await client.send(new DescribeChangeSetCommand({',\n        '      StackName: stackName,',\n        '      ChangeSetName: changeSetName,',\n        '      IncludePropertyValues: true,',\n        '    }));',\n        '',\n        '    const status = resp.Status;',\n        '    const statusReason = resp.StatusReason;',\n        '',\n        \"    if (status === 'CREATE_COMPLETE' || status === 'FAILED') {\",\n        '      // Gather all pages',\n        '      const changes: any[] = [];',\n        '      if (resp.Changes) changes.push(...resp.Changes);',\n        '      let next = resp.NextToken;',\n        '      while (next) {',\n        '        const page = await client.send(new DescribeChangeSetCommand({',\n        '          StackName: stackName,',\n        '          ChangeSetName: changeSetName,',\n        '          IncludePropertyValues: true,',\n        '          NextToken: next,',\n        '        }));',\n        '        if (page.Changes) changes.push(...page.Changes);',\n        '        next = page.NextToken;',\n        '      }',\n        '      return { status, statusReason, changes };',\n        '    }',\n        '',\n        '    // Not terminal yet; wait and retry',\n        '    await sleep(delayMs);',\n        '  }',\n        '',\n        \"  throw new Error('Timed out waiting for change set to reach a terminal status.');\",\n        '}',\n        '',\n        'async function postGithubComment(url: string, token: string, body: string): Promise<void> {',\n        '  const res = await fetch(url, {',\n        \"    method: 'POST',\",\n        '    headers: {',\n        \"      'Authorization': `token ${token}`,\",\n        \"      'Content-Type': 'application/json',\",\n        \"      'Accept': 'application/vnd.github+json',\",\n        '    },',\n        '    body: JSON.stringify({ body }),',\n        '  });',\n        '',\n        '  if (!res.ok) {',\n        \"    const text = await res.text().catch(() => '');\",\n        '    throw new Error(`Failed to post GitHub comment: ${res.status} ${res.statusText} ${text}`);',\n        '  }',\n        '}',\n        '',\n        'async function appendStepSummary(summaryPath: string, content: string): Promise<void> {',\n        \"  await appendFile(summaryPath, `${content}\\\\n`, { encoding: 'utf8' });\",\n        '}',\n        '',\n        'async function main() {',\n        '  const {',\n        '    STACK_NAME,',\n        '    CHANGE_SET_NAME,',\n        '    AWS_REGION,',\n        '    GITHUB_TOKEN,',\n        '    GITHUB_COMMENT_URL,',\n        '    GITHUB_STEP_SUMMARY,',\n        '    IGNORE_LOGICAL_IDS,',\n        '    IGNORE_RESOURCE_TYPES,',\n        '  } = process.env;',\n        '',\n        '  if (!STACK_NAME) {',\n        \"    throw new Error('STACK_NAME is required');\",\n        '  }',\n        '  const region = AWS_REGION || process.env.AWS_DEFAULT_REGION;',\n        '  if (!region) {',\n        \"    throw new Error('AWS_REGION is required');\",\n        '  }',\n        '',\n        '  const changeSetName = CHANGE_SET_NAME || STACK_NAME;',\n        '',\n        '  const client = new CloudFormationClient({ region });',\n        '',\n        '  let status: string | undefined;',\n        '  let statusReason: string | undefined;',\n        '  let changes: any[] = [];',\n        '',\n        '  try {',\n        '    const result = await getTerminalChangeSet(client, STACK_NAME, changeSetName);',\n        '    status = result.status;',\n        '    statusReason = result.statusReason;',\n        '    changes = result.changes ?? [];',\n        '  } catch (err: any) {',\n        '    // If DescribeChangeSet fails entirely, surface the error',\n        \"    console.error('Error describing change set:', err?.message || err);\",\n        '    process.exitCode = 1;',\n        '    return;',\n        '  }',\n        '',\n        \"  // Apply ignores from env vars (IDs and types). Default ignore IDs include 'CDKMetadata'.\",\n        '  const ignoreIdSet = new Set(',\n        \"    (IGNORE_LOGICAL_IDS ?? 'CDKMetadata')\",\n        \"      .split(',')\",\n        '      .map(s => s.trim())',\n        '      .filter(Boolean),',\n        '  );',\n        '  const ignoreTypeSet = new Set(',\n        \"    (IGNORE_RESOURCE_TYPES ?? '')\",\n        \"      .split(',')\",\n        '      .map(s => s.trim())',\n        '      .filter(Boolean),',\n        '  );',\n        '  const filteredChanges = changes.filter(c => !shouldIgnoreChange(c, ignoreIdSet, ignoreTypeSet));',\n        '',\n        '  // Build HTML exactly like pretty_format.py logic (table when there are changes; \"no change.\" otherwise).',\n        '  const html = buildHtml(STACK_NAME, filteredChanges);',\n        '',\n        '  // Print to stdout',\n        '  // This allows capturing output or redirecting to a file if needed.',\n        '  console.log(html);',\n        '',\n        '  // Optionally append to GitHub Step Summary',\n        '  if (GITHUB_STEP_SUMMARY) {',\n        '    try {',\n        '      await appendStepSummary(GITHUB_STEP_SUMMARY, html);',\n        '      console.error(`Appended HTML to GITHUB_STEP_SUMMARY: ${GITHUB_STEP_SUMMARY}`);',\n        '    } catch (e: any) {',\n        \"      console.error('Failed to append to GITHUB_STEP_SUMMARY:', e?.message || e);\",\n        '    }',\n        '  }',\n        '',\n        '  // Optionally post a PR comment',\n        '  if (GITHUB_TOKEN && GITHUB_COMMENT_URL) {',\n        '    try {',\n        '      await postGithubComment(GITHUB_COMMENT_URL, GITHUB_TOKEN, html);',\n        \"      console.error('Posted HTML as a GitHub PR comment.');\",\n        '    } catch (e: any) {',\n        \"      console.error('Failed to post GitHub PR comment:', e?.message || e);\",\n        '      // Do not fail the whole script just for comment posting',\n        '    }',\n        '  }',\n        '',\n        \"  // Note: When status is FAILED due to \\\"didn't contain changes\\\", the HTML naturally says \\\"no change.\\\"\",\n        \"  if (status === 'FAILED' && statusReason) {\",\n        '    console.error(`Change set status: FAILED. Reason: ${statusReason}`);',\n        '  }',\n        '}',\n        '',\n        'main().catch((err) => {',\n        '  console.error(err);',\n        '  process.exitCode = 1;',\n        '});',\n      ],\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-changeset-script.js","sourceRoot":"","sources":["../../src/bin/cdk-changeset-script.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile } from 'projen';\nimport { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\n\ninterface CdkChangesetScriptProps {\n  project: AwsCdkTypeScriptApp;\n  outputPath?: string;\n}\n\nexport class CdkChangesetScript {\n  constructor(props: CdkChangesetScriptProps) {\n    const outputPath = props.outputPath ?? 'projenrc/describe-cfn-changeset.ts';\n\n    new TextFile(props.project, outputPath, {\n      lines: [\n        \"import { appendFile } from 'fs/promises';\",\n        \"import { CloudFormationClient, DescribeChangeSetCommand, DescribeStacksCommand, DescribeStackResourceDriftsCommand } from '@aws-sdk/client-cloudformation';\",\n        '',\n        '/**',\n        ' * Small sleep helper.',\n        ' */',\n        'const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));',\n        '',\n        '/**',\n        ' * Build the HTML color chip for an action.',\n        ' * Modify=blue, Add=green, Remove=red (match pretty_format.py).',\n        ' */',\n        'function actionChip(action?: string): string {',\n        '  // Use emoji instead of external images for reliability',\n        '  const emojiMap: Record<string, string> = {',\n        \"    Modify: '🔵',\",\n        \"    Add: '🟢',\",\n        \"    Remove: '🔴',\",\n        '  };',\n        \"  const mark = action ? (emojiMap[action] ?? '⚪') : '⚪';\",\n        \"  return `${mark} ${action ?? '-'}`;\",\n        '}',\n        '',\n        '/**',\n        ' * Escape HTML special characters.',\n        ' */',\n        'function escapeHtml(str: string): string {',\n        \"  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\",\n        '}',\n        '',\n        '/**',\n        ' * Format a before→after change.',\n        ' */',\n        'function formatChange(name: string, changeType: string | undefined, before: string | undefined, after: string | undefined): string {',\n        \"  const changeEmoji = changeType === 'Add' ? '🟢' : changeType === 'Remove' ? '🔴' : '🔵';\",\n        '  ',\n        '  // If both values exist and are large, use a more compact format',\n        '  const beforeLen = before?.length ?? 0;',\n        '  const afterLen = after?.length ?? 0;',\n        '  const isLarge = beforeLen > 80 || afterLen > 80;',\n        '  ',\n        '  if (before && after) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (modified)</summary><strong>Before:</strong><pre>${escapeHtml(before)}</pre><strong>After:</strong><pre>${escapeHtml(after)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <code>${escapeHtml(before)}</code> → <code>${escapeHtml(after)}</code>`;',\n        '  } else if (after) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (added)</summary><pre>${escapeHtml(after)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <code>${escapeHtml(after)}</code>`;',\n        '  } else if (before) {',\n        '    if (isLarge) {',\n        '      return `<details><summary>${changeEmoji} <strong>${escapeHtml(name)}</strong> (removed)</summary><pre>${escapeHtml(before)}</pre></details>`;',\n        '    }',\n        '    return `${changeEmoji} <strong>${escapeHtml(name)}</strong>: <s><code>${escapeHtml(before)}</code></s>`;',\n        '  }',\n        '  // Fallback: no values available (API did not return them)',\n        '  return `${changeEmoji} <strong>${escapeHtml(name)}</strong>`;',\n        '}',\n        '',\n        '/**',\n        ' * Extract changed properties/tags/attributes with before/after values.',\n        ' */',\n        'function changedPropertiesHTML(change: any): string {',\n        '  const details = change?.ResourceChange?.Details ?? [];',\n        '  const props: string[] = [];',\n        '  for (const d of details) {',\n        '    const attr = d?.Target?.Attribute;',\n        '    // Use property name if available, otherwise use attribute type',\n        \"    const name = d?.Target?.Name ?? attr ?? 'unknown';\",\n        '    const changeType = d?.Target?.AttributeChangeType;',\n        '    const before = d?.Target?.BeforeValue;',\n        '    const after = d?.Target?.AfterValue;',\n        '    props.push(formatChange(name, changeType, before, after));',\n        '  }',\n        \"  return props.join('<br>');\",\n        '}',\n        '',\n        '/**',\n        ' * Determine if a change should be ignored based on logical IDs and/or resource types.',\n        \" * - IGNORE_LOGICAL_IDS: comma-separated list of logical IDs to ignore (default includes 'CDKMetadata')\",\n        \" * - IGNORE_RESOURCE_TYPES: comma-separated list of resource types to ignore (e.g., 'AWS::CDK::Metadata')\",\n        ' */',\n        'function shouldIgnoreChange(change: any, ignoreIds: Set<string>, ignoreTypes: Set<string>): boolean {',\n        '  const rc = change?.ResourceChange ?? {};',\n        '  const logicalId = rc?.LogicalResourceId as string | undefined;',\n        '  const resourceType = rc?.ResourceType as string | undefined;',\n        '  if (logicalId && ignoreIds.has(logicalId)) return true;',\n        '  if (resourceType && ignoreTypes.has(resourceType)) return true;',\n        '  return false;',\n        '}',\n        '',\n        '/**',\n        ' * Generate the HTML body similar to pretty_format.py',\n        ' */',\n        'function buildHtml(stackName: string, changes: any[]): string {',\n        '  let body = `<h1>Change set</h1><h2>Stack Name: ${stackName}</h2><br>`;',\n        '  if ((changes?.length ?? 0) > 0) {',\n        \"    body += '<table><tr><th>Action&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</th><th>ID</th><th>Type</th><th>Replacement</th><th>Details</th></tr>';\",\n        '    for (const c of changes) {',\n        '      const rc = c?.ResourceChange ?? {};',\n        '      const action = actionChip(rc?.Action);',\n        \"      const logicalId = rc?.LogicalResourceId ?? '-';\",\n        \"      const type = rc?.ResourceType ?? '-';\",\n        \"      const replacement = rc?.Replacement ?? '-';\",\n        '      const details = changedPropertiesHTML(c);',\n        '',\n        \"      body += '<tr>';\",\n        '      body += `<td>${action}</td>`;',\n        '      body += `<td>${logicalId}</td>`;',\n        '      body += `<td>${type}</td>`;',\n        '      body += `<td>${replacement}</td>`;',\n        '      body += `<td>${details}</td>`;',\n        \"      body += '</tr>';\",\n        '    }',\n        \"    body += '</table>';\",\n        '  } else {',\n        \"    body += 'no change.';\",\n        '  }',\n        '  return body;',\n        '}',\n        '',\n        '/**',\n        ' * Poll DescribeChangeSet until a terminal status, then paginate to retrieve all Changes.',\n        ' */',\n        'async function getTerminalChangeSet(',\n        '  client: CloudFormationClient,',\n        '  stackName: string,',\n        '  changeSetName: string,',\n        '  maxAttempts = 60,',\n        '  delayMs = 3000,',\n        '): Promise<{ status?: string; statusReason?: string; changes: any[] }> {',\n        '  for (let attempt = 1; attempt <= maxAttempts; attempt++) {',\n        '    const resp = await client.send(new DescribeChangeSetCommand({',\n        '      StackName: stackName,',\n        '      ChangeSetName: changeSetName,',\n        '      IncludePropertyValues: true,',\n        '    }));',\n        '',\n        '    const status = resp.Status;',\n        '    const statusReason = resp.StatusReason;',\n        '',\n        \"    if (status === 'CREATE_COMPLETE' || status === 'FAILED') {\",\n        '      // Gather all pages',\n        '      const changes: any[] = [];',\n        '      if (resp.Changes) changes.push(...resp.Changes);',\n        '      let next = resp.NextToken;',\n        '      while (next) {',\n        '        const page = await client.send(new DescribeChangeSetCommand({',\n        '          StackName: stackName,',\n        '          ChangeSetName: changeSetName,',\n        '          IncludePropertyValues: true,',\n        '          NextToken: next,',\n        '        }));',\n        '        if (page.Changes) changes.push(...page.Changes);',\n        '        next = page.NextToken;',\n        '      }',\n        '      return { status, statusReason, changes };',\n        '    }',\n        '',\n        '    // Not terminal yet; wait and retry',\n        '    await sleep(delayMs);',\n        '  }',\n        '',\n        \"  throw new Error('Timed out waiting for change set to reach a terminal status.');\",\n        '}',\n        '',\n        '/**',\n        ' * Parse the Link header from GitHub API responses for pagination.',\n        ' */',\n        'function parseLinkHeader(header: string | null): Record<string, string> {',\n        '  const links: Record<string, string> = {};',\n        '  if (!header) return links;',\n        \"  for (const part of header.split(',')) {\",\n        '    const match = part.match(/<([^>]+)>;\\\\s*rel=\"([^\"]+)\"/);',\n        '    if (match) links[match[2]] = match[1];',\n        '  }',\n        '  return links;',\n        '}',\n        '',\n        '/**',\n        ' * Search existing PR comments for one containing the given marker.',\n        ' * Returns the comment ID if found, null otherwise.',\n        ' */',\n        'async function findExistingComment(commentsUrl: string, token: string, marker: string): Promise<number | null> {',\n        '  let url: string | undefined = `${commentsUrl}?per_page=100`;',\n        '  while (url) {',\n        '    const res = await fetch(url, {',\n        '      headers: {',\n        \"        'Authorization': `token ${token}`,\",\n        \"        'Accept': 'application/vnd.github+json',\",\n        '      },',\n        '    });',\n        '    if (!res.ok) return null;',\n        '    const comments: any[] = await res.json();',\n        '    for (const c of comments) {',\n        \"      if (typeof c.body === 'string' && c.body.includes(marker)) {\",\n        '        return c.id;',\n        '      }',\n        '    }',\n        \"    const links = parseLinkHeader(res.headers.get('link'));\",\n        '    url = links.next;',\n        '  }',\n        '  return null;',\n        '}',\n        '',\n        '/**',\n        ' * Create or update a PR comment. Uses an HTML marker to find existing comments.',\n        ' * If found, PATCHes the existing comment; otherwise POSTs a new one.',\n        ' */',\n        'async function upsertGithubComment(commentsUrl: string, token: string, body: string, marker: string): Promise<void> {',\n        '  const markedBody = `${marker}\\\\n${body}`;',\n        '  const existingId = await findExistingComment(commentsUrl, token, marker);',\n        '',\n        '  let res: Response;',\n        '  if (existingId) {',\n        \"    const baseUrl = commentsUrl.substring(0, commentsUrl.indexOf('/issues/'));\",\n        '    const patchUrl = `${baseUrl}/issues/comments/${existingId}`;',\n        '    res = await fetch(patchUrl, {',\n        \"      method: 'PATCH',\",\n        '      headers: {',\n        \"        'Authorization': `token ${token}`,\",\n        \"        'Content-Type': 'application/json',\",\n        \"        'Accept': 'application/vnd.github+json',\",\n        '      },',\n        '      body: JSON.stringify({ body: markedBody }),',\n        '    });',\n        '  } else {',\n        '    res = await fetch(commentsUrl, {',\n        \"      method: 'POST',\",\n        '      headers: {',\n        \"        'Authorization': `token ${token}`,\",\n        \"        'Content-Type': 'application/json',\",\n        \"        'Accept': 'application/vnd.github+json',\",\n        '      },',\n        '      body: JSON.stringify({ body: markedBody }),',\n        '    });',\n        '  }',\n        '',\n        '  if (!res.ok) {',\n        \"    const text = await res.text().catch(() => '');\",\n        \"    throw new Error(`Failed to ${existingId ? 'update' : 'post'} GitHub comment: ${res.status} ${res.statusText} ${text}`);\",\n        '  }',\n        '}',\n        '',\n        'async function appendStepSummary(summaryPath: string, content: string): Promise<void> {',\n        \"  await appendFile(summaryPath, `${content}\\\\n`, { encoding: 'utf8' });\",\n        '}',\n        '',\n        '/**',\n        ' * Check cached drift status for the stack and return an HTML banner.',\n        ' * Non-fatal: returns empty string on any error.',\n        ' */',\n        'async function getDriftBannerHtml(client: CloudFormationClient, stackName: string): Promise<string> {',\n        '  const stackResp = await client.send(new DescribeStacksCommand({ StackName: stackName }));',\n        '  const stack = stackResp.Stacks?.[0];',\n        \"  if (!stack) return '';\",\n        '',\n        '  const driftInfo = stack.DriftInformation;',\n        '  const driftStatus = driftInfo?.StackDriftStatus;',\n        '  const lastChecked = driftInfo?.LastCheckTimestamp;',\n        '',\n        \"  if (driftStatus === 'IN_SYNC') return '';\",\n        '',\n        \"  if (driftStatus === 'NOT_CHECKED') {\",\n        \"    return '<blockquote><p>ℹ️ Drift detection has not been run for this stack.</p></blockquote>';\",\n        '  }',\n        '',\n        \"  if (driftStatus === 'DETECTION_IN_PROGRESS') {\",\n        \"    return '<blockquote><p>⏳ Drift detection is currently in progress.</p></blockquote>';\",\n        '  }',\n        '',\n        \"  if (driftStatus === 'DRIFTED') {\",\n        \"    let banner = '<blockquote>';\",\n        '',\n        '    try {',\n        '      const driftsResp = await client.send(new DescribeStackResourceDriftsCommand({',\n        '        StackName: stackName,',\n        \"        StackResourceDriftStatusFilters: ['MODIFIED', 'DELETED'],\",\n        '      }));',\n        '      const drifts = driftsResp.StackResourceDrifts ?? [];',\n        '      const count = drifts.length;',\n        \"      const ts = lastChecked ? lastChecked.toISOString() : 'unknown';\",\n        '',\n        \"      banner += `<h3>⚠️ Stack has drifted (${count} resource${count !== 1 ? 's' : ''} out of sync)</h3>`;\",\n        '      banner += `<p>Last drift check: <em>${ts}</em></p>`;',\n        '',\n        '      if (count > 0) {',\n        \"        banner += '<details><summary>View drifted resources</summary>';\",\n        \"        banner += '<table><tr><th>Resource</th><th>Type</th><th>Drift Status</th></tr>';\",\n        '        for (const d of drifts) {',\n        \"          const logicalId = d.LogicalResourceId ?? '-';\",\n        \"          const resourceType = d.ResourceType ?? '-';\",\n        \"          const status = d.StackResourceDriftStatus ?? '-';\",\n        '          banner += `<tr><td>${logicalId}</td><td>${resourceType}</td><td>${status}</td></tr>`;',\n        '        }',\n        \"        banner += '</table></details>';\",\n        '      }',\n        '    } catch (e: any) {',\n        \"      const ts = lastChecked ? lastChecked.toISOString() : 'unknown';\",\n        \"      banner += '<h3>⚠️ Stack has drifted</h3>';\",\n        '      banner += `<p>Last drift check: <em>${ts}</em></p>`;',\n        \"      banner += `<p><em>Could not retrieve drift details: ${e?.message ?? 'unknown error'}</em></p>`;\",\n        '    }',\n        '',\n        \"    banner += '</blockquote>';\",\n        '    return banner;',\n        '  }',\n        '',\n        \"  return '';\",\n        '}',\n        '',\n        'async function main() {',\n        '  const {',\n        '    STACK_NAME,',\n        '    CHANGE_SET_NAME,',\n        '    AWS_REGION,',\n        '    GITHUB_TOKEN,',\n        '    GITHUB_COMMENT_URL,',\n        '    GITHUB_STEP_SUMMARY,',\n        '    IGNORE_LOGICAL_IDS,',\n        '    IGNORE_RESOURCE_TYPES,',\n        '  } = process.env;',\n        '',\n        '  if (!STACK_NAME) {',\n        \"    throw new Error('STACK_NAME is required');\",\n        '  }',\n        '  const region = AWS_REGION || process.env.AWS_DEFAULT_REGION;',\n        '  if (!region) {',\n        \"    throw new Error('AWS_REGION is required');\",\n        '  }',\n        '',\n        '  const changeSetName = CHANGE_SET_NAME || STACK_NAME;',\n        '  const marker = `<!-- cdk-diff:stack:${STACK_NAME} -->`;',\n        '',\n        '  const client = new CloudFormationClient({ region });',\n        '',\n        '  let status: string | undefined;',\n        '  let statusReason: string | undefined;',\n        '  let changes: any[] = [];',\n        '',\n        '  try {',\n        '    const result = await getTerminalChangeSet(client, STACK_NAME, changeSetName);',\n        '    status = result.status;',\n        '    statusReason = result.statusReason;',\n        '    changes = result.changes ?? [];',\n        '  } catch (err: any) {',\n        '    // If DescribeChangeSet fails entirely, surface the error',\n        \"    console.error('Error describing change set:', err?.message || err);\",\n        '    process.exitCode = 1;',\n        '    return;',\n        '  }',\n        '',\n        \"  // Apply ignores from env vars (IDs and types). Default ignore IDs include 'CDKMetadata'.\",\n        '  const ignoreIdSet = new Set(',\n        \"    (IGNORE_LOGICAL_IDS ?? 'CDKMetadata')\",\n        \"      .split(',')\",\n        '      .map(s => s.trim())',\n        '      .filter(Boolean),',\n        '  );',\n        '  const ignoreTypeSet = new Set(',\n        \"    (IGNORE_RESOURCE_TYPES ?? '')\",\n        \"      .split(',')\",\n        '      .map(s => s.trim())',\n        '      .filter(Boolean),',\n        '  );',\n        '  const filteredChanges = changes.filter(c => !shouldIgnoreChange(c, ignoreIdSet, ignoreTypeSet));',\n        '',\n        '  // Build HTML exactly like pretty_format.py logic (table when there are changes; \"no change.\" otherwise).',\n        '  const html = buildHtml(STACK_NAME, filteredChanges);',\n        '',\n        '  // Check cached drift status (non-fatal)',\n        \"  let driftBanner = '';\",\n        '  try {',\n        '    driftBanner = await getDriftBannerHtml(client, STACK_NAME);',\n        '  } catch (e: any) {',\n        \"    console.error('Drift check failed:', e?.message || e);\",\n        '  }',\n        '  const fullHtml = driftBanner + html;',\n        '',\n        '  // Print to stdout',\n        '  console.log(fullHtml);',\n        '',\n        '  // Optionally append to GitHub Step Summary',\n        '  if (GITHUB_STEP_SUMMARY) {',\n        '    try {',\n        '      await appendStepSummary(GITHUB_STEP_SUMMARY, fullHtml);',\n        '      console.error(`Appended HTML to GITHUB_STEP_SUMMARY: ${GITHUB_STEP_SUMMARY}`);',\n        '    } catch (e: any) {',\n        \"      console.error('Failed to append to GITHUB_STEP_SUMMARY:', e?.message || e);\",\n        '    }',\n        '  }',\n        '',\n        '  // Upsert PR comment (find existing by marker, update or create)',\n        '  if (GITHUB_TOKEN && GITHUB_COMMENT_URL) {',\n        '    try {',\n        '      await upsertGithubComment(GITHUB_COMMENT_URL, GITHUB_TOKEN, fullHtml, marker);',\n        \"      console.error('Upserted GitHub PR comment.');\",\n        '    } catch (e: any) {',\n        \"      console.error('Failed to upsert GitHub PR comment:', e?.message || e);\",\n        '      // Do not fail the whole script just for comment posting',\n        '    }',\n        '  }',\n        '',\n        \"  // Note: When status is FAILED due to \\\"didn't contain changes\\\", the HTML naturally says \\\"no change.\\\"\",\n        \"  if (status === 'FAILED' && statusReason) {\",\n        '    console.error(`Change set status: FAILED. Reason: ${statusReason}`);',\n        '  }',\n        '}',\n        '',\n        'main().catch((err) => {',\n        '  console.error(err);',\n        '  process.exitCode = 1;',\n        '});',\n      ],\n    });\n  }\n}\n"]}

package/node_modules/@aws-sdk/client-cloudformation/node_modules/@aws-sdk/util-endpoints/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/util-endpoints",
-  "version": "3.986.0",
+  "version": "3.987.0",
   "description": "Utilities to help with endpoint resolution",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",

package/node_modules/@aws-sdk/client-cloudformation/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-cloudformation",
   "description": "AWS SDK for JavaScript Cloudformation Client for Node.js, Browser and React Native",
-  "version": "3.986.0",
+  "version": "3.987.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-cloudformation",
@@ -31,7 +31,7 @@
     "@aws-sdk/middleware-user-agent": "^3.972.7",
     "@aws-sdk/region-config-resolver": "^3.972.3",
     "@aws-sdk/types": "^3.973.1",
-    "@aws-sdk/util-endpoints": "3.986.0",
+    "@aws-sdk/util-endpoints": "3.987.0",
     "@aws-sdk/util-user-agent-browser": "^3.972.3",
     "@aws-sdk/util-user-agent-node": "^3.972.5",
     "@smithy/config-resolver": "^4.4.6",

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -990,8 +990,8 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace }) {
-        super({ defaultNamespace });
+    constructor({ defaultNamespace, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
     }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
@@ -1035,15 +1035,17 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        if (errorName.includes("#")) {
-            [namespace] = errorName.split("#");
-        }
         const errorMetadata = {
             $metadata: metadata,
             $fault: response.statusCode <= 500 ? "client" : "server",
         };
-        const registry = schema.TypeRegistry.for(namespace);
+        let namespace = this.options.defaultNamespace;
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
+        }
+        const registry = this.compositeErrorRegistry;
+        const nsRegistry = schema.TypeRegistry.for(namespace);
+        registry.copyFrom(nsRegistry);
         let errorSchema;
         try {
             errorSchema = registry.getSchema(errorName);
@@ -1052,10 +1054,11 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             if (dataObject.Message) {
                 dataObject.message = dataObject.Message;
             }
-            const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
-            const baseExceptionSchema = synthetic.getBaseException();
+            const syntheticRegistry = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            registry.copyFrom(syntheticRegistry);
+            const baseExceptionSchema = registry.getBaseException();
             if (baseExceptionSchema) {
-                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
+                const ErrorCtor = registry.getErrorCtor(baseExceptionSchema);
                 throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
             }
             throw Object.assign(new Error(errorName), errorMetadata, dataObject);

package/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -33,9 +33,14 @@ class SerdeContext {
 
 class HttpProtocol extends SerdeContext {
     options;
+    compositeErrorRegistry;
     constructor(options) {
         super();
         this.options = options;
+        this.compositeErrorRegistry = schema.TypeRegistry.for(options.defaultNamespace);
+        for (const etr of options.errorTypeRegistries ?? []) {
+            this.compositeErrorRegistry.copyFrom(etr);
+        }
     }
     getRequestType() {
         return protocolHttp.HttpRequest;

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -566,10 +566,24 @@ class TypeRegistry {
         }
         return TypeRegistry.registries.get(namespace);
     }
+    copyFrom(other) {
+        const { schemas, exceptions } = this;
+        for (const [k, v] of other.schemas) {
+            if (!schemas.has(k)) {
+                schemas.set(k, v);
+            }
+        }
+        for (const [k, v] of other.exceptions) {
+            if (!exceptions.has(k)) {
+                exceptions.set(k, v);
+            }
+        }
+    }
     register(shapeId, schema) {
         const qualifiedName = this.normalizeShapeId(shapeId);
-        const registry = TypeRegistry.for(qualifiedName.split("#")[0]);
-        registry.schemas.set(qualifiedName, schema);
+        for (const r of [this, TypeRegistry.for(qualifiedName.split("#")[0])]) {
+            r.schemas.set(qualifiedName, schema);
+        }
     }
     getSchema(shapeId) {
         const id = this.normalizeShapeId(shapeId);
@@ -580,12 +594,17 @@ class TypeRegistry {
     }
     registerError(es, ctor) {
         const $error = es;
-        const registry = TypeRegistry.for($error[1]);
-        registry.schemas.set($error[1] + "#" + $error[2], $error);
-        registry.exceptions.set($error, ctor);
+        const ns = $error[1];
+        for (const r of [this, TypeRegistry.for(ns)]) {
+            r.schemas.set(ns + "#" + $error[2], $error);
+            r.exceptions.set($error, ctor);
+        }
     }
     getErrorCtor(es) {
         const $error = es;
+        if (this.exceptions.has($error)) {
+            return this.exceptions.get($error);
+        }
         const registry = TypeRegistry.for($error[1]);
         return registry.exceptions.get($error);
     }

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -1,5 +1,6 @@
 import { RpcProtocol } from "@smithy/core/protocols";
-import { deref, NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { TypeRegistry } from "@smithy/core/schema";
+import { deref, NormalizedSchema } from "@smithy/core/schema";
 import { getSmithyContext } from "@smithy/util-middleware";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
@@ -7,8 +8,8 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace }) {
-        super({ defaultNamespace });
+    constructor({ defaultNamespace, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
     }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
@@ -52,15 +53,17 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        if (errorName.includes("#")) {
-            [namespace] = errorName.split("#");
-        }
         const errorMetadata = {
             $metadata: metadata,
             $fault: response.statusCode <= 500 ? "client" : "server",
         };
-        const registry = TypeRegistry.for(namespace);
+        let namespace = this.options.defaultNamespace;
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
+        }
+        const registry = this.compositeErrorRegistry;
+        const nsRegistry = TypeRegistry.for(namespace);
+        registry.copyFrom(nsRegistry);
         let errorSchema;
         try {
             errorSchema = registry.getSchema(errorName);
@@ -69,10 +72,11 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
             if (dataObject.Message) {
                 dataObject.message = dataObject.Message;
             }
-            const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
-            const baseExceptionSchema = synthetic.getBaseException();
+            const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            registry.copyFrom(syntheticRegistry);
+            const baseExceptionSchema = registry.getBaseException();
             if (baseExceptionSchema) {
-                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
+                const ErrorCtor = registry.getErrorCtor(baseExceptionSchema);
                 throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
             }
             throw Object.assign(new Error(errorName), errorMetadata, dataObject);

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -1,11 +1,16 @@
-import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
+import { NormalizedSchema, translateTraits, TypeRegistry } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
 import { SerdeContext } from "./SerdeContext";
 export class HttpProtocol extends SerdeContext {
     options;
+    compositeErrorRegistry;
     constructor(options) {
         super();
         this.options = options;
+        this.compositeErrorRegistry = TypeRegistry.for(options.defaultNamespace);
+        for (const etr of options.errorTypeRegistries ?? []) {
+            this.compositeErrorRegistry.copyFrom(etr);
+        }
     }
     getRequestType() {
         return HttpRequest;