gitarsenal-cli 1.1.1 → 1.1.3

package/python/gitarsenal_proxy_client.py

@@ -0,0 +1,375 @@
+#!/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 = "http://localhost:5001"  # Default to 5001 to avoid macOS AirPlay conflict
+        
+        # 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"""
+        data = {
+            "gpu_type": gpu_type,
+            "repo_url": repo_url,
+            "repo_name": repo_name,
+            "setup_commands": setup_commands or [],
+            "volume_name": volume_name,
+            "timeout": timeout
+        }
+        
+        response = self._make_request("post", "/api/create-ssh-container", data=data)
+        
+        if not response["success"]:
+            print(f"❌ Failed to create SSH container: {response['error']}")
+            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!")
+                        return {
+                            "container_id": container_id,
+                            "ssh_password": ssh_password,
+                            "info": status_data.get("info")
+                        }
+                
+                print(".", end="", flush=True)
+                time.sleep(poll_interval)
+            
+            print("\n⚠️ Timed out waiting for SSH container to be ready")
+        
+        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) 

package/python/modal_proxy_service.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""
+Modal Proxy Service for GitArsenal CLI
+
+This service allows GitArsenal CLI users to access Modal services without exposing your Modal token.
+It acts as a secure proxy between clients and Modal's API.
+"""
+
+import os
+import json
+import secrets
+import string
+import time
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import modal
+import threading
+import logging
+from dotenv import load_dotenv
+import uuid
+import sys
+from pathlib import Path
+
+# Add the current directory to the path so we can import the test_modalSandboxScript module
+current_dir = Path(__file__).parent.absolute()
+sys.path.append(str(current_dir.parent))
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("modal_proxy.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("modal-proxy")
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+# Get Modal token from environment variable
+MODAL_TOKEN = os.environ.get("MODAL_TOKEN")
+if not MODAL_TOKEN:
+    logger.error("MODAL_TOKEN environment variable is not set!")
+
+# Dictionary to store active containers
+active_containers = {}
+
+# Authentication tokens for clients
+# In a production environment, use a proper authentication system
+API_KEYS = {}
+if os.environ.get("API_KEYS"):
+    API_KEYS = {key.strip(): True for key in os.environ.get("API_KEYS").split(",")}
+
+def generate_api_key():
+    """Generate a new API key for a client"""
+    return ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(32))
+
+def authenticate_request():
+    """Authenticate the request using API key"""
+    api_key = request.headers.get('X-API-Key')
+    if not api_key or api_key not in API_KEYS:
+        return False
+    return True
+
+def generate_random_password(length=16):
+    """Generate a random password for SSH access"""
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    password = ''.join(secrets.choice(alphabet) for i in range(length))
+    return password
+
+def setup_modal_auth():
+    """Set up Modal authentication using the server's token"""
+    if not MODAL_TOKEN:
+        logger.error("Cannot set up Modal authentication: No token provided")
+        return False
+    
+    try:
+        # Set the token in the environment
+        os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+        logger.info("Modal token set in environment")
+        return True
+    except Exception as e:
+        logger.error(f"Error setting up Modal authentication: {e}")
+        return False
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({"status": "ok", "message": "Modal proxy service is running"})
+
+@app.route('/api/create-api-key', methods=['POST'])
+def create_api_key():
+    """Create a new API key (protected by admin key)"""
+    admin_key = request.headers.get('X-Admin-Key')
+    if not admin_key or admin_key != os.environ.get("ADMIN_KEY"):
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    new_key = generate_api_key()
+    API_KEYS[new_key] = True
+    
+    return jsonify({"api_key": new_key})
+
+@app.route('/api/create-sandbox', methods=['POST'])
+def create_sandbox():
+    """Create a Modal sandbox"""
+    if not authenticate_request():
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    if not setup_modal_auth():
+        return jsonify({"error": "Failed to set up Modal authentication"}), 500
+    
+    try:
+        data = request.json
+        gpu_type = data.get('gpu_type', 'A10G')
+        repo_url = data.get('repo_url')
+        repo_name = data.get('repo_name')
+        setup_commands = data.get('setup_commands', [])
+        volume_name = data.get('volume_name')
+        
+        # Import the sandbox creation function from your module
+        from test_modalSandboxScript import create_modal_sandbox
+        
+        logger.info(f"Creating sandbox with GPU: {gpu_type}, Repo: {repo_url}")
+        
+        # Create a unique ID for this sandbox
+        sandbox_id = str(uuid.uuid4())
+        
+        # Start sandbox creation in a separate thread
+        def create_sandbox_thread():
+            try:
+                result = create_modal_sandbox(
+                    gpu_type, 
+                    repo_url=repo_url, 
+                    repo_name=repo_name, 
+                    setup_commands=setup_commands,
+                    volume_name=volume_name
+                )
+                
+                if result:
+                    active_containers[sandbox_id] = {
+                        "container_id": result.get("container_id"),
+                        "sandbox_id": result.get("sandbox_id"),
+                        "created_at": time.time(),
+                        "type": "sandbox"
+                    }
+                    logger.info(f"Sandbox created successfully: {result.get('container_id')}")
+                else:
+                    logger.error("Failed to create sandbox")
+            except Exception as e:
+                logger.error(f"Error in sandbox creation thread: {e}")
+        
+        thread = threading.Thread(target=create_sandbox_thread)
+        thread.daemon = True
+        thread.start()
+        
+        return jsonify({
+            "message": "Sandbox creation started",
+            "sandbox_id": sandbox_id
+        })
+        
+    except Exception as e:
+        logger.error(f"Error creating sandbox: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/create-ssh-container', methods=['POST'])
+def create_ssh_container():
+    """Create a Modal SSH container"""
+    if not authenticate_request():
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    if not setup_modal_auth():
+        return jsonify({"error": "Failed to set up Modal authentication"}), 500
+    
+    try:
+        data = request.json
+        gpu_type = data.get('gpu_type', 'A10G')
+        repo_url = data.get('repo_url')
+        repo_name = data.get('repo_name')
+        setup_commands = data.get('setup_commands', [])
+        volume_name = data.get('volume_name')
+        timeout_minutes = data.get('timeout', 60)
+        
+        # Generate a random password for SSH
+        ssh_password = generate_random_password()
+        
+        # Import the SSH container creation function
+        from test_modalSandboxScript import create_modal_ssh_container
+        
+        logger.info(f"Creating SSH container with GPU: {gpu_type}, Repo: {repo_url}")
+        
+        # Create a unique ID for this container
+        container_id = str(uuid.uuid4())
+        
+        # Start container creation in a separate thread
+        def create_container_thread():
+            try:
+                result = create_modal_ssh_container(
+                    gpu_type, 
+                    repo_url=repo_url, 
+                    repo_name=repo_name, 
+                    setup_commands=setup_commands,
+                    volume_name=volume_name,
+                    timeout_minutes=timeout_minutes,
+                    ssh_password=ssh_password
+                )
+                
+                if result:
+                    active_containers[container_id] = {
+                        "container_id": result.get("app_name"),
+                        "ssh_password": ssh_password,
+                        "created_at": time.time(),
+                        "type": "ssh"
+                    }
+                    logger.info(f"SSH container created successfully: {result.get('app_name')}")
+                else:
+                    logger.error("Failed to create SSH container")
+            except Exception as e:
+                logger.error(f"Error in SSH container creation thread: {e}")
+        
+        thread = threading.Thread(target=create_container_thread)
+        thread.daemon = True
+        thread.start()
+        
+        return jsonify({
+            "message": "SSH container creation started",
+            "container_id": container_id,
+            "ssh_password": ssh_password
+        })
+        
+    except Exception as e:
+        logger.error(f"Error creating SSH container: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/container-status/<container_id>', methods=['GET'])
+def container_status(container_id):
+    """Get status of a container"""
+    if not authenticate_request():
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    if container_id in active_containers:
+        # Remove sensitive information like passwords
+        container_info = active_containers[container_id].copy()
+        if "ssh_password" in container_info:
+            del container_info["ssh_password"]
+        
+        return jsonify({
+            "status": "active",
+            "info": container_info
+        })
+    else:
+        return jsonify({
+            "status": "not_found",
+            "message": "Container not found or has been terminated"
+        }), 404
+
+@app.route('/api/terminate-container', methods=['POST'])
+def terminate_container():
+    """Terminate a Modal container"""
+    if not authenticate_request():
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    if not setup_modal_auth():
+        return jsonify({"error": "Failed to set up Modal authentication"}), 500
+    
+    try:
+        data = request.json
+        container_id = data.get('container_id')
+        
+        if not container_id:
+            return jsonify({"error": "Container ID is required"}), 400
+        
+        if container_id not in active_containers:
+            return jsonify({"error": "Container not found"}), 404
+        
+        modal_container_id = active_containers[container_id].get("container_id")
+        
+        # Terminate the container using Modal CLI
+        import subprocess
+        result = subprocess.run(
+            ["modal", "container", "terminate", modal_container_id],
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode == 0:
+            # Remove from active containers
+            del active_containers[container_id]
+            logger.info(f"Container terminated successfully: {modal_container_id}")
+            return jsonify({"message": "Container terminated successfully"})
+        else:
+            logger.error(f"Failed to terminate container: {result.stderr}")
+            return jsonify({"error": f"Failed to terminate container: {result.stderr}"}), 500
+        
+    except Exception as e:
+        logger.error(f"Error terminating container: {e}")
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    # Check if Modal token is set
+    if not MODAL_TOKEN:
+        logger.error("MODAL_TOKEN environment variable must be set!")
+        exit(1)
+    
+    # Generate an admin key if not set
+    if not os.environ.get("ADMIN_KEY"):
+        admin_key = generate_api_key()
+        os.environ["ADMIN_KEY"] = admin_key
+        logger.info(f"Generated admin key: {admin_key}")
+        print(f"Admin key: {admin_key}")
+    
+    port = int(os.environ.get("PORT", 5001))  # Default to 5001 to avoid macOS AirPlay conflict
+    app.run(host='0.0.0.0', port=port) 

package/python/requirements.txt

@@ -0,0 +1,6 @@
+modal>=0.56.4
+requests>=2.31.0
+pathlib>=1.0.1
+python-dotenv>=1.0.0
+flask>=2.0.0
+flask-cors>=3.0.0