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

{swarph_cli-0.16.0 → swarph_cli-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.16.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
@@ -65,7 +69,9 @@ This is one of three repos in the v0.3.x architecture:
 swarph "prompt"          one-shot against any provider (claude/openai/gemini/deepseek/grok)
 swarph chat              interactive REPL — multi-turn, slash commands, live provider switch
 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)
@@ -92,6 +98,18 @@ $ swarph brain-ask --no-synth --limit 3 "cross-vendor fallback governor order"
 
 Config is via env, mirroring `swarph mesh`'s token model: `GBRAIN_MCP_URL` or `SWARPH_BRAIN_MCP` (gbrain endpoint; defaults to `http://127.0.0.1:8792/mcp`), and the read token resolved `--token-file` > `GBRAIN_TOKEN` > `SWARPH_BRAIN_TOKEN` > the mesh per-peer token (`~/.config/swarph/<self>.peer_token`) — so the mesh peer token doubles as the gbrain read token. Optional `SWARPH_FACADE` / `SWARPH_FACADE_TOKEN` enable the $0 cited-synthesis pass; without them, brain-ask prints the raw ranked chunks.
 
+### `swarph brain serve`
+
+`brain-ask` *searches* a running brain; **`brain serve`** *runs* one. gbrain (the sovereign $0 semantic-memory server) is an external binary — this verb is a thin launcher that applies the swarph-blessed defaults and replaces itself with `gbrain serve`:
+
+```bash
+$ swarph brain serve                                 # 127.0.0.1:8792, 1-year token TTL
+$ swarph brain serve --bind 100.x.y.z --port 8792    # expose on a tailnet IP
+$ swarph brain serve --gbrain-bin /opt/gbrain        # explicit binary (else GBRAIN_BIN / PATH)
+```
+
+Defaults are loopback bind (expose a tailnet IP explicitly) and a **1-year token TTL** — a short TTL silently 401s long-lived mesh cells, a lesson learned the hard way. If `gbrain` isn't on `PATH` the verb prints an install hint and exits `2`; `brain-ask` still queries any already-running brain.
+
 ### `swarph gateway`
 
 The **mesh-gateway** is the coordination/DM server every other verb talks to — the peer registry, the DM inbox/outbox, feature aggregation with allowlist + caps, and lane/service control. It used to be a separate deployment; it's now bundled, so any host can stand one up with a single command. It pairs with the client verbs (`mesh`, `spawn`, `daemon`, `watchdog`) and with `brain-ask`/gbrain to form the mesh's coordination plane.
@@ -106,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.16.0/src/swarph_cli.egg-info/PKG-INFO → swarph_cli-0.18.0/README.md

@@ -1,43 +1,3 @@
-Metadata-Version: 2.4
-Name: swarph-cli
-Version: 0.16.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
-Project-URL: Homepage, https://github.com/BrainSurfing-tech/swarph-cli
-Project-URL: Source, https://github.com/BrainSurfing-tech/swarph-cli
-Project-URL: Substrate, https://github.com/BrainSurfing-tech/swarph-mesh
-Project-URL: Spec, https://github.com/darw007d/hedge-fund-mcp/blob/main/research/swarph_cli/PLAN.md
-Keywords: swarph,llm,cli,mesh,gemini,claude,deepseek
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Utilities
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: swarph-mesh>=0.5.0
-Requires-Dist: swarph-shared>=0.3.3
-Requires-Dist: PyYAML>=6.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0; extra == "dev"
-Provides-Extra: mcp
-Requires-Dist: mcp>=1.0; extra == "mcp"
-Provides-Extra: gateway
-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"
-Dynamic: license-file
-
 # swarph-cli
 
 **One CLI for every LLM.** Drive Claude, GPT, Gemini, DeepSeek, and Grok from a single binary — then connect them into a coordinating *mesh* where agents from different vendors talk to each other through a shared protocol, each staying itself.
@@ -65,7 +25,9 @@ This is one of three repos in the v0.3.x architecture:
 swarph "prompt"          one-shot against any provider (claude/openai/gemini/deepseek/grok)
 swarph chat              interactive REPL — multi-turn, slash commands, live provider switch
 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)
@@ -92,6 +54,18 @@ $ swarph brain-ask --no-synth --limit 3 "cross-vendor fallback governor order"
 
 Config is via env, mirroring `swarph mesh`'s token model: `GBRAIN_MCP_URL` or `SWARPH_BRAIN_MCP` (gbrain endpoint; defaults to `http://127.0.0.1:8792/mcp`), and the read token resolved `--token-file` > `GBRAIN_TOKEN` > `SWARPH_BRAIN_TOKEN` > the mesh per-peer token (`~/.config/swarph/<self>.peer_token`) — so the mesh peer token doubles as the gbrain read token. Optional `SWARPH_FACADE` / `SWARPH_FACADE_TOKEN` enable the $0 cited-synthesis pass; without them, brain-ask prints the raw ranked chunks.
 
