gitarsenal-cli 1.9.75 → 1.9.76

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-15T09:24:56.539Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-17T05:50:53.850Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/package.json

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

package/python/test_container_fail.py

@@ -0,0 +1,239 @@
+import subprocess
+import time
+import secrets
+import string
+import modal
+import sys
+import os
+
+def generate_random_password(length=16):
+    """Generate a random password for SSH access"""
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    password = ''.join(secrets.choice(alphabet) for i in range(length))
+    return password
+
+# Image building
+print("Building Modal image...")
+# base_image = modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
+base_image = modal.Image.debian_slim()
+
+ssh_image = (
+    base_image
+    .apt_install("openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", "python3", "python3-pip")
+    .uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")
+    .run_commands(
+        "mkdir -p /var/run/sshd",
+        "mkdir -p /root/.ssh",
+        "chmod 700 /root/.ssh",
+        "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",
+        "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+        "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+        "ssh-keygen -A",
+        "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        "mkdir -p /python",
+    )
+)
+
+print("✅ SSH image built successfully")
+
+# Create app
+app = modal.App("test_container", image=ssh_image)
+print("✅ Created app successfully")
+
+@app.function(gpu="A10G", timeout=3600, memory=32768)
+def get_ssh_connection(
+    test_data=None,
+    repo_info=None, 
+    setup_commands=None,
+    env_vars=None,
+    credentials=None,
+    debug_config=None
+):
+    """Test complex remote parameter passing that causes segfault"""
+    
+    print("🧪 TESTING COMPLEX REMOTE PARAMETER PASSING")
+    print("=" * 60)
+    
+    # Test complex parameter handling
+    if test_data:
+        print(f"📦 Received extra_data: {type(test_data)} with {len(test_data) if hasattr(test_data, '__len__') else 'N/A'} items")
+        if isinstance(test_data, dict):
+            for key, value in test_data.items():
+                print(f"   • {key}: {type(value)} = {str(value)[:100]}...")
+    
+    if repo_info:
+        print(f"📂 Received repo_info: {repo_info}")
+    
+    if setup_commands:
+        print(f"⚙️ Received {len(setup_commands)} setup commands:")
+        for i, cmd in enumerate(setup_commands[:3]):
+            print(f"   {i+1}. {cmd}")
+        if len(setup_commands) > 3:
+            print(f"   ... and {len(setup_commands) - 3} more")
+    
+    if env_vars:
+        print(f"🔧 Received {len(env_vars)} environment variables:")
+        for key, value in list(env_vars.items())[:3]:
+            masked_value = str(value)[:8] + "..." if len(str(value)) > 8 else str(value)
+            print(f"   • {key} = {masked_value}")
+    
+    if credentials:
+        print(f"🔐 Received {len(credentials)} credentials")
+        for key in list(credentials.keys())[:3]:
+            print(f"   • {key}: [MASKED]")
+    
+    if debug_config:
+        print(f"🐛 Received debug_config: {debug_config}")
+    
+    print("=" * 60)
+    
+    # Generate SSH password
+    password = generate_random_password()
+    
+    # Set root password
+    subprocess.run(["bash", "-c", f"echo 'root:{password}' | chpasswd"], check=True)
+    
+    # Start SSH server
+    ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
+    time.sleep(2)
+    
+    # Test CUDA
+    cuda_info = {}
+    nvidia_result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, timeout=30)
+    cuda_info["nvidia_smi_return_code"] = nvidia_result.returncode
+    cuda_info["nvidia_smi_output"] = nvidia_result.stdout[:500] if nvidia_result.stdout else "No output"
+    
+    # nvcc_result = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, timeout=30)
+    # cuda_info["nvcc_return_code"] = nvcc_result.returncode
+    # cuda_info["nvcc_output"] = nvcc_result.stdout[:500] if nvcc_result.stdout else "No output"
+    
+    # Forward SSH port and return connection info
+    with modal.forward(port=22, unencrypted=True) as tunnel:
+        hostname, port = tunnel.tcp_socket
+        
+        return {
+            "status": "success",
+            "hostname": hostname,
+            "port": port,
+            "password": password,
+            "cuda_info": cuda_info,
+            "ssh_command": f"ssh -p {port} root@{hostname}",
+            "parameters_received": {
+                "test_data": bool(test_data),
+                "repo_info": bool(repo_info),
+                "setup_commands": len(setup_commands) if setup_commands else 0,
+                "env_vars": len(env_vars) if env_vars else 0,
+                "credentials": len(credentials) if credentials else 0,
+                "debug_config": bool(debug_config),
+            }
+        }
+
+if __name__ == "__main__":
+    print("Starting CUDA container setup...")
+    
+    # Check Modal authentication
+    modal_toml = os.path.expanduser("~/.modal.toml")
+    modal_dir = os.path.expanduser("~/.modal/")
+    
+    if os.path.exists(modal_toml):
+        print("✓ Modal configuration found")
+    elif os.path.exists(modal_dir):
+        print("✓ Modal configuration found")
+    else:
+        print("⚠️  Warning: No Modal configuration found")
+    
+    print("Initializing Modal app...")
+    print("Building container image (this may take a while on first run)...")
+    
+    try:
+        with app.run():
+            print("Getting SSH connection info...")
+            
+            # THE COMPLEX DATA THAT CAUSES SEGFAULT
+            # Prepare test data to send to remote function
+            test_data = {
+                "message": "Hello from local machine!",
+                "number": 42,
+                "list": [1, 2, 3, "test"],
+                "nested": {
+                    "key1": "value1",
+                    "key2": 123
+                }
+            }
+            
+            setup_commands = [
+                "apt-get update",
+                "pip install numpy",
+                "echo 'Setup complete'"
+            ]
+            
+            env_vars = {
+                "CUSTOM_VAR": "test_value",
+                "DEBUG_MODE": "true",
+                "API_URL": "https://api.example.com"
+            }
+            
+            repo_info = {
+                "url": "https://github.com/test/repo.git",
+                "branch": "main"
+            }
+            
+            credentials = {
+                "openai_api_key": "sk-test123456789abcdef",
+                "anthropic_api_key": "sk-ant-api-key-987654321",
+                "github_token": "ghp_github_token_123456",
+                "modal_token": "ak-modal-token-abcdef"
+            }
+            
+            debug_config = {
+                "log_level": "INFO",
+                "enable_trace": True,
+                "output_file": "/tmp/debug.log",
+                "max_retries": 3
+            }
+            
+            model_settings = {
+                "model_name": "gpt-4",
+                "temperature": 0.7,
+                "max_tokens": 2048,
+                "timeout": 30,
+                "provider": "openai"
+            }
+            
+            print(f"📦 Sending complex data to remote function:")
+            print(f"   • test_data: {len(test_data)} items (includes 1KB string)")
+            print(f"   • repo_info: {len(repo_info)} items")
+            print(f"   • setup_commands: {len(setup_commands)} commands")
+            print(f"   • environment_vars: {len(env_vars)} variables")
+            print(f"   • credentials: {len(credentials)} credentials")
+            print(f"   • debug_config: {len(debug_config)} debug settings")
+            print("\n🚨 This should trigger the segfault...")
+            print()
+            
+            # This call should cause the segfault
+            result = get_ssh_connection.remote(
+                test_data=test_data,
+                repo_info=repo_info,
+                setup_commands=setup_commands,
+                env_vars=env_vars,
+                credentials=credentials,
+                debug_config=debug_config
+            )
+            
+            # If we get here, it didn't segfault
+            print("\n🎉 NO SEGFAULT! Function completed successfully")
+            print(f"SSH Command: {result['ssh_command']}")
+            print(f"Password: {result['password']}")
+            
+            # Keep container running
+            while True:
+                time.sleep(60)
+                print("Container still running... (Press Ctrl+C to stop)")
+                
+    except Exception as e:
+        print(f"\n💥 Error occurred: {e}")
+        print("This might be the segfault or another error")
+    
+    print("Container stopped")

