sirb 0.1.0__tar.gz

sirb-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sirb
+Version: 0.1.0
+Summary: Sirb — command-line client for the decentralized AI compute network.
+Author-email: Sirb maintainers <ops@sirb.run>
+License: MIT
+Project-URL: Homepage, https://sirb.run
+Project-URL: Documentation, https://sirb.run/docs/cli/
+Project-URL: Repository, https://github.com/ammarwa/SIRB
+Project-URL: Issues, https://github.com/ammarwa/SIRB/issues
+Keywords: sirb,ai,inference,decentralized,openai-compatible,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.7; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# `sirb` — Sirb CLI
+
+A thin command-line client for the Decentralized AI Compute network.
+
+## Install
+
+```bash
+cd cli
+pip install -e .
+```
+
+This installs a `sirb` console script.
+
+## First-time setup
+
+```bash
+sirb login
+# prompted for: API key (hidden), base URL, default model
+```
+
+Saves to `~/.sirb/config.json` (0600 on Unix). Environment variables override
+the saved config per-command: `SIRB_API_KEY`, `SIRB_BASE_URL`, `SIRB_MODEL`.
+
+## Commands
+
+```bash
+sirb models                          # list available models (and aliases)
+sirb chat "write a haiku about uvicorn"
+sirb chat --stream "explain CRDTs"   # streaming
+sirb balance                         # your Sirb allowance
+sirb usage --from 2026-05-01 --to 2026-05-14
+sirb keys list
+sirb keys create --name "opencode"   # prints plaintext key once
+sirb keys revoke key_abc123
+
+sirb opencode config                 # JSON snippet for OpenCode config
+sirb opencode env                    # `export` lines for OpenAI-SDK tools
+```
+
+## What it talks to
+
+Plain `httpx`. No `openai` SDK dependency — the CLI hits admin endpoints
+too (`/admin/api-keys`), so the marginal value of pulling in the full SDK
+just for `/v1/chat/completions` wasn't worth the dependency footprint. The
+HTTP code in `sirb_cli/client.py` is short enough to lift into a user's
+own integration if they want a starting point.
+
+## Status
+
+Phase 5B. The commands above all work today. Phase 5B-2 adds `/v1/completions`
+and `/v1/embeddings` to the CLI once the backend ships them; Phase 7 adds
+real onboarding (wallet-signed key creation) so users can self-serve their
+first key.

sirb-0.1.0/README.md

@@ -0,0 +1,53 @@
+# `sirb` — Sirb CLI
+
+A thin command-line client for the Decentralized AI Compute network.
+
+## Install
+
+```bash
+cd cli
+pip install -e .
+```
+
+This installs a `sirb` console script.
+
+## First-time setup
+
+```bash
+sirb login
+# prompted for: API key (hidden), base URL, default model
+```
+
+Saves to `~/.sirb/config.json` (0600 on Unix). Environment variables override
+the saved config per-command: `SIRB_API_KEY`, `SIRB_BASE_URL`, `SIRB_MODEL`.
+
+## Commands
+
+```bash
+sirb models                          # list available models (and aliases)
+sirb chat "write a haiku about uvicorn"
+sirb chat --stream "explain CRDTs"   # streaming
+sirb balance                         # your Sirb allowance
+sirb usage --from 2026-05-01 --to 2026-05-14
+sirb keys list
+sirb keys create --name "opencode"   # prints plaintext key once
+sirb keys revoke key_abc123
+
+sirb opencode config                 # JSON snippet for OpenCode config
+sirb opencode env                    # `export` lines for OpenAI-SDK tools
+```
+
+## What it talks to
+
+Plain `httpx`. No `openai` SDK dependency — the CLI hits admin endpoints
+too (`/admin/api-keys`), so the marginal value of pulling in the full SDK
+just for `/v1/chat/completions` wasn't worth the dependency footprint. The
+HTTP code in `sirb_cli/client.py` is short enough to lift into a user's
+own integration if they want a starting point.
+
+## Status
+
+Phase 5B. The commands above all work today. Phase 5B-2 adds `/v1/completions`
+and `/v1/embeddings` to the CLI once the backend ships them; Phase 7 adds
+real onboarding (wallet-signed key creation) so users can self-serve their
+first key.

