ai-lls-lib 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

ai_lls_lib/__init__.py

@@ -13,7 +13,7 @@ from ai_lls_lib.core.verifier import PhoneVerifier
 from ai_lls_lib.core.processor import BulkProcessor
 from ai_lls_lib.core.cache import DynamoDBCache
 
-__version__ = "1.1.0"
+__version__ = "1.3.0"
 __all__ = [
     "PhoneVerification",
     "BulkJob",

ai_lls_lib/auth/__init__.py

@@ -0,0 +1,4 @@
+"""Auth module for handling authentication and authorization."""
+from .context_parser import get_email_from_event, get_user_from_event
+
+__all__ = ["get_user_from_event", "get_email_from_event"]

ai_lls_lib/auth/context_parser.py

@@ -0,0 +1,68 @@
+"""Auth context parser for HTTP API v2.0 events."""
+from typing import Any, Dict, Optional
+
+
+def get_user_from_event(event: Dict[str, Any]) -> Optional[str]:
+    """
+    Extract user ID from HTTP API v2.0 event with all possible paths.
+    Handles both JWT and API key authentication contexts.
+
+    This function handles the complexities of AWS API Gateway authorizer contexts,
+    especially when EnableSimpleResponses is set to false, which wraps the
+    context in a 'lambda' key.
+
+    Args:
+        event: The Lambda event from API Gateway HTTP API v2.0
+
+    Returns:
+        User ID string if found, None otherwise
+    """
+    request_context = event.get("requestContext", {})
+    auth = request_context.get("authorizer", {})
+
+    # Handle lambda-wrapped context (EnableSimpleResponses: false)
+    # When EnableSimpleResponses is false, the authorizer context is wrapped
+    lam_ctx = auth.get("lambda", auth) if isinstance(auth.get("lambda"), dict) else auth
+
+    # Try all possible paths for user_id in priority order
+    user_id = (
+        # Lambda authorizer paths (most common with current setup)
+        lam_ctx.get("principal_id") or
+        lam_ctx.get("principalId") or
+        lam_ctx.get("sub") or
+        lam_ctx.get("user_id") or
+        # JWT paths (when using JWT authorizer directly)
+        auth.get("jwt", {}).get("claims", {}).get("sub") or
+        # Direct auth paths (fallback)
+        auth.get("principal_id") or
+        auth.get("principalId") or
+        auth.get("sub")
+    )
+
+    return user_id
+
+
+def get_email_from_event(event: Dict[str, Any]) -> Optional[str]:
+    """
+    Extract email from HTTP API v2.0 event.
+
+    Args:
+        event: The Lambda event from API Gateway HTTP API v2.0
+
+    Returns:
+        Email string if found, None otherwise
+    """
+    request_context = event.get("requestContext", {})
+    auth = request_context.get("authorizer", {})
+
+    # Handle lambda-wrapped context
+    lam_ctx = auth.get("lambda", auth) if isinstance(auth.get("lambda"), dict) else auth
+
+    # Try to get email from various locations
+    email = (
+        lam_ctx.get("email") or
+        auth.get("jwt", {}).get("claims", {}).get("email") or
+        auth.get("email")
+    )
+
+    return email

ai_lls_lib/cli/__main__.py

@@ -3,7 +3,7 @@ Landline Scrubber CLI entry point
 """
 import click
 import sys
-from ai_lls_lib.cli.commands import verify, cache, admin, test_stack
+from ai_lls_lib.cli.commands import verify, cache, admin, test_stack, stripe
 
 @click.group()
 @click.version_option(version="0.1.0", prog_name="ai-lls")
@@ -16,6 +16,7 @@ cli.add_command(verify.verify_group)
 cli.add_command(cache.cache_group)
 cli.add_command(admin.admin_group)
 cli.add_command(test_stack.test_stack_group)
+cli.add_command(stripe.stripe_group)
 
 def main():
     """Main entry point"""

ai_lls_lib/cli/commands/stripe.py

@@ -0,0 +1,329 @@
+"""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:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_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 - Variable",
+            "description": "Pay as you go - choose your amount",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "VARIABLE"
+            },
+            "price": {
+                "unit_amount": 500,  # $5.00 minimum
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "VARIABLE",
+                    "variable_amount": "true",
+                    "min_amount": "5",
+                    "default_amounts": "5,10,50",
+                    "credits_per_dollar": "285",  # ~$0.00175 per credit
+                    "plan_credits_text": "Variable credits",
+                    "percent_off": "",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "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": "5000",
+                    "plan_credits_text": "5,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": "28500",
+                    "plan_credits_text": "28,500 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": "66666",
+                    "plan_credits_text": "66,666 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": 29900,  # $299.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"]):
+                    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("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:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_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:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+
+    stripe.api_key = api_key
+
+    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"  {environment.upper()}_STRIPE_WEBHOOK_SECRET={webhook.secret}")
+
+    except stripe.error.StripeError as e:
+        click.echo(f"Error creating webhook: {e}", err=True)

ai_lls_lib/cli/env_loader.py

@@ -0,0 +1,122 @@
+"""Environment variable loader for CLI commands."""
+
+import os
+from pathlib import Path
+from typing import Optional, Dict
+import click
+
+
+def load_env_file(env_path: Path) -> Dict[str, str]:
+    """Load environment variables from a .env file."""
+    env_vars = {}
+    if env_path.exists():
+        try:
+            with open(env_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        # Remove quotes if present
+                        value = value.strip().strip('"').strip("'")
+                        env_vars[key.strip()] = value
+        except Exception as e:
+            click.echo(f"Warning: Could not read {env_path}: {e}", err=True)
+    return env_vars
+
+
+def load_environment_config() -> Dict[str, str]:
+    """
+    Load environment variables from multiple sources in order:
+    1. ~/.lls/.env (user global config)
+    2. ./.env (project local config)
+    3. System environment variables (highest priority)
+
+    Returns merged dictionary with system env taking precedence.
+    """
+    env_vars = {}
+
+    # Load from ~/.lls/.env
+    home_env = Path.home() / '.lls' / '.env'
+    if home_env.exists():
+        home_vars = load_env_file(home_env)
+        env_vars.update(home_vars)
+        click.echo(f"Loaded {len(home_vars)} variables from {home_env}", err=True)
+
+    # Load from ./.env
+    local_env = Path('.env')
+    if local_env.exists():
+        local_vars = load_env_file(local_env)
+        env_vars.update(local_vars)
+        click.echo(f"Loaded {len(local_vars)} variables from {local_env}", err=True)
+
+    # System environment variables override file-based ones
+    env_vars.update(os.environ)
+
+    return env_vars
+
+
+def get_stripe_key(environment: str, env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
+    """
+    Get Stripe API key for the specified environment.
+
+    Looks for keys in this order:
+    1. STAGING_STRIPE_SECRET_KEY or PROD_STRIPE_SECRET_KEY (based on environment)
+    2. STRIPE_SECRET_KEY (fallback)
+
+    Args:
+        environment: 'staging' or 'production'
+        env_vars: Optional pre-loaded environment variables
+
+    Returns:
+        Stripe API key or None if not found
+    """
+    if env_vars is None:
+        env_vars = load_environment_config()
+
+    # Map environment names to prefixes
+    env_prefix = {
+        'staging': 'STAGING',
+        'production': 'PROD'
+    }.get(environment, environment.upper())
+
+    # Try environment-specific key first
+    env_key = f"{env_prefix}_STRIPE_SECRET_KEY"
+    if env_key in env_vars:
+        return env_vars[env_key]
+
+    # Fall back to generic key
+    if 'STRIPE_SECRET_KEY' in env_vars:
+        return env_vars['STRIPE_SECRET_KEY']
+
+    return None
+
+
+def get_env_variable(key: str, environment: Optional[str] = None,
+                     env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
+    """
+    Get an environment variable, optionally with environment prefix.
+
+    Args:
+        key: Variable name (e.g., 'API_URL')
+        environment: Optional environment ('staging' or 'production')
+        env_vars: Optional pre-loaded environment variables
+
+    Returns:
+        Variable value or None if not found
+    """
+    if env_vars is None:
+        env_vars = load_environment_config()
+
+    if environment:
+        env_prefix = {
+            'staging': 'STAGING',
+            'production': 'PROD'
+        }.get(environment, environment.upper())
+
+        # Try environment-specific key first
+        env_key = f"{env_prefix}_{key}"
+        if env_key in env_vars:
+            return env_vars[env_key]
+
+    # Fall back to non-prefixed key
+    return env_vars.get(key)

ai_lls_lib/payment/__init__.py

@@ -0,0 +1,13 @@
+"""Payment module for Landline Scrubber."""
+
+from .models import Plan, PlanType, SubscriptionStatus
+from .stripe_manager import StripeManager
+from .credit_manager import CreditManager
+
+__all__ = [
+    "Plan",
+    "PlanType",
+    "SubscriptionStatus",
+    "StripeManager",
+    "CreditManager",
+]