mycomesh-consumer 0.1.31 → 0.1.33

package/README.md

@@ -1,156 +1,103 @@
 # mycomesh-consumer
 
-Local-first launcher and request CLI for the MycoMesh OpenAI-compatible
-Consumer edge. With no arguments it starts the pinned Docker runtime, opens a
-local page containing the export URL and payment key, and opens Codex through
-the loopback proxy.
+Native Node.js Consumer for the MycoMesh Settlement V8 Relay network. It runs
+on the user's machine with no Docker, Python runtime, Compose file, or public
+Gateway dependency.
 
-The package is published as `mycomesh-consumer`. `mycomesh-consumer` and the
-short `mycomesh` command are equivalent.
+## Install
 
-## Requirements
-
-- Node.js 20 or newer
-- Docker Desktop/Engine with Compose V2
-- The official Codex dependency installed with this npm package
-
-For local development, install it directly from the repository:
-
-```sh
-npm install --global ./packages/mycomesh-cli
-```
-
-For an npm install from the public registry:
+Requirements: Node.js 20 or newer. The package contains only the small
+cryptographic dependencies needed for V8 EIP-712 payment-key authorizations;
+Codex is an independent client.
 
 ```sh
 npm install --global mycomesh-consumer
 mycomesh-consumer
 ```
 
-No checkout, separate Codex install, host Python, GNU Make, public Gateway URL, or command arguments are
-required. The command prints the local credentials URL and opens it when
-possible. The page contains only `OPENAI_BASE_URL` and `OPENAI_API_KEY` exports;
-the payment key is generated and persisted in a protected Docker volume. No
-wallet signature or browser session is required.
-
-The runtime image is pinned by digest. Stop it without deleting state with:
+For a checkout:
 
 ```sh
-mycomesh-consumer --stop
+npm install --global ./packages/mycomesh-cli
 ```
 
-Use `--no-browser` on a headless machine or `--no-codex` to leave only the
-local proxy running. Consumer network traffic is direct by default. Use
-`--proxy http://127.0.0.1:10792` only when a proxy is needed; loopback proxy
-hosts are translated to `host.docker.internal`. Dedicated
-`MYCOMESH_CONSUMER_*_PROXY` variables remain available for operators.
-
-Upgrading the npm package does not require clearing the payment key. The
-Consumer volume is intentionally reused so its key and routing state survive
-restarts. To reset all local Consumer state,
-use the explicit, confirmed reset command:
-
-```sh
-mycomesh-consumer --reset-local
-```
+The command starts the Consumer API on `127.0.0.1:8110`, prints and optionally
+opens the local credentials page, and stays available for any
+OpenAI-compatible client. It does not start or configure Codex.
 
-If Codex reports an interrupted request, stop Codex and run
-`mycomesh-consumer --no-codex` to restart the local edge.
+The page exposes only the local API URL, payment key/export, prepaid balance,
+key operations, and local consumption history. It has no conversation or
+request-session UI. The payment key is generated once and stored at
+`~/.mycomesh/consumer/payment-key` with mode `0600`; set
+`MYCOMESH_CONSUMER_DATA_DIR` to choose another directory.
 
-This removes the local payment key and Consumer state. The command asks you to type `RESET`
-and removes only the fixed Consumer Compose project and its protected volume.
+## Connect a client
 
-The existing stateless API commands remain available. For example:
+The default command is already service-only. Load the export block into a
+shell and then use Codex or another compatible client:
 
 ```sh
-npx --yes --package=mycomesh-consumer mycomesh-consumer health
+mycomesh-consumer --no-browser
+eval "$(curl -sS http://127.0.0.1:8110/credentials)"
+codex
 ```
 
-## Configuration
+The optional convenience wrapper is explicit:
 
 ```sh
-export MYCOMESH_BASE_URL=http://127.0.0.1:8110/v1
-export MYCOMESH_API_KEY=your-consumer-key
+mycomesh-consumer --codex
 ```
 
-`--base-url` and `--api-key` override their corresponding environment
-variables. A base URL may be the service root or end in `/v1`.
-Remote base URLs must use HTTPS. Loopback HTTP remains available for local
-development; `--allow-insecure-http` is an explicit test-only escape hatch.
-Requests default to a 300-second deadline. Set `MYCOMESH_TIMEOUT_SECONDS` or
-`--timeout`; successful JSON bodies are capped at 32 MiB while SSE remains
-streamed with backpressure.
-
-Prefer `MYCOMESH_API_KEY` over `--api-key`: command-line arguments may be stored
-in shell history or visible to other local processes. The CLI never writes the
-key to disk and redacts it from HTTP error output.
-
-The zero-argument launcher configures Codex directly with a temporary
-`mycomesh` model provider and does not modify `~/.codex/config.toml`. For manual
-API commands, read the local credentials with the repository operator command
-or provide explicit values:
+Use `--no-browser` on a headless machine. Stop the process without deleting
+the key or history with `mycomesh-consumer --stop`. A full reset is explicit:
 
 ```sh
-export MYCOMESH_BASE_URL=http://127.0.0.1:8110/v1
-export MYCOMESH_API_KEY='replace-with-local-consumer-key'
+MYCOMESH_CONFIRM_RESET=RESET mycomesh-consumer --reset-local
 ```
 
