taskmux 0.2.3__tar.gz → 0.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskmux
-Version: 0.2.3
+Version: 0.2.5
 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
@@ -104,6 +104,67 @@ command = "docker compose up postgres"
 auto_start = false
 ```
 
+## Full Example
+
+A full-stack app with a database, API server, and frontend — using health checks to ensure each service is ready before starting its dependents:
+
+```toml
+name = "fullstack-app"
+
+[tasks.db]
+command = "docker compose up postgres redis"
+health_check = "pg_isready -h localhost -p 5432"
+health_interval = 3
+
+[tasks.migrate]
+command = "python manage.py migrate && echo 'done' && sleep infinity"
+cwd = "apps/api"
+depends_on = ["db"]
+health_check = "test -f .migrate-complete"
+
+[tasks.api]
+command = "python manage.py runserver 0.0.0.0:8000"
+cwd = "apps/api"
+depends_on = ["migrate"]
+health_check = "curl -sf http://localhost:8000/health"
+
+[tasks.worker]
+command = "celery -A myapp worker -l info"
+cwd = "apps/api"
+depends_on = ["db"]
+
+[tasks.web]
+command = "bun dev"
+cwd = "apps/web"
+depends_on = ["api"]
+health_check = "curl -sf http://localhost:3000"
+
+[tasks.storybook]
+command = "bun storybook"
+cwd = "apps/web"
+auto_start = false
+```
+
+What happens on `taskmux start`:
+
+1. **db** starts first (no dependencies)
+2. **migrate** and **worker** wait for db's health check (`pg_isready`) to pass
+3. **api** waits for migrate's health check
+4. **web** waits for api's health check (`curl localhost:8000/health`)
+5. **storybook** is skipped (`auto_start = false`) — start it manually with `taskmux start storybook`
+
+```bash
+taskmux start                    # Starts everything in dependency order
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs -g "ERROR"          # Grep all tasks for errors
+taskmux logs api                 # Logs from just the API
+taskmux logs -f api              # Follow API logs live
+taskmux health                   # Health check table
+taskmux inspect api              # JSON state for a single task
+taskmux restart worker           # Restart just the worker
+taskmux start storybook          # Start a manual task
+```
+
 ## Commands
 
 ```bash
@@ -124,10 +185,13 @@ taskmux remove <task>            # Remove task from config
 taskmux inspect <task>           # JSON task state (pid, command, health)
 
 # Logs
-taskmux logs <task>              # Show recent logs
-taskmux logs -f <task>           # Follow logs live
-taskmux logs -n 100 <task>       # Last N lines
-taskmux logs <task> -g "error"   # Search logs with grep
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs <task>              # Show recent logs for a task
+taskmux logs -f                  # Attach to session (switch windows with tmux keybinds)
+taskmux logs -f <task>           # Follow a task's logs live
+taskmux logs -n 200 <task>       # Last N lines
+taskmux logs -g "error"          # Search all tasks
+taskmux logs <task> -g "error"   # Search one task
 taskmux logs <task> -g "error" -C 5  # Grep with context lines
 
 # Init
@@ -161,12 +225,20 @@ after_stop = "echo done"
 
 [tasks.server]
 command = "python manage.py runserver"
+cwd = "apps/api"
+health_check = "curl -sf http://localhost:8000/health"
+depends_on = ["db"]
 
 [tasks.server.hooks]
 before_start = "python manage.py migrate"
 
+[tasks.db]
+command = "docker compose up postgres"
+health_check = "pg_isready -h localhost"
+
 [tasks.worker]
 command = "celery worker -A myapp"
+depends_on = ["db"]
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -185,8 +257,31 @@ auto_start = false
 | `hooks.after_stop` | — | Run after stopping tasks |
 | `tasks.<name>.command` | — | Shell command to run |
 | `tasks.<name>.auto_start` | `true` | Start with `taskmux start` |
+| `tasks.<name>.cwd` | — | Working directory for the task |
+| `tasks.<name>.health_check` | — | Shell command to check health (exit 0 = healthy) |
+| `tasks.<name>.health_interval` | `10` | Seconds between health checks |
+| `tasks.<name>.health_timeout` | `5` | Seconds before health check times out |
+| `tasks.<name>.health_retries` | `3` | Consecutive failures before "unhealthy" |
+| `tasks.<name>.depends_on` | `[]` | Task names that must be healthy before this task starts |
 | `tasks.<name>.hooks.*` | — | Per-task lifecycle hooks (same fields as global) |
 
