gitarsenal-cli 1.2.1 → 1.2.2

package/package.json

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

package/python/modal_proxy_service.py

@@ -223,6 +223,18 @@ def root():
     """Root endpoint for basic connectivity testing"""
     return jsonify({"status": "ok", "message": "Modal proxy service is running"})
 
+@app.route('/api/modal-tokens', methods=['GET'])
+def get_modal_tokens():
+    """Get Modal tokens (protected by API key)"""
+    if not authenticate_request():
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    # Return the server's Modal token
+    return jsonify({
+        "token_id": MODAL_TOKEN,
+        "token_secret": MODAL_TOKEN  # For compatibility, use the same token
+    })
+
 @app.route('/api/create-api-key', methods=['POST'])
 def create_api_key():
     """Create a new API key (protected by admin key)"""

package/python/test_modalSandboxScript.py

@@ -2181,17 +2181,113 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
             subprocess.run(["service", "ssh", "start"], check=True)
 
 # Now modify the create_modal_ssh_container function to use the standalone ssh_container_function
+
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
                                volume_name=None, timeout_minutes=60, ssh_password=None):
-    """Create a Modal SSH container with GPU support and proper tunneling"""
+    """Create a Modal SSH container with GPU support and tunneling"""
     
-    # Check Modal authentication
+    # Check if Modal is authenticated
     try:
-        modal.config.get_current_workspace_name()
-        print("✅ Modal authentication verified")
+        # Print all environment variables for debugging
+        print("🔍 DEBUG: Checking environment variables")
+        modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+        modal_token = os.environ.get("MODAL_TOKEN")
+        print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 MODAL_TOKEN exists: {'Yes' if modal_token else 'No'}")
+        if modal_token_id:
+            print(f"🔍 MODAL_TOKEN_ID length: {len(modal_token_id)}")
+        if modal_token:
+            print(f"🔍 MODAL_TOKEN length: {len(modal_token)}")
+        
+        # Try to access Modal token to check authentication
+        try:
+            # Check if token is set in environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token_id:
+                print("⚠️ MODAL_TOKEN_ID not found in environment.")
+                # Try to get from MODAL_TOKEN
+                modal_token = os.environ.get("MODAL_TOKEN")
+                if modal_token:
+                    print("✅ Found token in MODAL_TOKEN environment variable")
+                    os.environ["MODAL_TOKEN_ID"] = modal_token
+                    modal_token_id = modal_token
+                    print(f"✅ Set MODAL_TOKEN_ID from MODAL_TOKEN (length: {len(modal_token)})")
+            
+            if modal_token_id:
+                print(f"✅ Modal token found (length: {len(modal_token_id)})")
+                
+                # Use the comprehensive fix_modal_token script
+                try:
+                    # Execute the fix_modal_token.py script
+                    import subprocess
+                    print(f"🔄 Running fix_modal_token.py to set up Modal token...")
+                    result = subprocess.run(
+                        ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    # Print the output
+                    print(result.stdout)
+                    
+                    if result.returncode != 0:
+                        print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
+                        if result.stderr:
+                            print(f"Error: {result.stderr}")
+                            
+                    print(f"✅ Modal token setup completed")
+                except Exception as e:
+                    print(f"⚠️ Error running fix_modal_token.py: {e}")
+            else:
+                print("❌ No Modal token found in environment variables")
+                # Try to get from file as a last resort
+                try:
+                    home_dir = os.path.expanduser("~")
+                    modal_dir = os.path.join(home_dir, ".modal")
+                    token_file = os.path.join(modal_dir, "token.json")
+                    if os.path.exists(token_file):
+                        print(f"🔍 Found Modal token file at {token_file}")
+                        with open(token_file, 'r') as f:
+                            import json
+                            token_data = json.load(f)
+                            if "token_id" in token_data:
+                                modal_token_id = token_data["token_id"]
+                                os.environ["MODAL_TOKEN_ID"] = modal_token_id
+                                os.environ["MODAL_TOKEN"] = modal_token_id
+                                print(f"✅ Loaded token from file (length: {len(modal_token_id)})")
+                            else:
+                                print("❌ Token file does not contain token_id")
+                    else:
+                        print("❌ Modal token file not found")
+                except Exception as e:
+                    print(f"❌ Error loading token from file: {e}")
+                
+                if not os.environ.get("MODAL_TOKEN_ID"):
+                    print("❌ Could not find Modal token in any location")
+                    return None
+                
+        except Exception as e:
+            print(f"⚠️ Error checking Modal token: {e}")
+            # Try to use the token from environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            modal_token = os.environ.get("MODAL_TOKEN")
+            if modal_token_id:
+                print(f"🔄 Using MODAL_TOKEN_ID from environment (length: {len(modal_token_id)})")
+            elif modal_token:
+                print(f"🔄 Using MODAL_TOKEN from environment (length: {len(modal_token)})")
+                os.environ["MODAL_TOKEN_ID"] = modal_token
+                modal_token_id = modal_token
+            else:
+                print("❌ No Modal token available. Cannot proceed.")
+                return None
+            
+            # Set it in both environment variables
+            os.environ["MODAL_TOKEN_ID"] = modal_token_id
+            os.environ["MODAL_TOKEN"] = modal_token_id
+            print("✅ Set both MODAL_TOKEN_ID and MODAL_TOKEN environment variables")
     except Exception as e:
-        print(f"❌ Modal authentication failed: {e}")
-        return None
+        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")
@@ -2230,86 +2326,99 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print(f"⚠️ Could not setup volume '{volume_name}': {e}")
             print("⚠️ Continuing without persistent volume")
             volume = None
+    else:
+        # Create a default volume for this session
+        default_volume_name = f"ssh-vol-{timestamp}"
+        print(f"📦 Creating default volume: {default_volume_name}")
+        try:
+            volume = modal.Volume.from_name(default_volume_name, create_if_missing=True)
+            volume_name = default_volume_name
+            print(f"✅ Default volume '{default_volume_name}' created")
+        except Exception as e:
+            print(f"⚠️ Could not create default volume: {e}")
+            print("⚠️ Continuing without persistent volume")
+            volume = None
     
-    # Create the Modal app
-    app = modal.App(app_name)
+    # 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'}")
     
+    # Verify we can create a Modal app
+    try:
+        print("🔍 Testing Modal app creation...")
+        app = modal.App(app_name)
+        print("✅ Created Modal app successfully")
+    except Exception as e:
+        print(f"❌ Error creating Modal app: {e}")
+        return None
+
     # Create SSH-enabled image
-    ssh_image = (
-        modal.Image.debian_slim()
-        .apt_install(
-            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-            "gpg", "ca-certificates", "software-properties-common"
-        )
-        .pip_install("uv", "modal")
-        .run_commands(
-            # Create SSH directory
-            "mkdir -p /var/run/sshd",
-            "mkdir -p /root/.ssh",
-            "chmod 700 /root/.ssh",
-            
-            # Configure SSH server for password authentication
-            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-            
-            # SSH keep-alive settings
-            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-            
-            # Allow SSH on port 22
-            "echo 'Port 22' >> /etc/ssh/sshd_config",
-            
-            # Generate SSH host keys
-            "ssh-keygen -A",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+    try:
+        print("📦 Building SSH-enabled image...")
+        ssh_image = (
+            modal.Image.debian_slim()
+            .apt_install(
+                "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+                "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
+                "gpg", "ca-certificates", "software-properties-common"
+            )
+            .pip_install("uv", "modal")  # Fast Python package installer and Modal
+            .run_commands(
+                # Create SSH directory
+                "mkdir -p /var/run/sshd",
+                "mkdir -p /root/.ssh",
+                "chmod 700 /root/.ssh",
+                
+                # Configure SSH server
+                "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+                "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+                "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+                
+                # SSH keep-alive settings
+                "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+                "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+                
+                # Generate SSH host keys
+                "ssh-keygen -A",
+                
+                # Set up a nice bash prompt
+                "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+            )
         )
-    )
-    
+        print("✅ SSH image built successfully")
+    except Exception as e:
+        print(f"❌ Error building SSH image: {e}")
+        return None
+        
     # Configure volumes if available
     volumes_config = {}
     if volume:
         volumes_config[volume_mount_path] = volume
-    
-    # Define the SSH container function with proper tunnel setup
+        
+    # Define the SSH container function
     @app.function(
         image=ssh_image,
-        timeout=timeout_minutes * 60,
+        timeout=timeout_minutes * 60,  # Convert to seconds
         gpu=gpu_spec['gpu'],
         cpu=2,
         memory=8192,
+        serialized=True,
         volumes=volumes_config if volumes_config else None,
     )
-    def ssh_container():
-        """Start SSH container with password authentication and tunnel."""
+    def ssh_container_function():
+        """Start SSH container with password authentication and optional setup."""
         import subprocess
         import time
         import os
         
-        print("🔧 Setting up SSH container...")
-        
         # Set root password
-        print(f"🔐 Setting root password...")
         subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
         
         # Start SSH service
-        print("🚀 Starting SSH service...")
         subprocess.run(["service", "ssh", "start"], check=True)
         
-        # Verify SSH service is running
-        result = subprocess.run(["service", "ssh", "status"], capture_output=True, text=True)
-        if result.returncode == 0:
-            print("✅ SSH service is running")
-        else:
-            print("❌ SSH service failed to start")
-            print(result.stdout)
-            print(result.stderr)
-            return
-        
         # Clone repository if provided
         if repo_url:
             repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
@@ -2343,74 +2452,49 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     if e.stderr:
                         print(f"❌ Error: {e.stderr}")
         
-        # CRITICAL: Use unencrypted tunnel for SSH (port 22)
-        print("🌐 Creating unencrypted SSH tunnel...")
-        
-        # Use Modal's unencrypted tunnel for SSH protocol
+        # Create SSH tunnel
         with modal.forward(22, unencrypted=True) as tunnel:
+            host, port = tunnel.tcp_socket
+            
             print("\n" + "=" * 80)
             print("🎉 SSH CONTAINER IS READY!")
             print("=" * 80)
-            print(f"🌐 SSH Host: {tunnel.tcp_socket[0]}")
-            print(f"🔌 SSH Port: {tunnel.tcp_socket[1]}")
+            print(f"🌐 SSH Host: {host}")
+            print(f"🔌 SSH Port: {port}")
             print(f"👤 Username: root")
             print(f"🔐 Password: {ssh_password}")
             print()
             print("🔗 CONNECT USING THIS COMMAND:")
-            print(f"ssh -p {tunnel.tcp_socket[1]} root@{tunnel.tcp_socket[0]}")
+            print(f"ssh -p {port} root@{host}")
             print("=" * 80)
             
-            # Store connection info in a file for later reference
-            connection_info = {
-                "host": tunnel.tcp_socket[0],
-                "port": tunnel.tcp_socket[1],
-                "username": "root",
-                "password": ssh_password,
-                "app_name": app_name,
-                "timestamp": datetime.datetime.now().isoformat()
-            }
-            
-            try:
-                with open(os.path.expanduser("~/.modal_ssh_connection"), "w") as f:
-                    json.dump(connection_info, f, indent=2)
-                print(f"📋 Connection info saved to ~/.modal_ssh_connection")
-            except Exception as e:
-                print(f"⚠️ Could not save connection info: {e}")
-            
-            # Keep the container and tunnel alive
-            print("⏳ Container is running. Press Ctrl+C to stop...")
-            try:
-                while True:
-                    time.sleep(30)
-                    # Check if SSH service is still running
-                    try:
-                        subprocess.run(["service", "ssh", "status"], check=True, 
-                                     capture_output=True)
-                    except subprocess.CalledProcessError:
-                        print("⚠️ SSH service stopped, restarting...")
-                        subprocess.run(["service", "ssh", "start"], check=True)
-            except KeyboardInterrupt:
-                print("\n👋 Container stopping...")
-                return
+            # Keep the container running
+            while True:
+                time.sleep(30)
+                # Check if SSH service is still running
+                try:
+                    subprocess.run(["service", "ssh", "status"], check=True, 
+                                 capture_output=True)
+                except subprocess.CalledProcessError:
+                    print("⚠️ SSH service stopped, restarting...")
+                    subprocess.run(["service", "ssh", "start"], check=True)
     
     # Run the container
     try:
         print("⏳ Starting container... This may take 1-2 minutes...")
         
-        # Run the container function
-        with app.run():
-            ssh_container.remote()
-        
+        # Start the container in a new thread to avoid blocking
+        with modal.enable_output():
+            with app.run():
+                ssh_container_function.remote()
+                
         return {
             "app_name": app_name,
             "ssh_password": ssh_password,
             "volume_name": volume_name
         }
-        
     except Exception as e:
         print(f"❌ Error running container: {e}")
-        import traceback
-        traceback.print_exc()
         return None
 
 def fetch_setup_commands_from_api(repo_url):