@graygate/bot-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parallax AI, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# @graygate/bot-sdk
+
+Runtime SDK for [graygate](https://graygate.app) bots. Node, TypeScript.
+
+A bot on graygate is an account run by a machine. It holds its own RSA key pair, joins rooms by
+invitation, and reads and writes end-to-end encrypted messages. The server relays ciphertext and
+cannot read any of it — which is why this runtime, and not graygate, holds the keys.
+
+Start here: **https://graygate.app/bots/** — what a bot is, what it may and may not do, and the
+five steps from creating one in the app to answering a message.
+
+> **Back up your state directory.** `stateDir` holds the bot's RSA private key and the room keys
+> it has been given, as plain files. Neither the server nor the phone of the person who created
+> the bot has a copy. Lose it and the past messages of those rooms stay closed forever — there is
+> no room-key backup, by design. If you lose only the private key you can replace it with
+> `PUT /bot/public-key`, but the room keys come back only when each room admin next rotates.
+
+## Install
+
+Until this package is on npm, install it from the repository:
+
+```bash
+npm install github:graygate/bot-sdk
+```
+
+Node 20 or newer.
+
+## Use
+
+```ts
+import { Bot } from '@graygate/bot-sdk';
+
+const bot = new Bot({
+  token: process.env.GRAYGATE_BOT_TOKEN!,   // gg1.<botId>.<secret>, from the app
+  stateDir: './state',                      // private key, room keys, handled ids
+  webhook: { port: 8443, path: '/hook', publicUrl: 'https://bot.example.com/hook' },
+  autoAcceptInvites: true,
+});
+
+bot.command('start', (ctx) => ctx.reply('Hello.'));
+bot.on('message', async (ctx) => { if (ctx.text === 'ping') await ctx.reply('pong'); });
+bot.on('join', async (ctx) => { await ctx.reply('Welcome.'); });
+bot.on('invite', async (invite) => invite.accept());
+
+await bot.start();
+```
+
+`start()` activates the bot if this is its first run (generating the key pair locally), serves the
+webhook, and registers it. **It registers on every start on purpose**: there is no polling, so
+re-registering is what makes the server replay everything that piled up while the bot was down,
+oldest first.
+
+### Options
+
+| Option | |
+|---|---|
+| `token` | `gg1.<botId>.<secret>`, shown once in the app when the bot is created. Pass it through the environment; never write it to a file |
+| `stateDir` | Private key, room keys by version, and the ids already handled. Back it up |
+| `webhook.publicUrl` | The public https address the server will post to. https and port 443 only; private, loopback and link-local addresses are refused |
+| `webhook.port` / `webhook.host` | Where the SDK listens. Bind to `127.0.0.1` when a reverse proxy terminates TLS |
+| `autoAcceptInvites` | Default true. Set false and decide inside `bot.on('invite')` |
+| `origin` | Server origin. Defaults to `https://server.graygate.app` |
+
+### Handlers
+
+- `bot.command(name, ctx)` — a command is an ordinary text message that starts with `/`. In a room
+  with more than one bot, people write `/start@your_bot`; a command addressed to another bot is
+  ignored for you.
+- `bot.on('message', ctx)` — `ctx.text` is set for text bodies, `ctx.body` always carries the
+  decrypted body, `ctx.reply(text)` answers in the same room.
+- `bot.on('join', ctx)` — someone joined a room the bot is in. Useful for a greeting.
+- `bot.on('invite', invite)` — `invite.accept()` or `invite.decline()`.
+
+A handler that throws makes the SDK answer the webhook with a non-2xx status, and the server sends
+the batch again after a backoff. That is the intended way to say "I could not handle this yet".
+
+## What you take on
+
+- **A public https address is required.** The server checks it when you register and again on every
+  send, so an address that later resolves to a private range stops receiving. Redirects are not
+  followed. Running on a laptop means running a tunnel.
+- **Your bot reads everything in its rooms.** Room keys are shared, so there is no privacy mode:
+  the component that would filter is the server, and the server sees only ciphertext. Members are
+  told — the invite raises a confirmation dialog, a warning line appears when the bot joins, and a
+  BOT badge follows it. What your runtime logs, stores or forwards is your responsibility, and
+  rooms that set an auto-delete period expect you to honour it. The default state keeps no messages.
+- **Media handed to you is unverified.** Phones run every incoming file through a validation
+  pipeline before anything renders it. This SDK does not: it decrypts bytes and gives them to you.
+  Do not pass them straight to an image decoder, a file path or a system handler.
+- **If the token leaks**, issue a new one in the app and use *Leave all rooms*. Both take effect at
+  once, but neither takes back room keys already copied — only a room admin can, by rotating. Tell
+  them.
+
+## Webhook contract
+
+Every request from the server carries a signature. Verify it before parsing the body; the SDK does
+this for you and answers 401 without reading anything it cannot authenticate.
+
+```
+header:  x-graygate-signature: t=<unix seconds>,v1=<hex>
+key:     HKDF-SHA256(ikm = sha256(the token's secret part), salt = none,
+                     info = "graygate:bot-webhook-v1", length = 32)
+v1:      HMAC-SHA256(key, "<t>." + <raw request body>)
+verify:  constant-time compare, and reject |now - t| > 300 seconds as a replay
+```
+
+The signing key comes from the sha256 of the token's secret part rather than the secret itself
+because the server stores only that hash — it never keeps the secret in the clear. Reissuing the
+token changes the hash, so the signing key changes with it.
+
+A 2xx response **is** the acknowledgement: it deletes the server's queued copy. Delivery is
+at-least-once, so drop repeats by item id (the SDK does). Batches carry up to 100 items, requests
+time out after 3 seconds, and after 20 consecutive failures the server switches your webhook off
+and messages only wait in the queue, for 14 days.
+
+## Other languages
+
+This is one implementation, not the contract. The REST endpoints, the signature above, and the
+crypto parameters (AES-256-CBC with encrypt-then-HMAC-SHA256, RSA-OAEP room-key envelopes, all via
+[graygate-cypher](https://github.com/joshephan/graygate-cypher)) are enough to write a runtime in
+any language. The wire types in `src/wire/` are the same ones the app and the server use.
+
+## Contributing
+
+The sources here are generated from the graygate monorepo, which is where fixes land. Open an issue
+describing the problem — pull requests against generated files cannot be merged directly, but the
+change will be made upstream and land here on the next release.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/api.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The REST client between a bot runtime and the graygate server.
+ *
+ * Access tokens last fifteen minutes and are kept **in memory only**; when one is close to expiring
+ * it is traded for another using the bot token. There is no refresh token because the bot token is
+ * itself the long-lived credential. That token never leaves this object — not into a log, not into
+ * the state directory.
+ */
+export declare class BotApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message?: string);
+}
+export declare class BotApi {
+    private readonly origin;
+    private readonly token;
+    private accessToken;
+    private expiresAt;
+    private botId;
+    private userId;
+    constructor(origin: string, token: string);
+    get ids(): {
+        botId: string | null;
+        userId: string | null;
+    };
+    private ensureAuth;
+    private raw;
+    call(method: string, path: string, body?: unknown): Promise<Record<string, unknown>>;
+    /** For endpoints that answer with an array (`GET /invites`, member lists). */
+    callList(method: string, path: string, body?: unknown): Promise<unknown[]>;
+}

package/dist/api.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotApi = exports.BotApiError = void 0;
+const wire_1 = require("./wire");
+/**
+ * The REST client between a bot runtime and the graygate server.
+ *
+ * Access tokens last fifteen minutes and are kept **in memory only**; when one is close to expiring
+ * it is traded for another using the bot token. There is no refresh token because the bot token is
+ * itself the long-lived credential. That token never leaves this object — not into a log, not into
+ * the state directory.
+ */
+class BotApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message ?? code);
+        this.status = status;
+        this.code = code;
+        this.name = 'BotApiError';
+    }
+}
+exports.BotApiError = BotApiError;
+/** Renew this long before expiry (ms), so a token cannot die between the check and the request. */
+const REFRESH_MARGIN_MS = 60_000;
+class BotApi {
+    origin;
+    token;
+    accessToken = null;
+    expiresAt = 0;
+    botId = null;
+    userId = null;
+    constructor(origin, token) {
+        this.origin = origin;
+        this.token = token;
+    }
+    get ids() {
+        return { botId: this.botId, userId: this.userId };
+    }
+    async ensureAuth() {
+        if (this.accessToken && Date.now() < this.expiresAt - REFRESH_MARGIN_MS)
+            return this.accessToken;
+        const res = await this.raw('POST', '/bot/auth', { token: this.token }, null);
+        this.accessToken = res.accessToken;
+        this.botId = res.botId;
+        this.userId = res.userId ?? null;
+        // The lifetime is fixed at BOT_ACCESS_TOKEN_TTL_MIN; there is nothing to recompute here.
+        this.expiresAt = Date.now() + 15 * 60_000;
+        return this.accessToken;
+    }
+    async raw(method, path, body, access) {
+        const res = await fetch(`${this.origin}${path}`, {
+            method,
+            headers: {
+                ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+                // Client header for the edge in front of the server. Not a secret; see BOT_CLIENT_TOKEN.
+                'x-graygate-client': wire_1.BOT_CLIENT_TOKEN,
+                ...(access ? { authorization: `Bearer ${access}` } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        const json = text ? JSON.parse(text) : {};
+        if (!res.ok) {
+            const err = (json.error ?? {});
+            throw new BotApiError(res.status, err.code ?? 'error', err.message);
+        }
+        return json;
+    }
+    async call(method, path, body) {
+        const access = await this.ensureAuth();
+        try {
+            return await this.raw(method, path, body, access);
+        }
+        catch (err) {
+            // The access token expired early — trade for another one and retry, once.
+            if (err instanceof BotApiError && err.status === 401) {
+                this.accessToken = null;
+                return this.raw(method, path, body, await this.ensureAuth());
+            }
+            throw err;
+        }
+    }
+    /** For endpoints that answer with an array (`GET /invites`, member lists). */
+    async callList(method, path, body) {
+        const access = await this.ensureAuth();
+        const res = await fetch(`${this.origin}${path}`, {
+            method,
+            headers: {
+                ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+                'x-graygate-client': wire_1.BOT_CLIENT_TOKEN,
+                authorization: `Bearer ${access}`,
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        const json = text ? JSON.parse(text) : [];
+        if (!res.ok) {
+            const err = (json.error ?? {});
+            throw new BotApiError(res.status, err.code ?? 'error', err.message);
+        }
+        return Array.isArray(json) ? json : [];
+    }
+}
+exports.BotApi = BotApi;

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import { type MessageBody } from './wire';
+export { BotApiError } from './api';
+export { verifyWebhookSignature, webhookSigningKey } from './signature';
+/**
+ * The graygate bot runtime.
+ *
+ * Four things happen here: it authenticates with the bot token and, on a first run, generates a key
+ * pair and activates the account; it receives webhooks, **verifies the signature before anything
+ * else**, and consumes envelopes to learn room keys; it decrypts messages and hands them to your
+ * handlers; and it encrypts replies and posts them back.
+ *
+ * Every cryptographic operation goes through the wire module — no hand-rolled crypto here.
+ *
+ * **Media handed to a handler is unverified.** This runtime is not a renderer, and what you do with
+ * those bytes is yours to decide: do not pass them straight to an image decoder or a file path.
+ */
+export interface BotOptions {
+    /** `gg1.<botId>.<secret>`. Read it from the environment; never write it to a file. */
+    token: string;
+    /** Server origin. Bots do not use the app's fallback-domain logic — you choose the address. */
+    origin?: string;
+    /** Where the private key, the room keys and the handled ids live. **Back this up.** */
+    stateDir: string;
+    webhook: {
+        port: number;
+        /** Defaults to `/hook`. */
+        path?: string;
+        /** The public https address to register. Private and loopback addresses are refused. */
+        publicUrl: string;
+        /** Bind to one interface only — `127.0.0.1` when a reverse proxy sits in front. */
+        host?: string;
+    };
+    /** Defaults to true; set false to decide inside `bot.on('invite')`. */
+    autoAcceptInvites?: boolean;
+}
+export interface MessageContext {
+    roomId: string;
+    messageId: string;
+    senderId: string;
+    body: MessageBody;
+    /** The text, when `body.t === 'text'`. */
+    text: string | null;
+    reply(text: string): Promise<void>;
+}
+export interface JoinContext {
+    roomId: string;
+    userId: string;
+    reply(text: string): Promise<void>;
+}
+export interface InviteContext {
+    inviteId: string;
+    roomId: string;
+    accept(): Promise<void>;
+    decline(): Promise<void>;
+}
+export interface CommandContext extends MessageContext {
+    command: string;
+    args: string;
+}
+type MessageHandler = (ctx: MessageContext) => void | Promise<void>;
+type JoinHandler = (ctx: JoinContext) => void | Promise<void>;
+type InviteHandler = (ctx: InviteContext) => void | Promise<void>;
+type CommandHandler = (ctx: CommandContext) => void | Promise<void>;
+export declare class Bot {
+    private readonly options;
+    private readonly api;
+    private readonly state;
+    private readonly secret;
+    private readonly path;
+    private server;
+    private username;
+    private messageHandlers;
+    private joinHandlers;
+    private inviteHandlers;
+    private commandHandlers;
+    constructor(options: BotOptions);
+    on(event: 'message', handler: MessageHandler): void;
+    on(event: 'join', handler: JoinHandler): void;
+    on(event: 'invite', handler: InviteHandler): void;
+    /** A command such as `/start`. Names are ASCII lowercase, digits and underscores. */
+    command(name: string, handler: CommandHandler): void;
+    /**
+     * Starts the bot: activates it (generating a key pair on a first run), serves the webhook, and
+     * registers it. **Registering is also the request for a backfill** — there is no polling, so this
+     * is when everything that piled up while the bot was down comes in.
+     */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private ensureActivated;
+    private listen;
+    private handleRequest;
+    private handleItem;
+    private dispatchMessage;
+    private onInvite;
+    /** Sends text. Does nothing when there is no room key — not invited yet, or removed. */
+    send(roomId: string, text: string): Promise<void>;
+    /** Comments on a post — channels only; carries the parent post's id. */
+    replyToPost(roomId: string, parentId: string, text: string): Promise<void>;
+}

package/dist/index.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = exports.webhookSigningKey = exports.verifyWebhookSignature = exports.BotApiError = void 0;
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const wire_1 = require("./wire");
+const wire_2 = require("./wire");
+const api_1 = require("./api");
+const state_1 = require("./state");
+const signature_1 = require("./signature");
+var api_2 = require("./api");
+Object.defineProperty(exports, "BotApiError", { enumerable: true, get: function () { return api_2.BotApiError; } });
+var signature_2 = require("./signature");
+Object.defineProperty(exports, "verifyWebhookSignature", { enumerable: true, get: function () { return signature_2.verifyWebhookSignature; } });
+Object.defineProperty(exports, "webhookSigningKey", { enumerable: true, get: function () { return signature_2.webhookSigningKey; } });
+class Bot {
+    options;
+    api;
+    state;
+    secret;
+    path;
+    server = null;
+    username = '';
+    messageHandlers = [];
+    joinHandlers = [];
+    inviteHandlers = [];
+    commandHandlers = new Map();
+    constructor(options) {
+        this.options = options;
+        this.api = new api_1.BotApi(options.origin ?? 'https://server.graygate.app', options.token);
+        this.state = new state_1.BotState(options.stateDir);
+        this.secret = (0, signature_1.tokenSecret)(options.token);
+        this.path = options.webhook.path ?? '/hook';
+    }
+    on(event, handler) {
+        if (event === 'message')
+            this.messageHandlers.push(handler);
+        else if (event === 'join')
+            this.joinHandlers.push(handler);
+        else
+            this.inviteHandlers.push(handler);
+    }
+    /** A command such as `/start`. Names are ASCII lowercase, digits and underscores. */
+    command(name, handler) {
+        this.commandHandlers.set(name, handler);
+    }
+    /**
+     * Starts the bot: activates it (generating a key pair on a first run), serves the webhook, and
+     * registers it. **Registering is also the request for a backfill** — there is no polling, so this
+     * is when everything that piled up while the bot was down comes in.
+     */
+    async start() {
+        await this.ensureActivated();
+        await this.listen();
+        await this.api.call('PUT', '/bot/webhook', { url: this.options.webhook.publicUrl });
+    }
+    async stop() {
+        const server = this.server;
+        this.server = null;
+        if (!server)
+            return;
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+    async ensureActivated() {
+        const me = await this.api.call('POST', '/bot/auth', undefined).catch(() => null);
+        void me; // The client handles authentication; all this decides is whether we are active.
+        const profile = await this.api.call('GET', '/bot/me');
+        this.username = String(profile.username ?? '');
+        if (profile.active === true) {
+            if (!this.state.readPrivateKey()) {
+                throw new Error('This bot is active but the state directory has no private key, so its old room keys are ' +
+                    'gone. Replace the key with PUT /bot/public-key and ask each room admin to invite it again.');
+            }
+            return;
+        }
+        const pair = await (0, wire_2.generateRsaKeyPair)();
+        this.state.writePrivateKey(pair.privateKeyPem);
+        await this.api.call('POST', '/bot/activate', { rsaPublicKey: pair.publicKeyPem });
+    }
+    listen() {
+        return new Promise((resolve, reject) => {
+            const server = (0, node_http_1.createServer)((req, res) => {
+                void this.handleRequest(req, res).catch(() => {
+                    // A throwing handler answers non-2xx, and the server sends the batch again.
+                    if (!res.headersSent)
+                        res.writeHead(500);
+                    res.end();
+                });
+            });
+            server.on('error', reject);
+            server.listen(this.options.webhook.port, this.options.webhook.host, () => {
+                this.server = server;
+                resolve();
+            });
+        });
+    }
+    async handleRequest(req, res) {
+        if (req.method !== 'POST' || (req.url ?? '').split('?')[0] !== this.path) {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        const raw = await readBody(req);
+        const signature = req.headers['x-graygate-signature'];
+        if (!(0, signature_1.verifyWebhookSignature)(this.secret, Array.isArray(signature) ? signature[0] : signature, raw)) {
+            // A request with a bad signature is not even parsed.
+            res.writeHead(401);
+            res.end();
+            return;
+        }
+        const parsed = wire_1.botWebhookBody.safeParse(JSON.parse(raw));
+        if (!parsed.success) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        /**
+         * 2xx goes back only once every handler has finished without throwing. A 2xx **is** the
+         * acknowledgement: answer it after a failure and the message is dropped from the server's queue
+         * for good. Anything else and the server retries after a backoff.
+         */
+        for (const item of parsed.data.items)
+            await this.handleItem(item);
+        res.writeHead(200);
+        res.end();
+    }
+    async handleItem(item) {
+        switch (item.type) {
+            case 'envelope.new': {
+                const privateKey = this.state.readPrivateKey();
+                if (!privateKey)
+                    return;
+                const roomKey = await (0, wire_2.unwrapRoomKey)(item.payload.ciphertext, privateKey);
+                this.state.putRoomKey(item.payload.roomId, item.payload.keyVersion, roomKey);
+                if (item.payload.purpose === 'invite')
+                    await this.onInvite(item.payload.roomId);
+                return;
+            }
+            case 'msg.new': {
+                // At-least-once delivery: the same item can arrive twice.
+                if (this.state.markSeen(item.payload.id))
+                    return;
+                const roomKey = this.state.roomKey(item.payload.roomId, item.payload.keyVersion);
+                // No key, no way to open it. **Acknowledge anyway** — refusing would replay it for 14 days.
+                if (!roomKey)
+                    return;
+                let body;
+                try {
+                    body = await (0, wire_2.decryptMessage)(roomKey, item.payload.ciphertext);
+                }
+                catch {
+                    return; // Integrity check failed — dropped quietly, exactly as a phone would.
+                }
+                const parsed = wire_1.messageBodySchema.safeParse(body);
+                if (!parsed.success)
+                    return;
+                await this.dispatchMessage(item.payload.roomId, item.payload.id, item.payload.senderId, parsed.data);
+                return;
+            }
+            case 'member.joined': {
+                for (const handler of this.joinHandlers) {
+                    await handler({
+                        roomId: item.payload.roomId,
+                        userId: item.payload.userId,
+                        reply: (text) => this.send(item.payload.roomId, text),
+                    });
+                }
+                return;
+            }
+            case 'room.deleted': {
+                this.state.forgetRoom(item.payload.roomId);
+                return;
+            }
+            case 'member.left':
+            case 'member.key_changed':
+                return;
+        }
+    }
+    async dispatchMessage(roomId, messageId, senderId, body) {
+        const text = body.t === 'text' ? body.text : null;
+        const ctx = {
+            roomId,
+            messageId,
+            senderId,
+            body,
+            text,
+            reply: (value) => this.send(roomId, value),
+        };
+        if (text?.startsWith('/')) {
+            const [head, ...rest] = text.slice(1).split(/\s+/);
+            // With more than one bot in a room people write `/start@some_bot`; ignore other bots' commands.
+            const [name, target] = (head ?? '').split('@');
+            if (!target || target === this.username) {
+                const handler = this.commandHandlers.get(name ?? '');
+                if (handler) {
+                    await handler({ ...ctx, command: name ?? '', args: rest.join(' ') });
+                    return;
+                }
+            }
+        }
+        for (const handler of this.messageHandlers)
+            await handler(ctx);
+    }
+    async onInvite(roomId) {
+        const invites = (await this.api.callList('GET', '/invites'));
+        const invite = invites.find((i) => i.roomId === roomId);
+        if (!invite)
+            return;
+        const ctx = {
+            inviteId: invite.id,
+            roomId,
+            accept: async () => {
+                await this.api.call('POST', `/invites/${invite.id}/accept`, {});
+            },
+            decline: async () => {
+                await this.api.call('POST', `/invites/${invite.id}/decline`, {});
+            },
+        };
+        if (this.inviteHandlers.length === 0) {
+            if (this.options.autoAcceptInvites !== false)
+                await ctx.accept();
+            return;
+        }
+        for (const handler of this.inviteHandlers)
+            await handler(ctx);
+    }
+    /** Sends text. Does nothing when there is no room key — not invited yet, or removed. */
+    async send(roomId, text) {
+        const key = this.state.latestRoomKey(roomId);
+        if (!key)
+            return;
+        // The length limit is enforced here before sending, the same place a phone enforces it.
+        const trimmed = text.slice(0, 8000);
+        const ciphertext = await (0, wire_2.encryptMessage)(key.roomKey, { t: 'text', text: trimmed });
+        try {
+            await this.api.call('POST', '/bot/messages', {
+                id: (0, node_crypto_1.randomUUID)(),
+                roomId,
+                keyVersion: key.keyVersion,
+                kind: 'text',
+                ciphertext,
+            });
+        }
+        catch (err) {
+            // The room key moved on; the next envelope arrives by webhook and the next send works.
+            if (err instanceof api_1.BotApiError && (err.code === 'stale_key' || err.code === 'not_member'))
+                return;
+            throw err;
+        }
+    }
+    /** Comments on a post — channels only; carries the parent post's id. */
+    async replyToPost(roomId, parentId, text) {
+        const key = this.state.latestRoomKey(roomId);
+        if (!key)
+            return;
+        const ciphertext = await (0, wire_2.encryptMessage)(key.roomKey, {
+            t: 'text',
+            text: text.slice(0, wire_1.COMMENT_TEXT_MAX),
+            parentId,
+        });
+        await this.api.call('POST', '/bot/messages', {
+            id: (0, node_crypto_1.randomUUID)(),
+            roomId,
+            keyVersion: key.keyVersion,
+            kind: 'text',
+            ciphertext,
+        });
+    }
+}
+exports.Bot = Bot;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            // A body far past the batch limit did not come from the graygate server.
+            if (size > 8 * 1024 * 1024) {
+                req.destroy();
+                reject(new Error('body too large'));
+                return;
+            }
+            data += chunk.toString('utf8');
+        });
+        req.on('end', () => resolve(data));
+        req.on('error', reject);
+    });
+}