Consolidated final Dockerfile and app.py configurations

Dockerfile

@@ -1,15 +1,13 @@
-# Dockerfile
-# Use a Python base image that is compatible with Playwright's system dependencies
+# Use an official Python runtime as a parent image
 FROM python:3.11-slim-buster
 
 # Set the working directory inside the container
 WORKDIR /app
 
-# Install system dependencies required by Playwright's Chromium browser
-# These are common dependencies for running headless Chrome/Chromium.
-# This list might need minor adjustments based on specific runtime errors.
+# Install system dependencies required by Playwright, Git, and other libs
+# This list is comprehensive for headless Chromium on Debian-based systems.
 RUN apt-get update && apt-get install -y \
-    # Core libraries for graphics/rendering
+    # Core libraries for graphics/rendering (for browser)
     fonts-liberation \
     libappindicator3-1 \
     libasound2 \
@@ -34,50 +32,59 @@ RUN apt-get update && apt-get install -y \
     libxrender1 \
     libxss1 \
     libxtst6 \
-    # Specific to Chromium/GPU (even if not using GPU, these are for display stack)
+    # Specific to Chromium/GPU support (even if not using GPU, these are for display stack)
     libgbm-dev \
     libasound2-dev \
     # xvfb provides a virtual display server, often necessary for headless browsers
     xvfb \
-    # Ensure Chromium is installed on the system (Playwright uses its own, but sometimes useful)
-    chromium \
+    # Install Git, required by pip to clone proxy-lite from GitHub
     git \
