taskmux 0.1.0__py3-none-any.whl

taskmux/__init__.py

@@ -0,0 +1,21 @@
+"""
+Taskmux - Modern tmux development environment manager
+
+A dynamic tmux session manager with libtmux integration, health monitoring,
+auto-restart capabilities, and WebSocket API for real-time communication.
+"""
+
+__version__ = "2.0.0"
+__author__ = "Taskmux Contributors"
+
+from .config import TaskmuxConfig
+from .tmux_manager import TmuxManager
+from .daemon import TaskmuxDaemon
+from .cli import TaskmuxCLI
+
+__all__ = [
+    "TaskmuxConfig",
+    "TmuxManager", 
+    "TaskmuxDaemon",
+    "TaskmuxCLI",
+]

taskmux/cli.py

@@ -0,0 +1,189 @@
+"""
+Typer-based CLI interface for Taskmux.
+"""
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .config import TaskmuxConfig
+from .daemon import SimpleConfigWatcher, TaskmuxDaemon
+from .tmux_manager import TmuxManager
+
+app = typer.Typer(
+    name="taskmux",
+    help="Modern tmux development environment manager with real-time health monitoring, auto-restart, and WebSocket API",
+    epilog="Uses libtmux API with health monitoring and daemon capabilities.",
+    rich_markup_mode="rich",
+)
+
+console = Console()
+
+
+class TaskmuxCLI:
+    """Main CLI application class."""
+
+    def __init__(self):
+        self.config = TaskmuxConfig()
+        self.tmux = TmuxManager(self.config)
+
+    def handle_config_reload(self):
+        """Handle config file reload in daemon mode"""
+        # Check for new or changed tasks and restart them
+        current_windows = self.tmux.list_windows()
+
+        for task_name, command in self.config.tasks.items():
+            if task_name in current_windows:
+                # Task exists, check if command changed (simplified check)
+                console.print(f"🔄 Reloading task '{task_name}' due to config change")
+                self.tmux.restart_task(task_name)
+            else:
+                # New task, create window
+                if self.tmux.session_exists():
+                    console.print(f"➕ Adding new task '{task_name}'")
+                    self.tmux.restart_task(task_name)  # This will create if not exists
+
+
+@app.command()
+def list():
+    """List all tasks and their status."""
+    cli = TaskmuxCLI()
+    cli.tmux.list_tasks()
+
+
+@app.command()
+def start():
+    """Start all tasks."""
+    cli = TaskmuxCLI()
+    cli.tmux.create_session()
+
+
+@app.command()
+def restart(
+    task: str = typer.Argument(..., help="Task name to restart"),
+):
+    """Restart a specific task."""
+    cli = TaskmuxCLI()
+    cli.tmux.restart_task(task)
+
+
+@app.command()
+def kill(
+    task: str = typer.Argument(..., help="Task name to kill"),
+):
+    """Kill a specific task."""
+    cli = TaskmuxCLI()
+    cli.tmux.kill_task(task)
+
+
+@app.command()
+def logs(
+    task: str = typer.Argument(..., help="Task name"),
+    follow: bool = typer.Option(False, "-f", "--follow", help="Follow logs"),
+    lines: int = typer.Option(100, "-n", "--lines", help="Number of lines"),
+):
+    """Show logs for a task."""
+    cli = TaskmuxCLI()
+    cli.tmux.show_logs(task, follow, lines)
+
+
+@app.command()
+def add(
+    task: str = typer.Argument(..., help="Task name"),
+    command: str = typer.Argument(..., help="Command to run"),
+):
+    """Add a new task."""
+    config = TaskmuxConfig()
+    config.add_task(task, command)
+    console.print(f"✓ Added task '{task}': {command}")
+
+
+@app.command()
+def remove(
+    task: str = typer.Argument(..., help="Task name to remove"),
+):
+    """Remove a task."""
+    cli = TaskmuxCLI()
+
+    # Kill the task if it's running
+    if cli.tmux.session_exists():
+        cli.tmux.kill_task(task)
+
+    # Remove from config
+    if cli.config.remove_task(task):
+        console.print(f"✓ Removed task '{task}'")
+    else:
+        console.print(f"Task '{task}' not found in config", style="red")
+
+
+@app.command()
+def status():
+    """Show session status."""
+    cli = TaskmuxCLI()
+    cli.tmux.show_status()
+
+
+@app.command()
+def health():
+    """Check health of all tasks."""
+    cli = TaskmuxCLI()
+
+    if not cli.tmux.session_exists():
+        console.print("No session running", style="yellow")
+        return
+
+    table = Table(title="🏥 Health Check Results")
+    table.add_column("Status", style="cyan")
+    table.add_column("Task", style="magenta")
+    table.add_column("Health", style="green")
+
+    healthy_count = 0
+    total_count = len(cli.config.tasks)
+
+    for task_name in cli.config.tasks:
+        is_healthy = cli.tmux.check_task_health(task_name)
+        status_icon = "💚" if is_healthy else "🔴"
+        status_text = "Healthy" if is_healthy else "Unhealthy"
+
+        table.add_row(status_icon, task_name, status_text)
+
+        if is_healthy:
+            healthy_count += 1
+
+    console.print(table)
+    console.print(f"Health: {healthy_count}/{total_count} tasks healthy")
+
+
+@app.command()
+def watch():
+    """Watch config file for changes."""
+    cli = TaskmuxCLI()
+    watcher = SimpleConfigWatcher(cli)
+    watcher.watch_config()
+
+
+@app.command()
+def daemon(
+    port: int = typer.Option(8765, "--port", help="WebSocket API port"),
+):
+    """Run in daemon mode with API."""
+    daemon = TaskmuxDaemon(api_port=port)
+    asyncio.run(daemon.start())
+
+
+@app.command()
+def stop():
+    """Stop the session and all tasks."""
+    cli = TaskmuxCLI()
+    cli.tmux.stop_session()
+
+
+def main():
+    """Main entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

taskmux/config.py

@@ -0,0 +1,57 @@
+"""
+Taskmux configuration management.
+"""
+
+import json
+import sys
+from typing import Dict
+
+
+class TaskmuxConfig:
+    """Manages taskmux.json configuration file loading and validation."""
+
+    def __init__(self, config_path: str = "taskmux.json"):
+        self.config_path = config_path
+        self.config = {}
+        self.load_config()
+
+    def load_config(self):
+        """Load configuration from JSON file"""
+        try:
+            with open(self.config_path, "r") as f:
+                self.config = json.load(f)
+            print(f"✓ Loaded config from {self.config_path}")
+        except FileNotFoundError:
+            print(f"Error: Config file {self.config_path} not found")
+            sys.exit(1)
+        except json.JSONDecodeError as e:
+            print(f"Error: Invalid JSON in {self.config_path}: {e}")
+            sys.exit(1)
+
+    def save_config(self):
+        """Save current configuration to JSON file"""
+        with open(self.config_path, "w") as f:
+            json.dump(self.config, f, indent=2)
+
+    @property
+    def session_name(self) -> str:
+        """Get the tmux session name"""
+        return self.config.get("name", "taskmux")
+
+    @property
+    def tasks(self) -> Dict[str, str]:
+        """Get the tasks dictionary"""
+        return self.config.get("tasks", {})
+
+    def add_task(self, task_name: str, command: str):
+        """Add a new task to the configuration"""
+        self.config.setdefault("tasks", {})[task_name] = command
+        self.save_config()
+
+    def remove_task(self, task_name: str) -> bool:
+        """Remove a task from the configuration. Returns True if task was found and removed."""
+        if task_name not in self.tasks:
+            return False
+        del self.config["tasks"][task_name]
+        self.save_config()
+        return True

taskmux/daemon.py

@@ -0,0 +1,278 @@
+"""
+Daemon mode for Taskmux with enhanced monitoring and WebSocket API.
+"""
+
+import asyncio
+import json
+import logging
+import signal
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Set
+
+import websockets
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+class ConfigWatcher(FileSystemEventHandler):
+    """File system event handler for monitoring config file changes."""
+
+    def __init__(self, taskmux_cli, daemon_mode=False):
+        self.taskmux_cli = taskmux_cli
+        self.daemon_mode = daemon_mode
+
+    def on_modified(self, event):
+        if event.src_path.endswith("taskmux.json"):
+            print("\n🔄 Config file changed, reloading...")
+            self.taskmux_cli.config.load_config()
+
+            # In daemon mode, restart affected tasks
+            if self.daemon_mode:
+                self.taskmux_cli.handle_config_reload()
+
+
+class TaskmuxDaemon:
+    """Daemon mode for Taskmux with enhanced monitoring and API"""
+
+    def __init__(self, config_path: str = "taskmux.json", api_port: int = 8765):
+        self.config_path = config_path
+        self.api_port = api_port
+        self.running = False
+        self.cli = None
+        self.observer = None
+        self.health_check_interval = 30  # seconds
+        self.health_check_task = None
+        self.websocket_clients: Set = set()
+        self.logger = self._setup_logging()
+
+        # Setup signal handlers
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    def _setup_logging(self) -> logging.Logger:
+        """Setup logging for daemon mode"""
+        logger = logging.getLogger("taskmux-daemon")
+        logger.setLevel(logging.INFO)
+
+        # Console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        # File handler
+        log_file = Path.home() / ".taskmux" / "daemon.log"
+        log_file.parent.mkdir(exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+        return logger
+
+    def _signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        self.logger.info(f"Received signal {signum}, shutting down...")
+        self.stop()
+        sys.exit(0)
+
+    async def start(self):
+        """Start daemon mode with monitoring and API"""
+        self.running = True
+
+        # Import here to avoid circular import
+        from .cli import TaskmuxCLI
+
+        self.cli = TaskmuxCLI()
+
+        self.logger.info(f"Starting Taskmux daemon for config: {self.config_path}")
+
+        # Start file watching
+        self.observer = Observer()
+        self.observer.schedule(
+            ConfigWatcher(self.cli, daemon_mode=True), ".", recursive=False
+        )
+        self.observer.start()
+        self.logger.info("Started config file watcher")
+
+        # Start health checking
+        self.health_check_task = asyncio.create_task(self._health_check_loop())
+
+        # Start WebSocket API server
+        api_task = asyncio.create_task(self._start_api_server())
+
+        self.logger.info(f"Taskmux daemon started on port {self.api_port}")
+        self.logger.info("Use Ctrl+C to stop")
+
+        try:
+            await asyncio.gather(self.health_check_task, api_task)
+        except asyncio.CancelledError:
+            self.logger.info("Daemon tasks cancelled")
+
+    def stop(self):
+        """Stop daemon mode"""
+        self.running = False
+
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+
+        if self.health_check_task and not self.health_check_task.done():
+            self.health_check_task.cancel()
+
+        self.logger.info("Taskmux daemon stopped")
+
+    async def _health_check_loop(self):
+        """Continuous health checking loop"""
+        while self.running:
+            try:
+                if self.cli and self.cli.tmux.session_exists():
+                    self.cli.tmux.auto_restart_unhealthy_tasks()
+
+                    # Broadcast health status to WebSocket clients
+                    if self.websocket_clients:
+                        status = await self._get_full_status()
+                        await self._broadcast_to_clients(
+                            {"type": "health_check", "data": status}
+                        )
+
+                await asyncio.sleep(self.health_check_interval)
+            except Exception as e:
+                self.logger.error(f"Health check error: {e}")
+                await asyncio.sleep(5)  # Short sleep on error
+
+    async def _start_api_server(self):
+        """Start WebSocket API server"""
+
+        async def handle_client(websocket, path):
+            self.websocket_clients.add(websocket)
+            self.logger.info(
+                f"New WebSocket client connected: {websocket.remote_address}"
+            )
+
+            try:
+                async for message in websocket:
+                    try:
+                        data = json.loads(message)
+                        response = await self._handle_api_request(data)
+                        await websocket.send(json.dumps(response))
+                    except json.JSONDecodeError:
+                        await websocket.send(json.dumps({"error": "Invalid JSON"}))
+                    except Exception as e:
+                        await websocket.send(json.dumps({"error": str(e)}))
+            except websockets.exceptions.ConnectionClosed:
+                pass
+            finally:
+                self.websocket_clients.discard(websocket)
+                self.logger.info(
+                    f"WebSocket client disconnected: {websocket.remote_address}"
+                )
+
+        start_server = websockets.serve(handle_client, "localhost", self.api_port)
+        await start_server
+
+    async def _handle_api_request(self, data: dict) -> dict:
+        """Handle WebSocket API requests"""
+        command = data.get("command")
+        params = data.get("params", {})
+
+        if command == "status":
+            return await self._get_full_status()
+        elif command == "restart":
+            task_name = params.get("task")
+            if task_name:
+                self.cli.tmux.restart_task(task_name)
+                return {"success": True, "message": f"Restarted {task_name}"}
+            return {"error": "Task name required"}
+        elif command == "kill":
+            task_name = params.get("task")
+            if task_name:
+                self.cli.tmux.kill_task(task_name)
+                return {"success": True, "message": f"Killed {task_name}"}
+            return {"error": "Task name required"}
+        elif command == "logs":
+            task_name = params.get("task")
+            lines = params.get("lines", 100)
+            if task_name and self.cli.tmux.session_exists():
+                # Get logs via libtmux
+                try:
+                    window = self.cli.tmux.session.windows.get(window_name=task_name)
+                    if window:
+                        pane = window.active_pane
+                        output = pane.cmd(
+                            "capture-pane", "-p", "-S", f"-{lines}"
+                        ).stdout
+                        return {"success": True, "logs": output}
+                except Exception:
+                    pass
+            return {"error": "Could not retrieve logs"}
+        else:
+            return {"error": f"Unknown command: {command}"}
+
+    async def _get_full_status(self) -> dict:
+        """Get comprehensive status information"""
+        if not self.cli:
+            return {"error": "CLI not initialized"}
+
+        session_exists = self.cli.tmux.session_exists()
+        tasks_status = {}
+
+        for task_name in self.cli.config.tasks:
+            tasks_status[task_name] = self.cli.tmux.get_task_status(task_name)
+
+        return {
+            "session_name": self.cli.config.session_name,
+            "session_exists": session_exists,
+            "tasks": tasks_status,
+            "api_type": "libtmux",
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    async def _broadcast_to_clients(self, message: dict):
+        """Broadcast message to all connected WebSocket clients"""
+        if not self.websocket_clients:
+            return
+
+        message_str = json.dumps(message)
+        disconnected = set()
+
+        for client in self.websocket_clients:
+            try:
+                await client.send(message_str)
+            except:
+                disconnected.add(client)
+
+        # Remove disconnected clients
+        self.websocket_clients -= disconnected
+
+
+class SimpleConfigWatcher:
+    """Simple config file watcher for non-daemon mode."""
+
+    def __init__(self, taskmux_cli):
+        self.taskmux_cli = taskmux_cli
+
+    def watch_config(self):
+        """Watch config file for changes"""
+        print(f"👀 Watching {self.taskmux_cli.config.config_path} for changes...")
+        print("Press Ctrl+C to stop")
+
+        observer = Observer()
+        observer.schedule(ConfigWatcher(self.taskmux_cli), ".", recursive=False)
+        observer.start()
+
+        try:
+            import time
+
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            observer.stop()
+            print("\n👋 Stopped watching")
+
+        observer.join()

taskmux/main.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""
+Taskmux - Modern tmux development environment manager
+
+Entry point that delegates to the Typer-based CLI.
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

taskmux/tmux_manager.py

@@ -0,0 +1,259 @@
+"""
+Tmux session and task management.
+"""
+
+import time
+from datetime import datetime
+from typing import Dict, List, Union
+
+import libtmux
+
+from .config import TaskmuxConfig
+
+
+class TmuxManager:
+    """Manages tmux sessions and tasks using libtmux API."""
+
+    def __init__(self, config: TaskmuxConfig):
+        self.config = config
+        self.server = libtmux.Server()
+        self.session = None
+        self.task_health = {}  # Track task health status
+        self._refresh_session()
+
+    def _refresh_session(self):
+        """Refresh session object from server"""
+        try:
+            self.session = self.server.sessions.get(
+                session_name=self.config.session_name
+            )
+        except Exception:
+            self.session = None
+
+    def session_exists(self) -> bool:
+        """Check if tmux session exists"""
+        self._refresh_session()
+        return self.session is not None
+
+    def list_windows(self) -> List[str]:
+        """List all windows in the session"""
+        if not self.session_exists():
+            return []
+
+        try:
+            return [window.window_name for window in self.session.windows]
+        except Exception:
+            return []
+
+    def get_task_status(self, task_name: str) -> Dict[str, Union[str, bool]]:
+        """Get detailed status for a task"""
+        status = {
+            "name": task_name,
+            "running": False,
+            "healthy": False,
+            "command": self.config.tasks.get(task_name, ""),
+            "last_check": datetime.now().isoformat(),
+        }
+
+        if not self.session_exists():
+            return status
+
+        windows = self.list_windows()
+        status["running"] = task_name in windows
+
+        if self.session and status["running"]:
+            try:
+                window = self.session.windows.get(window_name=task_name)
+                if window:
+                    # Check if process is still running
+                    pane = window.active_pane
+                    current_command = getattr(pane, "pane_current_command", "")
+                    status["healthy"] = (
+                        current_command != "" and current_command != "bash"
+                    )
+            except Exception:
+                pass
+
+        return status
+
+    def create_session(self):
+        """Create new tmux session with all tasks"""
+        if self.session_exists():
+            print(f"Session '{self.config.session_name}' already exists")
+            return
+
+        tasks = list(self.config.tasks.items())
+        if not tasks:
+            print("No tasks defined in config")
+            return
+
+        # Create session with libtmux
+        self.session = self.server.new_session(
+            session_name=self.config.session_name, attach=False
+        )
+
+        # Rename the default window to first task, then create remaining tasks
+        first_task, first_command = tasks[0]
+        if self.session.windows:
+            # Rename default window to first task
+            default_window = self.session.windows[0]
+            default_window.rename_window(first_task)
+            # Send command to the window
+            pane = default_window.active_pane
+            pane.send_keys(first_command, enter=True)
+
+        # Create windows for remaining tasks
+        for task_name, command in tasks[1:]:
+            window = self.session.new_window(
+                attach=False, window_name=task_name
+            )
+            # Send command to the window
+            pane = window.active_pane
+            pane.send_keys(command, enter=True)
+
+        print(
+            f"✓ Created session '{self.config.session_name}' with {len(tasks)} tasks"
+        )
+
+    def restart_task(self, task_name: str):
+        """Restart a specific task"""
+        if not self.session_exists():
+            print(
+                f"Session '{self.config.session_name}' doesn't exist. Run 'taskmux start' first."
+            )
+            return
+
+        if task_name not in self.config.tasks:
+            print(f"Task '{task_name}' not found in config")
+            return
+
+        command = self.config.tasks[task_name]
+
+        window = self.session.windows.get(window_name=task_name)
+        if window:
+            # Kill current process and restart
+            pane = window.active_pane
+            pane.send_keys("C-c")
+            time.sleep(0.5)
+            pane.send_keys(command, enter=True)
+        else:
+            # Create new window
+            window = self.session.new_window(
+                attach=False, window_name=task_name
+            )
+            pane = window.active_pane
+            pane.send_keys(command, enter=True)
+
+        print(f"✓ Restarted task '{task_name}'")
+
+    def kill_task(self, task_name: str):
+        """Kill a specific task"""
+        if not self.session_exists():
+            print(f"Session '{self.config.session_name}' doesn't exist")
+            return
+
+        window = self.session.windows.get(window_name=task_name)
+        if window:
+            window.kill()
+            print(f"✓ Killed task '{task_name}'")
+        else:
+            print(f"Task '{task_name}' not found")
+
+    def show_logs(self, task_name: str, follow: bool = False, lines: int = 100):
+        """Show logs for a task"""
+        if not self.session_exists():
+            print(f"Session '{self.config.session_name}' doesn't exist")
+            return
+
+        if task_name not in self.config.tasks:
+            print(f"Task '{task_name}' not found in config")
+            return
+
+        window = self.session.windows.get(window_name=task_name)
+        if not window:
+            print(f"Task '{task_name}' not found")
+            return
+
+        if follow:
+            # Attach to the window to follow logs
+            window.select_window()
+            self.session.attach()
+        else:
+            # Show recent logs
+            pane = window.active_pane
+            output = pane.cmd(
+                "capture-pane", "-p", "-S", f"-{lines}"
+            ).stdout
+            for line in output:
+                print(line)
+
+    def list_tasks(self):
+        """List all tasks and their status"""
+        print(f"Session: {self.config.session_name}")
+        print("─" * 70)
+
+        if not self.config.tasks:
+            print("No tasks configured")
+            return
+
+        for task_name, command in self.config.tasks.items():
+            status = self.get_task_status(task_name)
+            health_icon = (
+                "💚" if status["healthy"] else "🔴" if status["running"] else "○"
+            )
+            status_text = (
+                "Healthy"
+                if status["healthy"]
+                else "Running"
+                if status["running"]
+                else "Stopped"
+            )
+            print(f"{health_icon} {status_text:8} {task_name:15} {command}")
+
+    def show_status(self):
+        """Show overall session status"""
+        exists = self.session_exists()
+        print(
+            f"Session '{self.config.session_name}': {'Running' if exists else 'Stopped'} (libtmux)"
+        )
+
+        if exists:
+            windows = self.list_windows()
+            print(f"Active tasks: {len(windows)}")
+            self.list_tasks()
+
+    def check_task_health(self, task_name: str) -> bool:
+        """Check if a task is healthy (process still running)"""
+        status = self.get_task_status(task_name)
+        is_healthy = status["running"] and status["healthy"]
+
+        # Update health tracking
+        self.task_health[task_name] = {
+            "healthy": is_healthy,
+            "last_check": datetime.now(),
+            "status": status,
+        }
+
+        return is_healthy
+
+    def auto_restart_unhealthy_tasks(self):
+        """Auto-restart tasks that have become unhealthy"""
+        if not self.session_exists():
+            return
+
+        for task_name in self.config.tasks:
+            if not self.check_task_health(task_name):
+                # Check if it was previously healthy (avoid restart loops)
+                prev_health = self.task_health.get(task_name, {}).get("healthy", True)
+                if prev_health:  # Only restart if it was previously healthy
+                    print(f"🔄 Auto-restarting unhealthy task: {task_name}")
+                    self.restart_task(task_name)
+
+    def stop_session(self):
+        """Stop the entire tmux session"""
+        if not self.session_exists():
+            print("No session running")
+            return
+
+        self.session.kill()
+        print(f"✓ Stopped session '{self.config.session_name}'")

taskmux-0.1.0.dist-info/METADATA

@@ -0,0 +1,451 @@
+Metadata-Version: 2.4
+Name: taskmux
+Version: 0.1.0
+Summary: Modern tmux development environment manager with real-time health monitoring, auto-restart, and WebSocket API
+Project-URL: Homepage, https://github.com/nc9/taskmux
+Project-URL: Repository, https://github.com/nc9/taskmux
+Project-URL: Issues, https://github.com/nc9/taskmux/issues
+Author-email: Nik Cubrilovic <git@nikcub.me>
+License: MIT
+License-File: LICENSE
+Keywords: daemon,development,manager,monitoring,session,terminal,tmux
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Terminals
+Requires-Python: >=3.8
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: libtmux>=0.37.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: websockets>=12.0
+Description-Content-Type: text/markdown
+
+# Taskmux
+
+A modern tmux development environment manager with real-time health monitoring, auto-restart capabilities, and WebSocket API. Built with Python using libtmux for reliable session management.
+
+## Why Taskmux?
+
+Instead of manually managing multiple tmux windows or remembering complex command sequences, Taskmux provides:
+
+- **Dynamic task management**: Define tasks in JSON, manage via modern CLI
+- **Health monitoring**: Real-time task health checks with visual indicators  
+- **Auto-restart**: Automatically restart failed tasks to keep development flowing
+- **WebSocket API**: Real-time status updates and remote task management
+- **Rich CLI**: Beautiful terminal output with Typer and Rich integration
+- **File watching**: Automatically detects config changes and reloads tasks
+- **Zero setup**: Single command installation with uv tool management
+
+## Installation
+
+### Prerequisites
+
+- [tmux](https://github.com/tmux/tmux) - Terminal multiplexer
+- [uv](https://docs.astral.sh/uv/) - Modern Python package manager
+
+### Install uv (if you don't have it)
+
+**Quick install** (macOS/Linux):
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+**Windows**:
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+**Alternative methods**:
+```bash
+# Via Homebrew (macOS)
+brew install uv
+
+# Via pipx
+pipx install uv
+
+# Via WinGet (Windows)
+winget install --id=astral-sh.uv -e
+```
+
+### Install Taskmux
+
+**Recommended** (installs globally):
+```bash
+uv tool install taskmux
+```
+
+**From source**:
+```bash
+git clone https://github.com/your-repo/taskmux
+cd taskmux
+uv tool install .
+```
+
+After installation, `taskmux` command will be available globally.
+
+## Quick Start
+
+1. **Create config file** in your project root:
+
+```json
+{
+  "name": "myproject",
+  "tasks": {
+    "server": "npm run dev",
+    "build": "npm run build:watch", 
+    "test": "npm run test:watch",
+    "db": "docker-compose up postgres"
+  }
+}
+```
+
+2. **Start all tasks**:
+```bash
+taskmux start
+```
+
+3. **Monitor and manage**:
+```bash
+taskmux list          # See what's running with health status
+taskmux health        # Detailed health check table
+taskmux restart server # Restart specific task
+taskmux logs -f test   # Follow logs
+```
+
+## Commands Reference
+
+### Core Commands
+
+```bash
+# Session Management
+taskmux start                    # Start all tasks in tmux session
+taskmux status                   # Show session and task status
+taskmux list                     # List all tasks with health indicators
+taskmux stop                     # Stop session and all tasks
+
+# Task Management  
+taskmux restart <task>           # Restart specific task
+taskmux kill <task>              # Kill specific task
+taskmux add <task> "<command>"   # Add new task to config
+taskmux remove <task>            # Remove task from config
+
+# Monitoring
+taskmux health                   # Health check with status table
+taskmux logs <task>              # Show recent logs
+taskmux logs -f <task>           # Follow logs (live)
+taskmux logs -n 100 <task>       # Show last N lines
+
+# Advanced
+taskmux watch                    # Watch config for changes
+taskmux daemon --port 8765       # Run with WebSocket API
+```
+
+### Command Examples
+
+```bash
+# Start development environment
+taskmux start
+
+# Check what's running with health status
+taskmux list
+# Output:
+# Session: myproject
+# ──────────────────────────────────────────────────
+# 💚 Healthy  server          npm run dev
+# 💚 Healthy  build           npm run build:watch
+# 🔴 Unhealthy test           npm run test:watch
+# 💚 Healthy  db              docker-compose up postgres
+
+# Detailed health check
+taskmux health
+# ┏━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┓
+# ┃ Status ┃ Task    ┃ Health    ┃
+# ┡━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━┩
+# │ 💚     │ server  │ Healthy   │
+# │ 💚     │ build   │ Healthy   │
+# │ 🔴     │ test    │ Unhealthy │
+# │ 💚     │ db      │ Healthy   │
+# └────────┴─────────┴───────────┘
+
+# Restart a misbehaving service
+taskmux restart server
+
+# Add a new background task
+taskmux add worker "python background_worker.py"
+
+# Follow logs for debugging
+taskmux logs -f test
+
+# Watch config file for changes
+taskmux watch
+```
+
+## Configuration
+
+### Config File Format
+
+Create `taskmux.json` in your project root:
+
+```json
+{
+  "name": "session-name",
+  "tasks": {
+    "task-name": "command to run",
+    "another-task": "another command"
+  }
+}
+```
+
+### Config Examples
+
+**Web Development**:
+```json
+{
+  "name": "webapp",
+  "tasks": {
+    "frontend": "npm run dev",
+    "backend": "python manage.py runserver",
+    "database": "docker-compose up -d postgres",
+    "redis": "redis-server",
+    "worker": "celery worker -A myapp",
+    "tailwind": "npx tailwindcss -w"
+  }
+}
+```
+
+**Data Science**:
+```json
+{
+  "name": "analysis",
+  "tasks": {
+    "jupyter": "jupyter lab --port=8888",
+    "mlflow": "mlflow ui --port=5000",
+    "airflow": "airflow webserver",
+    "postgres": "docker run -p 5432:5432 postgres:13",
+    "tensorboard": "tensorboard --logdir=./logs"
+  }
+}
+```
+
+**Microservices**:
+```json
+{
+  "name": "microservices", 
+  "tasks": {
+    "api-gateway": "node gateway/server.js",
+    "user-service": "go run services/user/main.go",
+    "order-service": "python services/orders/app.py",
+    "redis": "redis-server",
+    "postgres": "docker-compose up -d db",
+    "monitoring": "prometheus --config.file=prometheus.yml"
+  }
+}
+```
+
+## Advanced Features
+
+### Daemon Mode with WebSocket API
+
+Run Taskmux as a background daemon with real-time API:
+
+```bash
+# Start daemon on port 8765 (default)
+taskmux daemon
+
+# Custom port
+taskmux daemon --port 9000
+```
+
+**WebSocket API Usage**:
+```javascript
+// Connect to WebSocket API
+const ws = new WebSocket('ws://localhost:8765');
+
+// Get status
+ws.send(JSON.stringify({
+  command: "status"
+}));
+
+// Restart task
+ws.send(JSON.stringify({
+  command: "restart",
+  params: { task: "server" }
+}));
+
+// Get logs
+ws.send(JSON.stringify({
+  command: "logs", 
+  params: { task: "server", lines: 50 }
+}));
+```
+
+### Health Monitoring & Auto-restart
+
+Taskmux continuously monitors task health and can auto-restart failed processes:
+
+- **Health indicators**: 💚 Healthy, 🔴 Unhealthy, ○ Stopped
+- **Process monitoring**: Detects when tasks exit or become unresponsive
+- **Auto-restart**: Daemon mode automatically restarts failed tasks
+- **Health checks**: Run `taskmux health` for detailed status
+
+### File Watching
+
+Monitor config changes in real-time:
+
+```bash
+# Terminal 1: Start file watcher
+taskmux watch
+
+# Terminal 2: Edit config
+echo '{"name": "test", "tasks": {"new": "echo hello"}}' > taskmux.json
+# Watcher automatically reloads config and updates running tasks
+
+# New task is immediately available
+taskmux restart new
+```
+
+## Workflow Integration
+
+### Daily Development
+
+```bash
+# Morning: Start everything
+taskmux start
+
+# During development: Monitor health
+taskmux health
+
+# Restart services as needed
+taskmux restart api
+taskmux logs -f frontend
+
+# Add new services on the fly
+taskmux add monitoring "python monitor.py"
+
+# Run with file watching for config changes
+taskmux watch
+
+# Evening: Stop everything
+taskmux stop
+```
+
+### Tmux Integration
+
+Taskmux creates standard tmux sessions. You can use all tmux commands:
+
+```bash
+# Attach to session
+tmux attach-session -t myproject
+
+# Switch between task windows
+# Ctrl+b 1, Ctrl+b 2, etc.
+
+# Create additional windows
+tmux new-window -t myproject -n shell
+
+# Detach and reattach later
+# Ctrl+b d
+tmux attach-session -t myproject
+```
+
+### Multiple Projects
+
+Each project gets its own tmux session based on the `name` field:
+
+```bash
+# Project A (session: "webapp")
+cd ~/projects/webapp
+taskmux start
+
+# Project B (session: "api") 
+cd ~/projects/api
+taskmux start
+
+# Both run simultaneously with separate sessions
+tmux list-sessions
+# webapp: 4 windows
+# api: 2 windows
+```
+
+## Architecture
+
+Taskmux is built with modern Python tooling:
+
+- **libtmux**: Reliable Python API for tmux session management
+- **Typer**: Modern CLI framework with rich help and validation
+- **Rich**: Beautiful terminal output with tables and progress bars
+- **WebSockets**: Real-time API for remote monitoring and control
+- **asyncio**: Async health monitoring and daemon capabilities
+- **Watchdog**: File system monitoring for config changes
+
+## Troubleshooting
+
+### Common Issues
+
+**Config not found**:
+```bash
+Error: Config file taskmux.json not found
+```
+- Ensure `taskmux.json` exists in current directory
+- Check JSON syntax with `jq . taskmux.json`
+
+**Session already exists**:
+```bash
+Session 'myproject' already exists
+```
+- Kill existing session: `taskmux stop`
+- Or attach to it: `tmux attach-session -t myproject`
+
+**Task not restarting**:
+- Check if task name exists: `taskmux list`
+- Verify session is running: `taskmux status`
+- Check task health: `taskmux health`
+
+**libtmux connection issues**:
+- Ensure tmux is installed and in PATH
+- Try restarting tmux server: `tmux kill-server`
+
+### Debug Mode
+
+View detailed tmux session information:
+```bash
+# Check if session exists
+tmux has-session -t myproject
+
+# List windows in session  
+tmux list-windows -t myproject
+
+# View logs manually
+tmux capture-pane -t myproject:taskname -p
+
+# Check daemon logs
+tail -f ~/.taskmux/daemon.log
+```
+
+## Contributing
+
+Taskmux follows modern Python development practices:
+
+1. **Modular architecture**: Separate concerns (CLI, tmux management, daemon, config)
+2. **Type hints**: Full type annotation for better IDE support
+3. **Rich CLI**: Beautiful, user-friendly command-line interface
+4. **Async support**: Background monitoring and WebSocket API
+5. **Comprehensive testing**: Test across different tmux versions and platforms
+
+## License
+
+MIT License - feel free to modify and distribute.

taskmux-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+taskmux/__init__.py,sha256=W5wMUzcF5IPMuW5rgKAA3tKKd0CO_w9W7vyOvGWLD0g,501
+taskmux/cli.py,sha256=TNeMLcGhoZ7JxDUr90AsWgjbLhUy4Ne-DdYRxP--iDY,4799
+taskmux/config.py,sha256=ZwzCUxZWn-Pwfz1pVs2EUImTQBFepfqf6PaQ7BwPNg0,1803
+taskmux/daemon.py,sha256=WyELHEL8XUCTScJf_-kfDs_j7s__DYFnlx_ZdivZ4zU,9643
+taskmux/main.py,sha256=H2LAzjv5aTTigepneeBxP_0qE-no0g3642O5TF7yW6E,198
+taskmux/tmux_manager.py,sha256=oYlvBOBbF9aAEpC37S4wwtIKsuL8R4j524QhZKgUs5Y,8560
+taskmux/templates/claude.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taskmux-0.1.0.dist-info/METADATA,sha256=_cf4PClz_z5TEGychvrwdlyPU_8sjma2H8iu71ItTTk,11531
+taskmux-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+taskmux-0.1.0.dist-info/entry_points.txt,sha256=nKwgFRwZPanoeW-GSJ9QdBzg2bMqK-RjNYfg6fWCgwg,46
+taskmux-0.1.0.dist-info/licenses/LICENSE,sha256=gXlGWdKwicnxQy_myUxod66y7btv3y9clpO0_aEk9Ec,1070
+taskmux-0.1.0.dist-info/RECORD,,

taskmux-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

taskmux-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+taskmux = taskmux.main:main

taskmux-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nik Cubrilovic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.