gitarsenal-cli 1.0.7 → 1.0.8

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -1947,7 +1947,7 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
 
 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"""
+    """Create a Modal SSH container with GPU support and tunneling"""
     
     # Generate a unique app name with timestamp to avoid conflicts
     timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
@@ -1998,137 +1998,212 @@ 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
-
-    # Create Modal app
-    with modal.enable_output():
-        print(f"🚀 Creating Modal app: {app_name}")
-        
-        # Configure the global ssh_container_function with the correct parameters
-        global ssh_container_function
-        
-        # Update the function's configuration with our specific needs
-        ssh_container_function = ssh_container_function.update(
-            gpu=gpu_spec['gpu'],
-            timeout=timeout_minutes * 60,
-            volumes={volume_mount_path: volume} if volume else 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")  # Fast Python package installer
+        .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",
+        )
+    )
+    
+    # Create the Modal app
+    app = modal.App(app_name)
+    
+    # Configure volumes if available
+    volumes_config = {}
+    if volume:
+        volumes_config[volume_mount_path] = volume
+    
+    @app.function(
+        image=ssh_image,
+        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 run_ssh_container():
+        """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
         )
         
-        # Start the container
-        print("🚀 Starting SSH container...")
+        print("✅ Root password configured")
         
-        # Use spawn to run the container in the background
-        container_handle = ssh_container_function.spawn(ssh_password, repo_url, repo_name, setup_commands)
+        # Start SSH daemon in background
+        print("🔄 Starting SSH daemon...")
+        ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
         
-        # Wait a moment for the container to start
-        print("⏳ Waiting for container to initialize...")
-        time.sleep(10)
+        # Give SSH daemon a moment to start
+        time.sleep(2)
         
-        # Get container information
-        try:
-            # Try to get the container ID from Modal
-            container_id = None
-            
-            # Get container list to find our container
-            print("🔍 Looking for container information...")
-            result = subprocess.run(["modal", "container", "list", "--json"], 
-                                  capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                try:
-                    containers = json.loads(result.stdout)
-                    if containers and isinstance(containers, list):
-                        # Find the most recent container
-                        for container in containers:
-                            if container.get("App") == "ssh-container-app":
-                                container_id = container.get("Container ID")
-                                break
-                        
-                        if not container_id and containers:
-                            # Fall back to the first container
-                            container_id = containers[0].get("Container ID")
-                            
-                except json.JSONDecodeError:
-                    pass
-            
-            if not container_id:
-                # Try text parsing
-                result = subprocess.run(["modal", "container", "list"], 
-                                      capture_output=True, text=True)
-                if result.returncode == 0:
-                    lines = result.stdout.split('\n')
-                    for line in lines:
-                        if "ssh-container-app" in line or ('ta-' in line and '│' in line):
-                            parts = line.split('│')
-                            if len(parts) >= 2:
-                                possible_id = parts[1].strip()
-                                if possible_id.startswith('ta-'):
-                                    container_id = possible_id
-                                    break
+        # Clone repository if provided
+        if repo_url:
+            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+            print(f"📥 Cloning repository: {repo_url}")
             
-            if container_id:
-                print(f"📋 Container ID: {container_id}")
+            try:
+                subprocess.run(["git", "clone", repo_url, "/root/repo"], check=True)
+                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}")
                 
-                # Get the external IP for SSH access
-                print("🔍 Getting container connection info...")
+                # Initialize git submodules if they exist
+                if os.path.exists(".gitmodules"):
+                    print("📦 Initializing git submodules...")
+                    subprocess.run(["git", "submodule", "update", "--init", "--recursive"], check=True)
                 
-                # Try to get SSH connection details
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Failed to clone repository: {e}")
+        
+        # Run setup commands if provided
+        if setup_commands:
+            print(f"⚙️ Running {len(setup_commands)} setup commands...")
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
                 try:
