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

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/detect-drift.js

@@ -90,10 +90,33 @@ async function main() {
         }
     }
     // 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 Promise.resolve().then(() => require('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) {
+                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;
@@ -113,10 +136,27 @@ async function main() {
         }
         process.exit(1);
     }
+    // No drift case
+    if (outputFile) {
+        try {
+            const { writeFile } = await Promise.resolve().then(() => require('fs/promises'));
+            const result = [
+                {
+                    stackName,
+                    driftStatus: 'IN_SYNC',
+                    driftedResources: [],
+                },
+            ];
+            await writeFile(outputFile, JSON.stringify(result, null, 2), { encoding: 'utf8' });
+        }
+        catch (e) {
+            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);
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detect-drift.js","sourceRoot":"","sources":["../../src/bin/detect-drift.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CloudFormationClient,\n  DescribeStackDriftDetectionStatusCommand,\n  DetectStackDriftCommand,\n  DescribeStackResourceDriftsCommand,\n  type DescribeStackResourceDriftsCommandOutput,\n  type StackResourceDriftStatus,\n} from '@aws-sdk/client-cloudformation';\n\nasync function sleep(ms: number) {\n  return new Promise((r) => setTimeout(r, ms));\n}\n\nasync 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  if (stackDriftStatus !== 'IN_SYNC') {\n    console.error(`Drift detected (status: ${stackDriftStatus})`);\n    const drifts = await listDriftedResources();\n    const html = buildHtml(stackName, drifts);\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  console.log('No drift detected (IN_SYNC)');\n}\n\nmain().catch((e) => {\n  console.error(e);\n  process.exit(1);\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detect-drift.js","sourceRoot":"","sources":["../../src/bin/detect-drift.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CloudFormationClient,\n  DescribeStackDriftDetectionStatusCommand,\n  DetectStackDriftCommand,\n  DescribeStackResourceDriftsCommand,\n  type DescribeStackResourceDriftsCommandOutput,\n  type StackResourceDriftStatus,\n} from '@aws-sdk/client-cloudformation';\n\nasync function sleep(ms: number) {\n  return new Promise((r) => setTimeout(r, ms));\n}\n\nasync 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\nmain().catch((e) => {\n  console.error(e);\n  process.exit(1);\n});\n"]}

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './CdkDiffStackWorkflow';
 export * from './CdkDiffIamTemplate';
 export * from './CdkDriftIamTemplate';
+export * from './CdkDriftDetectionWorkflow';

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/lib/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CdkDiffStackWorkflow"), exports);
 __exportStar(require("./CdkDiffIamTemplate"), exports);
 __exportStar(require("./CdkDriftIamTemplate"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUF1QztBQUN2Qyx1REFBcUM7QUFDckMsd0RBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9DZGtEaWZmU3RhY2tXb3JrZmxvdyc7XG5leHBvcnQgKiBmcm9tICcuL0Nka0RpZmZJYW1UZW1wbGF0ZSc7XG5leHBvcnQgKiBmcm9tICcuL0Nka0RyaWZ0SWFtVGVtcGxhdGUnO1xuIl19
+__exportStar(require("./CdkDriftDetectionWorkflow"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUF1QztBQUN2Qyx1REFBcUM7QUFDckMsd0RBQXNDO0FBQ3RDLDhEQUE0QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vQ2RrRGlmZlN0YWNrV29ya2Zsb3cnO1xuZXhwb3J0ICogZnJvbSAnLi9DZGtEaWZmSWFtVGVtcGxhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9DZGtEcmlmdElhbVRlbXBsYXRlJztcbmV4cG9ydCAqIGZyb20gJy4vQ2RrRHJpZnREZXRlY3Rpb25Xb3JrZmxvdyc7XG4iXX0=

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/package.json

@@ -132,5 +132,5 @@
     }
   },
   "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".",
-  "yalcSig": "4c42e5badb02d7cb046288f1bf203db4"
+  "yalcSig": "339cef64feb85dd8fa374ad04691ebc5"
 }

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/yalc.lock

@@ -3,7 +3,7 @@
   "packages": {
     "@jjrawlins/cdk-diff-pr-github-action": {
       "version": "0.0.0",
-      "signature": "2480657d20e60759581899b5833215c7",
+      "signature": "b7f61d0bd76849d06e2d07384422c808",
       "file": true
     }
   }

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/.yalc/@jjrawlins/cdk-diff-pr-github-action/yalc.sig

@@ -1 +1 @@
-4c42e5badb02d7cb046288f1bf203db4
+339cef64feb85dd8fa374ad04691ebc5

package/.yalc/@jjrawlins/cdk-diff-pr-github-action/API.md

@@ -241,6 +241,122 @@ public readonly scriptOutputPath: string;
 
 ---
 
+### CdkDriftDetectionWorkflowProps <a name="CdkDriftDetectionWorkflowProps" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps"></a>
+
+#### Initializer <a name="Initializer" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.Initializer"></a>
+
+```typescript
+import { CdkDriftDetectionWorkflowProps } from '@jjrawlins/cdk-diff-pr-github-action'
+
+const cdkDriftDetectionWorkflowProps: CdkDriftDetectionWorkflowProps = { ... }
+```
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.oidcRegion">oidcRegion</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.oidcRoleArn">oidcRoleArn</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.project">project</a></code> | <code>any</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.scriptOutputPath">scriptOutputPath</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.stacks">stacks</a></code> | <code><a href="#@jjrawlins/cdk-diff-pr-github-action.Stack">Stack</a>[]</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.createIssues">createIssues</a></code> | <code>boolean</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.nodeVersion">nodeVersion</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.schedule">schedule</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.workflowName">workflowName</a></code> | <code>string</code> | *No description.* |
+
+---
+
+##### `oidcRegion`<sup>Required</sup> <a name="oidcRegion" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.oidcRegion"></a>
+
+```typescript
+public readonly oidcRegion: string;
+```
+
+- *Type:* string
+
+---
+
+##### `oidcRoleArn`<sup>Required</sup> <a name="oidcRoleArn" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.oidcRoleArn"></a>
+
+```typescript
+public readonly oidcRoleArn: string;
+```
+
+- *Type:* string
+
+---
+
+##### `project`<sup>Required</sup> <a name="project" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.project"></a>
+
+```typescript
+public readonly project: any;
+```
+
+- *Type:* any
+
+---
+
+##### `scriptOutputPath`<sup>Required</sup> <a name="scriptOutputPath" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.scriptOutputPath"></a>
+
+```typescript
+public readonly scriptOutputPath: string;
+```
+
+- *Type:* string
+
+---
+
+##### `stacks`<sup>Required</sup> <a name="stacks" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.stacks"></a>
+
+```typescript
+public readonly stacks: Stack[];
+```
+
+- *Type:* <a href="#@jjrawlins/cdk-diff-pr-github-action.Stack">Stack</a>[]
+
+---
+
+##### `createIssues`<sup>Optional</sup> <a name="createIssues" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.createIssues"></a>
+
+```typescript
+public readonly createIssues: boolean;
+```
+
+- *Type:* boolean
+
+---
+
+##### `nodeVersion`<sup>Optional</sup> <a name="nodeVersion" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.nodeVersion"></a>
+
+```typescript
+public readonly nodeVersion: string;
+```
+
+- *Type:* string
+
+---
+
+##### `schedule`<sup>Optional</sup> <a name="schedule" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.schedule"></a>
+
+```typescript
+public readonly schedule: string;
+```
+
+- *Type:* string
+
+---
+
+##### `workflowName`<sup>Optional</sup> <a name="workflowName" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps.property.workflowName"></a>
+
+```typescript
+public readonly workflowName: string;
+```
+
+- *Type:* string
+
+---
+
 ### CdkDriftIamTemplateProps <a name="CdkDriftIamTemplateProps" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplateProps"></a>
 
 #### Initializer <a name="Initializer" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplateProps.Initializer"></a>
@@ -313,6 +429,67 @@ public readonly outputPath: string;
 
 ---
 
+### Stack <a name="Stack" id="@jjrawlins/cdk-diff-pr-github-action.Stack"></a>
+
+#### Initializer <a name="Initializer" id="@jjrawlins/cdk-diff-pr-github-action.Stack.Initializer"></a>
+
+```typescript
+import { Stack } from '@jjrawlins/cdk-diff-pr-github-action'
+
+const stack: Stack = { ... }
+```
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.Stack.property.driftDetectionRoleToAssumeArn">driftDetectionRoleToAssumeArn</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.Stack.property.driftDetectionRoleToAssumeRegion">driftDetectionRoleToAssumeRegion</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.Stack.property.stackName">stackName</a></code> | <code>string</code> | *No description.* |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.Stack.property.failOnDrift">failOnDrift</a></code> | <code>boolean</code> | *No description.* |
+
+---
+
+##### `driftDetectionRoleToAssumeArn`<sup>Required</sup> <a name="driftDetectionRoleToAssumeArn" id="@jjrawlins/cdk-diff-pr-github-action.Stack.property.driftDetectionRoleToAssumeArn"></a>
+
+```typescript
+public readonly driftDetectionRoleToAssumeArn: string;
+```
+
+- *Type:* string
+
+---
+
+##### `driftDetectionRoleToAssumeRegion`<sup>Required</sup> <a name="driftDetectionRoleToAssumeRegion" id="@jjrawlins/cdk-diff-pr-github-action.Stack.property.driftDetectionRoleToAssumeRegion"></a>
+
+```typescript
+public readonly driftDetectionRoleToAssumeRegion: string;
+```
+
+- *Type:* string
+
+---
+
+##### `stackName`<sup>Required</sup> <a name="stackName" id="@jjrawlins/cdk-diff-pr-github-action.Stack.property.stackName"></a>
+
+```typescript
+public readonly stackName: string;
+```
+
+- *Type:* string
+
+---
+
+##### `failOnDrift`<sup>Optional</sup> <a name="failOnDrift" id="@jjrawlins/cdk-diff-pr-github-action.Stack.property.failOnDrift"></a>
+
+```typescript
+public readonly failOnDrift: boolean;
+```
+
+- *Type:* boolean
+
+---
+
 ## Classes <a name="Classes" id="Classes"></a>
 
 ### CdkDiffIamTemplate <a name="CdkDiffIamTemplate" id="@jjrawlins/cdk-diff-pr-github-action.CdkDiffIamTemplate"></a>
@@ -367,6 +544,32 @@ new CdkDiffStackWorkflow(props: CdkDiffStackWorkflowProps)
 
 
 
+### CdkDriftDetectionWorkflow <a name="CdkDriftDetectionWorkflow" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflow"></a>
+
+#### Initializers <a name="Initializers" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflow.Initializer"></a>
+
+```typescript
+import { CdkDriftDetectionWorkflow } from '@jjrawlins/cdk-diff-pr-github-action'
+
+new CdkDriftDetectionWorkflow(props: CdkDriftDetectionWorkflowProps)
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflow.Initializer.parameter.props">props</a></code> | <code><a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps">CdkDriftDetectionWorkflowProps</a></code> | *No description.* |
+
+---
+
+##### `props`<sup>Required</sup> <a name="props" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflow.Initializer.parameter.props"></a>
+
+- *Type:* <a href="#@jjrawlins/cdk-diff-pr-github-action.CdkDriftDetectionWorkflowProps">CdkDriftDetectionWorkflowProps</a>
+
+---
+
+
+
+
+
 ### CdkDriftIamTemplate <a name="CdkDriftIamTemplate" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplate"></a>
 
 #### Initializers <a name="Initializers" id="@jjrawlins/cdk-diff-pr-github-action.CdkDriftIamTemplate.Initializer"></a>