gitarsenal-cli 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/MODAL_PROXY_README.md

@@ -0,0 +1,145 @@
+# Modal Proxy Service for GitArsenal CLI
+
+This document explains how to set up and use the Modal proxy service with GitArsenal CLI.
+
+## What is the Modal Proxy Service?
+
+The Modal proxy service allows users to access Modal services (like GPU-accelerated containers) without exposing the owner's Modal token. The service runs on a server and provides API endpoints for creating sandboxes and SSH containers, using API key authentication.
+
+## Server-Side Setup
+
+1. **Install Requirements**:
+   ```bash
+   pip install flask flask-cors modal python-dotenv
+   ```
+
+2. **Set Environment Variables**:
+   Create a `.env` file in the same directory as `modal_proxy_service.py`:
+   ```
+   MODAL_TOKEN=your_modal_token_here
+   ADMIN_KEY=your_admin_key_here
+   API_KEYS=optional_comma_separated_list_of_api_keys
+   ```
+
+3. **Start the Service**:
+   ```bash
+   python modal_proxy_service.py
+   ```
+   
+   The service will start on port 5001 by default.
+
+4. **Create an API Key** (if not pre-configured in `.env`):
+   ```bash
+   curl -X POST http://localhost:5001/api/create-api-key \
+        -H "X-Admin-Key: your_admin_key_here"
+   ```
+   
+   This will return a JSON response with a new API key:
+   ```json
+   {"api_key": "generated_api_key_here"}
+   ```
+
+5. **Optional: Use ngrok to expose the service publicly**:
+   ```bash
+   ngrok http 5001
+   ```
+   
+   This will provide you with a public URL that you can share with users.
+   
+   Current ngrok URL: `https://e74889c63199.ngrok-free.app`
+
+## Client-Side Setup
+
+1. **Configure the proxy client**:
+   ```bash
+   ./gitarsenal.py proxy configure
+   ```
+   
+   You'll be prompted to enter:
+   - The proxy URL (the default is now set to `https://e74889c63199.ngrok-free.app`)
+   - Your API key
+
+2. **Check proxy service status**:
+   ```bash
+   ./gitarsenal.py proxy status
+   ```
+
+## Using the Proxy Service
+
+### Create an SSH Container
+
+```bash
+# Using the proxy command
+./gitarsenal.py proxy ssh --gpu A10G --repo-url https://github.com/username/repo.git --wait
+
+# Or using the standard ssh command with --use-proxy flag
+./gitarsenal.py ssh --use-proxy --gpu A10G --repo-url https://github.com/username/repo.git
+```
+
+### Create a Sandbox
+
+```bash
+# Using the proxy command
+./gitarsenal.py proxy sandbox --gpu A10G --repo-url https://github.com/username/repo.git --wait
+
+# Or using the standard sandbox command with --use-proxy flag
+./gitarsenal.py sandbox --use-proxy --gpu A10G --repo-url https://github.com/username/repo.git
+```
+
+## Troubleshooting
+
+### "Token missing" Error
+
+If you see a "Token missing" error when creating containers through the proxy service:
+
+1. **Check that the MODAL_TOKEN is set on the server**:
+   - Verify the `.env` file has a valid MODAL_TOKEN
+   - Ensure the token is correctly formatted and not expired
+   - Restart the proxy service after updating the token
+
+2. **Manually set the token on the server**:
+   ```bash
+   # On the server running the proxy service
+   export MODAL_TOKEN_ID=your_modal_token_here
+   modal token set your_modal_token_here
+   ```
+
+3. **Verify the token works directly on the server**:
+   ```bash
+   # Test if the token works by listing Modal volumes
+   modal volume list
+   ```
+
+4. **Check the proxy service logs**:
+   - Look at `modal_proxy.log` on the server for detailed error messages
+   - Check for messages like "Modal token verification failed"
+   - Ensure the token is being properly passed to the Modal API
+
+5. **Restart the proxy service**:
+   ```bash
+   # Kill the existing process and restart
+   pkill -f modal_proxy_service.py
+   python modal_proxy_service.py
+   ```
+
+6. **Check ngrok connection**:
+   - Verify the ngrok tunnel is active and the URL is correct
+   - Ensure requests are being properly forwarded to the proxy service
+
+### "Unauthorized" Error
+
+If you see an "Unauthorized" error:
+
+1. **When creating an API key**:
+   - Make sure you're including the correct admin key in the request header
+   - Example: `-H "X-Admin-Key: your_admin_key_here"`
+
+2. **When using the API**:
+   - Make sure your client is configured with a valid API key
+   - Reconfigure with `./gitarsenal.py proxy configure`
+
+## Security Considerations
+
+- Keep your admin key and API keys secure
+- Use HTTPS if exposing the service publicly (ngrok provides this automatically)
+- Consider implementing additional authentication mechanisms for production use 

