@nopeek/agent-bridge 0.1.0

package/README.md

@@ -0,0 +1,195 @@
+# @nopeek/agent-bridge
+
+Run your own AI agents as **end-to-end-encrypted NoPeek bots** — from your Mac, a Linux box, or a Raspberry Pi.
+
+The bridge is a small always-on process that:
+
+1. **Pairs** with your NoPeek account using a one-time pairing code (`npr_…`) from the NoPeek app ("Connect your computer").
+2. **Runs every bot you own** — each bot connects as a real NoPeek user with its own server device, publishes MLS key packages, and decrypts messages locally like any other client. The server never sees plaintext.
+3. **Pipes each incoming message to your "brain"** — any shell command (message on stdin, reply on stdout) or any HTTP webhook — and sends the reply back into the encrypted channel.
+
+When you create a new bot in the NoPeek app, the bridge adopts it live over its control connection. No restart, no redeploy.
+
+## Quick start
+
+```bash
+# Zero config: bots run in echo mode ("You said: …") — a smoke test
+npx @nopeek/agent-bridge --pair npr_XXXXXXXX --app-id app_XXXXXXXX
+
+# Plug in a real agent runtime (Hermes example):
+npx @nopeek/agent-bridge \
+  --pair npr_XXXXXXXX \
+  --app-id app_XXXXXXXX \
+  --brain-cmd 'HERMES_HOME=/Volumes/x10drive/hermes hermes --profile nopeek chat -Q -q "$(cat)"'
+```
+
+That's it. Every bot you own answers in every chat it's a member of. Add a bot to a group in the NoPeek app and it just starts working.
+
+## How the brain works
+
+The bridge is runtime-agnostic on purpose. A "brain" turns a message into a reply, and there are three flavors:
+
+### 1. Command brain (`--brain-cmd` / `BRAIN_CMD`)
+
+The bridge spawns `bash -c "<your command>"`, writes the user's message text to **stdin**, and takes trimmed **stdout** as the reply. ANSI escape codes are stripped automatically (agent CLIs like Hermes colorize their output).
+
+Context is passed as environment variables:
+
+| Variable | Meaning |
+| --- | --- |
+| `NOPEEK_BOT_HANDLE` | handle of the bot answering |
+| `NOPEEK_BOT_USER_ID` | user id of the bot |
+| `NOPEEK_CHANNEL_ID` | channel the message arrived in |
+| `NOPEEK_SENDER_USER_ID` | who sent the message |
+
+Examples:
+
+```bash
+# Hermes
+--brain-cmd 'HERMES_HOME=/Volumes/x10drive/hermes hermes --profile nopeek chat -Q -q "$(cat)"'
+
+# OpenClaw, Claude Code, llm, anything that reads a prompt and prints an answer
+--brain-cmd 'openclaw ask --stdin'
+--brain-cmd 'llm -m gpt-4o "$(cat)"'
+
+# Route per channel inside your own script
+--brain-cmd '/home/me/route.sh'   # read stdin, inspect $NOPEEK_CHANNEL_ID, print reply
+```
+
+On non-zero exit, timeout, or empty output the bridge logs the error and sends a short friendly fallback so the chat never goes silent.
+
+### 2. Webhook brain (`--brain-url` / `BRAIN_URL`)
+
+The bridge POSTs JSON to your endpoint and expects `{ "text": "…" }` (or `{ "reply": "…" }`) back:
+
+```
+POST <your url>
+Content-Type: application/json
+
+{
+  "text": "what's the weather?",
+  "botHandle": "weatherbot",
+  "botUserId": "usr_…",
+  "channelId": "ch_…",
+  "senderUserId": "usr_…"
+}
+```
+
+Minimal server:
+
+```js
+// node server.mjs
+import { createServer } from "node:http";
+createServer((req, res) => {
+  let body = "";
+  req.on("data", (d) => (body += d));
+  req.on("end", async () => {
+    const { text } = JSON.parse(body);
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({ text: `You asked: ${text}` }));
+  });
+}).listen(9000);
+```
+
+```bash
+npx @nopeek/agent-bridge --pair npr_… --app-id app_… --brain-url http://localhost:9000
+```
+
+### 3. Echo (default)
+
+With no brain configured, every bot replies `You said: <text>`. Use it to verify pairing and E2EE end to end before wiring a real agent.
+
+### Per-bot brains (`BRAIN_MAP`)
+
+Different bots, different brains. `BRAIN_MAP` is a JSON object keyed by bot handle; each entry is `{"cmd": "…"}` or `{"url": "…"}`:
+
+```bash
+BRAIN_MAP='{
+  "hermesbot": {"cmd": "HERMES_HOME=/Volumes/x10drive/hermes hermes --profile nopeek chat -Q -q \"$(cat)\""},
+  "weatherbot": {"url": "http://localhost:9000/weather"}
+}' npx @nopeek/agent-bridge --pair npr_… --app-id app_…
+```
+
+Resolution order per bot: `BRAIN_MAP[handle]` → global `BRAIN_CMD` → global `BRAIN_URL` → echo.
+
+## Configuration
+
+Everything can be set three ways, highest precedence first: **CLI flag → environment variable → `nopeek-bridge.config.json`** (same key names as the env vars, in the working directory or via `--config <path>`).
+
+| Flag | Env var | Default | Meaning |
+| --- | --- | --- | --- |
+| `--pair` | `NOPEEK_PAIRING_CODE` | *(required)* | One-time pairing code from the NoPeek app (`npr_…`) |
+| `--app-id` | `NOPEEK_APP_ID` | *(required)* | Your NoPeek app id (shown with the pairing code) |
+| `--api-url` | `NOPEEK_API_URL` | `https://d3qweh72vesa98.cloudfront.net` | NoPeek API base |
+| `--brain-cmd` | `BRAIN_CMD` | — | Global command brain |
+| `--brain-url` | `BRAIN_URL` | — | Global webhook brain |
+| `--brain-map` | `BRAIN_MAP` | `{}` | Per-handle overrides (JSON) |
+| `--brain-timeout-ms` | `BRAIN_TIMEOUT_MS` | `180000` | Brain timeout (generous: agent runtimes think slowly) |
+| `--port` | `NOPEEK_BRIDGE_PORT` | `8790` | Health endpoint port |
+| `--data-dir` | `NOPEEK_BRIDGE_DATA_DIR` | `./data` | Per-bot device-key store directory |
+| `--config` | — | `./nopeek-bridge.config.json` | Config file path |
+
+Example config file:
+
+```json
+{
+  "NOPEEK_PAIRING_CODE": "npr_XXXXXXXX",
+  "NOPEEK_APP_ID": "app_XXXXXXXX",
+  "BRAIN_CMD": "HERMES_HOME=/Volumes/x10drive/hermes hermes --profile nopeek chat -Q -q \"$(cat)\""
+}
+```
+
+## Health endpoint
+
+`GET http://localhost:8790/` →
+
+```json
+{
+  "ok": true,
+  "runtime": "rt_…",
+  "bots": [
+    { "handle": "hermesbot", "userId": "usr_…", "connected": true, "handled": 12 }
+  ],
+  "uptime": 3600
+}
+```
+
+`ok` reflects the control connection; each bot reports its own connection and how many messages it has answered.
+
+## Behavior & reliability
+
+- **Live adoption** — create a bot in the app and the bridge starts running it within seconds (control WebSocket push), plus a full re-sync on every reconnect so nothing is missed.
+- **Isolation** — each bot runs independently with its own retry/backoff loop; one misbehaving bot never affects the others.
+- **Reconnects** — the control socket and every bot connection reconnect forever with capped exponential backoff. Runtime sessions are refreshed before they expire.
+- **Dedupe** — redelivered messages are never answered twice.
+- **Crash guards** — unhandled rejections/exceptions are logged and survived; the process only exits on config errors (clearly, at startup) or a signal.
+- **Typing indicator** — shown while the brain is thinking.
+
+## Security notes
+
+- Messages are E2EE (MLS): decryption happens **on your machine**, inside this process. The NoPeek server only ever relays ciphertext.
+- Your API keys, agent credentials, and brain commands are yours — the bridge never sends them anywhere. Brains run locally (or on the webhook host **you** choose).
+- The only state written to disk is `./data/<botUserId>.json`: each bot's device identity and channel keys, needed so restarts keep the same device. Treat that directory like a private key (it is one) — it's `.gitignore`d, and you can move it with `--data-dir`.
+- The pairing code is a bearer credential for *running your bots*, nothing more. Revoke it from the NoPeek app at any time; the bridge simply stops authenticating.
+
+## Running it long-term
+
+Anything that keeps a process alive works. For example, on Linux:
+
+```ini
+# /etc/systemd/system/nopeek-bridge.service
+[Service]
+Environment=NOPEEK_PAIRING_CODE=npr_…
+Environment=NOPEEK_APP_ID=app_…
+Environment=BRAIN_CMD=…
+WorkingDirectory=/home/me/nopeek-bridge
+ExecStart=/usr/bin/npx @nopeek/agent-bridge
+Restart=always
+```
+
+On macOS, a `launchd` plist or just `tmux` works fine.
+
+## Requirements
+
+- Node.js **22+** (global `fetch`, `WebSocket`, WebCrypto — no polyfills needed).
+- `bash` on PATH if you use a command brain.

package/dist/bot.d.ts

@@ -0,0 +1,37 @@
+import type { BridgeConfig } from "./config.js";
+export interface BotInfo {
+    userId: string;
+    handle: string;
+    nickname?: string;
+    ownerType?: string;
+    ownerId?: string;
+}
+export declare class BotRunner {
+    readonly info: BotInfo;
+    connected: boolean;
+    handled: number;
+    brainKind: string;
+    private cfg;
+    private brain;
+    private np;
+    private stopped;
+    private refreshTimer;
+    private seen;
+    private channelCache;
+    private log;
+    private logErr;
+    constructor(info: BotInfo, cfg: BridgeConfig);
+    /** Fire-and-forget: runs the connect loop in the background, isolated. */
+    start(): void;
+    stop(): void;
+    private mintSession;
+    private run;
+    private connectOnce;
+    /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
+    private scheduleRefresh;
+    private reconnect;
+    private getChannel;
+    /** Bounded dedupe so a redelivered frame is never answered twice. */
+    private remember;
+    private handleMessage;
+}

package/dist/bot.js

@@ -0,0 +1,234 @@
+// One running bot: mints a runtime session from the pairing token, connects to
+// NoPeek AS the bot user (server device, MLS key packages published), listens
+// for decrypted messages and answers through the resolved brain. Failures are
+// isolated — a broken bot retries with backoff and never takes down its peers.
+import { NoPeek } from "@nopeek/chat";
+import { resolveBrain } from "./brain.js";
+import { FileStore } from "./storage.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const MAX_BACKOFF_MS = 60_000;
+// Refresh the bot session 5 min before it expires (clamped to a sane window).
+const REFRESH_MARGIN_MS = 5 * 60_000;
+const MAX_REFRESH_DELAY_MS = 6 * 24 * 60 * 60_000;
+export class BotRunner {
+    info;
+    connected = false;
+    handled = 0;
+    brainKind;
+    cfg;
+    brain;
+    np = null;
+    stopped = false;
+    refreshTimer = null;
+    seen = new Set();
+    channelCache = new Map();
+    log;
+    logErr;
+    constructor(info, cfg) {
+        this.info = info;
+        this.cfg = cfg;
+        const resolved = resolveBrain(cfg, info.handle);
+        this.brain = resolved.brain;
+        this.brainKind = resolved.kind;
+        const tag = `[bot:@${info.handle}]`;
+        this.log = (m) => console.log(`${tag} ${m}`);
+        this.logErr = (m) => console.error(`${tag} ${m}`);
+    }
+    /** Fire-and-forget: runs the connect loop in the background, isolated. */
+    start() {
+        void this.run().catch((err) => {
+            this.logErr(`runner crashed (bot stays down until restart): ${err.message}`);
+        });
+    }
+    stop() {
+        this.stopped = true;
+        if (this.refreshTimer)
+            clearTimeout(this.refreshTimer);
+        try {
+            this.np?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        this.np = null;
+        this.connected = false;
+    }
+    async mintSession() {
+        const res = await fetch(`${this.cfg.apiUrl}/v1/apps/${this.cfg.appId}/bots/${this.info.userId}/runtime-session`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.cfg.pairingCode}`,
+                "content-type": "application/json",
+            },
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`runtime-session HTTP ${res.status}: ${body.slice(0, 300)}`);
+        }
+        return (await res.json());
+    }
+    async run() {
+        this.log(`starting (${this.info.userId}) brain=${this.brainKind}`);
+        let delay = 2_000;
+        while (!this.stopped) {
+            try {
+                await this.connectOnce();
+                return; // connected; SDK auto-reconnects, session refresh re-enters via reconnect()
+            }
+            catch (err) {
+                this.logErr(`connect failed: ${err.message} — retrying in ${delay / 1000}s`);
+                await sleep(delay);
+                delay = Math.min(delay * 2, MAX_BACKOFF_MS);
+            }
+        }
+    }
+    async connectOnce() {
+        const session = await this.mintSession();
+        const store = new FileStore(this.cfg.dataDir, this.info.userId);
+        // platform:'server' + NO deferDeviceRegistration: on first connect the SDK
+        // registers a fresh device and publishes MLS key packages, which is exactly
+        // what a bot wants — peers claim those packages to send it welcomes. The
+        // FileStore makes restarts reuse the same device instead of minting new ones.
+        const np = await NoPeek.connect({
+            apiUrl: this.cfg.apiUrl,
+            sessionToken: session.sessionToken,
+            appId: this.cfg.appId,
+            userId: this.info.userId,
+            platform: "server",
+            storage: store,
+        });
+        if (this.stopped) {
+            np.close();
+            return;
+        }
+        this.np = np;
+        this.connected = true;
+        this.channelCache.clear();
+        this.log(`connected, device ${np.deviceId} (platform=server), store ${store.file}`);
+        np.on("connected", (() => {
+            this.connected = true;
+            this.log(`ws connected`);
+        }));
+        np.on("disconnected", (() => {
+            this.connected = false;
+            this.log(`ws disconnected — SDK will auto-reconnect`);
+        }));
+        np.on("channelKeyReceived", ((p) => {
+            this.log(`received channel key for ${p.channelId} (welcome ceremony completed)`);
+        }));
+        np.on("message", ((m) => {
+            void this.handleMessage(m).catch((err) => {
+                this.logErr(`handler error for ${m.messageId}: ${err.message}`);
+            });
+        }));
+        this.scheduleRefresh(session.expiresAt);
+    }
+    /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
+    scheduleRefresh(expiresAt) {
+        if (this.refreshTimer)
+            clearTimeout(this.refreshTimer);
+        if (!expiresAt)
+            return;
+        const at = Date.parse(expiresAt);
+        if (!Number.isFinite(at))
+            return;
+        const delay = Math.min(Math.max(at - Date.now() - REFRESH_MARGIN_MS, 60_000), MAX_REFRESH_DELAY_MS);
+        this.refreshTimer = setTimeout(() => {
+            this.log(`runtime session nearing expiry — reconnecting with a fresh one`);
+            void this.reconnect();
+        }, delay);
+        this.refreshTimer.unref?.();
+    }
+    async reconnect() {
+        if (this.stopped)
+            return;
+        try {
+            this.np?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        this.np = null;
+        this.connected = false;
+        await this.run();
+    }
+    async getChannel(channelId) {
+        let ch = this.channelCache.get(channelId);
+        if (!ch) {
+            ch = await this.np.channels.get(channelId);
+            this.channelCache.set(channelId, ch);
+        }
+        return ch;
+    }
+    /** Bounded dedupe so a redelivered frame is never answered twice. */
+    remember(id) {
+        this.seen.add(id);
+        if (this.seen.size > 5_000) {
+            // Set iterates in insertion order — drop the oldest fifth.
+            let n = 1_000;
+            for (const k of this.seen) {
+                this.seen.delete(k);
+                if (--n === 0)
+                    break;
+            }
+        }
+    }
+    async handleMessage(m) {
+        if (this.seen.has(m.messageId))
+            return;
+        this.remember(m.messageId);
+        if (m.senderUserId === this.info.userId)
+            return; // never answer ourselves
+        if (m.decryptionFailed) {
+            // Likely a missed welcome (message arrived before our key). Sync the key
+            // so the NEXT message decrypts; this frame's plaintext is unrecoverable.
+            this.logErr(`could not decrypt ${m.messageId} in ${m.channelId} — syncing channel key`);
+            try {
+                await (await this.getChannel(m.channelId)).ensureKey();
+            }
+            catch (err) {
+                this.logErr(`ensureKey(${m.channelId}) failed: ${err.message}`);
+            }
+            return;
+        }
+        if (m.body?.type !== "text" || typeof m.body.text !== "string" || !m.body.text.trim())
+            return;
+        // TODO(grants): enforce per-channel grants once bot_grant_changed carries
+        // enough to build an allowlist. v1 answers everyone in any channel the bot
+        // is a member of; the control socket already logs grant changes.
+        const text = m.body.text;
+        this.log(`${m.channelId} <- ${m.senderUserId}: ${text.slice(0, 120)}`);
+        const ch = await this.getChannel(m.channelId);
+        ch.markRead(m.messageId).catch(() => { });
+        try {
+            ch.typing(true);
+        }
+        catch {
+            /* typing is best-effort */
+        }
+        let reply = "";
+        try {
+            reply = await this.brain(text, {
+                botHandle: this.info.handle,
+                botUserId: this.info.userId,
+                channelId: m.channelId,
+                senderUserId: m.senderUserId,
+            });
+        }
+        finally {
+            try {
+                ch.typing(false);
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        if (!reply || !reply.trim()) {
+            this.log(`brain returned empty reply — ignoring`);
+            return;
+        }
+        await ch.send({ text: reply.trim() });
+        this.handled++;
+        this.log(`${m.channelId} -> replied (${reply.trim().length} chars, handled=${this.handled})`);
+    }
+}

package/dist/brain.d.ts

@@ -0,0 +1,20 @@
+import type { BridgeConfig } from "./config.js";
+export interface BrainContext {
+    botHandle: string;
+    botUserId: string;
+    channelId: string;
+    senderUserId: string;
+}
+export type Brain = (text: string, ctx: BrainContext) => Promise<string>;
+export declare const FALLBACK_REPLY = "Sorry \u2014 I hit an error processing that. Please try again.";
+export declare function stripAnsi(s: string): string;
+export interface ResolvedBrain {
+    brain: Brain;
+    /** Human-readable description for logs/health, e.g. `cmd (per-bot)` or `echo`. */
+    kind: string;
+}
+/**
+ * Pick the brain for one bot:
+ * BRAIN_MAP[handle] (cmd beats url within an entry) > BRAIN_CMD > BRAIN_URL > echo.
+ */
+export declare function resolveBrain(cfg: BridgeConfig, handle: string): ResolvedBrain;

package/dist/brain.js

@@ -0,0 +1,133 @@
+// Generic brain contract: (text, ctx) -> reply string. Resolved PER BOT:
+//   1. BRAIN_MAP["<handle>"] -> {"cmd": "…"} or {"url": "…"}
+//   2. global BRAIN_CMD (shell, stdin -> stdout)
+//   3. global BRAIN_URL (webhook, JSON in -> JSON out)
+//   4. echo ("You said: …") — zero-config smoke test
+// This is how ANY agentic runtime plugs in (Hermes, OpenClaw, a curl to your
+// own service): the bridge never knows or cares what's on the other side.
+import { spawn } from "node:child_process";
+export const FALLBACK_REPLY = "Sorry — I hit an error processing that. Please try again.";
+// ANSI escape sequences (CSI, OSC, and lone ESC controls). Agent runtimes like
+// Hermes color their stdout; the chat must receive plain text.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = 
+// eslint-disable-next-line no-control-regex
+/[\u001B\u009B](?:[\[\]()#;?]*(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?(?:\u0007|\u001B\\)|(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+/**
+ * Shell brain: spawn `bash -c "<cmd>"`, write the user's message to stdin,
+ * take trimmed (ANSI-stripped) stdout as the reply. Context rides in env vars:
+ * NOPEEK_BOT_HANDLE, NOPEEK_BOT_USER_ID, NOPEEK_CHANNEL_ID, NOPEEK_SENDER_USER_ID.
+ */
+function cmdBrain(cmd, timeoutMs) {
+    return (text, ctx) => new Promise((resolvePromise) => {
+        const child = spawn("bash", ["-c", cmd], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                NOPEEK_BOT_HANDLE: ctx.botHandle,
+                NOPEEK_BOT_USER_ID: ctx.botUserId,
+                NOPEEK_CHANNEL_ID: ctx.channelId,
+                NOPEEK_SENDER_USER_ID: ctx.senderUserId,
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (reply) => {
+            if (!settled) {
+                settled = true;
+                resolvePromise(reply);
+            }
+        };
+        const timer = setTimeout(() => {
+            console.error(`[brain:cmd:@${ctx.botHandle}] timed out after ${timeoutMs / 1000}s, killing`);
+            child.kill("SIGKILL");
+            finish(stripAnsi(stdout).trim() || FALLBACK_REPLY);
+        }, timeoutMs);
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            console.error(`[brain:cmd:@${ctx.botHandle}] spawn error: ${err.message}`);
+            finish(FALLBACK_REPLY);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const reply = stripAnsi(stdout).trim();
+            if (code !== 0) {
+                console.error(`[brain:cmd:@${ctx.botHandle}] exit ${code}. stderr: ${stderr.slice(0, 2000)}`);
+                finish(reply || FALLBACK_REPLY);
+                return;
+            }
+            if (!reply) {
+                console.error(`[brain:cmd:@${ctx.botHandle}] command produced empty stdout`);
+                finish(FALLBACK_REPLY);
+                return;
+            }
+            finish(reply);
+        });
+        child.stdin.on("error", () => {
+            /* command may exit before reading stdin — close handler settles */
+        });
+        child.stdin.write(text);
+        child.stdin.end();
+    });
+}
+/**
+ * Webhook brain: POST {text, botHandle, botUserId, channelId, senderUserId}
+ * as JSON; accept {text: "…"} or {reply: "…"} back.
+ */
+function urlBrain(url, timeoutMs) {
+    return async (text, ctx) => {
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal: AbortSignal.timeout(timeoutMs),
+                body: JSON.stringify({
+                    text,
+                    botHandle: ctx.botHandle,
+                    botUserId: ctx.botUserId,
+                    channelId: ctx.channelId,
+                    senderUserId: ctx.senderUserId,
+                }),
+            });
+            if (!res.ok) {
+                console.error(`[brain:url:@${ctx.botHandle}] HTTP ${res.status} from ${url}`);
+                return FALLBACK_REPLY;
+            }
+            const json = (await res.json());
+            const reply = typeof json.text === "string" ? json.text : typeof json.reply === "string" ? json.reply : "";
+            if (!reply.trim()) {
+                console.error(`[brain:url:@${ctx.botHandle}] webhook returned no {text} or {reply}`);
+                return FALLBACK_REPLY;
+            }
+            return reply.trim();
+        }
+        catch (err) {
+            console.error(`[brain:url:@${ctx.botHandle}] ${err.message}`);
+            return FALLBACK_REPLY;
+        }
+    };
+}
+/** Zero-config smoke test. */
+const echoBrain = async (text) => `You said: ${text}`;
+/**
+ * Pick the brain for one bot:
+ * BRAIN_MAP[handle] (cmd beats url within an entry) > BRAIN_CMD > BRAIN_URL > echo.
+ */
+export function resolveBrain(cfg, handle) {
+    const override = cfg.brainMap[handle.replace(/^@/, "")];
+    if (override?.cmd)
+        return { brain: cmdBrain(override.cmd, cfg.brainTimeoutMs), kind: "cmd (per-bot)" };
+    if (override?.url)
+        return { brain: urlBrain(override.url, cfg.brainTimeoutMs), kind: "url (per-bot)" };
+    if (cfg.brainCmd)
+        return { brain: cmdBrain(cfg.brainCmd, cfg.brainTimeoutMs), kind: "cmd" };
+    if (cfg.brainUrl)
+        return { brain: urlBrain(cfg.brainUrl, cfg.brainTimeoutMs), kind: "url" };
+    return { brain: echoBrain, kind: "echo" };
+}

package/dist/bridge.d.ts

@@ -0,0 +1,5 @@
+import type { BridgeConfig } from "./config.js";
+export interface Bridge {
+    stop(): void;
+}
+export declare function runBridge(cfg: BridgeConfig): Promise<Bridge>;

package/dist/bridge.js

@@ -0,0 +1,84 @@
+// Orchestrator: pairs this machine as a NoPeek runtime, discovers every bot it
+// owns (GET /runtime/bots), runs each as an isolated BotRunner, and keeps the
+// fleet current via the control WebSocket (adopt_bot arrives live — no restart).
+import { createServer } from "node:http";
+import { BotRunner } from "./bot.js";
+import { ControlSocket } from "./control.js";
+export async function runBridge(cfg) {
+    const startedAt = Date.now();
+    const bots = new Map(); // botUserId -> runner
+    // ------------------------------------------------------------- bot fleet --
+    const startBot = (info) => {
+        if (bots.has(info.userId))
+            return; // already running
+        const runner = new BotRunner(info, cfg);
+        bots.set(info.userId, runner);
+        runner.start(); // background; failures are isolated inside the runner
+    };
+    /** Fetch the authoritative bot list and start anything we're missing. */
+    const syncBots = async () => {
+        const res = await fetch(`${cfg.apiUrl}/v1/apps/${cfg.appId}/runtime/bots`, {
+            headers: { authorization: `Bearer ${cfg.pairingCode}` },
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`GET /runtime/bots HTTP ${res.status}: ${body.slice(0, 300)}`);
+        }
+        const { bots: list } = (await res.json());
+        console.log(`[bridge] runtime owns ${list.length} bot(s): ${list.map((b) => `@${b.handle}`).join(", ") || "(none yet)"}`);
+        for (const info of list)
+            startBot(info);
+    };
+    // ---------------------------------------------------------- control sock --
+    const control = new ControlSocket(cfg, {
+        onAuthed: () => {
+            // Initial connect AND every reconnect: catch up on bots created while
+            // we were away (adopt_bot frames we may have missed).
+            void syncBots().catch((err) => {
+                console.error(`[bridge] bot sync failed: ${err.message}`);
+            });
+        },
+        onAdoptBot: (f) => {
+            startBot({ userId: f.botUserId, handle: f.handle, ownerId: f.ownerUserId });
+        },
+        onGrantChanged: () => {
+            // v1: logged by ControlSocket. TODO(grants): pass down to the affected
+            // BotRunner and enforce an allowlist before answering.
+        },
+    });
+    // ---------------------------------------------------------------- health --
+    const health = createServer((_req, res) => {
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({
+            ok: control.connected,
+            runtime: control.runtimeId,
+            bots: [...bots.values()].map((b) => ({
+                handle: b.info.handle,
+                userId: b.info.userId,
+                connected: b.connected,
+                handled: b.handled,
+            })),
+            uptime: Math.round((Date.now() - startedAt) / 1000),
+        }));
+    });
+    health.listen(cfg.port, () => console.log(`[health] http://localhost:${cfg.port}/ -> {ok, runtime, bots, uptime}`));
+    // ----------------------------------------------------------------- start --
+    // Bots first (so a control-socket hiccup doesn't delay serving), then the
+    // control socket, whose auth.ok triggers a redundant-but-safe re-sync.
+    try {
+        await syncBots();
+    }
+    catch (err) {
+        // Non-fatal: the control socket's onAuthed will retry the sync.
+        console.error(`[bridge] initial bot sync failed (will retry on control auth): ${err.message}`);
+    }
+    control.start();
+    return {
+        stop() {
+            control.stop();
+            for (const b of bots.values())
+                b.stop();
+            health.close();
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// @nopeek/agent-bridge — connect your own agent runtime to NoPeek as E2EE bots.
+//   npx @nopeek/agent-bridge --pair npr_… --app-id app_… --brain-cmd '…'
+import { loadConfig, HELP } from "./config.js";
+import { runBridge } from "./bridge.js";
+// ---------------------------------------------------------------- guards ----
+// The bridge must never die to a stray rejection deep inside a WS/crypto
+// callback — one flaky bot cannot take the fleet down.
+process.on("unhandledRejection", (reason) => {
+    console.error(`[fatal-guard] unhandled rejection (continuing):`, reason);
+});
+process.on("uncaughtException", (err) => {
+    console.error(`[fatal-guard] uncaught exception (continuing):`, err);
+});
+if (typeof WebSocket === "undefined" || !globalThis.crypto?.subtle) {
+    console.error(`@nopeek/agent-bridge needs Node >= 22 (global WebSocket + fetch + WebCrypto). Current: ${process.version}`);
+    process.exit(1);
+}
+// ---------------------------------------------------------------- config ----
+// Config errors exit cleanly with guidance — never a crash loop.
+let cfg;
+try {
+    cfg = loadConfig();
+}
+catch (err) {
+    console.error(`[config] ${err.message}\n`);
+    console.error(HELP);
+    process.exit(1);
+}
+console.log(`[bridge] NoPeek agent-bridge starting`);
+console.log(`[bridge] api=${cfg.apiUrl} app=${cfg.appId} data=${cfg.dataDir} health=:${cfg.port}`);
+console.log(`[bridge] default brain: ${cfg.brainCmd ? "cmd" : cfg.brainUrl ? "url" : "echo (set --brain-cmd or --brain-url to plug in your agent)"}` +
+    (Object.keys(cfg.brainMap).length ? ` + ${Object.keys(cfg.brainMap).length} per-bot override(s)` : ""));
+const bridge = await runBridge(cfg);
+const shutdown = (signal) => {
+    console.log(`[bridge] ${signal} — shutting down`);
+    bridge.stop();
+    // Give sockets a beat to close, then force-exit so systemd/launchd restarts cleanly.
+    setTimeout(() => process.exit(0), 500).unref();
+};
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+/** Per-bot brain override, keyed by bot handle in BRAIN_MAP. */
+export interface BrainSpec {
+    cmd?: string;
+    url?: string;
+}
+export interface BridgeConfig {
+    /** NoPeek API base, e.g. https://d3qweh72vesa98.cloudfront.net */
+    apiUrl: string;
+    appId: string;
+    /** Runtime pairing token from the NoPeek app ("Connect your computer"), npr_… */
+    pairingCode: string;
+    /** Global brain: shell command reading the message on stdin, printing the reply. */
+    brainCmd: string | null;
+    /** Global brain: webhook POSTed {text, botHandle, botUserId, channelId, senderUserId}. */
+    brainUrl: string | null;
+    /** Per-handle overrides: { "<handle>": {"cmd": "…"} | {"url": "…"} }. */
+    brainMap: Record<string, BrainSpec>;
+    brainTimeoutMs: number;
+    /** Health endpoint port. */
+    port: number;
+    /** Where per-bot device identity/key stores live (./data by default). */
+    dataDir: string;
+}
+export declare const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
+export declare const DEFAULT_PORT = 8790;
+export declare const DEFAULT_BRAIN_TIMEOUT_MS = 180000;
+export declare const HELP = "nopeek-agent-bridge \u2014 run your agents as E2EE NoPeek bots\n\nUsage:\n  npx @nopeek/agent-bridge --pair npr_\u2026 --app-id app_\u2026 [--brain-cmd '\u2026' | --brain-url https://\u2026]\n\nOptions:\n  --pair <code>            One-time pairing code from the NoPeek app  (env NOPEEK_PAIRING_CODE)\n  --app-id <id>            NoPeek app id                              (env NOPEEK_APP_ID)\n  --api-url <url>          API base, default https://d3qweh72vesa98.cloudfront.net  (env NOPEEK_API_URL)\n  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)\n  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)\n  --brain-map <json>       Per-bot overrides {\"<handle>\":{\"cmd\":\"\u2026\"}|{\"url\":\"\u2026\"}} (env BRAIN_MAP)\n  --brain-timeout-ms <ms>  Brain timeout, default 180000          (env BRAIN_TIMEOUT_MS)\n  --port <port>            Health endpoint port, default 8790       (env NOPEEK_BRIDGE_PORT)\n  --data-dir <dir>         Device-key store dir, default ./data       (env NOPEEK_BRIDGE_DATA_DIR)\n  --config <path>          Config file, default ./nopeek-bridge.config.json\n  -h, --help               Show this help\n\nWith no brain configured, bots run in echo mode (\"You said: \u2026\") \u2014 a zero-config smoke test.";
+/** Load config from argv + env + config file. Throws on missing/invalid values. */
+export declare function loadConfig(argv?: string[]): BridgeConfig;

package/dist/config.js

@@ -0,0 +1,153 @@
+// Bridge config. Precedence: CLI flags > environment variables > optional
+// ./nopeek-bridge.config.json (same key names as the env vars). Throws with a
+// clear, actionable message when required values are missing — the CLI turns
+// that into a clean exit, never a crash loop.
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+export const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
+export const DEFAULT_PORT = 8790;
+export const DEFAULT_BRAIN_TIMEOUT_MS = 180_000;
+const CLI_OPTIONS = {
+    pair: { type: "string" },
+    "api-url": { type: "string" },
+    "app-id": { type: "string" },
+    "brain-cmd": { type: "string" },
+    "brain-url": { type: "string" },
+    "brain-map": { type: "string" },
+    "brain-timeout-ms": { type: "string" },
+    port: { type: "string" },
+    "data-dir": { type: "string" },
+    config: { type: "string" },
+    help: { type: "boolean", short: "h" },
+};
+// flag name -> env/config key
+const FLAG_TO_KEY = {
+    pair: "NOPEEK_PAIRING_CODE",
+    "api-url": "NOPEEK_API_URL",
+    "app-id": "NOPEEK_APP_ID",
+    "brain-cmd": "BRAIN_CMD",
+    "brain-url": "BRAIN_URL",
+    "brain-map": "BRAIN_MAP",
+    "brain-timeout-ms": "BRAIN_TIMEOUT_MS",
+    port: "NOPEEK_BRIDGE_PORT",
+    "data-dir": "NOPEEK_BRIDGE_DATA_DIR",
+};
+export const HELP = `nopeek-agent-bridge — run your agents as E2EE NoPeek bots
+
+Usage:
+  npx @nopeek/agent-bridge --pair npr_… --app-id app_… [--brain-cmd '…' | --brain-url https://…]
+
+Options:
+  --pair <code>            One-time pairing code from the NoPeek app  (env NOPEEK_PAIRING_CODE)
+  --app-id <id>            NoPeek app id                              (env NOPEEK_APP_ID)
+  --api-url <url>          API base, default ${DEFAULT_API_URL}  (env NOPEEK_API_URL)
+  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)
+  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)
+  --brain-map <json>       Per-bot overrides {"<handle>":{"cmd":"…"}|{"url":"…"}} (env BRAIN_MAP)
+  --brain-timeout-ms <ms>  Brain timeout, default ${DEFAULT_BRAIN_TIMEOUT_MS}          (env BRAIN_TIMEOUT_MS)
+  --port <port>            Health endpoint port, default ${DEFAULT_PORT}       (env NOPEEK_BRIDGE_PORT)
+  --data-dir <dir>         Device-key store dir, default ./data       (env NOPEEK_BRIDGE_DATA_DIR)
+  --config <path>          Config file, default ./nopeek-bridge.config.json
+  -h, --help               Show this help
+
+With no brain configured, bots run in echo mode ("You said: …") — a zero-config smoke test.`;
+function readConfigFile(path, explicit) {
+    if (!existsSync(path)) {
+        if (explicit)
+            throw new Error(`config file not found: ${path}`);
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (v === null || v === undefined)
+                continue;
+            out[k] = typeof v === "string" ? v : JSON.stringify(v);
+        }
+        console.log(`[config] loaded ${path}`);
+        return out;
+    }
+    catch (err) {
+        throw new Error(`failed to parse ${path}: ${err.message}`);
+    }
+}
+function parseBrainMap(raw) {
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`BRAIN_MAP is not valid JSON: ${err.message}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`BRAIN_MAP must be a JSON object like {"<handle>":{"cmd":"…"}}`);
+    }
+    const out = {};
+    for (const [handle, spec] of Object.entries(parsed)) {
+        if (typeof spec !== "object" || spec === null) {
+            throw new Error(`BRAIN_MAP["${handle}"] must be {"cmd":"…"} or {"url":"…"}`);
+        }
+        const { cmd, url } = spec;
+        if (typeof cmd !== "string" && typeof url !== "string") {
+            throw new Error(`BRAIN_MAP["${handle}"] needs a "cmd" or "url" string`);
+        }
+        out[handle.replace(/^@/, "")] = {
+            ...(typeof cmd === "string" ? { cmd } : {}),
+            ...(typeof url === "string" ? { url } : {}),
+        };
+    }
+    return out;
+}
+/** Load config from argv + env + config file. Throws on missing/invalid values. */
+export function loadConfig(argv = process.argv.slice(2)) {
+    const { values: flags } = parseArgs({ args: argv, options: CLI_OPTIONS, strict: true });
+    if (flags.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    const configPath = resolve(process.cwd(), flags.config ?? "nopeek-bridge.config.json");
+    const file = readConfigFile(configPath, flags.config !== undefined);
+    const get = (flagName) => {
+        const key = FLAG_TO_KEY[flagName];
+        const v = flags[flagName] ?? process.env[key] ?? file[key];
+        return v === undefined || v === "" ? undefined : v;
+    };
+    const pairingCode = get("pair");
+    if (!pairingCode) {
+        throw new Error(`missing pairing code.\n` +
+            `Get one from the NoPeek app ("Connect your computer"), then run:\n` +
+            `  npx @nopeek/agent-bridge --pair npr_…\n` +
+            `or set NOPEEK_PAIRING_CODE (env or nopeek-bridge.config.json).`);
+    }
+    if (!pairingCode.startsWith("npr_")) {
+        console.warn(`[config] pairing code does not start with "npr_" — double-check you pasted the runtime pairing code`);
+    }
+    const appId = get("app-id");
+    if (!appId) {
+        throw new Error(`missing app id.\n` +
+            `Pass --app-id app_… or set NOPEEK_APP_ID (shown alongside the pairing code in the NoPeek app).`);
+    }
+    const brainTimeoutMs = Number(get("brain-timeout-ms") ?? DEFAULT_BRAIN_TIMEOUT_MS);
+    if (!Number.isFinite(brainTimeoutMs) || brainTimeoutMs <= 0) {
+        throw new Error(`BRAIN_TIMEOUT_MS must be a positive number of milliseconds`);
+    }
+    const port = Number(get("port") ?? DEFAULT_PORT);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error(`NOPEEK_BRIDGE_PORT must be a valid port number`);
+    }
+    return {
+        apiUrl: (get("api-url") ?? DEFAULT_API_URL).replace(/\/+$/, ""),
+        appId,
+        pairingCode,
+        brainCmd: get("brain-cmd") ?? null,
+        brainUrl: get("brain-url") ?? null,
+        brainMap: parseBrainMap(get("brain-map")),
+        brainTimeoutMs,
+        port,
+        dataDir: resolve(process.cwd(), get("data-dir") ?? "data"),
+    };
+}

package/dist/control.d.ts

@@ -0,0 +1,36 @@
+import type { BridgeConfig } from "./config.js";
+export interface AdoptBotFrame {
+    type: "adopt_bot";
+    botUserId: string;
+    appId: string;
+    ownerUserId: string;
+    handle: string;
+}
+export interface BotGrantChangedFrame {
+    type: "bot_grant_changed";
+    channelId: string;
+    botUserId: string;
+    granteeUserId: string;
+    action: string;
+}
+export interface ControlHandlers {
+    /** Fired on every successful auth (initial + each reconnect) — resync bots here. */
+    onAuthed: (runtimeId: string) => void;
+    onAdoptBot: (frame: AdoptBotFrame) => void;
+    onGrantChanged: (frame: BotGrantChangedFrame) => void;
+}
+export declare class ControlSocket {
+    connected: boolean;
+    runtimeId: string | null;
+    private cfg;
+    private handlers;
+    private ws;
+    private stopped;
+    private delay;
+    constructor(cfg: BridgeConfig, handlers: ControlHandlers);
+    start(): void;
+    stop(): void;
+    private connect;
+    private handleFrame;
+    private scheduleReconnect;
+}

package/dist/control.js

@@ -0,0 +1,113 @@
+export class ControlSocket {
+    connected = false;
+    runtimeId = null;
+    cfg;
+    handlers;
+    ws = null;
+    stopped = false;
+    delay = 2_000;
+    constructor(cfg, handlers) {
+        this.cfg = cfg;
+        this.handlers = handlers;
+    }
+    start() {
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        try {
+            this.ws?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        this.ws = null;
+        this.connected = false;
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        const url = `${this.cfg.apiUrl.replace(/^http/, "ws")}/v1/ws?runtimeToken=${encodeURIComponent(this.cfg.pairingCode)}`;
+        let ws;
+        try {
+            ws = new WebSocket(url);
+        }
+        catch (err) {
+            console.error(`[control] could not open socket: ${err.message}`);
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws = ws;
+        ws.onopen = () => {
+            console.log(`[control] socket open, awaiting auth.ok`);
+        };
+        ws.onmessage = (ev) => {
+            let frame;
+            try {
+                frame = JSON.parse(String(ev.data));
+            }
+            catch {
+                console.error(`[control] non-JSON frame ignored: ${String(ev.data).slice(0, 200)}`);
+                return;
+            }
+            this.handleFrame(frame);
+        };
+        ws.onerror = () => {
+            // onclose always follows; log there.
+        };
+        ws.onclose = (ev) => {
+            const was = this.connected;
+            this.connected = false;
+            if (this.stopped)
+                return;
+            console.error(`[control] socket closed (code=${ev.code}${ev.reason ? `, reason=${ev.reason}` : ""})${was ? "" : " before auth.ok — is the pairing code valid?"}`);
+            this.scheduleReconnect();
+        };
+    }
+    handleFrame(frame) {
+        switch (frame.type) {
+            case "auth.ok": {
+                this.connected = true;
+                this.delay = 2_000; // reset backoff on a good auth
+                this.runtimeId = String(frame.runtimeId ?? "");
+                console.log(`[control] authenticated as runtime ${this.runtimeId} (control=${String(frame.control)})`);
+                this.handlers.onAuthed(this.runtimeId);
+                return;
+            }
+            case "adopt_bot": {
+                const f = frame;
+                console.log(`[control] adopt_bot @${f.handle} (${f.botUserId}) owner=${f.ownerUserId}`);
+                this.handlers.onAdoptBot(f);
+                return;
+            }
+            case "bot_grant_changed": {
+                const f = frame;
+                // TODO(grants): enforce these — for now bots answer everyone in their
+                // channels; we only log so operators can see grants flowing.
+                console.log(`[control] bot_grant_changed bot=${f.botUserId} channel=${f.channelId} grantee=${f.granteeUserId} action=${f.action} (logged only; enforcement TODO)`);
+                this.handlers.onGrantChanged(f);
+                return;
+            }
+            case "ping": {
+                try {
+                    this.ws?.send(JSON.stringify({ type: "pong" }));
+                }
+                catch {
+                    /* socket may be mid-close */
+                }
+                return;
+            }
+            default:
+                // Forward-compatible: unknown frames are logged, never fatal.
+                console.log(`[control] unhandled frame type "${String(frame.type)}"`);
+        }
+    }
+    scheduleReconnect() {
+        if (this.stopped)
+            return;
+        console.log(`[control] reconnecting in ${this.delay / 1000}s`);
+        const t = setTimeout(() => this.connect(), this.delay);
+        t.unref?.();
+        this.delay = Math.min(this.delay * 2, 30_000);
+    }
+}

package/dist/storage.d.ts

@@ -0,0 +1,8 @@
+export declare class FileStore {
+    private path;
+    private map;
+    constructor(dataDir: string, userId: string);
+    get file(): string;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+}

package/dist/storage.js

@@ -0,0 +1,36 @@
+// File-backed KeyValueStore for the SDK's `storage` option, mirroring the
+// localStorage default shape (get(key) -> string | null, set(key, value)).
+// Persists each bot's device identity + channel keys to <dataDir>/<userId>.json
+// so restarts reuse the same registered device instead of minting a new one.
+import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class FileStore {
+    path;
+    map;
+    constructor(dataDir, userId) {
+        this.path = join(dataDir, `${userId.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+        mkdirSync(dirname(this.path), { recursive: true });
+        this.map = {};
+        if (existsSync(this.path)) {
+            try {
+                this.map = JSON.parse(readFileSync(this.path, "utf8"));
+            }
+            catch (err) {
+                console.error(`[storage] could not parse ${this.path}, starting fresh: ${err.message}`);
+            }
+        }
+    }
+    get file() {
+        return this.path;
+    }
+    get(key) {
+        return Object.prototype.hasOwnProperty.call(this.map, key) ? this.map[key] : null;
+    }
+    set(key, value) {
+        this.map[key] = value;
+        // atomic-ish write: tmp file + rename, so a crash never truncates key material
+        const tmp = `${this.path}.tmp`;
+        writeFileSync(tmp, JSON.stringify(this.map, null, 2));
+        renameSync(tmp, this.path);
+    }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@nopeek/agent-bridge",
+  "version": "0.1.0",
+  "description": "Run your own agents as E2EE NoPeek bots. Pairs with a one-time code, runs every bot you own, and pipes messages to any command or webhook.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "nopeek-agent-bridge": "./dist/cli.js"
+  },
+  "main": "./dist/bridge.js",
+  "types": "./dist/bridge.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/bridge.d.ts",
+      "default": "./dist/bridge.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@nopeek/chat": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "nopeek",
+    "e2ee",
+    "bot",
+    "agent",
+    "bridge",
+    "mls"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}