@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/config-schema.ts

@@ -1,6 +0,0 @@
-import { buildChannelConfigSchema, MSTeamsConfigSchema } from "../config-api.js";
-import { msTeamsChannelConfigUiHints } from "./config-ui-hints.js";
-
-export const MSTeamsChannelConfigSchema = buildChannelConfigSchema(MSTeamsConfigSchema, {
-  uiHints: msTeamsChannelConfigUiHints,
-});

package/src/config-ui-hints.ts

@@ -1,12 +0,0 @@
-import type { ChannelConfigUiHint } from "openclaw/plugin-sdk/channel-core";
-
-export const msTeamsChannelConfigUiHints = {
-  "": {
-    label: "MS Teams",
-    help: "Microsoft Teams channel provider configuration and provider-specific policy toggles. Use this section to isolate Teams behavior from other enterprise chat providers.",
-  },
-  configWrites: {
-    label: "MS Teams Config Writes",
-    help: "Allow Microsoft Teams to write config in response to channel events/commands (default: true).",
-  },
-} satisfies Record<string, ChannelConfigUiHint>;

package/src/conversation-store-fs.test.ts

@@ -1,74 +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 { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";
-import type { StoredConversationReference } from "./conversation-store.js";
-import { setMSTeamsRuntime } from "./runtime.js";
-import { msteamsRuntimeStub } from "./test-runtime.js";
-
-describe("msteams conversation store (fs-only)", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(msteamsRuntimeStub);
-  });
-
-  it("filters and prunes expired entries while preserving legacy entries without lastSeenAt", async () => {
-    const stateDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "openclaw-msteams-store-"));
-
-    const env: NodeJS.ProcessEnv = {
-      ...process.env,
-      OPENCLAW_STATE_DIR: stateDir,
-    };
-
-    const store = createMSTeamsConversationStoreFs({ env, ttlMs: 1_000 });
-
-    const ref: StoredConversationReference = {
-      conversation: { id: "19:active@thread.tacv2" },
-      channelId: "msteams",
-      serviceUrl: "https://service.example.com",
-      user: { id: "u1", aadObjectId: "aad1" },
-    };
-
-    await store.upsert("19:active@thread.tacv2", ref);
-
-    const filePath = path.join(stateDir, "msteams-conversations.json");
-    const raw = await fs.promises.readFile(filePath, "utf-8");
-    const json = JSON.parse(raw) as {
-      version: number;
-      conversations: Record<string, StoredConversationReference>;
-    };
-
-    json.conversations["19:old@thread.tacv2"] = {
-      ...ref,
-      conversation: { id: "19:old@thread.tacv2" },
-      lastSeenAt: new Date(Date.now() - 60_000).toISOString(),
-    };
-
-    json.conversations["19:legacy@thread.tacv2"] = {
-      ...ref,
-      conversation: { id: "19:legacy@thread.tacv2" },
-    };
-
-    await fs.promises.writeFile(filePath, `${JSON.stringify(json, null, 2)}\n`);
-
-    const list = await store.list();
-    const ids = list.map((entry) => entry.conversationId).toSorted();
-    expect(ids).toEqual(["19:active@thread.tacv2", "19:legacy@thread.tacv2"]);
-
-    expect(await store.get("19:old@thread.tacv2")).toBeNull();
-    expect(await store.get("19:legacy@thread.tacv2")).not.toBeNull();
-
-    await store.upsert("19:new@thread.tacv2", {
-      ...ref,
-      conversation: { id: "19:new@thread.tacv2" },
-    });
-
-    const rawAfter = await fs.promises.readFile(filePath, "utf-8");
-    const jsonAfter = JSON.parse(rawAfter) as typeof json;
-    expect(Object.keys(jsonAfter.conversations).toSorted()).toEqual([
-      "19:active@thread.tacv2",
-      "19:legacy@thread.tacv2",
-      "19:new@thread.tacv2",
-    ]);
-  });
-});

package/src/conversation-store-fs.ts

