@openclaw/matrix 2026.3.13 → 2026.5.9-beta.1

package/src/matrix/send.test.ts

@@ -1,319 +0,0 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk/matrix";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { setMatrixRuntime } from "../runtime.js";
-import { createMatrixBotSdkMock } from "../test-mocks.js";
-
-vi.mock("music-metadata", () => ({
-  // `resolveMediaDurationMs` lazily imports `music-metadata`; in tests we don't
-  // need real duration parsing and the real module is expensive to load.
-  parseBuffer: vi.fn().mockResolvedValue({ format: {} }),
-}));
-
-vi.mock("@vector-im/matrix-bot-sdk", () =>
-  createMatrixBotSdkMock({
-    matrixClient: vi.fn(),
-    simpleFsStorageProvider: vi.fn(),
-    rustSdkCryptoStorageProvider: vi.fn(),
-  }),
-);
-
-vi.mock("./send-queue.js", () => ({
-  enqueueSend: async <T>(_roomId: string, fn: () => Promise<T>) => await fn(),
-}));
-
-const loadWebMediaMock = vi.fn().mockResolvedValue({
-  buffer: Buffer.from("media"),
-  fileName: "photo.png",
-  contentType: "image/png",
-  kind: "image",
-});
-const runtimeLoadConfigMock = vi.fn(() => ({}));
-const mediaKindFromMimeMock = vi.fn(() => "image");
-const isVoiceCompatibleAudioMock = vi.fn(() => false);
-const getImageMetadataMock = vi.fn().mockResolvedValue(null);
-const resizeToJpegMock = vi.fn();
-
-const runtimeStub = {
-  config: {
-    loadConfig: runtimeLoadConfigMock,
-  },
-  media: {
-    loadWebMedia: loadWebMediaMock as unknown as PluginRuntime["media"]["loadWebMedia"],
-    mediaKindFromMime:
-      mediaKindFromMimeMock as unknown as PluginRuntime["media"]["mediaKindFromMime"],
-    isVoiceCompatibleAudio:
-      isVoiceCompatibleAudioMock as unknown as PluginRuntime["media"]["isVoiceCompatibleAudio"],
-    getImageMetadata: getImageMetadataMock as unknown as PluginRuntime["media"]["getImageMetadata"],
-    resizeToJpeg: resizeToJpegMock as unknown as PluginRuntime["media"]["resizeToJpeg"],
-  },
-  channel: {
-    text: {
-      resolveTextChunkLimit: () => 4000,
-      resolveChunkMode: () => "length",
-      chunkMarkdownText: (text: string) => (text ? [text] : []),
-      chunkMarkdownTextWithMode: (text: string) => (text ? [text] : []),
-      resolveMarkdownTableMode: () => "code",
-      convertMarkdownTables: (text: string) => text,
-    },
-  },
-} as unknown as PluginRuntime;
-
-let sendMessageMatrix: typeof import("./send.js").sendMessageMatrix;
-let resolveMediaMaxBytes: typeof import("./send/client.js").resolveMediaMaxBytes;
-
-const makeClient = () => {
-  const sendMessage = vi.fn().mockResolvedValue("evt1");
-  const uploadContent = vi.fn().mockResolvedValue("mxc://example/file");
-  const client = {
-    sendMessage,
-    uploadContent,
-    getUserId: vi.fn().mockResolvedValue("@bot:example.org"),
-  } as unknown as import("@vector-im/matrix-bot-sdk").MatrixClient;
-  return { client, sendMessage, uploadContent };
-};
-
-beforeAll(async () => {
-  setMatrixRuntime(runtimeStub);
-  ({ sendMessageMatrix } = await import("./send.js"));
-  ({ resolveMediaMaxBytes } = await import("./send/client.js"));
-});
-
-describe("sendMessageMatrix media", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    runtimeLoadConfigMock.mockReset();
-    runtimeLoadConfigMock.mockReturnValue({});
-    mediaKindFromMimeMock.mockReturnValue("image");
-    isVoiceCompatibleAudioMock.mockReturnValue(false);
-    setMatrixRuntime(runtimeStub);
-  });
-
-  it("uploads media with url payloads", async () => {
-    const { client, sendMessage, uploadContent } = makeClient();
-
-    await sendMessageMatrix("room:!room:example", "caption", {
-      client,
-      mediaUrl: "file:///tmp/photo.png",
-    });
-
-    const uploadArg = uploadContent.mock.calls[0]?.[0];
-    expect(Buffer.isBuffer(uploadArg)).toBe(true);
-
-    const content = sendMessage.mock.calls[0]?.[1] as {
-      url?: string;
-      msgtype?: string;
-      format?: string;
-      formatted_body?: string;
-    };
-    expect(content.msgtype).toBe("m.image");
-    expect(content.format).toBe("org.matrix.custom.html");
-    expect(content.formatted_body).toContain("caption");
-    expect(content.url).toBe("mxc://example/file");
-  });
-
-  it("uploads encrypted media with file payloads", async () => {
-    const { client, sendMessage, uploadContent } = makeClient();
-    (client as { crypto?: object }).crypto = {
-      isRoomEncrypted: vi.fn().mockResolvedValue(true),
-      encryptMedia: vi.fn().mockResolvedValue({
-        buffer: Buffer.from("encrypted"),
-        file: {
-          key: {
-            kty: "oct",
-            key_ops: ["encrypt", "decrypt"],
-            alg: "A256CTR",
-            k: "secret",
-            ext: true,
-          },
-          iv: "iv",
-          hashes: { sha256: "hash" },
-          v: "v2",
-        },
-      }),
-    };
-
-    await sendMessageMatrix("room:!room:example", "caption", {
-      client,
-      mediaUrl: "file:///tmp/photo.png",
-    });
-
-    const uploadArg = uploadContent.mock.calls[0]?.[0] as Buffer | undefined;
-    expect(uploadArg?.toString()).toBe("encrypted");
-
-    const content = sendMessage.mock.calls[0]?.[1] as {
-      url?: string;
-      file?: { url?: string };
-    };
-    expect(content.url).toBeUndefined();
-    expect(content.file?.url).toBe("mxc://example/file");
-  });
-
-  it("marks voice metadata and sends caption follow-up when audioAsVoice is compatible", async () => {
-    const { client, sendMessage } = makeClient();
-    mediaKindFromMimeMock.mockReturnValue("audio");
-    isVoiceCompatibleAudioMock.mockReturnValue(true);
-    loadWebMediaMock.mockResolvedValueOnce({
-      buffer: Buffer.from("audio"),
-      fileName: "clip.mp3",
-      contentType: "audio/mpeg",
-      kind: "audio",
-    });
-
-    await sendMessageMatrix("room:!room:example", "voice caption", {
-      client,
-      mediaUrl: "file:///tmp/clip.mp3",
-      audioAsVoice: true,
-    });
-
-    expect(isVoiceCompatibleAudioMock).toHaveBeenCalledWith({
-      contentType: "audio/mpeg",
-      fileName: "clip.mp3",
-    });
-    expect(sendMessage).toHaveBeenCalledTimes(2);
-    const mediaContent = sendMessage.mock.calls[0]?.[1] as {
-      msgtype?: string;
-      body?: string;
-      "org.matrix.msc3245.voice"?: Record<string, never>;
-    };
-    expect(mediaContent.msgtype).toBe("m.audio");
-    expect(mediaContent.body).toBe("Voice message");
-    expect(mediaContent["org.matrix.msc3245.voice"]).toEqual({});
-  });
-
-  it("keeps regular audio payload when audioAsVoice media is incompatible", async () => {
-    const { client, sendMessage } = makeClient();
-    mediaKindFromMimeMock.mockReturnValue("audio");
-    isVoiceCompatibleAudioMock.mockReturnValue(false);
-    loadWebMediaMock.mockResolvedValueOnce({
-      buffer: Buffer.from("audio"),
-      fileName: "clip.wav",
-      contentType: "audio/wav",
-      kind: "audio",
-    });
-
-    await sendMessageMatrix("room:!room:example", "voice caption", {
-      client,
-      mediaUrl: "file:///tmp/clip.wav",
-      audioAsVoice: true,
-    });
-
-    expect(sendMessage).toHaveBeenCalledTimes(1);
-    const mediaContent = sendMessage.mock.calls[0]?.[1] as {
-      msgtype?: string;
-      body?: string;
-      "org.matrix.msc3245.voice"?: Record<string, never>;
-    };
-    expect(mediaContent.msgtype).toBe("m.audio");
-    expect(mediaContent.body).toBe("voice caption");
-    expect(mediaContent["org.matrix.msc3245.voice"]).toBeUndefined();
-  });
-});
-
-describe("sendMessageMatrix threads", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    runtimeLoadConfigMock.mockReset();
-    runtimeLoadConfigMock.mockReturnValue({});
-    setMatrixRuntime(runtimeStub);
-  });
-
-  it("includes thread relation metadata when threadId is set", async () => {
-    const { client, sendMessage } = makeClient();
-
-    await sendMessageMatrix("room:!room:example", "hello thread", {
-      client,
-      threadId: "$thread",
-    });
-
-    const content = sendMessage.mock.calls[0]?.[1] as {
-      "m.relates_to"?: {
-        rel_type?: string;
-        event_id?: string;
-        "m.in_reply_to"?: { event_id?: string };
-      };
-    };
-
-    expect(content["m.relates_to"]).toMatchObject({
-      rel_type: "m.thread",
-      event_id: "$thread",
-      "m.in_reply_to": { event_id: "$thread" },
-    });
-  });
-});
-
-describe("sendMessageMatrix cfg threading", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    runtimeLoadConfigMock.mockReset();
-    runtimeLoadConfigMock.mockReturnValue({
-      channels: {
-        matrix: {
-          mediaMaxMb: 7,
-        },
-      },
-    });
-    setMatrixRuntime(runtimeStub);
-  });
-
-  it("does not call runtime loadConfig when cfg is provided", async () => {
-    const { client } = makeClient();
-    const providedCfg = {
-      channels: {
-        matrix: {
-          mediaMaxMb: 4,
-        },
-      },
-    };
-
-    await sendMessageMatrix("room:!room:example", "hello cfg", {
-      client,
-      cfg: providedCfg as any,
-    });
-
-    expect(runtimeLoadConfigMock).not.toHaveBeenCalled();
-  });
-
-  it("falls back to runtime loadConfig when cfg is omitted", async () => {
-    const { client } = makeClient();
-
-    await sendMessageMatrix("room:!room:example", "hello runtime", { client });
-
-    expect(runtimeLoadConfigMock).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("resolveMediaMaxBytes cfg threading", () => {
-  beforeEach(() => {
-    runtimeLoadConfigMock.mockReset();
-    runtimeLoadConfigMock.mockReturnValue({
-      channels: {
-        matrix: {
-          mediaMaxMb: 9,
-        },
-      },
-    });
-    setMatrixRuntime(runtimeStub);
-  });
-
-  it("uses provided cfg and skips runtime loadConfig", () => {
-    const providedCfg = {
-      channels: {
-        matrix: {
-          mediaMaxMb: 3,
-        },
-      },
-    };
-
-    const maxBytes = resolveMediaMaxBytes(undefined, providedCfg as any);
-
-    expect(maxBytes).toBe(3 * 1024 * 1024);
-    expect(runtimeLoadConfigMock).not.toHaveBeenCalled();
-  });
-
-  it("falls back to runtime loadConfig when cfg is omitted", () => {
-    const maxBytes = resolveMediaMaxBytes();
-
-    expect(maxBytes).toBe(9 * 1024 * 1024);
-    expect(runtimeLoadConfigMock).toHaveBeenCalledTimes(1);
-  });
-});

package/src/matrix/send.ts

@@ -1,267 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import type { PollInput } from "openclaw/plugin-sdk/matrix";
-import { getMatrixRuntime } from "../runtime.js";
-import { buildPollStartContent, M_POLL_START } from "./poll-types.js";
-import { enqueueSend } from "./send-queue.js";
-import { resolveMatrixClient, resolveMediaMaxBytes } from "./send/client.js";
-import {
-  buildReplyRelation,
-  buildTextContent,
-  buildThreadRelation,
-  resolveMatrixMsgType,
-  resolveMatrixVoiceDecision,
-} from "./send/formatting.js";
-import {
-  buildMediaContent,
-  prepareImageInfo,
-  resolveMediaDurationMs,
-  uploadMediaMaybeEncrypted,
-} from "./send/media.js";
-import { normalizeThreadId, resolveMatrixRoomId } from "./send/targets.js";
-import {
-  EventType,
-  MsgType,
-  RelationType,
-  type MatrixOutboundContent,
-  type MatrixSendOpts,
-  type MatrixSendResult,
-  type ReactionEventContent,
-} from "./send/types.js";
-
-const MATRIX_TEXT_LIMIT = 4000;
-const getCore = () => getMatrixRuntime();
-
-export type { MatrixSendOpts, MatrixSendResult } from "./send/types.js";
-export { resolveMatrixRoomId } from "./send/targets.js";
-
-export async function sendMessageMatrix(
-  to: string,
-  message: string,
-  opts: MatrixSendOpts = {},
-): Promise<MatrixSendResult> {
-  const trimmedMessage = message?.trim() ?? "";
-  if (!trimmedMessage && !opts.mediaUrl) {
-    throw new Error("Matrix send requires text or media");
-  }
-  const { client, stopOnDone } = await resolveMatrixClient({
-    client: opts.client,
-    timeoutMs: opts.timeoutMs,
-    accountId: opts.accountId,
-    cfg: opts.cfg,
-  });
-  const cfg = opts.cfg ?? getCore().config.loadConfig();
-  try {
-    const roomId = await resolveMatrixRoomId(client, to);
-    return await enqueueSend(roomId, async () => {
-      const tableMode = getCore().channel.text.resolveMarkdownTableMode({
-        cfg,
-        channel: "matrix",
-        accountId: opts.accountId,
-      });
-      const convertedMessage = getCore().channel.text.convertMarkdownTables(
-        trimmedMessage,
-        tableMode,
-      );
-      const textLimit = getCore().channel.text.resolveTextChunkLimit(cfg, "matrix");
-      const chunkLimit = Math.min(textLimit, MATRIX_TEXT_LIMIT);
-      const chunkMode = getCore().channel.text.resolveChunkMode(cfg, "matrix", opts.accountId);
-      const chunks = getCore().channel.text.chunkMarkdownTextWithMode(
-        convertedMessage,
-        chunkLimit,
-        chunkMode,
-      );
-      const threadId = normalizeThreadId(opts.threadId);
-      const relation = threadId
-        ? buildThreadRelation(threadId, opts.replyToId)
-        : buildReplyRelation(opts.replyToId);
-      const sendContent = async (content: MatrixOutboundContent) => {
-        // @vector-im/matrix-bot-sdk uses sendMessage differently
-        const eventId = await client.sendMessage(roomId, content);
-        return eventId;
-      };
-
-      let lastMessageId = "";
-      if (opts.mediaUrl) {
-        const maxBytes = resolveMediaMaxBytes(opts.accountId, cfg);
-        const media = await getCore().media.loadWebMedia(opts.mediaUrl, maxBytes);
-        const uploaded = await uploadMediaMaybeEncrypted(client, roomId, media.buffer, {
-          contentType: media.contentType,
-          filename: media.fileName,
-        });
-        const durationMs = await resolveMediaDurationMs({
-          buffer: media.buffer,
-          contentType: media.contentType,
-          fileName: media.fileName,
-          kind: media.kind ?? "unknown",
-        });
-        const baseMsgType = resolveMatrixMsgType(media.contentType, media.fileName);
-        const { useVoice } = resolveMatrixVoiceDecision({
-          wantsVoice: opts.audioAsVoice === true,
-          contentType: media.contentType,
-          fileName: media.fileName,
-        });
-        const msgtype = useVoice ? MsgType.Audio : baseMsgType;
-        const isImage = msgtype === MsgType.Image;
-        const imageInfo = isImage
-          ? await prepareImageInfo({ buffer: media.buffer, client })
-          : undefined;
-        const [firstChunk, ...rest] = chunks;
-        const body = useVoice ? "Voice message" : (firstChunk ?? media.fileName ?? "(file)");
-        const content = buildMediaContent({
-          msgtype,
-          body,
-          url: uploaded.url,
-          file: uploaded.file,
-          filename: media.fileName,
-          mimetype: media.contentType,
-          size: media.buffer.byteLength,
-          durationMs,
-          relation,
-          isVoice: useVoice,
-          imageInfo,
-        });
-        const eventId = await sendContent(content);
-        lastMessageId = eventId ?? lastMessageId;
-        const textChunks = useVoice ? chunks : rest;
-        const followupRelation = threadId ? relation : undefined;
-        for (const chunk of textChunks) {
-          const text = chunk.trim();
-          if (!text) {
-            continue;
-          }
-          const followup = buildTextContent(text, followupRelation);
-          const followupEventId = await sendContent(followup);
-          lastMessageId = followupEventId ?? lastMessageId;
-        }
-      } else {
-        for (const chunk of chunks.length ? chunks : [""]) {
-          const text = chunk.trim();
-          if (!text) {
-            continue;
-          }
-          const content = buildTextContent(text, relation);
-          const eventId = await sendContent(content);
-          lastMessageId = eventId ?? lastMessageId;
-        }
-      }
-
-      return {
-        messageId: lastMessageId || "unknown",
-        roomId,
-      };
-    });
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}
-
-export async function sendPollMatrix(
-  to: string,
-  poll: PollInput,
-  opts: MatrixSendOpts = {},
-): Promise<{ eventId: string; roomId: string }> {
-  if (!poll.question?.trim()) {
-    throw new Error("Matrix poll requires a question");
-  }
-  if (!poll.options?.length) {
-    throw new Error("Matrix poll requires options");
-  }
-  const { client, stopOnDone } = await resolveMatrixClient({
-    client: opts.client,
-    timeoutMs: opts.timeoutMs,
-    accountId: opts.accountId,
-    cfg: opts.cfg,
-  });
-
-  try {
-    const roomId = await resolveMatrixRoomId(client, to);
-    const pollContent = buildPollStartContent(poll);
-    const threadId = normalizeThreadId(opts.threadId);
-    const pollPayload = threadId
-      ? { ...pollContent, "m.relates_to": buildThreadRelation(threadId) }
-      : pollContent;
-    // @vector-im/matrix-bot-sdk sendEvent returns eventId string directly
-    const eventId = await client.sendEvent(roomId, M_POLL_START, pollPayload);
-
-    return {
-      eventId: eventId ?? "unknown",
-      roomId,
-    };
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}
-
-export async function sendTypingMatrix(
-  roomId: string,
-  typing: boolean,
-  timeoutMs?: number,
-  client?: MatrixClient,
-): Promise<void> {
-  const { client: resolved, stopOnDone } = await resolveMatrixClient({
-    client,
-    timeoutMs,
-  });
-  try {
-    const resolvedTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : 30_000;
-    await resolved.setTyping(roomId, typing, resolvedTimeoutMs);
-  } finally {
-    if (stopOnDone) {
-      resolved.stop();
-    }
-  }
-}
-
-export async function sendReadReceiptMatrix(
-  roomId: string,
-  eventId: string,
-  client?: MatrixClient,
-): Promise<void> {
-  if (!eventId?.trim()) {
-    return;
-  }
-  const { client: resolved, stopOnDone } = await resolveMatrixClient({
-    client,
-  });
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(resolved, roomId);
-    await resolved.sendReadReceipt(resolvedRoom, eventId.trim());
-  } finally {
-    if (stopOnDone) {
-      resolved.stop();
-    }
-  }
-}
-
-export async function reactMatrixMessage(
-  roomId: string,
-  messageId: string,
-  emoji: string,
-  client?: MatrixClient,
-): Promise<void> {
-  if (!emoji.trim()) {
-    throw new Error("Matrix reaction requires an emoji");
-  }
-  const { client: resolved, stopOnDone } = await resolveMatrixClient({
-    client,
-  });
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(resolved, roomId);
-    const reaction: ReactionEventContent = {
-      "m.relates_to": {
-        rel_type: RelationType.Annotation,
-        event_id: messageId,
-        key: emoji,
-      },
-    };
-    await resolved.sendEvent(resolvedRoom, EventType.Reaction, reaction);
-  } finally {
-    if (stopOnDone) {
-      resolved.stop();
-    }
-  }
-}