aws-cost-calculator-cli 1.11.1__tar.gz → 2.1.0__tar.gz

{aws_cost_calculator_cli-1.11.1/aws_cost_calculator_cli.egg-info → aws_cost_calculator_cli-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.11.1
+Version: 2.1.0
 Summary: AWS Cost Calculator CLI - Calculate daily and annual AWS costs across multiple accounts
 Home-page: https://github.com/trilogy-group/aws-cost-calculator
 Author: Cost Optimization Team

{aws_cost_calculator_cli-1.11.1 → aws_cost_calculator_cli-2.1.0/aws_cost_calculator_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.11.1
+Version: 2.1.0
 Summary: AWS Cost Calculator CLI - Calculate daily and annual AWS costs across multiple accounts
 Home-page: https://github.com/trilogy-group/aws-cost-calculator
 Author: Cost Optimization Team

{aws_cost_calculator_cli-1.11.1 → aws_cost_calculator_cli-2.1.0}/cost_calculator/cli.py

@@ -18,6 +18,12 @@ from pathlib import Path
 from cost_calculator.trends import format_trends_markdown
 from cost_calculator.monthly import format_monthly_markdown
 from cost_calculator.drill import format_drill_down_markdown
+
+# API Configuration - can be overridden via environment variable
+PROFILES_API_URL = os.environ.get(
+    'COST_CALCULATOR_PROFILES_URL',
+    'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+)
 from cost_calculator.executor import execute_trends, execute_monthly, execute_drill
 
 
@@ -67,127 +73,197 @@ def apply_auth_options(config, sso=None, access_key_id=None, secret_access_key=N
     return config
 
 
-def load_profile(profile_name):
-    """Load profile configuration from DynamoDB API or local file as fallback"""
+def get_api_secret():
+    """Get API secret from config file or environment variable"""
     import os
-    import requests
     
-    config_dir = Path.home() / '.config' / 'cost-calculator'
-    config_file = config_dir / 'profiles.json'
-    creds_file = config_dir / 'credentials.json'
-    
-    # Try DynamoDB API first if COST_API_SECRET is set
+    # Check environment variable first
     api_secret = os.environ.get('COST_API_SECRET')
     if api_secret:
-        try:
-            response = requests.post(
-                'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/',
-                headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
-                json={'operation': 'get', 'profile_name': profile_name},
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                response_data = response.json()
-                # API returns {"profile": {...}} wrapper
-                profile_data = response_data.get('profile', response_data)
-                profile = {'accounts': profile_data['accounts']}
-                
-                # If profile has aws_profile field, use it
-                if 'aws_profile' in profile_data:
-                    profile['aws_profile'] = profile_data['aws_profile']
-                # Check for AWS_PROFILE environment variable (SSO support)
-                elif os.environ.get('AWS_PROFILE'):
-                    profile['aws_profile'] = os.environ['AWS_PROFILE']
-                # Use environment credentials
-                elif os.environ.get('AWS_ACCESS_KEY_ID'):
-                    profile['credentials'] = {
-                        'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
-                        'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
-                        'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
-                    }
-                else:
-                    # Try to find a matching AWS profile by name
-                    # This allows "khoros" profile to work with "khoros_umbrella" AWS profile
-                    import subprocess
-                    try:
-                        result = subprocess.run(
-                            ['aws', 'configure', 'list-profiles'],
-                            capture_output=True,
-                            text=True,
-                            timeout=5
-                        )
-                        if result.returncode == 0:
-                            available_profiles = result.stdout.strip().split('\n')
-                            # Try exact match first
-                            if profile_name in available_profiles:
-                                profile['aws_profile'] = profile_name
-                            # Try with common suffixes
-                            elif f"{profile_name}_umbrella" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}_umbrella"
-                            elif f"{profile_name}-umbrella" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}-umbrella"
-                            elif f"{profile_name}_prod" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}_prod"
-                            # If no match found, leave it unset - user must provide --sso
-                    except:
-                        # If we can't list profiles, leave it unset - user must provide --sso
-                        pass
-                
-                return profile
-            else:
-                raise click.ClickException(
-                    f"Profile '{profile_name}' not found in DynamoDB.\n"
-                    f"Run: cc profile create --name {profile_name} --accounts \"...\""
-                )
-        except requests.exceptions.RequestException as e:
-            raise click.ClickException(
-                f"Failed to fetch profile from API: {e}\n"
-            )
+        return api_secret
+    
+    # Check config file
+    config_dir = Path.home() / '.config' / 'cost-calculator'
+    config_file = config_dir / 'config.json'
     
-    # Fallback to local file if no API secret
     if config_file.exists():
         with open(config_file) as f:
-            profiles = json.load(f)
+            config = json.load(f)
+            return config.get('api_secret')
+    
+    return None
+
+
+def get_exclusions(profile_name=None):
+    """Get exclusions configuration from DynamoDB API"""
+    import requests
+    
+    api_secret = get_api_secret()
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET"
+        )
+    
+    try:
+        response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get_exclusions', 'profile_name': profile_name},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            return response.json().get('exclusions', {})
+        else:
+            # Return defaults if API fails
+            return {
+                'record_types': ['Tax', 'Support'],
+                'services': [],
+                'usage_types': [],
+                'line_item_types': []
+            }
+    except:
+        # Return defaults if request fails
+        return {
+            'record_types': ['Tax', 'Support'],
+            'services': [],
+            'usage_types': [],
+            'line_item_types': []
+        }
+
+
+def build_exclusion_filter(exclusions):
+    """Build AWS Cost Explorer filter from exclusions config"""
+    filter_parts = []
+    
+    # Exclude record types (Tax, Support, etc.)
+    if exclusions.get('record_types'):
+        filter_parts.append({
+            "Not": {
+                "Dimensions": {
+                    "Key": "RECORD_TYPE",
+                    "Values": exclusions['record_types']
+                }
+            }
+        })
+    
+    # Exclude specific services (OCBLateFee, etc.)
+    if exclusions.get('services'):
+        filter_parts.append({
+            "Not": {
+                "Dimensions": {
+                    "Key": "SERVICE",
+                    "Values": exclusions['services']
+                }
+            }
+        })
+    
+    # Exclude usage types
+    if exclusions.get('usage_types'):
+        filter_parts.append({
+            "Not": {
+                "Dimensions": {
+                    "Key": "USAGE_TYPE",
+                    "Values": exclusions['usage_types']
+                }
+            }
+        })
+    
+    # Exclude line item types (Refund, Credit, etc.)
+    if exclusions.get('line_item_types'):
+        filter_parts.append({
+            "Not": {
+                "Dimensions": {
+                    "Key": "LINE_ITEM_TYPE",
+                    "Values": exclusions['line_item_types']
+                }
+            }
+        })
+    
+    return filter_parts
+
+
+def load_profile(profile_name):
+    """Load profile configuration from DynamoDB API (API-only, no local files)"""
+    import requests
+    
+    # Get API secret
+    api_secret = get_api_secret()
+    
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET\n"
+            "Or set environment variable: export COST_API_SECRET=YOUR_SECRET"
+        )
+    
+    try:
+        response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get', 'profile_name': profile_name},
+            timeout=10
+        )
         