@@ -1,149 +0,0 @@
-import {
-  findPreferredDmConversationByUserId,
-  mergeStoredConversationReference,
-  normalizeStoredConversationId,
-  parseStoredConversationTimestamp,
-  toConversationStoreEntries,
-} from "./conversation-store-helpers.js";
-import type {
-  MSTeamsConversationStore,
-  MSTeamsConversationStoreEntry,
-  StoredConversationReference,
-} from "./conversation-store.js";
-import { resolveMSTeamsStorePath } from "./storage.js";
-import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
-
-type ConversationStoreData = {
-  version: 1;
-  conversations: Record<string, StoredConversationReference>;
-};
-
-const STORE_FILENAME = "msteams-conversations.json";
-const MAX_CONVERSATIONS = 1000;
-const CONVERSATION_TTL_MS = 365 * 24 * 60 * 60 * 1000;
-
-function pruneToLimit(conversations: Record<string, StoredConversationReference>) {
-  const entries = Object.entries(conversations);
-  if (entries.length <= MAX_CONVERSATIONS) {
-    return conversations;
-  }
-
-  entries.sort((a, b) => {
-    const aTs = parseStoredConversationTimestamp(a[1].lastSeenAt) ?? 0;
-    const bTs = parseStoredConversationTimestamp(b[1].lastSeenAt) ?? 0;
-    return aTs - bTs;
-  });
-
-  const keep = entries.slice(entries.length - MAX_CONVERSATIONS);
-  return Object.fromEntries(keep);
-}
-
-function pruneExpired(
-  conversations: Record<string, StoredConversationReference>,
-  nowMs: number,
-  ttlMs: number,
-) {
-  let removed = false;
-  const kept: typeof conversations = {};
-  for (const [conversationId, reference] of Object.entries(conversations)) {
-    const lastSeenAt = parseStoredConversationTimestamp(reference.lastSeenAt);
-    // Preserve legacy entries that have no lastSeenAt until they're seen again.
-    if (lastSeenAt != null && nowMs - lastSeenAt > ttlMs) {
-      removed = true;
-      continue;
-    }
-    kept[conversationId] = reference;
-  }
-  return { conversations: kept, removed };
-}
-
-export function createMSTeamsConversationStoreFs(params?: {
-  env?: NodeJS.ProcessEnv;
-  homedir?: () => string;
-  ttlMs?: number;
-  stateDir?: string;
-  storePath?: string;
-}): MSTeamsConversationStore {
-  const ttlMs = params?.ttlMs ?? CONVERSATION_TTL_MS;
-  const filePath = resolveMSTeamsStorePath({
-    filename: STORE_FILENAME,
-    env: params?.env,
-    homedir: params?.homedir,
-    stateDir: params?.stateDir,
-    storePath: params?.storePath,
-  });
-
-  const empty: ConversationStoreData = { version: 1, conversations: {} };
-
-  const readStore = async (): Promise<ConversationStoreData> => {
-    const { value } = await readJsonFile(filePath, empty);
-    if (
-      value.version !== 1 ||
-      !value.conversations ||
-      typeof value.conversations !== "object" ||
-      Array.isArray(value.conversations)
-    ) {
-      return empty;
-    }
-    const nowMs = Date.now();
-    const pruned = pruneExpired(value.conversations, nowMs, ttlMs).conversations;
-    return { version: 1, conversations: pruneToLimit(pruned) };
-  };
-
-  const list = async (): Promise<MSTeamsConversationStoreEntry[]> => {
-    const store = await readStore();
-    return toConversationStoreEntries(Object.entries(store.conversations));
-  };
-
-  const get = async (conversationId: string): Promise<StoredConversationReference | null> => {
-    const store = await readStore();
-    return store.conversations[normalizeStoredConversationId(conversationId)] ?? null;
-  };
-
-  const findPreferredDmByUserId = async (
-    id: string,
-  ): Promise<MSTeamsConversationStoreEntry | null> => {
-    return findPreferredDmConversationByUserId(await list(), id);
-  };
-
-  const upsert = async (
-    conversationId: string,
-    reference: StoredConversationReference,
-  ): Promise<void> => {
-    const normalizedId = normalizeStoredConversationId(conversationId);
-    await withFileLock(filePath, empty, async () => {
-      const store = await readStore();
-      store.conversations[normalizedId] = mergeStoredConversationReference(
-        store.conversations[normalizedId],
-        reference,
-        new Date().toISOString(),
-      );
-      const nowMs = Date.now();
-      store.conversations = pruneExpired(store.conversations, nowMs, ttlMs).conversations;
-      store.conversations = pruneToLimit(store.conversations);
-      await writeJsonFile(filePath, store);
-    });
-  };
-
-  const remove = async (conversationId: string): Promise<boolean> => {
-    const normalizedId = normalizeStoredConversationId(conversationId);
-    return await withFileLock(filePath, empty, async () => {
-      const store = await readStore();
-      if (!(normalizedId in store.conversations)) {
-        return false;
-      }
-      delete store.conversations[normalizedId];
-      await writeJsonFile(filePath, store);
-      return true;
-    });
-  };
-
-  return {
-    upsert,
-    get,
-    list,
-    remove,
-    findPreferredDmByUserId,
-    findByUserId: findPreferredDmByUserId,
-  };
-}

