gitarsenal-cli 1.1.25 → 1.2.1

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -2181,113 +2181,17 @@ 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 tunneling"""
+    """Create a Modal SSH container with GPU support and proper tunneling"""
     
-    # Check if Modal is authenticated
+    # Check Modal authentication
     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_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")
+        modal.config.get_current_workspace_name()
+        print("✅ Modal authentication verified")
     except Exception as e:
-        print(f"⚠️ Error checking Modal authentication: {e}")
-        print("Continuing anyway, but Modal operations may fail")
+        print(f"❌ Modal authentication failed: {e}")
+        return None
     
     # Generate a unique app name with timestamp to avoid conflicts
     timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
@@ -2326,99 +2230,86 @@ 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
     
-    # 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'}")
+    # Create the Modal app
+    app = modal.App(app_name)
     
-    # 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
-    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",
-            )
+    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"
         )
-        print("✅ SSH image built successfully")
-    except Exception as e:
-        print(f"❌ Error building SSH image: {e}")
-        return None
-        
+        .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",
+        )
+    )
+    
     # Configure volumes if available
     volumes_config = {}
     if volume:
         volumes_config[volume_mount_path] = volume
-        
-    # Define the SSH container function
+    
+    # Define the SSH container function with proper tunnel setup
     @app.function(
         image=ssh_image,
-        timeout=timeout_minutes * 60,  # Convert to seconds
+        timeout=timeout_minutes * 60,
         gpu=gpu_spec['gpu'],
         cpu=2,
         memory=8192,
-        serialized=True,
         volumes=volumes_config if volumes_config else None,
     )
-    def ssh_container_function():
-        """Start SSH container with password authentication and optional setup."""
+    def ssh_container():
+        """Start SSH container with password authentication and tunnel."""
         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', '')
@@ -2452,49 +2343,74 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     if e.stderr:
                         print(f"❌ Error: {e.stderr}")
         
-        # Create SSH tunnel
-        with modal.forward(22) as tunnel:
-            host, port = tunnel.host, tunnel.port
-            
+        # CRITICAL: Use unencrypted tunnel for SSH (port 22)
+        print("🌐 Creating unencrypted SSH tunnel...")
+        
+        # Use Modal's unencrypted tunnel for SSH protocol
+        with modal.forward(22, unencrypted=True) as tunnel:
             print("\n" + "=" * 80)
             print("🎉 SSH CONTAINER IS READY!")
             print("=" * 80)
-            print(f"🌐 SSH Host: {host}")
-            print(f"🔌 SSH Port: {port}")
+            print(f"🌐 SSH Host: {tunnel.tcp_socket[0]}")
+            print(f"🔌 SSH Port: {tunnel.tcp_socket[1]}")
             print(f"👤 Username: root")
             print(f"🔐 Password: {ssh_password}")
             print()
             print("🔗 CONNECT USING THIS COMMAND:")
-            print(f"ssh -p {port} root@{host}")
+            print(f"ssh -p {tunnel.tcp_socket[1]} root@{tunnel.tcp_socket[0]}")
             print("=" * 80)
             
-            # 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)
+            # 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
     
     # Run the container
     try:
         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():
-                ssh_container_function.remote()
-                
+        # Run the container function
+        with app.run():
+            ssh_container.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):