@openclaw/matrix 2026.3.13 → 2026.5.9-beta.1

package/src/matrix/monitor/events.test.ts

@@ -1,186 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import type { PluginRuntime, RuntimeLogger } from "openclaw/plugin-sdk/matrix";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { MatrixAuth } from "../client.js";
-import { registerMatrixMonitorEvents } from "./events.js";
-import type { MatrixRawEvent } from "./types.js";
-
-const sendReadReceiptMatrixMock = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
-
-vi.mock("../send.js", () => ({
-  sendReadReceiptMatrix: (...args: unknown[]) => sendReadReceiptMatrixMock(...args),
-}));
-
-describe("registerMatrixMonitorEvents", () => {
-  const roomId = "!room:example.org";
-
-  function makeEvent(overrides: Partial<MatrixRawEvent>): MatrixRawEvent {
-    return {
-      event_id: "$event",
-      sender: "@alice:example.org",
-      type: "m.room.message",
-      origin_server_ts: 0,
-      content: {},
-      ...overrides,
-    };
-  }
-
-  beforeEach(() => {
-    sendReadReceiptMatrixMock.mockClear();
-  });
-
-  function createHarness(options?: { getUserId?: ReturnType<typeof vi.fn> }) {
-    const handlers = new Map<string, (...args: unknown[]) => void>();
-    const getUserId = options?.getUserId ?? vi.fn().mockResolvedValue("@bot:example.org");
-    const client = {
-      on: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
-        handlers.set(event, handler);
-      }),
-      getUserId,
-      crypto: undefined,
-    } as unknown as MatrixClient;
-
-    const onRoomMessage = vi.fn();
-    const logVerboseMessage = vi.fn();
-    const logger = {
-      warn: vi.fn(),
-    } as unknown as RuntimeLogger;
-
-    registerMatrixMonitorEvents({
-      client,
-      auth: { encryption: false } as MatrixAuth,
-      logVerboseMessage,
-      warnedEncryptedRooms: new Set<string>(),
-      warnedCryptoMissingRooms: new Set<string>(),
-      logger,
-      formatNativeDependencyHint: (() =>
-        "") as PluginRuntime["system"]["formatNativeDependencyHint"],
-      onRoomMessage,
-    });
-
-    const roomMessageHandler = handlers.get("room.message");
-    if (!roomMessageHandler) {
-      throw new Error("missing room.message handler");
-    }
-
-    return { client, getUserId, onRoomMessage, roomMessageHandler, logVerboseMessage };
-  }
-
-  async function expectForwardedWithoutReadReceipt(event: MatrixRawEvent) {
-    const { onRoomMessage, roomMessageHandler } = createHarness();
-
-    roomMessageHandler(roomId, event);
-    await vi.waitFor(() => {
-      expect(onRoomMessage).toHaveBeenCalledWith(roomId, event);
-    });
-    expect(sendReadReceiptMatrixMock).not.toHaveBeenCalled();
-  }
-
-  it("sends read receipt immediately for non-self messages", async () => {
-    const { client, onRoomMessage, roomMessageHandler } = createHarness();
-    const event = makeEvent({
-      event_id: "$e1",
-      sender: "@alice:example.org",
-    });
-
-    roomMessageHandler("!room:example.org", event);
-
-    expect(onRoomMessage).toHaveBeenCalledWith("!room:example.org", event);
-    await vi.waitFor(() => {
-      expect(sendReadReceiptMatrixMock).toHaveBeenCalledWith("!room:example.org", "$e1", client);
-    });
-  });
-
-  it("does not send read receipts for self messages", async () => {
-    await expectForwardedWithoutReadReceipt(
-      makeEvent({
-        event_id: "$e2",
-        sender: "@bot:example.org",
-      }),
-    );
-  });
-
-  it("skips receipt when message lacks sender or event id", async () => {
-    await expectForwardedWithoutReadReceipt(
-      makeEvent({
-        sender: "@alice:example.org",
-        event_id: "",
-      }),
-    );
-  });
-
-  it("caches self user id across messages", async () => {
-    const { getUserId, roomMessageHandler } = createHarness();
-    const first = makeEvent({ event_id: "$e3", sender: "@alice:example.org" });
-    const second = makeEvent({ event_id: "$e4", sender: "@bob:example.org" });
-
-    roomMessageHandler("!room:example.org", first);
-    roomMessageHandler("!room:example.org", second);
-
-    await vi.waitFor(() => {
-      expect(sendReadReceiptMatrixMock).toHaveBeenCalledTimes(2);
-    });
-    expect(getUserId).toHaveBeenCalledTimes(1);
-  });
-
-  it("logs and continues when sending read receipt fails", async () => {
-    sendReadReceiptMatrixMock.mockRejectedValueOnce(new Error("network boom"));
-    const { roomMessageHandler, onRoomMessage, logVerboseMessage } = createHarness();
-    const event = makeEvent({ event_id: "$e5", sender: "@alice:example.org" });
-
-    roomMessageHandler("!room:example.org", event);
-
-    await vi.waitFor(() => {
-      expect(onRoomMessage).toHaveBeenCalledWith("!room:example.org", event);
-      expect(logVerboseMessage).toHaveBeenCalledWith(
-        expect.stringContaining("matrix: early read receipt failed"),
-      );
-    });
-  });
-
-  it("skips read receipts if self-user lookup fails", async () => {
-    const { roomMessageHandler, onRoomMessage, getUserId } = createHarness({
-      getUserId: vi.fn().mockRejectedValue(new Error("cannot resolve self")),
-    });
-    const event = makeEvent({ event_id: "$e6", sender: "@alice:example.org" });
-
-    roomMessageHandler("!room:example.org", event);
-
-    await vi.waitFor(() => {
-      expect(onRoomMessage).toHaveBeenCalledWith("!room:example.org", event);
-    });
-    expect(getUserId).toHaveBeenCalledTimes(1);
-    expect(sendReadReceiptMatrixMock).not.toHaveBeenCalled();
-  });
-
-  it("skips duplicate listener registration for the same client", () => {
-    const handlers = new Map<string, (...args: unknown[]) => void>();
-    const onMock = vi.fn((event: string, handler: (...args: unknown[]) => void) => {
-      handlers.set(event, handler);
-    });
-    const client = {
-      on: onMock,
-      getUserId: vi.fn().mockResolvedValue("@bot:example.org"),
-      crypto: undefined,
-    } as unknown as MatrixClient;
-    const params = {
-      client,
-      auth: { encryption: false } as MatrixAuth,
-      logVerboseMessage: vi.fn(),
-      warnedEncryptedRooms: new Set<string>(),
-      warnedCryptoMissingRooms: new Set<string>(),
-      logger: { warn: vi.fn() } as unknown as RuntimeLogger,
-      formatNativeDependencyHint: (() =>
-        "") as PluginRuntime["system"]["formatNativeDependencyHint"],
-      onRoomMessage: vi.fn(),
-    };
-    registerMatrixMonitorEvents(params);
-    const initialCallCount = onMock.mock.calls.length;
-    registerMatrixMonitorEvents(params);
-
-    expect(onMock).toHaveBeenCalledTimes(initialCallCount);
-    expect(params.logVerboseMessage).toHaveBeenCalledWith(
-      "matrix: skipping duplicate listener registration for client",
-    );
-  });
-});

