kctl-glitchtip 0.2.0__py3-none-any.whl

kctl_glitchtip/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

kctl_glitchtip/__main__.py

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

kctl_glitchtip/cli.py

@@ -0,0 +1,136 @@
+"""Main CLI entry point for kctl-glitchtip."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+from kctl_lib.self_update import notify_if_outdated
+
+from kctl_glitchtip import __version__
+from kctl_glitchtip.commands.alerts import app as alerts_app
+from kctl_glitchtip.commands.config_cmd import app as config_app
+from kctl_glitchtip.commands.doctor_cmd import app as doctor_app
+from kctl_glitchtip.commands.events import app as events_app
+from kctl_glitchtip.commands.health import app as health_app
+from kctl_glitchtip.commands.issues import app as issues_app
+from kctl_glitchtip.commands.orgs import app as orgs_app
+from kctl_glitchtip.commands.projects import app as projects_app
+from kctl_glitchtip.commands.skill_cmd import app as skill_app
+from kctl_glitchtip.commands.teams import app as teams_app
+from kctl_glitchtip.commands.uptime import app as uptime_app
+from kctl_glitchtip.commands.users import app as users_app
+from kctl_glitchtip.core.callbacks import AppContext
+from kctl_glitchtip.core.plugins import discover_and_load_plugins
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-glitchtip {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-glitchtip",
+    help="Kodemeio GlitchTip CLI - manage your GlitchTip error tracking platform.",
+    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,
+    format: Annotated[str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit header row in CSV output")] = False,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    token: Annotated[str | None, typer.Option("--token", help="API token override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio GlitchTip CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        format=format,
+        no_header=no_header,
+        url_override=url,
+        token_override=token,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-glitchtip", __version__)
+
+
+# Register all command groups
+app.add_typer(projects_app, name="projects")
+app.add_typer(issues_app, name="issues")
+app.add_typer(teams_app, name="teams")
+app.add_typer(orgs_app, name="orgs")
+app.add_typer(events_app, name="events")
+app.add_typer(users_app, name="users")
+app.add_typer(health_app, name="health")
+app.add_typer(alerts_app, name="alerts")
+app.add_typer(config_app, name="config")
+app.add_typer(uptime_app, name="uptime")
+app.add_typer(doctor_app, name="doctor")
+app.add_typer(skill_app, name="skill", hidden=True)
+
+# Load third-party plugins via entry points
+discover_and_load_plugins(app)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-glitchtip."""
+    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-glitchtip", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-glitchtip")
+        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-glitchtip", 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-glitchtip", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_glitchtip/commands/alerts.py

@@ -0,0 +1,110 @@
+"""Alert and notification commands."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Annotated
+
+import httpx
+import typer
+
+from kctl_glitchtip.core.callbacks import AppContext
+
+app = typer.Typer(help="Manage alerts and notifications.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    org_slug: Annotated[str, typer.Option("--org", help="Organization slug")],
+    project_slug: Annotated[str, typer.Option("--project", help="Project slug")],
+) -> None:
+    """List project alerts."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    alerts = c.get_list(f"projects/{org_slug}/{project_slug}/alerts/")
+
+    rows: list[list[str]] = []
+    for a in alerts:
+        alert_id = str(a.get("id", ""))
+        name = a.get("name", "")
+        alert_type = a.get("alertType", a.get("type", ""))
+        quantity = str(a.get("quantity", ""))
+        timespan = str(a.get("timespanMinutes", a.get("timespan_minutes", "")))
+        rows.append([alert_id, name, alert_type, quantity, f"{timespan}m" if timespan else "-"])
+
+    out.table(
+        f"Alerts — {org_slug}/{project_slug}",
+        [("ID", "cyan"), ("Name", ""), ("Type", ""), ("Threshold", ""), ("Window", "dim")],
+        rows,
+        data_for_json=alerts,
+    )
+
+
+@app.command("test-alert")
+def test_alert(
+    ctx: typer.Context,
+    org_slug: Annotated[str, typer.Option("--org", help="Organization slug")],
+    project_slug: Annotated[str, typer.Option("--project", help="Project slug")],
+    alert_id: Annotated[int, typer.Argument(help="Alert ID to test")],
+) -> None:
+    """Test a project alert."""
+    actx: AppContext = ctx.obj
+    c, out = actx.client, actx.output
+
+    result = c.post(f"projects/{org_slug}/{project_slug}/alerts/{alert_id}/test/")
+    out.success(f"Test alert {alert_id} sent")
+    if out.json_mode:
+        out.raw_json(result)
+
+
+@app.command("test-webhook")
+def test_webhook(
+    ctx: typer.Context,
+    url: Annotated[str, typer.Argument(help="Webhook URL to test")],
+) -> None:
+    """Send test alert to a webhook URL."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    payload = {
+        "text": "GlitchTip test alert from kctl-glitchtip",
+        "alias": "kctl-glitchtip-test",
+    }
+
+    try:
+        resp = httpx.post(url, json=payload, timeout=10)
+        if resp.status_code < 300:
+            out.success(f"Webhook responded: {resp.status_code}")
+        else:
+            out.error(f"Webhook failed: {resp.status_code} — {resp.text[:200]}")
+    except Exception as e:
+        out.error(f"Webhook error: {e}")
+
+
+@app.command("test-email")
+def test_email(
+    ctx: typer.Context,
+    to: Annotated[str | None, typer.Option("--to", help="Recipient email (default: admin)")] = None,
+) -> None:
+    """Send test email via Django (requires Docker access)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = ["docker", "exec", "kodemeio-glitchtip", "./manage.py", "sendtestemail"]
+    if to:
+        cmd.append(to)
+    else:
+        cmd.append("--admin")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        if result.returncode == 0:
+            out.success("Test email sent")
+        else:
+            out.error(f"Failed: {result.stderr.strip()}")
+    except FileNotFoundError:
+        out.error("Docker not found")
+    except subprocess.TimeoutExpired:
+        out.error("Email send timed out")