kctl-rustdesk 0.6.3__py3-none-any.whl

kctl_rustdesk/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-rustdesk: Kodemeio RustDesk server management CLI."""
+
+__version__ = "0.6.3"

kctl_rustdesk/__main__.py

@@ -0,0 +1,3 @@
+from kctl_rustdesk.cli import _run
+
+_run()

kctl_rustdesk/cli.py

@@ -0,0 +1,133 @@
+"""kctl-rustdesk CLI entry point."""
+
+from __future__ import annotations
+
+
+from typing import Annotated
+
+import typer
+
+from kctl_lib import handle_cli_error
+from kctl_lib.exceptions import KctlError
+
+from kctl_rustdesk import __version__
+from kctl_rustdesk.commands.audit import app as audit_app
+from kctl_rustdesk.commands.backup import app as backup_app
+from kctl_rustdesk.commands.config_cmd import app as config_app
+from kctl_rustdesk.commands.dashboard import app as dashboard_app
+from kctl_rustdesk.commands.health import app as health_app
+from kctl_rustdesk.commands.maintenance import app as maintenance_app
+from kctl_rustdesk.commands.peers import app as peers_app
+from kctl_rustdesk.commands.setup import app as setup_app
+from kctl_rustdesk.commands.users import app as users_app
+from kctl_rustdesk.core.plugins import discover_and_load_plugins
+from kctl_rustdesk.commands.skill_cmd import app as skill_app
+from kctl_rustdesk.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-rustdesk {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-rustdesk",
+    help="Kodemeio RustDesk CLI — manage RustDesk server infrastructure.",
+    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,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile")] = None,
+    format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit column headers")] = False,
+    host: Annotated[str | None, typer.Option("--host", help="Server host override")] = None,
+    version: Annotated[bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True)] = False,
+) -> None:
+    """Manage RustDesk server infrastructure."""
+    from kctl_rustdesk.core.callbacks import AppContext
+
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        format=format,
+        no_header=no_header,
+        host_override=host,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-rustdesk", __version__)
+
+
+app.add_typer(config_app, name="config")
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(peers_app, name="peers")
+app.add_typer(users_app, name="users")
+app.add_typer(audit_app, name="audit")
+app.add_typer(backup_app, name="backup")
+app.add_typer(setup_app, name="setup")
+app.add_typer(maintenance_app, name="maintenance")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(doctor_app, name="doctor")
+
+discover_and_load_plugins(app)
+add_tui_command(app, service_key="rustdesk", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-rustdesk."""
+    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-rustdesk", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-rustdesk")
+        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-rustdesk", 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-rustdesk", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_rustdesk/commands/audit.py

