gitarsenal-cli 1.9.21 → 1.9.24

package/python/modal_container.py

@@ -0,0 +1,626 @@
+import os
+import subprocess
+import time
+import json
+import threading
+import modal
+
+# Now modify the create_modal_ssh_container function to use the PersistentShell
+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, interactive=False):
+    """Create a Modal SSH container with GPU support and tunneling"""
+    
+    # Use interactive mode if specified
+    if interactive:
+        # If GPU type is not specified, use default
+        if not gpu_type:
+            gpu_type = "A10G"
+            print(f"✅ Using default GPU type: {gpu_type}")
+        else:
+            print(f"✅ Using provided GPU type: {gpu_type}")
+            
+        # If repo URL is not specified, prompt for it
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    return None
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+                
+        # If volume name is not specified, ask about persistent volume
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+    
+    # 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")
+        openai_api_key = os.environ.get("OPENAI_API_KEY")
+        print(f"🔍 token exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
+        print(f"🔍 openai_api_key exists: {'Yes' if openai_api_key else 'No'}")
+        if modal_token_id:
+            print(f"🔍 token length: {len(modal_token_id)}")
+        if modal_token:
+            print(f"🔍 token length: {len(modal_token)}")
+        if openai_api_key:
+            print(f"🔍 openai_api_key length: {len(openai_api_key)}")
+        
+        # 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 environment variable")
+                    os.environ["MODAL_TOKEN_ID"] = modal_token
+                    modal_token_id = modal_token
+                    print(f"✅ Set token (length: {len(modal_token)})")
+            
+            if modal_token_id:
+                print(f"✅ 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"✅ token setup completed")
+                except Exception as e:
+                    print(f"⚠️ Error running fix_modal_token.py: {e}")
+            else:
+                print("❌ No 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("❌ 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 token from environment (length: {len(modal_token_id)})")
+            elif modal_token:
+                print(f"🔄 Using 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 token and id environment variables")
+    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}"
+    
+    gpu_configs = {
+        'T4': {'gpu': 't4', 'memory': 16},
+        'L4': {'gpu': 'l4', 'memory': 24},
+        'A10G': {'gpu': 'a10g', 'memory': 24},
+        'A100-40GB': {'gpu': 'a100', 'memory': 40},
+        'A100-80GB': {'gpu': 'a100-80gb', 'memory': 80},
+        'L40S': {'gpu': 'l40s', 'memory': 48},
+        'H100': {'gpu': 'h100', 'memory': 80},
+        'H200': {'gpu': 'h200', 'memory': 141},
+        'B200': {'gpu': 'b200', 'memory': 96}
+    }
+    
+    if gpu_type not in gpu_configs:
+        print(f"⚠️ Unknown GPU type: {gpu_type}. Using A10G as default.")
+        gpu_type = 'A10G'
+    
+    gpu_spec = gpu_configs[gpu_type]
+    print(f"🚀 Creating SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    
+    # Generate or use provided SSH password
+    if not ssh_password:
+        ssh_password = generate_random_password()
+        print(f"🔐 Generated SSH password: {ssh_password}")
+    
+    # Setup volume if specified
+    volume = None
+    volume_mount_path = "/persistent"
+    
+    if volume_name:
+        print(f"📦 Setting up volume: {volume_name}")
+        try:
+            volume = modal.Volume.from_name(volume_name, create_if_missing=True)
+            print(f"✅ Volume '{volume_name}' ready for use")
+        except Exception as e:
+            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"  - token in env: {'Yes' if modal_token else 'No'}")
+    print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
+
+    # Create SSH-enabled image
+    try:
+        print("📦 Building SSH-enabled image...")
+        
+        # Use a more stable CUDA base image and avoid problematic packages
+        ssh_image = (
+            # modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
+            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"
+            )
+            .uv_pip_install("uv", "modal", "requests", "openai")  # Remove problematic CUDA packages
+            .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
+    
+    # Create app with image passed directly (THIS IS THE KEY CHANGE)
+    try:
+        print("🔍 Testing app creation...")
+        app = modal.App(app_name, image=ssh_image)  # Pass image here
+        print("✅ Created app successfully")
+    except Exception as e:
+        print(f"❌ Error creating app: {e}")
+        return None
+        
+    # Define the SSH container function (remove image from decorator)
+    @app.function(
+        timeout=timeout_minutes * 60,  # Convert to seconds
+        gpu="A10G",
+        serialized=True,
+        volumes=volumes_config if volumes_config else None,
+    )
+    def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None, stored_credentials=None):
+        """Start SSH container with password authentication and optional setup."""
+        import subprocess
+        import time
+        import os
+        import json
+        
+        # Set root password
+        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
+        
+        # Set OpenAI API key if provided
+        if openai_api_key:
+            os.environ['OPENAI_API_KEY'] = openai_api_key
+            # print(f"✅ Set OpenAI API key in container environment (length: {len(openai_api_key)})")
+        else:
+            print("⚠️ No OpenAI API key provided to container")
+        
+        # Set up stored credentials in container environment
+        if stored_credentials:
+            print(f"🔐 Setting up {len(stored_credentials)} stored credentials in container...")
+            for key, value in stored_credentials.items():
+                # Set each credential as an environment variable
+                env_var_name = key.upper().replace('-', '_').replace(' ', '_')
+                os.environ[env_var_name] = value
+                print(f"✅ Set {env_var_name} in container environment")
+            
+            # Also save credentials to a file in the container for easy access
+            try:
+                credentials_dir = "/root/.gitarsenal"
+                os.makedirs(credentials_dir, exist_ok=True)
+                credentials_file = os.path.join(credentials_dir, "credentials.json")
+                with open(credentials_file, 'w') as f:
+                    json.dump(stored_credentials, f, indent=2)
+                print(f"✅ Saved credentials to {credentials_file}")
+                
+                # Print available credentials for user reference
+                print("\n🔐 AVAILABLE CREDENTIALS IN CONTAINER:")
+                print("="*50)
+                for key, value in stored_credentials.items():
+                    masked_value = value[:8] + "..." if len(value) > 8 else "***"
+                    env_var_name = key.upper().replace('-', '_').replace(' ', '_')
+                    print(f"  {key} -> {env_var_name} = {masked_value}")
+                print("="*50)
+                print("💡 These credentials are available as environment variables and in /root/.gitarsenal/credentials.json")
+                
+            except Exception as e:
+                print(f"⚠️ Could not save credentials file: {e}")
+        else:
+            print("⚠️ No stored credentials provided to container")
+        
+        # Start SSH service
+        subprocess.run(["service", "ssh", "start"], check=True)
+        
+        # Preprocess setup commands using LLM to inject credentials
+        if setup_commands:
+            print(f"🔧 Preprocessing {len(setup_commands)} setup commands with LLM to inject credentials...")
+            api_key = os.environ.get("OPENAI_API_KEY")
+            processed_commands = preprocess_commands_with_llm(setup_commands, stored_credentials, api_key)
+            print(f"⚙️ Running {len(processed_commands)} preprocessed setup commands with dynamic command list...")
+            
+            # Create command list manager with processed commands
+            cmd_manager = CommandListManager(processed_commands)
+            
+            # Create persistent shell instance starting in /root
+            shell = PersistentShell(working_dir="/root", timeout=300)
+            
+            try:
+                # Start the persistent shell
+                shell.start()
+                
+                # Track how many commands have been executed since last analysis
+                commands_since_analysis = 0
+                
+                # Execute commands using the command list manager
+                while cmd_manager.has_pending_commands():
+                    # Get next command to execute
+                    next_cmd, cmd_type = cmd_manager.get_next_command()
+                    
+                    if not next_cmd:
+                        break
+                    
+                    # Print status before executing
+                    cmd_manager.print_status()
+                    
+                    # Periodically analyze and update the command list
+                    if commands_since_analysis >= 3 and cmd_type == 'main':
+                        print("\n🔍 Periodic command list analysis...")
+                        api_key = os.environ.get("OPENAI_API_KEY")
+                        cmd_manager.update_command_list_with_llm(api_key)
+                        commands_since_analysis = 0
+                    
+                    # Execute the command
+                    if cmd_type == 'main':
+                        cmd_text = next_cmd['command']
+                        cmd_index = next_cmd['index']
+                        print(f"📋 Executing main command {cmd_index + 1}/{cmd_manager.total_commands}: {cmd_text}")
+                        
+                        start_time = time.time()
+                        success, stdout, stderr = shell.execute(cmd_text, timeout=300)
+                        execution_time = time.time() - start_time
+                        
+                        # Check if the command was aborted due to waiting for input and an alternative was suggested
+                        if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
+                            alternative_cmd = shell.suggested_alternative
+                            print(f"🔄 Command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
+                            
+                            # Add the alternative command with high priority
+                            cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
+                            
+                            # Clear the suggested alternative
+                            shell.suggested_alternative = None
+                        # Check if the command should be removed as suggested by LLM
+                        elif not success and stderr.startswith("Command removed -"):
+                            reason = stderr.replace("Command removed -", "").strip()
+                            print(f"🚫 Removed command as suggested by LLM: {reason}")
+                            # We don't need to do anything else, just mark it as executed and move on
+                        
+                        # Mark command as executed
+                        cmd_manager.mark_command_executed(
+                            cmd_index, 'main', success, stdout, stderr, execution_time
+                        )
+                        
+                        # Increment counter for periodic analysis
+                        commands_since_analysis += 1
+                        
+                        if not success:
+                            print(f"⚠️ Command failed, attempting LLM debugging...")
+                            
+                            # Call LLM for debugging
+                            try:
+                                current_dir = shell.get_cwd()
+                                
+                                # Use unified LLM debugging function
+                                fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
+                                
+                                if fix_command:
+                                    print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                                    
+                                    # Add the fix to the command list manager
+                                    fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
+                                    
+                                    # Execute the fix command
+                                    print(f"🔄 Running suggested fix command: {fix_command}")
+                                    fix_start_time = time.time()
+                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=300)
+                                    fix_execution_time = time.time() - fix_start_time
+                                    
+                                    # Mark fix command as executed
+                                    cmd_manager.mark_command_executed(
+                                        fix_index, 'fix', fix_success, fix_stdout, fix_stderr, fix_execution_time
+                                    )
+                                    
+                                    if fix_success:
+                                        print(f"✅ Fix command succeeded")
+                                        
+                                        # Check if we should skip the original command
+                                        api_key = os.environ.get("OPENAI_API_KEY")
+                                        should_skip, skip_reason = cmd_manager.should_skip_original_command(
+                                            cmd_text, fix_command, fix_stdout, fix_stderr, api_key
+                                        )
+                                        
+                                        if should_skip:
+                                            print(f"🔄 Skipping original command: {skip_reason}")
+                                            
+                                            # Mark the original command as successful without running it
+                                            cmd_manager.mark_command_executed(
+                                                cmd_index, 'main', True, 
+                                                f"Command skipped after successful fix: {skip_reason}", 
+                                                "", time.time() - start_time
+                                            )
+                                            
+                                            print(f"✅ Original command marked as successful (skipped)")
+                                            
+                                            # After a successful fix and skipping the original command,
+                                            # analyze and update the entire command list
+                                            print("\n🔍 Analyzing and updating remaining commands based on fix results...")
+                                            cmd_manager.update_command_list_with_llm(api_key)
+                                        else:
+                                            # Retry the original command
+                                            print(f"🔄 Retrying original command: {cmd_text}")
+                                            retry_start_time = time.time()
+                                            retry_success, retry_stdout, retry_stderr = shell.execute(cmd_text, timeout=300)
+                                            retry_execution_time = time.time() - retry_start_time
+                                            
+                                            # Update the original command status
+                                            cmd_manager.mark_command_executed(
+                                                cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                            )
+                                            
+                                            if retry_success:
+                                                print(f"✅ Original command succeeded after fix!")
+                                                
+                                                # After a successful fix and successful retry,
+                                                # analyze and update the entire command list
+                                                print("\n🔍 Analyzing and updating remaining commands based on fix results...")
+                                                cmd_manager.update_command_list_with_llm(api_key)
+                                            else:
+                                                print(f"⚠️ Original command still failed after fix, continuing...")
+                                    else:
+                                        print(f"❌ Fix command failed: {fix_stderr}")
+                                        print(f"⚠️ Continuing with remaining commands...")
+                                else:
+                                    print("❌ No fix suggested by OpenAI")
+                                    print(f"⚠️ Continuing with remaining commands...")
+                                    
+                            except Exception as debug_e:
+                                print(f"❌ LLM debugging failed: {debug_e}")
+                                print(f"⚠️ Continuing with remaining commands...")
+                    
+                    elif cmd_type == 'fix':
+                        cmd_text = next_cmd['fix_command']
+                        cmd_index = next_cmd['index']
+                        print(f"🔧 Executing fix command {cmd_index + 1}: {cmd_text}")
+                        
+                        start_time = time.time()
+                        success, stdout, stderr = shell.execute(cmd_text, timeout=300)
+                        execution_time = time.time() - start_time
+                        
+                        # Check if the fix command was aborted due to waiting for input and an alternative was suggested
+                        if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
+                            alternative_cmd = shell.suggested_alternative
+                            print(f"🔄 Fix command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
+                            
+                            # Add the alternative command with high priority
+                            cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
+                            
+                            # Clear the suggested alternative
+                            shell.suggested_alternative = None
+                        # Check if the fix command should be removed as suggested by LLM
+                        elif not success and stderr.startswith("Command removed -"):
+                            reason = stderr.replace("Command removed -", "").strip()
+                            print(f"🚫 Removed fix command as suggested by LLM: {reason}")
+                            # We don't need to do anything else, just mark it as executed and move on
+                        
+                        # Mark fix command as executed
+                        cmd_manager.mark_command_executed(
+                            cmd_index, 'fix', success, stdout, stderr, execution_time
+                        )
+                
+                # After all commands are processed, do a final batch analysis of any remaining failed commands
+                failed_commands = cmd_manager.get_failed_commands_for_llm()
+                if failed_commands:
+                    print(f"\n🔍 Final batch analysis of {len(failed_commands)} failed commands...")
+                    current_dir = shell.get_cwd()
+                    api_key = os.environ.get("OPENAI_API_KEY")
+                    
+                    # Use batch analysis to get additional fixes
+                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell)
+                    
+                    if additional_fixes:
+                        print(f"🔧 Executing {len(additional_fixes)} additional fix commands...")
+                        
+                        # Execute the additional fix commands
+                        for fix_index in additional_fixes:
+                            fix_cmd = cmd_manager.suggested_fixes[fix_index]
+                            cmd_text = fix_cmd['fix_command']
+                            print(f"🔧 Executing additional fix: {cmd_text}")
+                            
+                            start_time = time.time()
+                            success, stdout, stderr = shell.execute(cmd_text, timeout=300)
+                            execution_time = time.time() - start_time
+                            
+                            # Check if the fix command was aborted due to waiting for input and an alternative was suggested
+                            if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
+                                alternative_cmd = shell.suggested_alternative
+                                print(f"🔄 Additional fix command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
+                                
+                                # Add the alternative command with high priority
+                                cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
+                                
+                                # Clear the suggested alternative
+                                shell.suggested_alternative = None
+                            # Check if the additional fix command should be removed as suggested by LLM
+                            elif not success and stderr.startswith("Command removed -"):
+                                reason = stderr.replace("Command removed -", "").strip()
+                                print(f"🚫 Removed additional fix command as suggested by LLM: {reason}")
+                                # We don't need to do anything else, just mark it as executed and move on
+                            
+                            # Mark fix command as executed
+                            cmd_manager.mark_command_executed(
+                                fix_index, 'fix', success, stdout, stderr, execution_time
+                            )
+                
+                # Print final status
+                print("\n" + "="*60)
+                print("🎉 SETUP COMMANDS EXECUTION COMPLETED")
+                print("="*60)
+                cmd_manager.print_status()
+                
+            except Exception as e:
+                print(f"❌ Error during setup command execution: {e}")
+            finally:
+                # Clean up the shell
+                shell.cleanup()
+        
+        # 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: {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("=" * 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)
+    
+    # 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():
+                # Get the API key from environment
+                api_key = os.environ.get("OPENAI_API_KEY")
+                
+                # Get stored credentials from local file
+                stored_credentials = get_stored_credentials()
+                if stored_credentials:
+                    print(f"🔐 Found {len(stored_credentials)} stored credentials to send to container")
+                else:
+                    print("⚠️ No stored credentials found")
+                
+                ssh_container_function.remote(ssh_password, repo_url, repo_name, setup_commands, api_key, stored_credentials)
+                
+        # Clean up Modal token after container is successfully created
+        cleanup_modal_token()
+        
+        return {
+            "app_name": app_name,
+            "ssh_password": ssh_password,
+            "volume_name": volume_name
+        }
+    except Exception as e:
+        print(f"❌ Error running container: {e}")
+        return None

package/python/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="gitarsenal-python",
+    version="0.1.0",
+    description="GitArsenal Python utilities for Modal containers",
+    packages=find_packages(),
+    install_requires=[
+        "modal",
+        "requests", 
+        "openai",
+        "anthropic"
+    ],
+    python_requires=">=3.8",
+)