@archipelagolab/lobi 1.0.0

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

@@ -0,0 +1,326 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  clearMatrixApprovalReactionTargetsForTest,
+  registerMatrixApprovalReactionTarget,
+  resolveMatrixApprovalReactionTarget,
+} from "../../approval-reactions.js";
+import type { CoreConfig } from "../../types.js";
+import { handleInboundMatrixReaction } from "./reaction-events.js";
+
+const resolveMatrixApproval = vi.fn();
+type MatrixReactionParams = Parameters<typeof handleInboundMatrixReaction>[0];
+type MatrixReactionClient = MatrixReactionParams["client"];
+type MatrixReactionCore = MatrixReactionParams["core"];
+type MatrixReactionEvent = MatrixReactionParams["event"];
+
+vi.mock("../../exec-approval-resolver.js", () => ({
+  isApprovalNotFoundError: (err: unknown) =>
+    err instanceof Error && /unknown or expired approval id/i.test(err.message),
+  resolveMatrixApproval: (...args: unknown[]) => resolveMatrixApproval(...args),
+}));
+
+beforeEach(() => {
+  resolveMatrixApproval.mockReset();
+  clearMatrixApprovalReactionTargetsForTest();
+});
+
+function buildConfig(): CoreConfig {
+  return {
+    channels: {
+      matrix: {
+        homeserver: "https://matrix.example.org",
+        userId: "@bot:example.org",
+        accessToken: "tok",
+        reactionNotifications: "own",
+        execApprovals: {
+          enabled: true,
+          approvers: ["@owner:example.org"],
+          target: "channel",
+        },
+      },
+    },
+  } as CoreConfig;
+}
+
+function buildCore() {
+  return {
+    channel: {
+      routing: {
+        resolveAgentRoute: vi.fn().mockReturnValue({
+          sessionKey: "agent:main:matrix:channel:!ops:example.org",
+          mainSessionKey: "agent:main:matrix:channel:!ops:example.org",
+          agentId: "main",
+          matchedBy: "peer",
+        }),
+      },
+    },
+    system: {
+      enqueueSystemEvent: vi.fn(),
+    },
+  } as unknown as Parameters<typeof handleInboundMatrixReaction>[0]["core"];
+}
+
+function createReactionClient(
+  getEvent: ReturnType<typeof vi.fn> = vi.fn(),
+): MatrixReactionClient & { getEvent: ReturnType<typeof vi.fn> } {
+  return { getEvent } as unknown as MatrixReactionClient & {
+    getEvent: ReturnType<typeof vi.fn>;
+  };
+}
+
+function createReactionEvent(
+  params: {
+    eventId?: string;
+    targetEventId?: string;
+    reactionKey?: string;
+  } = {},
+): MatrixReactionEvent {
+  return {
+    event_id: params.eventId ?? "$reaction-1",
+    sender: "@owner:example.org",
+    type: "m.reaction",
+    origin_server_ts: 123,
+    content: {
+      "m.relates_to": {
+        rel_type: "m.annotation",
+        event_id: params.targetEventId ?? "$approval-msg",
+        key: params.reactionKey ?? "✅",
+      },
+    },
+  } as MatrixReactionEvent;
+}
+
+async function handleReaction(params: {
+  client: MatrixReactionClient;
+  core: MatrixReactionCore;
+  cfg?: CoreConfig;
+  targetEventId?: string;
+  reactionKey?: string;
+}): Promise<void> {
+  await handleInboundMatrixReaction({
+    client: params.client,
+    core: params.core,
+    cfg: params.cfg ?? buildConfig(),
+    accountId: "default",
+    roomId: "!ops:example.org",
+    event: createReactionEvent({
+      targetEventId: params.targetEventId,
+      reactionKey: params.reactionKey,
+    }),
+    senderId: "@owner:example.org",
+    senderLabel: "Owner",
+    selfUserId: "@bot:example.org",
+    isDirectMessage: false,
+    logVerboseMessage: vi.fn(),
+  });
+}
+
+describe("matrix approval reactions", () => {
+  it("resolves approval reactions instead of enqueueing a generic reaction event", async () => {
+    const core = buildCore();
+    const cfg = buildConfig();
+    registerMatrixApprovalReactionTarget({
+      roomId: "!ops:example.org",
+      eventId: "$approval-msg",
+      approvalId: "req-123",
+      allowedDecisions: ["allow-once", "allow-always", "deny"],
+    });
+    const client = createReactionClient(
+      vi.fn().mockResolvedValue({
+        event_id: "$approval-msg",
+        sender: "@bot:example.org",
+        content: { body: "approval prompt" },
+      }),
+    );
+
+    await handleReaction({
+      client,
+      core,
+      cfg,
+    });
+
+    expect(resolveMatrixApproval).toHaveBeenCalledWith({
+      cfg,
+      approvalId: "req-123",
+      decision: "allow-once",
+      senderId: "@owner:example.org",
+    });
+    expect(core.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("keeps ordinary reactions on bot messages as generic reaction events", async () => {
+    const core = buildCore();
+    const client = createReactionClient(
+      vi.fn().mockResolvedValue({
+        event_id: "$msg-1",
+        sender: "@bot:example.org",
+        content: {
+          body: "normal bot message",
+        },
+      }),
+    );
+
+    await handleReaction({
+      client,
+      core,
+      targetEventId: "$msg-1",
+      reactionKey: "👍",
+    });
+
+    expect(resolveMatrixApproval).not.toHaveBeenCalled();
+    expect(core.system.enqueueSystemEvent).toHaveBeenCalledWith(
+      "Matrix reaction added: 👍 by Owner on msg $msg-1",
+      expect.objectContaining({
+        contextKey: "matrix:reaction:add:!ops:example.org:$msg-1:@owner:example.org:👍",
+      }),
+    );
+  });
+
+  it("still resolves approval reactions when generic reaction notifications are off", async () => {
+    const core = buildCore();
+    const cfg = buildConfig();
+    const matrixCfg = cfg.channels?.matrix;
+    if (!matrixCfg) {
+      throw new Error("matrix config missing");
+    }
+    matrixCfg.reactionNotifications = "off";
+    registerMatrixApprovalReactionTarget({
+      roomId: "!ops:example.org",
+      eventId: "$approval-msg",
+      approvalId: "req-123",
+      allowedDecisions: ["deny"],
+    });
+    const client = createReactionClient(
+      vi.fn().mockResolvedValue({
+        event_id: "$approval-msg",
+        sender: "@bot:example.org",
+        content: { body: "approval prompt" },
+      }),
+    );
+
+    await handleReaction({
+      client,
+      core,
+      cfg,
+      reactionKey: "❌",
+    });
+
+    expect(resolveMatrixApproval).toHaveBeenCalledWith({
+      cfg,
+      approvalId: "req-123",
+      decision: "deny",
+      senderId: "@owner:example.org",
+    });
+    expect(core.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("resolves registered approval reactions without fetching the target event", async () => {
+    const core = buildCore();
+    registerMatrixApprovalReactionTarget({
+      roomId: "!ops:example.org",
+      eventId: "$approval-msg",
+      approvalId: "req-123",
+      allowedDecisions: ["allow-once"],
+    });
+    const client = createReactionClient(vi.fn().mockRejectedValue(new Error("boom")));
+
+    await handleReaction({
+      client,
+      core,
+    });
+
+    expect(client.getEvent).not.toHaveBeenCalled();
+    expect(resolveMatrixApproval).toHaveBeenCalledWith({
+      cfg: buildConfig(),
+      approvalId: "req-123",
+      decision: "allow-once",
+      senderId: "@owner:example.org",
+    });
+    expect(core.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("resolves plugin approval reactions through the same Matrix reaction path", async () => {
+    const core = buildCore();
+    const cfg = buildConfig();
+    const matrixCfg = cfg.channels?.matrix;
+    if (!matrixCfg) {
+      throw new Error("matrix config missing");
+    }
+    matrixCfg.dm = { allowFrom: ["@owner:example.org"] };
+    registerMatrixApprovalReactionTarget({
+      roomId: "!ops:example.org",
+      eventId: "$plugin-approval-msg",
+      approvalId: "plugin:req-123",
+      allowedDecisions: ["allow-once", "deny"],
+    });
+    const client = createReactionClient();
+
+    await handleReaction({
+      client,
+      core,
+      cfg,
+      targetEventId: "$plugin-approval-msg",
+    });
+
+    expect(client.getEvent).not.toHaveBeenCalled();
+    expect(resolveMatrixApproval).toHaveBeenCalledWith({
+      cfg,
+      approvalId: "plugin:req-123",
+      decision: "allow-once",
+      senderId: "@owner:example.org",
+    });
+    expect(core.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("unregisters stale approval anchors after not-found resolution", async () => {
+    const core = buildCore();
+    resolveMatrixApproval.mockRejectedValueOnce(
+      new Error("unknown or expired approval id req-123"),
+    );
+    registerMatrixApprovalReactionTarget({
+      roomId: "!ops:example.org",
+      eventId: "$approval-msg",
+      approvalId: "req-123",
+      allowedDecisions: ["deny"],
+    });
+    const client = createReactionClient();
+
+    await handleReaction({
+      client,
+      core,
+      reactionKey: "❌",
+    });
+
+    expect(client.getEvent).not.toHaveBeenCalled();
+    expect(
+      resolveMatrixApprovalReactionTarget({
+        roomId: "!ops:example.org",
+        eventId: "$approval-msg",
+        reactionKey: "❌",
+      }),
+    ).toBeNull();
+  });
+
+  it("skips target fetches for ordinary reactions when notifications are off", async () => {
+    const core = buildCore();
+    const cfg = buildConfig();
+    const matrixCfg = cfg.channels?.matrix;
+    if (!matrixCfg) {
+      throw new Error("matrix config missing");
+    }
+    matrixCfg.reactionNotifications = "off";
+    const client = createReactionClient();
+
+    await handleReaction({
+      client,
+      core,
+      cfg,
+      targetEventId: "$msg-1",
+      reactionKey: "👍",
+    });
+
+    expect(client.getEvent).not.toHaveBeenCalled();
+    expect(resolveMatrixApproval).not.toHaveBeenCalled();
+    expect(core.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+});

package/src/matrix/monitor/reaction-events.ts

@@ -0,0 +1,187 @@
+import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-runtime";
+import { matrixApprovalCapability } from "../../approval-native.js";
+import {
+  resolveMatrixApprovalReactionTarget,
+  unregisterMatrixApprovalReactionTarget,
+} from "../../approval-reactions.js";
+import { isApprovalNotFoundError, resolveMatrixApproval } from "../../exec-approval-resolver.js";
+import type { CoreConfig } from "../../types.js";
+import { resolveMatrixAccountConfig } from "../account-config.js";
+import { extractMatrixReactionAnnotation } from "../reaction-common.js";
+import type { MatrixClient } from "../sdk.js";
+import { resolveMatrixInboundRoute } from "./route.js";
+import type { PluginRuntime } from "./runtime-api.js";
+import { resolveMatrixThreadRootId, resolveMatrixThreadRouting } from "./threads.js";
+import type { MatrixRawEvent, RoomMessageEventContent } from "./types.js";
+
+export type MatrixReactionNotificationMode = "off" | "own";
+
+export function resolveMatrixReactionNotificationMode(params: {
+  cfg: CoreConfig;
+  accountId: string;
+}): MatrixReactionNotificationMode {
+  const matrixConfig = params.cfg.channels?.matrix;
+  const accountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  return accountConfig.reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
+}
+
+async function maybeResolveMatrixApprovalReaction(params: {
+  cfg: CoreConfig;
+  accountId: string;
+  senderId: string;
+  target: ReturnType<typeof resolveMatrixApprovalReactionTarget>;
+  targetEventId: string;
+  roomId: string;
+  logVerboseMessage: (message: string) => void;
+}): Promise<boolean> {
+  if (!params.target) {
+    return false;
+  }
+  if (
+    !matrixApprovalCapability.authorizeActorAction?.({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      senderId: params.senderId,
+      action: "approve",
+      approvalKind: params.target.approvalId.startsWith("plugin:") ? "plugin" : "exec",
+    })?.authorized
+  ) {
+    return false;
+  }
+  try {
+    await resolveMatrixApproval({
+      cfg: params.cfg,
+      approvalId: params.target.approvalId,
+      decision: params.target.decision,
+      senderId: params.senderId,
+    });
+    params.logVerboseMessage(
+      `matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} decision=${params.target.decision}`,
+    );
+    return true;
+  } catch (err) {
+    if (isApprovalNotFoundError(err)) {
+      unregisterMatrixApprovalReactionTarget({
+        roomId: params.roomId,
+        eventId: params.targetEventId,
+      });
+      params.logVerboseMessage(
+        `matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`,
+      );
+      return true;
+    }
+    params.logVerboseMessage(
+      `matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`,
+    );
+    return true;
+  }
+}
+
+export async function handleInboundMatrixReaction(params: {
+  client: MatrixClient;
+  core: PluginRuntime;
+  cfg: CoreConfig;
+  accountId: string;
+  roomId: string;
+  event: MatrixRawEvent;
+  senderId: string;
+  senderLabel: string;
+  selfUserId: string;
+  isDirectMessage: boolean;
+  logVerboseMessage: (message: string) => void;
+}): Promise<void> {
+  const reaction = extractMatrixReactionAnnotation(params.event.content);
+  if (!reaction?.eventId) {
+    return;
+  }
+  if (params.senderId === params.selfUserId) {
+    return;
+  }
+  const approvalTarget = resolveMatrixApprovalReactionTarget({
+    roomId: params.roomId,
+    eventId: reaction.eventId,
+    reactionKey: reaction.key,
+  });
+  if (
+    await maybeResolveMatrixApprovalReaction({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      senderId: params.senderId,
+      target: approvalTarget,
+      targetEventId: reaction.eventId,
+      roomId: params.roomId,
+      logVerboseMessage: params.logVerboseMessage,
+    })
+  ) {
+    return;
+  }
+  const notificationMode = resolveMatrixReactionNotificationMode({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (notificationMode === "off") {
+    return;
+  }
+
+  const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
+    params.logVerboseMessage(
+      `matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`,
+    );
+    return null;
+  });
+  const targetSender =
+    targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
+  if (!targetSender) {
+    return;
+  }
+  if (notificationMode === "own" && targetSender !== params.selfUserId) {
+    return;
+  }
+
+  const targetContent =
+    targetEvent && targetEvent.content && typeof targetEvent.content === "object"
+      ? (targetEvent.content as RoomMessageEventContent)
+      : undefined;
+  const threadRootId = targetContent
+    ? resolveMatrixThreadRootId({
+        event: targetEvent as MatrixRawEvent,
+        content: targetContent,
+      })
+    : undefined;
+  const accountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  const thread = resolveMatrixThreadRouting({
+    isDirectMessage: params.isDirectMessage,
+    threadReplies: accountConfig.threadReplies ?? "inbound",
+    dmThreadReplies: accountConfig.dm?.threadReplies,
+    messageId: reaction.eventId,
+    threadRootId,
+  });
+  const { route, runtimeBindingId } = resolveMatrixInboundRoute({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    roomId: params.roomId,
+    senderId: params.senderId,
+    isDirectMessage: params.isDirectMessage,
+    dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
+    threadId: thread.threadId,
+    eventTs: params.event.origin_server_ts,
+    resolveAgentRoute: params.core.channel.routing.resolveAgentRoute,
+  });
+  if (runtimeBindingId) {
+    getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts);
+  }
+  const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
+  params.core.system.enqueueSystemEvent(text, {
+    sessionKey: route.sessionKey,
+    contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`,
+  });
+  params.logVerboseMessage(
+    `matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`,
+  );
+}

package/src/matrix/monitor/recent-invite.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { shouldPromoteRecentInviteRoom } from "./recent-invite.js";
+
+describe("shouldPromoteRecentInviteRoom", () => {
+  it("fails closed when room metadata could not be resolved", () => {
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!room:example.org",
+        roomInfo: {
+          altAliases: [],
+          nameResolved: false,
+          aliasesResolved: true,
+        },
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects named or aliased rooms", () => {
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!named:example.org",
+        roomInfo: {
+          name: "Ops Room",
+          altAliases: [],
+          nameResolved: true,
+          aliasesResolved: true,
+        },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!aliased:example.org",
+        roomInfo: {
+          canonicalAlias: "#ops:example.org",
+          altAliases: [],
+          nameResolved: true,
+          aliasesResolved: true,
+        },
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects rooms explicitly configured by direct match", () => {
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!room:example.org",
+        roomInfo: {
+          altAliases: [],
+          nameResolved: true,
+          aliasesResolved: true,
+        },
+        rooms: {
+          "!room:example.org": {
+            enabled: true,
+          },
+        },
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects rooms matched only by wildcard config", () => {
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!room:example.org",
+        roomInfo: {
+          altAliases: [],
+          nameResolved: true,
+          aliasesResolved: true,
+        },
+        rooms: {
+          "*": {
+            enabled: false,
+          },
+        },
+      }),
+    ).toBe(false);
+  });
+
+  it("allows strict unnamed invite rooms without direct room config", () => {
+    expect(
+      shouldPromoteRecentInviteRoom({
+        roomId: "!room:example.org",
+        roomInfo: {
+          altAliases: [],
+          nameResolved: true,
+          aliasesResolved: true,
+        },
+      }),
+    ).toBe(true);
+  });
+});

package/src/matrix/monitor/recent-invite.ts

@@ -0,0 +1,30 @@
+import type { MatrixRoomConfig } from "../../types.js";
+import type { MatrixRoomInfo } from "./room-info.js";
+import { resolveMatrixRoomConfig } from "./rooms.js";
+
+export function shouldPromoteRecentInviteRoom(params: {
+  roomId: string;
+  roomInfo: Pick<
+    MatrixRoomInfo,
+    "name" | "canonicalAlias" | "altAliases" | "nameResolved" | "aliasesResolved"
+  >;
+  rooms?: Record<string, MatrixRoomConfig>;
+}): boolean {
+  if (!params.roomInfo.nameResolved || !params.roomInfo.aliasesResolved) {
+    return false;
+  }
+
+  const roomAliases = [params.roomInfo.canonicalAlias ?? "", ...params.roomInfo.altAliases].filter(
+    Boolean,
+  );
+  if ((params.roomInfo.name?.trim() ?? "") || roomAliases.length > 0) {
+    return false;
+  }
+
+  const roomConfig = resolveMatrixRoomConfig({
+    rooms: params.rooms,
+    roomId: params.roomId,
+    aliases: roomAliases,
+  });
+  return roomConfig.matchSource === undefined;
+}