crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/mcp/progress_monitor.py

@@ -5,6 +5,7 @@ import subprocess
 import sys
 import tempfile
 import time
+import typing as t
 from contextlib import suppress
 from pathlib import Path
 
@@ -26,7 +27,7 @@ from .progress_components import (
 
 
 class AgentStatusPanel(Widget):
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.border_title = "🤖 AI Agents"
         self.border_title_align = "left"
@@ -49,13 +50,13 @@ class AgentStatusPanel(Widget):
 
             agents_table.styles.max_height = "8"
 
-    def update_agent_data(self, agent_data: dict) -> None:
+    def update_agent_data(self, agent_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             self._update_coordinator_status(agent_data)
             self._update_agents_table(agent_data)
             self._update_stats(agent_data)
 
-    def _update_coordinator_status(self, data: dict) -> None:
+    def _update_coordinator_status(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             activity = data.get("agent_activity", {})
             registry = activity.get("agent_registry", {})
@@ -68,7 +69,7 @@ class AgentStatusPanel(Widget):
                 f"Coordinator: {status_emoji} {coordinator_status.title()} ({total_agents} agents)",
             )
 
-    def _update_agents_table(self, data: dict) -> None:
+    def _update_agents_table(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             agents_table = self.query_one("#agents-table", DataTable)
             agents_table.clear()
@@ -105,7 +106,7 @@ class AgentStatusPanel(Widget):
                     f"{processing_time: .1f}s" if processing_time > 0 else "-",
                 )
 
-    def _update_stats(self, data: dict) -> None:
+    def _update_stats(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             performance = data.get("agent_performance", {})
             total_issues = performance.get("total_issues_processed", 0)
@@ -152,12 +153,12 @@ class AgentStatusPanel(Widget):
 
 
 class JobPanel(Widget):
-    def __init__(self, job_data: dict, **kwargs) -> None:
+    def __init__(self, job_data: dict[str, t.Any], **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.job_data = job_data
         self.completion_time = None
         self.iteration_count = job_data.get("iteration", 0)
-        self.max_iterations = job_data.get("max_iterations", 10)
+        self.max_iterations = job_data.get("max_iterations", 5)
         self.fade_timer = None
         self.remove_timer = None
         self.fade_level = 0
@@ -417,11 +418,13 @@ class CrackerjackDashboard(App):
 
     def __init__(self) -> None:
         super().__init__()
-        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack - mcp-progress"
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
         self.websocket_url = "ws://localhost:8675"
         self.refresh_timer = None
-        self.active_jobs = {}
-        self.completed_jobs_stats = {}
+        self._refresh_counter = 0
+        self.dev = False
+        self.active_jobs: dict[str, t.Any] = {}
+        self.completed_jobs_stats: dict[str, t.Any] = {}
         self.current_polling_method = "File"
         self.timeout_manager = get_timeout_manager()
 
@@ -532,19 +535,14 @@ class CrackerjackDashboard(App):
 
     async def _refresh_data(self) -> None:
         try:
-            # Refresh cycle with timeout protection
             async with self.timeout_manager.timeout_context(
                 "network_operations",
-                timeout=10.0,  # Total refresh timeout
+                timeout=10.0,
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             ):
-                if hasattr(self, "_refresh_counter"):
-                    self._refresh_counter += 1
-                else:
-                    self._refresh_counter = 0
+                self._refresh_counter += 1
 
-                # Ensure services running less frequently to avoid overhead
-                if self._refresh_counter % 20 == 0:  # Every 10 seconds instead of 5
+                if self._refresh_counter % 20 == 0:
                     with suppress(Exception):
                         await self.timeout_manager.with_timeout(
                             "network_operations",
@@ -553,7 +551,6 @@ class CrackerjackDashboard(App):
                             strategy=TimeoutStrategy.FAIL_FAST,
                         )
 
-                # Collect data with individual timeouts
                 jobs_data = await self.timeout_manager.with_timeout(
                     "network_operations",
                     self._discover_jobs(),
@@ -575,7 +572,6 @@ class CrackerjackDashboard(App):
                     strategy=TimeoutStrategy.FAIL_FAST,
                 )
 
-                # Update UI components
                 self.query_one("#services-panel").border_title = "🔧 Services"
 
                 self._update_jobs_table(jobs_data)
@@ -586,12 +582,11 @@ class CrackerjackDashboard(App):
                 self._update_status_bars(jobs_data)
 
         except Exception as e:
-            # Log error but don't crash the dashboard
             with suppress(Exception):
                 console = Console()
                 console.print(f"[red]Dashboard refresh error: {e}[/red]")
 
-    async def _discover_jobs(self) -> dict:
+    async def _discover_jobs(self) -> dict[str, t.Any]:
         try:
             result = await self.timeout_manager.with_timeout(
                 "network_operations",
@@ -600,9 +595,9 @@ class CrackerjackDashboard(App):
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
             self.current_polling_method = result["method"]
-            return result["data"]
+            data_result = result["data"]
+            return t.cast(dict[str, t.Any], data_result)
         except Exception:
-            # Return empty data structure on timeout or error
             return {
                 "active": 0,
                 "completed": 0,
@@ -615,31 +610,31 @@ class CrackerjackDashboard(App):
                 "current_errors": 0,
             }
 
-    async def _collect_services_data(self) -> list:
+    async def _collect_services_data(self) -> list[t.Any]:
         try:
-            return await self.timeout_manager.with_timeout(
+            services_data = await self.timeout_manager.with_timeout(
                 "network_operations",
                 self.service_checker.collect_services_data(),
                 timeout=3.0,
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
+            return t.cast(list[t.Any], services_data)
         except Exception:
-            # Return minimal service data on timeout
             return [("Services", "🔴 Timeout", "0")]
 
-    async def _collect_recent_errors(self) -> list:
+    async def _collect_recent_errors(self) -> list[t.Any]:
         try:
-            return await self.timeout_manager.with_timeout(
+            errors_data = await self.timeout_manager.with_timeout(
                 "file_operations",
                 self.error_collector.collect_recent_errors(),
                 timeout=2.0,
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
+            return t.cast(list[t.Any], errors_data)
         except Exception:
-            # Return empty error list on timeout
             return []
 
-    def _update_jobs_table(self, jobs_data: dict) -> None:
+    def _update_jobs_table(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             jobs_table = self.query_one("#jobs-table", DataTable)
             jobs_table.clear()
@@ -681,7 +676,7 @@ class CrackerjackDashboard(App):
                 ],
             )
 
-    def _update_services_table(self, services_data: list) -> None:
+    def _update_services_table(self, services_data: list[t.Any]) -> None:
         with suppress(Exception):
             services_table = self.query_one("#services-table", DataTable)
             services_table.clear()
@@ -705,7 +700,7 @@ class CrackerjackDashboard(App):
                 polling_status += " 🟢"
             services_table.add_row("Polling", polling_status, "")
 
-    def _update_errors_table(self, errors_data: list) -> None:
+    def _update_errors_table(self, errors_data: list[t.Any]) -> None:
         with suppress(Exception):
             errors_table = self.query_one("#errors-table", DataTable)
             errors_table.clear()
@@ -767,7 +762,7 @@ class CrackerjackDashboard(App):
                 ],
             )
 
-    def _update_agent_panel(self, jobs_data: dict) -> None:
+    def _update_agent_panel(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             agent_panel = self.query_one("#agent - status-panel", AgentStatusPanel)
 
@@ -780,7 +775,7 @@ class CrackerjackDashboard(App):
             if agent_data:
                 agent_panel.update_agent_data(agent_data)
 
-    def _update_job_panels(self, jobs_data: dict) -> None:
+    def _update_job_panels(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             container = self.query_one("#job - discovery-container")
             current_job_ids = self._get_current_job_ids(jobs_data)
@@ -789,14 +784,14 @@ class CrackerjackDashboard(App):
             self._update_or_create_panels(jobs_data, container)
             self._handle_placeholder_visibility(container)
 
-    def _get_current_job_ids(self, jobs_data: dict) -> set:
+    def _get_current_job_ids(self, jobs_data: dict[str, t.Any]) -> set[t.Any]:
         return (
             {job["job_id"] for job in jobs_data["individual_jobs"]}
             if jobs_data["individual_jobs"]
             else set()
         )
 
-    def _remove_obsolete_panels(self, current_job_ids: set) -> None:
+    def _remove_obsolete_panels(self, current_job_ids: set[t.Any]) -> None:
         jobs_to_remove = []
         for job_id, panel in self.active_jobs.items():
             panel_status = panel.job_data.get("status", "").lower()
@@ -811,7 +806,9 @@ class CrackerjackDashboard(App):
             panel = self.active_jobs.pop(job_id)
             panel.remove()
 
-    def _update_or_create_panels(self, jobs_data: dict, container) -> None:
+    def _update_or_create_panels(
+        self, jobs_data: dict[str, t.Any], container: t.Any
+    ) -> None:
         if not jobs_data["individual_jobs"]:
             return
 
@@ -822,7 +819,7 @@ class CrackerjackDashboard(App):
             else:
                 self._create_new_panel(job, container)
 
-    def _update_existing_panel(self, job: dict) -> None:
+    def _update_existing_panel(self, job: dict[str, t.Any]) -> None:
         existing_panel = self.active_jobs[job["job_id"]]
         existing_panel.job_data = job
         existing_panel.iteration_count = job.get("iteration", 0)
@@ -833,7 +830,7 @@ class CrackerjackDashboard(App):
         self._handle_job_completion(existing_panel, job)
         self._update_panel_border(existing_panel)
 
-    def _update_panel_title(self, panel, job: dict) -> None:
+    def _update_panel_title(self, panel: t.Any, job: dict[str, t.Any]) -> None:
         project_name = job.get("project", "crackerjack")
         status = job.get("status", "").lower()
 
@@ -846,25 +843,25 @@ class CrackerjackDashboard(App):
         else:
             panel.border_subtitle = ""
 
-    def _handle_job_completion(self, panel, job: dict) -> None:
+    def _handle_job_completion(self, panel: t.Any, job: dict[str, t.Any]) -> None:
         job_status = job.get("status", "").lower()
         if job_status in ("completed", "failed") and panel.completion_time is None:
             panel.completion_time = time.time()
             panel.fade_timer = panel.set_timer(300.0, panel._start_fade)
             panel.remove_timer = panel.set_timer(1200.0, panel._remove_panel)
 
-    def _update_panel_border(self, panel) -> None:
+    def _update_panel_border(self, panel: t.Any) -> None:
         new_border = panel._calculate_border_style()
         if new_border != panel.border_style:
             panel.border_style = new_border
             panel.refresh()
 
-    def _create_new_panel(self, job: dict, container) -> None:
+    def _create_new_panel(self, job: dict[str, t.Any], container: t.Any) -> None:
         job_panel = JobPanel(job)
         self.active_jobs[job["job_id"]] = job_panel
         container.mount(job_panel)
 
-    def _handle_placeholder_visibility(self, container) -> None:
+    def _handle_placeholder_visibility(self, container: t.Any) -> None:
         has_placeholder = bool(container.query("#no - jobs-label"))
 
         if not self.active_jobs and not has_placeholder:
@@ -877,7 +874,7 @@ class CrackerjackDashboard(App):
         elif self.active_jobs and has_placeholder:
             container.query("#no - jobs-label").remove()
 
-    def _update_status_bars(self, jobs_data: dict) -> None:
+    def _update_status_bars(self, jobs_data: dict[str, t.Any]) -> None:
         pass
 
     def action_refresh(self) -> None:
@@ -908,7 +905,7 @@ class CrackerjackDashboard(App):
     def _restore_terminal_fallback(self) -> None:
         self.terminal_restorer.restore_terminal()
 
-    def _signal_handler(self, _signum, _frame) -> None:
+    def _signal_handler(self, _signum: t.Any, _frame: t.Any) -> None:
         with suppress(Exception):
             self._restore_terminal()
             self._cleanup_started_services()
@@ -941,18 +938,18 @@ class JobMetrics:
         self.completion_time: float | None = None
 
         self.iteration = 0
-        self.max_iterations = 10
+        self.max_iterations = 5
         self.current_stage = "Initializing"
         self.status = "running"
         self.message = ""
 
-        self.stages_completed = set()
-        self.stages_failed = set()
+        self.stages_completed: set[str] = set()
+        self.stages_failed: set[str] = set()
 
-        self.errors = []
-        self.warnings = []
-        self.hook_failures = []
-        self.test_failures = []
+        self.errors: list[str] = []
+        self.warnings: list[str] = []
+        self.hook_failures: list[str] = []
+        self.test_failures: list[str] = []
 
 
 async def run_progress_monitor(

crackerjack/mcp/rate_limiter.py

@@ -35,10 +35,10 @@ class RateLimiter:
         self.requests_per_hour = requests_per_hour
 
         self.minute_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_minute),
+            lambda: deque(maxlen=requests_per_minute),  # type: ignore[misc]
         )
         self.hour_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_hour),
+            lambda: deque(maxlen=requests_per_hour),  # type: ignore[misc]
         )
 
         self.global_minute_window: deque[float] = deque(maxlen=requests_per_minute * 10)
@@ -110,7 +110,7 @@ class RateLimiter:
         self._cleanup_global_windows(minute_cutoff, hour_cutoff)
 
     def _cleanup_client_windows(self, minute_cutoff: float, hour_cutoff: float) -> None:
-        for client_id in list(self.minute_windows.keys()):
+        for client_id in list[t.Any](self.minute_windows.keys()):
             minute_window = self.minute_windows[client_id]
             hour_window = self.hour_windows[client_id]
 
@@ -200,7 +200,7 @@ class ResourceMonitor:
         stale_jobs = []
 
         async with self._lock:
-            for job_id, start_time in list(self.active_jobs.items()):
+            for job_id, start_time in list[t.Any](self.active_jobs.items()):
                 if now - start_time > max_duration:
                     stale_jobs.append(job_id)
                     del self.active_jobs[job_id]
@@ -234,7 +234,7 @@ class ResourceMonitor:
             if not progress_dir.exists():
                 return True
 
-            file_count = len(list(progress_dir.glob("job-* .json")))
+            file_count = len(list[t.Any](progress_dir.glob("job-* .json")))
             if file_count > self.config.max_progress_files:
                 console.print(
                     f"[red]🚫 Progress files ({file_count}) exceed limit ({self.config.max_progress_files})[/ red]",
@@ -272,7 +272,7 @@ class RateLimitMiddleware:
         )
         self.resource_monitor = ResourceMonitor(self.config)
 
-        self._cleanup_task: asyncio.Task | None = None
+        self._cleanup_task: asyncio.Task[None] | None = None
         self._running = False
 
     async def start(self) -> None:

crackerjack/mcp/server_core.py

@@ -7,12 +7,17 @@ from typing import Final
 from rich.console import Console
 
 try:
-    from mcp.server.fastmcp import FastMCP
+    import tomli
+except ImportError:
+    tomli = None  # type: ignore[assignment]
+
+try:
+    from fastmcp import FastMCP
 
     _mcp_available = True
 except ImportError:
     _mcp_available = False
-    FastMCP = None
+    FastMCP = None  # type: ignore[misc,assignment,no-redef]
 
 MCP_AVAILABLE: Final[bool] = _mcp_available
 
@@ -37,6 +42,41 @@ from .tools import (
 console = Console()
 
 
+def _load_mcp_config(project_path: Path) -> dict[str, t.Any]:
+    pyproject_path = project_path / "pyproject.toml"
+
+    if not pyproject_path.exists() or not tomli:
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+    try:
+        with pyproject_path.open("rb") as f:
+            pyproject_data = tomli.load(f)
+
+        crackerjack_config = pyproject_data.get("tool", {}).get("crackerjack", {})
+
+        return {
+            "http_port": crackerjack_config.get("mcp_http_port", 8676),
+            "http_host": crackerjack_config.get("mcp_http_host", "127.0.0.1"),
+            "websocket_port": crackerjack_config.get("mcp_websocket_port", 8675),
+            "http_enabled": crackerjack_config.get("mcp_http_enabled", False),
+        }
+    except Exception as e:
+        console.print(
+            f"[yellow]Warning: Failed to load MCP config from pyproject.toml: {e}[/yellow]"
+        )
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+
 class MCPOptions:
     def __init__(self, **kwargs: t.Any) -> None:
         self.commit: bool = False
@@ -77,11 +117,14 @@ async def _start_websocket_server() -> bool:
     return False
 
 
-def create_mcp_server() -> t.Any | None:
+def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
     if not MCP_AVAILABLE or FastMCP is None:
         return None
 
-    mcp_app = FastMCP("crackerjack - mcp-server")
+    if config is None:
+        config = {"http_port": 8676, "http_host": "127.0.0.1"}
+
+    mcp_app = FastMCP("crackerjack-mcp-server", streamable_http_path="/mcp")
 
     from crackerjack.slash_commands import get_slash_command_path
 
@@ -128,6 +171,8 @@ def handle_mcp_server_command(
     stop: bool = False,
     restart: bool = False,
     websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
 ) -> None:
     if stop or restart:
         console.print("[yellow]Stopping MCP servers...[/ yellow]")
@@ -157,7 +202,7 @@ def handle_mcp_server_command(
     if start or restart:
         console.print("[green]Starting MCP server...[/ green]")
         try:
-            main(".", websocket_port)
+            main(".", websocket_port, http_mode, http_port)
         except Exception as e:
             console.print(f"[red]Failed to start MCP server: {e}[/ red]")
 
@@ -177,45 +222,116 @@ def _stop_websocket_server() -> None:
             pass
 
 
-def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None:
+def _merge_config_with_args(
+    mcp_config: dict[str, t.Any],
+    http_port: int | None,
+    http_mode: bool,
+) -> dict[str, t.Any]:
+    if http_port:
+        mcp_config["http_port"] = http_port
+    if http_mode:
+        mcp_config["http_enabled"] = True
+    return mcp_config
+
+
+def _setup_server_context(
+    project_path: Path,
+    websocket_port: int | None,
+) -> MCPServerContext:
+    config = MCPServerConfig(
+        project_path=project_path,
+        rate_limit_config=RateLimitConfig(),
+    )
+
+    context = MCPServerContext(config)
+    context.console = console
+
+    if websocket_port:
+        context.websocket_server_port = websocket_port
+
+    _initialize_context(context)
+    return context
+
+
+def _print_server_info(
+    project_path: Path,
+    mcp_config: dict[str, t.Any],
+    websocket_port: int | None,
+    http_mode: bool,
+) -> None:
+    console.print("[green]Starting Crackerjack MCP Server...[/ green]")
+    console.print(f"Project path: {project_path}")
+
+    if mcp_config.get("http_enabled", False) or http_mode:
+        console.print(
+            f"[cyan]HTTP Mode: http: //{mcp_config['http_host']}: {mcp_config['http_port']}/mcp[/ cyan]"
+        )
+    else:
+        console.print("[cyan]STDIO Mode[/ cyan]")
+
+    if websocket_port:
+        console.print(f"WebSocket port: {websocket_port}")
+
+
+def _run_mcp_server(
+    mcp_app: t.Any, mcp_config: dict[str, t.Any], http_mode: bool
+) -> None:
+    console.print("[yellow]MCP app created, about to run...[/ yellow]")
+
+    try:
+        if mcp_config.get("http_enabled", False) or http_mode:
+            host = mcp_config.get("http_host", "127.0.0.1")
+            port = mcp_config.get("http_port", 8676)
+            mcp_app.run(transport="streamable-http", host=host, port=port)
+        else:
+            mcp_app.run()
+    except Exception as e:
+        console.print(f"[red]MCP run failed: {e}[/ red]")
+        import traceback
+
+        traceback.print_exc()
+        raise
+
+
+def main(
+    project_path_arg: str = ".",
+    websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
+) -> None:
     if not MCP_AVAILABLE:
         return
 
     try:
         project_path = Path(project_path_arg).resolve()
 
-        config = MCPServerConfig(
-            project_path=project_path,
-            rate_limit_config=RateLimitConfig(),
-        )
-
-        context = MCPServerContext(config)
-        context.console = console
-
-        if websocket_port:
-            context.websocket_server_port = websocket_port
+        mcp_config = _load_mcp_config(project_path)
+        mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
 
-        _initialize_context(context)
+        _setup_server_context(project_path, websocket_port)
 
-        mcp_app = create_mcp_server()
+        mcp_app = create_mcp_server(mcp_config)
         if not mcp_app:
             console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        console.print("[green]Starting Crackerjack MCP Server...[/ green]")
-        console.print(f"Project path: {project_path}")
+        _print_server_info(project_path, mcp_config, websocket_port, http_mode)
+
+        # Auto-start WebSocket server if websocket_port is specified
         if websocket_port:
-            console.print(f"WebSocket port: {websocket_port}")
+            import asyncio
 
-        console.print("[yellow]MCP app created, about to run...[/ yellow]")
-        try:
-            mcp_app.run()
-        except Exception as e:
-            console.print(f"[red]MCP run failed: {e}[/ red]")
-            import traceback
+            try:
+                asyncio.run(_start_websocket_server())
+                console.print(
+                    f"[green]✅ WebSocket server auto-started on port {websocket_port}[/green]"
+                )
+            except Exception as e:
+                console.print(
+                    f"[yellow]⚠️ WebSocket server auto-start failed: {e}[/yellow]"
+                )
 
-            traceback.print_exc()
-            raise
+        _run_mcp_server(mcp_app, mcp_config, http_mode)
 
     except KeyboardInterrupt:
         console.print("Server stopped by user")
@@ -232,7 +348,20 @@ def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None
 if __name__ == "__main__":
     import sys
 
-    project_path = sys.argv[1] if len(sys.argv) > 1 else "."
-    websocket_port = int(sys.argv[2]) if len(sys.argv) > 2 else None
+    project_path = "."
+    websocket_port = None
+    http_mode = "--http" in sys.argv
+    http_port = None
+
+    non_flag_args = [arg for arg in sys.argv[1:] if not arg.startswith("--")]
+    if non_flag_args:
+        project_path = non_flag_args[0]
+        if len(non_flag_args) > 1 and non_flag_args[1].isdigit():
+            websocket_port = int(non_flag_args[1])
+
+    if "--http-port" in sys.argv:
+        port_idx = sys.argv.index("--http-port")
+        if port_idx + 1 < len(sys.argv):
+            http_port = int(sys.argv[port_idx + 1])
 
-    main(project_path, websocket_port)
+    main(project_path, websocket_port, http_mode, http_port)

crackerjack/mcp/service_watchdog.py

@@ -34,11 +34,12 @@ class ServiceConfig:
         self.max_restarts = max_restarts
         self.restart_window = restart_window
 
-        self.process: subprocess.Popen | None = None
+        self.process: subprocess.Popen[bytes] | None = None
         self.restart_count = 0
         self.restart_timestamps: list[float] = []
         self.last_health_check = 0.0
         self.is_healthy = False
+        self._port_acknowledged = False
         self.last_error: str | None = None