@friggframework/devtools 2.0.0--canary.545.e256e95.0 → 2.0.0--canary.553.dc5f898.0

package/frigg-cli/repair-command/index.js

@@ -12,7 +12,7 @@
  */
 
 const path = require('path');
-const output = require('../utils/output');
+const readline = require('readline');
 
 // Domain and Application Layer
 const StackIdentifier = require('../../infrastructure/domains/health/domain/value-objects/stack-identifier');
@@ -34,6 +34,33 @@ const { TemplateParser } = require('../../infrastructure/domains/health/domain/s
 const { ImportTemplateGenerator } = require('../../infrastructure/domains/health/domain/services/import-template-generator');
 const { ImportProgressMonitor } = require('../../infrastructure/domains/health/domain/services/import-progress-monitor');
 
+/**
+ * Create readline interface for user prompts
+ * @returns {readline.Interface}
+ */
+function createReadlineInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+
+/**
+ * Prompt user for confirmation
+ * @param {string} question - Question to ask
+ * @returns {Promise<boolean>} User confirmed
+ */
+function confirm(question) {
+    const rl = createReadlineInterface();
+
+    return new Promise((resolve) => {
+        rl.question(`${question} (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+
 /**
  * Handle import repair operation using template comparison
  * @param {StackIdentifier} stackIdentifier - Stack identifier
@@ -44,13 +71,13 @@ async function handleImportRepair(stackIdentifier, report, options) {
     const orphanedResources = report.getOrphanedResources();
 
     if (orphanedResources.length === 0) {
-        output.success(' No orphaned resources to import');
+        console.log('\n✓ No orphaned resources to import');
         return { imported: 0, failed: 0 };
     }
 
-    output.info(`📦 Found ${orphanedResources.length} orphaned resource(s) to import:`);
+    console.log(`\n📦 Found ${orphanedResources.length} orphaned resource(s) to import:`);
     orphanedResources.forEach((resource, idx) => {
-        output.log(`  ${idx + 1}. ${resource.resourceType} - ${resource.physicalId}`);
+        console.log(`  ${idx + 1}. ${resource.resourceType} - ${resource.physicalId}`);
     });
 
     // Check for build template
@@ -58,12 +85,12 @@ async function handleImportRepair(stackIdentifier, report, options) {
     const buildTemplateExists = TemplateParser.buildTemplateExists();
 
     if (!buildTemplateExists) {
-        output.warn('️  Build template not found. Generating sequential logical IDs (not recommended).');
-        output.log(`   Run one of the following to generate build template:`);
-        output.log(`     • serverless package`);
-        output.log(`     • frigg build`);
-        output.log(`     • frigg deploy --stage dev`);
-        output.log(`   Then run 'frigg repair --import ${stackIdentifier.stackName}' again for correct logical IDs.\n`);
+        console.log('\n⚠️  Build template not found. Generating sequential logical IDs (not recommended).');
+        console.log(`   Run one of the following to generate build template:`);
+        console.log(`     • serverless package`);
+        console.log(`     • frigg build`);
+        console.log(`     • frigg deploy --stage dev`);
+        console.log(`   Then run 'frigg repair --import ${stackIdentifier.stackName}' again for correct logical IDs.\n`);
 
         // Fallback to sequential IDs (old behavior)
         const resourcesToImport = orphanedResources.map((resource, idx) => ({
@@ -73,9 +100,9 @@ async function handleImportRepair(stackIdentifier, report, options) {
         }));
 
         if (!options.yes) {
-            const confirmed = await output.confirm(`\nImport ${orphanedResources.length} orphaned resource(s) with sequential IDs?`);
+            const confirmed = await confirm(`\nImport ${orphanedResources.length} orphaned resource(s) with sequential IDs?`);
             if (!confirmed) {
-                output.log('Import cancelled');
+                console.log('Import cancelled by user');
                 return { imported: 0, failed: 0, cancelled: true };
             }
         }
@@ -84,20 +111,20 @@ async function handleImportRepair(stackIdentifier, report, options) {
         const resourceImporter = new AWSResourceImporter({ region: stackIdentifier.region });
         const repairUseCase = new RepairViaImportUseCase({ resourceDetector, resourceImporter });
 
-        output.info('🔧 Importing resources with sequential IDs...');
+        console.log('\n🔧 Importing resources with sequential IDs...');
         const importResult = await repairUseCase.importMultipleResources({
             stackIdentifier,
             resources: resourcesToImport,
         });
 
         if (importResult.success) {
-            output.success(` Successfully imported ${importResult.importedCount} resource(s)`);
+            console.log(`\n✓ Successfully imported ${importResult.importedCount} resource(s)`);
         } else {
-            output.log(`\n✗ Import failed: ${importResult.message}`);
+            console.log(`\n✗ Import failed: ${importResult.message}`);
             if (importResult.validationErrors && importResult.validationErrors.length > 0) {
-                output.log('\nValidation errors:');
+                console.log('\nValidation errors:');
                 importResult.validationErrors.forEach((error) => {
-                    output.log(`  • ${error.logicalId}: ${error.reason}`);
+                    console.log(`  • ${error.logicalId}: ${error.reason}`);
                 });
             }
         }
@@ -110,9 +137,9 @@ async function handleImportRepair(stackIdentifier, report, options) {
     }
 
     // Use template comparison to find correct logical IDs
-    output.info(`🔍 Analyzing templates to map orphaned resources to correct logical IDs...`);
-    output.log(`   Build template: ${buildTemplatePath}`);
-    output.log(`   Deployed template: CloudFormation (via AWS API)`);
+    console.log(`\n🔍 Analyzing templates to map orphaned resources to correct logical IDs...`);
+    console.log(`   Build template: ${buildTemplatePath}`);
+    console.log(`   Deployed template: CloudFormation (via AWS API)`);
 
     // Wire up use case with template comparison
     const stackRepository = new AWSStackRepository({ region: stackIdentifier.region });
@@ -132,31 +159,31 @@ async function handleImportRepair(stackIdentifier, report, options) {
     });
 
     if (!mappingResult.success) {
-        output.log(`\n✗ Mapping failed: ${mappingResult.message}`);
+        console.log(`\n✗ Mapping failed: ${mappingResult.message}`);
         return { imported: 0, failed: 0, success: false };
     }
 
     // Display mapping results
-    output.success(` Successfully mapped ${mappingResult.mappedCount} resource(s) to logical IDs:`);
+    console.log(`\n✅ Successfully mapped ${mappingResult.mappedCount} resource(s) to logical IDs:`);
     mappingResult.mappings.forEach((mapping) => {
-        output.log(`  • ${mapping.logicalId} ← ${mapping.physicalId} (${mapping.matchMethod}, ${mapping.confidence} confidence)`);
+        console.log(`  • ${mapping.logicalId} ← ${mapping.physicalId} (${mapping.matchMethod}, ${mapping.confidence} confidence)`);
     });
 
     if (mappingResult.unmappedCount > 0) {
-        output.warn(`️  Could not map ${mappingResult.unmappedCount} resource(s):`);
+        console.log(`\n⚠️  Could not map ${mappingResult.unmappedCount} resource(s):`);
         mappingResult.unmappedResources.forEach((resource) => {
-            output.log(`  • ${resource.resourceType} - ${resource.physicalId}`);
+            console.log(`  • ${resource.resourceType} - ${resource.physicalId}`);
         });
     }
 
     // Display warnings for multiple resources of same type
     if (mappingResult.warnings && mappingResult.warnings.length > 0) {
-        output.warn(`️  Warnings:`);
+        console.log(`\n⚠️  Warnings:`);
         mappingResult.warnings.forEach((warning) => {
-            output.log(`  • ${warning.message}`);
+            console.log(`  • ${warning.message}`);
             if (warning.type === 'MULTIPLE_RESOURCES') {
                 warning.resources.forEach((res) => {
-                    output.log(`      - ${res.logicalId} ← ${res.physicalId} (${res.matchMethod}, ${res.confidence})`);
+                    console.log(`      - ${res.logicalId} ← ${res.physicalId} (${res.matchMethod}, ${res.confidence})`);
                 });
             }
         });
@@ -164,20 +191,20 @@ async function handleImportRepair(stackIdentifier, report, options) {
 
     // Confirm with user (unless --yes flag)
     if (!options.yes) {
-        output.info(`📋 The following will be imported into CloudFormation:`);
+        console.log(`\n📋 The following will be imported into CloudFormation:`);
         mappingResult.resourcesToImport.forEach((resource) => {
-            output.log(`  • ${resource.LogicalResourceId} (${resource.ResourceType})`);
+            console.log(`  • ${resource.LogicalResourceId} (${resource.ResourceType})`);
         });
 
-        const confirmed = await output.confirm(`\nProceed with import of ${mappingResult.mappedCount} resource(s)?`);
+        const confirmed = await confirm(`\nProceed with import of ${mappingResult.mappedCount} resource(s)?`);
         if (!confirmed) {
-            output.log('Import cancelled');
+            console.log('Import cancelled by user');
             return { imported: 0, failed: 0, cancelled: true };
         }
     }
 
     // Execute actual CloudFormation import operation
-    output.info(`🔧 Preparing CloudFormation import operation...`);
+    console.log(`\n🔧 Preparing CloudFormation import operation...`);
 
     // Wire up ExecuteResourceImportUseCase
     const templateParser = new TemplateParser();
@@ -210,38 +237,38 @@ async function handleImportRepair(stackIdentifier, report, options) {
         buildTemplatePath,
         onProgress: (progress) => {
             if (progress.step === 'generate_template' && progress.status === 'in_progress') {
-                output.log('  • Generating import template...');
+                console.log('  • Generating import template...');
             } else if (progress.step === 'generate_template' && progress.status === 'complete') {
-                output.log('  ✓ Template generated');
+                console.log('  ✓ Template generated');
             } else if (progress.step === 'create_change_set' && progress.status === 'in_progress') {
-                output.log('  • Creating CloudFormation change set...');
+                console.log('  • Creating CloudFormation change set...');
             } else if (progress.step === 'create_change_set' && progress.status === 'complete') {
-                output.log(`  ✓ Change set created: ${progress.changeSetName}`);
+                console.log(`  ✓ Change set created: ${progress.changeSetName}`);
             } else if (progress.step === 'wait_change_set' && progress.status === 'in_progress') {
-                output.log('  • Waiting for change set...');
+                console.log('  • Waiting for change set...');
             } else if (progress.step === 'wait_change_set' && progress.status === 'complete') {
-                output.log('  ✓ Change set ready');
+                console.log('  ✓ Change set ready');
             } else if (progress.step === 'execute_import' && progress.status === 'in_progress') {
                 if (progress.resourceProgress) {
                     const { logicalId, status, progress: resourceProgress, total } = progress.resourceProgress;
-                    output.log(`  • Importing resource ${resourceProgress}/${total}: ${logicalId} (${status})`);
+                    console.log(`  • Importing resource ${resourceProgress}/${total}: ${logicalId} (${status})`);
                 } else {
-                    output.log('  • Executing import operation...');
+                    console.log('  • Executing import operation...');
                 }
             } else if (progress.step === 'execute_import' && progress.status === 'complete') {
-                output.log('  ✓ Import operation complete');
+                console.log('  ✓ Import operation complete');
             } else if (progress.step === 'verify' && progress.status === 'in_progress') {
-                output.log('  • Verifying imported resources...');
+                console.log('  • Verifying imported resources...');
             } else if (progress.step === 'verify' && progress.status === 'complete') {
-                output.log('  ✓ Verification complete');
+                console.log('  ✓ Verification complete');
             }
         },
     });
 
     if (importResult.success) {
-        output.success(` Successfully imported ${importResult.importedCount} resource(s) into CloudFormation!`);
-        output.log(`   Stack status: ${importResult.stackStatus}`);
-        output.log(`   Change set: ${importResult.changeSetName}`);
+        console.log(`\n✅ Successfully imported ${importResult.importedCount} resource(s) into CloudFormation!`);
+        console.log(`   Stack status: ${importResult.stackStatus}`);
+        console.log(`   Change set: ${importResult.changeSetName}`);
 
         return {
             imported: importResult.importedCount,
@@ -249,8 +276,8 @@ async function handleImportRepair(stackIdentifier, report, options) {
             success: true,
         };
     } else {
-        output.error(` Import operation failed: ${importResult.error}`);
-        output.error(`   Failed at step: ${importResult.step}`);
+        console.error(`\n❌ Import operation failed: ${importResult.error}`);
+        console.error(`   Failed at step: ${importResult.step}`);
 
         return {
             imported: 0,
@@ -271,7 +298,7 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
     const driftedResources = report.getDriftedResources();
 
     if (driftedResources.length === 0) {
-        output.success(' No property drift to reconcile');
+        console.log('\n✓ No property drift to reconcile');
         return { reconciled: 0, failed: 0 };
     }
 
@@ -284,12 +311,12 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
         totalMismatches += issues.length;
     });
 
-    output.info(`🔧 Found ${driftedResources.length} drifted resource(s) with ${totalMismatches} property mismatch(es):`);
+    console.log(`\n🔧 Found ${driftedResources.length} drifted resource(s) with ${totalMismatches} property mismatch(es):`);
     driftedResources.forEach((resource) => {
         const issues = report.issues.filter(
             (issue) => issue.type === 'PROPERTY_MISMATCH' && issue.resourceId === resource.physicalId
         );
-        output.log(`  • ${resource.logicalId} (${resource.resourceType}): ${issues.length} mismatch(es)`);
+        console.log(`  • ${resource.logicalId} (${resource.resourceType}): ${issues.length} mismatch(es)`);
     });
 
     // Determine mode (template or resource)
@@ -298,14 +325,14 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
         ? 'Update CloudFormation template to match actual resource state'
         : 'Update cloud resources to match CloudFormation template';
 
-    output.log(`\nReconciliation mode: ${mode}`);
-    output.log(`  ${modeDescription}`);
+    console.log(`\nReconciliation mode: ${mode}`);
+    console.log(`  ${modeDescription}`);
 
     // Confirm with user (unless --yes flag)
     if (!options.yes) {
-        const confirmed = await output.confirm(`\nReconcile ${totalMismatches} property mismatch(es) in ${mode} mode?`);
+        const confirmed = await confirm(`\nReconcile ${totalMismatches} property mismatch(es) in ${mode} mode?`);
         if (!confirmed) {
-            output.log('Reconciliation cancelled');
+            console.log('Reconciliation cancelled by user');
             return { reconciled: 0, failed: 0, cancelled: true };
         }
     }
@@ -319,7 +346,7 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
     const reconcileUseCase = new ReconcilePropertiesUseCase({ propertyReconciler });
 
     // Execute reconciliation for each drifted resource
-    output.info('🔧 Reconciling property drift...');
+    console.log('\n🔧 Reconciling property drift...');
     let reconciledCount = 0;
     let failedCount = 0;
     let skippedImmutableCount = 0;
@@ -364,56 +391,56 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
                 });
             }
 
-            output.log(`  ✓ ${resource.logicalId}: Reconciled ${result.reconciledCount} property(ies)`);
+            console.log(`  ✓ ${resource.logicalId}: Reconciled ${result.reconciledCount} property(ies)`);
             if (result.skippedCount > 0) {
-                output.log(`    ⚠ Skipped ${result.skippedCount} immutable property(ies) - requires manual intervention`);
+                console.log(`    ⚠ Skipped ${result.skippedCount} immutable property(ies) - requires manual intervention`);
             }
 
             // Debug: Log full result if reconciledCount is 0 but we expected properties
             if (process.env.DEBUG_RECONCILE && result.reconciledCount === 0 && mismatches.length > 0) {
-                output.log(`    [DEBUG] Expected ${mismatches.length} mismatches, got result:`, JSON.stringify(result, null, 2));
+                console.log(`    [DEBUG] Expected ${mismatches.length} mismatches, got result:`, JSON.stringify(result, null, 2));
             }
         } catch (error) {
             // Count failed properties, not just the resource
             failedCount += mismatches.length;
-            output.log(`  ✗ ${resource.logicalId}: ${error.message}`);
+            console.log(`  ✗ ${resource.logicalId}: ${error.message}`);
 
             // Debug: Log full error
             if (process.env.DEBUG_RECONCILE) {
-                output.log(`    [DEBUG] Error stack:`, error.stack);
+                console.log(`    [DEBUG] Error stack:`, error.stack);
             }
         }
     }
 
     // Report results
-    output.log(''); // Blank line before summary
+    console.log(''); // Blank line before summary
 
     if (reconciledCount > 0) {
-        output.log(`✅ Reconciled ${reconciledCount} property(ies)`);
+        console.log(`✅ Reconciled ${reconciledCount} property(ies)`);
     }
 
     if (skippedImmutableCount > 0) {
-        output.warn(` ${skippedImmutableCount} immutable property(ies) require manual intervention:`);
+        console.log(`\n⚠ ${skippedImmutableCount} immutable property(ies) require manual intervention:`);
         immutableProperties.forEach(prop => {
-            output.log(`  • ${prop.logicalId}.${prop.propertyPath}`);
-            output.log(`    Template: ${JSON.stringify(prop.expectedValue)}`);
-            output.log(`    Actual:   ${JSON.stringify(prop.actualValue)}`);
+            console.log(`  • ${prop.logicalId}.${prop.propertyPath}`);
+            console.log(`    Template: ${JSON.stringify(prop.expectedValue)}`);
+            console.log(`    Actual:   ${JSON.stringify(prop.actualValue)}`);
         });
 
-        output.info(`💡 To resolve immutable property drift:`);
-        output.log(`   1. These properties require resource replacement (cannot be updated in place)`);
-        output.log(`   2. Options:`);
-        output.log(`      a) Accept the drift - update your local template to match actual values`);
-        output.log(`      b) Replace the resource - delete and recreate via CloudFormation`);
-        output.log(`      c) Use import workflow - remove from stack, then re-import with correct values`);
-        output.log(`\n   For automated import workflow (coming soon):`);
-        output.log(`      frigg repair --import-drift ${stackIdentifier.stackName}`);
+        console.log(`\n💡 To resolve immutable property drift:`);
+        console.log(`   1. These properties require resource replacement (cannot be updated in place)`);
+        console.log(`   2. Options:`);
+        console.log(`      a) Accept the drift - update your local template to match actual values`);
+        console.log(`      b) Replace the resource - delete and recreate via CloudFormation`);
+        console.log(`      c) Use import workflow - remove from stack, then re-import with correct values`);
+        console.log(`\n   For automated import workflow (coming soon):`);
+        console.log(`      frigg repair --import-drift ${stackIdentifier.stackName}`);
     }
 
     if (failedCount === 0 && skippedImmutableCount === 0) {
-        output.log(`✓ Successfully reconciled all ${reconciledCount} property mismatch(es)`);
+        console.log(`✓ Successfully reconciled all ${reconciledCount} property mismatch(es)`);
     } else {
-        output.warn(` Reconciled ${reconciledCount} property(ies), ${failedCount} failed`);
+        console.log(`\n⚠ Reconciled ${reconciledCount} property(ies), ${failedCount} failed`);
     }
 
     return { reconciled: reconciledCount, failed: failedCount, success: failedCount === 0 };
@@ -426,28 +453,21 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
  */
 async function repairCommand(stackName, options = {}) {
     try {
-        // Guard: repair only works with AWS (CloudFormation stacks)
-        if (isNonAwsProvider()) {
-            output.error('The repair command is only available for AWS deployments.');
-            output.log('Your appDefinition uses a non-AWS provider.');
-            process.exit(1);
-        }
-
         // Validate required parameter
         if (!stackName) {
-            output.error('Error: Stack name is required');
-            output.log('Usage: frigg repair [options] <stack-name>');
-            output.log('Options:');
-            output.log('  --import      Import orphaned resources');
-            output.log('  --reconcile   Reconcile property drift');
-            output.log('  --yes         Skip confirmation prompts');
+            console.error('Error: Stack name is required');
+            console.log('Usage: frigg repair [options] <stack-name>');
+            console.log('Options:');
+            console.log('  --import      Import orphaned resources');
+            console.log('  --reconcile   Reconcile property drift');
+            console.log('  --yes         Skip confirmation prompts');
             process.exit(1);
         }
 
         // Validate at least one repair operation is selected
         if (!options.import && !options.reconcile) {
-            output.error('Error: At least one repair operation must be specified (--import or --reconcile)');
-            output.log('Usage: frigg repair [options] <stack-name>');
+            console.error('Error: At least one repair operation must be specified (--import or --reconcile)');
+            console.log('Usage: frigg repair [options] <stack-name>');
             process.exit(1);
         }
 
@@ -455,13 +475,13 @@ async function repairCommand(stackName, options = {}) {
         const region = options.region || process.env.AWS_REGION || 'us-east-1';
         const verbose = options.verbose || false;
 
-        output.info(`🏥 Running Frigg Repair on stack: ${stackName} (${region})`);
+        console.log(`\n🏥 Running Frigg Repair on stack: ${stackName} (${region})`);
 
         // 1. Create stack identifier
         const stackIdentifier = new StackIdentifier({ stackName, region });
 
         // 2. Run health check first to identify issues
-        output.info('🔍 Running health check to identify issues...');
+        console.log('\n🔍 Running health check to identify issues...');
 
         const stackRepository = new AWSStackRepository({ region });
         const resourceDetector = new AWSResourceDetector({ region });
@@ -477,8 +497,8 @@ async function repairCommand(stackName, options = {}) {
 
         const report = await runHealthCheckUseCase.execute({ stackIdentifier });
 
-        output.log(`\nHealth Score: ${report.healthScore.value}/100 (${report.healthScore.qualitativeAssessment()})`);
-        output.log(`Issues: ${report.getIssueCount()} total (${report.getCriticalIssueCount()} critical)`);
+        console.log(`\nHealth Score: ${report.healthScore.value}/100 (${report.healthScore.qualitativeAssessment()})`);
+        console.log(`Issues: ${report.getIssueCount()} total (${report.getCriticalIssueCount()} critical)`);
 
         // 3. Execute requested repair operations
         const results = {
@@ -504,24 +524,24 @@ async function repairCommand(stackName, options = {}) {
         }
 
         // 4. Final summary
-        output.log('\n' + '═'.repeat(80));
-        output.log('Repair Summary:');
+        console.log('\n' + '═'.repeat(80));
+        console.log('Repair Summary:');
         if (options.import) {
-            output.log(`  Imported:    ${results.imported} resource(s)`);
+            console.log(`  Imported:    ${results.imported} resource(s)`);
         }
         if (options.reconcile) {
-            output.log(`  Reconciled:  ${results.reconciled} property(ies)`);
+            console.log(`  Reconciled:  ${results.reconciled} property(ies)`);
         }
-        output.log(`  Failed:      ${results.failed}`);
-        output.log('═'.repeat(80));
+        console.log(`  Failed:      ${results.failed}`);
+        console.log('═'.repeat(80));
 
         // Run health check again to verify repairs
-        output.info('🔍 Running health check to verify repairs...');
+        console.log('\n🔍 Running health check to verify repairs...');
         const verifyReport = await runHealthCheckUseCase.execute({ stackIdentifier });
-        output.log(`\nNew Health Score: ${verifyReport.healthScore.value}/100 (${verifyReport.healthScore.qualitativeAssessment()})`);
+        console.log(`\nNew Health Score: ${verifyReport.healthScore.value}/100 (${verifyReport.healthScore.qualitativeAssessment()})`);
 
         if (verifyReport.healthScore.value > report.healthScore.value) {
-            output.success(` Health improved by ${verifyReport.healthScore.value - report.healthScore.value} points!`);
+            console.log(`\n✓ Health improved by ${verifyReport.healthScore.value - report.healthScore.value} points!`);
         }
 
         // 5. Exit with appropriate code
@@ -531,27 +551,14 @@ async function repairCommand(stackName, options = {}) {
             process.exit(0);
         }
     } catch (error) {
-        output.error(` Repair failed: ${error.message}`);
+        console.error(`\n✗ Repair failed: ${error.message}`);
 
         if (options.verbose && error.stack) {
-            output.error(`\nStack trace:\n${error.stack}`);
+            console.error(`\nStack trace:\n${error.stack}`);
         }
 
         process.exit(1);
     }
 }
 
-/**
- * Check if the current appDefinition uses a non-AWS provider.
- */
-function isNonAwsProvider() {
-    try {
-        const { loadProviderForCli } = require('../utils/provider-helper');
-        const result = loadProviderForCli();
-        return result && result.providerName !== 'aws';
-    } catch {
-        return false;
-    }
-}
-
 module.exports = { repairCommand };