gitarsenal-cli 1.1.8 → 1.1.10

package/package.json

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

package/python/gitarsenal.py

@@ -109,483 +109,184 @@ def check_proxy_config():
         return False
 
 def main():
-    parser = argparse.ArgumentParser(description="GitArsenal CLI - GPU-accelerated cloud environments")
+    """Main entry point for the GitArsenal CLI"""
+    parser = argparse.ArgumentParser(description="GitArsenal CLI - Tools for AI development")
     subparsers = parser.add_subparsers(dest="command", help="Command to run")
     
-    # Credentials command
-    cred_parser = subparsers.add_parser("credentials", help="Manage credentials")
-    cred_subparsers = cred_parser.add_subparsers(dest="cred_command", help="Credentials command")
-    
-    # Credentials setup command
-    cred_setup_parser = cred_subparsers.add_parser("setup", help="Set up all credentials")
-    
-    # Credentials set command
-    cred_set_parser = cred_subparsers.add_parser("set", help="Set a specific credential")
-    cred_set_parser.add_argument("key", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key"], 
-                               help="The credential to set")
-    
-    # Credentials get command
-    cred_get_parser = cred_subparsers.add_parser("get", help="Get a specific credential")
-    cred_get_parser.add_argument("key", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key"], 
-                               help="The credential to get")
-    
-    # Credentials clear command
-    cred_clear_parser = cred_subparsers.add_parser("clear", help="Clear credentials")
-    cred_clear_parser.add_argument("key", nargs="?", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key", "all"], 
-                                 default="all", help="The credential to clear (default: all)")
-    
-    # Credentials list command
-    cred_list_parser = cred_subparsers.add_parser("list", help="List all saved credentials")
-    
-    # Sandbox command
-    sandbox_parser = subparsers.add_parser("sandbox", help="Create a Modal sandbox")
-    sandbox_parser.add_argument("--gpu", type=str, default="A10G", choices=["A10G", "A100", "H100", "T4", "V100"],
-                              help="GPU type (default: A10G)")
-    sandbox_parser.add_argument("--repo-url", type=str, help="Repository URL to clone")
-    sandbox_parser.add_argument("--repo-name", type=str, help="Repository name override")
-    sandbox_parser.add_argument("--setup-commands", type=str, nargs="+", help="Setup commands to run")
-    sandbox_parser.add_argument("--volume-name", type=str, help="Name of the Modal volume for persistent storage")
-    sandbox_parser.add_argument("--use-api", action="store_true", help="Use API for setup commands")
-    sandbox_parser.add_argument("--use-proxy", action="store_true", help="Use Modal proxy service instead of direct Modal access")
-    
     # SSH command
     ssh_parser = subparsers.add_parser("ssh", help="Create a Modal SSH container")
-    ssh_parser.add_argument("--gpu", type=str, default="A10G", choices=["A10G", "A100", "H100", "T4", "V100"],
-                          help="GPU type (default: A10G)")
+    ssh_parser.add_argument("--gpu", type=str, default="A10G", help="GPU type (default: A10G)")
     ssh_parser.add_argument("--repo-url", type=str, help="Repository URL to clone")
     ssh_parser.add_argument("--repo-name", type=str, help="Repository name override")
-    ssh_parser.add_argument("--setup-commands", type=str, nargs="+", help="Setup commands to run")
-    ssh_parser.add_argument("--volume-name", type=str, help="Name of the Modal volume for persistent storage")
+    ssh_parser.add_argument("--volume-name", type=str, help="Volume name for persistent storage")
     ssh_parser.add_argument("--timeout", type=int, default=60, help="Container timeout in minutes (default: 60)")
-    ssh_parser.add_argument("--use-api", action="store_true", help="Use API for setup commands")
-    ssh_parser.add_argument("--use-proxy", action="store_true", help="Use Modal proxy service instead of direct Modal access")
+    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")
+    
+    # Sandbox command
+    sandbox_parser = subparsers.add_parser("sandbox", help="Create a Modal sandbox")
+    sandbox_parser.add_argument("--gpu", type=str, default="A10G", help="GPU type (default: A10G)")
+    sandbox_parser.add_argument("--repo-url", type=str, help="Repository URL to clone")
+    sandbox_parser.add_argument("--repo-name", type=str, help="Repository name override")
+    sandbox_parser.add_argument("--volume-name", type=str, help="Volume name for persistent storage")
+    sandbox_parser.add_argument("--use-proxy", action="store_true", help="Use Modal proxy service instead of direct Modal API")
+    sandbox_parser.add_argument("--wait", action="store_true", help="Wait for container to be ready")
     
