gitarsenal-cli 1.1.19 → 1.1.21

package/package.json

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

package/python/MODAL_TOKEN_README.md

@@ -6,21 +6,23 @@ This directory contains several scripts to solve the Modal token authentication
 
 We've implemented a comprehensive solution that uses multiple approaches to ensure Modal can authenticate properly:
 
-1. **modal_token_solution.py**: The main comprehensive solution that combines all approaches.
-2. **modal_auth_patch.py**: A direct patch for Modal's authentication system.
-3. **fix_modal_token.py**: A basic token setup script.
-4. **fix_modal_token_advanced.py**: An advanced version with more approaches.
+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. **Environment Variables**: Sets `MODAL_TOKEN_ID` and `MODAL_TOKEN` environment variables.
-2. **Token Files**: Creates token files in various formats and locations that Modal might look for.
-3. **Modal CLI**: Attempts to use the Modal CLI to set the token.
-4. **Direct Patching**: Directly patches Modal's authentication system to always return our token.
-5. **Monkey Patching**: Monkey-patches Modal's import system to inject our token.
-6. **Authentication Testing**: Tests that the authentication works by creating a simple Modal app.
+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
 
@@ -36,27 +38,38 @@ In most cases, you should simply import `modal_token_solution` before importing
 import modal_token_solution
 import modal
 
-# Now Modal will use our token
+# 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 token value is correct (`ak-eNMIXRdfbvpxIXcSHKPFQW`).
+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. Try running the scripts manually to see detailed output.
+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 Value**: We use a hardcoded token (`ak-eNMIXRdfbvpxIXcSHKPFQW`) that works with our Modal account.
+- **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.

package/python/fetch_modal_tokens.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+Fetch Modal Tokens
+
+This script fetches Modal tokens from the proxy server.
+"""
+
+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
+DEFAULT_TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+DEFAULT_TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
+
+def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
+    """
+    Fetch Modal tokens from the proxy server.
+    
+    Args:
+        proxy_url: URL of the proxy server
+        api_key: API key for authentication
+        
+    Returns:
+        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+    """
+    # 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
+    if not proxy_url.endswith("/"):
+        proxy_url += "/"
+    
+    # Add the endpoint for fetching tokens
+    token_url = f"{proxy_url}api/modal-tokens"
+    
+    try:
+        # Make the request
+        print(f"🔄 Fetching tokens from {token_url}")
+        response = requests.get(
+            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("token_id")
+            token_secret = data.get("token_secret")
+            
+            if token_id and token_secret:
+                print("✅ Successfully fetched tokens from proxy server")
+                return token_id, token_secret
+            else:
+                print("❌ Tokens not found in response")
+                return None, None
+        else:
+            print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
+            return None, None
+    except Exception as e:
+        print(f"❌ Error fetching tokens: {e}")
+        return None, 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)
+    """
+    # 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 not token_id or not token_secret:
+        print("⚠️ Using default tokens")
+        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:
+        json.dump({
+            "token_id": token_id,
+            "token_secret": token_secret
+        }, f)
+    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/fix_modal_token.py

@@ -38,28 +38,38 @@ except Exception as e:
     print(f"❌ Error running advanced Modal token fixer: {e}")
     print("🔄 Falling back to basic implementation")
 
-# The token to use
-TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"
+# Try to get tokens from the proxy server
+try:
+    # First, try to import the fetch_modal_tokens module
+    from fetch_modal_tokens import 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
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
+    print(f"⚠️ Using hardcoded tokens")
 
 print("🔧 Fixing Modal token (basic implementation)...")
 
 # Set environment variables
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
-print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN 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")
 
 # Create token file
 modal_dir = Path.home() / ".modal"
 modal_dir.mkdir(exist_ok=True)
 token_file = modal_dir / "token.json"
 with open(token_file, 'w') as f:
-    f.write(f'{{"token_id": "{TOKEN}", "token": "{TOKEN}"}}')
+    f.write(f'{{"token_id": "{TOKEN_ID}", "token_secret": "{TOKEN_SECRET}"}}')
 print(f"✅ Created token file at {token_file}")
 
 # Create .modalconfig file
 modalconfig_file = Path.home() / ".modalconfig"
 with open(modalconfig_file, 'w') as f:
-    f.write(f"token_id = {TOKEN}\n")
+    f.write(f"token_id = {TOKEN_ID}\n")
+    f.write(f"token_secret = {TOKEN_SECRET}\n")
 print(f"✅ Created .modalconfig file at {modalconfig_file}")
 
 print("\n✅ Done fixing Modal token. Please try your command again.") 

package/python/fix_modal_token_advanced.py

@@ -19,17 +19,26 @@ import inspect
 from pathlib import Path
 import time
 
