gitarsenal-cli 1.1.7 → 1.1.9

package/package.json

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

package/python/modal_proxy_service.py

@@ -82,30 +82,32 @@ def setup_modal_auth():
     try:
         # Set the token in the environment
         os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
-        # 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 to set the token using Modal CLI
         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
-                )
+            import subprocess
+            result = subprocess.run(
+                ["modal", "token", "set", MODAL_TOKEN],
+                capture_output=True, text=True, check=False
+            )
+            if result.returncode == 0:
                 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
+            else:
+                logger.warning(f"CLI token set returned: {result.stderr}")
+        except Exception as cli_err:
+            logger.warning(f"Failed to set token via CLI: {cli_err}")
         
-        logger.info("Modal token set in environment and config")
+        # Verify token is working by attempting a simple operation
+        try:
+            # Try a simple Modal operation
+            import modal.cli.app_create
+            logger.info("Modal module imported successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error importing Modal module: {e}")
+            return False
+            
+        logger.info("Modal token set in environment")
         return True
     except Exception as e:
         logger.error(f"Error setting up Modal authentication: {e}")
@@ -201,10 +203,31 @@ def create_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
+    # Check if Modal token is available
+    if not MODAL_TOKEN:
+        logger.error("Cannot create SSH container: No Modal token available")
+        return jsonify({"error": "Modal token not configured on server"}), 500
     
     try:
+        # Set the token directly in environment
+        os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+        os.environ["MODAL_TOKEN"] = MODAL_TOKEN
+        logger.info(f"Set MODAL_TOKEN_ID in environment (length: {len(MODAL_TOKEN)})")
+        
+        # Try to set token via CLI as well
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["modal", "token", "set", MODAL_TOKEN],
+                capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                logger.info("Successfully set token via Modal CLI")
+            else:
+                logger.warning(f"Modal CLI token set returned: {result.stderr}")
+        except Exception as e:
+            logger.warning(f"Failed to set token via CLI: {e}")
+        
         data = request.json
         gpu_type = data.get('gpu_type', 'A10G')
         repo_url = data.get('repo_url')
@@ -229,39 +252,33 @@ def create_ssh_container():
         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
+                # Set token in environment for this thread
                 os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+                os.environ["MODAL_TOKEN"] = MODAL_TOKEN
+                logger.info(f"Set MODAL_TOKEN_ID in thread (length: {len(MODAL_TOKEN)})")
                 
-                # Directly set the token in Modal config
-                modal.config._auth_config.token_id = MODAL_TOKEN
+                # Create a copy of the environment variables for the container creation
+                env_copy = os.environ.copy()
+                env_copy["MODAL_TOKEN_ID"] = MODAL_TOKEN
+                env_copy["MODAL_TOKEN"] = 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 to set token via CLI again in this thread
                 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}")
+                    import subprocess
+                    subprocess.run(
+                        ["modal", "token", "set", MODAL_TOKEN],
+                        capture_output=True, text=True, check=False
+                    )
+                    logger.info("Set Modal token via CLI in thread")
+                except Exception as e:
+                    logger.warning(f"Failed to set token via CLI in thread: {e}")
+                
+                # Explicitly print token status for debugging
+                logger.info(f"MODAL_TOKEN_ID in thread env: {os.environ.get('MODAL_TOKEN_ID')}")
+                logger.info(f"MODAL_TOKEN in thread env: {os.environ.get('MODAL_TOKEN')}")
                 
                 result = create_modal_ssh_container(
                     gpu_type, 

package/python/test_modalSandboxScript.py

@@ -2069,53 +2069,95 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     
     # Check if Modal is authenticated
     try:
+        # 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 = os.environ.get("MODAL_TOKEN_ID")
-            if not modal_token:
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token_id:
                 print("⚠️ MODAL_TOKEN_ID not found in environment.")
-                # Try to set from modal.config if available
+                # 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 Modal CLI to set the token
                 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
+                    import subprocess
+                    print(f"🔄 Setting token via Modal CLI (token length: {len(modal_token_id)})")
+                    result = subprocess.run(
+                        ["modal", "token", "set", modal_token_id],
+                        capture_output=True, text=True
+                    )
+                    if result.returncode == 0:
+                        print("✅ Modal token set via CLI")
+                    else:
+                        print(f"⚠️ Modal CLI token set returned: {result.stderr}")
                 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
+                    print(f"⚠️ Error setting token via CLI: {e}")
             else:
-                print("🔄 Using Modal token from environment")
-                # Try to authenticate with the token
+                print("❌ No Modal token found in environment variables")
+                # Try to get from file as a last resort
                 try:
-                    # Set token directly in modal config
-                    modal.config._auth_config.token_id = modal_token
-                    print("✅ Modal token set in config")
+                    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 setting Modal token: {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"⚠️ Error checking Modal authentication: {e}")
         print("Continuing anyway, but Modal operations may fail")
@@ -2176,83 +2218,59 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     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:
-        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
+        print("🔍 Testing Modal app creation...")
+        app = modal.App(app_name)
+        print("✅ Created Modal app successfully")
     except Exception as e:
-        print(f"❌ Error during token validation: {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")  # 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",
-            
-            # Install Modal CLI
-            "pip install modal",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-        )
-    )
-
-    # Create the Modal app
     try:
