kctl-telegram 0.6.3__py3-none-any.whl

kctl_telegram/__init__.py

@@ -0,0 +1,5 @@
+"""Kodemeio Telegram CLI."""
+
+from __future__ import annotations
+
+__version__ = "0.6.3"

kctl_telegram/__main__.py

@@ -0,0 +1,7 @@
+"""Allow running as python -m kctl_telegram."""
+
+from __future__ import annotations
+
+from kctl_telegram.cli import _run
+
+_run()

kctl_telegram/cli.py

@@ -0,0 +1,131 @@
+"""Main CLI entry point for kctl-telegram."""
+
+from __future__ import annotations
+
+
+from typing import Annotated
+
+import typer
+
+from kctl_telegram import __version__
+from kctl_telegram.commands.bots import app as bots_app
+from kctl_telegram.commands.chatwoot import app as chatwoot_app
+from kctl_telegram.commands.config_cmd import app as config_app
+from kctl_telegram.commands.dashboard import app as dashboard_app
+from kctl_telegram.commands.groups import app as groups_app
+from kctl_telegram.commands.health import app as health_app
+from kctl_telegram.commands.messages import app as messages_app
+from kctl_telegram.core.callbacks import AppContext
+from kctl_telegram.core.exceptions import KctlError
+from kctl_telegram.commands.skill_cmd import app as skill_app
+from kctl_telegram.commands.doctor_cmd import app as doctor_app
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-telegram {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-telegram",
+    help="Kodemeio Telegram CLI - manage your Telegram bot gateway.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    format_: Annotated[str, typer.Option("--format", "-f", help="Output format: pretty/json/csv/yaml")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Suppress table headers (csv)")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    api_key: Annotated[str | None, typer.Option("--api-key", help="API key override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio Telegram CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        format=format_,
+        no_header=no_header,
+        profile=profile,
+        url_override=url,
+        api_key_override=api_key,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-telegram", __version__)
+
+
+# Register all command groups
+app.add_typer(config_app, name="config")
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(bots_app, name="bots")
+app.add_typer(groups_app, name="groups")
+app.add_typer(messages_app, name="messages")
+app.add_typer(chatwoot_app, name="chatwoot")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(doctor_app, name="doctor")
+add_tui_command(app, service_key="telegram", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-telegram."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-telegram", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-telegram")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-telegram", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-telegram", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        from kctl_lib import handle_cli_error
+
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_telegram/commands/__init__.py

@@ -0,0 +1 @@
+"""Command modules for kctl-telegram."""

kctl_telegram/commands/bots.py

@@ -0,0 +1,175 @@
+"""Bot management commands.
+
+List, inspect, create, update, and remove Telegram bots.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_telegram.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage Telegram bots.")
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List all registered bots."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    data = c.get("bots")
+    bots = data.get("results", []) if isinstance(data, dict) else data if isinstance(data, list) else []
+
+    if not bots:
+        out.warn("No bots found.")
+        return
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for bot in bots:
+        bot_id = str(bot.get("id", ""))
+        username = bot.get("username", "")
+        display_name = bot.get("display_name", "")
+        is_active = bot.get("is_active", False)
+        status = "[green]active[/green]" if is_active else "[red]inactive[/red]"
+
+        rows.append([bot_id, f"@{username}" if username else "-", display_name, status])
+        json_data.append(bot)
+
+    out.table(
+        "Bots",
+        [("ID", "cyan"), ("Username", ""), ("Display Name", ""), ("Status", "")],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    bot_id: Annotated[int, typer.Argument(help="Bot ID")],
+) -> None:
+    """Show bot details."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    bot = c.get(f"bots/{bot_id}")
+
+    sections: list[tuple[str, list[tuple[str, str]]]] = []
+
+    info_kvs: list[tuple[str, str]] = [
+        ("ID", str(bot.get("id", ""))),
+        ("Username", f"@{bot.get('username', '')}" if bot.get("username") else "-"),
+        ("Display Name", bot.get("display_name", "")),
+        ("Is Active", "[green]Yes[/green]" if bot.get("is_active") else "[red]No[/red]"),
+    ]
+
+    # Show token masked
+    token = bot.get("token", "")
+    if token:
+        masked = f"{token[:4]}{'*' * (len(token) - 8)}{token[-4:]}" if len(token) > 10 else "****"
+        info_kvs.append(("Token", masked))
+
+    sections.append(("Bot Info", info_kvs))
+
+    # Timestamps
+    ts_kvs: list[tuple[str, str]] = []
+    if bot.get("created_at"):
+        ts_kvs.append(("Created", bot["created_at"]))
+    if bot.get("updated_at"):
+        ts_kvs.append(("Updated", bot["updated_at"]))
+    if ts_kvs:
+        sections.append(("Timestamps", ts_kvs))
+
+    out.detail(f"Bot: {bot.get('display_name', bot.get('username', bot_id))}", sections, data_for_json=bot)
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    token: Annotated[str, typer.Option("--token", help="Telegram bot token from BotFather.")],
+    display_name: Annotated[str | None, typer.Option("--display-name", help="Friendly display name.")] = None,
+) -> None:
+    """Register a new Telegram bot."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    payload: dict = {"token": token}
+    if display_name:
+        payload["display_name"] = display_name
+
+    bot = c.post("bots", json=payload)
+
+    out.success(f"Bot created: {bot.get('display_name', bot.get('username', ''))}")
+    out.kv("ID", str(bot.get("id", "")))
+    out.kv("Username", f"@{bot.get('username', '')}" if bot.get("username") else "-")
+    out.kv("Display Name", bot.get("display_name", ""))
+    out.kv("Active", str(bot.get("is_active", True)))
+
+    if actx.output.json_mode:
+        out.raw_json(bot)
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    bot_id: Annotated[int, typer.Argument(help="Bot ID")],
+    display_name: Annotated[str | None, typer.Option("--display-name", help="New display name.")] = None,
+    is_active: Annotated[bool | None, typer.Option("--is-active/--no-active", help="Enable or disable bot.")] = None,
+) -> None:
+    """Update a bot's settings."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    payload: dict = {}
+    if display_name is not None:
+        payload["display_name"] = display_name
+    if is_active is not None:
+        payload["is_active"] = is_active
+
+    if not payload:
+        out.warn("No changes specified. Use --display-name or --is-active/--no-active.")
+        raise typer.Exit(1)
+
+    bot = c.patch(f"bots/{bot_id}", json=payload)
+
+    out.success(f"Bot {bot_id} updated")
+    out.kv("Display Name", bot.get("display_name", ""))
+    out.kv("Active", str(bot.get("is_active", "")))
+
+    if actx.output.json_mode:
+        out.raw_json(bot)
+
+
+@app.command()
+def remove(
+    ctx: typer.Context,
+    bot_id: Annotated[int, typer.Argument(help="Bot ID")],
+    force: Annotated[bool, typer.Option("--force", help="Skip confirmation")] = False,
+) -> None:
+    """Remove a bot."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    if not force:
+        # Fetch bot info for confirmation
+        try:
+            bot = c.get(f"bots/{bot_id}")
+            name = bot.get("display_name", bot.get("username", str(bot_id)))
+        except Exception:
+            name = str(bot_id)
+
+        if not typer.confirm(f"Remove bot '{name}' (ID: {bot_id})?"):
+            raise typer.Exit(0)
+
+    c.delete(f"bots/{bot_id}")
+    out.success(f"Bot {bot_id} removed")

kctl_telegram/commands/chatwoot.py

@@ -0,0 +1,105 @@
+"""Chatwoot integration commands.
+
+Manage Chatwoot inbox connections for Telegram bots.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_telegram.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage Chatwoot integrations.")
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List Chatwoot inboxes linked to Telegram bots."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    data = c.get("chatwoot/inboxes")
+    inboxes = data.get("results", []) if isinstance(data, dict) else data if isinstance(data, list) else []
+
+    if not inboxes:
+        out.warn("No Chatwoot inboxes found.")
+        return
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for inbox in inboxes:
+        inbox_id = str(inbox.get("id", ""))
+        bot_id = str(inbox.get("bot_id", ""))
+        identifier = inbox.get("inbox_identifier", "")
+        base_url = inbox.get("base_url", "")
+
+        rows.append([inbox_id, bot_id, identifier, base_url])
+        json_data.append(inbox)
+
+    out.table(
+        "Chatwoot Inboxes",
+        [("ID", "cyan"), ("Bot ID", ""), ("Inbox Identifier", ""), ("Chatwoot URL", "")],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    bot_id: Annotated[int, typer.Option("--bot-id", help="Telegram bot ID.")],
+    inbox_identifier: Annotated[str, typer.Option("--inbox-identifier", help="Chatwoot inbox identifier.")],
+    base_url: Annotated[str, typer.Option("--base-url", help="Chatwoot instance base URL.")],
+    api_token: Annotated[str, typer.Option("--api-token", help="Chatwoot API token.")],
+) -> None:
+    """Link a Chatwoot inbox to a Telegram bot."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    payload: dict = {
+        "bot_id": bot_id,
+        "inbox_identifier": inbox_identifier,
+        "base_url": base_url,
+        "api_token": api_token,
+    }
+
+    result = c.post("chatwoot/inboxes", json=payload)
+
+    out.success("Chatwoot inbox linked")
+    out.kv("ID", str(result.get("id", "")))
+    out.kv("Bot ID", str(bot_id))
+    out.kv("Inbox", inbox_identifier)
+    out.kv("Chatwoot URL", base_url)
+
+    if actx.output.json_mode:
+        out.raw_json(result)
+
+
+@app.command()
+def remove(
+    ctx: typer.Context,
+    inbox_id: Annotated[int, typer.Argument(help="Chatwoot inbox ID to remove")],
+    force: Annotated[bool, typer.Option("--force", help="Skip confirmation")] = False,
+) -> None:
+    """Remove a Chatwoot inbox integration."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    if not force:
+        try:
+            inbox = c.get(f"chatwoot/inboxes/{inbox_id}")
+            identifier = inbox.get("inbox_identifier", str(inbox_id))
+        except Exception:
+            identifier = str(inbox_id)
+
+        if not typer.confirm(f"Remove Chatwoot inbox '{identifier}' (ID: {inbox_id})?"):
+            raise typer.Exit(0)
+
+    c.delete(f"chatwoot/inboxes/{inbox_id}")
+    out.success(f"Chatwoot inbox {inbox_id} removed")