-# The token to use
-TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"
+# Try to get tokens from the proxy server
+try:
+    # First, try to import the fetch_modal_tokens module
+    from fetch_modal_tokens import 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
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
+    print(f"⚠️ Using hardcoded tokens")
 
 print("🔧 Advanced Modal Token Fixer")
 
 # Approach 1: Set environment variables
 print("\n📋 Approach 1: Setting environment variables")
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
-print(f"✅ Set MODAL_TOKEN_ID = {TOKEN}")
-print(f"✅ Set MODAL_TOKEN = {TOKEN}")
+os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
+os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
+print(f"✅ Set MODAL_TOKEN_ID = {TOKEN_ID}")
+print(f"✅ Set MODAL_TOKEN_SECRET = {TOKEN_SECRET}")
 
 # Approach 2: Create token files in various formats
 print("\n📋 Approach 2: Creating token files in various formats")
@@ -40,8 +49,8 @@ modal_dir.mkdir(exist_ok=True)
 token_file = modal_dir / "token.json"
 with open(token_file, 'w') as f:
     token_data = {
-        "token_id": TOKEN,
-        "token": TOKEN
+        "token_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
     }
     json.dump(token_data, f)
 print(f"✅ Created token file at {token_file}")
@@ -50,8 +59,8 @@ print(f"✅ Created token file at {token_file}")
 token_file_alt = modal_dir / "token_alt.json"
 with open(token_file_alt, 'w') as f:
     token_data_alt = {
-        "id": TOKEN,
-        "secret": TOKEN
+        "id": TOKEN_ID,
+        "secret": TOKEN_SECRET
     }
     json.dump(token_data_alt, f)
 print(f"✅ Created alternative token file at {token_file_alt}")
@@ -59,15 +68,16 @@ print(f"✅ Created alternative token file at {token_file_alt}")
 # Format 3: Create .modalconfig file
 modalconfig_file = Path.home() / ".modalconfig"
 with open(modalconfig_file, 'w') as f:
-    f.write(f"token_id = {TOKEN}\n")
+    f.write(f"token_id = {TOKEN_ID}\n")
+    f.write(f"token_secret = {TOKEN_SECRET}\n")
 print(f"✅ Created .modalconfig file at {modalconfig_file}")
 
 # Format 4: Create config.json file
 config_file = modal_dir / "config.json"
 with open(config_file, 'w') as f:
     config_data = {
-        "token": TOKEN,
-        "token_id": TOKEN
+        "token_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
     }
     json.dump(config_data, f)
 print(f"✅ Created config.json file at {config_file}")
@@ -75,40 +85,16 @@ print(f"✅ Created config.json file at {config_file}")
 # Approach 3: Use Modal CLI to set token
 print("\n📋 Approach 3: Using Modal CLI")
 try:
-    # Create a temporary token file
-    temp_token_file = Path("/tmp/modal_token.txt")
-    with open(temp_token_file, 'w') as f:
-        f.write(TOKEN)
-    
-    # Use the token file with Modal CLI
+    # Use the CLI to set the token directly
     result = subprocess.run(
-        ["modal", "token", "set", "--from-file", str(temp_token_file)],
+        ["modal", "token", "set", "--token-id", TOKEN_ID, "--token-secret", TOKEN_SECRET, "--profile=fr8mafia", "--no-verify"],
         capture_output=True, text=True
     )
     
-    # Clean up
-    temp_token_file.unlink()
-    
     if result.returncode == 0:
         print(f"✅ Successfully set token via Modal CLI")
     else:
         print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
-        
-        # Try alternative approach with stdin
-        print("🔄 Trying alternative approach with stdin")
-        process = subprocess.Popen(
-            ["modal", "token", "set"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
-        stdout, stderr = process.communicate(input=TOKEN)
-        
-        if process.returncode == 0:
-            print(f"✅ Successfully set token via Modal CLI (stdin)")
-        else:
-            print(f"❌ Failed to set token via Modal CLI (stdin): {stderr}")
 except Exception as e:
     print(f"❌ Error using Modal CLI: {e}")
 
@@ -124,28 +110,30 @@ try:
         
         # Try different approaches to set the token
         try:
-            # Approach 4.1: Set token via _auth_config.token_id
+            # Approach 4.1: Set token via _auth_config
             if hasattr(modal.config, '_auth_config'):
-                modal.config._auth_config.token_id = TOKEN
-                print(f"✅ Set token via _auth_config.token_id")
+                modal.config._auth_config.token_id = TOKEN_ID
+                modal.config._auth_config.token_secret = TOKEN_SECRET
+                print(f"✅ Set tokens via _auth_config")
         except Exception as e:
-            print(f"❌ Error setting token via _auth_config: {e}")
+            print(f"❌ Error setting tokens via _auth_config: {e}")
             
         try:
-            # Approach 4.2: Set token via set_token()
+            # Approach 4.2: Set token via set_token() if it exists
             if hasattr(modal.config, 'set_token'):
-                modal.config.set_token(TOKEN)
-                print(f"✅ Set token via set_token()")
+                modal.config.set_token(TOKEN_ID, TOKEN_SECRET)
+                print(f"✅ Set tokens via set_token()")
         except Exception as e:
-            print(f"❌ Error setting token via set_token(): {e}")
+            print(f"❌ Error setting tokens via set_token(): {e}")
             
         try:
-            # Approach 4.3: Set token via Config.token_id
+            # Approach 4.3: Set token via Config
             if hasattr(modal.config, 'Config'):
-                modal.config.Config.token_id = TOKEN
-                print(f"✅ Set token via Config.token_id")
+                modal.config.Config.token_id = TOKEN_ID
+                modal.config.Config.token_secret = TOKEN_SECRET
+                print(f"✅ Set tokens via Config")
         except Exception as e:
-            print(f"❌ Error setting token via Config.token_id: {e}")
+            print(f"❌ Error setting tokens via Config: {e}")
             
         # Approach 4.4: Inspect modal.config and try to find token-related attributes
         print("\n🔍 Inspecting modal.config for token-related attributes...")
@@ -154,16 +142,16 @@ try:
                 print(f"Found potential token-related attribute: {name}")
                 try:
                     attr = getattr(modal.config, name)
-                    if hasattr(attr, "token") or hasattr(attr, "token_id"):
-                        print(f"  - Setting token in {name}")
-                        if hasattr(attr, "token"):
-                            setattr(attr, "token", TOKEN)
-                        if hasattr(attr, "token_id"):
-                            setattr(attr, "token_id", TOKEN)
+                    if hasattr(attr, "token_id"):
+                        print(f"  - Setting token_id in {name}")
+                        setattr(attr, "token_id", TOKEN_ID)
+                    if hasattr(attr, "token_secret"):
+                        print(f"  - Setting token_secret in {name}")
+                        setattr(attr, "token_secret", TOKEN_SECRET)
                 except Exception as e:
-                    print(f"  - Error setting token in {name}: {e}")
+                    print(f"  - Error setting tokens in {name}: {e}")
     except Exception as e:
-        print(f"❌ Error setting token in Modal config: {e}")
+        print(f"❌ Error setting tokens in Modal config: {e}")
 except Exception as e:
     print(f"❌ Error importing Modal: {e}")
 
@@ -172,6 +160,13 @@ print("\n📋 Approach 5: Monkey-patching Modal's authentication system")
 try:
     import modal
     
+    # Define functions that will always return our tokens
+    def get_token_id(*args, **kwargs):
+        return TOKEN_ID
+        
+    def get_token_secret(*args, **kwargs):
+        return TOKEN_SECRET
+    
     # Find all authentication-related classes and functions
     auth_related = []
     for module_name in dir(modal):
@@ -187,19 +182,23 @@ try:
     for name, module in auth_related:
         if inspect.ismodule(module):
             for func_name in dir(module):
-                if "get" in func_name.lower() and ("token" in func_name.lower() or "auth" in func_name.lower() or "cred" in func_name.lower()):
-                    try:
-                        original_func = getattr(module, func_name)
-                        if callable(original_func):
-                            print(f"  - Patching {name}.{func_name}")
-                            
-                            def patched_func(*args, **kwargs):
-                                print(f"    - Patched function called, returning token")
-                                return TOKEN
-                            
-                            setattr(module, func_name, patched_func)
-                    except Exception as e:
-                        print(f"  - Error patching {name}.{func_name}: {e}")
+                if "get" in func_name.lower():
+                    if "token_id" in func_name.lower():
+                        try:
+                            original_func = getattr(module, func_name)
+                            if callable(original_func):
+                                print(f"  - Patching {name}.{func_name} to return token_id")
+                                setattr(module, func_name, get_token_id)
+                        except Exception as e:
+                            print(f"  - Error patching {name}.{func_name}: {e}")
+                    elif "token_secret" in func_name.lower() or "token" in func_name.lower():
+                        try:
+                            original_func = getattr(module, func_name)
+                            if callable(original_func):
+                                print(f"  - Patching {name}.{func_name} to return token_secret")
+                                setattr(module, func_name, get_token_secret)
+                        except Exception as e:
+                            print(f"  - Error patching {name}.{func_name}: {e}")
 except Exception as e:
     print(f"❌ Error monkey-patching Modal: {e}")