loudmouth-ai 0.1.0 → 0.2.0

package/extensions/msteams/src/attachments.ts

@@ -1,18 +0,0 @@
-export {
-  downloadMSTeamsAttachments,
-  /** @deprecated Use `downloadMSTeamsAttachments` instead. */
-  downloadMSTeamsImageAttachments,
-} from "./attachments/download.js";
-export { buildMSTeamsGraphMessageUrls, downloadMSTeamsGraphMedia } from "./attachments/graph.js";
-export {
-  buildMSTeamsAttachmentPlaceholder,
-  summarizeMSTeamsHtmlAttachments,
-} from "./attachments/html.js";
-export { buildMSTeamsMediaPayload } from "./attachments/payload.js";
-export type {
-  MSTeamsAccessTokenProvider,
-  MSTeamsAttachmentLike,
-  MSTeamsGraphMediaResult,
-  MSTeamsHtmlAttachmentSummary,
-  MSTeamsInboundMedia,
-} from "./attachments/types.js";

package/extensions/msteams/src/channel.directory.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
-
-import { msteamsPlugin } from "./channel.js";
-
-describe("msteams directory", () => {
-  it("lists peers and groups from config", async () => {
-    const cfg = {
-      channels: {
-        msteams: {
-          allowFrom: ["alice", "user:Bob"],
-          dms: { carol: {}, bob: {} },
-          teams: {
-            team1: {
-              channels: {
-                "conversation:chan1": {},
-                chan2: {},
-              },
-            },
-          },
-        },
-      },
-    } as unknown as ClawdbotConfig;
-
-    expect(msteamsPlugin.directory).toBeTruthy();
-    expect(msteamsPlugin.directory?.listPeers).toBeTruthy();
-    expect(msteamsPlugin.directory?.listGroups).toBeTruthy();
-
-    await expect(msteamsPlugin.directory!.listPeers({ cfg, query: undefined, limit: undefined })).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "user", id: "user:alice" },
-        { kind: "user", id: "user:Bob" },
-        { kind: "user", id: "user:carol" },
-        { kind: "user", id: "user:bob" },
-      ]),
-    );
-
-    await expect(msteamsPlugin.directory!.listGroups({ cfg, query: undefined, limit: undefined })).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "group", id: "conversation:chan1" },
-        { kind: "group", id: "conversation:chan2" },
-      ]),
-    );
-  });
-});

package/extensions/msteams/src/channel.ts

