bot-master 0.1.0__tar.gz

bot_master-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+logs/
+.venv/
+__pycache__/
+*.egg-info/

bot_master-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: bot-master
+Version: 0.1.0
+Requires-Python: >=3.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: textual>=3.0

bot_master-0.1.0/README.md

@@ -0,0 +1,81 @@
+# Bot Master
+
+A process manager for Telegram bots with a terminal UI. Runs as a background daemon (survives reboots via systemd) with a Textual TUI client for monitoring.
+
+## Architecture
+
+- **Daemon** (`bot-master-daemon`) — manages bot subprocesses, auto-restarts on crash (exponential backoff), buffers logs in memory and writes to disk. Communicates via Unix socket.
+- **TUI Client** (`bot-master`) — connects to the daemon to view live status, stream logs, and send start/stop/restart commands. If the TUI crashes, bots keep running.
+
+## Setup
+
+```bash
+cd ~/bots/bot-master
+uv sync
+```
+
+## Configuration
+
+Edit `bots.yaml`:
+
+```yaml
+bots:
+  my-bot:
+    directory: /path/to/bot
+    command: uv run python main.py
+```
+
+## Usage
+
+### Start the daemon manually
+
+```bash
+uv run bot-master-daemon
+```
+
+### Install as a systemd service (auto-start on boot, auto-restart on failure)
+
+```bash
+./install.sh
+```
+
+This generates the systemd unit from the current directory, enables and starts the service.
+
+### Connect with the TUI
+
+```bash
+uv run bot-master
+```
+
+### TUI Keybindings
+
+| Key | Action |
+|-----|--------|
+| `s` | Start selected bot |
+| `x` | Stop selected bot |
+| `r` | Restart selected bot |
+| `a` | Start all bots |
+| `z` | Stop all bots |
+| `j`/`k` or arrows | Navigate bot list |
+| `q` | Quit TUI (daemon keeps running) |
+
+## Logs
+
+Logs are stored in the `logs/` directory (one file per bot, 10 MB rotation with 5 backups):
+
+```
+logs/
+  au-tomator.log
+  zapier.log
+  writing-assistant.log
+```
+
+The daemon also keeps the last 5000 lines per bot in memory for fast streaming to the TUI.
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BOT_MASTER_SOCK` | `/tmp/bot-master.sock` | Unix socket path |
+| `BOT_MASTER_CONFIG` | `bots.yaml` | Config file path |
+| `BOT_MASTER_LOG_DIR` | `logs` | Log directory path |

bot_master-0.1.0/bot_master/app.py

@@ -0,0 +1,284 @@
+import asyncio
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Footer, Header, RichLog, Static
+
+from bot_master.protocol import SOCKET_PATH, read_message, write_message
+
+
+class DaemonClient:
+    def __init__(self) -> None:
+        self.reader: asyncio.StreamReader | None = None
+        self.writer: asyncio.StreamWriter | None = None
+        self._lock = asyncio.Lock()
+
+    async def connect(self) -> bool:
+        try:
+            self.reader, self.writer = await asyncio.open_unix_connection(str(SOCKET_PATH))
+            return True
+        except (ConnectionRefusedError, FileNotFoundError, OSError):
+            return False
+
+    async def send(self, msg: dict) -> dict | None:
+        if not self.writer or not self.reader:
+            return None
+        async with self._lock:
+            try:
+                await write_message(self.writer, msg)
+                return await read_message(self.reader)
+            except (ConnectionError, BrokenPipeError, OSError):
+                return None
+
+    async def close(self) -> None:
+        if self.writer:
+            self.writer.close()
+            try:
+                await self.writer.wait_closed()
+            except Exception:
+                pass
+
+
+class BotItem(Static):
+    selected = reactive(False)
+
+    def __init__(self, bot_name: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.bot_name = bot_name
+        self.bot_status = "stopped"
+        self.bot_pid: int | None = None
+        self.bot_uptime: int | None = None
+        self.bot_restarts: int = 0
+
+    class Selected(Message):
+        def __init__(self, bot_name: str) -> None:
+            super().__init__()
+            self.bot_name = bot_name
+
+    def on_click(self) -> None:
+        self.post_message(self.Selected(self.bot_name))
+
+    def render(self) -> str:
+        status = self.bot_status
+        if status == "running":
+            indicator = "[green]●[/]"
+            extra = ""
+            if self.bot_uptime is not None:
+                m, s = divmod(self.bot_uptime, 60)
+                h, m = divmod(m, 60)
+                extra = f" [dim]{h:02d}:{m:02d}:{s:02d}[/]"
+        elif status == "backoff":
+            indicator = "[yellow]●[/]"
+            extra = f" [dim]restart #{self.bot_restarts}[/]"
+        else:
+            indicator = "[dim]●[/]"
+            extra = ""
+
+        sel = "▸ " if self.selected else "  "
+        return f"{sel}{indicator} {self.bot_name}{extra}"
+
+    def watch_selected(self, value: bool) -> None:
+        self.set_class(value, "--selected")
+
+
+class BotMasterApp(App):
+    CSS_PATH = "app.tcss"
+    TITLE = "Bot Master"
+
+    BINDINGS = [
+        Binding("s", "start_bot", "Start"),
+        Binding("x", "stop_bot", "Stop"),
+        Binding("r", "restart_bot", "Restart"),
+        Binding("a", "start_all", "Start All"),
+        Binding("z", "stop_all", "Stop All"),
+        Binding("j", "next_bot", "Next", show=False),
+        Binding("k", "prev_bot", "Prev", show=False),
+        Binding("down", "next_bot", "Next", show=False),
+        Binding("up", "prev_bot", "Prev", show=False),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    selected_bot: reactive[str] = reactive("")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.client = DaemonClient()
+        self.bot_names: list[str] = []
+        self._log_task: asyncio.Task | None = None
+        self._connected = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal(id="main-container"):
+            with Vertical(id="sidebar"):
+                yield Static("Bots", id="sidebar-title")
+                yield Vertical(id="bot-list")
+            with Vertical(id="log-container"):
+                yield Static("Select a bot", id="log-title")
+                yield RichLog(id="log-view", highlight=True, markup=True)
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        connected = await self.client.connect()
+        if not connected:
+            log_view = self.query_one("#log-view", RichLog)
+            log_view.write("[red]Cannot connect to daemon.[/]")
+            log_view.write(f"[dim]Is bot-master-daemon running? Socket: {SOCKET_PATH}[/]")
+            log_view.write("")
+            log_view.write("[dim]Start it with: bot-master-daemon[/]")
+            return
+
+        self._connected = True
+        resp = await self.client.send({"action": "status"})
+        if resp and resp.get("ok"):
+            bot_list = self.query_one("#bot-list", Vertical)
+            for bot_info in resp["bots"]:
+                name = bot_info["name"]
+                self.bot_names.append(name)
+                item = BotItem(name, id=f"bot-{name}")
+                item.bot_status = bot_info["status"]
+                item.bot_pid = bot_info.get("pid")
+                item.bot_uptime = bot_info.get("uptime")
+                item.bot_restarts = bot_info.get("restart_count", 0)
+                await bot_list.mount(item)
+
+            if self.bot_names:
+                self.selected_bot = self.bot_names[0]
+
+        self.set_interval(2, self._poll_status)
+
+    async def _poll_status(self) -> None:
+        if not self._connected:
+            return
+        resp = await self.client.send({"action": "status"})
+        if not resp or not resp.get("ok"):
+            return
+        for bot_info in resp["bots"]:
+            name = bot_info["name"]
+            try:
+                item = self.query_one(f"#bot-{name}", BotItem)
+                item.bot_status = bot_info["status"]
+                item.bot_pid = bot_info.get("pid")
+                item.bot_uptime = bot_info.get("uptime")
+                item.bot_restarts = bot_info.get("restart_count", 0)
+                item.refresh()
+            except Exception:
+                pass
+
+    def on_bot_item_selected(self, event: BotItem.Selected) -> None:
+        self.selected_bot = event.bot_name
+
+    async def watch_selected_bot(self, bot_name: str) -> None:
+        if not bot_name or not self._connected:
+            return
+
+        # Update selection UI
+        for name in self.bot_names:
+            try:
+                item = self.query_one(f"#bot-{name}", BotItem)
+                item.selected = name == bot_name
+            except Exception:
+                pass
+
+        # Update title
+        title = self.query_one("#log-title", Static)
+        title.update(f"Logs: {bot_name}")
+
+        # Cancel existing log stream
+        if self._log_task:
+            self._log_task.cancel()
+            self._log_task = None
+
+        # Fetch recent logs
+        log_view = self.query_one("#log-view", RichLog)
+        log_view.clear()
+
+        # We need a fresh connection for log streaming since the protocol
+        # uses subscribe_logs which holds the connection
+        resp = await self.client.send({"action": "logs", "bot": bot_name, "lines": 500})
+        if resp and resp.get("ok"):
+            for line in resp["lines"]:
+                log_view.write(line)
+
+        # Start streaming in a separate connection
+        self._log_task = asyncio.create_task(self._stream_logs(bot_name))
+
+    async def _stream_logs(self, bot_name: str) -> None:
+        try:
+            reader, writer = await asyncio.open_unix_connection(str(SOCKET_PATH))
+            await write_message(writer, {"action": "subscribe_logs", "bot": bot_name})
+            resp = await read_message(reader)
+            if not resp or not resp.get("ok"):
+                return
+
+            log_view = self.query_one("#log-view", RichLog)
+            while True:
+                msg = await read_message(reader)
+                if msg is None:
+                    break
+                if "log" in msg:
+                    log_view.write(msg["log"])
+
+        except (asyncio.CancelledError, ConnectionError, OSError):
+            pass
+
+    async def action_start_bot(self) -> None:
+        if self.selected_bot and self._connected:
+            await self.client.send({"action": "start", "bot": self.selected_bot})
+
+    async def action_stop_bot(self) -> None:
+        if self.selected_bot and self._connected:
+            await self.client.send({"action": "stop", "bot": self.selected_bot})
+
+    async def action_restart_bot(self) -> None:
+        if self.selected_bot and self._connected:
+            await self.client.send({"action": "restart", "bot": self.selected_bot})
+
+    async def action_start_all(self) -> None:
+        if self._connected:
+            for name in self.bot_names:
+                await self.client.send({"action": "start", "bot": name})
+
+    async def action_stop_all(self) -> None:
+        if self._connected:
+            for name in self.bot_names:
+                await self.client.send({"action": "stop", "bot": name})
+
+    def action_next_bot(self) -> None:
+        if not self.bot_names:
+            return
+        try:
+            idx = self.bot_names.index(self.selected_bot)
+            idx = (idx + 1) % len(self.bot_names)
+        except ValueError:
+            idx = 0
+        self.selected_bot = self.bot_names[idx]
+
+    def action_prev_bot(self) -> None:
+        if not self.bot_names:
+            return
+        try:
+            idx = self.bot_names.index(self.selected_bot)
+            idx = (idx - 1) % len(self.bot_names)
+        except ValueError:
+            idx = 0
+        self.selected_bot = self.bot_names[idx]
+
+    async def action_quit(self) -> None:
+        if self._log_task:
+            self._log_task.cancel()
+        await self.client.close()
+        self.exit()
+
+
+def main() -> None:
+    app = BotMasterApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

bot_master-0.1.0/bot_master/app.tcss

@@ -0,0 +1,53 @@
+#main-container {
+    height: 1fr;
+}
+
+#sidebar {
+    width: 32;
+    border-right: solid $primary;
+    padding: 0;
+}
+
+#sidebar-title {
+    text-style: bold;
+    padding: 1 1 0 1;
+    color: $text;
+}
+
+#bot-list {
+    height: 1fr;
+}
+
+BotItem {
+    height: 3;
+    padding: 0 1;
+}
+
+BotItem:hover {
+    background: $boost;
+}
+
+BotItem.--selected {
+    background: $accent;
+}
+
+#log-container {
+    width: 1fr;
+}
+
+#log-title {
+    text-style: bold;
+    padding: 1;
+    dock: top;
+    height: 3;
+}
+
+#log-view {
+    height: 1fr;
+}
+
+#no-connection {
+    width: 1fr;
+    height: 1fr;
+    content-align: center middle;
+}

bot_master-0.1.0/bot_master/daemon.py

@@ -0,0 +1,176 @@
+import asyncio
+import os
+import signal
+import sys
+from pathlib import Path
+
+from bot_master.process_manager import ProcessManager
+from bot_master.protocol import CONFIG_PATH, SOCKET_PATH, read_message, write_message
+
+manager = ProcessManager()
+
+
+async def handle_client(
+    reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+) -> None:
+    subscription: tuple[str, asyncio.Queue] | None = None
+
+    try:
+        while True:
+            msg = await read_message(reader)
+            if msg is None:
+                break
+
+            action = msg.get("action")
+
+            # Cancel any active log subscription when a new command arrives
+            if subscription:
+                bot_name, queue = subscription
+                try:
+                    manager.get_bot(bot_name).unsubscribe(queue)
+                except KeyError:
+                    pass
+                subscription = None
+
+            if action == "status":
+                await write_message(writer, {"ok": True, "bots": manager.get_all_status()})
+
+            elif action in ("start", "stop", "restart"):
+                bot_name = msg.get("bot", "")
+                try:
+                    bot = manager.get_bot(bot_name)
+                    await getattr(bot, action)()
+                    await write_message(writer, {"ok": True})
+                except KeyError:
+                    await write_message(writer, {"ok": False, "error": f"Unknown bot: {bot_name}"})
+                except Exception as e:
+                    await write_message(writer, {"ok": False, "error": str(e)})
+
+            elif action == "logs":
+                bot_name = msg.get("bot", "")
+                n = msg.get("lines", 200)
+                try:
+                    bot = manager.get_bot(bot_name)
+                    lines = bot.get_logs(n)
+                    await write_message(writer, {"ok": True, "lines": lines})
+                except KeyError:
+                    await write_message(writer, {"ok": False, "error": f"Unknown bot: {bot_name}"})
+
+            elif action == "subscribe_logs":
+                bot_name = msg.get("bot", "")
+                try:
+                    bot = manager.get_bot(bot_name)
+                    queue = bot.subscribe()
+                    subscription = (bot_name, queue)
+                    await write_message(writer, {"ok": True, "streaming": True})
+
+                    # Stream logs until client sends a new command or disconnects
+                    while True:
+                        # Wait for either a log line or a new command
+                        read_task = asyncio.create_task(reader.readline())
+                        queue_task = asyncio.create_task(queue.get())
+
+                        done, pending = await asyncio.wait(
+                            {read_task, queue_task},
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+
+                        for task in pending:
+                            task.cancel()
+                            try:
+                                await task
+                            except (asyncio.CancelledError, Exception):
+                                pass
+
+                        if queue_task in done:
+                            line = queue_task.result()
+                            await write_message(writer, {"log": line})
+
+                        if read_task in done:
+                            raw = read_task.result()
+                            if not raw:
+                                # Client disconnected
+                                bot.unsubscribe(queue)
+                                subscription = None
+                                return
+                            # Client sent a new command — unsubscribe and process it
+                            bot.unsubscribe(queue)
+                            subscription = None
+                            # Put the message back by processing it inline
+                            try:
+                                import json
+                                new_msg = json.loads(raw.decode("utf-8"))
+                                # Re-inject: we'll handle it by breaking and letting
+                                # the outer loop pick it up. But since we already consumed
+                                # the line, we handle it directly here.
+                                # Simplest: just break and let client resend
+                            except Exception:
+                                pass
+                            break
+
+                except KeyError:
+                    await write_message(writer, {"ok": False, "error": f"Unknown bot: {bot_name}"})
+
+            else:
+                await write_message(writer, {"ok": False, "error": f"Unknown action: {action}"})
+
+    except (ConnectionError, BrokenPipeError):
+        pass
+    finally:
+        if subscription:
+            bot_name, queue = subscription
+            try:
+                manager.get_bot(bot_name).unsubscribe(queue)
+            except KeyError:
+                pass
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except Exception:
+            pass
+
+
+async def run() -> None:
+    config_path = Path(sys.argv[1]) if len(sys.argv) > 1 else CONFIG_PATH
+    if not config_path.is_absolute():
+        config_path = Path.cwd() / config_path
+
+    print(f"Loading config from {config_path}")
+    manager.load_config(config_path)
+
+    print("Starting all bots...")
+    await manager.start_all()
+
+    # Clean up stale socket
+    SOCKET_PATH.unlink(missing_ok=True)
+
+    server = await asyncio.start_unix_server(handle_client, path=str(SOCKET_PATH))
+    os.chmod(SOCKET_PATH, 0o600)
+    print(f"Daemon listening on {SOCKET_PATH}")
+
+    loop = asyncio.get_running_loop()
+    shutdown_event = asyncio.Event()
+
+    def _signal_handler() -> None:
+        print("\nShutting down...")
+        shutdown_event.set()
+
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, _signal_handler)
+
+    await shutdown_event.wait()
+
+    print("Stopping all bots...")
+    await manager.stop_all()
+    server.close()
+    await server.wait_closed()
+    SOCKET_PATH.unlink(missing_ok=True)
+    print("Daemon stopped.")
+
+
+def main() -> None:
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()