-        app = modal.App(app_name)
-        print("✅ Created Modal app successfully")
+        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 creating Modal app: {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
     @app.function(
         image=ssh_image,
         timeout=timeout_minutes * 60,  # Convert to seconds
@@ -2262,27 +2280,17 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         serialized=True,
         volumes=volumes_config if volumes_config else None,
     )
-    def run_ssh_container():
+    def ssh_container_function():
         """Start SSH container with password authentication and optional setup."""
         import subprocess
         import time
         import os
         
         # Set root password
-        print("🔐 Setting up authentication...")
-        subprocess.run(
-            ["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], 
-            check=True
-        )
-        
-        print("✅ Root password configured")
-        
-        # Start SSH daemon in background
-        print("🔄 Starting SSH daemon...")
-        ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
+        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
         
-        # Give SSH daemon a moment to start
-        time.sleep(2)
+        # Start SSH service
+        subprocess.run(["service", "ssh", "start"], check=True)
         
         # Clone repository if provided
         if repo_url:
@@ -2290,18 +2298,14 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print(f"📥 Cloning repository: {repo_url}")
             
             try:
-                subprocess.run(["git", "clone", repo_url, "/root/repo"], check=True)
+                subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
                 print(f"✅ Repository cloned successfully: {repo_name_from_url}")
                 
                 # Change to repository directory
-                repo_dir = f"/root/repo"
-                os.chdir(repo_dir)
-                print(f"📂 Changed to repository directory: {repo_dir}")
-                
-                # Initialize git submodules if they exist
-                if os.path.exists(".gitmodules"):
-                    print("📦 Initializing git submodules...")
-                    subprocess.run(["git", "submodule", "update", "--init", "--recursive"], check=True)
+                repo_dir = f"/root/{repo_name_from_url}"
+                if os.path.exists(repo_dir):
+                    os.chdir(repo_dir)
+                    print(f"📂 Changed to repository directory: {repo_dir}")
                 
             except subprocess.CalledProcessError as e:
                 print(f"❌ Failed to clone repository: {e}")
@@ -2312,16 +2316,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             for i, cmd in enumerate(setup_commands, 1):
                 print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
                 try:
-                    # Run in repository directory if it exists, otherwise root
-                    work_dir = "/root/repo" if os.path.exists("/root/repo") else "/root"
-                    result = subprocess.run(
-                        cmd, 
-                        shell=True, 
-                        check=True, 
-                        cwd=work_dir,
-                        capture_output=True,
-                        text=True
-                    )
+                    result = subprocess.run(cmd, shell=True, check=True, 
+                                          capture_output=True, text=True)
                     if result.stdout:
                         print(f"✅ Output: {result.stdout}")
                 except subprocess.CalledProcessError as e:
@@ -2329,11 +2325,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     if e.stderr:
                         print(f"❌ Error: {e.stderr}")
         
-        # Create unencrypted tunnel for SSH (port 22)
-        print("🌐 Creating SSH tunnel...")
-        with modal.forward(22, unencrypted=True) as tunnel:
-            # Print connection information
-            host, port = tunnel.tcp_socket
+        # Create SSH tunnel
+        with modal.forward(22) as tunnel:
+            host, port = tunnel.host, tunnel.port
             
             print("\n" + "=" * 80)
             print("🎉 SSH CONTAINER IS READY!")
@@ -2345,80 +2339,33 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print()
             print("🔗 CONNECT USING THIS COMMAND:")
             print(f"ssh -p {port} root@{host}")
-            print()
-            print("💡 Connection Tips:")
-            print("• Copy the password above and paste when prompted")
-            print("• Use Ctrl+C to disconnect (container will keep running)")
-            print("• Type 'exit' in the SSH session to close the connection")
-            if repo_url:
-                print("• Your repository is in: /root/repo")
-            if volume:
-                print(f"• Persistent storage is mounted at: {volume_mount_path}")
-            print(f"• Container will auto-terminate in {timeout_minutes} minutes")
-            print()
-            print("🛠️ Available Tools:")
-            print("• Python 3 with pip and uv package manager")
-            print("• Git, curl, wget, vim, nano, htop")
-            print("• tmux and screen for session management")
-            print(f"• {gpu_type} GPU access")
             print("=" * 80)
             
-            # Keep the container running and monitor SSH daemon
-            try:
-                start_time = time.time()
-                last_check = start_time
-                
-                while True:
-                    current_time = time.time()
-                    
-                    # Check SSH daemon every 30 seconds
-                    if current_time - last_check >= 30:
-                        if ssh_process.poll() is not None:
-                            print("⚠️ SSH daemon stopped unexpectedly, restarting...")
-                            ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
-                            time.sleep(2)
-                        
-                        # Print alive status every 5 minutes
-                        elapsed_minutes = (current_time - start_time) / 60
-                        if int(elapsed_minutes) % 5 == 0 and elapsed_minutes > 0:
-                            remaining_minutes = timeout_minutes - elapsed_minutes
-                            print(f"⏱️ Container alive for {elapsed_minutes:.0f} minutes, {remaining_minutes:.0f} minutes remaining")
-                        
-                        last_check = current_time
-                    
-                    time.sleep(10)
-                        
-            except KeyboardInterrupt:
-                print("\n👋 Received shutdown signal...")
-                print("🔄 Stopping SSH daemon...")
-                ssh_process.terminate()
-                ssh_process.wait()
-                print("✅ Container shutting down gracefully")
-                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
-    print("⏳ Starting container... This may take 1-2 minutes...")
-    print("📦 Building image and allocating resources...")
-    
     try:
-        # Start the container and run the function
+        print("⏳ Starting container... This may take 1-2 minutes...")
+        
+        # Start the container in a new thread to avoid blocking
         with modal.enable_output():
             with app.run():
-                run_ssh_container.remote()
+                ssh_container_function.remote()
                 
         return {
             "app_name": app_name,
             "ssh_password": ssh_password,
-            "volume_name": volume_name,
-            "volume_mount_path": volume_mount_path if volume else None
+            "volume_name": volume_name
         }
-    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
     except Exception as e:
         print(f"❌ Error running container: {e}")
         return None