@jjrawlins/cdk-diff-pr-github-action 0.0.1-beta → 0.0.3-beta

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/bin/cdk-changeset-script.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkChangesetScript = void 0;
+const projen_1 = require("projen");
+class CdkChangesetScript {
+    constructor(props) {
+        const outputPath = props.outputPath ?? 'projenrc/describe-cfn-changeset.ts';
+        new projen_1.TextFile(props.project, outputPath, {
+            lines: [
+                "import { appendFile } from 'fs/promises';",
+                "import { CloudFormationClient, DescribeChangeSetCommand } from '@aws-sdk/client-cloudformation';",
+                '',
+                "type Change = NonNullable<Awaited<ReturnType<CloudFormationClient['send']>> extends any ? any : never>;",
+                '',
+                '/**',
+                ' * Small sleep helper.',
+                ' */',
+                'const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));',
+                '',
+                '/**',
+                ' * Build the HTML color chip for an action.',
+                ' * Modify=blue, Add=green, Remove=red (match pretty_format.py).',
+                ' */',
+                'function actionChip(action?: string): string {',
+                '  // Use emoji instead of external images for reliability',
+                '  const emojiMap: Record<string, string> = {',
+                "    Modify: '🔵',",
+                "    Add: '🟢',",
+                "    Remove: '🔴',",
+                '  };',
+                "  const mark = action ? (emojiMap[action] ?? '⚪') : '⚪';",
+                "  return `${mark} ${action ?? '-'}`;",
+                '}',
+                '',
+                '/**',
+                " * Extract changed property names only where Target.Attribute == 'Properties'",
+                ' * joined by <br>, prefixed with "- ".',
+                ' */',
+                'function changedPropertiesHTML(change: any): string {',
+                '  const details = change?.ResourceChange?.Details ?? [];',
+                '  const props: string[] = [];',
+                '  for (const d of details) {',
+                "    if (d?.Target?.Attribute !== 'Properties') continue;",
+                "    const workflowName = d?.Target?.Name ?? '-';",
+                '    props.push(`- ${workflowName}`);',
+                '  }',
+                "  return props.join('<br>');",
+                '}',
+                '',
+                '/**',
+                ' * Determine if a change should be ignored based on logical IDs and/or resource types.',
+                " * - IGNORE_LOGICAL_IDS: comma-separated list of logical IDs to ignore (default includes 'CDKMetadata')",
+                " * - IGNORE_RESOURCE_TYPES: comma-separated list of resource types to ignore (e.g., 'AWS::CDK::Metadata')",
+                ' */',
+                'function shouldIgnoreChange(change: any, ignoreIds: Set<string>, ignoreTypes: Set<string>): boolean {',
+                '  const rc = change?.ResourceChange ?? {};',
+                '  const logicalId = rc?.LogicalResourceId as string | undefined;',
+                '  const resourceType = rc?.ResourceType as string | undefined;',
+                '  if (logicalId && ignoreIds.has(logicalId)) return true;',
+                '  if (resourceType && ignoreTypes.has(resourceType)) return true;',
+                '  return false;',
+                '}',
+                '',
+                '/**',
+                ' * Generate the HTML body similar to pretty_format.py',
+                ' */',
+                'function buildHtml(stackName: string, changes: any[]): string {',
+                '  let body = `<h1>Change set</h1><h2>Stack Name: ${stackName}</h2><br>`;',
+                '  if ((changes?.length ?? 0) > 0) {',
+                "    body += '<table><tr><th>Action&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</th><th>ID</th><th>Type</th><th>Replacement</th><th>Changed Properties</th></tr>';",
+                '    for (const c of changes) {',
+                '      const rc = c?.ResourceChange ?? {};',
+                '      const action = actionChip(rc?.Action);',
+                "      const logicalId = rc?.LogicalResourceId ?? '-';",
+                "      const type = rc?.ResourceType ?? '-';",
+                "      const replacement = rc?.Replacement ?? '-';",
+                '      const details = changedPropertiesHTML(c);',
+                '',
+                "      body += '<tr>';",
+                '      body += `<td>${action}</td>`;',
+                '      body += `<td>${logicalId}</td>`;',
+                '      body += `<td>${type}</td>`;',
+                '      body += `<td>${replacement}</td>`;',
+                '      body += `<td>${details}</td>`;',
+                "      body += '</tr>';",
+                '    }',
+                "    body += '</table>';",
+                '  } else {',
+                "    body += 'no change.';",
+                '  }',
+                '  return body;',
+                '}',
+                '',
+                '/**',
+                ' * Poll DescribeChangeSet until a terminal status, then paginate to retrieve all Changes.',
+                ' */',
+                'async function getTerminalChangeSet(',
+                '  client: CloudFormationClient,',
+                '  stackName: string,',
+                '  changeSetName: string,',
+                '  maxAttempts = 60,',
+                '  delayMs = 3000,',
+                '): Promise<{ status?: string; statusReason?: string; changes: any[] }> {',
+                '  for (let attempt = 1; attempt <= maxAttempts; attempt++) {',
+                '    const resp = await client.send(new DescribeChangeSetCommand({',
+                '      StackName: stackName,',
+                '      ChangeSetName: changeSetName,',
+                '    }));',
+                '',
+                '    const status = resp.Status;',
+                '    const statusReason = resp.StatusReason;',
+                '',
+                "    if (status === 'CREATE_COMPLETE' || status === 'FAILED') {",
+                '      // Gather all pages',
+                '      const changes: any[] = [];',
+                '      if (resp.Changes) changes.push(...resp.Changes);',
+                '      let next = resp.NextToken;',
+                '      while (next) {',
+                '        const page = await client.send(new DescribeChangeSetCommand({',
+                '          StackName: stackName,',
+                '          ChangeSetName: changeSetName,',
+                '          NextToken: next,',
+                '        }));',
+                '        if (page.Changes) changes.push(...page.Changes);',
+                '        next = page.NextToken;',
+                '      }',
+                '      return { status, statusReason, changes };',
+                '    }',
+                '',
+                '    // Not terminal yet; wait and retry',
+                '    await sleep(delayMs);',
+                '  }',
+                '',
+                "  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 }),',
+                '  });',
+                '',
+                '  if (!res.ok) {',
+                "    const text = await res.text().catch(() => '');",
+                '    throw new Error(`Failed to post GitHub comment: ${res.status} ${res.statusText} ${text}`);',
+                '  }',
+                '}',
+                '',
+                'async function appendStepSummary(summaryPath: string, content: string): Promise<void> {',
+                "  await appendFile(summaryPath, `${content}\\n`, { encoding: 'utf8' });",
+                '}',
+                '',
+                'async function main() {',
+                '  const {',
+                '    STACK_NAME,',
+                '    CHANGE_SET_NAME,',
+                '    AWS_REGION,',
+                '    GITHUB_TOKEN,',
+                '    GITHUB_COMMENT_URL,',
+                '    GITHUB_STEP_SUMMARY,',
+                '    IGNORE_LOGICAL_IDS,',
+                '    IGNORE_RESOURCE_TYPES,',
+                '  } = process.env;',
+                '',
+                '  if (!STACK_NAME) {',
+                "    throw new Error('STACK_NAME is required');",
+                '  }',
+                '  const region = AWS_REGION || process.env.AWS_DEFAULT_REGION;',
+                '  if (!region) {',
+                "    throw new Error('AWS_REGION is required');",
+                '  }',
+                '',
+                '  const changeSetName = CHANGE_SET_NAME || STACK_NAME;',
+                '',
+                '  const client = new CloudFormationClient({ region });',
+                '',
+                '  let status: string | undefined;',
+                '  let statusReason: string | undefined;',
+                '  let changes: any[] = [];',
+                '',
+                '  try {',
+                '    const result = await getTerminalChangeSet(client, STACK_NAME, changeSetName);',
+                '    status = result.status;',
+                '    statusReason = result.statusReason;',
+                '    changes = result.changes ?? [];',
+                '  } catch (err: any) {',
+                '    // If DescribeChangeSet fails entirely, surface the error',
+                "    console.error('Error describing change set:', err?.message || err);",
+                '    process.exitCode = 1;',
+                '    return;',
+                '  }',
+                '',
+                "  // Apply ignores from env vars (IDs and types). Default ignore IDs include 'CDKMetadata'.",
+                '  const ignoreIdSet = new Set(',
+                "    (IGNORE_LOGICAL_IDS ?? 'CDKMetadata')",
+                "      .split(',')",
+                '      .map(s => s.trim())',
+                '      .filter(Boolean),',
+                '  );',
+                '  const ignoreTypeSet = new Set(',
+                "    (IGNORE_RESOURCE_TYPES ?? '')",
+                "      .split(',')",
+                '      .map(s => s.trim())',
+                '      .filter(Boolean),',
+                '  );',
+                '  const filteredChanges = changes.filter(c => !shouldIgnoreChange(c, ignoreIdSet, ignoreTypeSet));',
+                '',
+                '  // Build HTML exactly like pretty_format.py logic (table when there are changes; "no change." otherwise).',
+                '  const html = buildHtml(STACK_NAME, filteredChanges);',
+                '',
+                '  // Print to stdout',
+                '  // This allows capturing output or redirecting to a file if needed.',
+                '  console.log(html);',
+                '',
+                '  // Optionally append to GitHub Step Summary',
+                '  if (GITHUB_STEP_SUMMARY) {',
+                '    try {',
+                '      await appendStepSummary(GITHUB_STEP_SUMMARY, html);',
+                '      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',
+                '  if (GITHUB_TOKEN && GITHUB_COMMENT_URL) {',
+                '    try {',
+                '      await postGithubComment(GITHUB_COMMENT_URL, GITHUB_TOKEN, html);',
+                "      console.error('Posted HTML as a GitHub PR comment.');",
+                '    } catch (e: any) {',
+                "      console.error('Failed to post GitHub PR comment:', e?.message || e);",
+                '      // Do not fail the whole script just for comment posting',
+                '    }',
+                '  }',
+                '',
+                "  // Note: When status is FAILED due to \"didn't contain changes\", the HTML naturally says \"no change.\"",
+                "  if (status === 'FAILED' && statusReason) {",
+                '    console.error(`Change set status: FAILED. Reason: ${statusReason}`);',
+                '  }',
+                '}',
+                '',
+                'main().catch((err) => {',
+                '  console.error(err);',
+                '  process.exitCode = 1;',
+                '});',
+            ],
+        });
+    }
+}
+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":";;;AAAA,mCAAkC;AAQlC,MAAa,kBAAkB;IAC7B,YAAY,KAA8B;QACxC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,oCAAoC,CAAC;QAE5E,IAAI,iBAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE;YACtC,KAAK,EAAE;gBACL,2CAA2C;gBAC3C,kGAAkG;gBAClG,EAAE;gBACF,yGAAyG;gBACzG,EAAE;gBACF,KAAK;gBACL,wBAAwB;gBACxB,KAAK;gBACL,0EAA0E;gBAC1E,EAAE;gBACF,KAAK;gBACL,6CAA6C;gBAC7C,iEAAiE;gBACjE,KAAK;gBACL,gDAAgD;gBAChD,2DAA2D;gBAC3D,8CAA8C;gBAC9C,mBAAmB;gBACnB,gBAAgB;gBAChB,mBAAmB;gBACnB,MAAM;gBACN,0DAA0D;gBAC1D,sCAAsC;gBACtC,GAAG;gBACH,EAAE;gBACF,KAAK;gBACL,+EAA+E;gBAC/E,wCAAwC;gBACxC,KAAK;gBACL,uDAAuD;gBACvD,0DAA0D;gBAC1D,+BAA+B;gBAC/B,8BAA8B;gBAC9B,0DAA0D;gBAC1D,kDAAkD;gBAClD,sCAAsC;gBACtC,KAAK;gBACL,8BAA8B;gBAC9B,GAAG;gBACH,EAAE;gBACF,KAAK;gBACL,wFAAwF;gBACxF,yGAAyG;gBACzG,2GAA2G;gBAC3G,KAAK;gBACL,uGAAuG;gBACvG,4CAA4C;gBAC5C,kEAAkE;gBAClE,gEAAgE;gBAChE,2DAA2D;gBAC3D,mEAAmE;gBACnE,iBAAiB;gBACjB,GAAG;gBACH,EAAE;gBACF,KAAK;gBACL,uDAAuD;gBACvD,KAAK;gBACL,iEAAiE;gBACjE,0EAA0E;gBAC1E,qCAAqC;gBACrC,iKAAiK;gBACjK,gCAAgC;gBAChC,2CAA2C;gBAC3C,8CAA8C;gBAC9C,uDAAuD;gBACvD,6CAA6C;gBAC7C,mDAAmD;gBACnD,iDAAiD;gBACjD,EAAE;gBACF,uBAAuB;gBACvB,qCAAqC;gBACrC,wCAAwC;gBACxC,mCAAmC;gBACnC,0CAA0C;gBAC1C,sCAAsC;gBACtC,wBAAwB;gBACxB,OAAO;gBACP,yBAAyB;gBACzB,YAAY;gBACZ,2BAA2B;gBAC3B,KAAK;gBACL,gBAAgB;gBAChB,GAAG;gBACH,EAAE;gBACF,KAAK;gBACL,2FAA2F;gBAC3F,KAAK;gBACL,sCAAsC;gBACtC,iCAAiC;gBACjC,sBAAsB;gBACtB,0BAA0B;gBAC1B,qBAAqB;gBACrB,mBAAmB;gBACnB,0EAA0E;gBAC1E,8DAA8D;gBAC9D,mEAAmE;gBACnE,6BAA6B;gBAC7B,qCAAqC;gBACrC,UAAU;gBACV,EAAE;gBACF,iCAAiC;gBACjC,6CAA6C;gBAC7C,EAAE;gBACF,gEAAgE;gBAChE,2BAA2B;gBAC3B,kCAAkC;gBAClC,wDAAwD;gBACxD,kCAAkC;gBAClC,sBAAsB;gBACtB,uEAAuE;gBACvE,iCAAiC;gBACjC,yCAAyC;gBACzC,4BAA4B;gBAC5B,cAAc;gBACd,0DAA0D;gBAC1D,gCAAgC;gBAChC,SAAS;gBACT,iDAAiD;gBACjD,OAAO;gBACP,EAAE;gBACF,yCAAyC;gBACzC,2BAA2B;gBAC3B,KAAK;gBACL,EAAE;gBACF,oFAAoF;gBACpF,GAAG;gBACH,EAAE;gBACF,6FAA6F;gBAC7F,kCAAkC;gBAClC,qBAAqB;gBACrB,gBAAgB;gBAChB,0CAA0C;gBAC1C,2CAA2C;gBAC3C,gDAAgD;gBAChD,QAAQ;gBACR,qCAAqC;gBACrC,OAAO;gBACP,EAAE;gBACF,kBAAkB;gBAClB,oDAAoD;gBACpD,gGAAgG;gBAChG,KAAK;gBACL,GAAG;gBACH,EAAE;gBACF,yFAAyF;gBACzF,yEAAyE;gBACzE,GAAG;gBACH,EAAE;gBACF,yBAAyB;gBACzB,WAAW;gBACX,iBAAiB;gBACjB,sBAAsB;gBACtB,iBAAiB;gBACjB,mBAAmB;gBACnB,yBAAyB;gBACzB,0BAA0B;gBAC1B,yBAAyB;gBACzB,4BAA4B;gBAC5B,oBAAoB;gBACpB,EAAE;gBACF,sBAAsB;gBACtB,gDAAgD;gBAChD,KAAK;gBACL,gEAAgE;gBAChE,kBAAkB;gBAClB,gDAAgD;gBAChD,KAAK;gBACL,EAAE;gBACF,wDAAwD;gBACxD,EAAE;gBACF,wDAAwD;gBACxD,EAAE;gBACF,mCAAmC;gBACnC,yCAAyC;gBACzC,4BAA4B;gBAC5B,EAAE;gBACF,SAAS;gBACT,mFAAmF;gBACnF,6BAA6B;gBAC7B,yCAAyC;gBACzC,qCAAqC;gBACrC,wBAAwB;gBACxB,+DAA+D;gBAC/D,yEAAyE;gBACzE,2BAA2B;gBAC3B,aAAa;gBACb,KAAK;gBACL,EAAE;gBACF,6FAA6F;gBAC7F,gCAAgC;gBAChC,2CAA2C;gBAC3C,mBAAmB;gBACnB,2BAA2B;gBAC3B,yBAAyB;gBACzB,MAAM;gBACN,kCAAkC;gBAClC,mCAAmC;gBACnC,mBAAmB;gBACnB,2BAA2B;gBAC3B,yBAAyB;gBACzB,MAAM;gBACN,oGAAoG;gBACpG,EAAE;gBACF,6GAA6G;gBAC7G,wDAAwD;gBACxD,EAAE;gBACF,sBAAsB;gBACtB,uEAAuE;gBACvE,sBAAsB;gBACtB,EAAE;gBACF,+CAA+C;gBAC/C,8BAA8B;gBAC9B,WAAW;gBACX,2DAA2D;gBAC3D,sFAAsF;gBACtF,wBAAwB;gBACxB,mFAAmF;gBACnF,OAAO;gBACP,KAAK;gBACL,EAAE;gBACF,mCAAmC;gBACnC,6CAA6C;gBAC7C,WAAW;gBACX,wEAAwE;gBACxE,6DAA6D;gBAC7D,wBAAwB;gBACxB,4EAA4E;gBAC5E,gEAAgE;gBAChE,OAAO;gBACP,KAAK;gBACL,EAAE;gBACF,4GAA4G;gBAC5G,8CAA8C;gBAC9C,0EAA0E;gBAC1E,KAAK;gBACL,GAAG;gBACH,EAAE;gBACF,yBAAyB;gBACzB,uBAAuB;gBACvB,yBAAyB;gBACzB,KAAK;aACN;SACF,CAAC,CAAC;IACL,CAAC;CACF;AA1PD,gDA0PC","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        \"type Change = NonNullable<Awaited<ReturnType<CloudFormationClient['send']>> extends any ? any : never>;\",\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        \" * Extract changed property names only where Target.Attribute == 'Properties'\",\n        ' * joined by <br>, prefixed with \"- \".',\n        ' */',\n        'function changedPropertiesHTML(change: any): string {',\n        '  const details = change?.ResourceChange?.Details ?? [];',\n        '  const props: string[] = [];',\n        '  for (const d of details) {',\n        \"    if (d?.Target?.Attribute !== 'Properties') continue;\",\n        \"    const workflowName = d?.Target?.Name ?? '-';\",\n        '    props.push(`- ${workflowName}`);',\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>Changed Properties</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        '    }));',\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        '          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"]}

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/bin/cdk-drift-detection-script.d.ts

