@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/monitor-handler/reaction-handler.test.ts

@@ -1,267 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig, PluginRuntime } from "../../runtime-api.js";
-import type { MSTeamsMessageHandlerDeps } from "../monitor-handler.js";
-import { setMSTeamsRuntime } from "../runtime.js";
-import { createMSTeamsReactionHandler } from "./reaction-handler.js";
-
-function buildMockRuntime(overrides?: Partial<PluginRuntime>): PluginRuntime {
-  return {
-    logging: { shouldLogVerbose: () => false },
-    channel: {
-      routing: {
-        resolveAgentRoute: vi.fn(() => ({
-          sessionKey: "test-session",
-          agentId: "agent1",
-          accountId: "default",
-        })),
-      },
-      pairing: {
-        readAllowFromStore: vi.fn(async () => []),
-        upsertPairingRequest: vi.fn(async () => null),
-      },
-    },
-    system: {
-      enqueueSystemEvent: vi.fn(),
-    },
-    ...overrides,
-  } as unknown as PluginRuntime;
-}
-
-function buildDeps(cfg: OpenClawConfig, _runtime?: PluginRuntime): MSTeamsMessageHandlerDeps {
-  return {
-    cfg,
-    runtime: { error: vi.fn() } as unknown as MSTeamsMessageHandlerDeps["runtime"],
-    appId: "test-app",
-    adapter: {} as MSTeamsMessageHandlerDeps["adapter"],
-    tokenProvider: { getAccessToken: vi.fn(async () => "token") },
-    textLimit: 4000,
-    mediaMaxBytes: 1024 * 1024,
-    conversationStore: {
-      upsert: vi.fn(async () => undefined),
-    } as unknown as MSTeamsMessageHandlerDeps["conversationStore"],
-    pollStore: {
-      recordVote: vi.fn(async () => null),
-    } as unknown as MSTeamsMessageHandlerDeps["pollStore"],
-    log: {
-      info: vi.fn(),
-      debug: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-    } as unknown as MSTeamsMessageHandlerDeps["log"],
-  };
-}
-
-function createReactionTestHarness() {
-  const mockRuntime = buildMockRuntime();
-  setMSTeamsRuntime(mockRuntime);
-
-  const cfg: OpenClawConfig = {
-    channels: { msteams: { allowFrom: ["allowed-aad"] } },
-  } as OpenClawConfig;
-
-  const deps = buildDeps(cfg, mockRuntime);
-  const handler = createMSTeamsReactionHandler(deps);
-  const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-
-  return { handler, enqueue };
-}
-
-async function invokeReactionEvent(
-  handler: ReturnType<typeof createMSTeamsReactionHandler>,
-  activity: Record<string, unknown>,
-  direction: "added" | "removed",
-) {
-  await handler(
-    {
-      activity: {
-        type: "messageReaction",
-        conversation: { id: "dm-conv", conversationType: "personal" },
-        ...activity,
-      },
-      sendActivity: vi.fn(async () => undefined),
-    } as never,
-    direction,
-  );
-}
-
-describe("createMSTeamsReactionHandler", () => {
-  describe("emoji mapping", () => {
-    it("maps Teams reaction types to unicode emoji in event label", async () => {
-      const mockRuntime = buildMockRuntime();
-      setMSTeamsRuntime(mockRuntime);
-
-      const cfg: OpenClawConfig = {
-        channels: {
-          msteams: {
-            allowFrom: ["allowed-aad"],
-          },
-        },
-      } as OpenClawConfig;
-
-      const deps = buildDeps(cfg);
-      const handler = createMSTeamsReactionHandler(deps);
-
-      await handler(
-        {
-          activity: {
-            type: "messageReaction",
-            reactionsAdded: [{ type: "like" }],
-            from: { id: "user-id", aadObjectId: "allowed-aad", name: "Alice" },
-            conversation: { id: "personal-conv", conversationType: "personal" },
-            replyToId: "msg-123",
-          },
-          sendActivity: vi.fn(async () => undefined),
-        } as never,
-        "added",
-      );
-
-      const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-      expect(enqueue).toHaveBeenCalledOnce();
-      const label: string = enqueue.mock.calls[0][0];
-      expect(label).toContain("👍");
-      expect(label).toContain("Alice");
-      expect(label).toContain("msg-123");
-    });
-
-    it("maps heart, laugh, surprised, sad, angry reaction types", async () => {
-      const emojiMap: Record<string, string> = {
-        heart: "❤️",
-        laugh: "😆",
-        surprised: "😮",
-        sad: "😢",
-        angry: "😡",
-      };
-
-      for (const [type, expectedEmoji] of Object.entries(emojiMap)) {
-        const mockRuntime = buildMockRuntime();
-        setMSTeamsRuntime(mockRuntime);
-
-        const cfg: OpenClawConfig = {
-          channels: { msteams: { allowFrom: ["allowed-aad"] } },
-        } as OpenClawConfig;
-
-        const deps = buildDeps(cfg, mockRuntime);
-        const handler = createMSTeamsReactionHandler(deps);
-
-        await handler(
-          {
-            activity: {
-              type: "messageReaction",
-              reactionsAdded: [{ type }],
-              from: { id: "user-id", aadObjectId: "allowed-aad", name: "Bob" },
-              conversation: { id: "dm-conv", conversationType: "personal" },
-              replyToId: "msg-456",
-            },
-            sendActivity: vi.fn(async () => undefined),
-          } as never,
-          "added",
-        );
-
-        const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-        const label: string = enqueue.mock.calls[0][0];
-        expect(label).toContain(expectedEmoji);
-      }
-    });
-  });
-
-  describe("inbound reaction events", () => {
-    it("enqueues system event for reactionsAdded", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-1",
-        },
-        "added",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-      const [label, meta] = enqueue.mock.calls[0];
-      expect(label).toContain("added");
-      expect(meta.sessionKey).toBe("test-session");
-      expect(meta.contextKey).toContain("added");
-    });
-
-    it("enqueues system event for reactionsRemoved", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsRemoved: [{ type: "heart" }],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-2",
-        },
-        "removed",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-      const [label] = enqueue.mock.calls[0];
-      expect(label).toContain("removed");
-      expect(label).toContain("❤️");
-    });
-
-    it("skips when reactions array is empty", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-3",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-
-    it("skips when from.id is missing", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: {},
-          replyToId: "msg-4",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("sender authorization", () => {
-    it("drops reaction from non-allowlisted DM sender", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "bad-user", aadObjectId: "not-allowed", name: "Attacker" },
-          replyToId: "msg-5",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-
-    it("allows reaction from allowlisted DM sender", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "good-user", aadObjectId: "allowed-aad", name: "Alice" },
-          replyToId: "msg-6",
-        },
-        "added",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-    });
-  });
-});

