telegram-bot-control 0.5.1__py3-none-any.whl

telegram_bot_control/__init__.py

@@ -0,0 +1,22 @@
+"""Embedded telemetry for aiogram. Importing this package performs no I/O."""
+
+__version__ = "0.5.1"
+
+
+def start(**kwargs):
+    """Lazily import aiogram integration, keeping the stdio reader lightweight."""
+    from .monitor import start as attach
+
+    # Keep caller location: the wrapper must not become the detected entrypoint.
+    if kwargs.get("entrypoint") is None:
+        import inspect
+
+        frame = inspect.currentframe()
+        try:
+            filename = frame.f_back.f_globals.get("__file__") if frame and frame.f_back else None
+            if not filename:
+                raise ValueError("Set entrypoint explicitly when running interactively")
+            kwargs["entrypoint"] = filename
+        finally:
+            del frame
+    return attach(**kwargs)

telegram_bot_control/__main__.py

@@ -0,0 +1,6 @@
+"""Allow launching the CLI with python -m telegram_bot_control."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

telegram_bot_control/bridge.py

@@ -0,0 +1,204 @@
+"""A child process speaking JSON lines over stdin/stdout. Never opens a socket."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .config import data_directory, load_settings, save_settings, validate_settings
+from .store import cleanup_connection, mailbox_files, read_snapshot, reader, read_logs, table_exists
+from .processes import ProcessManager
+
+MAX_LINE = 1024 * 1024
+
+
+class Bridge:
+    def __init__(self, directory: Path):
+        self.directory = directory
+        self._last_cleanup = 0.0
+        self.processes = ProcessManager(directory)
+        self.web_manager = None
+
+    def close(self):
+        if self.web_manager:
+            self.web_manager.stop()
+
+    def preview(self, settings: dict[str, Any]) -> dict[str, int]:
+        result = {"events": 0, "errors": 0, "diagnostics": 0, "logs": 0, "resources": 0}
+        for path in mailbox_files(self.directory):
+            connection = None
+            try:
+                connection = reader(path)
+                for table, key in (
+                    ("events", "statistics_days"),
+                    ("errors", "errors_days"),
+                    ("diagnostics", "diagnostics_days"),
+                    ("logs", "logs_days"),
+                    ("resources", "resources_days"),
+                ):
+                    if settings[key] is not None and table_exists(connection, table):
+                        result[table] += connection.execute(
+                            f"SELECT COUNT(*) FROM {table} WHERE ts<?",
+                            (time.time() - settings[key] * 86400,),
+                        ).fetchone()[0]
+            except (sqlite3.Error, ValueError):
+                continue
+            finally:
+                if connection:
+                    connection.close()
+        return result
+
+    def cleanup(self, settings: dict[str, Any]) -> dict[str, int]:
+        result = {"events": 0, "errors": 0, "diagnostics": 0, "logs": 0, "resources": 0}
+        for path in mailbox_files(self.directory):
+            connection = None
+            try:
+                connection = sqlite3.connect(path, timeout=0.3)
+                deleted = cleanup_connection(connection, settings)
+                for key in result:
+                    result[key] += deleted[key]
+            except sqlite3.Error:
+                # Another bot may be flushing a batch; retry during the next sweep.
+                continue
+            finally:
+                if connection:
+                    connection.close()
+        self._last_cleanup = time.monotonic()
+        return result
+
+    def call(self, method: str, params: dict[str, Any]) -> Any:
+        if method == "logs":
+            return read_logs(self.directory, params)
+        if method == "inspect_project":
+            from .projects import inspect_project, integration_preview
+
+            project = inspect_project(str(params["directory"]))
+            entrypoint = params.get("entrypoint") or next(iter(project["entrypoints"]), "")
+            if entrypoint:
+                project["integration"] = integration_preview(
+                    Path(project["directory"]), str(entrypoint), self.directory
+                )
+            return project
+        if method == "register_project":
+            from .projects import register_project
+
+            return register_project(self.directory, params)
+        if method in ("web_status", "web_start", "web_stop"):
+            from .web_manager import WebManager
+
+            if self.web_manager is None:
+                self.web_manager = WebManager(self.directory)
+            if method == "web_start":
+                return self.web_manager.start(
+                    params.get("host", "127.0.0.1"), params.get("port", 8765)
+                )
+            if method == "web_stop":
+                return self.web_manager.stop()
+            return self.web_manager.status()
+        if method == "hello":
+            return {"version": __version__, "transport": "stdio", "data_dir": str(self.directory)}
+        if method == "snapshot":
+            if time.monotonic() - self._last_cleanup >= 60:
+                self.cleanup(load_settings(self.directory))
+            snapshot = read_snapshot(self.directory, params)
+            for bot in snapshot["bots"]:
+                try:
+                    bot["control"] = self.processes.status(bot["bot_id"])
+                    control = bot["control"]
+                    if (
+                        control["run"]
+                        and control["run"]["status"]
+                        in ("starting", "preparing", "running", "backoff")
+                        and not control["verified_sessions"]
+                    ):
+                        bot["state"] = "waiting"
+                    if bot.get("integration_pending"):
+                        bot["state"] = "waiting"
+                except (sqlite3.Error, ValueError, OSError) as error:
+                    bot["control"] = {
+                        "can_start": False,
+                        "can_stop": False,
+                        "reason": str(error)[:150],
+                        "run": None,
+                    }
+            return snapshot
+        if method == "launch_profile":
+            return self.processes.profile(str(params["bot_id"]))
+        if method == "save_launch_profile":
+            return self.processes.save_profile(str(params["bot_id"]), params["profile"])
+        if method == "control_bot":
+            return self.processes.control(
+                str(params["bot_id"]), params["action"], force=params.get("force", False)
+            )
+        if method == "preview_retention":
+            return self.preview(validate_settings(params["settings"]))
+        if method == "save_settings":
+            settings = validate_settings(params["settings"])
+            current = load_settings(self.directory)
+            reducing = any(
+                settings[key] is not None and (current[key] is None or settings[key] < current[key])
+                for key in (
+                    "statistics_days",
+                    "errors_days",
+                    "diagnostics_days",
+                    "logs_days",
+                    "resources_days",
+                )
+            )
+            if reducing and params.get("confirm_cleanup") is not True:
+                raise ValueError("Reducing retention requires confirm_cleanup")
+            save_settings(self.directory, settings)
+            return {"settings": settings, "deleted": self.cleanup(settings)}
+        raise ValueError("Unknown method")
+
+
+def serve(directory: Path) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stdin.reconfigure(encoding="utf-8")
+    bridge = Bridge(directory)
+    while True:
+        line = sys.stdin.readline(MAX_LINE + 1)
+        if not line:
+            bridge.close()
+            return 0
+        request_id = None
+        try:
+            if len(line) > MAX_LINE:
+                raise ValueError("Request too large")
+            request = json.loads(line)
+            if not isinstance(request, dict):
+                raise ValueError("Expected an object")
+            request_id = request.get("id")
+            params = request.get("params", {})
+            if not isinstance(params, dict):
+                raise ValueError("Expected object params")
+            result = bridge.call(request["method"], params)
+            response = {"id": request_id, "result": result}
+        except Exception as error:
+            from .privacy import redact
+
+            response = {
+                "id": request_id,
+                "error": {"type": type(error).__name__, "message": redact(str(error))[:500]},
+            }
+        sys.stdout.write(json.dumps(response, ensure_ascii=False, allow_nan=False) + "\n")
+        sys.stdout.flush()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Bot Control stdio bridge (no listening port)")
+    parser.add_argument("--stdio", action="store_true", required=True)
+    parser.add_argument("--data-dir")
+    args = parser.parse_args(argv)
+    return serve(data_directory(args.data_dir))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

