@kodelyth/msteams 2026.5.42 → 2026.6.1

package/src/pending-uploads.ts

@@ -1,121 +0,0 @@
-/**
- * In-memory storage for files awaiting user consent in the FileConsentCard flow.
- *
- * When sending large files (>=4MB) in personal chats, Teams requires user consent
- * before upload. This module stores the file data temporarily until the user
- * accepts or declines, or until the TTL expires.
- */
-
-import crypto from "node:crypto";
-
-export interface PendingUpload {
-  id: string;
-  buffer: Buffer;
-  filename: string;
-  contentType?: string;
-  conversationId: string;
-  /** Activity ID of the original FileConsentCard, used to replace it after upload */
-  consentCardActivityId?: string;
-  createdAt: number;
-}
-
-const pendingUploads = new Map<string, PendingUpload>();
-/** Timer handles keyed by upload ID, cleared on explicit removal to prevent ghost cleanup */
-const pendingUploadTimers = new Map<string, ReturnType<typeof setTimeout>>();
-
-/** TTL for pending uploads: 5 minutes */
-const PENDING_UPLOAD_TTL_MS = 5 * 60 * 1000;
-
-/**
- * Store a file pending user consent.
- * Returns the upload ID to include in the FileConsentCard context.
- */
-export function storePendingUpload(upload: Omit<PendingUpload, "id" | "createdAt">): string {
-  const id = crypto.randomUUID();
-  const entry: PendingUpload = {
-    ...upload,
-    id,
-    createdAt: Date.now(),
-  };
-  pendingUploads.set(id, entry);
-
-  // Auto-cleanup after TTL; timer ref stored so removePendingUpload can cancel it
-  const timer = setTimeout(() => {
-    pendingUploads.delete(id);
-    pendingUploadTimers.delete(id);
-  }, PENDING_UPLOAD_TTL_MS);
-  pendingUploadTimers.set(id, timer);
-
-  return id;
-}
-
-/**
- * Retrieve a pending upload by ID.
- * Returns undefined if not found or expired.
- */
-export function getPendingUpload(id?: string): PendingUpload | undefined {
-  if (!id) {
-    return undefined;
-  }
-  const entry = pendingUploads.get(id);
-  if (!entry) {
-    return undefined;
-  }
-
-  // Check if expired (in case timeout hasn't fired yet)
-  if (Date.now() - entry.createdAt > PENDING_UPLOAD_TTL_MS) {
-    pendingUploads.delete(id);
-    const timer = pendingUploadTimers.get(id);
-    if (timer !== undefined) {
-      clearTimeout(timer);
-      pendingUploadTimers.delete(id);
-    }
-    return undefined;
-  }
-
-  return entry;
-}
-
-/**
- * Remove a pending upload (after successful upload or user decline).
- * Also clears the TTL timer to prevent ghost Map deletions.
- */
-export function removePendingUpload(id?: string): void {
-  if (id) {
-    pendingUploads.delete(id);
-    const timer = pendingUploadTimers.get(id);
-    if (timer !== undefined) {
-      clearTimeout(timer);
-      pendingUploadTimers.delete(id);
-    }
-  }
-}
-
-/**
- * Set the consent card activity ID on an existing pending upload.
- * Called after the FileConsentCard is sent and we know its activity ID.
- */
-export function setPendingUploadActivityId(uploadId: string, activityId: string): void {
-  const entry = pendingUploads.get(uploadId);
-  if (entry) {
-    entry.consentCardActivityId = activityId;
-  }
-}
-
-/**
- * Get the count of pending uploads (for monitoring/debugging).
- */
-export function getPendingUploadCount(): number {
-  return pendingUploads.size;
-}
-
-/**
- * Clear all pending uploads (for testing).
- */
-export function clearPendingUploads(): void {
-  for (const timer of pendingUploadTimers.values()) {
-    clearTimeout(timer);
-  }
-  pendingUploadTimers.clear();
-  pendingUploads.clear();
-}

package/src/policy.test.ts

