@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/policy.ts

@@ -1,262 +0,0 @@
-import type {
-  AllowlistMatch,
-  ChannelGroupContext,
-  GroupPolicy,
-  GroupToolPolicyConfig,
-  MSTeamsChannelConfig,
-  MSTeamsConfig,
-  MSTeamsReplyStyle,
-  MSTeamsTeamConfig,
-} from "../runtime-api.js";
-import {
-  buildChannelKeyCandidates,
-  evaluateSenderGroupAccessForPolicy,
-  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 };
-}
-
-export function isMSTeamsGroupAllowed(params: {
-  groupPolicy: GroupPolicy;
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderName?: string | null;
-  allowNameMatching?: boolean;
-}): boolean {
-  return evaluateSenderGroupAccessForPolicy({
-    groupPolicy: params.groupPolicy,
-    groupAllowFrom: params.allowFrom.map((entry) => String(entry)),
-    senderId: params.senderId,
-    isSenderAllowed: () => resolveMSTeamsAllowlistMatch(params).allowed,
-  }).allowed;
-}

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 };
-}

package/src/polls.test.ts

@@ -1,160 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { createMSTeamsPollStoreMemory } from "./polls-store-memory.js";
-import { buildMSTeamsPollCard, createMSTeamsPollStoreFs, extractMSTeamsPollVote } from "./polls.js";
-import { setMSTeamsRuntime } from "./runtime.js";
-import { msteamsRuntimeStub } from "./test-runtime.js";
-
-describe("msteams polls", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(msteamsRuntimeStub);
-  });
-
-  it("builds poll cards with fallback text", () => {
-    const card = buildMSTeamsPollCard({
-      question: "Lunch?",
-      options: ["Pizza", "Sushi"],
-    });
-
-    expect(card.pollId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    );
-    expect(card.fallbackText).toBe("Poll: Lunch?\n1. Pizza\n2. Sushi");
-  });
-
-  it("extracts poll votes from activity values", () => {
-    const vote = extractMSTeamsPollVote({
-      value: {
-        openclawPollId: "poll-1",
-        choices: "0,1",
-      },
-    });
-
-    expect(vote).toEqual({
-      pollId: "poll-1",
-      selections: ["0", "1"],
-    });
-  });
-
-  it("stores and records poll votes", async () => {
-    const home = await fs.promises.mkdtemp(path.join(os.tmpdir(), "openclaw-msteams-polls-"));
-    const store = createMSTeamsPollStoreFs({ homedir: () => home });
-    await store.createPoll({
-      id: "poll-2",
-      question: "Pick one",
-      options: ["A", "B"],
-      maxSelections: 1,
-      createdAt: new Date().toISOString(),
-      votes: {},
-    });
-    await store.recordVote({
-      pollId: "poll-2",
-      voterId: "user-1",
-      selections: ["0", "1"],
-    });
-    const stored = await store.getPoll("poll-2");
-    if (!stored) {
-      throw new Error("expected stored poll after recordVote");
-    }
-    expect(stored.votes["user-1"]).toEqual(["0"]);
-  });
-});
-
-const createFsStore = async () => {
-  const stateDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "openclaw-msteams-polls-"));
-  return createMSTeamsPollStoreFs({ stateDir });
-};
-
-const createMemoryStore = () => createMSTeamsPollStoreMemory();
-
-describe.each([
-  { name: "memory", createStore: createMemoryStore },
-  { name: "fs", createStore: createFsStore },
-])("$name poll store", ({ createStore }) => {
-  it("stores polls and records normalized votes", async () => {
-    const store = await createStore();
-    await store.createPoll({
-      id: "poll-1",
-      question: "Lunch?",
-      options: ["Pizza", "Sushi"],
-      maxSelections: 1,
-      createdAt: new Date().toISOString(),
-      votes: {},
-    });
-
-    const poll = await store.recordVote({
-      pollId: "poll-1",
-      voterId: "user-1",
-      selections: ["0", "1"],
-    });
-
-    if (!poll) {
-      throw new Error("poll store did not return the updated poll");
-    }
-    expect(poll.votes["user-1"]).toEqual(["0"]);
-  });
-});
-
-describe("memory poll store", () => {
-  it("reads seeded polls back, updates timestamps, and returns null for missing polls", async () => {
-    const store = createMSTeamsPollStoreMemory([
-      {
-        id: "poll-1",
-        question: "Pick one",
-        options: ["A", "B"],
-        maxSelections: 1,
-        votes: {},
-        createdAt: "2026-03-22T00:00:00.000Z",
-        updatedAt: "2026-03-22T00:00:00.000Z",
-      },
-    ]);
-
-    await expect(store.getPoll("poll-1")).resolves.toEqual(
-      expect.objectContaining({
-        id: "poll-1",
-        question: "Pick one",
-      }),
-    );
-
-    const originalUpdatedAt = "2026-03-22T00:00:00.000Z";
-    const result = await store.recordVote({
-      pollId: "poll-1",
-      voterId: "user-1",
-      selections: ["1", "0", "missing"],
-    });
-
-    expect(result?.votes["user-1"]).toEqual(["1"]);
-    expect(result?.updatedAt).not.toBe(originalUpdatedAt);
-
-    await store.createPoll({
-      id: "poll-2",
-      question: "Pick many",
-      options: ["X", "Y"],
-      maxSelections: 2,
-      votes: {},
-      createdAt: "2026-03-22T00:00:00.000Z",
-      updatedAt: "2026-03-22T00:00:00.000Z",
-    });
-
-    await expect(
-      store.recordVote({
-        pollId: "poll-2",
-        voterId: "user-2",
-        selections: ["1", "0", "1"],
-      }),
-    ).resolves.toEqual(
-      expect.objectContaining({
-        id: "poll-2",
-        votes: {
-          "user-2": ["1", "0"],
-        },
-      }),
-    );
-
-    await expect(
-      store.recordVote({ pollId: "missing", voterId: "nobody", selections: ["x"] }),
-    ).resolves.toBeNull();
-  });
-});