@openclaw/msteams 2026.3.13 → 2026.5.2-beta.1

package/src/pending-uploads.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  clearPendingUploads,
+  getPendingUpload,
+  getPendingUploadCount,
+  removePendingUpload,
+  setPendingUploadActivityId,
+  storePendingUpload,
+} from "./pending-uploads.js";
+
+describe("pending-uploads", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    clearPendingUploads();
+  });
+
+  afterEach(() => {
+    clearPendingUploads();
+    vi.useRealTimers();
+  });
+
+  describe("storePendingUpload", () => {
+    it("stores and retrieves a pending upload", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        contentType: "text/plain",
+        conversationId: "conv-1",
+      });
+
+      const upload = getPendingUpload(id);
+      expect(upload).toBeDefined();
+      expect(upload?.filename).toBe("file.txt");
+      expect(upload?.conversationId).toBe("conv-1");
+    });
+
+    it("stores consentCardActivityId when provided", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+        consentCardActivityId: "activity-abc",
+      });
+
+      const upload = getPendingUpload(id);
+      expect(upload?.consentCardActivityId).toBe("activity-abc");
+    });
+
+    it("stores without consentCardActivityId when not provided", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      const upload = getPendingUpload(id);
+      expect(upload?.consentCardActivityId).toBeUndefined();
+    });
+
+    it("auto-removes entry after TTL expires", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      expect(getPendingUpload(id)).toBeDefined();
+      vi.advanceTimersByTime(5 * 60 * 1000 + 1);
+      // After TTL the in-memory check also gates access
+      expect(getPendingUpload(id)).toBeUndefined();
+    });
+  });
+
+  describe("removePendingUpload", () => {
+    it("removes the entry immediately", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      removePendingUpload(id);
+      expect(getPendingUpload(id)).toBeUndefined();
+    });
+
+    it("clears the TTL timer so it does not fire after explicit removal", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      expect(getPendingUploadCount()).toBe(1);
+      removePendingUpload(id);
+      expect(getPendingUploadCount()).toBe(0);
+
+      // Advance past TTL — timer should have been cleared and count stays 0
+      vi.advanceTimersByTime(5 * 60 * 1000 + 1);
+      expect(getPendingUploadCount()).toBe(0);
+    });
+
+    it("is a no-op for undefined id", () => {
+      storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      expect(() => removePendingUpload(undefined)).not.toThrow();
+      expect(getPendingUploadCount()).toBe(1);
+    });
+
+    it("is a no-op for unknown id", () => {
+      expect(() => removePendingUpload("non-existent-id")).not.toThrow();
+    });
+  });
+
+  describe("clearPendingUploads", () => {
+    it("removes all entries and cancels timers", () => {
+      storePendingUpload({ buffer: Buffer.from("a"), filename: "a.txt", conversationId: "c1" });
+      storePendingUpload({ buffer: Buffer.from("b"), filename: "b.txt", conversationId: "c2" });
+      expect(getPendingUploadCount()).toBe(2);
+
+      clearPendingUploads();
+      expect(getPendingUploadCount()).toBe(0);
+
+      // TTL timers should have been cleared — no side-effects after advance
+      vi.advanceTimersByTime(5 * 60 * 1000 + 1);
+      expect(getPendingUploadCount()).toBe(0);
+    });
+  });
+
+  describe("setPendingUploadActivityId", () => {
+    it("sets the consentCardActivityId on an existing upload", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      expect(getPendingUpload(id)?.consentCardActivityId).toBeUndefined();
+
+      setPendingUploadActivityId(id, "activity-xyz");
+      expect(getPendingUpload(id)?.consentCardActivityId).toBe("activity-xyz");
+    });
+
+    it("is a no-op for unknown upload id", () => {
+      expect(() => setPendingUploadActivityId("non-existent", "activity-xyz")).not.toThrow();
+    });
+  });
+
+  describe("getPendingUpload", () => {
+    it("returns undefined for undefined id", () => {
+      expect(getPendingUpload(undefined)).toBeUndefined();
+    });
+
+    it("returns undefined for unknown id", () => {
+      expect(getPendingUpload("no-such-id")).toBeUndefined();
+    });
+
+    it("returns undefined when entry is past TTL but timer has not yet fired", () => {
+      const id = storePendingUpload({
+        buffer: Buffer.from("data"),
+        filename: "file.txt",
+        conversationId: "conv-1",
+      });
+
+      // Manually advance time without firing timers to simulate stale entry
+      vi.setSystemTime(Date.now() + 5 * 60 * 1000 + 1);
+      expect(getPendingUpload(id)).toBeUndefined();
+    });
+  });
+});

package/src/pending-uploads.ts

