gitarsenal-cli 1.9.49 → 1.9.51

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-11T19:26:14.584Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-12T11:49:41.397Z","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.49",
+  "version": "1.9.51",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/command_manager.py

@@ -406,12 +406,12 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            preferred = get_current_debug_model()
+            preferred = os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
             providers = get_provider_rotation_order(preferred)
 
             for provider in providers:
-                # Use provided api_key only for the preferred provider; otherwise fetch per provider
-                provider_key = api_key if (api_key and provider == preferred) else get_api_key(provider)
+                # Always fetch provider-specific key; don't reuse a different provider's key
+                provider_key = get_api_key(provider)
                 if not provider_key:
                     print(f"⚠️ No {provider} API key available for skip analysis. Trying next provider...")
                     continue
@@ -494,7 +494,7 @@ class CommandListManager:
                 get_provider_rotation_order,
             )
             # Get API key if not provided
-            preferred = get_current_debug_model()
+            preferred = os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
             providers = get_provider_rotation_order(preferred)
             
             # Get all commands for context

package/python/fetch_modal_tokens.py

@@ -17,7 +17,7 @@ def fetch_default_tokens_from_gitarsenal():
     Fetch default Modal tokens and OpenAI API key from gitarsenal.dev API.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key) if successful, (None, None, None, None, None, None) otherwise
     """
     endpoint = "https://gitarsenal.dev/api/credentials"
     
@@ -40,30 +40,31 @@ def fetch_default_tokens_from_gitarsenal():
                 token_secret = data.get("modalTokenSecret")
                 openai_api_key = data.get("openaiApiKey")
                 anthropic_api_key = data.get("anthropicApiKey")
+                openrouter_api_key = data.get("openrouterApiKey")
                 groq_api_key = data.get("groqApiKey")
                 
                 if token_id and token_secret:
                     # print("✅ Successfully fetched default tokens from gitarsenal.dev")
-                    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
+                    return token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key
                 else:
                     print("❌ Modal tokens not found in gitarsenal.dev response")
-                    return None, None, None, None, None
+                    return None, None, None, None, None, None
             except json.JSONDecodeError:
                 print("❌ Invalid JSON response from gitarsenal.dev")
-                return None, None, None, None, None
+                return None, None, None, None, None, None
         else:
             print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
-            return None, None, None, None, None
+            return None, None, None, None, None, None
             
     except requests.exceptions.Timeout:
         print("❌ Request timeout when fetching from gitarsenal.dev")
-        return None, None, None, None, None
+        return None, None, None, None, None, None
     except requests.exceptions.ConnectionError:
         print("❌ Connection failed to gitarsenal.dev")
-        return None, None, None, None, None
+        return None, None, None, None, None, None
     except requests.exceptions.RequestException as e:
         print(f"❌ Request failed to gitarsenal.dev: {e}")
-        return None, None, None, None, None
+        return None, None, None, None, None, None
 
 def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
@@ -74,7 +75,7 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
         api_key: API key for authentication
         
     Returns:
-        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key) if successful, (None, None, None, None, None, None) otherwise
     """
     # Use environment variables if not provided
     if not proxy_url:
@@ -91,12 +92,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     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, None, None, None
+        return None, None, None, None, 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, None, None, None
+        return None, None, None, None, None, None
     
     # Ensure the URL ends with a slash
     if not proxy_url.endswith("/"):
@@ -120,19 +121,20 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
             token_secret = data.get("token_secret")
             openai_api_key = data.get("openai_api_key")
             anthropic_api_key = data.get("anthropic_api_key")
+            openrouter_api_key = data.get("openrouter_api_key")
             groq_api_key = data.get("groq_api_key")
             if token_id and token_secret:
                 print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
+                return token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key
             else:
                 print("❌ Tokens not found in response")
-                return None, None, None, None, None
+                return None, None, None, None, None, None
         else:
             print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None, None, None, None
+            return None, None, None, None, None, None
     except Exception as e:
         print(f"❌ Error fetching tokens: {e}")
-        return None, None, None, None, None
+        return None, None, None, None, None, None
 
 def get_tokens():
     """
@@ -140,21 +142,21 @@ def get_tokens():
     Also sets the tokens in environment variables.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key)
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key)
     """
     # Try to fetch from the proxy server
-    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_tokens_from_proxy()
+    token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = fetch_tokens_from_proxy()
     
     # If we couldn't fetch from the server, try to get default tokens from gitarsenal.dev
     if not token_id or not token_secret:
         # print("⚠️ Proxy server failed, trying to fetch default tokens from gitarsenal.dev")
-        token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_default_tokens_from_gitarsenal()
+        token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = fetch_default_tokens_from_gitarsenal()
     
     # If we still don't have tokens, we can't proceed
     if not token_id or not token_secret:
         print("❌ Failed to fetch tokens from both proxy server and gitarsenal.dev")
         print("💡 Please check your network connection and API endpoints")
-        return None, None, None, None, None
+        return None, None, None, None, None, None
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -169,11 +171,15 @@ def get_tokens():
     if anthropic_api_key:
         os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
     
+    # Set OpenRouter API key if available
+    if openrouter_api_key:
+        os.environ["OPENROUTER_API_KEY"] = openrouter_api_key
+    
     # Set Groq API key if available
     if groq_api_key:
         os.environ["GROQ_API_KEY"] = groq_api_key
     
-    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
+    return token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key
 
 if __name__ == "__main__":
     # Parse command-line arguments if run directly
@@ -194,19 +200,21 @@ if __name__ == "__main__":
         print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
-    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = get_tokens()
+    token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = get_tokens()
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
     print(f"OpenAI API Key: {openai_api_key[:5] + '...' if openai_api_key else None}")
     print(f"Anthropic API Key: {anthropic_api_key[:5] + '...' if anthropic_api_key else None}")
+    print(f"OpenRouter API Key: {openrouter_api_key[:5] + '...' if openrouter_api_key else None}")
     print(f"Groq API Key: {groq_api_key[:5] + '...' if groq_api_key else None}")
     
     # Check if tokens are set in environment variables
-    print(f"\n🔍 DEBUG: Checking 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'}")
     print(f"🔍 OPENAI_API_KEY exists: {'Yes' if os.environ.get('OPENAI_API_KEY') else 'No'}")
     print(f"🔍 ANTHROPIC_API_KEY exists: {'Yes' if os.environ.get('ANTHROPIC_API_KEY') else 'No'}")
+    print(f"🔍 OPENROUTER_API_KEY exists: {'Yes' if os.environ.get('OPENROUTER_API_KEY') else 'No'}")
     print(f"🔍 GROQ_API_KEY exists: {'Yes' if os.environ.get('GROQ_API_KEY') else 'No'}")
     if os.environ.get('MODAL_TOKEN_ID'):
         print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
@@ -216,6 +224,8 @@ if __name__ == "__main__":
         print(f"🔍 OPENAI_API_KEY length: {len(os.environ.get('OPENAI_API_KEY'))}")
     if os.environ.get('ANTHROPIC_API_KEY'):
         print(f"🔍 ANTHROPIC_API_KEY length: {len(os.environ.get('ANTHROPIC_API_KEY'))}")
+    if os.environ.get('OPENROUTER_API_KEY'):
+        print(f"🔍 OPENROUTER_API_KEY length: {len(os.environ.get('OPENROUTER_API_KEY'))}")
     if os.environ.get('GROQ_API_KEY'):
         print(f"🔍 GROQ_API_KEY length: {len(os.environ.get('GROQ_API_KEY'))}")
     
@@ -227,6 +237,7 @@ if __name__ == "__main__":
             "token_secret": token_secret,
             "openai_api_key": openai_api_key,
             "anthropic_api_key": anthropic_api_key,
+            "openrouter_api_key": openrouter_api_key,
             "groq_api_key": groq_api_key
         }, f)
     print(f"\n✅ Tokens written to {tokens_file}")
@@ -283,6 +294,17 @@ if __name__ == "__main__":
             f.write(env_content)
         print(f"✅ Updated Anthropic API key in {env_file}")
 
+    # Update or add OPENROUTER_API_KEY
+    if openrouter_api_key:
+        if "OPENROUTER_API_KEY" in env_content:
+            import re
+            env_content = re.sub(r'OPENROUTER_API_KEY=.*\n', f'OPENROUTER_API_KEY={openrouter_api_key}\n', env_content)
+        else:
+            env_content += f'\nOPENROUTER_API_KEY={openrouter_api_key}\n'
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Updated OpenRouter API key in {env_file}")
+
     # Update or add GROQ_API_KEY
     if groq_api_key:
         if "GROQ_API_KEY" in env_content:

package/python/llm_debugging.py

@@ -35,7 +35,7 @@ def generate_auth_context(stored_credentials):
 
 def get_current_debug_model():
     """Get the currently configured debugging model preference"""
-    return os.environ.get("GITARSENAL_DEBUG_MODEL", "anthropic")
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
 
 
 def _to_str(maybe_bytes):
@@ -347,7 +347,7 @@ def make_openai_request(api_key, prompt, retries=2):
     }
     
     payload = {
-        "model": "gpt-5-mini",
+        "model": "gpt-4.1",
         "messages": [
             {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue."},
             {"role": "user", "content": prompt}
@@ -536,7 +536,7 @@ def make_groq_request(api_key, prompt, retries=2):
 
 def get_provider_rotation_order(preferred=None):
     """Return provider rotation order starting with preferred if valid."""
-    default_order = ["anthropic", "openai", "groq", "openrouter"]
+    default_order = ["openai", "anthropic", "groq", "openrouter"]
     if preferred and preferred in default_order:
         return [preferred] + [p for p in default_order if p != preferred]
     return default_order

package/python/test_modalSandboxScript.py

@@ -46,7 +46,7 @@ if args.proxy_api_key:
 # Import the fetch_modal_tokens module
 # print("🔄 Fetching tokens from proxy server...")
 from fetch_modal_tokens import get_tokens
-token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = get_tokens()
+token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = get_tokens()
 
 # Check if we got valid tokens
 if token_id is None or token_secret is None:
@@ -139,12 +139,14 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
         print(f"🔍 openai_api_key exists: {'Yes' if openai_api_key else 'No'}")
         if modal_token_id:
-            print(f"🔍 token length: {len(modal_token_id)}")
+            # print(f"🔍 token length: {len(modal_token_id)}")
+            pass
         if modal_token:
-            print(f"🔍 token length: {len(modal_token)}")
+            # print(f"🔍 token length: {len(modal_token)}")
+            pass
         if openai_api_key:
-            print(f"🔍 openai_api_key length: {len(openai_api_key)}")
-        
+            # print(f"🔍 openai_api_key length: {len(openai_api_key)}")
+            pass
         # Try to access Modal token to check authentication
         try:
             # Check if token is set in environment
@@ -1840,7 +1842,7 @@ Return only the JSON array, no other text.
         client = openai.OpenAI(api_key=api_key)
         
         response = client.chat.completions.create(
-            model="gpt-4o-mini",  # Fixed: using valid OpenAI model
+            model="gpt-4.1",  # Fixed: using valid OpenAI model
             messages=[
                 {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
                 {"role": "user", "content": prompt}
@@ -2208,7 +2210,7 @@ if __name__ == "__main__":
     if args.gpu:
         gpu_type = args.gpu
         # Validate the provided GPU type
-        valid_gpus = ['T4', 'L4', 'A10G', 'A100-40', 'A100-80', 'L40S', 'H100', 'H200', 'B200']
+        valid_gpus = ['T4', 'L4', 'A10G', 'A100-40GB', 'A100-80GB', 'L40S', 'H100', 'H200', 'B200']
         if gpu_type not in valid_gpus:
             print(f"⚠️ Warning: '{gpu_type}' is not in the list of known GPU types.")
             print(f"Available GPU types: {', '.join(valid_gpus)}")