@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/describe-cfn-changeset.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+// type Change = NonNullable<Awaited<ReturnType<CloudFormationClient['send']>> extends any ? any : never>;
+/**
+ * Small sleep helper.
+ */
+const sleep = (ms) => 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) {
+    // Use emoji instead of external images for reliability
+    const emojiMap = {
+        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) {
+    const details = change?.ResourceChange?.Details ?? [];
+    const props = [];
+    for (const d of details) {
+        if (d?.Target?.Attribute !== 'Properties')
+            continue;
+        const name = d?.Target?.Name ?? '-';
+        props.push(`- ${name}`);
+    }
+    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, ignoreIds, ignoreTypes) {
+    const rc = change?.ResourceChange ?? {};
+    const logicalId = rc?.LogicalResourceId;
+    const resourceType = rc?.ResourceType;
+    if (logicalId && ignoreIds.has(logicalId))
+        return true;
+    return !!(resourceType && ignoreTypes.has(resourceType));
+}
+/**
+ * Generate the HTML body similar to pretty_format.py
+ */
+function buildHtml(stackName, changes) {
+    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, stackName, changeSetName, maxAttempts = 60, delayMs = 3000) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const resp = await client.send(new client_cloudformation_1.DescribeChangeSetCommand({
+            StackName: stackName,
+            ChangeSetName: changeSetName,
+        }));
+        const status = resp.Status;
+        const statusReason = resp.StatusReason;
+        if (status === 'CREATE_COMPLETE' || status === 'FAILED') {
+            // Gather all pages
+            const changes = [];
+            if (resp.Changes)
+                changes.push(...resp.Changes);
+            let next = resp.NextToken;
+            while (next) {
+                const page = await client.send(new client_cloudformation_1.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, token, body) {
+    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, content) {
+    await (0, promises_1.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 client_cloudformation_1.CloudFormationClient({ region });
+    let status;
+    let statusReason;
+    let changes = [];
+    try {
+        const result = await getTerminalChangeSet(client, STACK_NAME, changeSetName);
+        status = result.status;
+        statusReason = result.statusReason;
+        changes = result.changes ?? [];
+    }
+    catch (err) {
+        // 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) {
+            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) {
+            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;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"describe-cfn-changeset.js","sourceRoot":"","sources":["../../src/bin/describe-cfn-changeset.ts"],"names":[],"mappings":"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","sourcesContent":["import { appendFile } from 'fs/promises';\nimport { 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 */\nconst 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 */\nfunction 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 */\nfunction 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 name = d?.Target?.Name ?? '-';\n    props.push(`- ${name}`);\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 */\nfunction 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  return !!(resourceType && ignoreTypes.has(resourceType));\n\n}\n\n/**\n * Generate the HTML body similar to pretty_format.py\n */\nfunction 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 */\nasync 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\nasync 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\nasync function appendStepSummary(summaryPath: string, content: string): Promise<void> {\n  await appendFile(summaryPath, `${content}\\n`, { encoding: 'utf8' });\n}\n\nasync 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\nmain().catch((err) => {\n  console.error(err);\n  process.exitCode = 1;\n});\n"]}

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

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

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+async function sleep(ms) {
+    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 client_cloudformation_1.CloudFormationClient({});
+    const detect = await client.send(new client_cloudformation_1.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;
+    while (detectionStatus === 'DETECTION_IN_PROGRESS') {
+        await sleep(5000);
+        const res = await client.send(new client_cloudformation_1.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, drifts) => {
+        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) => {
+                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() {
+        const results = [];
+        // Only include resources that are not IN_SYNC
+        const filters = ['MODIFIED', 'DELETED', 'NOT_CHECKED'];
+        let nextToken = undefined;
+        do {
+            const resp = await client.send(new client_cloudformation_1.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, token, body) {
+        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 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;
+        if (stepSummary) {
+            try {
+                const { appendFile } = await Promise.resolve().then(() => require('fs/promises'));
+                await appendFile(stepSummary, `${html}\n`, { encoding: 'utf8' });
+            }
+            catch (e) {
+                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 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  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

@@ -0,0 +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

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CdkDiffStackWorkflow"), exports);
+__exportStar(require("./CdkDiffIamTemplate"), exports);
+__exportStar(require("./CdkDriftIamTemplate"), exports);
+__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

@@ -0,0 +1,136 @@
+{
+  "name": "@jjrawlins/cdk-diff-pr-github-action",
+  "description": "A GitHub Action that creates a CDK diff for a pull request.",
+  "repository": {
+    "type": "git",
+    "url": "https://jjrawlins@github.com/JaysonRawlins/cdk-diff-pr-github-action.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Jayson Rawlins",
+    "email": "JaysonJ.Rawlins@gmail.com",
+    "organization": false
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.85.0",
+    "constructs": ">=10.0.5 <11.0.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-cloudformation": "^3.922.0",
+    "@types/crypto-js": "^4.2.2",
+    "@types/js-yaml": "^4.0.9",
+    "crypto-js": "^4.2.0",
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21",
+    "lodash.merge": "^4.6.2",
+    "projen": "^0.95.6"
+  },
+  "bundledDependencies": [
+    "@aws-sdk/client-cloudformation",
+    "@types/crypto-js",
+    "@types/js-yaml",
+    "crypto-js",
+    "js-yaml",
+    "lodash",
+    "lodash.merge"
+  ],
+  "resolutions": {
+    "form-data": "^4.0.4",
+    "@eslint/plugin-kit": "^0.3.4",
+    "aws-cdk-lib": ">=2.85.0 <3.0.0",
+    "constructs": "10.0.5",
+    "projen": ">=0.95.6 <1.0.0"
+  },
+  "keywords": [
+    "action",
+    "aws",
+    "cdk",
+    "diff",
+    "github",
+    "pull request"
+  ],
+  "engines": {
+    "node": ">= 20.9.0"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "version": "0.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".",
+  "yalcSig": "339cef64feb85dd8fa374ad04691ebc5"
+}

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

@@ -0,0 +1,10 @@
+{
+  "version": "v1",
+  "packages": {
+    "@jjrawlins/cdk-diff-pr-github-action": {
+      "version": "0.0.0",
+      "signature": "b7f61d0bd76849d06e2d07384422c808",
+      "file": true
+    }
+  }
+}

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

@@ -0,0 +1 @@
+339cef64feb85dd8fa374ad04691ebc5