runbooks 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

runbooks/finops/ebs_optimizer.py

@@ -166,15 +166,8 @@ class EBSOptimizer:
             profile_name=get_profile_for_operation("operational", profile_name)
         )
         
-        # EBS pricing (per GB per month, as of 2024)
-        self.ebs_pricing = {
-            'gp2': 0.10,    # $0.10/GB/month
-            'gp3': 0.08,    # $0.08/GB/month (20% cheaper than GP2)
-            'io1': 0.125,   # $0.125/GB/month
-            'io2': 0.125,   # $0.125/GB/month
-            'st1': 0.045,   # $0.045/GB/month
-            'sc1': 0.025,   # $0.025/GB/month
-        }
+        # EBS pricing using dynamic AWS pricing engine for universal compatibility
+        self.ebs_pricing = self._initialize_dynamic_ebs_pricing()
         
         # GP3 conversion savings percentage
         self.gp3_savings_percentage = 0.20  # 20% savings GP2→GP3
@@ -184,6 +177,60 @@ class EBSOptimizer:
         self.low_usage_threshold_bytes = 1_000_000  # 1MB per day
         self.analysis_period_days = 7
         
+    def _initialize_dynamic_ebs_pricing(self) -> Dict[str, float]:
+        """Initialize dynamic EBS pricing using AWS pricing engine for universal compatibility."""
+        try:
+            from ..common.aws_pricing import get_service_monthly_cost
+            
+            # Get dynamic pricing for common EBS volume types in us-east-1 (base region)
+            base_region = "us-east-1"
+            
+            return {
+                'gp2': get_service_monthly_cost("ebs_gp2", base_region, self.profile_name),
+                'gp3': get_service_monthly_cost("ebs_gp3", base_region, self.profile_name),
+                'io1': get_service_monthly_cost("ebs_io1", base_region, self.profile_name),
+                'io2': get_service_monthly_cost("ebs_io2", base_region, self.profile_name),
+                'st1': get_service_monthly_cost("ebs_st1", base_region, self.profile_name),
+                'sc1': get_service_monthly_cost("ebs_sc1", base_region, self.profile_name),
+            }
+        except Exception as e:
+            print_warning(f"Dynamic EBS pricing initialization failed: {e}")
+            print_warning("Attempting AWS Pricing API fallback with universal profile support")
+            
+            try:
+                from ..common.aws_pricing import get_aws_pricing_engine
+                
+                # Use AWS Pricing API with profile support for universal compatibility
+                pricing_engine = get_aws_pricing_engine(profile=self.profile_name, enable_fallback=True)
+                
+                # Get actual AWS pricing instead of hardcoded values
+                gp2_pricing = pricing_engine.get_ebs_pricing("gp2", "us-east-1")
+                gp3_pricing = pricing_engine.get_ebs_pricing("gp3", "us-east-1")
+                io1_pricing = pricing_engine.get_ebs_pricing("io1", "us-east-1")
+                io2_pricing = pricing_engine.get_ebs_pricing("io2", "us-east-1")
+                st1_pricing = pricing_engine.get_ebs_pricing("st1", "us-east-1")
+                sc1_pricing = pricing_engine.get_ebs_pricing("sc1", "us-east-1")
+                
+                return {
+                    'gp2': gp2_pricing.monthly_cost_per_gb,
+                    'gp3': gp3_pricing.monthly_cost_per_gb,
+                    'io1': io1_pricing.monthly_cost_per_gb,
+                    'io2': io2_pricing.monthly_cost_per_gb,
+                    'st1': st1_pricing.monthly_cost_per_gb,
+                    'sc1': sc1_pricing.monthly_cost_per_gb,
+                }
+                
+            except Exception as pricing_error:
+                print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine EBS pricing without AWS API access: {pricing_error}")
+                print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
+                
+                # Return error state instead of hardcoded values to maintain enterprise compliance
+                raise RuntimeError(
+                    "Universal compatibility mode requires dynamic AWS pricing API access. "
+                    "Please ensure your AWS profile has pricing:GetProducts permissions or configure "
+                    "appropriate billing/management profile access."
+                )
+        
     async def analyze_ebs_volumes(self, dry_run: bool = True) -> EBSOptimizerResults:
         """
         Comprehensive EBS volume cost optimization analysis.

runbooks/finops/enhanced_trend_visualization.py

@@ -409,10 +409,15 @@ if __name__ == "__main__":
     console.print("[bold bright_cyan]🚀 CloudOps Runbooks - Enhanced Trend Analysis[/]")
     console.print("[dim]QA Testing Specialist Implementation - Reference Image Compliance[/]")
 
+    import os
+    # Use environment-driven values for universal compatibility
+    account_id = os.getenv("AWS_ACCOUNT_ID", "123456789012")
+    profile = os.getenv("SINGLE_AWS_PROFILE", "default-single-profile")
+    
     visualizer.create_enhanced_trend_display(
         monthly_costs=trend_data,
-        account_id="499201730520",
-        profile="ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
+        account_id=account_id,
+        profile=profile,
     )
 
     # Export to JSON (contract compliance)

runbooks/finops/finops_dashboard.py

@@ -22,7 +22,8 @@ AWS_AVAILABLE = True
 
 def get_aws_profiles() -> List[str]:
     """Stub implementation - use dashboard_runner.py instead."""
-    return ["default", "ams-admin-Billing-ReadOnlyAccess-909135376185"]
+    import os
+    return ["default", os.getenv("BILLING_PROFILE", "default-billing-profile")]
 
 
 def get_account_id(profile: str = "default") -> str:
@@ -46,10 +47,10 @@ class FinOpsConfig:
     include_budget_data: bool = True
     include_resource_analysis: bool = True
     
-    # Legacy compatibility properties with environment variable support
-    billing_profile: str = "ams-admin-Billing-ReadOnlyAccess-909135376185"
-    management_profile: str = "ams-admin-ReadOnlyAccess-909135376185"
-    operational_profile: str = "ams-centralised-ops-ReadOnlyAccess-335083429030"
+    # Legacy compatibility properties with universal environment support
+    billing_profile: str = field(default_factory=lambda: os.getenv("BILLING_PROFILE", "default-billing-profile"))
+    management_profile: str = field(default_factory=lambda: os.getenv("MANAGEMENT_PROFILE", "default-management-profile"))
+    operational_profile: str = field(default_factory=lambda: os.getenv("CENTRALISED_OPS_PROFILE", "default-ops-profile"))
     
     # Additional expected attributes from tests
     time_range_days: int = 30

runbooks/finops/iam_guidance.py

@@ -11,6 +11,8 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from runbooks.common import get_aws_cli_example_period
+
 console = Console()
 
 
@@ -311,6 +313,9 @@ def handle_cost_explorer_error(error: Exception, profile_name: Optional[str] = N
 
 def _display_single_account_cost_explorer_guidance(error: Exception, profile_name: Optional[str] = None):
     """Display context-aware guidance for single account Cost Explorer limitations."""
+    
+    # Get dynamic date period for CLI examples
+    start_date, end_date = get_aws_cli_example_period()
 
     # Main explanation panel
     explanation_panel = Panel(
@@ -354,7 +359,7 @@ def _display_single_account_cost_explorer_guidance(error: Exception, profile_nam
         f"[green]✅ Recommended Solutions:[/green]\n\n"
         f"{solution_commands}\n\n"
         f"[bold]🎯 Quick Test Commands:[/bold]\n"
-        f"• Test billing access: `aws ce get-cost-and-usage --time-period Start=2024-01-01,End=2024-01-02 --granularity MONTHLY --metrics UnblendedCost --profile your-billing-profile`\n"
+        f"• Test billing access: `aws ce get-cost-and-usage --time-period Start={start_date},End={end_date} --granularity MONTHLY --metrics UnblendedCost --profile your-billing-profile`\n"
         f"• List available profiles: `aws configure list-profiles`\n"
         f"• Check current identity: `aws sts get-caller-identity --profile {profile_name or 'your-profile'}`\n\n"
         f"[bold]💡 Alternative Approach:[/bold]\n"

runbooks/finops/nat_gateway_optimizer.py

@@ -143,7 +143,7 @@ class NATGatewayOptimizer:
         # NAT Gateway pricing - using dynamic pricing engine
         # Base monthly cost calculation (will be applied per region)
         self._base_monthly_cost_us_east_1 = get_service_monthly_cost("nat_gateway", "us-east-1")
-        self.nat_gateway_data_processing_cost = 0.045  # $0.045/GB (data transfer pricing)
+        self.nat_gateway_data_processing_cost = get_service_monthly_cost("data_transfer", "us-east-1")  # Dynamic data transfer pricing
         
         # Enterprise thresholds for optimization recommendations
         self.low_usage_threshold_connections = 10  # Active connections per day
@@ -155,9 +155,9 @@ class NATGatewayOptimizer:
         try:
             return get_service_monthly_cost("nat_gateway", region)
         except Exception:
-            # Fallback to regional cost calculation
+            # Fallback to regional cost calculation using dynamic pricing
             from ..common.aws_pricing import calculate_regional_cost
-            return calculate_regional_cost(self._base_monthly_cost_us_east_1, region)
+            return calculate_regional_cost(self._base_monthly_cost_us_east_1, region, "nat_gateway", self.profile_name)
         
     async def analyze_nat_gateways(self, dry_run: bool = True) -> NATGatewayOptimizerResults:
         """
@@ -778,39 +778,58 @@ class EnhancedVPCCostOptimizer:
         self.cost_model = self._initialize_dynamic_cost_model()
     
     def _initialize_dynamic_cost_model(self) -> Dict[str, float]:
-        """Initialize dynamic cost model using AWS pricing engine."""
+        """Initialize dynamic cost model using AWS pricing engine with universal compatibility."""
         try:
             # Get base pricing for us-east-1, then apply regional multipliers as needed
             base_region = "us-east-1"
             
             return {
-                "nat_gateway_monthly": get_service_monthly_cost("nat_gateway", base_region),
-                "nat_gateway_data_processing": get_service_monthly_cost("data_transfer", base_region),
-                "transit_gateway_monthly": get_service_monthly_cost("transit_gateway", base_region),
-                "vpc_endpoint_monthly": get_service_monthly_cost("vpc_endpoint", base_region),
-                "data_transfer_regional": get_service_monthly_cost("data_transfer", base_region),
-                "data_transfer_internet": get_service_monthly_cost("data_transfer", base_region) * 4.5,  # Internet is ~4.5x higher
+                "nat_gateway_monthly": get_service_monthly_cost("nat_gateway", base_region, self.profile),
+                "nat_gateway_data_processing": get_service_monthly_cost("data_transfer", base_region, self.profile),
+                "transit_gateway_monthly": get_service_monthly_cost("transit_gateway", base_region, self.profile),
+                "vpc_endpoint_monthly": get_service_monthly_cost("vpc_endpoint", base_region, self.profile),
+                "vpc_endpoint_interface_hourly": get_service_monthly_cost("vpc_endpoint_interface", base_region, self.profile) / (24 * 30),
+                "transit_gateway_attachment_hourly": get_service_monthly_cost("transit_gateway_attachment", base_region, self.profile) / (24 * 30),
+                "data_transfer_regional": get_service_monthly_cost("data_transfer", base_region, self.profile),
+                "data_transfer_internet": get_service_monthly_cost("data_transfer", base_region, self.profile) * 4.5,  # Internet is ~4.5x higher
             }
         except Exception as e:
             print_warning(f"Dynamic pricing initialization failed: {e}")
-            # Fallback to regional cost calculation
-            from ..common.aws_pricing import calculate_regional_cost
-            base_costs = {
-                "nat_gateway_hourly": 0.045,
-                "nat_gateway_data_processing": 0.045,  # per GB
-                "transit_gateway_monthly": 36.50,
-                "transit_gateway_attachment_hourly": 0.05,
-                "vpc_endpoint_interface_hourly": 0.01,
-                "data_transfer_regional": 0.01,  # per GB within region
-                "data_transfer_cross_region": 0.02,  # per GB cross-region
-                "data_transfer_internet": 0.09  # per GB to internet
-            }
+            print_warning("Attempting AWS Pricing API fallback with universal profile support")
+            # Enhanced fallback with AWS Pricing API integration
+            from ..common.aws_pricing import get_aws_pricing_engine, AWSOfficialPricingEngine
             
-            # Apply regional multipliers to fallback costs
-            return {
-                key: calculate_regional_cost(value, "us-east-1") 
-                for key, value in base_costs.items()
-            }
+            try:
+                # Use AWS Pricing API with profile support for universal compatibility
+                pricing_engine = get_aws_pricing_engine(profile=self.profile, enable_fallback=True)
+                
+                # Get actual AWS pricing instead of hardcoded values
+                nat_gateway_pricing = pricing_engine.get_nat_gateway_pricing("us-east-1")
+                transit_gateway_pricing = pricing_engine.get_transit_gateway_pricing("us-east-1")
+                vpc_endpoint_pricing = pricing_engine.get_vpc_endpoint_pricing("us-east-1")
+                data_transfer_pricing = pricing_engine.get_data_transfer_pricing("us-east-1", "internet")
+                
+                return {
+                    "nat_gateway_monthly": nat_gateway_pricing.monthly_cost,
+                    "nat_gateway_data_processing": data_transfer_pricing.cost_per_gb,
+                    "transit_gateway_monthly": transit_gateway_pricing.monthly_cost,
+                    "transit_gateway_attachment_hourly": transit_gateway_pricing.attachment_hourly_cost,
+                    "vpc_endpoint_interface_hourly": vpc_endpoint_pricing.interface_hourly_cost,
+                    "data_transfer_regional": data_transfer_pricing.cost_per_gb * 0.1,  # Regional is ~10% of internet cost
+                    "data_transfer_cross_region": data_transfer_pricing.cost_per_gb * 0.2,  # Cross-region is ~20% of internet cost
+                    "data_transfer_internet": data_transfer_pricing.cost_per_gb
+                }
+                
+            except Exception as pricing_error:
+                print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine pricing without AWS API access: {pricing_error}")
+                print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
+                
+                # Return error state instead of hardcoded values to maintain enterprise compliance
+                raise RuntimeError(
+                    "Universal compatibility mode requires dynamic AWS pricing API access. "
+                    "Please ensure your AWS profile has pricing:GetProducts permissions or configure "
+                    "appropriate billing/management profile access."
+                )
         
     async def analyze_comprehensive_vpc_costs(self, profile: Optional[str] = None, 
                                             regions: Optional[List[str]] = None) -> Dict[str, Any]:

runbooks/finops/tests/test_integration.py

@@ -34,6 +34,8 @@ try:
     except ImportError:
         # Define mock_costexplorer as a no-op decorator for compatibility
         def mock_costexplorer(func):
+    # Dynamic test period for consistent test data
+    test_period = get_test_date_period(30)
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
 
@@ -128,7 +130,7 @@ class TestAWSIntegrationWithMoto:
         mock_cost_data = {
             "ResultsByTime": [
                 {
-                    "TimePeriod": {"Start": "2024-01-01", "End": "2024-01-31"},
+                    "TimePeriod": {"Start": test_period["Start"], "End": test_period["End"]},
                     "Total": {"UnblendedCost": {"Amount": "50000.00", "Unit": "USD"}},
                     "Groups": [
                         {"Keys": ["EC2-Instance"], "Metrics": {"UnblendedCost": {"Amount": "20000.00", "Unit": "USD"}}},

runbooks/finops/vpc_cleanup_optimizer.py

@@ -610,18 +610,9 @@ class VPCCleanupOptimizer:
         
         print_header("🌐 Real-Time NO-ENI VPC Discovery", "MCP-Validated VPC Cleanup Analysis")
         
-        # Configure enterprise profiles for MCP validation - Universal compatibility
-        from runbooks.common.profile_utils import get_enterprise_profile_mapping
-        enterprise_profiles = get_enterprise_profile_mapping()
-        
-        # Override with current profile if available
-        current_profile_type = self._determine_profile_type(self.profile)
-        if current_profile_type:
-            enterprise_profiles[current_profile_type] = self.profile
-        
-        # Initialize MCP validator for dynamic discovery
+        # Initialize MCP validator with universal profile support
         print_info("🔧 Initializing dynamic MCP validator...")
-        mcp_validator = NOENIVPCMCPValidator(enterprise_profiles)
+        mcp_validator = NOENIVPCMCPValidator(user_profile=self.profile)
         
         # Perform dynamic discovery across all accounts
         print_info("🚀 Starting real-time discovery across all AWS accounts...")
@@ -641,7 +632,7 @@ class VPCCleanupOptimizer:
             # Get detailed VPC information for each NO-ENI VPC
             try:
                 # Use appropriate session for this account
-                session = self._get_session_for_account(target.account_id, enterprise_profiles)
+                session = self._get_session_for_account(target.account_id)
                 ec2_client = session.client('ec2', region_name=target.region)
                 
                 # Get VPC details
@@ -708,26 +699,28 @@ class VPCCleanupOptimizer:
             return 'CENTRALISED_OPS'
         return None
     
-    def _get_session_for_account(self, account_id: str, enterprise_profiles: Dict[str, str]) -> boto3.Session:
-        """Get appropriate session for accessing a specific account."""
+    def _get_session_for_account(self, account_id: str) -> boto3.Session:
+        """Get appropriate session for accessing a specific account using universal profile management."""
+        from runbooks.common.profile_utils import get_profile_for_operation
+        
         # In enterprise setup, would assume role here
-        # For now, return session with best available profile
+        # For now, return session with best available profile using three-tier priority system
         
-        # Priority order for account access
-        profile_priority = ['MANAGEMENT', 'CENTRALISED_OPS', 'BILLING']
+        # Try different operation types in priority order
+        profile_types = ['management', 'operational', 'billing']
         
-        for profile_type in profile_priority:
-            if profile_type in enterprise_profiles:
-                try:
-                    session = boto3.Session(profile_name=enterprise_profiles[profile_type])
-                    # Verify access
-                    sts_client = session.client('sts')
-                    identity = sts_client.get_caller_identity()
-                    
-                    if identity['Account'] == account_id:
-                        return session
-                except Exception:
-                    continue
+        for profile_type in profile_types:
+            try:
+                profile_name = get_profile_for_operation(profile_type, self.profile)
+                session = boto3.Session(profile_name=profile_name)
+                # Verify access
+                sts_client = session.client('sts')
+                identity = sts_client.get_caller_identity()
+                
+                if identity['Account'] == account_id:
+                    return session
+            except Exception:
+                continue
         
         # Fallback to current session
         return self.session

runbooks/inventory/core/collector.py

@@ -42,12 +42,13 @@ try:
     ENHANCED_PROFILES_AVAILABLE = True
 except ImportError:
     ENHANCED_PROFILES_AVAILABLE = False
-    # Fallback profile definitions
+    # Fallback profile definitions with universal environment support
+    import os
     ENTERPRISE_PROFILES = {
-        "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",
-        "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185",
-        "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",
-        "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
+        "BILLING_PROFILE": os.getenv("BILLING_PROFILE", "default-billing-profile"),
+        "MANAGEMENT_PROFILE": os.getenv("MANAGEMENT_PROFILE", "default-management-profile"),
+        "CENTRALISED_OPS_PROFILE": os.getenv("CENTRALISED_OPS_PROFILE", "default-ops-profile"),
+        "SINGLE_ACCOUNT_PROFILE": os.getenv("SINGLE_AWS_PROFILE", "default-single-profile"),
     }
 
 
@@ -141,28 +142,35 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         
         Strategic Alignment: "Do one thing and do it well"
         - Single profile override pattern: --profile takes precedence
-        - Simple fallback to environment variables when no --profile specified
-        - No hardcoded profile mappings - dynamic based on user input
+        - Universal AWS environment compatibility: works with ANY profile configuration
+        - Graceful fallback system for discovery across different AWS setups
         
         Returns:
             str: The active profile to use for all operations
         """
-        # Primary profile determination: user --profile parameter takes absolute precedence
+        # PRIMARY: User --profile parameter takes absolute precedence (Universal Compatibility)
         if self.profile:
-            print_info(f"Using user-specified profile: {self.profile}")
-            logger.info("Profile override via --profile parameter - enterprise priority system")
+            print_info(f"✅ Universal AWS Compatibility: Using user-specified profile '{self.profile}'")
+            logger.info("Profile override via --profile parameter - universal environment support")
             return self.profile
         
-        # Fallback to environment variables when no --profile specified
+        # SECONDARY: Environment variable fallback with intelligent prioritization
+        # Priority order: Management > Billing > Operations > Default (Organizations discovery preference)
         env_profile = (
             os.getenv("MANAGEMENT_PROFILE") or 
             os.getenv("BILLING_PROFILE") or 
             os.getenv("CENTRALISED_OPS_PROFILE") or
+            os.getenv("SINGLE_AWS_PROFILE") or
             "default"
         )
         
-        print_info(f"No --profile specified, using environment fallback: {env_profile}")
-        logger.info("Using environment variable fallback profile")
+        if env_profile != "default":
+            print_info(f"✅ Universal AWS Compatibility: Using environment profile '{env_profile}'")
+            logger.info(f"Environment variable profile selected: {env_profile}")
+        else:
+            print_info("✅ Universal AWS Compatibility: Using 'default' profile - works with any AWS CLI configuration")
+            logger.info("Using default profile - universal compatibility mode")
+        
         return env_profile
 
     def _initialize_collectors(self) -> Dict[str, str]:
@@ -226,21 +234,19 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 
     def get_organization_accounts(self) -> List[str]:
         """
-        Get list of accounts in AWS Organization.
+        Get list of accounts in AWS Organization with universal compatibility.
         
         Strategic Alignment: "Do one thing and do it well" 
-        - Single responsibility: discover organization structure
-        - Uses active profile for Organizations API access
-        - Enables multi-account inventory operations
+        - Universal AWS environment compatibility: works with ANY Organizations setup
+        - Intelligent fallback system: Organizations → standalone account detection
+        - Graceful handling of different permission scenarios
         """
         try:
-            # Use management profile for Organizations operations
-            # Use single active profile for all operations following --profile pattern
-            management_profile = self.active_profile
-            management_session = create_management_session(profile=management_profile)
+            # Use active profile for Organizations operations (Universal Compatibility)
+            management_session = create_management_session(profile=self.active_profile)
             organizations_client = management_session.client("organizations")
             
-            print_info("Discovering organization accounts with management profile...")
+            print_info(f"🔍 Universal Discovery: Attempting Organizations API with profile '{self.active_profile}'...")
             response = self._make_aws_call(organizations_client.list_accounts)
 
             accounts = []
@@ -248,14 +254,31 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 if account["Status"] == "ACTIVE":
                     accounts.append(account["Id"])
 
-            print_success(f"Found {len(accounts)} active accounts in organization")
-            logger.info(f"Found {len(accounts)} active accounts using management profile: {management_profile}")
-            return accounts
+            if accounts:
+                print_success(f"✅ Organizations Discovery: Found {len(accounts)} active accounts in organization")
+                logger.info(f"Organizations discovery successful: {len(accounts)} accounts with profile {self.active_profile}")
+                return accounts
+            else:
+                print_warning("⚠️ Organizations Discovery: No active accounts found in organization")
+                return [self.get_account_id()]
 
         except Exception as e:
-            print_warning(f"Could not list organization accounts: {e}")
-            logger.warning(f"Organization discovery failed, falling back to current account: {e}")
-            # Fallback to current account
+            # Enhanced error messages for different AWS environment scenarios
+            error_message = str(e).lower()
+            
+            if "accessdenied" in error_message or "unauthorized" in error_message:
+                print_warning(f"⚠️ Universal Compatibility: Profile '{self.active_profile}' lacks Organizations permissions")
+                print_info("💡 Single Account Mode: Continuing with current account (universal compatibility)")
+            elif "organizationsnotinuse" in error_message:
+                print_info(f"ℹ️ Standalone Account: Profile '{self.active_profile}' not in an AWS Organization")
+                print_info("💡 Single Account Mode: Continuing with current account")
+            else:
+                print_warning(f"⚠️ Organizations Discovery Failed: {e}")
+                print_info("💡 Fallback Mode: Continuing with current account for universal compatibility")
+            
+            logger.warning(f"Organization discovery failed, graceful fallback: {e}")
+            
+            # Universal fallback: always return current account for single-account operations
             return [self.get_account_id()]
 
     def get_current_account_id(self) -> str: