@openclaw/matrix 2026.3.13 → 2026.5.10-beta.1

package/src/matrix/actions/pins.test.ts

@@ -1,74 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import { describe, expect, it, vi } from "vitest";
-import { listMatrixPins, pinMatrixMessage, unpinMatrixMessage } from "./pins.js";
-
-function createPinsClient(seedPinned: string[], knownBodies: Record<string, string> = {}) {
-  let pinned = [...seedPinned];
-  const getRoomStateEvent = vi.fn(async () => ({ pinned: [...pinned] }));
-  const sendStateEvent = vi.fn(
-    async (_roomId: string, _type: string, _key: string, payload: any) => {
-      pinned = [...payload.pinned];
-    },
-  );
-  const getEvent = vi.fn(async (_roomId: string, eventId: string) => {
-    const body = knownBodies[eventId];
-    if (!body) {
-      throw new Error("missing");
-    }
-    return {
-      event_id: eventId,
-      sender: "@alice:example.org",
-      type: "m.room.message",
-      origin_server_ts: 123,
-      content: { msgtype: "m.text", body },
-    };
-  });
-
-  return {
-    client: {
-      getRoomStateEvent,
-      sendStateEvent,
-      getEvent,
-      stop: vi.fn(),
-    } as unknown as MatrixClient,
-    getPinned: () => pinned,
-    sendStateEvent,
-  };
-}
-
-describe("matrix pins actions", () => {
-  it("pins a message once even when asked twice", async () => {
-    const { client, getPinned, sendStateEvent } = createPinsClient(["$a"]);
-
-    const first = await pinMatrixMessage("!room:example.org", "$b", { client });
-    const second = await pinMatrixMessage("!room:example.org", "$b", { client });
-
-    expect(first.pinned).toEqual(["$a", "$b"]);
-    expect(second.pinned).toEqual(["$a", "$b"]);
-    expect(getPinned()).toEqual(["$a", "$b"]);
-    expect(sendStateEvent).toHaveBeenCalledTimes(2);
-  });
-
-  it("unpinds only the selected message id", async () => {
-    const { client, getPinned } = createPinsClient(["$a", "$b", "$c"]);
-
-    const result = await unpinMatrixMessage("!room:example.org", "$b", { client });
-
-    expect(result.pinned).toEqual(["$a", "$c"]);
-    expect(getPinned()).toEqual(["$a", "$c"]);
-  });
-
-  it("lists pinned ids and summarizes only resolvable events", async () => {
-    const { client } = createPinsClient(["$a", "$missing"], { $a: "hello" });
-
-    const result = await listMatrixPins("!room:example.org", { client });
-
-    expect(result.pinned).toEqual(["$a", "$missing"]);
-    expect(result.events).toEqual([
-      expect.objectContaining({
-        eventId: "$a",
-        body: "hello",
-      }),
-    ]);
-  });
-});

package/src/matrix/actions/pins.ts

@@ -1,84 +0,0 @@
-import { resolveMatrixRoomId } from "../send.js";
-import { resolveActionClient } from "./client.js";
-import { fetchEventSummary, readPinnedEvents } from "./summary.js";
-import {
-  EventType,
-  type MatrixActionClientOpts,
-  type MatrixActionClient,
-  type MatrixMessageSummary,
-  type RoomPinnedEventsEventContent,
-} from "./types.js";
-
-type ActionClient = MatrixActionClient["client"];
-
-async function withResolvedPinRoom<T>(
-  roomId: string,
-  opts: MatrixActionClientOpts,
-  run: (client: ActionClient, resolvedRoom: string) => Promise<T>,
-): Promise<T> {
-  const { client, stopOnDone } = await resolveActionClient(opts);
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-    return await run(client, resolvedRoom);
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}
-
-async function updateMatrixPins(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts,
-  update: (current: string[]) => string[],
-): Promise<{ pinned: string[] }> {
-  return await withResolvedPinRoom(roomId, opts, async (client, resolvedRoom) => {
-    const current = await readPinnedEvents(client, resolvedRoom);
-    const next = update(current);
-    const payload: RoomPinnedEventsEventContent = { pinned: next };
-    await client.sendStateEvent(resolvedRoom, EventType.RoomPinnedEvents, "", payload);
-    return { pinned: next };
-  });
-}
-
-export async function pinMatrixMessage(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts = {},
-): Promise<{ pinned: string[] }> {
-  return await updateMatrixPins(roomId, messageId, opts, (current) =>
-    current.includes(messageId) ? current : [...current, messageId],
-  );
-}
-
-export async function unpinMatrixMessage(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts = {},
-): Promise<{ pinned: string[] }> {
-  return await updateMatrixPins(roomId, messageId, opts, (current) =>
-    current.filter((id) => id !== messageId),
-  );
-}
-
-export async function listMatrixPins(
-  roomId: string,
-  opts: MatrixActionClientOpts = {},
-): Promise<{ pinned: string[]; events: MatrixMessageSummary[] }> {
-  return await withResolvedPinRoom(roomId, opts, async (client, resolvedRoom) => {
-    const pinned = await readPinnedEvents(client, resolvedRoom);
-    const events = (
-      await Promise.all(
-        pinned.map(async (eventId) => {
-          try {
-            return await fetchEventSummary(client, resolvedRoom, eventId);
-          } catch {
-            return null;
-          }
-        }),
-      )
-    ).filter((event): event is MatrixMessageSummary => Boolean(event));
-    return { pinned, events };
-  });
-}

package/src/matrix/actions/reactions.test.ts

@@ -1,109 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import { describe, expect, it, vi } from "vitest";
-import { listMatrixReactions, removeMatrixReactions } from "./reactions.js";
-
-function createReactionsClient(params: {
-  chunk: Array<{
-    event_id?: string;
-    sender?: string;
-    key?: string;
-  }>;
-  userId?: string | null;
-}) {
-  const doRequest = vi.fn(async (_method: string, _path: string, _query: any) => ({
-    chunk: params.chunk.map((item) => ({
-      event_id: item.event_id ?? "",
-      sender: item.sender ?? "",
-      content: item.key
-        ? {
-            "m.relates_to": {
-              rel_type: "m.annotation",
-              event_id: "$target",
-              key: item.key,
-            },
-          }
-        : {},
-    })),
-  }));
-  const getUserId = vi.fn(async () => params.userId ?? null);
-  const redactEvent = vi.fn(async () => undefined);
-
-  return {
-    client: {
-      doRequest,
-      getUserId,
-      redactEvent,
-      stop: vi.fn(),
-    } as unknown as MatrixClient,
-    doRequest,
-    redactEvent,
-  };
-}
-
-describe("matrix reaction actions", () => {
-  it("aggregates reactions by key and unique sender", async () => {
-    const { client, doRequest } = createReactionsClient({
-      chunk: [
-        { event_id: "$1", sender: "@alice:example.org", key: "👍" },
-        { event_id: "$2", sender: "@bob:example.org", key: "👍" },
-        { event_id: "$3", sender: "@alice:example.org", key: "👎" },
-        { event_id: "$4", sender: "@bot:example.org" },
-      ],
-      userId: "@bot:example.org",
-    });
-
-    const result = await listMatrixReactions("!room:example.org", "$msg", { client, limit: 2.9 });
-
-    expect(doRequest).toHaveBeenCalledWith(
-      "GET",
-      expect.stringContaining("/rooms/!room%3Aexample.org/relations/%24msg/"),
-      expect.objectContaining({ limit: 2 }),
-    );
-    expect(result).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          key: "👍",
-          count: 2,
-          users: expect.arrayContaining(["@alice:example.org", "@bob:example.org"]),
-        }),
-        expect.objectContaining({
-          key: "👎",
-          count: 1,
-          users: ["@alice:example.org"],
-        }),
-      ]),
-    );
-  });
-
-  it("removes only current-user reactions matching emoji filter", async () => {
-    const { client, redactEvent } = createReactionsClient({
-      chunk: [
-        { event_id: "$1", sender: "@me:example.org", key: "👍" },
-        { event_id: "$2", sender: "@me:example.org", key: "👎" },
-        { event_id: "$3", sender: "@other:example.org", key: "👍" },
-      ],
-      userId: "@me:example.org",
-    });
-
-    const result = await removeMatrixReactions("!room:example.org", "$msg", {
-      client,
-      emoji: "👍",
-    });
-
-    expect(result).toEqual({ removed: 1 });
-    expect(redactEvent).toHaveBeenCalledTimes(1);
-    expect(redactEvent).toHaveBeenCalledWith("!room:example.org", "$1");
-  });
-
-  it("returns removed=0 when current user id is unavailable", async () => {
-    const { client, redactEvent } = createReactionsClient({
-      chunk: [{ event_id: "$1", sender: "@me:example.org", key: "👍" }],
-      userId: null,
-    });
-
-    const result = await removeMatrixReactions("!room:example.org", "$msg", { client });
-
-    expect(result).toEqual({ removed: 0 });
-    expect(redactEvent).not.toHaveBeenCalled();
-  });
-});