package/python/gitarsenal.py

@@ -60,21 +60,49 @@ def check_modal_auth():
         return False
 
 def check_proxy_config():
-    """Check if Modal proxy is configured"""
+    """Check if Modal proxy configuration exists and is valid"""
     try:
-        # Import the proxy client
         from gitarsenal_proxy_client import GitArsenalProxyClient
         
-        # Create client and load config
+        # Initialize client
         client = GitArsenalProxyClient()
+        
+        # Check if configuration exists
         config = client.load_config()
         
-        # Check if proxy URL and API key are configured
-        if "proxy_url" in config and "api_key" in config:
-            return True
-        else:
+        if not config.get("proxy_url") or not config.get("api_key"):
+            print("⚠️ Modal proxy not configured. Setting up with default values...")
+            
+            # Set default proxy URL to the ngrok URL
+            default_url = "https://e74889c63199.ngrok-free.app"
+            
+            # Update configuration with default URL
+            config["proxy_url"] = default_url
+            client.save_config(config)
+            client.base_url = default_url
+            
+            print(f"✅ Set default proxy URL: {default_url}")
+            
+            # If API key is missing, prompt for configuration
+            if not config.get("api_key"):
+                print("⚠️ API key is still missing. Please configure:")
+                client.configure(interactive=True)
+            
             return False
+        
+        # Verify connection to proxy
+        health = client.health_check()
+        if not health["success"]:
+            print(f"⚠️ Could not connect to Modal proxy at {config.get('proxy_url')}")
+            print(f"   Error: {health.get('error', 'Unknown error')}")
+            print("   Run './gitarsenal.py proxy configure' to update configuration.")
+            return False
+        
+        print(f"✅ Connected to Modal proxy at {config.get('proxy_url')}")
+        return True
+        
     except ImportError:
+        print("⚠️ GitArsenalProxyClient module not found")
         return False
     except Exception as e:
         print(f"⚠️ Error checking proxy configuration: {e}")
@@ -384,7 +412,21 @@ def main():
                     from gitarsenal_proxy_client import GitArsenalProxyClient
                     client = GitArsenalProxyClient()
                     
+                    # Ensure proxy is configured
+                    config = client.load_config()
+                    if not config.get("proxy_url") or not config.get("api_key"):
+                        print("\n⚠️ Modal proxy service is not fully configured.")
+                        print("Running configuration wizard...")
+                        client.configure(interactive=True)
+                        # Reload config after configuration
+                        config = client.load_config()
+                        if not config.get("proxy_url") or not config.get("api_key"):
+                            print("❌ Proxy configuration failed or was cancelled.")
+                            return 1
+                        print("✅ Proxy configuration completed successfully.")
+                    
                     # Create SSH container through proxy
+                    print(f"🚀 Creating SSH container through proxy service ({config.get('proxy_url')})")
                     result = client.create_ssh_container(
                         gpu_type=args.gpu,
                         repo_url=args.repo_url,
@@ -475,6 +517,31 @@ def main():
             
             elif args.proxy_command == "ssh":
                 # Create SSH container through proxy
+                print("🚀 Creating SSH container through proxy...")
+                
+                # Verify proxy configuration is complete
+                config = client.load_config()
+                if not config.get("proxy_url") or not config.get("api_key"):
+                    print("⚠️ Proxy configuration incomplete. Running configuration wizard...")
+                    client.configure(interactive=True)
+                    # Reload config after configuration
+                    config = client.load_config()
+                    if not config.get("proxy_url") or not config.get("api_key"):
+                        print("❌ Proxy configuration failed or was cancelled.")
+                        return 1
+                    print("✅ Proxy configuration completed successfully.")
+                
+                # Check proxy service health
+                health = client.health_check()
+                if not health["success"]:
+                    print(f"❌ Could not connect to proxy service at {config.get('proxy_url')}")
+                    print(f"   Error: {health.get('error', 'Unknown error')}")
+                    print("   Please check if the proxy service is running.")
+                    return 1
+                
+                print(f"✅ Connected to proxy service at {config.get('proxy_url')}")
+                
+                # Create SSH container
                 result = client.create_ssh_container(
                     gpu_type=args.gpu,
                     repo_url=args.repo_url,
@@ -489,8 +556,19 @@ def main():
                     print("❌ Failed to create SSH container through proxy service")
                     return 1
                 
-                print("✅ SSH container created successfully through proxy service")
-            
+                # Print connection information if available
+                if isinstance(result, dict):
+                    if "container_id" in result:
+                        print(f"📋 Container ID: {result['container_id']}")
+                    if "ssh_password" in result:
+                        print(f"🔐 SSH Password: {result['ssh_password']}")
+                
+                print("✅ SSH container creation process initiated through proxy service")
+                
+                if not args.wait:
+                    print("\n⚠️ Container creation is asynchronous. Use --wait flag to wait for it to be ready.")
+                    print("   You can check the status later using the container ID above.")
+                
             else:
                 print(f"❌ Unknown proxy command: {args.proxy_command}")
                 proxy_parser.print_help()

package/python/gitarsenal_proxy_client.py

@@ -32,7 +32,7 @@ class GitArsenalProxyClient:
         
         # 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
+            self.base_url = "https://e74889c63199.ngrok-free.app"  # Default to ngrok URL
         
         # Warn if no API key
         if not self.api_key:
@@ -217,6 +217,28 @@ class GitArsenalProxyClient:
     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,
@@ -226,10 +248,21 @@ class GitArsenalProxyClient:
             "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")
@@ -253,21 +286,21 @@ class GitArsenalProxyClient:
                     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")
-                        }
+                        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
-        }
+        return {"container_id": container_id, "ssh_password": ssh_password}
     
     def get_container_status(self, container_id):
         """Get the status of a container"""

