loudmouth-ai 0.1.0 → 0.2.0

package/extensions/msteams/src/polls.ts

@@ -1,299 +0,0 @@
-import crypto from "node:crypto";
-
-import { resolveMSTeamsStorePath } from "./storage.js";
-import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
-
-export 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>;
-};
-
-export 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 Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-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 {
-  const found = readNestedValue(value, keys);
-  return typeof found === "string" && found.trim() ? found.trim() : undefined;
-}
-
-export function extractMSTeamsPollVote(
-  activity: { value?: unknown } | undefined,
-): MSTeamsPollVote | null {
-  const value = activity?.value;
-  if (!value || !isRecord(value)) return null;
-  const pollId =
-    readNestedString(value, ["clawdbotPollId"]) ??
-    readNestedString(value, ["pollId"]) ??
-    readNestedString(value, ["clawdbot", "pollId"]) ??
-    readNestedString(value, ["clawdbot", "poll", "id"]) ??
-    readNestedString(value, ["data", "clawdbotPollId"]) ??
-    readNestedString(value, ["data", "pollId"]) ??
-    readNestedString(value, ["data", "clawdbot", "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: {
-          clawdbotPollId: pollId,
-        },
-        msteams: {
-          type: "messageBack",
-          text: "clawdbot poll vote",
-          displayText: "Vote recorded",
-          value: { clawdbotPollId: 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"),
-  };
-}
-
-export 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<PollStoreData>(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/extensions/msteams/src/probe.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import type { MSTeamsConfig } from "clawdbot/plugin-sdk";
-
-const hostMockState = vi.hoisted(() => ({
-  tokenError: null as Error | null,
-}));
-
-vi.mock("@microsoft/agents-hosting", () => ({
-  getAuthConfigWithDefaults: (cfg: unknown) => cfg,
-  MsalTokenProvider: class {
-    async getAccessToken() {
-      if (hostMockState.tokenError) throw hostMockState.tokenError;
-      return "token";
-    }
-  },
-}));
-
-import { probeMSTeams } from "./probe.js";
-
-describe("msteams probe", () => {
-  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 () => {
-    hostMockState.tokenError = null;
-    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/extensions/msteams/src/probe.ts

@@ -1,99 +0,0 @@
-import type { MSTeamsConfig } from "clawdbot/plugin-sdk";
-import { formatUnknownError } from "./errors.js";
-import { loadMSTeamsSdkWithAuth } from "./sdk.js";
-import { resolveMSTeamsCredentials } from "./token.js";
-
-export type ProbeMSTeamsResult = {
-  ok: boolean;
-  error?: string;
-  appId?: string;
-  graph?: {
-    ok: boolean;
-    error?: string;
-    roles?: string[];
-    scopes?: string[];
-  };
-};
-
-function readAccessToken(value: unknown): string | null {
-  if (typeof value === "string") return value;
-  if (value && typeof value === "object") {
-    const token =
-      (value as { accessToken?: unknown }).accessToken ??
-      (value as { token?: unknown }).token;
-    return typeof token === "string" ? token : null;
-  }
-  return null;
-}
-
-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 = value.map((entry) => String(entry).trim()).filter(Boolean);
-  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 { sdk, authConfig } = await loadMSTeamsSdkWithAuth(creds);
-    const tokenProvider = new sdk.MsalTokenProvider(authConfig);
-    await tokenProvider.getAccessToken("https://api.botframework.com");
-    let graph:
-      | {
-          ok: boolean;
-          error?: string;
-          roles?: string[];
-          scopes?: string[];
-        }
-      | undefined;
-    try {
-      const graphToken = await tokenProvider.getAccessToken(
-        "https://graph.microsoft.com",
-      );
-      const accessToken = readAccessToken(graphToken);
-      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) };
-    }
-    return { ok: true, appId: creds.appId, ...(graph ? { graph } : {}) };
-  } catch (err) {
-    return {
-      ok: false,
-      appId: creds.appId,
-      error: formatUnknownError(err),
-    };
-  }
-}

package/extensions/msteams/src/reply-dispatcher.ts

@@ -1,128 +0,0 @@
-import {
-  createReplyPrefixContext,
-  createTypingCallbacks,
-  logTypingFailure,
-  resolveChannelMediaMaxBytes,
-  type ClawdbotConfig,
-  type MSTeamsReplyStyle,
-  type RuntimeEnv,
-} from "clawdbot/plugin-sdk";
-import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";
-import type { StoredConversationReference } from "./conversation-store.js";
-import {
-  classifyMSTeamsSendError,
-  formatMSTeamsSendErrorHint,
-  formatUnknownError,
-} from "./errors.js";
-import {
-  type MSTeamsAdapter,
-  renderReplyPayloadsToMessages,
-  sendMSTeamsMessages,
-} from "./messenger.js";
-import type { MSTeamsMonitorLogger } from "./monitor-types.js";
-import type { MSTeamsTurnContext } from "./sdk-types.js";
-import { getMSTeamsRuntime } from "./runtime.js";
-
-export function createMSTeamsReplyDispatcher(params: {
-  cfg: ClawdbotConfig;
-  agentId: string;
-  runtime: RuntimeEnv;
-  log: MSTeamsMonitorLogger;
-  adapter: MSTeamsAdapter;
-  appId: string;
-  conversationRef: StoredConversationReference;
-  context: MSTeamsTurnContext;
-  replyStyle: MSTeamsReplyStyle;
-  textLimit: number;
-  onSentMessageIds?: (ids: string[]) => void;
-  /** Token provider for OneDrive/SharePoint uploads in group chats/channels */
-  tokenProvider?: MSTeamsAccessTokenProvider;
-  /** SharePoint site ID for file uploads in group chats/channels */
-  sharePointSiteId?: string;
-}) {
-  const core = getMSTeamsRuntime();
-  const sendTypingIndicator = async () => {
-    await params.context.sendActivities([{ type: "typing" }]);
-  };
-  const typingCallbacks = createTypingCallbacks({
-    start: sendTypingIndicator,
-    onStartError: (err) => {
-      logTypingFailure({
-        log: (message) => params.log.debug(message),
-        channel: "msteams",
-        action: "start",
-        error: err,
-      });
-    },
-  });
-  const prefixContext = createReplyPrefixContext({
-    cfg: params.cfg,
-    agentId: params.agentId,
-  });
-  const chunkMode = core.channel.text.resolveChunkMode(params.cfg, "msteams");
-
-  const { dispatcher, replyOptions, markDispatchIdle } =
-    core.channel.reply.createReplyDispatcherWithTyping({
-      responsePrefix: prefixContext.responsePrefix,
-      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-      humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
-      deliver: async (payload) => {
-        const tableMode = core.channel.text.resolveMarkdownTableMode({
-          cfg: params.cfg,
-          channel: "msteams",
-      });
-      const messages = renderReplyPayloadsToMessages([payload], {
-        textChunkLimit: params.textLimit,
-        chunkText: true,
-        mediaMode: "split",
-        tableMode,
-        chunkMode,
-      });
-      const mediaMaxBytes = resolveChannelMediaMaxBytes({
-        cfg: params.cfg,
-        resolveChannelLimitMb: ({ cfg }) => cfg.channels?.msteams?.mediaMaxMb,
-      });
-      const ids = await sendMSTeamsMessages({
-        replyStyle: params.replyStyle,
-        adapter: params.adapter,
-        appId: params.appId,
-        conversationRef: params.conversationRef,
-        context: params.context,
-        messages,
-        // Enable default retry/backoff for throttling/transient failures.
-        retry: {},
-        onRetry: (event) => {
-          params.log.debug("retrying send", {
-            replyStyle: params.replyStyle,
-            ...event,
-          });
-        },
-        tokenProvider: params.tokenProvider,
-        sharePointSiteId: params.sharePointSiteId,
-        mediaMaxBytes,
-      });
-      if (ids.length > 0) params.onSentMessageIds?.(ids);
-      },
-      onError: (err, info) => {
-        const errMsg = formatUnknownError(err);
-        const classification = classifyMSTeamsSendError(err);
-        const hint = formatMSTeamsSendErrorHint(classification);
-        params.runtime.error?.(
-          `msteams ${info.kind} reply failed: ${errMsg}${hint ? ` (${hint})` : ""}`,
-        );
-        params.log.error("reply failed", {
-          kind: info.kind,
-          error: errMsg,
-          classification,
-          hint,
-        });
-      },
-      onReplyStart: typingCallbacks.onReplyStart,
-    });
-
-  return {
-    dispatcher,
-    replyOptions: { ...replyOptions, onModelSelected: prefixContext.onModelSelected },
-    markDispatchIdle,
-  };
-}