+### `swarph brain serve`
+
+`brain-ask` *searches* a running brain; **`brain serve`** *runs* one. gbrain (the sovereign $0 semantic-memory server) is an external binary — this verb is a thin launcher that applies the swarph-blessed defaults and replaces itself with `gbrain serve`:
+
+```bash
+$ swarph brain serve                                 # 127.0.0.1:8792, 1-year token TTL
+$ swarph brain serve --bind 100.x.y.z --port 8792    # expose on a tailnet IP
+$ swarph brain serve --gbrain-bin /opt/gbrain        # explicit binary (else GBRAIN_BIN / PATH)
+```
+
+Defaults are loopback bind (expose a tailnet IP explicitly) and a **1-year token TTL** — a short TTL silently 401s long-lived mesh cells, a lesson learned the hard way. If `gbrain` isn't on `PATH` the verb prints an install hint and exits `2`; `brain-ask` still queries any already-running brain.
+
 ### `swarph gateway`
 
 The **mesh-gateway** is the coordination/DM server every other verb talks to — the peer registry, the DM inbox/outbox, feature aggregation with allowlist + caps, and lane/service control. It used to be a separate deployment; it's now bundled, so any host can stand one up with a single command. It pairs with the client verbs (`mesh`, `spawn`, `daemon`, `watchdog`) and with `brain-ask`/gbrain to form the mesh's coordination plane.
@@ -106,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.16.0 → swarph_cli-0.18.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.16.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.16.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.16.0"
+__version__ = "0.18.0"
 
 __all__ = ["__version__"]

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

@@ -0,0 +1,74 @@
+"""``swarph brain`` — run the gbrain HTTP brain server (the $0 semantic memory).
+
+``brain-ask`` *searches* a running brain; ``brain serve`` *runs* one. gbrain
+(the sovereign $0 semantic-memory server) is an external binary — this verb is a
+thin launcher that applies the swarph-blessed defaults: loopback bind (expose a
+tailnet IP explicitly), and a 1-year token TTL (a short TTL silently 401s
+long-lived mesh cells — a lesson learned the hard way). It replaces the current
+process with ``gbrain serve`` via ``os.execvp`` so signals/stdio pass straight
+through.
+
+Usage:
+  swarph brain serve [--port 8792] [--bind 127.0.0.1]
+    [--token-ttl 31536000] [--gbrain-bin PATH]
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+
+_DEFAULT_PORT = 8792
+_DEFAULT_BIND = "127.0.0.1"
+_DEFAULT_TOKEN_TTL = 31536000  # 1 year — short TTLs silently 401 long-lived cells
+
+
+def _find_gbrain(explicit) -> str | None:
+    """Resolve the gbrain binary: --gbrain-bin, else GBRAIN_BIN, else PATH."""
+    if explicit:
+        return explicit if (os.path.isfile(explicit) or shutil.which(explicit)) else None
+    env = os.environ.get("GBRAIN_BIN")
+    if env and (os.path.isfile(env) or shutil.which(env)):
+        return env
+    return shutil.which("gbrain")
+
+
+def run_brain(argv: list) -> int:
+    p = argparse.ArgumentParser(
+        prog="swarph brain",
+        description="Run the gbrain HTTP brain server (the $0 semantic memory).")
+    sub = p.add_subparsers(dest="cmd")
+    serve = sub.add_parser("serve", help="run the gbrain HTTP brain server")
+    serve.add_argument("--port", type=int, default=_DEFAULT_PORT,
+                       help=f"HTTP port (default {_DEFAULT_PORT})")
+    serve.add_argument("--bind", default=_DEFAULT_BIND,
+                       help=f"bind address (default {_DEFAULT_BIND}; pass a tailnet "
+                            "IP to expose on the mesh)")
+    serve.add_argument("--token-ttl", type=int, default=_DEFAULT_TOKEN_TTL,
+                       help="minted-token lifetime in seconds (default 1 year — "
+                            "short TTLs silently 401 long-lived mesh cells)")
+    serve.add_argument("--gbrain-bin", default=None,
+                       help="path to the gbrain binary (else GBRAIN_BIN / PATH)")
+    args = p.parse_args(argv)
+
+    if args.cmd != "serve":
+        p.print_help()
+        return 0
+
+    gbin = _find_gbrain(args.gbrain_bin)
+    if not gbin:
+        print("swarph brain serve needs the `gbrain` binary on PATH (the sovereign "
+              "$0 semantic-memory server). Install it, or pass --gbrain-bin PATH / "
+              "set GBRAIN_BIN. `swarph brain-ask` queries an already-running brain.",
+              file=sys.stderr)
+        return 2
+
+    cmd = [gbin, "serve", "--http",
+           "--port", str(args.port),
+           "--bind", args.bind,
+           "--token-ttl", str(args.token_ttl)]
+    # Replace this process with gbrain so it owns the terminal / signals.
+    os.execvp(gbin, cmd)
+    return 0  # unreachable when execvp succeeds; keeps the type-checker happy

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.16.0 → swarph_cli-0.18.0}/src/swarph_cli/main.py

@@ -92,7 +92,9 @@ _VERB_HANDLERS: dict[str, str] = {
     "compress": "swarph_cli.commands.compress.run_compress",
     "cell": "swarph_cli.commands.cell.run_cell",
     "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.16.0/README.md → swarph_cli-0.18.0/src/swarph_cli.egg-info/PKG-INFO

@@ -1,3 +1,47 @@
+Metadata-Version: 2.4
+Name: swarph-cli
+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
+Project-URL: Homepage, https://github.com/BrainSurfing-tech/swarph-cli
+Project-URL: Source, https://github.com/BrainSurfing-tech/swarph-cli
+Project-URL: Substrate, https://github.com/BrainSurfing-tech/swarph-mesh
+Project-URL: Spec, https://github.com/darw007d/hedge-fund-mcp/blob/main/research/swarph_cli/PLAN.md
+Keywords: swarph,llm,cli,mesh,gemini,claude,deepseek
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: swarph-mesh>=0.5.0
+Requires-Dist: swarph-shared>=0.3.3
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: gateway
+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
 
 **One CLI for every LLM.** Drive Claude, GPT, Gemini, DeepSeek, and Grok from a single binary — then connect them into a coordinating *mesh* where agents from different vendors talk to each other through a shared protocol, each staying itself.
@@ -25,7 +69,9 @@ This is one of three repos in the v0.3.x architecture:
 swarph "prompt"          one-shot against any provider (claude/openai/gemini/deepseek/grok)
 swarph chat              interactive REPL — multi-turn, slash commands, live provider switch
 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)
@@ -52,6 +98,18 @@ $ swarph brain-ask --no-synth --limit 3 "cross-vendor fallback governor order"
 
 Config is via env, mirroring `swarph mesh`'s token model: `GBRAIN_MCP_URL` or `SWARPH_BRAIN_MCP` (gbrain endpoint; defaults to `http://127.0.0.1:8792/mcp`), and the read token resolved `--token-file` > `GBRAIN_TOKEN` > `SWARPH_BRAIN_TOKEN` > the mesh per-peer token (`~/.config/swarph/<self>.peer_token`) — so the mesh peer token doubles as the gbrain read token. Optional `SWARPH_FACADE` / `SWARPH_FACADE_TOKEN` enable the $0 cited-synthesis pass; without them, brain-ask prints the raw ranked chunks.
 
+### `swarph brain serve`
+
+`brain-ask` *searches* a running brain; **`brain serve`** *runs* one. gbrain (the sovereign $0 semantic-memory server) is an external binary — this verb is a thin launcher that applies the swarph-blessed defaults and replaces itself with `gbrain serve`:
+
+```bash
+$ swarph brain serve                                 # 127.0.0.1:8792, 1-year token TTL
+$ swarph brain serve --bind 100.x.y.z --port 8792    # expose on a tailnet IP
+$ swarph brain serve --gbrain-bin /opt/gbrain        # explicit binary (else GBRAIN_BIN / PATH)
+```
+
+Defaults are loopback bind (expose a tailnet IP explicitly) and a **1-year token TTL** — a short TTL silently 401s long-lived mesh cells, a lesson learned the hard way. If `gbrain` isn't on `PATH` the verb prints an install hint and exits `2`; `brain-ask` still queries any already-running brain.
+
 ### `swarph gateway`
 
 The **mesh-gateway** is the coordination/DM server every other verb talks to — the peer registry, the DM inbox/outbox, feature aggregation with allowlist + caps, and lane/service control. It used to be a separate deployment; it's now bundled, so any host can stand one up with a single command. It pairs with the client verbs (`mesh`, `spawn`, `daemon`, `watchdog`) and with `brain-ask`/gbrain to form the mesh's coordination plane.
@@ -66,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.16.0 → swarph_cli-0.18.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ src/swarph_cli/capture/paths.py
 src/swarph_cli/capture/verify.py
 src/swarph_cli/commands/__init__.py
 src/swarph_cli/commands/add.py
+src/swarph_cli/commands/brain.py
 src/swarph_cli/commands/brain_ask.py
 src/swarph_cli/commands/cell.py
 src/swarph_cli/commands/chat.py
@@ -39,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
@@ -53,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
@@ -65,6 +70,7 @@ tests/test_artifact_skill.py
 tests/test_artifact_tool.py
 tests/test_artifact_uri.py
 tests/test_brain_ask_command.py
+tests/test_brain_command.py
 tests/test_caller_meta_guard.py
 tests/test_capture_lineage.py
 tests/test_capture_liveness.py
@@ -106,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.16.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