-                    # Modal containers typically expose SSH on port 22
-                    ssh_info = f"ssh root@{container_id}.modal.run"
-                    
-                    print("\n" + "="*80)
-                    print("🚀 SSH CONTAINER READY!")
-                    print("="*80)
-                    print(f"🆔 Container ID: {container_id}")
-                    print(f"🔐 SSH Password: {ssh_password}")
-                    print(f"📱 App Name: ssh-container-app")
-                    if volume:
-                        print(f"💾 Volume: {volume_name} (mounted at {volume_mount_path})")
-                    print("\n🔗 SSH Connection:")
-                    print(f"   {ssh_info}")
-                    print(f"   Password: {ssh_password}")
-                    print("\n💡 Alternative connection methods:")
-                    print(f"   modal container exec --pty {container_id} bash")
-                    print(f"   modal shell {container_id}")
-                    print("="*80)
+                    # 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
+                    )
+                    if result.stdout:
+                        print(f"✅ Output: {result.stdout}")
+                except subprocess.CalledProcessError as e:
+                    print(f"❌ Command failed: {e}")
+                    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
+            
+            print("\n" + "=" * 80)
+            print("🎉 SSH CONTAINER IS READY!")
+            print("=" * 80)
+            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 {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()
                     
-                    # Try to open SSH connection in a new terminal
-                    try:
-                        terminal_script = f'''
-                        tell application "Terminal"
-                            do script "echo 'Connecting to Modal SSH container...'; echo 'Password: {ssh_password}'; {ssh_info}"
-                            activate
-                        end tell
-                        '''
+                    # 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)
                         
-                        subprocess.run(['osascript', '-e', terminal_script], 
-                                      capture_output=True, text=True, timeout=30)
-                        print("✅ New terminal window opened with SSH connection")
+                        # 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")
                         
-                    except Exception as e:
-                        print(f"⚠️ Could not open terminal window: {e}")
-                        print("📝 You can manually connect using the SSH command above")
+                        last_check = current_time
                     
-                except Exception as e:
-                    print(f"⚠️ Error getting SSH connection info: {e}")
-                    print("📝 You can connect using:")
-                    print(f"   modal container exec --pty {container_id} bash")
-            else:
-                print("⚠️ Could not determine container ID")
-                print("📝 Check running containers with: modal container list")
-        
-        except Exception as e:
-            print(f"❌ Error getting container information: {e}")
-        
-        # Return container information
+                    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
+    
+    # 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
+        with modal.enable_output():
+            with app.run():
+                run_ssh_container.remote()
+                
         return {
-            "container_handle": container_handle,
-            "container_id": container_id,
-            "app_name": "ssh-container-app",
+            "app_name": app_name,
             "ssh_password": ssh_password,
             "volume_name": volume_name,
             "volume_mount_path": volume_mount_path if volume else None
         }
+    except KeyboardInterrupt:
+        print("\n👋 Container startup interrupted")
+        return None
+    except Exception as e:
+        print(f"❌ Error running container: {e}")
+        return None
 
 def fetch_setup_commands_from_api(repo_url):
     """Fetch setup commands from the GitIngest API using real repository analysis."""
@@ -2475,6 +2550,124 @@ def get_setup_commands_from_local_api(repo_url, gitingest_data):
     
     return None
 
+# Define a function to create and return a properly configured ssh container function
+def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=None, volume_mount_path="/persistent"):
+    # Create a new app for this specific container
+    app_name = f"ssh-container-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    ssh_app = modal.App.lookup(app_name, create_if_missing=True)
+    
+    # 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")
+        .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",
+        )
+    )
+    
+    # Setup volume mount if available
+    volumes = {}
+    if volume:
+        volumes[volume_mount_path] = volume
+    
+    # Define the function with the specific configuration
+    @ssh_app.function(
+        image=ssh_image,
+        timeout=timeout_minutes * 60,  # Convert to seconds
+        gpu=gpu_type,
+        cpu=2,
+        memory=8192,
+        serialized=True,
+        volumes=volumes if volumes else None,
+    )
+    def ssh_container(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
+        import subprocess
+        import time
+        import os
+        
+        # Set root password
+        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
+        
+        # Start SSH service
+        subprocess.run(["service", "ssh", "start"], check=True)
+        
+        # Setup environment
+        os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
+        
+        # Clone repository if provided
+        if repo_url:
+            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+            print(f"📥 Cloning repository: {repo_url}")
+            
+            try:
+                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_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}")
+        
+        # Run setup commands if provided
+        if setup_commands:
+            print(f"⚙️ Running {len(setup_commands)} setup commands...")
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+                try:
+                    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:
+                    print(f"❌ Command failed: {e}")
+                    if e.stderr:
+                        print(f"❌ Error: {e.stderr}")
+        
+        # Get container info
+        print("🔍 Container started successfully!")
+        print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
+        
+        # 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)
+    
+    # Return the configured function
+    return ssh_container, app_name
+
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse