uro-cli 0.2.0__tar.gz → 0.5.0__tar.gz

{uro_cli-0.2.0 → uro_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: uro-cli
-Version: 0.2.0
+Version: 0.5.0
 Summary: Uro Engine reference client — play, dry-run, and dev tools against the engine
 Project-URL: Homepage, https://github.com/cupskeee/uro
 Project-URL: Repository, https://github.com/cupskeee/uro
@@ -9,10 +9,11 @@ Author: cupskeee
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.12
+Requires-Dist: python-dotenv>=1.0
 Requires-Dist: rich>=13.9
-Requires-Dist: typer>=0.15
-Requires-Dist: uro-core[llm,postgres]==0.2.0
-Requires-Dist: uro-server==0.2.0
+Requires-Dist: typer>=0.27.2
+Requires-Dist: uro-core[llm,postgres]==0.5.0
+Requires-Dist: uro-server==0.5.0
 Requires-Dist: websockets>=16.1
 Description-Content-Type: text/markdown
 

{uro_cli-0.2.0 → uro_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uro-cli"
-version = "0.2.0"
+version = "0.5.0"
 description = "Uro Engine reference client — play, dry-run, and dev tools against the engine"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -13,11 +13,12 @@ requires-python = ">=3.12"
 # pair a new uro-cli with an old uro-core; `just release` bumps all three together, and the
 # `{workspace = true}` sources make a drifted pin fail `uv sync` locally.
 dependencies = [
-    "uro-core[postgres,llm]==0.2.0",
-    "uro-server==0.2.0",
-    "typer>=0.15",
+    "uro-core[postgres,llm]==0.5.0",
+    "uro-server==0.5.0",
+    "typer>=0.27.2",
     "rich>=13.9",
     "websockets>=16.1",
+    "python-dotenv>=1.0",
 ]
 
 [project.urls]

uro_cli-0.5.0/tests/test_cli_scaffold.py

@@ -0,0 +1,89 @@
+from typer.testing import CliRunner
+from uro_cli.main import app
+
+
+def test_cli_version_runs() -> None:
+    result = CliRunner().invoke(app, ["version"])
+    assert result.exit_code == 0
+    assert "uro-core" in result.output
+
+
+def test_provider_codex_login(monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    """The whole `uro provider codex-login` flow, with codex_auth + the store mocked."""
+    from uro_cli import main
+    from uro_core.providers import codex_auth
+
+    async def dev(**kw: object) -> dict[str, object]:
+        return {
+            "device_auth_id": "d",
+            "user_code": "J7DE-8NXJS",
+            "verification_uri": "https://auth.openai.com/codex/device",
+            "interval": 0,  # instant poll — no real waiting in the test
+            "expires_in": 10,
+        }
+
+    async def poll(dev_id: str, code: str, **kw: object) -> dict[str, str]:
+        return {"authorization_code": "AC", "code_verifier": "V"}
+
+    async def exch(code: str, verifier: str, **kw: object) -> dict[str, str]:
+        return {"access_token": "AT", "refresh_token": "RT"}
+
+    async def disc(token: str, **kw: object) -> list[dict[str, str]]:
+        return [{"id": "gpt-5-codex", "modality": "chat"}]
+
+    monkeypatch.setattr(codex_auth, "request_device_code", dev)
+    monkeypatch.setattr(codex_auth, "poll_device_auth", poll)
+    monkeypatch.setattr(codex_auth, "exchange_code", exch)
+    monkeypatch.setattr(codex_auth, "discover_codex_models", disc)
+
+    class _Store:
+        async def add_credential(self, **kw: object) -> str:
+            assert kw["auth_mode"] == "oauth_device" and kw["provider"] == "codex"
+            return "cred-1"
+
+        async def add_connection(self, **kw: object) -> str:
+            return "conn-1"
+
+        async def set_connection_models(self, cid: str, models: object) -> bool:
+            return True
+
+        async def close(self) -> None:
+            pass
+
+    async def _noop(store: object) -> None:
+        return None
+
+    monkeypatch.setattr(main, "build_store", lambda: _Store())
+    monkeypatch.setattr(main, "connect_store", _noop)
+
+    result = CliRunner().invoke(app, ["provider", "codex-login", "--no-browser"])
+    assert result.exit_code == 0, result.output
+    assert "J7DE-8NXJS" in result.output  # the displayed device code
+    assert "connected: conn-1" in result.output
+    assert "gpt-5-codex" in result.output  # discovered model listed
+
+
+def test_provider_bind_rejects_a_chat_model_for_the_embedder(monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    """CLI parity with the server's embedder-modality guard (review): a chat model (codex is always
+    chat) can't back the embedder role."""
+    from uro_cli import main
+    from uro_core.ports.model_registry import ModelConnection
+
+    class _Store:
+        async def get_connection(self, cid: str) -> ModelConnection:
+            return ModelConnection(id=cid, name="cx", provider="codex", auth_id="a1")
+
+        async def set_role_binding(self, *a: object, **kw: object) -> None:
+            raise AssertionError("should not bind — the guard must reject first")
+
+        async def close(self) -> None:
+            pass
+
+    async def _noop(store: object) -> None:
+        return None
+
+    monkeypatch.setattr(main, "build_store", lambda: _Store())
+    monkeypatch.setattr(main, "connect_store", _noop)
+    result = CliRunner().invoke(app, ["provider", "bind", "embedder", "conn-1", "gpt-5-codex"])
+    assert result.exit_code == 1
+    assert "embedding model" in result.output

uro_cli-0.5.0/tests/test_registry_router.py

@@ -0,0 +1,123 @@
+"""D-47 (docs/20): `build_router_from_registry` resolves DB model-connection registry rows into a
+ProviderRouter. The resolution logic is pure, so it's tested against an in-memory fake registry (no
+DB) — the DB CRUD/crypto themselves live in uro-core's test_model_registry.py.
+"""
+
+import pytest
+from uro_cli.wiring import build_router_from_registry
+from uro_core.ports.model_registry import ModelConnection, RoleBinding
+from uro_core.providers.adapters.anthropic import AnthropicProvider
+from uro_core.providers.adapters.openai_compat import OpenAICompatProvider
+from uro_core.providers.adapters.stub import StubProvider
+
+
+class FakeRegistry:
+    """The subset of the ModelRegistry port that build_router_from_registry actually calls."""
+
+    def __init__(self, connections=None, bindings=None, secrets=None):  # type: ignore[no-untyped-def]
+        self._connections = connections or []
+        self._bindings = bindings or []
+        self._secrets = secrets or {}
+
+    async def list_role_bindings(self):  # type: ignore[no-untyped-def]
+        return self._bindings
+
+    async def list_connections(self):  # type: ignore[no-untyped-def]
+        return self._connections
+
+    async def get_secret(self, credential_id):  # type: ignore[no-untyped-def]
+        return self._secrets.get(credential_id)
+
+
+async def test_empty_registry_returns_none() -> None:
+    # No bindings → None, so `serve` falls back to the --provider/uro.toml seed.
+    assert await build_router_from_registry(FakeRegistry()) is None
+
+
+async def test_resolves_roles_with_default_fallback() -> None:
+    conn = ModelConnection(id="c1", name="stub", provider="stub")
+    reg = FakeRegistry(
+        connections=[conn],
+        bindings=[
+            RoleBinding(role="default", connection_id="c1", model="stub"),
+            RoleBinding(role="narrator", connection_id="c1", model="stub"),
+        ],
+    )
+    router = await build_router_from_registry(reg)
+    assert router is not None
+    assert isinstance(router._provider_for("narrator"), StubProvider)  # explicitly bound
+    assert isinstance(router._provider_for("judge"), StubProvider)  # unbound → the default binding
+
+
+async def test_disabled_or_missing_connection_is_skipped() -> None:
+    reg = FakeRegistry(
+        connections=[
+            ModelConnection(id="c1", name="def", provider="stub"),
+            ModelConnection(id="c2", name="off", provider="stub", is_enabled=False),
+        ],
+        bindings=[
+            RoleBinding(role="default", connection_id="c1", model="stub"),
+            RoleBinding(role="narrator", connection_id="c2", model="stub"),  # disabled → skip
+            RoleBinding(role="planner", connection_id="ghost", model="stub"),  # missing → skip
+        ],
+    )
+    router = await build_router_from_registry(reg)
+    assert router is not None
+    # Both skipped roles fall through to the enabled default.
+    assert router._provider_for("narrator") is router._provider_for("judge")
+    assert router._provider_for("planner") is router._provider_for("judge")
+
+
+async def test_builds_providers_with_decrypted_creds_and_base_url() -> None:
+    reg = FakeRegistry(
+        connections=[
+            ModelConnection(id="c1", name="oai", provider="openai", auth_id="k1"),
+            ModelConnection(
+                id="c2", name="ant", provider="anthropic", auth_id="k2", base_url="https://proxy"
+            ),
+        ],
+        bindings=[
+            RoleBinding(role="default", connection_id="c1", model="gpt-4o"),
+            RoleBinding(role="dialogue", connection_id="c2", model="claude-sonnet-5"),
+        ],
+        secrets={"k1": ("sk-oai", None), "k2": ("sk-ant", None)},
+    )
+    router = await build_router_from_registry(reg)
+    assert router is not None
+    oai = router._provider_for("default")
+    ant = router._provider_for("dialogue")
+    assert isinstance(oai, OpenAICompatProvider)
+    assert oai._api_key == "sk-oai" and oai._model == "gpt-4o"  # decrypted key injected
+    assert isinstance(ant, AnthropicProvider)
+    assert ant._api_key == "sk-ant" and ant._base_url == "https://proxy"  # per-connection override
+
+
+async def test_openai_compat_without_base_url_is_an_error() -> None:
+    reg = FakeRegistry(
+        connections=[ModelConnection(id="c1", name="compat", provider="openai_compat")],
+        bindings=[RoleBinding(role="default", connection_id="c1", model="m")],
+    )
+    with pytest.raises(ValueError):
+        await build_router_from_registry(reg)
+
+
+async def test_bindings_without_default_is_refused() -> None:
+    # A role bound but no `default` → any unbound role would KeyError mid-beat; refuse at build.
+    reg = FakeRegistry(
+        connections=[ModelConnection(id="c1", name="stub", provider="stub")],
+        bindings=[RoleBinding(role="narrator", connection_id="c1", model="stub")],
+    )
+    with pytest.raises(ValueError):
+        await build_router_from_registry(reg)
+
+
+async def test_all_roles_bound_without_default_is_ok() -> None:
+    # Every non-default role bound → no default needed → a valid router (no crash path).
+    roles = ["narrator", "extractor", "planner", "embedder", "dialogue", "judge"]
+    reg = FakeRegistry(
+        connections=[ModelConnection(id="c1", name="stub", provider="stub")],
+        bindings=[RoleBinding(role=r, connection_id="c1", model="stub") for r in roles],
+    )
+    router = await build_router_from_registry(reg)
+    assert router is not None
+    assert isinstance(router._provider_for("narrator"), StubProvider)

{uro_cli-0.2.0 → uro_cli-0.5.0}/uro_cli/main.py

@@ -6,25 +6,38 @@ Phase 0 subset: version, db migrate, world new, play.
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import sys
+import time
+import webbrowser
 from typing import Any
 
 import typer
+from dotenv import find_dotenv, load_dotenv
 from uro_core.adapters.postgres.store import PostgresEventStore
 from uro_core.pipeline.engine import Engine
+from uro_core.ports.model_registry import ROLES
+from uro_core.providers.router import ProviderRouter
 from uro_core.rulesets.base import CharSpec
 from uro_core.rulesets.rng import Rng
 from uro_core.timeline.models import World
 
 from uro_cli.wiring import (
-    DatabaseUnavailable,
     build_router,
+    build_router_from_registry,
     build_ruleset,
     build_store,
     connect_store,
     parse_role_models,
 )
 
+# Load a local `.env` (found from the CURRENT WORKING DIR, walking up) into the environment before
+# any command reads it — so `URO_SECRET_KEY` / provider keys / `URO_DATABASE_URL` need only live in
+# `.env`, not be exported by hand. `usecwd=True` so it finds the `.env` where you RUN `uro`, not the
+# installed package dir. Precedence preserved: an exported env var wins (dotenv never overrides). No
+# `.env` → find_dotenv returns "" → a harmless no-op.
+load_dotenv(find_dotenv(usecwd=True))
+
 app = typer.Typer(no_args_is_help=True, help="Uro Engine — reference client.")
 db_app = typer.Typer(no_args_is_help=True, help="Database management.")
 world_app = typer.Typer(no_args_is_help=True, help="World and campaign management.")
@@ -36,12 +49,25 @@ codex_app = typer.Typer(
 token_app = typer.Typer(
     no_args_is_help=True, help="Runtime session tokens against a running server (docs/18 B10)."
 )
+provider_app = typer.Typer(
+    no_args_is_help=True,
+    help="Model connections — the DB-backed LLM provider registry (D-47, docs/20).",
+)
+outbox_app = typer.Typer(
+    no_args_is_help=True,
+    help="The transactional outbox — publish committed beats to other processes (D-57).",
+)
 app.add_typer(db_app, name="db")
 app.add_typer(world_app, name="world")
 app.add_typer(branch_app, name="branch")
 app.add_typer(campaign_app, name="campaign")
 app.add_typer(codex_app, name="codex")
 app.add_typer(token_app, name="token")
+app.add_typer(provider_app, name="provider")
+app.add_typer(outbox_app, name="outbox")
+
+# The engine roles a connection can back (resolved by the ProviderRouter) — shared with the server.
+_ROLES = tuple(sorted(ROLES))
 
 PARTICIPANT = "player-1"  # Phase 0 is single-player; participants arrive in Phase 5.
 
@@ -55,6 +81,25 @@ def _run_async(coro_factory) -> None:  # type: ignore[no-untyped-def]
         raise typer.Exit(1) from exc
 
 
+def _resolve_router(store: PostgresEventStore, provider: str, model: str | None):  # type: ignore[no-untyped-def]
+    """Resolve the ProviderRouter for `serve`: the DB model-connection registry (D-47) wins if it
+    has usable bindings, else the `--provider`/`uro.toml` seed. This first DB touch also serves as
+    the preflight. Returns (router, source_label). Raises DatabaseUnavailable if the DB is down and
+    RuntimeError/ValueError if a CONFIGURED registry can't be built (bad KEK, missing key)."""
+
+    async def _read() -> ProviderRouter | None:
+        await connect_store(store)
+        try:
+            return await build_router_from_registry(store)
+        finally:
+            await store.close()
+
+    registry_router = asyncio.run(_read())
+    if registry_router is not None:
+        return registry_router, "DB model-connection registry (D-47)"
+    return build_router(provider, model), f"seed (provider={provider})"
+
+
 async def _world_or_exit(store: PostgresEventStore, ident: str) -> World:
     """Resolve a world by name (preferred) or id, or exit 1 with a clean message."""
     world = await store.get_world_by_name(ident) or await store.get_world(ident)
@@ -501,6 +546,14 @@ def serve(
         "(consensus). UNSET = auto (solo for 1 token, party for >1). Setting it EXPLICITLY binds "
         "that shape even for a 1-token launch, so a runtime-added player still gets turns (D-39).",
     ),
+    cors_origin: list[str] = typer.Option(  # noqa: B008
+        None,
+        "--cors-origin",
+        help="allow a browser origin to call this server, e.g. --cors-origin http://localhost:5173 "
+        "(repeatable). REQUIRED for the uro-loom web console (a cross-origin SPA); the browser "
+        "blocks calls with no CORS header. Pass '*' to allow any origin (dev only; disables "
+        "credentials). Omit for CLI/embedded use.",
+    ),
 ) -> None:
     """Run the Uro server (docs/08): a thin FastAPI shell over the engine. Each --token maps to
     a participant; with no --token, a single 'local' token binds player-1 (the solo dev loop).
@@ -530,7 +583,16 @@ def serve(
         tokens[tok] = name if sep else f"operator-{j + 1}"
         admin_tokens.add(tok)
     store = build_store()
-    engine = Engine(store, build_router(provider, model), ruleset=build_ruleset(ruleset))
+    # Resolve the ProviderRouter: the DB model-connection registry (D-47) wins if it has usable
+    # bindings, else the --provider/uro.toml seed. This first DB touch doubles as the preflight (a
+    # down DB → the clean docker-first hint, not a uvicorn startup traceback). A CONFIGURED-but-
+    # broken registry (bad KEK, missing key) fails LOUDLY rather than silently serving the stub.
+    try:
+        router, llm_source = _resolve_router(store, provider, model)
+    except (RuntimeError, ValueError) as exc:  # incl. DatabaseUnavailable (a RuntimeError subclass)
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    engine = Engine(store, router, ruleset=build_ruleset(ruleset))
     # Pick the turn shape (OQ-7, D-31/D-38/D-39). UNSET (--arbiter not given) is AUTO: solo for one
     # token (the dev loop → SoloArbiter), party for >1. Set EXPLICITLY, the shape binds regardless
     # of launch token count, so a player minted+joined at RUNTIME still gets real turns (D-39)
@@ -548,8 +610,8 @@ def serve(
         )
     else:
         arbiter = shapes[arbiter_kind]()
-    deps = engine_deps(store, engine, tokens, admin_tokens)
-    fastapi_app = create_app(deps, arbiter=arbiter)
+    deps = engine_deps(store, engine, tokens, admin_tokens, router=router)
+    fastapi_app = create_app(deps, arbiter=arbiter, cors_origins=cors_origin or None)
 
     @fastapi_app.on_event("startup")
     async def _startup() -> None:
@@ -561,27 +623,19 @@ def serve(
     async def _shutdown() -> None:
         await store.close()
 
-    # Preflight the DB here so a down database gets the same clean docker-first hint every other
-    # command gives (via connect_store), instead of a uvicorn "Application startup failed"
-    # traceback. The live pool is (re)opened by the startup hook on uvicorn's own event loop — an
-    # asyncpg pool is bound to the loop that created it, so this throwaway probe is closed at once.
-    async def _preflight() -> None:
-        await connect_store(store)
-        await store.close()
-
-    try:
-        asyncio.run(_preflight())
-    except DatabaseUnavailable as exc:
-        typer.echo(f"error: {exc}", err=True)
-        raise typer.Exit(1) from exc
-
+    # (The DB preflight is folded into _resolve_router above — its connect_store gives the same
+    # clean docker-first hint on a down DB, and the pool it opens is closed before uvicorn starts;
+    # the startup hook re-opens one on uvicorn's own loop.)
     shape = type(arbiter).__name__ if arbiter is not None else "solo"
     typer.echo(
         f"uro server on ws://{host}:{port}  "
         f"({len(tokens)} token(s), provider={provider}, arbiter={shape})"
     )
+    typer.echo(f"  LLM: {llm_source}")
     for t, p in tokens.items():
         typer.echo(f"  token {t!r} → {p}")
+    if cors_origin:
+        typer.echo(f"  CORS: allowing {', '.join(cors_origin)}")
     uvicorn.run(fastapi_app, host=host, port=port, log_level="warning")
 
 
@@ -684,6 +738,67 @@ def _server_post(server: str, path: str, token: str, body: dict[str, Any]) -> di
         raise typer.Exit(1) from exc
 
 
+@outbox_app.command("status")
+def outbox_status() -> None:
+    """How many committed beats are waiting to be published."""
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        try:
+            typer.echo(f"pending: {await store.outbox_pending()}")
+        finally:
+            await store.close()
+
+    _run_async(_run)
+
+
+@outbox_app.command("relay")
+def outbox_relay(
+    nats_url: str = typer.Option(..., "--nats", help="NATS server URL, e.g. nats://localhost:4222"),
+    stream: str = typer.Option("URO", help="JetStream stream (created if missing)"),
+    subject_prefix: str = typer.Option("uro", help="subjects are <prefix>.<world>.<branch>"),
+    once: bool = typer.Option(False, "--once", help="drain what is pending, then exit"),
+    interval: float = typer.Option(1.0, help="seconds between polls (without --once)"),
+    batch: int = typer.Option(100, min=1, help="commits claimed per transaction"),
+) -> None:
+    """Publish committed beats to NATS JetStream (D-57). At-least-once from the outbox; JetStream
+    drops a re-sent commit (Nats-Msg-Id = commit id). Run ONE relay to keep each branch in commit
+    order (there is no global order across branches); several are safe — no row is published
+    twice — but may interleave a branch. A publish error is retried with backoff (`--once` exits
+    instead)."""
+    try:
+        from uro_core.adapters.nats import NatsJetStreamPublisher
+    except ImportError as exc:
+        typer.echo("the NATS relay needs `pip install 'uro-core[nats]'`", err=True)
+        raise typer.Exit(1) from exc
+    from uro_core.outbox import relay_forever, relay_outbox
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        publisher = NatsJetStreamPublisher(nats_url, stream=stream, subject_prefix=subject_prefix)
+        await publisher.connect()
+        try:
+            if once:  # a one-shot drain: an error exits non-zero (right for scripts and cron)
+                sent = await relay_outbox(store, publisher, limit=batch)
+                typer.echo(f"published {sent} commit(s)")
+                return
+            # the daemon: a publish error is logged and retried with backoff, never fatal
+            await relay_forever(
+                store,
+                publisher,
+                interval=interval,
+                limit=batch,
+                on_published=lambda n: typer.echo(f"published {n} commit(s)"),
+            )
+        finally:
+            await publisher.close()
+            await store.close()
+
+    _run_async(_run)
+
+
 @token_app.command("mint")
 def token_mint(
     campaign_id: str,
@@ -1088,3 +1203,223 @@ def codex_list(
             typer.echo(f"- {n.text}{tag}")
 
     _run_async(_run)
+
+
+# --- Model-connection registry (D-47, docs/20) — direct-DB config of the LLM provider registry.
+# A server API mirror (for uro-loom / remote clients) lands in the next slice; today these edit the
+# instance's DB directly (operator with DB access), like `uro world`/`uro campaign`.
+
+
+@provider_app.command("add")
+def provider_add(
+    name: str = typer.Argument(..., help="a display label for this connection"),
+    provider: str = typer.Option(
+        ..., "--provider", help="provider kind: openai | anthropic | openai_compat | local | stub"
+    ),
+    base_url: str = typer.Option(None, "--base-url", help="per-connection endpoint override"),
+    api_key: str = typer.Option(
+        None,
+        "--api-key",
+        help="an API key to store ENCRYPTED (needs URO_SECRET_KEY) — creates + links a credential",
+    ),
+    credential: str = typer.Option(
+        None, "--credential", help="reuse an EXISTING credential id instead of --api-key"
+    ),
+) -> None:
+    """Register a model connection (a provider endpoint). With --api-key it also stores an encrypted
+    credential and links it; a keyless provider (local/stub) needs neither."""
+
+    async def _run() -> None:
+        if api_key and credential:
+            raise ValueError("pass either --api-key or --credential, not both")
+        store = build_store()
+        await connect_store(store)
+        try:
+            auth_id: str | None = None
+            if api_key:
+                auth_id = await store.add_credential(provider=provider, access_token=api_key)
+            elif credential:
+                if all(c.id != credential for c in await store.list_credentials()):
+                    raise ValueError(f"no such credential: {credential}")
+                auth_id = credential
+            cid = await store.add_connection(
+                name=name, provider=provider, base_url=base_url or None, auth_id=auth_id
+            )
+        finally:
+            await store.close()
+        typer.echo(f"connection: {cid}  ({name} → {provider})")
+        if auth_id:
+            typer.echo(f"credential: {auth_id}  (encrypted at rest)")
+        # Steer toward binding `default` FIRST — a registry with role bindings but no `default`
+        # is refused at serve/reload (unbound roles would crash a beat; holistic review).
+        typer.echo(f"\nbind the default role:  uro provider bind default {cid} <model>")
+
+    _run_async(_run)
+
+
+@provider_app.command("list")
+def provider_list() -> None:
+    """Show the registry: connections, role bindings, and credential metadata (never secrets)."""
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        try:
+            connections = await store.list_connections()
+            bindings = await store.list_role_bindings()
+            credentials = await store.list_credentials()
+        finally:
+            await store.close()
+        typer.echo("connections:")
+        if not connections:
+            typer.echo("  (none — add one with `uro provider add`)")
+        for c in connections:
+            base = f" @{c.base_url}" if c.base_url else ""
+            auth = f" auth={c.auth_id}" if c.auth_id else " (keyless)"
+            disabled = "" if c.is_enabled else " [disabled]"
+            typer.echo(f"  {c.id}  {c.name} → {c.provider}{base}{auth}{disabled}")
+        typer.echo("role bindings:")
+        if not bindings:
+            typer.echo("  (none — the server falls back to the --provider/uro.toml seed)")
+        for b in bindings:
+            typer.echo(f"  {b.role:<9} → {b.connection_id} : {b.model}")
+        if credentials:
+            typer.echo("credentials:")
+            for cr in credentials:
+                has = "  (access_token set)" if cr.has_access_token else ""
+                typer.echo(f"  {cr.id}  {cr.provider}  {cr.auth_mode}{has}")
+
+    _run_async(_run)
+
+
+@provider_app.command("rm")
+def provider_rm(
+    connection_id: str = typer.Argument(..., help="the connection id to delete"),
+) -> None:
+    """Delete a connection (its role bindings cascade → those roles fall back to `default`)."""
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        try:
+            ok = await store.delete_connection(connection_id)
+        finally:
+            await store.close()
+        typer.echo("deleted" if ok else f"no such connection: {connection_id}")
+
+    _run_async(_run)
+
+
+@provider_app.command("bind")
+def provider_bind(
+    role: str = typer.Argument(..., help=f"one of: {', '.join(_ROLES)}"),
+    connection_id: str = typer.Argument(...),
+    model: str = typer.Argument(..., help="a model id offered by the connection's provider"),
+) -> None:
+    """Bind an engine role to a connection + model. `default` backs any unbound role."""
+
+    async def _run() -> None:
+        from uro_core.providers.registry import classify_modality
+
+        if role not in _ROLES:
+            raise ValueError(f"unknown role {role!r}; one of: {', '.join(_ROLES)}")
+        store = build_store()
+        await connect_store(store)
+        try:
+            conn = await store.get_connection(connection_id)
+            if conn is None:
+                raise ValueError(f"no such connection: {connection_id}")
+            # Match the server's embedder-modality guard (D-47): the embedder needs an EMBEDDING
+            # model, so reject a chat model here too — else the binding fails only at runtime, and a
+            # codex/anthropic model (always "chat") could silently break semantic memory (review).
+            if role == "embedder" and classify_modality(conn.provider, model) == "chat":
+                raise ValueError(
+                    f"the embedder role needs an embedding model, not {model!r} "
+                    f"(a chat model on provider {conn.provider!r})"
+                )
+            await store.set_role_binding(role, connection_id, model)
+        finally:
+            await store.close()
+        typer.echo(f"bound {role} → {connection_id} : {model}")
+
+    _run_async(_run)
+
+
+@provider_app.command("unbind")
+def provider_unbind(role: str = typer.Argument(..., help="the role to unbind")) -> None:
+    """Remove a role binding (that role falls back to `default`)."""
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        try:
+            ok = await store.delete_role_binding(role)
+        finally:
+            await store.close()
+        typer.echo("unbound" if ok else f"no binding for role: {role}")
+
+    _run_async(_run)
+
+
+@provider_app.command("codex-login")
+def provider_codex_login(
+    name: str = typer.Option("codex", "--name", help="a display label for the connection"),
+    no_browser: bool = typer.Option(
+        False, "--no-browser", help="don't try to open the authorization page automatically"
+    ),
+) -> None:
+    """Connect a Codex (ChatGPT-subscription) provider via OpenAI's OAuth device login. Prints a
+    code to enter on the authorization page, then polls until you approve — no API key. UNOFFICIAL:
+    uses a consumer ChatGPT subscription; may breach OpenAI's terms (needs URO_SECRET_KEY)."""
+
+    async def _run() -> None:
+        from uro_core.providers import codex_auth
+
+        try:
+            dc = await codex_auth.request_device_code()
+            typer.echo(f"\n  Enter this code on the OpenAI authorization page:  {dc['user_code']}")
+            typer.echo(f"  Authorization page:  {dc['verification_uri']}\n")
+            if not no_browser:
+                with contextlib.suppress(Exception):  # opening a browser is best-effort
+                    webbrowser.open(dc["verification_uri"])
+            typer.echo("Waiting for you to authorize with OpenAI… (Ctrl-C to cancel)")
+
+            deadline = time.monotonic() + dc["expires_in"]
+            payload = None
+            while time.monotonic() < deadline:
+                await asyncio.sleep(dc["interval"])
+                payload = await codex_auth.poll_device_auth(dc["device_auth_id"], dc["user_code"])
+                if payload is not None:
+                    break
+            if payload is None:
+                raise ValueError("the login timed out before you approved the code — try again")
+            tokens = await codex_auth.exchange_code(
+                payload["authorization_code"], payload["code_verifier"]
+            )
+        except codex_auth.CodexAuthError as exc:
+            raise ValueError(f"codex login failed: {exc}") from exc
+
+        store = build_store()
+        await connect_store(store)
+        try:
+            cred_id = await store.add_credential(
+                provider="codex",
+                access_token=tokens["access_token"],
+                refresh_token=tokens.get("refresh_token"),
+                auth_mode="oauth_device",
+            )
+            conn_id = await store.add_connection(name=name, provider="codex", auth_id=cred_id)
+            models: list[dict[str, str]] = []
+            try:
+                models = await codex_auth.discover_codex_models(tokens["access_token"])
+                await store.set_connection_models(conn_id, models)
+            except Exception:
+                pass
+        finally:
+            await store.close()
+        typer.echo(f"\nconnected: {conn_id}  ({name} → codex)")
+        if models:
+            typer.echo("models: " + ", ".join(m["id"] for m in models))
+        typer.echo(f"\nbind the default role:  uro provider bind default {conn_id} <model>")
+
+    _run_async(_run)

{uro_cli-0.2.0 → uro_cli-0.5.0}/uro_cli/wiring.py

@@ -23,6 +23,7 @@ from uro_core.providers.adapters.anthropic import AnthropicProvider
 from uro_core.providers.adapters.openai_compat import OpenAICompatProvider
 from uro_core.providers.adapters.stub import StubProvider
 from uro_core.providers.base import LLMProvider
+from uro_core.providers.registry import build_router_from_registry as build_router_from_registry
 from uro_core.providers.router import ProviderRouter
 from uro_core.rulesets import registry
 from uro_core.rulesets.base import Ruleset

uro_cli-0.2.0/tests/test_cli_scaffold.py

@@ -1,8 +0,0 @@
-from typer.testing import CliRunner
-from uro_cli.main import app
-
-
-def test_cli_version_runs() -> None:
-    result = CliRunner().invoke(app, ["version"])
-    assert result.exit_code == 0
-    assert "uro-core" in result.output