fbuild 1.2.8__py3-none-any.whl → 1.2.15__py3-none-any.whl

fbuild/daemon/daemon.py

@@ -19,6 +19,7 @@ Architecture:
 """
 
 import _thread
+import json
 import logging
 import multiprocessing
 import os
@@ -27,11 +28,14 @@ import subprocess
 import sys
 import threading
 import time
+from dataclasses import dataclass, field
 from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
+from typing import Any, Callable, TypeVar
 
 import psutil
 
+from fbuild.daemon.connection_registry import ConnectionRegistry
 from fbuild.daemon.daemon_context import (
     DaemonContext,
     cleanup_daemon_context,
@@ -50,6 +54,9 @@ from fbuild.daemon.processors.deploy_processor import DeployRequestProcessor
 from fbuild.daemon.processors.install_deps_processor import InstallDependenciesProcessor
 from fbuild.daemon.processors.monitor_processor import MonitorRequestProcessor
 
+# Type variable for request types
+RequestT = TypeVar("RequestT", BuildRequest, DeployRequest, MonitorRequest, InstallDependenciesRequest)
+
 # Daemon configuration
 DAEMON_NAME = "fbuild_daemon"
 
@@ -70,10 +77,76 @@ INSTALL_DEPS_REQUEST_FILE = DAEMON_DIR / "install_deps_request.json"
 LOG_FILE = DAEMON_DIR / "daemon.log"
 PROCESS_REGISTRY_FILE = DAEMON_DIR / "process_registry.json"
 FILE_CACHE_FILE = DAEMON_DIR / "file_cache.json"
+
+# Device management request/response files
+DEVICE_LIST_REQUEST_FILE = DAEMON_DIR / "device_list_request.json"
+DEVICE_LIST_RESPONSE_FILE = DAEMON_DIR / "device_list_response.json"
+DEVICE_STATUS_REQUEST_FILE = DAEMON_DIR / "device_status_request.json"
+DEVICE_STATUS_RESPONSE_FILE = DAEMON_DIR / "device_status_response.json"
+DEVICE_LEASE_REQUEST_FILE = DAEMON_DIR / "device_lease_request.json"
+DEVICE_LEASE_RESPONSE_FILE = DAEMON_DIR / "device_lease_response.json"
+DEVICE_RELEASE_REQUEST_FILE = DAEMON_DIR / "device_release_request.json"
+DEVICE_RELEASE_RESPONSE_FILE = DAEMON_DIR / "device_release_response.json"
+DEVICE_PREEMPT_REQUEST_FILE = DAEMON_DIR / "device_preempt_request.json"
+DEVICE_PREEMPT_RESPONSE_FILE = DAEMON_DIR / "device_preempt_response.json"
+
+# Connection management file patterns
+CONNECTION_FILES_PATTERN = "connect_*.json"
+HEARTBEAT_FILES_PATTERN = "heartbeat_*.json"
+DISCONNECT_FILES_PATTERN = "disconnect_*.json"
+
 ORPHAN_CHECK_INTERVAL = 5  # Check for orphaned processes every 5 seconds
 STALE_LOCK_CHECK_INTERVAL = 60  # Check for stale locks every 60 seconds
 DEAD_CLIENT_CHECK_INTERVAL = 10  # Check for dead clients every 10 seconds
-IDLE_TIMEOUT = 43200  # 12 hours
+IDLE_TIMEOUT = 43200  # 12 hours (fallback)
+# Self-eviction timeout: if daemon has 0 clients AND 0 ops for this duration, shutdown
+# Per TASK.md: "If daemon has 0 clients AND 0 running operations, immediately evict the daemon within 4 seconds."
+SELF_EVICTION_TIMEOUT = 4.0  # 4 seconds
+
+
+@dataclass
+class RequestConfig:
+    """Configuration for a request type in the daemon loop."""
+
+    request_file: Path
+    request_class: type
+    processor: Any
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+
+@dataclass
+class DeviceRequestConfig:
+    """Configuration for a device management request."""
+
+    request_file: Path
+    response_file: Path
+    handler: Callable[[dict[str, Any], DaemonContext], dict[str, Any]]
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+
+@dataclass
+class PeriodicTask:
+    """Configuration for a periodic daemon task."""
+
+    name: str
+    interval: float
+    callback: Callable[[], None]
+    last_run: float = 0.0
+
+    def should_run(self) -> bool:
+        """Check if enough time has passed since last run."""
+        return time.time() - self.last_run >= self.interval
+
+    def run(self) -> None:
+        """Execute the task and update last run time."""
+        try:
+            self.callback()
+            self.last_run = time.time()
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
+        except Exception as e:
+            logging.error(f"Error in periodic task '{self.name}': {e}", exc_info=True)
 
 
 def setup_logging(foreground: bool = False) -> None:
@@ -111,29 +184,23 @@ def setup_logging(foreground: bool = False) -> None:
     logger.addHandler(file_handler)
 
 
-def read_request_file(request_file: Path, request_class: type) -> BuildRequest | DeployRequest | MonitorRequest | None:
+def read_request_file(request_file: Path, request_class: type[RequestT]) -> RequestT | None:
     """Read and parse request file.
 
     Args:
         request_file: Path to request file