telegram_bot_control/cli.py

@@ -0,0 +1,141 @@
+"""Command-line launchers for the desktop, stdio bridge and offline aiogram bot."""
+
+import argparse
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from . import __version__
+from .config import data_directory
+
+
+def launch_desktop(directory: Path, *, force_local: bool = False) -> int:
+    root = Path(__file__).resolve().parents[2]
+    desktop = root / "desktop"
+    override = os.environ.get("BOTCONTROL_DESKTOP")
+    installed = override or shutil.which("telegram-bot-control-desktop")
+    if installed:
+        command = [installed]
+    else:
+        binary = (
+            desktop
+            / "node_modules/electron/dist"
+            / ("electron.exe" if os.name == "nt" else "electron")
+        )
+        if not binary.exists() or not (desktop / "dist/index.html").exists():
+            print(
+                "Install/build the desktop first: pnpm install --dir desktop; pnpm --dir desktop run build",
+                file=sys.stderr,
+            )
+            print(
+                "Or set BOTCONTROL_DESKTOP to the installed application executable.",
+                file=sys.stderr,
+            )
+            return 1
+        command = [str(binary), str(desktop)]
+    env = dict(
+        os.environ, BOTCONTROL_PYTHON=sys.executable, BOTCONTROL_HOME=str(directory), PYTHONUTF8="1"
+    )
+    if force_local:
+        env["BOTCONTROL_FORCE_LOCAL"] = "1"
+    flags = subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0
+    subprocess.Popen(
+        command,
+        env=env,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        creationflags=flags,
+        start_new_session=os.name != "nt",
+    )
+    print("Telegram Bot Control opened")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(
+        prog="tgbots", description="Telegram Bot Control — embedded telemetry, no local server."
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command")
+    for name, help_text in (
+        ("open", "Open the desktop application"),
+        ("status", "Read recorded bot status"),
+        ("bridge", "Serve JSON lines on stdin/stdout"),
+        ("demo", "Run an offline aiogram fixture"),
+        ("web", "Open the optional authenticated web dashboard"),
+    ):
+        child = sub.add_parser(name, help=help_text)
+        child.add_argument("--data-dir", help="Shared local directory for this owner's bots")
+        if name == "web":
+            child.add_argument("--port", type=int, default=8765)
+            child.add_argument("--host", choices=("127.0.0.1", "0.0.0.0"), default="127.0.0.1")
+        if name == "status":
+            child.add_argument("--json", action="store_true")
+        if name == "demo":
+            child.add_argument(
+                "--duration", type=float, default=0, help="Seconds; 0 runs until Ctrl+C"
+            )
+            child.add_argument("--interval", type=float, default=0.8)
+            child.add_argument("--bots", type=int, default=1)
+    args = parser.parse_args(argv)
+    if args.command is None:
+        parser.print_help()
+        return 0
+    directory = data_directory(args.data_dir)
+    if args.command == "web":
+        from .web import run
+
+        if not 1 <= args.port <= 65535:
+            parser.error("port must be between 1 and 65535")
+        return run(directory, args.host, args.port)
+    if args.command == "open":
+        return launch_desktop(directory, force_local=args.data_dir is not None)
+    if args.command == "bridge":
+        from .bridge import serve
+
+        return serve(directory)
+    if args.command == "status":
+        from .store import read_snapshot
+
+        snapshot = read_snapshot(directory, {})
+        if args.json:
+            print(json.dumps(snapshot, ensure_ascii=False))
+        else:
+            print(f"Data: {directory}")
+            for bot in snapshot["bots"]:
+                print(
+                    f"{bot['bot_id']:>12}  {bot['state']:<14}  {bot['name']}  events={bot['metrics']['events']} errors={bot['metrics']['errors']}"
+                )
+            if not snapshot["bots"]:
+                print("No connected bots. Try: tgbots demo --data-dir <directory>")
+        return 0
+    if args.command == "demo":
+        if not 1 <= args.bots <= 1000 or args.interval <= 0 or args.duration < 0:
+            parser.error("bots: 1–1000, interval > 0, duration >= 0")
+        from .testing import run_offline
+
+        async def run() -> None:
+            await asyncio.gather(
+                *(
+                    run_offline(
+                        directory,
+                        duration=args.duration,
+                        interval=args.interval,
+                        bot_id=900000001 + index,
+                    )
+                    for index in range(args.bots)
+                )
+            )
+
+        try:
+            asyncio.run(run())
+        except KeyboardInterrupt:
+            pass
+    return 0

telegram_bot_control/config.py

@@ -0,0 +1,85 @@
+"""Shared on-disk configuration. No ports, services or registration server."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+DEFAULTS: dict[str, Any] = {
+    "statistics_days": 365,
+    "errors_days": 30,
+    "diagnostics_days": 7,
+    "logs_days": 7,
+    "resources_days": 7,
+    "resource_interval_seconds": 5,
+    "heartbeat_seconds": 10,
+    "connection_timeout_seconds": 30,
+}
+
+
+def data_directory(value: str | Path | None = None) -> Path:
+    if value:
+        return Path(value).expanduser().resolve()
+    if os.environ.get("BOTCONTROL_HOME"):
+        return Path(os.environ["BOTCONTROL_HOME"]).expanduser().resolve()
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData/Local"))
+        return base / "TelegramBotControl"
+    return (
+        Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state"))
+        / "telegram-bot-control"
+    )
+
+
+def ensure_private_directory(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True, mode=0o700)
+    if os.name != "nt":
+        path.chmod(0o700)
+
+
+def validate_settings(settings: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(settings, dict) or set(settings) - set(DEFAULTS):
+        raise ValueError("Unknown settings")
+    result = DEFAULTS | settings
+    for key in (
+        "statistics_days",
+        "errors_days",
+        "diagnostics_days",
+        "logs_days",
+        "resources_days",
+    ):
+        value = result[key]
+        if value is not None and (type(value) is not int or not 1 <= value <= 36500):
+            raise ValueError(f"{key}: expected 1–36500 or null")
+    for key in ("heartbeat_seconds", "connection_timeout_seconds", "resource_interval_seconds"):
+        if type(result[key]) is not int or not 1 <= result[key] <= 86400:
+            raise ValueError(f"{key}: expected integer 1–86400")
+    if result["connection_timeout_seconds"] < result["heartbeat_seconds"] * 3:
+        raise ValueError("connection_timeout_seconds must be at least 3 × heartbeat_seconds")
+    return result
+
+
+def load_settings(directory: Path) -> dict[str, Any]:
+    path = directory / "settings.json"
+    if not path.exists():
+        return dict(DEFAULTS)
+    return validate_settings(json.loads(path.read_text(encoding="utf-8")))
+
+
+def save_settings(directory: Path, settings: dict[str, Any]) -> dict[str, Any]:
+    validated = validate_settings(settings)
+    ensure_private_directory(directory)
+    # Atomic replacement: running bots always see a complete configuration.
+    fd, temporary = tempfile.mkstemp(prefix="settings-", suffix=".tmp", dir=directory)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as stream:
+            json.dump(validated, stream, ensure_ascii=False, indent=2)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, directory / "settings.json")
+    finally:
+        Path(temporary).unlink(missing_ok=True)
+    return validated

telegram_bot_control/launch_output.py

@@ -0,0 +1,94 @@
+"""Bounded, redacted stdout/stderr capture, including failures before SDK startup."""
+
+from __future__ import annotations
+
+import codecs
+import queue
+import re
+import subprocess
+import threading
+
+from .privacy import redact
+
+MAX_LINE = 8192
+MAX_OUTPUT = 32768
+ANSI = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+
+class LaunchOutput:
+    def __init__(self, child: subprocess.Popen, secrets: list[str], phase: str):
+        self.lines: queue.Queue[str] = queue.Queue(maxsize=128)
+        self.dropped = 0
+        self.phase = phase
+        self.secrets = secrets
+        self.streams = [child.stdout, child.stderr]
+        self.threads = [
+            threading.Thread(target=self._read, args=(stream, name), daemon=True)
+            for stream, name in zip(self.streams, ("stdout", "stderr"))
+        ]
+        for thread in self.threads:
+            thread.start()
+
+    def _offer(self, text: str, source: str) -> None:
+        text = redact(ANSI.sub("", text), self.secrets).replace("\0", "")
+        try:
+            self.lines.put_nowait(f"[{self.phase} / {source}] {text}\n")
+        except queue.Full:
+            self.dropped += 1
+
+    def _read(self, stream, source: str) -> None:
+        decoder = codecs.getincrementaldecoder("utf-8")("replace")
+        pending, discarding = "", False
+        try:
+            while True:
+                block = stream.read1(4096)
+                pending += decoder.decode(block, final=not block)
+                while "\n" in pending:
+                    line, _, pending = pending.partition("\n")
+                    if not discarding:
+                        self._offer(
+                            line.rstrip("\r")
+                            if len(line) <= MAX_LINE
+                            else "[long output line omitted]",
+                            source,
+                        )
+                    discarding = False
+                if len(pending) > MAX_LINE:
+                    if not discarding:
+                        self._offer("[long output line omitted]", source)
+                    pending, discarding = "", True
+                if not block:
+                    if pending and not discarding:
+                        self._offer(pending.rstrip("\r"), source)
+                    return
+        except (OSError, ValueError):
+            return
+        finally:
+            stream.close()
+
+    def drain(self, connection, launch_id: str) -> None:
+        batch = []
+        for _ in range(128):
+            try:
+                batch.append(self.lines.get_nowait())
+            except queue.Empty:
+                break
+        if self.dropped:
+            batch.append(f"[capture] {self.dropped} output lines omitted: queue full\n")
+            self.dropped = 0
+        if batch:
+            with connection:
+                connection.execute(
+                    "INSERT INTO run_output(id,output) VALUES (?,?) ON CONFLICT(id) "
+                    "DO UPDATE SET output=substr(run_output.output || excluded.output,-?)",
+                    (launch_id, "".join(batch)[-MAX_OUTPUT:], MAX_OUTPUT),
+                )
+
+    def finish(self, connection, launch_id: str) -> None:
+        # A background descendant may still hold a pipe; never wait indefinitely.
+        for thread in self.threads:
+            thread.join(timeout=0.3)
+        for _ in range(3):
+            self.drain(connection, launch_id)
+            if self.lines.empty():
+                break