@kodelyth/msteams 2026.5.42 → 2026.6.2

package/src/polls.test.ts

@@ -1,169 +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: {
-        klawPollId: "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(), "klaw-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(), "klaw-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({
-      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",
-    });
-
-    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",
-    });
-
-    const updatedPoll = await store.recordVote({
-      pollId: "poll-2",
-      voterId: "user-2",
-      selections: ["1", "0", "1"],
-    });
-    if (!updatedPoll?.updatedAt) {
-      throw new Error("expected updated poll timestamp after recordVote");
-    }
-    const { updatedAt, ...stableUpdatedPoll } = updatedPoll;
-    expect(typeof updatedAt).toBe("string");
-    expect(stableUpdatedPoll).toEqual({
-      id: "poll-2",
-      question: "Pick many",
-      options: ["X", "Y"],
-      maxSelections: 2,
-      votes: {
-        "user-2": ["1", "0"],
-      },
-      createdAt: "2026-03-22T00:00:00.000Z",
-    });
-
-    await expect(
-      store.recordVote({ pollId: "missing", voterId: "nobody", selections: ["x"] }),
-    ).resolves.toBeNull();
-  });
-});

package/src/polls.ts

@@ -1,312 +0,0 @@
-import crypto from "node:crypto";
-import { isRecord, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-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 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, ["klawPollId"]) ??
-    readNestedString(value, ["pollId"]) ??
-    readNestedString(value, ["klaw", "pollId"]) ??
-    readNestedString(value, ["klaw", "poll", "id"]) ??
-    readNestedString(value, ["data", "klawPollId"]) ??
-    readNestedString(value, ["data", "pollId"]) ??
-    readNestedString(value, ["data", "klaw", "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: {
-          klawPollId: pollId,
-          pollId,
-        },
-        msteams: {
-          type: "messageBack",
-          text: "klaw poll vote",
-          displayText: "Vote recorded",
-          value: { klawPollId: 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,93 +0,0 @@
-import {
-  adaptMessagePresentationForChannel,
-  type MessagePresentation,
-} from "klaw/plugin-sdk/interactive-runtime";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { ChannelOutboundAdapter } from "../runtime-api.js";
-
-export const MSTEAMS_PRESENTATION_CAPABILITIES = {
-  supported: true,
-  buttons: true,
-  selects: false,
-  context: true,
-  divider: true,
-  limits: {
-    actions: {
-      supportsStyles: false,
-      supportsDisabled: false,
-    },
-    text: {
-      markdownDialect: "markdown",
-    },
-  },
-} satisfies ChannelOutboundAdapter["presentationCapabilities"];
-
-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 = adaptMessagePresentationForChannel({
-    presentation: params.presentation,
-    capabilities: MSTEAMS_PRESENTATION_CAPABILITIES,
-  });
-  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) {
-        const targetUrl = button.url ?? button.webApp?.url ?? button.web_app?.url;
-        if (targetUrl) {
-          actions.push({
-            type: "Action.OpenUrl",
-            title: button.label,
-            url: targetUrl,
-          });
-          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,79 +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.toEqual({
-      ok: false,
-      error: "missing credentials (appId, appPassword, tenantId)",
-    });
-  });
-
-  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.toEqual({
-      ok: true,
-      appId: "app",
-      graph: { ok: true, roles: undefined, scopes: undefined },
-    });
-  });
-
-  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.toEqual({
-      ok: false,
-      appId: "app",
-      error: "bad creds",
-    });
-  });
-});