package/src/matrix/actions/reactions.ts

@@ -1,102 +0,0 @@
-import { resolveMatrixRoomId } from "../send.js";
-import { resolveActionClient } from "./client.js";
-import { resolveMatrixActionLimit } from "./limits.js";
-import {
-  EventType,
-  RelationType,
-  type MatrixActionClientOpts,
-  type MatrixRawEvent,
-  type MatrixReactionSummary,
-  type ReactionEventContent,
-} from "./types.js";
-
-function getReactionsPath(roomId: string, messageId: string): string {
-  return `/_matrix/client/v1/rooms/${encodeURIComponent(roomId)}/relations/${encodeURIComponent(messageId)}/${RelationType.Annotation}/${EventType.Reaction}`;
-}
-
-async function listReactionEvents(
-  client: NonNullable<MatrixActionClientOpts["client"]>,
-  roomId: string,
-  messageId: string,
-  limit: number,
-): Promise<MatrixRawEvent[]> {
-  const res = (await client.doRequest("GET", getReactionsPath(roomId, messageId), {
-    dir: "b",
-    limit,
-  })) as { chunk: MatrixRawEvent[] };
-  return res.chunk;
-}
-
-export async function listMatrixReactions(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts & { limit?: number } = {},
-): Promise<MatrixReactionSummary[]> {
-  const { client, stopOnDone } = await resolveActionClient(opts);
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-    const limit = resolveMatrixActionLimit(opts.limit, 100);
-    const chunk = await listReactionEvents(client, resolvedRoom, messageId, limit);
-    const summaries = new Map<string, MatrixReactionSummary>();
-    for (const event of chunk) {
-      const content = event.content as ReactionEventContent;
-      const key = content["m.relates_to"]?.key;
-      if (!key) {
-        continue;
-      }
-      const sender = event.sender ?? "";
-      const entry: MatrixReactionSummary = summaries.get(key) ?? {
-        key,
-        count: 0,
-        users: [],
-      };
-      entry.count += 1;
-      if (sender && !entry.users.includes(sender)) {
-        entry.users.push(sender);
-      }
-      summaries.set(key, entry);
-    }
-    return Array.from(summaries.values());
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}
-
-export async function removeMatrixReactions(
-  roomId: string,
-  messageId: string,
-  opts: MatrixActionClientOpts & { emoji?: string } = {},
-): Promise<{ removed: number }> {
-  const { client, stopOnDone } = await resolveActionClient(opts);
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-    const chunk = await listReactionEvents(client, resolvedRoom, messageId, 200);
-    const userId = await client.getUserId();
-    if (!userId) {
-      return { removed: 0 };
-    }
-    const targetEmoji = opts.emoji?.trim();
-    const toRemove = chunk
-      .filter((event) => event.sender === userId)
-      .filter((event) => {
-        if (!targetEmoji) {
-          return true;
-        }
-        const content = event.content as ReactionEventContent;
-        return content["m.relates_to"]?.key === targetEmoji;
-      })
-      .map((event) => event.event_id)
-      .filter((id): id is string => Boolean(id));
-    if (toRemove.length === 0) {
-      return { removed: 0 };
-    }
-    await Promise.all(toRemove.map((id) => client.redactEvent(resolvedRoom, id)));
-    return { removed: toRemove.length };
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}

package/src/matrix/actions/room.ts

