gitarsenal-cli 1.1.2 → 1.1.4

package/python/gitarsenal_proxy_client.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""
+GitArsenal Proxy Client - Integration for Modal Proxy Service
+
+This module provides integration between gitarsenal-cli and the Modal proxy service,
+allowing users to use Modal services without exposing the server's Modal token.
+"""
+
+import os
+import json
+import requests
+import time
+import sys
+from pathlib import Path
+import getpass
+
+class GitArsenalProxyClient:
+    """Client for interacting with the Modal Proxy Service from gitarsenal-cli"""
+    
+    def __init__(self, base_url=None, api_key=None):
+        """Initialize the client with base URL and API key"""
+        self.base_url = base_url or os.environ.get("MODAL_PROXY_URL")
+        self.api_key = api_key or os.environ.get("MODAL_PROXY_API_KEY")
+        
+        # If no URL/API key provided, try to load from config
+        if not self.base_url or not self.api_key:
+            config = self.load_config()
+            if not self.base_url:
+                self.base_url = config.get("proxy_url")
+            if not self.api_key:
+                self.api_key = config.get("api_key")
+        
+        # If still no URL, use default
+        if not self.base_url:
+            self.base_url = "https://e74889c63199.ngrok-free.app"  # Default to ngrok URL
+        
+        # Warn if no API key
+        if not self.api_key:
+            print("⚠️ No API key provided. You will need to authenticate with the proxy service.")
+    
+    def load_config(self):
+        """Load proxy configuration from user's home directory"""
+        config_file = Path.home() / ".gitarsenal" / "proxy_config.json"
+        if not config_file.exists():
+            return {}
+            
+        try:
+            with open(config_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+    
+    def save_config(self, config):
+        """Save proxy configuration to user's home directory"""
+        config_dir = Path.home() / ".gitarsenal"
+        config_file = config_dir / "proxy_config.json"
+        
+        # Ensure directory exists
+        if not config_dir.exists():
+            config_dir.mkdir(parents=True)
+            # Set restrictive permissions on Unix-like systems
+            if os.name == 'posix':
+                config_dir.chmod(0o700)  # Only owner can read/write/execute
+        
+        try:
+            with open(config_file, 'w') as f:
+                json.dump(config, f)
+                
+            # Set restrictive permissions on Unix-like systems
+            if os.name == 'posix':
+                config_file.chmod(0o600)  # Only owner can read/write
+                
+            return True
+        except IOError as e:
+            print(f"❌ Error saving proxy configuration: {e}")
+            return False
+    
+    def configure(self, interactive=True):
+        """Configure the proxy client with URL and API key"""
+        config = self.load_config()
+        
+        if interactive:
+            print("\n" + "="*60)
+            print("🔧 MODAL PROXY CONFIGURATION")
+            print("="*60)
+            print("Configure GitArsenal to use a Modal proxy service.")
+            print("This allows you to use Modal services without having your own Modal token.")
+            print("-" * 60)
+            
+            # Get proxy URL
+            default_url = config.get("proxy_url", self.base_url)
+            print(f"\nEnter the URL of the Modal proxy service")
+            print(f"(Press Enter to use default: {default_url})")
+            proxy_url = input("Proxy URL: ").strip()
+            if not proxy_url:
+                proxy_url = default_url
+            
+            # Get API key
+            print("\nEnter your API key for the Modal proxy service")
+            print("(Contact the proxy service administrator if you don't have one)")
+            api_key = getpass.getpass("API Key (hidden): ").strip()
+            
+            # Save configuration
+            config["proxy_url"] = proxy_url
+            if api_key:
+                config["api_key"] = api_key
+            
+            self.save_config(config)
+            
+            # Update current instance
+            self.base_url = proxy_url
+            if api_key:
+                self.api_key = api_key
+            
+            print("\n✅ Proxy configuration saved successfully!")
+            return True
+        else:
+            # Non-interactive configuration
+            if "proxy_url" in config:
+                self.base_url = config["proxy_url"]
+            if "api_key" in config:
+                self.api_key = config["api_key"]
+            return "proxy_url" in config and "api_key" in config
+    
+    def _make_request(self, method, endpoint, data=None, params=None):
+        """Make a request to the proxy service"""
+        url = f"{self.base_url}{endpoint}"
+        headers = {"X-API-Key": self.api_key} if self.api_key else {}
+        
+        try:
+            if method.lower() == "get":
+                response = requests.get(url, headers=headers, params=params, timeout=30)
+            elif method.lower() == "post":
+                response = requests.post(url, headers=headers, json=data, timeout=30)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+            
+            # Check if the response is valid JSON
+            try:
+                response_data = response.json()
+            except json.JSONDecodeError:
+                return {
+                    "success": False,
+                    "error": f"Invalid JSON response: {response.text[:100]}...",
+                    "status_code": response.status_code
+                }
+            
+            # Check for errors
+            if response.status_code >= 400:
+                return {
+                    "success": False,
+                    "error": response_data.get("error", "Unknown error"),
+                    "status_code": response.status_code
+                }
+            
+            # Return successful response
+            return {
+                "success": True,
+                "data": response_data,
+                "status_code": response.status_code
+            }
+            
+        except requests.exceptions.RequestException as e:
+            return {
+                "success": False,
+                "error": f"Request failed: {str(e)}",
+                "status_code": None
+            }
+    
+    def health_check(self):
+        """Check if the proxy service is running"""
+        return self._make_request("get", "/api/health")
+    
+    def create_sandbox(self, gpu_type="A10G", repo_url=None, repo_name=None, 
+                      setup_commands=None, volume_name=None, wait=False):
+        """Create a Modal sandbox through the proxy service"""
+        data = {
+            "gpu_type": gpu_type,
+            "repo_url": repo_url,
+            "repo_name": repo_name,
+            "setup_commands": setup_commands or [],
+            "volume_name": volume_name
+        }
+        
+        response = self._make_request("post", "/api/create-sandbox", data=data)
+        
+        if not response["success"]:
+            print(f"❌ Failed to create sandbox: {response['error']}")
+            return None
+        
+        sandbox_id = response["data"].get("sandbox_id")
+        print(f"🚀 Sandbox creation started. ID: {sandbox_id}")
+        
+        # If wait is True, poll for sandbox status
+        if wait and sandbox_id:
+            print("⏳ Waiting for sandbox to be ready...")
+            max_wait_time = 300  # 5 minutes
+            poll_interval = 10   # 10 seconds
+            start_time = time.time()
+            
+            while time.time() - start_time < max_wait_time:
+                status_response = self.get_container_status(sandbox_id)
+                
+                if status_response["success"]:
+                    status_data = status_response["data"]
+                    if status_data.get("status") == "active":
+                        print(f"✅ Sandbox is ready!")
+                        return status_data.get("info")
+                
+                print(".", end="", flush=True)
+                time.sleep(poll_interval)
+            
+            print("\n⚠️ Timed out waiting for sandbox to be ready")
+        
+        return {"sandbox_id": sandbox_id}
+    
+    def create_ssh_container(self, gpu_type="A10G", repo_url=None, repo_name=None,
+                           setup_commands=None, volume_name=None, timeout=60, wait=False):
+        """Create a Modal SSH container through the proxy service"""
+        # Verify we have a valid API key
+        if not self.api_key:
+            print("❌ No API key provided. Please configure the proxy client first:")
+            print("   ./gitarsenal.py proxy configure")
+            return None
+
+        # Verify proxy URL is set
+        if not self.base_url:
+            print("❌ No proxy URL provided. Please configure the proxy client first:")
+            print("   ./gitarsenal.py proxy configure")
+            return None
+            
+        # Check if proxy is reachable
+        health = self.health_check()
+        if not health["success"]:
+            print(f"❌ Could not connect to proxy service at {self.base_url}")
+            print(f"   Error: {health.get('error', 'Unknown error')}")
+            print("   Please check if the proxy service is running and properly configured.")
+            return None
+            
+        print(f"✅ Connected to proxy service at {self.base_url}")
+        
+        data = {
+            "gpu_type": gpu_type,
+            "repo_url": repo_url,
+            "repo_name": repo_name,
+            "setup_commands": setup_commands or [],
+            "volume_name": volume_name,
+            "timeout": timeout
+        }
+        
+        print("🔄 Sending request to create SSH container...")
+        response = self._make_request("post", "/api/create-ssh-container", data=data)
+        
+        if not response["success"]:
+            print(f"❌ Failed to create SSH container: {response['error']}")
+            print(f"   Status code: {response.get('status_code', 'Unknown')}")
+            
+            # Additional error handling for common issues
+            if response.get('status_code') == 401:
+                print("   Authentication failed. Please check your API key.")
+                print("   Run './gitarsenal.py proxy configure' to set up a new API key.")
+            elif response.get('status_code') == 500:
+                print("   Server error. The proxy service might be misconfigured.")
+                print("   Check if the MODAL_TOKEN is properly set on the server.")
+            
+            return None
+        
+        container_id = response["data"].get("container_id")
+        ssh_password = response["data"].get("ssh_password")
+        
+        print(f"🚀 SSH container creation started. ID: {container_id}")
+        if ssh_password:
+            print(f"🔐 SSH Password: {ssh_password}")
+        
+        # If wait is True, poll for container status
+        if wait and container_id:
+            print("⏳ Waiting for SSH container to be ready...")
+            max_wait_time = 300  # 5 minutes
+            poll_interval = 10   # 10 seconds
+            start_time = time.time()
+            
+            while time.time() - start_time < max_wait_time:
+                status_response = self.get_container_status(container_id)
+                
+                if status_response["success"]:
+                    status_data = status_response["data"]
+                    if status_data.get("status") == "active":
+                        print(f"✅ SSH container is ready!")
+                        container_info = status_data.get("info", {})
+                        
+                        # Add the password back since it's removed in the status endpoint
+                        container_info["ssh_password"] = ssh_password
+                        
+                        return container_info
+                
+                print(".", end="", flush=True)
+                time.sleep(poll_interval)
+            
+            print("\n⚠️ Timed out waiting for SSH container to be ready")
+            print("The container may still be initializing. Check status with:")
+            print(f"./gitarsenal.py proxy status {container_id}")
+        
+        return {"container_id": container_id, "ssh_password": ssh_password}
+    
+    def get_container_status(self, container_id):
+        """Get the status of a container"""
+        return self._make_request("get", f"/api/container-status/{container_id}")
+    
+    def terminate_container(self, container_id):
+        """Terminate a container"""
+        data = {"container_id": container_id}
+        return self._make_request("post", "/api/terminate-container", data=data)
+
+
+if __name__ == "__main__":
+    # Example usage
+    if len(sys.argv) < 2:
+        print("Usage: python gitarsenal_proxy_client.py [command] [options]")
+        print("Commands: configure, health, create-sandbox, create-ssh, status, terminate")
+        sys.exit(1)
+    
+    client = GitArsenalProxyClient()
+    command = sys.argv[1]
+    
+    if command == "configure":
+        client.configure(interactive=True)
+    
+    elif command == "health":
+        response = client.health_check()
+        if response["success"]:
+            print(f"✅ Proxy service is running: {response['data']['message']}")
+        else:
+            print(f"❌ Proxy service health check failed: {response['error']}")
+    
+    elif command == "create-sandbox":
+        import argparse
+        parser = argparse.ArgumentParser(description="Create a Modal sandbox")
+        parser.add_argument("--gpu", type=str, default="A10G", help="GPU type")
+        parser.add_argument("--repo", type=str, help="Repository URL")
+        parser.add_argument("--name", type=str, help="Repository name")
+        parser.add_argument("--volume", type=str, help="Volume name")
+        parser.add_argument("--wait", action="store_true", help="Wait for sandbox to be ready")
+        args = parser.parse_args(sys.argv[2:])
+        
+        result = client.create_sandbox(
+            gpu_type=args.gpu,
+            repo_url=args.repo,
+            repo_name=args.name,
+            volume_name=args.volume,
+            wait=args.wait
+        )
+        
+        if result:
+            print(f"🚀 Sandbox creation initiated: {result}")
+    
+    elif command == "create-ssh":
+        import argparse
+        parser = argparse.ArgumentParser(description="Create a Modal SSH container")
+        parser.add_argument("--gpu", type=str, default="A10G", help="GPU type")
+        parser.add_argument("--repo", type=str, help="Repository URL")
+        parser.add_argument("--name", type=str, help="Repository name")
+        parser.add_argument("--volume", type=str, help="Volume name")
+        parser.add_argument("--timeout", type=int, default=60, help="Timeout in minutes")
+        parser.add_argument("--wait", action="store_true", help="Wait for container to be ready")
+        args = parser.parse_args(sys.argv[2:])
+        
+        result = client.create_ssh_container(
+            gpu_type=args.gpu,
+            repo_url=args.repo,
+            repo_name=args.name,
+            volume_name=args.volume,
+            timeout=args.timeout,
+            wait=args.wait
+        )
+        
+        if result:
+            print(f"🚀 SSH container creation initiated: {result}")
+    
+    elif command == "status":
+        if len(sys.argv) < 3:
+            print("Usage: python gitarsenal_proxy_client.py status [container_id]")
+            sys.exit(1)
+        
+        container_id = sys.argv[2]
+        response = client.get_container_status(container_id)
+        
+        if response["success"]:
+            print(f"✅ Container status: {json.dumps(response['data'], indent=2)}")
+        else:
+            print(f"❌ Failed to get container status: {response['error']}")
+    
+    elif command == "terminate":
+        if len(sys.argv) < 3:
+            print("Usage: python gitarsenal_proxy_client.py terminate [container_id]")
+            sys.exit(1)
+        
+        container_id = sys.argv[2]
+        response = client.terminate_container(container_id)
+        
+        if response["success"]:
+            print(f"✅ Container terminated: {response['data']['message']}")
+        else:
+            print(f"❌ Failed to terminate container: {response['error']}")
+    
+    else:
+        print(f"❌ Unknown command: {command}")
+        print("Available commands: configure, health, create-sandbox, create-ssh, status, terminate")
+        sys.exit(1)