ai-lls-lib 2.0.0rc2__py3-none-any.whl

ai_lls_lib/cli/commands/monitor.py

@@ -0,0 +1,297 @@
+"""
+Real-time CloudWatch log monitoring for Lambda functions
+"""
+import click
+import json
+import time
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict
+from botocore.exceptions import ClientError
+from ai_lls_lib.cli.aws_client import AWSClient
+
+try:
+    from rich.console import Console
+    from rich.syntax import Syntax
+    from rich.table import Table
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich import box
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+    Console = None
+
+
+def get_log_groups(aws_client: AWSClient, environment: str) -> List[str]:
+    """Get relevant CloudWatch log groups for the environment"""
+    # Map environment to stack name pattern
+    stack_prefix = "landline-api-staging" if environment == "staging" else "landline-api"
+
+    # Key Lambda functions to monitor
+    lambda_functions = [
+        "PhoneVerifyHandler",
+        "BulkUploadHandler",
+        "BulkProcessHandler",
+        "PlansHandler",
+        "PaymentHandler",
+        "UserProfileHandler"
+    ]
+
+    log_groups = []
+    for func in lambda_functions:
+        log_group = f"/aws/lambda/{stack_prefix}-{func}"
+        log_groups.append(log_group)
+
+    return log_groups
+
+
+def format_log_event(event: Dict, use_rich: bool = True) -> str:
+    """Format a CloudWatch log event for display"""
+    timestamp = datetime.fromtimestamp(event.get('timestamp', 0) / 1000)
+    message = event.get('message', '')
+
+    # Try to parse JSON message
+    try:
+        if message.strip().startswith('{'):
+            parsed = json.loads(message)
+
+            # Check for external API calls
+            if 'external_api_call' in message.lower() or 'landlineremover.com' in message:
+                if use_rich and HAS_RICH:
+                    return f"[bold green]{timestamp.strftime('%H:%M:%S')}[/bold green] [cyan]EXTERNAL API:[/cyan] {message}"
+                else:
+                    return f"{timestamp.strftime('%H:%M:%S')} EXTERNAL API: {message}"
+
+            # Check for cache events
+            if 'cache' in message.lower():
+                if use_rich and HAS_RICH:
+                    return f"[bold blue]{timestamp.strftime('%H:%M:%S')}[/bold blue] [yellow]CACHE:[/yellow] {message}"
+                else:
+                    return f"{timestamp.strftime('%H:%M:%S')} CACHE: {message}"
+
+            # Check for errors
+            if 'error' in message.lower() or 'exception' in message.lower():
+                if use_rich and HAS_RICH:
+                    return f"[bold red]{timestamp.strftime('%H:%M:%S')}[/bold red] [red]ERROR:[/red] {message}"
+                else:
+                    return f"{timestamp.strftime('%H:%M:%S')} ERROR: {message}"
+
+            # Format structured logs
+            if use_rich and HAS_RICH:
+                message = json.dumps(parsed, indent=2)
+    except (json.JSONDecodeError, ValueError):
+        pass
+
+    # Default formatting
+    if use_rich and HAS_RICH:
+        return f"[dim]{timestamp.strftime('%H:%M:%S')}[/dim] {message}"
+    else:
+        return f"{timestamp.strftime('%H:%M:%S')} {message}"
+
+
+def tail_logs(aws_client: AWSClient, log_groups: List[str], duration: int = 300, follow: bool = True):
+    """Tail CloudWatch logs in real-time"""
+    console = Console() if HAS_RICH else None
+
+    # Calculate start time
+    start_time = int((datetime.utcnow() - timedelta(seconds=duration)).timestamp() * 1000)
+
+    # Track last event time for each log group
+    last_event_times = {group: start_time for group in log_groups}
+
+    if console and HAS_RICH:
+        console.print(Panel.fit(
+            f"[bold cyan]Monitoring {len(log_groups)} Lambda functions[/bold cyan]\n"
+            f"[dim]Press Ctrl+C to stop[/dim]",
+            title="CloudWatch Log Monitor",
+            border_style="cyan"
+        ))
+        console.print()
+    else:
+        click.echo(f"Monitoring {len(log_groups)} Lambda functions")
+        click.echo("Press Ctrl+C to stop\n")
+
+    try:
+        while True:
+            events_found = False
+
+            for log_group in log_groups:
+                try:
+                    # Use filter_log_events for real-time tailing
+                    response = aws_client.logs.filter_log_events(
+                        logGroupName=log_group,
+                        startTime=last_event_times[log_group],
+                        limit=100
+                    )
+
+                    events = response.get('events', [])
+
+                    if events:
+                        events_found = True
+                        # Update last event time
+                        last_event_times[log_group] = events[-1]['timestamp'] + 1
+
+                        # Display log group header
+                        if console and HAS_RICH:
+                            console.print(f"\n[bold magenta]═══ {log_group} ═══[/bold magenta]")
+                        else:
+                            click.echo(f"\n=== {log_group} ===")
+
+                        # Display events
+                        for event in events:
+                            formatted = format_log_event(event, use_rich=(console is not None))
+                            if console and HAS_RICH:
+                                console.print(formatted)
+                            else:
+                                click.echo(formatted)
+
+                except ClientError as e:
+                    if e.response['Error']['Code'] != 'ResourceNotFoundException':
+                        if console and HAS_RICH:
+                            console.print(f"[yellow]Warning: {e}[/yellow]")
+                        else:
+                            click.echo(f"Warning: {e}", err=True)
+
+            if not follow:
+                break
+
+            # Sleep briefly before next poll
+            time.sleep(2 if events_found else 5)
+
+    except KeyboardInterrupt:
+        if console and HAS_RICH:
+            console.print("\n[yellow]Monitoring stopped[/yellow]")
+        else:
+            click.echo("\nMonitoring stopped")
+
+
+def start_live_tail(aws_client: AWSClient, log_groups: List[str]):
+    """Start a CloudWatch Logs Live Tail session (requires AWS SDK v2)"""
+    console = Console() if HAS_RICH else None
+
+    try:
+        # Start live tail session
+        response = aws_client.logs.start_live_tail(
+            logGroupIdentifiers=log_groups,
+            logStreamNamePrefixes=[],
+            logEventFilterPattern=""
+        )
+
+        session_id = response.get('sessionId')
+        session_url = response.get('sessionUrl')
+
+        if console and HAS_RICH:
+            console.print(Panel.fit(
+                f"[bold green]Live Tail session started[/bold green]\n"
+                f"Session ID: {session_id}\n"
+                f"[dim]Note: Live Tail API requires WebSocket support[/dim]",
+                title="CloudWatch Live Tail",
+                border_style="green"
+            ))
+        else:
+            click.echo(f"Live Tail session started")
+            click.echo(f"Session ID: {session_id}")
+            click.echo(f"Note: Live Tail API requires WebSocket support")
+
+        # Note: Full WebSocket implementation would be needed here
+        # For now, fall back to filter_log_events polling
+        click.echo("\nFalling back to standard log polling...")
+        tail_logs(aws_client, log_groups, duration=300, follow=True)
+
+    except ClientError as e:
+        if 'start_live_tail' in str(e):
+            # Fall back to regular tailing if Live Tail not available
+            if console and HAS_RICH:
+                console.print("[yellow]Live Tail API not available, using standard polling[/yellow]")
+            else:
+                click.echo("Live Tail API not available, using standard polling")
+            tail_logs(aws_client, log_groups, duration=300, follow=True)
+        else:
+            raise
+
+
+@click.group(name="monitor")
+def monitor_group():
+    """Monitor CloudWatch logs in real-time"""
+    pass
+
+
+@monitor_group.command()
+@click.option('--staging', is_flag=True, help='Monitor staging environment (default: production)')
+@click.option('--production', is_flag=True, help='Monitor production environment')
+@click.option('--duration', default=300, help='How far back to start (seconds, default: 300)')
+@click.option('--follow', is_flag=True, default=True, help='Follow logs in real-time (default: true)')
+@click.option('--filter', 'filter_pattern', help='CloudWatch filter pattern to apply')
+@click.option('--profile', help='AWS profile to use')
+@click.option('--region', default='us-east-1', help='AWS region')
+def logs(staging, production, duration, follow, filter_pattern, profile, region):
+    """Tail CloudWatch logs for Lambda functions
+
+    Examples:
+        ai-lls monitor logs --staging
+        ai-lls monitor logs --production
+        ai-lls monitor logs --staging --filter "ERROR"
+        ai-lls monitor logs --duration 600 --follow
+    """
+    # Determine environment
+    if staging and production:
+        raise click.ClickException("Cannot specify both --staging and --production")
+
+    environment = "staging" if staging else "production"
+
+    # Show warning if Rich not installed
+    if not HAS_RICH:
+        click.echo("Warning: Install 'rich' library for better output formatting", err=True)
+        click.echo("Run: pip install rich", err=True)
+        click.echo()
+
+    # Initialize AWS client
+    aws_client = AWSClient(region=region, profile=profile)
+
+    # Get log groups
+    log_groups = get_log_groups(aws_client, environment)
+
+    click.echo(f"Monitoring {environment} environment...")
+    click.echo(f"Log groups: {', '.join([g.split('/')[-1] for g in log_groups])}")
+    click.echo()
+
+    # Start tailing logs
+    tail_logs(aws_client, log_groups, duration=duration, follow=follow)
+
+
+@monitor_group.command()
+@click.option('--staging', is_flag=True, help='Monitor staging environment')
+@click.option('--production', is_flag=True, help='Monitor production environment')
+@click.option('--profile', help='AWS profile to use')
+@click.option('--region', default='us-east-1', help='AWS region')
+def live(staging, production, profile, region):
+    """Start CloudWatch Logs Live Tail session (experimental)
+
+    Uses the CloudWatch Logs Live Tail API for real-time streaming.
+    Falls back to standard polling if Live Tail is not available.
+
+    Examples:
+        ai-lls monitor live --staging
+        ai-lls monitor live --production
+    """
+    # Determine environment
+    if staging and production:
+        raise click.ClickException("Cannot specify both --staging and --production")
+
+    environment = "staging" if staging else "production"
+
+    # Initialize AWS client
+    aws_client = AWSClient(region=region, profile=profile)
+
+    # Get log groups
+    log_groups = get_log_groups(aws_client, environment)
+
+    click.echo(f"Starting Live Tail for {environment} environment...")
+
+    # Start live tail
+    start_live_tail(aws_client, log_groups)
+
+
+# Export the group for registration
+__all__ = ['monitor_group']