-        if profile_name in profiles:
-            profile = profiles[profile_name]
+        if response.status_code == 200:
+            response_data = response.json()
+            # API returns {"profile": {...}} wrapper
+            profile_data = response_data.get('profile', response_data)
+            profile = {'accounts': profile_data['accounts']}
             
-            # Load credentials if using static credentials (not SSO)
-            if 'aws_profile' not in profile:
-                if not creds_file.exists():
-                    # Try environment variables
-                    if os.environ.get('AWS_ACCESS_KEY_ID'):
-                        profile['credentials'] = {
-                            'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
-                            'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
-                            'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
-                        }
-                        return profile
-                    
-                    raise click.ClickException(
-                        f"No credentials found for profile '{profile_name}'.\n"
-                        f"Run: cc configure --profile {profile_name}"
-                    )
-                
-                with open(creds_file) as f:
-                    creds = json.load(f)
-                
-                if profile_name not in creds:
-                    raise click.ClickException(
-                        f"No credentials found for profile '{profile_name}'.\n"
-                        f"Run: cc configure --profile {profile_name}"
+            # If profile has aws_profile field, use it
+            if 'aws_profile' in profile_data:
+                profile['aws_profile'] = profile_data['aws_profile']
+            # Check for AWS_PROFILE environment variable (SSO support)
+            elif os.environ.get('AWS_PROFILE'):
+                profile['aws_profile'] = os.environ['AWS_PROFILE']
+            # Use environment credentials
+            elif os.environ.get('AWS_ACCESS_KEY_ID'):
+                profile['credentials'] = {
+                    'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
+                    'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
+                    'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
+                }
+            else:
+                # Try to find a matching AWS profile by name
+                # This allows "khoros" profile to work with "khoros_umbrella" AWS profile
+                import subprocess
+                try:
+                    result = subprocess.run(
+                        ['aws', 'configure', 'list-profiles'],
+                        capture_output=True,
+                        text=True,
+                        timeout=5
                     )
-                
-                profile['credentials'] = creds[profile_name]
+                    if result.returncode == 0:
+                        available_profiles = result.stdout.strip().split('\n')
+                        # Try exact match first
+                        if profile_name in available_profiles:
+                            profile['aws_profile'] = profile_name
+                        # Try with common suffixes
+                        elif f"{profile_name}_umbrella" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}_umbrella"
+                        elif f"{profile_name}-umbrella" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}-umbrella"
+                        elif f"{profile_name}_prod" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}_prod"
+                        # If no match found, leave it unset - user must provide --sso
+                except:
+                    # If we can't list profiles, leave it unset - user must provide --sso
+                    pass
             
             return profile
