@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/channel.directory.test.ts

@@ -1,200 +0,0 @@
-import {
-  createDirectoryTestRuntime,
-  expectDirectorySurface,
-} from "openclaw/plugin-sdk/channel-test-helpers";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig, RuntimeEnv } from "../runtime-api.js";
-import { msteamsPlugin } from "./channel.js";
-import { resolveMSTeamsOutboundSessionRoute } from "./session-route.js";
-
-const msteamsDirectoryAdapter = msteamsPlugin.directory;
-
-function requireDirectorySelf(): NonNullable<NonNullable<typeof msteamsDirectoryAdapter>["self"]> {
-  const directorySelf = msteamsDirectoryAdapter?.self;
-  if (!directorySelf) {
-    throw new Error("expected msteams directory.self");
-  }
-  return directorySelf;
-}
-
-describe("msteams directory", () => {
-  const runtimeEnv = createDirectoryTestRuntime() as RuntimeEnv;
-  const directorySelf = requireDirectorySelf();
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  describe("self()", () => {
-    it("returns bot identity when credentials are configured", async () => {
-      const cfg = {
-        channels: {
-          msteams: {
-            appId: "test-app-id-1234",
-            appPassword: "secret",
-            tenantId: "tenant-id-5678",
-          },
-        },
-      } as unknown as OpenClawConfig;
-
-      const result = await directorySelf({ cfg, runtime: runtimeEnv });
-      expect(result).toEqual({ kind: "user", id: "test-app-id-1234", name: "test-app-id-1234" });
-    });
-
-    it("returns null when credentials are not configured", async () => {
-      vi.stubEnv("MSTEAMS_APP_ID", "");
-      vi.stubEnv("MSTEAMS_APP_PASSWORD", "");
-      vi.stubEnv("MSTEAMS_TENANT_ID", "");
-      const cfg = { channels: {} } as unknown as OpenClawConfig;
-      const result = await directorySelf({ cfg, runtime: runtimeEnv });
-      expect(result).toBeNull();
-    });
-  });
-
-  it("lists peers and groups from config", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          allowFrom: ["alice", "user:Bob"],
-          dms: { carol: {}, bob: {} },
-          teams: {
-            team1: {
-              channels: {
-                "conversation:chan1": {},
-                chan2: {},
-              },
-            },
-          },
-        },
-      },
-    } as unknown as OpenClawConfig;
-
-    const directory = expectDirectorySurface(msteamsDirectoryAdapter);
-
-    await expect(
-      directory.listPeers({
-        cfg,
-        query: undefined,
-        limit: undefined,
-        runtime: runtimeEnv,
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "user", id: "user:alice" },
-        { kind: "user", id: "user:Bob" },
-        { kind: "user", id: "user:carol" },
-        { kind: "user", id: "user:bob" },
-      ]),
-    );
-
-    await expect(
-      directory.listGroups({
-        cfg,
-        query: undefined,
-        limit: undefined,
-        runtime: runtimeEnv,
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "group", id: "conversation:chan1" },
-        { kind: "group", id: "conversation:chan2" },
-      ]),
-    );
-  });
-
-  it("normalizes spaced allowlist and dm entries", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          allowFrom: ["  user:Bob  ", "  Alice  "],
-          dms: { "  Carol  ": {}, "user:Dave": {} },
-        },
-      },
-    } as unknown as OpenClawConfig;
-
-    const directory = expectDirectorySurface(msteamsDirectoryAdapter);
-
-    await expect(
-      directory.listPeers({
-        cfg,
-        query: undefined,
-        limit: undefined,
-        runtime: runtimeEnv,
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "user", id: "user:Bob" },
-        { kind: "user", id: "user:Alice" },
-        { kind: "user", id: "user:Carol" },
-        { kind: "user", id: "user:Dave" },
-      ]),
-    );
-  });
-});
-
-describe("msteams session route", () => {
-  it("builds direct routes for explicit user targets", () => {
-    const route = resolveMSTeamsOutboundSessionRoute({
-      cfg: {},
-      agentId: "main",
-      accountId: "default",
-      target: "msteams:user:alice-id",
-    });
-
-    expect(route).toMatchObject({
-      peer: {
-        kind: "direct",
-        id: "alice-id",
-      },
-      from: "msteams:alice-id",
-      to: "user:alice-id",
-    });
-  });
-
-  it("builds channel routes for thread conversations and strips suffix metadata", () => {
-    const route = resolveMSTeamsOutboundSessionRoute({
-      cfg: {},
-      agentId: "main",
-      accountId: "default",
-      target: "teams:19:abc123@thread.tacv2;messageid=42",
-    });
-
-    expect(route).toMatchObject({
-      peer: {
-        kind: "channel",
-        id: "19:abc123@thread.tacv2",
-      },
-      from: "msteams:channel:19:abc123@thread.tacv2",
-      to: "conversation:19:abc123@thread.tacv2",
-    });
-  });
-
-  it("returns group routes for non-user, non-channel conversations", () => {
-    const route = resolveMSTeamsOutboundSessionRoute({
-      cfg: {},
-      agentId: "main",
-      accountId: "default",
-      target: "msteams:conversation:19:groupchat",
-    });
-
-    expect(route).toMatchObject({
-      peer: {
-        kind: "group",
-        id: "19:groupchat",
-      },
-      from: "msteams:group:19:groupchat",
-      to: "conversation:19:groupchat",
-    });
-  });
-
-  it("returns null when the target cannot be normalized", () => {
-    expect(
-      resolveMSTeamsOutboundSessionRoute({
-        cfg: {},
-        agentId: "main",
-        accountId: "default",
-        target: "msteams:",
-      }),
-    ).toBeNull();
-  });
-});

package/src/channel.runtime.ts

@@ -1,56 +0,0 @@
-import {
-  listMSTeamsDirectoryGroupsLive as listMSTeamsDirectoryGroupsLiveImpl,
-  listMSTeamsDirectoryPeersLive as listMSTeamsDirectoryPeersLiveImpl,
-} from "./directory-live.js";
-import {
-  addParticipantMSTeams as addParticipantMSTeamsImpl,
-  removeParticipantMSTeams as removeParticipantMSTeamsImpl,
-  renameGroupMSTeams as renameGroupMSTeamsImpl,
-} from "./graph-group-management.js";
-import { getMemberInfoMSTeams as getMemberInfoMSTeamsImpl } from "./graph-members.js";
-import {
-  getMessageMSTeams as getMessageMSTeamsImpl,
-  listPinsMSTeams as listPinsMSTeamsImpl,
-  listReactionsMSTeams as listReactionsMSTeamsImpl,
-  pinMessageMSTeams as pinMessageMSTeamsImpl,
-  reactMessageMSTeams as reactMessageMSTeamsImpl,
-  searchMessagesMSTeams as searchMessagesMSTeamsImpl,
-  unpinMessageMSTeams as unpinMessageMSTeamsImpl,
-  unreactMessageMSTeams as unreactMessageMSTeamsImpl,
-} from "./graph-messages.js";
-import {
-  listChannelsMSTeams as listChannelsMSTeamsImpl,
-  getChannelInfoMSTeams as getChannelInfoMSTeamsImpl,
-} from "./graph-teams.js";
-import { msteamsOutbound as msteamsOutboundImpl } from "./outbound.js";
-import { probeMSTeams as probeMSTeamsImpl } from "./probe.js";
-import {
-  deleteMessageMSTeams as deleteMessageMSTeamsImpl,
-  editMessageMSTeams as editMessageMSTeamsImpl,
-  sendAdaptiveCardMSTeams as sendAdaptiveCardMSTeamsImpl,
-  sendMessageMSTeams as sendMessageMSTeamsImpl,
-} from "./send.js";
-export const msTeamsChannelRuntime = {
-  addParticipantMSTeams: addParticipantMSTeamsImpl,
-  deleteMessageMSTeams: deleteMessageMSTeamsImpl,
-  editMessageMSTeams: editMessageMSTeamsImpl,
-  getChannelInfoMSTeams: getChannelInfoMSTeamsImpl,
-  getMemberInfoMSTeams: getMemberInfoMSTeamsImpl,
-  getMessageMSTeams: getMessageMSTeamsImpl,
-  listChannelsMSTeams: listChannelsMSTeamsImpl,
-  listPinsMSTeams: listPinsMSTeamsImpl,
-  listReactionsMSTeams: listReactionsMSTeamsImpl,
-  pinMessageMSTeams: pinMessageMSTeamsImpl,
-  reactMessageMSTeams: reactMessageMSTeamsImpl,
-  removeParticipantMSTeams: removeParticipantMSTeamsImpl,
-  renameGroupMSTeams: renameGroupMSTeamsImpl,
-  searchMessagesMSTeams: searchMessagesMSTeamsImpl,
-  unpinMessageMSTeams: unpinMessageMSTeamsImpl,
-  unreactMessageMSTeams: unreactMessageMSTeamsImpl,
-  listMSTeamsDirectoryGroupsLive: listMSTeamsDirectoryGroupsLiveImpl,
-  listMSTeamsDirectoryPeersLive: listMSTeamsDirectoryPeersLiveImpl,
-  msteamsOutbound: { ...msteamsOutboundImpl },
-  probeMSTeams: probeMSTeamsImpl,
-  sendAdaptiveCardMSTeams: sendAdaptiveCardMSTeamsImpl,
-  sendMessageMSTeams: sendMessageMSTeamsImpl,
-};

package/src/channel.setup.ts

@@ -1,77 +0,0 @@
-import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
-import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
-import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
-import type { ChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { MSTeamsChannelConfigSchema } from "./config-schema.js";
-import { msteamsSetupAdapter } from "./setup-core.js";
-import { msteamsSetupWizard } from "./setup-surface.js";
-import { resolveMSTeamsCredentials } from "./token.js";
-
-type ResolvedMSTeamsAccount = {
-  accountId: string;
-  enabled: boolean;
-  configured: boolean;
-};
-
-const meta = {
-  id: "msteams",
-  label: "Microsoft Teams",
-  selectionLabel: "Microsoft Teams (Bot Framework)",
-  docsPath: "/channels/msteams",
-  docsLabel: "msteams",
-  blurb: "Teams SDK; enterprise support.",
-  aliases: ["teams"],
-  order: 60,
-} as const;
-
-const resolveMSTeamsChannelConfig = (cfg: OpenClawConfig) => ({
-  allowFrom: cfg.channels?.msteams?.allowFrom,
-  defaultTo: cfg.channels?.msteams?.defaultTo,
-});
-
-const msteamsConfigAdapter = createTopLevelChannelConfigAdapter<
-  ResolvedMSTeamsAccount,
-  {
-    allowFrom?: Array<string | number>;
-    defaultTo?: string;
-  }
->({
-  sectionKey: "msteams",
-  resolveAccount: (cfg) => ({
-    accountId: "default",
-    enabled: cfg.channels?.msteams?.enabled !== false,
-    configured: Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
-  }),
-  resolveAccessorAccount: ({ cfg }) => resolveMSTeamsChannelConfig(cfg),
-  resolveAllowFrom: (account) => account.allowFrom,
-  formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
-  resolveDefaultTo: (account) => account.defaultTo,
-});
-
-export const msteamsSetupPlugin: ChannelPlugin<ResolvedMSTeamsAccount> = {
-  id: "msteams",
-  meta: {
-    ...meta,
-    aliases: [...meta.aliases],
-  },
-  capabilities: {
-    chatTypes: ["direct", "channel", "thread"],
-    polls: true,
-    threads: true,
-    media: true,
-  },
-  reload: { configPrefixes: ["channels.msteams"] },
-  configSchema: MSTeamsChannelConfigSchema,
-  config: {
-    ...msteamsConfigAdapter,
-    isConfigured: (_account, cfg) => Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
-    describeAccount: (account) =>
-      describeAccountSnapshot({
-        account,
-        configured: account.configured,
-      }),
-  },
-  setupWizard: msteamsSetupWizard,
-  setup: msteamsSetupAdapter,
-};

package/src/channel.test.ts

@@ -1,128 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { describe, expect, it } from "vitest";
-import { MSTeamsConfigSchema } from "../config-api.js";
-import { msTeamsApprovalAuth } from "./approval-auth.js";
-import { msteamsPlugin } from "./channel.js";
-
-function createConfiguredMSTeamsCfg(): OpenClawConfig {
-  return {
-    channels: {
-      msteams: {
-        appId: "app-id",
-        appPassword: "secret",
-        tenantId: "tenant-id",
-      },
-    },
-  };
-}
-
-describe("msteamsPlugin", () => {
-  it("exposes approval auth through approvalCapability", () => {
-    expect(msteamsPlugin.approvalCapability).toBe(msTeamsApprovalAuth);
-  });
-
-  it("advertises legacy and group-management message-tool actions together", () => {
-    const actions = msteamsPlugin.actions?.describeMessageTool?.({
-      cfg: createConfiguredMSTeamsCfg(),
-    })?.actions;
-
-    expect(actions).toEqual(
-      expect.arrayContaining([
-        "upload-file",
-        "member-info",
-        "channel-list",
-        "channel-info",
-        "addParticipant",
-        "removeParticipant",
-        "renameGroup",
-      ]),
-    );
-  });
-
-  it("reuses the shared Teams target-id matcher for explicit targets", () => {
-    const looksLikeId = msteamsPlugin.messaging?.targetResolver?.looksLikeId;
-
-    expect(looksLikeId?.("29:1a2b3c4d5e6f")).toBe(true);
-    expect(looksLikeId?.("a:1bfPersonalChat")).toBe(true);
-    expect(looksLikeId?.("user:Jane Doe")).toBe(false);
-  });
-});
-
-describe("msteams config schema", () => {
-  it("defaults groupPolicy to allowlist", () => {
-    const res = MSTeamsConfigSchema.safeParse({});
-
-    expect(res.success).toBe(true);
-    if (res.success) {
-      expect(res.data.groupPolicy).toBe("allowlist");
-    }
-  });
-
-  it("accepts historyLimit", () => {
-    const res = MSTeamsConfigSchema.safeParse({ historyLimit: 4 });
-
-    expect(res.success).toBe(true);
-    if (res.success) {
-      expect(res.data.historyLimit).toBe(4);
-    }
-  });
-
-  it("accepts replyStyle at global/team/channel levels", () => {
-    const res = MSTeamsConfigSchema.safeParse({
-      replyStyle: "top-level",
-      teams: {
-        team123: {
-          replyStyle: "thread",
-          channels: {
-            chan456: { replyStyle: "top-level" },
-          },
-        },
-      },
-    });
-
-    expect(res.success).toBe(true);
-    if (res.success) {
-      expect(res.data.replyStyle).toBe("top-level");
-      expect(res.data.teams?.team123?.replyStyle).toBe("thread");
-      expect(res.data.teams?.team123?.channels?.chan456?.replyStyle).toBe("top-level");
-    }
-  });
-
-  it("rejects invalid replyStyle", () => {
-    const res = MSTeamsConfigSchema.safeParse({
-      replyStyle: "nope",
-    });
-
-    expect(res.success).toBe(false);
-  });
-});
-
-describe("msTeamsApprovalAuth", () => {
-  it("authorizes stable Teams user ids and ignores display-name allowlists", () => {
-    expect(
-      msTeamsApprovalAuth.authorizeActorAction({
-        cfg: {
-          channels: {
-            msteams: {
-              allowFrom: ["user:123e4567-e89b-12d3-a456-426614174000"],
-            },
-          },
-        },
-        senderId: "123e4567-e89b-12d3-a456-426614174000",
-        action: "approve",
-        approvalKind: "exec",
-      }),
-    ).toEqual({ authorized: true });
-
-    expect(
-      msTeamsApprovalAuth.authorizeActorAction({
-        cfg: {
-          channels: { msteams: { allowFrom: ["Owner Display"] } },
-        },
-        senderId: "attacker-aad",
-        action: "approve",
-        approvalKind: "exec",
-      }),
-    ).toEqual({ authorized: true });
-  });
-});