bot-master 0.1.0__py3-none-any.whl

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/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/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()

bot_master/process_manager.py

@@ -0,0 +1,217 @@
+import asyncio
+import logging
+import os
+import signal
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+import yaml
+
+LOG_DIR = Path(os.environ.get("BOT_MASTER_LOG_DIR", "logs"))
+
+
+def _setup_file_logger(name: str, log_dir: Path) -> logging.Logger:
+    log_dir.mkdir(parents=True, exist_ok=True)
+    logger = logging.getLogger(f"bot.{name}")
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+    if not logger.handlers:
+        handler = RotatingFileHandler(
+            log_dir / f"{name}.log",
+            maxBytes=10 * 1024 * 1024,  # 10 MB
+            backupCount=5,
+            encoding="utf-8",
+        )
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logger.addHandler(handler)
+    return logger
+
+
+@dataclass
+class BotConfig:
+    name: str
+    directory: str
+    command: str
+
+
+class BotProcess:
+    def __init__(self, config: BotConfig, log_dir: Path) -> None:
+        self.config = config
+        self.process: asyncio.subprocess.Process | None = None
+        self.status: str = "stopped"  # stopped, running, backoff
+        self.log_buffer: deque[str] = deque(maxlen=5000)
+        self.subscribers: set[asyncio.Queue] = set()
+        self.restart_count: int = 0
+        self._should_run: bool = False
+        self._tasks: list[asyncio.Task] = []
+        self._start_time: float = 0
+        self._lock = asyncio.Lock()
+        self._file_logger = _setup_file_logger(config.name, log_dir)
+
+    async def start(self) -> None:
+        async with self._lock:
+            if self.status == "running":
+                return
+            self._should_run = True
+            self.restart_count = 0
+            await self._spawn()
+
+    async def _spawn(self) -> None:
+        env = {**os.environ, "PYTHONUNBUFFERED": "1"}
+        try:
+            self.process = await asyncio.create_subprocess_shell(
+                self.config.command,
+                cwd=self.config.directory,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                env=env,
+                start_new_session=True,
+            )
+        except Exception as e:
+            self._log(f"[bot-master] Failed to start: {e}")
+            self.status = "backoff"
+            if self._should_run:
+                asyncio.create_task(self._auto_restart(-1))
+            return
+
+        self.status = "running"
+        self._start_time = time.monotonic()
+        self._log(f"[bot-master] Started (pid={self.process.pid})")
+
+        reader_task = asyncio.create_task(self._read_output())
+        waiter_task = asyncio.create_task(self._wait())
+        self._tasks = [reader_task, waiter_task]
+
+    async def _read_output(self) -> None:
+        assert self.process and self.process.stdout
+        try:
+            async for raw_line in self.process.stdout:
+                line = raw_line.decode("utf-8", errors="replace").rstrip("\n\r")
+                self._log(line)
+        except Exception:
+            pass
+
+    async def _wait(self) -> None:
+        assert self.process
+        code = await self.process.wait()
+        ran_for = time.monotonic() - self._start_time
+
+        if self._should_run:
+            self._log(f"[bot-master] Exited with code {code}")
+            if ran_for > 30:
+                self.restart_count = 0
+            self.status = "backoff"
+            asyncio.create_task(self._auto_restart(code))
+        else:
+            self.status = "stopped"
+            self._log(f"[bot-master] Stopped (exit code {code})")
+
+    async def _auto_restart(self, code: int) -> None:
+        delay = min(2 ** self.restart_count, 60)
+        self.restart_count += 1
+        self._log(f"[bot-master] Restarting in {delay}s (attempt {self.restart_count})...")
+        await asyncio.sleep(delay)
+        if self._should_run:
+            await self._spawn()
+
+    async def stop(self) -> None:
+        async with self._lock:
+            self._should_run = False
+            if self.process and self.process.returncode is None:
+                self._log("[bot-master] Stopping...")
+                try:
+                    os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
+                except (ProcessLookupError, OSError):
+                    pass
+                try:
+                    await asyncio.wait_for(self.process.wait(), timeout=5)
+                except asyncio.TimeoutError:
+                    self._log("[bot-master] Force killing...")
+                    try:
+                        os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
+                    except (ProcessLookupError, OSError):
+                        pass
+                    try:
+                        await asyncio.wait_for(self.process.wait(), timeout=2)
+                    except asyncio.TimeoutError:
+                        pass
+
+            for task in self._tasks:
+                task.cancel()
+            self._tasks.clear()
+            self.process = None
+            self.status = "stopped"
+
+    async def restart(self) -> None:
+        await self.stop()
+        await self.start()
+
+    def subscribe(self) -> asyncio.Queue:
+        queue: asyncio.Queue = asyncio.Queue(maxsize=1000)
+        self.subscribers.add(queue)
+        return queue
+
+    def unsubscribe(self, queue: asyncio.Queue) -> None:
+        self.subscribers.discard(queue)
+
+    def get_status(self) -> dict:
+        pid = self.process.pid if self.process and self.process.returncode is None else None
+        uptime = None
+        if self.status == "running" and self._start_time:
+            uptime = int(time.monotonic() - self._start_time)
+        return {
+            "name": self.config.name,
+            "status": self.status,
+            "pid": pid,
+            "restart_count": self.restart_count,
+            "uptime": uptime,
+        }
+
+    def get_logs(self, n: int = 200) -> list[str]:
+        lines = list(self.log_buffer)
+        return lines[-n:]
+
+    def _log(self, line: str) -> None:
+        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        entry = f"{ts} {line}"
+        self.log_buffer.append(entry)
+        self._file_logger.info(entry)
+        for q in list(self.subscribers):
+            try:
+                q.put_nowait(entry)
+            except asyncio.QueueFull:
+                pass
+
+
+class ProcessManager:
+    def __init__(self, log_dir: Path | None = None) -> None:
+        self.bots: dict[str, BotProcess] = {}
+        self.log_dir = log_dir or LOG_DIR
+
+    def load_config(self, path: Path) -> None:
+        with open(path) as f:
+            data = yaml.safe_load(f)
+
+        for name, info in data["bots"].items():
+            config = BotConfig(
+                name=name,
+                directory=info["directory"],
+                command=info["command"],
+            )
+            self.bots[name] = BotProcess(config, self.log_dir)
+
+    async def start_all(self) -> None:
+        await asyncio.gather(*(bot.start() for bot in self.bots.values()))
+
+    async def stop_all(self) -> None:
+        await asyncio.gather(*(bot.stop() for bot in self.bots.values()))
+
+    def get_bot(self, name: str) -> BotProcess:
+        return self.bots[name]
+
+    def get_all_status(self) -> list[dict]:
+        return [bot.get_status() for bot in self.bots.values()]

