gitarsenal-cli 1.1.19 → 1.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "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,108 @@
+#!/usr/bin/env python3
+"""
+Fetch Modal Tokens
+
+This script fetches Modal tokens from the proxy server.
+"""
+
+import os
+import sys
+import json
+import requests
+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 not api_key:
+        api_key = os.environ.get("MODAL_PROXY_API_KEY")
+    
+    # Check if we have the necessary information
+    if not proxy_url:
+        print("❌ No proxy URL provided or found in environment")
+        return None, None
+        
+    if not api_key:
+        print("❌ No API key provided or found in environment")
+        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.
+    
+    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")
+        return DEFAULT_TOKEN_ID, DEFAULT_TOKEN_SECRET
+    
+    return token_id, token_secret
+
+if __name__ == "__main__":
+    token_id, token_secret = get_tokens()
+    print(f"Token ID: {token_id}")
+    print(f"Token Secret: {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"✅ Tokens written to {tokens_file}") 

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}")
 

package/python/modal_auth_patch.py

@@ -18,27 +18,40 @@ import types
 import json
 from pathlib import Path
 
-# 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")
 
 # Set environment variables
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
+os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
+os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
 
 # Create token files
 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}"}}')
 
 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")
+
+# Define functions that will always return our tokens
+def get_token_id(*args, **kwargs):
+    return TOKEN_ID
 
-# Define a function that will always return our token
-def get_token(*args, **kwargs):
-    return TOKEN
+def get_token_secret(*args, **kwargs):
+    return TOKEN_SECRET
 
 # Patch Modal's authentication system
 try:
@@ -47,25 +60,32 @@ try:
     
     # Create a fake auth config object
     class FakeAuthConfig:
-        token_id = TOKEN
-        token = TOKEN
+        token_id = TOKEN_ID
+        token_secret = TOKEN_SECRET
         
-        def get_token(self, *args, **kwargs):
-            return TOKEN
-            
         def get_token_id(self, *args, **kwargs):
-            return TOKEN
+            return TOKEN_ID
+            
+        def get_token_secret(self, *args, **kwargs):
+            return TOKEN_SECRET
     
     # Replace Modal's auth config with our fake one
     modal.config._auth_config = FakeAuthConfig()
     
     # Also patch any token-related functions
     for name in dir(modal.config):
-        if "token" in name.lower() or "auth" in name.lower():
+        if "token_id" in name.lower():
             try:
                 attr = getattr(modal.config, name)
                 if callable(attr):
-                    setattr(modal.config, name, get_token)
+                    setattr(modal.config, name, get_token_id)
+            except:
+                pass
+        elif "token_secret" in name.lower() or "token" in name.lower():
+            try:
+                attr = getattr(modal.config, name)
+                if callable(attr):
+                    setattr(modal.config, name, get_token_secret)
             except:
                 pass
     
@@ -92,34 +112,41 @@ except ImportError:
                     # Create a fake auth config object if needed
                     if not hasattr(config, "_auth_config"):
                         class FakeAuthConfig:
-                            token_id = TOKEN
-                            token = TOKEN
+                            token_id = TOKEN_ID
+                            token_secret = TOKEN_SECRET
                             
-                            def get_token(self, *args, **kwargs):
-                                return TOKEN
-                                
                             def get_token_id(self, *args, **kwargs):
-                                return TOKEN
+                                return TOKEN_ID
+                                
+                            def get_token_secret(self, *args, **kwargs):
+                                return TOKEN_SECRET
                         
                         config._auth_config = FakeAuthConfig()
                     else:
                         # Patch existing auth config
-                        config._auth_config.token_id = TOKEN
-                        config._auth_config.token = TOKEN
+                        config._auth_config.token_id = TOKEN_ID
+                        config._auth_config.token_secret = TOKEN_SECRET
                         
                         # Patch methods
-                        if hasattr(config._auth_config, "get_token"):
-                            config._auth_config.get_token = get_token
                         if hasattr(config._auth_config, "get_token_id"):
-                            config._auth_config.get_token_id = get_token
+                            config._auth_config.get_token_id = get_token_id
+                        if hasattr(config._auth_config, "get_token_secret"):
+                            config._auth_config.get_token_secret = get_token_secret
                     
                     # Also patch any token-related functions
                     for name in dir(config):
-                        if "token" in name.lower() or "auth" in name.lower():
+                        if "token_id" in name.lower():
+                            try:
+                                attr = getattr(config, name)
+                                if callable(attr):
+                                    setattr(config, name, get_token_id)
+                            except:
+                                pass
+                        elif "token_secret" in name.lower() or "token" in name.lower():
                             try:
                                 attr = getattr(config, name)
                                 if callable(attr):
