bitsreef-cli 0.1.0__py3-none-any.whl

bitsreef_cli/commands/webhooks.py

@@ -0,0 +1,123 @@
+"""Webhook commands: list, add, update, remove (project-scoped)."""
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..client import get_client
+from .. import context, output
+
+console = Console()
+
+EVENTS = [
+    "deployment.started", "deployment.completed", "deployment.failed",
+    "service.stopped", "service.crashed", "scaling.event", "alert.triggered",
+]
+
+
+def _project(client, project):
+    return context.resolve_project(client, project, context.read_link())
+
+
+def _results(resp):
+    data = resp.json()
+    return data.get("results", []) if isinstance(data, dict) else data
+
+
+@click.group()
+def webhooks():
+    """Manage project webhooks (outbound event notifications)."""
+
+
+@webhooks.command("list")
+@click.argument("project", required=False, default=None)
+def list_webhooks(project):
+    """List webhooks in a project (linked project if omitted)."""
+    client = get_client()
+    project_id = _project(client, project)
+    resp = client.get(f"/projects/{project_id}/webhooks/")
+    if resp.status_code != 200:
+        console.print(f"[red]Failed to fetch webhooks: {resp.text}[/red]")
+        raise SystemExit(1)
+
+    results = _results(resp)
+    if output.json_enabled():
+        output.emit(results)
+        return
+    if not results:
+        console.print("[dim]No webhooks.[/dim]")
+        return
+
+    table = Table(title="Webhooks")
+    table.add_column("ID", style="dim")
+    table.add_column("URL", style="bold")
+    table.add_column("Events")
+    table.add_column("Active")
+    for w in results:
+        active = "[green]yes[/green]" if w.get("is_active") else "[red]no[/red]"
+        events = ", ".join(w.get("events") or []) or "[dim]all[/dim]"
+        table.add_row(str(w["id"]), w["url"], events, active)
+    console.print(table)
+
+
+@webhooks.command("add")
+@click.argument("url")
+@click.argument("project", required=False, default=None)
+@click.option("--event", "-e", "events", multiple=True,
+              type=click.Choice(EVENTS), help="Event to subscribe to (repeatable)")
+@click.option("--secret", default=None, help="HMAC signing secret")
+def add_webhook(url, project, events, secret):
+    """Add a webhook to a project. Subscribes to all events if none given."""
+    client = get_client()
+    project_id = _project(client, project)
+    payload = {"url": url, "events": list(events)}
+    if secret:
+        payload["secret"] = secret
+    resp = client.post(f"/projects/{project_id}/webhooks/", json=payload)
+    if resp.status_code == 201:
+        w = resp.json()
+        console.print(f"[green]Added webhook[/green] [bold]{w['url']}[/bold] (id={w['id']})")
+    else:
+        console.print(f"[red]Failed: {resp.text}[/red]")
+
+
+@webhooks.command("update")
+@click.argument("webhook_id", type=int)
+@click.argument("project", required=False, default=None)
+@click.option("--event", "-e", "events", multiple=True,
+              type=click.Choice(EVENTS), help="Replace subscribed events (repeatable)")
+@click.option("--secret", default=None, help="New HMAC signing secret")
+@click.option("--active/--inactive", default=None, help="Enable or disable the webhook")
+def update_webhook(webhook_id, project, events, secret, active):
+    """Update a webhook's events, secret, or active state."""
+    client = get_client()
+    project_id = _project(client, project)
+    payload = {}
+    if events:
+        payload["events"] = list(events)
+    if secret is not None:
+        payload["secret"] = secret
+    if active is not None:
+        payload["is_active"] = active
+    if not payload:
+        console.print("[yellow]Nothing to update.[/yellow]")
+        return
+    resp = client.patch(f"/projects/{project_id}/webhooks/{webhook_id}/", json=payload)
+    if resp.status_code == 200:
+        console.print("[green]Updated.[/green]")
+    else:
+        console.print(f"[red]Failed: {resp.text}[/red]")
+
+
+@webhooks.command("remove")
+@click.argument("webhook_id", type=int)
+@click.argument("project", required=False, default=None)
+@click.confirmation_option(prompt="Delete this webhook?")
+def remove_webhook(webhook_id, project):
+    """Delete a webhook from a project."""
+    client = get_client()
+    project_id = _project(client, project)
+    resp = client.delete(f"/projects/{project_id}/webhooks/{webhook_id}/")
+    if resp.status_code == 204:
+        console.print("[green]Removed.[/green]")
+    else:
+        console.print(f"[red]Failed: {resp.text}[/red]")

bitsreef_cli/config.py

@@ -0,0 +1,92 @@
+"""Configuration and token storage for BitsReef CLI."""
+import json
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".bitsreef"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+# BitsReef is a hosted, multi-tenant SaaS — it is not self-hostable, so the CLI
+# always talks to the platform API at this fixed endpoint. The URL is baked into
+# the CLI on purpose and is not user-configurable (no flag, command, or public
+# env var sets it).
+API_URL = "https://v1.api.prod.bitsreef.com/v1"
+
+
+def _ensure_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    """Load config from disk."""
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE) as f:
+        return json.load(f)
+
+
+def save_config(data: dict):
+    """Save config to disk."""
+    _ensure_dir()
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+    # Restrict permissions
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def get_api_url() -> str:
+    """Return the (fixed) BitsReef API base URL.
+
+    BitsReef is hosted SaaS, so the endpoint is constant and cannot be changed
+    by users — there is no public flag, command, or env var for it.
+
+    `_BITSREEF_DEV_API_URL` is an internal, undocumented override used only by
+    platform developers running the CLI against a local backend. It is not part
+    of the public interface and must not be documented.
+    """
+    dev = os.environ.get("_BITSREEF_DEV_API_URL")
+    if dev:
+        return dev.rstrip("/")
+    return API_URL
+
+
+def get_tokens() -> tuple[str | None, str | None]:
+    """Return (access_token, refresh_token).
+
+    `BITSREEF_TOKEN` (env) wins over the config file and is used as the access
+    token, so CI/agents authenticate without a `login` step (no refresh token —
+    provide a token that outlives the job, or log in interactively for humans).
+    """
+    env = os.environ.get("BITSREEF_TOKEN")
+    if env:
+        return env, None
+    cfg = load_config()
+    return cfg.get("access_token"), cfg.get("refresh_token")
+
+
+def save_tokens(access: str, refresh: str):
+    """Store JWT tokens."""
+    cfg = load_config()
+    cfg["access_token"] = access
+    cfg["refresh_token"] = refresh
+    save_config(cfg)
+
+
+def clear_tokens():
+    """Remove stored tokens."""
+    cfg = load_config()
+    cfg.pop("access_token", None)
+    cfg.pop("refresh_token", None)
+    save_config(cfg)
+
+
+def get_default_org() -> int | None:
+    """Return the saved default organization ID, if any."""
+    return load_config().get("default_org")
+
+
+def set_default_org(org_id: int):
+    """Persist a default organization so commands stop re-prompting."""
+    cfg = load_config()
+    cfg["default_org"] = org_id
+    save_config(cfg)

bitsreef_cli/context.py

