gitarsenal-cli 1.9.21 → 1.9.24

package/python/modal_proxy_service.py

@@ -1,665 +0,0 @@
-#!/usr/bin/env python3
-"""
-Modal Proxy Service for GitArsenal CLI
-
-This service allows GitArsenal CLI users to access Modal services without exposing your Modal token.
-It acts as a secure proxy between clients and Modal's API.
-"""
-
-import os
-import json
-import secrets
-import string
-import time
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-import modal
-import threading
-import logging
-from dotenv import load_dotenv
-import uuid
-import sys
-from pathlib import Path
-import subprocess
-import signal
-
-# Add the current directory to the path so we can import the test_modalSandboxScript module
-current_dir = Path(__file__).parent.absolute()
-sys.path.append(str(current_dir.parent))
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("modal_proxy.log"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger("modal-proxy")
-
-app = Flask(__name__)
-CORS(app)  # Enable CORS for all routes
-
-# Set up the built-in Modal token
-try:
-    from setup_modal_token import setup_modal_token, BUILT_IN_MODAL_TOKEN
-    token_setup_success = setup_modal_token()
-    if token_setup_success:
-        logger.info("Modal token set up successfully using setup_modal_token module")
-    else:
-        logger.warning("setup_modal_token module failed to set up Modal token")
-    
-    # Always set the built-in token
-    MODAL_TOKEN = BUILT_IN_MODAL_TOKEN
-except ImportError:
-    logger.warning("setup_modal_token module not found")
-    # Fallback to a hardcoded token
-    # Modal tokens are in the format: ak-xxxxxxxxxxxxxxxxxx
-    MODAL_TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"  # Your actual token
-except Exception as e:
-    logger.error(f"Error using setup_modal_token module: {e}")
-    # Fallback to a hardcoded token
-    # Modal tokens are in the format: ak-xxxxxxxxxxxxxxxxxx
-    MODAL_TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"  # Your actual token
-
-# Set the token in environment variables
-os.environ["MODAL_TOKEN"] = MODAL_TOKEN
-os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
-logger.info(f"Using built-in Modal token (length: {len(MODAL_TOKEN)})")
-
-# Dictionary to store active containers
-active_containers = {}
-
-# Authentication tokens for clients
-# In a production environment, use a proper authentication system
-API_KEYS = {
-    "gitarsenal-default-key": True  # Default key for local development
-}
-if os.environ.get("API_KEYS"):
-    # Add any additional keys from environment
-    for key in os.environ.get("API_KEYS").split(","):
-        API_KEYS[key.strip()] = True
-
-def generate_api_key():
-    """Generate a new API key for a client"""
-    return ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(32))
-
-def authenticate_request():
-    """Authenticate the request using API key"""
-    api_key = request.headers.get('X-API-Key')
-    
-    # For development/testing: Accept requests without API key from localhost
-    if request.remote_addr in ['127.0.0.1', 'localhost']:
-        logger.info(f"Allowing request from localhost without API key check")
-        return True
-        
-    # Normal API key check for other requests
-    if not api_key or api_key not in API_KEYS:
-        logger.warning(f"Authentication failed: Invalid or missing API key")
-        return False
-        
-    logger.info(f"Request authenticated with API key")
-    return True
-
-def generate_random_password(length=16):
-    """Generate a random password for SSH access"""
-    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
-    password = ''.join(secrets.choice(alphabet) for i in range(length))
-    return password
-
-def setup_modal_auth():
-    """Set up Modal authentication using the server's token"""
-    # 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...")
-        import modal_token_solution
-        logger.info("Comprehensive Modal token solution applied")
-        
-        # 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 the authentication patch
-            try:
-                logger.info("Falling back to Modal authentication patch...")
-                import modal_auth_patch
-                logger.info("Modal authentication patch applied")
-                return True
-            except Exception as patch_e:
-                logger.error(f"Error applying Modal authentication patch: {patch_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...")
-                    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: {line}")
-                    
-                    if result.returncode != 0:
-                        logger.warning(f"fix_modal_token.py exited with code {result.returncode}")
-                        if result.stderr:
-                            logger.error(f"fix_modal_token.py error: {result.stderr}")
-                        return False
-                        
-                    logger.info("Modal token setup completed via fix_modal_token.py")
-                    return True
-                except Exception as token_e:
-                    logger.error(f"Error running fix_modal_token.py: {token_e}")
-                    return False
-    except Exception as e:
-        logger.error(f"Error setting up Modal authentication: {e}")
-        return False
-
-def cleanup_security_tokens():
-    """Delete all security tokens and API keys after SSH container is started"""
-    logger.info("🧹 Cleaning up security tokens and API keys...")
-    
-    try:
-        # Remove Modal tokens from environment variables
-        modal_env_vars = ["MODAL_TOKEN_ID", "MODAL_TOKEN", "MODAL_TOKEN_SECRET"]
-        for var in modal_env_vars:
-            if var in os.environ:
-                del os.environ[var]
-                logger.info(f"✅ Removed {var} from environment")
-        
-        # Remove OpenAI API key from environment
-        if "OPENAI_API_KEY" in os.environ:
-            del os.environ["OPENAI_API_KEY"]
-            logger.info("✅ Removed OpenAI API key from environment")
-        
-        # Delete ~/.modal.toml file
-        from pathlib import Path
-        modal_toml = Path.home() / ".modal.toml"
-        if modal_toml.exists():
-            modal_toml.unlink()
-            logger.info(f"✅ Deleted Modal token file at {modal_toml}")
-        
-        # Delete ~/.gitarsenal/openai_key file
-        openai_key_file = Path.home() / ".gitarsenal" / "openai_key"
-        if openai_key_file.exists():
-            openai_key_file.unlink()
-            logger.info(f"✅ Deleted OpenAI API key file at {openai_key_file}")
-        
-        logger.info("✅ Security cleanup completed successfully")
-    except Exception as e:
-        logger.error(f"❌ Error during security cleanup: {e}")
-
-# Keep the old function for backward compatibility
-def cleanup_modal_token():
-    """Legacy function - now calls the comprehensive cleanup"""
-    cleanup_security_tokens()
-
-@app.route('/api/health', methods=['GET'])
-def health_check():
-    """Health check endpoint"""
-    # Add CORS headers manually for this endpoint to ensure it works with direct browser requests
-    response = jsonify({"status": "ok", "message": "Modal proxy service is running"})
-    response.headers.add('Access-Control-Allow-Origin', '*')
-    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-API-Key')
-    response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS')
-    return response
-
-@app.route('/', methods=['GET'])
-def root():
-    """Root endpoint for basic connectivity testing"""
-    return jsonify({"status": "ok", "message": "Modal proxy service is running"})
-
-@app.route('/api/modal-tokens', methods=['GET'])
-def get_modal_tokens():
-    """Get Modal tokens (protected by API key)"""
-    if not authenticate_request():
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    # Return the server's Modal token
-    return jsonify({
-        "token_id": MODAL_TOKEN,
-        "token_secret": MODAL_TOKEN  # For compatibility, use the same token
-    })
-
-@app.route('/api/create-api-key', methods=['POST'])
-def create_api_key():
-    """Create a new API key (protected by admin key)"""
-    admin_key = request.headers.get('X-Admin-Key')
-    if not admin_key or admin_key != os.environ.get("ADMIN_KEY"):
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    new_key = generate_api_key()
-    API_KEYS[new_key] = True
-    
-    return jsonify({"api_key": new_key})
-
-@app.route('/api/create-sandbox', methods=['POST'])
-def create_sandbox():
-    """Create a Modal sandbox"""
-    if not authenticate_request():
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    if not setup_modal_auth():
-        return jsonify({"error": "Failed to set up Modal authentication"}), 500
-    
-    try:
-        data = request.json
-        gpu_type = data.get('gpu_type', 'A10G')
-        repo_url = data.get('repo_url')
-        repo_name = data.get('repo_name')
-        setup_commands = data.get('setup_commands', [])
-        volume_name = data.get('volume_name')
-        
-        # Import the sandbox creation function from your module
-        from test_modalSandboxScript import create_modal_sandbox
-        
-        logger.info(f"Creating sandbox with GPU: {gpu_type}, Repo: {repo_url}")
-        
-        # Create a unique ID for this sandbox
-        sandbox_id = str(uuid.uuid4())
-        
-        # Start sandbox creation in a separate thread
-        def create_sandbox_thread():
-            try:
-                # Ensure Modal token is set before creating sandbox
-                if not setup_modal_auth():
-                    logger.error("Failed to set up Modal authentication in thread")
-                    return
-                    
-                result = create_modal_sandbox(
-                    gpu_type, 
-                    repo_url=repo_url, 
-                    repo_name=repo_name, 
-                    setup_commands=setup_commands,
-                    volume_name=volume_name
-                )
-                
-                if result:
-                    active_containers[sandbox_id] = {
-                        "container_id": result.get("container_id"),
-                        "sandbox_id": result.get("sandbox_id"),
-                        "created_at": time.time(),
-                        "type": "sandbox"
-                    }
-                    logger.info(f"Sandbox created successfully: {result.get('container_id')}")
-                else:
-                    logger.error("Failed to create sandbox")
-            except Exception as e:
-                logger.error(f"Error in sandbox creation thread: {e}")
-        
-        thread = threading.Thread(target=create_sandbox_thread)
-        thread.daemon = True
-        thread.start()
-        
-        return jsonify({
-            "message": "Sandbox creation started",
-            "sandbox_id": sandbox_id
-        })
-        
-    except Exception as e:
-        logger.error(f"Error creating sandbox: {e}")
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/create-ssh-container', methods=['POST'])
-def create_ssh_container():
-    """Create a Modal SSH container"""
-    if not authenticate_request():
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    # Check if Modal token is available
-    if not MODAL_TOKEN:
-        logger.error("Cannot create SSH container: No Modal token available")
-        return jsonify({"error": "Modal token not configured on server"}), 500
-    
-    try:
-        # Set the token directly in environment
-        os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
-        os.environ["MODAL_TOKEN"] = MODAL_TOKEN
-        logger.info(f"Set MODAL_TOKEN_ID in environment (length: {len(MODAL_TOKEN)})")
-        
-        # Create the token file directly in the expected location
-        try:
-            from pathlib import Path
-            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": "{MODAL_TOKEN}", "token": "{MODAL_TOKEN}"}}')
-            logger.info(f"Created Modal token file at {token_file}")
-            
-            # Set up token using multiple approaches
-            # 1. Create .modalconfig file as an alternative method
-            modalconfig_file = Path.home() / ".modalconfig"
-            with open(modalconfig_file, 'w') as f:
-                f.write(f"token_id = {token}\n")
-            logger.info(f"Created .modalconfig file at {modalconfig_file}")
-            
-            # 2. Import modal and set token directly
-            import modal
-            
-            # 3. Try to directly configure Modal
-            try:
-                import modal.config
-                modal.config._auth_config.token_id = token
-                logger.info("Explicitly set token in Modal config")
-            except Exception as e:
-                logger.warning(f"Error setting token in Modal config: {e}")
-            # No need to clean up any temporary files
-                
-            if result.returncode == 0:
-                logger.info("Successfully set token via Modal CLI")
-            else:
-                logger.warning(f"Modal CLI token set returned: {result.stderr}")
-                
-            # As a fallback, also create the token file in the expected location
-            try:
-                from pathlib import Path
-                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": "{MODAL_TOKEN}", "token": "{MODAL_TOKEN}"}}')
-                logger.info(f"Created Modal token file at {token_file}")
-            except Exception as file_err:
-                logger.warning(f"Failed to create Modal token file: {file_err}")
-        except Exception as e:
-            logger.warning(f"Failed to set token via CLI: {e}")
-        
-        data = request.json
-        gpu_type = data.get('gpu_type', 'A10G')
-        repo_url = data.get('repo_url')
-        repo_name = data.get('repo_name')
-        setup_commands = data.get('setup_commands', [])
-        volume_name = data.get('volume_name')
-        timeout_minutes = data.get('timeout', 60)
-        
-        # Generate a random password for SSH
-        ssh_password = generate_random_password()
-        
-        # Import the SSH container creation function
-        from test_modalSandboxScript import create_modal_ssh_container
-        
-        logger.info(f"Creating SSH container with GPU: {gpu_type}, Repo: {repo_url}")
-        
-        # Create a unique ID for this container
-        container_id = str(uuid.uuid4())
-        
-        # Log token status for debugging
-        token_status = "Token is set" if MODAL_TOKEN else "Token is missing"
-        logger.info(f"Modal token status before thread: {token_status}")
-        logger.info(f"Modal token length: {len(MODAL_TOKEN) if MODAL_TOKEN else 'N/A'}")
-        
-        # Start container creation in a separate thread
-        def create_container_thread():
-            try:
-                # Set token in environment for this thread
-                os.environ["MODAL_TOKEN_ID"] = MODAL_TOKEN
-                os.environ["MODAL_TOKEN"] = MODAL_TOKEN
-                logger.info(f"Set MODAL_TOKEN_ID in thread (length: {len(MODAL_TOKEN)})")
-                
-                # Create a copy of the environment variables for the container creation
-                env_copy = os.environ.copy()
-                env_copy["MODAL_TOKEN_ID"] = MODAL_TOKEN
-                env_copy["MODAL_TOKEN"] = MODAL_TOKEN
-                
-                # First, try to fetch tokens from the proxy server
-                try:
-                    # 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 fetching Modal tokens in thread: {e}")
-                    
-                    # Fall back to the comprehensive Modal token solution
-                    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")
-                    except Exception as e:
-                        logger.error(f"Error applying comprehensive Modal token solution in thread: {e}")
-                        
-                        # Fall back to the authentication patch
-                        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}")
-                            
-                            # 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')}")
-                logger.info(f"MODAL_TOKEN in thread env: {os.environ.get('MODAL_TOKEN')}")
-                
-                result = create_modal_ssh_container(
-                    gpu_type, 
-                    repo_url=repo_url, 
-                    repo_name=repo_name, 
-                    setup_commands=setup_commands,
-                    volume_name=volume_name,
-                    timeout_minutes=timeout_minutes,
-                    ssh_password=ssh_password
-                )
-                
-                # Clean up Modal token after container is created
-                cleanup_modal_token()
-                
-                if result:
-                    active_containers[container_id] = {
-                        "container_id": result.get("app_name"),
-                        "ssh_password": ssh_password,
-                        "created_at": time.time(),
-                        "type": "ssh"
-                    }
-                    logger.info(f"SSH container created successfully: {result.get('app_name')}")
-                else:
-                    logger.error("Failed to create SSH container")
-            except Exception as e:
-                logger.error(f"Error in SSH container creation thread: {e}")
-        
-        thread = threading.Thread(target=create_container_thread)
-        thread.daemon = True
-        thread.start()
-        
-        return jsonify({
-            "message": "SSH container creation started",
-            "container_id": container_id,
-            "ssh_password": ssh_password
-        })
-        
-    except Exception as e:
-        logger.error(f"Error creating SSH container: {e}")
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/container-status/<container_id>', methods=['GET'])
-def container_status(container_id):
-    """Get status of a container"""
-    if not authenticate_request():
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    if container_id in active_containers:
-        # Remove sensitive information like passwords
-        container_info = active_containers[container_id].copy()
-        if "ssh_password" in container_info:
-            del container_info["ssh_password"]
-        
-        return jsonify({
-            "status": "active",
-            "info": container_info
-        })
-    else:
-        return jsonify({
-            "status": "not_found",
-            "message": "Container not found or has been terminated"
-        }), 404
-
-@app.route('/api/terminate-container', methods=['POST'])
-def terminate_container():
-    """Terminate a Modal container"""
-    if not authenticate_request():
-        return jsonify({"error": "Unauthorized"}), 401
-    
-    if not setup_modal_auth():
-        return jsonify({"error": "Failed to set up Modal authentication"}), 500
-    
-    try:
-        data = request.json
-        container_id = data.get('container_id')
-        
-        if not container_id:
-            return jsonify({"error": "Container ID is required"}), 400
-        
-        if container_id not in active_containers:
-            return jsonify({"error": "Container not found"}), 404
-        
-        modal_container_id = active_containers[container_id].get("container_id")
-        
-        # Terminate the container using Modal CLI
-        import subprocess
-        result = subprocess.run(
-            ["modal", "container", "terminate", modal_container_id],
-            capture_output=True,
-            text=True
-        )
-        
-        if result.returncode == 0:
-            # Remove from active containers
-            del active_containers[container_id]
-            logger.info(f"Container terminated successfully: {modal_container_id}")
-            return jsonify({"message": "Container terminated successfully"})
-        else:
-            logger.error(f"Failed to terminate container: {result.stderr}")
-            return jsonify({"error": f"Failed to terminate container: {result.stderr}"}), 500
-        
-    except Exception as e:
-        logger.error(f"Error terminating container: {e}")
-        return jsonify({"error": str(e)}), 500
-
-# Register signal handlers for cleanup on shutdown
-def signal_handler(sig, frame):
-    """Handle signals for graceful shutdown"""
-    logger.info(f"Received signal {sig}, cleaning up and shutting down...")
-    cleanup_modal_token()
-    sys.exit(0)
-
-# Register signal handlers for common termination signals
-signal.signal(signal.SIGINT, signal_handler)   # Ctrl+C
-signal.signal(signal.SIGTERM, signal_handler)  # Termination request
-
-if __name__ == '__main__':
-    # Check if Modal token is set
-    if not MODAL_TOKEN:
-        logger.error("MODAL_TOKEN environment variable must be set!")
-        exit(1)
-    
-    # Generate an admin key if not set
-    if not os.environ.get("ADMIN_KEY"):
-        admin_key = generate_api_key()
-        os.environ["ADMIN_KEY"] = admin_key
-        logger.info(f"Generated admin key: {admin_key}")
-        print(f"Admin key: {admin_key}")
-    
-    port = int(os.environ.get("PORT", 5001))  # Default to 5001 to avoid macOS AirPlay conflict
-    app.run(host='0.0.0.0', port=port)