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

fbuild/daemon/client.py

@@ -85,18 +85,37 @@ def is_daemon_running() -> bool:
 
 
 def start_daemon() -> None:
-    """Start the daemon process."""
+    """Start the daemon process.
+
+    Passes the spawning client's PID as an argument so the daemon can log
+    which client originally started it.
+
+    On Windows, uses proper detachment flags to ensure:
+    - Daemon survives client termination (DETACHED_PROCESS)
+    - Daemon is isolated from client's Ctrl-C signals (CREATE_NEW_PROCESS_GROUP)
+    """
     daemon_script = Path(__file__).parent / "daemon.py"
 
     if not daemon_script.exists():
         raise RuntimeError(f"Daemon script not found: {daemon_script}")
 
-    # Start daemon in background
+    # Pass spawning client PID so daemon can log who started it
+    spawner_pid = os.getpid()
+
+    # On Windows, use proper detachment flags:
+    # - CREATE_NEW_PROCESS_GROUP: Isolates daemon from client's Ctrl-C signals
+    # - DETACHED_PROCESS: Daemon survives client termination, no console inherited
+    creationflags = 0
+    if sys.platform == "win32":
+        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
+
+    # Start daemon in background as a fully detached process
     subprocess.Popen(
-        [sys.executable, str(daemon_script)],
+        [sys.executable, str(daemon_script), f"--spawned-by={spawner_pid}"],
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
         stdin=subprocess.DEVNULL,
+        creationflags=creationflags,
     )
 
 
@@ -372,6 +391,7 @@ class BaseRequestHandler(ABC):
         self.start_time = 0.0
         self.last_message: str | None = None
         self.monitoring_started = False
+        self.build_output_started = False
         self.output_file_position = 0
         self.spinner_idx = 0
         self.last_spinner_update = 0.0
@@ -420,6 +440,14 @@ class BaseRequestHandler(ABC):
         """
         return False
 
+    def get_output_file_path(self) -> Path:
+        """Get the output file path to tail. Override in subclasses.
+
+        Returns:
+            Path to the output file
+        """
+        return self.project_dir / ".fbuild" / "monitor_output.txt"
+
     def on_monitoring_started(self) -> None:
         """Hook called when monitoring phase starts."""
         pass
@@ -449,7 +477,7 @@ class BaseRequestHandler(ABC):
 
     def tail_output_file(self) -> None:
         """Tail the output file and print new lines."""
-        output_file = self.project_dir / ".fbuild" / "monitor_output.txt"
+        output_file = self.get_output_file_path()
         if output_file.exists():
             try:
                 with open(output_file, "r", encoding="utf-8", errors="replace") as f:
@@ -465,10 +493,10 @@ class BaseRequestHandler(ABC):
 
     def read_remaining_output(self) -> None:
         """Read any remaining output from output file."""
-        if not self.monitoring_started:
+        if not self.monitoring_started and not self.build_output_started:
             return
 
-        output_file = self.project_dir / ".fbuild" / "monitor_output.txt"
+        output_file = self.get_output_file_path()
         if output_file.exists():
             try:
                 with open(output_file, "r", encoding="utf-8", errors="replace") as f:
@@ -550,18 +578,32 @@ class BaseRequestHandler(ABC):
                     self.last_spinner_update = time.time()
                 else:
                     # Show spinner with elapsed time when in building/deploying state
+                    # Only show spinner if we're not tailing build output
                     if status.state in (DaemonState.BUILDING, DaemonState.DEPLOYING):
-                        current_time = time.time()
-                        # Update spinner every 100ms
-                        if current_time - self.last_spinner_update >= 0.1:
-                            self.spinner_idx += 1
-                            display_spinner_progress(status, elapsed, self.spinner_idx)
-                            self.last_spinner_update = current_time
+                        if not (self.should_tail_output() and status.state == DaemonState.BUILDING and self.build_output_started):
+                            current_time = time.time()
+                            # Update spinner every 100ms
+                            if current_time - self.last_spinner_update >= 0.1:
+                                self.spinner_idx += 1
+                                display_spinner_progress(status, elapsed, self.spinner_idx)
+                                self.last_spinner_update = current_time
+
+                # Handle build output tailing phase
+                if self.should_tail_output() and status.state == DaemonState.BUILDING:
+                    if not self.build_output_started:
+                        self.build_output_started = True
+                        # Clear spinner line before build output
+                        print("\r" + " " * 80 + "\r", end="", flush=True)
+                        print()  # Blank line before build output
+                    self.tail_output_file()
 
                 # Handle monitoring phase
                 if self.should_tail_output() and status.state == DaemonState.MONITORING:
                     if not self.monitoring_started:
                         self.monitoring_started = True
+                        # Reset file position when transitioning from build to monitor
+                        if self.build_output_started:
+                            self.output_file_position = 0
                         # Clear spinner line before monitor output
                         print("\r" + " " * 80 + "\r", end="", flush=True)
                         print()  # Blank line before serial output
@@ -646,6 +688,14 @@ class BuildRequestHandler(BaseRequestHandler):
         """Get operation emoji."""
         return "🔨"
 
+    def should_tail_output(self) -> bool:
+        """Build operations should tail output."""
+        return True
+
+    def get_output_file_path(self) -> Path:
+        """Build output goes to build_output.txt."""
+        return self.project_dir / ".fbuild" / "build_output.txt"
+
     def print_submission_info(self) -> None:
         """Print build submission information."""
         super().print_submission_info()
@@ -726,7 +776,15 @@ class DeployRequestHandler(BaseRequestHandler):
 
     def should_tail_output(self) -> bool:
         """Check if output should be tailed."""
-        return self.monitor_after
+        # Always tail during build phase, and during monitor if monitor_after is set
+        return True
+
+    def get_output_file_path(self) -> Path:
+        """During build phase, use build_output.txt; during monitor, use monitor_output.txt."""
+        status = read_status_file()
+        if status.state == DaemonState.BUILDING:
+            return self.project_dir / ".fbuild" / "build_output.txt"
+        return self.project_dir / ".fbuild" / "monitor_output.txt"
 
     def print_submission_info(self) -> None:
         """Print deploy submission information."""
@@ -1440,6 +1498,353 @@ def display_daemon_list() -> None:
         print()
 
 
+# ============================================================================
+# DEVICE MANAGEMENT FUNCTIONS
+# ============================================================================
+
+
+def list_devices(refresh: bool = False) -> list[dict[str, Any]] | None:
+    """List all devices known to the daemon.
+
+    Args:
+        refresh: Whether to refresh device discovery before listing.
+
+    Returns:
+        List of device info dictionaries, or None if daemon not running.
+        Each device dict contains:
+        - device_id: Stable device identifier
+        - port: Current port (may change)
+        - is_connected: Whether device is currently connected
+        - exclusive_holder: Client ID holding exclusive lease (or None)
+        - monitor_count: Number of active monitor leases
+    """
+    if not is_daemon_running():
+        return None
+
+    # For now, we use a signal file to communicate with the daemon
+    # In the future, this should use the async TCP connection
+    request_file = DAEMON_DIR / "device_list_request.json"
+    response_file = DAEMON_DIR / "device_list_response.json"
+
+    # Clean up any old response file
+    response_file.unlink(missing_ok=True)
+
+    # Write request
+    request = {"refresh": refresh, "timestamp": time.time()}
+    with open(request_file, "w") as f:
+        json.dump(request, f)
+
+    # Wait for response (timeout 5 seconds)
+    for _ in range(50):
+        if response_file.exists():
+            try:
+                with open(response_file) as f:
+                    response = json.load(f)
+                response_file.unlink(missing_ok=True)
+                if response.get("success"):
+                    return response.get("devices", [])
+                return []
+            except (json.JSONDecodeError, OSError):
+                pass
+        time.sleep(0.1)
+
+    # Timeout - clean up
+    request_file.unlink(missing_ok=True)
+    return None
+
+
+def get_device_status(device_id: str) -> dict[str, Any] | None:
+    """Get detailed status for a specific device.
+
+    Args:
+        device_id: The device ID to query.
+
+    Returns:
+        Device status dictionary, or None if device not found or daemon not running.
+    """
+    if not is_daemon_running():
+        return None
+
+    request_file = DAEMON_DIR / "device_status_request.json"
+    response_file = DAEMON_DIR / "device_status_response.json"
+
+    # Clean up any old response file
+    response_file.unlink(missing_ok=True)
+
+    # Write request
+    request = {"device_id": device_id, "timestamp": time.time()}
+    with open(request_file, "w") as f:
+        json.dump(request, f)
+
+    # Wait for response
+    for _ in range(50):
+        if response_file.exists():
+            try:
+                with open(response_file) as f:
+                    response = json.load(f)
+                response_file.unlink(missing_ok=True)
+                if response.get("success"):
+                    return response
+                return None
+            except (json.JSONDecodeError, OSError):
+                pass
+        time.sleep(0.1)
+
+    request_file.unlink(missing_ok=True)
+    return None
+
+
+def acquire_device_lease(
+    device_id: str,
+    lease_type: str = "exclusive",
+    description: str = "",
+) -> dict[str, Any] | None:
+    """Acquire a lease on a device.
+
+    Args:
+        device_id: The device ID to lease.
+        lease_type: Type of lease - "exclusive" or "monitor".
+        description: Description of the operation.
+
+    Returns:
+        Response dictionary with success status and lease_id, or None if failed.
+    """
+    if not is_daemon_running():
+        return None
+
+    request_file = DAEMON_DIR / "device_lease_request.json"
+    response_file = DAEMON_DIR / "device_lease_response.json"
+
+    response_file.unlink(missing_ok=True)
+
+    request = {
+        "device_id": device_id,
+        "lease_type": lease_type,
+        "description": description,
+        "timestamp": time.time(),
+    }
+    with open(request_file, "w") as f:
+        json.dump(request, f)
+
+    for _ in range(50):
+        if response_file.exists():
+            try:
+                with open(response_file) as f:
+                    response = json.load(f)
+                response_file.unlink(missing_ok=True)
+                return response
+            except (json.JSONDecodeError, OSError):
+                pass
+        time.sleep(0.1)
+
+    request_file.unlink(missing_ok=True)
+    return None
+
+
+def release_device_lease(device_id: str) -> dict[str, Any] | None:
+    """Release a lease on a device.
+
+    Args:
+        device_id: The device ID or lease ID to release.
+
+    Returns:
+        Response dictionary with success status, or None if failed.
+    """
+    if not is_daemon_running():
+        return None
+
+    request_file = DAEMON_DIR / "device_release_request.json"
+    response_file = DAEMON_DIR / "device_release_response.json"
+
+    response_file.unlink(missing_ok=True)
+
+    request = {"device_id": device_id, "timestamp": time.time()}
+    with open(request_file, "w") as f:
+        json.dump(request, f)
+
+    for _ in range(50):
+        if response_file.exists():
+            try:
+                with open(response_file) as f:
+                    response = json.load(f)
+                response_file.unlink(missing_ok=True)
+                return response
+            except (json.JSONDecodeError, OSError):
+                pass
+        time.sleep(0.1)
+
+    request_file.unlink(missing_ok=True)
+    return None
+
+
+def preempt_device(device_id: str, reason: str) -> dict[str, Any] | None:
+    """Preempt a device from its current holder.
+
+    Args:
+        device_id: The device ID to preempt.
+        reason: Reason for preemption (required).
+
+    Returns:
+        Response dictionary with success status and preempted_client_id, or None if failed.
+    """
+    if not is_daemon_running():
+        return None
+
+    if not reason:
+        return {"success": False, "message": "Reason is required for preemption"}
+
+    request_file = DAEMON_DIR / "device_preempt_request.json"
+    response_file = DAEMON_DIR / "device_preempt_response.json"
+
+    response_file.unlink(missing_ok=True)
+
+    request = {"device_id": device_id, "reason": reason, "timestamp": time.time()}
+    with open(request_file, "w") as f:
+        json.dump(request, f)
+
+    for _ in range(50):
+        if response_file.exists():
+            try:
+                with open(response_file) as f:
+                    response = json.load(f)
+                response_file.unlink(missing_ok=True)
+                return response
+            except (json.JSONDecodeError, OSError):
+                pass
+        time.sleep(0.1)
+
+    request_file.unlink(missing_ok=True)
+    return None
+
+
+def tail_daemon_logs(follow: bool = True, lines: int = 50) -> None:
+    """Tail the daemon log file.
+
+    This function streams the daemon's log output, allowing users to see
+    what the daemon is doing in real-time without affecting its operation.
+
+    Per TASK.md: `fbuild show daemon` should attach to daemon log stream
+    and tail it, with exit NOT stopping the daemon.
+
+    Args:
+        follow: If True, continuously follow the log file (like tail -f).
+                If False, just print the last N lines and exit.
+        lines: Number of lines to show initially (default: 50).
+    """
+    log_file = DAEMON_DIR / "daemon.log"
+
+    if not log_file.exists():
+        print("❌ Daemon log file not found")
+        print(f"   Expected at: {log_file}")
+        print("   Hint: Start the daemon first with 'fbuild build <project>'")
+        return
+
+    print(f"📋 Tailing daemon log: {log_file}")
+    if follow:
+        print("   (Press Ctrl-C to stop viewing - daemon will continue running)\n")
+    print("=" * 60)
+
+    try:
+        with open(log_file, "r", encoding="utf-8", errors="replace") as f:
+            # Read initial lines
+            all_lines = f.readlines()
+
+            # Show last N lines
+            if len(all_lines) > lines:
+                print(f"... (showing last {lines} lines) ...\n")
+                for line in all_lines[-lines:]:
+                    print(line, end="")
+            else:
+                for line in all_lines:
+                    print(line, end="")
+
+            if not follow:
+                return
+
+            # Follow mode - continuously read new content
+            while True:
+                line = f.readline()
+                if line:
+                    print(line, end="", flush=True)
+                else:
+                    # No new content - sleep briefly
+                    time.sleep(0.1)
+
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+        print("\n\n" + "=" * 60)
+        print("✅ Stopped viewing logs (daemon continues running)")
+        print("   Use 'fbuild daemon status' to check daemon status")
+        print("   Use 'fbuild daemon stop' to stop the daemon")
+
+
+def get_daemon_log_path() -> Path:
+    """Get the path to the daemon log file.
+
+    Returns:
+        Path to daemon.log file
+    """
+    return DAEMON_DIR / "daemon.log"
+
+
+def display_daemon_stats_compact() -> None:
+    """Display daemon stats in a compact single-line format.
+
+    This function is called immediately when the client starts to show
+    the current daemon status. It's designed to be non-intrusive.
+    """
+    if not is_daemon_running():
+        print("🔴 Daemon: not running")
+        return
+
+    status = read_status_file()
+
+    # Calculate uptime if daemon_started_at is available
+    uptime_str = ""
+    if status.daemon_started_at:
+        uptime = time.time() - status.daemon_started_at
+        if uptime < 60:
+            uptime_str = f"{uptime:.0f}s"
+        elif uptime < 3600:
+            uptime_str = f"{uptime / 60:.0f}m"
+        else:
+            uptime_str = f"{uptime / 3600:.1f}h"
+
+    # Build the status line
+    pid_str = f"PID {status.daemon_pid}" if status.daemon_pid else ""
+    state_emoji = {
+        DaemonState.IDLE: "🟢",
+        DaemonState.BUILDING: "🔨",
+        DaemonState.DEPLOYING: "📦",
+        DaemonState.MONITORING: "👁️",
+        DaemonState.COMPLETED: "✅",
+        DaemonState.FAILED: "❌",
+        DaemonState.UNKNOWN: "❓",
+    }.get(status.state, "❓")
+
+    # Count active locks
+    port_locks = status.locks.get("port_locks", {}) if status.locks else {}
+    active_port_locks = sum(1 for info in port_locks.values() if isinstance(info, dict) and info.get("is_held"))
+
+    # Build compact stats line
+    parts = [f"{state_emoji} Daemon: {status.state.value}"]
+    if pid_str:
+        parts.append(pid_str)
+    if uptime_str:
+        parts.append(f"up {uptime_str}")
+    if active_port_locks > 0:
+        parts.append(f"locks: {active_port_locks}")
+    if status.operation_in_progress:
+        op_info = status.current_operation or status.message
+        if op_info and len(op_info) > 30:
+            op_info = op_info[:27] + "..."
+        parts.append(f"[{op_info}]")
+
+    print(" | ".join(parts))
+
+
 def main() -> int:
     """Command-line interface for client."""
     import argparse
@@ -1453,6 +1858,9 @@ def main() -> int:
     parser.add_argument("--kill", type=int, metavar="PID", help="Kill specific daemon by PID")
     parser.add_argument("--kill-all", action="store_true", help="Kill all daemon instances")
     parser.add_argument("--force", action="store_true", help="Force kill (with --kill or --kill-all)")
+    parser.add_argument("--tail", action="store_true", help="Tail daemon logs")
+    parser.add_argument("--no-follow", action="store_true", help="Don't follow log file (with --tail)")
+    parser.add_argument("--lines", type=int, default=50, help="Number of lines to show initially (with --tail)")
 
     args = parser.parse_args()
 
@@ -1493,6 +1901,10 @@ def main() -> int:
         print(f"Killed {killed} daemon instance(s)")
         return 0
 
+    if args.tail:
+        tail_daemon_logs(follow=not args.no_follow, lines=args.lines)
+        return 0
+
     parser.print_help()
     return 1
 

fbuild/daemon/configuration_lock.py

@@ -313,7 +313,7 @@ class ConfigurationLockManager:
 
             # If non-blocking, return False
             if timeout <= 0:
-                logging.debug(f"Exclusive lock not available for {config_key}, " f"current state: {lock.state.value}")
+                logging.debug(f"Exclusive lock not available for {config_key}, current state: {lock.state.value}")
                 return False
 
             # Add to waiting queue
@@ -322,7 +322,7 @@ class ConfigurationLockManager:
                 description=description,
             )
             lock.waiting_queue.append(waiting_request)
-            logging.debug(f"Client {client_id} added to waiting queue for {config_key}, " f"position: {len(lock.waiting_queue)}")
+            logging.debug(f"Client {client_id} added to waiting queue for {config_key}, position: {len(lock.waiting_queue)}")
 
         # Wait outside the master lock to avoid blocking other operations
         if waiting_request:
@@ -343,7 +343,7 @@ class ConfigurationLockManager:
                     pass  # Already removed
 
                 if not signaled:
-                    logging.debug(f"Timeout waiting for exclusive lock on {config_key} " f"for client {client_id}")
+                    logging.debug(f"Timeout waiting for exclusive lock on {config_key} for client {client_id}")
                     return False
 
                 # Try to acquire now that we've been signaled
@@ -356,7 +356,7 @@ class ConfigurationLockManager:
                     )
                     lock.last_activity_at = time.time()
                     self._track_client_lock(client_id, config_key)
-                    logging.debug(f"Exclusive lock acquired (after wait) for {config_key} " f"by {client_id}")
+                    logging.debug(f"Exclusive lock acquired (after wait) for {config_key} by {client_id}")
                     return True
                 else:
                     # Lock was taken by someone else
@@ -395,13 +395,13 @@ class ConfigurationLockManager:
 
             # Cannot acquire if exclusive lock is held
             if lock.state == LockState.LOCKED_EXCLUSIVE:
-                logging.debug(f"Shared read lock not available for {config_key}, " f"exclusive lock held by {lock.exclusive_holder.client_id if lock.exclusive_holder else 'unknown'}")
+                logging.debug(f"Shared read lock not available for {config_key}, exclusive lock held by {lock.exclusive_holder.client_id if lock.exclusive_holder else 'unknown'}")
                 return False
 
             # Cannot acquire if there are clients waiting for exclusive lock
             # (to prevent starvation of exclusive lock requests)
             if lock.waiting_queue:
-                logging.debug(f"Shared read lock not available for {config_key}, " f"{len(lock.waiting_queue)} clients waiting for exclusive lock")
+                logging.debug(f"Shared read lock not available for {config_key}, {len(lock.waiting_queue)} clients waiting for exclusive lock")
                 return False
 
             # Acquire shared read lock
@@ -413,7 +413,7 @@ class ConfigurationLockManager:
             )
             lock.last_activity_at = time.time()
             self._track_client_lock(client_id, config_key)
-            logging.debug(f"Shared read lock acquired for {config_key} by {client_id}, " f"total shared holders: {len(lock.shared_holders)}")
+            logging.debug(f"Shared read lock acquired for {config_key} by {client_id}, total shared holders: {len(lock.shared_holders)}")
             return True
 
     def release(self, config_key: tuple[str, str, str], client_id: str) -> bool:
@@ -459,7 +459,7 @@ class ConfigurationLockManager:
                     # Grant to next waiting client if any
                     self._grant_next_waiting(lock)
 
-                logging.debug(f"Shared read lock released for {config_key} by {client_id}, " f"remaining shared holders: {len(lock.shared_holders)}")
+                logging.debug(f"Shared read lock released for {config_key} by {client_id}, remaining shared holders: {len(lock.shared_holders)}")
                 return True
 
             logging.debug(f"Client {client_id} does not hold a lock for {config_key}")
@@ -625,7 +625,7 @@ class ConfigurationLockManager:
 
             # Need to wait for other shared holders to release
             if timeout <= 0:
-                logging.debug(f"Cannot upgrade lock for {config_key}, " f"{len(lock.shared_holders) - 1} other shared holders")
+                logging.debug(f"Cannot upgrade lock for {config_key}, {len(lock.shared_holders) - 1} other shared holders")
                 return False
 
             # Release our shared lock and join waiting queue with priority
@@ -661,7 +661,7 @@ class ConfigurationLockManager:
                     )
                     lock_check.last_activity_at = time.time()
                     # Don't re-track since we kept the tracking from shared
-                    logging.debug(f"Lock upgraded (immediate) to exclusive for {config_key} " f"by {client_id}")
+                    logging.debug(f"Lock upgraded (immediate) to exclusive for {config_key} by {client_id}")
                     return True
 
             remaining_timeout = timeout - (time.time() - start_time)
@@ -682,7 +682,7 @@ class ConfigurationLockManager:
                     pass
 
                 if not signaled:
-                    logging.debug(f"Timeout waiting for upgrade on {config_key} " f"for client {client_id}")
+                    logging.debug(f"Timeout waiting for upgrade on {config_key} for client {client_id}")
                     # Re-acquire shared lock
                     lock_wait.shared_holders[client_id] = LockHolder(
                         client_id=client_id,
@@ -702,7 +702,7 @@ class ConfigurationLockManager:
                         lock_type="exclusive",
                     )
                     lock_wait.last_activity_at = time.time()
-                    logging.debug(f"Lock upgraded (after wait) to exclusive for {config_key} " f"by {client_id}")
+                    logging.debug(f"Lock upgraded (after wait) to exclusive for {config_key} by {client_id}")
                     return True
                 else:
                     # Someone else got the lock
@@ -749,7 +749,7 @@ class ConfigurationLockManager:
             # If there are clients waiting for exclusive, don't downgrade
             # (they should get the exclusive lock next)
             if lock.waiting_queue:
-                logging.debug(f"Cannot downgrade lock for {config_key}, " f"{len(lock.waiting_queue)} clients waiting for exclusive")
+                logging.debug(f"Cannot downgrade lock for {config_key}, {len(lock.waiting_queue)} clients waiting for exclusive")
                 return False
 
             # Downgrade to shared read