-                                    setattr(config, name, get_token)
+                                    setattr(config, name, get_token_secret)
                             except:
                                 pass
                     

package/python/modal_proxy_service.py

@@ -111,7 +111,50 @@ def generate_random_password(length=16):
 
 def setup_modal_auth():
     """Set up Modal authentication using the server's token"""
-    # Use the comprehensive Modal token solution
+    # First, try to fetch tokens from the proxy server
+    try:
+        # 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()
+        logger.info("Modal tokens fetched successfully")
+        
+        # Set the tokens in environment variables
+        os.environ["MODAL_TOKEN_ID"] = token_id
+        os.environ["MODAL_TOKEN_SECRET"] = token_secret
+        
+        # Create token files
+        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)
+        logger.info(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_id}\n")
+            f.write(f"token_secret = {token_secret}\n")
+        logger.info(f"Created .modalconfig file at {modalconfig_file}")
+        
+        # Verify token is working by attempting a simple operation
+        try:
+            # Try a simple Modal operation
+            import modal.cli.app_create
+            logger.info("Modal module imported successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error importing Modal module: {e}")
+            # Fall back to other methods
+    except Exception as e:
+        logger.error(f"Error fetching Modal tokens: {e}")
+        # Fall back to other methods
+    
+    # Use the comprehensive Modal token solution as fallback
     try:
         # Import the comprehensive solution module
         logger.info("Applying comprehensive Modal token solution...")
@@ -361,45 +404,77 @@ def create_ssh_container():
                 env_copy["MODAL_TOKEN_ID"] = MODAL_TOKEN
                 env_copy["MODAL_TOKEN"] = MODAL_TOKEN
                 
-                # Use the comprehensive Modal token solution
+                # First, try to fetch tokens from the proxy server
                 try:
-                    # Import the comprehensive solution module
-                    logger.info("Applying comprehensive Modal token solution in thread...")
-                    import modal_token_solution
-                    logger.info("Comprehensive Modal token solution applied in thread")
+                    # 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()
+                    logger.info("Modal tokens fetched successfully in thread")
+                    
+                    # Set the tokens in environment variables
+                    os.environ["MODAL_TOKEN_ID"] = token_id
+                    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+                    
+                    # Create token files
+                    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)
+                    logger.info(f"Created token file at {token_file} in thread")
+                    
+                    # Create .modalconfig 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")
+                    logger.info(f"Created .modalconfig file at {modalconfig_file} in thread")
                 except Exception as e:
-                    logger.error(f"Error applying comprehensive Modal token solution in thread: {e}")
+                    logger.error(f"Error fetching Modal tokens in thread: {e}")
                     
-                    # Fall back to the authentication patch
+                    # Fall back to the comprehensive Modal token solution
                     try:
-                        logger.info("Falling back to Modal authentication patch in thread...")
-                        import modal_auth_patch
-                        logger.info("Modal authentication patch applied in thread")
-                    except Exception as patch_e:
-                        logger.error(f"Error applying Modal authentication patch in thread: {patch_e}")
+                        # Import the comprehensive solution module
+                        logger.info("Applying comprehensive Modal token solution in thread...")
+                        import modal_token_solution
+                        logger.info("Comprehensive Modal token solution applied in thread")
+                    except Exception as e:
+                        logger.error(f"Error applying comprehensive Modal token solution in thread: {e}")
                         
-                        # Fall back to fix_modal_token.py
+                        # Fall back to the authentication patch
                         try:
-                            # Execute the fix_modal_token.py script
-                            logger.info("Falling back to fix_modal_token.py in thread...")
-                            result = subprocess.run(
-                                ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                                capture_output=True,
-                                text=True
-                            )
-                            
-                            # Log the output
-                            for line in result.stdout.splitlines():
-                                logger.info(f"fix_modal_token.py (thread): {line}")
+                            logger.info("Falling back to Modal authentication patch in thread...")
+                            import modal_auth_patch
+                            logger.info("Modal authentication patch applied in thread")
+                        except Exception as patch_e:
+                            logger.error(f"Error applying Modal authentication patch in thread: {patch_e}")
                             
-                            if result.returncode != 0:
-                                logger.warning(f"fix_modal_token.py exited with code {result.returncode} in thread")
-                                if result.stderr:
-                                    logger.error(f"fix_modal_token.py error in thread: {result.stderr}")
-                            else:
-                                logger.info("Modal token setup completed via fix_modal_token.py in thread")
-                        except Exception as token_e:
-                            logger.error(f"Error running fix_modal_token.py in thread: {token_e}")
+                            # Fall back to fix_modal_token.py
+                            try:
+                                # Execute the fix_modal_token.py script
+                                logger.info("Falling back to fix_modal_token.py in thread...")
+                                result = subprocess.run(
+                                    ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                                    capture_output=True,
+                                    text=True
+                                )
+                                
+                                # Log the output
+                                for line in result.stdout.splitlines():
+                                    logger.info(f"fix_modal_token.py (thread): {line}")
+                                
+                                if result.returncode != 0:
+                                    logger.warning(f"fix_modal_token.py exited with code {result.returncode} in thread")
+                                    if result.stderr:
+                                        logger.error(f"fix_modal_token.py error in thread: {result.stderr}")
+                                else:
+                                    logger.info("Modal token setup completed via fix_modal_token.py in thread")
+                            except Exception as token_e:
+                                logger.error(f"Error running fix_modal_token.py in thread: {token_e}")
                 
                 # Explicitly print token status for debugging
                 logger.info(f"MODAL_TOKEN_ID in thread env: {os.environ.get('MODAL_TOKEN_ID')}")

package/python/modal_token_solution.py

@@ -21,8 +21,17 @@ import types
 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("🔧 Modal Token Solution - Comprehensive Fix")
 
@@ -30,10 +39,10 @@ print("🔧 Modal Token Solution - Comprehensive Fix")
 # 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
@@ -46,8 +55,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}")
@@ -56,8 +65,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}")
@@ -65,15 +74,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}")
@@ -83,48 +93,27 @@ print(f"✅ Created config.json file at {config_file}")
 # =====================================================================
 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, "--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}")
 
 # =====================================================================
-# Approach 4: Define a function that will always return our token
+# Approach 4: Define functions that will always return our tokens
 # =====================================================================
-def get_token(*args, **kwargs):
-    return TOKEN
+def get_token_id(*args, **kwargs):
+    return TOKEN_ID
+
+def get_token_secret(*args, **kwargs):
+    return TOKEN_SECRET
 
 # =====================================================================
 # Approach 5: Patch Modal's authentication system
@@ -136,14 +125,14 @@ try:
     
     # Create a fake auth config object
     class FakeAuthConfig:
-        token_id = TOKEN
-        token = TOKEN
+        token_id = TOKEN_ID
+        token_secret = TOKEN_SECRET
         
-        def get_token(self, *args, **kwargs):
-            return TOKEN
-            
         def get_token_id(self, *args, **kwargs):
-            return TOKEN
+            return TOKEN_ID
+            
+        def get_token_secret(self, *args, **kwargs):
+            return TOKEN_SECRET
     
     # Replace Modal's auth config with our fake one
     try:
@@ -154,11 +143,19 @@ try:
     
     # Also patch any token-related functions
     for name in dir(modal.config):
-        if "token" in name.lower() or "auth" in name.lower():
+        if "token_id" in name.lower():
+            try:
+                attr = getattr(modal.config, name)
+                if callable(attr):
+                    setattr(modal.config, name, get_token_id)
+                    print(f"✅ Patched modal.config.{name}")
+            except:
+                pass
+        elif "token_secret" in name.lower() or "token" in name.lower():
             try:
                 attr = getattr(modal.config, name)
                 if callable(attr):
-                    setattr(modal.config, name, get_token)
+                    setattr(modal.config, name, get_token_secret)
                     print(f"✅ Patched modal.config.{name}")
             except:
                 pass
@@ -186,34 +183,41 @@ except ImportError:
                     # Create a fake auth config object if needed
                     if not hasattr(config, "_auth_config"):
                         class FakeAuthConfig:
-                            token_id = TOKEN
-                            token = TOKEN
+                            token_id = TOKEN_ID
+                            token_secret = TOKEN_SECRET
                             
-                            def get_token(self, *args, **kwargs):
-                                return TOKEN
-                                
                             def get_token_id(self, *args, **kwargs):
-                                return TOKEN
+                                return TOKEN_ID
+                                
+                            def get_token_secret(self, *args, **kwargs):
+                                return TOKEN_SECRET
                         
                         config._auth_config = FakeAuthConfig()
                     else:
                         # Patch existing auth config
-                        config._auth_config.token_id = TOKEN
-                        config._auth_config.token = TOKEN
+                        config._auth_config.token_id = TOKEN_ID
+                        config._auth_config.token_secret = TOKEN_SECRET
                         
                         # Patch methods
-                        if hasattr(config._auth_config, "get_token"):
-                            config._auth_config.get_token = get_token
                         if hasattr(config._auth_config, "get_token_id"):
-                            config._auth_config.get_token_id = get_token
+                            config._auth_config.get_token_id = get_token_id
+                        if hasattr(config._auth_config, "get_token_secret"):
+                            config._auth_config.get_token_secret = get_token_secret
                     
                     # Also patch any token-related functions
                     for name in dir(config):
-                        if "token" in name.lower() or "auth" in name.lower():
+                        if "token_id" in name.lower():
+                            try:
+                                attr = getattr(config, name)
+                                if callable(attr):
+                                    setattr(config, name, get_token_id)
+                            except:
+                                pass
+                        elif "token_secret" in name.lower() or "token" in name.lower():
                             try:
                                 attr = getattr(config, name)
                                 if callable(attr):
-                                    setattr(config, name, get_token)
+                                    setattr(config, name, get_token_secret)
                             except:
                                 pass
                     
@@ -248,19 +252,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}")
+                                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}")
+                                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}")
 

package/python/test_modalSandboxScript.py

@@ -11,46 +11,68 @@ import secrets
 import string
 from pathlib import Path
 
-# Apply the comprehensive Modal token solution first
+# First, try to fetch tokens from the proxy server
 try:
-    # Import the comprehensive solution module
-    print("🔄 Applying comprehensive Modal token solution...")
-    import modal_token_solution
-    print("✅ Comprehensive Modal token solution applied")
+    # Import the fetch_modal_tokens module
+    print("🔄 Fetching Modal tokens from proxy server...")
+    from fetch_modal_tokens import get_tokens
+    token_id, token_secret = get_tokens()
+    print(f"✅ Modal tokens fetched successfully")
+    
+    # Set token variables for later use
+    token = token_id  # For backward compatibility
 except Exception as e:
-    print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
+    print(f"⚠️ Error fetching Modal tokens: {e}")
     
-    # Fall back to the authentication patch
+    # Apply the comprehensive Modal token solution as fallback
     try:
-        # Import the patch module
-        print("🔄 Falling back to Modal authentication patch...")
-        import modal_auth_patch
-        print("✅ Modal authentication patch applied")
+        # Import the comprehensive solution module
+        print("🔄 Applying comprehensive Modal token solution...")
+        import modal_token_solution
+        print("✅ Comprehensive Modal token solution applied")
+        
+        # Set token variables for later use
+        token = modal_token_solution.TOKEN_ID  # For backward compatibility
     except Exception as e:
-        print(f"⚠️ Error applying Modal authentication patch: {e}")
+        print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
         
-        # Fall back to fix_modal_token.py
+        # Fall back to the authentication patch
         try:
-            # Execute the fix_modal_token.py script
-            print("🔄 Falling back to fix_modal_token.py...")
-            result = subprocess.run(
-                ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                capture_output=True,
-                text=True
-            )
+            # Import the patch module
+            print("🔄 Falling back to Modal authentication patch...")
+            import modal_auth_patch
+            print("✅ Modal authentication patch applied")
             
-            # Print the output
-            print(result.stdout)
-            
-            if result.returncode != 0:
-                print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
-                if result.stderr:
-                    print(f"Error: {result.stderr}")
+            # Set token variables for later use
+            token = modal_auth_patch.TOKEN_ID  # For backward compatibility
         except Exception as e:
-            print(f"⚠️ Error running fix_modal_token.py: {e}")
-
-# Set token variable for later use
-token = "ak-eNMIXRdfbvpxIXcSHKPFQW"
+            print(f"⚠️ Error applying Modal authentication patch: {e}")
+            
+            # Fall back to fix_modal_token.py
+            try:
+                # Execute the fix_modal_token.py script
+                print("🔄 Falling back to fix_modal_token.py...")
+                result = subprocess.run(
+                    ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                    capture_output=True,
+                    text=True
+                )
+                
+                # Print the output
+                print(result.stdout)
+                
+                if result.returncode != 0:
+                    print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
+                    if result.stderr:
+                        print(f"Error: {result.stderr}")
+                
+                # Set token variables for later use
+                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
+            except Exception as e:
+                print(f"⚠️ Error running fix_modal_token.py: {e}")
+                
+                # Last resort: use hardcoded tokens
+                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
 
 # Print debug info
 print(f"🔍 DEBUG: Checking environment variables")

package/python/test_modal_auth.py

@@ -11,25 +11,36 @@ import json
 from pathlib import Path
 import time
 
-# Set token directly in environment
-TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
+# 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")
+
+# Set tokens directly in environment
+os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
+os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
 
 # Print environment variables
 print(f"Environment variables:")
 print(f"MODAL_TOKEN_ID = {os.environ.get('MODAL_TOKEN_ID')}")
-print(f"MODAL_TOKEN = {os.environ.get('MODAL_TOKEN')}")
+print(f"MODAL_TOKEN_SECRET = {os.environ.get('MODAL_TOKEN_SECRET')}")
 
 # 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:
-    # Try different formats
+    # Use the correct format with token_id and token_secret
     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}")
@@ -38,7 +49,8 @@ print(f"Token file contents: {json.dumps(token_data)}")
 # 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}")
 
 # Try to import Modal