-    # Proxy command
-    proxy_parser = subparsers.add_parser("proxy", help="Configure and use Modal proxy service")
-    proxy_subparsers = proxy_parser.add_subparsers(dest="proxy_command", help="Proxy command")
+    # Proxy commands
+    proxy_parser = subparsers.add_parser("proxy", help="Modal proxy service commands")
+    proxy_subparsers = proxy_parser.add_subparsers(dest="proxy_command", help="Proxy command to run")
     
     # Proxy configure command
-    proxy_configure_parser = proxy_subparsers.add_parser("configure", help="Configure Modal proxy service")
+    proxy_configure_parser = proxy_subparsers.add_parser("configure", help="Configure proxy settings")
     
     # Proxy status command
-    proxy_status_parser = proxy_subparsers.add_parser("status", help="Check Modal proxy service status")
-    
-    # Proxy sandbox command
-    proxy_sandbox_parser = proxy_subparsers.add_parser("sandbox", help="Create a sandbox through Modal proxy")
-    proxy_sandbox_parser.add_argument("--gpu", type=str, default="A10G", choices=["A10G", "A100", "H100", "T4", "V100"],
-                                    help="GPU type (default: A10G)")
-    proxy_sandbox_parser.add_argument("--repo-url", type=str, help="Repository URL to clone")
-    proxy_sandbox_parser.add_argument("--repo-name", type=str, help="Repository name override")
-    proxy_sandbox_parser.add_argument("--setup-commands", type=str, nargs="+", help="Setup commands to run")
-    proxy_sandbox_parser.add_argument("--volume-name", type=str, help="Name of the Modal volume for persistent storage")
-    proxy_sandbox_parser.add_argument("--wait", action="store_true", help="Wait for sandbox to be ready")
+    proxy_status_parser = proxy_subparsers.add_parser("status", help="Check proxy status")
     
-    # Proxy ssh command
-    proxy_ssh_parser = proxy_subparsers.add_parser("ssh", help="Create an SSH container through Modal proxy")
-    proxy_ssh_parser.add_argument("--gpu", type=str, default="A10G", choices=["A10G", "A100", "H100", "T4", "V100"],
-                                help="GPU type (default: A10G)")
+    # Proxy SSH command
+    proxy_ssh_parser = proxy_subparsers.add_parser("ssh", help="Create SSH container through proxy")
+    proxy_ssh_parser.add_argument("--gpu", type=str, default="A10G", help="GPU type (default: A10G)")
     proxy_ssh_parser.add_argument("--repo-url", type=str, help="Repository URL to clone")
     proxy_ssh_parser.add_argument("--repo-name", type=str, help="Repository name override")
-    proxy_ssh_parser.add_argument("--setup-commands", type=str, nargs="+", help="Setup commands to run")
-    proxy_ssh_parser.add_argument("--volume-name", type=str, help="Name of the Modal volume for persistent storage")
+    proxy_ssh_parser.add_argument("--volume-name", type=str, help="Volume name for persistent storage")
     proxy_ssh_parser.add_argument("--timeout", type=int, default=60, help="Container timeout in minutes (default: 60)")
     proxy_ssh_parser.add_argument("--wait", action="store_true", help="Wait for container to be ready")
     
+    # Parse arguments
     args = parser.parse_args()
     
-    if not args.command:
-        parser.print_help()
-        return 0
-    
-    # For sandbox and SSH commands, check Modal authentication first
-    if args.command in ["sandbox", "ssh"]:
-        # Check if using proxy service
-        if hasattr(args, 'use_proxy') and args.use_proxy:
-            # Check if proxy is configured
-            if not check_proxy_config():
-                print("\n⚠️ Modal proxy service is not configured.")
-                print("Please run './gitarsenal.py proxy configure' first.")
-                return 1
-        else:
-            # Check if Modal is authenticated
-            if not check_modal_auth():
-                print("\n⚠️ Please authenticate with Modal before proceeding.")
-                return 1
-            
-            # Try to load credentials and set Modal token if available
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                credentials = credentials_manager.load_credentials()
-                
-                if "modal_token" in credentials:
-                    # Set the Modal token in the environment
-                    os.environ["MODAL_TOKEN_ID"] = credentials["modal_token"]
-                    print("✅ Using Modal token from credentials")
-                    
-                    # Try to authenticate with the token
-                    try:
-                        token_result = subprocess.run(
-                            ["modal", "token", "set", credentials["modal_token"]], 
-                            capture_output=True, text=True
-                        )
-                        if token_result.returncode == 0:
-                            print("✅ Successfully authenticated with Modal")
-                    except Exception as e:
-                        print(f"⚠️ Error setting Modal token: {e}")
-            except ImportError:
-                print("⚠️ Could not load credentials manager")
-            except Exception as e:
-                print(f"⚠️ Error loading credentials: {e}")
-    
-    # Handle credentials commands
-    if args.command == "credentials":
-        try:
-            from credentials_manager import CredentialsManager
-            credentials_manager = CredentialsManager()
-            
-            if args.cred_command == "setup":
-                # Set up all credentials
-                print("🔧 Setting up all credentials")
-                
-                # Modal token
-                modal_token = credentials_manager.get_modal_token()
-                if modal_token:
-                    print("✅ Modal token set")
-                else:
-                    print("⚠️ Modal token not set")
-                
-                # OpenAI API key
-                openai_api_key = credentials_manager.get_openai_api_key()
-                if openai_api_key:
-                    print("✅ OpenAI API key set")
-                else:
-                    print("⚠️ OpenAI API key not set")
-                
-                # Hugging Face token
-                huggingface_token = credentials_manager.get_huggingface_token()
-                if huggingface_token:
-                    print("✅ Hugging Face token set")
-                else:
-                    print("⚠️ Hugging Face token not set")
-                
-                # Weights & Biases API key
-                wandb_api_key = credentials_manager.get_wandb_api_key()
-                if wandb_api_key:
-                    print("✅ Weights & Biases API key set")
-                else:
-                    print("⚠️ Weights & Biases API key not set")
-                
-            elif args.cred_command == "set":
-                # Set a specific credential
-                if args.key == "modal_token":
-                    modal_token = credentials_manager.get_modal_token()
-                    if modal_token:
-                        print("✅ Modal token set")
-                    else:
-                        print("⚠️ Modal token not set")
-                elif args.key == "openai_api_key":
-                    openai_api_key = credentials_manager.get_openai_api_key()
-                    if openai_api_key:
-                        print("✅ OpenAI API key set")
-                    else:
-                        print("⚠️ OpenAI API key not set")
-                elif args.key == "huggingface_token":
-                    huggingface_token = credentials_manager.get_huggingface_token()
-                    if huggingface_token:
-                        print("✅ Hugging Face token set")
-                    else:
-                        print("⚠️ Hugging Face token not set")
-                elif args.key == "wandb_api_key":
-                    wandb_api_key = credentials_manager.get_wandb_api_key()
-                    if wandb_api_key:
-                        print("✅ Weights & Biases API key set")
-                    else:
-                        print("⚠️ Weights & Biases API key not set")
-            
-            elif args.cred_command == "get":
-                # Get a specific credential
-                credentials = credentials_manager.load_credentials()
-                if args.key in credentials:
-                    # Mask the credential for security
-                    value = credentials[args.key]
-                    masked_value = value[:4] + "*" * (len(value) - 8) + value[-4:] if len(value) > 8 else "****"
-                    print(f"{args.key}: {masked_value}")
-                else:
-                    print(f"⚠️ {args.key} not found")
-            
-            elif args.cred_command == "clear":
-                # Clear credentials
-                if args.key == "all":
-                    credentials_manager.clear_all_credentials()
-                    print("✅ All credentials cleared")
-                else:
-                    if credentials_manager.clear_credential(args.key):
-                        print(f"✅ {args.key} cleared")
-                    else:
-                        print(f"⚠️ {args.key} not found")
-            
-            elif args.cred_command == "list":
-                # List all credentials
-                credentials = credentials_manager.load_credentials()
-                if credentials:
-                    print("📋 Saved credentials:")
-                    for key in credentials:
-                        print(f"  - {key}")
-                else:
-                    print("⚠️ No credentials found")
-            
-            else:
-                print("⚠️ Unknown credentials command")
-                return 1
-                
-        except ImportError:
-            print("❌ Could not import credentials_manager module")
-            return 1
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            return 1
-    
-    # Handle sandbox command
-    elif args.command == "sandbox":
-        try:
-            # Check if using proxy service
-            if args.use_proxy:
-                # Import proxy client
-                try:
-                    from gitarsenal_proxy_client import GitArsenalProxyClient
-                    client = GitArsenalProxyClient()
-                    
-                    # Create sandbox through proxy
-                    result = client.create_sandbox(
-                        gpu_type=args.gpu,
-                        repo_url=args.repo_url,
-                        repo_name=args.repo_name,
-                        setup_commands=args.setup_commands,
-                        volume_name=args.volume_name,
-                        wait=True  # Always wait for sandbox to be ready
-                    )
-                    
-                    if not result:
-                        print("❌ Failed to create sandbox through proxy service")
-                        return 1
-                    
-                    print("✅ Sandbox created successfully through proxy service")
-                    
-                except ImportError:
-                    print("❌ Could not import gitarsenal_proxy_client module")
-                    print("Please make sure gitarsenal_proxy_client.py is in the same directory")
-                    return 1
-            else:
-                # Import sandbox creation function
-                from test_modalSandboxScript import create_modal_sandbox
-                
-                # Create sandbox directly
-                result = create_modal_sandbox(
-                    args.gpu,
+    if args.command == "ssh":
+        if args.use_proxy:
+            # Use proxy service for SSH container
+            print("🚀 Creating SSH container through proxy...")
+            if check_proxy_config():
+                from gitarsenal_proxy_client import GitArsenalProxyClient
+                client = GitArsenalProxyClient()
+                result = client.create_ssh_container(
+                    gpu_type=args.gpu,
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
-                    setup_commands=args.setup_commands,
-                    volume_name=args.volume_name
+                    volume_name=args.volume_name,
+                    timeout=args.timeout,
+                    wait=args.wait
                 )
-                
-                if not result:
-                    print("❌ Failed to create sandbox")
-                    return 1
-                
-                print("✅ Sandbox created successfully")
-        
-        except ImportError as e:
-            print(f"❌ Could not import required module: {e}")
-            return 1
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            return 1
-    
-    # Handle SSH command
-    elif args.command == "ssh":
-        try:
-            # Check if using proxy service
-            if args.use_proxy:
-                # Import proxy client
-                try:
-                    from gitarsenal_proxy_client import GitArsenalProxyClient
-                    client = GitArsenalProxyClient()
-                    
-                    # Ensure proxy is configured
-                    config = client.load_config()
-                    if not config.get("proxy_url") or not config.get("api_key"):
-                        print("\n⚠️ Modal proxy service is not fully configured.")
-                        print("Running configuration wizard...")
-                        client.configure(interactive=True)
-                        # Reload config after configuration
-                        config = client.load_config()
-                        if not config.get("proxy_url") or not config.get("api_key"):
-                            print("❌ Proxy configuration failed or was cancelled.")
-                            return 1
-                        print("✅ Proxy configuration completed successfully.")
-                    
-                    # Create SSH container through proxy
-                    print(f"🚀 Creating SSH container through proxy service ({config.get('proxy_url')})")
-                    result = client.create_ssh_container(
-                        gpu_type=args.gpu,
-                        repo_url=args.repo_url,
-                        repo_name=args.repo_name,
-                        setup_commands=args.setup_commands,
-                        volume_name=args.volume_name,
-                        timeout=args.timeout,
-                        wait=True  # Always wait for container to be ready
-                    )
-                    
-                    if not result:
-                        print("❌ Failed to create SSH container through proxy service")
-                        return 1
-                    
+                if result:
                     print("✅ SSH container created successfully through proxy service")
-                    
-                except ImportError:
-                    print("❌ Could not import gitarsenal_proxy_client module")
-                    print("Please make sure gitarsenal_proxy_client.py is in the same directory")
-                    return 1
+                    print(f"📋 Container ID: {result.get('container_id')}")
+                    print(f"🔐 SSH Password: {result.get('ssh_password')}")
+                    if not args.wait:
+                        print("\n⚠️ Container creation is asynchronous. Use --wait flag to wait for it to be ready.")
+                        print("   You can check the status later using the container ID above.")
+                else:
+                    print("❌ Failed to create SSH container through proxy service")
             else:
-                # Import SSH container creation function
+                print("❌ Proxy configuration failed or was cancelled.")
+        else:
+            # Use direct Modal API for SSH container
+            print("🚀 Creating SSH container...")
+            if check_modal_auth():
+                # Import the SSH container creation function
                 from test_modalSandboxScript import create_modal_ssh_container
-                
-                # Create SSH container directly
                 result = create_modal_ssh_container(
                     args.gpu,
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
-                    setup_commands=args.setup_commands,
                     volume_name=args.volume_name,
                     timeout_minutes=args.timeout
                 )
-                
-                if not result:
+                if result:
+                    print("✅ SSH container created successfully")
+                else:
                     print("❌ Failed to create SSH container")
-                    return 1
-                
-                print("✅ SSH container created successfully")
-        
-        except ImportError as e:
-            print(f"❌ Could not import required module: {e}")
-            return 1
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            return 1
+            else:
+                print("❌ Modal authentication failed or was cancelled.")
     
-    # Handle proxy commands
-    elif args.command == "proxy":
-        if not args.proxy_command:
-            proxy_parser.print_help()
-            return 0
-        
-        try:
-            # Import proxy client
-            from gitarsenal_proxy_client import GitArsenalProxyClient
-            client = GitArsenalProxyClient()
-            
-            if args.proxy_command == "configure":
-                # Configure proxy service
-                client.configure(interactive=True)
-            
-            elif args.proxy_command == "status":
-                # Check proxy service status
-                response = client.health_check()
-                if response["success"]:
-                    print(f"✅ Proxy service is running: {response['data']['message']}")
-                else:
-                    print(f"❌ Proxy service health check failed: {response['error']}")
-                    return 1
-            
-            elif args.proxy_command == "sandbox":
-                # Create sandbox through proxy
+    elif args.command == "sandbox":
+        if args.use_proxy:
+            # Use proxy service for sandbox
+            print("🚀 Creating sandbox through proxy...")
+            if check_proxy_config():
+                from gitarsenal_proxy_client import GitArsenalProxyClient
+                client = GitArsenalProxyClient()
                 result = client.create_sandbox(
                     gpu_type=args.gpu,
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
-                    setup_commands=args.setup_commands,
                     volume_name=args.volume_name,
                     wait=args.wait
                 )
-                
-                if not result:
+                if result:
+                    print("✅ Sandbox created successfully through proxy service")
+                else:
                     print("❌ Failed to create sandbox through proxy service")
-                    return 1
-                
-                print("✅ Sandbox created successfully through proxy service")
-            
-            elif args.proxy_command == "ssh":
-                # Create SSH container through proxy
-                print("🚀 Creating SSH container through proxy...")
-                
-                # Verify proxy configuration is complete
-                config = client.load_config()
-                if not config.get("proxy_url") or not config.get("api_key"):
-                    print("⚠️ Proxy configuration incomplete. Running configuration wizard...")
-                    client.configure(interactive=True)
-                    # Reload config after configuration
-                    config = client.load_config()
-                    if not config.get("proxy_url") or not config.get("api_key"):
-                        print("❌ Proxy configuration failed or was cancelled.")
-                        return 1
-                    print("✅ Proxy configuration completed successfully.")
-                
-                # Check proxy service health
-                health = client.health_check()
-                if not health["success"]:
-                    print(f"❌ Could not connect to proxy service at {config.get('proxy_url')}")
-                    print(f"   Error: {health.get('error', 'Unknown error')}")
-                    print("   Please check if the proxy service is running.")
-                    return 1
-                
-                print(f"✅ Connected to proxy service at {config.get('proxy_url')}")
-                
-                # Create SSH container
+            else:
+                print("❌ Proxy configuration failed or was cancelled.")
+        else:
+            # Use direct Modal API for sandbox
+            print("🚀 Creating sandbox...")
+            if check_modal_auth():
+                # Import the sandbox creation function
+                from test_modalSandboxScript import create_modal_sandbox
+                result = create_modal_sandbox(
+                    args.gpu,
+                    repo_url=args.repo_url,
+                    repo_name=args.repo_name,
+                    volume_name=args.volume_name
+                )
+                if result:
+                    print("✅ Sandbox created successfully")
+                else:
+                    print("❌ Failed to create sandbox")
+            else:
+                print("❌ Modal authentication failed or was cancelled.")
+    
+    elif args.command == "proxy":
+        if args.proxy_command == "configure":
+            # Configure proxy settings
+            from gitarsenal_proxy_client import GitArsenalProxyClient
+            client = GitArsenalProxyClient()
+            client.configure(interactive=True)
+        
+        elif args.proxy_command == "status":
+            # Check proxy status
+            from gitarsenal_proxy_client import GitArsenalProxyClient
+            client = GitArsenalProxyClient()
+            response = client.health_check()
+            if response["success"]:
+                print(f"✅ Proxy service is running: {response['data']['message']}")
+            else:
+                print(f"❌ Proxy service health check failed: {response['error']}")
+        
+        elif args.proxy_command == "ssh":
+            # Create SSH container through proxy
+            print("🚀 Creating SSH container through proxy...")
+            if check_proxy_config():
+                from gitarsenal_proxy_client import GitArsenalProxyClient
+                client = GitArsenalProxyClient()
                 result = client.create_ssh_container(
                     gpu_type=args.gpu,
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
-                    setup_commands=args.setup_commands,
                     volume_name=args.volume_name,
                     timeout=args.timeout,
                     wait=args.wait
                 )
-                
-                if not result:
+                if result:
+                    print("✅ SSH container created successfully through proxy service")
+                    print(f"📋 Container ID: {result.get('container_id')}")
+                    print(f"🔐 SSH Password: {result.get('ssh_password')}")
+                    if not args.wait:
+                        print("\n⚠️ Container creation is asynchronous. Use --wait flag to wait for it to be ready.")
+                        print("   You can check the status later using the container ID above.")
+                else:
                     print("❌ Failed to create SSH container through proxy service")
-                    return 1
-                
-                # Print connection information if available
-                if isinstance(result, dict):
-                    if "container_id" in result:
-                        print(f"📋 Container ID: {result['container_id']}")
-                    if "ssh_password" in result:
-                        print(f"🔐 SSH Password: {result['ssh_password']}")
-                
-                print("✅ SSH container creation process initiated through proxy service")
-                
-                if not args.wait:
-                    print("\n⚠️ Container creation is asynchronous. Use --wait flag to wait for it to be ready.")
-                    print("   You can check the status later using the container ID above.")
-                
             else:
-                print(f"❌ Unknown proxy command: {args.proxy_command}")
-                proxy_parser.print_help()
-                return 1
+                print("❌ Proxy configuration failed or was cancelled.")
         
-        except ImportError:
-            print("❌ Could not import gitarsenal_proxy_client module")
-            print("Please make sure gitarsenal_proxy_client.py is in the same directory")
-            return 1
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            return 1
+        else:
+            print("❌ Unknown proxy command. Available commands: configure, status, ssh")
     
     else:
-        print(f"❌ Unknown command: {args.command}")
         parser.print_help()
-        return 1
     
     return 0
 

package/python/modal_proxy_service.py

@@ -211,6 +211,7 @@ def create_ssh_container():
     try:
         # Set the token directly in environment
         os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+        os.environ["MODAL_TOKEN"] = MODAL_TOKEN
         logger.info(f"Set MODAL_TOKEN_ID in environment (length: {len(MODAL_TOKEN)})")
         
         # Try to set token via CLI as well
@@ -256,8 +257,29 @@ def create_ssh_container():
             try:
                 # Set token in environment for this thread
                 os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
+                os.environ["MODAL_TOKEN"] = MODAL_TOKEN
                 logger.info(f"Set MODAL_TOKEN_ID in thread (length: {len(MODAL_TOKEN)})")
                 
+                # Create a copy of the environment variables for the container creation
+                env_copy = os.environ.copy()
+                env_copy["MODAL_TOKEN_ID"] = MODAL_TOKEN
+                env_copy["MODAL_TOKEN"] = MODAL_TOKEN
+                
+                # Try to set token via CLI again in this thread
+                try:
+                    import subprocess
+                    subprocess.run(
+                        ["modal", "token", "set", MODAL_TOKEN],
+                        capture_output=True, text=True, check=False
+                    )
+                    logger.info("Set Modal token via CLI in thread")
+                except Exception as e:
+                    logger.warning(f"Failed to set token via CLI in thread: {e}")
+                
+                # Explicitly print token status for debugging
+                logger.info(f"MODAL_TOKEN_ID in thread env: {os.environ.get('MODAL_TOKEN_ID')}")
+                logger.info(f"MODAL_TOKEN in thread env: {os.environ.get('MODAL_TOKEN')}")
+                
                 result = create_modal_ssh_container(
                     gpu_type, 
                     repo_url=repo_url, 

package/python/test_modalSandboxScript.py

@@ -2069,26 +2069,40 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     
     # 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")
+        print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 MODAL_TOKEN exists: {'Yes' if modal_token else 'No'}")
+        if modal_token_id:
+            print(f"🔍 MODAL_TOKEN_ID length: {len(modal_token_id)}")
+        if modal_token:
+            print(f"🔍 MODAL_TOKEN length: {len(modal_token)}")
+        
         # Try to access Modal token to check authentication
         try:
             # Check if token is set in environment
-            modal_token = os.environ.get("MODAL_TOKEN_ID")
-            if not modal_token:
+            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 MODAL_TOKEN environment variable")
                     os.environ["MODAL_TOKEN_ID"] = modal_token
+                    modal_token_id = modal_token
+                    print(f"✅ Set MODAL_TOKEN_ID from MODAL_TOKEN (length: {len(modal_token)})")
             
-            if modal_token:
-                print(f"✅ Modal token found (length: {len(modal_token)})")
+            if modal_token_id:
+                print(f"✅ Modal token found (length: {len(modal_token_id)})")
                 
                 # Use the Modal CLI to set the token
                 try:
                     import subprocess
+                    print(f"🔄 Setting token via Modal CLI (token length: {len(modal_token_id)})")
                     result = subprocess.run(
-                        ["modal", "token", "set", modal_token],
+                        ["modal", "token", "set", modal_token_id],
                         capture_output=True, text=True
                     )
                     if result.returncode == 0:
@@ -2099,20 +2113,51 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     print(f"⚠️ Error setting token via CLI: {e}")
             else:
                 print("❌ No Modal token found in environment variables")
-                return None
+                # 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("❌ Modal 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 = os.environ.get("MODAL_TOKEN_ID") or os.environ.get("MODAL_TOKEN")
-            if not modal_token:
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            modal_token = os.environ.get("MODAL_TOKEN")
+            if modal_token_id:
+                print(f"🔄 Using MODAL_TOKEN_ID from environment (length: {len(modal_token_id)})")
+            elif modal_token:
+                print(f"🔄 Using MODAL_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
             
-            print(f"🔄 Using Modal token from environment (length: {len(modal_token)})")
             # Set it in both environment variables
-            os.environ["MODAL_TOKEN_ID"] = modal_token
-            os.environ["MODAL_TOKEN"] = modal_token
+            os.environ["MODAL_TOKEN_ID"] = modal_token_id
+            os.environ["MODAL_TOKEN"] = modal_token_id
+            print("✅ Set both MODAL_TOKEN_ID and MODAL_TOKEN environment variables")
     except Exception as e:
         print(f"⚠️ Error checking Modal authentication: {e}")
         print("Continuing anyway, but Modal operations may fail")