From 30faefaacbcbc6bba285e2a6c4669cf09685beb1 Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 01:08:30 -0700 Subject: [PATCH 1/7] feat(xchat): add XChat encrypted messaging adapter MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit New @chat-adapter/xchat package for XChat, X's encrypted messaging. All cryptography is handled inside the adapter via @xdevplatform/chat-xdk (wasm) and all REST goes through the typed @xdevplatform/xdk client. The adapter implements the standard Adapter interface only — no core changes. --- .changeset/xchat-inbound-features.md | 15 + .changeset/xchat-sdk-integration.md | 9 + packages/adapter-xchat/README.md | 279 ++ packages/adapter-xchat/package.json | 67 + packages/adapter-xchat/src/cards.test.ts | 146 + packages/adapter-xchat/src/cards.ts | 134 + packages/adapter-xchat/src/index.test.ts | 2282 +++++++++++++ packages/adapter-xchat/src/index.ts | 2836 +++++++++++++++++ packages/adapter-xchat/src/markdown.test.ts | 97 + packages/adapter-xchat/src/markdown.ts | 55 + packages/adapter-xchat/src/test-utils.ts | 257 ++ packages/adapter-xchat/src/types.ts | 256 ++ .../tests/fixtures/sdk_vectors.json | 26 + packages/adapter-xchat/tsconfig.json | 10 + packages/adapter-xchat/tsup.config.ts | 9 + packages/adapter-xchat/vitest.config.ts | 14 + .../src/documentation-test-utils.ts | 2 + pnpm-lock.yaml | 62 + turbo.json | 7 + 19 files changed, 6563 insertions(+) create mode 100644 .changeset/xchat-inbound-features.md create mode 100644 .changeset/xchat-sdk-integration.md create mode 100644 packages/adapter-xchat/README.md create mode 100644 packages/adapter-xchat/package.json create mode 100644 packages/adapter-xchat/src/cards.test.ts create mode 100644 packages/adapter-xchat/src/cards.ts create mode 100644 packages/adapter-xchat/src/index.test.ts create mode 100644 packages/adapter-xchat/src/index.ts create mode 100644 packages/adapter-xchat/src/markdown.test.ts create mode 100644 packages/adapter-xchat/src/markdown.ts create mode 100644 packages/adapter-xchat/src/test-utils.ts create mode 100644 packages/adapter-xchat/src/types.ts create mode 100644 packages/adapter-xchat/tests/fixtures/sdk_vectors.json create mode 100644 packages/adapter-xchat/tsconfig.json create mode 100644 packages/adapter-xchat/tsup.config.ts create mode 100644 packages/adapter-xchat/vitest.config.ts diff --git a/.changeset/xchat-inbound-features.md b/.changeset/xchat-inbound-features.md new file mode 100644 index 000000000..2bd5685db --- /dev/null +++ b/.changeset/xchat-inbound-features.md @@ -0,0 +1,15 @@ +--- +"@chat-adapter/xchat": minor +--- + +XChat inbound handling and messaging features: + +- Entity-based mention detection (structured mention entities + swipe-reply-to-bot), with plain-text `@handle` fallback +- Group replies sent as quoted replies (`encryptReply`) referencing the triggering message; TTL propagated from the inbound message +- Outgoing rich-text entities (URLs, @mentions) and auto-attached x.com post cards +- Media: inbound attachments exposed with lazy download+decrypt; outbound files encrypted (secretstream) and uploaded via the 3-step media upload flow +- Reactions: inbound routed to `onReaction`, outbound `addReaction`/`removeReaction` implemented +- `chat.conversation_join`: conversation-key bootstrap plus configurable group welcome message +- Read receipts: a seen-until watermark is sent for each delivered inbound message before handlers run (`sendReadReceipts` config, default on), falling back to the latest conversation event when the message carries no sequence id +- Typing keep-alive loop while handlers run; session identity (`setIdentity`) after unlock +- Non-message decrypted events (edits, mark-read, etc.) no longer surface as empty messages diff --git a/.changeset/xchat-sdk-integration.md b/.changeset/xchat-sdk-integration.md new file mode 100644 index 000000000..ffef00771 --- /dev/null +++ b/.changeset/xchat-sdk-integration.md @@ -0,0 +1,9 @@ +--- +"@chat-adapter/xchat": minor +--- + +XChat adapter on `@xdevplatform/chat-xdk` 0.4.3 and `@xdevplatform/xdk` 0.6.6: message ids are SDK-generated and signature-bound, the sender identity is established once per session, group quote-replies embed the raw signed original so recipients can validate the preview, replies whose preview fails that validation never count as a mention of the bot, and every REST call — including encrypted media download and upload — goes through the typed xdk client (requests target the production X API; pass `apiHeaders` to add custom headers). + +New capabilities: `openDM(userId)` starts (or reuses) an encrypted 1:1 conversation — it derives the pair conversation id, reuses a cached or history-recovered conversation key, and otherwise runs a full key exchange (`prepareConversationKeyChange` + key initialization) so the bot can message a user first. Cards are supported by degradation: since XChat has no interactive primitives, a card renders as plain text with tappable URL/mention entities, link buttons become `label: url` lines, and the card's primary link ships as a URL preview attachment with an optional encrypted banner image. + +`editMessage` and `deleteMessage` are now implemented. Edits are encrypted events targeting the original's sequence id (captured from the send echo, with a history-replay fallback) and sent through the regular message channel; fetched history renders an edit event as the edited message, since the backend stops serving superseded originals. Because receiving clients park an edit whose original has not arrived yet — leaving the message permanently invisible on that client — the first edit of a fresh message is age-gated by `editSafetyDelayMs` (default 5000ms, 0 disables). Deletes prepare a signed delete-for-all action locally (recipients verify it) and submit it to the chat delete endpoint; only the bot's own messages can be deleted. diff --git a/packages/adapter-xchat/README.md b/packages/adapter-xchat/README.md new file mode 100644 index 000000000..0f44b7573 --- /dev/null +++ b/packages/adapter-xchat/README.md @@ -0,0 +1,279 @@ +[![XChat adapter for Chat SDK](https://chat-sdk.dev/en/adapters/official/xchat/og)](https://chat-sdk.dev/adapters/official/xchat) + +# @chat-adapter/xchat + +> npm package: [`@chat-adapter/xchat`](https://www.npmjs.com/package/@chat-adapter/xchat) + +[![Agent Stack](https://img.shields.io/badge/Agent%20Stack-000?style=flat-square&logo=vercel&logoColor=FFF&labelColor=000&color=000)](https://vercel.com/kb/agent-stack) +[![MIT License](https://img.shields.io/badge/License-MIT-000?style=flat-square&logo=opensourceinitiative&logoColor=white&labelColor=000&color=000)](../../LICENSE) + +XChat (encrypted messaging) adapter for [Chat SDK](https://chat-sdk.dev), built on the [X API v2](https://docs.x.com/x-api/introduction) chat endpoints, the [X Activity API](https://docs.x.com/x-api/activity/introduction) for event delivery, and [`@xdevplatform/chat-xdk`](https://github.com/xdevplatform/chat-xdk) for encryption. + +Every XChat conversation is encrypted. The adapter handles the full crypto lifecycle transparently: conversation-key extraction and caching, message decryption and signature verification, and encryption + signing on send. + +Documentation: [chat-sdk.dev/adapters/official/xchat](https://chat-sdk.dev/adapters/official/xchat) · Guides: [vercel.com/kb/chat-sdk](https://vercel.com/kb/chat-sdk) + +## Installation + +```bash +pnpm add @chat-adapter/xchat +``` + +## Scaffold with the CLI + +To scaffold a new Chat SDK bot and add this adapter: + +```bash +npx create-chat-sdk@latest my-bot +``` + +Visit the [adapters directory](https://chat-sdk.dev/adapters) to see other available official and vendor-official adapters. + +## Usage + +```typescript +import { Chat } from "chat"; +import { createXChatAdapter } from "@chat-adapter/xchat"; +import { createMemoryState } from "@chat-adapter/state-memory"; + +const bot = new Chat({ + userName: "mybot", + adapters: { + xchat: createXChatAdapter(), + }, + state: createMemoryState(), +}); + +// DMs always +bot.onDirectMessage(async (thread, message) => { + await thread.post(`You said: ${message.text}`); +}); + +// Group chats when the bot is @mentioned +bot.onNewMention(async (thread, message) => { + await thread.post(`You said: ${message.text}`); +}); +``` + +When using `createXChatAdapter()` without arguments, credentials are auto-detected from environment variables. The bot's @handle is resolved from `GET /2/users/me` at startup, so mention detection works without any hardcoding. + +## X Chat setup + +### 1. Register encryption keys + +The bot account needs registered public keys and a Juicebox-backed private-key store before it can participate in encrypted conversations: + +1. Generate keypairs with `chat-xdk` (`generateKeypairs()`) +2. Register them via `POST /2/users/{id}/public_keys` +3. Store the private keys in Juicebox with a PIN (`chat.setup(pin)`) + +The adapter unlocks the keys at startup with the same PIN (`XCHAT_PIN`). Registration is a one-time step per account — see the [chat-xdk documentation](https://github.com/xdevplatform/chat-xdk) for the full flow. + +### 2. Create a webhook + +Register a webhook URL so the X Activity API can deliver events ([docs](https://docs.x.com/x-api/webhooks/introduction)): + +```bash +curl -X POST "https://api.x.com/2/webhooks" \ + -H "Authorization: Bearer $APP_BEARER_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"url": "https://your-domain.com/api/webhooks/xchat"}' +``` + +X validates the URL with a CRC challenge (see [Webhook route](#webhook-route) below), so the endpoint must be live before you create the webhook. + +Webhooks and activity subscriptions can also be created and managed in the [X Developer Portal](https://developer.x.com/en/portal/dashboard) instead of via the API. + +### 3. Subscribe to chat events + +Create [activity subscriptions](https://docs.x.com/x-api/activity/create-x-activity-subscription) for the bot user with the bot's OAuth2 user token: + +```bash +curl -X POST "https://api.x.com/2/activity/subscriptions" \ + -H "Authorization: Bearer $BOT_USER_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "event_type": "chat.received", + "filter": {"user_id": "YOUR_BOT_USER_ID"}, + "tag": "bot-chat-received", + "webhook_id": "YOUR_WEBHOOK_ID" + }' +``` + +Subscribe to `chat.conversation_join` as well if you want the bot to post a welcome message when it is added to a group. + +## Webhook route + +X sends two kinds of requests: + +1. **CRC challenge** (GET) — `?crc_token=...` must be answered with an HMAC-SHA256 of the token, keyed by your app's consumer secret. Handle this at the route level; it needs no adapter state. +2. **Event delivery** (POST) — chat events, verified by the adapter via the `x-twitter-webhooks-signature` header. + +```typescript +import { createHmac } from "node:crypto"; +import { bot } from "@/lib/bot"; + +export async function GET(request: Request) { + const url = new URL(request.url); + const crcToken = url.searchParams.get("crc_token"); + if (!crcToken) { + return new Response("Missing crc_token", { status: 400 }); + } + const hash = createHmac("sha256", process.env.X_CONSUMER_SECRET!) + .update(crcToken) + .digest("base64"); + return Response.json({ response_token: `sha256=${hash}` }); +} + +export async function POST(request: Request) { + return bot.webhooks.xchat(request); +} +``` + +## Configuration + +All options are auto-detected from environment variables when not provided. + +| Option | Required | Description | +|--------|----------|-------------| +| `botToken` / `accessToken` | No* | OAuth2 user access token for the bot account. Auto-detected from `XCHAT_BOT_TOKEN` or `X_ACCESS_TOKEN` | +| `userId` | No* | Bot's numeric X user ID. Auto-detected from `XCHAT_USER_ID` or `X_USER_ID` | +| `pin` | No | Juicebox PIN; when set, keys unlock automatically during `initialize()`. Auto-detected from `XCHAT_PIN` | +| `consumerSecret` | No | App consumer secret for webhook signature verification. Auto-detected from `X_CONSUMER_SECRET`. When unset, incoming webhook POSTs are **not** signature-verified (a warning is logged at startup) | +| `editSafetyDelayMs` | No | Minimum age (ms) a freshly posted message must reach before its first edit is sent, so receiving clients have stored the original the edit targets. Defaults to `5000`; `0` disables the wait | +| `sendReadReceipts` | No | Send a read receipt for each delivered inbound message before handlers run (default `true`) | +| `userName` | No | Bot @handle for mention detection. Auto-detected from `X_BOT_USERNAME`, otherwise resolved from `GET /2/users/me` | +| `welcomeMessage` | No | Message posted when the bot joins a group. `false` disables; omitted uses a default that explains @mention-to-reply | +| `verifySignatures` | No | Require verifiable signatures on incoming messages (default `true`). `X_VERIFY_SIGNATURES=false` opts out | +| `signingKeyVersion` | No | Signing key version override. Normally fetched during `initialize()`. Auto-detected from `X_SIGNING_KEY_VERSION` | +| `apiBaseUrl` | No | Base URL for media REST calls (defaults to `https://api.x.com`) | +| `apiHeaders` | No | Extra headers on every X API request | +| `logger` | No | Logger instance (defaults to `ConsoleLogger("info")`) | + +*Required at runtime — either via config or environment variable. + +## Environment variables + +```bash +XCHAT_BOT_TOKEN=xcbot_... # OAuth2 user token for the bot account +XCHAT_USER_ID=1234567890 # Bot's numeric user ID +XCHAT_PIN=... # Juicebox PIN for key unlock +X_CONSUMER_SECRET=... # App secret (CRC + webhook signature verification) +X_BOT_USERNAME=... # Optional @handle override; resolved from /2/users/me otherwise +X_VERIFY_SIGNATURES=true # Optional; set false to accept unverifiable messages +``` + +## Features + +### Messaging + +| Feature | Supported | +|---------|-----------| +| Post message | Yes (encrypted + signed) | +| Group replies | Yes (quoted reply to the triggering message) | +| Edit message | Yes (encrypted edit event targeting the original's sequence id; only the bot's own text messages). The first edit of a fresh message is held until the message is `editSafetyDelayMs` old, so receiving clients have stored the original before the edit arrives | +| Delete message | Yes (delete-for-all: a locally signed delete action removes the message for every participant; only the bot's own messages) | +| Streaming | Limited (message edits work, but the first edit is age-gated by `editSafetyDelayMs`, so rapid token-by-token updates are coarse) | +| Read receipts | Yes (sent for each delivered inbound message unless `sendReadReceipts: false`; falls back to the latest conversation event) | +| TTL propagation | Yes (replies inherit the inbound message's disappearing-message TTL) | + +### Rich content + +| Feature | Supported | +|---------|-----------| +| Markdown | No client-side rendering — outgoing markdown appears literally as plain text (tables are the exception, see below) | +| URL / @mention entities | Yes (detected in outgoing text, rendered as tappable links and mention pills) | +| Post cards | Yes (first `x.com/.../status/...` URL in outgoing text auto-attaches) | +| Media out | Yes (files encrypt-streamed and uploaded via the 3-step media upload flow) | +| Media in | Yes (attachments exposed with lazy download + decrypt via `fetchData()`) | +| Cards / buttons / modals | No (X Chat has no interactive message surface) | +| Tables | ASCII code blocks | + +### Conversations + +| Feature | Supported | +|---------|-----------| +| Mentions | Yes (structured mention entities, swipe-reply-to-bot, plain-text `@handle` fallback) | +| Add / remove reactions | Yes | +| Incoming reactions | Yes (routed to `onReaction`) | +| Typing indicator | Yes (keep-alive re-sent every 3s while a handler runs) | +| DMs | Yes | +| Group chats | Yes (`g`-prefixed conversation IDs) | +| Group join welcome | Yes (configurable via `welcomeMessage`) | +| Open DM | Yes (`openDM(userId)` reuses an existing conversation or runs a fresh key exchange; requires the recipient to have encrypted chat set up) | + +### Message history + +| Feature | Supported | +|---------|-----------| +| Fetch messages | Yes (`GET /2/chat/conversations/{id}/events`, batch-decrypted) | +| Fetch thread info | Yes | +| List threads | No | + +## Mention behavior in groups + +`chat.onNewMention(handler)` fires for group messages that mention the bot. A group message counts as a mention when: + +1. Its rich-text **mention entities** include the bot's @handle or user ID — the authoritative signal, or +2. It is a **swipe-reply** to one of the bot's own messages, or +3. Its plain text contains `@handle` (fallback when no entities are present). + +To reply to every group message instead, register a catch-all `chat.onNewMessage(/.+/, handler)`. + +## Thread ID format + +``` +xchat:{conversationId} +``` + +- 1:1 conversations: `xchat:1234567890-9876543210` (both participant IDs) +- Group conversations: `xchat:g123456789` (opaque `g`-prefixed ID) + +REST paths use the other participant's user ID for 1:1 conversations and the `g...` ID for groups; the adapter converts automatically. + +## Encryption notes + +- Conversation keys arrive via `KeyChange` events and are cached per conversation and key version. When a key is missing at send time, the adapter fetches recent conversation events to extract one. +- Incoming message signatures are verified against participants' signing keys (fetched from `GET /2/users/{id}/public_keys` and cached). With `verifySignatures: true` (the default), unverifiable messages are dropped. +- Media is encrypted separately from message text using streaming encryption; the message carries a `media_hash_key` reference that the recipient uses to download and decrypt the blob. + +## Troubleshooting + +### CRC validation failing + +- Confirm `X_CONSUMER_SECRET` matches your app's consumer secret in the developer portal +- The response must be `{"response_token": "sha256="}` for GET requests + +### Events not arriving + +- Verify the subscription exists: `GET /2/activity/subscriptions` with the app bearer token +- Confirm the subscription's `webhook_id` points at a webhook whose URL is your live endpoint +- Subscription changes can take a few minutes to provision + +### "Invalid signature" on webhook POSTs + +- The adapter verifies `x-twitter-webhooks-signature` with HMAC-SHA256 keyed by `X_CONSUMER_SECRET` — make sure it is the same app that owns the webhook + +### Messages decrypt but the bot never replies in groups + +- Group replies require a mention — check that the sender actually @mentioned the bot's handle (the one from `/2/users/me`), or use `{ allGroupMessages: true }` + +### "No conversation key" when posting + +- The bot can only send in conversations where a conversation key has been shared with it (i.e., someone messaged the bot first, added it to the group, or the bot opened the conversation itself via `openDM(userId)`). `openDM` requires the recipient to have encrypted chat set up, and the server requires the recipient to trust the bot (e.g. follow it) before the first message is accepted. + +## AI Coding Agents + +If you use an AI coding agent such as OpenAI Codex, Claude Code, or Cursor, install the Chat SDK skill so it knows the SDK APIs, adapter patterns, and project conventions before writing code. + +```bash +npx skills add vercel/chat +``` + +The skill references bundled documentation in `node_modules/chat/docs`, plus adapter guides and starter templates in the published package. + +For agent-readable documentation, see [chat-sdk.dev/llms.txt](https://chat-sdk.dev/llms.txt) (page index) or [chat-sdk.dev/llms-full.txt](https://chat-sdk.dev/llms-full.txt) (full text). + +## License + +MIT diff --git a/packages/adapter-xchat/package.json b/packages/adapter-xchat/package.json new file mode 100644 index 000000000..4c9bf17eb --- /dev/null +++ b/packages/adapter-xchat/package.json @@ -0,0 +1,67 @@ +{ + "name": "@chat-adapter/xchat", + "version": "0.1.0", + "description": "XChat adapter for Chat SDK: hold encrypted 1:1 and group conversations on X with all cryptography handled inside the adapter", + "type": "module", + "main": "./dist/index.js", + "module": "./dist/index.js", + "types": "./dist/index.d.ts", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "import": "./dist/index.js" + } + }, + "files": [ + "dist" + ], + "scripts": { + "build": "tsup", + "dev": "tsup --watch", + "test": "vitest run --coverage", + "test:watch": "vitest", + "typecheck": "tsc --noEmit", + "clean": "rm -rf dist" + }, + "dependencies": { + "@chat-adapter/shared": "workspace:*", + "@xdevplatform/chat-xdk": "^0.4.3", + "@xdevplatform/xdk": "^0.6.6", + "chat": "workspace:*", + "juicebox-sdk": "^0.3.6" + }, + "devDependencies": { + "@types/node": "^25.3.2", + "tsup": "^8.3.5", + "typescript": "^5.7.2", + "vitest": "^4.0.18" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/vercel/chat.git", + "directory": "packages/adapter-xchat" + }, + "homepage": "https://chat-sdk.dev/adapters/official/xchat", + "bugs": { + "url": "https://github.com/vercel/chat/issues" + }, + "publishConfig": { + "access": "public" + }, + "keywords": [ + "chat", + "chat-sdk", + "chatbot", + "xchat", + "x", + "x-api", + "bot", + "adapter", + "messaging", + "encryption", + "ai-agent", + "ai-sdk", + "vercel" + ], + "license": "MIT" +} diff --git a/packages/adapter-xchat/src/cards.test.ts b/packages/adapter-xchat/src/cards.test.ts new file mode 100644 index 000000000..d8400fde5 --- /dev/null +++ b/packages/adapter-xchat/src/cards.test.ts @@ -0,0 +1,146 @@ +import type { CardElement } from "chat"; +import { describe, expect, it } from "vitest"; +import { cardToXChat } from "./cards"; + +function card(overrides: Partial): CardElement { + return { type: "card", children: [], ...overrides }; +} + +describe("cardToXChat", () => { + it("renders title unwrapped and body text", () => { + const result = cardToXChat( + card({ + title: "Deploy ready", + subtitle: "build 42", + children: [{ type: "text", content: "All checks passed." }], + }) + ); + + expect(result.text).toBe("Deploy ready\nbuild 42\nAll checks passed."); + expect(result.urlCard).toBeUndefined(); + }); + + it("appends action link-buttons as label: url lines and uses the first as the preview card", () => { + const result = cardToXChat( + card({ + title: "Deploy ready", + children: [ + { type: "text", content: "All checks passed." }, + { + type: "actions", + children: [ + { + type: "link-button", + label: "View logs", + url: "https://ci.example.com/logs", + }, + { + type: "link-button", + label: "Dashboard", + url: "https://ci.example.com/dash", + }, + ], + }, + ], + }) + ); + + expect(result.text).toBe( + [ + "Deploy ready", + "All checks passed.", + "View logs: https://ci.example.com/logs", + "Dashboard: https://ci.example.com/dash", + ].join("\n") + ); + expect(result.urlCard).toEqual({ + url: "https://ci.example.com/logs", + displayTitle: "Deploy ready", + imageUrl: undefined, + }); + }); + + it("keeps inline links in the body without duplicating them as appended lines", () => { + const result = cardToXChat( + card({ + children: [ + { type: "link", label: "Docs", url: "https://docs.example.com" }, + ], + }) + ); + + // The shared fallback renders inline links as `label (url)` — no extra line. + expect(result.text).toBe("Docs (https://docs.example.com)"); + // Without a card title, the link label titles the preview card. + expect(result.urlCard).toEqual({ + url: "https://docs.example.com", + displayTitle: "Docs", + imageUrl: undefined, + }); + }); + + it("collects links nested inside sections", () => { + const result = cardToXChat( + card({ + children: [ + { + type: "section", + children: [ + { type: "link", label: "Docs", url: "https://docs.example.com" }, + ], + }, + ], + }) + ); + + expect(result.text).toBe("Docs (https://docs.example.com)"); + expect(result.urlCard?.url).toBe("https://docs.example.com"); + }); + + it("omits callback buttons entirely (no XChat representation)", () => { + const result = cardToXChat( + card({ + title: "Confirm", + children: [ + { + type: "actions", + children: [ + { type: "button", id: "approve", label: "Approve" }, + { type: "button", id: "reject", label: "Reject" }, + ], + }, + ], + }) + ); + + expect(result.text).toBe("Confirm"); + expect(result.urlCard).toBeUndefined(); + }); + + it("uses the card imageUrl as the preview banner", () => { + const result = cardToXChat( + card({ + title: "Release notes", + imageUrl: "https://cdn.example.com/banner.png", + children: [ + { type: "link", label: "Read", url: "https://example.com/notes" }, + ], + }) + ); + + expect(result.urlCard?.imageUrl).toBe("https://cdn.example.com/banner.png"); + }); + + it("falls back to the first image child for the preview banner", () => { + const result = cardToXChat( + card({ + children: [ + { type: "image", url: "https://cdn.example.com/chart.png" }, + { type: "link", label: "Report", url: "https://example.com/report" }, + ], + }) + ); + + expect(result.urlCard?.imageUrl).toBe("https://cdn.example.com/chart.png"); + }); +}); diff --git a/packages/adapter-xchat/src/cards.ts b/packages/adapter-xchat/src/cards.ts new file mode 100644 index 000000000..6a9f54314 --- /dev/null +++ b/packages/adapter-xchat/src/cards.ts @@ -0,0 +1,134 @@ +/** + * Card rendering for the XChat adapter. + * + * XChat has no interactive card primitives (no buttons, keyboards, or + * callbacks), so cards degrade to what the wire protocol carries: + * + * - text with tappable rich-text entities (urls, mentions) + * - one URL preview card per message (`attachment_type: "url"`), optionally + * with an encrypted banner image + * + * Link buttons and inline links become `label: url` lines so they stay + * usable as entities. Callback buttons have no representation and are + * omitted, matching the shared fallback-text behavior. + */ + +import { cardToFallbackText } from "@chat-adapter/shared"; +import type { CardChild, CardElement } from "chat"; + +/** A URL preview card derived from a CardElement. */ +export interface XChatUrlCardSpec { + /** Title shown on the preview card. */ + displayTitle?: string; + /** Image to encrypt and attach as the card banner. */ + imageUrl?: string; + url: string; +} + +export interface XChatCardResult { + text: string; + /** The card's primary link, when it has one. */ + urlCard?: XChatUrlCardSpec; +} + +interface CollectedLink { + label?: string; + url: string; +} + +function collectLinks(children: CardChild[], out: CollectedLink[]): void { + for (const child of children) { + if (child.type === "link") { + out.push({ label: child.label, url: child.url }); + } else if (child.type === "actions") { + for (const action of child.children) { + if (action.type === "link-button") { + out.push({ label: action.label, url: action.url }); + } + } + } else if (child.type === "section") { + collectLinks(child.children, out); + } + } +} + +function firstImageUrl(card: CardElement): string | undefined { + if (card.imageUrl) { + return card.imageUrl; + } + const stack: CardChild[] = [...card.children]; + while (stack.length > 0) { + const child = stack.shift(); + if (!child) { + continue; + } + if (child.type === "image") { + return child.url; + } + if (child.type === "section") { + stack.push(...child.children); + } + } + return undefined; +} + +/** + * Render a card to XChat message parts: plain text (links appended as + * `label: url` lines so URL entities make them tappable) and the primary + * link as a URL preview card spec. + */ +export function cardToXChat(card: CardElement): XChatCardResult { + const links: CollectedLink[] = []; + collectLinks(card.children, links); + + // XChat renders plain text, so unwrap the bold markers the shared + // fallback puts around the title. + let text = cardToFallbackText(card, { + boldFormat: "*", + lineBreak: "\n", + // The gchat fallback profile produces the plain-text output XChat needs. + platform: "gchat", + }); + if (card.title) { + text = text.replace(`*${card.title}*`, card.title); + } + + // The first link is the card's primary destination; the rest surface as + // extra lines (the shared fallback already renders inline `link` children, + // so only action-row link buttons need appending). + const buttonLinks: CollectedLink[] = []; + const seenInText = new Set(); + for (const child of card.children) { + if (child.type === "link") { + seenInText.add(child.url); + } + if (child.type === "section") { + for (const inner of child.children) { + if (inner.type === "link") { + seenInText.add(inner.url); + } + } + } + } + for (const link of links) { + if (!seenInText.has(link.url)) { + buttonLinks.push(link); + } + } + + const linkLines = buttonLinks.map((l) => + l.label ? `${l.label}: ${l.url}` : l.url + ); + const fullText = [text, ...linkLines].filter(Boolean).join("\n"); + + const primary = links[0]; + const urlCard: XChatUrlCardSpec | undefined = primary + ? { + url: primary.url, + displayTitle: card.title ?? primary.label, + imageUrl: firstImageUrl(card), + } + : undefined; + + return { text: fullText, urlCard }; +} diff --git a/packages/adapter-xchat/src/index.test.ts b/packages/adapter-xchat/src/index.test.ts new file mode 100644 index 000000000..9cefb151c --- /dev/null +++ b/packages/adapter-xchat/src/index.test.ts @@ -0,0 +1,2282 @@ +import type { ChatInstance } from "chat"; +import { describe, expect, it, vi } from "vitest"; + +const createChatMock = vi.hoisted(() => vi.fn()); +const getPublicKeyMock = vi.hoisted(() => + vi.fn().mockResolvedValue({ + data: [ + { + publicKeyVersion: "1", + juiceboxConfig: { + keyStoreTokenMapJson: JSON.stringify({ + realms: [], + register_threshold: 0, + recover_threshold: 0, + }), + maxGuessCount: 20, + tokenMap: [ + { + key: "testrealm", + value: { address: "https://juicebox.test", token: "test-token" }, + }, + ], + }, + }, + ], + }) +); + +vi.mock("@xdevplatform/chat-xdk", async (importOriginal) => { + const actual = + await importOriginal(); + return { + ...actual, + createChat: (...args: unknown[]) => createChatMock(...args), + }; +}); + +vi.mock("@xdevplatform/xdk", async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + Client: class MockClient { + users = { getPublicKey: getPublicKeyMock }; + chat = { + getConversationEvents: vi.fn(), + sendMessage: vi.fn(), + sendTypingIndicator: vi.fn(), + }; + }, + }; +}); + +import { + conversationPathId, + dashConversationId, + detectEntities, + extractMediaEntries, + extractPostAttachments, + mentionHandlesFromEntities, + XChatAdapter, +} from "./index"; +import { + b64ToBytes, + createInitializedTestAdapter, + createMockChatInstance, + createTestCryptoEngine, + loadVectors, + type MockXdkClient, + mockLogger, + TEST_CANONICAL_CONVERSATION_ID, + TEST_CONVERSATION_ID, + TEST_OTHER_USER_ID, + TEST_PIN, + TEST_THREAD_ID, + TEST_USER_ID, +} from "./test-utils"; +import type { XChatRawMessage } from "./types"; + +// ── Error-message patterns asserted in tests ──────────────────────── +const MISSING_ACCESS_TOKEN_RE = /accessToken|botToken/i; +const MISSING_USER_ID_RE = /userId/i; +const UNINITIALIZED_RE = /uninitialized/; +const NOT_INITIALIZED_RE = /not initialized/i; +const NO_CONVERSATION_KEY_RE = /No conversation key/; +const NO_REGISTERED_CHAT_KEYS_RE = /no registered chat keys/; +const NO_SEQUENCE_ID_RE = /No sequence id known/; +const NO_JUICEBOX_CONFIG_RE = /no Juicebox config/; +const HTTP_404_RE = /HTTP 404/; + +/** + * Create a minimal XChatAdapter for testing. + * Crypto and API calls are not initialized — only thread ID and parsing methods work. + */ +function createTestAdapter(): XChatAdapter { + return new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + userName: "test-bot", + logger: mockLogger, + }); +} + +describe("conversationPathId", () => { + it("returns the other participant for hyphen 1:1 ids", () => { + expect(conversationPathId(TEST_CONVERSATION_ID, TEST_USER_ID)).toBe( + TEST_OTHER_USER_ID + ); + }); + + it("returns the other participant for colon 1:1 ids", () => { + expect( + conversationPathId(TEST_CANONICAL_CONVERSATION_ID, TEST_USER_ID) + ).toBe(TEST_OTHER_USER_ID); + }); + + it("returns group ids unchanged", () => { + expect(conversationPathId("gABCDE", TEST_USER_ID)).toBe("gABCDE"); + }); +}); + +describe("dashConversationId", () => { + it("dash-joins colon 1:1 ids", () => { + expect(dashConversationId(TEST_CANONICAL_CONVERSATION_ID)).toBe( + TEST_CONVERSATION_ID + ); + }); + + it("keeps dash 1:1 ids unchanged", () => { + expect(dashConversationId(TEST_CONVERSATION_ID)).toBe(TEST_CONVERSATION_ID); + }); + + it("returns group ids unchanged", () => { + expect(dashConversationId("gABCDE")).toBe("gABCDE"); + }); +}); + +describe("encodeThreadId", () => { + it("should encode a 1:1 conversation ID", () => { + const adapter = createTestAdapter(); + const result = adapter.encodeThreadId({ conversationId: "12345-67890" }); + expect(result).toBe("xchat:12345-67890"); + }); + + it("should encode a group conversation ID", () => { + const adapter = createTestAdapter(); + const result = adapter.encodeThreadId({ conversationId: "gABCDE" }); + expect(result).toBe("xchat:gABCDE"); + }); +}); + +describe("decodeThreadId", () => { + it("should decode a valid 1:1 thread ID", () => { + const adapter = createTestAdapter(); + const result = adapter.decodeThreadId("xchat:12345-67890"); + expect(result).toEqual({ conversationId: "12345-67890" }); + }); + + it("should decode a valid group thread ID", () => { + const adapter = createTestAdapter(); + const result = adapter.decodeThreadId("xchat:gABCDE"); + expect(result).toEqual({ conversationId: "gABCDE" }); + }); + + it("should throw on invalid prefix", () => { + const adapter = createTestAdapter(); + expect(() => adapter.decodeThreadId("slack:C123:ts123")).toThrow( + "Invalid XChat thread ID" + ); + }); + + it("should throw on empty after prefix", () => { + const adapter = createTestAdapter(); + expect(() => adapter.decodeThreadId("xchat:")).toThrow( + "Invalid XChat thread ID format" + ); + }); +}); + +describe("isDM", () => { + it("should return true for 1:1 conversation", () => { + const adapter = createTestAdapter(); + expect(adapter.isDM("xchat:12345-67890")).toBe(true); + }); + + it("should return false for group conversation", () => { + const adapter = createTestAdapter(); + expect(adapter.isDM("xchat:gABCDE")).toBe(false); + }); +}); + +describe("channelIdFromThreadId", () => { + it("should return the same thread ID", () => { + const adapter = createTestAdapter(); + expect(adapter.channelIdFromThreadId("xchat:12345-67890")).toBe( + "xchat:12345-67890" + ); + }); +}); + +describe("parseMessage", () => { + it("should parse a decrypted text message", () => { + const adapter = createTestAdapter(); + const raw: XChatRawMessage = { + event: { + id: "msg-1", + conversationId: "12345-67890", + senderId: "67890", + encodedEvent: "base64data", + createdAtMsec: "1700000000000", + }, + decrypted: { + type: "message", + id: "msg-1", + senderId: "67890", + conversationId: "12345:67890", + createdAtMsec: 1700000000000, + content: { text: "Hello world", contentType: "Text" }, + verified: true, + }, + }; + + const message = adapter.parseMessage(raw); + expect(message.id).toBe("msg-1"); + expect(message.text).toBe("Hello world"); + expect(message.author.userId).toBe("67890"); + expect(message.author.isMe).toBe(false); + expect(message.threadId).toBe("xchat:12345-67890"); + }); + + it("should handle messages with no decrypted content", () => { + const adapter = createTestAdapter(); + const raw: XChatRawMessage = { + event: { + id: "msg-2", + conversationId: "12345-67890", + senderId: "67890", + encodedEvent: "base64data", + }, + decrypted: null, + }; + + const message = adapter.parseMessage(raw); + expect(message.id).toBe("msg-2"); + expect(message.text).toBe(""); + }); + + it("should detect self messages", () => { + const adapter = createTestAdapter(); + const raw: XChatRawMessage = { + event: { + id: "msg-3", + conversationId: "12345-67890", + senderId: "12345", + encodedEvent: "base64data", + }, + decrypted: { + type: "message", + senderId: "12345", + content: { text: "My message" }, + }, + }; + + const message = adapter.parseMessage(raw); + expect(message.author.isMe).toBe(true); + }); +}); + +describe("handleWebhook", () => { + // CRC challenges (GET) are handled at the route level, not by the adapter. + // The adapter only handles POST requests. + + it("should return 405 for GET requests", async () => { + const adapter = createTestAdapter(); + const request = new Request("https://example.com/webhook", { + method: "GET", + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(405); + }); + + it("should return 400 for invalid JSON body", async () => { + const adapter = createTestAdapter(); + const request = new Request("https://example.com/webhook", { + method: "POST", + body: "not json", + headers: { "Content-Type": "application/json" }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(400); + }); + + it("should return 200 for valid event without conversationId", async () => { + const adapter = createTestAdapter(); + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify({}), + headers: { "Content-Type": "application/json" }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + }); + + it("should reject POST with missing signature when consumerSecret is set", async () => { + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + consumerSecret: "test-secret", + userName: "test-bot", + logger: mockLogger, + }); + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "evt-1", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_OTHER_USER_ID, + encoded_event: "data", + }, + }, + }; + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { "Content-Type": "application/json" }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(401); + }); + + it("should reject POST with invalid signature", async () => { + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + consumerSecret: "test-secret", + userName: "test-bot", + logger: mockLogger, + }); + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "evt-1", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_OTHER_USER_ID, + encoded_event: "data", + }, + }, + }; + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { + "Content-Type": "application/json", + "x-twitter-webhooks-signature": "sha256=invalidsignature", + }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(401); + }); + + it("should accept POST with valid signature", async () => { + const { createHmac } = await import("node:crypto"); + const secret = "test-secret"; + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + consumerSecret: secret, + userName: "test-bot", + logger: mockLogger, + }); + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "evt-1", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_OTHER_USER_ID, + encoded_event: "data", + }, + }, + }; + const body = JSON.stringify(xaaPayload); + const sig = `sha256=${createHmac("sha256", secret).update(body).digest("base64")}`; + + const request = new Request("https://example.com/webhook", { + method: "POST", + body, + headers: { + "Content-Type": "application/json", + "x-twitter-webhooks-signature": sig, + }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + }); + + it("should skip chat.sent events", async () => { + const adapter = createTestAdapter(); + const xaaPayload = { + data: { + event_type: "chat.sent", + payload: { + id: "evt-1", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_OTHER_USER_ID, + encoded_event: "data", + }, + }, + }; + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { "Content-Type": "application/json" }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + }); +}); + +describe("createXChatAdapter", () => { + it("should throw when accessToken is missing", async () => { + const { createXChatAdapter } = await import("./index"); + expect(() => + createXChatAdapter({ + userId: "12345", + }) + ).toThrow(MISSING_ACCESS_TOKEN_RE); + }); + + it("should throw when userId is missing", async () => { + const { createXChatAdapter } = await import("./index"); + expect(() => + createXChatAdapter({ + accessToken: "token", + }) + ).toThrow(MISSING_USER_ID_RE); + }); + + it("should create adapter with only required config (interactive mode)", async () => { + const { createXChatAdapter } = await import("./index"); + const adapter = createXChatAdapter({ + accessToken: "token", + userId: "12345", + }); + expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter.name).toBe("xchat"); + expect(adapter.cryptoStatus).toBe("uninitialized"); + }); + + it("should accept botToken as accessToken alias", async () => { + const { createXChatAdapter } = await import("./index"); + const adapter = createXChatAdapter({ + botToken: "token", + userId: "12345", + }); + expect(adapter).toBeInstanceOf(XChatAdapter); + }); + + it("should accept optional signingKeyVersion override", async () => { + const { createXChatAdapter } = await import("./index"); + const adapter = createXChatAdapter({ + accessToken: "token", + userId: "12345", + signingKeyVersion: "42", + }); + expect(adapter).toBeInstanceOf(XChatAdapter); + }); + + it("should accept verifySignatures override", async () => { + const { createXChatAdapter } = await import("./index"); + const adapter = createXChatAdapter({ + accessToken: "token", + userId: "12345", + verifySignatures: false, + }); + expect(adapter).toBeInstanceOf(XChatAdapter); + }); + + it("should accept pin for Juicebox auto-unlock", async () => { + const { createXChatAdapter } = await import("./index"); + const adapter = createXChatAdapter({ + botToken: "token", + userId: "12345", + pin: "2580", + }); + expect(adapter).toBeInstanceOf(XChatAdapter); + }); +}); + +function juiceboxStubFromEngine( + engine: Awaited> +) { + return new Proxy(engine as object, { + get(target, prop, receiver) { + if (prop === "unlock" || prop === "setup") { + return async () => engine.getPublicKeys(); + } + return Reflect.get(target, prop, receiver); + }, + }); +} + +describe("verifySignatures", () => { + it("leaves chat-xdk default (reject unverified) when unset", async () => { + const engine = await createTestCryptoEngine(); + const setRejectSpy = vi.spyOn(engine, "setRejectUnverified"); + createChatMock.mockResolvedValue(juiceboxStubFromEngine(engine)); + getPublicKeyMock.mockClear(); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + pin: TEST_PIN, + userName: "test-bot", + logger: mockLogger, + }); + await adapter.initialize(mockChat as unknown as ChatInstance); + expect(setRejectSpy).not.toHaveBeenCalled(); + expect(adapter.cryptoStatus).toBe("ready"); + } finally { + createChatMock.mockReset(); + } + }); + + it("opts out of verification when verifySignatures is false", async () => { + const engine = await createTestCryptoEngine(); + const setRejectSpy = vi.spyOn(engine, "setRejectUnverified"); + createChatMock.mockResolvedValue(juiceboxStubFromEngine(engine)); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + pin: TEST_PIN, + verifySignatures: false, + userName: "test-bot", + logger: mockLogger, + }); + await adapter.initialize(mockChat as unknown as ChatInstance); + expect(setRejectSpy).toHaveBeenCalledWith(false); + } finally { + createChatMock.mockReset(); + } + }); +}); + +describe("unlock", () => { + it("should throw when called before initialize", async () => { + const adapter = createTestAdapter(); + await expect(adapter.unlock("1234")).rejects.toThrow(UNINITIALIZED_RE); + }); +}); + +// ============================================================================= +// Integration tests — real chat-xdk WASM crypto, mocked HTTP +// ============================================================================= + +describe("initialize (Juicebox)", () => { + it("should auto-unlock when pin is provided", async () => { + const engine = await createTestCryptoEngine(); + createChatMock.mockResolvedValue(juiceboxStubFromEngine(engine)); + getPublicKeyMock.mockClear(); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + pin: TEST_PIN, + userName: "test-bot", + logger: mockLogger, + }); + expect(adapter.cryptoStatus).toBe("uninitialized"); + await adapter.initialize(mockChat as unknown as ChatInstance); + expect(adapter.cryptoStatus).toBe("ready"); + expect(createChatMock).toHaveBeenCalled(); + expect(getPublicKeyMock).toHaveBeenCalled(); + } finally { + createChatMock.mockReset(); + } + }); + + it("establishes the session identity on unlock", async () => { + const engine = await createTestCryptoEngine(); + const setIdentitySpy = vi.spyOn(engine, "setIdentity"); + createChatMock.mockResolvedValue(juiceboxStubFromEngine(engine)); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + pin: TEST_PIN, + userName: "test-bot", + logger: mockLogger, + }); + await adapter.initialize(mockChat as unknown as ChatInstance); + // The signing key version comes from the mocked getPublicKey response. + expect(setIdentitySpy).toHaveBeenCalledWith(TEST_USER_ID, "1"); + } finally { + createChatMock.mockReset(); + } + }); + + it("should stay locked when pin is omitted", async () => { + const engine = await createTestCryptoEngine(); + createChatMock.mockResolvedValue(juiceboxStubFromEngine(engine)); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + userName: "test-bot", + logger: mockLogger, + }); + await adapter.initialize(mockChat as unknown as ChatInstance); + expect(adapter.cryptoStatus).toBe("locked"); + } finally { + createChatMock.mockReset(); + } + }); + + it("should throw and set error status when no juicebox config", async () => { + createChatMock.mockReset(); + getPublicKeyMock.mockResolvedValueOnce({ + data: [{ publicKeyVersion: "1" }], + }); + + try { + const mockChat = createMockChatInstance(); + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + userName: "test-bot", + logger: mockLogger, + }); + await expect( + adapter.initialize(mockChat as unknown as ChatInstance) + ).rejects.toThrow(NO_JUICEBOX_CONFIG_RE); + expect(adapter.cryptoStatus).toBe("error"); + expect(createChatMock).not.toHaveBeenCalled(); + } finally { + getPublicKeyMock.mockReset(); + getPublicKeyMock.mockResolvedValue({ + data: [ + { + publicKeyVersion: "1", + juiceboxConfig: { + keyStoreTokenMapJson: JSON.stringify({ + realms: [], + register_threshold: 0, + recover_threshold: 0, + }), + maxGuessCount: 20, + tokenMap: [ + { + key: "testrealm", + value: { + address: "https://juicebox.test", + token: "test-token", + }, + }, + ], + }, + }, + ], + }); + } + }); +}); + +describe("postMessage (with real crypto)", () => { + it("should throw when adapter is not ready", async () => { + const adapter = createTestAdapter(); + await expect(adapter.postMessage(TEST_THREAD_ID, "Hello")).rejects.toThrow( + NOT_INITIALIZED_RE + ); + }); + + it("should throw when no conversation key available even after auto-fetch", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + + // Mock getConversationEvents to return no events + xdk.chat.getConversationEvents = vi.fn().mockResolvedValue({ + data: [], + meta: {}, + }); + + await expect( + adapter.postMessage(TEST_THREAD_ID, "Hello") + ).rejects.toThrow(NO_CONVERSATION_KEY_RE); + } finally { + restore(); + } + }); +}); + +describe("postMessage sends encrypted payload (real crypto)", () => { + it("should encrypt text and call sendMessage with encrypted payload", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + + // Inject a conversation key so postMessage can encrypt + const keysMap = (adapter as any).conversationKeys as Map; + const vectors = loadVectors(); + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + + // Also inject a conversation token + const tokensMap = (adapter as any).conversationTokens as Map< + string, + string + >; + tokensMap.set(TEST_CONVERSATION_ID, "conv-token-123"); + + // Mock sendMessage on the XDK client + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ + data: { id: "sent-msg-123" }, + }); + + // Send a message — this uses real chat-xdk WASM encryption + const result = await adapter.postMessage(TEST_THREAD_ID, "Got it!"); + + expect(result.id).toBeDefined(); + expect(result.raw.decrypted?.content?.text).toBe("Got it!"); + + // Verify sendMessage was called with encrypted content + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + const [convId, payload] = (xdk.chat.sendMessage as any).mock.calls[0]; + // 1:1 REST paths use the recipient user id, not the composite conversation id. + expect(convId).toBe(TEST_OTHER_USER_ID); + expect(payload.encodedMessageCreateEvent).toBeTruthy(); + expect(typeof payload.encodedMessageCreateEvent).toBe("string"); + expect(payload.encodedMessageEventSignature).toBeTruthy(); + expect(payload.messageId).toBeTruthy(); + expect(payload.conversationToken).toBe("conv-token-123"); + } finally { + restore(); + } + }); +}); + +describe("fetchMessages with mocked API (adapter logic)", () => { + it("should parse API response events into messages", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + + // Mock getConversationEvents to return raw events. + // Note: since we can't create real decryptable events in unit tests + // (encryptMessage output ≠ what the API returns in encoded_event), + // we test the adapter's parsing logic with events that fail decryption. + // The adapter should gracefully skip undecryptable events. + xdk.chat.getConversationEvents = vi.fn().mockResolvedValue({ + data: [ + { + id: "evt-1", + sequenceId: "seq-1", + senderId: TEST_OTHER_USER_ID, + conversationId: TEST_CONVERSATION_ID, + createdAtMsec: "1700000000000", + encodedEvent: "not-a-real-encrypted-event", + conversationToken: "conv-token-456", + }, + ], + meta: {}, + }); + + // Signing-key lookup hits the API — return no usable keys so decryption + // proceeds unverified and the bogus event is skipped. + xdk.users.getPublicKey = vi.fn().mockResolvedValue({ data: [] }); + + const result = await adapter.fetchMessages(TEST_THREAD_ID, { limit: 50 }); + + // The event should fail decryption gracefully → 0 messages + expect(result.messages.length).toBe(0); + + // But the conversation token should have been cached + const tokensMap = (adapter as any).conversationTokens as Map< + string, + string + >; + expect(tokensMap.get(TEST_CONVERSATION_ID)).toBe("conv-token-456"); + + // Verify getConversationEvents was called with the recipient user id + expect(xdk.chat.getConversationEvents).toHaveBeenCalledOnce(); + expect(xdk.chat.getConversationEvents).toHaveBeenCalledWith( + TEST_OTHER_USER_ID, + expect.objectContaining({ maxResults: 50 }) + ); + } finally { + restore(); + } + }); +}); + +describe("handleWebhook full flow (real crypto)", () => { + it("should route a decryptable XAA chat.received event to handleIncomingMessage", async () => { + const { adapter, mockChat, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const vectors = loadVectors(); + const xdk = getXdkClient(); + + // Serve the fixture sender's signing keys so the event signature + // verifies for real. + xdk.users.getPublicKey = vi.fn().mockResolvedValue({ + data: [ + { + publicKeyVersion: vectors.event_signing_key_version, + signingPublicKey: vectors.signing_public_b64, + publicKey: vectors.identity_public_b64, + identityPublicKeySignature: + vectors.identity_public_key_signature_b64, + }, + ], + }); + + // Cache the conversation key the fixture event was encrypted with. + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(vectors.event_conversation_id, { + keys: { + [vectors.event_conversation_key_version]: b64ToBytes( + vectors.conversation_key_b64 + ), + }, + latestVersion: vectors.event_conversation_key_version, + }); + + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "webhook-evt-1", + conversation_id: vectors.event_conversation_id, + sender_id: vectors.event_sender_id, + encoded_event: vectors.event_message_b64, + conversation_key_version: vectors.event_conversation_key_version, + }, + }, + }; + + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { "Content-Type": "application/json" }, + }); + + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + + // The webhook decrypts in the background, then hands the parsed + // message to handleIncomingMessage. + await vi.waitFor(() => { + expect(mockChat.handleIncomingMessage).toHaveBeenCalledOnce(); + }); + const [, threadId, message] = ( + mockChat.handleIncomingMessage as ReturnType + ).mock.calls[0]; + expect(threadId).toBe(`xchat:${vectors.event_conversation_id}`); + expect(message.text).toBe(vectors.event_message_text); + expect(message.author.userId).toBe(vectors.event_sender_id); + expect(message.author.isMe).toBe(false); + } finally { + restore(); + } + }); + + it("drops webhook events that cannot be decrypted", async () => { + const { adapter, mockChat, restore } = await createInitializedTestAdapter(); + try { + // No conversation key is cached, so decryption fails; the event must + // be dropped (same as the poll path), not delivered as an empty + // message. + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "webhook-evt-undecryptable", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_OTHER_USER_ID, + encoded_event: "some-encrypted-data", + conversation_key_version: "1", + }, + }, + }; + + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { "Content-Type": "application/json" }, + }); + + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + + // Give the background decrypt task a chance to run. + await new Promise((resolve) => setTimeout(resolve, 20)); + expect(mockChat.handleIncomingMessage).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); + + it("should skip self-messages in webhook", async () => { + const { adapter, mockChat, restore } = await createInitializedTestAdapter(); + try { + const xaaPayload = { + data: { + event_type: "chat.received", + payload: { + id: "self-evt-1", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_USER_ID, // from self + encoded_event: "irrelevant", + }, + }, + }; + + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify(xaaPayload), + headers: { "Content-Type": "application/json" }, + }); + + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + // Give any (incorrect) background task a chance to run + await new Promise((resolve) => setImmediate(resolve)); + expect(mockChat.handleIncomingMessage).not.toHaveBeenCalled(); + expect(mockChat.processMessage).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); +}); + +describe("read receipts on delivery (real crypto)", () => { + /** Build the fixture chat.received webhook request and prime the adapter. */ + function primeFixtureDelivery( + adapter: XChatAdapter, + xdk: MockXdkClient + ): Request { + const vectors = loadVectors(); + + xdk.users.getPublicKey = vi.fn().mockResolvedValue({ + data: [ + { + publicKeyVersion: vectors.event_signing_key_version, + signingPublicKey: vectors.signing_public_b64, + publicKey: vectors.identity_public_b64, + identityPublicKeySignature: vectors.identity_public_key_signature_b64, + }, + ], + }); + // Fallback watermark for markAsRead when the event carries no sequence id. + xdk.chat.getConversationEvents = vi.fn().mockResolvedValue({ + data: [{ id: "evt-latest", sequenceId: "seq-42" }], + }); + + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(vectors.event_conversation_id, { + keys: { + [vectors.event_conversation_key_version]: b64ToBytes( + vectors.conversation_key_b64 + ), + }, + latestVersion: vectors.event_conversation_key_version, + }); + + return new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify({ + data: { + event_type: "chat.received", + payload: { + id: "webhook-evt-rr", + conversation_id: vectors.event_conversation_id, + sender_id: vectors.event_sender_id, + encoded_event: vectors.event_message_b64, + conversation_key_version: vectors.event_conversation_key_version, + }, + }, + }), + headers: { "Content-Type": "application/json" }, + }); + } + + it("sends a read receipt for each delivered message by default", async () => { + const { adapter, mockChat, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const request = primeFixtureDelivery(adapter, xdk); + + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + + await vi.waitFor(() => { + expect(mockChat.handleIncomingMessage).toHaveBeenCalledOnce(); + }); + expect(xdk.chat.markConversationRead).toHaveBeenCalledOnce(); + const [, body] = xdk.chat.markConversationRead.mock.calls[0]; + expect(typeof body.seenUntilSequenceId).toBe("string"); + expect(body.seenUntilSequenceId.length).toBeGreaterThan(0); + } finally { + restore(); + } + }); + + it("suppresses read receipts when sendReadReceipts is false", async () => { + const { adapter, mockChat, getXdkClient, restore } = + await createInitializedTestAdapter({ sendReadReceipts: false }); + try { + const xdk = getXdkClient(); + const request = primeFixtureDelivery(adapter, xdk); + + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + + await vi.waitFor(() => { + expect(mockChat.handleIncomingMessage).toHaveBeenCalledOnce(); + }); + expect(xdk.chat.markConversationRead).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); +}); + +describe("detectEntities", () => { + it("detects URLs and mentions with correct spans", () => { + const text = "hey @alice check https://example.com/x now"; + const entities = detectEntities(text); + expect(entities).toEqual([ + [4, 10, "mention"], + [17, 38, "url"], + ]); + expect(text.slice(4, 10)).toBe("@alice"); + expect(text.slice(17, 38)).toBe("https://example.com/x"); + }); + + it("skips mentions inside detected URLs and emails", () => { + const entities = detectEntities("mail foo@bar.com or https://a.io/@baz"); + expect(entities?.every(([, , kind]) => kind === "url")).toBe(true); + }); + + it("returns null when nothing matches", () => { + expect(detectEntities("plain text only")).toBeNull(); + }); +}); + +describe("extractPostAttachments", () => { + it("extracts x.com post URLs as post cards, deduped by id", () => { + const text = + "see https://x.com/foo/status/123 and https://twitter.com/foo/status/123 and https://x.com/bar/status/456"; + expect(extractPostAttachments(text)).toEqual([ + { + attachment_type: "post", + rest_id: "123", + post_url: "https://x.com/foo/status/123", + }, + { + attachment_type: "post", + rest_id: "456", + post_url: "https://x.com/bar/status/456", + }, + ]); + }); + + it("returns null when no post URLs are present", () => { + expect(extractPostAttachments("no posts here")).toBeNull(); + }); +}); + +describe("mentionHandlesFromEntities", () => { + const text = "hey @Test_Bot and @other"; + + it("extracts handles from snake_case entity spans", () => { + const entities = [ + { start_index: 4, end_index: 13, content: { mention: {} } }, + { start_index: 18, end_index: 24, content: { mention: {} } }, + ]; + expect(mentionHandlesFromEntities(text, entities)).toEqual([ + "test_bot", + "other", + ]); + }); + + it("extracts handles from camelCase entity spans", () => { + const entities = [ + { startIndex: 4, endIndex: 13, content: { mention: {} } }, + ]; + expect(mentionHandlesFromEntities(text, entities)).toEqual(["test_bot"]); + }); + + it("ignores non-mention entities", () => { + const entities = [{ start_index: 4, end_index: 13, content: { url: {} } }]; + expect(mentionHandlesFromEntities(text, entities)).toEqual([]); + }); +}); + +describe("parseMessage mention + attachment mapping", () => { + function rawFor(decrypted: Record): XChatRawMessage { + return { + event: { + id: "evt-m1", + conversationId: "gGROUP1", + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + }, + decrypted: decrypted as XChatRawMessage["decrypted"], + }; + } + + it("sets isMention when an entity mention targets the bot handle", () => { + const adapter = createTestAdapter(); + const text = "yo @test-bot help"; + const message = adapter.parseMessage( + rawFor({ + type: "message", + senderId: TEST_OTHER_USER_ID, + content: { + contentType: "text", + text, + entities: [ + { start_index: 3, end_index: 12, content: { mention: {} } }, + ], + }, + }) + ); + expect(message.isMention).toBe(true); + }); + + it("sets isMention on a swipe-reply to the bot", () => { + const adapter = createTestAdapter(); + const message = adapter.parseMessage( + rawFor({ + type: "message", + senderId: TEST_OTHER_USER_ID, + content: { + contentType: "text", + text: "what about this?", + replyingToPreview: { sender_id: TEST_USER_ID, text: "earlier" }, + }, + }) + ); + expect(message.isMention).toBe(true); + }); + + it("ignores a swipe-reply whose preview failed validation", () => { + const adapter = createTestAdapter(); + const message = adapter.parseMessage( + rawFor({ + type: "message", + senderId: TEST_OTHER_USER_ID, + replyPreviewValidation: "invalid", + content: { + contentType: "text", + text: "what about this?", + replyingToPreview: { sender_id: TEST_USER_ID, text: "earlier" }, + }, + }) + ); + expect(message.isMention).toBeUndefined(); + }); + + it("leaves isMention unset for plain group text", () => { + const adapter = createTestAdapter(); + const message = adapter.parseMessage( + rawFor({ + type: "message", + senderId: TEST_OTHER_USER_ID, + content: { contentType: "text", text: "just chatting" }, + }) + ); + expect(message.isMention).toBeUndefined(); + }); + + it("maps media attachments with lazy fetchData", () => { + const adapter = createTestAdapter(); + const message = adapter.parseMessage( + rawFor({ + type: "message", + senderId: TEST_OTHER_USER_ID, + keyVersion: "1", + content: { contentType: "media", text: "" }, + attachments: [ + { + media: { + media_hash_key: "hash-abc", + type: "image", + filename: "pic.jpg", + filesize_bytes: 1234, + dimensions: { width: 640, height: 480 }, + }, + }, + ], + }) + ); + expect(message.attachments).toHaveLength(1); + const att = message.attachments[0]; + expect(att.type).toBe("image"); + expect(att.name).toBe("pic.jpg"); + expect(att.width).toBe(640); + expect(typeof att.fetchData).toBe("function"); + }); +}); + +describe("extractMediaEntries", () => { + it("collects media from attachments, content, and mediaHashes without dupes", () => { + const entries = extractMediaEntries({ + type: "message", + attachments: [ + { media: { media_hash_key: "h1", type: "image" } }, + { attachmentType: "media", mediaHashKey: "h2", mediaType: "video" }, + ], + content: { + attachments: [{ media: { media_hash_key: "h1", type: "image" } }], + }, + mediaHashes: [{ source: "gif_attachment", mediaHashKey: "h3" }], + }); + expect(entries.map((e) => e.hashKey)).toEqual(["h1", "h2", "h3"]); + expect(entries.map((e) => e.mediaType)).toEqual(["image", "video", "gif"]); + }); +}); + +describe("group quote-replies (real crypto)", () => { + it("replies with the raw inbound event (replyToEvent) in groups", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const groupConvId = "gGROUP1"; + const groupThreadId = `xchat:${groupConvId}`; + const vectors = loadVectors(); + const convKey = b64ToBytes(vectors.conversation_key_b64); + + // Cache the conversation key under the version the fixture raw event + // was encrypted with, so the SDK can decrypt the original to derive + // the reply preview. + const keyVersion = vectors.event_conversation_key_version; + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(groupConvId, { + keys: { [keyVersion]: convKey }, + latestVersion: keyVersion, + }); + + // Record inbound context by parsing a group message that carries the + // fixture's genuine server-shaped raw signed event. + adapter.parseMessage({ + event: { + id: "evt-g1", + conversationId: groupConvId, + senderId: TEST_OTHER_USER_ID, + encodedEvent: vectors.event_message_b64, + }, + decrypted: { + type: "message", + id: "msg-g1", + senderId: TEST_OTHER_USER_ID, + sequenceId: "seq-42", + content: { contentType: "text", text: vectors.event_message_text }, + }, + }); + + const engine = (adapter as any).cryptoEngine; + const replySpy = vi.spyOn(engine, "encryptReply"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + const result = await adapter.postMessage(groupThreadId, "quoted reply"); + + expect(replySpy).toHaveBeenCalledOnce(); + const params = replySpy.mock.calls[0][0] as Record; + expect(params.replyToEvent).toBe(vectors.event_message_b64); + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + // The message id chat-xdk generated for the payload reaches the API + // and the returned RawMessage unchanged + const payload = replySpy.mock.results[0].value as { messageId: string }; + const sent = xdk.chat.sendMessage.mock.calls[0][1]; + expect(payload.messageId).toBeTruthy(); + expect(sent.messageId).toBe(payload.messageId); + expect(result.id).toBe(payload.messageId); + } finally { + restore(); + } + }); + + it("quote-replies the newest inbound message even when older history is parsed after it", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const groupConvId = "gGROUP3"; + const groupThreadId = `xchat:${groupConvId}`; + const vectors = loadVectors(); + + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(groupConvId, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + + const parseAt = (id: string, createdAtMsec: number) => + adapter.parseMessage({ + event: { + id: `evt-${id}`, + conversationId: groupConvId, + senderId: TEST_OTHER_USER_ID, + encodedEvent: `raw-${id}`, + }, + decrypted: { + type: "message", + id, + senderId: TEST_OTHER_USER_ID, + sequenceId: `seq-${id}`, + createdAtMsec, + content: { contentType: "text", text: id }, + }, + }); + + // Webhook delivers the triggering message, then a history fetch parses + // the page newest-first, ending on the oldest message. + parseAt("newest", 3000); + parseAt("older", 2000); + parseAt("oldest", 1000); + + const engine = (adapter as any).cryptoEngine; + const replySpy = vi.spyOn(engine, "encryptReply"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + await adapter.postMessage(groupThreadId, "reply"); + + // Both encryptReply calls (event-based, then override fallback for the + // unparseable raw event) must target the newest message. + for (const call of replySpy.mock.calls) { + const params = call[0] as Record; + if (params.replyToEvent !== undefined) { + expect(params.replyToEvent).toBe("raw-newest"); + } else { + expect(params.replyToSequenceId).toBe("seq-newest"); + } + } + } finally { + restore(); + } + }); + + it("falls back to preview overrides when the raw event is unusable", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const groupConvId = "gGROUP2"; + const groupThreadId = `xchat:${groupConvId}`; + const vectors = loadVectors(); + + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(groupConvId, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + + // Inbound context with an encoded event that is not a parseable event + adapter.parseMessage({ + event: { + id: "evt-g2", + conversationId: groupConvId, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + }, + decrypted: { + type: "message", + id: "msg-g2", + senderId: TEST_OTHER_USER_ID, + sequenceId: "seq-42", + content: { contentType: "text", text: "original" }, + }, + }); + + const engine = (adapter as any).cryptoEngine; + const replySpy = vi.spyOn(engine, "encryptReply"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + await adapter.postMessage(groupThreadId, "quoted reply"); + + // First call with replyToEvent throws inside chat-xdk; the fallback + // retries with the explicit preview overrides. + expect(replySpy).toHaveBeenCalledTimes(2); + const params = replySpy.mock.calls[1][0] as Record; + expect(params.replyToEvent).toBeUndefined(); + expect(params.replyToSequenceId).toBe("seq-42"); + expect(params.replyToSenderId).toBe(TEST_OTHER_USER_ID); + expect(params.replyToText).toBe("original"); + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + } finally { + restore(); + } + }); + + it("uses encryptMessage for 1:1 conversations", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + + const engine = (adapter as any).cryptoEngine; + const replySpy = vi.spyOn(engine, "encryptReply"); + const messageSpy = vi.spyOn(engine, "encryptMessage"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + await adapter.postMessage(TEST_THREAD_ID, "dm reply"); + + expect(replySpy).not.toHaveBeenCalled(); + expect(messageSpy).toHaveBeenCalledOnce(); + } finally { + restore(); + } + }); +}); + +describe("reactions (real crypto)", () => { + it("encrypts and sends a reaction for a cached sequence id", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + // Cache the message → sequence mapping via parseMessage + adapter.parseMessage({ + event: { + id: "evt-r1", + conversationId: TEST_CONVERSATION_ID, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + }, + decrypted: { + type: "message", + id: "msg-r1", + senderId: TEST_OTHER_USER_ID, + sequenceId: "seq-7", + content: { contentType: "text", text: "react to me" }, + }, + }); + + const engine = (adapter as any).cryptoEngine; + const reactSpy = vi.spyOn(engine, "encryptAddReaction"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + await adapter.addReaction(TEST_THREAD_ID, "msg-r1", "👍"); + + expect(reactSpy).toHaveBeenCalledOnce(); + const params = reactSpy.mock.calls[0][0] as Record; + expect(params.targetMessageSequenceId).toBe("seq-7"); + // The API receives the message id chat-xdk generated for the payload + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + const payload = reactSpy.mock.results[0].value as { messageId: string }; + const sent = xdk.chat.sendMessage.mock.calls[0][1]; + expect(sent.messageId).toBe(payload.messageId); + expect(sent.encodedMessageCreateEvent).toBe(payload.encryptedContent); + } finally { + restore(); + } + }); + + it("skips reactions without a cached sequence id", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + xdk.chat.sendMessage = vi.fn(); + await adapter.addReaction(TEST_THREAD_ID, "unknown-msg", "👍"); + expect(xdk.chat.sendMessage).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); +}); + +describe("inbound reaction routing", () => { + const reactionRaw = (targetSequenceId: string): XChatRawMessage => ({ + event: { + id: "evt-react", + conversationId: TEST_CONVERSATION_ID, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "y", + }, + decrypted: { + type: "message", + id: "react-1", + senderId: TEST_OTHER_USER_ID, + content: { + contentType: "reaction", + emoji: "👍", + targetMessageId: targetSequenceId, + }, + }, + }); + + it("resolves the reaction's target sequence id back to the message id", async () => { + const { adapter, mockChat, restore } = await createInitializedTestAdapter(); + try { + // Seed the messageId ⇄ sequenceId mapping via a parsed message. + adapter.parseMessage({ + event: { + id: "evt-r2", + conversationId: TEST_CONVERSATION_ID, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + }, + decrypted: { + type: "message", + id: "msg-r2", + senderId: TEST_OTHER_USER_ID, + sequenceId: "seq-9", + content: { contentType: "text", text: "react to me" }, + }, + }); + + const parsed = adapter.parseMessage(reactionRaw("seq-9")); + (adapter as any).routeReaction(TEST_THREAD_ID, parsed, true, undefined); + + expect(mockChat.processReaction).toHaveBeenCalledOnce(); + const [event] = (mockChat.processReaction as ReturnType) + .mock.calls[0]; + expect(event.messageId).toBe("msg-r2"); + expect(event.added).toBe(true); + expect(event.rawEmoji).toBe("👍"); + } finally { + restore(); + } + }); + + it("falls back to the raw sequence id when the target is unknown", async () => { + const { adapter, mockChat, restore } = await createInitializedTestAdapter(); + try { + const parsed = adapter.parseMessage(reactionRaw("seq-unseen")); + (adapter as any).routeReaction(TEST_THREAD_ID, parsed, false, undefined); + + expect(mockChat.processReaction).toHaveBeenCalledOnce(); + const [event] = (mockChat.processReaction as ReturnType) + .mock.calls[0]; + expect(event.messageId).toBe("seq-unseen"); + expect(event.added).toBe(false); + } finally { + restore(); + } + }); +}); + +describe("media upload/download via the XDK client (real crypto)", () => { + it("encrypt-streams and uploads outgoing files through the 3-step flow", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const convKey = b64ToBytes(vectors.conversation_key_b64); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": convKey }, + latestVersion: "1", + }); + + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + xdk.chat.mediaUploadInitialize.mockResolvedValue({ + data: { sessionId: "sess-1", mediaHashKey: "hash-up-1" }, + }); + xdk.chat.mediaUploadAppend.mockResolvedValue({ data: {} }); + xdk.chat.mediaUploadFinalize.mockResolvedValue({ data: {} }); + + const engine = (adapter as any).cryptoEngine; + const messageSpy = vi.spyOn(engine, "encryptMessage"); + const fileBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); + + await adapter.postMessage(TEST_THREAD_ID, { + markdown: "here you go", + files: [ + { + filename: "pic.png", + data: fileBytes.buffer, + mimeType: "image/png", + }, + ], + }); + + // Initialize with the encrypted (not plaintext) size + expect(xdk.chat.mediaUploadInitialize).toHaveBeenCalledOnce(); + const initBody = xdk.chat.mediaUploadInitialize.mock.calls[0][0]; + expect(initBody.conversationId).toBe(TEST_CONVERSATION_ID); + expect(initBody.totalBytes).toBeGreaterThan(fileBytes.length); + + // One appended segment whose payload decrypts back to the file bytes + expect(xdk.chat.mediaUploadAppend).toHaveBeenCalledOnce(); + const [appendSession, appendBody] = + xdk.chat.mediaUploadAppend.mock.calls[0]; + expect(appendSession).toBe("sess-1"); + expect(appendBody.mediaHashKey).toBe("hash-up-1"); + expect(appendBody.segmentIndex).toBe(0); + const roundTrip = engine.decryptStream( + b64ToBytes(appendBody.media), + convKey + ); + expect(new Uint8Array(roundTrip)).toEqual(fileBytes); + + expect(xdk.chat.mediaUploadFinalize).toHaveBeenCalledWith("sess-1", { + conversationId: TEST_CONVERSATION_ID, + mediaHashKey: "hash-up-1", + numParts: "1", + }); + + // The encrypted message references the uploaded media + const params = messageSpy.mock.calls[0][0] as { + attachments: Record[]; + }; + expect(params.attachments[0].media_hash_key).toBe("hash-up-1"); + expect(params.attachments[0].filename).toBe("pic.png"); + } finally { + restore(); + } + }); + + it("downloads and decrypt-streams media attachments", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const convKey = b64ToBytes(vectors.conversation_key_b64); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": convKey }, + latestVersion: "1", + }); + + const engine = (adapter as any).cryptoEngine; + const plaintext = new Uint8Array([9, 8, 7, 6, 5]); + const encrypted = engine.encryptStream(plaintext, convKey); + xdk.chat.mediaDownload.mockResolvedValue( + encrypted.buffer.slice( + encrypted.byteOffset, + encrypted.byteOffset + encrypted.byteLength + ) + ); + + const result = await adapter.fetchMediaAttachment( + TEST_CONVERSATION_ID, + "hash-down-1", + "1" + ); + + // Media routes take the dash-joined participant pair, not the peer id + expect(xdk.chat.mediaDownload).toHaveBeenCalledWith( + TEST_CONVERSATION_ID, + "hash-down-1" + ); + expect(new Uint8Array(result)).toEqual(plaintext); + } finally { + restore(); + } + }); +}); + +describe("markAsRead fallback", () => { + it("falls back to the latest event sequence id when the message has none", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + xdk.chat.getConversationEvents = vi.fn().mockResolvedValue({ + data: [{ id: "evt-l", sequenceId: "seq-99" }], + }); + xdk.chat.markConversationRead = vi.fn().mockResolvedValue({ data: {} }); + + const message = adapter.parseMessage({ + event: { + id: "evt-nr", + conversationId: TEST_CONVERSATION_ID, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + }, + decrypted: null, + }); + await adapter.markAsRead(TEST_THREAD_ID, message); + + expect(xdk.chat.markConversationRead).toHaveBeenCalledWith( + TEST_OTHER_USER_ID, + { seenUntilSequenceId: "seq-99" } + ); + } finally { + restore(); + } + }); +}); + +describe("conversation_join welcome", () => { + it("posts the welcome message when added to a group", async () => { + const { adapter, restore } = await createInitializedTestAdapter(); + try { + const postSpy = vi + .spyOn(adapter, "postMessage") + .mockResolvedValue({ id: "w1", raw: {} as any, threadId: "t" }); + + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify({ + data: { + event_type: "chat.conversation_join", + payload: { + id: "join-1", + conversation_id: "gNEWGROUP", + sender_id: TEST_USER_ID, + encoded_event: "x", + }, + }, + }), + headers: { "Content-Type": "application/json" }, + }); + const response = await adapter.handleWebhook(request); + expect(response.status).toBe(200); + + await vi.waitFor(() => { + expect(postSpy).toHaveBeenCalledOnce(); + }); + const [threadId, welcome] = postSpy.mock.calls[0]; + expect(threadId).toBe("xchat:gNEWGROUP"); + expect(String(welcome)).toContain("@test-bot"); + } finally { + restore(); + } + }); + + it("does not post a welcome for 1:1 joins", async () => { + const { adapter, restore } = await createInitializedTestAdapter(); + try { + const postSpy = vi + .spyOn(adapter, "postMessage") + .mockResolvedValue({ id: "w1", raw: {} as any, threadId: "t" }); + + const request = new Request("https://example.com/webhook", { + method: "POST", + body: JSON.stringify({ + data: { + event_type: "chat.conversation_join", + payload: { + id: "join-2", + conversation_id: TEST_CONVERSATION_ID, + sender_id: TEST_USER_ID, + encoded_event: "x", + }, + }, + }), + headers: { "Content-Type": "application/json" }, + }); + await adapter.handleWebhook(request); + await new Promise((resolve) => setImmediate(resolve)); + expect(postSpy).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); +}); + +describe("postMessage with a card (real crypto)", () => { + it("degrades the card to text + link entities + a url preview attachment", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + const engine = (adapter as any).cryptoEngine; + const messageSpy = vi.spyOn(engine, "encryptMessage"); + + await adapter.postMessage(TEST_THREAD_ID, { + card: { + type: "card", + title: "Deploy ready", + children: [ + { type: "text", content: "All checks passed." }, + { + type: "actions", + children: [ + { + type: "link-button", + label: "View logs", + url: "https://ci.example.com/logs", + }, + ], + }, + ], + }, + } as any); + + const params = messageSpy.mock.calls[0][0] as { + text: string; + entities: [number, number, string][] | null; + attachments: Record[] | null; + }; + expect(params.text).toBe( + "Deploy ready\nAll checks passed.\nView logs: https://ci.example.com/logs" + ); + // The appended link line becomes a tappable url entity + expect(params.entities?.some(([, , kind]) => kind === "url")).toBe(true); + // The primary link rides along as a URL preview card + expect(params.attachments).toEqual([ + { + attachment_type: "url", + url: "https://ci.example.com/logs", + display_title: "Deploy ready", + }, + ]); + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + } finally { + restore(); + } + }); +}); + +describe("urlCardAttachment banner upload (real crypto)", () => { + it("fetches, encrypts, and uploads the banner image", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + const originalFetch = globalThis.fetch; + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keyInfo = { + key: b64ToBytes(vectors.conversation_key_b64), + version: "1", + }; + xdk.chat.mediaUploadInitialize.mockResolvedValue({ + data: { sessionId: "sess-b", mediaHashKey: "hash-banner" }, + }); + xdk.chat.mediaUploadAppend.mockResolvedValue({ data: {} }); + xdk.chat.mediaUploadFinalize.mockResolvedValue({ data: {} }); + + const bannerBytes = new Uint8Array([1, 2, 3, 4, 5]); + globalThis.fetch = vi + .fn() + .mockResolvedValue(new Response(bannerBytes, { status: 200 })); + + const attachment = await (adapter as any).urlCardAttachment( + TEST_CONVERSATION_ID, + keyInfo, + { + url: "https://example.com/notes", + displayTitle: "Release notes", + imageUrl: "https://cdn.example.com/banner.png?v=2", + } + ); + + expect(globalThis.fetch).toHaveBeenCalledWith( + "https://cdn.example.com/banner.png?v=2" + ); + expect(xdk.chat.mediaUploadFinalize).toHaveBeenCalledOnce(); + expect(attachment.attachment_type).toBe("url"); + expect(attachment.url).toBe("https://example.com/notes"); + expect(attachment.display_title).toBe("Release notes"); + expect(attachment.banner_image.media_hash_key).toBe("hash-banner"); + // Wire size is the encrypted blob, and the query string is stripped + expect(attachment.banner_image.filesize_bytes).toBeGreaterThan( + bannerBytes.length + ); + expect(attachment.banner_image.filename).toBe("banner.png"); + } finally { + globalThis.fetch = originalFetch; + restore(); + } + }); + + it("degrades to a card without a banner when the image fetch fails", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + const originalFetch = globalThis.fetch; + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + globalThis.fetch = vi.fn().mockRejectedValue(new Error("boom")); + + const attachment = await (adapter as any).urlCardAttachment( + TEST_CONVERSATION_ID, + { key: b64ToBytes(vectors.conversation_key_b64), version: "1" }, + { + url: "https://example.com/notes", + imageUrl: "https://cdn.example.com/x.png", + } + ); + + expect(attachment).toEqual({ + attachment_type: "url", + url: "https://example.com/notes", + }); + expect(xdk.chat.mediaUploadInitialize).not.toHaveBeenCalled(); + } finally { + globalThis.fetch = originalFetch; + restore(); + } + }); +}); + +describe("parseMessage edit events", () => { + it("renders an edit event as the edited message and maps its target sequence id", () => { + const adapter = createTestAdapter(); + const message = adapter.parseMessage({ + event: { + id: "edit-evt-1", + conversationId: TEST_CONVERSATION_ID, + senderId: TEST_OTHER_USER_ID, + encodedEvent: "x", + sequenceId: "seq-edit-event", + createdAtMsec: "1700000000000", + }, + decrypted: { + type: "message", + id: "edit-evt-1", + senderId: TEST_OTHER_USER_ID, + conversationId: TEST_CANONICAL_CONVERSATION_ID, + createdAtMsec: 1700000000000, + sequenceId: "seq-edit-event", + content: { + contentType: "edit", + targetMessageId: "seq-original", + newText: "the corrected words", + }, + verified: true, + } as any, + }); + + expect(message.text).toBe("the corrected words"); + // Later reactions/edits/deletes through this message must hit the + // original, not the edit event. + expect((adapter as any).sequenceIdByMessageId.get("edit-evt-1")).toBe( + "seq-original" + ); + }); +}); + +describe("editMessage (real crypto)", () => { + it("encrypts an edit targeting the cached sequence id and sends it", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + (adapter as any).sequenceIdByMessageId.set("orig-1", "seq-orig"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + + const engine = (adapter as any).cryptoEngine; + const editSpy = vi.spyOn(engine, "encryptEdit"); + + const result = await adapter.editMessage( + TEST_THREAD_ID, + "orig-1", + "fixed: see https://example.com" + ); + + const params = editSpy.mock.calls[0][0] as Record; + expect(params.targetMessageSequenceId).toBe("seq-orig"); + expect(params.updatedText).toBe("fixed: see https://example.com"); + // The URL in the replacement text stays tappable. + expect( + (params.entities as [number, number, string][]).some( + ([, , kind]) => kind === "url" + ) + ).toBe(true); + + // The edit ships through the regular send channel with its own id. + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + const [, payload] = (xdk.chat.sendMessage as any).mock.calls[0]; + expect(payload.encodedMessageCreateEvent).toBeTruthy(); + expect(payload.messageId).not.toBe("orig-1"); + // The returned message keeps the edited message's id. + expect(result.id).toBe("orig-1"); + } finally { + restore(); + } + }); + + it("holds the first edit until the original message settles", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + const tokensMap = (adapter as any).conversationTokens as Map< + string, + string + >; + tokensMap.set(TEST_CONVERSATION_ID, "conv-token-123"); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + (adapter as any).editSafetyDelayMs = 120; + + const posted = await adapter.postMessage(TEST_THREAD_ID, "v1"); + (adapter as any).sequenceIdByMessageId.set(posted.id, "seq-v1"); + + const started = Date.now(); + await adapter.editMessage(TEST_THREAD_ID, posted.id, "v2"); + expect(Date.now() - started).toBeGreaterThanOrEqual(100); + + // A message not posted in this process (no recorded post time) is not + // delayed. + (adapter as any).sequenceIdByMessageId.set("old-msg", "seq-old"); + const startedOld = Date.now(); + await adapter.editMessage(TEST_THREAD_ID, "old-msg", "v2"); + expect(Date.now() - startedOld).toBeLessThan(100); + } finally { + restore(); + } + }); + + it("recovers the sequence id from history when it is not cached", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(TEST_CONVERSATION_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + xdk.chat.sendMessage = vi.fn().mockResolvedValue({ data: {} }); + // History replay repopulates the sequence-id cache via parseMessage. + vi.spyOn(adapter, "fetchMessages").mockImplementation(async () => { + (adapter as any).sequenceIdByMessageId.set("orig-2", "seq-2"); + return { messages: [] }; + }); + + await adapter.editMessage(TEST_THREAD_ID, "orig-2", "updated"); + + expect(adapter.fetchMessages).toHaveBeenCalledWith(TEST_THREAD_ID, { + limit: 50, + }); + expect(xdk.chat.sendMessage).toHaveBeenCalledOnce(); + } finally { + restore(); + } + }); + + it("throws when the sequence id cannot be resolved", async () => { + const { adapter, restore } = await createInitializedTestAdapter(); + try { + vi.spyOn(adapter, "fetchMessages").mockResolvedValue({ messages: [] }); + await expect( + adapter.editMessage(TEST_THREAD_ID, "unknown-msg", "text") + ).rejects.toThrow(NO_SEQUENCE_ID_RE); + } finally { + restore(); + } + }); +}); + +describe("deleteMessage (real crypto)", () => { + it("sends a signed delete-for-all through the typed client", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + (adapter as any).sequenceIdByMessageId.set("msg-del", "seq-del"); + xdk.chat.deleteMessages.mockResolvedValue({ data: {} }); + + await adapter.deleteMessage(TEST_THREAD_ID, "msg-del"); + + expect(xdk.chat.deleteMessages).toHaveBeenCalledOnce(); + const [convId, body] = xdk.chat.deleteMessages.mock.calls[0]; + // Delete routes take the dash-joined pair id in the URL. + expect(convId).toBe(TEST_CONVERSATION_ID); + expect(body.sequenceIds).toEqual(["seq-del"]); + expect(body.deleteMessageAction).toBe("delete_for_all"); + const sig = body.actionSignatures[0]; + expect(sig.messageId).toBeTruthy(); + expect(sig.encodedMessageEventDetail).toBeTruthy(); + // The signed payload covers the canonical colon-form conversation id. + expect(sig.signaturePayload).toBe( + `MessageDeleteEvent,${sig.messageId},${TEST_USER_ID},${TEST_CANONICAL_CONVERSATION_ID},2,seq-del` + ); + expect(sig.messageEventSignature.signature).toBeTruthy(); + expect(sig.messageEventSignature.signatureVersion).toBe("7"); + expect(sig.messageEventSignature.publicKeyVersion).toBe("1"); + expect(sig.messageEventSignature.signingPublicKey).toBeTruthy(); + } finally { + restore(); + } + }); + + it("propagates client errors from the delete call", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + (adapter as any).sequenceIdByMessageId.set("msg-404", "seq-404"); + xdk.chat.deleteMessages.mockRejectedValue(new Error("HTTP 404")); + + await expect( + adapter.deleteMessage(TEST_THREAD_ID, "msg-404") + ).rejects.toThrow(HTTP_404_RE); + } finally { + restore(); + } + }); +}); + +describe("openDM (real crypto)", () => { + const CANONICAL_ID = TEST_CANONICAL_CONVERSATION_ID; // "12345:67890" + const EXPECTED_THREAD_ID = `xchat:${CANONICAL_ID}`; + + function makeSigningKeyData() { + const vectors = loadVectors(); + return { + publicKeyVersion: "1", + publicKey: vectors.identity_public_b64, + signingPublicKey: vectors.signing_public_b64, + identityPublicKeySignature: vectors.identity_public_key_signature_b64, + }; + } + + it("returns the existing thread when a conversation key is already cached", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + keysMap.set(CANONICAL_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + + const threadId = await adapter.openDM(TEST_OTHER_USER_ID); + + expect(threadId).toBe(EXPECTED_THREAD_ID); + expect(xdk.chat.getConversationEvents).not.toHaveBeenCalled(); + expect(xdk.chat.addConversationKeys).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); + + it("reuses a key recovered from conversation history without a key exchange", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + const vectors = loadVectors(); + const keysMap = (adapter as any).conversationKeys as Map; + vi.spyOn(adapter, "fetchMessages").mockImplementation(async () => { + // History replay extracts the conversation key into the cache. + keysMap.set(CANONICAL_ID, { + keys: { "1": b64ToBytes(vectors.conversation_key_b64) }, + latestVersion: "1", + }); + return { messages: [] }; + }); + + const threadId = await adapter.openDM(TEST_OTHER_USER_ID); + + expect(threadId).toBe(EXPECTED_THREAD_ID); + expect(adapter.fetchMessages).toHaveBeenCalledWith(EXPECTED_THREAD_ID, { + limit: 50, + }); + expect(xdk.chat.addConversationKeys).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); + + it("performs a key exchange for a brand-new conversation", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + xdk.chat.getConversationEvents = vi + .fn() + .mockResolvedValue({ data: [], meta: {} }); + xdk.users.getPublicKey = vi + .fn() + .mockResolvedValue({ data: [makeSigningKeyData()] }); + xdk.chat.addConversationKeys.mockResolvedValue({ data: {} }); + + const threadId = await adapter.openDM(TEST_OTHER_USER_ID); + + expect(threadId).toBe(EXPECTED_THREAD_ID); + expect(xdk.chat.addConversationKeys).toHaveBeenCalledOnce(); + const [pathId, body] = xdk.chat.addConversationKeys.mock.calls[0]; + // Key-initialization path params take the dash-joined pair id + expect(pathId).toBe(TEST_CONVERSATION_ID); + expect(body.conversationKeyVersion).toBeTruthy(); + expect(body.conversationParticipantKeys).toHaveLength(2); + const participantIds = body.conversationParticipantKeys.map( + (k: { userId: string }) => k.userId + ); + expect(participantIds).toContain(TEST_USER_ID); + expect(participantIds).toContain(TEST_OTHER_USER_ID); + for (const key of body.conversationParticipantKeys) { + expect(key.encryptedConversationKey).toBeTruthy(); + expect(key.publicKeyVersion).toBe("1"); + } + expect(body.actionSignatures.length).toBeGreaterThan(0); + for (const sig of body.actionSignatures) { + expect(sig.messageId).toBeTruthy(); + expect(sig.encodedMessageEventDetail).toBeTruthy(); + expect(sig.messageEventSignature.signature).toBeTruthy(); + expect(sig.messageEventSignature.signingPublicKey).toBeTruthy(); + } + + // The new key is cached, so the bot can post immediately. + const keysMap = (adapter as any).conversationKeys as Map; + const cached = keysMap.get(CANONICAL_ID); + expect(cached?.latestVersion).toBe(body.conversationKeyVersion); + expect(cached?.keys[body.conversationKeyVersion]).toBeInstanceOf( + Uint8Array + ); + } finally { + restore(); + } + }); + + it("throws when the recipient has no registered chat keys", async () => { + const { adapter, getXdkClient, restore } = + await createInitializedTestAdapter(); + try { + const xdk = getXdkClient(); + xdk.chat.getConversationEvents = vi + .fn() + .mockResolvedValue({ data: [], meta: {} }); + xdk.users.getPublicKey = vi + .fn() + .mockImplementation(async (userId: string) => + userId === TEST_USER_ID + ? { data: [makeSigningKeyData()] } + : { data: [] } + ); + + await expect(adapter.openDM(TEST_OTHER_USER_ID)).rejects.toThrow( + NO_REGISTERED_CHAT_KEYS_RE + ); + expect(xdk.chat.addConversationKeys).not.toHaveBeenCalled(); + } finally { + restore(); + } + }); +}); diff --git a/packages/adapter-xchat/src/index.ts b/packages/adapter-xchat/src/index.ts new file mode 100644 index 000000000..40b3bcfb5 --- /dev/null +++ b/packages/adapter-xchat/src/index.ts @@ -0,0 +1,2836 @@ +/** + * XChat adapter for chat SDK. + * + * Provides encrypted messaging via the X API (/2/chat/*) and chat-xdk WASM. + * All conversations are encrypted — the adapter handles key extraction, decryption, + * encryption, and signing transparently. + * + * @example + * ```typescript + * import { Chat } from "chat"; + * import { createXChatAdapter } from "@chat-adapter/xchat"; + * import { MemoryState } from "@chat-adapter/state-memory"; + * + * const chat = new Chat({ + * userName: "my-bot", + * adapters: { + * xchat: createXChatAdapter(), + * }, + * state: new MemoryState(), + * }); + * ``` + */ + +import { createHmac, timingSafeEqual } from "node:crypto"; +import { ValidationError } from "@chat-adapter/shared"; +import { + type AttachmentDescriptor, + type ChatWithJuicebox, + type ConversationKeyResult, + createChat, + detectImageDimensions, + detectMimeType, + type EncryptMessageParams, + type EntityTuple, + type PublicKeyInput, + type SendPayload, + type SigningKeyEntry, + type UrlAttachmentImageDescriptor, +} from "@xdevplatform/chat-xdk"; +import { Client } from "@xdevplatform/xdk"; +import type { + Adapter, + AdapterPostableMessage, + Attachment, + Author, + CardElement, + ChatInstance, + EmojiValue, + FetchOptions, + FetchResult, + FileUpload, + FormattedContent, + Logger, + RawMessage, + ReactionEvent, + ThreadInfo, + WebhookOptions, +} from "chat"; +import { + ConsoleLogger, + defaultEmojiResolver, + getEmoji, + isCardElement, + Message, + parseMarkdown, +} from "chat"; +import { cardToXChat, type XChatUrlCardSpec } from "./cards"; +import { XChatFormatConverter } from "./markdown"; +import type { + XChatAdapterConfig, + XChatAttachmentEntry, + XChatCryptoStatus, + XChatDecryptedEvent, + XChatEvent, + XChatRawMessage, + XChatThreadId, +} from "./types"; + +/** Default base URL for X API requests */ +const DEFAULT_API_BASE_URL = "https://api.x.com"; + +/** Re-send the typing indicator this often while a handler is running */ +const TYPING_INTERVAL_MS = 3000; +/** Stop the typing keep-alive loop after this long regardless */ +const TYPING_MAX_MS = 120_000; + +/** Media upload append chunk size (pre-base64) */ +const UPLOAD_CHUNK_BYTES = 3 * 1024 * 1024; + +/** Cap on the messageId → sequenceId cache used for reactions/read receipts */ +const SEQUENCE_CACHE_MAX = 1000; +/** + * Minimum age a freshly posted message must reach before its first edit is + * sent. Receiving clients apply an edit to their stored copy of the original + * and park it when the original has not arrived yet; because the backend + * stops serving a superseded original, an edit that outruns delivery leaves + * the message permanently invisible to that client. + */ +const DEFAULT_EDIT_SAFETY_DELAY_MS = 5000; + +/** + * Fields requested for message events from GET + * /2/chat/conversations/{id}/events. This list must stay within the API's + * chat_message_event.fields enum — unknown values fail the whole request. + * The sequence id is not requestable here; it comes from the decrypted + * event's meta instead. + */ +const MESSAGE_EVENT_FIELDS = [ + "conversation_id", + "conversation_token", + "created_at", + "encoded_event", + "id", + "is_trusted", + "message_event_signature", + "previous_id", + "sender_id", +] as const; + +/** + * Field-list type for getConversationEvents. The API accepts `created_at`, + * which @xdevplatform/xdk's generated field union does not yet include, so + * call sites cast through this alias instead of the SDK's union. + */ +type MessageEventFields = NonNullable< + Parameters["chat"]["getConversationEvents"]>[1] +>["chatMessageEventFields"]; + +/** + * Public-key fields requested when fetching participants' signing keys. + * + * All four are needed to build a chat-xdk SigningKeyEntry that supports + * full signature + key-binding verification: + * - public_key_version → publicKeyVersion + * - signing_public_key → publicKey (the signing key itself) + * - public_key → identityPublicKey + * - identity_public_key_signature → identityPublicKeySignature + */ +const SIGNING_KEY_FIELDS = [ + "public_key_version", + "public_key", + "signing_public_key", + "identity_public_key_signature", +] as const; + +/** Splits a 1:1 conversation ID into its participant IDs. */ +const CONVERSATION_ID_SEPARATOR = /[-:]/; +/** Matches a numeric X user ID. */ +const NUMERIC_USER_ID = /^\d+$/; + +/** Prefer `publicKeyVersion`; older API responses carry the same value as `version`. */ +function publicKeyVersionOf(key: { + publicKeyVersion?: string; + version?: string; +}): string | undefined { + return key.publicKeyVersion ?? key.version; +} + +/** + * Public key entry from users.getPublicKey — only the fields the adapter + * reads. `version` is the older-response alias for `publicKeyVersion`. + */ +interface PublicKeyData { + identityPublicKeySignature?: string; + juiceboxConfig?: { + keyStoreTokenMapJson?: string; + tokenMap?: Array<{ + key: string; + value: { address: string; token: string }; + }>; + }; + /** Identity public key (base64) */ + publicKey?: string; + publicKeyVersion?: string; + /** Signing public key (base64) */ + signingPublicKey?: string; + version?: string; +} + +/** Minimal X API response envelope (`data` shape varies per endpoint). */ +interface XApiResponse { + data?: T; +} + +/** + * Response envelope for GET /2/chat/conversations/{id}/events. Events carry + * the same fields as webhook events; `next_token` covers untransformed + * snake_case responses. + */ +interface ConversationEventsResponse { + data?: Partial[]; + meta?: { nextToken?: string; next_token?: string }; +} + +/** + * Path segment for chat REST routes (`/2/chat/conversations/{id}/…`). + * + * 1:1 conversations accept the other participant's user id (no `:`/`-` + * composite). Groups use the opaque `g…` conversation id as-is. + */ +export function conversationPathId( + conversationId: string, + selfUserId: string +): string { + if (conversationId.startsWith("g")) { + return conversationId; + } + const other = conversationId + .split(CONVERSATION_ID_SEPARATOR) + .filter((part) => NUMERIC_USER_ID.test(part)) + .find((id) => id !== selfUserId); + return other ?? conversationId; +} + +/** + * Conversation id for routes that take it as a path parameter (media + * download, key initialization), which accept only the dash-joined + * participant pair or the g-prefixed group id. + */ +export function dashConversationId(conversationId: string): string { + if (conversationId.startsWith("g")) { + return conversationId; + } + return conversationId.replace(":", "-"); +} + +// ── Outgoing entity + attachment detection ──────────────────────────── + +/** + * URL matcher for outgoing entities: full http(s) URLs plus common bare + * domains. False positives are low-cost (link underline); false negatives + * mean no tappable link. + */ +const URL_ENTITY_RE = + /https?:\/\/[^\s\])>"']+|(?"']*)?/gi; + +/** @handle matcher (1-15 word chars); lookbehind excludes email-like text. */ +const MENTION_ENTITY_RE = + /(?/status/ or twitter.com//status/ */ +const POST_URL_RE = + /https?:\/\/(?:www\.)?(?:x|twitter)\.com\/[A-Za-z0-9_]+\/status\/(\d+)/gi; + +/** Strips a leading @ from a handle. */ +const LEADING_AT_RE = /^@/; + +/** + * Detect URL and @mention entities in outgoing text. + * + * Returns `[start, end, type]` tuples for `encryptMessage`/`encryptReply`, + * or null when nothing was found. Mentions overlapping a detected URL span + * (e.g. an @ inside a URL path) are skipped. + */ +export function detectEntities(text: string): EntityTuple[] | null { + const entities: EntityTuple[] = []; + for (const m of text.matchAll(URL_ENTITY_RE)) { + entities.push([m.index, m.index + m[0].length, "url"]); + } + for (const m of text.matchAll(MENTION_ENTITY_RE)) { + const start = m.index; + if (entities.some((e) => e[0] <= start && start < e[1])) { + continue; + } + entities.push([start, start + m[0].length, "mention"]); + } + entities.sort((a, b) => a[0] - b[0]); + return entities.length > 0 ? entities : null; +} + +/** + * Extract X post URLs from text as post-card attachment descriptors, + * deduplicated by post id. Returns null when none found. + */ +export function extractPostAttachments( + text: string +): AttachmentDescriptor[] | null { + const seen = new Set(); + const attachments: AttachmentDescriptor[] = []; + for (const m of text.matchAll(POST_URL_RE)) { + const postId = m[1]; + if (seen.has(postId)) { + continue; + } + seen.add(postId); + attachments.push({ + attachment_type: "post", + rest_id: postId, + post_url: m[0], + }); + } + return attachments.length > 0 ? attachments : null; +} + +/** The card carried by a postable message, if any. */ +function cardOf(message: AdapterPostableMessage): CardElement | null { + if (typeof message !== "object" || message === null) { + return null; + } + if ("card" in message && isCardElement(message.card)) { + return message.card; + } + return isCardElement(message) ? message : null; +} + +// ── Inbound event helpers ───────────────────────────────────────────── + +/** Tolerant accessor: chat-xdk JS emits camelCase, wire payloads snake_case. */ +function fieldOf(obj: unknown, camel: string, snake: string): unknown { + if (!obj || typeof obj !== "object") { + return undefined; + } + const rec = obj as Record; + return rec[camel] ?? rec[snake]; +} + +/** + * Extract @-mentioned handles from a decrypted message's rich-text + * entities. Handles are lowercased, without the leading `@`, deduplicated. + */ +export function mentionHandlesFromEntities( + text: string, + entities: unknown[] | undefined +): string[] { + if (!entities || entities.length === 0 || !text) { + return []; + } + const seen = new Set(); + const handles: string[] = []; + for (const entity of entities) { + if (!entity || typeof entity !== "object") { + continue; + } + const content = (entity as Record).content; + if (!content || typeof content !== "object") { + continue; + } + if (!("mention" in (content as Record))) { + continue; + } + const startRaw = fieldOf(entity, "startIndex", "start_index"); + const endRaw = fieldOf(entity, "endIndex", "end_index"); + if (startRaw == null || endRaw == null) { + continue; + } + const start = Math.max(0, Number(startRaw)); + const end = Math.min(text.length, Number(endRaw)); + if (!(Number.isFinite(start) && Number.isFinite(end)) || start >= end) { + continue; + } + const handle = text + .slice(start, end) + .replace(LEADING_AT_RE, "") + .toLowerCase(); + if (handle && !seen.has(handle)) { + seen.add(handle); + handles.push(handle); + } + } + return handles; +} + +/** Reply-to preview (swipe reply) from decrypted content, if present. */ +function replyPreviewOf( + content: XChatDecryptedEvent["content"] +): { senderId?: string; text?: string } | null { + const preview = fieldOf(content, "replyingToPreview", "replying_to_preview"); + if (!preview || typeof preview !== "object") { + return null; + } + const senderId = fieldOf(preview, "senderId", "sender_id"); + const text = (preview as Record).text; + return { + senderId: senderId == null ? undefined : String(senderId), + text: typeof text === "string" ? text : undefined, + }; +} + +/** Lowercased content type, tolerant of both binding spellings. */ +function contentTypeOf(content: XChatDecryptedEvent["content"]): string { + const ct = fieldOf(content, "contentType", "content_type"); + return typeof ct === "string" ? ct.toLowerCase() : ""; +} + +/** + * Whether a decrypted event is a processable chat message, and its text. + * + * Processable messages are: plain text; media (with or without caption); + * anything carrying attachments/media hashes; and card-like content with + * URL entities. Reactions/edits/mark-read return null. + */ +function processableText(decrypted: XChatDecryptedEvent | null): string | null { + if (!decrypted || decrypted.type.toLowerCase() !== "message") { + return null; + } + const content = decrypted.content ?? {}; + const text = typeof content.text === "string" ? content.text : ""; + const ct = contentTypeOf(content); + if (ct === "text" || ct === "media" || ct === "mediawithtext") { + return text; + } + if (decrypted.attachments?.length || decrypted.mediaHashes?.length) { + return text; + } + if (content.attachments?.length) { + return text; + } + for (const entity of content.entities ?? []) { + const ec = fieldOf(entity, "content", "content"); + if (ec && typeof ec === "object" && "url" in (ec as object)) { + return text; + } + } + return ct ? null : text; +} + +/** Normalized media reference extracted from a decrypted message. */ +interface MediaEntry { + durationMillis?: number; + filename?: string; + filesize?: number; + hashKey: string; + height?: number; + mediaType: string; + width?: number; +} + +function mediaTypeFromSource(source: string | undefined): string { + const value = (source ?? "").toLowerCase(); + if (value.includes("gif")) { + return "gif"; + } + if (value.includes("video")) { + return "video"; + } + if (value.includes("image")) { + return "image"; + } + return "media"; +} + +/** Extract all media references (hash keys + metadata) from a decrypted event. */ +export function extractMediaEntries( + decrypted: XChatDecryptedEvent +): MediaEntry[] { + const entries: MediaEntry[] = []; + const seen = new Set(); + + const addFromAttachment = (entry: XChatAttachmentEntry): void => { + // Nested `{ media: {...} }` (wire shape) or flattened (JS binding shape) + const media = entry.media ?? entry; + const hashKey = + fieldOf(media, "mediaHashKey", "media_hash_key") ?? + (entry.attachmentType === "media" ? entry.mediaHashKey : undefined); + if (!hashKey || seen.has(String(hashKey))) { + return; + } + seen.add(String(hashKey)); + const dims = (media as XChatAttachmentEntry).dimensions; + const rawType = + fieldOf(media, "mediaType", "media_type") ?? + (media as Record).type; + entries.push({ + mediaType: String(rawType ?? "media").toLowerCase(), + hashKey: String(hashKey), + width: dims?.width, + height: dims?.height, + filename: (fieldOf(media, "filename", "filename") ?? undefined) as + | string + | undefined, + filesize: Number( + fieldOf(media, "filesizeBytes", "filesize_bytes") ?? Number.NaN + ), + durationMillis: Number( + fieldOf(media, "durationMillis", "duration_millis") ?? Number.NaN + ), + }); + }; + + for (const entry of decrypted.attachments ?? []) { + addFromAttachment(entry); + } + for (const entry of decrypted.content?.attachments ?? []) { + addFromAttachment(entry); + } + for (const ref of decrypted.mediaHashes ?? []) { + const hashKey = ref.mediaHashKey; + if (!hashKey || seen.has(hashKey)) { + continue; + } + seen.add(hashKey); + entries.push({ + mediaType: mediaTypeFromSource(ref.source), + hashKey, + }); + } + return entries; +} + +/** Map an XChat media type string onto the Chat SDK attachment type. */ +function chatAttachmentType(mediaType: string): Attachment["type"] { + if (mediaType === "video") { + return "video"; + } + if (mediaType === "audio") { + return "audio"; + } + if (mediaType === "image" || mediaType === "gif") { + return "image"; + } + return "file"; +} + +/** Numeric media_type for outgoing attachment descriptors, keyed by MIME. */ +function outgoingMediaType(mimeType: string): number | undefined { + if (mimeType === "image/gif") { + return 2; + } + if (mimeType.startsWith("video/")) { + return 3; + } + if (mimeType.startsWith("audio/")) { + return 4; + } + if (mimeType.startsWith("image/")) { + // Image is the server default. + return undefined; + } + return 5; +} + +/** Latest-message context per conversation, for group quote-replies + TTL. */ +interface InboundContext { + createdAtMsec?: number; + encodedEvent?: string; + senderId?: string; + sequenceId?: string; + text?: string; + ttlMsec?: number; +} + +/** Normalize the Chat SDK's binary payload shapes to Uint8Array. */ +async function toBytes( + data: Buffer | Blob | ArrayBuffer | Uint8Array +): Promise { + if (data instanceof Uint8Array) { + return data; + } + if (data instanceof ArrayBuffer) { + return new Uint8Array(data); + } + // Blob (Buffer is a Uint8Array subclass, handled above) + return new Uint8Array(await (data as Blob).arrayBuffer()); +} + +export type { XChatCardResult, XChatUrlCardSpec } from "./cards"; +export { cardToXChat } from "./cards"; +export { XChatFormatConverter } from "./markdown"; +export type { + XChatAdapterConfig, + XChatAttachmentEntry, + XChatCryptoStatus, + XChatDecryptedEvent, + XChatEvent, + XChatRawMessage, + XChatThreadId, +} from "./types"; + +/** + * XChat adapter for chat SDK. + * + * Handles encrypted messaging via the X API and chat-xdk WASM crypto. + * All conversations are 1:1 DMs or group chats, always encrypted. + */ +export class XChatAdapter implements Adapter { + readonly name = "xchat"; + readonly persistMessageHistory = true; + private _userName: string; + private readonly userNameFromConfig: boolean; + + private readonly accessToken: string; + private readonly apiHeaders: Record; + private readonly consumerSecret: string | undefined; + private readonly userId: string; + /** Populated during initialize() from the X API, or from config override */ + private signingKeyVersion: string | null; + /** Juicebox PIN; when set, initialize() auto-unlocks after createChat */ + private readonly pin: string | undefined; + /** When false, decryption proceeds even for unverifiable signatures */ + private readonly verifySignatures: boolean; + private chat: ChatInstance | null = null; + private readonly logger: Logger; + private readonly formatConverter = new XChatFormatConverter(); + private xdkClient: InstanceType | null = null; + private cryptoEngine: ChatWithJuicebox | null = null; + private _cryptoStatus: XChatCryptoStatus = "uninitialized"; + /** Saved getAuthToken callback for re-installing on unlock() */ + private _getAuthToken: ((realmId: string) => Promise) | null = null; + /** + * Cached conversation keys: conversationId → { version → raw bytes }. + * Grows by one small entry per conversation the bot participates in; + * evicting a key would only force a re-fetch through conversation history, + * so the cache is kept unbounded for the process lifetime. + */ + private readonly conversationKeys = new Map(); + /** Cached conversation tokens: conversationId → token (one per conversation) */ + private readonly conversationTokens = new Map(); + /** Cached signing keys: userId → SigningKeyEntry[] (one per key version, one entry per user ever seen) */ + private readonly signingKeyCache = new Map(); + /** Base URL for X API requests */ + private readonly apiBaseUrl: string; + /** Welcome message posted on group join; false disables */ + private readonly welcomeMessage: string | false | undefined; + /** Latest inbound message context per conversation (quote-replies, TTL) */ + private readonly lastInboundByConv = new Map(); + /** messageId → sequenceId, for reactions + per-message read receipts */ + private readonly sequenceIdByMessageId = new Map(); + /** sequenceId → messageId, for resolving inbound reaction targets */ + private readonly messageIdBySequenceId = new Map(); + /** messageId → post time, for age-gating the first edit of a fresh message */ + private readonly postedAtByMessageId = new Map(); + /** Minimum age of a message before its first edit is sent */ + private readonly editSafetyDelayMs: number; + /** Whether a read receipt is sent for each delivered inbound message */ + private readonly sendReadReceipts: boolean; + /** Active typing keep-alive timers per conversation */ + private readonly typingTimers = new Map< + string, + ReturnType + >(); + + /** Bot @handle used for mention detection (from config or GET /2/users/me) */ + get userName(): string { + return this._userName; + } + + /** Bot user ID (same as userId for XChat) */ + get botUserId(): string | undefined { + return this.userId; + } + + /** Current encryption readiness status */ + get cryptoStatus(): XChatCryptoStatus { + return this._cryptoStatus; + } + + constructor(config: XChatAdapterConfig) { + this.accessToken = config.accessToken; + this.apiHeaders = { ...config.apiHeaders }; + this.apiBaseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL; + this.consumerSecret = config.consumerSecret; + this.userId = config.userId; + this.signingKeyVersion = config.signingKeyVersion ?? null; + this.pin = config.pin; + this.verifySignatures = config.verifySignatures ?? true; + this.welcomeMessage = config.welcomeMessage; + this.editSafetyDelayMs = + config.editSafetyDelayMs ?? DEFAULT_EDIT_SAFETY_DELAY_MS; + this.sendReadReceipts = config.sendReadReceipts !== false; + this.userNameFromConfig = Boolean(config.userName); + this._userName = config.userName ?? "xchat-bot"; + this.logger = config.logger; + } + + // ── Adapter lifecycle ───────────────────────────────────────────── + + /** + * Initialize the adapter. + * + * 1. Create the XDK API client (and resolve the bot @handle when needed) + * 2. Fetch signingKeyVersion + Juicebox config from users.getPublicKey() + * 3. Build the realm token cache from the initial response + * 4. createChat() (Juicebox-backed crypto); when `pin` was provided → + * unlock(pin), otherwise status stays `"locked"` + */ + async initialize(chatInstance: ChatInstance): Promise { + this.chat = chatInstance; + this._cryptoStatus = "initializing"; + + if (!this.consumerSecret) { + this.logger.warn( + "XChat adapter: consumerSecret is not set — incoming webhook POSTs " + + "will not be signature-verified. Set X_CONSUMER_SECRET to enable " + + "webhook authentication." + ); + } + + try { + // 1. Initialize XDK API client + this.xdkClient = new Client({ + accessToken: this.accessToken, + baseUrl: this.apiBaseUrl, + headers: this.apiHeaders, + }); + + // Resolve @handle from /2/users/me unless the caller set userName explicitly + if (!this.userNameFromConfig) { + const me = await this.xdkClient.users.getMe(); + const username = me?.data?.username; + if (typeof username === "string" && username.length > 0) { + this._userName = username; + this.logger.info("Resolved bot username from /2/users/me", { + userName: this._userName, + userId: this.userId, + }); + } else { + this.logger.warn( + "GET /2/users/me did not return a username; keeping placeholder", + { userName: this._userName } + ); + } + } + + // 2. Fetch signing key version + Juicebox config from the X API + // (signingKeyVersion may already be set via config override) + // + // XDK response (camelCase — transformKeys converts snake_case from API): + // { + // data: [{ + // publicKeyVersion: "1733889755256", + // juiceboxConfig: { + // keyStoreTokenMapJson: "{ \"realms\": [...], ... }", + // maxGuessCount: 20, + // tokenMap: [{ key: "realmHex", value: { address: "...", token: "jwt" } }] + // } + // }] + // } + let juiceboxConfigJson: string | null = null; + let tokenMapEntries: Array<{ + key: string; + value: { address: string; token: string }; + }> = []; + + const response = await this.xdkClient.users.getPublicKey(this.userId, { + publicKeyFields: ["public_key_version", "juicebox_config"], + }); + const keys = (response as XApiResponse).data ?? []; + if (keys.length === 0) { + throw new Error( + "No public key data returned from users.getPublicKey()" + ); + } + // Pick the latest version (highest numeric version string) + const publicKey = keys.reduce((latest, current) => { + const latestVersion = publicKeyVersionOf(latest) ?? "0"; + const currentVersion = publicKeyVersionOf(current) ?? "0"; + return Number(currentVersion) > Number(latestVersion) + ? current + : latest; + }); + + if (!this.signingKeyVersion) { + this.signingKeyVersion = publicKeyVersionOf(publicKey) ?? null; + } + const jbConfig = publicKey.juiceboxConfig; + if (jbConfig) { + juiceboxConfigJson = jbConfig.keyStoreTokenMapJson ?? null; + tokenMapEntries = jbConfig.tokenMap ?? []; + } + + this.logger.debug("Fetched public key info", { + signingKeyVersion: this.signingKeyVersion, + hasJuiceboxConfig: !!juiceboxConfigJson, + realmCount: tokenMapEntries.length, + }); + + if (!juiceboxConfigJson) { + // Throw like every other initialization failure so a misconfigured + // bot fails fast instead of surfacing "locked" errors per call. + throw new Error( + "XChat adapter: no Juicebox config found on the user's public key. " + + "Register keys (setup/PIN) before initializing the adapter." + ); + } + + // 3. Build realm token cache from the initial response + const realmTokenCache = new Map(); + for (const entry of tokenMapEntries) { + realmTokenCache.set(entry.key, entry.value.token); + } + + // 4. createChat (Juicebox) — unlock with pin when provided + const xdk = this.xdkClient; + const userId = this.userId; + const logger = this.logger; + + const getAuthToken = async (realmId: string): Promise => { + const cached = realmTokenCache.get(realmId); + if (cached) { + return cached; + } + + logger.debug("Fetching fresh Juicebox realm token", { realmId }); + const freshResponse = await xdk.users.getPublicKey(userId, { + publicKeyFields: ["juicebox_config"], + }); + const freshKeys = + (freshResponse as XApiResponse).data ?? []; + const freshKey = freshKeys.reduce((latest, current) => { + const latestVersion = publicKeyVersionOf(latest) ?? "0"; + const currentVersion = publicKeyVersionOf(current) ?? "0"; + return Number(currentVersion) > Number(latestVersion) + ? current + : latest; + }); + const freshEntries: Array<{ key: string; value: { token: string } }> = + freshKey?.juiceboxConfig?.tokenMap ?? []; + + for (const entry of freshEntries) { + realmTokenCache.set(entry.key, entry.value.token); + } + + const token = realmTokenCache.get(realmId); + if (!token) { + throw new Error(`No Juicebox auth token found for realm ${realmId}`); + } + return token; + }; + + this._getAuthToken = getAuthToken; + + const crypto = await createChat({ + juiceboxConfig: juiceboxConfigJson, + getAuthToken, + }); + // chat-xdk defaults to reject-unverified; only override when opting out + if (!this.verifySignatures) { + crypto.setRejectUnverified(false); + } + this.cryptoEngine = crypto; + this._cryptoStatus = "locked"; + this.logger.info("XChat adapter initialized (Juicebox, locked)", { + userId: this.userId, + userName: this._userName, + realmCount: realmTokenCache.size, + }); + + if (this.pin) { + await this.unlock(this.pin); + } + } catch (err) { + this._cryptoStatus = "error"; + this.logger.error("XChat adapter initialization failed", { error: err }); + throw err; + } + } + + /** + * Unlock encryption keys with a Juicebox PIN. + * + * Only available when `cryptoStatus === "locked"`. + * After successful unlock, `cryptoStatus` becomes `"ready"`. + */ + async unlock(pin: string): Promise { + if (this._cryptoStatus !== "locked") { + throw new Error( + `Cannot unlock: adapter is "${this._cryptoStatus}" (expected "locked"). ` + + (this._cryptoStatus === "ready" + ? "Already unlocked." + : "Call initialize() first.") + ); + } + + // chat-xdk's createChat() sets globalThis.JuiceboxGetAuthToken only during + // construction, then restores the previous value. But the Juicebox SDK + // needs the global set when recover() is called during unlock(). + // Install this adapter's getAuthToken callback for the duration of the + // unlock call, then restore the previous value so multiple adapters in + // one process don't clobber each other's callback. + interface JuiceboxGlobal { + JuiceboxGetAuthToken?: (realmId: Uint8Array | string) => Promise; + } + const jbGlobal = globalThis as JuiceboxGlobal; + const previousGetAuthToken = jbGlobal.JuiceboxGetAuthToken; + const getAuthToken = this._getAuthToken; + if (getAuthToken) { + jbGlobal.JuiceboxGetAuthToken = async (realmId: Uint8Array | string) => { + const realmIdHex = + typeof realmId === "string" + ? realmId + : Array.from(realmId) + .map((b) => b.toString(16).padStart(2, "0")) + .join(""); + return await getAuthToken(realmIdHex); + }; + } + + const jbChat = this.cryptoEngine as ChatWithJuicebox; + try { + await jbChat.unlock(pin); + } finally { + jbGlobal.JuiceboxGetAuthToken = previousGetAuthToken; + } + // Establish the session identity (sender id + registered signing key + // version) so chat-xdk signs with the right key version and handles + // KeyChange events for other versions correctly. + if (this.signingKeyVersion) { + try { + jbChat.setIdentity(this.userId, this.signingKeyVersion); + } catch (err) { + this.logger.warn("setIdentity failed", { error: err }); + } + } + this._cryptoStatus = "ready"; + this.logger.info("XChat adapter unlocked via PIN"); + } + + // ── Thread ID encoding ──────────────────────────────────────────── + + encodeThreadId(data: XChatThreadId): string { + return `xchat:${data.conversationId}`; + } + + decodeThreadId(threadId: string): XChatThreadId { + if (!threadId.startsWith("xchat:")) { + throw new Error(`Invalid XChat thread ID: ${threadId}`); + } + const conversationId = threadId.slice("xchat:".length); + if (!conversationId) { + throw new Error(`Invalid XChat thread ID format: ${threadId}`); + } + return { conversationId }; + } + + channelIdFromThreadId(threadId: string): string { + // XChat doesn't have channels — the conversation IS the channel + return threadId; + } + + // ── Webhook handling ────────────────────────────────────────────── + + async handleWebhook( + request: Request, + options?: WebhookOptions + ): Promise { + if (request.method !== "POST") { + // CRC challenges (GET) should be handled at the route level, + // not here — they don't need adapter initialization or crypto. + return new Response("Method not allowed", { status: 405 }); + } + + // Read the raw body for signature verification + const rawBody = await request.text(); + + // Verify webhook signature if consumer secret is configured + if (this.consumerSecret) { + const signature = request.headers.get("x-twitter-webhooks-signature"); + if (!signature) { + this.logger.warn("webhook_missing_signature"); + return new Response("Missing signature", { status: 401 }); + } + if (!this.verifySignature(rawBody, signature)) { + this.logger.warn("webhook_invalid_signature"); + return new Response("Invalid signature", { status: 401 }); + } + } + + // Parse the XAA webhook envelope and extract the event payload. + // + // XAA wraps the event in: + // { data: { event_type, event_uuid, filter, tag, payload: { ...event } } } + // Wire format is snake_case (raw HTTP body — not via XDK transformKeys). + let event: XChatEvent; + let eventType: string; + try { + const body = JSON.parse(rawBody); + const xaaData = body.data ?? body; + const payload = xaaData.payload ?? xaaData; + eventType = xaaData.event_type ?? "chat.received"; + const conversationId = String(payload.conversation_id ?? ""); + const encodedEvent = String(payload.encoded_event ?? ""); + if (!(conversationId && encodedEvent)) { + return new Response("OK", { status: 200 }); + } + event = { + id: String(payload.id ?? ""), + conversationId, + senderId: String(payload.sender_id ?? ""), + encodedEvent, + conversationKeyVersion: payload.conversation_key_version, + conversationKeyChangeEvent: payload.conversation_key_change_event, + conversationToken: payload.conversation_token, + encryptedConversationKey: payload.encrypted_conversation_key, + createdAtMsec: payload.created_at_msec, + messageEventSignature: payload.message_event_signature, + sequenceId: payload.sequence_id + ? String(payload.sequence_id) + : undefined, + }; + } catch { + return new Response("Invalid JSON", { status: 400 }); + } + + // Handle conversation join (bot added to group) before the echo skip — + // the join event's sender may be the bot itself. + if (eventType === "chat.conversation_join") { + this.handleConversationJoin(event, options); + return new Response("OK", { status: 200 }); + } + + // Skip echo events (messages sent by the bot itself) + if (eventType === "chat.sent" || event.senderId === this.userId) { + return new Response("OK", { status: 200 }); + } + + // chat.received — decrypt, then route to the message or reaction pipeline + const threadId = this.encodeThreadId({ + conversationId: event.conversationId, + }); + + const task = (async () => { + const parsed = await this.decryptAndParseEvent(event); + const decrypted = parsed.raw?.decrypted ?? null; + const ct = contentTypeOf(decrypted?.content); + + if (ct === "reaction" || ct === "reactionremoved") { + this.routeReaction(threadId, parsed, ct === "reaction", options); + return; + } + + // Same guards as the poll path (handleIncomingEvent): events that + // failed decryption or signature verification, non-message events, + // and empty messages are dropped instead of delivered. + if (!decrypted) { + this.logger.debug("Skipping undecryptable event", { + conversationId: event.conversationId, + eventId: event.id, + }); + return; + } + + const text = processableText(decrypted); + if (text === null) { + this.logger.debug("Skipping non-message event", { + conversationId: event.conversationId, + contentType: ct || decrypted.type, + eventId: event.id, + }); + return; + } + + if (decrypted.verified === false) { + this.logger.warn("Skipping unverified event", { + conversationId: event.conversationId, + eventId: event.id, + }); + return; + } + + if (!text.trim() && parsed.attachments.length === 0) { + return; + } + + // Read receipt before handlers run; markAsRead logs and swallows its + // own failures, so delivery is never blocked by a receipt error. + if (this.sendReadReceipts) { + await this.markAsRead(threadId, parsed); + } + + await this.chat?.handleIncomingMessage(this, threadId, parsed); + })().catch((err) => { + this.logger.error("Webhook event processing error", { + conversationId: event.conversationId, + eventId: event.id, + error: err instanceof Error ? err.message : String(err), + }); + }); + options?.waitUntil?.(task); + + return new Response("OK", { status: 200 }); + } + + /** + * Bot added to a conversation: bootstrap the conversation key from the + * KeyChange blob and post the welcome message (groups only). + */ + private handleConversationJoin( + event: XChatEvent, + options?: WebhookOptions + ): void { + const conversationId = event.conversationId; + this.logger.info("conversation_join", { conversationId }); + + if (this._cryptoStatus === "ready") { + const crypto = this.getCryptoEngine(); + for (const blob of [ + event.conversationKeyChangeEvent, + event.encodedEvent, + ]) { + if (!blob) { + continue; + } + try { + const extracted = crypto.extractConversationKeys([blob]); + this.mergeConversationKeys(conversationId, extracted); + } catch { + // Not a KeyChange blob — fine. + } + } + } + if (event.conversationToken) { + this.conversationTokens.set(conversationId, event.conversationToken); + } + + if (this.welcomeMessage === false || !conversationId.startsWith("g")) { + return; + } + const welcome = + this.welcomeMessage ?? + `Hey! I'm @${this._userName} — mention @${this._userName} in this group and I'll reply. Heads up: with a bot in the group, messages it can read are no longer fully private.`; + + const threadId = this.encodeThreadId({ conversationId }); + const task = this.postMessage(threadId, welcome).catch((err) => { + this.logger.warn("Failed to post welcome message", { + conversationId, + error: err instanceof Error ? err.message : String(err), + }); + }); + options?.waitUntil?.(task as Promise); + } + + /** Route a decrypted reaction event into the Chat SDK. */ + private routeReaction( + threadId: string, + parsed: Message, + added: boolean, + options?: WebhookOptions + ): void { + if (!this.chat) { + return; + } + const decrypted = parsed.raw?.decrypted; + const content = decrypted?.content ?? {}; + const rawEmoji = typeof content.emoji === "string" ? content.emoji : ""; + const targetMessageId = fieldOf( + content, + "targetMessageId", + "target_message_id" + ); + const senderId = decrypted?.senderId ?? parsed.raw?.event.senderId ?? ""; + + const user: Author = { + userId: senderId, + userName: senderId, + fullName: senderId, + isBot: false, + isMe: senderId === this.userId, + }; + + // A reaction targets its message by sequence id; resolve it back to the + // message id handlers saw. Falls back to the raw sequence id when the + // target is older than the bounded cache window. + const targetSequenceId = + targetMessageId == null ? "" : String(targetMessageId); + const resolvedMessageId = + this.messageIdBySequenceId.get(targetSequenceId) ?? targetSequenceId; + + const reactionEvent: Omit = { + emoji: getEmoji(rawEmoji), + rawEmoji, + added, + user, + messageId: resolvedMessageId, + threadId, + raw: parsed.raw, + }; + this.chat.processReaction({ ...reactionEvent, adapter: this }, options); + } + + /** + * Feed a polled conversation event into the Chat SDK. + * + * Expects an XDK camelCase event (transformKeys already applied). Decrypts + * + verifies via chat-xdk, then awaits `chat.handleIncomingMessage` so + * handlers (e.g. onDirectMessage) finish before this resolves. + * + * Returns the delivered Message, or null when the event was skipped + * (own message, non-message, decrypt failure, empty text). + */ + async handleIncomingEvent( + event: XChatEvent + ): Promise | null> { + if (!this.chat) { + throw new Error("XChat adapter not initialized — call Chat.initialize()"); + } + + if (!(event.conversationId && event.encodedEvent)) { + this.logger.debug( + "handleIncomingEvent: missing conversationId/encodedEvent" + ); + return null; + } + + if (event.senderId && event.senderId === this.userId) { + this.logger.debug("handleIncomingEvent: skip own message", { + id: event.id, + }); + return null; + } + + let message: Message; + try { + message = await this.decryptAndParseEvent(event); + } catch (err) { + this.logger.warn("handleIncomingEvent: decrypt failed", { + conversationId: event.conversationId, + eventId: event.id, + error: err instanceof Error ? err.message : String(err), + }); + return null; + } + + const decrypted = message.raw?.decrypted ?? null; + const text = processableText(decrypted); + if (text === null) { + this.logger.debug("handleIncomingEvent: skip non-message", { + type: decrypted?.type, + contentType: contentTypeOf(decrypted?.content), + eventId: event.id, + }); + return null; + } + + if (decrypted?.verified === false) { + this.logger.warn("handleIncomingEvent: skip unverified", { + conversationId: event.conversationId, + eventId: event.id, + }); + return null; + } + + if (!text.trim() && message.attachments.length === 0) { + return null; + } + + const threadId = this.encodeThreadId({ + conversationId: event.conversationId, + }); + + // Read receipt before handlers run; markAsRead logs and swallows its + // own failures, so delivery is never blocked by a receipt error. + if (this.sendReadReceipts) { + await this.markAsRead(threadId, message); + } + + await this.chat.handleIncomingMessage(this, threadId, message); + return message; + } + + /** + * Verify the HMAC-SHA256 signature on an incoming webhook POST. + * + * The `x-twitter-webhooks-signature` header contains `sha256=` + * where the hash is HMAC-SHA256(consumer_secret, raw_body). + */ + private verifySignature(body: string, signature: string): boolean { + if (!this.consumerSecret) { + return false; + } + + const expected = createHmac("sha256", this.consumerSecret) + .update(body) + .digest("base64"); + + const expectedBuf = Buffer.from(`sha256=${expected}`); + const actualBuf = Buffer.from(signature); + + if (expectedBuf.length !== actualBuf.length) { + return false; + } + + return timingSafeEqual(expectedBuf, actualBuf); + } + + // ── Message parsing ─────────────────────────────────────────────── + + parseMessage(raw: XChatRawMessage): Message { + const { event, decrypted } = raw; + + // An edit replaces its target: the backend stops serving the superseded + // original, so the edit's replacement text IS the message text, and the + // edit's target sequence id is what later reactions/edits/deletes must + // reference. + const content = decrypted?.content ?? {}; + const isEdit = contentTypeOf(content) === "edit"; + const editText = fieldOf(content, "newText", "new_text"); + const editTarget = fieldOf(content, "targetMessageId", "target_message_id"); + const text = + isEdit && typeof editText === "string" + ? editText + : (decrypted?.content?.text ?? ""); + const senderId = decrypted?.senderId ?? event.senderId; + const createdAtMsec = + decrypted?.createdAtMsec ?? Number(event.createdAtMsec ?? 0); + const conversationId = event.conversationId; + const threadId = this.encodeThreadId({ conversationId }); + + const messageId = decrypted?.id ?? event.id; + const sequenceId = + isEdit && typeof editTarget === "string" && editTarget + ? editTarget + : (decrypted?.sequenceId ?? event.sequenceId); + + // Track sequence ids + latest inbound context so reactions, read + // receipts, and group quote-replies can reference this message later. + if (sequenceId && messageId) { + this.rememberSequenceId(messageId, sequenceId); + } + if (senderId && senderId !== this.userId && decrypted) { + // Messages are parsed in whatever order they arrive — history pages come + // newest-first — so only a message at least as recent as the stored one + // may become the quote-reply target. + const previous = this.lastInboundByConv.get(conversationId); + if (!previous || (previous.createdAtMsec ?? 0) <= createdAtMsec) { + this.lastInboundByConv.set(conversationId, { + createdAtMsec, + encodedEvent: event.encodedEvent || undefined, + sequenceId, + senderId, + text: text || undefined, + ttlMsec: + typeof decrypted.ttlMsec === "number" + ? decrypted.ttlMsec + : Number( + fieldOf(decrypted, "ttlMsec", "ttl_msec") ?? Number.NaN + ) || undefined, + }); + } + } + + const isMention = this.detectBotMention(decrypted, text); + const attachments = decrypted + ? this.attachmentsFromDecrypted(conversationId, decrypted) + : []; + + return new Message({ + id: messageId ?? event.id, + threadId, + text, + formatted: parseMarkdown(text), + raw, + author: { + userId: senderId, + userName: senderId, + fullName: senderId, + isBot: false, + isMe: senderId === this.userId, + }, + metadata: { + dateSent: createdAtMsec ? new Date(createdAtMsec) : new Date(), + edited: isEdit, + }, + attachments, + ...(isMention ? { isMention: true } : {}), + }); + } + + /** + * Mention decision from the decrypted payload. + * + * Structured mention entities are authoritative when present; a + * swipe-reply to one of the bot's messages counts as a mention; otherwise + * undefined so the Chat SDK's plain-text `@handle` fallback applies. + */ + private detectBotMention( + decrypted: XChatDecryptedEvent | null, + text: string + ): boolean | undefined { + if (!decrypted) { + return undefined; + } + const content = decrypted.content; + const preview = replyPreviewOf(content); + // A reply preview that failed chat-xdk's validation against its embedded + // raw source event is forged and must not trigger the bot. + const previewTrusted = decrypted.replyPreviewValidation !== "invalid"; + const isReplyToBot = Boolean( + previewTrusted && preview?.senderId && preview.senderId === this.userId + ); + + const handles = mentionHandlesFromEntities(text, content?.entities); + if (handles.length > 0) { + const targets = new Set([ + this._userName.replace(LEADING_AT_RE, "").toLowerCase(), + this.userId.toLowerCase(), + ]); + if (handles.some((h) => targets.has(h))) { + return true; + } + return isReplyToBot || undefined; + } + + return isReplyToBot || undefined; + } + + /** Map media references on a decrypted event to Chat SDK attachments. */ + private attachmentsFromDecrypted( + conversationId: string, + decrypted: XChatDecryptedEvent + ): Attachment[] { + const keyVersion = decrypted.keyVersion; + return extractMediaEntries(decrypted).map((entry) => ({ + type: chatAttachmentType(entry.mediaType), + name: entry.filename, + size: Number.isFinite(entry.filesize) ? entry.filesize : undefined, + width: entry.width, + height: entry.height, + fetchData: () => + this.fetchMediaAttachment(conversationId, entry.hashKey, keyVersion), + })); + } + + /** Insert into the bounded messageId ⇄ sequenceId caches. */ + private rememberSequenceId(messageId: string, sequenceId: string): void { + if (this.sequenceIdByMessageId.size >= SEQUENCE_CACHE_MAX) { + const oldest = this.sequenceIdByMessageId.keys().next().value; + if (oldest !== undefined) { + const oldestSequenceId = this.sequenceIdByMessageId.get(oldest); + this.sequenceIdByMessageId.delete(oldest); + if (oldestSequenceId !== undefined) { + this.messageIdBySequenceId.delete(oldestSequenceId); + } + } + } + this.sequenceIdByMessageId.set(messageId, sequenceId); + this.messageIdBySequenceId.set(sequenceId, messageId); + } + + // ── Post / Edit / Delete ────────────────────────────────────────── + + async postMessage( + threadId: string, + message: AdapterPostableMessage + ): Promise> { + const { conversationId } = this.decodeThreadId(threadId); + // Cards degrade to text plus a URL preview attachment: XChat has no + // interactive primitives, so links become entities and the primary link + // becomes the preview card. + const card = cardOf(message); + const rendered = card ? cardToXChat(card) : null; + const text = rendered ? rendered.text : this.renderFormatted(message); + const crypto = this.getCryptoEngine(); + + this.stopTyping(conversationId); + + // Get conversation key — auto-fetch if missing + let keyInfo = this.getLatestKey(conversationId); + if (!keyInfo) { + this.logger.debug( + "No cached key, fetching conversation to extract keys", + { + conversationId, + } + ); + await this.fetchMessages(threadId, { limit: 1 }); + keyInfo = this.getLatestKey(conversationId); + if (!keyInfo) { + throw new Error( + `No conversation key for ${conversationId} even after fetching.` + ); + } + } + + // chat-xdk canonicalizes conversation id for signatures + if (!this.signingKeyVersion) { + throw new Error( + "signingKeyVersion not available. Was initialize() called?" + ); + } + + // Upload any file/attachment payloads (encrypt-stream + 3-step upload) + const mediaAttachments = await this.uploadOutgoingMedia( + conversationId, + keyInfo, + message + ); + + // Rich-text entities (tappable links / mention pills). A message carries + // one attachment kind, preferred in order: uploaded media, the card's URL + // preview, then the first x.com post card referenced in the text. + const entities = detectEntities(text); + let attachments: AttachmentDescriptor[] | null; + if (mediaAttachments.length > 0) { + attachments = mediaAttachments; + } else if (rendered?.urlCard) { + attachments = [ + await this.urlCardAttachment(conversationId, keyInfo, rendered.urlCard), + ]; + } else { + attachments = extractPostAttachments(text)?.slice(0, 1) ?? null; + } + + // Group chats reply-quote the triggering message; replies inherit its TTL. + const inbound = this.lastInboundByConv.get(conversationId); + const isGroup = conversationId.startsWith("g"); + const ttlMsec = inbound?.ttlMsec ?? null; + + const common = { + senderId: this.userId, + conversationId, + conversationKey: keyInfo.key, + text, + conversationKeyVersion: keyInfo.version, + signingKeyVersion: this.signingKeyVersion, + entities, + attachments, + ttlMsec, + }; + const payload = + isGroup && inbound?.sequenceId + ? this.encryptGroupReply(crypto, common, inbound) + : crypto.encryptMessage(common); + + // The SDK mints the message id and binds it into the signature. + const messageId = payload.messageId; + + await this.sendEncryptedPayload(conversationId, messageId, payload); + // Age gates the first edit of this message (bounded alongside the + // sequence-id cache). + if (this.postedAtByMessageId.size >= SEQUENCE_CACHE_MAX) { + const oldest = this.postedAtByMessageId.keys().next().value; + if (oldest !== undefined) { + this.postedAtByMessageId.delete(oldest); + } + } + this.postedAtByMessageId.set(messageId, Date.now()); + + // Build a synthetic raw message for the return + const rawMessage: XChatRawMessage = { + event: { + id: messageId, + conversationId, + senderId: this.userId, + encodedEvent: payload.encryptedContent, + createdAtMsec: String(Date.now()), + }, + decrypted: { + type: "message", + id: messageId, + senderId: this.userId, + conversationId, + createdAtMsec: Date.now(), + content: { text, contentType: "Text" }, + verified: true, + }, + }; + + return { + id: messageId, + raw: rawMessage, + threadId, + }; + } + + /** + * Encrypt a group quote-reply, preferring the event-based form. + * + * Passing the raw signed event (`replyToEvent`) lets chat-xdk derive the + * preview from the original — including the edited contents when the + * original was edited — and embed the raw event so recipients can + * validate the preview. When the original can't be parsed or decrypted + * (e.g. it was encrypted under a key version we don't hold), fall back + * to the explicit preview overrides, which skip the embedding. + */ + private encryptGroupReply( + crypto: ChatWithJuicebox, + common: EncryptMessageParams, + inbound: InboundContext + ): SendPayload { + if (inbound.encodedEvent) { + try { + return crypto.encryptReply({ + ...common, + replyToEvent: inbound.encodedEvent, + }); + } catch (err) { + this.logger.debug( + "encryptReply(replyToEvent) failed; using preview overrides", + { error: err instanceof Error ? err.message : String(err) } + ); + } + } + return crypto.encryptReply({ + ...common, + replyToSequenceId: inbound.sequenceId, + replyToSenderId: inbound.senderId ?? null, + replyToText: inbound.text ?? null, + }); + } + + /** POST an encrypted payload to the send-message endpoint. */ + private async sendEncryptedPayload( + conversationId: string, + messageId: string, + payload: { encryptedContent: string; encodedEventSignature: string } + ): Promise { + const client = this.getXdkClient(); + const apiConvId = conversationPathId(conversationId, this.userId); + const convToken = this.conversationTokens.get(conversationId); + const response = (await client.chat.sendMessage(apiConvId, { + messageId, + encodedMessageCreateEvent: payload.encryptedContent, + encodedMessageEventSignature: payload.encodedEventSignature, + ...(convToken ? { conversationToken: convToken } : {}), + })) as XApiResponse<{ + encodedMessageEvent?: string; + encoded_message_event?: string; + }>; + + // The response echoes the stored event; its sequence id is what edits, + // deletes, and reactions target, so capture it while it is cheap. A + // failed parse only costs the cache entry — resolveSequenceId falls + // back to a history fetch. + const encodedEvent: unknown = + response?.data?.encodedMessageEvent ?? + response?.data?.encoded_message_event; + if (typeof encodedEvent === "string" && encodedEvent.length > 0) { + try { + const crypto = this.getCryptoEngine(); + const keyInfo = this.getLatestKey(conversationId); + const event = crypto.decryptEvent( + encodedEvent, + keyInfo ? { [keyInfo.version]: keyInfo.key } : null, + this.signingKeyCache.get(this.userId) ?? [] + ) as { sequenceId?: unknown; message?: { sequenceId?: unknown } }; + const sequenceId = event?.sequenceId ?? event?.message?.sequenceId; + if (typeof sequenceId === "string" && sequenceId.length > 0) { + this.rememberSequenceId(messageId, sequenceId); + } + } catch { + // Undecodable echo — the id stays resolvable via fetchMessages. + } + } + } + + /** + * Resolve a message's sequence id (the identifier edits, deletes, and + * reactions target). Falls back to replaying recent history, which + * repopulates the cache through parseMessage. + */ + private async resolveSequenceId( + threadId: string, + messageId: string + ): Promise { + const cached = this.sequenceIdByMessageId.get(messageId); + if (cached) { + return cached; + } + await this.fetchMessages(threadId, { limit: 50 }); + const fetched = this.sequenceIdByMessageId.get(messageId); + if (!fetched) { + throw new Error( + `No sequence id known for message ${messageId}; it may be older than the last 50 events.` + ); + } + return fetched; + } + + /** + * Encrypt-stream + upload every file / data-bearing attachment on an + * outgoing message, returning media attachment descriptors. + */ + private async uploadOutgoingMedia( + conversationId: string, + keyInfo: { key: Uint8Array; version: string }, + message: AdapterPostableMessage + ): Promise { + if (typeof message === "string") { + return []; + } + const files: FileUpload[] = Array.isArray( + (message as { files?: FileUpload[] }).files + ) + ? ((message as { files?: FileUpload[] }).files as FileUpload[]) + : []; + const withData: Attachment[] = ( + Array.isArray((message as { attachments?: Attachment[] }).attachments) + ? ((message as { attachments?: Attachment[] }) + .attachments as Attachment[]) + : [] + ).filter((a) => a.data || a.fetchData); + + const descriptors: AttachmentDescriptor[] = []; + for (const file of files) { + const bytes = await toBytes(file.data); + descriptors.push( + await this.encryptAndUploadMedia(conversationId, keyInfo, bytes, { + filename: file.filename, + mimeType: file.mimeType, + }) + ); + } + for (const att of withData) { + const data = att.data ?? (await att.fetchData?.()); + if (!data) { + continue; + } + const bytes = await toBytes(data); + descriptors.push( + await this.encryptAndUploadMedia(conversationId, keyInfo, bytes, { + filename: att.name ?? "attachment", + mimeType: att.mimeType, + width: att.width, + height: att.height, + }) + ); + } + return descriptors; + } + + /** + * Edit a previously sent message. The edit is an encrypted event carrying + * the target's sequence id plus the replacement text and entities; it is + * sent through the same channel as a regular message and recipients apply + * it to the original in place. Only the bot's own text messages are + * editable. + */ + async editMessage( + threadId: string, + messageId: string, + message: AdapterPostableMessage + ): Promise> { + const { conversationId } = this.decodeThreadId(threadId); + const crypto = this.getCryptoEngine(); + if (!this.signingKeyVersion) { + throw new Error( + "signingKeyVersion not available. Was initialize() called?" + ); + } + const sequenceId = await this.resolveSequenceId(threadId, messageId); + const keyInfo = this.getLatestKey(conversationId); + if (!keyInfo) { + throw new Error(`No conversation key for ${conversationId}`); + } + + // Hold the edit until the original is old enough to have been delivered: + // an edit that reaches a client before the original leaves the message + // permanently invisible there (the backend stops serving superseded + // originals, so the client can never backfill the edit's target). + const postedAt = this.postedAtByMessageId.get(messageId); + if (postedAt !== undefined && this.editSafetyDelayMs > 0) { + const remaining = this.editSafetyDelayMs - (Date.now() - postedAt); + if (remaining > 0) { + this.logger.debug("Delaying first edit until the original settles", { + messageId, + remainingMs: remaining, + }); + await new Promise((resolveWait) => setTimeout(resolveWait, remaining)); + } + } + + const text = this.renderFormatted(message); + const payload = crypto.encryptEdit({ + senderId: this.userId, + conversationId, + targetMessageSequenceId: sequenceId, + updatedText: text, + entities: detectEntities(text), + conversationKey: keyInfo.key, + conversationKeyVersion: keyInfo.version, + signingKeyVersion: this.signingKeyVersion, + }); + await this.sendEncryptedPayload(conversationId, payload.messageId, payload); + + // The edit event has its own id; the returned message keeps the edited + // message's id so callers can keep referencing (and re-editing) it. + return { + id: messageId, + threadId, + raw: { + event: { + id: payload.messageId, + conversationId, + senderId: this.userId, + encodedEvent: payload.encryptedContent, + createdAtMsec: String(Date.now()), + }, + decrypted: { + type: "message", + id: messageId, + senderId: this.userId, + conversationId, + createdAtMsec: Date.now(), + content: { text, contentType: "Text" }, + verified: true, + }, + }, + }; + } + + /** + * Delete a message for every participant. The signed delete action is + * prepared locally (recipients verify it) and submitted with the request; + * the API accepts delete-for-all only for the bot's own messages. + */ + async deleteMessage(threadId: string, messageId: string): Promise { + const { conversationId } = this.decodeThreadId(threadId); + const crypto = this.getCryptoEngine(); + if (!this.signingKeyVersion) { + throw new Error( + "signingKeyVersion not available. Was initialize() called?" + ); + } + const sequenceId = await this.resolveSequenceId(threadId, messageId); + const signature = crypto.prepareMessageDelete({ + senderId: this.userId, + conversationId, + sequenceIds: [sequenceId], + deleteForAll: true, + signingKeyVersion: this.signingKeyVersion, + }); + + const client = this.getXdkClient(); + await client.chat.deleteMessages(dashConversationId(conversationId), { + sequenceIds: [sequenceId], + deleteMessageAction: "delete_for_all", + actionSignatures: [ + { + messageId: signature.messageId, + encodedMessageEventDetail: signature.encodedMessageEventDetail, + ...(signature.signaturePayload + ? { signaturePayload: signature.signaturePayload } + : {}), + messageEventSignature: { + signature: signature.signature, + publicKeyVersion: signature.publicKeyVersion, + signatureVersion: signature.signatureVersion, + signingPublicKey: crypto.getPublicKeys().signing, + }, + }, + ], + }); + this.logger.info("Deleted message", { conversationId, sequenceId }); + } + + // ── Reactions ───────────────────────────────────────────────────── + + async addReaction( + threadId: string, + messageId: string, + emoji: EmojiValue | string + ): Promise { + await this.sendReaction(threadId, messageId, emoji, true); + } + + async removeReaction( + threadId: string, + messageId: string, + emoji: EmojiValue | string + ): Promise { + await this.sendReaction(threadId, messageId, emoji, false); + } + + private async sendReaction( + threadId: string, + messageId: string, + emoji: EmojiValue | string, + add: boolean + ): Promise { + const { conversationId } = this.decodeThreadId(threadId); + // Reactions are best-effort: when the sequence id is neither cached nor + // recoverable from recent history, warn and skip instead of throwing. + let sequenceId: string; + try { + sequenceId = await this.resolveSequenceId(threadId, messageId); + } catch (err) { + this.logger.warn("Cannot react: no sequence id for message", { + threadId, + messageId, + error: err instanceof Error ? err.message : String(err), + }); + return; + } + + const crypto = this.getCryptoEngine(); + const keyInfo = this.getLatestKey(conversationId); + if (!keyInfo) { + throw new Error(`No conversation key for ${conversationId}`); + } + if (!this.signingKeyVersion) { + throw new Error( + "signingKeyVersion not available. Was initialize() called?" + ); + } + + // Resolve to a unicode emoji (X Chat reactions are unicode). The shared + // resolver's Google Chat profile is its plain-unicode output, so it is + // the right conversion here despite the name. + const unicodeEmoji = defaultEmojiResolver.toGChat(emoji); + + const params = { + senderId: this.userId, + conversationId, + conversationKey: keyInfo.key, + targetMessageSequenceId: sequenceId, + emoji: unicodeEmoji, + conversationKeyVersion: keyInfo.version, + signingKeyVersion: this.signingKeyVersion, + }; + const payload = add + ? crypto.encryptAddReaction(params) + : crypto.encryptRemoveReaction(params); + + // The SDK mints the reaction's message id and binds it into the signature. + await this.sendEncryptedPayload(conversationId, payload.messageId, payload); + } + + // ── Fetch messages ──────────────────────────────────────────────── + + async fetchMessages( + threadId: string, + options?: FetchOptions + ): Promise> { + const { conversationId } = this.decodeThreadId(threadId); + const client = this.getXdkClient(); + const crypto = this.getCryptoEngine(); + + // Conversation events come from GET /2/chat/conversations/{id}/events + // (GET /2/chat/conversations/{id} returns only conversation metadata). + // Conversation key (KeyChange) events arrive inline in data[] — not in + // meta — so we hand the whole batch to decryptEvents(), which extracts + // keys and decrypts messages in a single pass. + const apiConvId = conversationPathId(conversationId, this.userId); + const response = (await client.chat.getConversationEvents(apiConvId, { + maxResults: options?.limit ?? 50, + paginationToken: options?.cursor, + chatMessageEventFields: [ + ...MESSAGE_EVENT_FIELDS, + ] as unknown as MessageEventFields, + })) as unknown as ConversationEventsResponse; + + const rawEvents = response?.data ?? []; + const nextCursor = response?.meta?.nextToken ?? response?.meta?.next_token; + + // Cache keys/tokens under the conversationId on events (colon form), not + // the URL/list form — that is the only id decrypt paths will look up. + const cacheConvId = + rawEvents.find((e) => e.conversationId)?.conversationId ?? conversationId; + + // Collect encoded events, cache tokens, and map back to raw metadata. + const encodedEvents: string[] = []; + const b64ToRaw = new Map>(); + const senderIds = new Set(); + for (const evt of rawEvents) { + if (evt.conversationToken) { + this.conversationTokens.set( + evt.conversationId ?? cacheConvId, + evt.conversationToken + ); + } + if (evt.senderId) { + senderIds.add(evt.senderId); + } + const encodedEvent = evt.encodedEvent ?? ""; + if (encodedEvent) { + encodedEvents.push(encodedEvent); + b64ToRaw.set(encodedEvent, evt); + } + } + + if (encodedEvents.length === 0) { + return { messages: [], nextCursor }; + } + + // Fetch signing keys for everyone involved so decryptEvents can verify + // message signatures (verification is best-effort — missing keys just + // leave messages unverified rather than failing decryption). + const involvedUserIds = new Set([ + ...senderIds, + this.userId, + ...this.participantsFromConversationId(cacheConvId), + ]); + const signingKeys = await this.getSigningKeysForUsers([...involvedUserIds]); + + // Batch decrypt — extracts conversation keys from KeyChange events, + // matches signing keys by userId, and decrypts every message in one pass. + let result: ReturnType; + try { + result = crypto.decryptEvents(encodedEvents, signingKeys); + } catch (err) { + this.logger.warn("decryptEvents failed", { + conversationId: cacheConvId, + error: err, + }); + return { messages: [], nextCursor }; + } + + // Merge extracted conversation keys into the cache (used for sending). + this.mergeConversationKeys(cacheConvId, result.conversationKeys); + + // Under the SDK's hardened default (reject_unverified = true) any event + // whose signature can't be verified lands here instead of in messages. + // Surface it so silent drops are debuggable. + const errorCount = Object.keys(result.errors).length; + if (errorCount > 0) { + this.logger.debug("decryptEvents reported errors", { + conversationId: cacheConvId, + errorCount, + errors: result.errors, + }); + } + + const messages: Message[] = []; + for (const dm of result.messages) { + const event = dm.event; + if ( + !event || + processableText(event as unknown as XChatDecryptedEvent) === null + ) { + continue; + } + + const raw = dm.originalB64 ? b64ToRaw.get(dm.originalB64) : undefined; + // The decrypted event's meta carries epoch millis; the API event carries + // an ISO-8601 created_at instead. + const rawCreatedAtMsec = + raw?.createdAtMsec ?? + (raw?.createdAt ? Date.parse(raw.createdAt) : Number.NaN); + const createdAtMsec = + event.createdAtMsec ?? + (Number.isFinite(Number(rawCreatedAtMsec)) + ? rawCreatedAtMsec + : undefined); + const rawMessage: XChatRawMessage = { + event: { + id: event.id ?? raw?.id ?? "", + conversationId, + senderId: event.senderId ?? raw?.senderId ?? "", + encodedEvent: dm.originalB64 ?? raw?.encodedEvent ?? "", + createdAtMsec: + createdAtMsec == null ? undefined : String(createdAtMsec), + conversationToken: raw?.conversationToken, + messageEventSignature: raw?.messageEventSignature, + sequenceId: event.sequenceId ?? raw?.sequenceId, + }, + decrypted: event as XChatDecryptedEvent, + }; + messages.push(this.parseMessage(rawMessage)); + } + + // Sort chronologically (oldest first) + messages.sort( + (a, b) => a.metadata.dateSent.getTime() - b.metadata.dateSent.getTime() + ); + + return { messages, nextCursor }; + } + + async fetchThread(threadId: string): Promise { + const { conversationId } = this.decodeThreadId(threadId); + return { + id: threadId, + channelId: threadId, + isDM: !conversationId.startsWith("g"), + metadata: { conversationId }, + }; + } + + // ── Format rendering ────────────────────────────────────────────── + + renderFormatted(content: FormattedContent | AdapterPostableMessage): string { + if (typeof content === "string") { + return content; + } + if ("type" in content && content.type === "root") { + return this.formatConverter.fromAst(content as FormattedContent); + } + return this.formatConverter.renderPostable( + content as AdapterPostableMessage + ); + } + + // ── Typing indicator ────────────────────────────────────────────── + + /** + * Send a typing indicator and keep re-sending it every few seconds until + * the next postMessage in this conversation (or a safety timeout). X Chat + * typing pills expire quickly, so a single POST is invisible during a + * longer generation. + */ + async startTyping(threadId: string): Promise { + const { conversationId } = this.decodeThreadId(threadId); + this.stopTyping(conversationId); + await this.sendTypingOnce(conversationId); + + const startedAt = Date.now(); + const timer = setInterval(() => { + if (Date.now() - startedAt > TYPING_MAX_MS) { + this.stopTyping(conversationId); + return; + } + this.sendTypingOnce(conversationId).catch(() => undefined); + }, TYPING_INTERVAL_MS); + timer.unref?.(); + this.typingTimers.set(conversationId, timer); + } + + private async sendTypingOnce(conversationId: string): Promise { + try { + const client = this.getXdkClient(); + const apiConvId = conversationPathId(conversationId, this.userId); + await client.chat.sendTypingIndicator(apiConvId); + } catch (err) { + this.logger.warn("Failed to send typing indicator", { error: err }); + } + } + + private stopTyping(conversationId: string): void { + const timer = this.typingTimers.get(conversationId); + if (timer) { + clearInterval(timer); + this.typingTimers.delete(conversationId); + } + } + + // ── Read receipts ───────────────────────────────────────────────── + + /** + * Send a read receipt (seen-until watermark) for an inbound message. + * + * Called automatically for each delivered inbound message when + * `sendReadReceipts` is enabled (the default). Failures are logged and + * swallowed so message delivery is never blocked by a receipt error. + */ + async markAsRead(threadId: string, message: Message): Promise { + const { conversationId } = this.decodeThreadId(threadId); + const raw = message.raw as XChatRawMessage | undefined; + let sequenceId = raw?.decrypted?.sequenceId ?? raw?.event?.sequenceId ?? ""; + + try { + const client = this.getXdkClient(); + const apiConvId = conversationPathId(conversationId, this.userId); + + // Fallback: mark read up to the latest event in the conversation. + if (!sequenceId) { + const response = (await client.chat.getConversationEvents(apiConvId, { + maxResults: 1, + chatMessageEventFields: [ + ...MESSAGE_EVENT_FIELDS, + ] as unknown as MessageEventFields, + })) as unknown as ConversationEventsResponse; + const latest = response?.data?.[0]; + // Event ids are a different namespace — only a real sequence id is a + // valid read watermark, so skip when the latest event lacks one. + sequenceId = latest?.sequenceId ?? ""; + if (!sequenceId) { + this.logger.debug("markAsRead skipped: no sequenceId available", { + messageId: message.id, + threadId, + }); + return; + } + } + + await client.chat.markConversationRead(apiConvId, { + seenUntilSequenceId: sequenceId, + }); + this.logger.debug("Read receipt sent", { + conversationId: apiConvId, + sequenceId, + }); + } catch (err) { + this.logger.warn("Failed to send read receipt", { + threadId, + messageId: message.id, + error: err instanceof Error ? err.message : String(err), + }); + } + } + + // ── DM detection ────────────────────────────────────────────────── + + isDM(threadId: string): boolean { + const { conversationId } = this.decodeThreadId(threadId); + return !conversationId.startsWith("g"); + } + + // ── Media (encrypted download / upload) ────────────────────────── + + /** + * Download and decrypt a media attachment. + * + * Media bytes are secretstream-encrypted under a conversation key; + * `keyVersion` selects the matching cached key (latest when omitted). + */ + async fetchMediaAttachment( + conversationId: string, + mediaHashKey: string, + keyVersion?: string + ): Promise { + const crypto = this.getCryptoEngine(); + + let keyResult = this.conversationKeys.get(conversationId); + if (!keyResult) { + await this.fetchMessages(this.encodeThreadId({ conversationId }), { + limit: 1, + }); + keyResult = this.conversationKeys.get(conversationId); + } + const key = + (keyVersion ? keyResult?.keys[keyVersion] : undefined) ?? + (keyResult?.latestVersion + ? keyResult.keys[keyResult.latestVersion] + : undefined); + if (!key) { + throw new Error(`No conversation key for ${conversationId}`); + } + + const client = this.getXdkClient(); + // The media routes accept only the dash-joined participant pair (or the + // g-prefixed group id) — not the bare peer id the other chat routes take, + // and not the colon form carried in events. + const encrypted = new Uint8Array( + await client.chat.mediaDownload( + dashConversationId(conversationId), + mediaHashKey + ) + ); + const plaintext = crypto.decryptStream(encrypted, key); + return Buffer.from(plaintext); + } + + /** + * Encrypt-stream a payload and run the 3-step upload (initialize / append / + * finalize), returning the stored blob's media hash key. + */ + private async uploadEncryptedBlob( + conversationId: string, + keyInfo: { key: Uint8Array; version: string }, + bytes: Uint8Array + ): Promise<{ mediaHashKey: string; encryptedBytes: number }> { + const crypto = this.getCryptoEngine(); + const client = this.getXdkClient(); + const encrypted = crypto.encryptStream(bytes, keyInfo.key); + + const initBody = await client.chat.mediaUploadInitialize({ + conversationId, + totalBytes: encrypted.length, + }); + const sessionId = initBody.data?.sessionId; + const mediaHashKey = initBody.data?.mediaHashKey; + if (!(sessionId && mediaHashKey)) { + throw new Error("Media upload initialize returned no session"); + } + + let segmentIndex = 0; + for ( + let offset = 0; + offset < encrypted.length; + offset += UPLOAD_CHUNK_BYTES + ) { + const chunk = encrypted.subarray(offset, offset + UPLOAD_CHUNK_BYTES); + await client.chat.mediaUploadAppend(sessionId, { + conversationId, + mediaHashKey, + segmentIndex, + media: Buffer.from(chunk).toString("base64"), + }); + segmentIndex += 1; + } + + await client.chat.mediaUploadFinalize(sessionId, { + conversationId, + mediaHashKey, + numParts: String(segmentIndex), + }); + + return { mediaHashKey, encryptedBytes: encrypted.length }; + } + + private async encryptAndUploadMedia( + conversationId: string, + keyInfo: { key: Uint8Array; version: string }, + bytes: Uint8Array, + meta: { + filename: string; + mimeType?: string; + width?: number; + height?: number; + } + ): Promise { + const mimeType = meta.mimeType ?? detectMimeType(bytes) ?? ""; + const { mediaHashKey } = await this.uploadEncryptedBlob( + conversationId, + keyInfo, + bytes + ); + + // Dimensions from the plaintext; videos fall back to a 16:9 default so + // the client renders a usable preview card. + const isVideo = mimeType.startsWith("video/"); + const dims = detectImageDimensions(bytes); + const width = meta.width ?? dims?.width ?? (isVideo ? 1280 : 1024); + const height = meta.height ?? dims?.height ?? (isVideo ? 720 : 1024); + const mediaType = outgoingMediaType(mimeType); + + this.logger.debug("Media uploaded", { + conversationId, + mediaHashKey: mediaHashKey.slice(0, 16), + bytes: bytes.length, + mimeType, + }); + + return { + attachment_type: "media", + media_hash_key: mediaHashKey, + width, + height, + filesize_bytes: bytes.length, + filename: meta.filename, + ...(mediaType === undefined ? {} : { media_type: mediaType }), + }; + } + + /** + * Build a URL preview attachment from a card spec, encrypting and + * uploading the banner image when the spec carries one. The banner's + * hash key, encrypted size, and filename are all required on the wire — + * receiving clients silently discard the image when any is missing — so + * a failed banner fetch degrades to a card without an image. + */ + private async urlCardAttachment( + conversationId: string, + keyInfo: { key: Uint8Array; version: string }, + spec: XChatUrlCardSpec + ): Promise { + let bannerImage: UrlAttachmentImageDescriptor | undefined; + if (spec.imageUrl) { + try { + const response = await fetch(spec.imageUrl); + if (response.ok) { + const bytes = new Uint8Array(await response.arrayBuffer()); + const { mediaHashKey, encryptedBytes } = + await this.uploadEncryptedBlob(conversationId, keyInfo, bytes); + const dims = detectImageDimensions(bytes); + const filename = + spec.imageUrl.split("/").pop()?.split("?")[0] || "banner"; + bannerImage = { + media_hash_key: mediaHashKey, + filesize_bytes: encryptedBytes, + filename, + ...(dims ? { width: dims.width, height: dims.height } : {}), + }; + } + } catch (err) { + this.logger.warn("URL card banner upload failed; sending without it", { + imageUrl: spec.imageUrl, + error: err instanceof Error ? err.message : String(err), + }); + } + } + return { + attachment_type: "url", + url: spec.url, + ...(spec.displayTitle ? { display_title: spec.displayTitle } : {}), + ...(bannerImage ? { banner_image: bannerImage } : {}), + }; + } + + // ── Open a DM ───────────────────────────────────────────────────── + + /** + * Start (or reopen) a 1:1 conversation with a user, returning its thread + * id. XChat 1:1 ids are derived from the participant pair, so an existing + * conversation is reused: when a conversation key is already held (or + * fetchable), no key exchange happens. Otherwise a fresh conversation key + * is prepared, encrypted to both participants' identity keys, and posted + * to initialize the conversation. Requires the recipient to have encrypted + * chat set up; the server also requires the recipient to trust the bot + * (e.g. follow it) before the first message is accepted. + */ + async openDM(userId: string): Promise { + if (!NUMERIC_USER_ID.test(userId)) { + throw new Error( + `openDM requires a numeric X user id (got "${userId}"). ` + + "Handles like @alice must be resolved to a user id first." + ); + } + const crypto = this.getCryptoEngine(); + const client = this.getXdkClient(); + + const canonicalId = [userId, this.userId] + .map(BigInt) + .sort((a, b) => { + if (a === b) { + return 0; + } + return a < b ? -1 : 1; + }) + .map(String) + .join(":"); + const threadId = this.encodeThreadId({ conversationId: canonicalId }); + if (this.getLatestKey(canonicalId)) { + return threadId; + } + try { + await this.fetchMessages(threadId, { limit: 50 }); + } catch { + // No conversation yet — fall through to the key exchange. + } + if (this.getLatestKey(canonicalId)) { + return threadId; + } + + const signingEntries = await this.getSigningKeysForUsers([ + this.userId, + userId, + ]); + const publicKeys: PublicKeyInput[] = signingEntries.map((entry) => ({ + userId: entry.userId, + publicKey: entry.identityPublicKey, + keyVersion: entry.publicKeyVersion, + })); + if (!publicKeys.some((key) => key.userId === userId)) { + throw new Error( + `Cannot open DM: user ${userId} has no registered chat keys (encrypted chat not set up).` + ); + } + + const prepared = crypto.prepareConversationKeyChange({ publicKeys }); + const signingPublicKey = crypto.getPublicKeys().signing; + await client.chat.addConversationKeys( + dashConversationId(prepared.conversationId), + { + conversationKeyVersion: prepared.conversationKeyVersion, + conversationParticipantKeys: prepared.participantKeys.map((key) => ({ + userId: key.userId, + encryptedConversationKey: key.encryptedKey, + publicKeyVersion: key.publicKeyVersion, + })), + actionSignatures: prepared.actionSignatures.map((sig) => ({ + messageId: sig.messageId, + encodedMessageEventDetail: sig.encodedMessageEventDetail, + ...(sig.signaturePayload + ? { signaturePayload: sig.signaturePayload } + : {}), + messageEventSignature: { + signature: sig.signature, + signatureVersion: sig.signatureVersion, + publicKeyVersion: sig.publicKeyVersion, + signingPublicKey, + }, + })), + } + ); + + this.mergeConversationKeys(prepared.conversationId, { + keys: { [prepared.conversationKeyVersion]: prepared.conversationKey }, + latestVersion: prepared.conversationKeyVersion, + }); + this.logger.info("Opened DM conversation", { + conversationId: prepared.conversationId, + keyVersion: prepared.conversationKeyVersion, + }); + return this.encodeThreadId({ conversationId: prepared.conversationId }); + } + + // ── Internal helpers ────────────────────────────────────────────── + + private getXdkClient(): InstanceType { + if (!this.xdkClient) { + throw new Error( + "XChat adapter not initialized. Call initialize() first." + ); + } + return this.xdkClient; + } + + private getCryptoEngine(): ChatWithJuicebox { + if (!this.cryptoEngine || this._cryptoStatus !== "ready") { + throw new Error( + this._cryptoStatus === "locked" + ? "XChat adapter is locked. Call adapter.unlock(pin) first." + : "XChat crypto not initialized. Call initialize() first." + ); + } + return this.cryptoEngine; + } + + /** + * Derive the candidate participant user IDs from a conversation ID. + * + * 1:1 conversation IDs encode both participants as `{userId1}-{userId2}` + * (or `{userId1}:{userId2}`). Group conversation IDs are opaque (`g...`), + * so we return nothing and rely on the sender IDs seen in events. + */ + private participantsFromConversationId(conversationId: string): string[] { + if (conversationId.startsWith("g")) { + return []; + } + return conversationId + .split(CONVERSATION_ID_SEPARATOR) + .filter((part) => NUMERIC_USER_ID.test(part)); + } + + /** + * Fetch (and cache) signing keys for the given users from the X API. + * + * Returns a flat array of SigningKeyEntry (one per user per key version) + * suitable for `decryptEvents` / `decryptEvent`. Failures are swallowed — + * a missing signing key only means messages from that user stay unverified. + * Failed lookups are not cached, so a transient API error is retried on + * the next call instead of leaving the user permanently unverifiable. + */ + private async getSigningKeysForUsers( + userIds: string[] + ): Promise { + const client = this.getXdkClient(); + const missing = userIds.filter((id) => id && !this.signingKeyCache.has(id)); + + await Promise.all( + missing.map(async (userId) => { + try { + const response = (await client.users.getPublicKey(userId, { + publicKeyFields: [...SIGNING_KEY_FIELDS], + })) as XApiResponse; + const data = response?.data; + let keys: PublicKeyData[] = []; + if (Array.isArray(data)) { + keys = data; + } else if (data) { + keys = [data]; + } + + const entries: SigningKeyEntry[] = []; + for (const key of keys) { + const publicKeyVersion = publicKeyVersionOf(key); + if ( + publicKeyVersion && + key.signingPublicKey && + key.publicKey && + key.identityPublicKeySignature + ) { + entries.push({ + userId, + publicKeyVersion, + publicKey: key.signingPublicKey, + identityPublicKey: key.publicKey, + identityPublicKeySignature: key.identityPublicKeySignature, + }); + } + } + this.signingKeyCache.set(userId, entries); + } catch (err) { + // Deliberately not cached: the next lookup retries the fetch. + this.logger.debug("Failed to fetch signing keys", { + userId, + error: err, + }); + } + }) + ); + + const all: SigningKeyEntry[] = []; + for (const id of userIds) { + const cached = this.signingKeyCache.get(id); + if (cached) { + all.push(...cached); + } + } + return all; + } + + /** + * Merge freshly extracted conversation keys into the cache for a conversation. + */ + private mergeConversationKeys( + conversationId: string, + extracted: ConversationKeyResult + ): void { + if (!extracted || Object.keys(extracted.keys).length === 0) { + return; + } + const existing = this.conversationKeys.get(conversationId); + if (existing) { + for (const [version, key] of Object.entries(extracted.keys)) { + existing.keys[version] = key; + } + if (extracted.latestVersion) { + existing.latestVersion = extracted.latestVersion; + } + } else { + this.conversationKeys.set(conversationId, { + keys: { ...extracted.keys }, + latestVersion: extracted.latestVersion, + }); + } + } + + /** + * Decrypt a single event, returning a XChatRawMessage. + * Falls back gracefully if decryption fails (returns null decrypted). + */ + private tryDecryptEvent( + conversationId: string, + event: XChatEvent, + signingKeys: SigningKeyEntry[] = [] + ): XChatRawMessage { + const crypto = this.getCryptoEngine(); + const keyResult = this.conversationKeys.get(conversationId); + + if (!(keyResult && event.encodedEvent)) { + return { event, decrypted: null }; + } + + try { + const decrypted = crypto.decryptEvent( + event.encodedEvent, + keyResult.keys, + signingKeys + ) as XChatDecryptedEvent; + return { event, decrypted }; + } catch { + this.logger.debug("Failed to decrypt event", { + conversationId, + eventId: event.id, + }); + return { event, decrypted: null }; + } + } + + /** + * Decrypt an XAA or polled API event (key extraction from + * conversation_key_change_event, encrypted_conversation_key, or a + * KeyChange encoded as encoded_event), then parse into a Message. + * + * Falls back to decryptEvents when single-event decrypt fails — the + * conversation-events poll path often embeds key material that way. + */ + private async decryptAndParseEvent( + event: XChatEvent + ): Promise> { + const crypto = this.getCryptoEngine(); + const conversationId = event.conversationId; + + // Extract conversation key if a key change event is present + if (event.conversationKeyChangeEvent) { + const extracted = crypto.extractConversationKeys([ + event.conversationKeyChangeEvent, + ]); + this.mergeConversationKeys(conversationId, extracted); + } + + // Poll path: KeyChange may arrive as the encoded_event itself + if (event.encodedEvent) { + try { + const extracted = crypto.extractConversationKeys([event.encodedEvent]); + this.mergeConversationKeys(conversationId, extracted); + } catch { + // Not a key-change event — fine. + } + } + + // Also try the encryptedConversationKey field (XAA webhook path) + if ( + event.encryptedConversationKey && + event.conversationKeyVersion && + !this.conversationKeys.get(conversationId)?.keys[ + event.conversationKeyVersion + ] + ) { + try { + const rawKey = crypto.decryptConversationKey( + event.encryptedConversationKey + ); + const existing = this.conversationKeys.get(conversationId); + if (existing) { + existing.keys[event.conversationKeyVersion] = rawKey; + existing.latestVersion = event.conversationKeyVersion; + } else { + this.conversationKeys.set(conversationId, { + keys: { [event.conversationKeyVersion]: rawKey }, + latestVersion: event.conversationKeyVersion, + }); + } + } catch { + this.logger.debug("Failed to decrypt conversation key", { + conversationId, + }); + } + } + + if (event.conversationToken) { + this.conversationTokens.set(conversationId, event.conversationToken); + } + + // Fetch signing keys for the sender so the message signature can be verified. + const signingKeys = await this.getSigningKeysForUsers([ + event.senderId, + this.userId, + ]); + + const raw = this.tryDecryptEvent(conversationId, event, signingKeys); + if (raw.decrypted) { + return this.parseMessage(raw); + } + + // Fallback: batch decryptEvents (handles signed poll events + key cache) + try { + const result = crypto.decryptEvents([event.encodedEvent], signingKeys); + this.mergeConversationKeys(conversationId, result.conversationKeys); + + const dm = result.messages.find((m) => m.event?.type === "message"); + if (dm?.event) { + return this.parseMessage({ + event, + decrypted: dm.event as unknown as XChatDecryptedEvent, + }); + } + } catch { + // Fall through to undecrypted message + } + + return this.parseMessage({ event, decrypted: null }); + } + + /** + * Get the latest conversation key for a conversation. + */ + private getLatestKey( + conversationId: string + ): { key: Uint8Array; version: string } | null { + const result = this.conversationKeys.get(conversationId); + if (!result?.latestVersion) { + return null; + } + const key = result.keys[result.latestVersion]; + if (!key) { + return null; + } + return { key, version: result.latestVersion }; + } +} + +// ── Factory function ────────────────────────────────────────────────── + +/** + * Create an XChat adapter with configuration from env vars or explicit config. + * + * **Required** (via config or env vars): + * - `botToken` / `accessToken` / `XCHAT_BOT_TOKEN` / `X_ACCESS_TOKEN`: OAuth2 access token + * - `userId` / `XCHAT_USER_ID` / `X_USER_ID`: The bot's numeric user ID + * + * **Optional:** + * - `pin` / `XCHAT_PIN`: Juicebox PIN; when set, initialize() auto-unlocks + * - `signingKeyVersion` / `X_SIGNING_KEY_VERSION`: Override for signing key version. + * When omitted, fetched automatically from the X API during initialize(). + * - `userName` / `X_BOT_USERNAME`: Override @handle. When omitted, initialize() + * resolves it from GET /2/users/me. + * - `verifySignatures` / `X_VERIFY_SIGNATURES`: Require verifiable signatures + * on incoming messages (default true). Set false to decrypt unverifiable + * messages instead of dropping them. + */ +export function createXChatAdapter(config?: { + /** OAuth2 access token (alias for accessToken). */ + botToken?: string; + accessToken?: string; + /** Base URL for X API requests. Defaults to https://api.x.com. */ + apiBaseUrl?: string; + apiHeaders?: Record; + /** App consumer secret for webhook CRC + signature verification. Defaults to X_CONSUMER_SECRET env var. */ + consumerSecret?: string; + /** + * Minimum age (ms) a freshly posted message must reach before its first + * edit is sent, giving receiving clients time to store the original an + * edit targets. Defaults to 5000; 0 disables the wait. + */ + editSafetyDelayMs?: number; + logger?: Logger; + /** Juicebox PIN; when set, initialize() auto-unlocks. */ + pin?: string; + /** Override — normally fetched automatically during initialize(). */ + signingKeyVersion?: string; + /** + * Require verifiable signatures on incoming messages. Defaults to true. + * Set to false (or X_VERIFY_SIGNATURES=false) to decrypt unverifiable + * messages instead of dropping them. + */ + verifySignatures?: boolean; + userName?: string; + userId?: string; + /** Group-join welcome message; false disables, omitted uses a default. */ + welcomeMessage?: string | false; +}): XChatAdapter { + const logger = config?.logger ?? new ConsoleLogger("info").child("xchat"); + + const accessToken = + config?.botToken ?? + config?.accessToken ?? + process.env.XCHAT_BOT_TOKEN ?? + process.env.X_ACCESS_TOKEN; + if (!accessToken) { + throw new ValidationError( + "xchat", + "botToken/accessToken is required. Set XCHAT_BOT_TOKEN or X_ACCESS_TOKEN, or provide botToken/accessToken in config." + ); + } + + const userId = + config?.userId ?? process.env.XCHAT_USER_ID ?? process.env.X_USER_ID; + if (!userId) { + throw new ValidationError( + "xchat", + "userId is required. Set XCHAT_USER_ID or X_USER_ID, or provide it in config." + ); + } + + const consumerSecret = + config?.consumerSecret ?? process.env.X_CONSUMER_SECRET ?? undefined; + + const pin = config?.pin ?? process.env.XCHAT_PIN ?? undefined; + + const signingKeyVersion = + config?.signingKeyVersion ?? process.env.X_SIGNING_KEY_VERSION ?? undefined; + + const verifySignatures = + config?.verifySignatures ?? process.env.X_VERIFY_SIGNATURES !== "false"; + + // Prefer explicit config; env override; otherwise initialize() fills from /2/users/me + const userName = config?.userName ?? process.env.X_BOT_USERNAME; + + return new XChatAdapter({ + accessToken, + apiBaseUrl: config?.apiBaseUrl, + apiHeaders: config?.apiHeaders, + consumerSecret, + editSafetyDelayMs: config?.editSafetyDelayMs, + logger, + pin, + signingKeyVersion, + verifySignatures, + userName, + userId, + welcomeMessage: config?.welcomeMessage, + }); +} diff --git a/packages/adapter-xchat/src/markdown.test.ts b/packages/adapter-xchat/src/markdown.test.ts new file mode 100644 index 000000000..041f7c321 --- /dev/null +++ b/packages/adapter-xchat/src/markdown.test.ts @@ -0,0 +1,97 @@ +import { describe, expect, it } from "vitest"; +import { XChatFormatConverter } from "./markdown"; + +/** Italic markers may stringify as either `*italic*` or `_italic_`. */ +const ITALIC_MARKERS_RE = /[*_]italic[*_]/; + +describe("XChatFormatConverter", () => { + const converter = new XChatFormatConverter(); + + describe("toAst", () => { + it("should parse plain text", () => { + const ast = converter.toAst("Hello world"); + expect(ast.type).toBe("root"); + expect(ast.children.length).toBeGreaterThan(0); + }); + + it("should parse bold (**text**)", () => { + const ast = converter.toAst("**bold text**"); + expect(ast.type).toBe("root"); + }); + + it("should parse italic (_text_)", () => { + const ast = converter.toAst("_italic text_"); + expect(ast.type).toBe("root"); + }); + + it("should parse code blocks", () => { + const ast = converter.toAst("```\ncode\n```"); + expect(ast.type).toBe("root"); + }); + + it("should parse lists", () => { + const ast = converter.toAst("- item 1\n- item 2\n- item 3"); + expect(ast.type).toBe("root"); + }); + }); + + describe("fromAst", () => { + it("should stringify a simple AST", () => { + const ast = converter.toAst("Hello world"); + const result = converter.fromAst(ast); + expect(result).toContain("Hello world"); + }); + + it("should preserve bold formatting markers", () => { + const ast = converter.toAst("**bold text**"); + const result = converter.fromAst(ast); + expect(result).toContain("**bold text**"); + }); + + it("should preserve italic formatting markers", () => { + const ast = converter.toAst("_italic_"); + const result = converter.fromAst(ast); + expect(result).toMatch(ITALIC_MARKERS_RE); + }); + + it("should convert GFM tables to ASCII code blocks", () => { + const ast = converter.toAst( + "| Name | Age |\n|------|-----|\n| Alice | 30 |" + ); + const result = converter.fromAst(ast); + expect(result).toContain("```"); + expect(result).toContain("Name"); + expect(result).toContain("Age"); + expect(result).toContain("Alice"); + expect(result).toContain("30"); + // The whole table is fenced as a code block. + expect(result.startsWith("```")).toBe(true); + expect(result.endsWith("```")).toBe(true); + }); + + it("should roundtrip a complex message", () => { + const input = "Hello **world**! Here is a list:\n\n- item 1\n- item 2"; + const ast = converter.toAst(input); + const result = converter.fromAst(ast); + expect(result).toContain("Hello"); + expect(result).toContain("world"); + expect(result).toContain("item 1"); + expect(result).toContain("item 2"); + }); + }); + + describe("renderPostable", () => { + it("should render a string message", () => { + expect(converter.renderPostable("Hello")).toBe("Hello"); + }); + + it("should render a raw message", () => { + expect(converter.renderPostable({ raw: "raw text" })).toBe("raw text"); + }); + + it("should render a markdown message", () => { + const result = converter.renderPostable({ markdown: "**bold**" }); + expect(result).toContain("bold"); + }); + }); +}); diff --git a/packages/adapter-xchat/src/markdown.ts b/packages/adapter-xchat/src/markdown.ts new file mode 100644 index 000000000..a5f777676 --- /dev/null +++ b/packages/adapter-xchat/src/markdown.ts @@ -0,0 +1,55 @@ +/** + * XChat-specific format conversion using AST-based parsing. + * + * XChat clients render messages as plain text — there is no markdown + * rendering. The converter passes markdown through unchanged, so markers + * like `**bold**` appear literally but stay readable as plain-text + * conventions; URLs and @mentions are made tappable separately via + * entity spans. + * + * Tables are the one exception: raw GFM table syntax is unreadable as + * plain text, so they are converted to ASCII art in code blocks. + */ + +import { + BaseFormatConverter, + type Content, + isTableNode, + parseMarkdown, + type Root, + stringifyMarkdown, + tableToAscii, + walkAst, +} from "chat"; + +export class XChatFormatConverter extends BaseFormatConverter { + /** + * Convert an AST to the text sent in an XChat message. + * + * Markdown is stringified as-is and shows up literally in clients, with + * one exception: tables are converted to ASCII art in code blocks since + * raw GFM table syntax is unreadable as plain text. + */ + fromAst(ast: Root): string { + const transformed = walkAst(structuredClone(ast), (node: Content) => { + // Tables -> code blocks (ASCII art) + if (isTableNode(node)) { + return { + type: "code" as const, + value: tableToAscii(node), + lang: undefined, + } as Content; + } + return node; + }); + + return stringifyMarkdown(transformed).trim(); + } + + /** + * Parse standard markdown into an AST. + */ + toAst(markdown: string): Root { + return parseMarkdown(markdown); + } +} diff --git a/packages/adapter-xchat/src/test-utils.ts b/packages/adapter-xchat/src/test-utils.ts new file mode 100644 index 000000000..328c39802 --- /dev/null +++ b/packages/adapter-xchat/src/test-utils.ts @@ -0,0 +1,257 @@ +/** + * Test utilities for the XChat adapter. + * + * Provides helpers for creating test adapters with real chat-xdk WASM crypto + * using the deterministic sdk_vectors.json fixture keys. + * + * Fixture crypto loads the wasm `Chat` directly from the package's `pkg/` + * build, because the public JS API exposes only the Juicebox-backed + * `createChat()` and cannot import raw fixture keys. + */ + +import { readFileSync } from "node:fs"; +import { createRequire } from "node:module"; +import { dirname, join, resolve } from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; +import type { ChatWithJuicebox } from "@xdevplatform/chat-xdk"; +import type { ChatInstance, Logger } from "chat"; +import { vi } from "vitest"; +import { XChatAdapter } from "./index"; +import type { XChatAdapterConfig } from "./types"; + +// ── Fixture data ──────────────────────────────────────────────────── + +const VECTORS_PATH = resolve( + fileURLToPath(import.meta.url), + "../../tests/fixtures/sdk_vectors.json" +); + +export interface SdkVectors { + conversation_key_b64: string; + event_conversation_id: string; + event_conversation_key_version: string; + event_message_b64: string; + event_message_text: string; + event_sender_id: string; + event_signing_key_version: string; + identity_private_b64: string; + identity_public_b64: string; + identity_public_key_signature_b64: string; + message_utf8: string; + plaintext_b64: string; + private_keys_concat_b64: string; + signature_b64: string; + signing_private_b64: string; + signing_public_b64: string; +} + +export function loadVectors(): SdkVectors { + return JSON.parse(readFileSync(VECTORS_PATH, "utf-8")); +} + +function b64ToBytes(b64: string): Uint8Array { + return Uint8Array.from(Buffer.from(b64, "base64")); +} + +export { b64ToBytes }; + +// ── Test constants ────────────────────────────────────────────────── + +export const TEST_USER_ID = "12345"; +export const TEST_OTHER_USER_ID = "67890"; +export const TEST_CONVERSATION_ID = `${TEST_USER_ID}-${TEST_OTHER_USER_ID}`; +export const TEST_CANONICAL_CONVERSATION_ID = `${TEST_USER_ID}:${TEST_OTHER_USER_ID}`; +export const TEST_THREAD_ID = `xchat:${TEST_CONVERSATION_ID}`; +const TEST_SIGNING_KEY_VERSION = "1"; +export const TEST_PIN = "2580"; + +// ── Mock logger ───────────────────────────────────────────────────── + +export const mockLogger: Logger = { + debug: () => {}, + info: () => {}, + warn: () => {}, + error: () => {}, + child: () => mockLogger, +}; + +// ── Mock ChatInstance ─────────────────────────────────────────────── + +export function createMockChatInstance(): Record { + return { + processMessage: vi.fn(), + processReaction: vi.fn(), + processAction: vi.fn(), + processModalSubmit: vi.fn(), + processModalClose: vi.fn(), + processSlashCommand: vi.fn(), + processMemberJoinedChannel: vi.fn(), + processAssistantThreadStarted: vi.fn(), + processAssistantContextChanged: vi.fn(), + processAppHomeOpened: vi.fn(), + getState: vi.fn(), + getUserName: () => "test-bot", + getLogger: () => mockLogger, + handleIncomingMessage: vi.fn(), + }; +} + +// ── Wasm Chat loaded from pkg/ ────────────────────────────────────── + +interface WasmChat { + decryptConversationKey: (...args: unknown[]) => unknown; + decryptEvent: (...args: unknown[]) => unknown; + decryptEvents: (...args: unknown[]) => unknown; + encryptMessage(params: unknown): { + messageId: string; + encryptedContent: string; + encodedEventSignature: string; + }; + extractConversationKeys: (...args: unknown[]) => unknown; + getPublicKeys(): unknown; + importKeys(keys: Uint8Array, version?: string): void; + prepareConversationKeyChange(params: unknown): { + participantKeys: Array<{ userId: string; encryptedKey: string }>; + }; + setIdentity(userId: string, signingKeyVersion: string): void; + setRejectUnverified(reject: boolean): void; +} + +async function loadWasmChat(): Promise { + if (typeof globalThis.crypto === "undefined") { + const { webcrypto } = await import("node:crypto"); + (globalThis as { crypto: Crypto }).crypto = webcrypto as Crypto; + } + + const require = createRequire(import.meta.url); + const entry = require.resolve("@xdevplatform/chat-xdk"); + const pkgDir = dirname(entry); + const wasmMod = await import( + pathToFileURL(join(pkgDir, "pkg/chat_xdk_wasm.js")).href + ); + const init = wasmMod.default || wasmMod.init || wasmMod.__wbindgen_init; + if (typeof init !== "function") { + throw new Error("WASM init function not found in chat_xdk_wasm"); + } + const wasmBytes = readFileSync(join(pkgDir, "pkg/chat_xdk_wasm_bg.wasm")); + await init({ module_or_path: wasmBytes }); + return new wasmMod.Chat() as WasmChat; +} + +/** + * Real wasm crypto engine loaded with fixture keys (not via public createChat). + */ +export async function createTestCryptoEngine(): Promise { + const vectors = loadVectors(); + const chat = await loadWasmChat(); + // The version-aware import records the registered key version; the session + // identity supplies senderId + signingKeyVersion defaults for encryption. + chat.importKeys( + b64ToBytes(vectors.private_keys_concat_b64), + TEST_SIGNING_KEY_VERSION + ); + chat.setIdentity(TEST_USER_ID, TEST_SIGNING_KEY_VERSION); + return chat; +} + +/** + * Wrap fixture wasm Chat as a ChatWithJuicebox stand-in for mocked createChat. + * unlock/setup are no-ops — keys are already imported. + */ +function asJuiceboxStub(engine: WasmChat): ChatWithJuicebox { + return new Proxy(engine as object, { + get(target, prop, receiver) { + if (prop === "unlock" || prop === "setup") { + return async () => engine.getPublicKeys(); + } + if ( + prop === "delete" || + prop === "changePin" || + prop === "updateConfig" || + prop === "free" + ) { + return async () => undefined; + } + return Reflect.get(target, prop, receiver); + }, + }) as ChatWithJuicebox; +} + +// ── Create adapter with real crypto (Juicebox path, mocked createChat) ─ + +/** + * Stubbed XDK client injected into test adapters. Methods are plain vitest + * mocks and tests freely reassign or add entries, so the groups are typed as + * permissive records rather than mirroring the real client surface. + */ +export interface MockXdkClient { + chat: Record>; + users: Record>; +} + +/** + * Create and initialize an XChatAdapter with real wasm crypto. + * + * Wires a Juicebox-shaped stub (fixture keys already imported) and an XDK + * client without calling createChat — unit tests stay offline and avoid + * spying on ESM exports. + */ +export async function createInitializedTestAdapter( + configOverrides: Partial = {} +): Promise<{ + adapter: XChatAdapter; + mockChat: ReturnType; + /** Access the internal XDK client for mocking API calls */ + getXdkClient: () => MockXdkClient; + restore: () => void; +}> { + const mockChat = createMockChatInstance(); + const engine = await createTestCryptoEngine(); + + const adapter = new XChatAdapter({ + accessToken: "test-token", + userId: TEST_USER_ID, + pin: TEST_PIN, + userName: "test-bot", + logger: mockLogger, + ...configOverrides, + }); + + const internals = adapter as unknown as { + chat: ChatInstance | null; + xdkClient: unknown; + cryptoEngine: ChatWithJuicebox | null; + _cryptoStatus: string; + signingKeyVersion: string | null; + }; + + internals.chat = mockChat as unknown as ChatInstance; + const xdkClient: MockXdkClient = { + users: { + getPublicKey: vi.fn().mockResolvedValue({ data: [] }), + }, + chat: { + addConversationKeys: vi.fn(), + deleteMessages: vi.fn(), + getConversationEvents: vi.fn(), + markConversationRead: vi.fn().mockResolvedValue({ data: {} }), + sendMessage: vi.fn(), + sendTypingIndicator: vi.fn(), + mediaDownload: vi.fn(), + mediaUploadInitialize: vi.fn(), + mediaUploadAppend: vi.fn(), + mediaUploadFinalize: vi.fn(), + }, + }; + internals.xdkClient = xdkClient; + internals.cryptoEngine = asJuiceboxStub(engine); + internals.signingKeyVersion = TEST_SIGNING_KEY_VERSION; + internals._cryptoStatus = "ready"; + + return { + adapter, + mockChat, + getXdkClient: () => xdkClient, + restore: () => undefined, + }; +} diff --git a/packages/adapter-xchat/src/types.ts b/packages/adapter-xchat/src/types.ts new file mode 100644 index 000000000..d15aa6870 --- /dev/null +++ b/packages/adapter-xchat/src/types.ts @@ -0,0 +1,256 @@ +/** + * Type definitions for the XChat adapter. + * + * XChat is X's encrypted messaging system. Messages are encrypted + * client-side with chat-xdk (WASM) and sent/received via the X API (/2/chat/*). + * + * @see https://docs.x.com/x-api/direct-messages/introduction + */ + +import type { Logger } from "chat"; + +// ============================================================================= +// Configuration +// ============================================================================= + +/** + * XChat adapter configuration. + * + * Only `accessToken` and `userId` are required. The adapter fetches + * `signingKeyVersion` and Juicebox config automatically during `initialize()` + * by calling `users.getPublicKey(userId)`, then calls chat-xdk `createChat()`. + * + * Pass `pin` to auto-unlock after initialize, or call `adapter.unlock(pin)` later. + */ +export interface XChatAdapterConfig { + /** OAuth2 access token for X API calls */ + accessToken: string; + /** Base URL for X API requests. Defaults to https://api.x.com. */ + apiBaseUrl?: string; + /** Custom HTTP headers to send with every X API request */ + apiHeaders?: Record; + /** + * App consumer secret (API secret key) for webhook signature verification. + * When set, incoming POST webhooks are verified via HMAC-SHA256. + */ + consumerSecret?: string; + /** + * Minimum age (ms) a freshly posted message must reach before its first + * edit is sent, giving receiving clients time to store the original an + * edit targets. Defaults to 5000; 0 disables the wait. + */ + editSafetyDelayMs?: number; + /** Logger instance for error reporting */ + logger: Logger; + /** + * Juicebox PIN. When set, initialize() calls unlock(pin) automatically + * after createChat(). + */ + pin?: string; + /** + * When true (default), a read receipt is sent for each inbound message + * before it is handed to handlers. Set to false to disable. + */ + sendReadReceipts?: boolean; + /** + * Override for the signing key version. When omitted, the adapter + * fetches it automatically from GET /2/users/{id}/public_keys during + * initialize(). Only set this if you know what you're doing. + */ + signingKeyVersion?: string; + /** The authenticated user's numeric X user ID */ + userId: string; + /** + * Bot @handle for mention detection. When omitted, initialize() loads it + * from GET /2/users/me. + */ + userName?: string; + /** + * Whether incoming messages must have a verifiable signature. + * + * Defaults to `true` (chat-xdk's secure default): a message is only + * delivered when its signature verifies against a binding-checked signing + * key for the sender. Messages that can't be verified are dropped. + * + * Set to `false` to opt out of signature verification — messages decrypt + * even when no valid signing key is available. Use only when the binding + * verification can't be satisfied (e.g. participants registered with an + * incompatible key format) and you accept the reduced security. + */ + verifySignatures?: boolean; + /** + * Message posted when the bot is added to a group + * (`chat.conversation_join`). Set to `false` to disable. When omitted, a + * default that explains @mention-to-reply is used. + */ + welcomeMessage?: string | false; +} + +/** + * Encryption readiness states for the adapter. + * + * - `uninitialized`: initialize() not yet called + * - `initializing`: initialize() in progress (fetching keys, loading WASM) + * - `locked`: WASM loaded, Juicebox config fetched, waiting for unlock(pin) + * - `ready`: Keys loaded, adapter can encrypt/decrypt + * - `error`: Initialization or unlock failed + */ +export type XChatCryptoStatus = + | "uninitialized" + | "initializing" + | "locked" + | "ready" + | "error"; + +// ============================================================================= +// Thread ID +// ============================================================================= + +/** + * Decoded thread ID for XChat. + * + * XChat conversations can be 1:1 (userId1-userId2) or groups (gXXXXX). + * + * Format: xchat:{conversationId} + */ +export interface XChatThreadId { + /** The raw conversation ID (e.g. "12345-67890" or "gABCDE") */ + conversationId: string; +} + +// ============================================================================= +// XAA Event Payloads (X Activity API) +// ============================================================================= + +/** + * XAA chat event — the JSON payload delivered via webhook or activity stream. + * + * This is the same shape whether delivered via: + * - X Activity API webhook POST + * - X Activity API persistent HTTP stream + */ +export interface XChatEvent { + /** The conversation this event belongs to (e.g. "12345:67890" or "gABCDE") */ + conversationId: string; + /** Base64 key change event for extracting/rotating conversation keys */ + conversationKeyChangeEvent?: string; + /** Version of the conversation encryption key used */ + conversationKeyVersion?: string; + /** Conversation token for send continuity */ + conversationToken?: string; + /** Creation time as ISO 8601 (API conversation events) */ + createdAt?: string; + /** Timestamp in milliseconds (as string) */ + createdAtMsec?: string; + /** The base64-encoded encrypted event (the primary payload, decrypted via chat-xdk) */ + encodedEvent: string; + /** Base64 ECIES-encrypted conversation key for the bot user */ + encryptedConversationKey?: string; + /** Unique event ID (for dedup) */ + id: string; + /** Whether the message is from a trusted sender */ + isTrusted?: boolean; + /** Signature envelope */ + messageEventSignature?: { + publicKeyVersion?: string; + signature?: string; + signatureVersion?: string; + signingPublicKey?: string; + }; + /** Previous event ID in the conversation */ + previousId?: string; + /** Sender's numeric X user ID */ + senderId: string; + /** Backend sequence id (used for read receipts when present) */ + sequenceId?: string; +} + +/** + * XAA chat event types. + */ +export type XChatEventType = + | "chat.received" + | "chat.sent" + | "chat.conversation_join"; + +// ============================================================================= +// Raw Message Type +// ============================================================================= + +/** + * Platform-specific raw message type for XChat. + * + * Contains both the encrypted event envelope and the decrypted content. + */ +export interface XChatRawMessage { + /** The decrypted event from chat-xdk (null if decryption failed) */ + decrypted: XChatDecryptedEvent | null; + /** The raw XAA event or API response event */ + event: XChatEvent; +} + +/** + * A decrypted event as returned by chat-xdk. Declared as a plain local + * interface (instead of importing chat-xdk's types) so consumers don't need + * chat-xdk as a type dependency. + */ +export interface XChatDecryptedEvent { + attachments?: XChatAttachmentEntry[]; + content?: { + text?: string; + contentType?: string; + emoji?: string; + targetMessageId?: string; + entities?: unknown[]; + attachments?: XChatAttachmentEntry[]; + replyingToPreview?: unknown; + [key: string]: unknown; + }; + conversationId?: string; + createdAtMsec?: number; + id?: string; + keyVersion?: string; + mediaHashes?: Array<{ source?: string; mediaHashKey?: string }>; + participantKeys?: Array<{ + userId: string; + encryptedKey: string; + publicKeyVersion: string; + }>; + replyPreviewValidation?: "valid" | "invalid"; + senderId?: string; + sequenceId?: string; + ttlMsec?: number; + type: string; + verified?: boolean; + [key: string]: unknown; +} + +/** + * An attachment entry on a decrypted event. Tolerant of both the flattened + * camelCase shape produced by the chat-xdk JS binding and the nested + * snake_case `{ media: {...} }` shape seen on some wire payloads. + */ +export interface XChatAttachmentEntry { + attachmentType?: string; + dimensions?: { width?: number; height?: number }; + durationMillis?: number; + filename?: string; + filesizeBytes?: number; + media?: { + media_hash_key?: string; + mediaHashKey?: string; + dimensions?: { width?: number; height?: number }; + filesize_bytes?: number; + filesizeBytes?: number; + filename?: string; + media_type?: string; + mediaType?: string; + type?: string; + duration_millis?: number; + durationMillis?: number; + [key: string]: unknown; + }; + mediaHashKey?: string; + mediaType?: string; + [key: string]: unknown; +} diff --git a/packages/adapter-xchat/tests/fixtures/sdk_vectors.json b/packages/adapter-xchat/tests/fixtures/sdk_vectors.json new file mode 100644 index 000000000..2fb0827cd --- /dev/null +++ b/packages/adapter-xchat/tests/fixtures/sdk_vectors.json @@ -0,0 +1,26 @@ +{ + "conversation_key_b64": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM=", + "event_conversation_id": "1111:2222", + "event_conversation_key_version": "1001", + "event_failure_b64": "CwABAAAAATELAAIAAAANZmFpbHVyZS1tc2ctMQsAAwAAAAQxMTExCwAEAAAACTExMTE6MjIyMgsABgAAAA0xNzAwMDAwMDAwMDAwDAAHDAAFCAABAAAADAgAAgAAAAMAAAA=", + "event_garbage_b64": "!!!not-an-event!!!", + "event_key_change_b64": "CwABAAAAATELAAIAAAAIa2MtbXNnLTELAAMAAAAEMTExMQsABAAAAAkxMTExOjIyMjILAAYAAAANMTcwMDAwMDAwMDAwMAwABwwAAwsAAQAAAAQxMDAxDwACDAAAAAELAAEAAAAEMTExMQsAAgAAAJhCR0hGdmgzaUw3VitCbGZJRnpFM0E2VDBoRjNCbVM1RHhJaWp5R3Z0NEVVbVdKK2FFdWQweGZXSHNXcFJyOVBwU3hZSS9wNHNScGlkS3pkbXFXUmpZOFlVK3pQMFlIeFZidldMNWQ4MERtbEN2TmlBUFV1Ryszbldsdmx2Z3k2VFN5UnlaakZHb3JxUzArbitGVTd6cEU0PQsAAwAAAAExAAAADAAJCwABAAAAVmVpSkx2V1V0cDY1bkxVdWVEaUJDc01FSjJmQWY1c0d4T25aQ050ZHVEaUQxWWZ1UlQzSzhTTjFBcC9yN05YamZ6cEVWaXJCaTc5Q1N2WnE5a3dKaW1nCwACAAAAATELAAMAAAABNwAA", + "event_message_b64": "CwABAAAAATELAAIAAAAkMmMyYTFkMzItOTg4Yi00YjBlLTllNjMtYzNiYWFiMzAwM2ZkCwADAAAABDExMTELAAQAAAAJMTExMToyMjIyCwAGAAAADTE3MDAwMDAwMDAwMDAMAAcMAAELAGQAAABNyju49fSvP23md4h8MxYDM7/yP5czAJioJV+XI7e3bBM4gzkCp4+5iBBX4Jyee/0tULcB8Tkkl6qNbcRN9lWROcUxPyPGVVRp7WSqgVoLAGUAAAAEMTAwMQIAZgEAAAwACQsAAQAAAFZ4Rkk3NnA2VzZLY09jN0JGL0NLSjg4Sk5ZYnRvSitaS1VqdFFsTTNzYTRFdUdJZ1F2eHlLSG1tUkxqa0tlRUdMZkNEbU1EZDZTdlFMSTdiZVg0SFhZQQsAAgAAAAExCwADAAAAATcAAA==", + "event_message_text": "fixture event message", + "event_recipient_key_version": "1", + "event_reply_forged_b64": "CwABAAAAATELAAIAAAAkZGU3YTJiNzgtMTI4Ny00ZGUxLTliYzktNDQ3Mjc4YmYxNDUyCwADAAAABDExMTELAAQAAAAJMTExMToyMjIyCwAGAAAADTE3MDAwMDAwMDAwMDAMAAcMAAELAGQAAAHr2HANJYJJjNJD9rWtkjW68feM+I3vu++fxA1gEMBK2UjdNkd+cTKJ7AmPxxGOPq44F0ssa6ckES6aOLxF4WdMk1oY/hq27JPgyn88b9GVaevklTomM5Wb2WN8vS0CywxWXkY/iy9poJ+GWTGK34KfPen4osu57OO1lde151aOnNcDMj8WUVvR8aQujhYffmRiKzemwv94jdqH8v2oBOLgPEa1Kpt4qCASmDWZKc6nG8raBQxt8vRgl5mabT6tjEqWwjxCb+Jw82MOAR7cA6hM5Xf432cR1oU7DtYj89sOxbGaRVbHhzS1RgS3JrcKHCAvcn/0DHE06WIdL5ZMOPd3f3NMdzix7cZBidVf3Y98ceTzRAkPv+Py5QxbP7ljD0UhShOWfO6sWg69pwFYyl2iXwN87Ymzt+3beiECXFtZzArS3QiOp6ZzFXI4nGfkRP/xvnVQqBvjmbJMgyoPq8d+NMueC50+J1MKaaUZdbM7kWl9ey618OCodX8rdvzREDzWaNbT5r2ZzT+QUC7/UWhJrWR3UJ0cFF7n/Q2ZhF6QjApc1b4zNdt2QkAjXjj0VjTaZm33zcD4nItZHGu/GFesGbPv4QjWGNGMyHA6buZs4uLYePKoIL+junKoRK6rVycn8d6IrxOmzAbQQDYLAGUAAAAEMTAwMQIAZgEAAAwACQsAAQAAAFYrWHRQUVlIOUttZWNvWnN4Vk9ORlplcVRFb2Y3aEwwUDQ0TkxhYUlHN29ORlBKUmN6V2FkT2FWSnZyaFJyYWRZeE5NS0tCUjBVc0sxb0xOWVpJT2M1ZwsAAgAAAAExCwADAAAAATcAAA==", + "event_reply_forged_preview_text": "forged preview text", + "event_reply_text": "fixture reply message", + "event_reply_valid_b64": "CwABAAAAATELAAIAAAAkYzYzYjRmNTgtODU2Yi00YjQ5LTlmNGQtYTVjM2Y3MjM3ZjVmCwADAAAABDExMTELAAQAAAAJMTExMToyMjIyCwAGAAAADTE3MDAwMDAwMDAwMDAMAAcMAAELAGQAAAHtxf5QzAnBtH+rWXANpWMB3o5rf8xexfQC0/3pc/x/AaiqUpquGT+Tl1nDewt2x8BnIHra9V3//pMw1DNZp6X+d0bpJWWwACioojUy7xBmWsHquPCtOyUY40qKBNVtRPdL4LIOQPB/3TFNwqIE1F0WCs6M95T+U60d4/dp0X+OS1drQYQvzeQvOZ18YESWM0NE6L/yx+ugxttHcdFatZkPqAyilu2HYuv8OL2LvV4qWVG6DDg2Ixq/szkbl4Jfu61k613E3pj88avVyyDnCbavOT9T9Y46pznk3heuUJX9nOi1k2Kn5cx2l4SGTMglgILB70sc3qPATyHzflnM9ogqf9y70/N8EUT4FabppDeF8ghpqZs62weEAAjVq70+pFsj8imyYe91jIQiDZtZ8baPMa/O3v7U6soe5S7jbMHUzeU1WqR+Ad2QUT7X9DhSV5FrOaEEq21pDtCM7Ffh0I7VbYZRnmEumHBiLSgvWjqLKomxRnOXanSSSy0YgZbB2kPyrjC7aAnkbgiAZF5UzjO2T2iT+H2PXb821+Nxwf6kpbnZd6eCUSAPt3/s45AGGNol/NaXi446B31Ld6J8BTm5goeMMzPSzTUmEHVWmxF2R1SCYk5ulTqk5B0yJpxoLfKUiHywGfPb6KxNP9LO9wsAZQAAAAQxMDAxAgBmAQAADAAJCwABAAAAVkhGNGlkNDVrWXI1T1R6MUU3b3lxd1JCdnhsUGIyM2pGd3FDbElYS0ZZS0xjdHRhNUlFd0xvdlNOR2ZLdzdVTXJTRDRjWkFOZmJoRzdyQ3lJWk9CbklnCwACAAAAATELAAMAAAABNwAA", + "event_sender_id": "1111", + "event_signing_key_version": "1", + "identity_private_b64": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE=", + "identity_public_b64": "BGsX0fLhLEJH+Lzm5WOkQPJ3A32BLeszoPShOUXYmMKWT+NC4v4af5uO5+tKfA+eFivOM1drMV7Oy7ZAaDe/UfU=", + "identity_public_key_signature_b64": "lwqF3bFJN47NLoYzSyTTCaA+eGe3g2rbDzWc120eJYV3ClHqD1NI79WKL60ciN0fBjhmuAnIq/Beq/GhPUu52A==", + "message_utf8": "chat-xdk test vector message", + "plaintext_b64": "SGVsbG8sIFhDSEFUIQ==", + "private_keys_concat_b64": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg==", + "signature_b64": "y2eG2ncBrqNtyxmdkCDuMhbNvZEKrQ1d7kyLHbNvHRLtdgZgMLiixNKFdKfLzbcwMLAgB/uDAjFABULfN3NLYg==", + "signing_private_b64": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI=", + "signing_public_b64": "BHzyexiNA09+ilI4AwS1GsPAiWnid/IbNaYLSPxHZpl4B3dVENuO0EApPZrGn3Qw27p9reY86YIpngS3nSJ4c9E=" +} diff --git a/packages/adapter-xchat/tsconfig.json b/packages/adapter-xchat/tsconfig.json new file mode 100644 index 000000000..8768f5bdf --- /dev/null +++ b/packages/adapter-xchat/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "outDir": "./dist", + "rootDir": "./src", + "strictNullChecks": true + }, + "include": ["src/**/*"], + "exclude": ["node_modules", "dist", "**/*.test.ts"] +} diff --git a/packages/adapter-xchat/tsup.config.ts b/packages/adapter-xchat/tsup.config.ts new file mode 100644 index 000000000..faf3167a2 --- /dev/null +++ b/packages/adapter-xchat/tsup.config.ts @@ -0,0 +1,9 @@ +import { defineConfig } from "tsup"; + +export default defineConfig({ + entry: ["src/index.ts"], + format: ["esm"], + dts: true, + clean: true, + sourcemap: true, +}); diff --git a/packages/adapter-xchat/vitest.config.ts b/packages/adapter-xchat/vitest.config.ts new file mode 100644 index 000000000..5b01228bc --- /dev/null +++ b/packages/adapter-xchat/vitest.config.ts @@ -0,0 +1,14 @@ +import { defineConfig } from "vitest/config"; + +export default defineConfig({ + test: { + globals: true, + environment: "node", + coverage: { + provider: "v8", + reporter: ["text", "json-summary"], + include: ["src/**/*.ts"], + exclude: ["src/**/*.test.ts"], + }, + }, +}); diff --git a/packages/integration-tests/src/documentation-test-utils.ts b/packages/integration-tests/src/documentation-test-utils.ts index 8d40884af..893714af5 100644 --- a/packages/integration-tests/src/documentation-test-utils.ts +++ b/packages/integration-tests/src/documentation-test-utils.ts @@ -118,6 +118,7 @@ export const VALID_PACKAGE_README_IMPORTS = [ "@chat-adapter/twilio", "@chat-adapter/messenger", "@chat-adapter/x", + "@chat-adapter/xchat", "@chat-adapter/web", "@chat-adapter/web/react", "@chat-adapter/state-redis", @@ -172,6 +173,7 @@ export const VALID_DOC_PACKAGES = [ "@chat-adapter/twilio/webhook", "@chat-adapter/messenger", "@chat-adapter/x", + "@chat-adapter/xchat", "@chat-adapter/web", "@chat-adapter/web/react", "@chat-adapter/state-redis", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d6163f2a9..9501b54f0 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -720,6 +720,37 @@ importers: specifier: ^4.0.18 version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@25.9.2)(@vitest/coverage-v8@4.1.8)(vite@7.3.6(@types/node@25.9.2)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.48.0)(tsx@4.22.3)(yaml@2.9.0)) + packages/adapter-xchat: + dependencies: + '@chat-adapter/shared': + specifier: workspace:* + version: link:../adapter-shared + '@xdevplatform/chat-xdk': + specifier: ^0.4.3 + version: 0.4.3(juicebox-sdk@0.3.6) + '@xdevplatform/xdk': + specifier: ^0.6.6 + version: 0.6.6(node-fetch@3.3.2) + chat: + specifier: workspace:* + version: link:../chat + juicebox-sdk: + specifier: ^0.3.6 + version: 0.3.6 + devDependencies: + '@types/node': + specifier: ^25.3.2 + version: 25.9.2 + tsup: + specifier: ^8.3.5 + version: 8.5.1(@swc/core@1.15.3)(jiti@2.7.0)(postcss@8.5.16)(tsx@4.22.3)(typescript@5.9.3)(yaml@2.9.0) + typescript: + specifier: ^5.7.2 + version: 5.9.3 + vitest: + specifier: ^4.0.18 + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@25.9.2)(@vitest/coverage-v8@4.1.8)(vite@7.3.6(@types/node@25.9.2)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.48.0)(tsx@4.22.3)(yaml@2.9.0)) + packages/chat: dependencies: '@workflow/serde': @@ -6388,6 +6419,24 @@ packages: '@workflow/world@5.0.0-beta.21': resolution: {integrity: sha512-XAOtSr7CGL/81EqEvUuDSWzil12sRJwQfU7ymVZlui33BKK8vbtgqzuY5vI6/OWt6NiAqPMeJVeahD9oMkii/A==} + '@xdevplatform/chat-xdk@0.4.3': + resolution: {integrity: sha512-OoR2RRJlCfrOp/iOrLotcQwgxVuahc9lQIFLx5Odgq3EwdNik7KvNeDl5sE05C2k/5FAwM/iYxOSMJEsEelasQ==} + engines: {node: '>=18'} + peerDependencies: + juicebox-sdk: ^0.3.0 + peerDependenciesMeta: + juicebox-sdk: + optional: true + + '@xdevplatform/xdk@0.6.6': + resolution: {integrity: sha512-ced4iHSz08eQe1L0N3UWVvJyfGnmGU0CRjecoXpr27dVIyQvc637Pxm3cdP4G85PwhHn5IGVJ1DJF2YD9zWfAg==} + engines: {node: '>=16.14'} + peerDependencies: + node-fetch: ^3.3.0 + peerDependenciesMeta: + node-fetch: + optional: true + '@xhmikosr/archive-type@8.1.0': resolution: {integrity: sha512-EXOjEbnZFE5c/nFMf4FOrEURVanzHpnkPYmnmr78u02/8hAhE0FMq8p9TK1IM0/bFr5VcyBUY0gfLm8f7dKy+Q==} engines: {node: '>=20'} @@ -8605,6 +8654,9 @@ packages: resolution: {integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==} engines: {node: '>=12', npm: '>=6'} + juicebox-sdk@0.3.6: + resolution: {integrity: sha512-j4B9ExvbY5xJRNc5MrddVJOpglpdGzoWbHSqeu58GvUkg51nl/5QMDU+s00ZHJGuXuJzjHZ6b2IK8CogEXg9Tg==} + jwa@2.0.1: resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==} @@ -17637,6 +17689,14 @@ snapshots: ulid: 3.0.2 zod: 4.3.6 + '@xdevplatform/chat-xdk@0.4.3(juicebox-sdk@0.3.6)': + optionalDependencies: + juicebox-sdk: 0.3.6 + + '@xdevplatform/xdk@0.6.6(node-fetch@3.3.2)': + optionalDependencies: + node-fetch: 3.3.2 + '@xhmikosr/archive-type@8.1.0': dependencies: file-type: 21.3.4 @@ -20189,6 +20249,8 @@ snapshots: ms: 2.1.3 semver: 7.8.5 + juicebox-sdk@0.3.6: {} + jwa@2.0.1: dependencies: buffer-equal-constant-time: 1.0.1 diff --git a/turbo.json b/turbo.json index 76208a030..91e6a1354 100644 --- a/turbo.json +++ b/turbo.json @@ -30,6 +30,13 @@ "X_USER_ACCESS_TOKEN", "X_USER_ID", "X_USERNAME", + "XCHAT_BOT_TOKEN", + "XCHAT_USER_ID", + "XCHAT_PIN", + "X_ACCESS_TOKEN", + "X_BOT_USERNAME", + "X_VERIFY_SIGNATURES", + "X_SIGNING_KEY_VERSION", "BOT_USERNAME", "REDIS_URL", "EDGE_CONFIG" From 8bd436f5d0cb172bf8c1f44da819b5ac7d1d9c7a Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 01:10:02 -0700 Subject: [PATCH 2/7] docs(xchat): add webhook route wiring to README usage --- packages/adapter-xchat/README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/packages/adapter-xchat/README.md b/packages/adapter-xchat/README.md index 0f44b7573..c63287786 100644 --- a/packages/adapter-xchat/README.md +++ b/packages/adapter-xchat/README.md @@ -55,6 +55,20 @@ bot.onNewMention(async (thread, message) => { }); ``` +Wire the webhook route (e.g. `app/api/webhooks/xchat/route.ts` in Next.js): + +```typescript +import { bot } from "@/lib/bot"; + +export async function GET(request: Request) { + return bot.webhooks.xchat(request); +} + +export async function POST(request: Request) { + return bot.webhooks.xchat(request); +} +``` + When using `createXChatAdapter()` without arguments, credentials are auto-detected from environment variables. The bot's @handle is resolved from `GET /2/users/me` at startup, so mention detection works without any hardcoding. ## X Chat setup From d2ade1b0006855cdca18ea2b2aa95f923404e41f Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 13:09:45 -0700 Subject: [PATCH 3/7] fix(xchat): address review feedback - Rename exported identifiers to Xchat casing (XchatAdapter, createXchatAdapter, XchatAdapterConfig, and secondary types) so the konsistent check passes; the factory now takes the exported XchatAdapterConfig like the other adapters - Normalize the conversation id to the dash-joined form on the media upload initialize/append/finalize bodies - Combine the two changesets into one --- .changeset/xchat-adapter.md | 16 ++ .changeset/xchat-inbound-features.md | 15 -- .changeset/xchat-sdk-integration.md | 9 - packages/adapter-xchat/README.md | 6 +- packages/adapter-xchat/src/cards.ts | 10 +- packages/adapter-xchat/src/index.test.ts | 82 ++++----- packages/adapter-xchat/src/index.ts | 174 +++++++++----------- packages/adapter-xchat/src/markdown.test.ts | 6 +- packages/adapter-xchat/src/markdown.ts | 2 +- packages/adapter-xchat/src/test-utils.ts | 12 +- packages/adapter-xchat/src/types.ts | 47 ++++-- 11 files changed, 181 insertions(+), 198 deletions(-) create mode 100644 .changeset/xchat-adapter.md delete mode 100644 .changeset/xchat-inbound-features.md delete mode 100644 .changeset/xchat-sdk-integration.md diff --git a/.changeset/xchat-adapter.md b/.changeset/xchat-adapter.md new file mode 100644 index 000000000..9ebc92506 --- /dev/null +++ b/.changeset/xchat-adapter.md @@ -0,0 +1,16 @@ +--- +"@chat-adapter/xchat": minor +"chat": patch +"create-chat-sdk": patch +--- + +New XChat adapter for X's encrypted messaging. All cryptography is handled inside the adapter via `@xdevplatform/chat-xdk` (wasm) and all REST goes through the typed `@xdevplatform/xdk` client. + +- Encrypted send/receive in DMs and groups (webhook push + polling), signature verification on by default; undecryptable or unverified events are dropped +- Mention detection from structured mention entities, swipe-replies to the bot, and a plain-text `@handle` fallback; group replies sent as quoted replies +- `openDM(userId)` starts (or reuses) an encrypted 1:1, running a full key exchange when needed so the bot can message first +- Media both ways: inbound attachments with lazy download+decrypt, outbound encrypted uploads +- Edit and delete of the bot's own messages; the first edit of a fresh message is age-gated by `editSafetyDelayMs` (default 5000ms) so receiving clients have stored the original +- Reactions in and out, read receipts (`sendReadReceipts`, default on), typing keep-alive, configurable group welcome message +- Cards degrade to text with tappable URL/mention entities plus a URL preview attachment +- Registered in the `chat/adapters` catalog and the `create-chat-sdk` CLI scaffold diff --git a/.changeset/xchat-inbound-features.md b/.changeset/xchat-inbound-features.md deleted file mode 100644 index 2bd5685db..000000000 --- a/.changeset/xchat-inbound-features.md +++ /dev/null @@ -1,15 +0,0 @@ ---- -"@chat-adapter/xchat": minor ---- - -XChat inbound handling and messaging features: - -- Entity-based mention detection (structured mention entities + swipe-reply-to-bot), with plain-text `@handle` fallback -- Group replies sent as quoted replies (`encryptReply`) referencing the triggering message; TTL propagated from the inbound message -- Outgoing rich-text entities (URLs, @mentions) and auto-attached x.com post cards -- Media: inbound attachments exposed with lazy download+decrypt; outbound files encrypted (secretstream) and uploaded via the 3-step media upload flow -- Reactions: inbound routed to `onReaction`, outbound `addReaction`/`removeReaction` implemented -- `chat.conversation_join`: conversation-key bootstrap plus configurable group welcome message -- Read receipts: a seen-until watermark is sent for each delivered inbound message before handlers run (`sendReadReceipts` config, default on), falling back to the latest conversation event when the message carries no sequence id -- Typing keep-alive loop while handlers run; session identity (`setIdentity`) after unlock -- Non-message decrypted events (edits, mark-read, etc.) no longer surface as empty messages diff --git a/.changeset/xchat-sdk-integration.md b/.changeset/xchat-sdk-integration.md deleted file mode 100644 index ffef00771..000000000 --- a/.changeset/xchat-sdk-integration.md +++ /dev/null @@ -1,9 +0,0 @@ ---- -"@chat-adapter/xchat": minor ---- - -XChat adapter on `@xdevplatform/chat-xdk` 0.4.3 and `@xdevplatform/xdk` 0.6.6: message ids are SDK-generated and signature-bound, the sender identity is established once per session, group quote-replies embed the raw signed original so recipients can validate the preview, replies whose preview fails that validation never count as a mention of the bot, and every REST call — including encrypted media download and upload — goes through the typed xdk client (requests target the production X API; pass `apiHeaders` to add custom headers). - -New capabilities: `openDM(userId)` starts (or reuses) an encrypted 1:1 conversation — it derives the pair conversation id, reuses a cached or history-recovered conversation key, and otherwise runs a full key exchange (`prepareConversationKeyChange` + key initialization) so the bot can message a user first. Cards are supported by degradation: since XChat has no interactive primitives, a card renders as plain text with tappable URL/mention entities, link buttons become `label: url` lines, and the card's primary link ships as a URL preview attachment with an optional encrypted banner image. - -`editMessage` and `deleteMessage` are now implemented. Edits are encrypted events targeting the original's sequence id (captured from the send echo, with a history-replay fallback) and sent through the regular message channel; fetched history renders an edit event as the edited message, since the backend stops serving superseded originals. Because receiving clients park an edit whose original has not arrived yet — leaving the message permanently invisible on that client — the first edit of a fresh message is age-gated by `editSafetyDelayMs` (default 5000ms, 0 disables). Deletes prepare a signed delete-for-all action locally (recipients verify it) and submit it to the chat delete endpoint; only the bot's own messages can be deleted. diff --git a/packages/adapter-xchat/README.md b/packages/adapter-xchat/README.md index c63287786..4961e66df 100644 --- a/packages/adapter-xchat/README.md +++ b/packages/adapter-xchat/README.md @@ -33,13 +33,13 @@ Visit the [adapters directory](https://chat-sdk.dev/adapters) to see other avail ```typescript import { Chat } from "chat"; -import { createXChatAdapter } from "@chat-adapter/xchat"; +import { createXchatAdapter } from "@chat-adapter/xchat"; import { createMemoryState } from "@chat-adapter/state-memory"; const bot = new Chat({ userName: "mybot", adapters: { - xchat: createXChatAdapter(), + xchat: createXchatAdapter(), }, state: createMemoryState(), }); @@ -69,7 +69,7 @@ export async function POST(request: Request) { } ``` -When using `createXChatAdapter()` without arguments, credentials are auto-detected from environment variables. The bot's @handle is resolved from `GET /2/users/me` at startup, so mention detection works without any hardcoding. +When using `createXchatAdapter()` without arguments, credentials are auto-detected from environment variables. The bot's @handle is resolved from `GET /2/users/me` at startup, so mention detection works without any hardcoding. ## X Chat setup diff --git a/packages/adapter-xchat/src/cards.ts b/packages/adapter-xchat/src/cards.ts index 6a9f54314..aea0b4d5f 100644 --- a/packages/adapter-xchat/src/cards.ts +++ b/packages/adapter-xchat/src/cards.ts @@ -17,7 +17,7 @@ import { cardToFallbackText } from "@chat-adapter/shared"; import type { CardChild, CardElement } from "chat"; /** A URL preview card derived from a CardElement. */ -export interface XChatUrlCardSpec { +export interface XchatUrlCardSpec { /** Title shown on the preview card. */ displayTitle?: string; /** Image to encrypt and attach as the card banner. */ @@ -25,10 +25,10 @@ export interface XChatUrlCardSpec { url: string; } -export interface XChatCardResult { +export interface XchatCardResult { text: string; /** The card's primary link, when it has one. */ - urlCard?: XChatUrlCardSpec; + urlCard?: XchatUrlCardSpec; } interface CollectedLink { @@ -77,7 +77,7 @@ function firstImageUrl(card: CardElement): string | undefined { * `label: url` lines so URL entities make them tappable) and the primary * link as a URL preview card spec. */ -export function cardToXChat(card: CardElement): XChatCardResult { +export function cardToXChat(card: CardElement): XchatCardResult { const links: CollectedLink[] = []; collectLinks(card.children, links); @@ -122,7 +122,7 @@ export function cardToXChat(card: CardElement): XChatCardResult { const fullText = [text, ...linkLines].filter(Boolean).join("\n"); const primary = links[0]; - const urlCard: XChatUrlCardSpec | undefined = primary + const urlCard: XchatUrlCardSpec | undefined = primary ? { url: primary.url, displayTitle: card.title ?? primary.label, diff --git a/packages/adapter-xchat/src/index.test.ts b/packages/adapter-xchat/src/index.test.ts index 9cefb151c..a2d28abbe 100644 --- a/packages/adapter-xchat/src/index.test.ts +++ b/packages/adapter-xchat/src/index.test.ts @@ -57,7 +57,7 @@ import { extractMediaEntries, extractPostAttachments, mentionHandlesFromEntities, - XChatAdapter, + XchatAdapter, } from "./index"; import { b64ToBytes, @@ -74,7 +74,7 @@ import { TEST_THREAD_ID, TEST_USER_ID, } from "./test-utils"; -import type { XChatRawMessage } from "./types"; +import type { XchatRawMessage } from "./types"; // ── Error-message patterns asserted in tests ──────────────────────── const MISSING_ACCESS_TOKEN_RE = /accessToken|botToken/i; @@ -88,11 +88,11 @@ const NO_JUICEBOX_CONFIG_RE = /no Juicebox config/; const HTTP_404_RE = /HTTP 404/; /** - * Create a minimal XChatAdapter for testing. + * Create a minimal XchatAdapter for testing. * Crypto and API calls are not initialized — only thread ID and parsing methods work. */ -function createTestAdapter(): XChatAdapter { - return new XChatAdapter({ +function createTestAdapter(): XchatAdapter { + return new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, userName: "test-bot", @@ -200,7 +200,7 @@ describe("channelIdFromThreadId", () => { describe("parseMessage", () => { it("should parse a decrypted text message", () => { const adapter = createTestAdapter(); - const raw: XChatRawMessage = { + const raw: XchatRawMessage = { event: { id: "msg-1", conversationId: "12345-67890", @@ -229,7 +229,7 @@ describe("parseMessage", () => { it("should handle messages with no decrypted content", () => { const adapter = createTestAdapter(); - const raw: XChatRawMessage = { + const raw: XchatRawMessage = { event: { id: "msg-2", conversationId: "12345-67890", @@ -246,7 +246,7 @@ describe("parseMessage", () => { it("should detect self messages", () => { const adapter = createTestAdapter(); - const raw: XChatRawMessage = { + const raw: XchatRawMessage = { event: { id: "msg-3", conversationId: "12345-67890", @@ -301,7 +301,7 @@ describe("handleWebhook", () => { }); it("should reject POST with missing signature when consumerSecret is set", async () => { - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, consumerSecret: "test-secret", @@ -329,7 +329,7 @@ describe("handleWebhook", () => { }); it("should reject POST with invalid signature", async () => { - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, consumerSecret: "test-secret", @@ -362,7 +362,7 @@ describe("handleWebhook", () => { it("should accept POST with valid signature", async () => { const { createHmac } = await import("node:crypto"); const secret = "test-secret"; - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, consumerSecret: secret, @@ -418,73 +418,73 @@ describe("handleWebhook", () => { }); }); -describe("createXChatAdapter", () => { +describe("createXchatAdapter", () => { it("should throw when accessToken is missing", async () => { - const { createXChatAdapter } = await import("./index"); + const { createXchatAdapter } = await import("./index"); expect(() => - createXChatAdapter({ + createXchatAdapter({ userId: "12345", }) ).toThrow(MISSING_ACCESS_TOKEN_RE); }); it("should throw when userId is missing", async () => { - const { createXChatAdapter } = await import("./index"); + const { createXchatAdapter } = await import("./index"); expect(() => - createXChatAdapter({ + createXchatAdapter({ accessToken: "token", }) ).toThrow(MISSING_USER_ID_RE); }); it("should create adapter with only required config (interactive mode)", async () => { - const { createXChatAdapter } = await import("./index"); - const adapter = createXChatAdapter({ + const { createXchatAdapter } = await import("./index"); + const adapter = createXchatAdapter({ accessToken: "token", userId: "12345", }); - expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter).toBeInstanceOf(XchatAdapter); expect(adapter.name).toBe("xchat"); expect(adapter.cryptoStatus).toBe("uninitialized"); }); it("should accept botToken as accessToken alias", async () => { - const { createXChatAdapter } = await import("./index"); - const adapter = createXChatAdapter({ + const { createXchatAdapter } = await import("./index"); + const adapter = createXchatAdapter({ botToken: "token", userId: "12345", }); - expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter).toBeInstanceOf(XchatAdapter); }); it("should accept optional signingKeyVersion override", async () => { - const { createXChatAdapter } = await import("./index"); - const adapter = createXChatAdapter({ + const { createXchatAdapter } = await import("./index"); + const adapter = createXchatAdapter({ accessToken: "token", userId: "12345", signingKeyVersion: "42", }); - expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter).toBeInstanceOf(XchatAdapter); }); it("should accept verifySignatures override", async () => { - const { createXChatAdapter } = await import("./index"); - const adapter = createXChatAdapter({ + const { createXchatAdapter } = await import("./index"); + const adapter = createXchatAdapter({ accessToken: "token", userId: "12345", verifySignatures: false, }); - expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter).toBeInstanceOf(XchatAdapter); }); it("should accept pin for Juicebox auto-unlock", async () => { - const { createXChatAdapter } = await import("./index"); - const adapter = createXChatAdapter({ + const { createXchatAdapter } = await import("./index"); + const adapter = createXchatAdapter({ botToken: "token", userId: "12345", pin: "2580", }); - expect(adapter).toBeInstanceOf(XChatAdapter); + expect(adapter).toBeInstanceOf(XchatAdapter); }); }); @@ -510,7 +510,7 @@ describe("verifySignatures", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, pin: TEST_PIN, @@ -532,7 +532,7 @@ describe("verifySignatures", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, pin: TEST_PIN, @@ -567,7 +567,7 @@ describe("initialize (Juicebox)", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, pin: TEST_PIN, @@ -591,7 +591,7 @@ describe("initialize (Juicebox)", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, pin: TEST_PIN, @@ -612,7 +612,7 @@ describe("initialize (Juicebox)", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, userName: "test-bot", @@ -633,7 +633,7 @@ describe("initialize (Juicebox)", () => { try { const mockChat = createMockChatInstance(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, userName: "test-bot", @@ -951,7 +951,7 @@ describe("handleWebhook full flow (real crypto)", () => { describe("read receipts on delivery (real crypto)", () => { /** Build the fixture chat.received webhook request and prime the adapter. */ function primeFixtureDelivery( - adapter: XChatAdapter, + adapter: XchatAdapter, xdk: MockXdkClient ): Request { const vectors = loadVectors(); @@ -1114,7 +1114,7 @@ describe("mentionHandlesFromEntities", () => { }); describe("parseMessage mention + attachment mapping", () => { - function rawFor(decrypted: Record): XChatRawMessage { + function rawFor(decrypted: Record): XchatRawMessage { return { event: { id: "evt-m1", @@ -1122,7 +1122,7 @@ describe("parseMessage mention + attachment mapping", () => { senderId: TEST_OTHER_USER_ID, encodedEvent: "x", }, - decrypted: decrypted as XChatRawMessage["decrypted"], + decrypted: decrypted as XchatRawMessage["decrypted"], }; } @@ -1501,7 +1501,7 @@ describe("reactions (real crypto)", () => { }); describe("inbound reaction routing", () => { - const reactionRaw = (targetSequenceId: string): XChatRawMessage => ({ + const reactionRaw = (targetSequenceId: string): XchatRawMessage => ({ event: { id: "evt-react", conversationId: TEST_CONVERSATION_ID, diff --git a/packages/adapter-xchat/src/index.ts b/packages/adapter-xchat/src/index.ts index 40b3bcfb5..a1e09e7c3 100644 --- a/packages/adapter-xchat/src/index.ts +++ b/packages/adapter-xchat/src/index.ts @@ -8,13 +8,13 @@ * @example * ```typescript * import { Chat } from "chat"; - * import { createXChatAdapter } from "@chat-adapter/xchat"; + * import { createXchatAdapter } from "@chat-adapter/xchat"; * import { MemoryState } from "@chat-adapter/state-memory"; * * const chat = new Chat({ * userName: "my-bot", * adapters: { - * xchat: createXChatAdapter(), + * xchat: createXchatAdapter(), * }, * state: new MemoryState(), * }); @@ -64,16 +64,16 @@ import { Message, parseMarkdown, } from "chat"; -import { cardToXChat, type XChatUrlCardSpec } from "./cards"; -import { XChatFormatConverter } from "./markdown"; +import { cardToXChat, type XchatUrlCardSpec } from "./cards"; +import { XchatFormatConverter } from "./markdown"; import type { - XChatAdapterConfig, - XChatAttachmentEntry, - XChatCryptoStatus, - XChatDecryptedEvent, - XChatEvent, - XChatRawMessage, - XChatThreadId, + XchatAdapterConfig, + XchatAttachmentEntry, + XchatCryptoStatus, + XchatDecryptedEvent, + XchatEvent, + XchatRawMessage, + XchatThreadId, } from "./types"; /** Default base URL for X API requests */ @@ -188,7 +188,7 @@ interface XApiResponse { * snake_case responses. */ interface ConversationEventsResponse { - data?: Partial[]; + data?: Partial[]; meta?: { nextToken?: string; next_token?: string }; } @@ -362,7 +362,7 @@ export function mentionHandlesFromEntities( /** Reply-to preview (swipe reply) from decrypted content, if present. */ function replyPreviewOf( - content: XChatDecryptedEvent["content"] + content: XchatDecryptedEvent["content"] ): { senderId?: string; text?: string } | null { const preview = fieldOf(content, "replyingToPreview", "replying_to_preview"); if (!preview || typeof preview !== "object") { @@ -377,7 +377,7 @@ function replyPreviewOf( } /** Lowercased content type, tolerant of both binding spellings. */ -function contentTypeOf(content: XChatDecryptedEvent["content"]): string { +function contentTypeOf(content: XchatDecryptedEvent["content"]): string { const ct = fieldOf(content, "contentType", "content_type"); return typeof ct === "string" ? ct.toLowerCase() : ""; } @@ -389,7 +389,7 @@ function contentTypeOf(content: XChatDecryptedEvent["content"]): string { * anything carrying attachments/media hashes; and card-like content with * URL entities. Reactions/edits/mark-read return null. */ -function processableText(decrypted: XChatDecryptedEvent | null): string | null { +function processableText(decrypted: XchatDecryptedEvent | null): string | null { if (!decrypted || decrypted.type.toLowerCase() !== "message") { return null; } @@ -441,12 +441,12 @@ function mediaTypeFromSource(source: string | undefined): string { /** Extract all media references (hash keys + metadata) from a decrypted event. */ export function extractMediaEntries( - decrypted: XChatDecryptedEvent + decrypted: XchatDecryptedEvent ): MediaEntry[] { const entries: MediaEntry[] = []; const seen = new Set(); - const addFromAttachment = (entry: XChatAttachmentEntry): void => { + const addFromAttachment = (entry: XchatAttachmentEntry): void => { // Nested `{ media: {...} }` (wire shape) or flattened (JS binding shape) const media = entry.media ?? entry; const hashKey = @@ -456,7 +456,7 @@ export function extractMediaEntries( return; } seen.add(String(hashKey)); - const dims = (media as XChatAttachmentEntry).dimensions; + const dims = (media as XchatAttachmentEntry).dimensions; const rawType = fieldOf(media, "mediaType", "media_type") ?? (media as Record).type; @@ -553,17 +553,17 @@ async function toBytes( return new Uint8Array(await (data as Blob).arrayBuffer()); } -export type { XChatCardResult, XChatUrlCardSpec } from "./cards"; +export type { XchatCardResult, XchatUrlCardSpec } from "./cards"; export { cardToXChat } from "./cards"; -export { XChatFormatConverter } from "./markdown"; +export { XchatFormatConverter } from "./markdown"; export type { - XChatAdapterConfig, - XChatAttachmentEntry, - XChatCryptoStatus, - XChatDecryptedEvent, - XChatEvent, - XChatRawMessage, - XChatThreadId, + XchatAdapterConfig, + XchatAttachmentEntry, + XchatCryptoStatus, + XchatDecryptedEvent, + XchatEvent, + XchatRawMessage, + XchatThreadId, } from "./types"; /** @@ -572,7 +572,7 @@ export type { * Handles encrypted messaging via the X API and chat-xdk WASM crypto. * All conversations are 1:1 DMs or group chats, always encrypted. */ -export class XChatAdapter implements Adapter { +export class XchatAdapter implements Adapter { readonly name = "xchat"; readonly persistMessageHistory = true; private _userName: string; @@ -590,10 +590,10 @@ export class XChatAdapter implements Adapter { private readonly verifySignatures: boolean; private chat: ChatInstance | null = null; private readonly logger: Logger; - private readonly formatConverter = new XChatFormatConverter(); + private readonly formatConverter = new XchatFormatConverter(); private xdkClient: InstanceType | null = null; private cryptoEngine: ChatWithJuicebox | null = null; - private _cryptoStatus: XChatCryptoStatus = "uninitialized"; + private _cryptoStatus: XchatCryptoStatus = "uninitialized"; /** Saved getAuthToken callback for re-installing on unlock() */ private _getAuthToken: ((realmId: string) => Promise) | null = null; /** @@ -640,11 +640,17 @@ export class XChatAdapter implements Adapter { } /** Current encryption readiness status */ - get cryptoStatus(): XChatCryptoStatus { + get cryptoStatus(): XchatCryptoStatus { return this._cryptoStatus; } - constructor(config: XChatAdapterConfig) { + constructor( + config: XchatAdapterConfig & { + accessToken: string; + logger: Logger; + userId: string; + } + ) { this.accessToken = config.accessToken; this.apiHeaders = { ...config.apiHeaders }; this.apiBaseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL; @@ -907,11 +913,11 @@ export class XChatAdapter implements Adapter { // ── Thread ID encoding ──────────────────────────────────────────── - encodeThreadId(data: XChatThreadId): string { + encodeThreadId(data: XchatThreadId): string { return `xchat:${data.conversationId}`; } - decodeThreadId(threadId: string): XChatThreadId { + decodeThreadId(threadId: string): XchatThreadId { if (!threadId.startsWith("xchat:")) { throw new Error(`Invalid XChat thread ID: ${threadId}`); } @@ -960,7 +966,7 @@ export class XChatAdapter implements Adapter { // XAA wraps the event in: // { data: { event_type, event_uuid, filter, tag, payload: { ...event } } } // Wire format is snake_case (raw HTTP body — not via XDK transformKeys). - let event: XChatEvent; + let event: XchatEvent; let eventType: string; try { const body = JSON.parse(rawBody); @@ -1075,7 +1081,7 @@ export class XChatAdapter implements Adapter { * KeyChange blob and post the welcome message (groups only). */ private handleConversationJoin( - event: XChatEvent, + event: XchatEvent, options?: WebhookOptions ): void { const conversationId = event.conversationId; @@ -1122,7 +1128,7 @@ export class XChatAdapter implements Adapter { /** Route a decrypted reaction event into the Chat SDK. */ private routeReaction( threadId: string, - parsed: Message, + parsed: Message, added: boolean, options?: WebhookOptions ): void { @@ -1178,8 +1184,8 @@ export class XChatAdapter implements Adapter { * (own message, non-message, decrypt failure, empty text). */ async handleIncomingEvent( - event: XChatEvent - ): Promise | null> { + event: XchatEvent + ): Promise | null> { if (!this.chat) { throw new Error("XChat adapter not initialized — call Chat.initialize()"); } @@ -1198,7 +1204,7 @@ export class XChatAdapter implements Adapter { return null; } - let message: Message; + let message: Message; try { message = await this.decryptAndParseEvent(event); } catch (err) { @@ -1274,7 +1280,7 @@ export class XChatAdapter implements Adapter { // ── Message parsing ─────────────────────────────────────────────── - parseMessage(raw: XChatRawMessage): Message { + parseMessage(raw: XchatRawMessage): Message { const { event, decrypted } = raw; // An edit replaces its target: the backend stops serving the superseded @@ -1333,7 +1339,7 @@ export class XChatAdapter implements Adapter { ? this.attachmentsFromDecrypted(conversationId, decrypted) : []; - return new Message({ + return new Message({ id: messageId ?? event.id, threadId, text, @@ -1363,7 +1369,7 @@ export class XChatAdapter implements Adapter { * undefined so the Chat SDK's plain-text `@handle` fallback applies. */ private detectBotMention( - decrypted: XChatDecryptedEvent | null, + decrypted: XchatDecryptedEvent | null, text: string ): boolean | undefined { if (!decrypted) { @@ -1396,7 +1402,7 @@ export class XChatAdapter implements Adapter { /** Map media references on a decrypted event to Chat SDK attachments. */ private attachmentsFromDecrypted( conversationId: string, - decrypted: XChatDecryptedEvent + decrypted: XchatDecryptedEvent ): Attachment[] { const keyVersion = decrypted.keyVersion; return extractMediaEntries(decrypted).map((entry) => ({ @@ -1431,7 +1437,7 @@ export class XChatAdapter implements Adapter { async postMessage( threadId: string, message: AdapterPostableMessage - ): Promise> { + ): Promise> { const { conversationId } = this.decodeThreadId(threadId); // Cards degrade to text plus a URL preview attachment: XChat has no // interactive primitives, so links become entities and the primary link @@ -1526,7 +1532,7 @@ export class XChatAdapter implements Adapter { this.postedAtByMessageId.set(messageId, Date.now()); // Build a synthetic raw message for the return - const rawMessage: XChatRawMessage = { + const rawMessage: XchatRawMessage = { event: { id: messageId, conversationId, @@ -1719,7 +1725,7 @@ export class XChatAdapter implements Adapter { threadId: string, messageId: string, message: AdapterPostableMessage - ): Promise> { + ): Promise> { const { conversationId } = this.decodeThreadId(threadId); const crypto = this.getCryptoEngine(); if (!this.signingKeyVersion) { @@ -1910,7 +1916,7 @@ export class XChatAdapter implements Adapter { async fetchMessages( threadId: string, options?: FetchOptions - ): Promise> { + ): Promise> { const { conversationId } = this.decodeThreadId(threadId); const client = this.getXdkClient(); const crypto = this.getCryptoEngine(); @@ -1939,7 +1945,7 @@ export class XChatAdapter implements Adapter { // Collect encoded events, cache tokens, and map back to raw metadata. const encodedEvents: string[] = []; - const b64ToRaw = new Map>(); + const b64ToRaw = new Map>(); const senderIds = new Set(); for (const evt of rawEvents) { if (evt.conversationToken) { @@ -2000,12 +2006,12 @@ export class XChatAdapter implements Adapter { }); } - const messages: Message[] = []; + const messages: Message[] = []; for (const dm of result.messages) { const event = dm.event; if ( !event || - processableText(event as unknown as XChatDecryptedEvent) === null + processableText(event as unknown as XchatDecryptedEvent) === null ) { continue; } @@ -2021,7 +2027,7 @@ export class XChatAdapter implements Adapter { (Number.isFinite(Number(rawCreatedAtMsec)) ? rawCreatedAtMsec : undefined); - const rawMessage: XChatRawMessage = { + const rawMessage: XchatRawMessage = { event: { id: event.id ?? raw?.id ?? "", conversationId, @@ -2033,7 +2039,7 @@ export class XChatAdapter implements Adapter { messageEventSignature: raw?.messageEventSignature, sequenceId: event.sequenceId ?? raw?.sequenceId, }, - decrypted: event as XChatDecryptedEvent, + decrypted: event as XchatDecryptedEvent, }; messages.push(this.parseMessage(rawMessage)); } @@ -2124,7 +2130,7 @@ export class XChatAdapter implements Adapter { */ async markAsRead(threadId: string, message: Message): Promise { const { conversationId } = this.decodeThreadId(threadId); - const raw = message.raw as XChatRawMessage | undefined; + const raw = message.raw as XchatRawMessage | undefined; let sequenceId = raw?.decrypted?.sequenceId ?? raw?.event?.sequenceId ?? ""; try { @@ -2233,8 +2239,12 @@ export class XChatAdapter implements Adapter { const client = this.getXdkClient(); const encrypted = crypto.encryptStream(bytes, keyInfo.key); + // Media routes accept only the dash-joined participant pair (or the + // g-prefixed group id), never the colon-joined internal form. + const apiConversationId = dashConversationId(conversationId); + const initBody = await client.chat.mediaUploadInitialize({ - conversationId, + conversationId: apiConversationId, totalBytes: encrypted.length, }); const sessionId = initBody.data?.sessionId; @@ -2251,7 +2261,7 @@ export class XChatAdapter implements Adapter { ) { const chunk = encrypted.subarray(offset, offset + UPLOAD_CHUNK_BYTES); await client.chat.mediaUploadAppend(sessionId, { - conversationId, + conversationId: apiConversationId, mediaHashKey, segmentIndex, media: Buffer.from(chunk).toString("base64"), @@ -2260,7 +2270,7 @@ export class XChatAdapter implements Adapter { } await client.chat.mediaUploadFinalize(sessionId, { - conversationId, + conversationId: apiConversationId, mediaHashKey, numParts: String(segmentIndex), }); @@ -2322,7 +2332,7 @@ export class XChatAdapter implements Adapter { private async urlCardAttachment( conversationId: string, keyInfo: { key: Uint8Array; version: string }, - spec: XChatUrlCardSpec + spec: XchatUrlCardSpec ): Promise { let bannerImage: UrlAttachmentImageDescriptor | undefined; if (spec.imageUrl) { @@ -2588,14 +2598,14 @@ export class XChatAdapter implements Adapter { } /** - * Decrypt a single event, returning a XChatRawMessage. + * Decrypt a single event, returning a XchatRawMessage. * Falls back gracefully if decryption fails (returns null decrypted). */ private tryDecryptEvent( conversationId: string, - event: XChatEvent, + event: XchatEvent, signingKeys: SigningKeyEntry[] = [] - ): XChatRawMessage { + ): XchatRawMessage { const crypto = this.getCryptoEngine(); const keyResult = this.conversationKeys.get(conversationId); @@ -2608,7 +2618,7 @@ export class XChatAdapter implements Adapter { event.encodedEvent, keyResult.keys, signingKeys - ) as XChatDecryptedEvent; + ) as XchatDecryptedEvent; return { event, decrypted }; } catch { this.logger.debug("Failed to decrypt event", { @@ -2628,8 +2638,8 @@ export class XChatAdapter implements Adapter { * conversation-events poll path often embeds key material that way. */ private async decryptAndParseEvent( - event: XChatEvent - ): Promise> { + event: XchatEvent + ): Promise> { const crypto = this.getCryptoEngine(); const conversationId = event.conversationId; @@ -2704,7 +2714,7 @@ export class XChatAdapter implements Adapter { if (dm?.event) { return this.parseMessage({ event, - decrypted: dm.event as unknown as XChatDecryptedEvent, + decrypted: dm.event as unknown as XchatDecryptedEvent, }); } } catch { @@ -2751,37 +2761,7 @@ export class XChatAdapter implements Adapter { * on incoming messages (default true). Set false to decrypt unverifiable * messages instead of dropping them. */ -export function createXChatAdapter(config?: { - /** OAuth2 access token (alias for accessToken). */ - botToken?: string; - accessToken?: string; - /** Base URL for X API requests. Defaults to https://api.x.com. */ - apiBaseUrl?: string; - apiHeaders?: Record; - /** App consumer secret for webhook CRC + signature verification. Defaults to X_CONSUMER_SECRET env var. */ - consumerSecret?: string; - /** - * Minimum age (ms) a freshly posted message must reach before its first - * edit is sent, giving receiving clients time to store the original an - * edit targets. Defaults to 5000; 0 disables the wait. - */ - editSafetyDelayMs?: number; - logger?: Logger; - /** Juicebox PIN; when set, initialize() auto-unlocks. */ - pin?: string; - /** Override — normally fetched automatically during initialize(). */ - signingKeyVersion?: string; - /** - * Require verifiable signatures on incoming messages. Defaults to true. - * Set to false (or X_VERIFY_SIGNATURES=false) to decrypt unverifiable - * messages instead of dropping them. - */ - verifySignatures?: boolean; - userName?: string; - userId?: string; - /** Group-join welcome message; false disables, omitted uses a default. */ - welcomeMessage?: string | false; -}): XChatAdapter { +export function createXchatAdapter(config?: XchatAdapterConfig): XchatAdapter { const logger = config?.logger ?? new ConsoleLogger("info").child("xchat"); const accessToken = @@ -2819,7 +2799,7 @@ export function createXChatAdapter(config?: { // Prefer explicit config; env override; otherwise initialize() fills from /2/users/me const userName = config?.userName ?? process.env.X_BOT_USERNAME; - return new XChatAdapter({ + return new XchatAdapter({ accessToken, apiBaseUrl: config?.apiBaseUrl, apiHeaders: config?.apiHeaders, diff --git a/packages/adapter-xchat/src/markdown.test.ts b/packages/adapter-xchat/src/markdown.test.ts index 041f7c321..29cb4ee1b 100644 --- a/packages/adapter-xchat/src/markdown.test.ts +++ b/packages/adapter-xchat/src/markdown.test.ts @@ -1,11 +1,11 @@ import { describe, expect, it } from "vitest"; -import { XChatFormatConverter } from "./markdown"; +import { XchatFormatConverter } from "./markdown"; /** Italic markers may stringify as either `*italic*` or `_italic_`. */ const ITALIC_MARKERS_RE = /[*_]italic[*_]/; -describe("XChatFormatConverter", () => { - const converter = new XChatFormatConverter(); +describe("XchatFormatConverter", () => { + const converter = new XchatFormatConverter(); describe("toAst", () => { it("should parse plain text", () => { diff --git a/packages/adapter-xchat/src/markdown.ts b/packages/adapter-xchat/src/markdown.ts index a5f777676..bae165bfb 100644 --- a/packages/adapter-xchat/src/markdown.ts +++ b/packages/adapter-xchat/src/markdown.ts @@ -22,7 +22,7 @@ import { walkAst, } from "chat"; -export class XChatFormatConverter extends BaseFormatConverter { +export class XchatFormatConverter extends BaseFormatConverter { /** * Convert an AST to the text sent in an XChat message. * diff --git a/packages/adapter-xchat/src/test-utils.ts b/packages/adapter-xchat/src/test-utils.ts index 328c39802..9ba938f2c 100644 --- a/packages/adapter-xchat/src/test-utils.ts +++ b/packages/adapter-xchat/src/test-utils.ts @@ -16,8 +16,8 @@ import { fileURLToPath, pathToFileURL } from "node:url"; import type { ChatWithJuicebox } from "@xdevplatform/chat-xdk"; import type { ChatInstance, Logger } from "chat"; import { vi } from "vitest"; -import { XChatAdapter } from "./index"; -import type { XChatAdapterConfig } from "./types"; +import { XchatAdapter } from "./index"; +import type { XchatAdapterConfig } from "./types"; // ── Fixture data ──────────────────────────────────────────────────── @@ -190,16 +190,16 @@ export interface MockXdkClient { } /** - * Create and initialize an XChatAdapter with real wasm crypto. + * Create and initialize an XchatAdapter with real wasm crypto. * * Wires a Juicebox-shaped stub (fixture keys already imported) and an XDK * client without calling createChat — unit tests stay offline and avoid * spying on ESM exports. */ export async function createInitializedTestAdapter( - configOverrides: Partial = {} + configOverrides: Partial = {} ): Promise<{ - adapter: XChatAdapter; + adapter: XchatAdapter; mockChat: ReturnType; /** Access the internal XDK client for mocking API calls */ getXdkClient: () => MockXdkClient; @@ -208,7 +208,7 @@ export async function createInitializedTestAdapter( const mockChat = createMockChatInstance(); const engine = await createTestCryptoEngine(); - const adapter = new XChatAdapter({ + const adapter = new XchatAdapter({ accessToken: "test-token", userId: TEST_USER_ID, pin: TEST_PIN, diff --git a/packages/adapter-xchat/src/types.ts b/packages/adapter-xchat/src/types.ts index d15aa6870..bd5555daf 100644 --- a/packages/adapter-xchat/src/types.ts +++ b/packages/adapter-xchat/src/types.ts @@ -22,13 +22,18 @@ import type { Logger } from "chat"; * * Pass `pin` to auto-unlock after initialize, or call `adapter.unlock(pin)` later. */ -export interface XChatAdapterConfig { - /** OAuth2 access token for X API calls */ - accessToken: string; +export interface XchatAdapterConfig { + /** + * OAuth2 access token for X API calls. When omitted, resolved from the + * `XCHAT_BOT_TOKEN` or `X_ACCESS_TOKEN` env var by `createXchatAdapter`. + */ + accessToken?: string; /** Base URL for X API requests. Defaults to https://api.x.com. */ apiBaseUrl?: string; /** Custom HTTP headers to send with every X API request */ apiHeaders?: Record; + /** OAuth2 access token (alias for `accessToken`). */ + botToken?: string; /** * App consumer secret (API secret key) for webhook signature verification. * When set, incoming POST webhooks are verified via HMAC-SHA256. @@ -40,8 +45,11 @@ export interface XChatAdapterConfig { * edit targets. Defaults to 5000; 0 disables the wait. */ editSafetyDelayMs?: number; - /** Logger instance for error reporting */ - logger: Logger; + /** + * Logger instance for error reporting. When omitted, `createXchatAdapter` + * falls back to a console logger. + */ + logger?: Logger; /** * Juicebox PIN. When set, initialize() calls unlock(pin) automatically * after createChat(). @@ -58,8 +66,11 @@ export interface XChatAdapterConfig { * initialize(). Only set this if you know what you're doing. */ signingKeyVersion?: string; - /** The authenticated user's numeric X user ID */ - userId: string; + /** + * The authenticated user's numeric X user ID. When omitted, resolved from + * the `XCHAT_USER_ID` or `X_USER_ID` env var by `createXchatAdapter`. + */ + userId?: string; /** * Bot @handle for mention detection. When omitted, initialize() loads it * from GET /2/users/me. @@ -95,7 +106,7 @@ export interface XChatAdapterConfig { * - `ready`: Keys loaded, adapter can encrypt/decrypt * - `error`: Initialization or unlock failed */ -export type XChatCryptoStatus = +export type XchatCryptoStatus = | "uninitialized" | "initializing" | "locked" @@ -113,7 +124,7 @@ export type XChatCryptoStatus = * * Format: xchat:{conversationId} */ -export interface XChatThreadId { +export interface XchatThreadId { /** The raw conversation ID (e.g. "12345-67890" or "gABCDE") */ conversationId: string; } @@ -129,7 +140,7 @@ export interface XChatThreadId { * - X Activity API webhook POST * - X Activity API persistent HTTP stream */ -export interface XChatEvent { +export interface XchatEvent { /** The conversation this event belongs to (e.g. "12345:67890" or "gABCDE") */ conversationId: string; /** Base64 key change event for extracting/rotating conversation keys */ @@ -168,7 +179,7 @@ export interface XChatEvent { /** * XAA chat event types. */ -export type XChatEventType = +export type XchatEventType = | "chat.received" | "chat.sent" | "chat.conversation_join"; @@ -182,11 +193,11 @@ export type XChatEventType = * * Contains both the encrypted event envelope and the decrypted content. */ -export interface XChatRawMessage { +export interface XchatRawMessage { /** The decrypted event from chat-xdk (null if decryption failed) */ - decrypted: XChatDecryptedEvent | null; + decrypted: XchatDecryptedEvent | null; /** The raw XAA event or API response event */ - event: XChatEvent; + event: XchatEvent; } /** @@ -194,15 +205,15 @@ export interface XChatRawMessage { * interface (instead of importing chat-xdk's types) so consumers don't need * chat-xdk as a type dependency. */ -export interface XChatDecryptedEvent { - attachments?: XChatAttachmentEntry[]; +export interface XchatDecryptedEvent { + attachments?: XchatAttachmentEntry[]; content?: { text?: string; contentType?: string; emoji?: string; targetMessageId?: string; entities?: unknown[]; - attachments?: XChatAttachmentEntry[]; + attachments?: XchatAttachmentEntry[]; replyingToPreview?: unknown; [key: string]: unknown; }; @@ -230,7 +241,7 @@ export interface XChatDecryptedEvent { * camelCase shape produced by the chat-xdk JS binding and the nested * snake_case `{ media: {...} }` shape seen on some wire payloads. */ -export interface XChatAttachmentEntry { +export interface XchatAttachmentEntry { attachmentType?: string; dimensions?: { width?: number; height?: number }; durationMillis?: number; From 9e4fa0223eae30d1f44c1987a928aa7b06932bed Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 13:09:50 -0700 Subject: [PATCH 4/7] docs(xchat): register the adapter in the catalog, docs site, and CLI Adds the official docs page with OG image, the adapters.json registry entry, the chat/adapters catalog entry, and the create-chat-sdk scaffold spec, modeled on the x adapter's registration. --- apps/docs/adapters.json | 10 + apps/docs/content/adapters/official/meta.json | 1 + .../content/adapters/official/og/xchat.png | Bin 0 -> 290899 bytes apps/docs/content/adapters/official/xchat.mdx | 269 ++++++++++++++++++ packages/chat/src/adapters/index.ts | 45 +++ .../src/catalog/scaffold-spec.ts | 3 + .../src/docs-adapters.test.ts | 1 + 7 files changed, 329 insertions(+) create mode 100644 apps/docs/content/adapters/official/og/xchat.png create mode 100644 apps/docs/content/adapters/official/xchat.mdx diff --git a/apps/docs/adapters.json b/apps/docs/adapters.json index 0a11d87bb..9123f5f97 100644 --- a/apps/docs/adapters.json +++ b/apps/docs/adapters.json @@ -99,6 +99,16 @@ "beta": true, "readme": "https://github.com/vercel/chat/tree/main/packages/adapter-x" }, + { + "name": "XChat", + "slug": "xchat", + "type": "platform", + "description": "Hold encrypted 1:1 and group conversations on XChat with all cryptography handled inside the adapter.", + "packageName": "@chat-adapter/xchat", + "icon": "x", + "beta": true, + "readme": "https://github.com/vercel/chat/tree/main/packages/adapter-xchat" + }, { "name": "Messenger", "slug": "messenger", diff --git a/apps/docs/content/adapters/official/meta.json b/apps/docs/content/adapters/official/meta.json index 925bddeb3..405092d5d 100644 --- a/apps/docs/content/adapters/official/meta.json +++ b/apps/docs/content/adapters/official/meta.json @@ -14,6 +14,7 @@ "twilio", "messenger", "x", + "xchat", "web", "---State---", "memory", diff --git a/apps/docs/content/adapters/official/og/xchat.png b/apps/docs/content/adapters/official/og/xchat.png new file mode 100644 index 0000000000000000000000000000000000000000..eed8bd8f4de28c4fd43e3c67dc63cc45b14953bb GIT binary patch literal 290899 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�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

    t;ai#d57dx*cN9J( zrM$bbWO-^N#g8X;Ye;%3=LQ=5smuJ)BGyPfr{dwrh!C~tdKNl?9@Q=jw8bFWVxchp zxV0q^vGFfEJa?DeyFS*YwCQjug*@M){e3dd+D+A*UnwkKb1RZQ@9T3~N4X*6gR07T zJV_^|JD@c8J_PquuYeop#6%JSbctxT-w`FgElQ^5jyWMwT8B7==-rQxugp-kmHw-@ zw?(ouk03(Oi6WX**OM~aeJd((oU%!``^pbMab!F(HtCscFUs+Tz!DDFO>Uw^#K*So z)1{KN%*(m_f(g#cp(4BW(98XdN#@e%@;n7B>K>E`X3-mSC`6isWK=GFJuUZph90M6 z&!4(~RE8h~;p_D@ujD0bhKn7z5zet4m7XyUeW`ca(8X6v*~v<@xptP%&#(oh!A+C;cC8dOWcCiP(w zaakh6`;^;tjrIP&I6vwTwcNGSm)#w_&OD^Wy9sm6P z%NL6m7i%$tV)PC+-C4h=xE_N9T)$8blY2!~Y4Ph*^{n&|vc_?17xu&uT(A}IBRk2* zix|S9RyyAI@tf(LHCev8sc3y@0X2%;DDgAp(5r>!K~~y%K&Z%P6-d(~&>4_ULOC-< z;WB4X`DRmN$?=QTh~4qjkX$yKd*NBKhNOXGP8yyJw=D1bUT@l@i4N4A5?R1+YO9u4 znDSsi+*@h!mKc6Hfq|KqRj@7E{d##0&#fB4zl_{K7_`48f94*BT2OLbu{Lb6XfFtr zE2(P>YYd3O3R2mQF48gOHy*p{Pn*MyLr)_TgF4RECCfvDB#7| z@2HcgVkVt9@EbQl=c|&04vdNrg+0!pHyWWOAWEe;@u=41q|AyJCa(;8Px*3&`(oBy zS?X?^_mwQY*I9Hz8fNi!HWl)rJT64MhYe>Nv(AK_emncZjoo?}7n_T%1Tl_ic2gd| zgn5uD3$b$>pMV$i{d);nmJCe>#$fVb)NAUEzEU#t0i`Q!O8ip+ z1(AA+ujYz^f<@g(w%$0B0bkncQ>$skCD`(~^aNNNpDh)FSB6@spA@BBE`Vih&0ae8<<#(Xn0k77sbUC|wMe(T zicFNg$Ztk1C~_$Kdph?0|43{`%0M~_14a(oI>WKsO|D_4NvKU2GL1y|5UI-{Rm7H~oGTCHo|wS?Y)eLNW&o+VbbNdLvR!tTR%e$``-}qlm&A++Tyd zPDX$eyyn7{BT3dDQ+#HH)Eq zS$twR=ola_di)rlXe`gnJxQTd2_2xK>ZW$9N`H0T_mrq!lO<%RQGcbs@u z^9Pp*Ar4teu+~uxc)xFJb!f!+Q>Nw)BNV+InkDP`j<)+;Az~Y9&m5P^pNt@eU7>{O zVY3wau5v$UC|cv8UFr^*k+UI>KH#%B>u!!0%-WRg&|&U z1TGfKlv8PR{O?%28C_@_i!7MX>9!bZ-kP_Nc<2`MOWt+k{)B~mvt&5|L?8{=uE+A1 z?ozkziqxLkLXMb{IC3laJaoipQU%J|6l#4$vMaNxh75RrjIZJUb*eWZ0k zQ&2{Z-&D1Z#H%k#ideqeq^5b?9> z1}~@jl%21!Rxd3ml^3T0Qiv{E)wLfQb_}uR?ie-Wt7CO^daB{9&%awiO-w zMPKGKACmh~FenMrK`roXoFi)c@~-4nE&CuwKm*-+Bsu7#Y+CL}if6zdx7^MP4;zJg z_KS44knD@fLc5J{HsWO`-`mwwAy>??HUYxVIWFggP$4+t2jY@w`=U@XS}er4clhKl zcBQ^OfrbAAdO?N0YUI6M6V{RvG_ANS?@G?!J|i$4mpqTjQ$f+f87GFhA)65($Vh5I zCGCS)rU>L*lIN7j;a;vE{vVu#gPv~fgl{S&yPd;|2?TG8j*T=Fx^=asBi82gtb?NH zJ9ajk)IKgHVa8{93=t5r<;`Zqe8DbF3LGJEPY$0LUB%Ff^NhBR{U@h2k>vPlw={)z zlQgL!!a6)cDmjj{@E2*`7KGMmagDvn0s0j~MMR8zgPz=JFO$;0; zpJ(!m8L=v^me?q7XWCt-Z!gjq$-V^=S(UE+w$VVjy ztK1kk6Ey8lzyVT}$e=y#KmPHL_k$P*6bS$B$<@SL=3~w;Fj&EYhls&P?QhIn~_?%>r1G@PsElaodgqY|!Y#kouEveB&Ed zL-;}sn!L0Rt)4pfu`WSzCVeKt3J8lDOlP!RuB!@ZSA>&D|#zGh1TL6`My- zcso;N5tn8vw# zu0fH?JfGKw7Oe`fi1naFcM(6kLH0P&1a~o}V z)8Uw7jQy`7|5s7VtaygZ z6lj}troe``ZCPne|Nrd0dCYBjRsKm;F$glss1`qFN<;>O10lo^R8%x7Dn!vlz$n47 z9n!RIhiLRKHEm-wlI}K6_=j_hQ9%)i14E)BqLe@aihzdFA1El&Qbm8xdG7n%b=P;; z-#wi3p7++>sq9+cwVw5?XRW>8bI;yqT3N-M@XV#H-+(9uP4Z3xO3vGlCmx}ZuEDeM zOoA&Po^9*y1Bq{b^P71u<&XTxkMP7o*OTl)f@#rmTomOg2(N+gqkup7gFpD1*Sv-& zNu=ny6oaS!RPhsf9ZeDufD8b5D1-s#(?9*wc~3hZ>mZ9LFq|M!1wg_u(#AU?@c{nV ztskR>|M@Tf!Zij()v3r+3d?2ZRg10U?|2|t&%=D^k>T@{lqo^TpfGe$%IZXEncGaf z#>I=hEWwbaIY^I>h5cd%Nk|(9=)1n_yEqm&Im$To+*E{RT>ylT3XIp*1TcSzSBRSk zTp5x`n`|v|(osUoWIg-Y&*nGnU-!D#VS|@)Y&IB>0T^3`>*A4ZzYSxO5doa-)Z)&< z{qKK&y?98iUCFb*GKtr?IIH>OHm@1-o%#HDo@mht0~;8abs*~ZIL&}c7HOvza5hIcSU)4hZ#a1g!v{&e!fu; zUwUNIgDu*~;>IaUgz;90f^{>8w0j!nl?ImkQ2x6kEB-Bt#JSPfhi06{jX%U4Wv5E4 zcxv{3R+k1CTPSC4sUbI_2yD0ncj3QIg`8B^S&1jG=wqtTy`>bhDY zAtT8V?5d;<>z2bg-+p_oF^l~sOw<|e9zzi;+bVOx2k&RB8M-b#RYR4#J11Vl`<69Z2j*yQBd z1}`1!XX?17Xfd?Me~cgroez|RE$Y#7=@E~g9&;8kP(<99dp)0^!1=B^AghsKlnj7#T;uz8({*x>}4-Yby*^YS9fo| z`DRkm@roqL<{0tg;bQaQ(2~7c(9-Sj{8C4d{SW=n4^fM|35-s4<1tFLyi^yo!w(Jc z6QnS6vaxqvm&Qq7Y#6+!00wfEZnn~Z8ACXZ0}Xbb?skZ>}6g$yO<19 z;&n&~<}U~_*z9e%3#4-N`B4Vm69I|-7OYmIUZCf^QZ&r-s!m-d#)iQRANarr^4a)* zeBXQZnDGDI`Y}IB$Y8G@>*a$O{4MZevU2Idhk!$Qj_n+$wEqM!RIxmcrRO->2CG;( zc-azM`V*mHRYTwyO6hT_T73SC+p^rjf8h&X$RnGaks;bKy|hcDA0hx_vtjIhqVnv= zDOvIu!fDKb)PGmd%5~`g( z8!bc*S+@#fx#B-wJyCsUB_pWYCGtqTPuY(*Km+WON&EZ%cGJ@q;Iqv$j^q8mD$(U* z)Xu{hluP6ikeq4R%CcW1gH#dRv7?5_9BpIFV^1`Qrez-w*nnh2o?>RVFz@27Vp$=P1z_$KF3!}kSiP(rS z7^Lv;EmuUg@o-7W2ch}mYc{T$2x+gxRD~tacwo5nd}x1?@mz#2&E^GO-p~AdzxR9m z;v)vvg!*N#D2A+i-}~NNE$|)MPkG8y_@w}DK=3q(T5y6Ct*#AN;*_0ah!ZEq+u#27 zANYYEz~K6rbi`w8FWA(6hY#ECiAdTsuH>A%goJHYmKuyHczDvub?kfI^B#_u#uATL z1l#7)mmzbV%o|=9mrejjZKxa~HFL6<=ffWMFkX4%&FWMEz|FOVaZ6Q{Ss;b}!ux%tps|x?r8-Hfx$FZ0W51WuY zNMI0UJM;AZqCuUdo|U@x|MmnlXV10`+(mp)Fa}dZD6rGZDsu@VLsf~L7?87(5}lEu zZ!1d-Eu@(fAk|IL>M~KKrBhmd0|t$x5ZX?s4sBIkA{WylgGWfV^?D*hw58AnAPtH1iIFZhBlkWENY_Ng>ToVt?drVm%?-}imr$IrZzXe0n1 zL^<`mme0j})mMGh^Pm5GUa{8^6buXo%o?MXI&Gkm(@HSd0DtfIelMX{z3Npw>t)H8 zxAS>sLO6BEaH12QH@@+W+&-WLO90jx4Zu+hAXmTfse@-}%ol zGYhxskSA?$iahOMXoV8eFj5qXxpEp~Kq9Fw$ug%I>>(uKbfVgBW^7)D{gvz?&p5)GoSfPK7jMEhdm6Bu88rv$F!6X7;BM}eVfgabm@r4*1sTfMvU!9SUMwHM3#0HX=lk?GE_ZET+ahJBvD4R6}5mA z!k=UaDOCoirL!Vfb_&@!XmCs^s&-VgOsonnVR%Z}k<;DTsFFmUG96D$$4;Ka85v^8 zBq`m?R$?UC%2q8Tv6XdkRtsHv2Sh7e=8PlDT+fA&<(9BPPqk0ymLqVeYRtt~Nuska zFCuMQgNIxt!O3SRcpm{@mB)Pn{``1C&r=+prW4Y26r4QafY6+-f+4^EZh6I?bln+d=DuEuqkBAeS034106+an(Fh+q1pU*awRAG-PTKmYUhzyJMwfhe;g#KyZM zc!{3d4gCE3)1UtIr#sPI1NWi$w$Yco4nK12kkc<$$P58C6{Rm=BG(I#%$DEL;EPvjmhW=o zfYLbM0H+}<(F$qJwn#)P+ss;eZ@&$PFrqWs5mVYAtEJ_1RD^LKvr5{XNAo#*y1CPb zXa9OHUmi*Pj(5H@-?;IakADK6qGIDM4-8qSC3hdNb&^wvMD|QlVi(bT; z4-!vZ!?C=();8J}P$?xI5e?0X97=uwrN>!UhcRoO9@J#-E#zc50IggXog@KSC8;`1 z8;!{lrkX@X+R~nt?xOI-L~MoZlwrL6rGTo(go>J{3Qo>h;FNoyrH7NWc{z7J2hwTU zmLB`9+$qs$MO*%u8*P`vNp4(5*tor(VZ2sCs`oVl;`GGRnF)Ycv5JghOkPF07sKq? z(CCo2La~JrC6hb}kd`V@7A-wdjG|Sl2s<6S-%ixIyAFwH?1T21$i0jjqCRY4s(`99 zrJw9FiT5bfvZFQx;KBxjC+K|ko)5M1J$bq&#KV;*&)_k@=;}`UIDt+T3b~dppICxd zO1Y1;rLA19G0-DPKl-CT$|vf@qbPn|T9g-TCPWEfHazToy<6Px_zHfZkQ)J9F!NCky+wr^ zPrNyWjXOu&hG3H5dBqsbeCz@SiD8e2CFcg8bl{B)yir2ee)!o0z)+_k5e7MUebxqk zqS%Clr;tQalwJ__+Sk68*636)^##5_-XdpWfEf>2Y%&C}-*`B&qhBcoMB@^8_pS1I z6O2R8`M{6=ai`|N4}LKB#h&nlCp_jckGb)aKgDmJ;+Rs7$+O82tsW)l4g)^}=Pu7T ze&aVXTgden6vZ6DmM{u+W>S?g7hff*I>l^Z7V_i(UQQ`O_OOh&83BwNxT zp5zosD#5Y}>r^zu+{E;Zq^hS=cO(=gS!bEp2^pLwla|0*BvC_^t)wz68iTNyvcN98 zsOpD#_nLVu;7l6{5W&$lK02`n(^J;@F1OMw9#6(b*FWtS*8qT3R2Psun+I$s2I(R!wc%ldiv7OMrJWg^D~A4_EEFOSCG3ClCx4Qc(;

    )REEwAWT`L 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

    {5X=v%9*=&k-Cu}9= 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

    Gp)DFl_rfyc0qS)dW7}QBe$k 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 Wsv|;s*midS0000 + +## Quick start + + +The adapter auto-detects `XCHAT_BOT_TOKEN`, `XCHAT_USER_ID`, `XCHAT_PIN`, and `X_CONSUMER_SECRET` from the environment. The bot's @handle is resolved from `GET /2/users/me` at startup. + + +```typescript title="lib/bot.ts" lineNumbers +import { Chat } from "chat"; +import { createXchatAdapter } from "@chat-adapter/xchat"; + +const bot = new Chat({ + userName: "mybot", + adapters: { + xchat: createXchatAdapter(), + }, +}); + +bot.onDirectMessage(async (thread, message) => { + await thread.post(`You said: ${message.text}`); +}); + +bot.onNewMention(async (thread, message) => { + await thread.post(`You said: ${message.text}`); +}); +``` + +X sends two kinds of webhook requests: a **CRC challenge** (GET) answered with an HMAC-SHA256 of the token keyed by your app's consumer secret, and **event delivery** (POST) verified by the adapter via the `x-twitter-webhooks-signature` header. Handle the CRC challenge at the route level; it needs no adapter state: + +```typescript title="app/api/webhooks/xchat/route.ts" lineNumbers +import { createHmac } from "node:crypto"; +import { bot } from "@/lib/bot"; + +export async function GET(request: Request) { + const url = new URL(request.url); + const crcToken = url.searchParams.get("crc_token"); + if (!crcToken) { + return new Response("Missing crc_token", { status: 400 }); + } + const hash = createHmac("sha256", process.env.X_CONSUMER_SECRET!) + .update(crcToken) + .digest("base64"); + return Response.json({ response_token: `sha256=${hash}` }); +} + +export async function POST(request: Request) { + return bot.webhooks.xchat(request); +} +``` + +## Configuration + + + +## Setup + +### 1. Register encryption keys + +The bot account needs registered public keys and a Juicebox-backed private-key store before it can participate in encrypted conversations: + +1. Generate keypairs with [`chat-xdk`](https://github.com/xdevplatform/chat-xdk) (`generateKeypairs()`). +2. Register them via `POST /2/users/{id}/public_keys`. +3. Store the private keys in Juicebox with a PIN (`chat.setup(pin)`). + +The adapter unlocks the keys at startup with the same PIN (`XCHAT_PIN`). Registration is a one-time step per account. + +### 2. Create a webhook + +Register a webhook URL so the [X Activity API](https://docs.x.com/x-api/activity/introduction) can deliver events: + +```bash +curl -X POST "https://api.x.com/2/webhooks" \ + -H "Authorization: Bearer $APP_BEARER_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"url": "https://your-domain.com/api/webhooks/xchat"}' +``` + +X validates the URL with a CRC challenge, so the endpoint must be live before you create the webhook. Webhooks and activity subscriptions can also be managed in the [X Developer Portal](https://developer.x.com/en/portal/dashboard). + +### 3. Subscribe to chat events + +Create [activity subscriptions](https://docs.x.com/x-api/activity/create-x-activity-subscription) for the bot user with the bot's OAuth 2.0 user token: + +```bash +curl -X POST "https://api.x.com/2/activity/subscriptions" \ + -H "Authorization: Bearer $BOT_USER_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "event_type": "chat.received", + "filter": {"user_id": "YOUR_BOT_USER_ID"}, + "tag": "bot-chat-received", + "webhook_id": "YOUR_WEBHOOK_ID" + }' +``` + +Subscribe to `chat.conversation_join` as well if you want the bot to post a welcome message when it is added to a group. + +## Environment variables + +```bash +XCHAT_BOT_TOKEN=xcbot_... # OAuth2 user token for the bot account +XCHAT_USER_ID=1234567890 # Bot's numeric user ID +XCHAT_PIN=... # Juicebox PIN for key unlock +X_CONSUMER_SECRET=... # App secret (CRC + webhook signature verification) +X_BOT_USERNAME=... # Optional @handle override; resolved from /2/users/me otherwise +X_VERIFY_SIGNATURES=true # Optional; set false to accept unverifiable messages +``` + +## Advanced + +### Encryption + +Every XChat conversation is encrypted. The adapter handles the full crypto lifecycle transparently: conversation-key extraction and caching, message decryption and signature verification, and encryption + signing on send. Conversation keys arrive via `KeyChange` events and are cached per conversation and key version. Incoming message signatures are verified against participants' signing keys; with `verifySignatures: true` (the default), unverifiable messages are dropped. Media is encrypted separately from message text using streaming encryption. + +### Formatting + +XChat has no client-side markdown rendering — outgoing markdown appears literally as plain text. URLs and @mentions are detected in outgoing text and rendered as tappable links and mention pills, tables are rendered as ASCII code blocks, and cards degrade to text with URL/mention entities plus a URL preview attachment (the first `x.com/.../status/...` URL in outgoing text auto-attaches as a post card). + +### Edits, deletes, and streaming + +The adapter can edit and delete only the bot's own messages. The first edit of a fresh message is held until the message is `editSafetyDelayMs` old (default 5000ms), so receiving clients have stored the original before the edit arrives. Deletes are delete-for-all. Streaming works through message edits, but the age gate makes rapid token-by-token updates coarse. + +### Mention behavior in groups + +`bot.onNewMention(handler)` fires for group messages that mention the bot. A group message counts as a mention when its rich-text mention entities include the bot's @handle or user ID, when it is a swipe-reply to one of the bot's own messages, or when its plain text contains `@handle` (fallback when no entities are present). To reply to every group message instead, register a catch-all `bot.onNewMessage(/.+/, handler)`. + +### Open DM + +`openDM(userId)` reuses an existing conversation or runs a fresh key exchange so the bot can message first. It requires the recipient to have encrypted chat set up, and the server requires the recipient to trust the bot (e.g. follow it) before the first message is accepted. + +### Read receipts and typing + +A read receipt is sent for each delivered inbound message before handlers run unless `sendReadReceipts: false`. The typing indicator is re-sent every 3 seconds while a handler runs. + +### Thread ID format + +``` +xchat:{conversationId} +``` + +- 1:1 conversations: `xchat:1234567890-9876543210` (both participant IDs) +- Group conversations: `xchat:g123456789` (opaque `g`-prefixed ID) + +REST paths use the other participant's user ID for 1:1 conversations and the `g...` ID for groups; the adapter converts automatically. + +## Feature support + + diff --git a/packages/chat/src/adapters/index.ts b/packages/chat/src/adapters/index.ts index 5e629e3b0..03368d712 100644 --- a/packages/chat/src/adapters/index.ts +++ b/packages/chat/src/adapters/index.ts @@ -1093,6 +1093,51 @@ export const ADAPTERS = { slug: "x", type: "platform", }, + xchat: { + description: + "Hold encrypted 1:1 and group conversations on XChat with all cryptography handled inside the adapter.", + env: { + optional: [ + secretEnv( + "X_CONSUMER_SECRET", + "App consumer secret for webhook CRC and signature verification. Incoming webhook POSTs are not signature-verified when omitted." + ), + env( + "X_BOT_USERNAME", + "Bot account handle used for mention detection. Resolved from /2/users/me when omitted." + ), + env( + "X_VERIFY_SIGNATURES", + "Set to false to accept messages without verifiable signatures. Defaults to true." + ), + env( + "X_SIGNING_KEY_VERSION", + "Signing key version override. Fetched from the X API when omitted." + ), + ], + required: [ + secretEnv( + "XCHAT_BOT_TOKEN", + "OAuth 2.0 user access token for the bot account.", + { aliases: ["X_ACCESS_TOKEN"] } + ), + env("XCHAT_USER_ID", "Bot account numeric X user ID.", { + aliases: ["X_USER_ID"], + }), + secretEnv( + "XCHAT_PIN", + "Juicebox PIN used to unlock the bot's private keys at startup." + ), + ], + }, + factoryExport: "createXchatAdapter", + group: "official", + name: "XChat", + packageName: "@chat-adapter/xchat", + peerDeps: ["@xdevplatform/chat-xdk", "@xdevplatform/xdk", "juicebox-sdk"], + slug: "xchat", + type: "platform", + }, zernio: { description: "Unified social media DM adapter covering Instagram, Facebook, Telegram, WhatsApp, X/Twitter, Bluesky, and Reddit through a single integration.", diff --git a/packages/create-chat-sdk/src/catalog/scaffold-spec.ts b/packages/create-chat-sdk/src/catalog/scaffold-spec.ts index f1d910545..1a02188af 100644 --- a/packages/create-chat-sdk/src/catalog/scaffold-spec.ts +++ b/packages/create-chat-sdk/src/catalog/scaffold-spec.ts @@ -329,6 +329,9 @@ export const CLI_SCAFFOLD_SPEC = { x: { invocation: { kind: "zero-arg" }, }, + xchat: { + invocation: { kind: "zero-arg" }, + }, zernio: { invocation: { kind: "zero-arg" }, }, diff --git a/packages/integration-tests/src/docs-adapters.test.ts b/packages/integration-tests/src/docs-adapters.test.ts index 656850d06..513f15de3 100644 --- a/packages/integration-tests/src/docs-adapters.test.ts +++ b/packages/integration-tests/src/docs-adapters.test.ts @@ -262,6 +262,7 @@ describe("Official platform adapter OG images", () => { "web", "whatsapp", "x", + "xchat", ].sort() ); }); From ab9534be97b42b3f6b05a4e11a7d10fa1259a751 Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 13:27:28 -0700 Subject: [PATCH 5/7] feat(xchat): resolve the bot user id from /2/users/me when not configured userId (and XCHAT_USER_ID / X_USER_ID) becomes optional: initialize() resolves the id and @handle from a single GET /2/users/me call when either is missing, so the only required credentials are the token and the PIN. --- apps/docs/content/adapters/official/xchat.mdx | 4 +- packages/adapter-xchat/README.md | 4 +- packages/adapter-xchat/src/index.test.ts | 11 ++-- packages/adapter-xchat/src/index.ts | 54 +++++++++++-------- packages/adapter-xchat/src/types.ts | 3 +- packages/chat/src/adapters/index.ts | 8 +-- 6 files changed, 47 insertions(+), 37 deletions(-) diff --git a/apps/docs/content/adapters/official/xchat.mdx b/apps/docs/content/adapters/official/xchat.mdx index 87eb0f03a..d5d501c2d 100644 --- a/apps/docs/content/adapters/official/xchat.mdx +++ b/apps/docs/content/adapters/official/xchat.mdx @@ -120,7 +120,7 @@ export async function POST(request: Request) { userId: { type: "string", description: - "Bot's numeric X user ID. Auto-detected from `XCHAT_USER_ID` or `X_USER_ID`.", + "Bot's numeric X user ID. Auto-detected from `XCHAT_USER_ID` or `X_USER_ID`, otherwise resolved from `GET /2/users/me` at startup.", }, pin: { type: "string", @@ -220,7 +220,7 @@ Subscribe to `chat.conversation_join` as well if you want the bot to post a welc ```bash XCHAT_BOT_TOKEN=xcbot_... # OAuth2 user token for the bot account -XCHAT_USER_ID=1234567890 # Bot's numeric user ID +XCHAT_USER_ID=1234567890 # Optional: bot's numeric user ID (resolved from /2/users/me when unset) XCHAT_PIN=... # Juicebox PIN for key unlock X_CONSUMER_SECRET=... # App secret (CRC + webhook signature verification) X_BOT_USERNAME=... # Optional @handle override; resolved from /2/users/me otherwise diff --git a/packages/adapter-xchat/README.md b/packages/adapter-xchat/README.md index 4961e66df..c315699c8 100644 --- a/packages/adapter-xchat/README.md +++ b/packages/adapter-xchat/README.md @@ -151,7 +151,7 @@ All options are auto-detected from environment variables when not provided. | Option | Required | Description | |--------|----------|-------------| | `botToken` / `accessToken` | No* | OAuth2 user access token for the bot account. Auto-detected from `XCHAT_BOT_TOKEN` or `X_ACCESS_TOKEN` | -| `userId` | No* | Bot's numeric X user ID. Auto-detected from `XCHAT_USER_ID` or `X_USER_ID` | +| `userId` | No | Bot's numeric X user ID. Auto-detected from `XCHAT_USER_ID` or `X_USER_ID`, otherwise resolved from `GET /2/users/me` at startup | | `pin` | No | Juicebox PIN; when set, keys unlock automatically during `initialize()`. Auto-detected from `XCHAT_PIN` | | `consumerSecret` | No | App consumer secret for webhook signature verification. Auto-detected from `X_CONSUMER_SECRET`. When unset, incoming webhook POSTs are **not** signature-verified (a warning is logged at startup) | | `editSafetyDelayMs` | No | Minimum age (ms) a freshly posted message must reach before its first edit is sent, so receiving clients have stored the original the edit targets. Defaults to `5000`; `0` disables the wait | @@ -170,7 +170,7 @@ All options are auto-detected from environment variables when not provided. ```bash XCHAT_BOT_TOKEN=xcbot_... # OAuth2 user token for the bot account -XCHAT_USER_ID=1234567890 # Bot's numeric user ID +XCHAT_USER_ID=1234567890 # Optional: bot's numeric user ID (resolved from /2/users/me when unset) XCHAT_PIN=... # Juicebox PIN for key unlock X_CONSUMER_SECRET=... # App secret (CRC + webhook signature verification) X_BOT_USERNAME=... # Optional @handle override; resolved from /2/users/me otherwise diff --git a/packages/adapter-xchat/src/index.test.ts b/packages/adapter-xchat/src/index.test.ts index a2d28abbe..53162054d 100644 --- a/packages/adapter-xchat/src/index.test.ts +++ b/packages/adapter-xchat/src/index.test.ts @@ -428,13 +428,12 @@ describe("createXchatAdapter", () => { ).toThrow(MISSING_ACCESS_TOKEN_RE); }); - it("should throw when userId is missing", async () => { + it("should not require userId (resolved from /2/users/me at initialize)", async () => { const { createXchatAdapter } = await import("./index"); - expect(() => - createXchatAdapter({ - accessToken: "token", - }) - ).toThrow(MISSING_USER_ID_RE); + const adapter = createXchatAdapter({ + accessToken: "token", + }); + expect(adapter).toBeDefined(); }); it("should create adapter with only required config (interactive mode)", async () => { diff --git a/packages/adapter-xchat/src/index.ts b/packages/adapter-xchat/src/index.ts index a1e09e7c3..92c176f32 100644 --- a/packages/adapter-xchat/src/index.ts +++ b/packages/adapter-xchat/src/index.ts @@ -581,7 +581,8 @@ export class XchatAdapter implements Adapter { private readonly accessToken: string; private readonly apiHeaders: Record; private readonly consumerSecret: string | undefined; - private readonly userId: string; + /** Bot user id (from config or resolved from GET /2/users/me) */ + private userId: string; /** Populated during initialize() from the X API, or from config override */ private signingKeyVersion: string | null; /** Juicebox PIN; when set, initialize() auto-unlocks after createChat */ @@ -648,14 +649,13 @@ export class XchatAdapter implements Adapter { config: XchatAdapterConfig & { accessToken: string; logger: Logger; - userId: string; } ) { this.accessToken = config.accessToken; this.apiHeaders = { ...config.apiHeaders }; this.apiBaseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL; this.consumerSecret = config.consumerSecret; - this.userId = config.userId; + this.userId = config.userId ?? ""; this.signingKeyVersion = config.signingKeyVersion ?? null; this.pin = config.pin; this.verifySignatures = config.verifySignatures ?? true; @@ -699,22 +699,34 @@ export class XchatAdapter implements Adapter { headers: this.apiHeaders, }); - // Resolve @handle from /2/users/me unless the caller set userName explicitly - if (!this.userNameFromConfig) { + // Resolve identity from /2/users/me unless the caller provided both + // the user id and the @handle explicitly. + if (!(this.userId && this.userNameFromConfig)) { const me = await this.xdkClient.users.getMe(); + const id = me?.data?.id; const username = me?.data?.username; - if (typeof username === "string" && username.length > 0) { - this._userName = username; - this.logger.info("Resolved bot username from /2/users/me", { - userName: this._userName, - userId: this.userId, - }); - } else { - this.logger.warn( - "GET /2/users/me did not return a username; keeping placeholder", - { userName: this._userName } - ); + if (!this.userId) { + if (typeof id !== "string" || id.length === 0) { + throw new Error( + "GET /2/users/me did not return a user id; set userId (or XCHAT_USER_ID) explicitly" + ); + } + this.userId = id; + } + if (!this.userNameFromConfig) { + if (typeof username === "string" && username.length > 0) { + this._userName = username; + } else { + this.logger.warn( + "GET /2/users/me did not return a username; keeping placeholder", + { userName: this._userName } + ); + } } + this.logger.info("Resolved bot identity from /2/users/me", { + userId: this.userId, + userName: this._userName, + }); } // 2. Fetch signing key version + Juicebox config from the X API @@ -2749,9 +2761,10 @@ export class XchatAdapter implements Adapter { * * **Required** (via config or env vars): * - `botToken` / `accessToken` / `XCHAT_BOT_TOKEN` / `X_ACCESS_TOKEN`: OAuth2 access token - * - `userId` / `XCHAT_USER_ID` / `X_USER_ID`: The bot's numeric user ID * * **Optional:** + * - `userId` / `XCHAT_USER_ID` / `X_USER_ID`: The bot's numeric user ID. + * When omitted, initialize() resolves it from GET /2/users/me. * - `pin` / `XCHAT_PIN`: Juicebox PIN; when set, initialize() auto-unlocks * - `signingKeyVersion` / `X_SIGNING_KEY_VERSION`: Override for signing key version. * When omitted, fetched automatically from the X API during initialize(). @@ -2776,14 +2789,9 @@ export function createXchatAdapter(config?: XchatAdapterConfig): XchatAdapter { ); } + // Optional: when omitted, initialize() resolves the id from /2/users/me. const userId = config?.userId ?? process.env.XCHAT_USER_ID ?? process.env.X_USER_ID; - if (!userId) { - throw new ValidationError( - "xchat", - "userId is required. Set XCHAT_USER_ID or X_USER_ID, or provide it in config." - ); - } const consumerSecret = config?.consumerSecret ?? process.env.X_CONSUMER_SECRET ?? undefined; diff --git a/packages/adapter-xchat/src/types.ts b/packages/adapter-xchat/src/types.ts index bd5555daf..21b091748 100644 --- a/packages/adapter-xchat/src/types.ts +++ b/packages/adapter-xchat/src/types.ts @@ -68,7 +68,8 @@ export interface XchatAdapterConfig { signingKeyVersion?: string; /** * The authenticated user's numeric X user ID. When omitted, resolved from - * the `XCHAT_USER_ID` or `X_USER_ID` env var by `createXchatAdapter`. + * the `XCHAT_USER_ID` or `X_USER_ID` env var by `createXchatAdapter`, or + * from `GET /2/users/me` during `initialize()`. */ userId?: string; /** diff --git a/packages/chat/src/adapters/index.ts b/packages/chat/src/adapters/index.ts index 03368d712..7887c526d 100644 --- a/packages/chat/src/adapters/index.ts +++ b/packages/chat/src/adapters/index.ts @@ -1106,6 +1106,11 @@ export const ADAPTERS = { "X_BOT_USERNAME", "Bot account handle used for mention detection. Resolved from /2/users/me when omitted." ), + env( + "XCHAT_USER_ID", + "Bot account numeric X user ID. Resolved from /2/users/me when omitted.", + { aliases: ["X_USER_ID"] } + ), env( "X_VERIFY_SIGNATURES", "Set to false to accept messages without verifiable signatures. Defaults to true." @@ -1121,9 +1126,6 @@ export const ADAPTERS = { "OAuth 2.0 user access token for the bot account.", { aliases: ["X_ACCESS_TOKEN"] } ), - env("XCHAT_USER_ID", "Bot account numeric X user ID.", { - aliases: ["X_USER_ID"], - }), secretEnv( "XCHAT_PIN", "Juicebox PIN used to unlock the bot's private keys at startup." From bb1624b903f484e2c794e97242a4c629707bf0e7 Mon Sep 17 00:00:00 2001 From: Santiago Medina Rolong Date: Sat, 25 Jul 2026 13:38:25 -0700 Subject: [PATCH 6/7] feat(xchat): drop the user id from config entirely The bot's identity is fully determined by the token, so the userId config field and the XCHAT_USER_ID / X_USER_ID env vars are gone; initialize() always resolves the id and @handle from GET /2/users/me. The only required credentials are the bot token and the Juicebox PIN. Also relabels the OG image row as X Chat. --- .changeset/xchat-adapter.md | 2 +- .../content/adapters/official/og/xchat.png | Bin 290899 -> 392382 bytes apps/docs/content/adapters/official/xchat.mdx | 8 +------- packages/adapter-xchat/README.md | 2 -- packages/adapter-xchat/src/index.test.ts | 19 ++---------------- packages/adapter-xchat/src/index.ts | 11 +++------- packages/adapter-xchat/src/types.ts | 6 ------ packages/chat/src/adapters/index.ts | 5 ----- turbo.json | 1 - 9 files changed, 7 insertions(+), 47 deletions(-) diff --git a/.changeset/xchat-adapter.md b/.changeset/xchat-adapter.md index 9ebc92506..6c1872dd2 100644 --- a/.changeset/xchat-adapter.md +++ b/.changeset/xchat-adapter.md @@ -4,7 +4,7 @@ "create-chat-sdk": patch --- -New XChat adapter for X's encrypted messaging. All cryptography is handled inside the adapter via `@xdevplatform/chat-xdk` (wasm) and all REST goes through the typed `@xdevplatform/xdk` client. +New XChat adapter for X's encrypted messaging. All cryptography is handled inside the adapter via `@xdevplatform/chat-xdk` (wasm) and all REST goes through the typed `@xdevplatform/xdk` client. Only a bot token and a Juicebox PIN are required — the bot's identity (user id and @handle) is resolved from `GET /2/users/me` at startup. - Encrypted send/receive in DMs and groups (webhook push + polling), signature verification on by default; undecryptable or unverified events are dropped - Mention detection from structured mention entities, swipe-replies to the bot, and a plain-text `@handle` fallback; group replies sent as quoted replies diff --git a/apps/docs/content/adapters/official/og/xchat.png b/apps/docs/content/adapters/official/og/xchat.png index eed8bd8f4de28c4fd43e3c67dc63cc45b14953bb..ec5b054f1a13b1c4dd6df3423e418d92fede9527 100644 GIT binary patch literal 392382 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 z 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

    gAH^>bc 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%0D? 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

    h<2+Hov4;3F`DO$Y)M!smMj1J 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