lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__py3-none-any.whl

lfx/services/mcp_composer/service.py

@@ -1,13 +1,18 @@
 """MCP Composer service for proxying and orchestrating MCP servers."""
 
 import asyncio
+import json
 import os
+import platform
 import re
 import select
 import socket
 import subprocess
+import tempfile
+import typing
 from collections.abc import Callable
 from functools import wraps
+from pathlib import Path
 from typing import Any
 
 from lfx.log.logger import logger
@@ -68,20 +73,379 @@ class MCPComposerService(Service):
 
     def __init__(self):
         super().__init__()
-        self.project_composers: dict[str, dict] = {}  # project_id -> {process, host, port, sse_url, auth_config}
+        self.project_composers: dict[
+            str, dict
+        ] = {}  # project_id -> {process, host, port, streamable_http_url, auth_config}
         self._start_locks: dict[
             str, asyncio.Lock
         ] = {}  # Lock to prevent concurrent start operations for the same project
+        self._active_start_tasks: dict[
+            str, asyncio.Task
+        ] = {}  # Track active start tasks to cancel them when new request arrives
+        self._port_to_project: dict[int, str] = {}  # Track which project is using which port
+        self._pid_to_project: dict[int, str] = {}  # Track which PID belongs to which project
+        self._last_errors: dict[str, str] = {}  # Track last error message per project for UI display
 
-    def _is_port_available(self, port: int) -> bool:
-        """Check if a port is available by trying to bind to it."""
+    def get_last_error(self, project_id: str) -> str | None:
+        """Get the last error message for a project, if any."""
+        return self._last_errors.get(project_id)
+
+    def set_last_error(self, project_id: str, error_message: str) -> None:
+        """Set the last error message for a project."""
+        self._last_errors[project_id] = error_message
+
+    def clear_last_error(self, project_id: str) -> None:
+        """Clear the last error message for a project."""
+        self._last_errors.pop(project_id, None)
+
+    def _is_port_available(self, port: int, host: str = "localhost") -> bool:
+        """Check if a port is available by trying to bind to it.
+
+        Args:
+            port: Port number to check
+            host: Host to check (default: localhost)
+
+        Returns:
+            True if port is available (not in use), False if in use
+
+        Raises:
+            ValueError: If port is not in valid range (0-65535)
+        """
+        import errno
+
+        # Validate port range before attempting bind
+        max_port = 65535
+        if not isinstance(port, int) or port < 0 or port > max_port:
+            msg = f"Invalid port number: {port}. Port must be between 0 and {max_port}."
+            raise ValueError(msg)
+
+        # Check both IPv4 and IPv6 to ensure port is truly available
+        # MCP Composer tries to bind on both, so we need to check both
+
+        # Check IPv4
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                sock.bind(("0.0.0.0", port))
-                return True  # Port is available
+                # Don't use SO_REUSEADDR here as it can give false positives
+                sock.bind((host, port))
         except OSError:
-            return False  # Port is in use/bound
+            return False  # Port is in use on IPv4
+
+        # Check IPv6 (if supported on this system)
+        try:
+            with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock:
+                # Don't use SO_REUSEADDR here as it can give false positives
+                # Use ::1 for localhost on IPv6
+                ipv6_host = "::1" if host in ("localhost", "127.0.0.1") else host
+                sock.bind((ipv6_host, port))
+        except OSError as e:
+            # Check if it's "address already in use" error
+            # errno.EADDRINUSE is 48 on macOS, 98 on Linux, 10048 on Windows (WSAEADDRINUSE)
+            # We check both the standard errno and Windows-specific error code
+            if e.errno in (errno.EADDRINUSE, 10048):
+                return False  # Port is in use on IPv6
+            # For other errors (e.g., IPv6 not supported, EADDRNOTAVAIL), continue
+            # IPv6 might not be supported on this system, which is okay
+
+        return True  # Port is available on both IPv4 and IPv6 (or IPv6 not supported)
+
+    async def _kill_process_on_port(self, port: int) -> bool:
+        """Kill the process using the specified port.
+
+        Cross-platform implementation supporting Windows, macOS, and Linux.
+
+        Args:
+            port: The port number to check
+
+        Returns:
+            True if a process was found and killed, False otherwise
+        """
+        try:
+            await logger.adebug(f"Checking for processes using port {port}...")
+            os_type = platform.system()
+
+            # Platform-specific command to find PID
+            if os_type == "Windows":
+                # Use netstat on Windows - use full path to avoid PATH issues
+                netstat_cmd = os.path.join(os.environ.get("SYSTEMROOT", "C:\\Windows"), "System32", "netstat.exe")  # noqa: PTH118
+                result = await asyncio.to_thread(
+                    subprocess.run,
+                    [netstat_cmd, "-ano"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+
+                if result.returncode == 0:
+                    # Parse netstat output to find PID
+                    # Format: TCP    0.0.0.0:PORT    0.0.0.0:0    LISTENING    PID
+                    windows_pids: list[int] = []
+                    for line in result.stdout.split("\n"):
+                        if f":{port}" in line and "LISTENING" in line:
+                            parts = line.split()
+                            if parts:
+                                try:
+                                    pid = int(parts[-1])
+                                    windows_pids.append(pid)
+                                except (ValueError, IndexError):
+                                    continue
+
+                    await logger.adebug(f"Found {len(windows_pids)} process(es) using port {port}: {windows_pids}")
+
+                    for pid in windows_pids:
+                        try:
+                            await logger.adebug(f"Attempting to kill process {pid} on port {port}...")
+                            # Use taskkill on Windows - use full path to avoid PATH issues
+                            taskkill_cmd = os.path.join(  # noqa: PTH118
+                                os.environ.get("SYSTEMROOT", "C:\\Windows"), "System32", "taskkill.exe"
+                            )
+                            kill_result = await asyncio.to_thread(
+                                subprocess.run,
+                                [taskkill_cmd, "/F", "/PID", str(pid)],
+                                capture_output=True,
+                                check=False,
+                            )
+
+                            if kill_result.returncode == 0:
+                                await logger.adebug(f"Successfully killed process {pid} on port {port}")
+                                return True
+                            await logger.awarning(
+                                f"taskkill returned {kill_result.returncode} for process {pid} on port {port}"
+                            )
+                        except Exception as e:  # noqa: BLE001
+                            await logger.aerror(f"Error killing PID {pid}: {e}")
+
+                    return False
+            else:
+                # Use lsof on Unix-like systems (macOS, Linux)
+                result = await asyncio.to_thread(
+                    subprocess.run,
+                    ["lsof", "-ti", f":{port}"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+
+                await logger.adebug(f"lsof returned code {result.returncode} for port {port}")
+
+                # Extract PIDs from lsof output
+                lsof_output = result.stdout.strip()
+                lsof_errors = result.stderr.strip()
+
+                if lsof_output:
+                    await logger.adebug(f"lsof stdout: {lsof_output}")
+                if lsof_errors:
+                    await logger.adebug(f"lsof stderr: {lsof_errors}")
+
+                if result.returncode == 0 and lsof_output:
+                    unix_pids = lsof_output.split("\n")
+                    await logger.adebug(f"Found {len(unix_pids)} process(es) using port {port}: {unix_pids}")
+
+                    for pid_str in unix_pids:
+                        try:
+                            pid = int(pid_str.strip())
+                            await logger.adebug(f"Attempting to kill process {pid} on port {port}...")
+
+                            # Try to kill the process
+                            kill_result = await asyncio.to_thread(
+                                subprocess.run,
+                                ["kill", "-9", str(pid)],
+                                capture_output=True,
+                                check=False,
+                            )
+
+                            if kill_result.returncode == 0:
+                                await logger.adebug(f"Successfully sent kill signal to process {pid} on port {port}")
+                                return True
+                            await logger.awarning(
+                                f"kill command returned {kill_result.returncode} for process {pid} on port {port}"
+                            )
+                        except (ValueError, ProcessLookupError) as e:
+                            await logger.aerror(f"Error processing PID {pid_str}: {e}")
+
+                    # If we get here, we found processes but couldn't kill any
+                    return False
+                await logger.adebug(f"No process found using port {port}")
+                return False
+        except Exception as e:  # noqa: BLE001
+            await logger.aerror(f"Error finding/killing process on port {port}: {e}")
+            return False
+        return False
+
+    async def _kill_zombie_mcp_processes(self, port: int) -> bool:
+        """Kill zombie MCP Composer processes that may be stuck.
+
+        On Windows, sometimes MCP Composer processes start but fail to bind to port.
+        These processes become "zombies" that need to be killed before retry.
+
+        Args:
+            port: The port that should be used
+
+        Returns:
+            True if zombie processes were found and killed
+        """
+        try:
+            os_type = platform.system()
+            if os_type != "Windows":
+                return False
+
+            await logger.adebug(f"Looking for zombie MCP Composer processes on Windows for port {port}...")
+
+            # First, try to find and kill any process using the port directly
+            # Use full path to netstat on Windows to avoid PATH issues
+            netstat_cmd = os.path.join(os.environ.get("SYSTEMROOT", "C:\\Windows"), "System32", "netstat.exe")  # noqa: PTH118
+            netstat_result = await asyncio.to_thread(
+                subprocess.run,
+                [netstat_cmd, "-ano"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            killed_any = False
+            if netstat_result.returncode == 0:
+                # Parse netstat output to find PIDs using our port
+                pids_on_port: list[int] = []
+                for line in netstat_result.stdout.split("\n"):
+                    if f":{port}" in line and "LISTENING" in line:
+                        parts = line.split()
+                        if parts:
+                            try:
+                                pid = int(parts[-1])
+                                # Only kill if not tracked by us
+                                if pid not in self._pid_to_project:
+                                    pids_on_port.append(pid)
+                                else:
+                                    project = self._pid_to_project[pid]
+                                    await logger.adebug(
+                                        f"Process {pid} on port {port} is tracked, skipping (project: {project})"
+                                    )
+                            except (ValueError, IndexError):
+                                continue
+
+                if pids_on_port:
+                    await logger.adebug(
+                        f"Found {len(pids_on_port)} untracked process(es) on port {port}: {pids_on_port}"
+                    )
+                    for pid in pids_on_port:
+                        try:
+                            await logger.adebug(f"Killing process {pid} on port {port}...")
+                            # Use full path to taskkill on Windows to avoid PATH issues
+                            taskkill_cmd = os.path.join(  # noqa: PTH118
+                                os.environ.get("SYSTEMROOT", "C:\\Windows"), "System32", "taskkill.exe"
+                            )
+                            kill_result = await asyncio.to_thread(
+                                subprocess.run,
+                                [taskkill_cmd, "/F", "/PID", str(pid)],
+                                capture_output=True,
+                                check=False,
+                            )
+                            if kill_result.returncode == 0:
+                                await logger.adebug(f"Successfully killed process {pid} on port {port}")
+                                killed_any = True
+                            else:
+                                stderr_output = (
+                                    kill_result.stderr.decode()
+                                    if isinstance(kill_result.stderr, bytes)
+                                    else kill_result.stderr
+                                )
+                                await logger.awarning(f"Failed to kill process {pid} on port {port}: {stderr_output}")
+                        except Exception as e:  # noqa: BLE001
+                            await logger.adebug(f"Error killing process {pid}: {e}")
+
+            # Also look for any orphaned mcp-composer processes (without checking port)
+            # This catches processes that failed to bind but are still running
+            # Use PowerShell instead of deprecated wmic.exe for Windows 10/11 compatibility
+            try:
+                # Use PowerShell to get Python processes with command line info
+                # Build PowerShell command to find MCP Composer processes
+                ps_filter = (
+                    f"$_.Name -eq 'python.exe' -and $_.CommandLine -like '*mcp-composer*' "
+                    f"-and ($_.CommandLine -like '*--port {port}*' -or $_.CommandLine -like '*--port={port}*')"
+                )
+                ps_cmd = (
+                    f"Get-WmiObject Win32_Process | Where-Object {{ {ps_filter} }} | "
+                    "Select-Object ProcessId,CommandLine | ConvertTo-Json"
+                )
+                powershell_cmd = ["powershell.exe", "-NoProfile", "-Command", ps_cmd]
+
+                ps_result = await asyncio.to_thread(
+                    subprocess.run,
+                    powershell_cmd,
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=5,
+                )
+
+                if ps_result.returncode == 0 and ps_result.stdout.strip():
+                    try:
+                        # PowerShell may return single object or array
+                        processes = json.loads(ps_result.stdout)
+                        if isinstance(processes, dict):
+                            processes = [processes]
+                        elif not isinstance(processes, list):
+                            processes = []
+
+                        for proc in processes:
+                            try:
+                                pid = int(proc.get("ProcessId", 0))
+                                if pid <= 0 or pid in self._pid_to_project:
+                                    continue
+
+                                await logger.adebug(
+                                    f"Found orphaned MCP Composer process {pid} for port {port}, killing it"
+                                )
+                                # Use full path to taskkill on Windows to avoid PATH issues
+                                taskkill_cmd = os.path.join(  # noqa: PTH118
+                                    os.environ.get("SYSTEMROOT", "C:\\Windows"), "System32", "taskkill.exe"
+                                )
+                                kill_result = await asyncio.to_thread(
+                                    subprocess.run,
+                                    [taskkill_cmd, "/F", "/PID", str(pid)],
+                                    capture_output=True,
+                                    check=False,
+                                )
+                                if kill_result.returncode == 0:
+                                    await logger.adebug(f"Successfully killed orphaned process {pid}")
+                                    killed_any = True
+
+                            except (ValueError, KeyError) as e:
+                                await logger.adebug(f"Error processing PowerShell result: {e}")
+                                continue
+
+                    except json.JSONDecodeError as e:
+                        await logger.adebug(f"Failed to parse PowerShell output: {e}")
+
+            except asyncio.TimeoutError:
+                await logger.adebug("PowerShell command timed out while checking for orphaned processes")
+            except Exception as e:  # noqa: BLE001
+                await logger.adebug(f"Error using PowerShell to find orphaned processes: {e}")
+
+            if killed_any:
+                # Give Windows time to clean up
+                await logger.adebug("Waiting 3 seconds for Windows to release port...")
+                await asyncio.sleep(3)
+
+            return killed_any  # noqa: TRY300
+
+        except Exception as e:  # noqa: BLE001
+            await logger.adebug(f"Error killing zombie processes: {e}")
+            return False
+
+    def _is_port_used_by_another_project(self, port: int, current_project_id: str) -> tuple[bool, str | None]:
+        """Check if a port is being used by another project.
+
+        Args:
+            port: The port to check
+            current_project_id: The current project ID
+
+        Returns:
+            Tuple of (is_used_by_other, other_project_id)
+        """
+        other_project_id = self._port_to_project.get(port)
+        if other_project_id and other_project_id != current_project_id:
+            return True, other_project_id
+        return False, None
 
     async def start(self):
         """Check if the MCP Composer service is enabled."""
@@ -125,47 +489,300 @@ class MCPComposerService(Service):
         composer_info = self.project_composers[project_id]
         process = composer_info.get("process")
 
-        if process:
-            try:
-                # Check if process is still running before trying to terminate
-                if process.poll() is None:
-                    await logger.adebug(f"Terminating MCP Composer process {process.pid} for project {project_id}")
-                    process.terminate()
+        try:
+            if process:
+                try:
+                    # Check if process is still running before trying to terminate
+                    if process.poll() is None:
+                        await logger.adebug(f"Terminating MCP Composer process {process.pid} for project {project_id}")
+                        process.terminate()
 
-                    # Wait longer for graceful shutdown
-                    try:
-                        await asyncio.wait_for(self._wait_for_process_exit(process), timeout=3.0)
-                        await logger.adebug(f"MCP Composer for project {project_id} terminated gracefully")
-                    except asyncio.TimeoutError:
-                        await logger.aerror(
-                            f"MCP Composer for project {project_id} did not terminate gracefully, force killing"
-                        )
-                        process.kill()
-                        # Wait a bit more for force kill to complete
+                        # Wait longer for graceful shutdown
                         try:
-                            await asyncio.wait_for(self._wait_for_process_exit(process), timeout=2.0)
+                            await asyncio.wait_for(asyncio.to_thread(process.wait), timeout=2.0)
+                            await logger.adebug(f"MCP Composer for project {project_id} terminated gracefully")
                         except asyncio.TimeoutError:
                             await logger.aerror(
-                                f"Failed to kill MCP Composer process {process.pid} for project {project_id}"
+                                f"MCP Composer for project {project_id} did not terminate gracefully, force killing"
                             )
-                else:
-                    await logger.adebug(f"MCP Composer process for project {project_id} was already terminated")
-
-                await logger.adebug(f"MCP Composer stopped for project {project_id}")
+                            await asyncio.to_thread(process.kill)
+                            await asyncio.to_thread(process.wait)
+                    else:
+                        await logger.adebug(f"MCP Composer process for project {project_id} was already terminated")
 
-            except ProcessLookupError:
-                # Process already terminated
-                await logger.adebug(f"MCP Composer process for project {project_id} was already terminated")
-            except Exception as e:  # noqa: BLE001
-                await logger.aerror(f"Error stopping MCP Composer for project {project_id}: {e}")
+                    await logger.adebug(f"MCP Composer stopped for project {project_id}")
 
-        # Remove from tracking
-        del self.project_composers[project_id]
+                except ProcessLookupError:
+                    # Process already terminated
+                    await logger.adebug(f"MCP Composer process for project {project_id} was already terminated")
+                except Exception as e:  # noqa: BLE001
+                    await logger.aerror(f"Error stopping MCP Composer for project {project_id}: {e}")
+        finally:
+            # Always clean up tracking, even if stopping failed
+            port = composer_info.get("port")
+            if port and self._port_to_project.get(port) == project_id:
+                self._port_to_project.pop(port, None)
+                await logger.adebug(f"Released port {port} from project {project_id}")
+
+            # Clean up PID tracking
+            if process and process.pid:
+                self._pid_to_project.pop(process.pid, None)
+                await logger.adebug(f"Released PID {process.pid} tracking for project {project_id}")
+
+            # Remove from tracking
+            self.project_composers.pop(project_id, None)
+            await logger.adebug(f"Removed tracking for project {project_id}")
 
     async def _wait_for_process_exit(self, process):
         """Wait for a process to exit."""
         await asyncio.to_thread(process.wait)
 
+    async def _read_process_output_and_extract_error(
+        self,
+        process: subprocess.Popen,
+        oauth_server_url: str | None,
+        timeout: float = 2.0,
+        stdout_file=None,
+        stderr_file=None,
+    ) -> tuple[str, str, str]:
+        """Read process output and extract user-friendly error message.
+
+        Args:
+            process: The subprocess to read from
+            oauth_server_url: OAuth server URL for error messages
+            timeout: Timeout for reading output
+            stdout_file: Optional file handle for stdout (Windows)
+            stderr_file: Optional file handle for stderr (Windows)
+
+        Returns:
+            Tuple of (stdout, stderr, error_message)
+        """
+        stdout_content = ""
+        stderr_content = ""
+
+        try:
+            # On Windows with temp files, read from files instead of pipes
+            if stdout_file and stderr_file:
+                # Close file handles to flush and allow reading
+                try:
+                    stdout_file.close()
+                    stderr_file.close()
+                except Exception as e:  # noqa: BLE001
+                    await logger.adebug(f"Error closing temp files: {e}")
+
+                # Read from temp files using asyncio.to_thread
+                try:
+
+                    def read_file(filepath):
+                        return Path(filepath).read_bytes()
+
+                    stdout_bytes = await asyncio.to_thread(read_file, stdout_file.name)
+                    stdout_content = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+                except Exception as e:  # noqa: BLE001
+                    await logger.adebug(f"Error reading stdout file: {e}")
+
+                try:
+
+                    def read_file(filepath):
+                        return Path(filepath).read_bytes()
+
+                    stderr_bytes = await asyncio.to_thread(read_file, stderr_file.name)
+                    stderr_content = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+                except Exception as e:  # noqa: BLE001
+                    await logger.adebug(f"Error reading stderr file: {e}")
+
+                # Clean up temp files
+                try:
+                    Path(stdout_file.name).unlink()
+                    Path(stderr_file.name).unlink()
+                except Exception as e:  # noqa: BLE001
+                    await logger.adebug(f"Error removing temp files: {e}")
+            else:
+                # Use asyncio.to_thread to avoid blocking the event loop
+                # Process returns bytes, decode with error handling
+                stdout_bytes, stderr_bytes = await asyncio.to_thread(process.communicate, timeout=timeout)
+                stdout_content = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+                stderr_content = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+
+        except subprocess.TimeoutExpired:
+            process.kill()
+            error_msg = self._extract_error_message("", "", oauth_server_url)
+            return "", "", error_msg
+
+        error_msg = self._extract_error_message(stdout_content, stderr_content, oauth_server_url)
+        return stdout_content, stderr_content, error_msg
+
+    async def _read_stream_non_blocking(self, stream, stream_name: str) -> str:
+        """Read from a stream without blocking and log the content.
+
+        Args:
+            stream: The stream to read from (stdout or stderr)
+            stream_name: Name of the stream for logging ("stdout" or "stderr")
+
+        Returns:
+            The content read from the stream (empty string if nothing available)
+        """
+        if not stream:
+            return ""
+
+        try:
+            # On Windows, select.select() doesn't work with pipes (only sockets)
+            # Use platform-specific approach
+            os_type = platform.system()
+
+            if os_type == "Windows":
+                # On Windows, select.select() doesn't work with pipes
+                # Skip stream reading during monitoring - output will be captured when process terminates
+                # This prevents blocking on peek() which can cause the monitoring loop to hang
+                return ""
+            # On Unix-like systems, use select
+            if select.select([stream], [], [], 0)[0]:
+                line_bytes = stream.readline()
+                if line_bytes:
+                    # Decode bytes with error handling
+                    line = line_bytes.decode("utf-8", errors="replace") if isinstance(line_bytes, bytes) else line_bytes
+                    stripped = line.strip()
+                    if stripped:
+                        # Log errors at error level, everything else at debug
+                        if stream_name == "stderr" and ("ERROR" in stripped or "error" in stripped):
+                            await logger.aerror(f"MCP Composer {stream_name}: {stripped}")
+                        else:
+                            await logger.adebug(f"MCP Composer {stream_name}: {stripped}")
+                        return stripped
+        except Exception as e:  # noqa: BLE001
+            await logger.adebug(f"Error reading {stream_name}: {e}")
+        return ""
+
+    async def _ensure_port_available(self, port: int, current_project_id: str) -> None:
+        """Ensure a port is available, only killing untracked processes.
+
+        Args:
+            port: The port number to ensure is available
+            current_project_id: The project ID requesting the port
+
+        Raises:
+            MCPComposerPortError: If port cannot be made available
+            MCPComposerConfigError: If port is invalid
+        """
+        try:
+            is_port_available = self._is_port_available(port)
+            await logger.adebug(f"Port {port} availability check: {is_port_available}")
+        except (ValueError, OverflowError, TypeError) as e:
+            # Port validation failed - invalid port number or type
+            # ValueError: from our validation
+            # OverflowError: from socket.bind() when port > 65535
+            # TypeError: when port is not an integer
+            error_msg = f"Invalid port number: {port}. Port must be an integer between 0 and 65535."
+            await logger.aerror(f"Invalid port for project {current_project_id}: {e}")
+            raise MCPComposerConfigError(error_msg, current_project_id) from e
+
+        if not is_port_available:
+            # Check if the port is being used by a tracked project
+            is_used_by_other, other_project_id = self._is_port_used_by_another_project(port, current_project_id)
+
+            if is_used_by_other and other_project_id:
+                # Port is being used by another tracked project
+                # Check if we can take ownership (e.g., the other project is failing)
+                other_composer = self.project_composers.get(other_project_id)
+                if other_composer and other_composer.get("process"):
+                    other_process = other_composer["process"]
+                    # If the other process is still running and healthy, don't kill it
+                    if other_process.poll() is None:
+                        await logger.aerror(
+                            f"Port {port} requested by project {current_project_id} is already in use by "
+                            f"project {other_project_id}. Will not kill active MCP Composer process."
+                        )
+                        port_error_msg = (
+                            f"Port {port} is already in use by another project. "
+                            f"Please choose a different port (e.g., {port + 1}) "
+                            f"or disable OAuth on the other project first."
+                        )
+                        raise MCPComposerPortError(port_error_msg, current_project_id)
+
+                    # Process died but port tracking wasn't cleaned up - allow takeover
+                    await logger.adebug(
+                        f"Port {port} was tracked to project {other_project_id} but process died. "
+                        f"Allowing project {current_project_id} to take ownership."
+                    )
+                    # Clean up the old tracking
+                    await self._do_stop_project_composer(other_project_id)
+
+            # Check if port is used by a process owned by the current project (e.g., stuck in startup loop)
+            port_owner_project = self._port_to_project.get(port)
+            if port_owner_project == current_project_id:
+                # Port is owned by current project - safe to kill
+                await logger.adebug(
+                    f"Port {port} is in use by current project {current_project_id} (likely stuck in startup). "
+                    f"Killing process to retry."
+                )
+                killed = await self._kill_process_on_port(port)
+                if killed:
+                    await logger.adebug(
+                        f"Successfully killed own process on port {port}. Waiting for port to be released..."
+                    )
+                    await asyncio.sleep(2)
+                    is_port_available = self._is_port_available(port)
+                    if not is_port_available:
+                        await logger.aerror(f"Port {port} is still in use after killing own process.")
+                        port_error_msg = f"Port {port} is still in use after killing process"
+                        raise MCPComposerPortError(port_error_msg)
+            else:
+                # Port is in use by unknown process - don't kill it (security concern)
+                await logger.aerror(
+                    f"Port {port} is in use by an unknown process (not owned by Langflow). "
+                    f"Will not kill external application for security reasons."
+                )
+                port_error_msg = (
+                    f"Port {port} is already in use by another application. "
+                    f"Please choose a different port (e.g., {port + 1}) or free up the port manually."
+                )
+                raise MCPComposerPortError(port_error_msg, current_project_id)
+
+        await logger.adebug(f"Port {port} is available, proceeding with MCP Composer startup")
+
+    async def _log_startup_error_details(
+        self,
+        project_id: str,
+        cmd: list[str],
+        host: str,
+        port: int,
+        stdout: str = "",
+        stderr: str = "",
+        error_msg: str = "",
+        exit_code: int | None = None,
+        pid: int | None = None,
+    ) -> None:
+        """Log detailed startup error information.
+
+        Args:
+            project_id: The project ID
+            cmd: The command that was executed
+            host: Target host
+            port: Target port
+            stdout: Standard output from the process
+            stderr: Standard error from the process
+            error_msg: User-friendly error message
+            exit_code: Process exit code (if terminated)
+            pid: Process ID (if still running)
+        """
+        await logger.aerror(f"MCP Composer startup failed for project {project_id}:")
+        if exit_code is not None:
+            await logger.aerror(f"  - Process died with exit code: {exit_code}")
+        if pid is not None:
+            await logger.aerror(f"  - Process is running (PID: {pid}) but failed to bind to port {port}")
+        await logger.aerror(f"  - Target: {host}:{port}")
+
+        # Obfuscate secrets in command before logging
+        safe_cmd = self._obfuscate_command_secrets(cmd)
+        await logger.aerror(f"  - Command: {' '.join(safe_cmd)}")
+
+        if stderr.strip():
+            await logger.aerror(f"  - Error output: {stderr.strip()}")
+        if stdout.strip():
+            await logger.aerror(f"  - Standard output: {stdout.strip()}")
+        if error_msg:
+            await logger.aerror(f"  - Error message: {error_msg}")
+
     def _validate_oauth_settings(self, auth_config: dict[str, Any]) -> None:
         """Validate that all required OAuth settings are present and non-empty.
 
@@ -205,6 +822,18 @@ class MCPComposerService(Service):
             config_error_msg = f"Invalid OAuth configuration: {'; '.join(error_parts)}"
             raise MCPComposerConfigError(config_error_msg)
 
+    @staticmethod
+    def _normalize_config_value(value: Any) -> Any:
+        """Normalize a config value (None or empty string becomes None).
+
+        Args:
+            value: The value to normalize
+
+        Returns:
+            None if value is None or empty string, otherwise the value
+        """
+        return None if (value is None or value == "") else value
+
     def _has_auth_config_changed(self, existing_auth: dict[str, Any] | None, new_auth: dict[str, Any] | None) -> bool:
         """Check if auth configuration has changed in a way that requires restart."""
         if not existing_auth and not new_auth:
@@ -230,12 +859,8 @@ class MCPComposerService(Service):
 
         # Compare relevant fields
         for field in fields_to_check:
-            old_val = existing_auth.get(field)
-            new_val = new_auth.get(field)
-
-            # Convert None and empty string to None for comparison
-            old_normalized = None if (old_val is None or old_val == "") else old_val
-            new_normalized = None if (new_val is None or new_val == "") else new_val
+            old_normalized = self._normalize_config_value(existing_auth.get(field))
+            new_normalized = self._normalize_config_value(new_auth.get(field))
 
             if old_normalized != new_normalized:
                 return True
@@ -252,23 +877,30 @@ class MCPComposerService(Service):
             List of command arguments with secrets replaced with ***REDACTED***
         """
         safe_cmd = []
-        skip_next = False
+        i = 0
 
-        for i, arg in enumerate(cmd):
-            if skip_next:
-                skip_next = False
-                safe_cmd.append("***REDACTED***")
-                continue
+        while i < len(cmd):
+            arg = cmd[i]
 
+            # Check if this is --env followed by a secret key
             if arg == "--env" and i + 2 < len(cmd):
-                # Check if next env var is a secret
                 env_key = cmd[i + 1]
+                env_value = cmd[i + 2]
+
                 if any(secret in env_key.lower() for secret in ["secret", "key", "token"]):
-                    safe_cmd.extend([arg, env_key])  # Keep env key, redact value
-                    skip_next = True
+                    # Redact the value
+                    safe_cmd.extend([arg, env_key, "***REDACTED***"])
+                    i += 3  # Skip all three: --env, key, and value
                     continue
 
+                # Not a secret, keep as-is
+                safe_cmd.extend([arg, env_key, env_value])
+                i += 3
+                continue
+
+            # Regular argument
             safe_cmd.append(arg)
+            i += 1
 
         return safe_cmd
 
@@ -319,16 +951,93 @@ class MCPComposerService(Service):
     async def start_project_composer(
         self,
         project_id: str,
-        sse_url: str,
+        streamable_http_url: str,
         auth_config: dict[str, Any] | None,
-        max_startup_checks: int = 5,
+        max_retries: int = 3,
+        max_startup_checks: int = 40,
         startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
     ) -> None:
         """Start an MCP Composer instance for a specific project.
 
+        Args:
+            project_id: The project ID
+            streamable_http_url: Streamable HTTP endpoint for the remote Langflow MCP server
+            auth_config: Authentication configuration
+            max_retries: Maximum number of retry attempts (default: 3)
+            max_startup_checks: Number of checks per retry attempt (default: 40)
+            startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility
+
         Raises:
             MCPComposerError: Various specific errors if startup fails
         """
+        # Cancel any active start operation for this project
+        if project_id in self._active_start_tasks:
+            active_task = self._active_start_tasks[project_id]
+            if not active_task.done():
+                await logger.adebug(f"Cancelling previous MCP Composer start operation for project {project_id}")
+                active_task.cancel()
+                try:
+                    await active_task
+                except asyncio.CancelledError:
+                    await logger.adebug(f"Previous start operation for project {project_id} cancelled successfully")
+                finally:
+                    # Clean up the cancelled task from tracking
+                    del self._active_start_tasks[project_id]
+
+        # Create and track the current task
+        current_task = asyncio.current_task()
+        if not current_task:
+            await logger.awarning(
+                f"Could not get current task for project {project_id}. "
+                f"Concurrent start operations may not be properly cancelled."
+            )
+        else:
+            self._active_start_tasks[project_id] = current_task
+
+        try:
+            await self._do_start_project_composer(
+                project_id,
+                streamable_http_url,
+                auth_config,
+                max_retries,
+                max_startup_checks,
+                startup_delay,
+                legacy_sse_url=legacy_sse_url,
+            )
+        finally:
+            # Clean up the task reference when done
+            if project_id in self._active_start_tasks and self._active_start_tasks[project_id] == current_task:
+                del self._active_start_tasks[project_id]
+
+    async def _do_start_project_composer(
+        self,
+        project_id: str,
+        streamable_http_url: str,
+        auth_config: dict[str, Any] | None,
+        max_retries: int = 3,
+        max_startup_checks: int = 40,
+        startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
+    ) -> None:
+        """Internal method to start an MCP Composer instance.
+
+        Args:
+            project_id: The project ID
+            streamable_http_url: Streamable HTTP endpoint for the remote Langflow MCP server
+            auth_config: Authentication configuration
+            max_retries: Maximum number of retry attempts (default: 3)
+            max_startup_checks: Number of checks per retry attempt (default: 40)
+            startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility
+
+        Raises:
+            MCPComposerError: Various specific errors if startup fails
+        """
+        legacy_sse_url = legacy_sse_url or f"{streamable_http_url.rstrip('/')}/sse"
         if not auth_config:
             no_auth_error_msg = "No auth settings provided"
             raise MCPComposerConfigError(no_auth_error_msg, project_id)
@@ -366,11 +1075,13 @@ class MCPComposerService(Service):
                 composer_info = self.project_composers[project_id]
                 process = composer_info.get("process")
                 existing_auth = composer_info.get("auth_config", {})
+                existing_port = composer_info.get("port")
 
                 # Check if process is still running
                 if process and process.poll() is None:
                     # Process is running - only restart if config changed
                     auth_changed = self._has_auth_config_changed(existing_auth, auth_config)
+
                     if auth_changed:
                         await logger.adebug(f"Config changed for project {project_id}, restarting MCP Composer")
                         await self._do_stop_project_composer(project_id)
@@ -383,48 +1094,181 @@ class MCPComposerService(Service):
                     # Process died or never started properly, restart it
                     await logger.adebug(f"MCP Composer process died for project {project_id}, restarting")
                     await self._do_stop_project_composer(project_id)
+                    # Also kill any process that might be using the old port
+                    if existing_port:
+                        try:
+                            await asyncio.wait_for(self._kill_process_on_port(existing_port), timeout=5.0)
+                        except asyncio.TimeoutError:
+                            await logger.aerror(f"Timeout while killing process on port {existing_port}")
 
-            is_port_available = self._is_port_available(project_port)
-            if not is_port_available:
-                await logger.awarning(f"Port {project_port} is already in use.")
-                port_error_msg = f"Port {project_port} is already in use"
-                raise MCPComposerPortError(port_error_msg)
+            # Retry loop: try starting the process multiple times
+            last_error = None
+            try:
+                # Before first attempt, try to kill any zombie MCP Composer processes
+                # This is a best-effort operation - don't fail startup if it errors
+                try:
+                    await logger.adebug(
+                        f"Checking for zombie MCP Composer processes on port {project_port} before startup..."
+                    )
+                    zombies_killed = await self._kill_zombie_mcp_processes(project_port)
+                    if zombies_killed:
+                        await logger.adebug(f"Killed zombie processes, port {project_port} should now be free")
+                except Exception as zombie_error:  # noqa: BLE001
+                    # Log but continue - zombie cleanup is optional
+                    await logger.awarning(
+                        f"Failed to check/kill zombie processes (non-fatal): {zombie_error}. Continuing with startup..."
+                    )
 
-            # Start the MCP Composer process (single attempt, no outer retry loop)
-            process = await self._start_project_composer_process(
-                project_id, project_host, project_port, sse_url, auth_config, max_startup_checks, startup_delay
-            )
-            self.project_composers[project_id] = {
-                "process": process,
-                "host": project_host,
-                "port": project_port,
-                "sse_url": sse_url,
-                "auth_config": auth_config,
-            }
+                # Ensure port is available (only kill untracked processes)
+                try:
+                    await self._ensure_port_available(project_port, project_id)
+                except (MCPComposerPortError, MCPComposerConfigError) as e:
+                    # Port/config error before starting - store and raise immediately (no retries)
+                    self._last_errors[project_id] = e.message
+                    raise
+                for retry_attempt in range(1, max_retries + 1):
+                    try:
+                        await logger.adebug(
+                            f"Starting MCP Composer for project {project_id} (attempt {retry_attempt}/{max_retries})"
+                        )
 
-            await logger.adebug(
-                f"MCP Composer started for project {project_id} on port {project_port} (PID: {process.pid})"
-            )
+                        # Re-check port availability before each attempt to prevent race conditions
+                        if retry_attempt > 1:
+                            await logger.adebug(f"Re-checking port {project_port} availability before retry...")
+                            await self._ensure_port_available(project_port, project_id)
+
+                        process = await self._start_project_composer_process(
+                            project_id,
+                            project_host,
+                            project_port,
+                            streamable_http_url,
+                            auth_config,
+                            max_startup_checks,
+                            startup_delay,
+                            legacy_sse_url=legacy_sse_url,
+                        )
+
+                    except MCPComposerError as e:
+                        last_error = e
+                        await logger.aerror(
+                            f"MCP Composer startup attempt {retry_attempt}/{max_retries} failed "
+                            f"for project {project_id}: {e.message}"
+                        )
+
+                        # For config/port errors, don't retry - fail immediately
+                        if isinstance(e, (MCPComposerConfigError, MCPComposerPortError)):
+                            await logger.aerror(
+                                f"Configuration or port error for project {project_id}, not retrying: {e.message}"
+                            )
+                            raise  # Re-raise to exit retry loop immediately
+
+                        # Clean up any partially started process before retrying
+                        if project_id in self.project_composers:
+                            await self._do_stop_project_composer(project_id)
+
+                        # If not the last attempt, wait and try to clean up zombie processes
+                        if retry_attempt < max_retries:
+                            await logger.adebug(f"Waiting 2 seconds before retry attempt {retry_attempt + 1}...")
+                            await asyncio.sleep(2)
+
+                            # On Windows, try to kill any zombie MCP Composer processes for this port
+                            # This is a best-effort operation - don't fail retry if it errors
+                            try:
+                                msg = f"Checking for zombie MCP Composer processes on port {project_port}"
+                                await logger.adebug(msg)
+                                zombies_killed = await self._kill_zombie_mcp_processes(project_port)
+                                if zombies_killed:
+                                    await logger.adebug(f"Killed zombie processes, port {project_port} should be free")
+                            except Exception as retry_zombie_error:  # noqa: BLE001
+                                # Log but continue - zombie cleanup is optional
+                                msg = f"Failed to check/kill zombie processes during retry: {retry_zombie_error}"
+                                await logger.awarning(msg)
+
+                    else:
+                        # Success! Store the composer info and register the port and PID
+                        self.project_composers[project_id] = {
+                            "process": process,
+                            "host": project_host,
+                            "port": project_port,
+                            "streamable_http_url": streamable_http_url,
+                            "legacy_sse_url": legacy_sse_url,
+                            "sse_url": legacy_sse_url,
+                            "auth_config": auth_config,
+                        }
+                        self._port_to_project[project_port] = project_id
+                        self._pid_to_project[process.pid] = project_id
+                        # Clear any previous error on success
+                        self.clear_last_error(project_id)
+
+                        await logger.adebug(
+                            f"MCP Composer started for project {project_id} on port {project_port} "
+                            f"(PID: {process.pid}) after {retry_attempt} attempt(s)"
+                        )
+                        return  # Success!
+
+                # All retries failed, raise the last error
+                if last_error:
+                    await logger.aerror(
+                        f"MCP Composer failed to start for project {project_id} after {max_retries} attempts"
+                    )
+                    # Store the error message for later retrieval
+                    self._last_errors[project_id] = last_error.message
+                    raise last_error
+
+            except asyncio.CancelledError:
+                # Operation was cancelled, clean up any started process
+                await logger.adebug(f"MCP Composer start operation for project {project_id} was cancelled")
+                if project_id in self.project_composers:
+                    await self._do_stop_project_composer(project_id)
+                raise  # Re-raise to propagate cancellation
 
     async def _start_project_composer_process(
         self,
         project_id: str,
         host: str,
         port: int,
-        sse_url: str,
+        streamable_http_url: str,
         auth_config: dict[str, Any] | None = None,
-        max_startup_checks: int = 5,
+        max_startup_checks: int = 40,
         startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
     ) -> subprocess.Popen:
-        """Start the MCP Composer subprocess for a specific project."""
+        """Start the MCP Composer subprocess for a specific project.
+
+        Args:
+            project_id: The project ID
+            host: Host to bind to
+            port: Port to bind to
+            streamable_http_url: Streamable HTTP endpoint to connect to
+            auth_config: Authentication configuration
+            max_startup_checks: Number of port binding checks (default: 40)
+            startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility when required by tooling
+
+        Returns:
+            The started subprocess
+
+        Raises:
+            MCPComposerStartupError: If startup fails
+        """
         settings = get_settings_service().settings
+        # Some composer tooling still uses the --sse-url flag for backwards compatibility even in HTTP mode.
+        effective_legacy_sse_url = legacy_sse_url or f"{streamable_http_url.rstrip('/')}/sse"
+
         cmd = [
             "uvx",
             f"mcp-composer{settings.mcp_composer_version}",
+            "--port",
+            str(port),
+            "--host",
+            host,
             "--mode",
-            "sse",
+            "http",
+            "--endpoint",
+            streamable_http_url,
             "--sse-url",
-            sse_url,
+            effective_legacy_sse_url,
             "--disable-composer-tools",
         ]
 
@@ -442,6 +1286,8 @@ class MCPComposerService(Service):
                 cmd.extend(["--env", "ENABLE_OAUTH", "True"])
 
                 # Map auth config to environment variables for OAuth
+                # Note: oauth_host and oauth_port are passed both via --host/--port CLI args
+                # (for server binding) and as environment variables (for OAuth flow)
                 oauth_env_mapping = {
                     "oauth_host": "OAUTH_HOST",
                     "oauth_port": "OAUTH_PORT",
@@ -462,68 +1308,102 @@ class MCPComposerService(Service):
                     if value is not None and str(value).strip():
                         cmd.extend(["--env", env_key, str(value)])
 
+        # Log the command being executed (with secrets obfuscated)
+        safe_cmd = self._obfuscate_command_secrets(cmd)
+        await logger.adebug(f"Starting MCP Composer with command: {' '.join(safe_cmd)}")
+
         # Start the subprocess with both stdout and stderr captured
-        process = subprocess.Popen(cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)  # noqa: ASYNC220, S603
+        # On Windows, use temp files to avoid pipe buffering issues that can cause process to hang
+        stdout_handle: int | typing.IO[bytes] = subprocess.PIPE
+        stderr_handle: int | typing.IO[bytes] = subprocess.PIPE
+        stdout_file = None
+        stderr_file = None
+
+        if platform.system() == "Windows":
+            # Create temp files for stdout/stderr on Windows to avoid pipe deadlocks
+            # Note: We intentionally don't use context manager as we need files to persist
+            # for the subprocess and be cleaned up manually later
+            stdout_file = tempfile.NamedTemporaryFile(  # noqa: SIM115
+                mode="w+b", delete=False, prefix=f"mcp_composer_{project_id}_stdout_", suffix=".log"
+            )
+            stderr_file = tempfile.NamedTemporaryFile(  # noqa: SIM115
+                mode="w+b", delete=False, prefix=f"mcp_composer_{project_id}_stderr_", suffix=".log"
+            )
+            stdout_handle = stdout_file
+            stderr_handle = stderr_file
+            stdout_name = stdout_file.name
+            stderr_name = stderr_file.name
+            await logger.adebug(f"Using temp files for MCP Composer logs: stdout={stdout_name}, stderr={stderr_name}")
+
+        process = subprocess.Popen(cmd, env=env, stdout=stdout_handle, stderr=stderr_handle)  # noqa: ASYNC220, S603
 
         # Monitor the process startup with multiple checks
         process_running = False
         port_bound = False
 
-        await logger.adebug(f"Monitoring MCP Composer startup for project {project_id} (PID: {process.pid})")
+        await logger.adebug(
+            f"MCP Composer process started with PID {process.pid}, monitoring startup for project {project_id}..."
+        )
 
-        for check in range(max_startup_checks):
-            await asyncio.sleep(startup_delay)
+        try:
+            for check in range(max_startup_checks):
+                await asyncio.sleep(startup_delay)
 
-            # Check if process is still running
-            poll_result = process.poll()
+                # Check if process is still running
+                poll_result = process.poll()
 
-            startup_error_msg = None
-            if poll_result is not None:
-                # Process terminated, get the error output
-                await logger.aerror(f"MCP Composer process {process.pid} terminated with exit code: {poll_result}")
-                try:
-                    stdout_content, stderr_content = process.communicate(timeout=2)
-                    # Log the full error details for debugging
-                    await logger.aerror(f"MCP Composer startup failed for project {project_id}")
-                    await logger.aerror(f"MCP Composer stdout:\n{stdout_content}")
-                    await logger.aerror(f"MCP Composer stderr:\n{stderr_content}")
-                    safe_cmd = self._obfuscate_command_secrets(cmd)
-                    await logger.aerror(f"Command that failed: {' '.join(safe_cmd)}")
-
-                    # Extract meaningful error message
-                    startup_error_msg = self._extract_error_message(stdout_content, stderr_content, oauth_server_url)
-                    raise MCPComposerStartupError(startup_error_msg, project_id)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    await logger.aerror(
-                        f"MCP Composer process {process.pid} terminated unexpectedly for project {project_id}"
+                startup_error_msg = None
+                if poll_result is not None:
+                    # Process terminated, get the error output
+                    (
+                        stdout_content,
+                        stderr_content,
+                        startup_error_msg,
+                    ) = await self._read_process_output_and_extract_error(
+                        process, oauth_server_url, stdout_file=stdout_file, stderr_file=stderr_file
                     )
-                    startup_error_msg = self._extract_error_message("", "", oauth_server_url)
-                    raise MCPComposerStartupError(startup_error_msg, project_id) from None
+                    await self._log_startup_error_details(
+                        project_id, cmd, host, port, stdout_content, stderr_content, startup_error_msg, poll_result
+                    )
+                    raise MCPComposerStartupError(startup_error_msg, project_id)
 
-            # Process is still running, check if port is bound
-            port_bound = not self._is_port_available(port)
+                # Process is still running, check if port is bound
+                port_bound = not self._is_port_available(port)
 
-            if port_bound:
+                if port_bound:
+                    await logger.adebug(
+                        f"MCP Composer for project {project_id} bound to port {port} "
+                        f"(check {check + 1}/{max_startup_checks})"
+                    )
+                    process_running = True
+                    break
                 await logger.adebug(
-                    f"MCP Composer for project {project_id} bound to port {port} "
+                    f"MCP Composer for project {project_id} not yet bound to port {port} "
                     f"(check {check + 1}/{max_startup_checks})"
                 )
-                process_running = True
-                break
+
+                # Try to read any available stderr/stdout without blocking to see what's happening
+                await self._read_stream_non_blocking(process.stderr, "stderr")
+                await self._read_stream_non_blocking(process.stdout, "stdout")
+
+        except asyncio.CancelledError:
+            # Operation was cancelled, kill the process and cleanup
             await logger.adebug(
-                f"MCP Composer for project {project_id} not yet bound to port {port} "
-                f"(check {check + 1}/{max_startup_checks})"
+                f"MCP Composer process startup cancelled for project {project_id}, terminating process {process.pid}"
             )
-
-            # Try to read any available stderr without blocking (only log if there's an error)
-            if process.stderr and select.select([process.stderr], [], [], 0)[0]:
+            try:
+                process.terminate()
+                # Wait for graceful termination with timeout
                 try:
-                    stderr_line = process.stderr.readline()
-                    if stderr_line and "ERROR" in stderr_line:
-                        await logger.aerror(f"MCP Composer error: {stderr_line.strip()}")
-                except Exception:  # noqa: BLE001
-                    pass
+                    await asyncio.wait_for(asyncio.to_thread(process.wait), timeout=2.0)
+                except asyncio.TimeoutError:
+                    # Force kill if graceful termination times out
+                    await logger.adebug(f"Process {process.pid} did not terminate gracefully, force killing")
+                    await asyncio.to_thread(process.kill)
+                    await asyncio.to_thread(process.wait)
+            except Exception as e:  # noqa: BLE001
+                await logger.adebug(f"Error terminating process during cancellation: {e}")
+            raise  # Re-raise to propagate cancellation
 
         # After all checks
         if not process_running or not port_bound:
@@ -532,56 +1412,43 @@ class MCPComposerService(Service):
 
             if poll_result is not None:
                 # Process died
-                startup_error_msg = None
-                try:
-                    stdout_content, stderr_content = process.communicate(timeout=2)
-                    # Extract meaningful error message
-                    startup_error_msg = self._extract_error_message(stdout_content, stderr_content, oauth_server_url)
-                    await logger.aerror(f"MCP Composer startup failed for project {project_id}:")
-                    await logger.aerror(f"  - Process died with exit code: {poll_result}")
-                    await logger.aerror(f"  - Target: {host}:{port}")
-                    # Obfuscate secrets in command before logging
-                    safe_cmd = self._obfuscate_command_secrets(cmd)
-                    await logger.aerror(f"  - Command: {' '.join(safe_cmd)}")
-                    if stderr_content.strip():
-                        await logger.aerror(f"  - Error output: {stderr_content.strip()}")
-                    if stdout_content.strip():
-                        await logger.aerror(f"  - Standard output: {stdout_content.strip()}")
-                    await logger.aerror(f"  - Error message: {startup_error_msg}")
-                except subprocess.TimeoutExpired:
-                    await logger.aerror(f"MCP Composer for project {project_id} died but couldn't read output")
-                    process.kill()
-
+                stdout_content, stderr_content, startup_error_msg = await self._read_process_output_and_extract_error(
+                    process, oauth_server_url, stdout_file=stdout_file, stderr_file=stderr_file
+                )
+                await self._log_startup_error_details(
+                    project_id, cmd, host, port, stdout_content, stderr_content, startup_error_msg, poll_result
+                )
                 raise MCPComposerStartupError(startup_error_msg, project_id)
             # Process running but port not bound
-            await logger.aerror(f"MCP Composer startup failed for project {project_id}:")
-            await logger.aerror(f"  - Process is running (PID: {process.pid}) but failed to bind to port {port}")
             await logger.aerror(
                 f"  - Checked {max_startup_checks} times over {max_startup_checks * startup_delay} seconds"
             )
-            await logger.aerror(f"  - Target: {host}:{port}")
 
             # Get any available output before terminating
-            startup_error_msg = None
-            try:
-                process.terminate()
-                stdout_content, stderr_content = process.communicate(timeout=2)
-                startup_error_msg = self._extract_error_message(stdout_content, stderr_content, oauth_server_url)
-                if stderr_content.strip():
-                    await logger.aerror(f"  - Process stderr: {stderr_content.strip()}")
-                if stdout_content.strip():
-                    await logger.aerror(f"  - Process stdout: {stdout_content.strip()}")
-            except Exception:  # noqa: BLE001
-                process.kill()
-                await logger.aerror("  - Could not retrieve process output before termination")
-
+            process.terminate()
+            stdout_content, stderr_content, startup_error_msg = await self._read_process_output_and_extract_error(
+                process, oauth_server_url, stdout_file=stdout_file, stderr_file=stderr_file
+            )
+            await self._log_startup_error_details(
+                project_id, cmd, host, port, stdout_content, stderr_content, startup_error_msg, pid=process.pid
+            )
             raise MCPComposerStartupError(startup_error_msg, project_id)
 
-        # Close the pipes if everything is successful
-        if process.stdout:
-            process.stdout.close()
-        if process.stderr:
-            process.stderr.close()
+        # Close the pipes/files if everything is successful
+        if stdout_file and stderr_file:
+            # Clean up temp files on success
+            try:
+                stdout_file.close()
+                stderr_file.close()
+                Path(stdout_file.name).unlink()
+                Path(stderr_file.name).unlink()
+            except Exception as e:  # noqa: BLE001
+                await logger.adebug(f"Error cleaning up temp files on success: {e}")
+        else:
+            if process.stdout:
+                process.stdout.close()
+            if process.stderr:
+                process.stderr.close()
 
         return process