+### Dependency Ordering
+
+Tasks with `depends_on` are started in topological order. Before starting a task, taskmux waits for each dependency's health check to pass (up to `health_retries * health_interval` seconds). If a dependency never becomes healthy, the dependent task is skipped with a warning.
+
+Circular dependencies and references to nonexistent tasks are rejected at config load time.
+
+When starting a single task with `taskmux start <task>`, dependencies are not auto-started — you get a warning if they aren't running.
+
+### Health Checks
+
+If `health_check` is set, taskmux runs it as a shell command. Exit code 0 means healthy. If not set, taskmux falls back to checking if the tmux pane has a running process (not just a shell prompt).
+
+Health checks are used by:
+- `taskmux health` — shows a table of all task health
+- `taskmux start` — waits for dependencies to be healthy before starting dependents
+- `taskmux daemon` — continuously monitors and auto-restarts unhealthy tasks
+
 ### Hook Cascade
 
 Hooks fire in this order:
@@ -212,14 +307,17 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ```json
 {
-  "name": "server",
-  "command": "npm run dev",
+  "name": "api",
+  "command": "python manage.py runserver 0.0.0.0:8000",
   "auto_start": true,
+  "cwd": "apps/api",
+  "health_check": "curl -sf http://localhost:8000/health",
+  "depends_on": ["db"],
   "running": true,
   "healthy": true,
   "pid": "12345",
-  "pane_current_command": "node",
-  "pane_current_path": "/home/user/project",
+  "pane_current_command": "python",
+  "pane_current_path": "/home/user/project/apps/api",
   "window_id": "@1",
   "pane_id": "%1"
 }

{taskmux-0.2.3 → taskmux-0.2.5}/README.md

@@ -69,6 +69,67 @@ command = "docker compose up postgres"
 auto_start = false
 ```
 
+## Full Example
+
+A full-stack app with a database, API server, and frontend — using health checks to ensure each service is ready before starting its dependents:
+
+```toml
+name = "fullstack-app"
+
+[tasks.db]
+command = "docker compose up postgres redis"
+health_check = "pg_isready -h localhost -p 5432"
+health_interval = 3
+
+[tasks.migrate]
+command = "python manage.py migrate && echo 'done' && sleep infinity"
+cwd = "apps/api"
+depends_on = ["db"]
+health_check = "test -f .migrate-complete"
+
+[tasks.api]
+command = "python manage.py runserver 0.0.0.0:8000"
+cwd = "apps/api"
+depends_on = ["migrate"]
+health_check = "curl -sf http://localhost:8000/health"
+
+[tasks.worker]
+command = "celery -A myapp worker -l info"
+cwd = "apps/api"
+depends_on = ["db"]
+
+[tasks.web]
+command = "bun dev"
+cwd = "apps/web"
+depends_on = ["api"]
+health_check = "curl -sf http://localhost:3000"
+
+[tasks.storybook]
+command = "bun storybook"
+cwd = "apps/web"
+auto_start = false
+```
+
+What happens on `taskmux start`:
+
+1. **db** starts first (no dependencies)
+2. **migrate** and **worker** wait for db's health check (`pg_isready`) to pass
+3. **api** waits for migrate's health check
+4. **web** waits for api's health check (`curl localhost:8000/health`)
+5. **storybook** is skipped (`auto_start = false`) — start it manually with `taskmux start storybook`
+
+```bash
+taskmux start                    # Starts everything in dependency order
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs -g "ERROR"          # Grep all tasks for errors
+taskmux logs api                 # Logs from just the API
+taskmux logs -f api              # Follow API logs live
+taskmux health                   # Health check table
+taskmux inspect api              # JSON state for a single task
+taskmux restart worker           # Restart just the worker
+taskmux start storybook          # Start a manual task
+```
+
 ## Commands
 
 ```bash
@@ -89,10 +150,13 @@ taskmux remove <task>            # Remove task from config
 taskmux inspect <task>           # JSON task state (pid, command, health)
 
 # Logs
-taskmux logs <task>              # Show recent logs
-taskmux logs -f <task>           # Follow logs live
-taskmux logs -n 100 <task>       # Last N lines
-taskmux logs <task> -g "error"   # Search logs with grep
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs <task>              # Show recent logs for a task
+taskmux logs -f                  # Attach to session (switch windows with tmux keybinds)
+taskmux logs -f <task>           # Follow a task's logs live
+taskmux logs -n 200 <task>       # Last N lines
+taskmux logs -g "error"          # Search all tasks
+taskmux logs <task> -g "error"   # Search one task
 taskmux logs <task> -g "error" -C 5  # Grep with context lines
 
 # Init
@@ -126,12 +190,20 @@ after_stop = "echo done"
 
 [tasks.server]
 command = "python manage.py runserver"
+cwd = "apps/api"
+health_check = "curl -sf http://localhost:8000/health"
+depends_on = ["db"]
 
 [tasks.server.hooks]
 before_start = "python manage.py migrate"
 
+[tasks.db]
+command = "docker compose up postgres"
+health_check = "pg_isready -h localhost"
+
 [tasks.worker]
 command = "celery worker -A myapp"
+depends_on = ["db"]
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -150,8 +222,31 @@ auto_start = false
 | `hooks.after_stop` | — | Run after stopping tasks |
 | `tasks.<name>.command` | — | Shell command to run |
 | `tasks.<name>.auto_start` | `true` | Start with `taskmux start` |
+| `tasks.<name>.cwd` | — | Working directory for the task |
+| `tasks.<name>.health_check` | — | Shell command to check health (exit 0 = healthy) |
+| `tasks.<name>.health_interval` | `10` | Seconds between health checks |
+| `tasks.<name>.health_timeout` | `5` | Seconds before health check times out |
+| `tasks.<name>.health_retries` | `3` | Consecutive failures before "unhealthy" |
+| `tasks.<name>.depends_on` | `[]` | Task names that must be healthy before this task starts |
 | `tasks.<name>.hooks.*` | — | Per-task lifecycle hooks (same fields as global) |
 
+### Dependency Ordering
+
+Tasks with `depends_on` are started in topological order. Before starting a task, taskmux waits for each dependency's health check to pass (up to `health_retries * health_interval` seconds). If a dependency never becomes healthy, the dependent task is skipped with a warning.
+
+Circular dependencies and references to nonexistent tasks are rejected at config load time.
+
+When starting a single task with `taskmux start <task>`, dependencies are not auto-started — you get a warning if they aren't running.
+
+### Health Checks
+
+If `health_check` is set, taskmux runs it as a shell command. Exit code 0 means healthy. If not set, taskmux falls back to checking if the tmux pane has a running process (not just a shell prompt).
+
+Health checks are used by:
+- `taskmux health` — shows a table of all task health
+- `taskmux start` — waits for dependencies to be healthy before starting dependents
+- `taskmux daemon` — continuously monitors and auto-restarts unhealthy tasks
+
 ### Hook Cascade
 
 Hooks fire in this order:
@@ -177,14 +272,17 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ```json
 {
-  "name": "server",
-  "command": "npm run dev",
+  "name": "api",
+  "command": "python manage.py runserver 0.0.0.0:8000",
   "auto_start": true,
+  "cwd": "apps/api",
+  "health_check": "curl -sf http://localhost:8000/health",
+  "depends_on": ["db"],
   "running": true,
   "healthy": true,
   "pid": "12345",
-  "pane_current_command": "node",
-  "pane_current_path": "/home/user/project",
+  "pane_current_command": "python",
+  "pane_current_path": "/home/user/project/apps/api",
   "window_id": "@1",
   "pane_id": "%1"
 }

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

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

{taskmux-0.2.3 → taskmux-0.2.5}/taskmux/cli.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import json
+from typing import List, Optional  # noqa: UP035
 
 import typer
 from rich.console import Console
@@ -106,13 +107,13 @@ def kill(
 
 @app.command()
 def logs(
-    task: str = typer.Argument(..., help="Task name"),
+    task: str | None = typer.Argument(None, help="Task name (omit for all)"),
     follow: bool = typer.Option(False, "-f", "--follow", help="Follow logs"),
     lines: int = typer.Option(100, "-n", "--lines", help="Number of lines"),
     grep: str | None = typer.Option(None, "-g", "--grep", help="Filter logs by pattern"),
     context: int = typer.Option(3, "-C", "--context", help="Context lines around grep matches"),
 ):
-    """Show logs for a task."""
+    """Show logs for a task, or all tasks if none specified."""
     cli = TaskmuxCLI()
     cli.tmux.show_logs(task, follow, lines, grep=grep, context=context)
 
@@ -131,9 +132,14 @@ def inspect(
 def add(
     task: str = typer.Argument(..., help="Task name"),
     command: str = typer.Argument(..., help="Command to run"),
+    cwd: str | None = typer.Option(None, "--cwd", help="Working directory"),
+    health_check: str | None = typer.Option(None, "--health-check", help="Health check command"),
+    depends_on: Optional[List[str]] = typer.Option(  # noqa: UP006, UP045, B008
+        None, "--depends-on", help="Dependency task names"
+    ),
 ):
     """Add a new task."""
-    addTask(None, task, command)
+    addTask(None, task, command, cwd=cwd, health_check=health_check, depends_on=depends_on)
     console.print(f"Added task '{task}': {command}")
 
 

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

@@ -104,6 +104,18 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
         inner.add("command", task_cfg.command)
         if not task_cfg.auto_start:
             inner.add("auto_start", False)
+        if task_cfg.cwd is not None:
+            inner.add("cwd", task_cfg.cwd)
+        if task_cfg.health_check is not None:
+            inner.add("health_check", task_cfg.health_check)
+        if task_cfg.health_interval != 10:
+            inner.add("health_interval", task_cfg.health_interval)
+        if task_cfg.health_timeout != 5:
+            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.depends_on:
+            inner.add("depends_on", task_cfg.depends_on)
         # Task-level hooks
         task_hooks_tbl = _writeHooksTable(task_cfg.hooks)
         if task_hooks_tbl:
@@ -115,11 +127,26 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
     return p
 
 
-def addTask(path: Path | None, name: str, command: str) -> TaskmuxConfig:
+def addTask(
+    path: Path | None,
+    name: str,
+    command: str,
+    *,
+    cwd: str | None = None,
+    health_check: str | None = None,
+    depends_on: list[str] | None = None,
+) -> TaskmuxConfig:
     """Add a task to config and persist."""
     cfg = loadConfig(path)
     new_tasks = dict(cfg.tasks)
-    new_tasks[name] = TaskConfig(command=command)
+    kwargs: dict = {"command": command}
+    if cwd is not None:
+        kwargs["cwd"] = cwd
+    if health_check is not None:
+        kwargs["health_check"] = health_check
+    if depends_on:
+        kwargs["depends_on"] = depends_on
+    new_tasks[name] = TaskConfig(**kwargs)
     cfg = TaskmuxConfig(name=cfg.name, auto_start=cfg.auto_start, hooks=cfg.hooks, tasks=new_tasks)
     writeConfig(path, cfg)
     return cfg

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

@@ -191,7 +191,7 @@ class TaskmuxDaemon:
             if task_name and self.cli.tmux.session_exists():
                 try:
                     sess = self.cli.tmux._get_session()
-                    window = sess.windows.get(window_name=task_name)
+                    window = sess.windows.get(window_name=task_name, default=None)
                     if window and window.active_pane:
                         output = window.active_pane.cmd(
                             "capture-pane", "-p", "-S", f"-{lines}"

taskmux-0.2.5/taskmux/models.py

@@ -0,0 +1,84 @@
+"""Pydantic models for Taskmux configuration."""
+
+import warnings
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+
+class _StrictConfig(BaseModel):
+    """Base config: frozen, warns on unknown keys."""
+
+    model_config = ConfigDict(frozen=True)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _warn_unknown_keys(cls, values: dict) -> dict:
+        if not isinstance(values, dict):
+            return values
+        known = set(cls.model_fields.keys())
+        unknown = set(values.keys()) - known
+        for key in sorted(unknown):
+            warnings.warn(f"Unknown config key: {key!r}", UserWarning, stacklevel=2)
+        return values
+
+
+class HookConfig(_StrictConfig):
+    """Lifecycle hooks for tasks or global config."""
+
+    before_start: str | None = None
+    after_start: str | None = None
+    before_stop: str | None = None
+    after_stop: str | None = None
+
+
+class TaskConfig(_StrictConfig):
+    """Single task definition."""
+
+    command: str
+    auto_start: bool = True
+    cwd: str | None = None
+    health_check: str | None = None
+    health_interval: int = 10
+    health_timeout: int = 5
+    health_retries: int = 3
+    depends_on: list[str] = []
+    hooks: HookConfig = HookConfig()
+
+
+class TaskmuxConfig(_StrictConfig):
+    """Top-level taskmux.toml schema."""
+
+    name: str = "taskmux"
+    auto_start: bool = True
+    hooks: HookConfig = HookConfig()
+    tasks: dict[str, TaskConfig] = {}
+
+    @model_validator(mode="after")
+    def _validate_depends_on(self) -> "TaskmuxConfig":
+        """Reject unknown depends_on references and cycles."""
+        task_names = set(self.tasks.keys())
+        for name, cfg in self.tasks.items():
+            for dep in cfg.depends_on:
+                if dep not in task_names:
+                    raise ValueError(f"Task '{name}' depends on unknown task '{dep}'")
+                if dep == name:
+                    raise ValueError(f"Task '{name}' depends on itself")
+
+        # Cycle detection via DFS
+        WHITE, GRAY, BLACK = 0, 1, 2
+        color: dict[str, int] = {n: WHITE for n in task_names}
+
+        def dfs(node: str) -> None:
+            color[node] = GRAY
+            for dep in self.tasks[node].depends_on:
+                if color[dep] == GRAY:
+                    raise ValueError(f"Dependency cycle detected involving '{dep}'")
+                if color[dep] == WHITE:
+                    dfs(dep)
+            color[node] = BLACK
+
+        for n in task_names:
+            if color[n] == WHITE:
+                dfs(n)
+
+        return self

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

@@ -2,14 +2,33 @@
 
 from __future__ import annotations
 
+import subprocess
 import time
+from collections import deque
 from datetime import datetime
 
 import libtmux
+from rich.console import Console
+from rich.markup import escape
 
 from .hooks import runHook
 from .models import TaskmuxConfig
 
+TASK_COLORS = ["cyan", "green", "yellow", "magenta", "blue", "red"]
+
+
+def _find_new_lines(current: list[str], prev_tail: list[str]) -> list[str]:
+    """Return lines in current that are new since prev_tail."""
+    if not prev_tail:
+        return current
+    target = prev_tail[-1]
+    for i in range(len(current) - 1, -1, -1):
+        if current[i] == target:
+            ctx = min(len(prev_tail), i + 1)
+            if current[i - ctx + 1 : i + 1] == prev_tail[-ctx:]:
+                return current[i + 1 :]
+    return current  # no match, prev scrolled away — return all
+
 
 class TmuxManager:
     """Manages tmux sessions and tasks using libtmux API."""
@@ -47,6 +66,39 @@ class TmuxManager:
         except Exception:
             return []
 
+    def _is_pane_alive(self, task_name: str) -> bool:
+        """Check if task's pane has a running process (not just a shell)."""
+        if not self.session_exists():
+            return False
+        try:
+            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"
+        except Exception:
+            pass
+        return False
+
+    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)
+        if not task_cfg:
+            return False
+
+        if not task_cfg.health_check:
+            return self._is_pane_alive(task_name)
+
+        try:
+            result = subprocess.run(
+                task_cfg.health_check,
+                shell=True,
+                capture_output=True,
+                timeout=task_cfg.health_timeout,
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, OSError):
+            return False
+
     def get_task_status(self, task_name: str) -> dict[str, str | bool]:
         """Get detailed status for a task"""
         task_cfg = self.config.tasks.get(task_name)
@@ -64,27 +116,65 @@ class TmuxManager:
         windows = self.list_windows()
         status["running"] = task_name in windows
 
-        if self.session and status["running"]:
-            try:
-                window = self._get_session().windows.get(window_name=task_name)
-                if window and window.active_pane:
-                    current_command = getattr(window.active_pane, "pane_current_command", "")
-                    status["healthy"] = current_command != "" and current_command != "bash"
-            except Exception:
-                pass
+        if status["running"]:
+            status["healthy"] = self.is_task_healthy(task_name)
 
         return status
 
     def _send_command_to_window(
-        self, sess: libtmux.Session, task_name: str, command: str
+        self, sess: libtmux.Session, task_name: str, command: str, cwd: str | None = None
     ) -> libtmux.Window:
         """Create a new window and send a command to it."""
-        window = sess.new_window(attach=False, window_name=task_name)
+        kwargs: dict = {"attach": False, "window_name": task_name}
+        if cwd:
+            kwargs["start_directory"] = cwd
+        window = sess.new_window(**kwargs)
         pane = window.active_pane
         if pane:
             pane.send_keys(command, enter=True)
         return window
 
+    def _toposort_tasks(self, task_names: list[str]) -> list[str]:
+        """Topological sort tasks by depends_on (Kahn's algorithm). Raises on cycles."""
+        # Build adjacency + in-degree for the subset
+        in_degree: dict[str, int] = {n: 0 for n in task_names}
+        dependents: dict[str, list[str]] = {n: [] for n in task_names}
+        name_set = set(task_names)
+
+        for name in task_names:
+            for dep in self.config.tasks[name].depends_on:
+                if dep in name_set:
+                    in_degree[name] += 1
+                    dependents[dep].append(name)
+
+        queue: deque[str] = deque(n for n in task_names if in_degree[n] == 0)
+        result: list[str] = []
+
+        while queue:
+            node = queue.popleft()
+            result.append(node)
+            for dep in dependents[node]:
+                in_degree[dep] -= 1
+                if in_degree[dep] == 0:
+                    queue.append(dep)
+
+        if len(result) != len(task_names):
+            raise ValueError("Dependency cycle detected in tasks")
+
+        return result
+
+    def _wait_for_healthy(self, task_name: str, timeout: float) -> bool:
+        """Poll is_task_healthy until True or timeout."""
+        task_cfg = self.config.tasks[task_name]
+        interval = task_cfg.health_interval
+        elapsed = 0.0
+        while elapsed < timeout:
+            if self.is_task_healthy(task_name):
+                return True
+            time.sleep(interval)
+            elapsed += interval
+        return self.is_task_healthy(task_name)
+
     def start_task(self, task_name: str) -> None:
         """Start a single task (create window + send command)."""
         if task_name not in self.config.tasks:
@@ -99,11 +189,16 @@ class TmuxManager:
         task_cfg = self.config.tasks[task_name]
 
         # Check if already running
-        existing = sess.windows.get(window_name=task_name)
+        existing = sess.windows.get(window_name=task_name, default=None)
         if existing:
             print(f"Task '{task_name}' already running")
             return
 
+        # Warn if deps aren't running
+        for dep in task_cfg.depends_on:
+            if dep not in self.list_windows():
+                print(f"Warning: dependency '{dep}' is not running")
+
         # Hooks: global before_start, then task before_start
         if not runHook(self.config.hooks.before_start, task_name):
             return
@@ -118,11 +213,13 @@ class TmuxManager:
                 default.rename_window(task_name)
                 pane = default.active_pane
                 if pane:
+                    if task_cfg.cwd:
+                        pane.send_keys(f"cd {task_cfg.cwd}", enter=True)
                     pane.send_keys(task_cfg.command, enter=True)
             else:
-                self._send_command_to_window(sess, task_name, task_cfg.command)
+                self._send_command_to_window(sess, task_name, task_cfg.command, task_cfg.cwd)
         else:
-            self._send_command_to_window(sess, task_name, task_cfg.command)
+            self._send_command_to_window(sess, task_name, task_cfg.command, task_cfg.cwd)
 
         runHook(task_cfg.hooks.after_start, task_name)
         runHook(self.config.hooks.after_start, task_name)
@@ -139,7 +236,7 @@ class TmuxManager:
             return
 
         sess = self._get_session()
-        window = sess.windows.get(window_name=task_name)
+        window = sess.windows.get(window_name=task_name, default=None)
         if not window:
             print(f"Task '{task_name}' not running")
             return
@@ -160,7 +257,7 @@ class TmuxManager:
         print(f"Stopped task '{task_name}'")
 
     def start_all(self) -> None:
-        """Start all auto_start tasks (or create session if global auto_start=False)."""
+        """Start all auto_start tasks in dependency order."""
         if self.session_exists():
             print(f"Session '{self.config.name}' already exists")
             return
@@ -171,11 +268,14 @@ class TmuxManager:
             print(f"Created session '{self.config.name}' (auto_start disabled, no tasks launched)")
             return
 
-        auto_tasks = [(name, cfg) for name, cfg in self.config.tasks.items() if cfg.auto_start]
+        auto_tasks = {name: cfg for name, cfg in self.config.tasks.items() if cfg.auto_start}
         if not auto_tasks:
             print("No auto-start tasks defined in config")
             return
 
+        # Topological sort for dependency ordering
+        sorted_names = self._toposort_tasks(list(auto_tasks.keys()))
+
         # Global before_start
         if not runHook(self.config.hooks.before_start):
             return
@@ -183,20 +283,38 @@ class TmuxManager:
         self.session = self.server.new_session(session_name=self.config.name, attach=False)
         sess = self._get_session()
 
-        # First task reuses default window
-        first_name, first_cfg = auto_tasks[0]
-        runHook(first_cfg.hooks.before_start, first_name)
-        if sess.windows:
-            default_window = sess.windows[0]
-            default_window.rename_window(first_name)
-            pane = default_window.active_pane
-            if pane:
-                pane.send_keys(first_cfg.command, enter=True)
-        runHook(first_cfg.hooks.after_start, first_name)
+        first = True
+        for task_name in sorted_names:
+            task_cfg = auto_tasks[task_name]
+
+            # Wait for dependencies to become healthy before starting
+            skip = False
+            for dep in task_cfg.depends_on:
+                if dep in auto_tasks:
+                    dep_cfg = auto_tasks[dep]
+                    timeout = dep_cfg.health_retries * dep_cfg.health_interval
+                    if not self._wait_for_healthy(dep, timeout):
+                        print(f"Warning: dependency '{dep}' not healthy, skipping '{task_name}'")
+                        skip = True
+                        break
+            if skip:
+                continue
 
-        for task_name, task_cfg in auto_tasks[1:]:
             runHook(task_cfg.hooks.before_start, task_name)
-            self._send_command_to_window(sess, task_name, task_cfg.command)
+
+            if first and sess.windows:
+                # First task reuses default window
+                default_window = sess.windows[0]
+                default_window.rename_window(task_name)
+                pane = default_window.active_pane
+                if pane:
+                    if task_cfg.cwd:
+                        pane.send_keys(f"cd {task_cfg.cwd}", enter=True)
+                    pane.send_keys(task_cfg.command, enter=True)
+                first = False
+            else:
+                self._send_command_to_window(sess, task_name, task_cfg.command, task_cfg.cwd)
+
             runHook(task_cfg.hooks.after_start, task_name)
 
         # Global after_start
@@ -215,7 +333,7 @@ class TmuxManager:
         # Stop each task with hooks
         sess = self._get_session()
         for task_name, task_cfg in self.config.tasks.items():
-            window = sess.windows.get(window_name=task_name)
+            window = sess.windows.get(window_name=task_name, default=None)
             if window:
                 runHook(task_cfg.hooks.before_stop, task_name)
                 pane = window.active_pane
@@ -253,7 +371,7 @@ class TmuxManager:
         task_cfg = self.config.tasks[task_name]
         command = task_cfg.command
 
-        window = sess.windows.get(window_name=task_name)
+        window = sess.windows.get(window_name=task_name, default=None)
         if window:
             runHook(task_cfg.hooks.before_stop, task_name)
             pane = window.active_pane
@@ -265,11 +383,13 @@ class TmuxManager:
             runHook(task_cfg.hooks.before_start, task_name)
             pane = window.active_pane
             if pane:
+                if task_cfg.cwd:
+                    pane.send_keys(f"cd {task_cfg.cwd}", enter=True)
                 pane.send_keys(command, enter=True)
             runHook(task_cfg.hooks.after_start, task_name)
         else:
             runHook(task_cfg.hooks.before_start, task_name)
-            self._send_command_to_window(sess, task_name, command)
+            self._send_command_to_window(sess, task_name, command, task_cfg.cwd)
             runHook(task_cfg.hooks.after_start, task_name)
 
         print(f"Restarted task '{task_name}'")
@@ -280,7 +400,7 @@ class TmuxManager:
             print(f"Session '{self.config.name}' doesn't exist")
             return
 
-        window = self._get_session().windows.get(window_name=task_name)
+        window = self._get_session().windows.get(window_name=task_name, default=None)
         if window:
             window.kill()
             print(f"Killed task '{task_name}'")
@@ -297,6 +417,9 @@ class TmuxManager:
             "name": task_name,
             "command": task_cfg.command,
             "auto_start": task_cfg.auto_start,
+            "cwd": task_cfg.cwd,
+            "health_check": task_cfg.health_check,
+            "depends_on": task_cfg.depends_on,
             "running": False,
             "healthy": False,
             "pid": None,
@@ -310,7 +433,7 @@ class TmuxManager:
             return info
 
         sess = self._get_session()
-        window = sess.windows.get(window_name=task_name)
+        window = sess.windows.get(window_name=task_name, default=None)
         if not window:
             return info
 
@@ -324,37 +447,88 @@ class TmuxManager:
             info["pane_current_command"] = getattr(pane, "pane_current_command", None)
             info["pane_current_path"] = getattr(pane, "pane_current_path", None)
 
-            current_cmd = info["pane_current_command"] or ""
-            info["healthy"] = current_cmd != "" and current_cmd != "bash"
-
+        info["healthy"] = self.is_task_healthy(task_name)
         return info
 
+    def _tail_panes(
+        self,
+        panes: list[tuple[str, libtmux.Pane, str]],
+        lines: int = 100,
+        grep: str | None = None,
+    ) -> None:
+        """Poll capture-pane and print new lines with colored task prefixes."""
+        console = Console()
+        state: dict[str, list[str]] = {}
+
+        try:
+            while True:
+                for task_name, pane, color in panes:
+                    output = pane.cmd("capture-pane", "-p", "-S", f"-{lines}").stdout
+                    while output and not output[-1].strip():
+                        output.pop()
+
+                    prev = state.get(task_name, [])
+                    new = _find_new_lines(output, prev)
+
+                    if grep:
+                        new = [ln for ln in new if grep.lower() in ln.lower()]
+
+                    for line in new:
+                        prefix = escape(f"[{task_name}]")
+                        console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
+
+                    if output:
+                        state[task_name] = output[-50:]
+
+                time.sleep(0.5)
+        except KeyboardInterrupt:
+            console.print("\n[dim]Stopped following logs[/dim]")
+
+    def _collect_panes(self, task_names: list[str]) -> list[tuple[str, libtmux.Pane, str]]:
+        """Collect (name, pane, color) tuples for running tasks."""
+        sess = self._get_session()
+        result: list[tuple[str, libtmux.Pane, str]] = []
+        for i, name in enumerate(task_names):
+            window = sess.windows.get(window_name=name, default=None)
+            if not window:
+                continue
+            pane = window.active_pane
+            if pane:
+                color = TASK_COLORS[i % len(TASK_COLORS)]
+                result.append((name, pane, color))
+        return result
+
     def show_logs(
         self,
-        task_name: str,
+        task_name: str | None,
         follow: bool = False,
         lines: int = 100,
         grep: str | None = None,
         context: int = 3,
     ) -> None:
-        """Show logs for a task, optionally filtering with grep."""
+        """Show logs for a task or all tasks."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist")
             return
 
+        if task_name is None:
+            self.show_all_logs(follow=follow, lines=lines, grep=grep, context=context)
+            return
+
         if task_name not in self.config.tasks:
             print(f"Task '{task_name}' not found in config")
             return
 
         sess = self._get_session()
-        window = sess.windows.get(window_name=task_name)
+        window = sess.windows.get(window_name=task_name, default=None)
         if not window:
             print(f"Task '{task_name}' not found")
             return
 
         if follow:
-            window.select_window()
-            sess.attach()
+            panes = self._collect_panes([task_name])
+            if panes:
+                self._tail_panes(panes, lines=lines, grep=grep)
         else:
             pane = window.active_pane
             if pane:
@@ -365,6 +539,43 @@ class TmuxManager:
                     for line in output:
                         print(line)
 
+    def show_all_logs(
+        self,
+        follow: bool = False,
+        lines: int = 100,
+        grep: str | None = None,
+        context: int = 3,
+    ) -> None:
+        """Show logs from all running tasks."""
+        sess = self._get_session()
+        console = Console()
+        task_names = list(self.config.tasks.keys())
+
+        if follow:
+            panes = self._collect_panes(task_names)
+            if panes:
+                self._tail_panes(panes, lines=lines, grep=grep)
+            return
+
+        for i, task_name in enumerate(task_names):
+            window = sess.windows.get(window_name=task_name, default=None)
+            if not window:
+                continue
+            pane = window.active_pane
+            if not pane:
+                continue
+            color = TASK_COLORS[i % len(TASK_COLORS)]
+            output = pane.cmd("capture-pane", "-p", "-S", f"-{lines}").stdout
+            if grep:
+                matching = [line for line in output if grep.lower() in line.lower()]
+                for line in matching:
+                    prefix = escape(f"[{task_name}]")
+                    console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
+            else:
+                for line in output:
+                    prefix = escape(f"[{task_name}]")
+                    console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
+
     def list_tasks(self) -> None:
         """List all tasks and their status"""
         print(f"Session: {self.config.name}")
@@ -381,7 +592,12 @@ class TmuxManager:
                 "Healthy" if status["healthy"] else "Running" if status["running"] else "Stopped"
             )
             auto = "" if task_cfg.auto_start else " [manual]"
-            print(f"{health_icon} {status_text:8} {task_name:15} {task_cfg.command}{auto}")
+            extras = ""
+            if task_cfg.cwd:
+                extras += f" cwd={task_cfg.cwd}"
+            if task_cfg.depends_on:
+                extras += f" deps=[{','.join(task_cfg.depends_on)}]"
+            print(f"{health_icon} {status_text:8} {task_name:15} {task_cfg.command}{auto}{extras}")
 
     def show_status(self) -> None:
         """Show overall session status"""
@@ -394,9 +610,9 @@ class TmuxManager:
             self.list_tasks()
 
     def check_task_health(self, task_name: str) -> bool:
-        """Check if a task is healthy (process still running)"""
+        """Check if a task is healthy"""
+        is_healthy = self.is_task_healthy(task_name)
         status = self.get_task_status(task_name)
-        is_healthy = bool(status["running"] and status["healthy"])
 
         self.task_health[task_name] = {
             "healthy": is_healthy,

taskmux-0.2.3/taskmux/models.py

@@ -1,48 +0,0 @@
-"""Pydantic models for Taskmux configuration."""
-
-import warnings
-
-from pydantic import BaseModel, ConfigDict, model_validator
-
-
-class _StrictConfig(BaseModel):
-    """Base config: frozen, warns on unknown keys."""
-
-    model_config = ConfigDict(frozen=True)
-
-    @model_validator(mode="before")
-    @classmethod
-    def _warn_unknown_keys(cls, values: dict) -> dict:
-        if not isinstance(values, dict):
-            return values
-        known = set(cls.model_fields.keys())
-        unknown = set(values.keys()) - known
-        for key in sorted(unknown):
-            warnings.warn(f"Unknown config key: {key!r}", UserWarning, stacklevel=2)
-        return values
-
-
-class HookConfig(_StrictConfig):
-    """Lifecycle hooks for tasks or global config."""
-
-    before_start: str | None = None
-    after_start: str | None = None
-    before_stop: str | None = None
-    after_stop: str | None = None
-
-
-class TaskConfig(_StrictConfig):
-    """Single task definition."""
-
-    command: str
-    auto_start: bool = True
-    hooks: HookConfig = HookConfig()
-
-
-class TaskmuxConfig(_StrictConfig):
-    """Top-level taskmux.toml schema."""
-
-    name: str = "taskmux"
-    auto_start: bool = True
-    hooks: HookConfig = HookConfig()
-    tasks: dict[str, TaskConfig] = {}