gitarsenal-cli 1.4.6 → 1.4.8

package/package.json

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

package/python/gitarsenal.py

@@ -126,6 +126,7 @@ def main():
     ssh_parser.add_argument("--timeout", type=int, default=60, help="Container timeout in minutes (default: 60)")
     ssh_parser.add_argument("--use-proxy", action="store_true", help="Use Modal proxy service instead of direct Modal API")
     ssh_parser.add_argument("--wait", action="store_true", help="Wait for container to be ready")
+    ssh_parser.add_argument("--interactive", action="store_true", help="Run in interactive mode with prompts")
     
     # Sandbox command
     sandbox_parser = subparsers.add_parser("sandbox", help="Create a Modal sandbox")
@@ -195,7 +196,8 @@ def main():
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
                     volume_name=args.volume_name,
-                    timeout_minutes=args.timeout
+                    timeout_minutes=args.timeout,
+                    interactive=args.interactive
                 )
                 if result:
                     print("✅ SSH container created successfully")

package/python/test_modalSandboxScript.py

@@ -13,7 +13,7 @@ import argparse
 from pathlib import Path
 
 # Parse command-line arguments
-parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
+parser = argparse.ArgumentParser()
 parser.add_argument('--proxy-url', help='URL of the proxy server')
 parser.add_argument('--proxy-api-key', help='API key for the proxy server')
 parser.add_argument('--gpu', default='A10G', help='GPU type to use')
@@ -2583,9 +2583,39 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
 # 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):
+                               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, prompt for it
+        if not gpu_type:
+            gpu_type = prompt_for_gpu()
+            
+        # 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
@@ -4064,13 +4094,134 @@ def get_setup_commands_from_gitingest(repo_url):
     print("❌ All API endpoints failed")
     return generate_fallback_commands(gitingest_data)
 
+def prompt_for_gpu():
+    """
+    Prompt the user to select a GPU type from available options using arrow keys.
+    Returns the selected GPU type.
+    """
+    import sys
+    import tty
+    import termios
+    
+    # Define available GPU types and their specifications
+    gpu_specs = {
+        'T4': {'gpu': 'T4', 'memory': '16GB'},
+        'L4': {'gpu': 'L4', 'memory': '24GB'},
+        'A10G': {'gpu': 'A10G', 'memory': '24GB'},
+        'A100-40GB': {'gpu': 'A100-SXM4-40GB', 'memory': '40GB'},
+        'A100-80GB': {'gpu': 'A100-80GB', 'memory': '80GB'},
+        'L40S': {'gpu': 'L40S', 'memory': '48GB'},
+        'H100': {'gpu': 'H100', 'memory': '80GB'},
+        'H200': {'gpu': 'H200', 'memory': '141GB'},
+        'B200': {'gpu': 'B200', 'memory': '141GB'}
+    }
+    
+    # Create a list of options
+    options = list(gpu_specs.keys())
+    selected_index = 2  # Default to A10G (index 2)
+    
+    def get_key():
+        """Get a single keypress from the user."""
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            ch = sys.stdin.read(1)
+            if ch == '\x1b':  # Escape sequence
+                ch2 = sys.stdin.read(1)
+                if ch2 == '[':
+                    ch3 = sys.stdin.read(1)
+                    if ch3 == 'A':
+                        return 'UP'
+                    elif ch3 == 'B':
+                        return 'DOWN'
+            elif ch == '\r' or ch == '\n':
+                return 'ENTER'
+            elif ch == '\x03':  # Ctrl+C
+                return 'CTRL_C'
+            return ch
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+    
+    def display_menu():
+        """Display the GPU selection menu with current selection highlighted."""
+        print("\n📊 Available GPU Options:")
+        print("┌─────────────┬──────────┐")
+        print("│ GPU Type    │ Memory   │")
+        print("├─────────────┼──────────┤")
+        
+        for i, gpu_type in enumerate(options):
+            specs = gpu_specs[gpu_type]
+            # Calculate proper spacing for alignment
+            number_part = f"{i+1}."
+            if i == selected_index:
+                prefix = "> "
+                suffix = " ←"
+            else:
+                prefix = "  "
+                suffix = ""
+            
+            # Ensure consistent width for GPU type column
+            gpu_display = f"{prefix}{number_part} {gpu_type}"
+            gpu_padded = f"{gpu_display:<12}"  # Fixed width for GPU column
+            
+            print(f"│ {gpu_padded} │ {specs['memory']:<7} │{suffix}")
+        
+        print("└─────────────┴──────────┘")
+        print("Use ↑/↓ arrows to select, Enter to confirm, Ctrl+C to cancel")
+    
+    # Clear screen and show initial menu
+    print("\033[2J\033[H", end="")  # Clear screen and move cursor to top
+    display_menu()
+    
+    while True:
+        try:
+            key = get_key()
+            
+            if key == 'UP':
+                selected_index = (selected_index - 1) % len(options)
+                print("\033[2J\033[H", end="")  # Clear screen
+                display_menu()
+            elif key == 'DOWN':
+                selected_index = (selected_index + 1) % len(options)
+                print("\033[2J\033[H", end="")  # Clear screen
+                display_menu()
+            elif key == 'ENTER':
+                selected_gpu = options[selected_index]
+                print(f"\n✅ Selected GPU: {selected_gpu}")
+                return selected_gpu
+            elif key == 'CTRL_C':
+                print("\n🛑 Selection cancelled.")
+                sys.exit(1)
+                
+        except KeyboardInterrupt:
+            print("\n🛑 Selection cancelled.")
+            sys.exit(1)
+        except Exception as e:
+            print(f"\n❌ Error: {e}")
+            # Fall back to simple input method
+            try:
+                choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
+                if not choice:
+                    return "A10G"
+                if choice.isdigit():
+                    index = int(choice) - 1
+                    if 0 <= index < len(options):
+                        return options[index]
+                elif choice in options:
+                    return choice
+                return "A10G"
+            except:
+                return "A10G"
+
+# Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse
     import sys
     
