mozbridge-cli 0.2.1__tar.gz → 0.3.0__tar.gz

{mozbridge_cli-0.2.1 → mozbridge_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mozbridge-cli
-Version: 0.2.1
+Version: 0.3.0
 Summary: Command-line client for the Mozbridge deployment platform: SSO login, build, publish, status, and rollback for any project hosted on Mozbridge.
 Project-URL: Homepage, https://mozbridge.com
 Project-URL: Documentation, https://github.com/jessin01/mozbridge/blob/main/cli/docs/commands.md

{mozbridge_cli-0.2.1 → mozbridge_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mozbridge-cli"
-version = "0.2.1"
+version = "0.3.0"
 description = "Command-line client for the Mozbridge deployment platform: SSO login, build, publish, status, and rollback for any project hosted on Mozbridge."
 readme = "README.md"
 requires-python = ">=3.10"

{mozbridge_cli-0.2.1 → mozbridge_cli-0.3.0}/scripts/release.sh

@@ -10,8 +10,25 @@
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+REPO_ROOT="$(cd "$ROOT/.." && pwd)"
 PYPROJECT="$ROOT/pyproject.toml"
 
+# Hard first check: `git fetch` updates the remote-tracking ref, not the
+# working tree — only merge/rebase/pull do that. mozbridge-cli 0.2.0 was
+# published missing 3 commands because this build ran between a `git
+# fetch` and the merge that would have actually updated the checkout.
+# Refuse to build from a checkout that's behind origin/main.
+if command -v git >/dev/null 2>&1 && git -C "$REPO_ROOT" rev-parse --git-dir >/dev/null 2>&1; then
+  git -C "$REPO_ROOT" fetch origin main --quiet 2>/dev/null || true
+  BEHIND="$(git -C "$REPO_ROOT" rev-list --count HEAD..origin/main 2>/dev/null || echo 0)"
+  if [ "${BEHIND:-0}" != "0" ]; then
+    echo "✗ Local main is ${BEHIND} commit(s) behind origin/main." >&2
+    echo "  Run: git -C \"$REPO_ROOT\" merge --ff-only origin/main" >&2
+    echo "  then re-run this script. Refusing to build a stale release." >&2
+    exit 1
+  fi
+fi
+
 usage() {
   echo "Usage: $0 [--patch|--minor|--major] [--dry-run]" >&2
   echo "  Default bump: patch" >&2

{mozbridge_cli-0.2.1 → mozbridge_cli-0.3.0}/src/mozbridge_cli/api.py

@@ -308,6 +308,122 @@ def delete_project_env_var(
     return resp.json()
 
 
+def get_project_registry(client: httpx.Client, access_token: str, org_id: int, project_id: int) -> dict:
+    """GET /api/v1/projects/{project_id}/registry -> schemas.RegistryCredentialStatus.
+
+    {configured, registry_url, username, updated_at} — the token/secret value
+    is never returned by this route (router.py:2343-2352), by design, so
+    there is nothing here for a caller to accidentally print.
+    """
+    url = f"{config.API_BASE_URL}{config.PROJECTS_PATH}/{project_id}/registry"
+    try:
+        resp = client.get(url, headers=_headers(access_token, org_id))
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach Mozbridge API: {exc}") from exc
+    _raise_for_status(resp, "fetch the registry credential status")
+    return resp.json()
+
+
+def set_project_registry(
+    client: httpx.Client,
+    access_token: str,
+    org_id: int,
+    project_id: int,
+    registry_url: str,
+    username: str,
+    token: str,
+) -> dict:
+    """PUT /api/v1/projects/{project_id}/registry, body schemas.RegistryCredentialSet.
+
+    Admin-gated (ensure_permify_can_administer) and validated against the
+    real registry BEFORE storing (router.py:2355-2384) — a bad credential
+    comes back as a 400 with a real message ("Could not validate registry
+    credential: ..."), which `_raise_for_status` already surfaces via
+    ApiError, same as every other function in this module.
+    """
+    url = f"{config.API_BASE_URL}{config.PROJECTS_PATH}/{project_id}/registry"
+    payload = {"registry_url": registry_url, "username": username, "token": token}
+    try:
+        resp = client.put(url, json=payload, headers=_headers(access_token, org_id))
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach Mozbridge API: {exc}") from exc
+    _raise_for_status(resp, "set the registry credential")
+    return resp.json()
+
+
+def _secrets_url(project_id: int, env_slug: str, component: str) -> str:
+    """Shared path builder for the four secrets endpoints below — keeps the
+    env_slug/component path segments byte-for-byte identical across list
+    keys / get values / patch one key, rather than four separately-typed
+    f-strings that could drift apart.
+    """
+    base = f"{config.API_BASE_URL}{config.PROJECTS_PATH}/{project_id}"
+    return f"{base}/environments/{env_slug}/secrets/{component}"
+
+
+def list_env_secret_keys(
+    client: httpx.Client, access_token: str, org_id: int, project_id: int, env_slug: str, component: str
+) -> dict:
+    """GET .../environments/{env_slug}/secrets/{component}/keys -> {keys, count}.
+
+    Key NAMES only — no values leave the server (router.py:3422-3434). This
+    is the default listing behavior for `mozbridge secrets list`.
+    """
+    url = f"{_secrets_url(project_id, env_slug, component)}/keys"
+    try:
+        resp = client.get(url, headers=_headers(access_token, org_id))
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach Mozbridge API: {exc}") from exc
+    _raise_for_status(resp, "list secret keys")
+    return resp.json()
+
+
+def get_env_secrets(
+    client: httpx.Client, access_token: str, org_id: int, project_id: int, env_slug: str, component: str
+) -> dict:
+    """GET .../environments/{env_slug}/secrets/{component} -> dict[key, value].
+
+    Returns actual secret VALUES (router.py:3412-3419). Only called from
+    `mozbridge secrets list --show-values`, gated behind an interactive
+    confirmation (or --yes) before this is ever invoked.
+    """
+    url = _secrets_url(project_id, env_slug, component)
+    try:
+        resp = client.get(url, headers=_headers(access_token, org_id))
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach Mozbridge API: {exc}") from exc
+    _raise_for_status(resp, "fetch secret values")
+    return resp.json()
+
+
+def patch_env_secret(
+    client: httpx.Client,
+    access_token: str,
+    org_id: int,
+    project_id: int,
+    env_slug: str,
+    component: str,
+    key: str,
+    value: str,
+) -> dict:
+    """PATCH .../environments/{env_slug}/secrets/{component}, body schemas.SecretPatch {key, value}.
+
+    Merges ONE key server-side over a strict read (router.py:3437-3453) —
+    the safe way to set one secret without touching the rest. `mozbridge
+    secrets set` MUST use this, never the POST replace-all endpoint below.
+
+    Returns {"status": "success", "key", "created", "total_keys"} — never
+    the merged secret values.
+    """
+    url = _secrets_url(project_id, env_slug, component)
+    try:
+        resp = client.patch(url, json={"key": key, "value": value}, headers=_headers(access_token, org_id))
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach Mozbridge API: {exc}") from exc
+    _raise_for_status(resp, "set the secret")
+    return resp.json()
+
+
 def trigger_prebuilt_build(
     client: httpx.Client,
     access_token: str,

mozbridge_cli-0.3.0/src/mozbridge_cli/cmd_auth.py

@@ -0,0 +1,152 @@
+"""`mozbridge login` / `whoami` / `logout` command definitions.
+
+The underlying device-flow logic lives in auth.py (unchanged, imported
+here, not duplicated). This module owns only the Typer command layer that
+used to live directly in main.py.
+"""
+
+from __future__ import annotations
+
+import httpx
+import typer
+
+from . import auth, config, session
+
+app = typer.Typer(add_completion=False)
+
+
+@app.command("login")
+def login_cmd() -> None:
+    """Sign in via Logto's device authorization flow (opens a URL for you to approve)."""
+    if session.token_from_env() is not None:
+        typer.echo(
+            f"{session.TOKEN_ENV_VAR} is set — this CLI is already authenticating as that "
+            "token for every command, so an interactive `mozbridge login` doesn't apply here. "
+            f"These are mutually exclusive auth modes; unset {session.TOKEN_ENV_VAR} first if "
+            "you want to log in interactively instead.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    with httpx.Client(timeout=30.0) as client:
+        try:
+            authorization = auth.start_device_authorization(client)
+        except httpx.HTTPError as exc:
+            typer.echo(f"Could not start login: {exc}", err=True)
+            raise typer.Exit(code=1)
+
+        if authorization.verification_uri_complete:
+            typer.echo(f"Open this URL to sign in:\n\n  {authorization.verification_uri_complete}\n")
+        typer.echo(f"Or go to {authorization.verification_uri} and enter code: {authorization.user_code}")
+        typer.echo("Waiting for approval...")
+
+        try:
+            token_response = auth.poll_for_token(client, authorization)
+        except auth.AccessDenied as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+        except auth.ExpiredToken as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+        except auth.DeviceLoginError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+    new_session = session.session_from_token_response(token_response)
+    path = session.save_session(new_session)
+    typer.echo(f"Logged in. Session saved to {path}")
+
+
+def load_and_refresh_session(client: httpx.Client) -> session.Session:
+    """Return the bearer token to use for this command.
+
+    Single choke point for auth used by every command below (whoami, link,
+    status, rollback, diff, publish's remote AND --local paths). Checked
+    BEFORE anything session-file-related, mirroring gh/flyctl/Vercel's own
+    env-var precedence: if MOZBRIDGE_TOKEN is set, it is used directly as
+    the bearer token and load_session()/save_session()/refresh-token logic
+    are never invoked — there's no on-disk session file involved in this
+    path. Otherwise, falls back to loading the cached session, refreshing
+    the access token first if expired.
+
+    Exits the process with a clear message if there is no session, or if
+    refresh fails.
+    """
+    env_token = session.token_from_env()
+    if env_token is not None:
+        return session.Session(
+            access_token=env_token,
+            refresh_token=None,
+            id_token=None,
+            expires_at=float("inf"),
+        )
+
+    current = session.load_session()
+    if current is None:
+        typer.echo("Not logged in. Run `mozbridge login` first.", err=True)
+        raise typer.Exit(code=1)
+
+    if not current.is_expired():
+        return current
+
+    if not current.refresh_token:
+        typer.echo("Session expired and cannot be refreshed. Run `mozbridge login` again.", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        token_response = auth.refresh_access_token(client, current.refresh_token)
+    except auth.RefreshError as exc:
+        typer.echo(f"{exc} — run `mozbridge login` again.", err=True)
+        raise typer.Exit(code=1)
+
+    refreshed = session.session_from_token_response(token_response)
+    # Logto may omit refresh_token on rotation-less refresh — keep the old one.
+    if not refreshed.refresh_token:
+        refreshed.refresh_token = current.refresh_token
+    session.save_session(refreshed)
+    return refreshed
+
+
+@app.command("whoami")
+def whoami_cmd() -> None:
+    """Show the signed-in Mozbridge identity."""
+    with httpx.Client(timeout=30.0) as client:
+        active_session = load_and_refresh_session(client)
+
+        url = f"{config.API_BASE_URL}{config.WHOAMI_PATH}"
+        try:
+            resp = client.get(url, headers={"Authorization": f"Bearer {active_session.access_token}"})
+        except httpx.HTTPError as exc:
+            typer.echo(f"Could not reach Mozbridge API: {exc}", err=True)
+            raise typer.Exit(code=1)
+
+        if resp.status_code == 401:
+            typer.echo("Session is no longer valid. Run `mozbridge login` again.", err=True)
+            raise typer.Exit(code=1)
+        if resp.status_code != 200:
+            typer.echo(f"Mozbridge API returned {resp.status_code}: {resp.text}", err=True)
+            raise typer.Exit(code=1)
+
+        data = resp.json()
+
+    email = data.get("email") or "(no email on record)"
+    username = data.get("username")
+    full_name = data.get("full_name")
+    display = full_name or username or email
+
+    typer.echo(f"Logged in as {display}")
+    typer.echo(f"  email:            {email}")
+    if username:
+        typer.echo(f"  username:         {username}")
+    typer.echo(f"  user id:          {data.get('id')}")
+    typer.echo(f"  platform admin:   {bool(data.get('is_platform_admin'))}")
+
+
+@app.command("logout")
+def logout_cmd() -> None:
+    """Delete the cached local session. Safe to run even if already logged out."""
+    removed = session.delete_session()
+    if removed:
+        typer.echo("Logged out.")
+    else:
+        typer.echo("Already logged out.")

mozbridge_cli-0.3.0/src/mozbridge_cli/cmd_deploy.py

@@ -0,0 +1,307 @@
+"""`mozbridge status` / `rollback` / `deploy` / `logs` — deploy lifecycle commands."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+import httpx
+import typer
+
+from . import api
+from .cmd_shared import require_link_and_session
+
+app = typer.Typer(add_completion=False)
+
+
+@app.command("status")
+def status_cmd() -> None:
+    """Show the linked project's status and its 5 most recent deployments."""
+    cwd = Path.cwd()
+
+    with httpx.Client(timeout=30.0) as client:
+        current_link, active_session = require_link_and_session(client, cwd)
+
+        try:
+            project = api.get_project(
+                client, active_session.access_token, current_link.org_id, current_link.project_id
+            )
+        except api.ApiError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+        try:
+            deployments = api.list_project_deployments(
+                client, active_session.access_token, current_link.org_id, current_link.project_id
+            )
+        except api.ApiError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+    typer.echo(f"{project.get('name')} ({project.get('slug')})")
+    typer.echo(f"  status: {project.get('status')}")
+
+    if not deployments:
+        typer.echo("No deployments yet.")
+        return
+
+    typer.echo("Recent deployments:")
+    for deployment in deployments[:5]:
+        stable_marker = " [stable]" if deployment.get("is_stable") else ""
+        typer.echo(
+            f"  #{deployment.get('id')}  {deployment.get('deployed_at') or '(no timestamp)'}  "
+            f"{deployment.get('component')}={deployment.get('version')}  "
+            f"{deployment.get('status')}{stable_marker}"
+        )
+
+
+@app.command("rollback")
+def rollback_cmd(
+    to: int | None = typer.Option(
+        None, "--to", help="Deployment id to roll back to. Omit to roll back to the previous deployment."
+    ),
+    yes: bool = typer.Option(False, "--yes", help="Skip the interactive confirmation prompt."),
+) -> None:
+    """Roll back the linked project's deployment. A real, consequential production action."""
+    cwd = Path.cwd()
+
+    with httpx.Client(timeout=30.0) as client:
+        current_link, active_session = require_link_and_session(client, cwd)
+
+        target_desc = f"deployment #{to}" if to is not None else "the previous deployment"
+        project_desc = f"{current_link.org_slug}/{current_link.project_slug}"
+        typer.echo(f"This will roll back {project_desc} to {target_desc}.")
+        typer.echo("Target environment: prod.")
+        if not yes:
+            typer.confirm("Continue?", abort=True)
+
+        try:
+            if to is not None:
+                result = api.rollback_project_to(
+                    client,
+                    active_session.access_token,
+                    current_link.org_id,
+                    current_link.project_id,
+                    to,
+                )
+            else:
+                result = api.rollback_project(
+                    client, active_session.access_token, current_link.org_id, current_link.project_id
+                )
+        except api.ApiError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+    task_id = result.get("task_id") or result.get("target_task")
+    typer.echo(f"Rollback triggered (task_id={task_id}).")
+
+
+@app.command("deploy")
+def deploy_cmd(
+    frontend: str | None = typer.Option(
+        None, "--frontend", help="Frontend image tag to deploy (e.g. v1.9.319)."
+    ),
+    backend: str | None = typer.Option(
+        None, "--backend", help="Backend image tag to deploy (e.g. v1.9.319)."
+    ),
+    environment: str = typer.Option("prod", "--env", help="Environment to deploy to."),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help=(
+            "Override a blocking preflight check (the platform's own "
+            "known-to-fail guard). A separate, explicit decision each time — "
+            "never set automatically by this CLI."
+        ),
+    ),
+    yes: bool = typer.Option(False, "--yes", help="Skip the interactive confirmation prompt."),
+) -> None:
+    """Deploy an already-built image tag to the linked Mozbridge project.
+
+    A real, consequential production action — same category as `mozbridge
+    rollback`: it mutates production the moment it's called, not a dry-run.
+    Requires `mozbridge link` and an active login session. At least one of
+    --frontend/--backend must be given (deploying neither makes no sense).
+
+    Only the services you actually gave a tag for are deployed — `services`
+    is built from --frontend/--backend, not left to the API's own default of
+    both, unless you passed both.
+    """
+    if frontend is None and backend is None:
+        typer.echo(
+            "Provide at least one of --frontend/--backend — deploying neither makes no sense.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    services: list[str] = []
+    if frontend is not None:
+        services.append("frontend")
+    if backend is not None:
+        services.append("backend")
+
+    cwd = Path.cwd()
+
+    with httpx.Client(timeout=30.0) as client:
+        current_link, active_session = require_link_and_session(client, cwd)
+
+        project_desc = f"{current_link.org_slug}/{current_link.project_slug}"
+        typer.echo(f"This will deploy {project_desc} ({environment}):")
+        if frontend is not None:
+            typer.echo(f"  frontend -> {frontend}")
+        if backend is not None:
+            typer.echo(f"  backend  -> {backend}")
+        if not yes:
+            typer.confirm("Continue?", abort=True)
+
+        payload = {
+            "frontend_version": frontend,
+            "backend_version": backend,
+            "services": services,
+            "environment": environment,
+            "force": force,
+        }
+
+        try:
+            result = api.deploy_project(
+                client, active_session.access_token, current_link.org_id, current_link.project_id, payload
+            )
+        except api.PreflightBlockedError as exc:
+            typer.echo(str(exc), err=True)
+            for check in exc.blocking:
+                title = check.get("title") or check.get("key") or "(unnamed check)"
+                detail = check.get("detail") or ""
+                typer.echo(f"  - {title}: {detail}", err=True)
+                if check.get("action"):
+                    typer.echo(f"    action: {check['action']}", err=True)
+            typer.echo(exc.override or "Pass force=true to deploy anyway.", err=True)
+            typer.echo("Re-run with --force to override — this is not done automatically.", err=True)
+            raise typer.Exit(code=1)
+        except api.ApiError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+    task_id = result.get("task_id")
+    typer.echo(f"Deploy triggered (task_id={task_id}).")
+    typer.echo("Run `mozbridge logs` to watch it.")
+
+
+def _iter_sse_events(lines) -> Iterator[tuple[str, str]]:
+    """Parse a text/event-stream line iterator into (event, data) pairs.
+
+    Standard SSE framing (see router.py's `stream_operation_logs`, which is
+    the only producer this ever reads): lines starting with "data:" accumulate
+    until a blank line, which dispatches one event; an "event:" line names
+    its type (defaults to "message" if absent, though this server always
+    sends one). A leading single space after the colon is stripped per the
+    SSE spec; any other line (comments, unknown fields) is ignored.
+    """
+    event_type = "message"
+    data_lines: list[str] = []
+    for raw_line in lines:
+        line = raw_line.rstrip("\r")
+        if line == "":
+            if data_lines:
+                yield event_type, "\n".join(data_lines)
+            event_type = "message"
+            data_lines = []
+            continue
+        if line.startswith("event:"):
+            event_type = line[len("event:") :].strip()
+        elif line.startswith("data:"):
+            value = line[len("data:") :]
+            if value.startswith(" "):
+                value = value[1:]
+            data_lines.append(value)
+    if data_lines:
+        yield event_type, "\n".join(data_lines)
+
+
+@app.command("logs")
+def logs_cmd(
+    task_id: str | None = typer.Argument(
+        None, help="Task id of a build/deploy operation. Omit to use the most recent one for this project."
+    ),
+    follow: bool = typer.Option(
+        False, "--follow", "-f", help="Stream new log output as it arrives; exits when the run finishes."
+    ),
+) -> None:
+    """Show BUILD/DEPLOY OPERATION logs for the linked project.
+
+    This is the log output of a Mozbridge build or deploy task — what
+    `publish`, `deploy`, and `rollback` trigger — NOT your running
+    application's runtime/request logs. This platform does not expose
+    application runtime logs via any API today; this command is not
+    `docker logs` for your live app.
+
+    Requires `mozbridge link` and an active login session. Without --follow,
+    fetches and prints whatever log content exists right now, once. With
+    --follow, opens the platform's SSE log stream and prints new content as
+    it arrives, exiting cleanly when the server closes the stream (it does
+    so automatically once the operation reaches a terminal state).
+    """
+    cwd = Path.cwd()
+
+    with httpx.Client(timeout=30.0) as client:
+        current_link, active_session = require_link_and_session(client, cwd)
+
+        resolved_task_id = task_id
+        if resolved_task_id is None:
+            try:
+                operations = api.list_project_operations(
+                    client,
+                    active_session.access_token,
+                    current_link.org_id,
+                    current_link.project_id,
+                    limit=1,
+                )
+            except api.ApiError as exc:
+                typer.echo(str(exc), err=True)
+                raise typer.Exit(code=1)
+            if not operations or not operations[0].get("task_id"):
+                typer.echo("No operations found for this project yet.", err=True)
+                raise typer.Exit(code=1)
+            resolved_task_id = operations[0]["task_id"]
+
+        if not follow:
+            try:
+                op = api.get_operation(
+                    client, active_session.access_token, current_link.org_id, resolved_task_id
+                )
+            except api.ApiError as exc:
+                typer.echo(str(exc), err=True)
+                raise typer.Exit(code=1)
+            logs = (op.get("result") or {}).get("logs")
+            if logs:
+                typer.echo(logs)
+            else:
+                typer.echo(f"No logs yet for task {resolved_task_id} (status: {op.get('status')}).")
+            return
+
+        org_id = current_link.org_id
+        access_token = active_session.access_token
+
+    # --follow: a separate client with no read timeout — the server holds
+    # this connection open for as long as the operation runs, closing it
+    # itself once the operation reaches a terminal state (see
+    # stream_operation_logs's docstring); we only need to survive that,
+    # not impose our own timeout on top of it.
+    stream_url = api.operation_stream_url(resolved_task_id)
+    headers = {"Authorization": f"Bearer {access_token}", "X-Organization-Id": str(org_id)}
+    try:
+        with httpx.Client(timeout=httpx.Timeout(30.0, read=None)) as stream_client:
+            with stream_client.stream("GET", stream_url, headers=headers) as resp:
+                if resp.status_code != 200:
+                    resp.read()
+                    typer.echo(f"Could not stream logs: HTTP {resp.status_code}: {resp.text}", err=True)
+                    raise typer.Exit(code=1)
+                for event_type, data in _iter_sse_events(resp.iter_lines()):
+                    if event_type == "log":
+                        typer.echo(data)
+                    elif event_type == "error":
+                        typer.echo(f"Stream error: {data}", err=True)
+                    elif event_type == "done":
+                        break
+    except httpx.HTTPError as exc:
+        typer.echo(f"Log stream connection dropped: {exc}", err=True)
+        raise typer.Exit(code=1)