keboola-cli 0.63.4__py3-none-any.whl

keboola_agent_cli/server/routers/lineage.py

@@ -0,0 +1,226 @@
+"""Lineage endpoints (cross-project sharing graph + deep column lineage).
+
+The ``/browser`` family mirrors what ``kbagent lineage server`` does as a
+standalone CLI subcommand -- HTML browser + data.json + query API +
+Mermaid renderer -- but mounted into the FastAPI app so the React UI can
+``<iframe>`` it instead of duplicating the rendering logic.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, PlainTextResponse
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/lineage", tags=["lineage"])
+
+
+class LineageBuild(BaseModel):
+    directory: str
+    output: str
+    use_ai: bool = False
+    refresh: bool = False
+
+
+class LineageQuery(BaseModel):
+    load: str
+    upstream: str | None = None
+    downstream: str | None = None
+    project: str | None = None
+    depth: int = 10
+    format: str = "text"
+
+
+@router.get("/edges", summary="List cross-project lineage edges")
+def edges(
+    project: list[str] | None = Query(None),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Cross-project bucket-sharing edges (LineageService)."""
+    return registry.lineage.get_lineage(aliases=project)
+
+
+@router.post("/build", summary="Build deep column-level lineage")
+def build(body: LineageBuild, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Build deep column-level lineage and write JSON cache to ``output``.
+
+    Auto-creates the working directory if missing -- it's empty before the
+    first ``sync pull`` anyway, so 404'ing on absence was just user-hostile.
+    """
+    directory = Path(body.directory).resolve()
+    output = Path(body.output).resolve()
+    try:
+        directory.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Cannot create working directory '{body.directory}': {exc}",
+        ) from exc
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    if body.refresh:
+        registry.sync.pull_all(base_dir=directory)
+    result = registry.deep_lineage.build_lineage(directory, generate_ai_tasks=body.use_ai)
+    try:
+        with output.open("w") as fh:
+            json.dump(result, fh, indent=2)
+    except OSError as exc:
+        raise HTTPException(status_code=500, detail=f"Cannot write '{body.output}': {exc}") from exc
+    # Tag the result with the resolved output path so the React UI can
+    # auto-load it without re-typing.
+    return {**result, "output_path": str(output)}
+
+
+@router.post("/show", summary="Query a built lineage graph")
+def show(body: LineageQuery, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Query a built lineage graph (upstream / downstream walk)."""
+    load_path = Path(body.load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{body.load}' not found.")
+    graph = registry.deep_lineage.load_from_cache(load_path)
+    if body.upstream:
+        return registry.deep_lineage.query_upstream(
+            graph, body.upstream, body.project or "", body.depth
+        )
+    if body.downstream:
+        return registry.deep_lineage.query_downstream(
+            graph, body.downstream, body.project or "", body.depth
+        )
+    raise HTTPException(status_code=400, detail="Provide --upstream or --downstream.")
+
+
+@router.get("/info", summary="Show lineage cache summary")
+def info(
+    load: str = Query(...), registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Return a summary of nodes/edges in a built lineage cache. Mirrors `kbagent lineage info`."""
+    load_path = Path(load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{load}' not found.")
+    graph = registry.deep_lineage.load_from_cache(load_path)
+    return graph.summary()
+
+
+# ── Browser surface ───────────────────────────────────────────────
+# Reuses the HTML template + handler logic from `kbagent lineage server`
+# (commands/lineage.py) so we don't have a second copy of the renderer.
+# The CLI command serves them on a fresh http.server thread; here we
+# re-host them inside FastAPI so the React UI can iframe the result.
+
+
+def _rewrite_browser_html(load_path: str) -> str:
+    """Return the lineage browser HTML with fetch URLs rewritten.
+
+    The original template (from commands/lineage.py) hard-codes
+    ``/data.json`` / ``/api/query`` / ``/api/mermaid`` paths because
+    ``kbagent lineage server`` is the only thing serving the request.
+    Inside FastAPI we live under ``/lineage/...`` and the BFF proxies
+    that under ``/api/lineage/...`` for the browser. Rewrite the three
+    fetch endpoints so the same HTML works inside an iframe.
+
+    The ``load`` query param is baked into every rewritten URL so the
+    browser never has to know which JSON cache to read -- one HTML
+    response = one cache file.
+    """
+    from ...commands.lineage import _LINEAGE_HTML_TEMPLATE
+
+    enc = quote(load_path, safe="")
+    return (
+        _LINEAGE_HTML_TEMPLATE
+        # /data.json -> /api/lineage/data?load=...
+        .replace('"/data.json"', f'"/api/lineage/data?load={enc}"')
+        # /api/query?node=X... -> /api/lineage/walk?load=...&node=X...
+        .replace('"/api/query?node="', f'"/api/lineage/walk?load={enc}&node="')
+        # /api/mermaid?node=X... -> /api/lineage/mermaid?load=...&node=X...
+        .replace('"/api/mermaid?node="', f'"/api/lineage/mermaid?load={enc}&node="')
+    )
+
+
+@router.get("/browser", response_class=HTMLResponse, summary="Open lineage browser UI")
+def browser(load: str = Query(...)) -> HTMLResponse:
+    """Serve the interactive lineage browser HTML for a JSON cache file."""
+    load_path = Path(load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{load}' not found.")
+    return HTMLResponse(content=_rewrite_browser_html(load))
+
+
+@router.get("/data", summary="Return raw lineage JSON")
+def data(load: str = Query(...)) -> Any:
+    """Raw lineage JSON, served verbatim from disk for the browser."""
+    load_path = Path(load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{load}' not found.")
+    try:
+        raw = load_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise HTTPException(status_code=500, detail=f"Cannot read '{load}': {exc}") from exc
+    # Hand the parsed dict back so FastAPI sets the right content-type and
+    # the browser fetch().json() call works without surprises.
+    return json.loads(raw)
+
+
+@router.get("/walk", summary="Walk lineage graph from a node")
+def walk(
+    load: str = Query(...),
+    node: str = Query(...),
+    direction: str = Query("downstream"),
+    depth: int = Query(3, ge=1, le=20),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Walk the lineage graph upstream / downstream from a node FQN.
+
+    Used by the in-browser query bar (``/api/query`` in the standalone
+    server). Mirrors the CLI ``lineage show`` semantics but is GET-only
+    so the HTML's ``fetch()`` calls work without preflight.
+    """
+    load_path = Path(load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{load}' not found.")
+    graph = registry.deep_lineage.load_from_cache(load_path)
+    if direction == "upstream":
+        return registry.deep_lineage.query_upstream(graph, node, "", depth)
+    return registry.deep_lineage.query_downstream(graph, node, "", depth)
+
+
+@router.get("/mermaid", response_class=PlainTextResponse, summary="Render lineage as Mermaid")
+def mermaid(
+    load: str = Query(...),
+    node: str = Query(...),
+    direction: str = Query("downstream"),
+    depth: int = Query(3, ge=1, le=20),
+    view: str = Query("flow"),
+    columns: str = Query("false"),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> PlainTextResponse:
+    """Return a Mermaid diagram for the requested upstream/downstream walk."""
+    from ...services.deep_lineage_service import DeepLineageService
+
+    load_path = Path(load)
+    if not load_path.exists():
+        raise HTTPException(status_code=400, detail=f"Lineage cache '{load}' not found.")
+    graph = registry.deep_lineage.load_from_cache(load_path)
+
+    if direction == "upstream":
+        result = registry.deep_lineage.query_upstream(graph, node, "", depth)
+    else:
+        result = registry.deep_lineage.query_downstream(graph, node, "", depth)
+
+    if "error" in result:
+        return PlainTextResponse("graph LR\n  error[" + result["error"].replace('"', "'") + "]")
+    edges = result.get("edges", [])
+    show_cols = columns == "true"
+    if view == "er":
+        code = DeepLineageService.render_er_diagram(edges, graph, node, show_columns=show_cols)
+    else:
+        code = DeepLineageService.render_mermaid(
+            edges, graph, direction, node, show_columns=show_cols
+        )
+    return PlainTextResponse(code)

keboola_agent_cli/server/routers/mcp.py

@@ -0,0 +1,70 @@
+"""MCP tool endpoints (list, call across projects)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/mcp", tags=["mcp"])
+
+
+class ToolCall(BaseModel):
+    input: dict[str, Any] | None = None
+    project: str | None = None
+    branch_id: str | None = None
+
+
+@router.get("/tools", summary="List MCP tools")
+def list_tools(
+    project: str | None = None,
+    branch_id: str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Discover every MCP tool exposed by `keboola-mcp-server` for one or
+    all projects. Omit `project` to fan out across every registered alias.
+    """
+    aliases = [project] if project else None
+    return registry.mcp.list_tools(aliases=aliases, branch_id=branch_id)
+
+
+@router.get("/tools/{tool_name}/schema", summary="Fetch a tool's input schema")
+def tool_schema(
+    tool_name: str,
+    project: str | None = None,
+    branch_id: str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """JSON Schema for one MCP tool's `input` -- useful when wiring a form
+    or pre-validating before `POST /mcp/tools/{name}/call`.
+    """
+    aliases = [project] if project else None
+    schema = registry.mcp.get_tool_schema(tool_name=tool_name, aliases=aliases, branch_id=branch_id)
+    return {"tool": tool_name, "input_schema": schema or {}}
+
+
+@router.post("/tools/{tool_name}/call", summary="Call an MCP tool")
+def call_tool(
+    tool_name: str, body: ToolCall, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Invoke one MCP tool. Input is validated against the tool's schema
+    server-side before the MCP subprocess is spawned, so obvious mistakes
+    fail fast with a 4xx instead of a cryptic MCP error.
+    """
+    return registry.mcp.validate_and_call_tool(
+        tool_name=tool_name,
+        tool_input=body.input,
+        alias=body.project,
+        branch_id=body.branch_id,
+    )
+
+
+@router.get("/server-status", summary="Check MCP server availability")
+def server_status(registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Whether the bundled `keboola-mcp-server` subprocess is reachable
+    (HTTP transport or stdio fallback, depending on env vars).
+    """
+    return registry.mcp.check_server_available()

keboola_agent_cli/server/routers/members.py

@@ -0,0 +1,170 @@
+"""Project members endpoints (invite/list/remove/role) -- all require manage token."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, is_dataclass
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_manage_token, get_registry
+
+router = APIRouter(prefix="/members", tags=["members"])
+
+# Member endpoints all hit the Manage API, so every operation needs the
+# per-request Manage token alongside the standard bearer token. Declaring
+# the joint requirement here surfaces it as a separate scheme in the
+# Swagger UI "Authorize" dialog.
+_NEEDS_MANAGE_TOKEN: dict[str, Any] = {"security": [{"BearerAuth": [], "ManageToken": []}]}
+
+
+class InviteOne(BaseModel):
+    email: str
+    role: str
+    reason: str | None = None
+    dry_run: bool = False
+
+
+class CancelInvitation(BaseModel):
+    email: str
+    invitation_id: int | None = None
+
+
+class RemoveMember(BaseModel):
+    email: str
+
+
+class SetRole(BaseModel):
+    email: str
+    role: str
+
+
+def _require_manage(token: str | None) -> str:
+    if not token:
+        raise HTTPException(status_code=401, detail="Missing X-Manage-Token header.")
+    return token
+
+
+def _serialize(value: Any) -> Any:
+    if is_dataclass(value):
+        return asdict(value)
+    return value
+
+
+@router.get("/{project}", summary="List members", openapi_extra=_NEEDS_MANAGE_TOKEN)
+def list_members(
+    project: str,
+    include_pending: bool = False,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Active members of `project`. Pass `include_pending=true` to also include
+    invitations that have not yet been accepted. Mirrors
+    `kbagent project member-list`.
+    """
+    return registry.member.list_members(
+        manage_token=_require_manage(manage_token),
+        alias=project,
+        include_pending=include_pending,
+    )
+
+
+@router.get(
+    "/{project}/invitations",
+    summary="List pending invitations",
+    openapi_extra=_NEEDS_MANAGE_TOKEN,
+)
+def list_invitations(
+    project: str,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Outstanding invitations for `project`. Mirrors
+    `kbagent project invitation-list`.
+    """
+    return registry.member.list_invitations(
+        manage_token=_require_manage(manage_token), alias=project
+    )
+
+
+@router.post("/{project}/invite", summary="Invite a single user", openapi_extra=_NEEDS_MANAGE_TOKEN)
+def invite(
+    project: str,
+    body: InviteOne,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Send a single invitation. Pass `dry_run=true` to validate without
+    actually sending. Mirrors `kbagent project invite --email --role`.
+    """
+    return registry.member.invite(
+        manage_token=_require_manage(manage_token),
+        alias=project,
+        email=body.email,
+        role=body.role,
+        reason=body.reason,
+        dry_run=body.dry_run,
+    )
+
+
+@router.post(
+    "/{project}/invitations/cancel",
+    summary="Cancel invitation",
+    openapi_extra=_NEEDS_MANAGE_TOKEN,
+)
+def cancel_invitation(
+    project: str,
+    body: CancelInvitation,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Revoke an outstanding invitation. Identified by email (the API picks
+    the right invitation), or pin a specific `invitation_id`. Mirrors
+    `kbagent project invitation-cancel`.
+    """
+    return registry.member.cancel_invitation(
+        manage_token=_require_manage(manage_token),
+        alias=project,
+        email=body.email,
+        invitation_id=body.invitation_id,
+    )
+
+
+@router.post("/{project}/remove", summary="Remove member", openapi_extra=_NEEDS_MANAGE_TOKEN)
+def remove(
+    project: str,
+    body: RemoveMember,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Revoke a user's access to the project. Mirrors
+    `kbagent project member-remove`.
+    """
+    return registry.member.remove_member(
+        manage_token=_require_manage(manage_token),
+        alias=project,
+        email=body.email,
+    )
+
+
+@router.post(
+    "/{project}/set-role",
+    summary="Change member role",
+    openapi_extra=_NEEDS_MANAGE_TOKEN,
+)
+def set_role(
+    project: str,
+    body: SetRole,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Promote / demote a member. Role is one of `admin`, `guest`,
+    `readOnly`, `share`. Mirrors `kbagent project member-set-role`.
+    """
+    return registry.member.set_member_role(
+        manage_token=_require_manage(manage_token),
+        alias=project,
+        email=body.email,
+        role=body.role,
+    )

keboola_agent_cli/server/routers/org.py

@@ -0,0 +1,96 @@
+"""Organization bulk-onboarding endpoints (require manage token)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_manage_token, get_registry
+
+router = APIRouter(prefix="/org", tags=["org"])
+
+# Every endpoint in this router requires BOTH the standard bearer token AND
+# the per-request Manage API token. Declaring it here means Swagger UI's
+# "Authorize" dialog will list both schemes so users can paste each one
+# once instead of guessing why a request 401s.
+_NEEDS_MANAGE_TOKEN: dict[str, Any] = {"security": [{"BearerAuth": [], "ManageToken": []}]}
+
+
+class OrgSetup(BaseModel):
+    stack_url: str
+    org_id: int | None = None
+    project_ids: list[int] | None = None
+    token_description: str = "kbagent"
+    dry_run: bool = False
+    token_expires_in: int | None = None
+
+
+class OrgRefresh(BaseModel):
+    aliases: list[str] | None = None
+    refresh_all: bool = False
+    token_description: str = "kbagent"
+    dry_run: bool = False
+    force: bool = False
+    token_expires_in: int | None = None
+
+
+@router.post("/setup", summary="Onboard org / project list", openapi_extra=_NEEDS_MANAGE_TOKEN)
+def setup(
+    body: OrgSetup,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Bulk-register every project in an organization (or a fixed project ID list).
+
+    Issues a fresh storage token per project via the Manage API and persists
+    each project under a slug-style alias. Idempotent: existing aliases that
+    already point at the same project ID are skipped. Mirrors
+    `kbagent org setup`.
+    """
+    if not manage_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing X-Manage-Token header. Org setup requires a manage token.",
+        )
+    return registry.org.setup_organization(
+        stack_url=body.stack_url,
+        manage_token=manage_token,
+        org_id=body.org_id,
+        token_description=body.token_description,
+        dry_run=body.dry_run,
+        token_expires_in=body.token_expires_in,
+        project_ids=body.project_ids,
+    )
+
+
+@router.post("/refresh", summary="Re-issue storage tokens", openapi_extra=_NEEDS_MANAGE_TOKEN)
+def refresh(
+    body: OrgRefresh,
+    manage_token: str | None = Depends(get_manage_token),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Refresh the storage token for one alias, several aliases, or every project.
+
+    Useful after rotating a Manage API token or when a per-project token is
+    near expiry. Pass `refresh_all=true` to refresh every persisted alias,
+    or a list of aliases to scope the refresh. Mirrors
+    `kbagent project refresh --project` and `kbagent project refresh --all`.
+    """
+    if not manage_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing X-Manage-Token header. Refresh requires a manage token.",
+        )
+    # Service has no refresh_all param: pass aliases=None to refresh all,
+    # or aliases=body.aliases to scope the refresh.
+    effective_aliases = None if body.refresh_all else body.aliases
+    return registry.org.refresh_tokens(
+        manage_token=manage_token,
+        aliases=effective_aliases,
+        token_description=body.token_description,
+        dry_run=body.dry_run,
+        force=body.force,
+        token_expires_in=body.token_expires_in,
+    )

keboola_agent_cli/server/routers/projects.py

@@ -0,0 +1,106 @@
+"""Project CRUD + status endpoints."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/projects", tags=["projects"])
+
+
+class ProjectCreate(BaseModel):
+    alias: str
+    stack_url: str
+    token: str
+
+
+class ProjectEdit(BaseModel):
+    stack_url: str | None = None
+    token: str | None = None
+    new_alias: str | None = None
+    dry_run: bool = False
+
+
+class ProjectDescription(BaseModel):
+    description: str
+
+
+@router.get("", summary="List registered projects")
+def list_projects(registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """All registered project aliases."""
+    return {"projects": registry.project.list_projects()}
+
+
+@router.post("", summary="Add a project")
+def add_project(
+    body: ProjectCreate, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Add a project. Verifies the storage token before persisting."""
+    return registry.project.add_project(body.alias, body.stack_url, body.token)
+
+
+@router.delete("/{alias}", summary="Remove a project")
+def remove_project(alias: str, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Remove a project by alias. Mirrors `kbagent project remove`."""
+    return registry.project.remove_project(alias)
+
+
+@router.patch("/{alias}", summary="Edit a project")
+def edit_project(
+    alias: str, body: ProjectEdit, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Update stack URL, token, or alias of a project. Mirrors `kbagent project edit`."""
+    return registry.project.edit_project(
+        alias=alias,
+        stack_url=body.stack_url,
+        token=body.token,
+        new_alias=body.new_alias,
+        dry_run=body.dry_run,
+    )
+
+
+@router.get("/status", summary="Check project connectivity")
+def status(
+    alias: str | None = None, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Connectivity check; pass ``?alias=`` to limit to one project."""
+    aliases = [alias] if alias else None
+    return {"status": registry.project.get_status(aliases=aliases)}
+
+
+@router.get("/current", summary="Get the active project")
+def current(registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Currently pinned project alias. Mirrors `kbagent project current`."""
+    return registry.project.current_project()
+
+
+@router.post("/use/{alias}", summary="Switch the active project")
+def use_project(alias: str, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Pin a project as the current default. Mirrors `kbagent project use`."""
+    return registry.project.use_project(alias)
+
+
+@router.get("/{alias}/info", summary="Get project metadata")
+def info(alias: str, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Project metadata (stack, owner, tokens). Mirrors `kbagent project info`."""
+    return registry.project.get_info(alias)
+
+
+@router.get("/{alias}/description", summary="Get the project description")
+def get_description(
+    alias: str, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    return registry.branch.get_project_description(alias)
+
+
+@router.put("/{alias}/description", summary="Set the project description")
+def set_description(
+    alias: str,
+    body: ProjectDescription,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    return registry.branch.set_project_description(alias, body.description)