@@ -1,156 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { MSTeamsConfig } from "../runtime-api.js";
-import { resolveMSTeamsReplyPolicy, resolveMSTeamsRouteConfig } from "./policy.js";
-
-function resolveNamedTeamRouteConfig(allowNameMatching = false) {
-  const cfg: MSTeamsConfig = {
-    teams: {
-      "My Team": {
-        requireMention: true,
-        channels: {
-          "General Chat": { requireMention: false },
-        },
-      },
-    },
-  };
-
-  return resolveMSTeamsRouteConfig({
-    cfg,
-    teamName: "My Team",
-    channelName: "General Chat",
-    conversationId: "ignored",
-    allowNameMatching,
-  });
-}
-
-describe("msteams policy", () => {
-  describe("resolveMSTeamsRouteConfig", () => {
-    it("returns team and channel config when present", () => {
-      const cfg: MSTeamsConfig = {
-        teams: {
-          team123: {
-            requireMention: false,
-            channels: {
-              chan456: { requireMention: true },
-            },
-          },
-        },
-      };
-
-      const res = resolveMSTeamsRouteConfig({
-        cfg,
-        teamId: "team123",
-        conversationId: "chan456",
-      });
-
-      if (!res.teamConfig || !res.channelConfig) {
-        throw new Error("expected matched team and channel config");
-      }
-      expect(res.teamConfig.requireMention).toBe(false);
-      expect(res.channelConfig.requireMention).toBe(true);
-      expect(res.allowlistConfigured).toBe(true);
-      expect(res.allowed).toBe(true);
-      expect(res.channelMatchKey).toBe("chan456");
-      expect(res.channelMatchSource).toBe("direct");
-    });
-
-    it("returns undefined configs when teamId is missing", () => {
-      const cfg: MSTeamsConfig = {
-        teams: { team123: { requireMention: false } },
-      };
-
-      const res = resolveMSTeamsRouteConfig({
-        cfg,
-        teamId: undefined,
-        conversationId: "chan",
-      });
-      expect(res.teamConfig).toBeUndefined();
-      expect(res.channelConfig).toBeUndefined();
-      expect(res.allowlistConfigured).toBe(true);
-      expect(res.allowed).toBe(false);
-    });
-
-    it("blocks team and channel name matches by default", () => {
-      const res = resolveNamedTeamRouteConfig();
-
-      expect(res.teamConfig).toBeUndefined();
-      expect(res.channelConfig).toBeUndefined();
-      expect(res.allowed).toBe(false);
-    });
-
-    it("matches team and channel by name when dangerous name matching is enabled", () => {
-      const res = resolveNamedTeamRouteConfig(true);
-
-      if (!res.teamConfig || !res.channelConfig) {
-        throw new Error("expected matched named team and channel config");
-      }
-      expect(res.teamConfig.requireMention).toBe(true);
-      expect(res.channelConfig.requireMention).toBe(false);
-      expect(res.allowed).toBe(true);
-    });
-  });
-
-  describe("resolveMSTeamsReplyPolicy", () => {
-    it("forces thread replies for direct messages", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: true,
-        globalConfig: { replyStyle: "top-level", requireMention: false },
-      });
-      expect(policy).toEqual({ requireMention: false, replyStyle: "thread" });
-    });
-
-    it("defaults to requireMention=true and replyStyle=thread", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: {},
-      });
-      expect(policy).toEqual({ requireMention: true, replyStyle: "thread" });
-    });
-
-    it("defaults replyStyle to top-level when requireMention=false", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: false },
-      });
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("prefers channel overrides over team and global defaults", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: true },
-        teamConfig: { requireMention: true },
-        channelConfig: { requireMention: false },
-      });
-
-      // requireMention from channel -> false, and replyStyle defaults from requireMention -> top-level
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("inherits team mention settings when channel config is missing", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: true },
-        teamConfig: { requireMention: false },
-      });
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("uses explicit replyStyle even when requireMention defaults would differ", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: false, replyStyle: "thread" },
-      });
-      expect(policy).toEqual({ requireMention: false, replyStyle: "thread" });
-    });
-  });
-});

package/src/policy.ts

@@ -1,245 +0,0 @@
-import type {
-  AllowlistMatch,
-  ChannelGroupContext,
-  GroupToolPolicyConfig,
-  MSTeamsChannelConfig,
-  MSTeamsConfig,
-  MSTeamsReplyStyle,
-  MSTeamsTeamConfig,
-} from "../runtime-api.js";
-import {
-  buildChannelKeyCandidates,
-  normalizeChannelSlug,
-  resolveAllowlistMatchSimple,
-  resolveToolsBySender,
-  resolveChannelEntryMatchWithFallback,
-  resolveNestedAllowlistDecision,
-  isDangerousNameMatchingEnabled,
-} from "../runtime-api.js";
-
-type MSTeamsResolvedRouteConfig = {
-  teamConfig?: MSTeamsTeamConfig;
-  channelConfig?: MSTeamsChannelConfig;
-  allowlistConfigured: boolean;
-  allowed: boolean;
-  teamKey?: string;
-  channelKey?: string;
-  channelMatchKey?: string;
-  channelMatchSource?: "direct" | "wildcard";
-};
-
-export function resolveMSTeamsRouteConfig(params: {
-  cfg?: MSTeamsConfig;
-  teamId?: string | null | undefined;
-  teamName?: string | null | undefined;
-  conversationId?: string | null | undefined;
-  channelName?: string | null | undefined;
-  allowNameMatching?: boolean;
-}): MSTeamsResolvedRouteConfig {
-  const teamId = params.teamId?.trim();
-  const teamName = params.teamName?.trim();
-  const conversationId = params.conversationId?.trim();
-  const channelName = params.channelName?.trim();
-  const teams = params.cfg?.teams ?? {};
-  const allowlistConfigured = Object.keys(teams).length > 0;
-  const teamCandidates = buildChannelKeyCandidates(
-    teamId,
-    params.allowNameMatching ? teamName : undefined,
-    params.allowNameMatching && teamName ? normalizeChannelSlug(teamName) : undefined,
-  );
-  const teamMatch = resolveChannelEntryMatchWithFallback({
-    entries: teams,
-    keys: teamCandidates,
-    wildcardKey: "*",
-    normalizeKey: normalizeChannelSlug,
-  });
-  const teamConfig = teamMatch.entry;
-  const channels = teamConfig?.channels ?? {};
-  const channelAllowlistConfigured = Object.keys(channels).length > 0;
-  const channelCandidates = buildChannelKeyCandidates(
-    conversationId,
-    params.allowNameMatching ? channelName : undefined,
-    params.allowNameMatching && channelName ? normalizeChannelSlug(channelName) : undefined,
-  );
-  const channelMatch = resolveChannelEntryMatchWithFallback({
-    entries: channels,
-    keys: channelCandidates,
-    wildcardKey: "*",
-    normalizeKey: normalizeChannelSlug,
-  });
-  const channelConfig = channelMatch.entry;
-
-  const allowed = resolveNestedAllowlistDecision({
-    outerConfigured: allowlistConfigured,
-    outerMatched: Boolean(teamConfig),
-    innerConfigured: channelAllowlistConfigured,
-    innerMatched: Boolean(channelConfig),
-  });
-
-  return {
-    teamConfig,
-    channelConfig,
-    allowlistConfigured,
-    allowed,
-    teamKey: teamMatch.matchKey ?? teamMatch.key,
-    channelKey: channelMatch.matchKey ?? channelMatch.key,
-    channelMatchKey: channelMatch.matchKey,
-    channelMatchSource:
-      channelMatch.matchSource === "direct" || channelMatch.matchSource === "wildcard"
-        ? channelMatch.matchSource
-        : undefined,
-  };
-}
-
-export function resolveMSTeamsGroupToolPolicy(
-  params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
-  const cfg = params.cfg.channels?.msteams;
-  if (!cfg) {
-    return undefined;
-  }
-  const groupId = params.groupId?.trim();
-  const groupChannel = params.groupChannel?.trim();
-  const groupSpace = params.groupSpace?.trim();
-  const allowNameMatching = isDangerousNameMatchingEnabled(cfg);
-
-  const resolved = resolveMSTeamsRouteConfig({
-    cfg,
-    teamId: groupSpace,
-    teamName: groupSpace,
-    conversationId: groupId,
-    channelName: groupChannel,
-    allowNameMatching,
-  });
-
-  if (resolved.channelConfig) {
-    const senderPolicy = resolveToolsBySender({
-      toolsBySender: resolved.channelConfig.toolsBySender,
-      senderId: params.senderId,
-      senderName: params.senderName,
-      senderUsername: params.senderUsername,
-      senderE164: params.senderE164,
-    });
-    if (senderPolicy) {
-      return senderPolicy;
-    }
-    if (resolved.channelConfig.tools) {
-      return resolved.channelConfig.tools;
-    }
-    const teamSenderPolicy = resolveToolsBySender({
-      toolsBySender: resolved.teamConfig?.toolsBySender,
-      senderId: params.senderId,
-      senderName: params.senderName,
-      senderUsername: params.senderUsername,
-      senderE164: params.senderE164,
-    });
-    if (teamSenderPolicy) {
-      return teamSenderPolicy;
-    }
-    return resolved.teamConfig?.tools;
-  }
-  if (resolved.teamConfig) {
-    const teamSenderPolicy = resolveToolsBySender({
-      toolsBySender: resolved.teamConfig.toolsBySender,
-      senderId: params.senderId,
-      senderName: params.senderName,
-      senderUsername: params.senderUsername,
-      senderE164: params.senderE164,
-    });
-    if (teamSenderPolicy) {
-      return teamSenderPolicy;
-    }
-    if (resolved.teamConfig.tools) {
-      return resolved.teamConfig.tools;
-    }
-  }
-
-  if (!groupId) {
-    return undefined;
-  }
-
-  const channelCandidates = buildChannelKeyCandidates(
-    groupId,
-    allowNameMatching ? groupChannel : undefined,
-    allowNameMatching && groupChannel ? normalizeChannelSlug(groupChannel) : undefined,
-  );
-  for (const teamConfig of Object.values(cfg.teams ?? {})) {
-    const match = resolveChannelEntryMatchWithFallback({
-      entries: teamConfig?.channels ?? {},
-      keys: channelCandidates,
-      wildcardKey: "*",
-      normalizeKey: normalizeChannelSlug,
-    });
-    if (match.entry) {
-      const senderPolicy = resolveToolsBySender({
-        toolsBySender: match.entry.toolsBySender,
-        senderId: params.senderId,
-        senderName: params.senderName,
-        senderUsername: params.senderUsername,
-        senderE164: params.senderE164,
-      });
-      if (senderPolicy) {
-        return senderPolicy;
-      }
-      if (match.entry.tools) {
-        return match.entry.tools;
-      }
-      const teamSenderPolicy = resolveToolsBySender({
-        toolsBySender: teamConfig?.toolsBySender,
-        senderId: params.senderId,
-        senderName: params.senderName,
-        senderUsername: params.senderUsername,
-        senderE164: params.senderE164,
-      });
-      if (teamSenderPolicy) {
-        return teamSenderPolicy;
-      }
-      return teamConfig?.tools;
-    }
-  }
-
-  return undefined;
-}
-
-type MSTeamsReplyPolicy = {
-  requireMention: boolean;
-  replyStyle: MSTeamsReplyStyle;
-};
-
-type MSTeamsAllowlistMatch = AllowlistMatch<"wildcard" | "id" | "name">;
-
-export function resolveMSTeamsAllowlistMatch(params: {
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderName?: string | null;
-  allowNameMatching?: boolean;
-}): MSTeamsAllowlistMatch {
-  return resolveAllowlistMatchSimple(params);
-}
-
-export function resolveMSTeamsReplyPolicy(params: {
-  isDirectMessage: boolean;
-  globalConfig?: MSTeamsConfig;
-  teamConfig?: MSTeamsTeamConfig;
-  channelConfig?: MSTeamsChannelConfig;
-}): MSTeamsReplyPolicy {
-  if (params.isDirectMessage) {
-    return { requireMention: false, replyStyle: "thread" };
-  }
-
-  const requireMention =
-    params.channelConfig?.requireMention ??
-    params.teamConfig?.requireMention ??
-    params.globalConfig?.requireMention ??
-    true;
-
-  const explicitReplyStyle =
-    params.channelConfig?.replyStyle ??
-    params.teamConfig?.replyStyle ??
-    params.globalConfig?.replyStyle;
-
-  const replyStyle: MSTeamsReplyStyle =
-    explicitReplyStyle ?? (requireMention ? "thread" : "top-level");
-
-  return { requireMention, replyStyle };
-}

package/src/polls-store-memory.ts

@@ -1,32 +0,0 @@
-import {
-  type MSTeamsPoll,
-  type MSTeamsPollStore,
-  normalizeMSTeamsPollSelections,
-} from "./polls.js";
-
-export function createMSTeamsPollStoreMemory(initial: MSTeamsPoll[] = []): MSTeamsPollStore {
-  const polls = new Map<string, MSTeamsPoll>();
-  for (const poll of initial) {
-    polls.set(poll.id, { ...poll });
-  }
-
-  const createPoll = async (poll: MSTeamsPoll) => {
-    polls.set(poll.id, { ...poll });
-  };
-
-  const getPoll = async (pollId: string) => polls.get(pollId) ?? null;
-
-  const recordVote = async (params: { pollId: string; voterId: string; selections: string[] }) => {
-    const poll = polls.get(params.pollId);
-    if (!poll) {
-      return null;
-    }
-    const normalized = normalizeMSTeamsPollSelections(poll, params.selections);
-    poll.votes[params.voterId] = normalized;
-    poll.updatedAt = new Date().toISOString();
-    polls.set(poll.id, poll);
-    return poll;
-  };
-
-  return { createPoll, getPoll, recordVote };
-}