package/src/matrix/monitor/events.ts

@@ -1,168 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import type { PluginRuntime, RuntimeLogger } from "openclaw/plugin-sdk/matrix";
-import type { MatrixAuth } from "../client.js";
-import { sendReadReceiptMatrix } from "../send.js";
-import type { MatrixRawEvent } from "./types.js";
-import { EventType } from "./types.js";
-
-const matrixMonitorListenerRegistry = (() => {
-  // Prevent duplicate listener registration when both bundled and extension
-  // paths attempt to start monitors against the same shared client.
-  const registeredClients = new WeakSet<object>();
-  return {
-    tryRegister(client: object): boolean {
-      if (registeredClients.has(client)) {
-        return false;
-      }
-      registeredClients.add(client);
-      return true;
-    },
-  };
-})();
-
-function createSelfUserIdResolver(client: Pick<MatrixClient, "getUserId">) {
-  let selfUserId: string | undefined;
-  let selfUserIdLookup: Promise<string | undefined> | undefined;
-
-  return async (): Promise<string | undefined> => {
-    if (selfUserId) {
-      return selfUserId;
-    }
-    if (!selfUserIdLookup) {
-      selfUserIdLookup = client
-        .getUserId()
-        .then((userId) => {
-          selfUserId = userId;
-          return userId;
-        })
-        .catch(() => undefined)
-        .finally(() => {
-          if (!selfUserId) {
-            selfUserIdLookup = undefined;
-          }
-        });
-    }
-    return await selfUserIdLookup;
-  };
-}
-
-export function registerMatrixMonitorEvents(params: {
-  client: MatrixClient;
-  auth: MatrixAuth;
-  logVerboseMessage: (message: string) => void;
-  warnedEncryptedRooms: Set<string>;
-  warnedCryptoMissingRooms: Set<string>;
-  logger: RuntimeLogger;
-  formatNativeDependencyHint: PluginRuntime["system"]["formatNativeDependencyHint"];
-  onRoomMessage: (roomId: string, event: MatrixRawEvent) => void | Promise<void>;
-}): void {
-  if (!matrixMonitorListenerRegistry.tryRegister(params.client)) {
-    params.logVerboseMessage("matrix: skipping duplicate listener registration for client");
-    return;
-  }
-
-  const {
-    client,
-    auth,
-    logVerboseMessage,
-    warnedEncryptedRooms,
-    warnedCryptoMissingRooms,
-    logger,
-    formatNativeDependencyHint,
-    onRoomMessage,
-  } = params;
-
-  const resolveSelfUserId = createSelfUserIdResolver(client);
-  client.on("room.message", (roomId: string, event: MatrixRawEvent) => {
-    const eventId = event?.event_id;
-    const senderId = event?.sender;
-    if (eventId && senderId) {
-      void (async () => {
-        const currentSelfUserId = await resolveSelfUserId();
-        if (!currentSelfUserId || senderId === currentSelfUserId) {
-          return;
-        }
-        await sendReadReceiptMatrix(roomId, eventId, client).catch((err) => {
-          logVerboseMessage(
-            `matrix: early read receipt failed room=${roomId} id=${eventId}: ${String(err)}`,
-          );
-        });
-      })();
-    }
-
-    onRoomMessage(roomId, event);
-  });
-
-  client.on("room.encrypted_event", (roomId: string, event: MatrixRawEvent) => {
-    const eventId = event?.event_id ?? "unknown";
-    const eventType = event?.type ?? "unknown";
-    logVerboseMessage(`matrix: encrypted event room=${roomId} type=${eventType} id=${eventId}`);
-  });
-
-  client.on("room.decrypted_event", (roomId: string, event: MatrixRawEvent) => {
-    const eventId = event?.event_id ?? "unknown";
-    const eventType = event?.type ?? "unknown";
-    logVerboseMessage(`matrix: decrypted event room=${roomId} type=${eventType} id=${eventId}`);
-  });
-
-  client.on(
-    "room.failed_decryption",
-    async (roomId: string, event: MatrixRawEvent, error: Error) => {
-      logger.warn("Failed to decrypt message", {
-        roomId,
-        eventId: event.event_id,
-        error: error.message,
-      });
-      logVerboseMessage(
-        `matrix: failed decrypt room=${roomId} id=${event.event_id ?? "unknown"} error=${error.message}`,
-      );
-    },
-  );
-
-  client.on("room.invite", (roomId: string, event: MatrixRawEvent) => {
-    const eventId = event?.event_id ?? "unknown";
-    const sender = event?.sender ?? "unknown";
-    const isDirect = (event?.content as { is_direct?: boolean } | undefined)?.is_direct === true;
-    logVerboseMessage(
-      `matrix: invite room=${roomId} sender=${sender} direct=${String(isDirect)} id=${eventId}`,
-    );
-  });
-
-  client.on("room.join", (roomId: string, event: MatrixRawEvent) => {
-    const eventId = event?.event_id ?? "unknown";
-    logVerboseMessage(`matrix: join room=${roomId} id=${eventId}`);
-  });
-
-  client.on("room.event", (roomId: string, event: MatrixRawEvent) => {
-    const eventType = event?.type ?? "unknown";
-    if (eventType === EventType.RoomMessageEncrypted) {
-      logVerboseMessage(
-        `matrix: encrypted raw event room=${roomId} id=${event?.event_id ?? "unknown"}`,
-      );
-      if (auth.encryption !== true && !warnedEncryptedRooms.has(roomId)) {
-        warnedEncryptedRooms.add(roomId);
-        const warning =
-          "matrix: encrypted event received without encryption enabled; set channels.matrix.encryption=true and verify the device to decrypt";
-        logger.warn(warning, { roomId });
-      }
-      if (auth.encryption === true && !client.crypto && !warnedCryptoMissingRooms.has(roomId)) {
-        warnedCryptoMissingRooms.add(roomId);
-        const hint = formatNativeDependencyHint({
-          packageName: "@matrix-org/matrix-sdk-crypto-nodejs",
-          manager: "pnpm",
-          downloadCommand: "node node_modules/@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js",
-        });
-        const warning = `matrix: encryption enabled but crypto is unavailable; ${hint}`;
-        logger.warn(warning, { roomId });
-      }
-      return;
-    }
-    if (eventType === EventType.RoomMember) {
-      const membership = (event?.content as { membership?: string } | undefined)?.membership;
-      const stateKey = (event as { state_key?: string }).state_key ?? "";
-      logVerboseMessage(
-        `matrix: member event room=${roomId} stateKey=${stateKey} membership=${membership ?? "unknown"}`,
-      );
-    }
-  });
-}

package/src/matrix/monitor/handler.body-for-agent.test.ts

@@ -1,196 +0,0 @@
-import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import type { PluginRuntime, RuntimeEnv, RuntimeLogger } from "openclaw/plugin-sdk/matrix";
-import { describe, expect, it, vi } from "vitest";
-import {
-  createMatrixRoomMessageHandler,
-  resolveMatrixBaseRouteSession,
-  shouldOverrideMatrixDmToGroup,
-} from "./handler.js";
-import { EventType, type MatrixRawEvent } from "./types.js";
-
-describe("createMatrixRoomMessageHandler BodyForAgent sender label", () => {
-  it("stores sender-labeled BodyForAgent for group thread messages", async () => {
-    const recordInboundSession = vi.fn().mockResolvedValue(undefined);
-    const formatInboundEnvelope = vi
-      .fn()
-      .mockImplementation((params: { senderLabel?: string; body: string }) => params.body);
-    const finalizeInboundContext = vi
-      .fn()
-      .mockImplementation((ctx: Record<string, unknown>) => ctx);
-
-    const core = {
-      channel: {
-        pairing: {
-          readAllowFromStore: vi.fn().mockResolvedValue([]),
-          upsertPairingRequest: vi.fn().mockResolvedValue(undefined),
-        },
-        routing: {
-          buildAgentSessionKey: vi
-            .fn()
-            .mockImplementation(
-              (params: { agentId: string; channel: string; peer?: { kind: string; id: string } }) =>
-                `agent:${params.agentId}:${params.channel}:${params.peer?.kind ?? "direct"}:${params.peer?.id ?? "unknown"}`,
-            ),
-          resolveAgentRoute: vi.fn().mockReturnValue({
-            agentId: "main",
-            accountId: undefined,
-            sessionKey: "agent:main:matrix:channel:!room:example.org",
-            mainSessionKey: "agent:main:main",
-          }),
-        },
-        session: {
-          resolveStorePath: vi.fn().mockReturnValue("/tmp/openclaw-test-session.json"),
-          readSessionUpdatedAt: vi.fn().mockReturnValue(123),
-          recordInboundSession,
-        },
-        reply: {
-          resolveEnvelopeFormatOptions: vi.fn().mockReturnValue({}),
-          formatInboundEnvelope,
-          formatAgentEnvelope: vi
-            .fn()
-            .mockImplementation((params: { body: string }) => params.body),
-          finalizeInboundContext,
-          resolveHumanDelayConfig: vi.fn().mockReturnValue(undefined),
-          createReplyDispatcherWithTyping: vi.fn().mockReturnValue({
-            dispatcher: {},
-            replyOptions: {},
-            markDispatchIdle: vi.fn(),
-          }),
-          withReplyDispatcher: vi
-            .fn()
-            .mockResolvedValue({ queuedFinal: false, counts: { final: 0, partial: 0, tool: 0 } }),
-        },
-        commands: {
-          shouldHandleTextCommands: vi.fn().mockReturnValue(true),
-        },
-        text: {
-          hasControlCommand: vi.fn().mockReturnValue(false),
-          resolveMarkdownTableMode: vi.fn().mockReturnValue("code"),
-        },
-      },
-      system: {
-        enqueueSystemEvent: vi.fn(),
-      },
-    } as unknown as PluginRuntime;
-
-    const runtime = {
-      error: vi.fn(),
-    } as unknown as RuntimeEnv;
-    const logger = {
-      info: vi.fn(),
-      warn: vi.fn(),
-    } as unknown as RuntimeLogger;
-    const logVerboseMessage = vi.fn();
-
-    const client = {
-      getUserId: vi.fn().mockResolvedValue("@bot:matrix.example.org"),
-    } as unknown as MatrixClient;
-
-    const handler = createMatrixRoomMessageHandler({
-      client,
-      core,
-      cfg: {},
-      runtime,
-      logger,
-      logVerboseMessage,
-      allowFrom: [],
-      roomsConfig: undefined,
-      mentionRegexes: [],
-      groupPolicy: "open",
-      replyToMode: "first",
-      threadReplies: "inbound",
-      dmEnabled: true,
-      dmPolicy: "open",
-      textLimit: 4000,
-      mediaMaxBytes: 5 * 1024 * 1024,
-      startupMs: Date.now(),
-      startupGraceMs: 60_000,
-      directTracker: {
-        isDirectMessage: vi.fn().mockResolvedValue(false),
-      },
-      getRoomInfo: vi.fn().mockResolvedValue({
-        name: "Dev Room",
-        canonicalAlias: "#dev:matrix.example.org",
-        altAliases: [],
-      }),
-      getMemberDisplayName: vi.fn().mockResolvedValue("Bu"),
-      accountId: undefined,
-    });
-
-    const event = {
-      type: EventType.RoomMessage,
-      event_id: "$event1",
-      sender: "@bu:matrix.example.org",
-      origin_server_ts: Date.now(),
-      content: {
-        msgtype: "m.text",
-        body: "show me my commits",
-        "m.mentions": { user_ids: ["@bot:matrix.example.org"] },
-        "m.relates_to": {
-          rel_type: "m.thread",
-          event_id: "$thread-root",
-        },
-      },
-    } as unknown as MatrixRawEvent;
-
-    await handler("!room:example.org", event);
-
-    expect(formatInboundEnvelope).toHaveBeenCalledWith(
-      expect.objectContaining({
-        chatType: "channel",
-        senderLabel: "Bu (bu)",
-      }),
-    );
-    expect(recordInboundSession).toHaveBeenCalledWith(
-      expect.objectContaining({
-        ctx: expect.objectContaining({
-          ChatType: "thread",
-          BodyForAgent: "Bu (bu): show me my commits",
-        }),
-      }),
-    );
-  });
-
-  it("uses room-scoped session keys for DM rooms matched via parentPeer binding", () => {
-    const buildAgentSessionKey = vi
-      .fn()
-      .mockReturnValue("agent:main:matrix:channel:!dmroom:example.org");
-
-    const resolved = resolveMatrixBaseRouteSession({
-      buildAgentSessionKey,
-      baseRoute: {
-        agentId: "main",
-        sessionKey: "agent:main:main",
-        mainSessionKey: "agent:main:main",
-        matchedBy: "binding.peer.parent",
-      },
-      isDirectMessage: true,
-      roomId: "!dmroom:example.org",
-      accountId: undefined,
-    });
-
-    expect(buildAgentSessionKey).toHaveBeenCalledWith({
-      agentId: "main",
-      channel: "matrix",
-      accountId: undefined,
-      peer: { kind: "channel", id: "!dmroom:example.org" },
-    });
-    expect(resolved).toEqual({
-      sessionKey: "agent:main:matrix:channel:!dmroom:example.org",
-      lastRoutePolicy: "session",
-    });
-  });
-
-  it("does not override DMs to groups for explicit allow:false room config", () => {
-    expect(
-      shouldOverrideMatrixDmToGroup({
-        isDirectMessage: true,
-        roomConfigInfo: {
-          config: { allow: false },
-          allowed: false,
-          matchSource: "direct",
-        },
-      }),
-    ).toBe(false);
-  });
-});