claude-mpm 5.0.9__py3-none-any.whl → 5.4.41__py3-none-any.whl

claude_mpm/services/monitor/server.py

@@ -15,7 +15,6 @@ DESIGN DECISIONS:
 """
 
 import asyncio
-import contextlib
 import os
 import threading
 import time
@@ -25,10 +24,11 @@ from typing import Dict, Optional
 
 import socketio
 from aiohttp import web
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
 
 from ...core.enums import ServiceState
 from ...core.logging_config import get_logger
-from ...dashboard.api.simple_directory import list_directory
 from .event_emitter import get_event_emitter
 from .handlers.code_analysis import CodeAnalysisHandler
 from .handlers.dashboard import DashboardHandler
@@ -45,6 +45,91 @@ except ImportError:
     EVENTBUS_AVAILABLE = False
 
 
+class SvelteBuildWatcher(FileSystemEventHandler):
+    """File watcher for Svelte build directory changes.
+
+    Watches for file changes in svelte-build directory and triggers
+    hot reload via Socket.IO event emission.
+
+    STABILITY FIX: Added thread lock and stop() method to prevent timer leaks.
+    """
+
+    def __init__(
+        self, sio: socketio.AsyncServer, loop: asyncio.AbstractEventLoop, logger
+    ):
+        """Initialize the file watcher.
+
+        Args:
+            sio: Socket.IO server instance for emitting events
+            loop: Event loop for async operations
+            logger: Logger instance
+        """
+        super().__init__()
+        self.sio = sio
+        self.loop = loop
+        self.logger = logger
+        self.debounce_timer = None
+        self.debounce_delay = 0.5  # Wait 500ms after last change
+        self._timer_lock = threading.Lock()  # STABILITY FIX: Prevent race condition
+
+    def stop(self):
+        """Stop the watcher and cancel any pending timers.
+
+        STABILITY FIX: Ensures timer is cancelled on shutdown.
+        """
+        with self._timer_lock:
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+                self.debounce_timer = None
+
+    def on_any_event(self, event):
+        """Handle any file system event.
+
+        Args:
+            event: File system event from watchdog
+        """
+        # Ignore directory events and temporary files
+        if event.is_directory or event.src_path.endswith((".tmp", ".swp", "~")):
+            return
+
+        self.logger.debug(
+            f"File change detected: {event.event_type} - {event.src_path}"
+        )
+
+        # STABILITY FIX: Use lock to prevent timer race condition
+        with self._timer_lock:
+            # Cancel existing timer
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+
+            # Schedule reload after debounce delay
+            self.debounce_timer = threading.Timer(
+                self.debounce_delay, self._trigger_reload
+            )
+            self.debounce_timer.start()
+
+    def _trigger_reload(self):
+        """Trigger hot reload by emitting Socket.IO event."""
+        try:
+            # Schedule the async emit in the event loop
+            asyncio.run_coroutine_threadsafe(self._emit_reload_event(), self.loop)
+            self.logger.info("Hot reload triggered - Svelte build changed")
+        except Exception as e:
+            self.logger.error(f"Error triggering reload: {e}")
+
+    async def _emit_reload_event(self):
+        """Emit the reload event to all connected clients."""
+        if self.sio:
+            await self.sio.emit(
+                "reload",
+                {
+                    "type": "reload",
+                    "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+                    "reason": "svelte-build-updated",
+                },
+            )
+
+
 class UnifiedMonitorServer:
     """Unified server that combines HTTP dashboard and Socket.IO functionality.
 
@@ -52,15 +137,19 @@ class UnifiedMonitorServer:
     Replaces multiple competing server implementations with one stable solution.
     """
 
-    def __init__(self, host: str = "localhost", port: int = 8765):
+    def __init__(
+        self, host: str = "localhost", port: int = 8765, enable_hot_reload: bool = False
+    ):
         """Initialize the unified monitor server.
 
         Args:
             host: Host to bind to
             port: Port to bind to
