emdash-cli 0.1.35__py3-none-any.whl → 0.1.67__py3-none-any.whl

emdash_cli/server_manager.py

@@ -1,6 +1,7 @@
 """Server lifecycle management for emdash-core."""
 
 import atexit
+import hashlib
 import os
 import signal
 import socket
@@ -17,15 +18,15 @@ class ServerManager:
     """Manages FastAPI server lifecycle for CLI.
 
     The ServerManager handles:
+    - Per-repo server instances (each repo gets its own server)
     - Discovering running servers via port file
     - Starting new servers when needed
     - Health checking servers
     - Graceful shutdown on CLI exit
+    - Cleanup of stale servers
     """
 
-    DEFAULT_PORT = 8765
-    PORT_FILE = Path.home() / ".emdash" / "server.port"
-    PID_FILE = Path.home() / ".emdash" / "server.pid"
+    SERVERS_DIR = Path.home() / ".emdash" / "servers"
     STARTUP_TIMEOUT = 30.0  # seconds
     HEALTH_TIMEOUT = 2.0  # seconds
 
@@ -40,8 +41,35 @@ class ServerManager:
         self.port: Optional[int] = None
         self._started_by_us = False
 
+        # Create servers directory
+        self.SERVERS_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Cleanup stale servers on init
+        self._cleanup_stale_servers()
+
+    @property
+    def _repo_hash(self) -> str:
+        """Get a short hash of the repo root path for unique file naming."""
+        path_str = str(self.repo_root.resolve())
+        return hashlib.sha256(path_str.encode()).hexdigest()[:12]
+
+    @property
+    def _port_file(self) -> Path:
+        """Get the port file path for this repo."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.port"
+
+    @property
+    def _pid_file(self) -> Path:
+        """Get the PID file path for this repo."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.pid"
+
+    @property
+    def _repo_file(self) -> Path:
+        """Get the repo path file for this repo (for debugging)."""
+        return self.SERVERS_DIR / f"{self._repo_hash}.repo"
+
     def get_server_url(self) -> str:
-        """Get URL of running server, starting one if needed.
+        """Get URL of running server for this repo, starting one if needed.
 
         Returns:
             Base URL of the running server (e.g., "http://localhost:8765")
@@ -49,17 +77,19 @@ class ServerManager:
         Raises:
             RuntimeError: If server fails to start
         """
-        # Check if server already running
-        if self.PORT_FILE.exists():
+        # Check if server already running for THIS repo
+        if self._port_file.exists():
             try:
-                port = int(self.PORT_FILE.read_text().strip())
+                port = int(self._port_file.read_text().strip())
                 if self._check_health(port):
                     self.port = port
                     return f"http://localhost:{port}"
             except (ValueError, IOError):
                 pass
+            # Server not healthy, clean up stale files
+            self._cleanup_files()
 
-        # Start new server
+        # Start new server for this repo
         self.port = self._find_free_port()
         self._spawn_server()
         return f"http://localhost:{self.port}"
@@ -133,6 +163,11 @@ class ServerManager:
 
         self._started_by_us = True
 
+        # Write port, PID, and repo files
+        self._port_file.write_text(str(self.port))
+        self._pid_file.write_text(str(self.process.pid))
+        self._repo_file.write_text(str(self.repo_root))
+
         # Register cleanup for normal exit
         atexit.register(self.shutdown)
 
@@ -203,14 +238,39 @@ class ServerManager:
         )
 
     def _cleanup_files(self) -> None:
-        """Clean up port and PID files."""
-        for file in [self.PORT_FILE, self.PID_FILE]:
+        """Clean up port, PID, and repo files for this repo."""
+        for file in [self._port_file, self._pid_file, self._repo_file]:
             try:
                 if file.exists():
                     file.unlink()
             except IOError:
                 pass
 
+    def _cleanup_stale_servers(self) -> None:
+        """Clean up stale server files where process no longer exists."""
+        if not self.SERVERS_DIR.exists():
+            return
+
+        for pid_file in self.SERVERS_DIR.glob("*.pid"):
+            try:
+                pid = int(pid_file.read_text().strip())
+                # Check if process exists
+                try:
+                    os.kill(pid, 0)  # Signal 0 checks if process exists
+                except OSError:
+                    # Process doesn't exist, clean up files
+                    hash_prefix = pid_file.stem
+                    for ext in [".port", ".pid", ".repo"]:
+                        stale_file = self.SERVERS_DIR / f"{hash_prefix}{ext}"
+                        if stale_file.exists():
+                            stale_file.unlink()
+            except (ValueError, IOError):
+                # Invalid PID file, remove it
+                try:
+                    pid_file.unlink()
+                except IOError:
+                    pass
+
 
 # Global singleton for CLI commands
 _server_manager: Optional[ServerManager] = None