@cloudrise/openclaw-channel-rocketchat 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,20 @@
+# @cloudrise/openclaw-channel-rocketchat
+
+Rocket.Chat channel plugin for **OpenClaw** (Cloudrise-maintained).
+
+- **Inbound:** Rocket.Chat Realtime (DDP/WebSocket) subscribe to `stream-room-messages`
+- **Outbound:** Rocket.Chat REST `chat.postMessage`
+
+## Install
+
+```bash
+npm i @cloudrise/openclaw-channel-rocketchat
+```
+
+## Upgrade / rename notice
+
+If you were using the old Clawdbot-era package:
+
+- Old: `@cloudrise/clawdbot-channel-rocketchat`
+- New: `@cloudrise/openclaw-channel-rocketchat`
+

package/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Rocket.Chat channel plugin for OpenClaw
+ * 
+ * Provides integration with self-hosted Rocket.Chat instances via REST API
+ * for sending messages and the Realtime/DDP API for receiving messages.
+ */
+
+import type { OpenclawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+
+import { rocketChatPlugin } from "./src/channel.js";
+import { setRocketChatRuntime } from "./src/runtime.js";
+
+const plugin = {
+  id: "rocketchat",
+  name: "Rocket.Chat",
+  description: "Rocket.Chat channel plugin for OpenClaw",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenclawPluginApi) {
+    setRocketChatRuntime(api.runtime);
+    api.registerChannel({ plugin: rocketChatPlugin });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,12 @@
+{
+  "id": "rocketchat",
+  "name": "Rocket.Chat",
+  "description": "Rocket.Chat channel plugin for OpenClaw",
+  "version": "0.1.0",
+  "channels": ["rocketchat"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@cloudrise/openclaw-channel-rocketchat",
+  "version": "0.1.0",
+  "description": "Rocket.Chat channel plugin for OpenClaw (Cloudrise)",
+  "type": "module",
+  "main": "index.ts",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "rocketchat",
+      "label": "Rocket.Chat",
+      "selectionLabel": "Rocket.Chat (self-hosted)",
+      "docsPath": "/channels/rocketchat",
+      "docsLabel": "rocketchat",
+      "blurb": "Self-hosted team chat via Rocket.Chat REST + Realtime API.",
+      "order": 66,
+      "aliases": [
+        "rc",
+        "rocket"
+      ]
+    }
+  },
+  "dependencies": {
+    "ws": "^8.14.0"
+  },
+  "peerDependencies": {
+    "openclaw": "*"
+  }
+}

package/src/channel.ts

@@ -0,0 +1,231 @@
+/**
+ * Rocket.Chat channel plugin for OpenClaw
+ */
+
+import {
+  DEFAULT_ACCOUNT_ID,
+  type ChannelPlugin,
+} from "openclaw/plugin-sdk";
+
+import {
+  listRocketChatAccountIds,
+  resolveDefaultRocketChatAccountId,
+  resolveRocketChatAccount,
+  type ResolvedRocketChatAccount,
+} from "./rocketchat/accounts.js";
+import { normalizeRocketChatBaseUrl } from "./rocketchat/client.js";
+import { monitorRocketChatProvider } from "./rocketchat/monitor.js";
+import { sendMessageRocketChat } from "./rocketchat/send.js";
+import { getRocketChatRuntime } from "./runtime.js";
+
+const meta = {
+  id: "rocketchat",
+  label: "Rocket.Chat",
+  selectionLabel: "Rocket.Chat (plugin)",
+  detailLabel: "Rocket.Chat Bot",
+  docsPath: "/channels/rocketchat",
+  docsLabel: "rocketchat",
+  blurb: "Self-hosted team chat via Rocket.Chat REST + Realtime API.",
+  systemImage: "bubble.left.and.bubble.right",
+  order: 66,
+  aliases: ["rc", "rocket"],
+  quickstartAllowFrom: true,
+} as const;
+
+function normalizeAllowEntry(entry: string): string {
+  return entry
+    .trim()
+    .replace(/^(rocketchat|user):/i, "")
+    .replace(/^@/, "")
+    .toLowerCase();
+}
+
+function formatAllowEntry(entry: string): string {
+  const trimmed = entry.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("@")) {
+    const username = trimmed.slice(1).trim();
+    return username ? `@${username.toLowerCase()}` : "";
+  }
+  return trimmed.replace(/^(rocketchat|user):/i, "").toLowerCase();
+}
+
+function looksLikeRocketChatTargetId(value: string): boolean {
+  const trimmed = value.trim();
+  // Rocket.Chat room IDs are typically 17-character alphanumeric
+  if (/^[A-Za-z0-9]{17}$/.test(trimmed)) return true;
+  if (trimmed.startsWith("#") || trimmed.startsWith("@")) return true;
+  if (trimmed.toLowerCase().startsWith("room:")) return true;
+  if (trimmed.toLowerCase().startsWith("user:")) return true;
+  return false;
+}
+
+function normalizeRocketChatMessagingTarget(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  return trimmed;
+}
+
+export const rocketChatPlugin: ChannelPlugin<ResolvedRocketChatAccount> = {
+  id: "rocketchat",
+  meta: {
+    ...meta,
+  },
+  pairing: {
+    idLabel: "rocketchatUserId",
+    normalizeAllowEntry,
+    notifyApproval: async ({ id }) => {
+      console.log(`[rocketchat] User ${id} approved for pairing`);
+    },
+  },
+  capabilities: {
+    chatTypes: ["direct", "channel", "group", "thread"],
+    threads: true,
+    media: true,
+  },
+  streaming: {
+    blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
+  },
+  reload: { configPrefixes: ["channels.rocketchat"] },
+  config: {
+    listAccountIds: (cfg) => listRocketChatAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveRocketChatAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultRocketChatAccountId(cfg),
+    isConfigured: (account) =>
+      Boolean(account.authToken && account.userId && account.baseUrl),
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: Boolean(account.authToken && account.userId && account.baseUrl),
+      authTokenSource: account.authTokenSource,
+      baseUrl: account.baseUrl,
+    }),
+    resolveAllowFrom: ({ cfg, accountId }) =>
+      (resolveRocketChatAccount({ cfg, accountId }).config.allowFrom ?? []).map(String),
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom.map((entry) => formatAllowEntry(String(entry))).filter(Boolean),
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+      const rcConfig = (cfg as Record<string, unknown>).channels?.rocketchat;
+      const useAccountPath = Boolean(rcConfig?.accounts?.[resolvedAccountId]);
+      const basePath = useAccountPath
+        ? `channels.rocketchat.accounts.${resolvedAccountId}.`
+        : "channels.rocketchat.";
+      return {
+        policy: account.config.dmPolicy ?? "pairing",
+        allowFrom: account.config.allowFrom ?? [],
+        policyPath: `${basePath}dmPolicy`,
+        allowFromPath: basePath,
+        approveHint: `openclaw pairing approve rocketchat <code>`,
+        normalizeEntry: normalizeAllowEntry,
+      };
+    },
+  },
+  messaging: {
+    normalizeTarget: normalizeRocketChatMessagingTarget,
+    targetResolver: {
+      looksLikeId: looksLikeRocketChatTargetId,
+      hint: "<roomId|#channel|@username|room:ID|user:USERNAME>",
+    },
+  },
+  outbound: {
+    deliveryMode: "direct",
+    chunker: (text, limit) =>
+      getRocketChatRuntime().channel?.text?.chunkMarkdownText?.(text, limit) ?? [text],
+    chunkerMode: "markdown",
+    textChunkLimit: 4000,
+    resolveTarget: ({ to }) => {
+      const trimmed = to?.trim();
+      if (!trimmed) {
+        return {
+          ok: false,
+          error: new Error(
+            "Delivering to Rocket.Chat requires --to <roomId|#channel|@username>"
+          ),
+        };
+      }
+      return { ok: true, to: trimmed };
+    },
+    sendText: async ({ to, text, accountId, replyToId }) => {
+      const result = await sendMessageRocketChat(to, text, {
+        accountId: accountId ?? undefined,
+        replyToId: replyToId ?? undefined,
+      });
+      return { channel: "rocketchat", ...result };
+    },
+    sendMedia: async ({ to, text, mediaUrl, accountId, replyToId }) => {
+      const result = await sendMessageRocketChat(to, text, {
+        accountId: accountId ?? undefined,
+        mediaUrl,
+        replyToId: replyToId ?? undefined,
+      });
+      return { channel: "rocketchat", ...result };
+    },
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      connected: false,
+      lastConnectedAt: null,
+      lastDisconnect: null,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      authTokenSource: snapshot.authTokenSource ?? "none",
+      running: snapshot.running ?? false,
+      connected: snapshot.connected ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+      baseUrl: snapshot.baseUrl ?? null,
+      probe: snapshot.probe,
+      lastProbeAt: snapshot.lastProbeAt ?? null,
+    }),
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: Boolean(account.authToken && account.userId && account.baseUrl),
+      authTokenSource: account.authTokenSource,
+      baseUrl: account.baseUrl,
+      running: runtime?.running ?? false,
+      connected: runtime?.connected ?? false,
+      lastConnectedAt: runtime?.lastConnectedAt ?? null,
+      lastDisconnect: runtime?.lastDisconnect ?? null,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      probe,
+      lastInboundAt: runtime?.lastInboundAt ?? null,
+      lastOutboundAt: runtime?.lastOutboundAt ?? null,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      ctx.setStatus({
+        accountId: account.accountId,
+        baseUrl: account.baseUrl,
+        authTokenSource: account.authTokenSource,
+      });
+      ctx.log?.info(`[${account.accountId}] starting Rocket.Chat channel`);
+      return monitorRocketChatProvider({
+        authToken: account.authToken ?? undefined,
+        userId: account.userId ?? undefined,
+        baseUrl: account.baseUrl ?? undefined,
+        accountId: account.accountId,
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
+      });
+    },
+  },
+};

package/src/rocketchat/accounts.ts

@@ -0,0 +1,128 @@
+/**
+ * Rocket.Chat account resolution
+ */
+
+import type { OpenclawConfig } from "openclaw/plugin-sdk";
+
+export type RocketChatReplyMode = "thread" | "channel" | "auto";
+
+type RocketChatRoomConfig = {
+  requireMention?: boolean;
+  /** Optional per-room override. Use the room rid (e.g. GENERAL), not the channel name. */
+  replyMode?: RocketChatReplyMode;
+};
+
+export type RocketChatAccountConfig = {
+  enabled?: boolean;
+  name?: string;
+  baseUrl?: string;
+  userId?: string;
+  authToken?: string;
+  authTokenFile?: string;
+  dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: string[];
+  groupPolicy?: "allowlist" | "open" | "disabled";
+  groupAllowFrom?: string[];
+  rooms?: Record<string, RocketChatRoomConfig>;
+
+  /** Reply mode selection (thread | channel | auto). Default: thread (legacy behavior). */
+  replyMode?: RocketChatReplyMode;
+
+  /** Back-compat: if true, behave like replyMode=thread; if false, replyMode=channel. */
+  replyInThread?: boolean;
+
+  /** Typing indicator delay (ms) before emitting user-typing. Default 1000. */
+  typingDelayMs?: number;
+};
+
+export type ResolvedRocketChatAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  baseUrl?: string;
+  userId?: string;
+  authToken?: string;
+  authTokenSource: "config" | "env" | "file" | "none";
+  config: RocketChatAccountConfig;
+};
+
+const DEFAULT_ACCOUNT_ID = "default";
+
+function getRocketChatConfig(cfg: OpenclawConfig): Record<string, unknown> | undefined {
+  return (cfg as Record<string, unknown>).channels?.rocketchat;
+}
+
+export function listRocketChatAccountIds(cfg: OpenclawConfig): string[] {
+  const rc = getRocketChatConfig(cfg);
+  if (!rc) return [];
+
+  const accounts = rc.accounts as Record<string, unknown> | undefined;
+  if (accounts && typeof accounts === "object") {
+    return Object.keys(accounts);
+  }
+
+  // Check for top-level config (legacy/default account)
+  if (rc.baseUrl || rc.userId || rc.authToken) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+
+  return [];
+}
+
+export function resolveDefaultRocketChatAccountId(cfg: OpenclawConfig): string {
+  const ids = listRocketChatAccountIds(cfg);
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+export function resolveRocketChatAccount(opts: {
+  cfg: OpenclawConfig;
+  accountId?: string;
+}): ResolvedRocketChatAccount {
+  const { cfg, accountId: rawAccountId } = opts;
+  const accountId = rawAccountId?.trim() || resolveDefaultRocketChatAccountId(cfg);
+  const rc = getRocketChatConfig(cfg) ?? {};
+
+  const accounts = rc.accounts as Record<string, RocketChatAccountConfig> | undefined;
+  const accountConfig = accounts?.[accountId];
+
+  // Check for top-level config (default account)
+  const isDefaultPath = accountId === DEFAULT_ACCOUNT_ID && !accountConfig;
+  const config: RocketChatAccountConfig = accountConfig ?? (isDefaultPath ? rc : {});
+
+  // Resolve auth token from config, env, or file
+  let authToken = config.authToken as string | undefined;
+  let authTokenSource: "config" | "env" | "file" | "none" = "none";
+
+  if (authToken) {
+    authTokenSource = "config";
+  } else if (accountId === DEFAULT_ACCOUNT_ID) {
+    const envToken = process.env.ROCKETCHAT_AUTH_TOKEN;
+    if (envToken) {
+      authToken = envToken;
+      authTokenSource = "env";
+    }
+  }
+
+  // Resolve user ID from config or env
+  let userId = config.userId as string | undefined;
+  if (!userId && accountId === DEFAULT_ACCOUNT_ID) {
+    userId = process.env.ROCKETCHAT_USER_ID;
+  }
+
+  // Resolve base URL from config or env
+  let baseUrl = config.baseUrl as string | undefined;
+  if (!baseUrl && accountId === DEFAULT_ACCOUNT_ID) {
+    baseUrl = process.env.ROCKETCHAT_URL;
+  }
+
+  return {
+    accountId,
+    name: config.name,
+    enabled: config.enabled !== false,
+    baseUrl,
+    userId,
+    authToken,
+    authTokenSource,
+    config,
+  };
+}

package/src/rocketchat/client.ts

@@ -0,0 +1,227 @@
+/**
+ * Rocket.Chat REST API client
+ */
+
+export type RocketChatClient = {
+  baseUrl: string;
+  userId: string;
+  authToken: string;
+  fetch: typeof fetch;
+};
+
+export type RocketChatUser = {
+  _id: string;
+  username: string;
+  name?: string;
+  status?: string;
+};
+
+export type RocketChatRoom = {
+  _id: string;
+  name?: string;
+  fname?: string;
+  t: "c" | "p" | "d" | "l"; // channel, private, direct, livechat
+  usernames?: string[];
+  usersCount?: number;
+  msgs?: number;
+  default?: boolean;
+  topic?: string;
+};
+
+export type RocketChatMessage = {
+  _id: string;
+  rid: string;
+  msg: string;
+  ts: string;
+  u: RocketChatUser;
+  _updatedAt: string;
+  mentions?: RocketChatUser[];
+  channels?: { _id: string; name: string }[];
+  attachments?: RocketChatAttachment[];
+  tmid?: string; // thread message id
+  t?: string; // system message type
+};
+
+export type RocketChatAttachment = {
+  title?: string;
+  title_link?: string;
+  image_url?: string;
+  audio_url?: string;
+  video_url?: string;
+  type?: string;
+};
+
+export function createRocketChatClient(opts: {
+  baseUrl: string;
+  userId: string;
+  authToken: string;
+}): RocketChatClient {
+  const baseUrl = normalizeRocketChatBaseUrl(opts.baseUrl);
+  if (!baseUrl) throw new Error("Invalid Rocket.Chat baseUrl");
+  return {
+    baseUrl,
+    userId: opts.userId,
+    authToken: opts.authToken,
+    fetch: globalThis.fetch,
+  };
+}
+
+export function normalizeRocketChatBaseUrl(url?: string): string | null {
+  if (!url) return null;
+  const trimmed = url.trim().replace(/\/+$/, "");
+  if (!trimmed) return null;
+  try {
+    const parsed = new URL(trimmed.startsWith("http") ? trimmed : `https://${trimmed}`);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return null;
+  }
+}
+
+async function rcFetch<T>(
+  client: RocketChatClient,
+  path: string,
+  opts: RequestInit = {}
+): Promise<T> {
+  const url = `${client.baseUrl}${path}`;
+  const headers: Record<string, string> = {
+    "X-Auth-Token": client.authToken,
+    "X-User-Id": client.userId,
+    "Content-Type": "application/json",
+    ...(opts.headers as Record<string, string> ?? {}),
+  };
+  const res = await client.fetch(url, { ...opts, headers });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Rocket.Chat API error ${res.status}: ${text}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+export async function fetchRocketChatMe(client: RocketChatClient): Promise<RocketChatUser> {
+  const res = await rcFetch<{ _id: string; username: string; name?: string; success: boolean }>(
+    client,
+    "/api/v1/me"
+  );
+  return { _id: res._id, username: res.username, name: res.name };
+}
+
+export async function fetchRocketChatUser(
+  client: RocketChatClient,
+  userId: string
+): Promise<RocketChatUser> {
+  const res = await rcFetch<{ user: RocketChatUser; success: boolean }>(
+    client,
+    `/api/v1/users.info?userId=${encodeURIComponent(userId)}`
+  );
+  return res.user;
+}
+
+export async function fetchRocketChatUserByUsername(
+  client: RocketChatClient,
+  username: string
+): Promise<RocketChatUser> {
+  const res = await rcFetch<{ user: RocketChatUser; success: boolean }>(
+    client,
+    `/api/v1/users.info?username=${encodeURIComponent(username)}`
+  );
+  return res.user;
+}
+
+export async function fetchRocketChatRoom(
+  client: RocketChatClient,
+  roomId: string
+): Promise<RocketChatRoom> {
+  const res = await rcFetch<{ room: RocketChatRoom; success: boolean }>(
+    client,
+    `/api/v1/rooms.info?roomId=${encodeURIComponent(roomId)}`
+  );
+  return res.room;
+}
+
+export async function fetchRocketChatChannels(
+  client: RocketChatClient
+): Promise<RocketChatRoom[]> {
+  const res = await rcFetch<{ channels: RocketChatRoom[]; success: boolean }>(
+    client,
+    "/api/v1/channels.list.joined"
+  );
+  return res.channels;
+}
+
+export type RocketChatSubscription = {
+  _id: string;
+  rid: string;
+  name: string;
+  fname?: string;
+  t: "c" | "p" | "d" | "l";
+  open?: boolean;
+};
+
+export async function fetchRocketChatSubscriptions(
+  client: RocketChatClient
+): Promise<RocketChatSubscription[]> {
+  const res = await rcFetch<{ update: RocketChatSubscription[]; success: boolean }>(
+    client,
+    "/api/v1/subscriptions.get"
+  );
+  return res.update ?? [];
+}
+
+export async function createRocketChatDirectMessage(
+  client: RocketChatClient,
+  username: string
+): Promise<{ rid: string }> {
+  const res = await rcFetch<{ room: { rid: string }; success: boolean }>(
+    client,
+    "/api/v1/im.create",
+    {
+      method: "POST",
+      body: JSON.stringify({ username }),
+    }
+  );
+  return { rid: res.room.rid };
+}
+
+export async function postRocketChatMessage(
+  client: RocketChatClient,
+  opts: {
+    roomId?: string;
+    channel?: string;
+    text: string;
+    tmid?: string;
+    attachments?: RocketChatAttachment[];
+  }
+): Promise<RocketChatMessage> {
+  const payload: Record<string, unknown> = {
+    text: opts.text,
+  };
+  if (opts.roomId) payload.roomId = opts.roomId;
+  if (opts.channel) payload.channel = opts.channel;
+  if (opts.tmid) payload.tmid = opts.tmid;
+  if (opts.attachments) payload.attachments = opts.attachments;
+
+  const res = await rcFetch<{ message: RocketChatMessage; success: boolean }>(
+    client,
+    "/api/v1/chat.postMessage",
+    {
+      method: "POST",
+      body: JSON.stringify(payload),
+    }
+  );
+  return res.message;
+}
+
+export async function sendRocketChatTyping(
+  client: RocketChatClient,
+  roomId: string,
+  isTyping: boolean
+): Promise<void> {
+  // Rocket.Chat exposes a REST endpoint for typing state in most deployments.
+  // If the server doesn't support it (or it changes), callers should treat
+  // failures as non-fatal.
+  await rcFetch<{ success: boolean }>(client, "/api/v1/typing", {
+    method: "POST",
+    body: JSON.stringify({ roomId, typing: Boolean(isTyping) }),
+  });
+}