-    
-    # Profile not found anywhere
-    raise click.ClickException(
-        f"Profile '{profile_name}' not found.\n"
-        f"Run: cc profile create --name {profile_name} --accounts \"...\""
-    )
+        else:
+            raise click.ClickException(
+                f"Profile '{profile_name}' not found in DynamoDB.\n"
+                f"Run: cc profile create --name {profile_name} --accounts \"...\""
+            )
+    except requests.exceptions.RequestException as e:
+        raise click.ClickException(
+            f"Failed to fetch profile from API: {e}\n"
+            "Check your API secret and network connection."
+        )
 
 
 def calculate_costs(profile_config, accounts, start_date, offset, window):
@@ -265,7 +341,10 @@ def calculate_costs(profile_config, accounts, start_date, offset, window):
                 )
         raise
     
-    # Build filter
+    # Build filter with dynamic exclusions
+    exclusions = get_exclusions()  # Get from DynamoDB
+    exclusion_filters = build_exclusion_filter(exclusions)
+    
     cost_filter = {
         "And": [
             {
@@ -279,18 +358,13 @@ def calculate_costs(profile_config, accounts, start_date, offset, window):
                     "Key": "BILLING_ENTITY",
                     "Values": ["AWS"]
                 }
-            },
-            {
-                "Not": {
-                    "Dimensions": {
-                        "Key": "RECORD_TYPE",
-                        "Values": ["Tax", "Support"]
-                    }
-                }
             }
         ]
     }
     
+    # Add dynamic exclusion filters
+    cost_filter["And"].extend(exclusion_filters)
+    
     # Get daily costs
     click.echo("Fetching cost data...")
     try:
@@ -737,77 +811,81 @@ def setup():
 
 
 @cli.command()
-@click.option('--profile', required=True, help='Profile name to configure')
-@click.option('--access-key-id', prompt=True, hide_input=False, help='AWS Access Key ID')
-@click.option('--secret-access-key', prompt=True, hide_input=True, help='AWS Secret Access Key')
-@click.option('--session-token', default='', help='AWS Session Token (optional, for temporary credentials)')
-@click.option('--region', default='us-east-1', help='AWS Region (default: us-east-1)')
-def configure(profile, access_key_id, secret_access_key, session_token, region):
-    """Configure AWS credentials for a profile (alternative to SSO)"""
+@click.option('--api-secret', help='API secret for DynamoDB profile access')
+@click.option('--show', is_flag=True, help='Show current configuration')
+def configure(api_secret, show):
+    """
+    Configure Cost Calculator CLI settings.
     
-    config_dir = Path.home() / '.config' / 'cost-calculator'
-    config_file = config_dir / 'profiles.json'
-    creds_file = config_dir / 'credentials.json'
+    This tool requires an API secret to access profiles stored in DynamoDB.
+    The secret can be configured here or set via COST_API_SECRET environment variable.
     
-    # Create config directory if it doesn't exist
+    Examples:
+        # Configure API secret
+        cc configure --api-secret YOUR_SECRET_KEY
+        
+        # Show current configuration
+        cc configure --show
+        
+        # Use environment variable instead (no configuration needed)
+        export COST_API_SECRET=YOUR_SECRET_KEY
+    """
+    import os
+    
+    config_dir = Path.home() / '.config' / 'cost-calculator'
     config_dir.mkdir(parents=True, exist_ok=True)
+    config_file = config_dir / 'config.json'
     
-    # Load existing profiles
-    if config_file.exists() and config_file.stat().st_size > 0:
-        try:
+    if show:
+        # Show current configuration
+        if config_file.exists():
             with open(config_file) as f:
-                profiles = json.load(f)
-        except json.JSONDecodeError:
-            profiles = {}
-    else:
-        profiles = {}
-    
-    # Check if profile exists
-    if profile not in profiles:
-        click.echo(f"Error: Profile '{profile}' not found. Create it first with: cc init --profile {profile}")
+                config = json.load(f)
+                if 'api_secret' in config:
+                    masked_secret = config['api_secret'][:8] + '...' + config['api_secret'][-4:]
+                    click.echo(f"API Secret: {masked_secret} (configured)")
+                else:
+                    click.echo("API Secret: Not configured")
+        else:
+            click.echo("No configuration file found")
+        
+        # Check environment variable
+        import os
+        if os.environ.get('COST_API_SECRET'):
+            click.echo("Environment: COST_API_SECRET is set")
+        else:
+            click.echo("Environment: COST_API_SECRET is not set")
+        
         return
     
-    # Remove aws_profile if it exists (switching from SSO to static creds)
-    if 'aws_profile' in profiles[profile]:
-        del profiles[profile]['aws_profile']
-    
-    # Save updated profile
-    with open(config_file, 'w') as f:
-        json.dump(profiles, f, indent=2)
-    
-    # Load or create credentials file
-    if creds_file.exists() and creds_file.stat().st_size > 0:
-        try:
-            with open(creds_file) as f:
-                creds = json.load(f)
-        except json.JSONDecodeError:
-            creds = {}
-    else:
-        creds = {}
+    if not api_secret:
+        raise click.ClickException(
+            "Please provide --api-secret or use --show to view current configuration\n"
+            "Example: cc configure --api-secret YOUR_SECRET_KEY"
+        )
     
-    # Store credentials (encrypted would be better, but for now just file permissions)
-    creds[profile] = {
-        'aws_access_key_id': access_key_id,
-        'aws_secret_access_key': secret_access_key,
-        'region': region
-    }
+    # Load existing config
+    config = {}
+    if config_file.exists():
+        with open(config_file) as f:
+            config = json.load(f)
     
-    if session_token:
-        creds[profile]['aws_session_token'] = session_token
+    # Update API secret
+    config['api_secret'] = api_secret
     
-    # Save credentials with restricted permissions
-    with open(creds_file, 'w') as f:
-        json.dump(creds, f, indent=2)
+    # Save config
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
     
-    # Set file permissions to 600 (owner read/write only)
-    creds_file.chmod(0o600)
+    # Set restrictive permissions (Unix/Mac only - Windows uses different permission model)
+    import platform
+    if platform.system() != 'Windows':
+        os.chmod(config_file, 0o600)
     
-    click.echo(f"✓ AWS credentials configured for profile '{profile}'")
-    click.echo(f"✓ Credentials saved to {creds_file} (permissions: 600)")
-    click.echo(f"\nUsage: cc calculate --profile {profile}")
-    click.echo("\nNote: Credentials are stored locally. For temporary credentials,")
-    click.echo("      you'll need to reconfigure when they expire.")
-
+    masked_secret = api_secret[:8] + '...' + api_secret[-4:]
+    click.echo(f"✓ API secret configured: {masked_secret}")
+    click.echo(f"\nYou can now run: cc calculate --profile PROFILE_NAME")
+    click.echo(f"\nNote: Profiles are stored in DynamoDB and accessed via the API.")
 
 @cli.command()
 @click.option('--profile', required=True, help='Profile name')
