update

opencode_gateway.py

@@ -1,306 +0,0 @@
-#!/usr/bin/env python3
-"""
-OpenCode API Gateway with Authentication
-
-This module provides a secure gateway to OpenCode services through nginx,
-handling authentication, rate limiting, and request forwarding.
-"""
-
-import os
-import logging
-import asyncio
-import json
-from typing import Dict, Any, Optional, List
-from datetime import datetime, timedelta
-
-import aiohttp
-from aiohttp import web, ClientSession
-from aiohttp.web import middleware
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class OpenCodeGateway:
-    """Secure gateway for OpenCode API services"""
-    
-    def __init__(self):
-        self.opencode_base = "http://127.0.0.1:57860"
-        self.session_timeout = 300
-        self.rate_limits = {}  # Simple in-memory rate limiting
-        self.allowed_origins = [
-            "https://airsltd-ocngx.hf.space",
-            "http://localhost:7860",
-            "https://localhost:7860"
-        ]
-        
-    async def setup_session(self) -> ClientSession:
-        """Setup HTTP session with proper headers"""
-        return ClientSession(
-            timeout=aiohttp.ClientTimeout(total=self.session_timeout),
-            headers={
-                'User-Agent': 'OpenCode-Gateway/1.0',
-                'Content-Type': 'application/json'
-            }
-        )
-    
-    def check_rate_limit(self, client_ip: str, endpoint: str) -> bool:
-        """Simple rate limiting (100 requests per minute per IP)"""
-        now = datetime.now()
-        key = f"{client_ip}:{endpoint}"
-        
-        if key not in self.rate_limits:
-            self.rate_limits[key] = []
-        
-        # Remove old requests (older than 1 minute)
-        self.rate_limits[key] = [
-            req_time for req_time in self.rate_limits[key]
-            if now - req_time < timedelta(minutes=1)
-        ]
-        
-        # Check if under limit
-        if len(self.rate_limits[key]) < 100:
-            self.rate_limits[key].append(now)
-            return True
-        
-        return False
-    
-    def check_cors(self, request: web.Request) -> bool:
-        """Check CORS origin"""
-        origin = request.headers.get('Origin', '')
-        if origin in self.allowed_origins or not origin:
-            return True
-        return False
-    
-    @middleware
-    async def auth_middleware(self, request: web.Request, handler):
-        """Authentication and security middleware"""
-        
-        # CORS handling
-        origin = request.headers.get('Origin', '')
-        if origin and origin in self.allowed_origins:
-            # Handle preflight requests
-            if request.method == 'OPTIONS':
-                return web.Response(
-                    status=200,
-                    headers={
-                        'Access-Control-Allow-Origin': origin,
-                        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-                        'Access-Control-Max-Age': '86400'
-                    }
-                )
-        
-        # Rate limiting check
-        client_ip = request.remote or 'unknown'
-        endpoint = request.path
-        
-        if not self.check_rate_limit(client_ip, endpoint):
-            return web.Response(
-                status=429,
-                text=json.dumps({"error": "Rate limit exceeded"}),
-                headers={'Content-Type': 'application/json'}
-            )
-        
-        # Log request
-        logger.info(f"{request.method} {request.path} from {client_ip}")
-        
-        try:
-            response = await handler(request)
-            
-            # Add CORS headers if needed
-            if origin and origin in self.allowed_origins:
-                response.headers['Access-Control-Allow-Origin'] = origin
-                response.headers['Access-Control-Allow-Credentials'] = 'true'
-            
-            return response
-            
-        except Exception as e:
-            logger.error(f"Error handling request: {str(e)}")
-            return web.Response(
-                status=500,
-                text=json.dumps({"error": "Internal server error"}),
-                headers={'Content-Type': 'application/json'}
-            )
-    
-    async def proxy_request(self, request: web.Request) -> web.Response:
-        """Proxy request to OpenCode server"""
-        
-        # Remove /opencode prefix if present
-        path = request.path
-        if path.startswith('/opencode/'):
-            path = path[10:]  # Remove /opencode/
-        
-        # Build target URL
-        target_url = f"{self.opencode_base}{path}"
-        if request.query_string:
-            target_url += f"?{request.query_string}"
-        
-        async with await self.setup_session() as session:
-            try:
-                # Prepare headers
-                headers = dict(request.headers)
-                headers.pop('Host', None)  # Remove Host header
-                headers.pop('Origin', None)  # Remove Origin for security
-                
-                # Make request
-                if request.method in ['POST', 'PUT', 'PATCH']:
-                    data = await request.read()
-                    async with session.request(
-                        method=request.method,
-                        url=target_url,
-                        headers=headers,
-                        data=data
-                    ) as resp:
-                        response_data = await resp.read()
-                        return web.Response(
-                            body=response_data,
-                            status=resp.status,
-                            headers=dict(resp.headers)
-                        )
-                else:
-                    async with session.request(
-                        method=request.method,
-                        url=target_url,
-                        headers=headers
-                    ) as resp:
-                        response_data = await resp.read()
-                        return web.Response(
-                            body=response_data,
-                            status=resp.status,
-                            headers=dict(resp.headers)
-                        )
-                        
-            except asyncio.TimeoutError:
-                logger.error(f"Timeout proxying to {target_url}")
-                return web.Response(
-                    status=504,
-                    text=json.dumps({"error": "Gateway timeout"}),
-                    headers={'Content-Type': 'application/json'}
-                )
-            except Exception as e:
-                logger.error(f"Error proxying to {target_url}: {str(e)}")
-                return web.Response(
-                    status=502,
-                    text=json.dumps({"error": "Bad gateway"}),
-                    headers={'Content-Type': 'application/json'}
-                )
-    
-    async def health_check(self, request: web.Request) -> web.Response:
-        """Health check endpoint"""
-        health_data = {
-            "status": "healthy",
-            "service": "OpenCode Gateway",
-            "version": "1.0.0",
-            "timestamp": datetime.now().isoformat(),
-            "upstream": {
-                "healthy": True,
-                "url": self.opencode_base
-            }
-        }
-        
-        return web.Response(
-            text=json.dumps(health_data, indent=2),
-            headers={'Content-Type': 'application/json'}
-        )
-    
-    async def api_info(self, request: web.Request) -> web.Response:
-        """API information and documentation"""
-        info_data = {
-            "title": "OpenCode API Gateway",
-            "description": "Secure gateway to OpenCode AI coding services",
-            "version": "1.0.0",
-            "endpoints": {
-                "health": "/gateway/health",
-                "api_docs": "/opencode/doc",
-                "global_endpoints": "/opencode/global/*",
-                "project_endpoints": "/opencode/project/*",
-                "session_endpoints": "/opencode/session/*",
-                "provider_endpoints": "/opencode/provider/*",
-                "file_operations": "/opencode/file/*",
-                "search_operations": "/opencode/find/*"
-            },
-            "features": [
-                "HTTP Basic Authentication",
-                "Rate Limiting (100 req/min)",
-                "CORS Support",
-                "Request Logging",
-                "Health Monitoring",
-                "Error Handling"
-            ],
-            "security": {
-                "authentication": "HTTP Basic Auth",
-                "rate_limiting": "100 requests per minute per IP",
-                "cors": "Configured origins only",
-                "logging": "All requests logged"
-            }
-        }
-        
-        return web.Response(
-            text=json.dumps(info_data, indent=2),
-            headers={'Content-Type': 'application/json'}
-        )
-
-
-async def create_app() -> web.Application:
-    """Create and configure the gateway application"""
-    
-    gateway = OpenCodeGateway()
-    app = web.Application(middlewares=[gateway.auth_middleware])
-    
-    # Gateway endpoints
-    app.router.add_get('/gateway/health', gateway.health_check)
-    app.router.add_get('/gateway/info', gateway.api_info)
-    
-    # OpenCode proxy endpoints
-    app.router.add_route('*', '/opencode/{path:.*}', gateway.proxy_request)
-    
-    # Direct OpenCode endpoints (for convenience)
-    opencode_endpoints = [
-        '/global', '/project', '/session', '/provider', '/config', '/auth',
-        '/file', '/find', '/command', '/agent', '/tool', '/lsp',
-        '/formatter', '/mcp', '/log', '/tui', '/event', '/doc'
-    ]
-    
-    for endpoint in opencode_endpoints:
-        app.router.add_route('*', f'{endpoint}{{path:.*}}', gateway.proxy_request)
-        app.router.add_route('*', endpoint, gateway.proxy_request)
-    
-    return app
-
-
-async def main():
-    """Main function to start the gateway"""
-    
-    # Environment configuration
-    host = os.getenv('GATEWAY_HOST', '127.0.0.1')
-    port = int(os.getenv('GATEWAY_PORT', '57860'))
-    
-    logger.info(f"Starting OpenCode Gateway on {host}:{port}")
-    
-    # Create application
-    app = await create_app()
-    
-    # Start server
-    runner = web.AppRunner(app)
-    await runner.setup()
-    
-    site = web.TCPSite(runner, host, port)
-    await site.start()
-    
-    logger.info(f"OpenCode Gateway started successfully")
-    logger.info(f"API Health: http://{host}:{port}/gateway/health")
-    logger.info(f"API Info: http://{host}:{port}/gateway/info")
-    logger.info(f"OpenCode Docs: http://{host}:{port}/opencode/doc")
-    
-    try:
-        # Keep the server running
-        while True:
-            await asyncio.sleep(1)
-    except KeyboardInterrupt:
-        logger.info("Shutting down OpenCode Gateway")
-        await runner.cleanup()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())