initial server file watching works

Author: Dylan Huang

eval_protocol/cli.py

@@ -14,6 +14,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 from eval_protocol.evaluation import create_evaluation, preview_evaluation
 
 from .cli_commands.agent_eval_cmd import agent_eval_command
@@ -26,6 +27,7 @@
 from .cli_commands.deploy_mcp import deploy_mcp_command
 from .cli_commands.preview import preview_command
 from .cli_commands.run_eval_cmd import hydra_cli_entry_point
+from .cli_commands.logs import logs_command
 
 
 def parse_args(args=None):
@@ -285,6 +287,39 @@ def parse_args(args=None):
         help="Override the number of parallel rollouts to execute for each task.",
     )
 
+    # Logs command
+    logs_parser = subparsers.add_parser("logs", help="Serve logs with file watching and real-time updates")
+    logs_parser.add_argument(
+        "--build-dir",
+        default="dist",
+        help="Path to the Vite build output directory (default: dist)",
+    )
+    logs_parser.add_argument(
+        "--host",
+        default="localhost",
+        help="Host to bind the server to (default: localhost)",
+    )
+    logs_parser.add_argument(
+        "--port",
+        type=int,
+        default=4789,
+        help="Port to bind the server to (default: 4789)",
+    )
+    logs_parser.add_argument(
+        "--index-file",
+        default="index.html",
+        help="Name of the main index file (default: index.html)",
+    )
+    logs_parser.add_argument(
+        "--watch-paths",
+        help="Comma-separated list of paths to watch for file changes (default: current directory)",
+    )
+    logs_parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable auto-reload (default: False)",
+    )
+
     # Run command (for Hydra-based evaluations)
     # This subparser intentionally defines no arguments itself.
     # All arguments after 'run' will be passed to Hydra by parse_known_args.
@@ -338,6 +373,8 @@ def main():
         return deploy_mcp_command(args)
     elif args.command == "agent-eval":
         return agent_eval_command(args)
+    elif args.command == "logs":
+        return logs_command(args)
     elif args.command == "run":
         # For the 'run' command, Hydra takes over argument parsing.
 

eval_protocol/cli_commands/logs.py

@@ -0,0 +1,40 @@
+"""
+CLI command for serving logs with file watching and real-time updates.
+"""
+
+import sys
+from pathlib import Path
+
+from ..utils.logs_server import serve_logs
+
+
+def logs_command(args):
+    """Serve logs with file watching and real-time updates"""
+
+    # Parse watch paths
+    watch_paths = None
+    if args.watch_paths:
+        watch_paths = args.watch_paths.split(",")
+        watch_paths = [path.strip() for path in watch_paths if path.strip()]
+
+    print(f"🚀 Starting Eval Protocol Logs Server")
+    print(f"🌐 URL: http://{args.host}:{args.port}")
+    print(f"🔌 WebSocket: ws://{args.host}:{args.port}/ws")
+    print(f"👀 Watching paths: {watch_paths or ['current directory']}")
+    print("Press Ctrl+C to stop the server")
+    print("-" * 50)
+
+    try:
+        serve_logs(
+            host=args.host,
+            port=args.port,
+            watch_paths=watch_paths,
+            reload=args.reload,
+        )
+        return 0
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped by user")
+        return 0
+    except Exception as e:
+        print(f"❌ Error starting server: {e}")
+        return 1

eval_protocol/utils/__init__.py

@@ -6,3 +6,8 @@
 
 # For now, allow direct import of modules like:
 # from eval_protocol.utils.dataset_helpers import ...
+
+# Export ViteServer for easier access
+from .logs_server import LogsServer
+
+__all__ = ["LogsServer"]

eval_protocol/utils/logs_server.py

