loudmouth-ai 0.1.0 → 0.2.0

package/extensions/msteams/src/media-helpers.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { extractFilename, extractMessageId, getMimeType, isLocalPath } from "./media-helpers.js";
-
-describe("msteams media-helpers", () => {
-  describe("getMimeType", () => {
-    it("detects png from URL", async () => {
-      expect(await getMimeType("https://example.com/image.png")).toBe("image/png");
-    });
-
-    it("detects jpeg from URL (both extensions)", async () => {
-      expect(await getMimeType("https://example.com/photo.jpg")).toBe("image/jpeg");
-      expect(await getMimeType("https://example.com/photo.jpeg")).toBe("image/jpeg");
-    });
-
-    it("detects gif from URL", async () => {
-      expect(await getMimeType("https://example.com/anim.gif")).toBe("image/gif");
-    });
-
-    it("detects webp from URL", async () => {
-      expect(await getMimeType("https://example.com/modern.webp")).toBe("image/webp");
-    });
-
-    it("handles URLs with query strings", async () => {
-      expect(await getMimeType("https://example.com/image.png?v=123")).toBe("image/png");
-    });
-
-    it("handles data URLs", async () => {
-      expect(await getMimeType("data:image/png;base64,iVBORw0KGgo=")).toBe("image/png");
-      expect(await getMimeType("data:image/jpeg;base64,/9j/4AAQ")).toBe("image/jpeg");
-      expect(await getMimeType("data:image/gif;base64,R0lGOD")).toBe("image/gif");
-    });
-
-    it("handles data URLs without base64", async () => {
-      expect(await getMimeType("data:image/svg+xml,%3Csvg")).toBe("image/svg+xml");
-    });
-
-    it("handles local paths", async () => {
-      expect(await getMimeType("/tmp/image.png")).toBe("image/png");
-      expect(await getMimeType("/Users/test/photo.jpg")).toBe("image/jpeg");
-    });
-
-    it("handles tilde paths", async () => {
-      expect(await getMimeType("~/Downloads/image.gif")).toBe("image/gif");
-    });
-
-    it("defaults to application/octet-stream for unknown extensions", async () => {
-      expect(await getMimeType("https://example.com/image")).toBe("application/octet-stream");
-      expect(await getMimeType("https://example.com/image.unknown")).toBe("application/octet-stream");
-    });
-
-    it("is case-insensitive", async () => {
-      expect(await getMimeType("https://example.com/IMAGE.PNG")).toBe("image/png");
-      expect(await getMimeType("https://example.com/Photo.JPEG")).toBe("image/jpeg");
-    });
-
-    it("detects document types", async () => {
-      expect(await getMimeType("https://example.com/doc.pdf")).toBe("application/pdf");
-      expect(await getMimeType("https://example.com/doc.docx")).toBe(
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      );
-      expect(await getMimeType("https://example.com/spreadsheet.xlsx")).toBe(
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      );
-    });
-  });
-
-  describe("extractFilename", () => {
-    it("extracts filename from URL with extension", async () => {
-      expect(await extractFilename("https://example.com/photo.jpg")).toBe("photo.jpg");
-    });
-
-    it("extracts filename from URL with path", async () => {
-      expect(await extractFilename("https://example.com/images/2024/photo.png")).toBe("photo.png");
-    });
-
-    it("handles URLs without extension by deriving from MIME", async () => {
-      // Now defaults to application/octet-stream → .bin fallback
-      expect(await extractFilename("https://example.com/images/photo")).toBe("photo.bin");
-    });
-
-    it("handles data URLs", async () => {
-      expect(await extractFilename("data:image/png;base64,iVBORw0KGgo=")).toBe("image.png");
-      expect(await extractFilename("data:image/jpeg;base64,/9j/4AAQ")).toBe("image.jpg");
-    });
-
-    it("handles document data URLs", async () => {
-      expect(await extractFilename("data:application/pdf;base64,JVBERi0")).toBe("file.pdf");
-    });
-
-    it("handles local paths", async () => {
-      expect(await extractFilename("/tmp/screenshot.png")).toBe("screenshot.png");
-      expect(await extractFilename("/Users/test/photo.jpg")).toBe("photo.jpg");
-    });
-
-    it("handles tilde paths", async () => {
-      expect(await extractFilename("~/Downloads/image.gif")).toBe("image.gif");
-    });
-
-    it("returns fallback for empty URL", async () => {
-      expect(await extractFilename("")).toBe("file.bin");
-    });
-
-    it("extracts original filename from embedded pattern", async () => {
-      // Pattern: {original}---{uuid}.{ext}
-      expect(
-        await extractFilename("/media/inbound/report---a1b2c3d4-e5f6-7890-abcd-ef1234567890.pdf"),
-      ).toBe("report.pdf");
-    });
-
-    it("extracts original filename with uppercase UUID", async () => {
-      expect(
-        await extractFilename("/media/inbound/Document---A1B2C3D4-E5F6-7890-ABCD-EF1234567890.docx"),
-      ).toBe("Document.docx");
-    });
-
-    it("falls back to UUID filename for legacy paths", async () => {
-      // UUID-only filename (legacy format, no embedded name)
-      expect(
-        await extractFilename("/media/inbound/a1b2c3d4-e5f6-7890-abcd-ef1234567890.pdf"),
-      ).toBe("a1b2c3d4-e5f6-7890-abcd-ef1234567890.pdf");
-    });
-
-    it("handles --- in filename without valid UUID pattern", async () => {
-      // foo---bar.txt (bar is not a valid UUID)
-      expect(await extractFilename("/media/inbound/foo---bar.txt")).toBe("foo---bar.txt");
-    });
-  });
-
-  describe("isLocalPath", () => {
-    it("returns true for file:// URLs", () => {
-      expect(isLocalPath("file:///tmp/image.png")).toBe(true);
-      expect(isLocalPath("file://localhost/tmp/image.png")).toBe(true);
-    });
-
-    it("returns true for absolute paths", () => {
-      expect(isLocalPath("/tmp/image.png")).toBe(true);
-      expect(isLocalPath("/Users/test/photo.jpg")).toBe(true);
-    });
-
-    it("returns true for tilde paths", () => {
-      expect(isLocalPath("~/Downloads/image.png")).toBe(true);
-    });
-
-    it("returns false for http URLs", () => {
-      expect(isLocalPath("http://example.com/image.png")).toBe(false);
-      expect(isLocalPath("https://example.com/image.png")).toBe(false);
-    });
-
-    it("returns false for data URLs", () => {
-      expect(isLocalPath("data:image/png;base64,iVBORw0KGgo=")).toBe(false);
-    });
-  });
-
-  describe("extractMessageId", () => {
-    it("extracts id from valid response", () => {
-      expect(extractMessageId({ id: "msg123" })).toBe("msg123");
-    });
-
-    it("returns null for missing id", () => {
-      expect(extractMessageId({ foo: "bar" })).toBeNull();
-    });
-
-    it("returns null for empty id", () => {
-      expect(extractMessageId({ id: "" })).toBeNull();
-    });
-
-    it("returns null for non-string id", () => {
-      expect(extractMessageId({ id: 123 })).toBeNull();
-      expect(extractMessageId({ id: null })).toBeNull();
-    });
-
-    it("returns null for null response", () => {
-      expect(extractMessageId(null)).toBeNull();
-    });
-
-    it("returns null for undefined response", () => {
-      expect(extractMessageId(undefined)).toBeNull();
-    });
-
-    it("returns null for non-object response", () => {
-      expect(extractMessageId("string")).toBeNull();
-      expect(extractMessageId(123)).toBeNull();
-    });
-  });
-});