@@ -1,436 +0,0 @@
-import type { ChannelMessageActionName, ChannelPlugin, ClawdbotConfig } from "clawdbot/plugin-sdk";
-import {
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID,
-  MSTeamsConfigSchema,
-  PAIRING_APPROVED_MESSAGE,
-} from "clawdbot/plugin-sdk";
-
-import { msteamsOnboardingAdapter } from "./onboarding.js";
-import { msteamsOutbound } from "./outbound.js";
-import { probeMSTeams } from "./probe.js";
-import { resolveMSTeamsGroupToolPolicy } from "./policy.js";
-import {
-  normalizeMSTeamsMessagingTarget,
-  normalizeMSTeamsUserInput,
-  parseMSTeamsConversationId,
-  parseMSTeamsTeamChannelInput,
-  resolveMSTeamsChannelAllowlist,
-  resolveMSTeamsUserAllowlist,
-} from "./resolve-allowlist.js";
-import { sendAdaptiveCardMSTeams, sendMessageMSTeams } from "./send.js";
-import { resolveMSTeamsCredentials } from "./token.js";
-import {
-  listMSTeamsDirectoryGroupsLive,
-  listMSTeamsDirectoryPeersLive,
-} from "./directory-live.js";
-
-type ResolvedMSTeamsAccount = {
-  accountId: string;
-  enabled: boolean;
-  configured: boolean;
-};
-
-const meta = {
-  id: "msteams",
-  label: "Microsoft Teams",
-  selectionLabel: "Microsoft Teams (Bot Framework)",
-  docsPath: "/channels/msteams",
-  docsLabel: "msteams",
-  blurb: "Bot Framework; enterprise support.",
-  aliases: ["teams"],
-  order: 60,
-} as const;
-
-export const msteamsPlugin: ChannelPlugin<ResolvedMSTeamsAccount> = {
-  id: "msteams",
-  meta: {
-    ...meta,
-  },
-  onboarding: msteamsOnboardingAdapter,
-  pairing: {
-    idLabel: "msteamsUserId",
-    normalizeAllowEntry: (entry) => entry.replace(/^(msteams|user):/i, ""),
-    notifyApproval: async ({ cfg, id }) => {
-      await sendMessageMSTeams({
-        cfg,
-        to: id,
-        text: PAIRING_APPROVED_MESSAGE,
-      });
-    },
-  },
-  capabilities: {
-    chatTypes: ["direct", "channel", "thread"],
-    polls: true,
-    threads: true,
-    media: true,
-  },
-  agentPrompt: {
-    messageToolHints: () => [
-      "- Adaptive Cards supported. Use `action=send` with `card={type,version,body}` to send rich cards.",
-      "- MSTeams targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:ID` or `user:Display Name` (requires Graph API) for DMs, `conversation:19:...@thread.tacv2` for groups/channels. Prefer IDs over display names for speed.",
-    ],
-  },
-  threading: {
-    buildToolContext: ({ context, hasRepliedRef }) => ({
-      currentChannelId: context.To?.trim() || undefined,
-      currentThreadTs: context.ReplyToId,
-      hasRepliedRef,
-    }),
-  },
-  groups: {
-    resolveToolPolicy: resolveMSTeamsGroupToolPolicy,
-  },
-  reload: { configPrefixes: ["channels.msteams"] },
-  configSchema: buildChannelConfigSchema(MSTeamsConfigSchema),
-  config: {
-    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg) => ({
-      accountId: DEFAULT_ACCOUNT_ID,
-      enabled: cfg.channels?.msteams?.enabled !== false,
-      configured: Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
-    }),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    setAccountEnabled: ({ cfg, enabled }) => ({
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        msteams: {
-          ...cfg.channels?.msteams,
-          enabled,
-        },
-      },
-    }),
-    deleteAccount: ({ cfg }) => {
-      const next = { ...cfg } as ClawdbotConfig;
-      const nextChannels = { ...cfg.channels };
-      delete nextChannels.msteams;
-      if (Object.keys(nextChannels).length > 0) {
-        next.channels = nextChannels;
-      } else {
-        delete next.channels;
-      }
-      return next;
-    },
-    isConfigured: (_account, cfg) => Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-    }),
-    resolveAllowFrom: ({ cfg }) => cfg.channels?.msteams?.allowFrom ?? [],
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => String(entry).trim())
-        .filter(Boolean)
-        .map((entry) => entry.toLowerCase()),
-  },
-  security: {
-    collectWarnings: ({ cfg }) => {
-      const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-      const groupPolicy = cfg.channels?.msteams?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-      if (groupPolicy !== "open") return [];
-      return [
-        `- MS Teams groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.msteams.groupPolicy="allowlist" + channels.msteams.groupAllowFrom to restrict senders.`,
-      ];
-    },
-  },
-  setup: {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    applyAccountConfig: ({ cfg }) => ({
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        msteams: {
-          ...cfg.channels?.msteams,
-          enabled: true,
-        },
-      },
-    }),
-  },
-  messaging: {
-    normalizeTarget: normalizeMSTeamsMessagingTarget,
-    targetResolver: {
-      looksLikeId: (raw) => {
-        const trimmed = raw.trim();
-        if (!trimmed) return false;
-        if (/^conversation:/i.test(trimmed)) return true;
-        if (/^user:/i.test(trimmed)) {
-          // Only treat as ID if the value after user: looks like a UUID
-          const id = trimmed.slice("user:".length).trim();
-          return /^[0-9a-fA-F-]{16,}$/.test(id);
-        }
-        return trimmed.includes("@thread");
-      },
-      hint: "<conversationId|user:ID|conversation:ID>",
-    },
-  },
-  directory: {
-    self: async () => null,
-    listPeers: async ({ cfg, query, limit }) => {
-      const q = query?.trim().toLowerCase() || "";
-      const ids = new Set<string>();
-      for (const entry of cfg.channels?.msteams?.allowFrom ?? []) {
-        const trimmed = String(entry).trim();
-        if (trimmed && trimmed !== "*") ids.add(trimmed);
-      }
-      for (const userId of Object.keys(cfg.channels?.msteams?.dms ?? {})) {
-        const trimmed = userId.trim();
-        if (trimmed) ids.add(trimmed);
-      }
-      return Array.from(ids)
-        .map((raw) => raw.trim())
-        .filter(Boolean)
-        .map((raw) => normalizeMSTeamsMessagingTarget(raw) ?? raw)
-        .map((raw) => {
-          const lowered = raw.toLowerCase();
-          if (lowered.startsWith("user:")) return raw;
-          if (lowered.startsWith("conversation:")) return raw;
-          return `user:${raw}`;
-        })
-        .filter((id) => (q ? id.toLowerCase().includes(q) : true))
-        .slice(0, limit && limit > 0 ? limit : undefined)
-        .map((id) => ({ kind: "user", id }) as const);
-    },
-    listGroups: async ({ cfg, query, limit }) => {
-      const q = query?.trim().toLowerCase() || "";
-      const ids = new Set<string>();
-      for (const team of Object.values(cfg.channels?.msteams?.teams ?? {})) {
-        for (const channelId of Object.keys(team.channels ?? {})) {
-          const trimmed = channelId.trim();
-          if (trimmed && trimmed !== "*") ids.add(trimmed);
-        }
-      }
-      return Array.from(ids)
-        .map((raw) => raw.trim())
-        .filter(Boolean)
-        .map((raw) => raw.replace(/^conversation:/i, "").trim())
-        .map((id) => `conversation:${id}`)
-        .filter((id) => (q ? id.toLowerCase().includes(q) : true))
-        .slice(0, limit && limit > 0 ? limit : undefined)
-        .map((id) => ({ kind: "group", id }) as const);
-    },
-    listPeersLive: async ({ cfg, query, limit }) =>
-      listMSTeamsDirectoryPeersLive({ cfg, query, limit }),
-    listGroupsLive: async ({ cfg, query, limit }) =>
-      listMSTeamsDirectoryGroupsLive({ cfg, query, limit }),
-  },
-  resolver: {
-    resolveTargets: async ({ cfg, inputs, kind, runtime }) => {
-      const results = inputs.map((input) => ({
-        input,
-        resolved: false,
-        id: undefined as string | undefined,
-        name: undefined as string | undefined,
-        note: undefined as string | undefined,
-      }));
-
-      const stripPrefix = (value: string) =>
-        normalizeMSTeamsUserInput(value);
-
-      if (kind === "user") {
-        const pending: Array<{ input: string; query: string; index: number }> = [];
-        results.forEach((entry, index) => {
-          const trimmed = entry.input.trim();
-          if (!trimmed) {
-            entry.note = "empty input";
-            return;
-          }
-          const cleaned = stripPrefix(trimmed);
-          if (/^[0-9a-fA-F-]{16,}$/.test(cleaned) || cleaned.includes("@")) {
-            entry.resolved = true;
-            entry.id = cleaned;
-            return;
-          }
-          pending.push({ input: entry.input, query: cleaned, index });
-        });
-
-        if (pending.length > 0) {
-          try {
-            const resolved = await resolveMSTeamsUserAllowlist({
-              cfg,
-              entries: pending.map((entry) => entry.query),
-            });
-            resolved.forEach((entry, idx) => {
-              const target = results[pending[idx]?.index ?? -1];
-              if (!target) return;
-              target.resolved = entry.resolved;
-              target.id = entry.id;
-              target.name = entry.name;
-              target.note = entry.note;
-            });
-          } catch (err) {
-            runtime.error?.(`msteams resolve failed: ${String(err)}`);
-            pending.forEach(({ index }) => {
-              const entry = results[index];
-              if (entry) entry.note = "lookup failed";
-            });
-          }
-        }
-
-        return results;
-      }
-
-      const pending: Array<{ input: string; query: string; index: number }> = [];
-      results.forEach((entry, index) => {
-        const trimmed = entry.input.trim();
-        if (!trimmed) {
-          entry.note = "empty input";
-          return;
-        }
-        const conversationId = parseMSTeamsConversationId(trimmed);
-        if (conversationId !== null) {
-          entry.resolved = Boolean(conversationId);
-          entry.id = conversationId || undefined;
-          entry.note = conversationId ? "conversation id" : "empty conversation id";
-          return;
-        }
-        const parsed = parseMSTeamsTeamChannelInput(trimmed);
-        if (!parsed.team) {
-          entry.note = "missing team";
-          return;
-        }
-        const query = parsed.channel ? `${parsed.team}/${parsed.channel}` : parsed.team;
-        pending.push({ input: entry.input, query, index });
-      });
-
-      if (pending.length > 0) {
-        try {
-          const resolved = await resolveMSTeamsChannelAllowlist({
-            cfg,
-            entries: pending.map((entry) => entry.query),
-          });
-          resolved.forEach((entry, idx) => {
-            const target = results[pending[idx]?.index ?? -1];
-            if (!target) return;
-            if (!entry.resolved || !entry.teamId) {
-              target.resolved = false;
-              target.note = entry.note;
-              return;
-            }
-            target.resolved = true;
-            if (entry.channelId) {
-              target.id = `${entry.teamId}/${entry.channelId}`;
-              target.name =
-                entry.channelName && entry.teamName
-                  ? `${entry.teamName}/${entry.channelName}`
-                  : entry.channelName ?? entry.teamName;
-            } else {
-              target.id = entry.teamId;
-              target.name = entry.teamName;
-              target.note = "team id";
-            }
-            if (entry.note) target.note = entry.note;
-          });
-        } catch (err) {
-          runtime.error?.(`msteams resolve failed: ${String(err)}`);
-          pending.forEach(({ index }) => {
-            const entry = results[index];
-            if (entry) entry.note = "lookup failed";
-          });
-        }
-      }
-
-      return results;
-    },
-  },
-  actions: {
-    listActions: ({ cfg }) => {
-      const enabled =
-        cfg.channels?.msteams?.enabled !== false &&
-        Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams));
-      if (!enabled) return [];
-      return ["poll"] satisfies ChannelMessageActionName[];
-    },
-    supportsCards: ({ cfg }) => {
-      return (
-        cfg.channels?.msteams?.enabled !== false &&
-        Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams))
-      );
-    },
-    handleAction: async (ctx) => {
-      // Handle send action with card parameter
-      if (ctx.action === "send" && ctx.params.card) {
-        const card = ctx.params.card as Record<string, unknown>;
-        const to =
-          typeof ctx.params.to === "string"
-            ? ctx.params.to.trim()
-            : typeof ctx.params.target === "string"
-              ? ctx.params.target.trim()
-              : "";
-        if (!to) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: "Card send requires a target (to)." }],
-          };
-        }
-        const result = await sendAdaptiveCardMSTeams({
-          cfg: ctx.cfg,
-          to,
-          card,
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                ok: true,
-                channel: "msteams",
-                messageId: result.messageId,
-                conversationId: result.conversationId,
-              }),
-            },
-          ],
-        };
-      }
-      // Return null to fall through to default handler
-      return null as never;
-    },
-  },
-  outbound: msteamsOutbound,
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-      port: null,
-    },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      port: snapshot.port ?? null,
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? null,
-    }),
-    probeAccount: async ({ cfg }) => await probeMSTeams(cfg.channels?.msteams),
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      port: runtime?.port ?? null,
-      probe,
-    }),
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const { monitorMSTeamsProvider } = await import("./index.js");
-      const port = ctx.cfg.channels?.msteams?.webhook?.port ?? 3978;
-      ctx.setStatus({ accountId: ctx.accountId, port });
-      ctx.log?.info(`starting provider (port ${port})`);
-      return monitorMSTeamsProvider({
-        cfg: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-      });
-    },
-  },
-};

