kctl-redis 0.8.4__py3-none-any.whl

kctl_redis/__init__.py

@@ -0,0 +1,3 @@
+"""Kodemeio Redis CLI."""
+
+__version__ = "0.8.4"

kctl_redis/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_redis."""
+
+from kctl_redis.cli import _run
+
+_run()

kctl_redis/cli.py

@@ -0,0 +1,154 @@
+"""Main CLI entry point for kctl-redis."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import handle_cli_error
+from kctl_lib import cli_entrypoint, register_introspection_commands
+
+from kctl_redis import __version__
+from kctl_redis.commands.backup import app as backup_app
+from kctl_redis.commands.clients import app as clients_app
+from kctl_redis.commands.config_cmd import app as config_app
+from kctl_redis.commands.dashboard import app as dashboard_app
+from kctl_redis.commands.db import app as db_app
+from kctl_redis.commands.health import app as health_app
+from kctl_redis.commands.keys import app as keys_app
+from kctl_redis.commands.maintenance import app as maintenance_app
+from kctl_redis.commands.memory import app as memory_app
+from kctl_redis.commands.performance import app as performance_app
+from kctl_redis.commands.persistence import app as persistence_app
+from kctl_redis.commands.pubsub import app as pubsub_app
+from kctl_redis.commands.query import app as query_app
+from kctl_redis.commands.replication import app as replication_app
+from kctl_redis.commands.server import app as server_app
+from kctl_redis.commands.streams import app as streams_app
+from kctl_redis.commands.skill_cmd import app as skill_app
+from kctl_redis.commands.doctor_cmd import app as doctor_app
+from kctl_redis.core.callbacks import AppContext
+from kctl_redis.core.exceptions import KctlError
+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-redis {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-redis",
+    help="Kodemeio Redis CLI - manage Redis servers via SSH tunnel.",
+    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 name")] = None,
+    host: Annotated[str | None, typer.Option("--host", "-H", help="Redis host override")] = None,
+    port: Annotated[int | None, typer.Option("--port", help="Redis port override")] = None,
+    user: Annotated[str | None, typer.Option("--user", "-U", help="Redis username override")] = None,
+    password: Annotated[str | None, typer.Option("--password", help="Redis password override")] = None,
+    db: Annotated[int | None, typer.Option("--db", help="Redis database number override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio Redis CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        host_override=host,
+        port_override=port,
+        user_override=user,
+        password_override=password,
+        db_override=db,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-redis", __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(query_app, name="query")
+app.add_typer(keys_app, name="keys")
+app.add_typer(db_app, name="db")
+app.add_typer(memory_app, name="memory")
+app.add_typer(clients_app, name="clients")
+app.add_typer(server_app, name="server")
+app.add_typer(persistence_app, name="persistence")
+app.add_typer(replication_app, name="replication")
+app.add_typer(pubsub_app, name="pubsub")
+app.add_typer(streams_app, name="streams")
+app.add_typer(performance_app, name="performance")
+app.add_typer(backup_app, name="backup")
+app.add_typer(maintenance_app, name="maintenance")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(doctor_app, name="doctor")
+add_tui_command(app, service_key="redis", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-redis."""
+    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-redis", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-redis")
+        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-redis", 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-redis", shell)
+        typer.echo(script)
+
+
+# Wrap app so KctlError subclasses surface as clean user-facing messages.
+app = cli_entrypoint(app)
+register_introspection_commands(app)
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_redis/commands/backup.py

@@ -0,0 +1,144 @@
+"""Backup commands for kctl-redis (via SSH/SCP)."""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from kctl_lib.ssh import scp_download, scp_upload, ssh_run
+from kctl_redis.core.callbacks import AppContext
+from kctl_redis.core.config import ServiceConfig, resolve_connection
+
+app = typer.Typer(help="Redis backup operations via SSH.", no_args_is_help=True)
+
+
+def _resolve_ssh_config(app_ctx: AppContext) -> ServiceConfig:
+    """Resolve connection config with all CLI overrides applied."""
+    return resolve_connection(
+        profile_name=app_ctx.profile,
+        host_override=app_ctx.host_override,
+        port_override=app_ctx.port_override,
+        user_override=app_ctx.user_override,
+        password_override=app_ctx.password_override,
+        db_override=app_ctx.db_override,
+    )
+
+
+@app.command()
+def dump(
+    ctx: typer.Context,
+    output_path: Annotated[str, typer.Option("--output", "-o", help="Local output path")] = "",
+) -> None:
+    """Trigger BGSAVE and download the RDB file."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    c = app_ctx.client
+
+    out.info("Triggering BGSAVE...")
+    c.execute("BGSAVE")
+
+    deadline = time.monotonic() + 300
+    while True:
+        persist = c.info("persistence")
+        if not persist.get("rdb_bgsave_in_progress", 0):
+            break
+        if time.monotonic() >= deadline:
+            out.error("BGSAVE timed out after 300 seconds")
+            raise typer.Exit(1)
+        time.sleep(1)
+
+    status = c.info("persistence").get("rdb_last_bgsave_status", "?")
+    if status != "ok":
+        out.error(f"BGSAVE failed: {status}")
+        raise typer.Exit(1)
+
+    if not output_path:
+        timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+        output_path = f"dump-{timestamp}.rdb"
+
+    cfg = _resolve_ssh_config(app_ctx)
+    remote_path = "/data/dump.rdb"
+
+    out.info(f"Downloading RDB from {cfg.ssh_host}...")
+    try:
+        scp_download(
+            cfg.ssh_host,
+            remote_path,
+            output_path,
+            user=cfg.ssh_user,
+            port=cfg.ssh_port,
+            ssh_key=cfg.ssh_key,
+        )
+    except Exception as e:
+        out.error(f"SCP failed: {e}")
+        raise typer.Exit(1) from e
+
+    out.success(f"Backup saved to {output_path}")
+    app_ctx.close()
+
+
+@app.command()
+def restore(
+    ctx: typer.Context,
+    file_path: Annotated[str, typer.Argument(help="Local RDB file to upload")],
+) -> None:
+    """Upload an RDB file to the server."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+
+    local = Path(file_path)
+    if not local.exists():
+        out.error(f"File not found: {file_path}")
+        raise typer.Exit(1)
+
+    cfg = _resolve_ssh_config(app_ctx)
+    remote_path = "/data/dump.rdb"
+
+    typer.confirm("This will overwrite the remote dump.rdb. Redis must be restarted to load it. Continue?", abort=True)
+
+    out.info(f"Uploading {file_path} to {cfg.ssh_host}...")
+    try:
+        scp_upload(
+            cfg.ssh_host,
+            str(local),
+            remote_path,
+            user=cfg.ssh_user,
+            port=cfg.ssh_port,
+            ssh_key=cfg.ssh_key,
+        )
+    except Exception as e:
+        out.error(f"SCP failed: {e}")
+        raise typer.Exit(1) from e
+
+    out.success(f"Uploaded {file_path}. Restart Redis to load the restored data.")
+    app_ctx.close()
+
+
+@app.command(name="list")
+def list_backups(
+    ctx: typer.Context,
+    remote_dir: Annotated[str, typer.Option(help="Remote backup directory")] = "/backups",
+) -> None:
+    """List backup files on the remote server."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+
+    cfg = _resolve_ssh_config(app_ctx)
+
+    result = ssh_run(
+        cfg.ssh_host,
+        f"ls -lhtr {remote_dir}/*.rdb 2>/dev/null || echo '(no backups found)'",
+        user=cfg.ssh_user,
+        port=cfg.ssh_port,
+        ssh_key=cfg.ssh_key,
+    )
+    if not result.ok:
+        out.error(f"SSH failed: {result.stderr}")
+        raise typer.Exit(1)
+
+    out.text(result.stdout)
+    app_ctx.close()

kctl_redis/commands/clients.py

@@ -0,0 +1,71 @@
+"""Client connection management commands for kctl-redis."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_redis.core.callbacks import AppContext
+
+app = typer.Typer(help="Redis client management.", no_args_is_help=True)
+
+
+@app.command(name="list")
+def list_clients(ctx: typer.Context) -> None:
+    """List connected clients."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    r = app_ctx.client.r
+
+    clients = r.client_list()
+    if app_ctx.json_mode:
+        out.json({"clients": clients})
+    else:
+        rows = [
+            {
+                "id": c.get("id", "?"),
+                "addr": c.get("addr", "?"),
+                "name": c.get("name", ""),
+                "age": c.get("age", "?"),
+                "idle": c.get("idle", "?"),
+                "db": c.get("db", "?"),
+                "cmd": c.get("cmd", "?"),
+            }
+            for c in clients
+        ]
+        out.table(rows, columns=["id", "addr", "name", "age", "idle", "db", "cmd"], title="Connected Clients")
+
+    app_ctx.close()
+
+
+@app.command()
+def kill(
+    ctx: typer.Context,
+    client_id: Annotated[int, typer.Argument(help="Client ID to kill")],
+) -> None:
+    """Kill a client connection by ID."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    r = app_ctx.client.r
+
+    r.client_kill_filter(_id=client_id)
+    out.success(f"Killed client {client_id}")
+    app_ctx.close()
+
+
+@app.command()
+def info(ctx: typer.Context) -> None:
+    """Show client connection info."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    c = app_ctx.client
+
+    clients_info = c.info("clients")
+    if app_ctx.json_mode:
+        out.json(clients_info)
+    else:
+        rows = [{"metric": k, "value": str(v)} for k, v in clients_info.items()]
+        out.table(rows, columns=["metric", "value"], title="Client Info")
+
+    app_ctx.close()

kctl_redis/commands/config_cmd.py

@@ -0,0 +1,242 @@
+"""Config profile management commands for kctl-redis."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_redis.core.callbacks import AppContext
+from kctl_redis.core.config import (
+    ServiceConfig,
+    get_profile_names,
+    get_service_config,
+    remove_profile,
+    resolve_active_profile_name,
+    set_default_profile,
+    set_service_config,
+)
+from kctl_redis.core.exceptions import KctlError
+
+app = typer.Typer(help="Manage kctl-redis configuration profiles.", no_args_is_help=True)
+
+
+@app.command()
+def init(
+    ctx: typer.Context,
+    profile: Annotated[str, typer.Option("--profile", "-p", help="Profile name")] = "production",
+    host: Annotated[str | None, typer.Option(help="Redis host (private IP)")] = None,
+    port: Annotated[int, typer.Option(help="Redis port")] = 6379,
+    username: Annotated[str, typer.Option(help="Redis username")] = "default",
+    password: Annotated[str | None, typer.Option(help="Redis password")] = None,
+    db: Annotated[int, typer.Option(help="Redis database number")] = 0,
+    ssh_host: Annotated[str | None, typer.Option(help="SSH jump host")] = None,
+    ssh_port: Annotated[int, typer.Option(help="SSH port")] = 22,
+    ssh_user: Annotated[str, typer.Option(help="SSH username")] = "root",
+    ssh_key: Annotated[str, typer.Option(help="SSH private key path")] = "~/.ssh/id_ed25519",
+) -> None:
+    """Initialize kctl-redis configuration."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+
+    if not host:
+        host = typer.prompt("Redis host (private IP)")
+    if not password:
+        password = typer.prompt("Redis password", hide_input=True)
+    if not ssh_host:
+        ssh_host = typer.prompt("SSH jump host (public IP)")
+
+    svc = ServiceConfig(
+        host=host,
+        port=port,
+        username=username,
+        password=password,
+        db=db,
+        ssh_host=ssh_host,
+        ssh_port=ssh_port,
+        ssh_user=ssh_user,
+        ssh_key=ssh_key,
+    )
+    set_service_config(profile, svc)
+    set_default_profile(profile)
+    out.success(f"Profile '{profile}' created and set as default.")
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    profile: Annotated[str, typer.Argument(help="Profile name")],
+    host: Annotated[str, typer.Option(help="Redis host")] = "",
+    port: Annotated[int, typer.Option(help="Redis port")] = 6379,
+    username: Annotated[str, typer.Option(help="Redis username")] = "default",
+    password: Annotated[str, typer.Option(help="Redis password")] = "",
+    db: Annotated[int, typer.Option(help="Redis database number")] = 0,
+    ssh_host: Annotated[str, typer.Option(help="SSH jump host")] = "",
+    ssh_port: Annotated[int, typer.Option(help="SSH port")] = 22,
+    ssh_user: Annotated[str, typer.Option(help="SSH username")] = "root",
+    ssh_key: Annotated[str, typer.Option(help="SSH key path")] = "~/.ssh/id_ed25519",
+) -> None:
+    """Add or update a profile."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    svc = ServiceConfig(
+        host=host,
+        port=port,
+        username=username,
+        password=password,
+        db=db,
+        ssh_host=ssh_host,
+        ssh_port=ssh_port,
+        ssh_user=ssh_user,
+        ssh_key=ssh_key,
+    )
+    set_service_config(profile, svc)
+    out.success(f"Profile '{profile}' saved.")
+
+
+@app.command()
+def use(
+    ctx: typer.Context,
+    profile: Annotated[str, typer.Argument(help="Profile to activate")],
+) -> None:
+    """Switch the default profile."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    names = get_profile_names()
+    if profile not in names:
+        out.error(f"Profile '{profile}' not found. Available: {', '.join(names)}")
+        raise typer.Exit(1)
+    set_default_profile(profile)
+    out.success(f"Default profile set to '{profile}'.")
+
+
+@app.command(name="remove")
+def remove_(
+    ctx: typer.Context,
+    profile: Annotated[str, typer.Argument(help="Profile to remove")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation")] = False,
+) -> None:
+    """Remove a profile."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    if not force:
+        typer.confirm(f"Remove profile '{profile}'?", abort=True)
+    remove_profile(profile)
+    out.success(f"Profile '{profile}' removed.")
+
+
+@app.command()
+def show(ctx: typer.Context) -> None:
+    """Show current configuration (passwords masked)."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    try:
+        pname = resolve_active_profile_name(app_ctx.profile)
+    except KctlError:
+        out.error("No profile configured. Run: kctl-redis config init")
+        raise typer.Exit(1)
+
+    svc = get_service_config(pname)
+    masked_pass = _mask(svc.password)
+    rows = [
+        {"key": "profile", "value": pname},
+        {"key": "host", "value": svc.host or "(not set)"},
+        {"key": "port", "value": str(svc.port)},
+        {"key": "username", "value": svc.username},
+        {"key": "password", "value": masked_pass},
+        {"key": "db", "value": str(svc.db)},
+        {"key": "ssh_host", "value": svc.ssh_host or "(not set)"},
+        {"key": "ssh_port", "value": str(svc.ssh_port)},
+        {"key": "ssh_user", "value": svc.ssh_user},
+        {"key": "ssh_key", "value": svc.ssh_key},
+    ]
+    out.table(rows, columns=["key", "value"], title="Redis Configuration")
+
+
+@app.command(name="set")
+def set_field(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config field name")],
+    value: Annotated[str, typer.Argument(help="Config field value")],
+) -> None:
+    """Set a configuration value."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    pname = resolve_active_profile_name(app_ctx.profile)
+    svc = get_service_config(pname)
+    valid_fields = set(ServiceConfig.model_fields.keys())
+    if key not in valid_fields:
+        out.error(f"Unknown field '{key}'. Valid: {', '.join(sorted(valid_fields))}")
+        raise typer.Exit(1)
+    field_info = ServiceConfig.model_fields[key]
+    if field_info.annotation is int:
+        setattr(svc, key, int(value))
+    else:
+        setattr(svc, key, value)
+    set_service_config(pname, svc)
+    out.success(f"Set {key} = {_mask(value) if 'pass' in key else value}")
+
+
+@app.command()
+def profiles(ctx: typer.Context) -> None:
+    """List all profiles."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    names = get_profile_names()
+    if not names:
+        out.info("No profiles configured. Run: kctl-redis config init")
+        return
+    try:
+        active = resolve_active_profile_name(app_ctx.profile)
+    except KctlError:
+        active = ""
+    rows = []
+    for name in names:
+        svc = get_service_config(name)
+        rows.append(
+            {
+                "name": name,
+                "active": "*" if name == active else "",
+                "host": svc.host or "(not set)",
+                "ssh_host": svc.ssh_host or "(not set)",
+            }
+        )
+    out.table(rows, columns=["name", "active", "host", "ssh_host"], title="Profiles")
+
+
+@app.command()
+def current(ctx: typer.Context) -> None:
+    """Show the active profile name."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    try:
+        pname = resolve_active_profile_name(app_ctx.profile)
+        out.text(pname)
+    except KctlError:
+        out.error("No profile configured.")
+        raise typer.Exit(1)
+
+
+@app.command()
+def test(ctx: typer.Context) -> None:
+    """Test Redis connection."""
+    app_ctx: AppContext = ctx.obj
+    out = app_ctx.output
+    try:
+        client = app_ctx.client
+        version = client.server_version
+        info = client.info("server")
+        out.success(f"Connected to Redis {version}")
+        out.kv("Uptime", f"{info.get('uptime_in_days', '?')} days")
+        out.kv("Role", info.get("role", "unknown"))
+        app_ctx.close()
+    except KctlError as e:
+        out.error(f"Connection failed: {e}")
+        raise typer.Exit(1)
+
+
+def _mask(value: str) -> str:
+    """Mask a password: first4****last4."""
+    if not value or len(value) <= 8:
+        return "****"
+    return f"{value[:4]}****{value[-4:]}"