loudmouth-ai 0.1.0 → 0.2.0

package/extensions/msteams/src/policy.test.ts

@@ -1,210 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { MSTeamsConfig } from "clawdbot/plugin-sdk";
-import {
-  isMSTeamsGroupAllowed,
-  resolveMSTeamsReplyPolicy,
-  resolveMSTeamsRouteConfig,
-} from "./policy.js";
-
-describe("msteams policy", () => {
-  describe("resolveMSTeamsRouteConfig", () => {
-    it("returns team and channel config when present", () => {
-      const cfg: MSTeamsConfig = {
-        teams: {
-          team123: {
-            requireMention: false,
-            channels: {
-              chan456: { requireMention: true },
-            },
-          },
-        },
-      };
-
-      const res = resolveMSTeamsRouteConfig({
-        cfg,
-        teamId: "team123",
-        conversationId: "chan456",
-      });
-
-      expect(res.teamConfig?.requireMention).toBe(false);
-      expect(res.channelConfig?.requireMention).toBe(true);
-      expect(res.allowlistConfigured).toBe(true);
-      expect(res.allowed).toBe(true);
-      expect(res.channelMatchKey).toBe("chan456");
-      expect(res.channelMatchSource).toBe("direct");
-    });
-
-    it("returns undefined configs when teamId is missing", () => {
-      const cfg: MSTeamsConfig = {
-        teams: { team123: { requireMention: false } },
-      };
-
-      const res = resolveMSTeamsRouteConfig({
-        cfg,
-        teamId: undefined,
-        conversationId: "chan",
-      });
-      expect(res.teamConfig).toBeUndefined();
-      expect(res.channelConfig).toBeUndefined();
-      expect(res.allowlistConfigured).toBe(true);
-      expect(res.allowed).toBe(false);
-    });
-
-    it("matches team and channel by name", () => {
-      const cfg: MSTeamsConfig = {
-        teams: {
-          "My Team": {
-            requireMention: true,
-            channels: {
-              "General Chat": { requireMention: false },
-            },
-          },
-        },
-      };
-
-      const res = resolveMSTeamsRouteConfig({
-        cfg,
-        teamName: "My Team",
-        channelName: "General Chat",
-        conversationId: "ignored",
-      });
-
-      expect(res.teamConfig?.requireMention).toBe(true);
-      expect(res.channelConfig?.requireMention).toBe(false);
-      expect(res.allowed).toBe(true);
-    });
-  });
-
-  describe("resolveMSTeamsReplyPolicy", () => {
-    it("forces thread replies for direct messages", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: true,
-        globalConfig: { replyStyle: "top-level", requireMention: false },
-      });
-      expect(policy).toEqual({ requireMention: false, replyStyle: "thread" });
-    });
-
-    it("defaults to requireMention=true and replyStyle=thread", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: {},
-      });
-      expect(policy).toEqual({ requireMention: true, replyStyle: "thread" });
-    });
-
-    it("defaults replyStyle to top-level when requireMention=false", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: false },
-      });
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("prefers channel overrides over team and global defaults", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: true },
-        teamConfig: { requireMention: true },
-        channelConfig: { requireMention: false },
-      });
-
-      // requireMention from channel -> false, and replyStyle defaults from requireMention -> top-level
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("inherits team mention settings when channel config is missing", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: true },
-        teamConfig: { requireMention: false },
-      });
-      expect(policy).toEqual({
-        requireMention: false,
-        replyStyle: "top-level",
-      });
-    });
-
-    it("uses explicit replyStyle even when requireMention defaults would differ", () => {
-      const policy = resolveMSTeamsReplyPolicy({
-        isDirectMessage: false,
-        globalConfig: { requireMention: false, replyStyle: "thread" },
-      });
-      expect(policy).toEqual({ requireMention: false, replyStyle: "thread" });
-    });
-  });
-
-  describe("isMSTeamsGroupAllowed", () => {
-    it("allows when policy is open", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "open",
-          allowFrom: [],
-          senderId: "user-id",
-          senderName: "User",
-        }),
-      ).toBe(true);
-    });
-
-    it("blocks when policy is disabled", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "disabled",
-          allowFrom: ["user-id"],
-          senderId: "user-id",
-          senderName: "User",
-        }),
-      ).toBe(false);
-    });
-
-    it("blocks allowlist when empty", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "allowlist",
-          allowFrom: [],
-          senderId: "user-id",
-          senderName: "User",
-        }),
-      ).toBe(false);
-    });
-
-    it("allows allowlist when sender matches", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "allowlist",
-          allowFrom: ["User-Id"],
-          senderId: "user-id",
-          senderName: "User",
-        }),
-      ).toBe(true);
-    });
-
-    it("allows allowlist when sender name matches", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "allowlist",
-          allowFrom: ["user"],
-          senderId: "other",
-          senderName: "User",
-        }),
-      ).toBe(true);
-    });
-
-    it("allows allowlist wildcard", () => {
-      expect(
-        isMSTeamsGroupAllowed({
-          groupPolicy: "allowlist",
-          allowFrom: ["*"],
-          senderId: "other",
-          senderName: "User",
-        }),
-      ).toBe(true);
-    });
-  });
-});