ai_lls_lib/cli/commands/stripe.py

@@ -0,0 +1,355 @@
+"""Stripe management CLI commands."""
+
+import click
+import os
+import json
+from typing import Optional
+from ..env_loader import load_environment_config, get_stripe_key
+
+@click.group(name="stripe")
+def stripe_group():
+    """Manage Stripe products and prices."""
+    pass
+
+
+@stripe_group.command("seed")
+@click.option("--environment", type=click.Choice(["staging", "production"]), required=True)
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--dry-run", is_flag=True, help="Show what would be created without making changes")
+def seed_products(environment: str, api_key: Optional[str], dry_run: bool):
+    """Create or update Stripe products and prices with metadata."""
+    try:
+        import stripe
+    except ImportError:
+        click.echo("Error: stripe package not installed. Run: pip install stripe", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            env_prefix = 'STAGING' if environment == 'staging' else 'PROD'
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {env_prefix}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+        click.echo(f"Using Stripe key for {environment} environment", err=True)
+
+    stripe.api_key = api_key
+
+    # Define the products and prices to create
+    products_config = [
+        {
+            "name": "Landline Scrubber - STANDARD",
+            "description": "One-time purchase",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "STANDARD"
+            },
+            "price": {
+                "unit_amount": 1000,  # $10.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "STANDARD",
+                    "credits": "50000",
+                    "plan_credits_text": "50,000 credits",
+                    "percent_off": "",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - POWER",
+            "description": "Best value",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "POWER"
+            },
+            "price": {
+                "unit_amount": 5000,  # $50.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "POWER",
+                    "credits": "285000",
+                    "plan_credits_text": "285,000 credits",
+                    "percent_off": "12.5% OFF",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - ELITE",
+            "description": "Maximum savings",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "ELITE"
+            },
+            "price": {
+                "unit_amount": 10000,  # $100.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "ELITE",
+                    "credits": "666660",
+                    "plan_credits_text": "666,660 credits",
+                    "percent_off": "25% OFF",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - UNLIMITED",
+            "description": "Monthly subscription",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "UNLIMITED"
+            },
+            "price": {
+                "unit_amount": 300000,  # $3000.00
+                "currency": "usd",
+                "recurring": {"interval": "month"},
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "postpaid",
+                    "tier": "UNLIMITED",
+                    "credits": "unlimited",
+                    "plan_credits_text": "Unlimited",
+                    "percent_off": "",
+                    "active": "true"
+                }
+            }
+        }
+    ]
+
+    if dry_run:
+        click.echo("DRY RUN - Would create the following:")
+        for config in products_config:
+            click.echo(f"\nProduct: {config['name']}")
+            click.echo(f"  Description: {config['description']}")
+            click.echo(f"  Price: ${config['price']['unit_amount'] / 100:.2f}")
+            if "recurring" in config["price"]:
+                click.echo(f"  Billing: Monthly subscription")
+            else:
+                click.echo(f"  Billing: One-time payment")
+        return
+
+    created_prices = []
+
+    for config in products_config:
+        try:
+            # Check if product already exists
+            existing_products = stripe.Product.list(limit=100)
+            product = None
+            for p in existing_products.data:
+                if (p.metadata.get("product_type") == "landline_scrubber" and
+                    p.metadata.get("environment") == environment and
+                    p.metadata.get("tier") == config["metadata"]["tier"] and
+                    p.active):  # Only use active products
+                    product = p
+                    click.echo(f"Found existing product: {product.name}")
+                    break
+
+            if not product:
+                # Create new product
+                product = stripe.Product.create(
+                    name=config["name"],
+                    description=config["description"],
+                    metadata=config["metadata"]
+                )
+                click.echo(f"Created product: {product.name}")
+
+            # Create price (always create new prices, don't modify existing)
+            price_data = {
+                "product": product.id,
+                "unit_amount": config["price"]["unit_amount"],
+                "currency": config["price"]["currency"],
+                "metadata": config["price"]["metadata"]
+            }
+
+            if "recurring" in config["price"]:
+                price_data["recurring"] = config["price"]["recurring"]
+
+            price = stripe.Price.create(**price_data)
+            created_prices.append(price.id)
+            click.echo(f"  Created price: {price.id} (${price.unit_amount / 100:.2f})")
+
+        except stripe.error.StripeError as e:
+            click.echo(f"Error creating {config['name']}: {e}", err=True)
+
+    if created_prices:
+        click.echo(f"\nCreated {len(created_prices)} prices for {environment} environment")
+        click.echo("\nPrice IDs:")
+        for price_id in created_prices:
+            click.echo(f"  {price_id}")
+
+
+@stripe_group.command("clean")
+@click.option("--environment", type=click.Choice(["staging", "production"]), default="staging")
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--force", is_flag=True, help="Skip confirmation")
+def clean_products(environment: str, api_key: Optional[str], force: bool):
+    """Remove all Landline Scrubber products and prices."""
+    import stripe
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            return
+
+    stripe.api_key = api_key
+
+    if not force:
+        if not click.confirm(f"This will DELETE all Landline Scrubber products in {environment}. Continue?"):
+            return
+
+    try:
+        # List all products
+        products = stripe.Product.list(limit=100)
+        deleted_count = 0
+
+        for product in products.data:
+            if (product.metadata.get("product_type") == "landline_scrubber" and
+                product.metadata.get("environment") == environment):
+                # Archive all prices first
+                prices = stripe.Price.list(product=product.id, limit=100)
+                for price in prices.data:
+                    if price.active:
+                        stripe.Price.modify(price.id, active=False)
+                        click.echo(f"  Archived price: {price.id}")
+
+                # Archive the product
+                stripe.Product.modify(product.id, active=False)
+                click.echo(f"Archived product: {product.name}")
+                deleted_count += 1
+
+        click.echo(f"\nArchived {deleted_count} products in {environment} environment")
+
+    except stripe.error.StripeError as e:
+        click.echo(f"Error: {e}", err=True)
+
+
+@stripe_group.command("list")
+@click.option("--environment", type=click.Choice(["staging", "production"]), default="staging")
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def list_products(environment: str, api_key: Optional[str], output_json: bool):
+    """List all products and prices with metadata."""
+    try:
+        from ai_lls_lib.payment import StripeManager
+    except ImportError:
+        click.echo("Error: Payment module not found", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            env_prefix = 'STAGING' if environment == 'staging' else 'PROD'
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {env_prefix}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+
+    try:
+        manager = StripeManager(api_key=api_key, environment=environment)
+        plans = manager.list_plans()
+
+        if output_json:
+            output = [plan.to_dict() for plan in plans]
+            click.echo(json.dumps(output, indent=2))
+        else:
+            click.echo(f"Active plans for {environment} environment:\n")
+            for plan in plans:
+                click.echo(f"{plan.plan_name}:")
+                click.echo(f"  Price: ${plan.plan_amount:.2f}")
+                click.echo(f"  Credits: {plan.plan_credits_text}")
+                click.echo(f"  Type: {plan.plan_type}")
+                click.echo(f"  Reference: {plan.plan_reference}")
+                if plan.percent_off:
+                    click.echo(f"  Discount: {plan.percent_off}")
+                click.echo()
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+
+
+@stripe_group.command("webhook")
+@click.option("--endpoint-url", help="Webhook endpoint URL")
+@click.option("--environment", type=click.Choice(["staging", "production"]), default="staging")
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--print-secret", is_flag=True, help="Print the webhook signing secret")
+def setup_webhook(endpoint_url: Optional[str], environment: str, api_key: Optional[str], print_secret: bool):
+    """Configure or display webhook endpoint."""
+    try:
+        import stripe
+    except ImportError:
+        click.echo("Error: stripe package not installed. Run: pip install stripe", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            env_prefix = 'STAGING' if environment == 'staging' else 'PROD'
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {env_prefix}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+
+    stripe.api_key = api_key
+    env_prefix = 'STAGING' if environment == 'staging' else 'PROD'
+
+    if print_secret:
+        # List existing webhooks
+        webhooks = stripe.WebhookEndpoint.list(limit=10)
+        if webhooks.data:
+            click.echo("Existing webhook endpoints:\n")
+            for webhook in webhooks.data:
+                click.echo(f"URL: {webhook.url}")
+                click.echo(f"ID: {webhook.id}")
+                click.echo(f"Secret: {webhook.secret}")
+                click.echo(f"Status: {webhook.status}")
+                click.echo()
+        else:
+            click.echo("No webhook endpoints configured")
+        return
+
+    if not endpoint_url:
+        click.echo("Error: --endpoint-url required to create webhook", err=True)
+        return
+
+    try:
+        # Create webhook endpoint
+        webhook = stripe.WebhookEndpoint.create(
+            url=endpoint_url,
+            enabled_events=[
+                "checkout.session.completed",
+                "customer.subscription.created",
+                "customer.subscription.updated",
+                "customer.subscription.deleted",
+                "invoice.payment_succeeded",
+                "invoice.payment_failed"
+            ]
+        )
+
+        click.echo(f"Webhook endpoint created:")
+        click.echo(f"  URL: {webhook.url}")
+        click.echo(f"  ID: {webhook.id}")
+        click.echo(f"  Secret: {webhook.secret}")
+        click.echo(f"\nAdd this to your environment:")
+        click.echo(f"  {env_prefix}_STRIPE_WEBHOOK_SECRET={webhook.secret}")
+
+    except stripe.error.StripeError as e:
+        click.echo(f"Error creating webhook: {e}", err=True)