-The local proxy selects a healthy Relay and authorizes each request with the
-persisted payment key. No session identifier or per-request wallet signature is needed. A public Gateway can
-still be used explicitly with `--base-url`, but it is never the default.
-
-## Commands
+The local API is OpenAI-compatible:
 
 ```sh
-mycomesh health
-mycomesh models
+export OPENAI_BASE_URL=http://127.0.0.1:8110/v1
+export OPENAI_API_KEY='myco_sk_...'
+mycomesh responses --input 'hello' --model mycomesh-codex-standard-v1
+```
 
-mycomesh responses \
-  --input "Summarize this text" \
-  --model mycomesh-codex-standard-v1 \
-  --max-output-tokens 500
+The browser's export block is the canonical way to obtain both values.
 
-mycomesh chat \
-  --message "Explain this function" \
-  --system "Be concise." \
-  --model mycomesh-codex-standard-v1 \
-  --max-completion-tokens 500
-```
+## Relay scheduling and V8 payments
 
-The request CLI sends standard OpenAI-shaped requests. The local proxy binds
-each request to the persisted payment key automatically.
+The Consumer checks each configured Relay's V8 health and automatically tries
+the next Relay after a health, timeout, or retryable HTTP failure. A single
+request ID is preserved across failover. Each attempt carries a fresh V8
+EIP-712 payment authorization signed by the persisted key; the Relay resolves
+the key address to its on-chain grant and settles the signed receipt. No wallet
+signature or Consumer-managed conversation state is involved in inference.
 
-Use `--stream` to request SSE. SSE bytes are forwarded to stdout as they arrive,
-without rewriting event boundaries:
+Configure multiple Relay origins and an optional outbound proxy:
 
 ```sh
-mycomesh responses \
-  --input "Write a short status update" \
-  --max-output-tokens 500 \
-  --stream
+export MYCOMESH_V8_RELAY_URLS='https://relay-a.example,https://relay-b.example'
+mycomesh-consumer --proxy http://127.0.0.1:10792
 ```
 
-## JSON Input
-
-Pass an inline object, read a file, or read stdin explicitly:
+The default Relay is `https://bridge.mycomesh.xyz`. The V8 deployment and RPC
+defaults are embedded in the package; `MYCOMESH_CONSUMER_NETWORK_CONFIG` and
+`MYCOMESH_CONSUMER_SETTLEMENT_RPC_URLS` can override them for another network.
 
-```sh
-mycomesh responses --json '{"model":"my-model","input":"hello"}'
-mycomesh chat --json @request.json
-generate-request | mycomesh responses --json -
-```
+## Stateless request CLI
 
-Piped stdin is treated as JSON even without `--json`:
+The package also keeps the stateless API commands:
 
 ```sh
-printf '%s' '{"model":"my-model","messages":[{"role":"user","content":"hello"}]}' \
-  | mycomesh chat
+mycomesh health
+mycomesh models
+mycomesh responses --input 'Summarize this' --max-output-tokens 500
+mycomesh chat --message 'Explain this function'
 ```
 
-Explicit flags such as `--model`, `--input`, `--message`, `--system`, and
-`--stream` override the corresponding JSON fields. Successful JSON responses
-are pretty-printed. SSE and other response types are copied to stdout. HTTP and
-input errors are written to stderr and return a nonzero exit status.
+Use `--json @file`, `--json -`, or piped JSON for complete OpenAI-shaped
+requests. `--stream` returns buffered-compatible SSE events from the Relay.
 
 ## Development
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.1.31",
-  "description": "Local-first MycoMesh Consumer launcher and OpenAI-compatible request CLI.",
+  "version": "0.1.33",
+  "description": "Native Node.js MycoMesh Consumer and OpenAI-compatible request CLI.",
   "publishConfig": {
     "access": "public"
   },
@@ -15,15 +15,16 @@
     "bin/mycomesh-consumer.mjs",
     "src/cli.mjs",
     "src/consumer.mjs",
-    "scripts/start-consumer.sh",
-    "consumer.compose.yml",
+    "src/consumer-runtime.mjs",
     "README.md"
   ],
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
-    "@openai/codex": "0.146.0"
+    "@noble/curves": "1.9.1",
+    "@noble/hashes": "1.8.0",
+    "undici": "6.28.0"
   },
   "scripts": {
     "test": "node --test"

package/src/cli.mjs

@@ -1,7 +1,7 @@
 import { once } from "node:events";
 import { readFile } from "node:fs/promises";
 
-const CLI_VERSION = "0.1.31";
+const CLI_VERSION = "0.1.33";
 // The npm client is local-first. A public Gateway is an explicit override;
 // the default remains the loopback Consumer edge so a blocked domain cannot
 // strand the Codex client.