+    # Install Chromium browser, though Playwright often manages its own, this ensures system deps are met
+    chromium \
     # Clean up apt caches to reduce image size
     && rm -rf /var/lib/apt/lists/*
 
-# Copy Python dependencies (now only common ones, proxy-lite will be handled separately)
+# Copy Python dependencies (only core Flask/Gunicorn deps, proxy-lite installed separately)
 COPY requirements.txt .
 
-# --- NEW/MODIFIED INSTALLATION BLOCK ---
-# Upgrade pip, setuptools, and wheel for a robust build environment
+# --- START: Critical steps for proxy-lite and permissions ---
+
+# Create the directory that proxy-lite's recorder insists on writing to
+# and grant full permissions. This is a workaround for the PermissionError.
+RUN mkdir -p /app/src/proxy-lite/local_trajectories \
+    && chmod -R 777 /app/src/proxy-lite/local_trajectories
+
+# Upgrade pip, setuptools, and wheel for a robust Python build environment.
+# This addresses potential build issues with older versions.
 RUN pip install --no-cache-dir --upgrade pip setuptools wheel
 
-# Install proxy-lite in editable mode directly from its Git repository
-# This explicitly tells pip to clone and "install" it by linking directly,
-# which can sometimes bypass wheel build issues for complex projects.
+# Install proxy-lite in "editable" mode directly from its GitHub repository.
+# This explicitly tells pip to clone and link it, essential for its structure.
 RUN pip install --no-cache-dir -e git+https://github.com/convergence-ai/proxy-lite.git#egg=proxy-lite
 
-# Install the rest of the dependencies from requirements.txt
+# --- END: Critical steps for proxy-lite and permissions ---
+
+# Install the rest of the common Python dependencies from requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
-# --- END NEW/MODIFIED INSTALLATION BLOCK ---
 
-# Copy your application code into the container
+# Copy your Flask application code into the container
 COPY . .
 
 # Install Playwright browser binaries within the container
-# This downloads Chromium into the container's Playwright-managed location.
+# This downloads the actual browser executables that Playwright controls.
 RUN playwright install chromium
 
 # Set environment variables for Playwright
 # PLAYWRIGHT_BROWSERS_PATH: Tells Playwright where to find the installed browsers.
-# DISPLAY, XDG_RUNTIME_DIR: Often needed for headless browser environments.
-ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright/
+# DISPLAY, XDG_RUNTIME_DIR: Often needed for headless browser environments (xvfb).
+ENV PLAYWRIGHT_BROWSERS_PATH=/root/.cache/ms-playwright/
 ENV DISPLAY=:99
 ENV XDG_RUNTIME_DIR=/tmp
 
-# Expose the port your Flask app will listen on. Hugging Face Spaces expects 7860.
+# Expose the port your Flask app will listen on. Hugging Face Spaces requires 7860.
 EXPOSE 7860
 
-# Define the command to run your Flask application using Gunicorn for production
-# Hugging Face Spaces will execute this command to start your web service.
+# Define the command to run your Flask application using Gunicorn for production.
+# --worker-class gevent is used because proxy-lite uses asyncio.
+# --timeout 300s gives 5 minutes for tasks to complete.
 CMD exec gunicorn --bind 0.0.0.0:7860 --workers 2 --worker-class gevent app:app --timeout 300

app.py

@@ -1,36 +1,50 @@
+# app.py
+# IMPORTANT: These two lines MUST be at the very top, before any other imports.
+# They patch asyncio to work cooperatively with gevent workers.
 import gevent.monkey
 gevent.monkey.patch_all(asyncio=True)
-# app.py
+
 import asyncio
 from flask import Flask, request, jsonify
 from proxy_lite import Runner, RunnerConfig
-from proxy_lite.config import RecorderConfig 
+from proxy_lite.config import RecorderConfig # Needed for explicit instantiation
 import os
 import logging
 
+# Configure logging for better visibility in Hugging Face Space logs
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
 
+# Global runner instance. It will be initialized once per worker process/greenlet
+# upon the first request to ensure correct event loop binding.
 _runner = None
 
 async def initialize_runner():
+    """Initializes the Proxy-lite Runner asynchronously."""
     global _runner
     if _runner is None:
         logger.info("Initializing Proxy-lite Runner...")
+        # Retrieve Hugging Face API Token from environment variables (set as Space Secret)
         hf_api_token = os.environ.get("HF_API_TOKEN")
         if not hf_api_token:
             logger.error("HF_API_TOKEN environment variable not set. Cannot initialize Runner.")
             raise ValueError("HF_API_TOKEN environment variable not set. Please set it as a Space secret.")
 
+        # --- EXPLICITLY CREATE RECORDER_CONFIG ---
+        # This addresses the PermissionError by ensuring the root_path is explicitly set
+        # and passed as a Pydantic object, rather than relying on nested dict parsing.
         recorder_config_instance = RecorderConfig(root_path="/tmp/proxy_lite_runs")
+        # --- END EXPLICIT RECORDER_CONFIG ---
 
+        # --- EXPLICITLY CREATE RUNNER_CONFIG ---
+        # Pass all configuration parameters as keyword arguments to the Pydantic model.
         config = RunnerConfig(
             environment={
                 "name": "webbrowser",
                 "homepage": "https://www.google.com",
-                "headless": True,
+                "headless": True, # Keep headless for server environment
             },
             solver={
                 "name": "simple",
@@ -46,31 +60,33 @@ async def initialize_runner():
             },
             recorder=recorder_config_instance # Pass the explicitly created instance
         )
+        # --- END EXPLICIT RUNNER_CONFIG ---
+
+        # Instantiate the Runner, passing the config as a keyword argument (Pydantic style)
         _runner = Runner(config=config)
         logger.info("Proxy-lite Runner initialized successfully.")
     return _runner
 
-# --- MODIFIED run_async_task FUNCTION ---
 def run_async_task(coro):
     """
     Helper to run async coroutines in a synchronous context (like Flask routes).
-    Ensures an event loop exists and runs the coroutine.
+    Ensures an event loop exists for the current thread/greenlet and runs the coroutine.
+    This addresses the "no current event loop" errors.
     """
     try:
         # Try to get the running loop (for current thread/greenlet)
         loop = asyncio.get_running_loop()
     except RuntimeError:
-        # If no loop is running, create a new one for this thread
+        # If no loop is running, create a new one for this thread/greenlet
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-    
+
     # Run the coroutine until it completes
     return loop.run_until_complete(coro)
-# --- END MODIFIED run_async_task FUNCTION ---
-
 
 @app.route('/run_proxy_task', methods=['POST'])
 def run_proxy_task_endpoint():
+    """API endpoint to receive a task and execute it with Proxy-lite."""
     data = request.json
     task = data.get('task')
     if not task:
@@ -79,23 +95,29 @@ def run_proxy_task_endpoint():
 
     logger.info(f"Received task for proxy-lite: '{task}'")
     try:
+        # Ensure runner is initialized (and event loop handled) before use
         runner = run_async_task(initialize_runner())
+        # Run the task using the proxy-lite runner
         result = run_async_task(runner.run(task))
 
-        logger.info(f"Proxy-lite task completed. Output: {result[:200]}...")
+        logger.info(f"Proxy-lite task completed. Output: {result[:200]}...") # Log truncated output
+        # Return the result as a JSON response
         return jsonify({"output": result})
     except Exception as e:
-        logger.exception(f"Error processing task '{task}':")
+        logger.exception(f"Error processing task '{task}':") # Logs full traceback for debugging
         return jsonify({"error": f"An error occurred: {str(e)}. Check logs for details."}), 500
 
 @app.route('/')
 def root():
+    """Basic root endpoint for health check and user info."""
     logger.info("Root endpoint accessed.")
     return "Proxy-lite API is running. Send POST requests to /run_proxy_task with a 'task' in JSON body."
 
 if __name__ == '__main__':
+    # During local development, ensure HF_API_TOKEN is set manually
     if not os.environ.get("HF_API_TOKEN"):
         logger.error("HF_API_TOKEN environment variable is not set. Please set it for local testing.")
         exit(1)
     logger.info("Starting Flask development server on 0.0.0.0:7860...")
-    app.run(host='0.0.0.0', port=7860, debug=True)
+    # Hugging Face Spaces expects binding to 0.0.0.0 and listening on port 7860
+    app.run(host='0.0.0.0', port=7860, debug=True) # debug=True for local testing, disable for production