@@ -14,10 +14,14 @@ export interface PendingUpload {
   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;
@@ -35,10 +39,12 @@ export function storePendingUpload(upload: Omit<PendingUpload, "id" | "createdAt
   };
   pendingUploads.set(id, entry);
 
-  // Auto-cleanup after TTL
-  setTimeout(() => {
+  // 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;
 }
@@ -59,6 +65,11 @@ export function getPendingUpload(id?: string): PendingUpload | 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;
   }
 
@@ -67,10 +78,27 @@ export function getPendingUpload(id?: string): PendingUpload | undefined {
 
 /**
  * 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;
   }
 }
 
@@ -85,5 +113,9 @@ export function getPendingUploadCount(): number {
  * 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,5 +1,5 @@
-import type { MSTeamsConfig } from "openclaw/plugin-sdk/msteams";
 import { describe, expect, it } from "vitest";
+import type { MSTeamsConfig } from "../runtime-api.js";
 import {
   isMSTeamsGroupAllowed,
   resolveMSTeamsReplyPolicy,
@@ -47,8 +47,11 @@ describe("msteams policy", () => {
         conversationId: "chan456",
       });
 
-      expect(res.teamConfig?.requireMention).toBe(false);
-      expect(res.channelConfig?.requireMention).toBe(true);
+      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");
@@ -82,8 +85,11 @@ describe("msteams policy", () => {
     it("matches team and channel by name when dangerous name matching is enabled", () => {
       const res = resolveNamedTeamRouteConfig(true);
 
-      expect(res.teamConfig?.requireMention).toBe(true);
-      expect(res.channelConfig?.requireMention).toBe(false);
+      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);
     });
   });

package/src/policy.ts

@@ -7,7 +7,7 @@ import type {
   MSTeamsConfig,
   MSTeamsReplyStyle,
   MSTeamsTeamConfig,
-} from "openclaw/plugin-sdk/msteams";
+} from "../runtime-api.js";
 import {
   buildChannelKeyCandidates,
   evaluateSenderGroupAccessForPolicy,
@@ -17,9 +17,9 @@ import {
   resolveChannelEntryMatchWithFallback,
   resolveNestedAllowlistDecision,
   isDangerousNameMatchingEnabled,
-} from "openclaw/plugin-sdk/msteams";
+} from "../runtime-api.js";
 
-export type MSTeamsResolvedRouteConfig = {
+type MSTeamsResolvedRouteConfig = {
   teamConfig?: MSTeamsTeamConfig;
   channelConfig?: MSTeamsChannelConfig;
   allowlistConfigured: boolean;
@@ -203,12 +203,12 @@ export function resolveMSTeamsGroupToolPolicy(
   return undefined;
 }
 
-export type MSTeamsReplyPolicy = {
+type MSTeamsReplyPolicy = {
   requireMention: boolean;
   replyStyle: MSTeamsReplyStyle;
 };
 
-export type MSTeamsAllowlistMatch = AllowlistMatch<"wildcard" | "id" | "name">;
+type MSTeamsAllowlistMatch = AllowlistMatch<"wildcard" | "id" | "name">;
 
 export function resolveMSTeamsAllowlistMatch(params: {
   allowFrom: Array<string | number>;

package/src/polls.test.ts

@@ -2,6 +2,7 @@ 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";
@@ -17,10 +18,10 @@ describe("msteams polls", () => {
       options: ["Pizza", "Sushi"],
     });
 
-    expect(card.pollId).toBeTruthy();
-    expect(card.fallbackText).toContain("Poll: Lunch?");
-    expect(card.fallbackText).toContain("1. Pizza");
-    expect(card.fallbackText).toContain("2. 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", () => {
@@ -54,6 +55,106 @@ describe("msteams polls", () => {
       selections: ["0", "1"],
     });
     const stored = await store.getPoll("poll-2");
-    expect(stored?.votes["user-1"]).toEqual(["0"]);
+    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();
   });
 });

package/src/polls.ts

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import { resolveMSTeamsStorePath } from "./storage.js";
 import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
 
-export type MSTeamsPollVote = {
+type MSTeamsPollVote = {
   pollId: string;
   selections: string[];
 };
@@ -29,7 +29,7 @@ export type MSTeamsPollStore = {
   }) => Promise<MSTeamsPoll | null>;
 };
 
-export type MSTeamsPollCard = {
+type MSTeamsPollCard = {
   pollId: string;
   question: string;
   options: string[];
@@ -46,8 +46,17 @@ type PollStoreData = {
 const STORE_FILENAME = "msteams-polls.json";
 const MAX_POLLS = 1000;
 const POLL_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeOptionalString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
 }
 
 function normalizeChoiceValue(value: unknown): string | null {
@@ -90,8 +99,7 @@ function readNestedValue(value: unknown, keys: Array<string | number>): unknown
 }
 
 function readNestedString(value: unknown, keys: Array<string | number>): string | undefined {
-  const found = readNestedValue(value, keys);
-  return typeof found === "string" && found.trim() ? found.trim() : undefined;
+  return normalizeOptionalString(readNestedValue(value, keys));
 }
 
 export function extractMSTeamsPollVote(
@@ -213,7 +221,7 @@ export function buildMSTeamsPollCard(params: {
   };
 }
 
-export type MSTeamsPollStoreFsOptions = {
+type MSTeamsPollStoreFsOptions = {
   env?: NodeJS.ProcessEnv;
   homedir?: () => string;
   stateDir?: string;
@@ -273,7 +281,7 @@ export function createMSTeamsPollStoreFs(params?: MSTeamsPollStoreFsOptions): MS
   const empty: PollStoreData = { version: 1, polls: {} };
 
   const readStore = async (): Promise<PollStoreData> => {
-    const { value } = await readJsonFile<PollStoreData>(filePath, empty);
+    const { value } = await readJsonFile(filePath, empty);
     const pruned = pruneToLimit(pruneExpired(value.polls ?? {}));
     return { version: 1, polls: pruned };
   };

package/src/presentation.ts

@@ -0,0 +1,68 @@
+import type { MessagePresentation } from "openclaw/plugin-sdk/interactive-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+
+export function buildMSTeamsPresentationCard(params: {
+  presentation: MessagePresentation;
+  text?: string | null;
+}) {
+  const body: Record<string, unknown>[] = [];
+  const text = normalizeOptionalString(params.text);
+  if (text) {
+    body.push({
+      type: "TextBlock",
+      text,
+      wrap: true,
+    });
+  }
+  const { presentation } = params;
+  if (presentation.title) {
+    body.push({
+      type: "TextBlock",
+      text: presentation.title,
+      weight: "Bolder",
+      size: "Medium",
+      wrap: true,
+    });
+  }
+  const actions: Record<string, unknown>[] = [];
+  for (const block of presentation.blocks) {
+    if (block.type === "text" || block.type === "context") {
+      body.push({
+        type: "TextBlock",
+        text: block.text,
+        wrap: true,
+        ...(block.type === "context" ? { isSubtle: true, size: "Small" } : {}),
+      });
+      continue;
+    }
+    if (block.type === "divider") {
+      body.push({ type: "TextBlock", text: "---", wrap: true, isSubtle: true });
+      continue;
+    }
+    if (block.type === "buttons") {
+      for (const button of block.buttons) {
+        if (button.url) {
+          actions.push({
+            type: "Action.OpenUrl",
+            title: button.label,
+            url: button.url,
+          });
+          continue;
+        }
+        if (button.value) {
+          actions.push({
+            type: "Action.Submit",
+            title: button.label,
+            data: { value: button.value, label: button.label },
+          });
+        }
+      }
+    }
+  }
+  return {
+    type: "AdaptiveCard",
+    version: "1.4",
+    body,
+    ...(actions.length ? { actions } : {}),
+  };
+}

package/src/probe.test.ts

@@ -1,25 +1,45 @@
-import type { MSTeamsConfig } from "openclaw/plugin-sdk/msteams";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { MSTeamsConfig } from "../runtime-api.js";
 
 const hostMockState = vi.hoisted(() => ({
   tokenError: null as Error | null,
 }));
 
-vi.mock("@microsoft/agents-hosting", () => ({
-  getAuthConfigWithDefaults: (cfg: unknown) => cfg,
-  MsalTokenProvider: class {
-    async getAccessToken() {
+vi.mock("@microsoft/teams.apps", () => ({
+  App: class {
+    protected async getBotToken() {
       if (hostMockState.tokenError) {
         throw hostMockState.tokenError;
       }
-      return "token";
+      return { value: "token" };
+    }
+    protected async getAppGraphToken() {
+      if (hostMockState.tokenError) {
+        throw hostMockState.tokenError;
+      }
+      return { value: "token" };
     }
   },
 }));
 
+vi.mock("@microsoft/teams.api", () => ({
+  Client: function Client() {},
+}));
+
 import { probeMSTeams } from "./probe.js";
 
 describe("msteams probe", () => {
+  beforeEach(() => {
+    hostMockState.tokenError = null;
+    vi.stubEnv("MSTEAMS_APP_ID", "");
+    vi.stubEnv("MSTEAMS_APP_PASSWORD", "");
+    vi.stubEnv("MSTEAMS_TENANT_ID", "");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
   it("returns an error when credentials are missing", async () => {
     const cfg = { enabled: true } as unknown as MSTeamsConfig;
     await expect(probeMSTeams(cfg)).resolves.toMatchObject({
@@ -28,7 +48,6 @@ describe("msteams probe", () => {
   });
 
   it("validates credentials by acquiring a token", async () => {
-    hostMockState.tokenError = null;
     const cfg = {
       enabled: true,
       appId: "app",