@openclaw/msteams 2026.5.2 → 2026.5.3-beta.2

package/src/polls.ts

@@ -1,323 +0,0 @@
-import crypto from "node:crypto";
-import { resolveMSTeamsStorePath } from "./storage.js";
-import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
-
-type MSTeamsPollVote = {
-  pollId: string;
-  selections: string[];
-};
-
-export type MSTeamsPoll = {
-  id: string;
-  question: string;
-  options: string[];
-  maxSelections: number;
-  createdAt: string;
-  updatedAt?: string;
-  conversationId?: string;
-  messageId?: string;
-  votes: Record<string, string[]>;
-};
-
-export type MSTeamsPollStore = {
-  createPoll: (poll: MSTeamsPoll) => Promise<void>;
-  getPoll: (pollId: string) => Promise<MSTeamsPoll | null>;
-  recordVote: (params: {
-    pollId: string;
-    voterId: string;
-    selections: string[];
-  }) => Promise<MSTeamsPoll | null>;
-};
-
-type MSTeamsPollCard = {
-  pollId: string;
-  question: string;
-  options: string[];
-  maxSelections: number;
-  card: Record<string, unknown>;
-  fallbackText: string;
-};
-
-type PollStoreData = {
-  version: 1;
-  polls: Record<string, MSTeamsPoll>;
-};
-
-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 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 {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    return trimmed ? trimmed : null;
-  }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
-  }
-  return null;
-}
-
-function extractSelections(value: unknown): string[] {
-  if (Array.isArray(value)) {
-    return value.map(normalizeChoiceValue).filter((entry): entry is string => Boolean(entry));
-  }
-  const normalized = normalizeChoiceValue(value);
-  if (!normalized) {
-    return [];
-  }
-  if (normalized.includes(",")) {
-    return normalized
-      .split(",")
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  }
-  return [normalized];
-}
-
-function readNestedValue(value: unknown, keys: Array<string | number>): unknown {
-  let current: unknown = value;
-  for (const key of keys) {
-    if (!isRecord(current)) {
-      return undefined;
-    }
-    current = current[key as keyof typeof current];
-  }
-  return current;
-}
-
-function readNestedString(value: unknown, keys: Array<string | number>): string | undefined {
-  return normalizeOptionalString(readNestedValue(value, keys));
-}
-
-export function extractMSTeamsPollVote(
-  activity: { value?: unknown } | undefined,
-): MSTeamsPollVote | null {
-  const value = activity?.value;
-  if (!value || !isRecord(value)) {
-    return null;
-  }
-  const pollId =
-    readNestedString(value, ["openclawPollId"]) ??
-    readNestedString(value, ["pollId"]) ??
-    readNestedString(value, ["openclaw", "pollId"]) ??
-    readNestedString(value, ["openclaw", "poll", "id"]) ??
-    readNestedString(value, ["data", "openclawPollId"]) ??
-    readNestedString(value, ["data", "pollId"]) ??
-    readNestedString(value, ["data", "openclaw", "pollId"]);
-  if (!pollId) {
-    return null;
-  }
-
-  const directSelections = extractSelections(value.choices);
-  const nestedSelections = extractSelections(readNestedValue(value, ["choices"]));
-  const dataSelections = extractSelections(readNestedValue(value, ["data", "choices"]));
-  const selections =
-    directSelections.length > 0
-      ? directSelections
-      : nestedSelections.length > 0
-        ? nestedSelections
-        : dataSelections;
-
-  if (selections.length === 0) {
-    return null;
-  }
-
-  return {
-    pollId,
-    selections,
-  };
-}
-
-export function buildMSTeamsPollCard(params: {
-  question: string;
-  options: string[];
-  maxSelections?: number;
-  pollId?: string;
-}): MSTeamsPollCard {
-  const pollId = params.pollId ?? crypto.randomUUID();
-  const maxSelections =
-    typeof params.maxSelections === "number" && params.maxSelections > 1
-      ? Math.floor(params.maxSelections)
-      : 1;
-  const cappedMaxSelections = Math.min(Math.max(1, maxSelections), params.options.length);
-  const choices = params.options.map((option, index) => ({
-    title: option,
-    value: String(index),
-  }));
-  const hint =
-    cappedMaxSelections > 1
-      ? `Select up to ${cappedMaxSelections} option${cappedMaxSelections === 1 ? "" : "s"}.`
-      : "Select one option.";
-
-  const card = {
-    type: "AdaptiveCard",
-    version: "1.5",
-    body: [
-      {
-        type: "TextBlock",
-        text: params.question,
-        wrap: true,
-        weight: "Bolder",
-        size: "Medium",
-      },
-      {
-        type: "Input.ChoiceSet",
-        id: "choices",
-        isMultiSelect: cappedMaxSelections > 1,
-        style: "expanded",
-        choices,
-      },
-      {
-        type: "TextBlock",
-        text: hint,
-        wrap: true,
-        isSubtle: true,
-        spacing: "Small",
-      },
-    ],
-    actions: [
-      {
-        type: "Action.Submit",
-        title: "Vote",
-        data: {
-          openclawPollId: pollId,
-          pollId,
-        },
-        msteams: {
-          type: "messageBack",
-          text: "openclaw poll vote",
-          displayText: "Vote recorded",
-          value: { openclawPollId: pollId, pollId },
-        },
-      },
-    ],
-  };
-
-  const fallbackLines = [
-    `Poll: ${params.question}`,
-    ...params.options.map((option, index) => `${index + 1}. ${option}`),
-  ];
-
-  return {
-    pollId,
-    question: params.question,
-    options: params.options,
-    maxSelections: cappedMaxSelections,
-    card,
-    fallbackText: fallbackLines.join("\n"),
-  };
-}
-
-type MSTeamsPollStoreFsOptions = {
-  env?: NodeJS.ProcessEnv;
-  homedir?: () => string;
-  stateDir?: string;
-  storePath?: string;
-};
-
-function parseTimestamp(value?: string): number | null {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function pruneExpired(polls: Record<string, MSTeamsPoll>) {
-  const cutoff = Date.now() - POLL_TTL_MS;
-  const entries = Object.entries(polls).filter(([, poll]) => {
-    const ts = parseTimestamp(poll.updatedAt ?? poll.createdAt) ?? 0;
-    return ts >= cutoff;
-  });
-  return Object.fromEntries(entries);
-}
-
-function pruneToLimit(polls: Record<string, MSTeamsPoll>) {
-  const entries = Object.entries(polls);
-  if (entries.length <= MAX_POLLS) {
-    return polls;
-  }
-  entries.sort((a, b) => {
-    const aTs = parseTimestamp(a[1].updatedAt ?? a[1].createdAt) ?? 0;
-    const bTs = parseTimestamp(b[1].updatedAt ?? b[1].createdAt) ?? 0;
-    return aTs - bTs;
-  });
-  const keep = entries.slice(entries.length - MAX_POLLS);
-  return Object.fromEntries(keep);
-}
-
-export function normalizeMSTeamsPollSelections(poll: MSTeamsPoll, selections: string[]) {
-  const maxSelections = Math.max(1, poll.maxSelections);
-  const mapped = selections
-    .map((entry) => Number.parseInt(entry, 10))
-    .filter((value) => Number.isFinite(value))
-    .filter((value) => value >= 0 && value < poll.options.length)
-    .map((value) => String(value));
-  const limited = maxSelections > 1 ? mapped.slice(0, maxSelections) : mapped.slice(0, 1);
-  return Array.from(new Set(limited));
-}
-
-export function createMSTeamsPollStoreFs(params?: MSTeamsPollStoreFsOptions): MSTeamsPollStore {
-  const filePath = resolveMSTeamsStorePath({
-    filename: STORE_FILENAME,
-    env: params?.env,
-    homedir: params?.homedir,
-    stateDir: params?.stateDir,
-    storePath: params?.storePath,
-  });
-  const empty: PollStoreData = { version: 1, polls: {} };
-
-  const readStore = async (): Promise<PollStoreData> => {
-    const { value } = await readJsonFile(filePath, empty);
-    const pruned = pruneToLimit(pruneExpired(value.polls ?? {}));
-    return { version: 1, polls: pruned };
-  };
-
-  const writeStore = async (data: PollStoreData) => {
-    await writeJsonFile(filePath, data);
-  };
-
-  const createPoll = async (poll: MSTeamsPoll) => {
-    await withFileLock(filePath, empty, async () => {
-      const data = await readStore();
-      data.polls[poll.id] = poll;
-      await writeStore({ version: 1, polls: pruneToLimit(data.polls) });
-    });
-  };
-
-  const getPoll = async (pollId: string) =>
-    await withFileLock(filePath, empty, async () => {
-      const data = await readStore();
-      return data.polls[pollId] ?? null;
-    });
-
-  const recordVote = async (params: { pollId: string; voterId: string; selections: string[] }) =>
-    await withFileLock(filePath, empty, async () => {
-      const data = await readStore();
-      const poll = data.polls[params.pollId];
-      if (!poll) {
-        return null;
-      }
-      const normalized = normalizeMSTeamsPollSelections(poll, params.selections);
-      poll.votes[params.voterId] = normalized;
-      poll.updatedAt = new Date().toISOString();
-      data.polls[poll.id] = poll;
-      await writeStore({ version: 1, polls: pruneToLimit(data.polls) });
-      return poll;
-    });
-
-  return { createPoll, getPoll, recordVote };
-}

package/src/presentation.ts

@@ -1,68 +0,0 @@
-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,77 +0,0 @@
-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/teams.apps", () => ({
-  App: class {
-    protected async getBotToken() {
-      if (hostMockState.tokenError) {
-        throw hostMockState.tokenError;
-      }
-      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({
-      ok: false,
-    });
-  });
-
-  it("validates credentials by acquiring a token", async () => {
-    const cfg = {
-      enabled: true,
-      appId: "app",
-      appPassword: "pw",
-      tenantId: "tenant",
-    } as unknown as MSTeamsConfig;
-    await expect(probeMSTeams(cfg)).resolves.toMatchObject({
-      ok: true,
-      appId: "app",
-    });
-  });
-
-  it("returns a helpful error when token acquisition fails", async () => {
-    hostMockState.tokenError = new Error("bad creds");
-    const cfg = {
-      enabled: true,
-      appId: "app",
-      appPassword: "pw",
-      tenantId: "tenant",
-    } as unknown as MSTeamsConfig;
-    await expect(probeMSTeams(cfg)).resolves.toMatchObject({
-      ok: false,
-      appId: "app",
-      error: "bad creds",
-    });
-  });
-});