@@ -0,0 +1,233 @@
+import asyncio
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+from watchdog.events import FileSystemEventHandler, FileSystemEvent
+from watchdog.observers import Observer
+
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+from .vite_server import ViteServer
+
+logger = logging.getLogger(__name__)
+
+
+class FileWatcher(FileSystemEventHandler):
+    """File system watcher that tracks file changes."""
+
+    def __init__(self, websocket_manager):
+        self.websocket_manager = websocket_manager
+        self.ignored_patterns = {
+            ".git",
+            "__pycache__",
+            ".pytest_cache",
+            "node_modules",
+            ".DS_Store",
+            "*.pyc",
+            "*.pyo",
+            "*.pyd",
+            ".coverage",
+            "*.log",
+            "*.tmp",
+            "*.swp",
+            "*.swo",
+            "*~",
+        }
+
+    def should_ignore(self, path: str) -> bool:
+        """Check if a path should be ignored."""
+        path_lower = path.lower()
+        for pattern in self.ignored_patterns:
+            if pattern.startswith("*"):
+                if path_lower.endswith(pattern[1:]):
+                    return True
+            elif pattern in path_lower:
+                return True
+        return False
+
+    def on_created(self, event: FileSystemEvent):
+        if not event.is_directory and not self.should_ignore(event.src_path):
+            self.websocket_manager.broadcast_file_update("file_created", event.src_path)
+
+    def on_modified(self, event: FileSystemEvent):
+        if not event.is_directory and not self.should_ignore(event.src_path):
+            self.websocket_manager.broadcast_file_update("file_changed", event.src_path)
+
+    def on_deleted(self, event: FileSystemEvent):
+        if not event.is_directory and not self.should_ignore(event.src_path):
+            self.websocket_manager.broadcast_file_update("file_deleted", event.src_path)
+
+
+class WebSocketManager:
+    """Manages WebSocket connections and broadcasts messages."""
+
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+        self._loop = None
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
+        logger.info(f"WebSocket connected. Total connections: {len(self.active_connections)}")
+
+    def disconnect(self, websocket: WebSocket):
+        if websocket in self.active_connections:
+            self.active_connections.remove(websocket)
+        logger.info(f"WebSocket disconnected. Total connections: {len(self.active_connections)}")
+
+    def broadcast_file_update(self, update_type: str, file_path: str):
+        """Broadcast file update to all connected clients."""
+        message = {"type": update_type, "path": file_path, "timestamp": time.time()}
+        json_message = json.dumps(message)
+
+        # Broadcast to all active connections
+        for connection in self.active_connections:
+            try:
+                asyncio.run_coroutine_threadsafe(connection.send_text(json_message), self._loop)
+            except Exception as e:
+                logger.error(f"Failed to send message to WebSocket: {e}")
+                # Remove broken connection
+                self.active_connections.remove(connection)
+
+
+class LogsServer(ViteServer):
+    """
+    Enhanced server for serving Vite-built SPA with file watching and WebSocket support.
+
+    This server extends ViteServer to add:
+    - File system watching
+    - WebSocket connections for real-time updates
+    - Live log streaming
+    """
+
+    def __init__(
+        self,
+        build_dir: str = os.path.abspath(
+            os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "vite-app", "dist")
+        ),
+        host: str = "localhost",
+        port: int = 4789,
+        index_file: str = "index.html",
+        watch_paths: Optional[List[str]] = None,
+    ):
+        super().__init__(build_dir, host, port, index_file)
+
+        # Initialize WebSocket manager
+        self.websocket_manager = WebSocketManager()
+
+        # Set up file watching
+        self.watch_paths = watch_paths or [os.getcwd()]
+        self.observer = Observer()
+        self.file_watcher = FileWatcher(self.websocket_manager)
+
+        # Add WebSocket endpoint
+        self._setup_websocket_routes()
+
+        logger.info(f"LogsServer initialized on {host}:{port}")
+        logger.info(f"Watching paths: {self.watch_paths}")
+
+    def _setup_websocket_routes(self):
+        """Set up WebSocket routes for real-time communication."""
+
+        @self.app.websocket("/ws")
+        async def websocket_endpoint(websocket: WebSocket):
+            await self.websocket_manager.connect(websocket)
+            try:
+                while True:
+                    # Keep connection alive
+                    await websocket.receive_text()
+            except WebSocketDisconnect:
+                self.websocket_manager.disconnect(websocket)
+            except Exception as e:
+                logger.error(f"WebSocket error: {e}")
+                self.websocket_manager.disconnect(websocket)
+
+        @self.app.get("/api/status")
+        async def status():
+            """Get server status including active connections."""
+            return {
+                "status": "ok",
+                "build_dir": str(self.build_dir),
+                "active_connections": len(self.websocket_manager.active_connections),
+                "watch_paths": self.watch_paths,
+            }
+
+    def start_file_watching(self):
+        """Start watching file system for changes."""
+        for path in self.watch_paths:
+            if os.path.exists(path):
+                self.observer.schedule(self.file_watcher, path, recursive=True)
+                logger.info(f"Started watching: {path}")
+            else:
+                logger.warning(f"Watch path does not exist: {path}")
+
+        self.observer.start()
+        logger.info("File watching started")
+
+    def stop_file_watching(self):
+        """Stop watching file system."""
+        self.observer.stop()
+        self.observer.join()
+        logger.info("File watching stopped")
+
+    async def run_async(self, reload: bool = False):
+        """
+        Run the logs server asynchronously with file watching.
+
+        Args:
+            reload: Whether to enable auto-reload (default: False)
+        """
+        try:
+            # Start file watching
+            self.start_file_watching()
+
+            logger.info(f"Starting LogsServer on {self.host}:{self.port}")
+            logger.info(f"Serving files from: {self.build_dir}")
+            logger.info("WebSocket endpoint available at /ws")
+
+            # Store the event loop for WebSocket manager
+            self.websocket_manager._loop = asyncio.get_running_loop()
+
+            config = uvicorn.Config(self.app, host=self.host, port=self.port, reload=reload, log_level="info")
+            server = uvicorn.Server(config)
+            await server.serve()
+        except KeyboardInterrupt:
+            logger.info("Shutting down LogsServer...")
+        finally:
+            self.stop_file_watching()
+
+    def run(self, reload: bool = False):
+        """
+        Run the logs server with file watching.
+
+        Args:
+            reload: Whether to enable auto-reload (default: False)
+        """
+        asyncio.run(self.run_async(reload))
+
+
+def serve_logs(
+    host: str = "localhost",
+    port: int = 4789,
+    watch_paths: Optional[List[str]] = None,
+    reload: bool = False,
+):
+    """
+    Convenience function to create and run a LogsServer.
+
+    Args:
+        build_dir: Path to the Vite build output directory
+        host: Host to bind the server to
+        port: Port to bind the server to (default: 4789 for logs)
+        index_file: Name of the main index file
+        watch_paths: List of paths to watch for file changes
+        reload: Whether to enable auto-reload
+    """
+    server = LogsServer(host=host, port=port, watch_paths=watch_paths)
+    server.run(reload=reload)