@openclaw/msteams 2026.3.2 → 2026.3.7

package/src/monitor.lifecycle.test.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk/msteams";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { MSTeamsConversationStore } from "./conversation-store.js";
 import type { MSTeamsPollStore } from "./polls.js";
@@ -15,8 +15,14 @@ const expressControl = vi.hoisted(() => ({
   mode: { value: "listening" as "listening" | "error" },
 }));
 
-vi.mock("openclaw/plugin-sdk", () => ({
+vi.mock("openclaw/plugin-sdk/msteams", () => ({
   DEFAULT_WEBHOOK_MAX_BODY_BYTES: 1024 * 1024,
+  normalizeSecretInputString: (value: unknown) =>
+    typeof value === "string" && value.trim() ? value.trim() : undefined,
+  hasConfiguredSecretInput: (value: unknown) =>
+    typeof value === "string" && value.trim().length > 0,
+  normalizeResolvedSecretInputString: (params: { value?: unknown }) =>
+    typeof params?.value === "string" && params.value.trim() ? params.value.trim() : undefined,
   keepHttpServerTaskAlive: vi.fn(
     async (params: { abortSignal?: AbortSignal; onAbort?: () => Promise<void> | void }) => {
       await new Promise<void>((resolve) => {
@@ -134,7 +140,7 @@ function createConfig(port: number): OpenClawConfig {
       msteams: {
         enabled: true,
         appId: "app-id",
-        appPassword: "app-password",
+        appPassword: "app-password", // pragma: allowlist secret
         tenantId: "tenant-id",
         webhook: {
           port,

package/src/monitor.ts

@@ -7,7 +7,7 @@ import {
   summarizeMapping,
   type OpenClawConfig,
   type RuntimeEnv,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";
 import type { MSTeamsConversationStore } from "./conversation-store.js";
 import { formatUnknownError } from "./errors.js";

package/src/onboarding.ts

@@ -5,14 +5,17 @@ import type {
   DmPolicy,
   WizardPrompter,
   MSTeamsTeamConfig,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 import {
-  addWildcardAllowFrom,
   DEFAULT_ACCOUNT_ID,
   formatDocsLink,
   mergeAllowFromEntries,
   promptChannelAccessConfig,
-} from "openclaw/plugin-sdk";
+  setTopLevelChannelAllowFrom,
+  setTopLevelChannelDmPolicyWithAllowFrom,
+  setTopLevelChannelGroupPolicy,
+  splitOnboardingEntries,
+} from "openclaw/plugin-sdk/msteams";
 import {
   parseMSTeamsTeamEntry,
   resolveMSTeamsChannelAllowlist,
@@ -24,41 +27,19 @@ import { hasConfiguredMSTeamsCredentials, resolveMSTeamsCredentials } from "./to
 const channel = "msteams" as const;
 
 function setMSTeamsDmPolicy(cfg: OpenClawConfig, dmPolicy: DmPolicy) {
-  const allowFrom =
-    dmPolicy === "open"
-      ? addWildcardAllowFrom(cfg.channels?.msteams?.allowFrom)?.map((entry) => String(entry))
-      : undefined;
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      msteams: {
-        ...cfg.channels?.msteams,
-        dmPolicy,
-        ...(allowFrom ? { allowFrom } : {}),
-      },
-    },
-  };
+  return setTopLevelChannelDmPolicyWithAllowFrom({
+    cfg,
+    channel: "msteams",
+    dmPolicy,
+  });
 }
 
 function setMSTeamsAllowFrom(cfg: OpenClawConfig, allowFrom: string[]): OpenClawConfig {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      msteams: {
-        ...cfg.channels?.msteams,
-        allowFrom,
-      },
-    },
-  };
-}
-
-function parseAllowFromInput(raw: string): string[] {
-  return raw
-    .split(/[\n,;]+/g)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
+  return setTopLevelChannelAllowFrom({
+    cfg,
+    channel: "msteams",
+    allowFrom,
+  });
 }
 
 function looksLikeGuid(value: string): boolean {
@@ -115,7 +96,7 @@ async function promptMSTeamsAllowFrom(params: {
       initialValue: existing[0] ? String(existing[0]) : undefined,
       validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
     });
-    const parts = parseAllowFromInput(String(entry));
+    const parts = splitOnboardingEntries(String(entry));
     if (parts.length === 0) {
       await params.prompter.note("Enter at least one user.", "MS Teams allowlist");
       continue;
@@ -171,17 +152,12 @@ function setMSTeamsGroupPolicy(
   cfg: OpenClawConfig,
   groupPolicy: "open" | "allowlist" | "disabled",
 ): OpenClawConfig {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      msteams: {
-        ...cfg.channels?.msteams,
-        enabled: true,
-        groupPolicy,
-      },
-    },
-  };
+  return setTopLevelChannelGroupPolicy({
+    cfg,
+    channel: "msteams",
+    groupPolicy,
+    enabled: true,
+  });
 }
 
 function setMSTeamsTeamsAllowlist(

package/src/outbound.test.ts

@@ -0,0 +1,131 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/msteams";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  sendMessageMSTeams: vi.fn(),
+  sendPollMSTeams: vi.fn(),
+  createPoll: vi.fn(),
+}));
+
+vi.mock("./send.js", () => ({
+  sendMessageMSTeams: mocks.sendMessageMSTeams,
+  sendPollMSTeams: mocks.sendPollMSTeams,
+}));
+
+vi.mock("./polls.js", () => ({
+  createMSTeamsPollStoreFs: () => ({
+    createPoll: mocks.createPoll,
+  }),
+}));
+
+vi.mock("./runtime.js", () => ({
+  getMSTeamsRuntime: () => ({
+    channel: {
+      text: {
+        chunkMarkdownText: (text: string) => [text],
+      },
+    },
+  }),
+}));
+
+import { msteamsOutbound } from "./outbound.js";
+
+describe("msteamsOutbound cfg threading", () => {
+  beforeEach(() => {
+    mocks.sendMessageMSTeams.mockReset();
+    mocks.sendPollMSTeams.mockReset();
+    mocks.createPoll.mockReset();
+    mocks.sendMessageMSTeams.mockResolvedValue({
+      messageId: "msg-1",
+      conversationId: "conv-1",
+    });
+    mocks.sendPollMSTeams.mockResolvedValue({
+      pollId: "poll-1",
+      messageId: "msg-poll-1",
+      conversationId: "conv-1",
+    });
+    mocks.createPoll.mockResolvedValue(undefined);
+  });
+
+  it("passes resolved cfg to sendMessageMSTeams for text sends", async () => {
+    const cfg = {
+      channels: {
+        msteams: {
+          appId: "resolved-app-id",
+        },
+      },
+    } as OpenClawConfig;
+
+    await msteamsOutbound.sendText!({
+      cfg,
+      to: "conversation:abc",
+      text: "hello",
+    });
+
+    expect(mocks.sendMessageMSTeams).toHaveBeenCalledWith({
+      cfg,
+      to: "conversation:abc",
+      text: "hello",
+    });
+  });
+
+  it("passes resolved cfg and media roots for media sends", async () => {
+    const cfg = {
+      channels: {
+        msteams: {
+          appId: "resolved-app-id",
+        },
+      },
+    } as OpenClawConfig;
+
+    await msteamsOutbound.sendMedia!({
+      cfg,
+      to: "conversation:abc",
+      text: "photo",
+      mediaUrl: "file:///tmp/photo.png",
+      mediaLocalRoots: ["/tmp"],
+    });
+
+    expect(mocks.sendMessageMSTeams).toHaveBeenCalledWith({
+      cfg,
+      to: "conversation:abc",
+      text: "photo",
+      mediaUrl: "file:///tmp/photo.png",
+      mediaLocalRoots: ["/tmp"],
+    });
+  });
+
+  it("passes resolved cfg to sendPollMSTeams and stores poll metadata", async () => {
+    const cfg = {
+      channels: {
+        msteams: {
+          appId: "resolved-app-id",
+        },
+      },
+    } as OpenClawConfig;
+
+    await msteamsOutbound.sendPoll!({
+      cfg,
+      to: "conversation:abc",
+      poll: {
+        question: "Snack?",
+        options: ["Pizza", "Sushi"],
+      },
+    });
+
+    expect(mocks.sendPollMSTeams).toHaveBeenCalledWith({
+      cfg,
+      to: "conversation:abc",
+      question: "Snack?",
+      options: ["Pizza", "Sushi"],
+      maxSelections: 1,
+    });
+    expect(mocks.createPoll).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "poll-1",
+        question: "Snack?",
+        options: ["Pizza", "Sushi"],
+      }),
+    );
+  });
+});

package/src/outbound.ts

@@ -1,4 +1,4 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/msteams";
 import { createMSTeamsPollStoreFs } from "./polls.js";
 import { getMSTeamsRuntime } from "./runtime.js";
 import { sendMessageMSTeams, sendPollMSTeams } from "./send.js";

package/src/policy.test.ts

@@ -1,4 +1,4 @@
-import type { MSTeamsConfig } from "openclaw/plugin-sdk";
+import type { MSTeamsConfig } from "openclaw/plugin-sdk/msteams";
 import { describe, expect, it } from "vitest";
 import {
   isMSTeamsGroupAllowed,

package/src/policy.ts

@@ -7,15 +7,16 @@ import type {
   MSTeamsConfig,
   MSTeamsReplyStyle,
   MSTeamsTeamConfig,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 import {
   buildChannelKeyCandidates,
+  evaluateSenderGroupAccessForPolicy,
   normalizeChannelSlug,
   resolveAllowlistMatchSimple,
   resolveToolsBySender,
   resolveChannelEntryMatchWithFallback,
   resolveNestedAllowlistDecision,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 
 export type MSTeamsResolvedRouteConfig = {
   teamConfig?: MSTeamsTeamConfig;
@@ -248,12 +249,10 @@ export function isMSTeamsGroupAllowed(params: {
   senderName?: string | null;
   allowNameMatching?: boolean;
 }): boolean {
-  const { groupPolicy } = params;
-  if (groupPolicy === "disabled") {
-    return false;
-  }
-  if (groupPolicy === "open") {
-    return true;
-  }
-  return resolveMSTeamsAllowlistMatch(params).allowed;
+  return evaluateSenderGroupAccessForPolicy({
+    groupPolicy: params.groupPolicy,
+    groupAllowFrom: params.allowFrom.map((entry) => String(entry)),
+    senderId: params.senderId,
+    isSenderAllowed: () => resolveMSTeamsAllowlistMatch(params).allowed,
+  }).allowed;
 }

package/src/probe.test.ts

@@ -1,4 +1,4 @@
-import type { MSTeamsConfig } from "openclaw/plugin-sdk";
+import type { MSTeamsConfig } from "openclaw/plugin-sdk/msteams";
 import { describe, expect, it, vi } from "vitest";
 
 const hostMockState = vi.hoisted(() => ({

package/src/probe.ts

@@ -1,4 +1,8 @@
-import type { BaseProbeResult, MSTeamsConfig } from "openclaw/plugin-sdk";
+import {
+  normalizeStringEntries,
+  type BaseProbeResult,
+  type MSTeamsConfig,
+} from "openclaw/plugin-sdk/msteams";
 import { formatUnknownError } from "./errors.js";
 import { loadMSTeamsSdkWithAuth } from "./sdk.js";
 import { readAccessToken } from "./token-response.js";
@@ -35,7 +39,7 @@ function readStringArray(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) {
     return undefined;
   }
-  const out = value.map((entry) => String(entry).trim()).filter(Boolean);
+  const out = normalizeStringEntries(value);
   return out.length > 0 ? out : undefined;
 }
 

package/src/reply-dispatcher.ts

@@ -6,7 +6,7 @@ import {
   type OpenClawConfig,
   type MSTeamsReplyStyle,
   type RuntimeEnv,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";
 import type { StoredConversationReference } from "./conversation-store.js";
 import {

package/src/resolve-allowlist.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from "vitest";
+
+const {
+  listTeamsByName,
+  listChannelsForTeam,
+  normalizeQuery,
+  resolveGraphToken,
+  searchGraphUsers,
+} = vi.hoisted(() => ({
+  listTeamsByName: vi.fn(),
+  listChannelsForTeam: vi.fn(),
+  normalizeQuery: vi.fn((value: string) => value.trim().toLowerCase()),
+  resolveGraphToken: vi.fn(async () => "graph-token"),
+  searchGraphUsers: vi.fn(),
+}));
+
+vi.mock("./graph.js", () => ({
+  listTeamsByName,
+  listChannelsForTeam,
+  normalizeQuery,
+  resolveGraphToken,
+}));
+
+vi.mock("./graph-users.js", () => ({
+  searchGraphUsers,
+}));
+
+import {
+  resolveMSTeamsChannelAllowlist,
+  resolveMSTeamsUserAllowlist,
+} from "./resolve-allowlist.js";
+
+describe("resolveMSTeamsUserAllowlist", () => {
+  it("marks empty input unresolved", async () => {
+    const [result] = await resolveMSTeamsUserAllowlist({ cfg: {}, entries: ["  "] });
+    expect(result).toEqual({ input: "  ", resolved: false });
+  });
+
+  it("resolves first Graph user match", async () => {
+    searchGraphUsers.mockResolvedValueOnce([
+      { id: "user-1", displayName: "Alice One" },
+      { id: "user-2", displayName: "Alice Two" },
+    ]);
+    const [result] = await resolveMSTeamsUserAllowlist({ cfg: {}, entries: ["alice"] });
+    expect(result).toEqual({
+      input: "alice",
+      resolved: true,
+      id: "user-1",
+      name: "Alice One",
+      note: "multiple matches; chose first",
+    });
+  });
+});
+
+describe("resolveMSTeamsChannelAllowlist", () => {
+  it("resolves team/channel by team name + channel display name", async () => {
+    listTeamsByName.mockResolvedValueOnce([{ id: "team-1", displayName: "Product Team" }]);
+    listChannelsForTeam.mockResolvedValueOnce([
+      { id: "channel-1", displayName: "General" },
+      { id: "channel-2", displayName: "Roadmap" },
+    ]);
+
+    const [result] = await resolveMSTeamsChannelAllowlist({
+      cfg: {},
+      entries: ["Product Team/Roadmap"],
+    });
+
+    expect(result).toEqual({
+      input: "Product Team/Roadmap",
+      resolved: true,
+      teamId: "team-1",
+      teamName: "Product Team",
+      channelId: "channel-2",
+      channelName: "Roadmap",
+      note: "multiple channels; chose first",
+    });
+  });
+});

package/src/resolve-allowlist.ts

@@ -1,3 +1,4 @@
+import { mapAllowlistResolutionInputs } from "openclaw/plugin-sdk/compat";
 import { searchGraphUsers } from "./graph-users.js";
 import {
   listChannelsForTeam,
@@ -105,61 +106,55 @@ export async function resolveMSTeamsChannelAllowlist(params: {
   entries: string[];
 }): Promise<MSTeamsChannelResolution[]> {
   const token = await resolveGraphToken(params.cfg);
-  const results: MSTeamsChannelResolution[] = [];
-
-  for (const input of params.entries) {
-    const { team, channel } = parseMSTeamsTeamChannelInput(input);
-    if (!team) {
-      results.push({ input, resolved: false });
-      continue;
-    }
-    const teams = /^[0-9a-fA-F-]{16,}$/.test(team)
-      ? [{ id: team, displayName: team }]
-      : await listTeamsByName(token, team);
-    if (teams.length === 0) {
-      results.push({ input, resolved: false, note: "team not found" });
-      continue;
-    }
-    const teamMatch = teams[0];
-    const teamId = teamMatch.id?.trim();
-    const teamName = teamMatch.displayName?.trim() || team;
-    if (!teamId) {
-      results.push({ input, resolved: false, note: "team id missing" });
-      continue;
-    }
-    if (!channel) {
-      results.push({
+  return await mapAllowlistResolutionInputs({
+    inputs: params.entries,
+    mapInput: async (input): Promise<MSTeamsChannelResolution> => {
+      const { team, channel } = parseMSTeamsTeamChannelInput(input);
+      if (!team) {
+        return { input, resolved: false };
+      }
+      const teams = /^[0-9a-fA-F-]{16,}$/.test(team)
+        ? [{ id: team, displayName: team }]
+        : await listTeamsByName(token, team);
+      if (teams.length === 0) {
+        return { input, resolved: false, note: "team not found" };
+      }
+      const teamMatch = teams[0];
+      const teamId = teamMatch.id?.trim();
+      const teamName = teamMatch.displayName?.trim() || team;
+      if (!teamId) {
+        return { input, resolved: false, note: "team id missing" };
+      }
+      if (!channel) {
+        return {
+          input,
+          resolved: true,
+          teamId,
+          teamName,
+          note: teams.length > 1 ? "multiple teams; chose first" : undefined,
+        };
+      }
+      const channels = await listChannelsForTeam(token, teamId);
+      const channelMatch =
+        channels.find((item) => item.id === channel) ??
+        channels.find((item) => item.displayName?.toLowerCase() === channel.toLowerCase()) ??
+        channels.find((item) =>
+          item.displayName?.toLowerCase().includes(channel.toLowerCase() ?? ""),
+        );
+      if (!channelMatch?.id) {
+        return { input, resolved: false, note: "channel not found" };
+      }
+      return {
         input,
         resolved: true,
         teamId,
         teamName,
-        note: teams.length > 1 ? "multiple teams; chose first" : undefined,
-      });
-      continue;
-    }
-    const channels = await listChannelsForTeam(token, teamId);
-    const channelMatch =
-      channels.find((item) => item.id === channel) ??
-      channels.find((item) => item.displayName?.toLowerCase() === channel.toLowerCase()) ??
-      channels.find((item) =>
-        item.displayName?.toLowerCase().includes(channel.toLowerCase() ?? ""),
-      );
-    if (!channelMatch?.id) {
-      results.push({ input, resolved: false, note: "channel not found" });
-      continue;
-    }
-    results.push({
-      input,
-      resolved: true,
-      teamId,
-      teamName,
-      channelId: channelMatch.id,
-      channelName: channelMatch.displayName ?? channel,
-      note: channels.length > 1 ? "multiple channels; chose first" : undefined,
-    });
-  }
-
-  return results;
+        channelId: channelMatch.id,
+        channelName: channelMatch.displayName ?? channel,
+        note: channels.length > 1 ? "multiple channels; chose first" : undefined,
+      };
+    },
+  });
 }
 
 export async function resolveMSTeamsUserAllowlist(params: {
@@ -167,32 +162,28 @@ export async function resolveMSTeamsUserAllowlist(params: {
   entries: string[];
 }): Promise<MSTeamsUserResolution[]> {
   const token = await resolveGraphToken(params.cfg);
-  const results: MSTeamsUserResolution[] = [];
-
-  for (const input of params.entries) {
-    const query = normalizeQuery(normalizeMSTeamsUserInput(input));
-    if (!query) {
-      results.push({ input, resolved: false });
-      continue;
-    }
-    if (/^[0-9a-fA-F-]{16,}$/.test(query)) {
-      results.push({ input, resolved: true, id: query });
-      continue;
-    }
-    const users = await searchGraphUsers({ token, query, top: 10 });
-    const match = users[0];
-    if (!match?.id) {
-      results.push({ input, resolved: false });
-      continue;
-    }
-    results.push({
-      input,
-      resolved: true,
-      id: match.id,
-      name: match.displayName ?? undefined,
-      note: users.length > 1 ? "multiple matches; chose first" : undefined,
-    });
-  }
-
-  return results;
+  return await mapAllowlistResolutionInputs({
+    inputs: params.entries,
+    mapInput: async (input): Promise<MSTeamsUserResolution> => {
+      const query = normalizeQuery(normalizeMSTeamsUserInput(input));
+      if (!query) {
+        return { input, resolved: false };
+      }
+      if (/^[0-9a-fA-F-]{16,}$/.test(query)) {
+        return { input, resolved: true, id: query };
+      }
+      const users = await searchGraphUsers({ token, query, top: 10 });
+      const match = users[0];
+      if (!match?.id) {
+        return { input, resolved: false };
+      }
+      return {
+        input,
+        resolved: true,
+        id: match.id,
+        name: match.displayName ?? undefined,
+        note: users.length > 1 ? "multiple matches; chose first" : undefined,
+      };
+    },
+  });
 }

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/msteams";
 
 let runtime: PluginRuntime | null = null;
 

package/src/secret-input.ts

@@ -2,6 +2,6 @@ import {
   hasConfiguredSecretInput,
   normalizeResolvedSecretInputString,
   normalizeSecretInputString,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 
 export { hasConfiguredSecretInput, normalizeResolvedSecretInputString, normalizeSecretInputString };

package/src/send-context.ts

@@ -2,7 +2,7 @@ import {
   resolveChannelMediaMaxBytes,
   type OpenClawConfig,
   type PluginRuntime,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/msteams";
 import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";
 import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";
 import type {

package/src/send.test.ts

@@ -1,4 +1,4 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/msteams";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { sendMessageMSTeams } from "./send.js";
 
@@ -11,7 +11,7 @@ const mockState = vi.hoisted(() => ({
   sendMSTeamsMessages: vi.fn(),
 }));
 
-vi.mock("openclaw/plugin-sdk", () => ({
+vi.mock("openclaw/plugin-sdk/msteams", () => ({
   loadOutboundMediaFromUrl: mockState.loadOutboundMediaFromUrl,
 }));