bot_master/protocol.py

@@ -0,0 +1,23 @@
+import asyncio
+import json
+import os
+from pathlib import Path
+
+SOCKET_PATH = Path(os.environ.get("BOT_MASTER_SOCK", "/tmp/bot-master.sock"))
+CONFIG_PATH = Path(os.environ.get("BOT_MASTER_CONFIG", "bots.yaml"))
+
+
+async def read_message(reader: asyncio.StreamReader) -> dict | None:
+    try:
+        line = await reader.readline()
+        if not line:
+            return None
+        return json.loads(line.decode("utf-8"))
+    except (json.JSONDecodeError, ConnectionError):
+        return None
+
+
+async def write_message(writer: asyncio.StreamWriter, msg: dict) -> None:
+    data = json.dumps(msg) + "\n"
+    writer.write(data.encode("utf-8"))
+    await writer.drain()

bot_master-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+bot_master/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bot_master/app.py,sha256=B0DFmQlUkudDK26T1ls2yTmC7LbRs1QDJ9pCCKmkAEA,9797
+bot_master/app.tcss,sha256=D8Eq3TzUq0Hz2rU_0Nz05ywbgZq2Lh5kqb0UJWk0SrM,607
+bot_master/daemon.py,sha256=M9iVFihPkaJR_GTr-JTBEpiKLHLoydoJPBgaLBktAdk,6330
+bot_master/process_manager.py,sha256=CQdIKBli-zI6Cb3pp_vOY-ecL28lNxozEv3HFIua4T8,7375
+bot_master/protocol.py,sha256=163sy_Eul95Lx2oEEmL6vZLcgJ6feUo61A4etU5r4Cc,668
+bot_master-0.1.0.dist-info/METADATA,sha256=JIrMWhUZFeQWGXpitrj3l0O3cykf8kE1dJkOjuQgQaw,133
+bot_master-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+bot_master-0.1.0.dist-info/entry_points.txt,sha256=83fr9qU5B5jsjrEiisvGmaB6D28gqlYNfUQCSwr1Ugg,94
+bot_master-0.1.0.dist-info/RECORD,,

bot_master-0.1.0.dist-info/WHEEL

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

bot_master-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bot-master = bot_master.app:main
+bot-master-daemon = bot_master.daemon:main