@@ -1,85 +0,0 @@
-import { resolveMatrixRoomId } from "../send.js";
-import { resolveActionClient } from "./client.js";
-import { EventType, type MatrixActionClientOpts } from "./types.js";
-
-export async function getMatrixMemberInfo(
-  userId: string,
-  opts: MatrixActionClientOpts & { roomId?: string } = {},
-) {
-  const { client, stopOnDone } = await resolveActionClient(opts);
-  try {
-    const roomId = opts.roomId ? await resolveMatrixRoomId(client, opts.roomId) : undefined;
-    // @vector-im/matrix-bot-sdk uses getUserProfile
-    const profile = await client.getUserProfile(userId);
-    // Note: @vector-im/matrix-bot-sdk doesn't have getRoom().getMember() like matrix-js-sdk
-    // We'd need to fetch room state separately if needed
-    return {
-      userId,
-      profile: {
-        displayName: profile?.displayname ?? null,
-        avatarUrl: profile?.avatar_url ?? null,
-      },
-      membership: null, // Would need separate room state query
-      powerLevel: null, // Would need separate power levels state query
-      displayName: profile?.displayname ?? null,
-      roomId: roomId ?? null,
-    };
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}
-
-export async function getMatrixRoomInfo(roomId: string, opts: MatrixActionClientOpts = {}) {
-  const { client, stopOnDone } = await resolveActionClient(opts);
-  try {
-    const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-    // @vector-im/matrix-bot-sdk uses getRoomState for state events
-    let name: string | null = null;
-    let topic: string | null = null;
-    let canonicalAlias: string | null = null;
-    let memberCount: number | null = null;
-
-    try {
-      const nameState = await client.getRoomStateEvent(resolvedRoom, "m.room.name", "");
-      name = nameState?.name ?? null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const topicState = await client.getRoomStateEvent(resolvedRoom, EventType.RoomTopic, "");
-      topic = topicState?.topic ?? null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const aliasState = await client.getRoomStateEvent(resolvedRoom, "m.room.canonical_alias", "");
-      canonicalAlias = aliasState?.alias ?? null;
-    } catch {
-      // ignore
-    }
-
-    try {
-      const members = await client.getJoinedRoomMembers(resolvedRoom);
-      memberCount = members.length;
-    } catch {
-      // ignore
-    }
-
-    return {
-      roomId: resolvedRoom,
-      name,
-      topic,
-      canonicalAlias,
-      altAliases: [], // Would need separate query
-      memberCount,
-    };
-  } finally {
-    if (stopOnDone) {
-      client.stop();
-    }
-  }
-}

package/src/matrix/actions/summary.ts

@@ -1,75 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import {
-  EventType,
-  type MatrixMessageSummary,
-  type MatrixRawEvent,
-  type RoomMessageEventContent,
-  type RoomPinnedEventsEventContent,
-} from "./types.js";
-
-export function summarizeMatrixRawEvent(event: MatrixRawEvent): MatrixMessageSummary {
-  const content = event.content as RoomMessageEventContent;
-  const relates = content["m.relates_to"];
-  let relType: string | undefined;
-  let eventId: string | undefined;
-  if (relates) {
-    if ("rel_type" in relates) {
-      relType = relates.rel_type;
-      eventId = relates.event_id;
-    } else if ("m.in_reply_to" in relates) {
-      eventId = relates["m.in_reply_to"]?.event_id;
-    }
-  }
-  const relatesTo =
-    relType || eventId
-      ? {
-          relType,
-          eventId,
-        }
-      : undefined;
-  return {
-    eventId: event.event_id,
-    sender: event.sender,
-    body: content.body,
-    msgtype: content.msgtype,
-    timestamp: event.origin_server_ts,
-    relatesTo,
-  };
-}
-
-export async function readPinnedEvents(client: MatrixClient, roomId: string): Promise<string[]> {
-  try {
-    const content = (await client.getRoomStateEvent(
-      roomId,
-      EventType.RoomPinnedEvents,
-      "",
-    )) as RoomPinnedEventsEventContent;
-    const pinned = content.pinned;
-    return pinned.filter((id) => id.trim().length > 0);
-  } catch (err: unknown) {
-    const errObj = err as { statusCode?: number; body?: { errcode?: string } };
-    const httpStatus = errObj.statusCode;
-    const errcode = errObj.body?.errcode;
-    if (httpStatus === 404 || errcode === "M_NOT_FOUND") {
-      return [];
-    }
-    throw err;
-  }
-}
-
-export async function fetchEventSummary(
-  client: MatrixClient,
-  roomId: string,
-  eventId: string,
-): Promise<MatrixMessageSummary | null> {
-  try {
-    const raw = (await client.getEvent(roomId, eventId)) as unknown as MatrixRawEvent;
-    if (raw.unsigned?.redacted_because) {
-      return null;
-    }
-    return summarizeMatrixRawEvent(raw);
-  } catch {
-    // Event not found, redacted, or inaccessible - return null
-    return null;
-  }
-}

package/src/matrix/actions/types.ts

@@ -1,85 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-
-export const MsgType = {
-  Text: "m.text",
-} as const;
-
-export const RelationType = {
-  Replace: "m.replace",
-  Annotation: "m.annotation",
-} as const;
-
-export const EventType = {
-  RoomMessage: "m.room.message",
-  RoomPinnedEvents: "m.room.pinned_events",
-  RoomTopic: "m.room.topic",
-  Reaction: "m.reaction",
-} as const;
-
-export type RoomMessageEventContent = {
-  msgtype: string;
-  body: string;
-  "m.new_content"?: RoomMessageEventContent;
-  "m.relates_to"?: {
-    rel_type?: string;
-    event_id?: string;
-    "m.in_reply_to"?: { event_id?: string };
-  };
-};
-
-export type ReactionEventContent = {
-  "m.relates_to": {
-    rel_type: string;
-    event_id: string;
-    key: string;
-  };
-};
-
-export type RoomPinnedEventsEventContent = {
-  pinned: string[];
-};
-
-export type RoomTopicEventContent = {
-  topic?: string;
-};
-
-export type MatrixRawEvent = {
-  event_id: string;
-  sender: string;
-  type: string;
-  origin_server_ts: number;
-  content: Record<string, unknown>;
-  unsigned?: {
-    redacted_because?: unknown;
-  };
-};
-
-export type MatrixActionClientOpts = {
-  client?: MatrixClient;
-  timeoutMs?: number;
-  accountId?: string | null;
-};
-
-export type MatrixMessageSummary = {
-  eventId?: string;
-  sender?: string;
-  body?: string;
-  msgtype?: string;
-  timestamp?: number;
-  relatesTo?: {
-    relType?: string;
-    eventId?: string;
-    key?: string;
-  };
-};
-
-export type MatrixReactionSummary = {
-  key: string;
-  count: number;
-  users: string[];
-};
-
-export type MatrixActionClient = {
-  client: MatrixClient;
-  stopOnDone: boolean;
-};

package/src/matrix/actions.ts

@@ -1,15 +0,0 @@
-export type {
-  MatrixActionClientOpts,
-  MatrixMessageSummary,
-  MatrixReactionSummary,
-} from "./actions/types.js";
-export {
-  sendMatrixMessage,
-  editMatrixMessage,
-  deleteMatrixMessage,
-  readMatrixMessages,
-} from "./actions/messages.js";
-export { listMatrixReactions, removeMatrixReactions } from "./actions/reactions.js";
-export { pinMatrixMessage, unpinMatrixMessage, listMatrixPins } from "./actions/pins.js";
-export { getMatrixMemberInfo, getMatrixRoomInfo } from "./actions/room.js";
-export { reactMatrixMessage } from "./send.js";

package/src/matrix/active-client.ts

@@ -1,32 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-
-// Support multiple active clients for multi-account
-const activeClients = new Map<string, MatrixClient>();
-
-export function setActiveMatrixClient(
-  client: MatrixClient | null,
-  accountId?: string | null,
-): void {
-  const key = normalizeAccountId(accountId);
-  if (client) {
-    activeClients.set(key, client);
-  } else {
-    activeClients.delete(key);
-  }
-}
-
-export function getActiveMatrixClient(accountId?: string | null): MatrixClient | null {
-  const key = normalizeAccountId(accountId);
-  return activeClients.get(key) ?? null;
-}
-
-export function getAnyActiveMatrixClient(): MatrixClient | null {
-  // Return any available client (for backward compatibility)
-  const first = activeClients.values().next();
-  return first.done ? null : first.value;
-}
-
-export function clearAllActiveMatrixClients(): void {
-  activeClients.clear();
-}