-        request_class: Class to parse into (BuildRequest, DeployRequest, or MonitorRequest)
+        request_class: Class to parse into (BuildRequest, DeployRequest, MonitorRequest, or InstallDependenciesRequest)
 
     Returns:
         Request object if valid, None otherwise
     """
-    import json
-
     if not request_file.exists():
         return None
 
     try:
         with open(request_file) as f:
             data = json.load(f)
-
-        # Parse into typed request
-        request = request_class.from_dict(data)
-        return request
-
+        return request_class.from_dict(data)
     except (json.JSONDecodeError, ValueError, TypeError) as e:
         logging.error(f"Failed to parse request file {request_file}: {e}")
         return None
@@ -253,6 +320,303 @@ def cleanup_and_exit(context: DaemonContext) -> None:
     sys.exit(0)
 
 
+def handle_device_request(config: DeviceRequestConfig, context: DaemonContext) -> bool:
+    """Handle a device request file if it exists.
+
+    Args:
+        config: Device request configuration
+        context: Daemon context
+
+    Returns:
+        True if a request was processed, False otherwise
+    """
+    if not config.request_file.exists():
+        return False
+
+    try:
+        with open(config.request_file) as f:
+            request_data = json.load(f)
+
+        # Clear request file immediately (atomic consumption)
+        config.request_file.unlink(missing_ok=True)
+
+        # Process request
+        response_data = config.handler(request_data, context)
+
+        # Write response atomically
+        temp_file = config.response_file.with_suffix(".tmp")
+        with open(temp_file, "w") as f:
+            json.dump(response_data, f, indent=2)
+        temp_file.replace(config.response_file)
+
+        return True
+
+    except json.JSONDecodeError as e:
+        logging.error(f"Invalid JSON in request file {config.request_file}: {e}")
+        config.request_file.unlink(missing_ok=True)
+        return False
+    except KeyboardInterrupt:
+        _thread.interrupt_main()
+        raise
+    except Exception as e:
+        logging.error(f"Error handling device request {config.request_file}: {e}")
+        try:
+            with open(config.response_file, "w") as f:
+                json.dump({"success": False, "message": str(e)}, f)
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
+        except Exception:
+            pass
+        return False
+
+
+def handle_device_list_request(request_data: dict[str, Any], context: DaemonContext) -> dict[str, Any]:
+    """Handle device list request."""
+    refresh = request_data.get("refresh", False)
+
+    if refresh:
+        context.device_manager.refresh_devices()
+
+    devices = context.device_manager.get_all_devices()
+    device_list = []
+
+    for device_id, state in devices.items():
+        device_list.append(
+            {
+                "device_id": device_id,
+                "port": state.device_info.port,
+                "is_connected": state.is_connected,
+                "exclusive_holder": (state.exclusive_lease.client_id if state.exclusive_lease else None),
+                "monitor_count": len(state.monitor_leases),
+            }
+        )
+
+    logging.info(f"Device list request processed: {len(device_list)} devices")
+    return {"success": True, "devices": device_list}
+
+
+def handle_device_status_request(request_data: dict[str, Any], context: DaemonContext) -> dict[str, Any]:
+    """Handle device status request."""
+    device_id = request_data.get("device_id")
+    if not device_id:
+        return {"success": False, "message": "device_id is required"}
+
+    status = context.device_manager.get_device_status(device_id)
+    if not status.get("exists", False):
+        return {"success": False, "message": f"Device {device_id} not found"}
+
+    logging.info(f"Device status request processed for {device_id}")
+    return {"success": True, **status}
+
+
+def handle_device_lease_request(request_data: dict[str, Any], context: DaemonContext) -> dict[str, Any]:
+    """Handle device lease request."""
+    device_id = request_data.get("device_id")
+    lease_type = request_data.get("lease_type", "exclusive")
+    description = request_data.get("description", "")
+    # Generate a client ID for file-based IPC clients (they don't have a persistent connection)
+    client_id = request_data.get("client_id", f"file-ipc-{time.time()}")
+
+    if not device_id:
+        return {"success": False, "message": "device_id is required"}
+
+    if lease_type == "monitor":
+        lease = context.device_manager.acquire_monitor(
+            device_id=device_id,
+            client_id=client_id,
+            description=description,
+        )
+    else:
+        lease = context.device_manager.acquire_exclusive(
+            device_id=device_id,
+            client_id=client_id,
+            description=description,
+        )
+
+    if lease is None:
+        return {
+            "success": False,
+            "message": f"Failed to acquire {lease_type} lease on {device_id}",
+        }
+
+    logging.info(f"Device lease acquired: {lease_type} on {device_id} (lease_id={lease.lease_id})")
+    return {"success": True, "lease_id": lease.lease_id, "client_id": client_id}
+
+
+def handle_device_release_request(request_data: dict[str, Any], context: DaemonContext) -> dict[str, Any]:
+    """Handle device release request."""
+    device_id = request_data.get("device_id")
+    client_id = request_data.get("client_id")
+
+    if not device_id:
+        return {"success": False, "message": "device_id is required"}
+
+    # If device_id looks like a UUID, it might be a lease_id
+    # Try to find the actual device and release by client
+    state = context.device_manager.get_device(device_id)
+
+    if state is None:
+        # Try looking up by lease_id
+        return {"success": False, "message": f"Device {device_id} not found"}
+
+    # If client_id not provided, try to release any lease on this device
+    # This is a simplification for file-based IPC where we don't track clients persistently
+    if state.exclusive_lease:
+        actual_client_id = client_id if client_id else state.exclusive_lease.client_id
+        result = context.device_manager.release_lease(state.exclusive_lease.lease_id, actual_client_id)
+        if result:
+            logging.info(f"Released exclusive lease on {device_id}")
+            return {"success": True, "message": f"Released exclusive lease on {device_id}"}
+
+    return {"success": False, "message": f"No lease found to release on {device_id}"}
+
+
+def handle_device_preempt_request(request_data: dict[str, Any], context: DaemonContext) -> dict[str, Any]:
+    """Handle device preempt request."""
+    device_id = request_data.get("device_id")
+    reason = request_data.get("reason", "")
+    client_id = request_data.get("client_id", f"file-ipc-{time.time()}")
+
+    if not device_id:
+        return {"success": False, "message": "device_id is required"}
+
+    if not reason:
+        return {"success": False, "message": "reason is required for preemption"}
+
+    try:
+        success, preempted_client_id = context.device_manager.preempt_device(
+            device_id=device_id,
+            requesting_client_id=client_id,
+            reason=reason,
+        )
+
+        if success:
+            # Get the new lease info
+            state = context.device_manager.get_device(device_id)
+            lease_id = state.exclusive_lease.lease_id if state and state.exclusive_lease else None
+
+            logging.info(f"Device {device_id} preempted from {preempted_client_id} by {client_id}")
+            return {
+                "success": True,
+                "preempted_client_id": preempted_client_id,
+                "lease_id": lease_id,
+                "client_id": client_id,
+            }
+        else:
+            return {"success": False, "message": f"Failed to preempt device {device_id}"}
+
+    except KeyboardInterrupt:
+        _thread.interrupt_main()
+        raise
+    except Exception as e:
+        logging.error(f"Error during device preemption: {e}")
+        return {"success": False, "message": str(e)}
+
+
+def process_operation_request(config: RequestConfig, context: DaemonContext) -> bool:
+    """Process an operation request if one exists.
+
+    Atomically consumes the request file and processes it.
+
+    Args:
+        config: Request configuration (file, class, processor, lock)
+        context: Daemon context
+
+    Returns:
+        True if a request was processed, False otherwise
+    """
+    # Atomically read and clear request file under lock
+    with config.lock:
+        request = read_request_file(config.request_file, config.request_class)
+        if request:
+            clear_request_file(config.request_file)
+
+    if not request:
+        return False
+
+    logging.info(f"Received {config.request_class.__name__}: {request}")
+
+    # Mark operation in progress
+    context.status_manager.set_operation_in_progress(True)
+    try:
+        config.processor.process_request(request, context)
+    finally:
+        context.status_manager.set_operation_in_progress(False)
+
+    return True
+
+
+def process_connection_files(registry: ConnectionRegistry, daemon_dir: Path) -> None:
+    """Process connection/heartbeat/disconnect files from clients."""
+    # Process connect files
+    for connect_file in daemon_dir.glob("connect_*.json"):
+        try:
+            with open(connect_file) as f:
+                data = json.load(f)
+
+            # Extract connection ID from filename
+            conn_id = connect_file.stem.replace("connect_", "")
+
+            # Register the connection
+            registry.register_connection(
+                connection_id=data.get("client_id", conn_id),
+                project_dir=data.get("project_dir", ""),
+                environment=data.get("environment", ""),
+                platform=data.get("platform", ""),
+                client_pid=data.get("pid", 0),
+                client_hostname=data.get("hostname", ""),
+                client_version=data.get("version", ""),
+            )
+
+            # Remove processed file
+            connect_file.unlink(missing_ok=True)
+            logging.info(f"Registered connection from {data.get('hostname')} pid={data.get('pid')}")
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
+        except Exception as e:
+            logging.error(f"Error processing connect file {connect_file}: {e}")
+            connect_file.unlink(missing_ok=True)
+
+    # Process heartbeat files
+    for heartbeat_file in daemon_dir.glob("heartbeat_*.json"):
+        try:
+            with open(heartbeat_file) as f:
+                data = json.load(f)
+
+            conn_id = data.get("client_id", heartbeat_file.stem.replace("heartbeat_", ""))
+            registry.update_heartbeat(conn_id)
+
+            # Remove processed file
+            heartbeat_file.unlink(missing_ok=True)
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
+        except Exception as e:
+            logging.debug(f"Error processing heartbeat file {heartbeat_file}: {e}")
+            heartbeat_file.unlink(missing_ok=True)
+
+    # Process disconnect files
+    for disconnect_file in daemon_dir.glob("disconnect_*.json"):
+        try:
+            with open(disconnect_file) as f:
+                data = json.load(f)
+
+            conn_id = data.get("client_id", disconnect_file.stem.replace("disconnect_", ""))
+            registry.unregister_connection(conn_id)
+
+            # Remove processed file
+            disconnect_file.unlink(missing_ok=True)
+            logging.info(f"Unregistered connection {conn_id} (reason: {data.get('reason', 'unknown')})")
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
+        except Exception as e:
+            logging.error(f"Error processing disconnect file {disconnect_file}: {e}")
+            disconnect_file.unlink(missing_ok=True)
+
+
 def run_daemon_loop() -> None:
     """Main daemon loop: process build, deploy and monitor requests."""
     daemon_pid = os.getpid()
@@ -276,9 +640,20 @@ def run_daemon_loop() -> None:
         status_file_path=STATUS_FILE,
     )
 
+    # Create connection registry for file-based client connection tracking
+    connection_registry = ConnectionRegistry(heartbeat_timeout=30.0)
+
     # Write initial IDLE status IMMEDIATELY to prevent clients from reading stale status
     context.status_manager.update_status(DaemonState.IDLE, "Daemon starting...")
 
+    # Start async server in background thread for real-time client communication
+    if context.async_server is not None:
+        logging.info("Starting async server in background thread...")
+        context.async_server.start_in_background()
+        logging.info("Async server started successfully")
+    else:
+        logging.warning("Async server not available, clients will use file-based IPC only")
+
     # Initialize process tracker
     process_tracker = ProcessTracker(PROCESS_REGISTRY_FILE)
 
@@ -289,30 +664,70 @@ def run_daemon_loop() -> None:
     signal.signal(signal.SIGTERM, signal_handler_wrapper)
     signal.signal(signal.SIGINT, signal_handler_wrapper)
 
-    # Create request processors
-    build_processor = BuildRequestProcessor()
-    deploy_processor = DeployRequestProcessor()
-    install_deps_processor = InstallDependenciesProcessor()
-    monitor_processor = MonitorRequestProcessor()
+    # Configure operation request processors
+    operation_requests = [
+        RequestConfig(BUILD_REQUEST_FILE, BuildRequest, BuildRequestProcessor()),
+        RequestConfig(DEPLOY_REQUEST_FILE, DeployRequest, DeployRequestProcessor()),
+        RequestConfig(MONITOR_REQUEST_FILE, MonitorRequest, MonitorRequestProcessor()),
+        RequestConfig(INSTALL_DEPS_REQUEST_FILE, InstallDependenciesRequest, InstallDependenciesProcessor()),
+    ]
+
+    # Configure device request handlers
+    device_requests = [
+        DeviceRequestConfig(DEVICE_LIST_REQUEST_FILE, DEVICE_LIST_RESPONSE_FILE, handle_device_list_request),
+        DeviceRequestConfig(DEVICE_STATUS_REQUEST_FILE, DEVICE_STATUS_RESPONSE_FILE, handle_device_status_request),
+        DeviceRequestConfig(DEVICE_LEASE_REQUEST_FILE, DEVICE_LEASE_RESPONSE_FILE, handle_device_lease_request),
+        DeviceRequestConfig(DEVICE_RELEASE_REQUEST_FILE, DEVICE_RELEASE_RESPONSE_FILE, handle_device_release_request),
+        DeviceRequestConfig(DEVICE_PREEMPT_REQUEST_FILE, DEVICE_PREEMPT_RESPONSE_FILE, handle_device_preempt_request),
+    ]
 
     logging.info(f"Daemon started with PID {daemon_pid}")
     context.status_manager.update_status(DaemonState.IDLE, "Daemon ready")
 
     last_activity = time.time()
-    last_orphan_check = time.time()
-    last_cancel_cleanup = time.time()
-    last_stale_lock_check = time.time()
-    last_dead_client_check = time.time()
+    daemon_empty_since: float | None = None
+
+    # Define periodic task callbacks
+    def cleanup_orphans() -> None:
+        orphaned_clients = process_tracker.cleanup_orphaned_processes()
+        if orphaned_clients:
+            logging.info(f"Cleaned up orphaned processes for {len(orphaned_clients)} dead clients: {orphaned_clients}")
+
+    def cleanup_cancel_signals() -> None:
+        cleanup_stale_cancel_signals()
+
+    def cleanup_dead_clients() -> None:
+        dead_clients = context.client_manager.cleanup_dead_clients()
+        if dead_clients:
+            logging.info(f"Cleaned up {len(dead_clients)} dead clients: {dead_clients}")
+
+    def cleanup_stale_locks() -> None:
+        stale_locks = context.lock_manager.get_stale_locks()
+        stale_count = len(stale_locks["port_locks"]) + len(stale_locks["project_locks"])
+        if stale_count > 0:
+            logging.warning(f"Found {stale_count} stale locks, force-releasing...")
+            released = context.lock_manager.force_release_stale_locks()
+            logging.info(f"Force-released {released} stale locks")
+        context.lock_manager.cleanup_unused_locks()
+
+    def process_connections() -> None:
+        process_connection_files(connection_registry, DAEMON_DIR)
+        cleaned = connection_registry.cleanup_stale_connections()
+        if cleaned > 0:
+            logging.info(f"Cleaned up {cleaned} stale connections")
+
+    # Configure periodic tasks
+    periodic_tasks = [
+        PeriodicTask("orphan_cleanup", ORPHAN_CHECK_INTERVAL, cleanup_orphans),
+        PeriodicTask("cancel_signal_cleanup", 60, cleanup_cancel_signals),
+        PeriodicTask("dead_client_cleanup", DEAD_CLIENT_CHECK_INTERVAL, cleanup_dead_clients),
+        PeriodicTask("stale_lock_cleanup", STALE_LOCK_CHECK_INTERVAL, cleanup_stale_locks),
+        PeriodicTask("connection_processing", 2, process_connections),
+    ]
 
     logging.info("Entering main daemon loop...")
     iteration_count = 0
 
-    # Locks for atomic request consumption
-    build_request_lock = threading.Lock()
-    deploy_request_lock = threading.Lock()
-    install_deps_request_lock = threading.Lock()
-    monitor_request_lock = threading.Lock()
-
     while True:
         try:
             iteration_count += 1
@@ -330,29 +745,26 @@ def run_daemon_loop() -> None:
                 logging.info(f"Idle timeout reached ({idle_time:.1f}s / {IDLE_TIMEOUT}s), shutting down")
                 cleanup_and_exit(context)
 
-            # Periodically check for and cleanup orphaned processes
-            if time.time() - last_orphan_check >= ORPHAN_CHECK_INTERVAL:
-                try:
-                    orphaned_clients = process_tracker.cleanup_orphaned_processes()
-                    if orphaned_clients:
-                        logging.info(f"Cleaned up orphaned processes for {len(orphaned_clients)} dead clients: {orphaned_clients}")
-                    last_orphan_check = time.time()
-                except KeyboardInterrupt:
-                    _thread.interrupt_main()
-                    raise
-                except Exception as e:
-                    logging.error(f"Error during orphan cleanup: {e}", exc_info=True)
-
-            # Periodically cleanup stale cancel signals (every 60 seconds)
-            if time.time() - last_cancel_cleanup >= 60:
-                try:
-                    cleanup_stale_cancel_signals()
-                    last_cancel_cleanup = time.time()
-                except KeyboardInterrupt:
-                    _thread.interrupt_main()
-                    raise
-                except Exception as e:
-                    logging.error(f"Error during cancel signal cleanup: {e}", exc_info=True)
+            # Self-eviction check: if daemon has 0 clients AND 0 ops for SELF_EVICTION_TIMEOUT, shutdown
+            client_count = len(connection_registry.connections)
+            operation_running = context.status_manager.get_operation_in_progress()
+            daemon_is_empty = client_count == 0 and not operation_running
+
+            if daemon_is_empty:
+                if daemon_empty_since is None:
+                    daemon_empty_since = time.time()
+                    logging.debug("Daemon is now empty (0 clients, 0 ops), starting eviction timer")
+                elif time.time() - daemon_empty_since >= SELF_EVICTION_TIMEOUT:
+                    logging.info(f"Self-eviction triggered: daemon empty for {time.time() - daemon_empty_since:.1f}s, shutting down")
+                    cleanup_and_exit(context)
+            elif daemon_empty_since is not None:
+                logging.debug(f"Daemon is no longer empty (clients={client_count}, op_running={operation_running})")
+                daemon_empty_since = None
+
+            # Run periodic tasks
+            for task in periodic_tasks:
+                if task.should_run():
+                    task.run()
 
             # Check for manual stale lock clear signal
             clear_locks_signal = DAEMON_DIR / "clear_stale_locks.signal"
@@ -374,124 +786,30 @@ def run_daemon_loop() -> None:
                 except Exception as e:
                     logging.error(f"Error handling clear locks signal: {e}", exc_info=True)
 
-            # Periodically check for and cleanup dead clients (every 10 seconds)
-            if time.time() - last_dead_client_check >= DEAD_CLIENT_CHECK_INTERVAL:
-                try:
-                    dead_clients = context.client_manager.cleanup_dead_clients()
-                    if dead_clients:
-                        logging.info(f"Cleaned up {len(dead_clients)} dead clients: {dead_clients}")
-                    last_dead_client_check = time.time()
-                except KeyboardInterrupt:
-                    _thread.interrupt_main()
-                    raise
-                except Exception as e:
-                    logging.error(f"Error during dead client cleanup: {e}", exc_info=True)
-
-            # Periodically check for and cleanup stale locks (every 60 seconds)
-            if time.time() - last_stale_lock_check >= STALE_LOCK_CHECK_INTERVAL:
-                try:
-                    # Check for stale locks (held beyond timeout)
-                    stale_locks = context.lock_manager.get_stale_locks()
-                    stale_count = len(stale_locks["port_locks"]) + len(stale_locks["project_locks"])
-                    if stale_count > 0:
-                        logging.warning(f"Found {stale_count} stale locks, force-releasing...")
-                        released = context.lock_manager.force_release_stale_locks()
-                        logging.info(f"Force-released {released} stale locks")
-
-                    # Also clean up unused lock entries (memory cleanup)
-                    context.lock_manager.cleanup_unused_locks()
-                    last_stale_lock_check = time.time()
-                except KeyboardInterrupt:
-                    _thread.interrupt_main()
-                    raise
-                except Exception as e:
-                    logging.error(f"Error during stale lock cleanup: {e}", exc_info=True)
-
-            # Check for build requests (with lock for atomic consumption)
-            with build_request_lock:
-                build_request = read_request_file(BUILD_REQUEST_FILE, BuildRequest)
-                if build_request:
-                    # Clear request file IMMEDIATELY (atomic consumption)
-                    clear_request_file(BUILD_REQUEST_FILE)
-
-            if build_request:
-                last_activity = time.time()
-                logging.info(f"Received build request: {build_request}")
-
-                # Mark operation in progress
-                context.status_manager.set_operation_in_progress(True)
-
-                # Process request
-                build_processor.process_request(build_request, context)
-
-                # Mark operation complete
-                context.status_manager.set_operation_in_progress(False)
-
-            # Check for deploy requests (with lock for atomic consumption)
-            with deploy_request_lock:
-                deploy_request = read_request_file(DEPLOY_REQUEST_FILE, DeployRequest)
-                if deploy_request:
-                    # Clear request file IMMEDIATELY (atomic consumption)
-                    clear_request_file(DEPLOY_REQUEST_FILE)
+            # Process operation requests (build, deploy, monitor, install_deps)
+            for config in operation_requests:
+                if process_operation_request(config, context):
+                    last_activity = time.time()
 
-            if deploy_request:
-                last_activity = time.time()
-                logging.info(f"Received deploy request: {deploy_request}")
-
-                # Mark operation in progress
-                context.status_manager.set_operation_in_progress(True)
-
-                # Process request
-                deploy_processor.process_request(deploy_request, context)
-
-                # Mark operation complete
-                context.status_manager.set_operation_in_progress(False)
-
-            # Check for monitor requests (with lock for atomic consumption)
-            with monitor_request_lock:
-                monitor_request = read_request_file(MONITOR_REQUEST_FILE, MonitorRequest)
-                if monitor_request:
-                    # Clear request file IMMEDIATELY (atomic consumption)
-                    clear_request_file(MONITOR_REQUEST_FILE)
-
-            if monitor_request:
-                last_activity = time.time()
-                logging.info(f"Received monitor request: {monitor_request}")
-
-                # Mark operation in progress
-                context.status_manager.set_operation_in_progress(True)
-
-                # Process request
-                monitor_processor.process_request(monitor_request, context)
-
-                # Mark operation complete
-                context.status_manager.set_operation_in_progress(False)
-
-            # Check for install dependencies requests (with lock for atomic consumption)
-            with install_deps_request_lock:
-                install_deps_request = read_request_file(INSTALL_DEPS_REQUEST_FILE, InstallDependenciesRequest)
-                if install_deps_request:
-                    # Clear request file IMMEDIATELY (atomic consumption)
-                    clear_request_file(INSTALL_DEPS_REQUEST_FILE)
-
-            if install_deps_request:
-                last_activity = time.time()
-                logging.info(f"Received install dependencies request: {install_deps_request}")
-
-                # Mark operation in progress
-                context.status_manager.set_operation_in_progress(True)
-
-                # Process request
-                install_deps_processor.process_request(install_deps_request, context)
-
-                # Mark operation complete
-                context.status_manager.set_operation_in_progress(False)
+            # Process device management requests
+            for config in device_requests:
+                with config.lock:
+                    handle_device_request(config, context)
 
             # Sleep briefly to avoid busy-wait
             time.sleep(0.5)
 
         except KeyboardInterrupt:
-            logging.warning("Daemon interrupted by user")
+            # Check if operation is in progress - refuse to exit if so
+            if context.status_manager.get_operation_in_progress():
+                logging.warning("Received KeyboardInterrupt during active operation. Refusing to exit.")
+                print(
+                    f"\n⚠️  KeyboardInterrupt during operation\n⚠️  Cannot shutdown while operation is active\n⚠️  Use 'kill -9 {os.getpid()}' to force termination\n",
+                    flush=True,
+                )
+                # Continue the main loop instead of exiting
+                continue
+            logging.warning("Daemon interrupted by user (no operation in progress)")
             _thread.interrupt_main()
             cleanup_and_exit(context)
         except Exception as e:
@@ -500,14 +818,36 @@ def run_daemon_loop() -> None:
             time.sleep(1)
 
 
+def parse_spawner_pid() -> int | None:
+    """Parse --spawned-by argument from command line.
+
+    Returns:
+        The PID of the client that spawned this daemon, or None if not provided.
+    """
+    for arg in sys.argv:
+        if arg.startswith("--spawned-by="):
+            try:
+                return int(arg.split("=", 1)[1])
+            except (ValueError, IndexError):
+                return None
+    return None
+
+
 def main() -> int:
     """Main entry point for daemon."""
     # Parse command-line arguments
     foreground = "--foreground" in sys.argv
+    spawner_pid = parse_spawner_pid()
 
     # Setup logging
     setup_logging(foreground=foreground)
 
+    # Log spawner information immediately after logging setup
+    if spawner_pid is not None:
+        logging.info(f"Daemon spawned by client PID {spawner_pid}")
+    else:
+        logging.info("Daemon started without spawner info (manual start or legacy client)")
+
     # Ensure daemon directory exists
     DAEMON_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -545,19 +885,32 @@ def main() -> int:
 
     # Simple daemonization for cross-platform compatibility
     try:
-        # Fork to background
+        # Fork to background (Unix/Linux/macOS)
         if hasattr(os, "fork") and os.fork() > 0:  # type: ignore[attr-defined]
             # Parent process exits
             return 0
     except (OSError, AttributeError):
-        # Fork not supported (Windows) - run in background as subprocess
-        logging.info("Fork not supported, using subprocess")
+        # Fork not supported (Windows) - run in background as detached subprocess
+        logging.info("Fork not supported (Windows), using detached subprocess")
+        # Build command with spawner info if available
+        cmd = [sys.executable, __file__, "--foreground"]
+        if spawner_pid is not None:
+            cmd.append(f"--spawned-by={spawner_pid}")
+
+        # On Windows, use proper detachment flags:
+        # - CREATE_NEW_PROCESS_GROUP: Isolates daemon from parent's Ctrl-C signals
+        # - DETACHED_PROCESS: Daemon survives parent termination, no console inherited
+        creationflags = 0
+        if sys.platform == "win32":
+            creationflags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
+
         subprocess.Popen(
-            [sys.executable, __file__, "--foreground"],
+            cmd,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             stdin=subprocess.DEVNULL,
             cwd=str(DAEMON_DIR),
+            creationflags=creationflags,
         )
         return 0