@openclaw/matrix 2026.3.13 → 2026.5.9-beta.1

package/src/matrix/send/targets.ts

@@ -1,150 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import { EventType, type MatrixDirectAccountData } from "./types.js";
-
-function normalizeTarget(raw: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new Error("Matrix target is required (room:<id> or #alias)");
-  }
-  return trimmed;
-}
-
-export function normalizeThreadId(raw?: string | number | null): string | null {
-  if (raw === undefined || raw === null) {
-    return null;
-  }
-  const trimmed = String(raw).trim();
-  return trimmed ? trimmed : null;
-}
-
-// Size-capped to prevent unbounded growth (#4948)
-const MAX_DIRECT_ROOM_CACHE_SIZE = 1024;
-const directRoomCache = new Map<string, string>();
-function setDirectRoomCached(key: string, value: string): void {
-  directRoomCache.set(key, value);
-  if (directRoomCache.size > MAX_DIRECT_ROOM_CACHE_SIZE) {
-    const oldest = directRoomCache.keys().next().value;
-    if (oldest !== undefined) {
-      directRoomCache.delete(oldest);
-    }
-  }
-}
-
-async function persistDirectRoom(
-  client: MatrixClient,
-  userId: string,
-  roomId: string,
-): Promise<void> {
-  let directContent: MatrixDirectAccountData | null = null;
-  try {
-    directContent = await client.getAccountData(EventType.Direct);
-  } catch {
-    // Ignore fetch errors and fall back to an empty map.
-  }
-  const existing = directContent && !Array.isArray(directContent) ? directContent : {};
-  const current = Array.isArray(existing[userId]) ? existing[userId] : [];
-  if (current[0] === roomId) {
-    return;
-  }
-  const next = [roomId, ...current.filter((id) => id !== roomId)];
-  try {
-    await client.setAccountData(EventType.Direct, {
-      ...existing,
-      [userId]: next,
-    });
-  } catch {
-    // Ignore persistence errors.
-  }
-}
-
-async function resolveDirectRoomId(client: MatrixClient, userId: string): Promise<string> {
-  const trimmed = userId.trim();
-  if (!trimmed.startsWith("@")) {
-    throw new Error(`Matrix user IDs must be fully qualified (got "${trimmed}")`);
-  }
-
-  const cached = directRoomCache.get(trimmed);
-  if (cached) {
-    return cached;
-  }
-
-  // 1) Fast path: use account data (m.direct) for *this* logged-in user (the bot).
-  try {
-    const directContent = (await client.getAccountData(EventType.Direct)) as Record<
-      string,
-      string[] | undefined
-    >;
-    const list = Array.isArray(directContent?.[trimmed]) ? directContent[trimmed] : [];
-    if (list && list.length > 0) {
-      setDirectRoomCached(trimmed, list[0]);
-      return list[0];
-    }
-  } catch {
-    // Ignore and fall back.
-  }
-
-  // 2) Fallback: look for an existing joined room that looks like a 1:1 with the user.
-  // Many clients only maintain m.direct for *their own* account data, so relying on it is brittle.
-  let fallbackRoom: string | null = null;
-  try {
-    const rooms = await client.getJoinedRooms();
-    for (const roomId of rooms) {
-      let members: string[];
-      try {
-        members = await client.getJoinedRoomMembers(roomId);
-      } catch {
-        continue;
-      }
-      if (!members.includes(trimmed)) {
-        continue;
-      }
-      // Prefer classic 1:1 rooms, but allow larger rooms if requested.
-      if (members.length === 2) {
-        setDirectRoomCached(trimmed, roomId);
-        await persistDirectRoom(client, trimmed, roomId);
-        return roomId;
-      }
-      if (!fallbackRoom) {
-        fallbackRoom = roomId;
-      }
-    }
-  } catch {
-    // Ignore and fall back.
-  }
-
-  if (fallbackRoom) {
-    setDirectRoomCached(trimmed, fallbackRoom);
-    await persistDirectRoom(client, trimmed, fallbackRoom);
-    return fallbackRoom;
-  }
-
-  throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);
-}
-
-export async function resolveMatrixRoomId(client: MatrixClient, raw: string): Promise<string> {
-  const target = normalizeTarget(raw);
-  const lowered = target.toLowerCase();
-  if (lowered.startsWith("matrix:")) {
-    return await resolveMatrixRoomId(client, target.slice("matrix:".length));
-  }
-  if (lowered.startsWith("room:")) {
-    return await resolveMatrixRoomId(client, target.slice("room:".length));
-  }
-  if (lowered.startsWith("channel:")) {
-    return await resolveMatrixRoomId(client, target.slice("channel:".length));
-  }
-  if (lowered.startsWith("user:")) {
-    return await resolveDirectRoomId(client, target.slice("user:".length));
-  }
-  if (target.startsWith("@")) {
-    return await resolveDirectRoomId(client, target);
-  }
-  if (target.startsWith("#")) {
-    const resolved = await client.resolveRoom(target);
-    if (!resolved) {
-      throw new Error(`Matrix alias ${target} could not be resolved`);
-    }
-    return resolved;
-  }
-  return target;
-}

package/src/matrix/send/types.ts

@@ -1,110 +0,0 @@
-import type {
-  DimensionalFileInfo,
-  EncryptedFile,
-  FileWithThumbnailInfo,
-  MessageEventContent,
-  TextualMessageEventContent,
-  TimedFileInfo,
-  VideoFileInfo,
-} from "@vector-im/matrix-bot-sdk";
-
-// Message types
-export const MsgType = {
-  Text: "m.text",
-  Image: "m.image",
-  Audio: "m.audio",
-  Video: "m.video",
-  File: "m.file",
-  Notice: "m.notice",
-} as const;
-
-// Relation types
-export const RelationType = {
-  Annotation: "m.annotation",
-  Replace: "m.replace",
-  Thread: "m.thread",
-} as const;
-
-// Event types
-export const EventType = {
-  Direct: "m.direct",
-  Reaction: "m.reaction",
-  RoomMessage: "m.room.message",
-} as const;
-
-export type MatrixDirectAccountData = Record<string, string[]>;
-
-export type MatrixReplyRelation = {
-  "m.in_reply_to": { event_id: string };
-};
-
-export type MatrixThreadRelation = {
-  rel_type: typeof RelationType.Thread;
-  event_id: string;
-  is_falling_back?: boolean;
-  "m.in_reply_to"?: { event_id: string };
-};
-
-export type MatrixRelation = MatrixReplyRelation | MatrixThreadRelation;
-
-export type MatrixReplyMeta = {
-  "m.relates_to"?: MatrixRelation;
-};
-
-export type MatrixMediaInfo =
-  | FileWithThumbnailInfo
-  | DimensionalFileInfo
-  | TimedFileInfo
-  | VideoFileInfo;
-
-export type MatrixTextContent = TextualMessageEventContent & MatrixReplyMeta;
-
-export type MatrixMediaContent = MessageEventContent &
-  MatrixReplyMeta & {
-    info?: MatrixMediaInfo;
-    url?: string;
-    file?: EncryptedFile;
-    filename?: string;
-    "org.matrix.msc3245.voice"?: Record<string, never>;
-    "org.matrix.msc1767.audio"?: { duration: number };
-  };
-
-export type MatrixOutboundContent = MatrixTextContent | MatrixMediaContent;
-
-export type ReactionEventContent = {
-  "m.relates_to": {
-    rel_type: typeof RelationType.Annotation;
-    event_id: string;
-    key: string;
-  };
-};
-
-export type MatrixSendResult = {
-  messageId: string;
-  roomId: string;
-};
-
-export type MatrixSendOpts = {
-  cfg?: import("../../types.js").CoreConfig;
-  client?: import("@vector-im/matrix-bot-sdk").MatrixClient;
-  mediaUrl?: string;
-  accountId?: string;
-  replyToId?: string;
-  threadId?: string | number | null;
-  timeoutMs?: number;
-  /** Send audio as voice message (voice bubble) instead of audio file. Defaults to false. */
-  audioAsVoice?: boolean;
-};
-
-export type MatrixMediaMsgType =
-  | typeof MsgType.Image
-  | typeof MsgType.Audio
-  | typeof MsgType.Video
-  | typeof MsgType.File;
-
-export type MediaKind = "image" | "audio" | "video" | "document" | "unknown";
-
-export type MatrixFormattedContent = MessageEventContent & {
-  format?: string;
-  formatted_body?: string;
-};

package/src/matrix/send-queue.test.ts

