gitarsenal-cli 1.1.18 → 1.1.20

package/package.json

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

package/python/MODAL_TOKEN_README.md

@@ -0,0 +1,77 @@
+# 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/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

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Fix Modal Token
+
+This script tries different approaches to fix the Modal token issue.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+# Just run the advanced token fixer
+try:
+    # Get the directory of this script
+    script_dir = Path(__file__).parent.absolute()
+    
+    # Path to the advanced fixer
+    advanced_fixer = script_dir / "fix_modal_token_advanced.py"
+    
+    # Check if the advanced fixer exists
+    if advanced_fixer.exists():
+        print(f"🔄 Running advanced Modal token fixer: {advanced_fixer}")
+        
+        # Execute the advanced fixer
+        result = subprocess.run(
+            ["python", str(advanced_fixer)],
+            check=True  # Raise an exception if the command fails
+        )
+        
+        # Exit with the same code as the advanced fixer
+        sys.exit(result.returncode)
+    else:
+        print(f"❌ Advanced Modal token fixer not found at {advanced_fixer}")
+        # Fall back to the basic implementation
+        print("🔄 Falling back to basic implementation")
+except Exception as e:
+    print(f"❌ Error running advanced Modal token fixer: {e}")
+    print("🔄 Falling back to basic implementation")
+
+# 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_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_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_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

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Advanced Modal Token Fixer
+
+This script tries multiple approaches to fix Modal token issues, including:
+1. Setting environment variables
+2. Creating token files in various formats
+3. Using Modal CLI
+4. Directly modifying Modal's internal configuration
+5. Monkey-patching Modal's authentication system
+"""
+
+import os
+import sys
+import json
+import subprocess
+import importlib
+import inspect
+from pathlib import Path
+import time
+
+# 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_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")
+modal_dir = Path.home() / ".modal"
+modal_dir.mkdir(exist_ok=True)
+
+# Format 1: Standard token.json
+token_file = modal_dir / "token.json"
+with open(token_file, 'w') as f:
+    token_data = {
+        "token_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
+    }
+    json.dump(token_data, f)
+print(f"✅ Created token file at {token_file}")
+
+# Format 2: Alternative token.json format
+token_file_alt = modal_dir / "token_alt.json"
+with open(token_file_alt, 'w') as f:
+    token_data_alt = {
+        "id": TOKEN_ID,
+        "secret": TOKEN_SECRET
+    }
+    json.dump(token_data_alt, f)
+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_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_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
+    }
+    json.dump(config_data, f)
+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:
+    # Use the CLI to set the token directly
+    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}")
+
+# Approach 4: Use Modal Python API to set token
+print("\n📋 Approach 4: Using Modal Python API")
+try:
+    import modal
+    print(f"✅ Successfully imported Modal")
+    
+    # Try to set token directly in Modal's config
+    try:
+        import modal.config
+        
+        # Try different approaches to set the token
+        try:
+            # Approach 4.1: Set token via _auth_config
+            if hasattr(modal.config, '_auth_config'):
+                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 tokens via _auth_config: {e}")
+            
+        try:
+            # Approach 4.2: Set token via set_token() if it exists
+            if hasattr(modal.config, '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 tokens via set_token(): {e}")
+            
+        try:
+            # Approach 4.3: Set token via Config
+            if hasattr(modal.config, 'Config'):
+                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 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...")
+        for name in dir(modal.config):
+            if "token" in name.lower() or "auth" in name.lower():
+                print(f"Found potential token-related attribute: {name}")
+                try:
+                    attr = getattr(modal.config, name)
+                    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 tokens in {name}: {e}")
+    except Exception as e:
+        print(f"❌ Error setting tokens in Modal config: {e}")
+except Exception as e:
+    print(f"❌ Error importing Modal: {e}")
+
+# Approach 5: Monkey-patch Modal's authentication system
+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):
+        if "auth" in module_name.lower() or "token" in module_name.lower() or "config" in module_name.lower():
+            try:
+                module = getattr(modal, module_name)
+                auth_related.append((module_name, module))
+                print(f"Found potential auth-related module: {module_name}")
+            except Exception:
+                pass
+    
+    # Try to monkey-patch auth functions to always return valid credentials
+    for name, module in auth_related:
+        if inspect.ismodule(module):
+            for func_name in dir(module):
+                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}")
+
+# Approach 6: Create a test Modal app to verify token
+print("\n📋 Approach 6: Testing Modal authentication")
+try:
+    import modal
+    
+    print("Creating a test Modal app...")
+    app = modal.App("test-auth")
+    
+    @app.function()
+    def hello():
+        return "Hello, world!"
+    
+    print("Running the test function...")
+    try:
+        with app.run():
+            result = hello.remote()
+            print(f"✅ Successfully ran Modal function: {result}")
+            print("🎉 Modal authentication is working!")
+    except Exception as e:
+        print(f"❌ Error running Modal function: {e}")
+except Exception as e:
+    print(f"❌ Error testing Modal authentication: {e}")
+
+print("\n✅ Done fixing Modal token. Please try your command again.") 

package/python/modal_auth_patch.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Modal Authentication Patcher
+
+This script directly patches Modal's authentication system to always return our token.
+It should be imported before any Modal code is used.
+
+Usage:
+    import modal_auth_patch
+    import modal
+    # Now Modal will use our token
+"""
+
+import os
+import sys
+import importlib
+import types
+import json
+from pathlib import Path
+
+# 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_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_ID}", "token_secret": "{TOKEN_SECRET}"}}')
+
+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")
+
+# 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
+
+# Patch Modal's authentication system
+try:
+    # Try to import modal.config
+    import modal.config
+    
+    # Create a fake auth config object
+    class FakeAuthConfig:
+        token_id = TOKEN_ID
+        token_secret = TOKEN_SECRET
+        
+        def get_token_id(self, *args, **kwargs):
+            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_id" in name.lower():
+            try:
+                attr = getattr(modal.config, name)
+                if callable(attr):
+                    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
+    
+    print("✅ Modal authentication patched successfully")
+except ImportError:
+    # Modal not installed yet, we'll monkey-patch it when it's imported
+    print("⚠️ Modal not installed yet, setting up import hook")
+    
+    # Original import function
+    original_import = __import__
+    
+    # Our custom import function
+    def custom_import(name, globals=None, locals=None, fromlist=(), level=0):
+        # Call the original import function
+        module = original_import(name, globals, locals, fromlist, level)
+        
+        # Check if this is modal or a submodule
+        if name == "modal" or name.startswith("modal."):
+            try:
+                # Try to patch modal.config
+                if hasattr(module, "config"):
+                    config = module.config
+                    
+                    # Create a fake auth config object if needed
+                    if not hasattr(config, "_auth_config"):
+                        class FakeAuthConfig:
+                            token_id = TOKEN_ID
+                            token_secret = TOKEN_SECRET
+                            
+                            def get_token_id(self, *args, **kwargs):
+                                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_ID
+                        config._auth_config.token_secret = TOKEN_SECRET
+                        
+                        # Patch methods
+                        if hasattr(config._auth_config, "get_token_id"):
+                            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_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_secret)
+                            except:
+                                pass
+                    
+                    print("✅ Modal authentication patched during import")
+            except Exception as e:
+                print(f"⚠️ Error patching Modal: {e}")
+        
+        return module
+    
+    # Replace the built-in import function
+    sys.modules["builtins"].__import__ = custom_import
+
+print("✅ Modal authentication patch installed")
+
+# Test the patch if Modal is already imported
+try:
+    import modal
+    print("Testing Modal authentication patch...")
+    
+    # Create a simple app
+    app = modal.App("test-auth-patch")
+    
+    @app.function()
+    def hello():
+        return "Hello from patched Modal!"
+    
+    print("✅ Modal app created successfully")
+except ImportError:
+    print("⚠️ Modal not installed, patch will be applied when it's imported")
+except Exception as e:
+    print(f"❌ Error testing Modal patch: {e}")