sirb-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "sirb"
+version = "0.1.0"
+description = "Sirb — command-line client for the decentralized AI compute network."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+  { name = "Sirb maintainers", email = "ops@sirb.run" },
+]
+requires-python = ">=3.11"
+keywords = ["sirb", "ai", "inference", "decentralized", "openai-compatible", "llm"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Utilities",
+]
+dependencies = [
+  "typer>=0.12",
+  "httpx>=0.27",
+  "rich>=13.7",
+]
+
+[project.urls]
+Homepage      = "https://sirb.run"
+Documentation = "https://sirb.run/docs/cli/"
+Repository    = "https://github.com/ammarwa/SIRB"
+Issues        = "https://github.com/ammarwa/SIRB/issues"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.3",
+  "respx>=0.21",
+  "ruff>=0.7",
+  "build>=1.2",
+  "twine>=5.0",
+]
+
+[project.scripts]
+sirb = "sirb_cli.main:app"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sirb_cli*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]

sirb-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sirb-0.1.0/sirb.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sirb
+Version: 0.1.0
+Summary: Sirb — command-line client for the decentralized AI compute network.
+Author-email: Sirb maintainers <ops@sirb.run>
+License: MIT
+Project-URL: Homepage, https://sirb.run
+Project-URL: Documentation, https://sirb.run/docs/cli/
+Project-URL: Repository, https://github.com/ammarwa/SIRB
+Project-URL: Issues, https://github.com/ammarwa/SIRB/issues
+Keywords: sirb,ai,inference,decentralized,openai-compatible,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.7; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# `sirb` — Sirb CLI
+
+A thin command-line client for the Decentralized AI Compute network.
+
+## Install
+
+```bash
+cd cli
+pip install -e .
+```
+
+This installs a `sirb` console script.
+
+## First-time setup
+
+```bash
+sirb login
+# prompted for: API key (hidden), base URL, default model
+```
+
+Saves to `~/.sirb/config.json` (0600 on Unix). Environment variables override
+the saved config per-command: `SIRB_API_KEY`, `SIRB_BASE_URL`, `SIRB_MODEL`.
+
+## Commands
+
+```bash
+sirb models                          # list available models (and aliases)
+sirb chat "write a haiku about uvicorn"
+sirb chat --stream "explain CRDTs"   # streaming
+sirb balance                         # your Sirb allowance
+sirb usage --from 2026-05-01 --to 2026-05-14
+sirb keys list
+sirb keys create --name "opencode"   # prints plaintext key once
+sirb keys revoke key_abc123
+
+sirb opencode config                 # JSON snippet for OpenCode config
+sirb opencode env                    # `export` lines for OpenAI-SDK tools
+```
+
+## What it talks to
+
+Plain `httpx`. No `openai` SDK dependency — the CLI hits admin endpoints
+too (`/admin/api-keys`), so the marginal value of pulling in the full SDK
+just for `/v1/chat/completions` wasn't worth the dependency footprint. The
+HTTP code in `sirb_cli/client.py` is short enough to lift into a user's
+own integration if they want a starting point.
+
+## Status
+
+Phase 5B. The commands above all work today. Phase 5B-2 adds `/v1/completions`
+and `/v1/embeddings` to the CLI once the backend ships them; Phase 7 adds
+real onboarding (wallet-signed key creation) so users can self-serve their
+first key.

sirb-0.1.0/sirb.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+sirb.egg-info/PKG-INFO
+sirb.egg-info/SOURCES.txt
+sirb.egg-info/dependency_links.txt
+sirb.egg-info/entry_points.txt
+sirb.egg-info/requires.txt
+sirb.egg-info/top_level.txt
+sirb_cli/__init__.py
+sirb_cli/client.py
+sirb_cli/config.py
+sirb_cli/main.py
+sirb_cli/commands/__init__.py
+sirb_cli/commands/balance.py
+sirb_cli/commands/chat.py
+sirb_cli/commands/keys.py
+sirb_cli/commands/login.py
+sirb_cli/commands/models.py
+sirb_cli/commands/observations.py
+sirb_cli/commands/opencode.py
+sirb_cli/commands/usage.py
+tests/test_cli.py

sirb-0.1.0/sirb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sirb-0.1.0/sirb.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sirb = sirb_cli.main:app

sirb-0.1.0/sirb.egg-info/requires.txt

@@ -0,0 +1,10 @@
+typer>=0.12
+httpx>=0.27
+rich>=13.7
+
+[dev]
+pytest>=8.3
+respx>=0.21
+ruff>=0.7
+build>=1.2
+twine>=5.0

sirb-0.1.0/sirb.egg-info/top_level.txt

@@ -0,0 +1 @@
+sirb_cli

sirb-0.1.0/sirb_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sirb-0.1.0/sirb_cli/client.py

@@ -0,0 +1,85 @@
+"""Thin HTTP client over the Sirb backend.
+
+Plain httpx — we deliberately do NOT depend on the openai SDK here. The
+CLI also hits admin endpoints (keys, usage) that aren't OpenAI-compatible,
+so dragging the SDK in for two chat endpoints would just add deps. Plus
+plain httpx is easier to lift into a user's own integration.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import Any
+
+import httpx
+
+from sirb_cli.config import CliConfig
+
+
+class SirbClient:
+    def __init__(self, config: CliConfig, timeout: float = 60.0) -> None:
+        self._cfg = config
+        self._timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        if not self._cfg.api_key:
+            raise RuntimeError("no API key configured — run `sirb login`")
+        return {"Authorization": f"Bearer {self._cfg.api_key}"}
+
+    # ─────────── reads ───────────
+
+    def get(self, path: str, params: dict | None = None) -> dict:
+        r = httpx.get(f"{self._cfg.base_url}{path}", headers=self._headers(),
+                      params=params, timeout=self._timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def post(self, path: str, body: dict) -> dict:
+        r = httpx.post(f"{self._cfg.base_url}{path}", headers=self._headers(),
+                       json=body, timeout=self._timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def delete(self, path: str) -> None:
+        r = httpx.delete(f"{self._cfg.base_url}{path}", headers=self._headers(),
+                         timeout=self._timeout)
+        r.raise_for_status()
+
+    # ─────────── chat / streaming ───────────
+
+    def chat(self, prompt: str, model: str | None = None) -> dict:
+        return self.post("/v1/chat/completions", {
+            "model": model or self._cfg.default_model,
+            "messages": [{"role": "user", "content": prompt}],
+        })
+
+    def chat_stream(self, prompt: str, model: str | None = None) -> Iterator[str]:
+        """Yields completion text fragments as they arrive."""
+        with httpx.stream(
+            "POST", f"{self._cfg.base_url}/v1/chat/completions",
+            headers=self._headers(),
+            json={
+                "model": model or self._cfg.default_model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": True,
+            },
+            timeout=self._timeout,
+        ) as r:
+            r.raise_for_status()
+            for line in r.iter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+                payload = line[len("data:"):].strip()
+                if payload == "[DONE]":
+                    return
+                try:
+                    obj: Any = json.loads(payload)
+                except ValueError:
+                    continue
+                choices = obj.get("choices") or []
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {}).get("content")
+                if delta:
+                    yield delta

sirb-0.1.0/sirb_cli/commands/balance.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from rich import print as rprint
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+
+def run() -> None:
+    body = SirbClient(env_override_or_config()).get("/v1/balance")
+    src = body.get("source", "?")
+    bal = body.get("balance", 0.0)
+    if src == "unconfigured":
+        rprint("[yellow]Balance unavailable[/yellow] (backend has no chain configured).")
+        rprint(f"  wallet: [dim]{body.get('wallet')}[/dim]")
+        return
+    rprint(f"[green]{bal:.6f} Sirb[/green] available")
+    rprint(f"  wallet: [dim]{body.get('wallet')}[/dim]")
+    rprint(f"  source: [dim]{src}[/dim]")

sirb-0.1.0/sirb_cli/commands/chat.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import sys
+
+import typer
+from rich import print as rprint
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+
+def run(
+    prompt: list[str] = typer.Argument(..., help="The user prompt."),
+    model: str | None = typer.Option(None, "--model", "-m",
+                                     help="Model id or alias. Defaults to config default."),
+    stream: bool = typer.Option(False, "--stream", help="Stream tokens as they arrive."),
+) -> None:
+    text = " ".join(prompt)
+    client = SirbClient(env_override_or_config())
+
+    if stream:
+        for chunk in client.chat_stream(text, model=model):
+            sys.stdout.write(chunk)
+            sys.stdout.flush()
+        sys.stdout.write("\n")
+        return
+
+    body = client.chat(text, model=model)
+    completion = body["choices"][0]["message"]["content"]
+    rprint(completion)
+    u = body.get("usage", {})
+    rprint(f"[dim]usage: {u.get('prompt_tokens', 0)} prompt + "
+           f"{u.get('completion_tokens', 0)} completion = "
+           f"{u.get('total_tokens', 0)} tokens[/dim]")

sirb-0.1.0/sirb_cli/commands/keys.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+app = typer.Typer(no_args_is_help=True, help="Manage your Sirb API keys.")
+
+
+@app.command("list")
+def list_keys() -> None:
+    body = SirbClient(env_override_or_config()).get("/admin/api-keys")
+    t = Table(title="Your API keys")
+    t.add_column("id"); t.add_column("name"); t.add_column("status")
+    t.add_column("created"); t.add_column("last used")
+    for k in body.get("data", []):
+        t.add_row(k["id"], k["name"], k["status"],
+                  (k.get("created_at") or "")[:19],
+                  (k.get("last_used_at") or "—")[:19])
+    Console().print(t)
+
+
+@app.command("create")
+def create_key(
+    name: str = typer.Option(..., "--name", "-n", help="Human-friendly label."),
+    rate_limit: int | None = typer.Option(None, "--rate-limit-per-minute",
+                                          help="Optional rate limit (default 60)."),
+) -> None:
+    body = SirbClient(env_override_or_config()).post(
+        "/admin/api-keys",
+        {"name": name, "rate_limit_per_minute": rate_limit},
+    )
+    rprint(f"[green]Created[/green] key [bold]{body['id']}[/bold]")
+    rprint(f"\n  [bold yellow]{body['key']}[/bold yellow]\n")
+    rprint("[red]This is the only time this plaintext key is shown. Save it now.[/red]")
+
+
+@app.command("revoke")
+def revoke_key(key_id: str = typer.Argument(..., help="Key id to revoke.")) -> None:
+    SirbClient(env_override_or_config()).delete(f"/admin/api-keys/{key_id}")
+    rprint(f"[green]Revoked[/green] {key_id}")

sirb-0.1.0/sirb_cli/commands/login.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import typer
+from rich import print as rprint
+
+from sirb_cli.config import CliConfig
+
+
+def run(
+    api_key: str = typer.Option(..., "--api-key", "-k", prompt=True, hide_input=True,
+                                help="Your Sirb API key (input is hidden)."),
+    base_url: str = typer.Option("http://localhost:8000", "--base-url", "-u",
+                                 help="Backend base URL."),
+    default_model: str = typer.Option("mock-7b", "--model", "-m",
+                                       help="Default model id for `sirb chat`."),
+) -> None:
+    cfg = CliConfig(base_url=base_url.rstrip("/"), api_key=api_key, default_model=default_model)
+    p = cfg.save()
+    rprint(f"[green]Saved[/green] config to [bold]{p}[/bold]")
+    rprint(f"  base_url: {cfg.base_url}")
+    rprint(f"  default_model: {cfg.default_model}")
+    rprint(f"  api_key: [dim]sirb_***{api_key[-6:] if len(api_key) > 6 else '***'}[/dim]")

sirb-0.1.0/sirb_cli/commands/models.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+
+def run() -> None:
+    body = SirbClient(env_override_or_config()).get("/v1/models")
+    table = Table(title="Available models", show_lines=False)
+    table.add_column("id", style="bold")
+    table.add_column("owned_by", style="dim")
+    for m in body.get("data", []):
+        table.add_row(m.get("id", ""), m.get("owned_by", ""))
+    Console().print(table)

sirb-0.1.0/sirb_cli/commands/observations.py

@@ -0,0 +1,112 @@
+"""Phase 9A — agent observations subcommand.
+
+Two operations, matching the admin API surface:
+
+    sirb observations list [--kind monitoring] [--limit 20]
+    sirb observations run
+
+``list`` paginates the most-recent observations across all kinds (or a
+single kind). ``run`` triggers a manual monitoring agent cycle — useful
+for verifying snapshot + LLM config without waiting for the runner
+interval.
+
+Observations include the network snapshot that drove them; pass
+``--full`` to ``list`` to print that too. Otherwise output is a compact
+one-line-per-observation table — what an operator wants when glancing
+at recent agent activity.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+app = typer.Typer(no_args_is_help=True, help="Agent observations (Phase 9A monitoring agent).")
+
+
+def _client() -> SirbClient:
+    return SirbClient(env_override_or_config())
+
+
+def _fmt_findings(findings: list[dict]) -> str:
+    """Compact one-line summary of findings — count + severity histogram."""
+    if not findings:
+        return "(none)"
+    counts: dict[str, int] = {}
+    for f in findings:
+        sev = f.get("severity", "info")
+        counts[sev] = counts.get(sev, 0) + 1
+    parts = []
+    for sev in ("critical", "warning", "info"):
+        if sev in counts:
+            parts.append(f"{counts[sev]} {sev}")
+    return ", ".join(parts) or "(none)"
+
+
+@app.command("list")
+def list_observations(
+    kind: str | None = typer.Option(None, "--kind", help="Filter by agent kind, e.g. monitoring."),
+    limit: int = typer.Option(20, "--limit", min=1, max=500),
+    full: bool = typer.Option(False, "--full", help="Print the per-observation findings detail."),
+) -> None:
+    """List recent agent observations."""
+    params = {"limit": str(limit)}
+    if kind:
+        params["kind"] = kind
+    body = _client().get("/admin/observations", params=params)
+    data = body.get("data", [])
+    if not data:
+        rprint("[dim](no observations recorded)[/dim]")
+        return
+
+    t = Table(title=f"agent observations ({len(data)} shown)")
+    for col in ("when", "kind", "outcome", "provider", "summary", "findings"):
+        t.add_column(col)
+    for obs in data:
+        t.add_row(
+            obs.get("created_at", "")[:19].replace("T", " "),
+            obs.get("kind", ""),
+            obs.get("outcome", ""),
+            obs.get("provider", ""),
+            (obs.get("summary") or "")[:80],
+            _fmt_findings(obs.get("findings", [])),
+        )
+    Console().print(t)
+
+    if full:
+        for obs in data:
+            rprint(f"\n[bold]{obs.get('id')}[/bold]  ({obs.get('outcome')})")
+            rprint(f"  summary:    {obs.get('summary')}")
+            rprint(f"  confidence: {obs.get('confidence')}")
+            for f in obs.get("findings", []):
+                color = {"critical": "red", "warning": "yellow", "info": "cyan"}.get(
+                    f.get("severity", "info"), "white",
+                )
+                rprint(f"    [{color}]{f.get('severity'):>8}[/{color}]  "
+                       f"{f.get('category', '')}  "
+                       f"[bold]{f.get('target', '')}[/bold]  {f.get('detail', '')}")
+
+
+@app.command("run")
+def run_now() -> None:
+    """Trigger one monitoring agent run immediately."""
+    body = _client().post("/admin/observations/run", {})
+    rprint(f"[bold]{body.get('id')}[/bold]  {body.get('outcome')}  "
+           f"({body.get('provider')}, {body.get('latency_ms')}ms)")
+    rprint(f"  summary: {body.get('summary')}")
+    findings = body.get("findings", [])
+    if not findings:
+        rprint("  findings: [dim](none)[/dim]")
+        return
+    for f in findings:
+        color = {"critical": "red", "warning": "yellow", "info": "cyan"}.get(
+            f.get("severity", "info"), "white",
+        )
+        rprint(f"  [{color}]{f.get('severity'):>8}[/{color}]  "
+               f"{f.get('category', '')}  "
+               f"[bold]{f.get('target', '')}[/bold]  {f.get('detail', '')}")

sirb-0.1.0/sirb_cli/commands/opencode.py

@@ -0,0 +1,47 @@
+"""`sirb opencode config` and `sirb opencode env`.
+
+Prints config snippets for OpenCode-style tools. Reads the saved CLI
+config so users don't have to retype anything.
+"""
+
+from __future__ import annotations
+
+import json
+import typer
+from rich import print as rprint
+
+from sirb_cli.config import env_override_or_config
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command("config")
+def show_config() -> None:
+    """Print an OpenAI-compatible JSON config for OpenCode."""
+    cfg = env_override_or_config()
+    if not cfg.api_key:
+        rprint("[red]No API key configured.[/red] Run `sirb login` first.")
+        raise typer.Exit(1)
+    out = {
+        "provider": "openai-compatible",
+        "baseURL": cfg.base_url.rstrip("/") + "/v1",
+        "apiKey": cfg.api_key,
+        "model": cfg.default_model,
+    }
+    print(json.dumps(out, indent=2))
+
+
+@app.command("env")
+def show_env() -> None:
+    """Print export commands that point an OpenAI-SDK-based tool at Sirb."""
+    cfg = env_override_or_config()
+    if not cfg.api_key:
+        rprint("[red]No API key configured.[/red] Run `sirb login` first.")
+        raise typer.Exit(1)
+    base = cfg.base_url.rstrip("/") + "/v1"
+    print(f'export OPENAI_API_KEY="{cfg.api_key}"')
+    print(f'export OPENAI_BASE_URL="{base}"')
+    print(f'export OPENAI_MODEL="{cfg.default_model}"')
+    print(f'export SIRB_API_KEY="{cfg.api_key}"')
+    print(f'export SIRB_BASE_URL="{base}"')
+    print(f'export SIRB_MODEL="{cfg.default_model}"')