package/src/conversation-store-helpers.test.ts

@@ -1,202 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findPreferredDmConversationByUserId } from "./conversation-store-helpers.js";
-import type { MSTeamsConversationStoreEntry } from "./conversation-store.js";
-
-function entry(params: {
-  conversationId: string;
-  userId?: string;
-  aadObjectId?: string;
-  conversationType?: string;
-  lastSeenAt?: string;
-}): MSTeamsConversationStoreEntry {
-  return {
-    conversationId: params.conversationId,
-    reference: {
-      user: {
-        id: params.userId ?? "user-1",
-        aadObjectId: params.aadObjectId ?? "aad-1",
-      },
-      conversation: {
-        id: params.conversationId,
-        conversationType: params.conversationType,
-      },
-      lastSeenAt: params.lastSeenAt,
-    },
-  };
-}
-
-describe("findPreferredDmConversationByUserId", () => {
-  it("returns null for empty id", () => {
-    expect(findPreferredDmConversationByUserId([], "  ")).toBeNull();
-  });
-
-  it("returns null when no entries match", () => {
-    const entries = [entry({ conversationId: "conv-1", aadObjectId: "other-user" })];
-    expect(findPreferredDmConversationByUserId(entries, "aad-1")).toBeNull();
-  });
-
-  it("returns a personal DM conversation by aadObjectId", () => {
-    const entries = [
-      entry({
-        conversationId: "dm-conv",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("dm-conv");
-  });
-
-  it("returns a personal DM conversation by user.id", () => {
-    const entries = [
-      entry({
-        conversationId: "dm-conv",
-        userId: "user-target",
-        aadObjectId: "other",
-        conversationType: "personal",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "user-target");
-    expect(result?.conversationId).toBe("dm-conv");
-  });
-
-  it("does NOT return a channel conversation for a user lookup (#54520)", () => {
-    // This is the core bug: user sends messages in both a DM and a channel.
-    // The channel conversation also carries the user's aadObjectId.
-    // findPreferredDmByUserId must NOT return the channel conversation.
-    const entries = [
-      entry({
-        conversationId: "19:channel@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "channel",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result).toBeNull();
-  });
-
-  it("does NOT return a groupChat conversation for a user lookup (#54520)", () => {
-    const entries = [
-      entry({
-        conversationId: "19:group@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "groupChat",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result).toBeNull();
-  });
-
-  it("prefers personal DM over channel even when channel is more recent (#54520)", () => {
-    // Reproduces the exact race: channel message arrives after DM, but the
-    // DM conversation should still be returned.
-    const entries = [
-      entry({
-        conversationId: "dm-conv",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-        lastSeenAt: "2026-03-25T20:00:00.000Z",
-      }),
-      entry({
-        conversationId: "19:channel@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "channel",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("dm-conv");
-  });
-
-  it("prefers personal DM over groupChat even when groupChat is more recent", () => {
-    const entries = [
-      entry({
-        conversationId: "dm-conv",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-        lastSeenAt: "2026-03-25T20:00:00.000Z",
-      }),
-      entry({
-        conversationId: "19:group@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "groupChat",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("dm-conv");
-  });
-
-  it("prefers the freshest personal DM when multiple exist", () => {
-    const entries = [
-      entry({
-        conversationId: "dm-old",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-        lastSeenAt: "2026-03-25T20:00:00.000Z",
-      }),
-      entry({
-        conversationId: "dm-new",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("dm-new");
-  });
-
-  it("falls back to unknown-type entries when no personal conversations exist", () => {
-    // Legacy entries without conversationType should still be usable as a
-    // fallback to avoid breaking existing deployments.
-    const entries = [
-      entry({
-        conversationId: "legacy-conv",
-        aadObjectId: "aad-target",
-        // No conversationType set (legacy entry)
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("legacy-conv");
-  });
-
-  it("prefers personal over unknown-type entries", () => {
-    const entries = [
-      entry({
-        conversationId: "legacy-conv",
-        aadObjectId: "aad-target",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-        // No conversationType
-      }),
-      entry({
-        conversationId: "dm-conv",
-        aadObjectId: "aad-target",
-        conversationType: "personal",
-        lastSeenAt: "2026-03-25T20:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result?.conversationId).toBe("dm-conv");
-  });
-
-  it("does NOT fall back to channel/group when no personal or unknown entries exist", () => {
-    const entries = [
-      entry({
-        conversationId: "19:channel@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "channel",
-        lastSeenAt: "2026-03-25T21:00:00.000Z",
-      }),
-      entry({
-        conversationId: "19:group@thread.tacv2",
-        aadObjectId: "aad-target",
-        conversationType: "groupChat",
-        lastSeenAt: "2026-03-25T20:00:00.000Z",
-      }),
-    ];
-    const result = findPreferredDmConversationByUserId(entries, "aad-target");
-    expect(result).toBeNull();
-  });
-});

package/src/conversation-store-helpers.ts

@@ -1,105 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-import type {
-  MSTeamsConversationStoreEntry,
-  StoredConversationReference,
-} from "./conversation-store.js";
-
-export function normalizeStoredConversationId(raw: string): string {
-  return raw.split(";")[0] ?? raw;
-}
-
-export function parseStoredConversationTimestamp(value: string | undefined): number | null {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  if (!Number.isFinite(parsed)) {
-    return null;
-  }
-  return parsed;
-}
-
-export function toConversationStoreEntries(
-  entries: Iterable<[string, StoredConversationReference]>,
-): MSTeamsConversationStoreEntry[] {
-  return Array.from(entries, ([conversationId, reference]) => ({
-    conversationId,
-    reference,
-  }));
-}
-
-export function mergeStoredConversationReference(
-  existing: StoredConversationReference | undefined,
-  incoming: StoredConversationReference,
-  nowIso: string,
-): StoredConversationReference {
-  return {
-    // Preserve fields from the previous entry that may not be present on every
-    // inbound activity. Without this, sparse activities (e.g. conversationUpdate,
-    // reactions) would clear previously captured values. Some fields are only
-    // populated opportunistically, such as timezone from clientInfo entities and
-    // graphChatId from Graph lookups used for DM media downloads.
-    ...(existing?.timezone && !incoming.timezone ? { timezone: existing.timezone } : {}),
-    ...(existing?.graphChatId && !incoming.graphChatId
-      ? { graphChatId: existing.graphChatId }
-      : {}),
-    ...(existing?.tenantId && !incoming.tenantId ? { tenantId: existing.tenantId } : {}),
-    ...(existing?.aadObjectId && !incoming.aadObjectId
-      ? { aadObjectId: existing.aadObjectId }
-      : {}),
-    ...incoming,
-    lastSeenAt: nowIso,
-  };
-}
-
-export function findPreferredDmConversationByUserId(
-  entries: Iterable<MSTeamsConversationStoreEntry>,
-  id: string,
-): MSTeamsConversationStoreEntry | null {
-  const target = id.trim();
-  if (!target) {
-    return null;
-  }
-
-  // Partition user matches into DM-safe and non-DM buckets.
-  // Channel and group conversations also carry the sender's aadObjectId, but
-  // returning one of those when the caller asked for a user-targeted DM would
-  // leak the reply into a shared channel -- the root cause of #54520.
-  const personalMatches: MSTeamsConversationStoreEntry[] = [];
-  const unknownTypeMatches: MSTeamsConversationStoreEntry[] = [];
-  for (const entry of entries) {
-    if (entry.reference.user?.aadObjectId !== target && entry.reference.user?.id !== target) {
-      continue;
-    }
-    const convType = normalizeLowercaseStringOrEmpty(
-      entry.reference.conversation?.conversationType ?? "",
-    );
-    if (convType === "personal") {
-      personalMatches.push(entry);
-    } else if (convType === "channel" || convType === "groupchat") {
-      // Explicitly skip channel/group conversations -- these must never be
-      // returned for a user-targeted DM lookup.
-    } else {
-      // Legacy entries without conversationType are ambiguous. Include them
-      // as a fallback but rank below confirmed personal conversations.
-      unknownTypeMatches.push(entry);
-    }
-  }
-
-  // Prefer confirmed personal DMs, fall back to unknown-type entries.
-  const candidates = personalMatches.length > 0 ? personalMatches : unknownTypeMatches;
-  if (candidates.length === 0) {
-    return null;
-  }
-
-  // When multiple candidates exist, prefer the most recently seen one.
-  if (candidates.length > 1) {
-    candidates.sort(
-      (a, b) =>
-        (parseStoredConversationTimestamp(b.reference.lastSeenAt) ?? 0) -
-        (parseStoredConversationTimestamp(a.reference.lastSeenAt) ?? 0),
-    );
-  }
-
-  return candidates[0] ?? null;
-}

package/src/conversation-store-memory.ts

@@ -1,51 +0,0 @@
-import {
-  findPreferredDmConversationByUserId,
-  mergeStoredConversationReference,
-  normalizeStoredConversationId,
-  toConversationStoreEntries,
-} from "./conversation-store-helpers.js";
-import type {
-  MSTeamsConversationStore,
-  MSTeamsConversationStoreEntry,
-  StoredConversationReference,
-} from "./conversation-store.js";
-
-export function createMSTeamsConversationStoreMemory(
-  initial: MSTeamsConversationStoreEntry[] = [],
-): MSTeamsConversationStore {
-  const map = new Map<string, StoredConversationReference>();
-  for (const { conversationId, reference } of initial) {
-    map.set(normalizeStoredConversationId(conversationId), reference);
-  }
-
-  const findPreferredDmByUserId = async (
-    id: string,
-  ): Promise<MSTeamsConversationStoreEntry | null> => {
-    return findPreferredDmConversationByUserId(toConversationStoreEntries(map.entries()), id);
-  };
-
-  return {
-    upsert: async (conversationId, reference) => {
-      const normalizedId = normalizeStoredConversationId(conversationId);
-      map.set(
-        normalizedId,
-        mergeStoredConversationReference(
-          map.get(normalizedId),
-          reference,
-          new Date().toISOString(),
-        ),
-      );
-    },
-    get: async (conversationId) => {
-      return map.get(normalizeStoredConversationId(conversationId)) ?? null;
-    },
-    list: async () => {
-      return toConversationStoreEntries(map.entries());
-    },
-    remove: async (conversationId) => {
-      return map.delete(normalizeStoredConversationId(conversationId));
-    },
-    findPreferredDmByUserId,
-    findByUserId: findPreferredDmByUserId,
-  };
-}