gitarsenal-cli 1.4.6 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "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,74 @@ 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.
+    Returns the selected GPU type.
+    """
+    # 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'}
+    }
+    
+    print("\n📊 Available GPU Options:")
+    print("┌─────────────┬──────────┐")
+    print("│ GPU Type    │ Memory   │")
+    print("├─────────────┼──────────┤")
+    
+    # Create a list to keep track of valid options
+    options = []
+    
+    # Display GPU options
+    for i, (gpu_type, specs) in enumerate(gpu_specs.items(), 1):
+        options.append(gpu_type)
+        print(f"│ {i}. {gpu_type:<8} │ {specs['memory']:<7} │")
+    
+    print("└─────────────┴──────────┘")
+    
+    # Prompt for selection
+    while True:
+        try:
+            choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
+            
+            # Default to A10G if empty
+            if not choice:
+                return "A10G"
+            
+            # Check if input is a number
+            if choice.isdigit():
+                index = int(choice) - 1
+                if 0 <= index < len(options):
+                    return options[index]
+                else:
+                    print(f"❌ Invalid selection. Please enter a number between 1 and {len(options)}.")
+            # Check if input is a valid GPU type
+            elif choice in options:
+                return choice
+            else:
+                print(f"❌ Invalid GPU type. Please select from the available options.")
+        except KeyboardInterrupt:
+            print("\n🛑 Selection cancelled.")
+            sys.exit(1)
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+# 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 +4176,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 +4391,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")