@@ -0,0 +1,143 @@
+"""Audit log and connection history commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_rustdesk.core.callbacks import AppContext
+
+app = typer.Typer(help="Audit logs and connection history.")
+
+
+@app.command()
+def connections(
+    ctx: typer.Context,
+    today: Annotated[bool, typer.Option("--today", help="Only today")] = False,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max rows")] = 50,
+) -> None:
+    """Show connection history."""
+    c: AppContext = ctx.obj
+    ex = c.executor
+
+    where = "WHERE date(created_at) = date('now')" if today else ""
+    sql = f"SELECT peer_id, ip, created_at FROM conn_log {where} ORDER BY created_at DESC LIMIT {limit};"
+
+    rows_data = ex.query_db(sql)
+    rows = [[r.get("peer_id", ""), r.get("ip", ""), r.get("created_at", "")] for r in rows_data]
+
+    title = "Connections (today)" if today else f"Connections (last {limit})"
+    c.output.table(
+        title,
+        [("Peer ID", "cyan"), ("IP", ""), ("Time", "dim")],
+        rows,
+        data_for_json=rows_data,
+    )
+
+
+@app.command()
+def logins(
+    ctx: typer.Context,
+    failed: Annotated[bool, typer.Option("--failed", help="Only failed logins")] = False,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max rows")] = 50,
+) -> None:
+    """Show login history."""
+    c: AppContext = ctx.obj
+    ex = c.executor
+
+    where = "WHERE type != 0" if failed else ""
+    sql = f"SELECT user_id, ip, type, created_at FROM login_log {where} ORDER BY created_at DESC LIMIT {limit};"
+
+    rows_data = ex.query_db(sql)
+    rows = [
+        [
+            r.get("user_id", ""),
+            r.get("ip", ""),
+            "failed" if r.get("type", "0") != "0" else "ok",
+            r.get("created_at", ""),
+        ]
+        for r in rows_data
+    ]
+
+    title = "Failed Logins" if failed else f"Logins (last {limit})"
+    c.output.table(
+        title,
+        [("User", "cyan"), ("IP", ""), ("Status", ""), ("Time", "dim")],
+        rows,
+        data_for_json=rows_data,
+    )
+
+
+@app.command()
+def stats(ctx: typer.Context) -> None:
+    """Show connection statistics."""
+    c: AppContext = ctx.obj
+    ex = c.executor
+
+    total_conns = ex.query_db_scalar("SELECT count(*) FROM conn_log;")
+    today_conns = ex.query_db_scalar("SELECT count(*) FROM conn_log WHERE date(created_at) = date('now');")
+    unique_peers = ex.query_db_scalar("SELECT count(DISTINCT peer_id) FROM conn_log;")
+    unique_ips = ex.query_db_scalar("SELECT count(DISTINCT ip) FROM conn_log;")
+    total_logins = ex.query_db_scalar("SELECT count(*) FROM login_log;")
+    failed_logins = ex.query_db_scalar("SELECT count(*) FROM login_log WHERE type != 0;")
+
+    top_peers = ex.query_db("SELECT peer_id, count(*) as cnt FROM conn_log GROUP BY peer_id ORDER BY cnt DESC LIMIT 5;")
+
+    sections = [
+        (
+            "Connection Stats",
+            [
+                ("Total connections", total_conns),
+                ("Today", today_conns),
+                ("Unique peers", unique_peers),
+                ("Unique IPs", unique_ips),
+            ],
+        ),
+        (
+            "Login Stats",
+            [
+                ("Total logins", total_logins),
+                ("Failed logins", failed_logins),
+            ],
+        ),
+        ("Top Peers", [(p.get("peer_id", ""), f"{p.get('cnt', 0)} connections") for p in top_peers]),
+    ]
+
+    c.output.detail(
+        "Audit Statistics",
+        sections,
+        data_for_json={
+            "connections": {
+                "total": int(total_conns),
+                "today": int(today_conns),
+                "unique_peers": int(unique_peers),
+                "unique_ips": int(unique_ips),
+            },
+            "logins": {"total": int(total_logins), "failed": int(failed_logins)},
+            "top_peers": top_peers,
+        },
+    )
+
+
+@app.command()
+def active(ctx: typer.Context) -> None:
+    """Show currently active sessions."""
+    c: AppContext = ctx.obj
+    ex = c.executor
+
+    sql = (
+        "SELECT peer_id, ip, created_at FROM conn_log "
+        "WHERE created_at > datetime('now', '-5 minutes') "
+        "ORDER BY created_at DESC;"
+    )
+
+    rows_data = ex.query_db(sql)
+    rows = [[r.get("peer_id", ""), r.get("ip", ""), r.get("created_at", "")] for r in rows_data]
+
+    c.output.table(
+        "Active Sessions (last 5m)",
+        [("Peer ID", "cyan"), ("IP", ""), ("Connected", "dim")],
+        rows,
+        data_for_json=rows_data,
+    )

kctl_rustdesk/commands/backup.py

@@ -0,0 +1,151 @@
+"""Backup and restore commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_rustdesk.core.callbacks import AppContext
+
+app = typer.Typer(help="Backup and restore RustDesk server data.")
+
+BACKUP_DIR = "/opt/kodemeio-rustdesk/backups"
+DATA_DIR = "/root"
+
+
+@app.command()
+def create(ctx: typer.Context) -> None:
+    """Create a backup of keys and database."""
+    c: AppContext = ctx.obj
+    out = c.output
+    ex = c.executor
+
+    out.info("Creating backup...")
+    ex.shell(["mkdir", "-p", BACKUP_DIR])
+
+    timestamp = ex.shell(["date", "+%Y%m%d-%H%M%S"])
+    backup_name = f"rustdesk-backup-{timestamp}.tar.gz"
+    backup_path = f"{BACKUP_DIR}/{backup_name}"
+
+    ex.exec_hbbs(
+        [
+            "tar",
+            "czf",
+            f"/tmp/{backup_name}",
+            "-C",
+            DATA_DIR,
+            "id_ed25519",
+            "id_ed25519.pub",
+            "db_v2.sqlite3",
+        ]
+    )
+
+    container_name = f"{ex.config.project_name}-hbbs-1"
+    ex.shell(["docker", "cp", f"{container_name}:/tmp/{backup_name}", backup_path])
+    ex.exec_hbbs(["rm", "-f", f"/tmp/{backup_name}"], check=False)
+
+    out.success(f"Backup created: {backup_path}")
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List available backups."""
+    c: AppContext = ctx.obj
+    ex = c.executor
+
+    output = ex.shell(
+        ["find", BACKUP_DIR, "-name", "rustdesk-backup-*.tar.gz", "-printf", r"%f\t%s\t%T+\n"],
+        check=False,
+    )
+
+    if not output.strip():
+        c.output.info("No backups found.")
+        return
+
+    rows: list[list[str]] = []
+    for line in output.strip().splitlines():
+        parts = line.split("\t")
+        if len(parts) >= 3:
+            name = parts[0]
+            size_bytes = int(parts[1]) if parts[1].isdigit() else 0
+            if size_bytes < 1048576:
+                size = f"{size_bytes / 1024:.1f} KB"
+            else:
+                size = f"{size_bytes / 1048576:.1f} MB"
+            date = parts[2][:19].replace("T", " ")
+            rows.append([name, size, date])
+
+    c.output.table(
+        "Backups",
+        [("File", "cyan"), ("Size", ""), ("Date", "dim")],
+        rows,
+    )
+
+
+@app.command()
+def restore(
+    ctx: typer.Context,
+    backup_file: Annotated[str, typer.Argument(help="Backup filename or full path")],
+) -> None:
+    """Restore from a backup file."""
+    c: AppContext = ctx.obj
+    out = c.output
+    ex = c.executor
+
+    if "/" not in backup_file:
+        backup_file = f"{BACKUP_DIR}/{backup_file}"
+
+    if not typer.confirm(f"Restore from {backup_file}? This will overwrite current data."):
+        out.info("Restore cancelled.")
+        raise typer.Exit()
+
+    out.info(f"Restoring from {backup_file}...")
+
+    container_name = f"{ex.config.project_name}-hbbs-1"
+    ex.shell(["docker", "cp", backup_file, f"{container_name}:/tmp/restore.tar.gz"])
+    ex.exec_hbbs(["tar", "xzf", "/tmp/restore.tar.gz", "-C", DATA_DIR])
+    ex.exec_hbbs(["rm", "-f", "/tmp/restore.tar.gz"])
+
+    out.info("Restarting services...")
+    ex.shell([*ex._dc_cmd(), "restart"])
+
+    out.success("Restore complete. Services restarted.")
+
+
+@app.command()
+def clean(
+    ctx: typer.Context,
+    days: Annotated[int, typer.Option("--days", "-d", help="Delete backups older than N days")] = 30,
+) -> None:
+    """Remove old backups."""
+    c: AppContext = ctx.obj
+    out = c.output
+    ex = c.executor
+
+    old_files = ex.shell(
+        ["find", BACKUP_DIR, "-name", "rustdesk-backup-*.tar.gz", "-mtime", f"+{days}"],
+        check=False,
+    )
+
+    if not old_files.strip():
+        out.info(f"No backups older than {days} days.")
+        return
+
+    file_count = len(old_files.strip().splitlines())
+    if not typer.confirm(f"Delete {file_count} backup(s) older than {days} days?"):
+        out.info("Cleanup cancelled.")
+        raise typer.Exit()
+
+    ex.shell(
+        [
+            "find",
+            BACKUP_DIR,
+            "-name",
+            "rustdesk-backup-*.tar.gz",
+            "-mtime",
+            f"+{days}",
+            "-delete",
+        ]
+    )
+    out.success(f"Deleted {file_count} old backup(s).")

kctl_rustdesk/commands/config_cmd.py

@@ -0,0 +1,173 @@
+"""Configuration management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_lib.config import (
+    CONFIG_FILE,
+    get_default_profile,
+    get_profile_names,
+    set_default_profile,
+)
+
+from kctl_rustdesk.core.callbacks import AppContext
+from kctl_rustdesk.core.config import (
+    SERVICE_KEY,
+    ServiceConfig,
+    get_rustdesk_config,
+    resolve_active_profile,
+    set_rustdesk_config,
+)
+
+app = typer.Typer(help="Manage CLI configuration and profiles.")
+
+
+@app.command()
+def init(
+    ctx: typer.Context,
+    host: Annotated[str | None, typer.Option("--host", help="Server hostname")] = None,
+    ssh_user: Annotated[str | None, typer.Option("--ssh-user", help="SSH username")] = None,
+    compose_file: Annotated[str | None, typer.Option("--compose-file")] = None,
+    env_file: Annotated[str | None, typer.Option("--env-file")] = None,
+    project_name: Annotated[str | None, typer.Option("--project-name")] = None,
+    domain: Annotated[str | None, typer.Option("--domain")] = None,
+    name: Annotated[str | None, typer.Option("--name", "-n", help="Profile name")] = None,
+) -> None:
+    """Initialize CLI configuration with a new profile."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    profile_name = name or typer.prompt("Profile name", default="production")
+    h = host or typer.prompt("Server host", default="dokploy.kodeme.io")
+    u = ssh_user or typer.prompt("SSH user", default="root")
+    cf = compose_file or typer.prompt("Compose file path", default="/opt/kodemeio-rustdesk/docker-compose.prod.yml")
+    ef = env_file or typer.prompt("Env file path", default="/opt/kodemeio-rustdesk/.env.prod")
+    pn = project_name or typer.prompt("Compose project name", default="kodemeio-rustdesk")
+    d = domain or typer.prompt("Domain", default="rustdesk.kodeme.io")
+
+    svc = ServiceConfig(
+        host=h,
+        ssh_user=u,
+        compose_file=cf,
+        env_file=ef,
+        project_name=pn,
+        domain=d,
+    )
+    set_rustdesk_config(profile_name, svc)
+
+    if len(get_profile_names()) <= 1:
+        set_default_profile(profile_name)
+
+    out.success(f"Profile '{profile_name}' saved to {CONFIG_FILE}")
+
+
+@app.command()
+def show(ctx: typer.Context) -> None:
+    """Show current configuration."""
+    c: AppContext = ctx.obj
+    out = c.output
+    default = get_default_profile()
+    active = resolve_active_profile(c.profile)
+
+    sections: list[tuple[str, list[tuple[str, str]]]] = [
+        (
+            "General",
+            [
+                ("Config file", str(CONFIG_FILE)),
+                ("Default profile", default),
+                ("Active profile", active),
+                ("Service key", SERVICE_KEY),
+            ],
+        ),
+    ]
+
+    for pname in get_profile_names():
+        marker = " (default)" if pname == default else ""
+        svc = get_rustdesk_config(pname)
+        sections.append(
+            (
+                f"Profile: {pname}{marker}",
+                [
+                    ("Host", svc.host),
+                    ("SSH user", svc.ssh_user),
+                    ("Compose file", svc.compose_file),
+                    ("Env file", svc.env_file),
+                    ("Project name", svc.project_name),
+                    ("Domain", svc.domain),
+                ],
+            )
+        )
+
+    out.detail(
+        "RustDesk Configuration",
+        sections,
+        data_for_json={
+            "config_file": str(CONFIG_FILE),
+            "default_profile": default,
+            "active_profile": active,
+            "profiles": {pname: get_rustdesk_config(pname).model_dump() for pname in get_profile_names()},
+        },
+    )
+
+
+@app.command()
+def profiles(ctx: typer.Context) -> None:
+    """List all profiles."""
+    c: AppContext = ctx.obj
+    default = get_default_profile()
+    rows: list[list[str]] = []
+    for pname in get_profile_names():
+        svc = get_rustdesk_config(pname)
+        is_default = "yes" if pname == default else ""
+        rows.append([pname, svc.host, svc.domain, is_default])
+
+    c.output.table(
+        "Profiles",
+        [("Name", "cyan"), ("Host", ""), ("Domain", ""), ("Default", "green")],
+        rows,
+    )
+
+
+@app.command()
+def use(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name to set as default")],
+) -> None:
+    """Set the default profile."""
+    c: AppContext = ctx.obj
+    if name not in get_profile_names():
+        c.output.error(f"Profile '{name}' not found")
+        raise typer.Exit(1)
+    set_default_profile(name)
+    c.output.success(f"Default profile set to '{name}'")
+
+
+@app.command()
+def test(ctx: typer.Context) -> None:
+    """Test connection to the RustDesk server."""
+    c: AppContext = ctx.obj
+    out = c.output
+    ex = c.executor
+
+    out.info(f"Testing connection to {ex.config.host}...")
+
+    try:
+        version = ex.get_compose_version()
+        out.success(f"Docker Compose: {version}")
+    except Exception as e:
+        out.error(f"Cannot reach server: {e}")
+        raise typer.Exit(1)
+
+    hbbs_ok = ex.container_running("hbbs")
+    hbbr_ok = ex.container_running("hbbr")
+    out.success(f"hbbs container: {'running' if hbbs_ok else 'NOT running'}")
+    out.success(f"hbbr container: {'running' if hbbr_ok else 'NOT running'}")
+
+    try:
+        count = ex.query_db_scalar("SELECT count(*) FROM peer;")
+        out.success(f"Database accessible: {count} peers")
+    except Exception as e:
+        out.warn(f"Database check failed: {e}")