package/extensions/msteams/src/policy.ts

@@ -1,202 +0,0 @@
-import type {
-  AllowlistMatch,
-  ChannelGroupContext,
-  GroupPolicy,
-  GroupToolPolicyConfig,
-  MSTeamsChannelConfig,
-  MSTeamsConfig,
-  MSTeamsReplyStyle,
-  MSTeamsTeamConfig,
-} from "clawdbot/plugin-sdk";
-import {
-  buildChannelKeyCandidates,
-  normalizeChannelSlug,
-  resolveChannelEntryMatchWithFallback,
-  resolveNestedAllowlistDecision,
-} from "clawdbot/plugin-sdk";
-
-export type MSTeamsResolvedRouteConfig = {
-  teamConfig?: MSTeamsTeamConfig;
-  channelConfig?: MSTeamsChannelConfig;
-  allowlistConfigured: boolean;
-  allowed: boolean;
-  teamKey?: string;
-  channelKey?: string;
-  channelMatchKey?: string;
-  channelMatchSource?: "direct" | "wildcard";
-};
-
-export function resolveMSTeamsRouteConfig(params: {
-  cfg?: MSTeamsConfig;
-  teamId?: string | null | undefined;
-  teamName?: string | null | undefined;
-  conversationId?: string | null | undefined;
-  channelName?: string | null | undefined;
-}): MSTeamsResolvedRouteConfig {
-  const teamId = params.teamId?.trim();
-  const teamName = params.teamName?.trim();
-  const conversationId = params.conversationId?.trim();
-  const channelName = params.channelName?.trim();
-  const teams = params.cfg?.teams ?? {};
-  const allowlistConfigured = Object.keys(teams).length > 0;
-  const teamCandidates = buildChannelKeyCandidates(
-    teamId,
-    teamName,
-    teamName ? normalizeChannelSlug(teamName) : undefined,
-  );
-  const teamMatch = resolveChannelEntryMatchWithFallback({
-    entries: teams,
-    keys: teamCandidates,
-    wildcardKey: "*",
-    normalizeKey: normalizeChannelSlug,
-  });
-  const teamConfig = teamMatch.entry;
-  const channels = teamConfig?.channels ?? {};
-  const channelAllowlistConfigured = Object.keys(channels).length > 0;
-  const channelCandidates = buildChannelKeyCandidates(
-    conversationId,
-    channelName,
-    channelName ? normalizeChannelSlug(channelName) : undefined,
-  );
-  const channelMatch = resolveChannelEntryMatchWithFallback({
-    entries: channels,
-    keys: channelCandidates,
-    wildcardKey: "*",
-    normalizeKey: normalizeChannelSlug,
-  });
-  const channelConfig = channelMatch.entry;
-
-  const allowed = resolveNestedAllowlistDecision({
-    outerConfigured: allowlistConfigured,
-    outerMatched: Boolean(teamConfig),
-    innerConfigured: channelAllowlistConfigured,
-    innerMatched: Boolean(channelConfig),
-  });
-
-  return {
-    teamConfig,
-    channelConfig,
-    allowlistConfigured,
-    allowed,
-    teamKey: teamMatch.matchKey ?? teamMatch.key,
-    channelKey: channelMatch.matchKey ?? channelMatch.key,
-    channelMatchKey: channelMatch.matchKey,
-    channelMatchSource:
-      channelMatch.matchSource === "direct" || channelMatch.matchSource === "wildcard"
-        ? channelMatch.matchSource
-        : undefined,
-  };
-}
-
-export function resolveMSTeamsGroupToolPolicy(
-  params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
-  const cfg = params.cfg.channels?.msteams;
-  if (!cfg) return undefined;
-  const groupId = params.groupId?.trim();
-  const groupChannel = params.groupChannel?.trim();
-  const groupSpace = params.groupSpace?.trim();
-
-  const resolved = resolveMSTeamsRouteConfig({
-    cfg,
-    teamId: groupSpace,
-    teamName: groupSpace,
-    conversationId: groupId,
-    channelName: groupChannel,
-  });
-
-  if (resolved.channelConfig) {
-    return resolved.channelConfig.tools ?? resolved.teamConfig?.tools;
-  }
-  if (resolved.teamConfig?.tools) return resolved.teamConfig.tools;
-
-  if (!groupId) return undefined;
-
-  const channelCandidates = buildChannelKeyCandidates(
-    groupId,
-    groupChannel,
-    groupChannel ? normalizeChannelSlug(groupChannel) : undefined,
-  );
-  for (const teamConfig of Object.values(cfg.teams ?? {})) {
-    const match = resolveChannelEntryMatchWithFallback({
-      entries: teamConfig?.channels ?? {},
-      keys: channelCandidates,
-      wildcardKey: "*",
-      normalizeKey: normalizeChannelSlug,
-    });
-    if (match.entry) {
-      return match.entry.tools ?? teamConfig?.tools;
-    }
-  }
-
-  return undefined;
-}
-
-export type MSTeamsReplyPolicy = {
-  requireMention: boolean;
-  replyStyle: MSTeamsReplyStyle;
-};
-
-export type MSTeamsAllowlistMatch = AllowlistMatch<"wildcard" | "id" | "name">;
-
-export function resolveMSTeamsAllowlistMatch(params: {
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderName?: string | null;
-}): MSTeamsAllowlistMatch {
-  const allowFrom = params.allowFrom
-    .map((entry) => String(entry).trim().toLowerCase())
-    .filter(Boolean);
-  if (allowFrom.length === 0) return { allowed: false };
-  if (allowFrom.includes("*")) {
-    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
-  }
-  const senderId = params.senderId.toLowerCase();
-  if (allowFrom.includes(senderId)) {
-    return { allowed: true, matchKey: senderId, matchSource: "id" };
-  }
-  const senderName = params.senderName?.toLowerCase();
-  if (senderName && allowFrom.includes(senderName)) {
-    return { allowed: true, matchKey: senderName, matchSource: "name" };
-  }
-  return { allowed: false };
-}
-
-export function resolveMSTeamsReplyPolicy(params: {
-  isDirectMessage: boolean;
-  globalConfig?: MSTeamsConfig;
-  teamConfig?: MSTeamsTeamConfig;
-  channelConfig?: MSTeamsChannelConfig;
-}): MSTeamsReplyPolicy {
-  if (params.isDirectMessage) {
-    return { requireMention: false, replyStyle: "thread" };
-  }
-
-  const requireMention =
-    params.channelConfig?.requireMention ??
-    params.teamConfig?.requireMention ??
-    params.globalConfig?.requireMention ??
-    true;
-
-  const explicitReplyStyle =
-    params.channelConfig?.replyStyle ??
-    params.teamConfig?.replyStyle ??
-    params.globalConfig?.replyStyle;
-
-  const replyStyle: MSTeamsReplyStyle =
-    explicitReplyStyle ?? (requireMention ? "thread" : "top-level");
-
-  return { requireMention, replyStyle };
-}
-
-export function isMSTeamsGroupAllowed(params: {
-  groupPolicy: GroupPolicy;
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderName?: string | null;
-}): boolean {
-  const { groupPolicy } = params;
-  if (groupPolicy === "disabled") return false;
-  if (groupPolicy === "open") return true;
-  return resolveMSTeamsAllowlistMatch(params).allowed;
-}