sirb-0.1.0/sirb_cli/commands/usage.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+from sirb_cli.client import SirbClient
+from sirb_cli.config import env_override_or_config
+
+
+def run(
+    from_date: str | None = typer.Option(None, "--from", help="Start date (YYYY-MM-DD)."),
+    to_date: str | None = typer.Option(None, "--to", help="End date (YYYY-MM-DD)."),
+) -> None:
+    params = {}
+    if from_date:
+        params["from"] = from_date
+    if to_date:
+        params["to"] = to_date
+    body = SirbClient(env_override_or_config()).get("/v1/usage", params=params or None)
+    # Phase 8D: backends running 8D+ return total_cost/per-row cost in
+    # SIRB; older backends omit them. Default to 0.0 / "—" so the CLI
+    # works against either era.
+    total_cost = body.get("total_cost", 0.0)
+    currency = body.get("currency", "SIRB")
+    rprint(f"[bold]{body['wallet']}[/bold]   {body['from_date']} → {body['to_date']}")
+    rprint(f"  total: [green]{body['total_requests']}[/green] requests "
+           f"({body['successful_requests']} ok, {body['failed_requests']} failed)")
+    rprint(f"  tokens: {body['total_prompt_tokens']} in + "
+           f"{body['total_completion_tokens']} out = "
+           f"[green]{body['total_tokens']}[/green]")
+    rprint(f"  cost:   [green]{_fmt_cost(total_cost)}[/green] {currency}")
+
+    if body.get("by_day"):
+        t = Table(title="By day")
+        for col in ("date", "requests", "in", "out", f"cost ({currency})"):
+            t.add_column(col)
+        for d in body["by_day"]:
+            t.add_row(d["date"], str(d["requests"]), str(d["prompt_tokens"]),
+                      str(d["completion_tokens"]),
+                      _fmt_cost(d.get("cost", 0.0)))
+        Console().print(t)
+
+    if body.get("by_model"):
+        t = Table(title="By model")
+        for col in ("model", "requests", "in", "out", f"cost ({currency})"):
+            t.add_column(col)
+        for d in body["by_model"]:
+            t.add_row(d["model"], str(d["requests"]), str(d["prompt_tokens"]),
+                      str(d["completion_tokens"]),
+                      _fmt_cost(d.get("cost", 0.0)))
+        Console().print(t)
+
+
+def _fmt_cost(c: float) -> str:
+    """SIRB prices live in the 1e-4 range at MVP rates. Six decimals is
+    enough resolution to distinguish a 100-token call from a 10-token
+    one (~1e-7 difference) without looking like a scientific paper."""
+    if c == 0.0:
+        return "0"
+    return f"{c:.6f}"