package/extensions/msteams/src/media-helpers.ts

@@ -1,77 +0,0 @@
-/**
- * MIME type detection and filename extraction for MSTeams media attachments.
- */
-
-import path from "node:path";
-
-import {
-  detectMime,
-  extensionForMime,
-  extractOriginalFilename,
-  getFileExtension,
-} from "clawdbot/plugin-sdk";
-
-/**
- * Detect MIME type from URL extension or data URL.
- * Uses shared MIME detection for consistency with core handling.
- */
-export async function getMimeType(url: string): Promise<string> {
-  // Handle data URLs: data:image/png;base64,...
-  if (url.startsWith("data:")) {
-    const match = url.match(/^data:([^;,]+)/);
-    if (match?.[1]) return match[1];
-  }
-
-  // Use shared MIME detection (extension-based for URLs)
-  const detected = await detectMime({ filePath: url });
-  return detected ?? "application/octet-stream";
-}
-
-/**
- * Extract filename from URL or local path.
- * For local paths, extracts original filename if stored with embedded name pattern.
- * Falls back to deriving the extension from MIME type when no extension present.
- */
-export async function extractFilename(url: string): Promise<string> {
-  // Handle data URLs: derive extension from MIME
-  if (url.startsWith("data:")) {
-    const mime = await getMimeType(url);
-    const ext = extensionForMime(mime) ?? ".bin";
-    const prefix = mime.startsWith("image/") ? "image" : "file";
-    return `${prefix}${ext}`;
-  }
-
-  // Try to extract from URL pathname
-  try {
-    const pathname = new URL(url).pathname;
-    const basename = path.basename(pathname);
-    const existingExt = getFileExtension(pathname);
-    if (basename && existingExt) return basename;
-    // No extension in URL, derive from MIME
-    const mime = await getMimeType(url);
-    const ext = extensionForMime(mime) ?? ".bin";
-    const prefix = mime.startsWith("image/") ? "image" : "file";
-    return basename ? `${basename}${ext}` : `${prefix}${ext}`;
-  } catch {
-    // Local paths - use extractOriginalFilename to extract embedded original name
-    return extractOriginalFilename(url);
-  }
-}
-
-/**
- * Check if a URL refers to a local file path.
- */
-export function isLocalPath(url: string): boolean {
-  return url.startsWith("file://") || url.startsWith("/") || url.startsWith("~");
-}
-
-/**
- * Extract the message ID from a Bot Framework response.
- */
-export function extractMessageId(response: unknown): string | null {
-  if (!response || typeof response !== "object") return null;
-  if (!("id" in response)) return null;
-  const { id } = response as { id?: unknown };
-  if (typeof id !== "string" || !id) return null;
-  return id;
-}

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

