Initial commit: Billing Auth Gateway

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,142 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import json
+import os
+from datetime import datetime
+from auth import validate_api_key, get_key_info
+from key_generator import generate_api_key
+
+app = FastAPI(title="Billing & Auth Gateway", version="1.0.0")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Request models
+class GenerateKeyRequest(BaseModel):
+    plan_tier: str
+    user_email: str = "demo@example.com"
+
+class ValidateKeyRequest(BaseModel):
+    api_key: str
+
+class RevokeKeyRequest(BaseModel):
+    api_key: str
+
+@app.get("/")
+async def root():
+    return {
+        "service": "Billing & Auth Gateway",
+        "version": "1.0.0",
+        "status": "operational",
+        "endpoints": [
+            "/api/generate_key",
+            "/api/validate_key",
+            "/api/revoke_key",
+            "/api/key_info/{api_key}",
+            "/health"
+        ]
+    }
+
+@app.post("/api/generate_key")
+async def generate_key(request: GenerateKeyRequest):
+    """Generate a new API key"""
+    try:
+        result = generate_api_key(request.plan_tier, request.user_email)
+        return {
+            "api_key": result["api_key"],
+            "plan_tier": result["plan_tier"],
+            "calls_limit": result["calls_limit"],
+            "created_date": result["created_date"],
+            "status": "success"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/validate_key")
+async def validate_key(request: ValidateKeyRequest):
+    """Validate an API key"""
+    result = validate_api_key(request.api_key)
+    
+    if not result["valid"]:
+        return {
+            "valid": False,
+            "error": "Invalid API key",
+            "status": "error"
+        }
+    
+    return {
+        "valid": True,
+        "plan_tier": result["plan_tier"],
+        "calls_limit": result["calls_limit"],
+        "calls_used": result["calls_used"],
+        "active": result["active"],
+        "status": "success"
+    }
+
+@app.post("/api/revoke_key")
+async def revoke_key(request: RevokeKeyRequest):
+    """Revoke an API key"""
+    try:
+        # Load existing keys
+        keys_file = "data/api_keys.json"
+        if os.path.exists(keys_file):
+            with open(keys_file, 'r') as f:
+                keys = json.load(f)
+        else:
+            return {"revoked": False, "error": "Key not found", "status": "error"}
+        
+        # Find and revoke key
+        key_found = False
+        for key in keys:
+            if key["api_key"] == request.api_key:
+                key["active"] = False
+                key_found = True
+                break
+        
+        if not key_found:
+            return {"revoked": False, "error": "Key not found", "status": "error"}
+        
+        # Save updated keys
+        with open(keys_file, 'w') as f:
+            json.dump(keys, f, indent=2)
+        
+        return {"revoked": True, "status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/key_info/{api_key}")
+async def key_info(api_key: str):
+    """Get information about an API key"""
+    info = get_key_info(api_key)
+    
+    if not info:
+        raise HTTPException(status_code=404, detail="Key not found")
+    
+    return {
+        "plan_tier": info["plan_tier"],
+        "calls_limit": info["calls_limit"],
+        "calls_used": info["calls_used"],
+        "created_date": info["created_date"],
+        "active": info["active"],
+        "status": "success"
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "service": "billing-auth-gateway",
+        "version": "1.0.0",
+        "timestamp": datetime.now().isoformat()
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

auth.py

@@ -0,0 +1,74 @@
+import json
+import os
+
+def validate_api_key(api_key):
+    """
+    Validate an API key
+    
+    Args:
+        api_key: API key to validate
+    
+    Returns:
+        dict with validation result and key information
+    """
+    keys_file = "data/api_keys.json"
+    
+    # Check if keys file exists
+    if not os.path.exists(keys_file):
+        return {"valid": False}
+    
+    # Load keys
+    try:
+        with open(keys_file, 'r') as f:
+            keys = json.load(f)
+    except Exception as e:
+        return {"valid": False}
+    
+    # Find key
+    for key in keys:
+        if key["api_key"] == api_key:
+            if not key.get("active", True):
+                return {"valid": False}
+            
+            return {
+                "valid": True,
+                "plan_tier": key["plan_tier"],
+                "calls_limit": key["calls_limit"],
+                "calls_used": key.get("calls_used", 0),
+                "active": key.get("active", True)
+            }
+    
+    return {"valid": False}
+
+def get_key_info(api_key):
+    """
+    Get information about an API key
+    
+    Args:
+        api_key: API key to look up
+    
+    Returns:
+        dict with key information or None if not found
+    """
+    keys_file = "data/api_keys.json"
+    
+    if not os.path.exists(keys_file):
+        return None
+    
+    try:
+        with open(keys_file, 'r') as f:
+            keys = json.load(f)
+    except Exception as e:
+        return None
+    
+    for key in keys:
+        if key["api_key"] == api_key:
+            return {
+                "plan_tier": key["plan_tier"],
+                "calls_limit": key["calls_limit"],
+                "calls_used": key.get("calls_used", 0),
+                "created_date": key["created_date"],
+                "active": key.get("active", True)
+            }
+    
+    return None

data/api_keys.json

@@ -0,0 +1,12 @@
+[
+  {
+    "key_id": "key_demo_001",
+    "api_key": "bdr_test_demo_key_12345",
+    "plan_tier": "Pro",
+    "user_email": "demo@bdr-ai.com",
+    "created_date": "2026-01-08",
+    "calls_limit": 10000,
+    "calls_used": 0,
+    "active": true
+  }
+]

deploy_to_hf.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+import os
+import sys
+from huggingface_hub import HfApi, create_repo
+
+def deploy_to_huggingface():
+    repo_name = "billing-auth-gateway"
+    username = "BDR-AI"
+    repo_id = f"{username}/{repo_name}"
+    
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hf_token:
+        print("Error: HF_TOKEN environment variable not set")
+        sys.exit(1)
+    
+    print(f"Deploying {repo_name} to Hugging Face Spaces...")
+    
+    try:
+        api = HfApi(token=hf_token)
+        create_repo(repo_id=repo_id, repo_type="space", space_sdk="docker", token=hf_token, exist_ok=True)
+        print(f"✓ Repository {repo_id} created/verified")
+        
+        files_to_upload = [
+            "app.py",
+            "auth.py",
+            "key_generator.py",
+            "requirements.txt",
+            "README.md",
+            "data/api_keys.json",
+            "utils/encryption.py"
+        ]
+        
+        for file_path in files_to_upload:
+            try:
+                api.upload_file(path_or_fileobj=file_path, path_in_repo=file_path, repo_id=repo_id, repo_type="space", token=hf_token)
+                print(f"✓ Uploaded {file_path}")
+            except Exception as e:
+                print(f"✗ Failed to upload {file_path}: {e}")
+        
+        print(f"\n✓ Deployment complete!")
+        print(f"View your space at: https://huggingface.co/spaces/{repo_id}")
+    except Exception as e:
+        print(f"✗ Deployment failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    deploy_to_huggingface()

key_generator.py

@@ -0,0 +1,64 @@
+import json
+import os
+import secrets
+from datetime import datetime
+
+def generate_api_key(plan_tier, user_email):
+    """
+    Generate a new API key
+    
+    Args:
+        plan_tier: Plan tier (Free, Starter, Pro)
+        user_email: User email address
+    
+    Returns:
+        dict with api_key and key information
+    """
+    # Validate plan tier
+    valid_tiers = ["Free", "Starter", "Pro"]
+    if plan_tier not in valid_tiers:
+        raise ValueError(f"Invalid plan tier. Must be one of: {', '.join(valid_tiers)}")
+    
+    # Set calls limit based on plan
+    calls_limits = {
+        "Free": 100,
+        "Starter": 1000,
+        "Pro": 10000
+    }
+    calls_limit = calls_limits[plan_tier]
+    
+    # Generate unique API key
+    key_prefix = "bdr_test_" if plan_tier == "Free" else "bdr_prod_"
+    random_part = secrets.token_urlsafe(16)
+    api_key = f"{key_prefix}{random_part}"
+    
+    # Create key data
+    key_data = {
+        "key_id": f"key_{secrets.token_hex(4)}",
+        "api_key": api_key,
+        "plan_tier": plan_tier,
+        "user_email": user_email,
+        "created_date": datetime.now().strftime("%Y-%m-%d"),
+        "calls_limit": calls_limit,
+        "calls_used": 0,
+        "active": True
+    }
+    
+    # Load existing keys
+    keys_file = "data/api_keys.json"
+    os.makedirs("data", exist_ok=True)
+    
+    if os.path.exists(keys_file):
+        with open(keys_file, 'r') as f:
+            keys = json.load(f)
+    else:
+        keys = []
+    
+    # Add new key
+    keys.append(key_data)
+    
+    # Save keys
+    with open(keys_file, 'w') as f:
+        json.dump(keys, f, indent=2)
+    
+    return key_data

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.109.0
+uvicorn==0.27.0
+pydantic==2.5.3
+python-multipart==0.0.6

utils/encryption.py

@@ -0,0 +1,20 @@
+import hashlib
+import secrets
+
+def hash_api_key(api_key):
+    """Hash an API key for secure storage"""
+    return hashlib.sha256(api_key.encode()).hexdigest()
+
+def generate_secure_token(length=32):
+    """Generate a secure random token"""
+    return secrets.token_urlsafe(length)
+
+def verify_key_format(api_key):
+    """Verify API key format"""
+    if not api_key:
+        return False
+    if not api_key.startswith(("bdr_test_", "bdr_prod_")):
+        return False
+    if len(api_key) < 20:
+        return False
+    return True