sirb-0.1.0/sirb_cli/config.py

@@ -0,0 +1,68 @@
+"""CLI config persistence.
+
+State lives at ``~/.sirb/config.json`` by default (overridable with
+``SIRB_CLI_CONFIG``). One JSON object with base_url + api_key. We do NOT
+keep a separate credential store — the config file's permissions are the
+boundary (0600 on Unix). On Windows the file inherits user-level perms.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+def _config_path() -> Path:
+    env = os.environ.get("SIRB_CLI_CONFIG")
+    if env:
+        return Path(env)
+    return Path.home() / ".sirb" / "config.json"
+
+
+@dataclass
+class CliConfig:
+    base_url: str = "http://localhost:8000"
+    api_key: str | None = None
+    default_model: str = "mock-7b"
+
+    @classmethod
+    def load(cls) -> "CliConfig":
+        p = _config_path()
+        if not p.exists():
+            return cls()
+        try:
+            data = json.loads(p.read_text())
+        except (OSError, json.JSONDecodeError):
+            return cls()
+        return cls(
+            base_url=data.get("base_url", cls.base_url),
+            api_key=data.get("api_key"),
+            default_model=data.get("default_model", cls.default_model),
+        )
+
+    def save(self) -> Path:
+        p = _config_path()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(json.dumps(asdict(self), indent=2))
+        # Tighten perms on Unix so other users can't read the key.
+        try:
+            os.chmod(p, stat.S_IRUSR | stat.S_IWUSR)
+        except (OSError, NotImplementedError):
+            pass
+        return p
+
+
+def env_override_or_config() -> CliConfig:
+    """Env vars trump the config file. Lets users do one-off calls without
+    rewriting their saved config."""
+    cfg = CliConfig.load()
+    if (env_url := os.environ.get("SIRB_BASE_URL")):
+        cfg.base_url = env_url
+    if (env_key := os.environ.get("SIRB_API_KEY")):
+        cfg.api_key = env_key
+    if (env_model := os.environ.get("SIRB_MODEL")):
+        cfg.default_model = env_model
+    return cfg

sirb-0.1.0/sirb_cli/main.py

@@ -0,0 +1,34 @@
+"""``sirb`` CLI entry point.
+
+Each command lives in ``sirb_cli.commands.<name>`` and registers itself
+against the Typer app here.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from sirb_cli.commands import balance, chat, keys, login, models, observations, opencode, usage
+
+app = typer.Typer(
+    name="sirb",
+    no_args_is_help=True,
+    help="Sirb — Decentralized AI Compute CLI",
+    rich_markup_mode="rich",
+    add_completion=False,
+)
+
+app.command(name="login", help="Save your API key and base URL to ~/.sirb/config.json.")(login.run)
+app.command(name="models", help="List available models (and aliases).")(models.run)
+app.command(name="balance", help="Show your current Sirb allowance.")(balance.run)
+app.command(name="usage", help="Show your usage rollup.")(usage.run)
+app.command(name="chat", help="Send a single chat completion request.")(chat.run)
+
+app.add_typer(keys.app, name="keys", help="Manage API keys.")
+app.add_typer(opencode.app, name="opencode", help="Print OpenCode-compatible config.")
+app.add_typer(observations.app, name="observations",
+              help="Agent observations (Phase 9A monitoring agent).")
+
+
+if __name__ == "__main__":
+    app()

