mozbridge-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{mozbridge_cli-0.4.0 → mozbridge_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mozbridge-cli
-Version: 0.4.0
+Version: 0.5.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.4.0 → mozbridge_cli-0.5.0}/docs/commands.md

@@ -811,6 +811,92 @@ the credential (bad token, wrong URL): the raw validation error, exit 1.
 
 ---
 
+## `mozbridge config set` / `mozbridge config get`
+
+Manages one key on the linked project's `config`
+(`PUT /api/v1/projects/{project_id}`, body `{"config": {KEY: VALUE}}`) —
+the same allowlisted settings the platform template reads
+(`app_compose_file`, `backend_port`, `data_volumes`, and anything else on
+`schemas.PROJECT_CONFIG_ALLOWLIST` in
+`backend/app/features/projects/schemas.py`). This wraps an existing
+endpoint with zero backend changes — the same one `env`/`registry`/
+`secrets` wrap, using the normal logged-in session (`get_valid_project`),
+no special scope.
+
+**Requires**: link + login, same as `env`/`registry`.
+
+### `mozbridge config set KEY VALUE`
+
+**What it does**: `PUT /api/v1/projects/{project_id}` with body
+`{"config": {KEY: VALUE}}`. **This merges into the existing config, it
+does not replace it** — read directly off
+`backend/app/features/projects/router.py`'s `update_project`:
+`current_config.update(incoming)`, so setting one key never touches any
+other key already set.
+
+`KEY` is checked against `PROJECT_CONFIG_ALLOWLIST` **server-side only**
+— there is no client-side copy of that list in this CLI, and none is
+maintained here. A `KEY` not on the allowlist gets the whole request
+rejected with a 400:
+
+```
+$ mozbridge config set totally_made_up_key x
+Could not set the project config: Unknown or privileged config keys rejected: totally_made_up_key
+```
+
+On success, the confirmation is read back off the response body's
+`config` field — not echoed from what was typed — so it reflects what
+the backend actually stored:
+
+```
+$ mozbridge config set app_compose_file compose.custom.yml
+Set app_compose_file = compose.custom.yml
+```
+
+An empty-string `VALUE` is passed through unchanged, same posture as
+`env set` — this command does not second-guess values.
+
+### `mozbridge config get KEY`
+
+**What it does**: `GET /api/v1/projects/{project_id}` (the same call
+`status`/`doctor` already make), prints the current value of `KEY` from
+the response's `config` field:
+
+```
+$ mozbridge config get app_compose_file
+app_compose_file = compose.custom.yml
+```
+
+If `KEY` isn't present in the project's config, prints a clear message
+instead of a raw `None`/`null`:
+
+```
+$ mozbridge config get backend_port
+backend_port is not set.
+```
+
+**This command does not validate `KEY` against any allowlist** — it
+prints whatever is actually stored, including a key that isn't (or is no
+longer) on `PROJECT_CONFIG_ALLOWLIST`, e.g. a leftover from before it was
+removed. It mirrors reality; it is not a gatekeeper.
+
+**No `config list` / `config unset`**: unlike `env`, which has a real
+`DELETE /env-vars/{key}` route, the backend has no operation to delete a
+single arbitrary config key — only `set` (merge) and reading the whole
+project. Inventing client-side behavior for something the backend can't
+actually do would be misleading, so neither subcommand exists.
+
+**Failure modes**:
+- Not linked / not logged in: identical messages to `publish` above,
+  exit 1.
+- `set` against a key not on the backend's allowlist: the raw `ApiError`
+  message (`Could not set the project config: Unknown or privileged
+  config keys rejected: <key>`), exit 1.
+- Any other API error (e.g. a 500 from the database): the raw `ApiError`
+  message, exit 1.
+
+---
+
 ## `mozbridge secrets list` / `mozbridge secrets set`
 
 Manages the linked project's Vault-backed, per-environment/per-component

{mozbridge_cli-0.4.0 → mozbridge_cli-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mozbridge-cli"
-version = "0.4.0"
+version = "0.5.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.4.0 → mozbridge_cli-0.5.0}/src/mozbridge_cli/api.py

@@ -378,6 +378,33 @@ def set_project_registry(
     return resp.json()
 
 
+def set_project_config(
+    client: httpx.Client, access_token: str, org_id: int, project_id: int, key: str, value: str
+) -> dict:
+    """PUT /api/v1/projects/{project_id}, body schemas.ProjectUpdate {"config": {key: value}}.
+
+    router.py's update_project merges `incoming` into the project's existing
+    config (`current_config.update(incoming)`) — it does NOT replace the
+    whole config, so this never touches any other key. Unknown/privileged
+    keys (anything not on schemas.PROJECT_CONFIG_ALLOWLIST) come back as a
+    400 with `"Unknown or privileged config keys rejected: <key>"`, which
+    `_raise_for_status` already surfaces verbatim via ApiError, same as
+    every other function in this module.
+
+    Returns the full updated schemas.Project — the caller reads the
+    confirmed value back off its `config` field rather than trusting what
+    was sent, in case the backend did anything to it.
+    """
+    url = f"{config.API_BASE_URL}{config.PROJECTS_PATH}/{project_id}"
+    payload = {"config": {key: value}}
+    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 project config")
+    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

mozbridge_cli-0.5.0/src/mozbridge_cli/cmd_config.py

@@ -0,0 +1,110 @@
+"""`mozbridge config` sub-typer — set / get one key on the linked project's config.
+
+Same wrapping pattern as cmd_env.py/cmd_registry.py: this is a thin CLI layer
+over a real, already-shipped backend feature — `PUT /api/v1/projects/{id}`
+(backend/app/features/projects/router.py's `update_project`), which merges
+`{"config": {key: value}}` into the project's existing config rather than
+replacing it, and rejects any key not on schemas.PROJECT_CONFIG_ALLOWLIST
+with a 400.
+
+Deliberately does NOT duplicate that allowlist here. The backend is the
+single source of truth for what's valid; this CLI just surfaces whatever
+400 it returns, same posture as the rest of this CLI not re-validating
+what a real endpoint already validates server-side.
+
+Deliberately no `config list` / `config unset`: the backend has no
+delete-a-single-config-key operation for arbitrary config (unlike `env`,
+which has a real DELETE route), so there is nothing for either to wrap.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+import typer
+
+from . import api
+from .cmd_shared import require_link_and_session
+
+app = typer.Typer(
+    name="config",
+    help="Manage the linked project's config (set, get).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+@app.command("set")
+def config_set_cmd(
+    key: str = typer.Argument(..., help="Config key (must be on the backend's allowlist)."),
+    value: str = typer.Argument(..., help="Config value."),
+) -> None:
+    """Set one key on the linked project's config.
+
+    Requires `mozbridge link` and an active login session, same as `env
+    set`. The real endpoint (PUT .../projects/{id}) merges this key into
+    the project's existing config — it never touches any other key — and
+    rejects a key that isn't on the backend's config allowlist with a 400
+    surfaced here verbatim (e.g. "Unknown or privileged config keys
+    rejected: <key>").
+
+    The confirmation reads the value back off the response's `config` dict
+    rather than echoing what was typed, so it reflects what the backend
+    actually stored.
+    """
+    cwd = Path.cwd()
+
+    with httpx.Client(timeout=30.0) as client:
+        current_link, active_session = require_link_and_session(client, cwd)
+
+        try:
+            project = api.set_project_config(
+                client,
+                active_session.access_token,
+                current_link.org_id,
+                current_link.project_id,
+                key,
+                value,
+            )
+        except api.ApiError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1)
+
+    stored_value = (project.get("config") or {}).get(key)
+    typer.echo(f"Set {key} = {stored_value}")
+
+
+@app.command("get")
+def config_get_cmd(
+    key: str = typer.Argument(..., help="Config key to read."),
+) -> None:
+    """Print the current value of one key on the linked project's config.
+
+    Requires `mozbridge link` and an active login session. This is a
+    mirror of reality, not a gatekeeper: it does NOT validate `key`
+    against the backend's config allowlist, so it will happily print a
+    key that isn't (or is no longer) allowlisted, e.g. a value left over
+    from before a key was removed from it. A key that is absent from the
+    project's config prints a clear "not set" message, never a raw
+    `None`/`null`.
+    """
+    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)
+
+    project_config = project.get("config") or {}
+    if key not in project_config:
+        typer.echo(f"{key} is not set.")
+        return
+
+    typer.echo(f"{key} = {project_config[key]}")

{mozbridge_cli-0.4.0 → mozbridge_cli-0.5.0}/src/mozbridge_cli/main.py

@@ -1,22 +1,22 @@
 """Mozbridge CLI: login / whoami / logout / link / build / publish / diff / status /
-deploy / rollback / logs / env / registry / secrets / token / doctor.
+deploy / rollback / logs / env / registry / secrets / config / token / doctor.
 
 macOS-only for v1 (no Windows code paths).
 
 This module is a thin composition root: the root Typer `app` is assembled
 from the command modules below, each of which owns one feature area's
 command definitions (see cmd_auth.py, cmd_projects.py, cmd_publish.py,
-cmd_deploy.py, cmd_env.py, cmd_registry.py, cmd_secrets.py, cmd_token.py,
-cmd_doctor.py).
+cmd_deploy.py, cmd_env.py, cmd_registry.py, cmd_secrets.py, cmd_config.py,
+cmd_token.py, cmd_doctor.py).
 `app.add_typer(<module>.app)`, called with no explicit `name`, merges a
 nameless sub-Typer's commands flatly into `app` (confirmed against Typer's
 real behavior — see cmd_*.py's own module-level Typer() calls, none of
 which pass `name=` except cmd_env's/cmd_registry's/cmd_secrets's/
-cmd_token's, which is why `env`/`registry`/`secrets`/`token` stay nested
-command groups while `doctor` — a single flat command, same shape as
-`login`/`whoami`/`logout` — merges directly into `app`). `from
-mozbridge_cli.main import app` continues to expose every command exactly as
-before.
+cmd_config's/cmd_token's, which is why `env`/`registry`/`secrets`/
+`config`/`token` stay nested command groups while `doctor` — a single flat
+command, same shape as `login`/`whoami`/`logout` — merges directly into
+`app`). `from mozbridge_cli.main import app` continues to expose every
+command exactly as before.
 """
 
 from __future__ import annotations
@@ -25,6 +25,7 @@ import typer
 
 from . import (
     cmd_auth,
+    cmd_config,
     cmd_deploy,
     cmd_doctor,
     cmd_env,
@@ -39,7 +40,7 @@ app = typer.Typer(
     name="mozbridge",
     help=(
         "Mozbridge platform CLI: login, whoami, logout, link, build, publish, diff, "
-        "status, deploy, rollback, logs, env, registry, secrets, token, doctor."
+        "status, deploy, rollback, logs, env, registry, secrets, config, token, doctor."
     ),
     no_args_is_help=True,
     add_completion=False,
@@ -52,6 +53,7 @@ app.add_typer(cmd_deploy.app)
 app.add_typer(cmd_env.app, name="env")
 app.add_typer(cmd_registry.app, name="registry")
 app.add_typer(cmd_secrets.app, name="secrets")
+app.add_typer(cmd_config.app, name="config")
 app.add_typer(cmd_token.app, name="token")
 app.add_typer(cmd_doctor.app)
 

mozbridge_cli-0.5.0/tests/test_config.py

@@ -0,0 +1,244 @@
+import json
+import time
+
+import httpx
+import respx
+from typer.testing import CliRunner
+
+from mozbridge_cli import config, session
+from mozbridge_cli.link import Link, save_link
+from mozbridge_cli.main import app
+
+runner = CliRunner()
+
+
+def _seed_session():
+    s = session.Session(
+        access_token="AT-valid",
+        refresh_token="RT-valid",
+        id_token="IDT",
+        expires_at=time.time() + 3600,
+    )
+    session.save_session(s)
+    return s
+
+
+def _seed_link(cwd):
+    save_link(cwd, Link(org_id=1, org_slug="acme", project_id=10, project_slug="web-app"))
+
+
+# --- config set -------------------------------------------------------
+
+
+def test_config_set_without_link_gives_clear_error(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+
+    result = runner.invoke(app, ["config", "set", "app_compose_file", "compose.custom.yml"])
+
+    assert result.exit_code == 1
+    assert "mozbridge link" in result.output
+
+
+def test_config_set_without_login_gives_clear_error(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_link(tmp_path)
+
+    result = runner.invoke(app, ["config", "set", "app_compose_file", "compose.custom.yml"])
+
+    assert result.exit_code == 1
+    assert "mozbridge login" in result.output
+
+
+def test_config_set_happy_path_puts_correct_body_and_prints_confirmed_value(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        route = respx.put(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "id": 10,
+                    "name": "web-app",
+                    "slug": "web-app",
+                    "status": "active",
+                    "config": {"app_compose_file": "compose.custom.yml"},
+                },
+            )
+        )
+
+        result = runner.invoke(app, ["config", "set", "app_compose_file", "compose.custom.yml"])
+
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert route.calls.last.request.headers["authorization"] == "Bearer AT-valid"
+    assert route.calls.last.request.headers["x-organization-id"] == "1"
+    body = json.loads(route.calls.last.request.content)
+    assert body == {"config": {"app_compose_file": "compose.custom.yml"}}
+
+    assert "app_compose_file" in result.output
+    assert "compose.custom.yml" in result.output
+
+
+def test_config_set_reads_confirmation_back_from_response_not_input(tmp_path, monkeypatch):
+    """If the backend does anything to the value (e.g. trims it), the
+    confirmation must reflect what's actually stored, not what was typed."""
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        respx.put(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(
+                200,
+                json={"id": 10, "config": {"backend_port": "8000"}},
+            )
+        )
+
+        result = runner.invoke(app, ["config", "set", "backend_port", "  8000  "])
+
+    assert result.exit_code == 0, result.output
+    assert "8000" in result.output
+    assert "  8000  " not in result.output
+
+
+def test_config_set_unknown_key_surfaces_backend_detail_message(tmp_path, monkeypatch):
+    """The real PUT endpoint rejects the WHOLE request with a 400 for any key
+    not on schemas.PROJECT_CONFIG_ALLOWLIST — this exact message is the
+    actual useful information and must reach the terminal verbatim."""
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        respx.put(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(
+                400, json={"detail": "Unknown or privileged config keys rejected: totally_made_up_key"}
+            )
+        )
+
+        result = runner.invoke(app, ["config", "set", "totally_made_up_key", "x"])
+
+    assert result.exit_code == 1
+    assert "Unknown or privileged config keys rejected: totally_made_up_key" in result.output
+
+
+def test_config_set_empty_string_value_is_passed_through(tmp_path, monkeypatch):
+    """No client-side special-casing of an empty-string value — matches
+    env set's own posture of not second-guessing values."""
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        route = respx.put(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(200, json={"id": 10, "config": {"backend_command": ""}})
+        )
+
+        result = runner.invoke(app, ["config", "set", "backend_command", ""])
+
+    assert result.exit_code == 0, result.output
+    body = json.loads(route.calls.last.request.content)
+    assert body == {"config": {"backend_command": ""}}
+
+
+# --- config get -------------------------------------------------------
+
+
+def test_config_get_without_link_gives_clear_error(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+
+    result = runner.invoke(app, ["config", "get", "app_compose_file"])
+
+    assert result.exit_code == 1
+    assert "mozbridge link" in result.output
+
+
+def test_config_get_without_login_gives_clear_error(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_link(tmp_path)
+
+    result = runner.invoke(app, ["config", "get", "app_compose_file"])
+
+    assert result.exit_code == 1
+    assert "mozbridge login" in result.output
+
+
+def test_config_get_set_key_prints_its_value(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        route = respx.get(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(
+                200,
+                json={"id": 10, "config": {"app_compose_file": "compose.custom.yml"}},
+            )
+        )
+
+        result = runner.invoke(app, ["config", "get", "app_compose_file"])
+
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert route.calls.last.request.headers["authorization"] == "Bearer AT-valid"
+    assert route.calls.last.request.headers["x-organization-id"] == "1"
+    assert "compose.custom.yml" in result.output
+
+
+def test_config_get_absent_key_prints_not_set_not_none(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        respx.get(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(200, json={"id": 10, "config": {}})
+        )
+
+        result = runner.invoke(app, ["config", "get", "backend_port"])
+
+    assert result.exit_code == 0, result.output
+    assert "not set" in result.output
+    assert "None" not in result.output
+    assert "null" not in result.output
+
+
+def test_config_get_does_not_validate_key_against_any_allowlist(tmp_path, monkeypatch):
+    """A key that's actually present but not (or no longer) on the backend's
+    allowlist is still read and printed — this command mirrors reality, it
+    is not a client-side gatekeeper."""
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        respx.get(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(
+                200, json={"id": 10, "config": {"leftover_unlisted_key": "still-here"}}
+            )
+        )
+
+        result = runner.invoke(app, ["config", "get", "leftover_unlisted_key"])
+
+    assert result.exit_code == 0, result.output
+    assert "still-here" in result.output
+
+
+def test_config_get_api_failure_surfaces_clear_error(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    _seed_session()
+    _seed_link(tmp_path)
+
+    with respx.mock:
+        respx.get(f"{config.API_BASE_URL}{config.PROJECTS_PATH}/10").mock(
+            return_value=httpx.Response(500, json={"detail": "Database temporarily unreachable"})
+        )
+
+        result = runner.invoke(app, ["config", "get", "app_compose_file"])
+
+    assert result.exit_code == 1
+    assert "Database temporarily unreachable" in result.output