@openclaw/msteams 2026.5.2 → 2026.5.3-beta.2

package/src/outbound.test.ts

@@ -1,130 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig } from "../runtime-api.js";
-
-const mocks = vi.hoisted(() => ({
-  sendMessageMSTeams: vi.fn(),
-  sendPollMSTeams: vi.fn(),
-  createPoll: vi.fn(),
-}));
-
-vi.mock("./send.js", () => ({
-  sendMessageMSTeams: mocks.sendMessageMSTeams,
-  sendPollMSTeams: mocks.sendPollMSTeams,
-}));
-
-vi.mock("./polls.js", () => ({
-  createMSTeamsPollStoreFs: () => ({
-    createPoll: mocks.createPoll,
-  }),
-}));
-
-import { msteamsOutbound } from "./outbound.js";
-
-describe("msteamsOutbound cfg threading", () => {
-  beforeEach(() => {
-    mocks.sendMessageMSTeams.mockReset();
-    mocks.sendPollMSTeams.mockReset();
-    mocks.createPoll.mockReset();
-    mocks.sendMessageMSTeams.mockResolvedValue({
-      messageId: "msg-1",
-      conversationId: "conv-1",
-    });
-    mocks.sendPollMSTeams.mockResolvedValue({
-      pollId: "poll-1",
-      messageId: "msg-poll-1",
-      conversationId: "conv-1",
-    });
-    mocks.createPoll.mockResolvedValue(undefined);
-  });
-
-  it("passes resolved cfg to sendMessageMSTeams for text sends", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          appId: "resolved-app-id",
-        },
-      },
-    } as OpenClawConfig;
-
-    await msteamsOutbound.sendText!({
-      cfg,
-      to: "conversation:abc",
-      text: "hello",
-    });
-
-    expect(mocks.sendMessageMSTeams).toHaveBeenCalledWith({
-      cfg,
-      to: "conversation:abc",
-      text: "hello",
-    });
-  });
-
-  it("passes resolved cfg and media roots for media sends", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          appId: "resolved-app-id",
-        },
-      },
-    } as OpenClawConfig;
-
-    await msteamsOutbound.sendMedia!({
-      cfg,
-      to: "conversation:abc",
-      text: "photo",
-      mediaUrl: "file:///tmp/photo.png",
-      mediaLocalRoots: ["/tmp"],
-    });
-
-    expect(mocks.sendMessageMSTeams).toHaveBeenCalledWith({
-      cfg,
-      to: "conversation:abc",
-      text: "photo",
-      mediaUrl: "file:///tmp/photo.png",
-      mediaLocalRoots: ["/tmp"],
-    });
-  });
-
-  it("passes resolved cfg to sendPollMSTeams and stores poll metadata", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          appId: "resolved-app-id",
-        },
-      },
-    } as OpenClawConfig;
-
-    await msteamsOutbound.sendPoll!({
-      cfg,
-      to: "conversation:abc",
-      poll: {
-        question: "Snack?",
-        options: ["Pizza", "Sushi"],
-      },
-    });
-
-    expect(mocks.sendPollMSTeams).toHaveBeenCalledWith({
-      cfg,
-      to: "conversation:abc",
-      question: "Snack?",
-      options: ["Pizza", "Sushi"],
-      maxSelections: 1,
-    });
-    expect(mocks.createPoll).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: "poll-1",
-        question: "Snack?",
-        options: ["Pizza", "Sushi"],
-      }),
-    );
-  });
-
-  it("chunks outbound text without requiring MSTeams runtime initialization", () => {
-    const chunker = msteamsOutbound.chunker;
-    if (!chunker) {
-      throw new Error("msteams outbound.chunker unavailable");
-    }
-
-    expect(chunker("alpha beta", 5)).toEqual(["alpha", "beta"]);
-  });
-});

package/src/outbound.ts

