@gakr-gakr/msteams 0.1.0

package/src/polls.ts

@@ -0,0 +1,312 @@
+import crypto from "node:crypto";
+import { isRecord, normalizeOptionalString } from "autobot/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, ["autobotPollId"]) ??
+    readNestedString(value, ["pollId"]) ??
+    readNestedString(value, ["autobot", "pollId"]) ??
+    readNestedString(value, ["autobot", "poll", "id"]) ??
+    readNestedString(value, ["data", "autobotPollId"]) ??
+    readNestedString(value, ["data", "pollId"]) ??
+    readNestedString(value, ["data", "autobot", "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: {
+          autobotPollId: pollId,
+          pollId,
+        },
+        msteams: {
+          type: "messageBack",
+          text: "autobot poll vote",
+          displayText: "Vote recorded",
+          value: { autobotPollId: 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

@@ -0,0 +1,93 @@
+import {
+  adaptMessagePresentationForChannel,
+  type MessagePresentation,
+} from "autobot/plugin-sdk/interactive-runtime";
+import { normalizeOptionalString } from "autobot/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.ts

@@ -0,0 +1,132 @@
+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),
+    };
+  }
+}