gitarsenal-cli 1.9.18 → 1.9.20

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-06T08:11:48.991Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-06T11:31:44.083Z","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.18",
+  "version": "1.9.20",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/credentials_manager.py

@@ -145,7 +145,7 @@ class CredentialsManager:
         # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
         try:
             from fetch_modal_tokens import get_tokens
-            _, _, api_key = get_tokens()
+            _, _, api_key, _ = get_tokens()
             if api_key and validate_openai_key(api_key):
                 # Set in environment for future use
                 os.environ["OPENAI_API_KEY"] = api_key
@@ -220,6 +220,27 @@ class CredentialsManager:
         prompt = "A Weights & Biases API key is required.\nYou can get your API key from: https://wandb.ai/authorize"
         return self.get_credential("wandb_api_key", prompt, is_password=True, validate_func=validate_wandb_key)
     
+    def get_anthropic_api_key(self):
+        """Get Anthropic API key with validation"""
+        def validate_anthropic_key(key):
+            # Anthropic keys usually start with "sk-ant-" and are typically 48+ characters
+            return key.startswith("sk-ant-") and len(key) > 40
+        
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "anthropic_api_key" in credentials:
+            stored_key = credentials["anthropic_api_key"]
+            if validate_anthropic_key(stored_key):
+                return stored_key
+        
+        # Then check environment variable
+        env_key = os.environ.get("ANTHROPIC_API_KEY")
+        if env_key and validate_anthropic_key(env_key):
+            return env_key
+            
+        prompt = "An Anthropic API key is required.\nYou can get your API key from: https://console.anthropic.com/"
+        return self.get_credential("anthropic_api_key", prompt, is_password=True, validate_func=validate_anthropic_key)
+    
     def clear_credential(self, key):
         """Remove a specific credential"""
         credentials = self.load_credentials()
@@ -259,6 +280,7 @@ class CredentialsManager:
             import os
             security_vars = [
                 "OPENAI_API_KEY", 
+                "ANTHROPIC_API_KEY",
                 "HUGGINGFACE_TOKEN", 
                 "WANDB_API_KEY",
                 "MODAL_TOKEN_ID",

package/python/fetch_modal_tokens.py

@@ -39,29 +39,30 @@ def fetch_default_tokens_from_gitarsenal():
                 token_id = data.get("modalTokenId")
                 token_secret = data.get("modalTokenSecret")
                 openai_api_key = data.get("openaiApiKey")
+                anthropic_api_key = data.get("anthropicApiKey")
                 
                 if token_id and token_secret:
                     # print("✅ Successfully fetched default tokens from gitarsenal.dev")
-                    return token_id, token_secret, openai_api_key
+                    return token_id, token_secret, openai_api_key, anthropic_api_key
                 else:
                     print("❌ Modal tokens not found in gitarsenal.dev response")
-                    return None, None, None
+                    return None, None, None, None
             except json.JSONDecodeError:
                 print("❌ Invalid JSON response from gitarsenal.dev")
-                return None, None, None
+                return None, None, None, None
         else:
             print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
-            return None, None, None
+            return None, None, None, None
             
     except requests.exceptions.Timeout:
         print("❌ Request timeout when fetching from gitarsenal.dev")
-        return None, None, None
+        return None, None, None, None
     except requests.exceptions.ConnectionError:
         print("❌ Connection failed to gitarsenal.dev")
-        return None, None, None
+        return None, None, None, None
     except requests.exceptions.RequestException as e:
         print(f"❌ Request failed to gitarsenal.dev: {e}")
-        return None, None, None
+        return None, None, None, None
 
 def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
@@ -89,12 +90,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
+        return 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
+        return None, None, None, None
     
     # Ensure the URL ends with a slash
     if not proxy_url.endswith("/"):
@@ -117,41 +118,42 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
             token_id = data.get("token_id")
             token_secret = data.get("token_secret")
             openai_api_key = data.get("openai_api_key")
+            anthropic_api_key = data.get("anthropic_api_key")
             
             if token_id and token_secret:
                 print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret, openai_api_key
+                return token_id, token_secret, openai_api_key, anthropic_api_key
             else:
                 print("❌ Tokens not found in response")
-                return None, None, None
+                return None, None, None, None
         else:
             print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None, None
+            return None, None, None, None
     except Exception as e:
         print(f"❌ Error fetching tokens: {e}")
-        return None, None, None
+        return None, None, None, None
 
 def get_tokens():
     """
-    Get Modal tokens and OpenAI API key, trying to fetch from the proxy server first.
+    Get Modal tokens, OpenAI API key, and Anthropic API key, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key)
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key)
     """
     # Try to fetch from the proxy server
-    token_id, token_secret, openai_api_key = fetch_tokens_from_proxy()
+    token_id, token_secret, openai_api_key, anthropic_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 = fetch_default_tokens_from_gitarsenal()
+        token_id, token_secret, openai_api_key, anthropic_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
+        return None, None, None, None
     
     # Debug print the full token values
     # print("\n🔍 DEBUG: FULL TOKEN VALUES:")
@@ -169,7 +171,11 @@ def get_tokens():
     if openai_api_key:
         os.environ["OPENAI_API_KEY"] = openai_api_key
     
-    return token_id, token_secret, openai_api_key
+    # Set Anthropic API key if available
+    if anthropic_api_key:
+        os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
+    
+    return token_id, token_secret, openai_api_key, anthropic_api_key
 
 if __name__ == "__main__":
     # Parse command-line arguments if run directly
@@ -190,22 +196,26 @@ if __name__ == "__main__":
         print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
-    token_id, token_secret, openai_api_key = get_tokens()
+    token_id, token_secret, openai_api_key, anthropic_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}")
     
     # 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'}")
     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'}")
     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('OPENAI_API_KEY'):
         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'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
@@ -213,7 +223,8 @@ if __name__ == "__main__":
         json.dump({
             "token_id": token_id,
             "token_secret": token_secret,
-            "openai_api_key": openai_api_key
+            "openai_api_key": openai_api_key,
+            "anthropic_api_key": anthropic_api_key
         }, f)
     print(f"\n✅ Tokens written to {tokens_file}")
     
@@ -234,7 +245,7 @@ if __name__ == "__main__":
         f.write(f"token_secret = {token_secret}\n")
     print(f"✅ Created .modalconfig file at {modalconfig_file}")
     
-    # Create or update .env file with OpenAI API key
+    # Create or update .env file with API keys
     env_file = Path.home() / ".env"
     env_content = ""
     if env_file.exists():
@@ -255,6 +266,20 @@ if __name__ == "__main__":
             f.write(env_content)
         print(f"✅ Updated OpenAI API key in {env_file}")
     
+    # Update or add ANTHROPIC_API_KEY
+    if anthropic_api_key:
+        if "ANTHROPIC_API_KEY" in env_content:
+            # Replace existing key
+            import re
+            env_content = re.sub(r'ANTHROPIC_API_KEY=.*\n', f'ANTHROPIC_API_KEY={anthropic_api_key}\n', env_content)
+        else:
+            # Add new key
+            env_content += f'\nANTHROPIC_API_KEY={anthropic_api_key}\n'
+        
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Updated Anthropic API key in {env_file}")
+    
     # Try to use the Modal CLI to set the token
     try:
         print(f"\n🔄 Setting token via Modal CLI...")

package/python/fix_modal_token.py

@@ -42,7 +42,7 @@ except Exception as e:
 try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET = get_tokens()
+    TOKEN_ID, TOKEN_SECRET, _, _ = get_tokens()
     
     # Check if we got valid tokens
     if TOKEN_ID is None or TOKEN_SECRET is None:

package/python/modal_auth_patch.py

@@ -22,7 +22,7 @@ from pathlib import Path
 try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET = get_tokens()
+    TOKEN_ID, TOKEN_SECRET, _, _ = get_tokens()
     print(f"✅ Using tokens from proxy server or defaults")
 except ImportError:
     # If the module is not available, use hardcoded tokens

package/python/modal_proxy_service.py

@@ -118,7 +118,7 @@ def setup_modal_auth():
         # Import the fetch_modal_tokens module
         logger.info("Fetching Modal tokens from proxy server...")
         from fetch_modal_tokens import get_tokens
-        token_id, token_secret = get_tokens()
+        token_id, token_secret, _, _ = get_tokens()
         logger.info("Modal tokens fetched successfully")
         
         # Set the tokens in environment variables
@@ -462,7 +462,7 @@ def create_ssh_container():
                     # Import the fetch_modal_tokens module
                     logger.info("Fetching Modal tokens from proxy server in thread...")
                     from fetch_modal_tokens import get_tokens
-                    token_id, token_secret = get_tokens()
+                    token_id, token_secret, _, _ = get_tokens()
                     logger.info("Modal tokens fetched successfully in thread")
                     
                     # Set the tokens in environment variables

package/python/modal_token_solution.py

@@ -25,7 +25,7 @@ import time
 try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET = get_tokens()
+    TOKEN_ID, TOKEN_SECRET, _, _ = get_tokens()
     print(f"✅ Using tokens from proxy server or defaults")
 except ImportError:
     # If the module is not available, use hardcoded tokens