@@ -2013,5 +2091,238 @@ def query(profile, query, database, output_bucket, sso):
         raise click.ClickException(f"Query failed: {e}")
 
 
+@cli.group()
+def exclusions():
+    """
+    Manage cost exclusions (services/types to exclude from calculations).
+    
+    Exclusions are stored in DynamoDB and apply globally or per-profile.
+    Common exclusions: Tax, Support, OCBLateFee, Refunds, Credits
+    """
+    pass
+
+
+@exclusions.command('show')
+@click.option('--profile', help='Show profile-specific exclusions (default: global)')
+@click.option('--json', 'output_json', is_flag=True, help='Output as JSON')
+def show_exclusions(profile, output_json):
+    """Show current exclusions configuration"""
+    import requests
+    
+    api_secret = get_api_secret()
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET"
+        )
+    
+    try:
+        response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get_exclusions', 'profile_name': profile},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            exclusions_data = response.json().get('exclusions', {})
+            
+            if output_json:
+                click.echo(json.dumps(exclusions_data, indent=2))
+            else:
+                scope = profile if profile else "global"
+                click.echo(f"Exclusions ({scope}):")
+                click.echo("")
+                
+                if exclusions_data.get('record_types'):
+                    click.echo("Record Types:")
+                    for rt in exclusions_data['record_types']:
+                        click.echo(f"  - {rt}")
+                    click.echo("")
+                
+                if exclusions_data.get('services'):
+                    click.echo("Services:")
+                    for svc in exclusions_data['services']:
+                        click.echo(f"  - {svc}")
+                    click.echo("")
+                
+                if exclusions_data.get('line_item_types'):
+                    click.echo("Line Item Types:")
+                    for lit in exclusions_data['line_item_types']:
+                        click.echo(f"  - {lit}")
+                    click.echo("")
+                
+                if exclusions_data.get('usage_types'):
+                    click.echo("Usage Types:")
+                    for ut in exclusions_data['usage_types']:
+                        click.echo(f"  - {ut}")
+        else:
+            raise click.ClickException(f"Failed to fetch exclusions: {response.status_code}")
+    
+    except requests.exceptions.RequestException as e:
+        raise click.ClickException(f"API request failed: {e}")
+
+
+@exclusions.command('add')
+@click.option('--record-type', help='Add record type exclusion (e.g., Tax, Support)')
+@click.option('--service', help='Add service exclusion (e.g., OCBLateFee)')
+@click.option('--line-item-type', help='Add line item type exclusion (e.g., Refund, Credit)')
+@click.option('--usage-type', help='Add usage type exclusion')
+@click.option('--profile', help='Add to profile-specific exclusions (default: global)')
+def add_exclusion(record_type, service, line_item_type, usage_type, profile):
+    """Add an exclusion"""
+    import requests
+    
+    if not any([record_type, service, line_item_type, usage_type]):
+        raise click.ClickException(
+            "Must specify at least one of: --record-type, --service, --line-item-type, --usage-type"
+        )
+    
+    api_secret = get_api_secret()
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET"
+        )
+    
+    # Get current exclusions
+    try:
+        response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get_exclusions', 'profile_name': profile},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            exclusions_data = response.json().get('exclusions', {})
+        else:
+            exclusions_data = {
+                'record_types': [],
+                'services': [],
+                'line_item_types': [],
+                'usage_types': []
+            }
+        
+        # Add new exclusions
+        if record_type and record_type not in exclusions_data.get('record_types', []):
+            exclusions_data.setdefault('record_types', []).append(record_type)
+        
+        if service and service not in exclusions_data.get('services', []):
+            exclusions_data.setdefault('services', []).append(service)
+        
+        if line_item_type and line_item_type not in exclusions_data.get('line_item_types', []):
+            exclusions_data.setdefault('line_item_types', []).append(line_item_type)
+        
+        if usage_type and usage_type not in exclusions_data.get('usage_types', []):
+            exclusions_data.setdefault('usage_types', []).append(usage_type)
+        
+        # Update exclusions
+        update_response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={
+                'operation': 'update_exclusions',
+                'profile_name': profile,
+                'record_types': exclusions_data.get('record_types', []),
+                'services': exclusions_data.get('services', []),
+                'line_item_types': exclusions_data.get('line_item_types', []),
+                'usage_types': exclusions_data.get('usage_types', [])
+            },
+            timeout=10
+        )
+        
+        if update_response.status_code == 200:
+            scope = profile if profile else "global"
+            click.echo(f"✓ Exclusion added to {scope} config")
+            if record_type:
+                click.echo(f"  Record Type: {record_type}")
+            if service:
+                click.echo(f"  Service: {service}")
+            if line_item_type:
+                click.echo(f"  Line Item Type: {line_item_type}")
+            if usage_type:
+                click.echo(f"  Usage Type: {usage_type}")
+        else:
+            raise click.ClickException(f"Failed to update exclusions: {update_response.status_code}")
+    
+    except requests.exceptions.RequestException as e:
+        raise click.ClickException(f"API request failed: {e}")
+
+
+@exclusions.command('remove')
+@click.option('--record-type', help='Remove record type exclusion')
+@click.option('--service', help='Remove service exclusion')
+@click.option('--line-item-type', help='Remove line item type exclusion')
+@click.option('--usage-type', help='Remove usage type exclusion')
+@click.option('--profile', help='Remove from profile-specific exclusions (default: global)')
+def remove_exclusion(record_type, service, line_item_type, usage_type, profile):
+    """Remove an exclusion"""
+    import requests
+    
+    if not any([record_type, service, line_item_type, usage_type]):
+        raise click.ClickException(
+            "Must specify at least one of: --record-type, --service, --line-item-type, --usage-type"
+        )
+    
+    api_secret = get_api_secret()
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET"
+        )
+    
+    # Get current exclusions
+    try:
+        response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get_exclusions', 'profile_name': profile},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            exclusions_data = response.json().get('exclusions', {})
+        else:
+            raise click.ClickException("No exclusions found")
+        
+        # Remove exclusions
+        if record_type and record_type in exclusions_data.get('record_types', []):
+            exclusions_data['record_types'].remove(record_type)
+        
+        if service and service in exclusions_data.get('services', []):
+            exclusions_data['services'].remove(service)
+        
+        if line_item_type and line_item_type in exclusions_data.get('line_item_types', []):
+            exclusions_data['line_item_types'].remove(line_item_type)
+        
+        if usage_type and usage_type in exclusions_data.get('usage_types', []):
+            exclusions_data['usage_types'].remove(usage_type)
+        
+        # Update exclusions
+        update_response = requests.post(
+            PROFILES_API_URL,
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={
+                'operation': 'update_exclusions',
+                'profile_name': profile,
+                'record_types': exclusions_data.get('record_types', []),
+                'services': exclusions_data.get('services', []),
+                'line_item_types': exclusions_data.get('line_item_types', []),
+                'usage_types': exclusions_data.get('usage_types', [])
+            },
+            timeout=10
+        )
+        
+        if update_response.status_code == 200:
+            scope = profile if profile else "global"
+            click.echo(f"✓ Exclusion removed from {scope} config")
+        else:
+            raise click.ClickException(f"Failed to update exclusions: {update_response.status_code}")
+    
+    except requests.exceptions.RequestException as e:
+        raise click.ClickException(f"API request failed: {e}")
+
+
 if __name__ == '__main__':
     cli()

{aws_cost_calculator_cli-1.11.1 → aws_cost_calculator_cli-2.1.0}/cost_calculator/executor.py

@@ -227,8 +227,11 @@ def execute_profile_operation(operation, profile_name=None, accounts=None, descr
     
     api_secret = os.environ.get('COST_API_SECRET', '')
     
-    # Use profiles endpoint (hardcoded URL)
-    url = 'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+    # Use profiles endpoint (can be overridden via environment variable)
+    url = os.environ.get(
+        'COST_CALCULATOR_PROFILES_URL',
+        'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+    )
     
     payload = {'operation': operation}
     if profile_name:

{aws_cost_calculator_cli-1.11.1 → aws_cost_calculator_cli-2.1.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name='aws-cost-calculator-cli',
-    version='1.11.1',
+    version='2.1.0',
     packages=['cost_calculator'],
     install_requires=[
         'click>=8.0.0',