@@ -0,0 +1,15 @@
+interface CdkDriftDetectionScriptProps {
+    project: any;
+    outputPath?: string;
+}
+/**
+ * Projen helper to emit the drift detection script into the repository so
+ * GitHub workflows can execute it from a stable location.
+ *
+ * This mirrors the pattern used by CdkChangesetScript, but writes the
+ * drift script (detect-drift.ts) under the workflows scripts directory by default.
+ */
+export declare class CdkDriftDetectionScript {
+    constructor(props: CdkDriftDetectionScriptProps);
+}
+export {};

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/bin/cdk-drift-detection-script.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkDriftDetectionScript = void 0;
+const projen_1 = require("projen");
+/**
+ * Projen helper to emit the drift detection script into the repository so
+ * GitHub workflows can execute it from a stable location.
+ *
+ * This mirrors the pattern used by CdkChangesetScript, but writes the
+ * drift script (detect-drift.ts) under the workflows scripts directory by default.
+ */
+class CdkDriftDetectionScript {
+    constructor(props) {
+        const outputPath = props.outputPath ?? '.github/workflows/scripts/detect-drift.ts';
+        new projen_1.TextFile(props.project, outputPath, {
+            lines: [
+                "import {\n  CloudFormationClient,\n  DescribeStackDriftDetectionStatusCommand,\n  DetectStackDriftCommand,\n  DescribeStackResourceDriftsCommand,\n  type DescribeStackResourceDriftsCommandOutput,\n  type StackResourceDriftStatus,\n} from '@aws-sdk/client-cloudformation';",
+                '',
+                'async function sleep(ms: number) {',
+                '  return new Promise((r) => setTimeout(r, ms));',
+                '}',
+                '',
+                'async function main() {',
+                '  const stackName = process.env.STACK_NAME;',
+                '  if (!stackName) {',
+                "    console.error('STACK_NAME env var is required');",
+                '    process.exit(1);',
+                '  }',
+                '',
+                '  // Region and credentials pulled from environment set by actions/configure-aws-credentials',
+                '  const client = new CloudFormationClient({});',
+                '',
+                '  const detect = await client.send(new DetectStackDriftCommand({ StackName: stackName }));',
+                '  if (!detect.StackDriftDetectionId) {',
+                "    console.error('Failed to start drift detection');",
+                '    process.exit(1);',
+                '  }',
+                '',
+                '  const id = detect.StackDriftDetectionId;',
+                '  console.log(`Drift detection started: ${id}`);',
+                '',
+                "  let detectionStatus = 'DETECTION_IN_PROGRESS';",
+                '  let stackDriftStatus: string | undefined;',
+                '',
+                "  while (detectionStatus === 'DETECTION_IN_PROGRESS') {",
+                '    await sleep(5000);',
+                '    const res = await client.send(',
+                '      new DescribeStackDriftDetectionStatusCommand({ StackDriftDetectionId: id }),',
+                '    );',
+                "    detectionStatus = res.DetectionStatus ?? 'UNKNOWN';",
+                '    stackDriftStatus = res.StackDriftStatus;',
+                '    console.log(`Detection status: ${detectionStatus}`);',
+                '  }',
+                '',
+                '  // Helper to build an HTML report of drifted resources',
+                '  const buildHtml = (stack: string, drifts: any[]): string => {',
+                '    let body = `<h1>Drift report</h1><h2>Stack Name: ${stack}</h2><br>`;',
+                '    if (drifts.length === 0) {',
+                "      body += 'no drift.';",
+                '      return body;',
+                '    }',
+                "    body += '<table>' +",
+                "      '<tr><th>Status</th><th>ID</th><th>Type</th><th>Differences</th></tr>';",
+                '    for (const d of drifts) {',
+                "      const status = d.StackResourceDriftStatus ?? '-';",
+                "      const logicalId = d.LogicalResourceId ?? '-';",
+                "      const type = d.ResourceType ?? '-';",
+                '      const diffs = (d.PropertyDifferences ?? []).map((pd: any) => {',
+                "        const p = pd.PropertyPath ?? '-';",
+                "        const t = pd.DifferenceType ?? '-';",
+                "        return `- ${t}: ${p}`;",
+                "      }).join('<br>');",
+                "      const statusEmoji = status === 'MODIFIED' ? '🟠' : status === 'DELETED' ? '🔴' : status === 'NOT_CHECKED' ? '⚪' : '🟢';",
+                "      body += '<tr>' +",
+                '        `<td>${statusEmoji} ${status}</td>` +',
+                '        `<td>${logicalId}</td>` +',
+                '        `<td>${type}</td>` +',
+                '        `<td>${diffs}</td>` +',
+                "        '</tr>';",
+                '    }',
+                "    body += '</table>';",
+                '    return body;',
+                '  };',
+                '',
+                '  async function listDriftedResources(): Promise<any[]> {',
+                '    const results: any[] = [];',
+                '    // Only include resources that are not IN_SYNC',
+                "    const filters: StackResourceDriftStatus[] = ['MODIFIED', 'DELETED', 'NOT_CHECKED'];",
+                '    let nextToken: string | undefined = undefined;',
+                '    do {',
+                '      const resp: DescribeStackResourceDriftsCommandOutput = await client.send(new DescribeStackResourceDriftsCommand({',
+                '        StackName: stackName,',
+                '        NextToken: nextToken,',
+                '        StackResourceDriftStatusFilters: filters,',
+                '      }));',
+                '      if (resp.StackResourceDrifts) results.push(...resp.StackResourceDrifts);',
+                '      nextToken = resp.NextToken;',
+                '    } while (nextToken);',
+                '    return results;',
+                '  }',
+                '',
+                '  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 }),',
+                '    });',
+                '    if (!res.ok) {',
+                '      const text = await res.text().catch(() => \'\');',
+                '      console.error(`Failed to post GitHub comment: ${res.status} ${res.statusText} ${text}`);',
+                '    }',
+                '  }',
+                '',
+                '  // When there is drift, collect details and post a PR comment + step summary',
+                '  const outputFile = process.env.DRIFT_DETECTION_OUTPUT;',
+                "  if (stackDriftStatus !== 'IN_SYNC') {",
+                "    console.error(`Drift detected (status: ${stackDriftStatus})`);",
+                '    const drifts = await listDriftedResources();',
+                '    const html = buildHtml(stackName, drifts);',
+                '',
+                '    // Write machine-readable JSON if requested',
+                '    if (outputFile) {',
+                '      try {',
+                "        const { writeFile } = await import('fs/promises');",
+                '        const result = [',
+                '          {',
+                '            stackName,',
+                '            driftStatus: stackDriftStatus,',
+                '            driftedResources: (drifts || []).map(d => ({',
+                '              logicalResourceId: d.LogicalResourceId,',
+                '              resourceType: d.ResourceType,',
+                '              stackResourceDriftStatus: d.StackResourceDriftStatus,',
+                '              propertyDifferences: d.PropertyDifferences,',
+                '            })),',
+                '          },',
+                '        ];',
+                "        await writeFile(outputFile, JSON.stringify(result, null, 2), { encoding: 'utf8' });",
+                '      } catch (e: any) {',
+                "        console.error('Failed to write drift JSON results:', e?.message || e);",
+                '      }',
+                '    }',
+                '',
+                '    // Print to stdout and append to summary if available',
+                '    console.log(html);',
+                '    const stepSummary = process.env.GITHUB_STEP_SUMMARY;',
+                '    if (stepSummary) {',
+                '      try {',
+                "        const { appendFile } = await import('fs/promises');",
+                "        await appendFile(stepSummary, `${html}\\n`, { encoding: 'utf8' });",
+                '      } catch (e: any) {',
+                "        console.error('Failed to append to GITHUB_STEP_SUMMARY:', e?.message || e);",
+                '      }',
+                '    }',
+                '',
+                '    const commentUrl = process.env.GITHUB_COMMENT_URL;',
+                '    const token = process.env.GITHUB_TOKEN;',
+                '    if (commentUrl && token) {',
+                '      await postGithubComment(commentUrl, token, html);',
+                '    }',
+                '',
+                '    process.exit(1);',
+                '  }',
+                '',
+                '  // No drift case',
+                '  if (outputFile) {',
+                '    try {',
+                "      const { writeFile } = await import('fs/promises');",
+                '      const result = [',
+                '        {',
+                '          stackName,',
+                "          driftStatus: 'IN_SYNC',",
+                '          driftedResources: [],',
+                '        },',
+                '      ];',
+                "      await writeFile(outputFile, JSON.stringify(result, null, 2), { encoding: 'utf8' });",
+                '    } catch (e: any) {',
+                "      console.error('Failed to write drift JSON results:', e?.message || e);",
+                '    }',
+                '  }',
+                "  console.log('No drift detected (IN_SYNC)');",
+                '}',
+                '',
+                'main().catch((e) => {',
+                '  console.error(e);',
+                '  process.exit(1);',
+                '});',
+            ],
+        });
+    }
+}
+exports.CdkDriftDetectionScript = CdkDriftDetectionScript;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-drift-detection-script.js","sourceRoot":"","sources":["../../src/bin/cdk-drift-detection-script.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile } from 'projen';\n\ninterface CdkDriftDetectionScriptProps {\n  // Avoid exporting projen types in public API\n  project: any;\n  outputPath?: string;\n}\n\n/**\n * Projen helper to emit the drift detection script into the repository so\n * GitHub workflows can execute it from a stable location.\n *\n * This mirrors the pattern used by CdkChangesetScript, but writes the\n * drift script (detect-drift.ts) under the workflows scripts directory by default.\n */\nexport class CdkDriftDetectionScript {\n  constructor(props: CdkDriftDetectionScriptProps) {\n    const outputPath = props.outputPath ?? '.github/workflows/scripts/detect-drift.ts';\n\n    new TextFile(props.project, outputPath, {\n      lines: [\n        \"import {\\n  CloudFormationClient,\\n  DescribeStackDriftDetectionStatusCommand,\\n  DetectStackDriftCommand,\\n  DescribeStackResourceDriftsCommand,\\n  type DescribeStackResourceDriftsCommandOutput,\\n  type StackResourceDriftStatus,\\n} from '@aws-sdk/client-cloudformation';\",\n        '',\n        'async function sleep(ms: number) {',\n        '  return new Promise((r) => setTimeout(r, ms));',\n        '}',\n        '',\n        'async function main() {',\n        '  const stackName = process.env.STACK_NAME;',\n        '  if (!stackName) {',\n        \"    console.error('STACK_NAME env var is required');\",\n        '    process.exit(1);',\n        '  }',\n        '',\n        '  // Region and credentials pulled from environment set by actions/configure-aws-credentials',\n        '  const client = new CloudFormationClient({});',\n        '',\n        '  const detect = await client.send(new DetectStackDriftCommand({ StackName: stackName }));',\n        '  if (!detect.StackDriftDetectionId) {',\n        \"    console.error('Failed to start drift detection');\",\n        '    process.exit(1);',\n        '  }',\n        '',\n        '  const id = detect.StackDriftDetectionId;',\n        '  console.log(`Drift detection started: ${id}`);',\n        '',\n        \"  let detectionStatus = 'DETECTION_IN_PROGRESS';\",\n        '  let stackDriftStatus: string | undefined;',\n        '',\n        \"  while (detectionStatus === 'DETECTION_IN_PROGRESS') {\",\n        '    await sleep(5000);',\n        '    const res = await client.send(',\n        '      new DescribeStackDriftDetectionStatusCommand({ StackDriftDetectionId: id }),',\n        '    );',\n        \"    detectionStatus = res.DetectionStatus ?? 'UNKNOWN';\",\n        '    stackDriftStatus = res.StackDriftStatus;',\n        '    console.log(`Detection status: ${detectionStatus}`);',\n        '  }',\n        '',\n        '  // Helper to build an HTML report of drifted resources',\n        '  const buildHtml = (stack: string, drifts: any[]): string => {',\n        '    let body = `<h1>Drift report</h1><h2>Stack Name: ${stack}</h2><br>`;',\n        '    if (drifts.length === 0) {',\n        \"      body += 'no drift.';\",\n        '      return body;',\n        '    }',\n        \"    body += '<table>' +\",\n        \"      '<tr><th>Status</th><th>ID</th><th>Type</th><th>Differences</th></tr>';\",\n        '    for (const d of drifts) {',\n        \"      const status = d.StackResourceDriftStatus ?? '-';\",\n        \"      const logicalId = d.LogicalResourceId ?? '-';\",\n        \"      const type = d.ResourceType ?? '-';\",\n        '      const diffs = (d.PropertyDifferences ?? []).map((pd: any) => {',\n        \"        const p = pd.PropertyPath ?? '-';\",\n        \"        const t = pd.DifferenceType ?? '-';\",\n        \"        return `- ${t}: ${p}`;\",\n        \"      }).join('<br>');\",\n        \"      const statusEmoji = status === 'MODIFIED' ? '🟠' : status === 'DELETED' ? '🔴' : status === 'NOT_CHECKED' ? '⚪' : '🟢';\",\n        \"      body += '<tr>' +\",\n        '        `<td>${statusEmoji} ${status}</td>` +',\n        '        `<td>${logicalId}</td>` +',\n        '        `<td>${type}</td>` +',\n        '        `<td>${diffs}</td>` +',\n        \"        '</tr>';\",\n        '    }',\n        \"    body += '</table>';\",\n        '    return body;',\n        '  };',\n        '',\n        '  async function listDriftedResources(): Promise<any[]> {',\n        '    const results: any[] = [];',\n        '    // Only include resources that are not IN_SYNC',\n        \"    const filters: StackResourceDriftStatus[] = ['MODIFIED', 'DELETED', 'NOT_CHECKED'];\",\n        '    let nextToken: string | undefined = undefined;',\n        '    do {',\n        '      const resp: DescribeStackResourceDriftsCommandOutput = await client.send(new DescribeStackResourceDriftsCommand({',\n        '        StackName: stackName,',\n        '        NextToken: nextToken,',\n        '        StackResourceDriftStatusFilters: filters,',\n        '      }));',\n        '      if (resp.StackResourceDrifts) results.push(...resp.StackResourceDrifts);',\n        '      nextToken = resp.NextToken;',\n        '    } while (nextToken);',\n        '    return results;',\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        '    if (!res.ok) {',\n        '      const text = await res.text().catch(() => \\'\\');',\n        '      console.error(`Failed to post GitHub comment: ${res.status} ${res.statusText} ${text}`);',\n        '    }',\n        '  }',\n        '',\n        '  // When there is drift, collect details and post a PR comment + step summary',\n        '  const outputFile = process.env.DRIFT_DETECTION_OUTPUT;',\n        \"  if (stackDriftStatus !== 'IN_SYNC') {\",\n        \"    console.error(`Drift detected (status: ${stackDriftStatus})`);\",\n        '    const drifts = await listDriftedResources();',\n        '    const html = buildHtml(stackName, drifts);',\n        '',\n        '    // Write machine-readable JSON if requested',\n        '    if (outputFile) {',\n        '      try {',\n        \"        const { writeFile } = await import('fs/promises');\",\n        '        const result = [',\n        '          {',\n        '            stackName,',\n        '            driftStatus: stackDriftStatus,',\n        '            driftedResources: (drifts || []).map(d => ({',\n        '              logicalResourceId: d.LogicalResourceId,',\n        '              resourceType: d.ResourceType,',\n        '              stackResourceDriftStatus: d.StackResourceDriftStatus,',\n        '              propertyDifferences: d.PropertyDifferences,',\n        '            })),',\n        '          },',\n        '        ];',\n        \"        await writeFile(outputFile, JSON.stringify(result, null, 2), { encoding: 'utf8' });\",\n        '      } catch (e: any) {',\n        \"        console.error('Failed to write drift JSON results:', e?.message || e);\",\n        '      }',\n        '    }',\n        '',\n        '    // Print to stdout and append to summary if available',\n        '    console.log(html);',\n        '    const stepSummary = process.env.GITHUB_STEP_SUMMARY;',\n        '    if (stepSummary) {',\n        '      try {',\n        \"        const { appendFile } = await import('fs/promises');\",\n        \"        await appendFile(stepSummary, `${html}\\\\n`, { encoding: 'utf8' });\",\n        '      } catch (e: any) {',\n        \"        console.error('Failed to append to GITHUB_STEP_SUMMARY:', e?.message || e);\",\n        '      }',\n        '    }',\n        '',\n        '    const commentUrl = process.env.GITHUB_COMMENT_URL;',\n        '    const token = process.env.GITHUB_TOKEN;',\n        '    if (commentUrl && token) {',\n        '      await postGithubComment(commentUrl, token, html);',\n        '    }',\n        '',\n        '    process.exit(1);',\n        '  }',\n        '',\n        '  // No drift case',\n        '  if (outputFile) {',\n        '    try {',\n        \"      const { writeFile } = await import('fs/promises');\",\n        '      const result = [',\n        '        {',\n        '          stackName,',\n        \"          driftStatus: 'IN_SYNC',\",\n        '          driftedResources: [],',\n        '        },',\n        '      ];',\n        \"      await writeFile(outputFile, JSON.stringify(result, null, 2), { encoding: 'utf8' });\",\n        '    } catch (e: any) {',\n        \"      console.error('Failed to write drift JSON results:', e?.message || e);\",\n        '    }',\n        '  }',\n        \"  console.log('No drift detected (IN_SYNC)');\",\n        '}',\n        '',\n        'main().catch((e) => {',\n        '  console.error(e);',\n        '  process.exit(1);',\n        '});',\n      ],\n    });\n  }\n}\n"]}

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/bin/describe-cfn-changeset.d.ts

@@ -0,0 +1 @@
+export {};