@jjrawlins/cfn-drift-remediate 0.0.0

package/lib/cli.js

@@ -0,0 +1,391 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remediate = remediate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cfn_client_1 = require("./lib/cfn-client");
+const eligible_resources_1 = require("./lib/eligible-resources");
+const interactive_1 = require("./lib/interactive");
+const plan_1 = require("./lib/plan");
+const resource_importer_1 = require("./lib/resource-importer");
+const template_transformer_1 = require("./lib/template-transformer");
+const utils_1 = require("./lib/utils");
+const DEFAULT_CAPABILITIES = ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM', 'CAPABILITY_AUTO_EXPAND'];
+function packageVersion() {
+    try {
+        const pkgPath = path.join(__dirname, '..', 'package.json');
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Main remediation function that orchestrates the drift remediation process
+ */
+async function remediate(options, spinner) {
+    const client = new cfn_client_1.CfnClientWrapper({
+        region: options.region,
+        profile: options.profile,
+    });
+    const result = {
+        success: false,
+        remediatedResources: [],
+        skippedResources: [],
+        removedResources: [],
+        errors: [],
+    };
+    const log = (message) => {
+        if (spinner) {
+            spinner.text = message;
+        }
+        else if (options.verbose) {
+            console.log(message);
+        }
+    };
+    try {
+        // Step 1: Get stack info and original template
+        log('Fetching stack information...');
+        const stackInfo = await client.getStackInfo(options.stackName);
+        log('Fetching original template...');
+        const originalTemplateBody = await client.getTemplate(stackInfo.stackId, true);
+        const originalTemplate = (0, template_transformer_1.parseTemplate)(originalTemplateBody);
+        if (options.verbose) {
+            console.log(`Found stack: ${stackInfo.stackName} (${stackInfo.stackId})`);
+        }
+        // Steps 2-4: Detect drift and collect decisions (or load from plan)
+        let allDriftedResources;
+        let decisions;
+        if (options.applyPlan) {
+            // Apply a previously exported plan — skip drift detection and prompting
+            log('Loading remediation plan...');
+            const planJson = fs.readFileSync(path.resolve(options.applyPlan), 'utf-8');
+            const plan = (0, plan_1.loadPlan)(planJson, options.stackName);
+            const loaded = (0, plan_1.planToDecisions)(plan);
+            allDriftedResources = loaded.allDriftedResources;
+            decisions = loaded.decisions;
+            if (spinner)
+                spinner.start('Processing...');
+        }
+        else {
+            // Normal flow: detect drift and prompt interactively
+            // Step 2: Detect drift
+            log('Detecting stack drift...');
+            const detectionId = await client.detectDrift(stackInfo.stackId);
+            log('Waiting for drift detection to complete...');
+            const detectionResult = await client.waitForDriftDetection(detectionId);
+            if (detectionResult.status !== 'DETECTION_COMPLETE') {
+                result.errors.push(`Drift detection did not complete: ${detectionResult.status}`);
+                return result;
+            }
+            if (detectionResult.driftStatus === 'IN_SYNC') {
+                if (spinner)
+                    spinner.succeed('Stack is in sync - no drift detected');
+                result.success = true;
+                return result;
+            }
+            // Step 3: Get drifted resources and separate by type
+            log('Analyzing drifted resources...');
+            allDriftedResources = await client.getDriftedResources(stackInfo.stackId);
+            if (allDriftedResources.length === 0) {
+                if (spinner)
+                    spinner.succeed('No drifted resources found');
+                result.success = true;
+                return result;
+            }
+            // Filter to only importable resources
+            const modifiedResources = [];
+            const deletedResources = [];
+            for (const resource of allDriftedResources) {
+                if (!(0, eligible_resources_1.isResourceImportable)(resource.resourceType)) {
+                    result.skippedResources.push(resource.logicalResourceId);
+                    continue;
+                }
+                if (resource.stackResourceDriftStatus === 'DELETED') {
+                    deletedResources.push(resource);
+                }
+                else {
+                    modifiedResources.push(resource);
+                }
+            }
+            if (modifiedResources.length === 0 && deletedResources.length === 0) {
+                result.errors.push('All drifted resources are not eligible for import');
+                return result;
+            }
+            // Step 4: Interactive decisions
+            if (spinner)
+                spinner.stop();
+            decisions = await (0, interactive_1.promptForDecisions)(modifiedResources, deletedResources, options.yes ?? false);
+            if (spinner)
+                spinner.start('Processing...');
+            // Export plan if requested (exit without executing)
+            if (options.exportPlan) {
+                const planMetadata = {
+                    stackName: stackInfo.stackName,
+                    region: client.region,
+                    createdAt: new Date().toISOString(),
+                    toolVersion: packageVersion(),
+                    driftDetectionId: detectionId,
+                };
+                const plan = (0, plan_1.buildPlan)(planMetadata, decisions);
+                const planPath = path.resolve(options.exportPlan);
+                fs.writeFileSync(planPath, (0, plan_1.serializePlan)(plan));
+                if (spinner)
+                    spinner.succeed(`Plan exported to ${planPath}`);
+                result.success = true;
+                return result;
+            }
+        }
+        // Record skipped resources
+        for (const r of decisions.skip) {
+            result.skippedResources.push(r.logicalResourceId);
+        }
+        // If everything was skipped or cancelled, we're done
+        if (decisions.autofix.length === 0 && decisions.reimport.length === 0 && decisions.remove.length === 0) {
+            if (spinner)
+                spinner.succeed('No actions selected');
+            result.success = true;
+            return result;
+        }
+        // Step 5: Build resources to import from decisions
+        const resourceIdentifiers = await client.getResourceIdentifiers(originalTemplateBody);
+        // Autofix resources: use existing buildResourcesToImport
+        const { importable: autofixImportable, skipped: autofixSkipped } = (0, resource_importer_1.buildResourcesToImport)(decisions.autofix, resourceIdentifiers);
+        for (const s of autofixSkipped) {
+            if (!result.skippedResources.includes(s.logicalResourceId)) {
+                result.skippedResources.push(s.logicalResourceId);
+            }
+        }
+        // Reimport resources: build from user-provided physical IDs
+        const reimportImportable = [];
+        for (const { resource, physicalId } of decisions.reimport) {
+            const descriptor = (0, resource_importer_1.buildReimportDescriptor)(resource, physicalId, resourceIdentifiers);
+            if (descriptor) {
+                reimportImportable.push(descriptor);
+            }
+            else {
+                result.errors.push(`Could not determine import identifier for ${resource.logicalResourceId} from "${physicalId}"`);
+                result.skippedResources.push(resource.logicalResourceId);
+            }
+        }
+        // Combined importable list
+        const allImportable = [...autofixImportable, ...reimportImportable];
+        // If nothing to import AND nothing to remove, we're stuck
+        if (allImportable.length === 0 && decisions.remove.length === 0) {
+            result.errors.push('Could not determine import identifiers for any selected resources');
+            return result;
+        }
+        // Build the set of logical IDs that need removal from the template
+        // This includes everything being acted on (autofix, reimport, remove)
+        const logicalIdsToRemove = new Set([
+            ...autofixImportable.map((r) => r.LogicalResourceId),
+            ...reimportImportable.map((r) => r.LogicalResourceId),
+            ...decisions.remove.map((r) => r.logicalResourceId),
+        ]);
+        // Analyze cascade removals (resources with broken Ref/GetAtt to removed resources)
+        const cascadeRemovals = (0, template_transformer_1.analyzeCascadeRemovals)(originalTemplate, logicalIdsToRemove);
+        // Partition into permanent (depend on user-removed resources) vs temporary (depend on autofix/reimport)
+        const permanentlyRemovedIds = new Set(decisions.remove.map((r) => r.logicalResourceId));
+        const permanentCascade = cascadeRemovals.filter((c) => permanentlyRemovedIds.has(c.dependsOn));
+        const temporaryCascade = cascadeRemovals.filter((c) => !permanentlyRemovedIds.has(c.dependsOn));
+        if (cascadeRemovals.length > 0) {
+            if (spinner)
+                spinner.stop();
+            (0, interactive_1.displayCascadeWarning)(permanentCascade, temporaryCascade);
+            if (spinner)
+                spinner.start('Processing...');
+        }
+        // Dry run - show what would be done
+        if (options.dryRun) {
+            if (spinner)
+                spinner.info('Dry run - planned actions:');
+            if (allImportable.length > 0) {
+                console.log('\nResources to remediate:');
+                for (const resource of allImportable) {
+                    console.log(`  - ${resource.LogicalResourceId} (${resource.ResourceType})`);
+                    console.log(`    Identifier: ${JSON.stringify(resource.ResourceIdentifier)}`);
+                }
+            }
+            if (decisions.remove.length > 0) {
+                console.log('\nResources to remove from stack:');
+                for (const r of decisions.remove) {
+                    console.log(`  - ${r.logicalResourceId} (${r.resourceType})`);
+                }
+            }
+            if (permanentCascade.length > 0) {
+                console.log('\nResources permanently cascade-removed (broken references):');
+                for (const c of permanentCascade) {
+                    console.log(`  - ${c.logicalResourceId} (${c.resourceType}) -> depends on ${c.dependsOn}`);
+                }
+            }
+            if (temporaryCascade.length > 0) {
+                console.log('\nResources temporarily removed and recreated:');
+                for (const c of temporaryCascade) {
+                    console.log(`  - ${c.logicalResourceId} (${c.resourceType}) -> depends on ${c.dependsOn}`);
+                }
+            }
+            result.success = true;
+            result.remediatedResources = allImportable.map((r) => r.LogicalResourceId);
+            result.removedResources = [
+                ...decisions.remove.map((r) => r.logicalResourceId),
+                ...permanentCascade.map((c) => c.logicalResourceId),
+            ];
+            return result;
+        }
+        // Determine required capabilities
+        const resourceTypes = allImportable.map((r) => r.ResourceType);
+        const additionalCaps = (0, eligible_resources_1.getAllRequiredCapabilities)(resourceTypes);
+        const capabilities = [...new Set([...DEFAULT_CAPABILITIES, ...additionalCaps])];
+        // Save recovery checkpoint before any stack mutations
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupFileName = `.cfn-drift-remediate-backup-${stackInfo.stackName}-${timestamp}.json`;
+        const backupPath = path.resolve(process.cwd(), backupFileName);
+        const checkpoint = {
+            stackName: stackInfo.stackName,
+            stackId: stackInfo.stackId,
+            originalTemplateBody,
+            parameters: stackInfo.parameters,
+            driftedResourceIds: Array.from(logicalIdsToRemove),
+            timestamp: new Date().toISOString(),
+        };
+        fs.writeFileSync(backupPath, JSON.stringify(checkpoint, null, 2));
+        log(`Recovery checkpoint saved to: ${backupPath}`);
+        if (options.verbose) {
+            console.log(`Recovery checkpoint: ${backupPath}`);
+        }
+        // Step 6: Set DeletionPolicy: Retain on all resources
+        // DELETED resources must be removed from the template first — CloudFormation
+        // cannot update metadata on resources that no longer exist in AWS.
+        log('Setting DeletionPolicy: Retain on all resources...');
+        const deletedLogicalIds = new Set(allDriftedResources
+            .filter((r) => r.stackResourceDriftStatus === 'DELETED' && logicalIdsToRemove.has(r.logicalResourceId))
+            .map((r) => r.logicalResourceId));
+        let retainTemplate = (0, template_transformer_1.setRetentionOnAllResources)(originalTemplate);
+        if (deletedLogicalIds.size > 0) {
+            // Remove deleted resources and clean up their dangling references
+            const { template: cleanedTemplate } = (0, template_transformer_1.transformTemplateForRemoval)(retainTemplate, deletedLogicalIds, new Map());
+            retainTemplate = cleanedTemplate;
+        }
+        await client.updateStack(stackInfo.stackId, (0, template_transformer_1.stringifyTemplate)(retainTemplate), retainTemplate.Parameters ? stackInfo.parameters : undefined, capabilities);
+        // Step 7: Resolve cross-references to MODIFIED resources being removed
+        // (DELETED resources are already removed from the template, so only MODIFIED refs remain)
+        const modifiedIdsToRemove = new Set([...logicalIdsToRemove].filter((id) => !deletedLogicalIds.has(id)));
+        const references = (0, template_transformer_1.collectReferences)(retainTemplate, modifiedIdsToRemove);
+        let resolvedValues = new Map();
+        if (references.size > 0) {
+            log('Resolving references to drifted resources...');
+            const outputTemplate = (0, template_transformer_1.addResolutionOutputs)(retainTemplate, references);
+            await client.updateStack(stackInfo.stackId, (0, template_transformer_1.stringifyTemplate)(outputTemplate), outputTemplate.Parameters ? stackInfo.parameters : undefined, capabilities);
+            const updatedStackInfo = await client.getStackInfo(stackInfo.stackId);
+            resolvedValues = (0, template_transformer_1.parseResolvedOutputs)(updatedStackInfo.outputs || [], references);
+        }
+        // Step 8: Remove remaining (MODIFIED) resources from template
+        log('Removing resources from stack (resources retained in AWS)...');
+        const { template: removalTemplate } = (0, template_transformer_1.transformTemplateForRemoval)(retainTemplate, modifiedIdsToRemove, resolvedValues);
+        const removalParams = removalTemplate.Parameters ? stackInfo.parameters : undefined;
+        await client.updateStack(stackInfo.stackId, (0, template_transformer_1.stringifyTemplate)(removalTemplate), removalParams, capabilities);
+        // Step 9: Import resources (only if there are resources to import)
+        if (allImportable.length > 0) {
+            log('Preparing import template with actual resource state...');
+            // Build import template from the removal template (current stack state)
+            // and add back the resources being imported with their actual properties
+            const importTemplate = (0, utils_1.deepClone)(removalTemplate);
+            for (const importable of allImportable) {
+                const logicalId = importable.LogicalResourceId;
+                const originalResource = originalTemplate.Resources?.[logicalId];
+                if (!originalResource)
+                    continue;
+                // Start with original resource definition
+                importTemplate.Resources[logicalId] = (0, utils_1.deepClone)(originalResource);
+                // For autofix resources, override with actual (drifted) properties
+                const autofixResource = decisions.autofix.find((r) => r.logicalResourceId === logicalId);
+                if (autofixResource?.actualProperties && Object.keys(autofixResource.actualProperties).length > 0) {
+                    importTemplate.Resources[logicalId].Properties = autofixResource.actualProperties;
+                }
+                importTemplate.Resources[logicalId].DeletionPolicy = 'Retain';
+            }
+            // Ensure Retain on all resources in import template
+            for (const logicalId of Object.keys(importTemplate.Resources)) {
+                importTemplate.Resources[logicalId].DeletionPolicy = 'Retain';
+            }
+            log('Creating import change set...');
+            const changeSetName = await client.createImportChangeSet(stackInfo.stackName, (0, template_transformer_1.stringifyTemplate)(importTemplate), allImportable, capabilities);
+            log('Executing import...');
+            await client.executeChangeSet(stackInfo.stackName, changeSetName);
+        }
+        // Step 10: Restore template
+        if (decisions.remove.length > 0) {
+            // Some resources permanently removed — restore original MINUS removed resources
+            log('Restoring template (excluding removed resources)...');
+            const restoredTemplate = (0, utils_1.deepClone)(originalTemplate);
+            for (const r of decisions.remove) {
+                delete restoredTemplate.Resources[r.logicalResourceId];
+            }
+            // Clean up references and outputs pointing to removed resources
+            const { template: cleanedTemplate } = (0, template_transformer_1.transformTemplateForRemoval)(restoredTemplate, new Set(decisions.remove.map((r) => r.logicalResourceId)), resolvedValues);
+            // Restore original DeletionPolicy values (transformTemplateForRemoval sets Retain on all)
+            for (const [logicalId, resource] of Object.entries(cleanedTemplate.Resources || {})) {
+                const originalResource = originalTemplate.Resources?.[logicalId];
+                if (originalResource?.DeletionPolicy) {
+                    resource.DeletionPolicy = originalResource.DeletionPolicy;
+                }
+                else {
+                    delete resource.DeletionPolicy;
+                }
+            }
+            await client.updateStack(stackInfo.stackName, (0, template_transformer_1.stringifyTemplate)(cleanedTemplate), cleanedTemplate.Parameters ? stackInfo.parameters : undefined, capabilities);
+        }
+        else {
+            // No removals — restore exact original
+            log('Restoring original template...');
+            await client.updateStack(stackInfo.stackName, originalTemplateBody, stackInfo.parameters, capabilities);
+        }
+        result.success = true;
+        result.remediatedResources = allImportable.map((r) => r.LogicalResourceId);
+        result.removedResources = [
+            ...decisions.remove.map((r) => r.logicalResourceId),
+            ...permanentCascade.map((c) => c.logicalResourceId),
+        ];
+        if (options.verbose) {
+            console.log(`Remediation complete. Recovery checkpoint can be removed: ${backupPath}`);
+        }
+    }
+    catch (error) {
+        result.errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Ora } from 'ora';\nimport { CfnClientWrapper } from './lib/cfn-client';\nimport { isResourceImportable, getAllRequiredCapabilities } from './lib/eligible-resources';\nimport { displayCascadeWarning, promptForDecisions } from './lib/interactive';\nimport { buildPlan, serializePlan, loadPlan, planToDecisions } from './lib/plan';\nimport { buildResourcesToImport, buildReimportDescriptor } from './lib/resource-importer';\nimport {\n  parseTemplate,\n  stringifyTemplate,\n  collectReferences,\n  addResolutionOutputs,\n  parseResolvedOutputs,\n  setRetentionOnAllResources,\n  transformTemplateForRemoval,\n  analyzeCascadeRemovals,\n} from './lib/template-transformer';\nimport {\n  RemediationOptions,\n  RemediationResult,\n  RecoveryCheckpoint,\n  DriftedResource,\n  InteractiveDecisions,\n  ResourceToImport,\n} from './lib/types';\nimport { deepClone } from './lib/utils';\n\nconst DEFAULT_CAPABILITIES = ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM', 'CAPABILITY_AUTO_EXPAND'];\n\nfunction packageVersion(): string {\n  try {\n    const pkgPath = path.join(__dirname, '..', 'package.json');\n    return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;\n  } catch {\n    return 'unknown';\n  }\n}\n\n/**\n * Main remediation function that orchestrates the drift remediation process\n */\nexport async function remediate(\n  options: RemediationOptions,\n  spinner?: Ora,\n): Promise<RemediationResult> {\n  const client = new CfnClientWrapper({\n    region: options.region,\n    profile: options.profile,\n  });\n\n  const result: RemediationResult = {\n    success: false,\n    remediatedResources: [],\n    skippedResources: [],\n    removedResources: [],\n    errors: [],\n  };\n\n  const log = (message: string) => {\n    if (spinner) {\n      spinner.text = message;\n    } else if (options.verbose) {\n      console.log(message);\n    }\n  };\n\n  try {\n    // Step 1: Get stack info and original template\n    log('Fetching stack information...');\n    const stackInfo = await client.getStackInfo(options.stackName);\n\n    log('Fetching original template...');\n    const originalTemplateBody = await client.getTemplate(stackInfo.stackId, true);\n    const originalTemplate = parseTemplate(originalTemplateBody);\n\n    if (options.verbose) {\n      console.log(`Found stack: ${stackInfo.stackName} (${stackInfo.stackId})`);\n    }\n\n    // Steps 2-4: Detect drift and collect decisions (or load from plan)\n    let allDriftedResources: DriftedResource[];\n    let decisions: InteractiveDecisions;\n\n    if (options.applyPlan) {\n      // Apply a previously exported plan — skip drift detection and prompting\n      log('Loading remediation plan...');\n      const planJson = fs.readFileSync(path.resolve(options.applyPlan), 'utf-8');\n      const plan = loadPlan(planJson, options.stackName);\n      const loaded = planToDecisions(plan);\n      allDriftedResources = loaded.allDriftedResources;\n      decisions = loaded.decisions;\n\n      if (spinner) spinner.start('Processing...');\n    } else {\n      // Normal flow: detect drift and prompt interactively\n\n      // Step 2: Detect drift\n      log('Detecting stack drift...');\n      const detectionId = await client.detectDrift(stackInfo.stackId);\n\n      log('Waiting for drift detection to complete...');\n      const detectionResult = await client.waitForDriftDetection(detectionId);\n\n      if (detectionResult.status !== 'DETECTION_COMPLETE') {\n        result.errors.push(`Drift detection did not complete: ${detectionResult.status}`);\n        return result;\n      }\n\n      if (detectionResult.driftStatus === 'IN_SYNC') {\n        if (spinner) spinner.succeed('Stack is in sync - no drift detected');\n        result.success = true;\n        return result;\n      }\n\n      // Step 3: Get drifted resources and separate by type\n      log('Analyzing drifted resources...');\n      allDriftedResources = await client.getDriftedResources(stackInfo.stackId);\n\n      if (allDriftedResources.length === 0) {\n        if (spinner) spinner.succeed('No drifted resources found');\n        result.success = true;\n        return result;\n      }\n\n      // Filter to only importable resources\n      const modifiedResources: DriftedResource[] = [];\n      const deletedResources: DriftedResource[] = [];\n\n      for (const resource of allDriftedResources) {\n        if (!isResourceImportable(resource.resourceType)) {\n          result.skippedResources.push(resource.logicalResourceId);\n          continue;\n        }\n        if (resource.stackResourceDriftStatus === 'DELETED') {\n          deletedResources.push(resource);\n        } else {\n          modifiedResources.push(resource);\n        }\n      }\n\n      if (modifiedResources.length === 0 && deletedResources.length === 0) {\n        result.errors.push('All drifted resources are not eligible for import');\n        return result;\n      }\n\n      // Step 4: Interactive decisions\n      if (spinner) spinner.stop();\n\n      decisions = await promptForDecisions(\n        modifiedResources,\n        deletedResources,\n        options.yes ?? false,\n      );\n\n      if (spinner) spinner.start('Processing...');\n\n      // Export plan if requested (exit without executing)\n      if (options.exportPlan) {\n        const planMetadata = {\n          stackName: stackInfo.stackName,\n          region: client.region,\n          createdAt: new Date().toISOString(),\n          toolVersion: packageVersion(),\n          driftDetectionId: detectionId,\n        };\n        const plan = buildPlan(planMetadata, decisions);\n        const planPath = path.resolve(options.exportPlan);\n        fs.writeFileSync(planPath, serializePlan(plan));\n        if (spinner) spinner.succeed(`Plan exported to ${planPath}`);\n        result.success = true;\n        return result;\n      }\n    }\n\n    // Record skipped resources\n    for (const r of decisions.skip) {\n      result.skippedResources.push(r.logicalResourceId);\n    }\n\n    // If everything was skipped or cancelled, we're done\n    if (decisions.autofix.length === 0 && decisions.reimport.length === 0 && decisions.remove.length === 0) {\n      if (spinner) spinner.succeed('No actions selected');\n      result.success = true;\n      return result;\n    }\n\n    // Step 5: Build resources to import from decisions\n    const resourceIdentifiers = await client.getResourceIdentifiers(originalTemplateBody);\n\n    // Autofix resources: use existing buildResourcesToImport\n    const { importable: autofixImportable, skipped: autofixSkipped } =\n      buildResourcesToImport(decisions.autofix, resourceIdentifiers);\n\n    for (const s of autofixSkipped) {\n      if (!result.skippedResources.includes(s.logicalResourceId)) {\n        result.skippedResources.push(s.logicalResourceId);\n      }\n    }\n\n    // Reimport resources: build from user-provided physical IDs\n    const reimportImportable: ResourceToImport[] = [];\n    for (const { resource, physicalId } of decisions.reimport) {\n      const descriptor = buildReimportDescriptor(resource, physicalId, resourceIdentifiers);\n      if (descriptor) {\n        reimportImportable.push(descriptor);\n      } else {\n        result.errors.push(\n          `Could not determine import identifier for ${resource.logicalResourceId} from \"${physicalId}\"`,\n        );\n        result.skippedResources.push(resource.logicalResourceId);\n      }\n    }\n\n    // Combined importable list\n    const allImportable = [...autofixImportable, ...reimportImportable];\n\n    // If nothing to import AND nothing to remove, we're stuck\n    if (allImportable.length === 0 && decisions.remove.length === 0) {\n      result.errors.push('Could not determine import identifiers for any selected resources');\n      return result;\n    }\n\n    // Build the set of logical IDs that need removal from the template\n    // This includes everything being acted on (autofix, reimport, remove)\n    const logicalIdsToRemove = new Set([\n      ...autofixImportable.map((r) => r.LogicalResourceId),\n      ...reimportImportable.map((r) => r.LogicalResourceId),\n      ...decisions.remove.map((r) => r.logicalResourceId),\n    ]);\n\n    // Analyze cascade removals (resources with broken Ref/GetAtt to removed resources)\n    const cascadeRemovals = analyzeCascadeRemovals(originalTemplate, logicalIdsToRemove);\n\n    // Partition into permanent (depend on user-removed resources) vs temporary (depend on autofix/reimport)\n    const permanentlyRemovedIds = new Set(decisions.remove.map((r) => r.logicalResourceId));\n    const permanentCascade = cascadeRemovals.filter((c) => permanentlyRemovedIds.has(c.dependsOn));\n    const temporaryCascade = cascadeRemovals.filter((c) => !permanentlyRemovedIds.has(c.dependsOn));\n\n    if (cascadeRemovals.length > 0) {\n      if (spinner) spinner.stop();\n      displayCascadeWarning(permanentCascade, temporaryCascade);\n      if (spinner) spinner.start('Processing...');\n    }\n\n    // Dry run - show what would be done\n    if (options.dryRun) {\n      if (spinner) spinner.info('Dry run - planned actions:');\n      if (allImportable.length > 0) {\n        console.log('\\nResources to remediate:');\n        for (const resource of allImportable) {\n          console.log(`  - ${resource.LogicalResourceId} (${resource.ResourceType})`);\n          console.log(`    Identifier: ${JSON.stringify(resource.ResourceIdentifier)}`);\n        }\n      }\n      if (decisions.remove.length > 0) {\n        console.log('\\nResources to remove from stack:');\n        for (const r of decisions.remove) {\n          console.log(`  - ${r.logicalResourceId} (${r.resourceType})`);\n        }\n      }\n      if (permanentCascade.length > 0) {\n        console.log('\\nResources permanently cascade-removed (broken references):');\n        for (const c of permanentCascade) {\n          console.log(`  - ${c.logicalResourceId} (${c.resourceType}) -> depends on ${c.dependsOn}`);\n        }\n      }\n      if (temporaryCascade.length > 0) {\n        console.log('\\nResources temporarily removed and recreated:');\n        for (const c of temporaryCascade) {\n          console.log(`  - ${c.logicalResourceId} (${c.resourceType}) -> depends on ${c.dependsOn}`);\n        }\n      }\n      result.success = true;\n      result.remediatedResources = allImportable.map((r) => r.LogicalResourceId);\n      result.removedResources = [\n        ...decisions.remove.map((r) => r.logicalResourceId),\n        ...permanentCascade.map((c) => c.logicalResourceId),\n      ];\n      return result;\n    }\n\n    // Determine required capabilities\n    const resourceTypes = allImportable.map((r) => r.ResourceType);\n    const additionalCaps = getAllRequiredCapabilities(resourceTypes);\n    const capabilities = [...new Set([...DEFAULT_CAPABILITIES, ...additionalCaps])];\n\n    // Save recovery checkpoint before any stack mutations\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n    const backupFileName = `.cfn-drift-remediate-backup-${stackInfo.stackName}-${timestamp}.json`;\n    const backupPath = path.resolve(process.cwd(), backupFileName);\n    const checkpoint: RecoveryCheckpoint = {\n      stackName: stackInfo.stackName,\n      stackId: stackInfo.stackId,\n      originalTemplateBody,\n      parameters: stackInfo.parameters,\n      driftedResourceIds: Array.from(logicalIdsToRemove),\n      timestamp: new Date().toISOString(),\n    };\n    fs.writeFileSync(backupPath, JSON.stringify(checkpoint, null, 2));\n    log(`Recovery checkpoint saved to: ${backupPath}`);\n    if (options.verbose) {\n      console.log(`Recovery checkpoint: ${backupPath}`);\n    }\n\n    // Step 6: Set DeletionPolicy: Retain on all resources\n    // DELETED resources must be removed from the template first — CloudFormation\n    // cannot update metadata on resources that no longer exist in AWS.\n    log('Setting DeletionPolicy: Retain on all resources...');\n    const deletedLogicalIds = new Set(\n      allDriftedResources\n        .filter((r) => r.stackResourceDriftStatus === 'DELETED' && logicalIdsToRemove.has(r.logicalResourceId))\n        .map((r) => r.logicalResourceId),\n    );\n\n    let retainTemplate = setRetentionOnAllResources(originalTemplate);\n\n    if (deletedLogicalIds.size > 0) {\n      // Remove deleted resources and clean up their dangling references\n      const { template: cleanedTemplate } = transformTemplateForRemoval(\n        retainTemplate,\n        deletedLogicalIds,\n        new Map(), // no resolved values — just strip unresolvable references\n      );\n      retainTemplate = cleanedTemplate;\n    }\n\n    await client.updateStack(\n      stackInfo.stackId,\n      stringifyTemplate(retainTemplate),\n      retainTemplate.Parameters ? stackInfo.parameters : undefined,\n      capabilities,\n    );\n\n    // Step 7: Resolve cross-references to MODIFIED resources being removed\n    // (DELETED resources are already removed from the template, so only MODIFIED refs remain)\n    const modifiedIdsToRemove = new Set(\n      [...logicalIdsToRemove].filter((id) => !deletedLogicalIds.has(id)),\n    );\n    const references = collectReferences(retainTemplate, modifiedIdsToRemove);\n\n    let resolvedValues = new Map<string, unknown>();\n    if (references.size > 0) {\n      log('Resolving references to drifted resources...');\n\n      const outputTemplate = addResolutionOutputs(retainTemplate, references);\n      await client.updateStack(\n        stackInfo.stackId,\n        stringifyTemplate(outputTemplate),\n        outputTemplate.Parameters ? stackInfo.parameters : undefined,\n        capabilities,\n      );\n\n      const updatedStackInfo = await client.getStackInfo(stackInfo.stackId);\n      resolvedValues = parseResolvedOutputs(updatedStackInfo.outputs || [], references);\n    }\n\n    // Step 8: Remove remaining (MODIFIED) resources from template\n    log('Removing resources from stack (resources retained in AWS)...');\n    const { template: removalTemplate } = transformTemplateForRemoval(\n      retainTemplate,\n      modifiedIdsToRemove,\n      resolvedValues,\n    );\n\n    const removalParams = removalTemplate.Parameters ? stackInfo.parameters : undefined;\n    await client.updateStack(\n      stackInfo.stackId,\n      stringifyTemplate(removalTemplate),\n      removalParams,\n      capabilities,\n    );\n\n    // Step 9: Import resources (only if there are resources to import)\n    if (allImportable.length > 0) {\n      log('Preparing import template with actual resource state...');\n\n      // Build import template from the removal template (current stack state)\n      // and add back the resources being imported with their actual properties\n      const importTemplate = deepClone(removalTemplate);\n\n      for (const importable of allImportable) {\n        const logicalId = importable.LogicalResourceId;\n        const originalResource = originalTemplate.Resources?.[logicalId];\n        if (!originalResource) continue;\n\n        // Start with original resource definition\n        importTemplate.Resources[logicalId] = deepClone(originalResource);\n\n        // For autofix resources, override with actual (drifted) properties\n        const autofixResource = decisions.autofix.find((r) => r.logicalResourceId === logicalId);\n        if (autofixResource?.actualProperties && Object.keys(autofixResource.actualProperties).length > 0) {\n          importTemplate.Resources[logicalId].Properties = autofixResource.actualProperties;\n        }\n\n        importTemplate.Resources[logicalId].DeletionPolicy = 'Retain';\n      }\n\n      // Ensure Retain on all resources in import template\n      for (const logicalId of Object.keys(importTemplate.Resources)) {\n        importTemplate.Resources[logicalId].DeletionPolicy = 'Retain';\n      }\n\n      log('Creating import change set...');\n      const changeSetName = await client.createImportChangeSet(\n        stackInfo.stackName,\n        stringifyTemplate(importTemplate),\n        allImportable,\n        capabilities,\n      );\n\n      log('Executing import...');\n      await client.executeChangeSet(stackInfo.stackName, changeSetName);\n    }\n\n    // Step 10: Restore template\n    if (decisions.remove.length > 0) {\n      // Some resources permanently removed — restore original MINUS removed resources\n      log('Restoring template (excluding removed resources)...');\n      const restoredTemplate = deepClone(originalTemplate);\n      for (const r of decisions.remove) {\n        delete restoredTemplate.Resources[r.logicalResourceId];\n      }\n      // Clean up references and outputs pointing to removed resources\n      const { template: cleanedTemplate } = transformTemplateForRemoval(\n        restoredTemplate,\n        new Set(decisions.remove.map((r) => r.logicalResourceId)),\n        resolvedValues,\n      );\n      // Restore original DeletionPolicy values (transformTemplateForRemoval sets Retain on all)\n      for (const [logicalId, resource] of Object.entries(cleanedTemplate.Resources || {})) {\n        const originalResource = originalTemplate.Resources?.[logicalId];\n        if (originalResource?.DeletionPolicy) {\n          resource.DeletionPolicy = originalResource.DeletionPolicy;\n        } else {\n          delete resource.DeletionPolicy;\n        }\n      }\n      await client.updateStack(\n        stackInfo.stackName,\n        stringifyTemplate(cleanedTemplate),\n        cleanedTemplate.Parameters ? stackInfo.parameters : undefined,\n        capabilities,\n      );\n    } else {\n      // No removals — restore exact original\n      log('Restoring original template...');\n      await client.updateStack(\n        stackInfo.stackName,\n        originalTemplateBody,\n        stackInfo.parameters,\n        capabilities,\n      );\n    }\n\n    result.success = true;\n    result.remediatedResources = allImportable.map((r) => r.LogicalResourceId);\n    result.removedResources = [\n      ...decisions.remove.map((r) => r.logicalResourceId),\n      ...permanentCascade.map((c) => c.logicalResourceId),\n    ];\n\n    if (options.verbose) {\n      console.log(`Remediation complete. Recovery checkpoint can be removed: ${backupPath}`);\n    }\n\n  } catch (error) {\n    result.errors.push(error instanceof Error ? error.message : String(error));\n  }\n\n  return result;\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export { remediate } from './cli';
+export { CfnClientWrapper } from './lib/cfn-client';
+export * from './lib/types';
+export * from './lib/eligible-resources';
+export * from './lib/template-transformer';
+export * from './lib/resource-importer';
+export * from './lib/resource-identifier';
+export { promptForDecisions, formatDriftDiff, displayCascadeWarning } from './lib/interactive';
+export { buildPlan, serializePlan, loadPlan, planToDecisions } from './lib/plan';