package/python/modal_proxy_service.py

@@ -82,7 +82,30 @@ def setup_modal_auth():
     try:
         # Set the token in the environment
         os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
-        logger.info("Modal token set in environment")
+        # Also set the token directly in modal.config
+        modal.config._auth_config.token_id = MODAL_TOKEN
+        
+        # Verify token is working by attempting a simple operation
+        try:
+            # Try to list volumes as a simple API test
+            test_vol = modal.Volume.list()
+            logger.info("Modal token verified successfully - able to list volumes")
+        except Exception as vol_err:
+            logger.error(f"Modal token verification failed: {vol_err}")
+            # Try setting token again with different approach
+            try:
+                import subprocess
+                result = subprocess.run(
+                    ["modal", "token", "set", MODAL_TOKEN],
+                    capture_output=True, text=True, check=True
+                )
+                logger.info("Modal token set via CLI command")
+                return True
+            except Exception as cli_err:
+                logger.error(f"Failed to set token via CLI: {cli_err}")
+                return False
+        
+        logger.info("Modal token set in environment and config")
         return True
     except Exception as e:
         logger.error(f"Error setting up Modal authentication: {e}")
@@ -133,6 +156,11 @@ def create_sandbox():
         # Start sandbox creation in a separate thread
         def create_sandbox_thread():
             try:
+                # Ensure Modal token is set before creating sandbox
+                if not setup_modal_auth():
+                    logger.error("Failed to set up Modal authentication in thread")
+                    return
+                    
                 result = create_modal_sandbox(
                     gpu_type, 
                     repo_url=repo_url, 
@@ -196,9 +224,45 @@ def create_ssh_container():
         # Create a unique ID for this container
         container_id = str(uuid.uuid4())
         
+        # Log token status for debugging
+        token_status = "Token is set" if MODAL_TOKEN else "Token is missing"
+        logger.info(f"Modal token status before thread: {token_status}")
+        logger.info(f"Modal token length: {len(MODAL_TOKEN) if MODAL_TOKEN else 'N/A'}")
+        
+        # Ensure Modal token is set in environment
+        if MODAL_TOKEN:
+            os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+            # Also set directly in modal.config
+            modal.config._auth_config.token_id = MODAL_TOKEN
+            logger.info("Modal token explicitly set in environment and config")
+        
         # Start container creation in a separate thread
         def create_container_thread():
             try:
+                # Ensure Modal token is set before creating container
+                if not setup_modal_auth():
+                    logger.error("Failed to set up Modal authentication in thread")
+                    return
+                
+                # Explicitly set the Modal token in the environment again for this thread
+                os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+                
+                # Directly set the token in Modal config
+                modal.config._auth_config.token_id = MODAL_TOKEN
+                
+                # Log token status for debugging
+                token_status = "Token is set" if MODAL_TOKEN else "Token is missing"
+                logger.info(f"Modal token status in thread: {token_status}")
+                logger.info(f"Modal token length in thread: {len(MODAL_TOKEN) if MODAL_TOKEN else 'N/A'}")
+                
+                # Verify token is actually working
+                try:
+                    # Try a simple Modal operation to verify authentication
+                    import modal.cli.app_create
+                    logger.info("Modal module imported successfully in thread")
+                except Exception as auth_err:
+                    logger.error(f"Modal authentication verification error: {auth_err}")
+                
                 result = create_modal_ssh_container(
                     gpu_type, 
                     repo_url=repo_url, 

package/python/test_modalSandboxScript.py

@@ -2067,6 +2067,59 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                volume_name=None, timeout_minutes=60, ssh_password=None):
     """Create a Modal SSH container with GPU support and tunneling"""
     
+    # Check if Modal is authenticated
+    try:
+        # Try to access Modal token to check authentication
+        try:
+            # Check if token is set in environment
+            modal_token = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token:
+                print("⚠️ MODAL_TOKEN_ID not found in environment.")
+                # Try to set from modal.config if available
+                try:
+                    modal_token = modal.config._auth_config.token_id
+                    if modal_token:
+                        print("✅ Found token in modal.config")
+                        # Set it in environment for consistency
+                        os.environ["MODAL_TOKEN_ID"] = modal_token
+                except Exception as e:
+                    print(f"⚠️ Error accessing modal.config: {e}")
+            
+            # If still no token, try to get workspace name as authentication test
+            if not modal_token:
+                # This will raise an exception if not authenticated
+                workspace = modal.config.get_current_workspace_name()
+                print(f"✅ Modal authentication verified (workspace: {workspace})")
+            else:
+                print(f"✅ Modal token found (length: {len(modal_token)})")
+                # Explicitly set the token in modal config
+                modal.config._auth_config.token_id = modal_token
+                print("✅ Token explicitly set in modal.config")
+        except modal.exception.AuthError:
+            print("\n" + "="*80)
+            print("🔑 MODAL AUTHENTICATION REQUIRED")
+            print("="*80)
+            print("GitArsenal requires Modal authentication to create cloud environments.")
+            
+            # Check if token is in environment
+            modal_token = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token:
+                print("⚠️ No Modal token found in environment.")
+                return None
+            else:
+                print("🔄 Using Modal token from environment")
+                # Try to authenticate with the token
+                try:
+                    # Set token directly in modal config
+                    modal.config._auth_config.token_id = modal_token
+                    print("✅ Modal token set in config")
+                except Exception as e:
+                    print(f"⚠️ Error setting Modal token: {e}")
+                    return None
+    except Exception as e:
+        print(f"⚠️ Error checking Modal authentication: {e}")
+        print("Continuing anyway, but Modal operations may fail")
+    
     # Generate a unique app name with timestamp to avoid conflicts
     timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
     app_name = f"ssh-container-{timestamp}"
@@ -2116,6 +2169,41 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print(f"⚠️ Could not create default volume: {e}")
             print("⚠️ Continuing without persistent volume")
             volume = None
+    
+    # Print debug info for authentication
+    print("🔍 Modal authentication debug info:")
+    modal_token = os.environ.get("MODAL_TOKEN_ID")
+    print(f"  - MODAL_TOKEN_ID in env: {'Yes' if modal_token else 'No'}")
+    print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
+    
+    try:
+        workspace = modal.config.get_current_workspace_name()
+        print(f"  - Current workspace: {workspace}")
+    except Exception as e:
+        print(f"  - Error getting workspace: {e}")
+        
+    # Verify token is valid by trying a simple Modal operation
+    try:
+        print("🔍 Verifying Modal token validity...")
+        # Try to access Modal API
+        if not modal_token:
+            print("❌ No Modal token available. Cannot proceed.")
+            return None
+            
+        # Set token directly in modal config again to be sure
+        modal.config._auth_config.token_id = modal_token
+        
+        # Try to list volumes as a simple API test
+        try:
+            test_vol = modal.Volume.list()
+            print(f"✅ Modal token is valid! Successfully listed volumes.")
+        except Exception as vol_err:
+            print(f"❌ Token validation failed: {vol_err}")
+            print("Please check that your Modal token is valid and properly set.")
+            return None
+    except Exception as e:
+        print(f"❌ Error during token validation: {e}")
+        return None
 
     # Create SSH-enabled image
     ssh_image = (
@@ -2153,7 +2241,12 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     )
 
     # Create the Modal app
-    app = modal.App(app_name)
+    try:
+        app = modal.App(app_name)
+        print("✅ Created Modal app successfully")
+    except Exception as e:
+        print(f"❌ Error creating Modal app: {e}")
+        return None
     
     # Configure volumes if available
     volumes_config = {}
@@ -2319,6 +2412,10 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             "volume_name": volume_name,
             "volume_mount_path": volume_mount_path if volume else None
         }
+    except modal.exception.AuthError as auth_err:
+        print(f"❌ Modal authentication error: {auth_err}")
+        print("🔑 Please check that your Modal token is valid and properly set")
+        return None
     except KeyboardInterrupt:
         print("\n👋 Container startup interrupted")
         return None