gitarsenal-cli 1.1.20 → 1.1.22

package/package.json

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

package/python/fetch_modal_tokens.py

@@ -9,6 +9,7 @@ import os
 import sys
 import json
 import requests
+import subprocess
 from pathlib import Path
 
 # Default tokens to use if we can't fetch from the server
@@ -29,17 +30,23 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     # Use environment variables if not provided
     if not proxy_url:
         proxy_url = os.environ.get("MODAL_PROXY_URL")
+        if proxy_url:
+            print(f"📋 Using proxy URL from environment: {proxy_url}")
     
     if not api_key:
         api_key = os.environ.get("MODAL_PROXY_API_KEY")
+        if api_key:
+            print(f"📋 Using API key from environment (length: {len(api_key)})")
     
     # Check if we have the necessary information
     if not proxy_url:
         print("❌ No proxy URL provided or found in environment")
+        print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
         return None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
+        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
         return None, None
     
     # Ensure the URL ends with a slash
@@ -79,6 +86,7 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
 def get_tokens():
     """
     Get Modal tokens, trying to fetch from the proxy server first.
+    Also sets the tokens in environment variables.
     
     Returns:
         tuple: (token_id, token_secret)
@@ -89,15 +97,48 @@ def get_tokens():
     # If we couldn't fetch from the server, use the default tokens
     if not token_id or not token_secret:
         print("⚠️ Using default tokens")
-        return DEFAULT_TOKEN_ID, DEFAULT_TOKEN_SECRET
+        token_id = DEFAULT_TOKEN_ID
+        token_secret = DEFAULT_TOKEN_SECRET
+    
+    # Set the tokens in environment variables
+    os.environ["MODAL_TOKEN_ID"] = token_id
+    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+    print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
     
     return token_id, token_secret
 
 if __name__ == "__main__":
+    # Parse command-line arguments if run directly
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Fetch Modal tokens from the proxy server')
+    parser.add_argument('--proxy-url', help='URL of the proxy server')
+    parser.add_argument('--proxy-api-key', help='API key for the proxy server')
+    args = parser.parse_args()
+    
+    # Set proxy URL and API key in environment variables if provided
+    if args.proxy_url:
+        os.environ["MODAL_PROXY_URL"] = args.proxy_url
+        print(f"✅ Set MODAL_PROXY_URL from command line: {args.proxy_url}")
+    
+    if args.proxy_api_key:
+        os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
+        print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+    
+    # Get tokens
     token_id, token_secret = get_tokens()
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
     
+    # Check if tokens are set in environment variables
+    print(f"\n🔍 DEBUG: Checking environment variables")
+    print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+    print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+    if os.environ.get('MODAL_TOKEN_ID'):
+        print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+    if os.environ.get('MODAL_TOKEN_SECRET'):
+        print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
+    
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
     with open(tokens_file, 'w') as f:
@@ -105,4 +146,38 @@ if __name__ == "__main__":
             "token_id": token_id,
             "token_secret": token_secret
         }, f)
-    print(f"✅ Tokens written to {tokens_file}") 
+    print(f"\n✅ Tokens written to {tokens_file}")
+    
+    # Create token files in standard locations
+    modal_dir = Path.home() / ".modal"
+    modal_dir.mkdir(exist_ok=True)
+    token_file = modal_dir / "token.json"
+    with open(token_file, 'w') as f:
+        json.dump({
+            "token_id": token_id,
+            "token_secret": token_secret
+        }, f)
+    print(f"✅ Created token file at {token_file}")
+    
+    modalconfig_file = Path.home() / ".modalconfig"
+    with open(modalconfig_file, 'w') as f:
+        f.write(f"token_id = {token_id}\n")
+        f.write(f"token_secret = {token_secret}\n")
+    print(f"✅ Created .modalconfig file at {modalconfig_file}")
+    
+    # Try to use the Modal CLI to set the token
+    try:
+        print(f"\n🔄 Setting token via Modal CLI...")
+        result = subprocess.run(
+            ["modal", "token", "set", "--token-id", token_id, "--token-secret", token_secret, "--profile=fr8mafia", "--no-verify"],
+            capture_output=True, text=True
+        )
+        
+        if result.returncode == 0:
+            print(f"✅ Successfully set token via Modal CLI")
+        else:
+            print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
+    except Exception as e:
+        print(f"❌ Error using Modal CLI: {e}")
+    
+    print(f"\n✅ All token setup completed successfully") 

package/python/test_modalSandboxScript.py

@@ -9,8 +9,30 @@ import getpass
 import requests
 import secrets
 import string
+import argparse
 from pathlib import Path
 
+# Parse command-line arguments
+parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
+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')
+parser.add_argument('--repo-url', help='Repository URL')
+parser.add_argument('--volume-name', help='Volume name')
+parser.add_argument('--use-api', action='store_true', help='Use API to fetch setup commands')
+
+# Parse only known args to avoid conflicts with other arguments
+args, unknown = parser.parse_known_args()
+
+# Set proxy URL and API key in environment variables if provided
+if args.proxy_url:
+    os.environ["MODAL_PROXY_URL"] = args.proxy_url
+    print(f"✅ Set MODAL_PROXY_URL from command line: {args.proxy_url}")
+    
+if args.proxy_api_key:
+    os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
+    print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+
 # First, try to fetch tokens from the proxy server
 try:
     # Import the fetch_modal_tokens module
@@ -19,6 +41,13 @@ try:
     token_id, token_secret = get_tokens()
     print(f"✅ Modal tokens fetched successfully")
     
+    # Explicitly set the environment variables again to be sure
+    os.environ["MODAL_TOKEN_ID"] = token_id
+    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+    
+    # Also set the old environment variable for backward compatibility
+    os.environ["MODAL_TOKEN"] = token_id
+    
     # Set token variables for later use
     token = token_id  # For backward compatibility
 except Exception as e:
@@ -77,9 +106,12 @@ except Exception as e:
 # Print debug info
 print(f"🔍 DEBUG: Checking environment variables")
 print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
 print(f"🔍 MODAL_TOKEN exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
 if os.environ.get('MODAL_TOKEN_ID'):
     print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+if os.environ.get('MODAL_TOKEN_SECRET'):
+    print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
 if os.environ.get('MODAL_TOKEN'):
     print(f"🔍 MODAL_TOKEN length: {len(os.environ.get('MODAL_TOKEN'))}")
 print(f"✅ Modal token setup completed")
@@ -2462,7 +2494,7 @@ def fetch_setup_commands_from_api(repo_url):
     import shutil
     import json
     
-    api_url = "http://git-arsenal.vercel.app/api/analyze-with-gitingest"
+    api_url = "https://git-arsenal.vercel.app/api/analyze-with-gitingest"
     
     print(f"🔍 Fetching setup commands from API for repository: {repo_url}")
     
@@ -2573,11 +2605,32 @@ def fetch_setup_commands_from_api(repo_url):
                         commands = data["setupInstructions"]["commands"]
                         print(f"✅ Successfully fetched {len(commands)} setup commands from API")
                         
-                        # Print the commands for reference
+                        # Print the original commands for reference
+                        print("📋 Original commands from API:")
                         for i, cmd in enumerate(commands, 1):
                             print(f"  {i}. {cmd}")
                         
-                        return commands
+                        # Fix the commands by removing placeholders and comments
+                        fixed_commands = fix_setup_commands(commands)
+                        
+                        # If we have a temp_dir with the cloned repo, try to find the entry point
+                        # and replace any placeholder entry points
+                        for i, cmd in enumerate(fixed_commands):
+                            if "python main.py" in cmd or "python3 main.py" in cmd:
+                                try:
+                                    entry_point = find_entry_point(temp_dir)
+                                    if entry_point and entry_point != "main.py":
+                                        fixed_commands[i] = cmd.replace("main.py", entry_point)
+                                        print(f"🔄 Replaced main.py with detected entry point: {entry_point}")
+                                except Exception as e:
+                                    print(f"⚠️ Error finding entry point: {e}")
+                        
+                        # Print the fixed commands
+                        print("\n📋 Fixed commands:")
+                        for i, cmd in enumerate(fixed_commands, 1):
+                            print(f"  {i}. {cmd}")
+                        
+                        return fixed_commands
                     else:
                         print("⚠️ API response did not contain setupInstructions.commands field")
                         print("📋 Available fields in response:")
@@ -2723,11 +2776,14 @@ def generate_fallback_commands(gitingest_data):
     # Combine all commands
     all_commands = default_commands + language_commands
     
+    # Fix the commands
+    fixed_commands = fix_setup_commands(all_commands)
+    
     print("\n📋 Generated fallback setup commands:")
-    for i, cmd in enumerate(all_commands, 1):
+    for i, cmd in enumerate(fixed_commands, 1):
         print(f"  {i}. {cmd}")
     
-    return all_commands
+    return fixed_commands
 
 def generate_basic_repo_analysis_from_url(repo_url):
     """Generate basic repository analysis data from a repository URL."""
@@ -2915,9 +2971,21 @@ def get_setup_commands_from_local_api(repo_url, gitingest_data):
             if "setupInstructions" in data and "commands" in data["setupInstructions"]:
                 commands = data["setupInstructions"]["commands"]
                 print(f"✅ Successfully fetched {len(commands)} setup commands from local API")
+                
+                # Print the original commands
+                print("📋 Original commands from local API:")
                 for i, cmd in enumerate(commands, 1):
                     print(f"  {i}. {cmd}")
-                return commands
+                
+                # Fix the commands
+                fixed_commands = fix_setup_commands(commands)
+                
+                # Print the fixed commands
+                print("\n📋 Fixed commands:")
+                for i, cmd in enumerate(fixed_commands, 1):
+                    print(f"  {i}. {cmd}")
+                
+                return fixed_commands
     except Exception as e:
         print(f"❌ Error connecting to local API: {e}")
     
@@ -3041,6 +3109,58 @@ def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=No
     # Return the configured function
     return ssh_container, app_name
 
+def fix_setup_commands(commands):
+    """Fix setup commands by removing placeholders and comments."""
+    fixed_commands = []
+    
+    for cmd in commands:
+        # Remove placeholders like "(or the appropriate entry point...)"
+        cmd = re.sub(r'\([^)]*\)', '', cmd).strip()
+        
+        # Skip empty commands or pure comments
+        if not cmd or cmd.startswith('#'):
+            continue
+            
+        # Remove trailing comments
+        cmd = re.sub(r'#.*$', '', cmd).strip()
+        
+        if cmd:
+            fixed_commands.append(cmd)
+    
+    return fixed_commands
+
+def find_entry_point(repo_dir):
+    """Find the entry point script for a repository."""
+    # Common entry point files to check
+    common_entry_points = [
+        "main.py", "app.py", "run.py", "train.py", "start.py", 
+        "server.py", "cli.py", "demo.py", "example.py"
+    ]
+    
+    # Check if any of the common entry points exist
+    for entry_point in common_entry_points:
+        if os.path.exists(os.path.join(repo_dir, entry_point)):
+            return entry_point
+    
+    # Look for Python files in the root directory
+    python_files = [f for f in os.listdir(repo_dir) if f.endswith('.py')]
+    if python_files:
+        # Prioritize files with main function or if_name_main pattern
+        for py_file in python_files:
+            file_path = os.path.join(repo_dir, py_file)
+            try:
+                with open(file_path, 'r') as f:
+                    content = f.read()
+                    if "def main" in content or "if __name__ == '__main__'" in content or 'if __name__ == "__main__"' in content:
+                        return py_file
+            except:
+                pass
+        
+        # If no main function found, return the first Python file
+        return python_files[0]
+    
+    return None
+
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse