@kodelyth/msteams 2026.5.42 → 2026.6.2

package/src/channel.directory.test.ts

@@ -1,176 +0,0 @@
-import {
-  createDirectoryTestRuntime,
-  expectDirectorySurface,
-} from "klaw/plugin-sdk/channel-test-helpers";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { KlawConfig, 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 KlawConfig;
-
-      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 KlawConfig;
-      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 KlawConfig;
-
-    const directory = expectDirectorySurface(msteamsDirectoryAdapter);
-
-    const peers = await directory.listPeers({
-      cfg,
-      query: undefined,
-      limit: undefined,
-      runtime: runtimeEnv,
-    });
-    expect(peers).toStrictEqual([
-      { kind: "user", id: "user:alice" },
-      { kind: "user", id: "user:Bob" },
-      { kind: "user", id: "user:carol" },
-      { kind: "user", id: "user:bob" },
-    ]);
-
-    const groups = await directory.listGroups({
-      cfg,
-      query: undefined,
-      limit: undefined,
-      runtime: runtimeEnv,
-    });
-    expect(groups).toStrictEqual([
-      { 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 KlawConfig;
-
-    const directory = expectDirectorySurface(msteamsDirectoryAdapter);
-
-    const peers = await directory.listPeers({
-      cfg,
-      query: undefined,
-      limit: undefined,
-      runtime: runtimeEnv,
-    });
-    expect(peers).toStrictEqual([
-      { 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?.peer).toEqual({ kind: "direct", id: "alice-id" });
-    expect(route?.from).toBe("msteams:alice-id");
-    expect(route?.to).toBe("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?.peer).toEqual({ kind: "channel", id: "19:abc123@thread.tacv2" });
-    expect(route?.from).toBe("msteams:channel:19:abc123@thread.tacv2");
-    expect(route?.to).toBe("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?.peer).toEqual({ kind: "group", id: "19:groupchat" });
-    expect(route?.from).toBe("msteams:group:19:groupchat");
-    expect(route?.to).toBe("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.message-adapter.test.ts

@@ -1,227 +0,0 @@
-import {
-  verifyChannelMessageAdapterCapabilityProofs,
-  verifyChannelMessageLiveCapabilityAdapterProofs,
-  verifyChannelMessageLiveFinalizerProofs,
-} from "klaw/plugin-sdk/channel-message";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { KlawConfig } from "../runtime-api.js";
-
-const mocks = vi.hoisted(() => ({
-  sendText: vi.fn(),
-  sendMedia: vi.fn(),
-  sendPayload: vi.fn(),
-  sendPoll: vi.fn(),
-}));
-
-vi.mock("./channel.runtime.js", () => ({
-  msTeamsChannelRuntime: {
-    msteamsOutbound: {
-      sendText: mocks.sendText,
-      sendMedia: mocks.sendMedia,
-      sendPayload: mocks.sendPayload,
-      sendPoll: mocks.sendPoll,
-    },
-  },
-}));
-
-import { msteamsPlugin } from "./channel.js";
-
-type MSTeamsMessageAdapter = NonNullable<typeof msteamsPlugin.message>;
-type MSTeamsMessageSender = NonNullable<MSTeamsMessageAdapter["send"]>;
-
-function requireMSTeamsMessageAdapter(): MSTeamsMessageAdapter {
-  const adapter = msteamsPlugin.message;
-  if (!adapter) {
-    throw new Error("Expected msteams channel message adapter");
-  }
-  return adapter;
-}
-
-function requireTextSender(
-  adapter: MSTeamsMessageAdapter,
-): NonNullable<MSTeamsMessageSender["text"]> {
-  const text = adapter.send?.text;
-  if (!text) {
-    throw new Error("Expected msteams message adapter text sender");
-  }
-  return text;
-}
-
-function requireMediaSender(
-  adapter: MSTeamsMessageAdapter,
-): NonNullable<MSTeamsMessageSender["media"]> {
-  const media = adapter.send?.media;
-  if (!media) {
-    throw new Error("Expected msteams message adapter media sender");
-  }
-  return media;
-}
-
-function requirePayloadSender(
-  adapter: MSTeamsMessageAdapter,
-): NonNullable<MSTeamsMessageSender["payload"]> {
-  const payload = adapter.send?.payload;
-  if (!payload) {
-    throw new Error("Expected msteams message adapter payload sender");
-  }
-  return payload;
-}
-
-const cfg = {
-  channels: {
-    msteams: {
-      appId: "resolved-app-id",
-    },
-  },
-} as KlawConfig;
-
-describe("msteams channel message adapter", () => {
-  beforeEach(() => {
-    mocks.sendText.mockReset();
-    mocks.sendMedia.mockReset();
-    mocks.sendPayload.mockReset();
-    mocks.sendPoll.mockReset();
-    mocks.sendText.mockResolvedValue({
-      channel: "msteams",
-      messageId: "msg-1",
-      conversationId: "conv-1",
-    });
-    mocks.sendMedia.mockResolvedValue({
-      channel: "msteams",
-      messageId: "msg-media-1",
-      conversationId: "conv-1",
-    });
-    mocks.sendPayload.mockResolvedValue({
-      channel: "msteams",
-      messageId: "msg-payload-1",
-      conversationId: "conv-1",
-    });
-  });
-
-  it("backs declared durable-final capabilities with outbound send proofs", async () => {
-    const adapter = requireMSTeamsMessageAdapter();
-    const sendText = requireTextSender(adapter);
-    const sendMedia = requireMediaSender(adapter);
-    const sendPayload = requirePayloadSender(adapter);
-    expect(adapter.durableFinal?.capabilities?.replyTo).toBeUndefined();
-    expect(adapter.durableFinal?.capabilities?.thread).toBeUndefined();
-
-    const proveText = async () => {
-      mocks.sendText.mockClear();
-      const result = await sendText({
-        cfg,
-        to: "conversation:abc",
-        text: "hello",
-        accountId: "default",
-      });
-      expect(mocks.sendText).toHaveBeenLastCalledWith({
-        cfg,
-        to: "conversation:abc",
-        text: "hello",
-        accountId: "default",
-      });
-      expect(result.receipt.platformMessageIds).toEqual(["msg-1"]);
-      expect(result.receipt.parts[0]?.kind).toBe("text");
-    };
-
-    const proveMedia = async () => {
-      mocks.sendMedia.mockClear();
-      const result = await sendMedia({
-        cfg,
-        to: "conversation:abc",
-        text: "photo",
-        mediaUrl: "file:///tmp/photo.png",
-        mediaLocalRoots: ["/tmp"],
-        accountId: "default",
-      });
-      expect(mocks.sendMedia).toHaveBeenLastCalledWith({
-        cfg,
-        to: "conversation:abc",
-        text: "photo",
-        mediaUrl: "file:///tmp/photo.png",
-        mediaLocalRoots: ["/tmp"],
-        accountId: "default",
-      });
-      expect(result.receipt.platformMessageIds).toEqual(["msg-media-1"]);
-      expect(result.receipt.parts[0]?.kind).toBe("media");
-    };
-
-    const provePayload = async () => {
-      mocks.sendPayload.mockClear();
-      const payload = {
-        presentation: {
-          blocks: [{ type: "text" as const, text: "card body" }],
-        },
-      };
-      const result = await sendPayload({
-        cfg,
-        to: "conversation:abc",
-        text: "",
-        payload,
-        accountId: "default",
-      });
-      expect(mocks.sendPayload).toHaveBeenLastCalledWith({
-        cfg,
-        to: "conversation:abc",
-        text: "",
-        payload,
-        accountId: "default",
-      });
-      expect(result.receipt.platformMessageIds).toEqual(["msg-payload-1"]);
-      expect(result.receipt.parts[0]?.kind).toBe("card");
-    };
-
-    await verifyChannelMessageAdapterCapabilityProofs({
-      adapterName: "msteamsMessageAdapter",
-      adapter,
-      proofs: {
-        text: proveText,
-        media: proveMedia,
-        payload: provePayload,
-        messageSendingHooks: () => {
-          expect(sendText).toBeTypeOf("function");
-        },
-      },
-    });
-  });
-
-  it("backs declared live preview finalizer capabilities with adapter proofs", async () => {
-    const adapter = requireMSTeamsMessageAdapter();
-    const sendText = requireTextSender(adapter);
-
-    await verifyChannelMessageLiveCapabilityAdapterProofs({
-      adapterName: "msteamsMessageAdapter",
-      adapter,
-      proofs: {
-        draftPreview: () => {
-          expect(adapter.live?.capabilities?.nativeStreaming).toBe(true);
-        },
-        previewFinalization: () => {
-          expect(adapter.live?.finalizer?.capabilities?.finalEdit).toBe(true);
-        },
-        progressUpdates: () => {
-          expect(adapter.live?.capabilities?.draftPreview).toBe(true);
-        },
-        nativeStreaming: () => {
-          expect(adapter.live?.finalizer?.capabilities?.previewReceipt).toBe(true);
-        },
-      },
-    });
-
-    await verifyChannelMessageLiveFinalizerProofs({
-      adapterName: "msteamsMessageAdapter",
-      adapter,
-      proofs: {
-        finalEdit: () => {
-          expect(adapter.live?.capabilities?.previewFinalization).toBe(true);
-        },
-        normalFallback: () => {
-          expect(sendText).toBeTypeOf("function");
-        },
-        previewReceipt: () => {
-          expect(adapter.live?.capabilities?.nativeStreaming).toBe(true);
-        },
-      },
-    });
-  });
-});

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 "klaw/plugin-sdk/account-helpers";
-import { formatAllowFromLowercase } from "klaw/plugin-sdk/allow-from";
-import { createTopLevelChannelConfigAdapter } from "klaw/plugin-sdk/channel-config-helpers";
-import type { ChannelPlugin } from "klaw/plugin-sdk/channel-core";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-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: KlawConfig) => ({
-  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,136 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-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(): KlawConfig {
-  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([
-      "upload-file",
-      "poll",
-      "edit",
-      "delete",
-      "pin",
-      "unpin",
-      "list-pins",
-      "read",
-      "react",
-      "reactions",
-      "search",
-      "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 });
-  });
-});