@@ -0,0 +1,175 @@
+"""Project/service context resolution — directory linking + name/ID lookup.
+
+Lets commands take a project/service as an **id or a name/slug**, and fall back
+to the linked directory when omitted, so you rarely type raw integer IDs. A link
+is a `.bitsreef.json` file written to a directory (and discovered by walking up
+from the cwd, like `.git`). The filename is deliberately distinct from the global
+`~/.bitsreef/config.json` so directory links never collide with global config.
+"""
+import json
+import os
+from pathlib import Path
+
+import click
+
+from . import config
+
+LINK_FILENAME = ".bitsreef.json"
+
+
+# ── link file ────────────────────────────────────────────────────────────────
+
+def find_link_file(start: str | None = None) -> Path | None:
+    """Walk up from `start` (or cwd) to find a `.bitsreef.json` link file."""
+    d = Path(start or os.getcwd()).resolve()
+    for parent in [d, *d.parents]:
+        f = parent / LINK_FILENAME
+        if f.is_file():
+            return f
+    return None
+
+
+def read_link(start: str | None = None) -> dict:
+    """Return the nearest link's contents, or {} if none/invalid."""
+    f = find_link_file(start)
+    if not f:
+        return {}
+    try:
+        return json.loads(f.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def write_link(data: dict, directory: str | None = None) -> Path:
+    """Write a link file into `directory` (or cwd). Returns its path."""
+    path = Path(directory or os.getcwd()) / LINK_FILENAME
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return path
+
+
+def clear_link() -> Path | None:
+    """Remove the nearest link file. Returns its path, or None if absent."""
+    f = find_link_file()
+    if f:
+        f.unlink()
+        return f
+    return None
+
+
+# ── resolution ───────────────────────────────────────────────────────────────
+
+def _paginate(client, path: str) -> list[dict]:
+    """Fetch all results across DRF pages for a collection endpoint."""
+    out: list[dict] = []
+    resp = client.get(path)
+    if resp.status_code != 200:
+        raise click.ClickException(f"Request to {path} failed ({resp.status_code}).")
+    data = resp.json()
+    if isinstance(data, list):
+        return data
+    out.extend(data.get("results", []))
+    next_url = data.get("next")
+    while next_url:
+        # `next` is absolute; route it back through the client so auth applies.
+        sub = next_url.split("/v1", 1)[-1] if "/v1" in next_url else next_url
+        r = client.get(sub)
+        if r.status_code != 200:
+            break
+        d = r.json()
+        out.extend(d.get("results", []))
+        next_url = d.get("next")
+    return out
+
+
+def resolve_org(client, explicit=None, link: dict | None = None, *, save: bool = True) -> int:
+    """Resolve an org ID: explicit > link > saved default > interactive pick."""
+    link = link or {}
+    if explicit is not None:
+        return int(explicit)
+    if link.get("org_id"):
+        return int(link["org_id"])
+    default = config.get_default_org()
+    if default:
+        return int(default)
+
+    orgs = _paginate(client, "/organizations/")
+    if not orgs:
+        raise click.ClickException("No organizations found.")
+    if len(orgs) == 1:
+        org_id = int(orgs[0]["id"])
+    else:
+        click.echo("Select an organization:")
+        for i, org in enumerate(orgs, 1):
+            click.echo(f"  {i}. {org['name']} (id={org['id']})")
+        choice = click.prompt("Enter number", type=int, default=1)
+        org_id = int(orgs[choice - 1]["id"])
+    if save:
+        config.set_default_org(org_id)
+    return org_id
+
+
+def resolve_project(client, value=None, link: dict | None = None, *, org=None) -> int:
+    """Resolve a project ID from an id/name/slug, or the linked project.
+
+    `value` may be a numeric id (returned as-is), a name/slug (looked up within
+    the resolved org), or None (falls back to the link).
+    """
+    link = link or {}
+    if value is None:
+        if link.get("project_id"):
+            return int(link["project_id"])
+        raise click.ClickException(
+            "No project given and none linked. Pass a project or run `bitsreef link`."
+        )
+    text = str(value)
+    if text.isdigit():
+        return int(text)
+    org_id = resolve_org(client, org, link)
+    projects = _paginate(client, f"/organizations/{org_id}/projects/")
+    for p in projects:
+        if p.get("name") == text or p.get("slug") == text:
+            return int(p["id"])
+    raise click.ClickException(f"No project named '{text}' in org {org_id}.")
+
+
+def resolve_service(client, project_id: int, value=None, link: dict | None = None) -> int:
+    """Resolve a service ID from an id/name, or the linked service."""
+    link = link or {}
+    if value is None:
+        if link.get("service_id"):
+            return int(link["service_id"])
+        raise click.ClickException(
+            "No service given and none linked. Pass a service or run `bitsreef link`."
+        )
+    text = str(value)
+    if text.isdigit():
+        return int(text)
+    services = _paginate(client, f"/projects/{project_id}/services/")
+    for s in services:
+        if s.get("name") == text:
+            return int(s["id"])
+    raise click.ClickException(f"No service named '{text}' in project {project_id}.")
+
+
+def resolve_environment(client, project_id: int, value=None) -> int:
+    """Resolve an environment ID from an id/name within a project.
+
+    With no value, returns the project's default (production) environment.
+    """
+    envs = _paginate(client, f"/projects/{project_id}/environments/")
+    if value is None:
+        for e in envs:
+            if e.get("is_default"):
+                return int(e["id"])
+        if envs:
+            return int(envs[0]["id"])
+        raise click.ClickException(f"Project {project_id} has no environments.")
+    text = str(value)
+    if text.isdigit():
+        return int(text)
+    for e in envs:
+        if e.get("name") == text:
+            return int(e["id"])
+    raise click.ClickException(
+        f"No environment named '{text}' in project {project_id}."
+    )

bitsreef_cli/deploy_watch.py

@@ -0,0 +1,87 @@
+"""Poll a deployment to completion — shared by `bitsreef up` and `deploy up --follow`.
+
+Streams new build/deploy log lines as they appear and returns a (success, final)
+tuple so callers can set a correct process exit code. Terminal states come from
+the Deployment model: `running` = success, `failed` = failure; everything else
+(`queued`, `building`, `pushing`, `deploying`) is in-flight.
+"""
+import time
+
+from rich.console import Console
+
+console = Console()
+
+TERMINAL_OK = {"running"}
+TERMINAL_FAIL = {"failed", "cancelled"}
+
+
+def follow_deployment(
+    client,
+    service_id: int,
+    deployment_id: int,
+    *,
+    interval: float = 2.0,
+    timeout: float = 600.0,
+    json_mode: bool = False,
+) -> tuple[bool, dict | None]:
+    """Poll `/services/{id}/deployments/{id}/` until terminal.
+
+    Returns (success, final_payload). `success` is False on failure, a non-200
+    poll, or timeout. Quiet when `json_mode` is set (caller renders the result).
+    """
+    seen_status = None
+    build_len = 0
+    deploy_len = 0
+    start = time.monotonic()
+
+    while True:
+        resp = client.get(f"/services/{service_id}/deployments/{deployment_id}/")
+        if resp.status_code != 200:
+            if not json_mode:
+                console.print(
+                    f"[red]Could not fetch deployment status "
+                    f"({resp.status_code}).[/red]"
+                )
+            return False, None
+
+        d = resp.json()
+        status = d.get("status")
+
+        if status != seen_status:
+            if not json_mode:
+                console.print(f"[cyan]● {status}[/cyan]")
+            seen_status = status
+
+        if not json_mode:
+            build_len = _stream_log(d.get("build_log") or "", build_len)
+            deploy_len = _stream_log(d.get("deploy_log") or "", deploy_len)
+
+        if status in TERMINAL_OK:
+            return True, d
+
+        if status in TERMINAL_FAIL:
+            if not json_mode:
+                err = d.get("error_message") or "(no error message)"
+                console.print(f"[red]Deployment {status}: {err}[/red]")
+            return False, d
+
+        if time.monotonic() - start > timeout:
+            if not json_mode:
+                console.print(
+                    f"[yellow]Timed out after {int(timeout)}s "
+                    f"(last status: {status}). The deploy may still finish — "
+                    f"check `bitsreef deploy status`.[/yellow]"
+                )
+            return False, d
+
+        time.sleep(interval)
+
+
+def _stream_log(text: str, shown: int) -> int:
+    """Print any log content past `shown` chars; return the new length."""
+    if len(text) > shown:
+        for line in text[shown:].splitlines():
+            if line:
+                console.print(f"[dim]│[/dim] {line}")
+        return len(text)
+    return shown

bitsreef_cli/log_stream.py

@@ -0,0 +1,83 @@
+"""Live log streaming over WebSocket (`bitsreef logs --follow`).
+
+Connects to the platform's ServiceLogConsumer at
+`/ws/services/{id}/logs/?token=<JWT>` (WS auth is the `?token` query param,
+handled by JWTAuthMiddleware). The consumer streams JSON messages:
+  {"type": "history", "logs": "<block>"}   — initial tail
+  {"type": "log", "message": "<line>"}     — each new line
+  {"type": "error", "message": "..."}      — a stream error
+"""
+import json
+from urllib.parse import urlsplit, urlunsplit
+
+from rich.console import Console
+
+console = Console()
+
+
+def ws_url(api_url: str, service_id) -> str:
+    """Derive the log-stream WS URL from the REST base URL.
+
+    The WS route lives at the host root (`/ws/...`), not under the `/v1` API
+    prefix, so only scheme+host are taken from `api_url`.
+    """
+    parts = urlsplit(api_url)
+    scheme = "wss" if parts.scheme == "https" else "ws"
+    return urlunsplit((scheme, parts.netloc, f"/ws/services/{service_id}/logs/", "", ""))
+
+
+def follow_logs(api_url: str, token: str | None, service_id) -> int:
+    """Stream logs until interrupted (Ctrl-C). Returns a process exit code."""
+    try:
+        import websocket  # from websocket-client
+    except ImportError:
+        console.print("[red]Live follow needs 'websocket-client'. "
+                      "Install it: pip install websocket-client[/red]")
+        return 1
+
+    if not token:
+        console.print("[red]Not logged in. Run: bitsreef auth login[/red]")
+        return 1
+
+    url = f"{ws_url(api_url, service_id)}?token={token}"
+    try:
+        ws = websocket.create_connection(url, timeout=30)
+    except Exception as exc:  # noqa: BLE001 — surface any connect failure cleanly
+        console.print(f"[red]Could not connect to log stream: {exc}[/red]")
+        return 1
+
+    try:
+        while True:
+            try:
+                raw = ws.recv()
+            except websocket.WebSocketTimeoutException:
+                continue  # idle keepalive tick — keep waiting
+            except websocket.WebSocketConnectionClosedException:
+                break
+            if not raw:
+                break
+            _print_message(raw)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        try:
+            ws.close()
+        except Exception:  # noqa: BLE001
+            pass
+    return 0
+
+
+def _print_message(raw) -> None:
+    try:
+        msg = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        console.print(raw)
+        return
+    msg_type = msg.get("type")
+    if msg_type == "history":
+        for line in (msg.get("logs") or "").splitlines():
+            console.print(line)
+    elif msg_type == "log":
+        console.print(msg.get("message", ""))
+    elif msg_type == "error":
+        console.print(f"[red]{msg.get('message', 'stream error')}[/red]")

bitsreef_cli/main.py

@@ -0,0 +1,43 @@
+"""BitsReef CLI — main entry point."""
+import click
+
+from . import __version__, output
+from .commands import (
+    auth, projects, services, env, environments, functions, deploy, logs, up,
+    link, exec_cmd, domains, volumes, metrics, cron, webhooks, templates,
+    completion,
+)
+
+
+@click.group()
+@click.version_option(__version__, prog_name="bitsreef")
+@click.option("--json", "json_mode", is_flag=True,
+              help="Machine-readable JSON output (place before the command: bitsreef --json ...)")
+def cli(json_mode):
+    """BitsReef — Deploy and manage your services from the command line."""
+    output.set_json(json_mode)
+
+
+cli.add_command(up.up)
+cli.add_command(exec_cmd.exec_)
+cli.add_command(link.link)
+cli.add_command(link.unlink)
+cli.add_command(auth.auth)
+cli.add_command(projects.projects)
+cli.add_command(services.services)
+cli.add_command(env.env)
+cli.add_command(environments.environments)
+cli.add_command(functions.functions)
+cli.add_command(deploy.deploy)
+cli.add_command(logs.logs)
+cli.add_command(domains.domains)
+cli.add_command(volumes.volumes)
+cli.add_command(metrics.metrics)
+cli.add_command(cron.cron)
+cli.add_command(webhooks.webhooks)
+cli.add_command(templates.templates)
+cli.add_command(completion.completion)
+
+
+if __name__ == "__main__":
+    cli()

bitsreef_cli/output.py

@@ -0,0 +1,25 @@
+"""Output mode — the global `--json` flag and a helper to emit JSON.
+
+A process-wide singleton set by the root `cli` callback (`bitsreef --json ...`),
+so read commands can render either a Rich table (humans) or machine-readable
+JSON (CI/agents/scripts) without threading a flag through every signature.
+"""
+import json as _json
+
+import click
+
+_JSON_MODE = False
+
+
+def set_json(enabled: bool) -> None:
+    global _JSON_MODE
+    _JSON_MODE = bool(enabled)
+
+
+def json_enabled() -> bool:
+    return _JSON_MODE
+
+
+def emit(data) -> None:
+    """Print `data` as JSON on stdout (used in --json mode)."""
+    click.echo(_json.dumps(data, default=str))