taskmux 0.2.5__tar.gz → 0.2.6__tar.gz

{taskmux-0.2.5 → taskmux-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskmux
-Version: 0.2.5
+Version: 0.2.6
 Summary: Modern tmux-based task manager for LLM development tools
 Project-URL: Homepage, https://github.com/nc9/taskmux
 Project-URL: Repository, https://github.com/nc9/taskmux

{taskmux-0.2.5 → taskmux-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskmux"
-version = "0.2.5"
+version = "0.2.6"
 description = "Modern tmux-based task manager for LLM development tools"
 readme = "README.md"
 license-file = "LICENSE"

{taskmux-0.2.5 → taskmux-0.2.6}/taskmux/config.py

@@ -106,6 +106,8 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
             inner.add("auto_start", False)
         if task_cfg.cwd is not None:
             inner.add("cwd", task_cfg.cwd)
+        if task_cfg.port is not None:
+            inner.add("port", task_cfg.port)
         if task_cfg.health_check is not None:
             inner.add("health_check", task_cfg.health_check)
         if task_cfg.health_interval != 10:
@@ -114,6 +116,12 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
             inner.add("health_timeout", task_cfg.health_timeout)
         if task_cfg.health_retries != 3:
             inner.add("health_retries", task_cfg.health_retries)
+        if task_cfg.stop_grace_period != 5:
+            inner.add("stop_grace_period", task_cfg.stop_grace_period)
+        if task_cfg.max_restarts != 5:
+            inner.add("max_restarts", task_cfg.max_restarts)
+        if task_cfg.restart_backoff != 2.0:
+            inner.add("restart_backoff", task_cfg.restart_backoff)
         if task_cfg.depends_on:
             inner.add("depends_on", task_cfg.depends_on)
         # Task-level hooks

{taskmux-0.2.5 → taskmux-0.2.6}/taskmux/daemon.py

@@ -39,6 +39,26 @@ class ConfigWatcher(FileSystemEventHandler):
                 self.taskmux_cli.handle_config_reload()
 
 
+class RestartTracker:
+    """Tracks per-task restart counts and timestamps for backoff."""
+
+    def __init__(self) -> None:
+        self._data: dict[str, dict[str, float]] = {}
+
+    def get(self, task_name: str) -> dict[str, float]:
+        return self._data.get(task_name, {"count": 0, "last": 0.0})
+
+    def record(self, task_name: str) -> None:
+        info = self.get(task_name)
+        self._data[task_name] = {
+            "count": info["count"] + 1,
+            "last": time.time(),
+        }
+
+    def reset(self, task_name: str) -> None:
+        self._data.pop(task_name, None)
+
+
 class TaskmuxDaemon:
     """Daemon mode for Taskmux with enhanced monitoring and API"""
 
@@ -51,6 +71,7 @@ class TaskmuxDaemon:
         self.health_check_interval = 30
         self.health_check_task: asyncio.Task | None = None
         self.websocket_clients: set = set()
+        self.restart_tracker = RestartTracker()
         self.logger = self._setup_logging()
 
         signal.signal(signal.SIGINT, self._signal_handler)
@@ -124,11 +145,11 @@ class TaskmuxDaemon:
         self.logger.info("Taskmux daemon stopped")
 
     async def _health_check_loop(self) -> None:
-        """Continuous health checking loop"""
+        """Continuous health checking loop with restart backoff."""
         while self.running:
             try:
                 if self.cli and self.cli.tmux.session_exists():
-                    self.cli.tmux.auto_restart_unhealthy_tasks()
+                    self._auto_restart_with_backoff()
 
                     if self.websocket_clients:
                         status = await self._get_full_status()
@@ -139,6 +160,42 @@ class TaskmuxDaemon:
                 self.logger.error(f"Health check error: {e}")
                 await asyncio.sleep(5)
 
+    def _auto_restart_with_backoff(self) -> None:
+        """Auto-restart unhealthy tasks with exponential backoff."""
+        assert self.cli is not None
+        now = time.time()
+
+        for task_name, task_cfg in self.cli.config.tasks.items():
+            healthy = self.cli.tmux.check_task_health(task_name)
+
+            if healthy:
+                # Reset tracker if healthy for >60s
+                info = self.restart_tracker.get(task_name)
+                if info["count"] > 0 and now - info["last"] > 60:
+                    self.restart_tracker.reset(task_name)
+                continue
+
+            # Skip if not previously healthy (avoid restart loop on first check)
+            prev_health = self.cli.tmux.task_health.get(task_name, {}).get("healthy", True)
+            if not prev_health:
+                info = self.restart_tracker.get(task_name)
+
+                # Check max_restarts
+                if task_cfg.max_restarts and info["count"] >= task_cfg.max_restarts:
+                    self.logger.warning(
+                        f"Task '{task_name}' exceeded max restarts ({task_cfg.max_restarts})"
+                    )
+                    continue
+
+                # Check backoff delay
+                delay = min(task_cfg.restart_backoff ** info["count"], 60)
+                if info["last"] and now - info["last"] < delay:
+                    continue
+
+            self.logger.info(f"Auto-restarting unhealthy task: {task_name}")
+            self.cli.tmux.restart_task(task_name)
+            self.restart_tracker.record(task_name)
+
     async def _start_api_server(self) -> None:
         """Start WebSocket API server"""
 

{taskmux-0.2.5 → taskmux-0.2.6}/taskmux/models.py

@@ -37,10 +37,14 @@ class TaskConfig(_StrictConfig):
     command: str
     auto_start: bool = True
     cwd: str | None = None
+    port: int | None = None
     health_check: str | None = None
     health_interval: int = 10
     health_timeout: int = 5
     health_retries: int = 3
+    stop_grace_period: int = 5
+    max_restarts: int = 5
+    restart_backoff: float = 2.0
     depends_on: list[str] = []
     hooks: HookConfig = HookConfig()
 

{taskmux-0.2.5 → taskmux-0.2.6}/taskmux/tmux_manager.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import contextlib
+import os
+import signal as sig
 import subprocess
 import time
 from collections import deque
@@ -14,6 +17,8 @@ from rich.markup import escape
 from .hooks import runHook
 from .models import TaskmuxConfig
 
+SHELL_NAMES = frozenset(("bash", "zsh", "sh", "fish"))
+
 TASK_COLORS = ["cyan", "green", "yellow", "magenta", "blue", "red"]
 
 
@@ -74,11 +79,61 @@ class TmuxManager:
             window = self._get_session().windows.get(window_name=task_name, default=None)
             if window and window.active_pane:
                 cmd = getattr(window.active_pane, "pane_current_command", "")
-                return cmd != "" and cmd != "bash"
+                return cmd != "" and cmd not in SHELL_NAMES
         except Exception:
             pass
         return False
 
+    def _wait_for_exit(self, pane: libtmux.Pane, timeout: float) -> bool:
+        """Poll pane_current_command until it returns to a shell or timeout."""
+        elapsed = 0.0
+        while elapsed < timeout:
+            time.sleep(0.5)
+            elapsed += 0.5
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd == "" or cmd in SHELL_NAMES:
+                return True
+        return False
+
+    def _get_pane_child_pid(self, pane: libtmux.Pane) -> int | None:
+        """Get the child process PID running inside the pane's shell."""
+        shell_pid = getattr(pane, "pane_pid", None)
+        if not shell_pid:
+            return None
+        try:
+            result = subprocess.run(
+                ["pgrep", "-P", str(shell_pid)],
+                capture_output=True,
+                text=True,
+            )
+            pids = result.stdout.strip().split("\n")
+            return int(pids[0]) if pids and pids[0] else None
+        except (ValueError, OSError):
+            return None
+
+    def _kill_process_tree(self, pid: int, signal_num: int = sig.SIGKILL) -> None:
+        """Kill process and all children via process group."""
+        try:
+            pgid = os.getpgid(pid)
+            os.killpg(pgid, signal_num)
+        except (ProcessLookupError, PermissionError, OSError):
+            pass
+
+    def _cleanup_port(self, port: int) -> None:
+        """Kill any process listening on port."""
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{port}"],
+                capture_output=True,
+                text=True,
+            )
+            for pid_str in result.stdout.strip().split("\n"):
+                if pid_str.strip():
+                    with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
+                        os.kill(int(pid_str.strip()), sig.SIGKILL)
+        except OSError:
+            pass
+
     def is_task_healthy(self, task_name: str) -> bool:
         """Check task health. Uses health_check command if configured, falls back to pane-alive."""
         task_cfg = self.config.tasks.get(task_name)
@@ -188,6 +243,10 @@ class TmuxManager:
         sess = self._get_session()
         task_cfg = self.config.tasks[task_name]
 
+        # Kill anything occupying the port before starting
+        if task_cfg.port:
+            self._cleanup_port(task_cfg.port)
+
         # Check if already running
         existing = sess.windows.get(window_name=task_name, default=None)
         if existing:
@@ -226,7 +285,7 @@ class TmuxManager:
         print(f"Started task '{task_name}'")
 
     def stop_task(self, task_name: str) -> None:
-        """Graceful stop (C-c) a single task. Window stays alive."""
+        """Graceful stop with signal escalation: C-c → SIGTERM → SIGKILL."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist")
             return
@@ -249,8 +308,22 @@ class TmuxManager:
 
         pane = window.active_pane
         if pane:
+            # Phase 1: SIGINT (Ctrl+C)
             pane.send_keys("C-c")
 
+            if not self._wait_for_exit(pane, timeout=task_cfg.stop_grace_period):
+                # Phase 2: SIGTERM via process group
+                pid = self._get_pane_child_pid(pane)
+                if pid:
+                    self._kill_process_tree(pid, sig.SIGTERM)
+
+                if not self._wait_for_exit(pane, timeout=3):
+                    # Phase 3: SIGKILL entire process group
+                    if pid:
+                        self._kill_process_tree(pid, sig.SIGKILL)
+                    # Final wait for cleanup
+                    self._wait_for_exit(pane, timeout=1)
+
         # Hooks: task after_stop, then global after_stop
         runHook(task_cfg.hooks.after_stop, task_name)
         runHook(self.config.hooks.after_stop, task_name)
@@ -322,7 +395,7 @@ class TmuxManager:
         print(f"Started session '{self.config.name}' with {len(auto_tasks)} tasks")
 
     def stop_all(self) -> None:
-        """Stop all tasks then kill session."""
+        """Stop all tasks with signal escalation then kill session."""
         if not self.session_exists():
             print("No session running")
             return
@@ -330,8 +403,9 @@ class TmuxManager:
         # Global before_stop
         runHook(self.config.hooks.before_stop)
 
-        # Stop each task with hooks
+        # Phase 1: send C-c to all tasks
         sess = self._get_session()
+        pane_map: dict[str, tuple[libtmux.Pane, int | None]] = {}
         for task_name, task_cfg in self.config.tasks.items():
             window = sess.windows.get(window_name=task_name, default=None)
             if window:
@@ -339,7 +413,30 @@ class TmuxManager:
                 pane = window.active_pane
                 if pane:
                     pane.send_keys("C-c")
-                runHook(task_cfg.hooks.after_stop, task_name)
+                    pid = self._get_pane_child_pid(pane)
+                    pane_map[task_name] = (pane, pid)
+
+        # Wait for graceful exit (use max grace period across tasks)
+        max_grace = max((cfg.stop_grace_period for cfg in self.config.tasks.values()), default=5)
+        time.sleep(max_grace)
+
+        # Phase 2: SIGTERM then SIGKILL any survivors
+        for _name, (pane, pid) in pane_map.items():
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd and cmd not in SHELL_NAMES and pid:
+                self._kill_process_tree(pid, sig.SIGTERM)
+
+        time.sleep(1)
+
+        for _name, (pane, pid) in pane_map.items():
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd and cmd not in SHELL_NAMES and pid:
+                self._kill_process_tree(pid, sig.SIGKILL)
+
+        # Run after_stop hooks
+        for task_name in pane_map:
+            task_cfg = self.config.tasks[task_name]
+            runHook(task_cfg.hooks.after_stop, task_name)
 
         sess.kill()
 
@@ -358,7 +455,7 @@ class TmuxManager:
         self.start_all()
 
     def restart_task(self, task_name: str) -> None:
-        """Restart a specific task (works regardless of auto_start)"""
+        """Restart a specific task with full stop escalation."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist. Run 'taskmux start' first.")
             return
@@ -373,13 +470,25 @@ class TmuxManager:
 
         window = sess.windows.get(window_name=task_name, default=None)
         if window:
+            # Full stop with signal escalation
             runHook(task_cfg.hooks.before_stop, task_name)
             pane = window.active_pane
             if pane:
                 pane.send_keys("C-c")
-                time.sleep(0.5)
+                if not self._wait_for_exit(pane, timeout=task_cfg.stop_grace_period):
+                    pid = self._get_pane_child_pid(pane)
+                    if pid:
+                        self._kill_process_tree(pid, sig.SIGTERM)
+                    if not self._wait_for_exit(pane, timeout=3):
+                        if pid:
+                            self._kill_process_tree(pid, sig.SIGKILL)
+                        self._wait_for_exit(pane, timeout=1)
             runHook(task_cfg.hooks.after_stop, task_name)
 
+            # Port cleanup before restart
+            if task_cfg.port:
+                self._cleanup_port(task_cfg.port)
+
             runHook(task_cfg.hooks.before_start, task_name)
             pane = window.active_pane
             if pane:
@@ -388,6 +497,9 @@ class TmuxManager:
                 pane.send_keys(command, enter=True)
             runHook(task_cfg.hooks.after_start, task_name)
         else:
+            # Port cleanup before start
+            if task_cfg.port:
+                self._cleanup_port(task_cfg.port)
             runHook(task_cfg.hooks.before_start, task_name)
             self._send_command_to_window(sess, task_name, command, task_cfg.cwd)
             runHook(task_cfg.hooks.after_start, task_name)
@@ -395,13 +507,18 @@ class TmuxManager:
         print(f"Restarted task '{task_name}'")
 
     def kill_task(self, task_name: str) -> None:
-        """Kill a specific task"""
+        """Kill a specific task (process group + window)."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist")
             return
 
         window = self._get_session().windows.get(window_name=task_name, default=None)
         if window:
+            pane = window.active_pane
+            if pane:
+                pid = self._get_pane_child_pid(pane)
+                if pid:
+                    self._kill_process_tree(pid)
             window.kill()
             print(f"Killed task '{task_name}'")
         else: