gitarsenal-cli 1.4.3 → 1.4.4

package/package.json

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

package/python/fetch_modal_tokens.py

@@ -2,7 +2,7 @@
 """
 Fetch Modal Tokens
 
-This script fetches Modal tokens from the GitArsenal API.
+This script fetches Modal tokens from the proxy server.
 """
 
 import os
@@ -12,108 +12,144 @@ import requests
 import subprocess
 from pathlib import Path
 
-# Default tokens to use if we can't fetch from the server
-# DEFAULT_TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
-# DEFAULT_TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
+def fetch_default_tokens_from_gitarsenal():
+    """
+    Fetch default Modal tokens from gitarsenal.dev API.
+    
+    Returns:
+        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+    """
+    endpoint = "https://gitarsenal.dev/api/credentials"
+    
+    try:
+        headers = {
+            'User-Agent': 'Python-Modal-Token-Fetcher/1.0',
+            'Accept': 'application/json'
+        }
+        
+        print(f"🔗 Fetching default tokens from: {endpoint}")
+        
+        response = requests.get(endpoint, headers=headers, timeout=30)
+        
+        print(f"📊 Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            try:
+                data = response.json()
+                token_id = data.get("modalTokenId")
+                token_secret = data.get("modalTokenSecret")
+                
+                if token_id and token_secret:
+                    print("✅ Successfully fetched default tokens from gitarsenal.dev")
+                    return token_id, token_secret
+                else:
+                    print("❌ Modal tokens not found in gitarsenal.dev response")
+                    return None, None
+            except json.JSONDecodeError:
+                print("❌ Invalid JSON response from gitarsenal.dev")
+                return None, None
+        else:
+            print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
+            return None, None
+            
+    except requests.exceptions.Timeout:
+        print("❌ Request timeout when fetching from gitarsenal.dev")
+        return None, None
+    except requests.exceptions.ConnectionError:
+        print("❌ Connection failed to gitarsenal.dev")
+        return None, None
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Request failed to gitarsenal.dev: {e}")
+        return None, None
 
-def fetch_credentials_from_api(api_url=None, api_key=None, credential_id=None):
+def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
-    Fetch credentials from the GitArsenal API.
+    Fetch Modal tokens from the proxy server.
     
     Args:
-        api_url: Base URL of the API (default: gitarsenal.dev)
+        proxy_url: URL of the proxy server
         api_key: API key for authentication
-        credential_id: Optional ID of specific credentials to fetch
         
     Returns:
-        dict: Credentials containing modalTokenId and modalTokenSecret if successful, None otherwise
+        tuple: (token_id, token_secret) if successful, (None, None) otherwise
     """
     # Use environment variables if not provided
-    if not api_url:
-        api_url = os.environ.get("GITARSENAL_API_URL", "https://gitarsenal.dev")
-        if api_url:
-            print(f"📋 Using API URL from environment")
+    if not proxy_url:
+        proxy_url = os.environ.get("MODAL_PROXY_URL")
+        if proxy_url:
+            print(f"📋 Using proxy URL from environment")
     
     if not api_key:
-        api_key = os.environ.get("GITARSENAL_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 GITARSENAL_API_KEY environment variable or use --api-key argument")
-        return None
+        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
+        return None, None
     
     # Ensure the URL ends with a slash
-    if not api_url.endswith("/"):
-        api_url += "/"
+    if not proxy_url.endswith("/"):
+        proxy_url += "/"
     
-    # Add the endpoint for fetching credentials
-    credentials_url = f"{api_url}api/credentials"
-    
-    # Add credential ID if provided
-    if credential_id:
-        credentials_url += f"?id={credential_id}"
+    # Add the endpoint for fetching tokens
+    token_url = f"{proxy_url}api/modal-tokens"
     
     try:
         # Make the request
-        print(f"🔄 Fetching credentials from GitArsenal API")
+        print(f"🔄 Fetching tokens from proxy server")
         response = requests.get(
-            credentials_url,
+            token_url,
             headers={"X-API-Key": api_key}
         )
         
         # Check if the request was successful
         if response.status_code == 200:
             data = response.json()
-            token_id = data.get("modalTokenId")
-            token_secret = data.get("modalTokenSecret")
-            openai_api_key = data.get("openaiApiKey")
+            token_id = data.get("token_id")
+            token_secret = data.get("token_secret")
             
             if token_id and token_secret:
-                print("✅ Successfully fetched credentials from GitArsenal API")
-                return {
-                    "token_id": token_id,
-                    "token_secret": token_secret,
-                    "openai_api_key": openai_api_key
-                }
+                print("✅ Successfully fetched tokens from proxy server")
+                return token_id, token_secret
             else:
-                print("❌ Modal tokens not found in response")
-                return None
+                print("❌ Tokens not found in response")
+                return None, None
         else:
-            print(f"❌ Failed to fetch credentials: {response.status_code} - {response.text}")
-            return None
+            print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
+            return None, None
     except Exception as e:
-        print(f"❌ Error fetching credentials: {e}")
-        return None
+        print(f"❌ Error fetching tokens: {e}")
+        return None, None
 
 def get_tokens():
     """
-    Get Modal tokens, trying to fetch from the GitArsenal API first.
+    Get Modal tokens, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
         tuple: (token_id, token_secret)
     """
-    # Try to fetch from the API
-    credentials = fetch_credentials_from_api()
-    
-    # If we couldn't fetch from the API, use the default tokens
-    if not credentials:
-        print("⚠️ Using default tokens")
-        token_id = DEFAULT_TOKEN_ID
-        token_secret = DEFAULT_TOKEN_SECRET
-        openai_api_key = None
-    else:
-        token_id = credentials["token_id"]
-        token_secret = credentials["token_secret"]
-        openai_api_key = credentials.get("openai_api_key")
-        
-        # Set OpenAI API key if available
-        if openai_api_key:
-            os.environ["OPENAI_API_KEY"] = openai_api_key
-            print(f"✅ Set OPENAI_API_KEY environment variable")
+    # Try to fetch from the proxy server
+    token_id, token_secret = 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 = 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
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -126,23 +162,33 @@ if __name__ == "__main__":
     # Parse command-line arguments if run directly
     import argparse
     
-    parser = argparse.ArgumentParser(description='Fetch credentials from the GitArsenal API')
-    parser.add_argument('--api-url', help='Base URL of the GitArsenal API')
-    parser.add_argument('--api-key', help='API key for authentication')
-    parser.add_argument('--credential-id', help='ID of specific credentials to fetch')
+    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 API URL and API key in environment variables if provided
-    if args.api_url:
-        os.environ["GITARSENAL_API_URL"] = args.api_url
-        print(f"✅ Set GITARSENAL_API_URL from command line")
+    # 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.api_key:
-        os.environ["GITARSENAL_API_KEY"] = args.api_key
-        print(f"✅ Set GITARSENAL_API_KEY from command line")
+    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"
@@ -185,4 +231,4 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error using Modal CLI: {e}")
     
-    print(f"\n✅ All token setup completed successfully") 
+    print(f"\n✅ All token setup completed successfully")

package/python/fetched_credentials.json

@@ -0,0 +1,8 @@
+{
+  "token_id": "ak-sLhYqCjkvixiYcb9LAuCHp",
+  "token_secret": "as-fPzD0Zm0dl6IFAEkhaH9pq",
+  "openai_api_key": "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",
+  "modalTokenId": "ak-sLhYqCjkvixiYcb9LAuCHp",
+  "modalTokenSecret": "as-fPzD0Zm0dl6IFAEkhaH9pq",
+  "openaiApiKey": "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"
+}

package/python/fix_modal_token.py

@@ -43,11 +43,16 @@ try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
     TOKEN_ID, TOKEN_SECRET = get_tokens()
+    
+    # Check if we got valid tokens
+    if TOKEN_ID is None or TOKEN_SECRET is None:
+        raise ValueError("Could not get valid tokens")
+        
     print(f"✅ Using tokens from proxy server or defaults")
-except ImportError:
-    # If the module is not available, use hardcoded tokens
-    # TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
-    # TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
+except (ImportError, ValueError) as e:
+    # If the module is not available or tokens are invalid, use hardcoded tokens
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
     print(f"⚠️ Using default tokens")
 
 print("🔧 Fixing Modal token (basic implementation)...")

package/python/fix_modal_token_advanced.py

@@ -28,6 +28,8 @@ try:
 except ImportError:
     # If the module is not available, use hardcoded tokens
     # print(f"⚠️ Using default tokens")
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
 
 # print("🔧 Advanced Modal Token Fixer")
 
@@ -90,10 +92,13 @@ try:
     )
     
     if result.returncode == 0:
+        pass
         # print(f"✅ Successfully set token via Modal CLI")
     else:
+        pass
         # print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
 except Exception as e:
+    pass
     # print(f"❌ Error using Modal CLI: {e}")
 
 # Approach 4: Use Modal Python API to set token

package/python/modal_tokens.json

@@ -0,0 +1,4 @@
+{
+  "token_id": "ak-sLhYqCjkvixiYcb9LAuCHp",
+  "token_secret": "as-fPzD0Zm0dl6IFAEkhaH9pq"
+}

package/python/test_import.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Test importing and using get_tokens from fetch_modal_tokens
+"""
+
+import os
+import sys
+
+def main():
+    """Main function to test importing and using get_tokens"""
+    print("🔍 Testing import of get_tokens from fetch_modal_tokens...")
+    
+    # Set a test API key for the script to use
+    os.environ["GITARSENAL_API_KEY"] = "test_key"
+    
+    try:
+        # Import the function
+        from fetch_modal_tokens import get_tokens
+        print("✅ Successfully imported get_tokens from fetch_modal_tokens")
+        
+        # Call the function
+        print("🔄 Calling get_tokens()...")
+        token_id, token_secret = get_tokens()
+        
+        # Check the results
+        print("✅ Successfully called get_tokens()")
+        print(f"   token_id: {token_id[:5]}...{token_id[-5:]}")
+        print(f"   token_secret: {token_secret[:5]}...{token_secret[-5:]}")
+        
+        # Check if environment variables were set
+        if os.environ.get("MODAL_TOKEN_ID") == token_id:
+            print("✅ MODAL_TOKEN_ID environment variable set correctly")
+        else:
+            print("❌ MODAL_TOKEN_ID environment variable not set correctly")
+        
+        if os.environ.get("MODAL_TOKEN_SECRET") == token_secret:
+            print("✅ MODAL_TOKEN_SECRET environment variable set correctly")
+        else:
+            print("❌ MODAL_TOKEN_SECRET environment variable not set correctly")
+        
+        # Check if OPENAI_API_KEY was set
+        if os.environ.get("OPENAI_API_KEY"):
+            print("✅ OPENAI_API_KEY environment variable set")
+            print(f"   length: {len(os.environ.get('OPENAI_API_KEY'))}")
+        else:
+            print("❌ OPENAI_API_KEY environment variable not set")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

package/python/test_modalSandboxScript.py

@@ -39,6 +39,11 @@ try:
     # print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
     token_id, token_secret = get_tokens()
+    
+    # Check if we got valid tokens
+    if token_id is None or token_secret is None:
+        raise ValueError("Could not get valid tokens")
+    
     # print(f"✅ Tokens fetched successfully")
     
     # Explicitly set the environment variables again to be sure

package/python/verify_env_vars.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Verify that environment variables are set correctly after running fetch_modal_tokens.py
+"""
+
+import os
+import subprocess
+import sys
+
+def check_env_var(var_name):
+    """Check if an environment variable is set and print its status"""
+    value = os.environ.get(var_name)
+    if value:
+        print(f"✅ {var_name} is set (length: {len(value)})")
+        return True
+    else:
+        print(f"❌ {var_name} is not set")
+        return False
+
+def main():
+    """Main function to verify environment variables"""
+    print("🔍 Checking environment variables before running fetch_modal_tokens.py...")
+    modal_id_before = check_env_var("MODAL_TOKEN_ID")
+    modal_secret_before = check_env_var("MODAL_TOKEN_SECRET")
+    openai_key_before = check_env_var("OPENAI_API_KEY")
+    
+    print("\n🔄 Running fetch_modal_tokens.py...")
+    # Set a test API key for the script to use
+    os.environ["GITARSENAL_API_KEY"] = "test_key"
+    
+    try:
+        # Import the module to run it
+        from fetch_modal_tokens import get_tokens
+        token_id, token_secret = get_tokens()
+        print(f"\n✅ get_tokens() returned values successfully")
+        print(f"   token_id length: {len(token_id) if token_id else 0}")
+        print(f"   token_secret length: {len(token_secret) if token_secret else 0}")
+    except Exception as e:
+        print(f"\n❌ Error running get_tokens(): {e}")
+        sys.exit(1)
+    
+    print("\n🔍 Checking environment variables after running fetch_modal_tokens.py...")
+    modal_id_after = check_env_var("MODAL_TOKEN_ID")
+    modal_secret_after = check_env_var("MODAL_TOKEN_SECRET")
+    openai_key_after = check_env_var("OPENAI_API_KEY")
+    
+    # Verify that the variables were set
+    if modal_id_after and modal_secret_after:
+        print("\n✅ MODAL_TOKEN_ID and MODAL_TOKEN_SECRET were successfully set")
+    else:
+        print("\n❌ Failed to set all required environment variables")
+    
+    if openai_key_after:
+        print("✅ OPENAI_API_KEY was also set")
+    
+    # Check if the values match what was returned by get_tokens()
+    if modal_id_after and os.environ.get("MODAL_TOKEN_ID") == token_id:
+        print("✅ MODAL_TOKEN_ID matches the value returned by get_tokens()")
+    
+    if modal_secret_after and os.environ.get("MODAL_TOKEN_SECRET") == token_secret:
+        print("✅ MODAL_TOKEN_SECRET matches the value returned by get_tokens()")
+
+if __name__ == "__main__":
+    main()