sirb-0.1.0/tests/test_cli.py

@@ -0,0 +1,123 @@
+"""CLI smoke tests.
+
+We don't spin up a real backend — respx intercepts httpx calls and returns
+canned responses. The goal is to assert the CLI parses output correctly
+and shapes the right HTTP requests, not to re-test the backend.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+import respx
+from httpx import Response
+from typer.testing import CliRunner
+
+from sirb_cli.config import CliConfig
+from sirb_cli.main import app
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def tmp_config(tmp_path: Path, monkeypatch):
+    """Point the CLI's config at a tmp file so tests don't touch the real one."""
+    monkeypatch.setenv("SIRB_CLI_CONFIG", str(tmp_path / "config.json"))
+    # Pre-seed with a base_url + api_key so commands work without `login`.
+    CliConfig(base_url="http://sirb.test", api_key="sirb_test", default_model="mock-7b").save()
+    yield
+
+
+def test_login_writes_config(tmp_path):
+    cfg_path = Path(os.environ["SIRB_CLI_CONFIG"])
+    r = runner.invoke(app, ["login", "--api-key", "sirb_new", "--base-url", "https://example.com"])
+    assert r.exit_code == 0, r.output
+    saved = json.loads(cfg_path.read_text())
+    assert saved["api_key"] == "sirb_new"
+    assert saved["base_url"] == "https://example.com"
+
+
+@respx.mock
+def test_models_calls_endpoint_and_renders():
+    respx.get("http://sirb.test/v1/models").mock(
+        return_value=Response(200, json={"object": "list", "data": [
+            {"id": "mock-7b", "owned_by": "decentralized-community"},
+        ]})
+    )
+    r = runner.invoke(app, ["models"])
+    assert r.exit_code == 0, r.output
+    assert "mock-7b" in r.output
+
+
+@respx.mock
+def test_chat_non_stream_prints_completion():
+    respx.post("http://sirb.test/v1/chat/completions").mock(
+        return_value=Response(200, json={
+            "id": "x", "object": "chat.completion", "created": 0, "model": "mock-7b",
+            "choices": [{"index": 0, "message": {"role": "assistant", "content": "pong"},
+                         "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+        })
+    )
+    r = runner.invoke(app, ["chat", "ping"])
+    assert r.exit_code == 0, r.output
+    assert "pong" in r.output
+
+
+@respx.mock
+def test_balance_unconfigured_renders_warning():
+    respx.get("http://sirb.test/v1/balance").mock(
+        return_value=Response(200, json={
+            "object": "sirb.balance", "wallet": "0xtest",
+            "balance": 0.0, "balance_wei": "0", "currency": "SIRB",
+            "source": "unconfigured",
+        })
+    )
+    r = runner.invoke(app, ["balance"])
+    assert r.exit_code == 0, r.output
+    assert "unavailable" in r.output.lower() or "no chain" in r.output.lower()
+
+
+@respx.mock
+def test_keys_create_renders_plaintext_warning():
+    respx.post("http://sirb.test/admin/api-keys").mock(
+        return_value=Response(201, json={
+            "object": "sirb.api_key.created", "id": "key_abc",
+            "key": "sirb_supersecret", "name": "demo",
+            "wallet_address": "0xtest", "created_at": "2026-05-14T00:00:00Z",
+            "rate_limit_per_minute": 60,
+        })
+    )
+    r = runner.invoke(app, ["keys", "create", "--name", "demo"])
+    assert r.exit_code == 0, r.output
+    assert "sirb_supersecret" in r.output
+    assert "only time" in r.output.lower()
+
+
+@respx.mock
+def test_keys_revoke_calls_delete():
+    route = respx.delete("http://sirb.test/admin/api-keys/key_abc").mock(
+        return_value=Response(204)
+    )
+    r = runner.invoke(app, ["keys", "revoke", "key_abc"])
+    assert r.exit_code == 0, r.output
+    assert route.called
+
+
+def test_opencode_env_prints_export_lines():
+    r = runner.invoke(app, ["opencode", "env"])
+    assert r.exit_code == 0, r.output
+    assert 'export OPENAI_API_KEY="sirb_test"' in r.output
+    assert 'export OPENAI_BASE_URL="http://sirb.test/v1"' in r.output
+
+
+def test_opencode_config_prints_json():
+    r = runner.invoke(app, ["opencode", "config"])
+    assert r.exit_code == 0, r.output
+    parsed = json.loads(r.output)
+    assert parsed["provider"] == "openai-compatible"
+    assert parsed["baseURL"] == "http://sirb.test/v1"
+    assert parsed["apiKey"] == "sirb_test"