package/extensions/msteams/src/polls-store-memory.ts

@@ -1,30 +0,0 @@
-import {
-  type MSTeamsPoll,
-  type MSTeamsPollStore,
-  normalizeMSTeamsPollSelections,
-} from "./polls.js";
-
-export function createMSTeamsPollStoreMemory(initial: MSTeamsPoll[] = []): MSTeamsPollStore {
-  const polls = new Map<string, MSTeamsPoll>();
-  for (const poll of initial) {
-    polls.set(poll.id, { ...poll });
-  }
-
-  const createPoll = async (poll: MSTeamsPoll) => {
-    polls.set(poll.id, { ...poll });
-  };
-
-  const getPoll = async (pollId: string) => polls.get(pollId) ?? null;
-
-  const recordVote = async (params: { pollId: string; voterId: string; selections: string[] }) => {
-    const poll = polls.get(params.pollId);
-    if (!poll) return null;
-    const normalized = normalizeMSTeamsPollSelections(poll, params.selections);
-    poll.votes[params.voterId] = normalized;
-    poll.updatedAt = new Date().toISOString();
-    polls.set(poll.id, poll);
-    return poll;
-  };
-
-  return { createPoll, getPoll, recordVote };
-}

package/extensions/msteams/src/polls-store.test.ts

@@ -1,40 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-import { createMSTeamsPollStoreFs } from "./polls.js";
-import { createMSTeamsPollStoreMemory } from "./polls-store-memory.js";
-
-const createFsStore = async () => {
-  const stateDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "clawdbot-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"],
-    });
-
-    expect(poll?.votes["user-1"]).toEqual(["0"]);
-  });
-});

package/extensions/msteams/src/polls.test.ts

@@ -1,72 +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 type { PluginRuntime } from "clawdbot/plugin-sdk";
-import { buildMSTeamsPollCard, createMSTeamsPollStoreFs, extractMSTeamsPollVote } from "./polls.js";
-import { setMSTeamsRuntime } from "./runtime.js";
-
-const runtimeStub = {
-  state: {
-    resolveStateDir: (env: NodeJS.ProcessEnv = process.env, homedir?: () => string) => {
-      const override = env.CLAWDBOT_STATE_DIR?.trim();
-      if (override) return override;
-      const resolvedHome = homedir ? homedir() : os.homedir();
-      return path.join(resolvedHome, ".clawdbot");
-    },
-  },
-} as unknown as PluginRuntime;
-
-describe("msteams polls", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(runtimeStub);
-  });
-
-  it("builds poll cards with fallback text", () => {
-    const card = buildMSTeamsPollCard({
-      question: "Lunch?",
-      options: ["Pizza", "Sushi"],
-    });
-
-    expect(card.pollId).toBeTruthy();
-    expect(card.fallbackText).toContain("Poll: Lunch?");
-    expect(card.fallbackText).toContain("1. Pizza");
-    expect(card.fallbackText).toContain("2. Sushi");
-  });
-
-  it("extracts poll votes from activity values", () => {
-    const vote = extractMSTeamsPollVote({
-      value: {
-        clawdbotPollId: "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(), "clawdbot-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");
-    expect(stored?.votes["user-1"]).toEqual(["0"]);
-  });
-});