swarph-cli 0.17.0__tar.gz → 0.18.0__tar.gz

{swarph_cli-0.17.0/src/swarph_cli.egg-info → swarph_cli-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.17.0
+Version: 0.18.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -36,6 +36,10 @@ Requires-Dist: fastapi>=0.115; extra == "gateway"
 Requires-Dist: uvicorn[standard]>=0.32; extra == "gateway"
 Requires-Dist: pydantic>=2.9; extra == "gateway"
 Requires-Dist: croniter>=6.2; extra == "gateway"
+Provides-Extra: service
+Requires-Dist: fastapi>=0.115; extra == "service"
+Requires-Dist: uvicorn[standard]>=0.32; extra == "service"
+Requires-Dist: pydantic>=2.9; extra == "service"
 Dynamic: license-file
 
 # swarph-cli
@@ -67,6 +71,7 @@ swarph chat              interactive REPL — multi-turn, slash commands, live p
 swarph brain-ask "<q>"   search the swarph-brain (gbrain) memory — $0 cited answer or raw chunks
 swarph brain serve       run the gbrain HTTP brain server (the $0 semantic memory)
 swarph gateway serve     run the bundled mesh-gateway server (the mesh's coordination/DM hub)
+swarph service serve     stand up a $0 subscription-LLM HTTP lane (claude/codex/gemini)
 swarph highlight "<x>"   log a highlight to the shared git-backed swarph timeline
 swarph spawn <role>      launch a long-lived agent session as a named mesh cell
 swarph daemon            foreground inbox-drain loop (the mesh doorbell)
@@ -119,6 +124,20 @@ $ swarph gateway serve --host 100.x.y.z --port 8788   # expose on a tailnet IP
 
 `--token` sets the bearer (`MESH_GATEWAY_TOKEN`) for the served process; omit it and an existing env token is used, or a fresh one is minted and printed once so you can hand it to the mesh cells. `--db PATH` points the gateway at a specific SQLite file (`MESH_DB_PATH`). Run without the extra and the verb prints a `pip install "swarph-cli[gateway]"` hint and exits.
 
+### `swarph service`
+
+Turn a *subscription* LLM CLI into a **$0 HTTP lane** the mesh can call — `swarph service serve --provider <claude|codex|gemini>` runs a small FastAPI app exposing `POST /delegate` (bearer-authed) + `GET /health`:
+
+```bash
+$ pip install "swarph-cli[service]"
+$ swarph service serve --provider claude               # 127.0.0.1:8799, mints+prints a token
+$ swarph service serve --provider gemini --host 100.x.y.z --port 8799   # expose on a tailnet IP
+$ curl -s localhost:8799/delegate -H "Authorization: Bearer $TOK" \
+    -d '{"prompt":"summarise this in one line: ..."}'   # -> {"text": "...", "cost_usd": 0.0}
+```
+
+The load-bearing piece is **billing-scrub**: the subprocess env has every known provider API-key var (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, …) stripped, so the wrapped CLI can *only* use its $0 subscription auth — it can never silently fall back to metered API billing. Default loopback bind (expose a tailnet IP explicitly); the bearer is `--token` > `SWARPH_SERVICE_TOKEN` > a freshly minted+printed token. Note the `gemini` (agy) lane reads the prompt from argv only and hard-caps its length (~4 KB) — very long prompts are rejected, not truncated. Run without the extra and the verb prints a `pip install "swarph-cli[service]"` hint and exits.
+
 ### `swarph highlight`
 
 The swarph **timeline** is an append-only, multi-author `TIMELINE.md` — a git-backed continuous-learning log where every cell's highlights converge into one file. `swarph highlight` is the mechanics; *you* (or your agent) decide what's worth logging and which memory it links to.

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/README.md

@@ -27,6 +27,7 @@ swarph chat              interactive REPL — multi-turn, slash commands, live p
 swarph brain-ask "<q>"   search the swarph-brain (gbrain) memory — $0 cited answer or raw chunks
 swarph brain serve       run the gbrain HTTP brain server (the $0 semantic memory)
 swarph gateway serve     run the bundled mesh-gateway server (the mesh's coordination/DM hub)
+swarph service serve     stand up a $0 subscription-LLM HTTP lane (claude/codex/gemini)
 swarph highlight "<x>"   log a highlight to the shared git-backed swarph timeline
 swarph spawn <role>      launch a long-lived agent session as a named mesh cell
 swarph daemon            foreground inbox-drain loop (the mesh doorbell)
@@ -79,6 +80,20 @@ $ swarph gateway serve --host 100.x.y.z --port 8788   # expose on a tailnet IP
 
 `--token` sets the bearer (`MESH_GATEWAY_TOKEN`) for the served process; omit it and an existing env token is used, or a fresh one is minted and printed once so you can hand it to the mesh cells. `--db PATH` points the gateway at a specific SQLite file (`MESH_DB_PATH`). Run without the extra and the verb prints a `pip install "swarph-cli[gateway]"` hint and exits.
 
+### `swarph service`
+
+Turn a *subscription* LLM CLI into a **$0 HTTP lane** the mesh can call — `swarph service serve --provider <claude|codex|gemini>` runs a small FastAPI app exposing `POST /delegate` (bearer-authed) + `GET /health`:
+
+```bash
+$ pip install "swarph-cli[service]"
+$ swarph service serve --provider claude               # 127.0.0.1:8799, mints+prints a token
+$ swarph service serve --provider gemini --host 100.x.y.z --port 8799   # expose on a tailnet IP
+$ curl -s localhost:8799/delegate -H "Authorization: Bearer $TOK" \
+    -d '{"prompt":"summarise this in one line: ..."}'   # -> {"text": "...", "cost_usd": 0.0}
+```
+
+The load-bearing piece is **billing-scrub**: the subprocess env has every known provider API-key var (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, …) stripped, so the wrapped CLI can *only* use its $0 subscription auth — it can never silently fall back to metered API billing. Default loopback bind (expose a tailnet IP explicitly); the bearer is `--token` > `SWARPH_SERVICE_TOKEN` > a freshly minted+printed token. Note the `gemini` (agy) lane reads the prompt from argv only and hard-caps its length (~4 KB) — very long prompts are rejected, not truncated. Run without the extra and the verb prints a `pip install "swarph-cli[service]"` hint and exits.
+
 ### `swarph highlight`
 
 The swarph **timeline** is an append-only, multi-author `TIMELINE.md` — a git-backed continuous-learning log where every cell's highlights converge into one file. `swarph highlight` is the mechanics; *you* (or your agent) decide what's worth logging and which memory it links to.

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.17.0"
+version = "0.18.0"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }
@@ -70,6 +70,15 @@ gateway = [
     "pydantic>=2.9",
     "croniter>=6.2",
 ]
+# `swarph service serve` stands up a $0 subscription-LLM HTTP lane. Same
+# FastAPI/uvicorn stack as the gateway, behind its own extra so the core
+# client paths stay dependency-light; the verb prints a
+# `pip install swarph-cli[service]` hint when these are absent.
+service = [
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.32",
+    "pydantic>=2.9",
+]
 
 [project.scripts]
 swarph = "swarph_cli.main:main"

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.17.0"
+__version__ = "0.18.0"
 
 __all__ = ["__version__"]

swarph_cli-0.18.0/src/swarph_cli/commands/service.py

@@ -0,0 +1,74 @@
+"""``swarph service`` — stand up a $0 subscription-LLM HTTP lane.
+
+`swarph service serve --provider <claude|codex|gemini>` runs a small FastAPI app
+that exposes the provider's *subscription* CLI as a $0 HTTP lane (`POST /delegate`,
+`GET /health`, bearer auth). The subprocess env is billing-scrubbed so the lane
+can only use the $0 subscription path, never metered API billing. The server
+stack (fastapi/uvicorn) is the optional ``[service]`` extra; the verb prints an
+install hint and exits 2 when it's absent.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import secrets
+import sys
+
+
+def _have_server_deps() -> bool:
+    try:
+        import fastapi  # noqa: F401
+        import uvicorn  # noqa: F401
+        return True
+    except ModuleNotFoundError:
+        return False
+
+
+def run_service(argv: list) -> int:
+    p = argparse.ArgumentParser(
+        prog="swarph service",
+        description="Stand up a $0 subscription-LLM HTTP lane.")
+    sub = p.add_subparsers(dest="cmd")
+    serve = sub.add_parser("serve", help="run a $0 service lane for one provider")
+    serve.add_argument("--provider", required=True,
+                       help="claude | codex | gemini")
+    serve.add_argument("--host", default="127.0.0.1",
+                       help="bind host (default 127.0.0.1; pass a tailnet IP to expose)")
+    serve.add_argument("--port", type=int, default=8799, help="HTTP port (default 8799)")
+    serve.add_argument("--token", default=None,
+                       help="bearer token (else SWARPH_SERVICE_TOKEN, else minted+printed)")
+    serve.add_argument("--timeout", type=int, default=120,
+                       help="per-call subprocess timeout in seconds (default 120)")
+    args = p.parse_args(argv)
+
+    if args.cmd != "serve":
+        p.print_help()
+        return 0
+
+    from swarph_cli.service import providers as pv
+    if args.provider not in pv.SUPPORTED:
+        print(f"swarph service: unsupported provider {args.provider!r}; "
+              f"supported: {', '.join(pv.SUPPORTED)}", file=sys.stderr)
+        return 2
+
+    if not _have_server_deps():
+        print('swarph service serve needs the server extra: '
+              'pip install "swarph-cli[service]"', file=sys.stderr)
+        return 2
+
+    token = args.token or os.environ.get("SWARPH_SERVICE_TOKEN")
+    if not token:
+        token = secrets.token_urlsafe(32)
+        print("swarph service: minted bearer token (set SWARPH_SERVICE_TOKEN to "
+              f"reuse it):\n  {token}", file=sys.stderr)
+
+    from swarph_cli.service.app import build_app
+    import uvicorn
+
+    app = build_app(args.provider, token, timeout=args.timeout)
+    print(f"swarph service: {args.provider} $0 lane on "
+          f"http://{args.host}:{args.port}  (POST /delegate, GET /health)",
+          file=sys.stderr)
+    uvicorn.run(app, host=args.host, port=args.port)
+    return 0

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/src/swarph_cli/main.py

@@ -94,6 +94,7 @@ _VERB_HANDLERS: dict[str, str] = {
     "brain-ask": "swarph_cli.commands.brain_ask.run_brain_ask",
     "brain": "swarph_cli.commands.brain.run_brain",
     "gateway": "swarph_cli.commands.gateway.run_gateway",
+    "service": "swarph_cli.commands.service.run_service",
     "highlight": "swarph_cli.commands.highlight.run_highlight",
     # Future: "list-peers", "list-adapters", etc.
 }

swarph_cli-0.18.0/src/swarph_cli/service/app.py

@@ -0,0 +1,53 @@
+"""FastAPI $0-service app — a subscription LLM CLI exposed as a $0 HTTP lane.
+
+`POST /delegate` (bearer-authed) runs the provider's subscription CLI one-shot
+with a billing-scrubbed env (see ``providers.scrub_billing_env``) and returns the
+completion at ``cost_usd: 0.0``. Behind the optional ``[service]`` extra.
+"""
+
+from __future__ import annotations
+
+import time
+
+from fastapi import FastAPI, Header, HTTPException
+from pydantic import BaseModel
+
+from . import providers as pv
+
+
+class DelegateRequest(BaseModel):
+    prompt: str
+    system: str | None = None
+    timeout: int | None = None
+
+
+def build_app(provider: str, token: str, timeout: int = pv._DEFAULT_TIMEOUT) -> FastAPI:
+    if provider not in pv.SUPPORTED:
+        raise ValueError(
+            f"unsupported provider {provider!r}; supported: {', '.join(pv.SUPPORTED)}")
+
+    app = FastAPI(title=f"swarph service ({provider})",
+                  description="$0 subscription-LLM HTTP lane")
+
+    def _auth(authorization: str) -> None:
+        if authorization != f"Bearer {token}":
+            raise HTTPException(status_code=401, detail="bad or missing bearer token")
+
+    @app.get("/health")
+    def health():
+        return {"ok": True, "provider": provider, "cost_model": "$0 subscription"}
+
+    @app.post("/delegate")
+    def delegate(req: DelegateRequest, authorization: str = Header(default="")):
+        _auth(authorization)
+        prompt = req.prompt if not req.system else f"System: {req.system}\n\n{req.prompt}"
+        t0 = time.monotonic()
+        try:
+            text = pv.run_provider(provider, prompt, timeout=req.timeout or timeout)
+        except RuntimeError as exc:
+            # CLI failed — surface the (already-truncated, env-free) reason, never the env.
+            raise HTTPException(status_code=502, detail=str(exc))
+        return {"text": text, "provider": provider, "cost_usd": 0.0,
+                "duration_s": round(time.monotonic() - t0, 3)}
+
+    return app

swarph_cli-0.18.0/src/swarph_cli/service/providers.py

@@ -0,0 +1,87 @@
+"""$0-service provider core — billing-scrub + the CLI command map.
+
+A swarph **service** wraps a *subscription* LLM CLI as a $0 HTTP lane. The
+load-bearing security property: such a lane must NEVER be able to fall back to
+metered API billing (the €50-Google-alert lesson, made structural). A
+subscription CLI authenticates from its own config files (``~/.claude``,
+``~/.codex``, ``~/.gemini/antigravity``, …) — *not* from an API-key env var. So
+we strip every known provider API-key var from the subprocess env: if a stray
+``ANTHROPIC_API_KEY`` were present, the CLI could silently bill it instead of
+the subscription. Scrubbing makes the $0 path the only path.
+
+No fastapi here — this module is the pure, importable security logic; the HTTP
+app lives in ``service/app.py`` behind the optional ``[service]`` extra.
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+# Union of metered API-key env vars, stripped for EVERY lane (a claude lane must
+# not be able to bill OpenAI either). These are unambiguously "use a paid API
+# key" — subscription auth never lives here, so stripping them only removes the
+# metered-fallback path.
+_SCRUB_KEYS = frozenset({
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "GEMINI_API_KEY",
+    "GOOGLE_API_KEY",
+    "XAI_API_KEY",
+    "GROK_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "MISTRAL_API_KEY",
+    "GROQ_API_KEY",
+    "TOGETHER_API_KEY",
+    "PERPLEXITY_API_KEY",
+})
+
+# provider -> argv prefix (the prompt is appended as the final arg). The prompt
+# already carries any system context (the app composes it) so these stay simple.
+# NOTE: the gemini lane (agy) reads the prompt ONLY from argv and hard-caps it
+# (MAX_ARG_LEN ~4128) — very long prompts will be rejected by agy, not truncated.
+_COMMANDS = {
+    "claude": ["claude", "-p"],
+    "codex": ["codex", "exec"],
+    "gemini": ["agy", "--print"],
+}
+
+SUPPORTED = tuple(_COMMANDS.keys())
+
+_DEFAULT_TIMEOUT = 120  # seconds; mirrors CLAUDE_SUBSCRIPTION_TIMEOUT default
+
+
+def scrub_billing_env(provider: str, base_env: dict) -> dict:
+    """Return a COPY of ``base_env`` with every metered API-key var removed.
+
+    ``provider`` is accepted for symmetry / future per-provider nuance; today the
+    scrub is the full union for defense in depth. The input dict is never mutated.
+    """
+    return {k: v for k, v in base_env.items() if k not in _SCRUB_KEYS}
+
+
+def provider_command(provider: str, prompt: str) -> list:
+    """Build the subprocess argv for ``provider`` running ``prompt`` one-shot."""
+    prefix = _COMMANDS.get(provider)
+    if prefix is None:
+        raise ValueError(
+            f"unsupported provider {provider!r}; supported: {', '.join(SUPPORTED)}")
+    return [*prefix, prompt]
+
+
+def run_provider(provider: str, prompt: str, timeout: int = _DEFAULT_TIMEOUT,
+                 base_env: dict | None = None) -> str:
+    """Run the provider's subscription CLI one-shot with a billing-scrubbed env.
+
+    Returns stdout (stripped). Raises ``ValueError`` for an unknown provider and
+    ``RuntimeError`` on a non-zero exit (stderr head only — never echo the env).
+    """
+    import os
+
+    argv = provider_command(provider, prompt)
+    env = scrub_billing_env(provider, os.environ if base_env is None else base_env)
+    proc = subprocess.run(argv, env=env, capture_output=True, text=True,
+                          timeout=timeout)
+    if proc.returncode != 0:
+        raise RuntimeError(
+            f"{provider} CLI exited {proc.returncode}: {proc.stderr.strip()[:200]}")
+    return proc.stdout.strip()

{swarph_cli-0.17.0 → swarph_cli-0.18.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.17.0
+Version: 0.18.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -36,6 +36,10 @@ Requires-Dist: fastapi>=0.115; extra == "gateway"
 Requires-Dist: uvicorn[standard]>=0.32; extra == "gateway"
 Requires-Dist: pydantic>=2.9; extra == "gateway"
 Requires-Dist: croniter>=6.2; extra == "gateway"
+Provides-Extra: service
+Requires-Dist: fastapi>=0.115; extra == "service"
+Requires-Dist: uvicorn[standard]>=0.32; extra == "service"
+Requires-Dist: pydantic>=2.9; extra == "service"
 Dynamic: license-file
 
 # swarph-cli
@@ -67,6 +71,7 @@ swarph chat              interactive REPL — multi-turn, slash commands, live p
 swarph brain-ask "<q>"   search the swarph-brain (gbrain) memory — $0 cited answer or raw chunks
 swarph brain serve       run the gbrain HTTP brain server (the $0 semantic memory)
 swarph gateway serve     run the bundled mesh-gateway server (the mesh's coordination/DM hub)
+swarph service serve     stand up a $0 subscription-LLM HTTP lane (claude/codex/gemini)
 swarph highlight "<x>"   log a highlight to the shared git-backed swarph timeline
 swarph spawn <role>      launch a long-lived agent session as a named mesh cell
 swarph daemon            foreground inbox-drain loop (the mesh doorbell)
@@ -119,6 +124,20 @@ $ swarph gateway serve --host 100.x.y.z --port 8788   # expose on a tailnet IP
 
 `--token` sets the bearer (`MESH_GATEWAY_TOKEN`) for the served process; omit it and an existing env token is used, or a fresh one is minted and printed once so you can hand it to the mesh cells. `--db PATH` points the gateway at a specific SQLite file (`MESH_DB_PATH`). Run without the extra and the verb prints a `pip install "swarph-cli[gateway]"` hint and exits.
 
+### `swarph service`
+
+Turn a *subscription* LLM CLI into a **$0 HTTP lane** the mesh can call — `swarph service serve --provider <claude|codex|gemini>` runs a small FastAPI app exposing `POST /delegate` (bearer-authed) + `GET /health`:
+
+```bash
+$ pip install "swarph-cli[service]"
+$ swarph service serve --provider claude               # 127.0.0.1:8799, mints+prints a token
+$ swarph service serve --provider gemini --host 100.x.y.z --port 8799   # expose on a tailnet IP
+$ curl -s localhost:8799/delegate -H "Authorization: Bearer $TOK" \
+    -d '{"prompt":"summarise this in one line: ..."}'   # -> {"text": "...", "cost_usd": 0.0}
+```
+
+The load-bearing piece is **billing-scrub**: the subprocess env has every known provider API-key var (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, …) stripped, so the wrapped CLI can *only* use its $0 subscription auth — it can never silently fall back to metered API billing. Default loopback bind (expose a tailnet IP explicitly); the bearer is `--token` > `SWARPH_SERVICE_TOKEN` > a freshly minted+printed token. Note the `gemini` (agy) lane reads the prompt from argv only and hard-caps its length (~4 KB) — very long prompts are rejected, not truncated. Run without the extra and the verb prints a `pip install "swarph-cli[service]"` hint and exits.
+
 ### `swarph highlight`
 
 The swarph **timeline** is an append-only, multi-author `TIMELINE.md` — a git-backed continuous-learning log where every cell's highlights converge into one file. `swarph highlight` is the mechanics; *you* (or your agent) decide what's worth logging and which memory it links to.

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/swarph_cli/commands/onboard.py
 src/swarph_cli/commands/protocol_handler.py
 src/swarph_cli/commands/ratify.py
 src/swarph_cli/commands/security.py
+src/swarph_cli/commands/service.py
 src/swarph_cli/commands/spawn.py
 src/swarph_cli/commands/watchdog.py
 src/swarph_cli/compress/__init__.py
@@ -54,6 +55,9 @@ src/swarph_cli/gateway/server.py
 src/swarph_cli/gateway/services_control.py
 src/swarph_cli/parsers/__init__.py
 src/swarph_cli/parsers/claude.py
+src/swarph_cli/service/__init__.py
+src/swarph_cli/service/app.py
+src/swarph_cli/service/providers.py
 src/swarph_cli/systemd/swarph-watchdog.default
 src/swarph_cli/systemd/swarph-watchdog.service
 src/swarph_cli/systemd/swarph-watchdog.timer
@@ -108,6 +112,9 @@ tests/test_protocol_handler.py
 tests/test_ratify_command.py
 tests/test_repl_caller_convention.py
 tests/test_security.py
+tests/test_service_app.py
+tests/test_service_command.py
+tests/test_service_providers.py
 tests/test_session_path_role_gate.py
 tests/test_smoke_chat.py
 tests/test_smoke_one_shot.py

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/src/swarph_cli.egg-info/requires.txt

@@ -13,3 +13,8 @@ croniter>=6.2
 
 [mcp]
 mcp>=1.0
+
+[service]
+fastapi>=0.115
+uvicorn[standard]>=0.32
+pydantic>=2.9

{swarph_cli-0.17.0 → swarph_cli-0.18.0}/tests/test_caller_meta_guard.py

@@ -111,13 +111,15 @@ def test_no_modules_skipped_by_the_walk():
         try:
             importlib.import_module(mod.name)
         except Exception as e:  # noqa: BLE001 — we want to surface ANY import failure
-            # The gateway subpackage is a vendored FastAPI/uvicorn server behind the
-            # optional [gateway] extra and carries NO caller-convention surface, so it
-            # is legitimately skippable when that extra isn't installed (e.g. CI). A
-            # real bug in a gateway module (any other import error) still surfaces.
-            if (mod.name.startswith("swarph_cli.gateway")
+            # The gateway/ subpackage and service/app are vendored FastAPI/uvicorn
+            # servers behind the optional [gateway]/[service] extras and carry NO
+            # caller-convention surface, so they're legitimately skippable when that
+            # extra isn't installed (e.g. CI). A real bug in those modules (any other
+            # import error) still surfaces. (service/providers has no fastapi import,
+            # so it is always walked.)
+            if (mod.name.startswith(("swarph_cli.gateway", "swarph_cli.service.app"))
                     and isinstance(e, ModuleNotFoundError)
-                    and getattr(e, "name", None) in ("fastapi", "uvicorn")):
+                    and getattr(e, "name", None) in ("fastapi", "uvicorn", "pydantic")):
                 continue
             skipped.append((mod.name, repr(e)))
     assert not skipped, (

swarph_cli-0.18.0/tests/test_service_app.py

@@ -0,0 +1,57 @@
+"""Tests for the $0-service FastAPI app (skipped when fastapi isn't installed).
+
+The subprocess is mocked, so no real subscription CLI runs.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("fastapi")
+from fastapi.testclient import TestClient  # noqa: E402
+
+from swarph_cli.service import providers as pv  # noqa: E402
+from swarph_cli.service.app import build_app  # noqa: E402
+
+
+def _client(monkeypatch, stdout="hello from claude"):
+    class _P:
+        returncode = 0
+        stderr = ""
+
+    _P.stdout = stdout
+    monkeypatch.setattr(pv.subprocess, "run", lambda *a, **k: _P())
+    return TestClient(build_app("claude", "secret-tok"))
+
+
+def test_health_ok(monkeypatch):
+    r = _client(monkeypatch).get("/health")
+    assert r.status_code == 200
+    assert r.json()["provider"] == "claude"
+    assert r.json()["ok"] is True
+
+
+def test_delegate_requires_token(monkeypatch):
+    r = _client(monkeypatch).post("/delegate", json={"prompt": "hi"})
+    assert r.status_code == 401
+
+
+def test_delegate_bad_token_rejected(monkeypatch):
+    r = _client(monkeypatch).post("/delegate", json={"prompt": "hi"},
+                                  headers={"Authorization": "Bearer wrong"})
+    assert r.status_code == 401
+
+
+def test_delegate_runs_and_returns_zero_cost(monkeypatch):
+    r = _client(monkeypatch).post("/delegate", json={"prompt": "hi"},
+                                  headers={"Authorization": "Bearer secret-tok"})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["text"] == "hello from claude"
+    assert body["cost_usd"] == 0.0
+    assert body["provider"] == "claude"
+
+
+def test_build_app_unknown_provider_raises():
+    with pytest.raises(ValueError):
+        build_app("nope", "tok")

swarph_cli-0.18.0/tests/test_service_command.py

@@ -0,0 +1,53 @@
+"""Tests for the ``swarph service`` verb.
+
+The dep-light cases (registered / help / unknown-provider / missing-deps) run
+everywhere; the uvicorn-start case skips when the server extra isn't installed.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from swarph_cli.commands import service as sv
+
+
+def test_service_registered_in_verb_handlers():
+    from swarph_cli.main import _VERB_HANDLERS
+    assert _VERB_HANDLERS["service"] == "swarph_cli.commands.service.run_service"
+
+
+def test_service_no_subcommand_prints_help():
+    assert sv.run_service([]) == 0
+
+
+def test_service_unknown_provider_returns_2(capsys):
+    rc = sv.run_service(["serve", "--provider", "nope"])
+    assert rc == 2
+    assert "supported" in capsys.readouterr().err.lower()
+
+
+def test_service_serve_missing_deps_returns_2(capsys, monkeypatch):
+    monkeypatch.setattr(sv, "_have_server_deps", lambda: False)
+    rc = sv.run_service(["serve", "--provider", "claude"])
+    assert rc == 2
+    assert "swarph-cli[service]" in capsys.readouterr().err
+
+
+def test_service_serve_starts_uvicorn(monkeypatch):
+    pytest.importorskip("fastapi")
+    pytest.importorskip("uvicorn")
+    monkeypatch.setattr(sv, "_have_server_deps", lambda: True)
+    monkeypatch.setenv("SWARPH_SERVICE_TOKEN", "tok")
+
+    import swarph_cli.service.app as appmod
+    sentinel_app = object()
+    monkeypatch.setattr(appmod, "build_app", lambda *a, **k: sentinel_app)
+
+    import uvicorn
+    calls = {}
+    monkeypatch.setattr(uvicorn, "run", lambda app, **k: calls.update(app=app, kw=k))
+
+    rc = sv.run_service(["serve", "--provider", "claude", "--port", "9000"])
+    assert rc == 0
+    assert calls["app"] is sentinel_app
+    assert calls["kw"]["port"] == 9000

swarph_cli-0.18.0/tests/test_service_providers.py

@@ -0,0 +1,97 @@
+"""Tests for the $0-service provider core (no fastapi needed).
+
+The load-bearing security property: a $0 lane must NEVER be able to fall back to
+metered API billing. ``scrub_billing_env`` strips every known provider API-key
+var from the subprocess env, so the wrapped CLI can only use its $0 subscription
+auth (which lives in CLI config files, not these env vars).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from swarph_cli.service import providers as pv
+
+
+# --- billing-scrub (the security core) -------------------------------------
+
+def test_scrub_strips_all_known_metered_keys():
+    base = {"ANTHROPIC_API_KEY": "sk-a", "OPENAI_API_KEY": "sk-o",
+            "GEMINI_API_KEY": "g", "GOOGLE_API_KEY": "g2", "XAI_API_KEY": "x",
+            "GROK_API_KEY": "gk", "DEEPSEEK_API_KEY": "d",
+            "PATH": "/usr/bin", "HOME": "/home/u"}
+    env = pv.scrub_billing_env("claude", base)
+    for k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY",
+              "GOOGLE_API_KEY", "XAI_API_KEY", "GROK_API_KEY", "DEEPSEEK_API_KEY"):
+        assert k not in env, f"{k} not scrubbed — metered-billing leak"
+    # non-key env survives (the CLI still needs PATH/HOME for its subscription auth)
+    assert env["PATH"] == "/usr/bin" and env["HOME"] == "/home/u"
+
+
+def test_scrub_strips_every_provider_regardless_of_lane():
+    # a claude lane must not be able to bill OpenAI either (defense in depth)
+    env = pv.scrub_billing_env("claude", {"OPENAI_API_KEY": "sk-o", "PATH": "/b"})
+    assert "OPENAI_API_KEY" not in env
+
+
+def test_scrub_does_not_mutate_input():
+    base = {"ANTHROPIC_API_KEY": "sk", "PATH": "/b"}
+    pv.scrub_billing_env("claude", base)
+    assert base["ANTHROPIC_API_KEY"] == "sk"  # original env untouched
+
+
+# --- provider command map --------------------------------------------------
+
+def test_provider_command_claude():
+    assert pv.provider_command("claude", "hi") == ["claude", "-p", "hi"]
+
+
+def test_provider_command_codex():
+    assert pv.provider_command("codex", "hi") == ["codex", "exec", "hi"]
+
+
+def test_provider_command_gemini():
+    assert pv.provider_command("gemini", "hi") == ["agy", "--print", "hi"]
+
+
+def test_provider_command_unknown_raises():
+    with pytest.raises(ValueError):
+        pv.provider_command("nope", "hi")
+
+
+def test_supported_providers_exposed():
+    assert set(pv.SUPPORTED) == {"claude", "codex", "gemini"}
+
+
+# --- run_provider (subprocess, mocked) -------------------------------------
+
+def test_run_provider_scrubs_env_and_returns_stdout(monkeypatch):
+    captured = {}
+
+    class _P:
+        returncode = 0
+        stdout = "answer\n"
+        stderr = ""
+
+    def fake_run(argv, env=None, **kw):
+        captured["argv"] = argv
+        captured["env"] = env
+        return _P()
+
+    monkeypatch.setattr(pv.subprocess, "run", fake_run)
+    out = pv.run_provider("claude", "hi",
+                          base_env={"ANTHROPIC_API_KEY": "sk", "PATH": "/b"})
+    assert out == "answer"
+    assert "ANTHROPIC_API_KEY" not in captured["env"]  # scrubbed at the subprocess boundary
+    assert captured["argv"] == ["claude", "-p", "hi"]
+
+
+def test_run_provider_raises_on_nonzero(monkeypatch):
+    class _P:
+        returncode = 1
+        stdout = ""
+        stderr = "boom"
+
+    monkeypatch.setattr(pv.subprocess, "run", lambda *a, **k: _P())
+    with pytest.raises(RuntimeError):
+        pv.run_provider("claude", "hi", base_env={})