gitarsenal-cli 1.4.2 → 1.4.4

package/package.json

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

package/python/fetch_modal_tokens.py

@@ -12,9 +12,55 @@ 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_tokens_from_proxy(proxy_url=None, api_key=None):
     """
@@ -41,12 +87,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     # 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")
+        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")
+        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
         return None, None
     
     # Ensure the URL ends with a slash
@@ -94,11 +140,16 @@ def get_tokens():
     # Try to fetch from the proxy server
     token_id, token_secret = fetch_tokens_from_proxy()
     
-    # If we couldn't fetch from the server, use the default tokens
+    # 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("⚠️ Using default tokens")
-        token_id = DEFAULT_TOKEN_ID
-        token_secret = DEFAULT_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
@@ -119,25 +170,25 @@ if __name__ == "__main__":
     # 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")
+        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")
+        print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
     token_id, token_secret = get_tokens()
-    # print(f"Token ID: [HIDDEN]")
-    # print(f"Token Secret: [HIDDEN]")
-    
-    # # 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'))}")
+    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"
@@ -180,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/test_modal_auth.py

@@ -19,8 +19,8 @@ try:
     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
+    # TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    # TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
     print(f"⚠️ Using hardcoded tokens")
 
 # Set tokens directly in environment

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() 

package/python/MODAL_TOKEN_README.md

@@ -1,77 +0,0 @@
-# Modal Token Solution
-
-This directory contains several scripts to solve the Modal token authentication issue. The problem occurs when Modal cannot find or validate the authentication token, resulting in errors like "Token missing" or "Could not authenticate client".
-
-## Overview of the Solution
-
-We've implemented a comprehensive solution that uses multiple approaches to ensure Modal can authenticate properly:
-
-1. **fetch_modal_tokens.py**: Fetches tokens from the proxy server.
-2. **modal_token_solution.py**: The main comprehensive solution that combines all approaches.
-3. **modal_auth_patch.py**: A direct patch for Modal's authentication system.
-4. **fix_modal_token.py**: A basic token setup script.
-5. **fix_modal_token_advanced.py**: An advanced version with more approaches.
-
-## How It Works
-
-Our solution uses multiple approaches to ensure Modal authentication works:
-
-1. **Token Fetching**: Tries to fetch tokens from the proxy server.
-2. **Environment Variables**: Sets `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET` environment variables.
-3. **Token Files**: Creates token files in various formats and locations that Modal might look for.
-4. **Modal CLI**: Attempts to use the Modal CLI to set the token with the correct profile.
-5. **Direct Patching**: Directly patches Modal's authentication system to always return our tokens.
-6. **Monkey Patching**: Monkey-patches Modal's import system to inject our tokens.
-7. **Authentication Testing**: Tests that the authentication works by creating a simple Modal app.
-
-## Usage
-
-The scripts are used in this order of preference:
-
-1. First, try `modal_token_solution.py` (most comprehensive)
-2. If that fails, fall back to `modal_auth_patch.py`
-3. If that fails, fall back to `fix_modal_token.py`
-
-In most cases, you should simply import `modal_token_solution` before importing Modal:
-
-```python
-import modal_token_solution
-import modal
-
-# Now Modal will use our tokens
-```
-
-## Proxy Server Integration
-
-The solution now integrates with the proxy server to fetch tokens:
-
-1. **fetch_modal_tokens.py**: This script fetches tokens from the proxy server using the `MODAL_PROXY_URL` and `MODAL_PROXY_API_KEY` environment variables.
-2. If the proxy server is not available, it falls back to hardcoded tokens.
-3. All other scripts try to use the fetch_modal_tokens module first before falling back to hardcoded tokens.
-
-## Troubleshooting
-
-If you still encounter token issues:
-
-1. Check that the tokens are correct (token ID: `ak-sLhYqCjkvixiYcb9LAuCHp`, token secret: `as-fPzD0Zm0dl6IFAEkhaH9pq`).
-2. Verify that the token files are created in the correct locations:
-   - `~/.modal/token.json`
-   - `~/.modalconfig`
-3. Check if the proxy server is accessible and returning valid tokens.
-4. Try running the scripts manually to see detailed output.
-
-## Implementation Details
-
-- **Token Values**: We try to fetch tokens from the proxy server, with fallback to hardcoded values.
-- **File Locations**: Token files are created in the user's home directory under `~/.modal/`.
-- **Patching**: We use Python's dynamic nature to patch Modal's authentication system at runtime.
-- **Profile**: We use the `fr8mafia` profile when setting tokens via the CLI.
-
-## Files
-
-- **fetch_modal_tokens.py**: Fetches tokens from the proxy server.
-- **modal_token_solution.py**: Comprehensive solution combining all approaches.
-- **modal_auth_patch.py**: Direct patch for Modal's authentication system.
-- **fix_modal_token.py**: Basic token setup script.
-- **fix_modal_token_advanced.py**: Advanced version with more approaches.
-- **test_modal_auth.py**: Test script for Modal authentication. 

package/python/MODAL_TOKEN_SETUP.md

@@ -1,82 +0,0 @@
-# Modal Token Setup Solution
-
-This document explains how the Modal token setup solution works in GitArsenal CLI.
-
-## Problem
-
-The GitArsenal CLI was failing with errors like:
-
-```
-🔍 MODAL_TOKEN_ID not found in environment.
-❌ No Modal token found in environment variables
-❌ Modal token file not found
-❌ Could not find Modal token in any location
-```
-
-This happened because the Modal token was not being properly set in the environment variables.
-
-## Solution
-
-We implemented a comprehensive solution to automatically find and set up the Modal token from various sources:
-
-1. Created a `setup_modal_token.py` module that:
-   - Checks for the token in environment variables (MODAL_TOKEN_ID and MODAL_TOKEN)
-   - Checks for the token in GitArsenal credentials file (~/.gitarsenal/credentials.json)
-   - Checks for the token in Modal token file (~/.modal/token.json)
-   - Sets the token in both MODAL_TOKEN_ID and MODAL_TOKEN environment variables
-
-2. Modified key files to use this module:
-   - `gitarsenal.py` - Main CLI entry point
-   - `modal_proxy_service.py` - Modal proxy service
-   - `test_modalSandboxScript.py` - Modal sandbox script
-
-3. Created a wrapper script `run_with_modal_token.py` that:
-   - Sets up the Modal token using the setup_modal_token module
-   - Runs a specified command with the token properly set in the environment
-
-## Usage
-
-### Running Commands with Modal Token
-
-Use the wrapper script to run any command that requires Modal authentication:
-
-```bash
-python run_with_modal_token.py <command> [args...]
-```
-
-Example:
-
-```bash
-python run_with_modal_token.py python modal_proxy_service.py
-```
-
-### Setting Up Modal Token
-
-If you need to set up the Modal token manually:
-
-```bash
-python setup_modal_token.py
-```
-
-This will prompt you for the token if it's not found in any of the sources.
-
-### Adding Modal Token to GitArsenal Credentials
-
-You can also add the Modal token to GitArsenal credentials:
-
-```bash
-./gitarsenal.py credentials set modal_token
-```
-
-## How It Works
-
-1. The `setup_modal_token.py` module checks multiple sources for the Modal token:
-   - Environment variables (MODAL_TOKEN_ID and MODAL_TOKEN)
-   - GitArsenal credentials file (~/.gitarsenal/credentials.json)
-   - Modal token file (~/.modal/token.json)
-
-2. When it finds a token, it sets both MODAL_TOKEN_ID and MODAL_TOKEN environment variables.
-
-3. The modified files import and use this module to ensure the token is set before any Modal operations.
-
-4. The wrapper script makes it easy to run any command with the token properly set up.