@@ -1,71 +0,0 @@
-import { createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
-import { resolveOutboundSendDep } from "openclaw/plugin-sdk/outbound-send-deps";
-import { chunkTextForOutbound, type ChannelOutboundAdapter } from "../runtime-api.js";
-import { createMSTeamsPollStoreFs } from "./polls.js";
-import { sendMessageMSTeams, sendPollMSTeams } from "./send.js";
-
-export const msteamsOutbound: ChannelOutboundAdapter = {
-  deliveryMode: "direct",
-  chunker: chunkTextForOutbound,
-  chunkerMode: "markdown",
-  textChunkLimit: 4000,
-  pollMaxOptions: 12,
-  ...createAttachedChannelResultAdapter({
-    channel: "msteams",
-    sendText: async ({ cfg, to, text, deps }) => {
-      type SendFn = (
-        to: string,
-        text: string,
-      ) => Promise<{ messageId: string; conversationId: string }>;
-      const send =
-        resolveOutboundSendDep<SendFn>(deps, "msteams") ??
-        ((to, text) => sendMessageMSTeams({ cfg, to, text }));
-      return await send(to, text);
-    },
-    sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, deps }) => {
-      type SendFn = (
-        to: string,
-        text: string,
-        opts?: {
-          mediaUrl?: string;
-          mediaLocalRoots?: readonly string[];
-          mediaReadFile?: (filePath: string) => Promise<Buffer>;
-        },
-      ) => Promise<{ messageId: string; conversationId: string }>;
-      const send =
-        resolveOutboundSendDep<SendFn>(deps, "msteams") ??
-        ((to, text, opts) =>
-          sendMessageMSTeams({
-            cfg,
-            to,
-            text,
-            mediaUrl: opts?.mediaUrl,
-            mediaLocalRoots: opts?.mediaLocalRoots,
-            mediaReadFile: opts?.mediaReadFile,
-          }));
-      return await send(to, text, { mediaUrl, mediaLocalRoots, mediaReadFile });
-    },
-    sendPoll: async ({ cfg, to, poll }) => {
-      const maxSelections = poll.maxSelections ?? 1;
-      const result = await sendPollMSTeams({
-        cfg,
-        to,
-        question: poll.question,
-        options: poll.options,
-        maxSelections,
-      });
-      const pollStore = createMSTeamsPollStoreFs();
-      await pollStore.createPoll({
-        id: result.pollId,
-        question: poll.question,
-        options: poll.options,
-        maxSelections,
-        createdAt: new Date().toISOString(),
-        conversationId: result.conversationId,
-        messageId: result.messageId,
-        votes: {},
-      });
-      return result;
-    },
-  }),
-};

package/src/pending-uploads-fs.test.ts