-    parser = argparse.ArgumentParser(description='Create a Modal SSH container with GPU')
-    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB)')
     parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
     parser.add_argument('--repo-name', type=str, help='Repository name override')
     parser.add_argument('--setup-commands', type=str, nargs='+', help='Setup commands to run (deprecated)')
@@ -4085,20 +4236,105 @@ if __name__ == "__main__":
     parser.add_argument('--use-gitingest', action='store_true', default=True, help='Use gitingest approach to fetch setup commands (default)')
     parser.add_argument('--no-gitingest', action='store_true', help='Disable gitingest approach for setup commands')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
+    parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
+    parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
     
     args = parser.parse_args()
     
+    # If --list-gpus is specified, just show GPU options and exit
+    if args.list_gpus:
+        prompt_for_gpu()
+        sys.exit(0)
+    
     # If no arguments or only --show-examples is provided, show usage examples
     if len(sys.argv) == 1 or args.show_examples:
         show_usage_examples()
         sys.exit(0)
     
+    # Check for dependencies
+    print("⠏ Checking dependencies...")
+    print("--- Dependency Check ---")
+    
+    # Check Python version
+    python_version = sys.version.split()[0]
+    print(f"✓ Python {python_version} found")
+    
+    # Check Modal CLI
+    try:
+        subprocess.run(["modal", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Modal CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install with: pip install modal")
+    
+    # Check Gitingest CLI
+    try:
+        subprocess.run(["gitingest", "--help"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Gitingest CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("⚠️ Gitingest CLI not found (optional)")
+    
+    # Check Git
+    try:
+        subprocess.run(["git", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Git found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Git not found. Please install Git.")
+    
+    print("------------------------")
+    print("\n✔ Dependencies checked")
+    
+    # Always prompt for GPU selection regardless of interactive mode
+    gpu_type = prompt_for_gpu()
+    args.gpu = gpu_type
+    
+    # Interactive mode or missing required arguments
+    if args.interactive or not args.repo_url or not args.volume_name:
+        # Get repository URL if not provided
+        repo_url = args.repo_url
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    sys.exit(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Ask about persistent volume
+        volume_name = args.volume_name
+        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.")
+                sys.exit(1)
+        
+        # Ask about setup commands
+        use_gitingest = args.use_gitingest and not args.no_gitingest
+        if not args.use_api and not args.setup_commands and not args.setup_commands_json:
+            try:
+                auto_detect = input("? Automatically detect setup commands for this repository? (Y/n): ").strip().lower()
+                if auto_detect in ('n', 'no'):
+                    use_gitingest = False
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Update args with interactive values
+        args.repo_url = repo_url
+        args.volume_name = volume_name
+        args.use_gitingest = use_gitingest
+    
     try:    
         # Get setup commands from file if specified
         setup_commands = args.setup_commands or []
         
-        # If --use-api flag is set and repo_url is provided, fetch setup commands from API
-        
         # Use gitingest by default unless --no-gitingest is set
         if args.repo_url and (args.use_gitingest and not args.no_gitingest):
             print("🔄 Using gitingest approach to fetch setup commands (default)")
@@ -4215,7 +4451,8 @@ if __name__ == "__main__":
             setup_commands=setup_commands,
             volume_name=args.volume_name,
             timeout_minutes=args.timeout,
-            ssh_password=ssh_password
+            ssh_password=ssh_password,
+            interactive=args.interactive
         )
     except KeyboardInterrupt:
         # print("\n\n🛑 Execution interrupted")