@@ -1,145 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createDeferred } from "../../../shared/deferred.js";
-import { DEFAULT_SEND_GAP_MS, enqueueSend } from "./send-queue.js";
-
-describe("enqueueSend", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("serializes sends per room", async () => {
-    const gate = createDeferred<void>();
-    const events: string[] = [];
-
-    const first = enqueueSend("!room:example.org", async () => {
-      events.push("start1");
-      await gate.promise;
-      events.push("end1");
-      return "one";
-    });
-    const second = enqueueSend("!room:example.org", async () => {
-      events.push("start2");
-      events.push("end2");
-      return "two";
-    });
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    expect(events).toEqual(["start1"]);
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS * 2);
-    expect(events).toEqual(["start1"]);
-
-    gate.resolve();
-    await first;
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS - 1);
-    expect(events).toEqual(["start1", "end1"]);
-    await vi.advanceTimersByTimeAsync(1);
-    await second;
-    expect(events).toEqual(["start1", "end1", "start2", "end2"]);
-  });
-
-  it("does not serialize across different rooms", async () => {
-    const events: string[] = [];
-
-    const a = enqueueSend("!a:example.org", async () => {
-      events.push("a");
-      return "a";
-    });
-    const b = enqueueSend("!b:example.org", async () => {
-      events.push("b");
-      return "b";
-    });
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    await Promise.all([a, b]);
-    expect(events.sort()).toEqual(["a", "b"]);
-  });
-
-  it("continues queue after failures", async () => {
-    const first = enqueueSend("!room:example.org", async () => {
-      throw new Error("boom");
-    }).then(
-      () => ({ ok: true as const }),
-      (error) => ({ ok: false as const, error }),
-    );
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    const firstResult = await first;
-    expect(firstResult.ok).toBe(false);
-    if (firstResult.ok) {
-      throw new Error("expected first queue item to fail");
-    }
-    expect(firstResult.error).toBeInstanceOf(Error);
-    expect(firstResult.error.message).toBe("boom");
-
-    const second = enqueueSend("!room:example.org", async () => "ok");
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    await expect(second).resolves.toBe("ok");
-  });
-
-  it("continues queued work when the head task fails", async () => {
-    const gate = createDeferred<void>();
-    const events: string[] = [];
-
-    const first = enqueueSend("!room:example.org", async () => {
-      events.push("start1");
-      await gate.promise;
-      throw new Error("boom");
-    }).then(
-      () => ({ ok: true as const }),
-      (error) => ({ ok: false as const, error }),
-    );
-    const second = enqueueSend("!room:example.org", async () => {
-      events.push("start2");
-      return "two";
-    });
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    expect(events).toEqual(["start1"]);
-
-    gate.resolve();
-    const firstResult = await first;
-    expect(firstResult.ok).toBe(false);
-    if (firstResult.ok) {
-      throw new Error("expected head queue item to fail");
-    }
-    expect(firstResult.error).toBeInstanceOf(Error);
-
-    await vi.advanceTimersByTimeAsync(DEFAULT_SEND_GAP_MS);
-    await expect(second).resolves.toBe("two");
-    expect(events).toEqual(["start1", "start2"]);
-  });
-
-  it("supports custom gap and delay injection", async () => {
-    const events: string[] = [];
-    const delayFn = vi.fn(async (_ms: number) => {});
-
-    const first = enqueueSend(
-      "!room:example.org",
-      async () => {
-        events.push("first");
-        return "one";
-      },
-      { gapMs: 7, delayFn },
-    );
-    const second = enqueueSend(
-      "!room:example.org",
-      async () => {
-        events.push("second");
-        return "two";
-      },
-      { gapMs: 7, delayFn },
-    );
-
-    await expect(first).resolves.toBe("one");
-    await expect(second).resolves.toBe("two");
-    expect(events).toEqual(["first", "second"]);
-    expect(delayFn).toHaveBeenCalledTimes(2);
-    expect(delayFn).toHaveBeenNthCalledWith(1, 7);
-    expect(delayFn).toHaveBeenNthCalledWith(2, 7);
-  });
-});

package/src/matrix/send-queue.ts

@@ -1,28 +0,0 @@
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-
-export const DEFAULT_SEND_GAP_MS = 150;
-
-type MatrixSendQueueOptions = {
-  gapMs?: number;
-  delayFn?: (ms: number) => Promise<void>;
-};
-
-// Serialize sends per room to preserve Matrix delivery order.
-const roomQueues = new KeyedAsyncQueue();
-
-export function enqueueSend<T>(
-  roomId: string,
-  fn: () => Promise<T>,
-  options?: MatrixSendQueueOptions,
-): Promise<T> {
-  const gapMs = options?.gapMs ?? DEFAULT_SEND_GAP_MS;
-  const delayFn = options?.delayFn ?? delay;
-  return roomQueues.enqueue(roomId, async () => {
-    await delayFn(gapMs);
-    return await fn();
-  });
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}