@@ -1,246 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { prepareFileConsentActivityFs } from "./file-consent-helpers.js";
-import {
-  getPendingUploadFs,
-  removePendingUploadFs,
-  setPendingUploadActivityIdFs,
-  storePendingUploadFs,
-} from "./pending-uploads-fs.js";
-import { clearPendingUploads } from "./pending-uploads.js";
-import { setMSTeamsRuntime } from "./runtime.js";
-import { msteamsRuntimeStub } from "./test-runtime.js";
-
-// Track temp dirs created by each test so afterEach can clean them up.
-const createdTempDirs: string[] = [];
-
-async function makeTempStateDir(): Promise<string> {
-  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "openclaw-msteams-pending-"));
-  createdTempDirs.push(dir);
-  return dir;
-}
-
-function makeEnv(stateDir: string): NodeJS.ProcessEnv {
-  return { ...process.env, OPENCLAW_STATE_DIR: stateDir };
-}
-
-async function cleanupTempDirs(): Promise<void> {
-  while (createdTempDirs.length > 0) {
-    const dir = createdTempDirs.pop();
-    if (!dir) {
-      continue;
-    }
-    try {
-      await fs.promises.rm(dir, { recursive: true, force: true });
-    } catch {
-      // tmp dir may already be gone
-    }
-  }
-}
-
-describe("msteams pending uploads (fs-backed)", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(msteamsRuntimeStub);
-    clearPendingUploads();
-  });
-
-  afterEach(async () => {
-    await cleanupTempDirs();
-  });
-
-  it("stores and retrieves a pending upload by id", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    await storePendingUploadFs(
-      {
-        id: "upload-1",
-        buffer: Buffer.from("hello world"),
-        filename: "greeting.txt",
-        contentType: "text/plain",
-        conversationId: "19:conv@thread.v2",
-      },
-      { env },
-    );
-
-    const loaded = await getPendingUploadFs("upload-1", { env });
-    expect(loaded).toBeDefined();
-    expect(loaded?.id).toBe("upload-1");
-    expect(loaded?.filename).toBe("greeting.txt");
-    expect(loaded?.contentType).toBe("text/plain");
-    expect(loaded?.conversationId).toBe("19:conv@thread.v2");
-    expect(loaded?.buffer.toString("utf8")).toBe("hello world");
-  });
-
-  it("returns undefined for missing and undefined ids", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    expect(await getPendingUploadFs(undefined, { env })).toBeUndefined();
-    expect(await getPendingUploadFs("does-not-exist", { env })).toBeUndefined();
-  });
-
-  it("persists so another reader finds the entry (simulates cross-process)", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    // First "process": writer
-    await storePendingUploadFs(
-      {
-        id: "upload-x",
-        buffer: Buffer.from("top secret"),
-        filename: "secret.bin",
-        conversationId: "19:conv@thread.v2",
-      },
-      { env },
-    );
-
-    // Confirm the backing file actually exists on disk with expected shape
-    const storePath = path.join(stateDir, "msteams-pending-uploads.json");
-    const raw = await fs.promises.readFile(storePath, "utf-8");
-    const parsed = JSON.parse(raw) as {
-      version: number;
-      uploads: Record<string, { bufferBase64: string; filename: string }>;
-    };
-    expect(parsed.version).toBe(1);
-    expect(parsed.uploads["upload-x"]?.filename).toBe("secret.bin");
-    expect(Buffer.from(parsed.uploads["upload-x"].bufferBase64, "base64").toString("utf8")).toBe(
-      "top secret",
-    );
-
-    // Second "process": reader using the same state dir
-    const reader = await getPendingUploadFs("upload-x", { env });
-    expect(reader?.buffer.toString("utf8")).toBe("top secret");
-    expect(reader?.filename).toBe("secret.bin");
-  });
-
-  it("removes persisted entries", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    await storePendingUploadFs(
-      {
-        id: "upload-rm",
-        buffer: Buffer.from("x"),
-        filename: "rm.bin",
-        conversationId: "19:conv@thread.v2",
-      },
-      { env },
-    );
-    expect(await getPendingUploadFs("upload-rm", { env })).toBeDefined();
-
-    await removePendingUploadFs("upload-rm", { env });
-    expect(await getPendingUploadFs("upload-rm", { env })).toBeUndefined();
-  });
-
-  it("remove is a no-op for unknown ids", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    await expect(removePendingUploadFs("never-existed", { env })).resolves.toBeUndefined();
-    await expect(removePendingUploadFs(undefined, { env })).resolves.toBeUndefined();
-  });
-
-  it("expires entries past their ttl on read", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    await storePendingUploadFs(
-      {
-        id: "upload-old",
-        buffer: Buffer.from("stale"),
-        filename: "stale.txt",
-        conversationId: "19:conv@thread.v2",
-      },
-      { env, ttlMs: 1 },
-    );
-    // Wait past ttl
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(await getPendingUploadFs("upload-old", { env, ttlMs: 1 })).toBeUndefined();
-  });
-
-  it("updates consent card activity id on an existing entry", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-
-    await storePendingUploadFs(
-      {
-        id: "upload-a",
-        buffer: Buffer.from("payload"),
-        filename: "f.txt",
-        conversationId: "19:conv@thread.v2",
-      },
-      { env },
-    );
-
-    await setPendingUploadActivityIdFs("upload-a", "activity-xyz", { env });
-    const loaded = await getPendingUploadFs("upload-a", { env });
-    expect(loaded?.consentCardActivityId).toBe("activity-xyz");
-  });
-
-  it("ignores malformed or empty store files and returns undefined", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-    const storePath = path.join(stateDir, "msteams-pending-uploads.json");
-    await fs.promises.writeFile(storePath, "not valid json", "utf-8");
-
-    // Should not throw and should treat as empty
-    expect(await getPendingUploadFs("anything", { env })).toBeUndefined();
-
-    await fs.promises.writeFile(storePath, JSON.stringify({ version: 2, uploads: {} }), "utf-8");
-    expect(await getPendingUploadFs("anything", { env })).toBeUndefined();
-  });
-});
-
-describe("prepareFileConsentActivityFs end-to-end", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(msteamsRuntimeStub);
-    clearPendingUploads();
-  });
-
-  afterEach(async () => {
-    await cleanupTempDirs();
-  });
-
-  it("writes the pending upload to the fs store with the same id as the card", async () => {
-    const stateDir = await makeTempStateDir();
-    const env = makeEnv(stateDir);
-    // Redirect state dir via env so the helper's FS writes land under our tmp
-    const originalEnv = process.env.OPENCLAW_STATE_DIR;
-    process.env.OPENCLAW_STATE_DIR = stateDir;
-
-    try {
-      const result = await prepareFileConsentActivityFs({
-        media: {
-          buffer: Buffer.from("cli file"),
-          filename: "cli.bin",
-          contentType: "application/octet-stream",
-        },
-        conversationId: "19:victim@thread.v2",
-        description: "Sent via CLI",
-      });
-
-      expect(result.uploadId).toMatch(/[0-9a-f-]/);
-      const attachments = result.activity.attachments as Array<Record<string, unknown>>;
-      expect(attachments).toHaveLength(1);
-      const content = attachments[0]?.content as { acceptContext: { uploadId: string } };
-      expect(content.acceptContext.uploadId).toBe(result.uploadId);
-
-      // Reader in (simulated) other process finds the entry under the same key
-      const loaded = await getPendingUploadFs(result.uploadId, { env });
-      expect(loaded).toBeDefined();
-      expect(loaded?.filename).toBe("cli.bin");
-      expect(loaded?.contentType).toBe("application/octet-stream");
-      expect(loaded?.conversationId).toBe("19:victim@thread.v2");
-      expect(loaded?.buffer.toString("utf8")).toBe("cli file");
-    } finally {
-      if (originalEnv === undefined) {
-        delete process.env.OPENCLAW_STATE_DIR;
-      } else {
-        process.env.OPENCLAW_STATE_DIR = originalEnv;
-      }
-    }
-  });
-});

package/src/pending-uploads-fs.ts

@@ -1,235 +0,0 @@
-/**
- * Filesystem-backed pending upload store for the FileConsentCard flow.
- *
- * The CLI `message send --media` path runs in a different process from the
- * gateway's bot monitor that receives the `fileConsent/invoke` callback.
- * An in-memory `pending-uploads.ts` store cannot bridge those processes, so
- * when the user clicks "Allow" the monitor handler's lookup misses and the
- * user sees "card action not supported".
- *
- * This FS store persists pending uploads to a JSON file (with the file buffer
- * base64-encoded) so any process that shares the OpenClaw state dir can read
- * them back. The in-memory store in `pending-uploads.ts` is still the fast
- * path for same-process flows (for example the messenger reply path); this FS
- * store is a cross-process fallback.
- */
-
-import { resolveMSTeamsStorePath } from "./storage.js";
-import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
-
-/** TTL for persisted pending uploads (matches in-memory store). */
-const PENDING_UPLOAD_TTL_MS = 5 * 60 * 1000;
-
-/** Cap to avoid unbounded growth if a process crashes mid-flow. */
-const MAX_PENDING_UPLOADS = 100;
-
-const STORE_FILENAME = "msteams-pending-uploads.json";
-
-type PendingUploadFsRecord = {
-  id: string;
-  bufferBase64: string;
-  filename: string;
-  contentType?: string;
-  conversationId: string;
-  /** Activity ID of the original FileConsentCard, used to replace it after upload */
-  consentCardActivityId?: string;
-  createdAt: number;
-};
-
-type PendingUploadFs = {
-  id: string;
-  buffer: Buffer;
-  filename: string;
-  contentType?: string;
-  conversationId: string;
-  consentCardActivityId?: string;
-  createdAt: number;
-};
-
-type PendingUploadStoreData = {
-  version: 1;
-  uploads: Record<string, PendingUploadFsRecord>;
-};
-
-const empty: PendingUploadStoreData = { version: 1, uploads: {} };
-
-type PendingUploadsFsOptions = {
-  env?: NodeJS.ProcessEnv;
-  homedir?: () => string;
-  stateDir?: string;
-  storePath?: string;
-  ttlMs?: number;
-};
-
-function resolveFilePath(options: PendingUploadsFsOptions | undefined): string {
-  return resolveMSTeamsStorePath({
-    filename: STORE_FILENAME,
-    env: options?.env,
-    homedir: options?.homedir,
-    stateDir: options?.stateDir,
-    storePath: options?.storePath,
-  });
-}
-
-function pruneExpired(
-  uploads: Record<string, PendingUploadFsRecord>,
-  nowMs: number,
-  ttlMs: number,
-): Record<string, PendingUploadFsRecord> {
-  const kept: Record<string, PendingUploadFsRecord> = {};
-  for (const [id, record] of Object.entries(uploads)) {
-    if (nowMs - record.createdAt <= ttlMs) {
-      kept[id] = record;
-    }
-  }
-  return kept;
-}
-
-function pruneToLimit(
-  uploads: Record<string, PendingUploadFsRecord>,
-): Record<string, PendingUploadFsRecord> {
-  const entries = Object.entries(uploads);
-  if (entries.length <= MAX_PENDING_UPLOADS) {
-    return uploads;
-  }
-  // Oldest createdAt first; drop the oldest until we fit.
-  entries.sort((a, b) => a[1].createdAt - b[1].createdAt);
-  const keep = entries.slice(entries.length - MAX_PENDING_UPLOADS);
-  return Object.fromEntries(keep);
-}
-
-function recordToUpload(record: PendingUploadFsRecord): PendingUploadFs {
-  return {
-    id: record.id,
-    buffer: Buffer.from(record.bufferBase64, "base64"),
-    filename: record.filename,
-    contentType: record.contentType,
-    conversationId: record.conversationId,
-    consentCardActivityId: record.consentCardActivityId,
-    createdAt: record.createdAt,
-  };
-}
-
-function isValidStore(value: unknown): value is PendingUploadStoreData {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value as Partial<PendingUploadStoreData>;
-  return (
-    candidate.version === 1 &&
-    typeof candidate.uploads === "object" &&
-    candidate.uploads !== null &&
-    !Array.isArray(candidate.uploads)
-  );
-}
-
-async function readStore(filePath: string, ttlMs: number): Promise<PendingUploadStoreData> {
-  const { value } = await readJsonFile<unknown>(filePath, empty);
-  if (!isValidStore(value)) {
-    return { version: 1, uploads: {} };
-  }
-  const uploads = pruneToLimit(pruneExpired(value.uploads, Date.now(), ttlMs));
-  return { version: 1, uploads };
-}
-
-/**
- * Persist a pending upload record so another process can read it back.
- * Pass in the pre-generated id (same as the one placed in the consent card
- * context) so the in-memory and FS stores share the same key.
- */
-export async function storePendingUploadFs(
-  upload: {
-    id: string;
-    buffer: Buffer;
-    filename: string;
-    contentType?: string;
-    conversationId: string;
-    consentCardActivityId?: string;
-  },
-  options?: PendingUploadsFsOptions,
-): Promise<void> {
-  const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS;
-  const filePath = resolveFilePath(options);
-  await withFileLock(filePath, empty, async () => {
-    const store = await readStore(filePath, ttlMs);
-    store.uploads[upload.id] = {
-      id: upload.id,
-      bufferBase64: upload.buffer.toString("base64"),
-      filename: upload.filename,
-      contentType: upload.contentType,
-      conversationId: upload.conversationId,
-      consentCardActivityId: upload.consentCardActivityId,
-      createdAt: Date.now(),
-    };
-    store.uploads = pruneToLimit(pruneExpired(store.uploads, Date.now(), ttlMs));
-    await writeJsonFile(filePath, store);
-  });
-}
-
-/**
- * Retrieve a persisted pending upload. Expired entries are treated as absent.
- */
-export async function getPendingUploadFs(
-  id: string | undefined,
-  options?: PendingUploadsFsOptions,
-): Promise<PendingUploadFs | undefined> {
-  if (!id) {
-    return undefined;
-  }
-  const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS;
-  const filePath = resolveFilePath(options);
-  const store = await readStore(filePath, ttlMs);
-  const record = store.uploads[id];
-  if (!record) {
-    return undefined;
-  }
-  if (Date.now() - record.createdAt > ttlMs) {
-    return undefined;
-  }
-  return recordToUpload(record);
-}
-
-/**
- * Remove a persisted pending upload (after successful upload or decline).
- * No-op if the entry is already gone.
- */
-export async function removePendingUploadFs(
-  id: string | undefined,
-  options?: PendingUploadsFsOptions,
-): Promise<void> {
-  if (!id) {
-    return;
-  }
-  const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS;
-  const filePath = resolveFilePath(options);
-  await withFileLock(filePath, empty, async () => {
-    const store = await readStore(filePath, ttlMs);
-    if (!(id in store.uploads)) {
-      return;
-    }
-    delete store.uploads[id];
-    await writeJsonFile(filePath, store);
-  });
-}
-
-/**
- * Set the consent card activity ID on a persisted entry. Called after the
- * FileConsentCard activity is sent and we know its message id.
- */
-export async function setPendingUploadActivityIdFs(
-  id: string,
-  activityId: string,
-  options?: PendingUploadsFsOptions,
-): Promise<void> {
-  const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS;
-  const filePath = resolveFilePath(options);
-  await withFileLock(filePath, empty, async () => {
-    const store = await readStore(filePath, ttlMs);
-    const record = store.uploads[id];
-    if (!record) {
-      return;
-    }
-    record.consentCardActivityId = activityId;
-    await writeJsonFile(filePath, store);
-  });
-}