@@ -1,245 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-
-import { SILENT_REPLY_TOKEN, type PluginRuntime } from "clawdbot/plugin-sdk";
-import type { StoredConversationReference } from "./conversation-store.js";
-import {
-  type MSTeamsAdapter,
-  renderReplyPayloadsToMessages,
-  sendMSTeamsMessages,
-} from "./messenger.js";
-import { setMSTeamsRuntime } from "./runtime.js";
-
-const chunkMarkdownText = (text: string, limit: number) => {
-  if (!text) return [];
-  if (limit <= 0 || text.length <= limit) return [text];
-  const chunks: string[] = [];
-  for (let index = 0; index < text.length; index += limit) {
-    chunks.push(text.slice(index, index + limit));
-  }
-  return chunks;
-};
-
-const runtimeStub = {
-  channel: {
-    text: {
-      chunkMarkdownText,
-      chunkMarkdownTextWithMode: chunkMarkdownText,
-      resolveMarkdownTableMode: () => "code",
-      convertMarkdownTables: (text: string) => text,
-    },
-  },
-} as unknown as PluginRuntime;
-
-describe("msteams messenger", () => {
-  beforeEach(() => {
-    setMSTeamsRuntime(runtimeStub);
-  });
-
-  describe("renderReplyPayloadsToMessages", () => {
-    it("filters silent replies", () => {
-      const messages = renderReplyPayloadsToMessages([{ text: SILENT_REPLY_TOKEN }], {
-        textChunkLimit: 4000,
-        tableMode: "code",
-      });
-      expect(messages).toEqual([]);
-    });
-
-    it("filters silent reply prefixes", () => {
-      const messages = renderReplyPayloadsToMessages(
-        [{ text: `${SILENT_REPLY_TOKEN} -- ignored` }],
-        { textChunkLimit: 4000, tableMode: "code" },
-      );
-      expect(messages).toEqual([]);
-    });
-
-    it("splits media into separate messages by default", () => {
-      const messages = renderReplyPayloadsToMessages(
-        [{ text: "hi", mediaUrl: "https://example.com/a.png" }],
-        { textChunkLimit: 4000, tableMode: "code" },
-      );
-      expect(messages).toEqual([{ text: "hi" }, { mediaUrl: "https://example.com/a.png" }]);
-    });
-
-    it("supports inline media mode", () => {
-      const messages = renderReplyPayloadsToMessages(
-        [{ text: "hi", mediaUrl: "https://example.com/a.png" }],
-        { textChunkLimit: 4000, mediaMode: "inline", tableMode: "code" },
-      );
-      expect(messages).toEqual([{ text: "hi", mediaUrl: "https://example.com/a.png" }]);
-    });
-
-    it("chunks long text when enabled", () => {
-      const long = "hello ".repeat(200);
-      const messages = renderReplyPayloadsToMessages([{ text: long }], {
-        textChunkLimit: 50,
-        tableMode: "code",
-      });
-      expect(messages.length).toBeGreaterThan(1);
-    });
-  });
-
-  describe("sendMSTeamsMessages", () => {
-    const baseRef: StoredConversationReference = {
-      activityId: "activity123",
-      user: { id: "user123", name: "User" },
-      agent: { id: "bot123", name: "Bot" },
-      conversation: { id: "19:abc@thread.tacv2;messageid=deadbeef" },
-      channelId: "msteams",
-      serviceUrl: "https://service.example.com",
-    };
-
-    it("sends thread messages via the provided context", async () => {
-      const sent: string[] = [];
-      const ctx = {
-        sendActivity: async (activity: unknown) => {
-          const { text } = activity as { text?: string };
-          sent.push(text ?? "");
-          return { id: `id:${text ?? ""}` };
-        },
-      };
-
-      const adapter: MSTeamsAdapter = {
-        continueConversation: async () => {},
-      };
-
-      const ids = await sendMSTeamsMessages({
-        replyStyle: "thread",
-        adapter,
-        appId: "app123",
-        conversationRef: baseRef,
-        context: ctx,
-        messages: [{ text: "one" }, { text: "two" }],
-      });
-
-      expect(sent).toEqual(["one", "two"]);
-      expect(ids).toEqual(["id:one", "id:two"]);
-    });
-
-    it("sends top-level messages via continueConversation and strips activityId", async () => {
-      const seen: { reference?: unknown; texts: string[] } = { texts: [] };
-
-      const adapter: MSTeamsAdapter = {
-        continueConversation: async (_appId, reference, logic) => {
-          seen.reference = reference;
-          await logic({
-            sendActivity: async (activity: unknown) => {
-              const { text } = activity as { text?: string };
-              seen.texts.push(text ?? "");
-              return { id: `id:${text ?? ""}` };
-            },
-          });
-        },
-      };
-
-      const ids = await sendMSTeamsMessages({
-        replyStyle: "top-level",
-        adapter,
-        appId: "app123",
-        conversationRef: baseRef,
-        messages: [{ text: "hello" }],
-      });
-
-      expect(seen.texts).toEqual(["hello"]);
-      expect(ids).toEqual(["id:hello"]);
-
-      const ref = seen.reference as {
-        activityId?: string;
-        conversation?: { id?: string };
-      };
-      expect(ref.activityId).toBeUndefined();
-      expect(ref.conversation?.id).toBe("19:abc@thread.tacv2");
-    });
-
-    it("retries thread sends on throttling (429)", async () => {
-      const attempts: string[] = [];
-      const retryEvents: Array<{ nextAttempt: number; delayMs: number }> = [];
-
-      const ctx = {
-        sendActivity: async (activity: unknown) => {
-          const { text } = activity as { text?: string };
-          attempts.push(text ?? "");
-          if (attempts.length === 1) {
-            throw Object.assign(new Error("throttled"), { statusCode: 429 });
-          }
-          return { id: `id:${text ?? ""}` };
-        },
-      };
-
-      const adapter: MSTeamsAdapter = {
-        continueConversation: async () => {},
-      };
-
-      const ids = await sendMSTeamsMessages({
-        replyStyle: "thread",
-        adapter,
-        appId: "app123",
-        conversationRef: baseRef,
-        context: ctx,
-        messages: [{ text: "one" }],
-        retry: { maxAttempts: 2, baseDelayMs: 0, maxDelayMs: 0 },
-        onRetry: (e) => retryEvents.push({ nextAttempt: e.nextAttempt, delayMs: e.delayMs }),
-      });
-
-      expect(attempts).toEqual(["one", "one"]);
-      expect(ids).toEqual(["id:one"]);
-      expect(retryEvents).toEqual([{ nextAttempt: 2, delayMs: 0 }]);
-    });
-
-    it("does not retry thread sends on client errors (4xx)", async () => {
-      const ctx = {
-        sendActivity: async () => {
-          throw Object.assign(new Error("bad request"), { statusCode: 400 });
-        },
-      };
-
-      const adapter: MSTeamsAdapter = {
-        continueConversation: async () => {},
-      };
-
-      await expect(
-        sendMSTeamsMessages({
-          replyStyle: "thread",
-          adapter,
-          appId: "app123",
-          conversationRef: baseRef,
-          context: ctx,
-          messages: [{ text: "one" }],
-          retry: { maxAttempts: 3, baseDelayMs: 0, maxDelayMs: 0 },
-        }),
-      ).rejects.toMatchObject({ statusCode: 400 });
-    });
-
-    it("retries top-level sends on transient (5xx)", async () => {
-      const attempts: string[] = [];
-
-      const adapter: MSTeamsAdapter = {
-        continueConversation: async (_appId, _reference, logic) => {
-          await logic({
-            sendActivity: async (activity: unknown) => {
-              const { text } = activity as { text?: string };
-              attempts.push(text ?? "");
-              if (attempts.length === 1) {
-                throw Object.assign(new Error("server error"), {
-                  statusCode: 503,
-                });
-              }
-              return { id: `id:${text ?? ""}` };
-            },
-          });
-        },
-      };
-
-      const ids = await sendMSTeamsMessages({
-        replyStyle: "top-level",
-        adapter,
-        appId: "app123",
-        conversationRef: baseRef,
-        messages: [{ text: "hello" }],
-        retry: { maxAttempts: 2, baseDelayMs: 0, maxDelayMs: 0 },
-      });
-
-      expect(attempts).toEqual(["hello", "hello"]);
-      expect(ids).toEqual(["id:hello"]);
-    });
-  });
-});