package/python/test_container_pass.py

@@ -0,0 +1,290 @@
+import subprocess
+import time
+import secrets
+import string
+import modal
+import sys
+
+def generate_random_password(length=16):
+    """Generate a random password for SSH access"""
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    password = ''.join(secrets.choice(alphabet) for i in range(length))
+    return password
+
+base_image = modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
+
+ssh_image = (
+    base_image
+    .apt_install("openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", "python3", "python3-pip")
+    .uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")
+    .run_commands(
+        "mkdir -p /var/run/sshd",
+        "mkdir -p /root/.ssh",
+        "chmod 700 /root/.ssh",
+        "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",
+        "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+        "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+        "ssh-keygen -A",
+        "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        "mkdir -p /python",
+    )
+)
+print("✅ SSH image built successfully")
+    
+
+# Create app with image passed directly (THIS IS THE KEY CHANGE)
+print("🔍 Testing app creation...")
+app = modal.App("test_container", image=ssh_image)  # Pass image here
+print("✅ Created app successfully")
+    
+# Define the SSH container function (remove image from decorator)
+@app.function(
+    timeout= 3600,  # Convert to seconds
+    gpu="A10G",  # Use the user-selected GPU type and count
+    serialized=True,
+    # volumes=volumes_config if volumes_config else None,
+    memory=32768,
+)
+def start_ssh():
+    # Generate SSH password
+    password = generate_random_password()
+    
+    # Set root password
+    subprocess.run(["bash", "-c", f"echo 'root:{password}' | chpasswd"], check=True)
+    
+    # Start SSH server
+    ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
+    time.sleep(2)
+    
+    # Test CUDA
+    cuda_info = {}
+    nvidia_result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, timeout=30)
+    cuda_info["nvidia_smi_output"] = nvidia_result.stdout if nvidia_result.stdout else "No output"
+    
+    nvcc_result = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, timeout=30)
+    cuda_info["nvcc_output"] = nvcc_result.stdout if nvcc_result.stdout else "No output"
+    
+    # Forward SSH port
+    with modal.forward(port=22, unencrypted=True) as tunnel:
+        hostname, port = tunnel.tcp_socket
+        
+        # Return connection info to local terminal
+        connection_info = {
+            "hostname": hostname,
+            "port": port,
+            "password": password,
+            "cuda_info": cuda_info,
+            "status": "success"
+        }
+        
+        # Keep alive with periodic status updates
+        counter = 0
+        while True:
+            counter += 1
+            time.sleep(60)
+
+@app.function(gpu="A10G", timeout=3600)
+def get_ssh_connection(test_data=None, setup_commands=None, env_vars=None, repo_info=None, 
+                      credentials=None, debug_config=None, model_settings=None):
+    """Get SSH connection info and test remote parameter passing"""
+    
+    print("🧪 REMOTE FUNCTION - Testing parameter passing...")
+    print("=" * 50)
+    
+    if test_data:
+        print(f"📦 Received test_data: {type(test_data)}")
+        if isinstance(test_data, dict):
+            for key, value in test_data.items():
+                print(f"   • {key}: {value}")
+        elif isinstance(test_data, list):
+            print(f"   • List with {len(test_data)} items: {test_data}")
+        else:
+            print(f"   • Value: {test_data}")
+    
+    if setup_commands:
+        print(f"⚙️ Received {len(setup_commands)} setup commands:")
+        for i, cmd in enumerate(setup_commands):
+            print(f"   {i+1}. {cmd}")
+    
+    if env_vars:
+        print(f"🔧 Received {len(env_vars)} environment variables:")
+        for key, value in env_vars.items():
+            print(f"   • {key} = {value}")
+    
+    if repo_info:
+        print(f"📂 Received repo_info: {repo_info}")
+    
+    if credentials:
+        print(f"🔐 Received {len(credentials)} credentials:")
+        for key, value in credentials.items():
+            # Mask sensitive data
+            masked_value = value[:8] + "..." if len(str(value)) > 8 else "***"
+            print(f"   • {key}: {masked_value}")
+    
+    if debug_config:
+        print(f"🐛 Received debug_config:")
+        for key, value in debug_config.items():
+            print(f"   • {key}: {value}")
+    
+    if model_settings:
+        print(f"🤖 Received model_settings:")
+        for key, value in model_settings.items():
+            print(f"   • {key}: {value}")
+    
+    print("=" * 50)
+    
+    # Generate SSH password
+    password = generate_random_password()
+    
+    # Set root password
+    subprocess.run(["bash", "-c", f"echo 'root:{password}' | chpasswd"], check=True)
+    
+    # Start SSH server
+    ssh_process = subprocess.Popen(["/usr/sbin/sshd", "-D"])
+    time.sleep(2)
+    
+    # Test CUDA
+    cuda_info = {}
+    nvidia_result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, timeout=30)
+    cuda_info["nvidia_smi_return_code"] = nvidia_result.returncode
+    cuda_info["nvidia_smi_output"] = nvidia_result.stdout[:500] if nvidia_result.stdout else "No output"
+    
+    nvcc_result = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, timeout=30)
+    cuda_info["nvcc_return_code"] = nvcc_result.returncode
+    cuda_info["nvcc_output"] = nvcc_result.stdout[:500] if nvcc_result.stdout else "No output"
+    
+    # Forward SSH port and return connection info
+    with modal.forward(port=22, unencrypted=True) as tunnel:
+        hostname, port = tunnel.tcp_socket
+        
+        # Return connection info immediately
+        return {
+            "status": "success",
+            "hostname": hostname,
+            "port": port,
+            "password": password,
+            "cuda_info": cuda_info,
+            "ssh_command": f"ssh -p {port} root@{hostname}"
+        }
+
+if __name__ == "__main__":
+    print("Starting CUDA container setup...")
+    
+    # Check Modal authentication files
+    import os
+    modal_toml = os.path.expanduser("~/.modal.toml")
+    modal_dir = os.path.expanduser("~/.modal/")
+    
+    if os.path.exists(modal_toml):
+        print("✓ Modal configuration found")
+    elif os.path.exists(modal_dir):
+        print("✓ Modal configuration found")
+    else:
+        print("⚠️  Warning: No Modal configuration found")
+    
+    print("Initializing Modal app...")
+    print("Building container image (this may take a while on first run)...")
+    
+    with app.run():
+        print("Getting SSH connection info...")
+        
+        # Prepare test data to send to remote function
+        test_data = {
+            "message": "Hello from local machine!",
+            "number": 42,
+            "list": [1, 2, 3, "test"],
+            "nested": {
+                "key1": "value1",
+                "key2": 123
+            }
+        }
+        
+        setup_commands = [
+            "apt-get update",
+            "pip install numpy",
+            "echo 'Setup complete'"
+        ]
+        
+        env_vars = {
+            "CUSTOM_VAR": "test_value",
+            "DEBUG_MODE": "true",
+            "API_URL": "https://api.example.com"
+        }
+        
+        repo_info = {
+            "url": "https://github.com/test/repo.git",
+            "branch": "main"
+        }
+        
+        credentials = {
+            "openai_api_key": "sk-test123456789abcdef",
+            "anthropic_api_key": "sk-ant-api-key-987654321",
+            "github_token": "ghp_github_token_123456",
+            "modal_token": "ak-modal-token-abcdef"
+        }
+        
+        debug_config = {
+            "log_level": "INFO",
+            "enable_trace": True,
+            "output_file": "/tmp/debug.log",
+            "max_retries": 3
+        }
+        
+        model_settings = {
+            "model_name": "gpt-4",
+            "temperature": 0.7,
+            "max_tokens": 2048,
+            "timeout": 30,
+            "provider": "openai"
+        }
+        
+        print("📦 Sending test parameters to remote function:")
+        print(f"   • test_data: {len(test_data)} items")
+        print(f"   • setup_commands: {len(setup_commands)} commands")
+        print(f"   • env_vars: {len(env_vars)} variables")
+        print(f"   • repo_info: {repo_info}")
+        print(f"   • credentials: {len(credentials)} items")
+        print(f"   • debug_config: {len(debug_config)} items")
+        print(f"   • model_settings: {len(model_settings)} items")
+        print()
+        
+        # Get connection info with test parameters
+        result = get_ssh_connection.remote(
+            test_data=test_data,
+            setup_commands=setup_commands,
+            env_vars=env_vars,
+            repo_info=repo_info,
+            credentials=credentials,
+            debug_config=debug_config,
+            model_settings=model_settings
+        )
+        
+        if result and "error" not in result:
+            print("\n" + "="*60)
+            print("🚀 CUDA CONTAINER READY!")
+            print("="*60)
+            print(f"SSH Command: {result['ssh_command']}")
+            print(f"Password: {result['password']}")
+            print("="*60)
+            
+            print("\n📊 CUDA Information:")
+            if "nvidia_smi_output" in result["cuda_info"]:
+                print("nvidia-smi output:")
+                print(result["cuda_info"]["nvidia_smi_output"])
+            if "nvcc_output" in result["cuda_info"]:
+                print("\nnvcc output:")
+                print(result["cuda_info"]["nvcc_output"])
+            
+            print("\n⚠️  Note: Container will stay running until you stop this script")
+            print("Press Ctrl+C to stop the container")
+            
+            # Keep the local script running to maintain the container
+            while True:
+                time.sleep(60)
+                print("Container still running... (Press Ctrl+C to stop)")
+        else:
+            print(f"\n❌ Error: {result.get('error', 'Unknown error')}")
+    
+    print("Container stopped")