package/extensions/msteams/src/conversation-store-fs.test.ts

@@ -1,88 +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 type { StoredConversationReference } from "./conversation-store.js";
-import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.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 conversation store (fs)", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(runtimeStub);
-  });
-
-  it("filters and prunes expired entries (but keeps legacy ones)", async () => {
-    const stateDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "clawdbot-msteams-store-"));
-
-    const env: NodeJS.ProcessEnv = {
-      ...process.env,
-      CLAWDBOT_STATE_DIR: stateDir,
-    };
-
-    const store = createMSTeamsConversationStoreFs({ env, ttlMs: 1_000 });
-
-    const ref: StoredConversationReference = {
-      conversation: { id: "19:active@thread.tacv2" },
-      channelId: "msteams",
-      serviceUrl: "https://service.example.com",
-      user: { id: "u1", aadObjectId: "aad1" },
-    };
-
-    await store.upsert("19:active@thread.tacv2", ref);
-
-    const filePath = path.join(stateDir, "msteams-conversations.json");
-    const raw = await fs.promises.readFile(filePath, "utf-8");
-    const json = JSON.parse(raw) as {
-      version: number;
-      conversations: Record<string, StoredConversationReference & { lastSeenAt?: string }>;
-    };
-
-    json.conversations["19:old@thread.tacv2"] = {
-      ...ref,
-      conversation: { id: "19:old@thread.tacv2" },
-      lastSeenAt: new Date(Date.now() - 60_000).toISOString(),
-    };
-
-    // Legacy entry without lastSeenAt should be preserved.
-    json.conversations["19:legacy@thread.tacv2"] = {
-      ...ref,
-      conversation: { id: "19:legacy@thread.tacv2" },
-    };
-
-    await fs.promises.writeFile(filePath, `${JSON.stringify(json, null, 2)}\n`);
-
-    const list = await store.list();
-    const ids = list.map((e) => e.conversationId).sort();
-    expect(ids).toEqual(["19:active@thread.tacv2", "19:legacy@thread.tacv2"]);
-
-    expect(await store.get("19:old@thread.tacv2")).toBeNull();
-    expect(await store.get("19:legacy@thread.tacv2")).not.toBeNull();
-
-    await store.upsert("19:new@thread.tacv2", {
-      ...ref,
-      conversation: { id: "19:new@thread.tacv2" },
-    });
-
-    const rawAfter = await fs.promises.readFile(filePath, "utf-8");
-    const jsonAfter = JSON.parse(rawAfter) as typeof json;
-    expect(Object.keys(jsonAfter.conversations).sort()).toEqual([
-      "19:active@thread.tacv2",
-      "19:legacy@thread.tacv2",
-      "19:new@thread.tacv2",
-    ]);
-  });
-});