+            enable_hot_reload: Enable file watching and hot reload for development
         """
         self.host = host
         self.port = port
+        self.enable_hot_reload = enable_hot_reload
         self.logger = get_logger(__name__)
 
         # Core components
@@ -78,6 +167,10 @@ class UnifiedMonitorServer:
         # High-performance event emitter
         self.event_emitter = None
 
+        # File watching (optional for dev mode)
+        self.file_observer: Optional[Observer] = None
+        self.file_watcher: Optional[SvelteBuildWatcher] = None
+
         # State
         self.running = False
         self.loop = None
@@ -184,6 +277,9 @@ class UnifiedMonitorServer:
 
                         time.sleep(0.1)
 
+                        # STABILITY FIX: Give tasks more time to clean up before closing
+                        time.sleep(0.5)
+
                         # Clear the event loop from the thread BEFORE closing
                         # This prevents other code from accidentally using it
                         asyncio.set_event_loop(None)
@@ -229,6 +325,10 @@ class UnifiedMonitorServer:
             self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
             self.logger.info("Heartbeat task started (3-minute interval)")
 
+            # Setup file watching for hot reload (if enabled)
+            if self.enable_hot_reload:
+                self._setup_file_watcher()
+
             # Setup HTTP routes
             self._setup_http_routes()
 
@@ -304,20 +404,64 @@ class UnifiedMonitorServer:
             self.logger.error(f"Error setting up event emitter: {e}")
             raise
 
+    def _setup_file_watcher(self):
+        """Setup file watcher for Svelte build directory.
+
+        Watches for changes in svelte-build and triggers hot reload.
+        Only enabled when enable_hot_reload is True.
+        """
+        try:
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            svelte_build_dir = dashboard_dir / "static" / "svelte-build"
+
+            if not svelte_build_dir.exists():
+                self.logger.warning(
+                    f"Svelte build directory not found: {svelte_build_dir}. "
+                    "Hot reload disabled."
+                )
+                return
+
+            # Create file watcher with Socket.IO reference
+            self.file_watcher = SvelteBuildWatcher(
+                sio=self.sio, loop=self.loop, logger=self.logger
+            )
+
+            # Create observer and schedule watching
+            self.file_observer = Observer()
+            self.file_observer.schedule(
+                self.file_watcher, str(svelte_build_dir), recursive=True
+            )
+            self.file_observer.start()
+
+            self.logger.info(f"🔥 Hot reload enabled - watching {svelte_build_dir}")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up file watcher: {e}")
+            # Don't raise - hot reload is optional
+
     def _setup_http_routes(self):
         """Setup HTTP routes for the dashboard."""
         try:
-            # Dashboard static files
-            dashboard_dir = Path(__file__).parent.parent.parent / "dashboard"
+            # Dashboard static files - use .resolve() for absolute path
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            static_dir = dashboard_dir / "static"
 
-            # Main dashboard route
+            # Main dashboard route - serve Svelte dashboard
             async def dashboard_index(request):
-                template_path = dashboard_dir / "templates" / "index.html"
-                if template_path.exists():
-                    with template_path.open() as f:
+                svelte_index = static_dir / "svelte-build" / "index.html"
+                if svelte_index.exists():
+                    with svelte_index.open(encoding="utf-8") as f:
                         content = f.read()
                     return web.Response(text=content, content_type="text/html")
-                return web.Response(text="Dashboard not found", status=404)
+
+                # Log error with path details for debugging
+                self.logger.error(
+                    f"Dashboard index.html not found at: {svelte_index.resolve()}"
+                )
+                return web.Response(
+                    text=f"Dashboard not found. Expected location: {svelte_index.resolve()}",
+                    status=404,
+                )
 
             # Health check
             async def health_check(request):
@@ -325,7 +469,8 @@ class UnifiedMonitorServer:
                 version = "1.0.0"
                 try:
                     version_file = (
-                        Path(__file__).parent.parent.parent.parent.parent / "VERSION"
+                        Path(__file__).resolve().parent.parent.parent.parent.parent
+                        / "VERSION"
                     )
                     if version_file.exists():
                         version = version_file.read_text().strip()
@@ -442,6 +587,243 @@ class UnifiedMonitorServer:
                         {"success": False, "error": str(e)}, status=500
                     )
 
+            # File listing endpoint for file browser
+            async def api_files_handler(request):
+                """List files in a directory for the file browser."""
+                try:
+                    # Get path from query param, default to working directory
+                    path = request.query.get("path", str(Path.cwd()))
+                    dir_path = Path(path)
+
+                    if not dir_path.exists():
+                        return web.json_response(
+                            {"success": False, "error": "Directory not found"},
+                            status=404,
+                        )
+
+                    if not dir_path.is_dir():
+                        return web.json_response(
+                            {"success": False, "error": "Path is not a directory"},
+                            status=400,
+                        )
+
+                    # Patterns to exclude
+                    exclude_patterns = {
+                        ".git",
+                        "node_modules",
+                        "__pycache__",
+                        ".svelte-kit",
+                        "venv",
+                        ".venv",
+                        "dist",
+                        "build",
+                        ".next",
+                        ".cache",
+                        ".pytest_cache",
+                        ".mypy_cache",
+                        ".ruff_cache",
+                        "eggs",
+                        "*.egg-info",
+                        ".tox",
+                        ".nox",
+                        "htmlcov",
+                        ".coverage",
+                    }
+
+                    entries = []
+                    try:
+                        for entry in sorted(
+                            dir_path.iterdir(),
+                            key=lambda x: (not x.is_dir(), x.name.lower()),
+                        ):
+                            # Skip hidden files and excluded patterns
+                            if entry.name.startswith(".") and entry.name not in {
+                                ".env",
+                                ".gitignore",
+                            }:
+                                if entry.name in {".git", ".svelte-kit", ".cache"}:
+                                    continue
+                            if entry.name in exclude_patterns:
+                                continue
+                            if any(
+                                entry.name.endswith(p.replace("*", ""))
+                                for p in exclude_patterns
+                                if "*" in p
+                            ):
+                                continue
+
+                            try:
+                                stat = entry.stat()
+                                entries.append(
+                                    {
+                                        "name": entry.name,
+                                        "path": str(entry),
+                                        "type": "directory"
+                                        if entry.is_dir()
+                                        else "file",
+                                        "size": stat.st_size if entry.is_file() else 0,
+                                        "modified": stat.st_mtime,
+                                        "extension": entry.suffix.lstrip(".")
+                                        if entry.is_file()
+                                        else None,
+                                    }
+                                )
+                            except (PermissionError, OSError):
+                                continue
+
+                    except PermissionError:
+                        return web.json_response(
+                            {"success": False, "error": "Permission denied"},
+                            status=403,
+                        )
+
+                    # Separate directories and files
+                    directories = [e for e in entries if e["type"] == "directory"]
+                    files = [e for e in entries if e["type"] == "file"]
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "path": str(dir_path),
+                            "directories": directories,
+                            "files": files,
+                            "total_directories": len(directories),
+                            "total_files": len(files),
+                        }
+                    )
+
+                except Exception as e:
+                    self.logger.error(f"Error listing directory: {e}")
+                    return web.json_response(
+                        {"success": False, "error": str(e)}, status=500
+                    )
+
+            # File read endpoint (GET) for file browser
+            async def api_file_read_handler(request):
+                """Read file content via GET request."""
+                import base64
+
+                try:
+                    file_path = request.query.get("path", "")
+
+                    if not file_path:
+                        return web.json_response(
+                            {"success": False, "error": "Path parameter required"},
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+
+                    if not path.exists():
+                        return web.json_response(
+                            {"success": False, "error": "File not found"},
+                            status=404,
+                        )
+
+                    if not path.is_file():
+                        return web.json_response(
+                            {"success": False, "error": "Path is not a file"},
+                            status=400,
+                        )
+
+                    # Get file info
+                    file_size = path.stat().st_size
+                    file_ext = path.suffix.lstrip(".").lower()
+
+                    # Define image extensions
+                    image_extensions = {
+                        "png",
+                        "jpg",
+                        "jpeg",
+                        "gif",
+                        "svg",
+                        "webp",
+                        "ico",
+                        "bmp",
+                    }
+
+                    # Check if file is an image
+                    if file_ext in image_extensions:
+                        # Read as binary and encode to base64
+                        try:
+                            binary_content = path.read_bytes()
+                            base64_content = base64.b64encode(binary_content).decode(
+                                "utf-8"
+                            )
+
+                            # Map extension to MIME type
+                            mime_types = {
+                                "png": "image/png",
+                                "jpg": "image/jpeg",
+                                "jpeg": "image/jpeg",
+                                "gif": "image/gif",
+                                "svg": "image/svg+xml",
+                                "webp": "image/webp",
+                                "ico": "image/x-icon",
+                                "bmp": "image/bmp",
+                            }
+                            mime_type = mime_types.get(file_ext, "image/png")
+
+                            return web.json_response(
+                                {
+                                    "success": True,
+                                    "path": str(path),
+                                    "content": base64_content,
+                                    "size": file_size,
+                                    "type": "image",
+                                    "mime": mime_type,
+                                    "extension": file_ext,
+                                }
+                            )
+                        except Exception as e:
+                            self.logger.error(f"Error reading image file: {e}")
+                            return web.json_response(
+                                {
+                                    "success": False,
+                                    "error": f"Failed to read image: {e!s}",
+                                },
+                                status=500,
+                            )
+
+                    # Read text file content
+                    try:
+                        content = path.read_text(encoding="utf-8")
+                        lines = content.count("\n") + 1
+                    except UnicodeDecodeError:
+                        return web.json_response(
+                            {"success": False, "error": "File is not a text file"},
+                            status=415,
+                        )
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "path": str(path),
+                            "content": content,
+                            "lines": lines,
+                            "size": file_size,
+                            "type": file_ext or "text",
+                        }
+                    )
+
+                except Exception as e:
+                    self.logger.error(f"Error reading file: {e}")
+                    return web.json_response(
+                        {"success": False, "error": str(e)}, status=500
+                    )
+
+            # Favicon handler
+            async def favicon_handler(request):
+                """Serve favicon.svg from static directory."""
+                from aiohttp.web_fileresponse import FileResponse
+
+                favicon_path = static_dir / "svelte-build" / "favicon.svg"
+                if favicon_path.exists():
+                    return FileResponse(
+                        favicon_path, headers={"Content-Type": "image/svg+xml"}
+                    )
+                raise web.HTTPNotFound()
+
             # Version endpoint for dashboard build tracker
             async def version_handler(request):
                 """Serve version information for dashboard build tracker."""
@@ -507,7 +889,7 @@ class UnifiedMonitorServer:
             async def working_directory_handler(request):
                 """Return the current working directory."""
                 return web.json_response(
-                    {"working_directory": Path.cwd(), "success": True}
+                    {"working_directory": str(Path.cwd()), "success": True}
                 )
 
             # Monitor page routes
@@ -525,15 +907,249 @@ class UnifiedMonitorServer:
                     return web.Response(text=content, content_type="text/html")
                 return web.Response(text="Page not found", status=404)
 
+            # Git history handler
+            async def git_history_handler(request: web.Request) -> web.Response:
+                """Get git history for a file."""
+                import subprocess
+
+                try:
+                    data = await request.json()
+                    file_path = data.get("path", "")
+                    limit = data.get("limit", 10)
+
+                    if not file_path:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "No path provided",
+                                "commits": [],
+                            },
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+                    if not path.exists():
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "File not found",
+                                "commits": [],
+                            },
+                            status=404,
+                        )
+
+                    # Get git log for file
+                    result = subprocess.run(
+                        [
+                            "git",
+                            "log",
+                            f"-{limit}",
+                            "--pretty=format:%H|%an|%ar|%s",
+                            "--",
+                            str(path),
+                        ],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(path.parent),
+                    )
+
+                    commits = []
+                    if result.returncode == 0 and result.stdout:
+                        for line in result.stdout.strip().split("\n"):
+                            if line:
+                                parts = line.split("|", 3)
+                                if len(parts) == 4:
+                                    commits.append(
+                                        {
+                                            "hash": parts[0][:7],
+                                            "author": parts[1],
+                                            "date": parts[2],
+                                            "message": parts[3],
+                                        }
+                                    )
+
+                    return web.json_response({"success": True, "commits": commits})
+                except Exception as e:
+                    return web.json_response(
+                        {"success": False, "error": str(e), "commits": []}, status=500
+                    )
+
+            # Git diff handler
+            async def git_diff_handler(request: web.Request) -> web.Response:
+                """Get git diff for a file with optional commit selection."""
+                import subprocess
+
+                try:
+                    file_path = request.query.get("path", "")
+                    commit_hash = request.query.get(
+                        "commit", ""
+                    )  # Optional commit hash
+
+                    if not file_path:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "No path provided",
+                                "diff": "",
+                                "has_changes": False,
+                            },
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+                    if not path.exists():
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "File not found",
+                                "diff": "",
+                                "has_changes": False,
+                            },
+                            status=404,
+                        )
+
+                    # Find git repository root
+                    git_root_result = subprocess.run(
+                        ["git", "rev-parse", "--show-toplevel"],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(path.parent),
+                    )
+
+                    if git_root_result.returncode != 0:
+                        # Not in a git repository
+                        return web.json_response(
+                            {
+                                "success": True,
+                                "diff": "",
+                                "has_changes": False,
+                                "tracked": False,
+                                "history": [],
+                                "has_uncommitted": False,
+                            }
+                        )
+
+                    git_root = Path(git_root_result.stdout.strip())
+
+                    # Check if file is tracked by git
+                    ls_files_result = subprocess.run(
+                        ["git", "ls-files", "--error-unmatch", str(path)],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    if ls_files_result.returncode != 0:
+                        # File is not tracked by git
+                        return web.json_response(
+                            {
+                                "success": True,
+                                "diff": "",
+                                "has_changes": False,
+                                "tracked": False,
+                                "history": [],
+                                "has_uncommitted": False,
+                            }
+                        )
+
+                    # Get commit history for this file (last 5 commits)
+                    history_result = subprocess.run(
+                        [
+                            "git",
+                            "log",
+                            "-5",
+                            "--pretty=format:%H|%s|%ar",
+                            "--",
+                            str(path),
+                        ],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    history = []
+                    if history_result.returncode == 0 and history_result.stdout:
+                        for line in history_result.stdout.strip().split("\n"):
+                            if line:
+                                parts = line.split("|", 2)
+                                if len(parts) == 3:
+                                    history.append(
+                                        {
+                                            "hash": parts[0][:7],  # Short hash
+                                            "full_hash": parts[0],  # Full hash for API
+                                            "message": parts[1],
+                                            "time_ago": parts[2],
+                                        }
+                                    )
+
+                    # Check for uncommitted changes
+                    uncommitted_result = subprocess.run(
+                        ["git", "diff", "HEAD", str(path)],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    has_uncommitted = bool(uncommitted_result.stdout.strip())
+
+                    # Get diff based on commit parameter
+                    if commit_hash:
+                        # Get diff for specific commit
+                        result = subprocess.run(
+                            ["git", "show", commit_hash, "--", str(path)],
+                            check=False,
+                            capture_output=True,
+                            text=True,
+                            cwd=str(git_root),
+                        )
+                        diff_output = result.stdout if result.returncode == 0 else ""
+                        has_changes = bool(diff_output.strip())
+                    else:
+                        # Get uncommitted diff (default behavior)
+                        diff_output = uncommitted_result.stdout
+                        has_changes = has_uncommitted
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "diff": diff_output,
+                            "has_changes": has_changes,
+                            "tracked": True,
+                            "history": history,
+                            "has_uncommitted": has_uncommitted,
+                        }
+                    )
+                except Exception as e:
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": str(e),
+                            "diff": "",
+                            "has_changes": False,
+                            "history": [],
+                            "has_uncommitted": False,
+                        },
+                        status=500,
+                    )
+
             # Register routes
             self.app.router.add_get("/", dashboard_index)
+            self.app.router.add_get("/favicon.svg", favicon_handler)
             self.app.router.add_get("/health", health_check)
             self.app.router.add_get("/version.json", version_handler)
             self.app.router.add_get("/api/config", config_handler)
             self.app.router.add_get("/api/working-directory", working_directory_handler)
-            self.app.router.add_get("/api/directory", list_directory)
+            self.app.router.add_get("/api/files", api_files_handler)
+            self.app.router.add_get("/api/file/read", api_file_read_handler)
+            self.app.router.add_get("/api/file/diff", git_diff_handler)
             self.app.router.add_post("/api/events", api_events_handler)
             self.app.router.add_post("/api/file", api_file_handler)
+            self.app.router.add_post("/api/git-history", git_history_handler)
 
             # Monitor page routes
             self.app.router.add_get("/monitor", lambda r: monitor_page_handler(r))
@@ -546,12 +1162,43 @@ class UnifiedMonitorServer:
                 "/monitor/events", lambda r: monitor_page_handler(r)
             )
 
-            # Static files with cache busting headers for development
-            static_dir = dashboard_dir / "static"
+            # Serve Svelte _app assets (compiled JS/CSS)
+            svelte_build_dir = static_dir / "svelte-build"
+            if svelte_build_dir.exists():
+                svelte_app_dir = svelte_build_dir / "_app"
+                if svelte_app_dir.exists():
+                    # Serve _app assets with proper caching
+                    async def app_assets_handler(request):
+                        """Serve Svelte _app assets."""
+                        from aiohttp.web_fileresponse import FileResponse
+
+                        rel_path = request.match_info["filepath"]
+                        file_path = svelte_app_dir / rel_path
+
+                        if not file_path.exists() or not file_path.is_file():
+                            raise web.HTTPNotFound()
+
+                        response = FileResponse(file_path)
+
+                        # Add cache headers for immutable assets
+                        if "/immutable/" in str(rel_path):
+                            response.headers["Cache-Control"] = (
+                                "public, max-age=31536000, immutable"
+                            )
+                        else:
+                            response.headers["Cache-Control"] = (
+                                "no-cache, no-store, must-revalidate"
+                            )
+
+                        return response
+
+                    self.app.router.add_get("/_app/{filepath:.*}", app_assets_handler)
+
+            # Legacy static files (for backward compatibility)
             if static_dir.exists():
 
                 async def static_handler(request):
-                    """Serve static files with cache-control headers for development."""
+                    """Serve legacy static files with cache-control headers for development."""
 
                     from aiohttp.web_fileresponse import FileResponse
 
@@ -576,10 +1223,13 @@ class UnifiedMonitorServer:
 
                 self.app.router.add_get("/static/{filepath:.*}", static_handler)
 
-            # Templates
-            templates_dir = dashboard_dir / "templates"
-            if templates_dir.exists():
-                self.app.router.add_static("/templates/", templates_dir)
+            # Log dashboard availability
+            if svelte_build_dir.exists():
+                self.logger.info(
+                    f"✅ Svelte dashboard available at / (root) (build: {svelte_build_dir})"
+                )
+            else:
+                self.logger.warning(f"Svelte build not found at: {svelte_build_dir}")
 
             self.logger.info("HTTP routes registered successfully")
 
@@ -691,11 +1341,37 @@ class UnifiedMonitorServer:
     async def _cleanup_async(self):
         """Cleanup async resources."""
         try:
+            # Stop file observer if running
+            # STABILITY FIX: Ensure watcher is stopped and verify observer termination
+            if self.file_observer:
+                try:
+                    # Stop the watcher first to cancel pending timers
+                    if self.file_watcher:
+                        self.file_watcher.stop()
+
+                    # Stop the observer
+                    self.file_observer.stop()
+                    self.file_observer.join(timeout=2)
+
+                    # Verify observer actually stopped
+                    if self.file_observer.is_alive():
+                        self.logger.warning("File observer did not stop cleanly")
+
+                    self.logger.debug("File observer stopped")
+                except Exception as e:
+                    self.logger.debug(f"Error stopping file observer: {e}")
+                finally:
+                    self.file_observer = None
+                    self.file_watcher = None
+
             # Cancel heartbeat task if running
+            # STABILITY FIX: Add timeout to prevent infinite wait on cancellation
             if self.heartbeat_task and not self.heartbeat_task.done():
                 self.heartbeat_task.cancel()
-                with contextlib.suppress(asyncio.CancelledError):
-                    await self.heartbeat_task
+                try:
+                    await asyncio.wait_for(self.heartbeat_task, timeout=2.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
                 self.logger.debug("Heartbeat task cancelled")
 
             # Close the Socket.IO server first to stop accepting new connections