package/src/monitor-handler/reaction-handler.ts

@@ -1,210 +0,0 @@
-import {
-  DEFAULT_ACCOUNT_ID,
-  isDangerousNameMatchingEnabled,
-  resolveEffectiveAllowFromLists,
-  readStoreAllowFromForDmPolicy,
-  resolveDmGroupAccessWithLists,
-  resolveDefaultGroupPolicy,
-  createChannelPairingController,
-} from "../../runtime-api.js";
-import { normalizeMSTeamsConversationId } from "../inbound.js";
-import type { MSTeamsMessageHandlerDeps } from "../monitor-handler.types.js";
-import {
-  isMSTeamsGroupAllowed,
-  resolveMSTeamsAllowlistMatch,
-  resolveMSTeamsRouteConfig,
-} from "../policy.js";
-import { getMSTeamsRuntime } from "../runtime.js";
-import type { MSTeamsTurnContext } from "../sdk-types.js";
-
-/** Teams reaction type names → Unicode emoji. */
-const TEAMS_REACTION_EMOJI: Record<string, string> = {
-  like: "👍",
-  heart: "❤️",
-  laugh: "😆",
-  surprised: "😮",
-  sad: "😢",
-  angry: "😡",
-};
-
-/**
- * Map a Teams reaction type string to a Unicode emoji.
- * Falls back to the raw type if not recognized.
- */
-function mapReactionEmoji(reactionType: string): string {
-  return TEAMS_REACTION_EMOJI[reactionType] ?? reactionType;
-}
-
-type ReactionDirection = "added" | "removed";
-
-/**
- * Create a handler for MS Teams reaction activities (reactionsAdded / reactionsRemoved).
- * The returned function accepts a turn context and a direction string.
- */
-export function createMSTeamsReactionHandler(deps: MSTeamsMessageHandlerDeps) {
-  const { cfg, log } = deps;
-  const core = getMSTeamsRuntime();
-  const msteamsCfg = cfg.channels?.msteams;
-  const pairing = createChannelPairingController({
-    core,
-    channel: "msteams",
-    accountId: DEFAULT_ACCOUNT_ID,
-  });
-
-  return async function handleReaction(
-    context: MSTeamsTurnContext,
-    direction: ReactionDirection,
-  ): Promise<void> {
-    const activity = context.activity;
-
-    // Reactions are carried in reactionsAdded / reactionsRemoved on the activity.
-    const reactions: Array<{ type?: string }> =
-      direction === "added"
-        ? ((activity as unknown as { reactionsAdded?: Array<{ type?: string }> }).reactionsAdded ??
-          [])
-        : ((activity as unknown as { reactionsRemoved?: Array<{ type?: string }> })
-            .reactionsRemoved ?? []);
-
-    if (reactions.length === 0) {
-      log.debug?.("reaction activity has no reactions; skipping");
-      return;
-    }
-
-    const from = activity.from;
-    if (!from?.id) {
-      log.debug?.("reaction activity missing from.id; skipping");
-      return;
-    }
-
-    const rawConversationId = activity.conversation?.id ?? "";
-    const conversationId = normalizeMSTeamsConversationId(rawConversationId);
-    const conversationType = activity.conversation?.conversationType ?? "personal";
-    const isGroupChat = conversationType === "groupChat" || activity.conversation?.isGroup === true;
-    const isChannel = conversationType === "channel";
-    const isDirectMessage = !isGroupChat && !isChannel;
-
-    const senderId = from.aadObjectId ?? from.id;
-    const senderName = from.name ?? from.id;
-    const dmPolicy = msteamsCfg?.dmPolicy ?? "pairing";
-
-    // Simplified authorization: reuse the same allowlist/policy checks as the message handler.
-    const storedAllowFrom = await readStoreAllowFromForDmPolicy({
-      provider: "msteams",
-      accountId: pairing.accountId,
-      dmPolicy,
-      readStore: pairing.readStoreForDmPolicy,
-    });
-
-    const dmAllowFrom = msteamsCfg?.allowFrom ?? [];
-    const groupAllowFrom = msteamsCfg?.groupAllowFrom;
-    const resolvedAllowFromLists = resolveEffectiveAllowFromLists({
-      allowFrom: dmAllowFrom,
-      groupAllowFrom,
-      storeAllowFrom: storedAllowFrom,
-      dmPolicy,
-    });
-
-    // Enforce dmPolicy for DMs (open / disabled / allowlist / pairing).
-    const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
-    if (isDirectMessage && msteamsCfg) {
-      const access = resolveDmGroupAccessWithLists({
-        isGroup: false,
-        dmPolicy,
-        groupPolicy: msteamsCfg.groupPolicy ?? defaultGroupPolicy ?? "allowlist",
-        allowFrom: dmAllowFrom,
-        groupAllowFrom,
-        storeAllowFrom: storedAllowFrom,
-        groupAllowFromFallbackToAllowFrom: false,
-        isSenderAllowed: (allowFrom) =>
-          resolveMSTeamsAllowlistMatch({
-            allowFrom,
-            senderId,
-            senderName,
-            allowNameMatching: isDangerousNameMatchingEnabled(msteamsCfg),
-          }).allowed,
-      });
-      if (access.decision !== "allow") {
-        log.debug?.("dropping reaction (dm access denied)", {
-          sender: senderId,
-          reason: access.reason,
-        });
-        return;
-      }
-    }
-
-    // For group/channel messages, check the route allowlist and sender allowlist.
-    if (!isDirectMessage && msteamsCfg) {
-      const teamId = (activity as unknown as { channelData?: { team?: { id?: string } } })
-        .channelData?.team?.id;
-      const teamName = (activity as unknown as { channelData?: { team?: { name?: string } } })
-        .channelData?.team?.name;
-      const channelName = (activity as unknown as { channelData?: { channel?: { name?: string } } })
-        .channelData?.channel?.name;
-      const channelGate = resolveMSTeamsRouteConfig({
-        cfg: msteamsCfg,
-        teamId,
-        teamName,
-        conversationId,
-        channelName,
-        allowNameMatching: isDangerousNameMatchingEnabled(msteamsCfg),
-      });
-      if (channelGate.allowlistConfigured && !channelGate.allowed) {
-        log.debug?.("dropping reaction (not in team/channel allowlist)", { conversationId });
-        return;
-      }
-
-      const effectiveGroupAllowFrom = resolvedAllowFromLists.effectiveGroupAllowFrom;
-      const groupAllowed = isMSTeamsGroupAllowed({
-        groupPolicy: msteamsCfg.groupPolicy ?? defaultGroupPolicy ?? "allowlist",
-        allowFrom: effectiveGroupAllowFrom,
-        senderId,
-        senderName,
-        allowNameMatching: isDangerousNameMatchingEnabled(msteamsCfg),
-      });
-      if (!groupAllowed) {
-        log.debug?.("dropping reaction (sender not in group allowlist)", { sender: senderId });
-        return;
-      }
-    }
-
-    // Resolve the agent route for this conversation/sender.
-    // Extract teamId for team-scoped routing bindings (channel/group reactions).
-    const teamId = isDirectMessage
-      ? undefined
-      : (activity as unknown as { channelData?: { team?: { id?: string } } }).channelData?.team?.id;
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: "msteams",
-      peer: {
-        kind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
-        id: isDirectMessage ? senderId : conversationId,
-      },
-      ...(teamId ? { teamId } : {}),
-    });
-
-    // The replyToId points to the message that was reacted to.
-    const targetMessageId = (activity as unknown as { replyToId?: string }).replyToId ?? "unknown";
-
-    for (const reaction of reactions) {
-      const reactionType = reaction.type ?? "unknown";
-      const emoji = mapReactionEmoji(reactionType);
-      const label =
-        direction === "added"
-          ? `Teams reaction ${emoji} added by ${senderName} on message ${targetMessageId}`
-          : `Teams reaction ${emoji} removed by ${senderName} from message ${targetMessageId}`;
-
-      log.info(`reaction ${direction}`, {
-        sender: senderId,
-        reactionType,
-        emoji,
-        targetMessageId,
-        conversationId,
-      });
-
-      core.system.enqueueSystemEvent(label, {
-        sessionKey: route.sessionKey,
-        contextKey: `msteams:reaction:${conversationId}:${targetMessageId}:${senderId}:${reactionType}:${direction}`,
-      });
-    }
-  };
-}

package/src/monitor-handler/thread-session.ts

@@ -1,17 +0,0 @@
-import { resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-
-export function resolveMSTeamsRouteSessionKey(params: {
-  baseSessionKey: string;
-  isChannel: boolean;
-  conversationMessageId?: string;
-  replyToId?: string;
-}): string {
-  const channelThreadId = params.isChannel
-    ? (params.conversationMessageId ?? params.replyToId ?? undefined)
-    : undefined;
-  return resolveThreadSessionKeys({
-    baseSessionKey: params.baseSessionKey,
-    threadId: channelThreadId,
-    parentSessionKey: channelThreadId ? params.baseSessionKey : undefined,
-  }).sessionKey;
-}

package/src/monitor-handler.adaptive-card.test.ts

@@ -1,162 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig, RuntimeEnv } from "../runtime-api.js";
-import type { MSTeamsConversationStore } from "./conversation-store.js";
-import {
-  type MSTeamsActivityHandler,
-  type MSTeamsMessageHandlerDeps,
-  registerMSTeamsHandlers,
-} from "./monitor-handler.js";
-import { installMSTeamsTestRuntime } from "./monitor-handler.test-helpers.js";
-import type { MSTeamsTurnContext } from "./sdk-types.js";
-
-const runtimeApiMockState = vi.hoisted(() => ({
-  dispatchReplyFromConfigWithSettledDispatcher: vi.fn(async (params: { ctxPayload: unknown }) => ({
-    queuedFinal: false,
-    counts: {},
-    capturedCtxPayload: params.ctxPayload,
-  })),
-}));
-
-vi.mock("openclaw/plugin-sdk/inbound-reply-dispatch", () => {
-  return {
-    dispatchReplyFromConfigWithSettledDispatcher:
-      runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher,
-  };
-});
-
-vi.mock("./reply-dispatcher.js", () => ({
-  createMSTeamsReplyDispatcher: () => ({
-    dispatcher: {},
-    replyOptions: {},
-    markDispatchIdle: vi.fn(),
-  }),
-}));
-
-function createDeps(): MSTeamsMessageHandlerDeps {
-  installMSTeamsTestRuntime();
-
-  return {
-    cfg: {} as OpenClawConfig,
-    runtime: { error: vi.fn() } as unknown as RuntimeEnv,
-    appId: "test-app",
-    adapter: {} as MSTeamsMessageHandlerDeps["adapter"],
-    tokenProvider: {
-      getAccessToken: vi.fn(async () => "token"),
-    },
-    textLimit: 4000,
-    mediaMaxBytes: 1024 * 1024,
-    conversationStore: {
-      get: vi.fn(async () => null),
-      upsert: vi.fn(async () => undefined),
-      list: vi.fn(async () => []),
-      remove: vi.fn(async () => false),
-      findPreferredDmByUserId: vi.fn(async () => null),
-      findByUserId: vi.fn(async () => null),
-    } satisfies MSTeamsConversationStore,
-    pollStore: {
-      recordVote: vi.fn(async () => null),
-    } as unknown as MSTeamsMessageHandlerDeps["pollStore"],
-    log: {
-      info: vi.fn(),
-      debug: vi.fn(),
-      error: vi.fn(),
-    } as unknown as MSTeamsMessageHandlerDeps["log"],
-  };
-}
-
-function createActivityHandler() {
-  const messageHandlers: Array<(context: unknown, next: () => Promise<void>) => Promise<void>> = [];
-  const run = vi.fn(async (context: unknown) => {
-    const activityType = (context as MSTeamsTurnContext).activity?.type;
-    if (activityType !== "message") {
-      return;
-    }
-    for (const handler of messageHandlers) {
-      await handler(context, async () => {});
-    }
-  });
-
-  let handler: MSTeamsActivityHandler & {
-    run: NonNullable<MSTeamsActivityHandler["run"]>;
-  };
-  handler = {
-    onMessage: (nextHandler) => {
-      messageHandlers.push(nextHandler);
-      return handler;
-    },
-    onMembersAdded: () => handler,
-    onReactionsAdded: () => handler,
-    onReactionsRemoved: () => handler,
-    run,
-  };
-
-  return { handler, run };
-}
-
-describe("msteams adaptive card action invoke", () => {
-  beforeEach(() => {
-    runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher.mockClear();
-  });
-
-  it("forwards adaptive card invoke values to the agent as message text", async () => {
-    const deps = createDeps();
-    const { handler, run } = createActivityHandler();
-    const registered = registerMSTeamsHandlers(handler, deps) as MSTeamsActivityHandler & {
-      run: NonNullable<MSTeamsActivityHandler["run"]>;
-    };
-    const payload = {
-      action: {
-        type: "Action.Submit",
-        data: {
-          intent: "deploy",
-          environment: "prod",
-        },
-      },
-      trigger: "button-click",
-    };
-
-    await registered.run({
-      activity: {
-        id: "invoke-1",
-        type: "invoke",
-        name: "adaptiveCard/action",
-        channelId: "msteams",
-        serviceUrl: "https://service.example.test",
-        from: {
-          id: "user-bf",
-          aadObjectId: "user-aad",
-          name: "User",
-        },
-        recipient: {
-          id: "bot-id",
-          name: "Bot",
-        },
-        conversation: {
-          id: "19:personal-chat;messageid=abc123",
-          conversationType: "personal",
-        },
-        channelData: {},
-        attachments: [],
-        value: payload,
-      },
-      sendActivity: vi.fn(async () => ({ id: "activity-id" })),
-      sendActivities: async () => [],
-    } as unknown as MSTeamsTurnContext);
-
-    expect(run).not.toHaveBeenCalled();
-    expect(runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher).toHaveBeenCalledTimes(
-      1,
-    );
-    expect(
-      runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher.mock.calls[0]?.[0],
-    ).toMatchObject({
-      ctxPayload: {
-        RawBody: JSON.stringify(payload),
-        BodyForAgent: JSON.stringify(payload),
-        CommandBody: JSON.stringify(payload),
-        SessionKey: "msteams:direct:user-aad",
-        SenderId: "user-aad",
-      },
-    });
-  });
-});