package/src/probe.ts

@@ -1,132 +0,0 @@
-import {
-  normalizeStringEntries,
-  type BaseProbeResult,
-  type MSTeamsConfig,
-} from "../runtime-api.js";
-import { formatUnknownError } from "./errors.js";
-import { createMSTeamsTokenProvider, loadMSTeamsSdkWithAuth } from "./sdk.js";
-import { readAccessToken } from "./token-response.js";
-import { loadDelegatedTokens, resolveMSTeamsCredentials } from "./token.js";
-
-export type ProbeMSTeamsResult = BaseProbeResult<string> & {
-  appId?: string;
-  graph?: {
-    ok: boolean;
-    error?: string;
-    roles?: string[];
-    scopes?: string[];
-  };
-  delegatedAuth?: {
-    ok: boolean;
-    error?: string;
-    scopes?: string[];
-    userPrincipalName?: string;
-  };
-};
-
-function decodeJwtPayload(token: string): Record<string, unknown> | null {
-  const parts = token.split(".");
-  if (parts.length < 2) {
-    return null;
-  }
-  const payload = parts[1] ?? "";
-  const padded = payload.padEnd(payload.length + ((4 - (payload.length % 4)) % 4), "=");
-  const normalized = padded.replace(/-/g, "+").replace(/_/g, "/");
-  try {
-    const decoded = Buffer.from(normalized, "base64").toString("utf8");
-    const parsed = JSON.parse(decoded) as Record<string, unknown>;
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function readStringArray(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  const out = normalizeStringEntries(value);
-  return out.length > 0 ? out : undefined;
-}
-
-function readScopes(value: unknown): string[] | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const out = value
-    .split(/\s+/)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-  return out.length > 0 ? out : undefined;
-}
-
-export async function probeMSTeams(cfg?: MSTeamsConfig): Promise<ProbeMSTeamsResult> {
-  const creds = resolveMSTeamsCredentials(cfg);
-  if (!creds) {
-    return {
-      ok: false,
-      error: "missing credentials (appId, appPassword, tenantId)",
-    };
-  }
-
-  try {
-    const { app } = await loadMSTeamsSdkWithAuth(creds);
-    const tokenProvider = createMSTeamsTokenProvider(app);
-    const botTokenValue = await tokenProvider.getAccessToken("https://api.botframework.com");
-    if (!botTokenValue) {
-      throw new Error("Failed to acquire bot token");
-    }
-
-    let graph:
-      | {
-          ok: boolean;
-          error?: string;
-          roles?: string[];
-          scopes?: string[];
-        }
-      | undefined;
-    try {
-      const graphTokenValue = await tokenProvider.getAccessToken("https://graph.microsoft.com");
-      const accessToken = readAccessToken(graphTokenValue);
-      const payload = accessToken ? decodeJwtPayload(accessToken) : null;
-      graph = {
-        ok: true,
-        roles: readStringArray(payload?.roles),
-        scopes: readScopes(payload?.scp),
-      };
-    } catch (err) {
-      graph = { ok: false, error: formatUnknownError(err) };
-    }
-    let delegatedAuth: ProbeMSTeamsResult["delegatedAuth"];
-    if (cfg?.delegatedAuth?.enabled) {
-      try {
-        const tokens = loadDelegatedTokens();
-        if (tokens) {
-          const isExpired = tokens.expiresAt <= Date.now();
-          delegatedAuth = {
-            ok: !isExpired,
-            scopes: tokens.scopes,
-            userPrincipalName: tokens.userPrincipalName,
-            ...(isExpired ? { error: "token expired (will auto-refresh on next use)" } : {}),
-          };
-        } else {
-          delegatedAuth = { ok: false, error: "no delegated tokens found (run setup wizard)" };
-        }
-      } catch {
-        delegatedAuth = { ok: false, error: "failed to load delegated tokens" };
-      }
-    }
-    return {
-      ok: true,
-      appId: creds.appId,
-      ...(graph ? { graph } : {}),
-      ...(delegatedAuth ? { delegatedAuth } : {}),
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      appId: creds.appId,
-      error: formatUnknownError(err),
-    };
-  }
-}