@openclaw/msteams 2026.5.2 → 2026.5.3-beta.2

package/src/media-helpers.test.ts

@@ -1,202 +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 true for Windows absolute drive paths", () => {
-      expect(isLocalPath("C:\\Users\\test\\image.png")).toBe(true);
-      expect(isLocalPath("D:/data/photo.jpg")).toBe(true);
-    });
-
-    it("returns true for Windows UNC paths", () => {
-      expect(isLocalPath("\\\\server\\share\\image.png")).toBe(true);
-    });
-
-    it("returns true for Windows rooted paths", () => {
-      expect(isLocalPath("\\tmp\\openclaw\\file.txt")).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/src/media-helpers.ts

@@ -1,105 +0,0 @@
-/**
- * MIME type detection and filename extraction for MSTeams media attachments.
- */
-
-import path from "node:path";
-import {
-  detectMime,
-  extensionForMime,
-  extractOriginalFilename,
-  getFileExtension,
-} from "../runtime-api.js";
-
-/**
- * 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 {
-  if (url.startsWith("file://") || url.startsWith("/") || url.startsWith("~")) {
-    return true;
-  }
-
-  // Windows rooted path on current drive (e.g. \tmp\file.txt)
-  if (url.startsWith("\\") && !url.startsWith("\\\\")) {
-    return true;
-  }
-
-  // Windows drive-letter absolute path (e.g. C:\foo\bar.txt or C:/foo/bar.txt)
-  if (/^[a-zA-Z]:[\\/]/.test(url)) {
-    return true;
-  }
-
-  // Windows UNC path (e.g. \\server\share\file.txt)
-  if (url.startsWith("\\\\")) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * 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/src/mentions.test.ts

@@ -1,244 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildMentionEntities, formatMentionText, parseMentions } from "./mentions.js";
-
-function requireFirstEntity(result: ReturnType<typeof parseMentions>) {
-  const entity = result.entities[0];
-  if (!entity) {
-    throw new Error("expected parseMentions to return at least one entity");
-  }
-  return entity;
-}
-
-function requireOnlyEntity(result: ReturnType<typeof parseMentions>) {
-  expect(result.entities).toHaveLength(1);
-  return requireFirstEntity(result);
-}
-
-describe("parseMentions", () => {
-  it("parses single mention", () => {
-    const result = parseMentions("Hello @[John Doe](28:a1b2c3-d4e5f6)!");
-
-    expect(result.text).toBe("Hello <at>John Doe</at>!");
-    expect(requireOnlyEntity(result)).toEqual({
-      type: "mention",
-      text: "<at>John Doe</at>",
-      mentioned: {
-        id: "28:a1b2c3-d4e5f6",
-        name: "John Doe",
-      },
-    });
-  });
-
-  it("parses multiple mentions", () => {
-    const result = parseMentions("Hey @[Alice](28:aaa) and @[Bob](28:bbb), can you review this?");
-
-    expect(result.text).toBe("Hey <at>Alice</at> and <at>Bob</at>, can you review this?");
-    expect(result.entities).toHaveLength(2);
-    expect(result.entities[0]).toEqual({
-      type: "mention",
-      text: "<at>Alice</at>",
-      mentioned: {
-        id: "28:aaa",
-        name: "Alice",
-      },
-    });
-    expect(result.entities[1]).toEqual({
-      type: "mention",
-      text: "<at>Bob</at>",
-      mentioned: {
-        id: "28:bbb",
-        name: "Bob",
-      },
-    });
-  });
-
-  it("handles text without mentions", () => {
-    const result = parseMentions("Hello world!");
-
-    expect(result.text).toBe("Hello world!");
-    expect(result.entities).toHaveLength(0);
-  });
-
-  it("handles empty text", () => {
-    const result = parseMentions("");
-
-    expect(result.text).toBe("");
-    expect(result.entities).toHaveLength(0);
-  });
-
-  it("handles mention with spaces in name", () => {
-    const result = parseMentions("@[John Peter Smith](28:a1b2c3)");
-
-    expect(result.text).toBe("<at>John Peter Smith</at>");
-    expect(requireFirstEntity(result).mentioned.name).toBe("John Peter Smith");
-  });
-
-  it("trims whitespace from id and name", () => {
-    const result = parseMentions("@[ John Doe ]( 28:a1b2c3 )");
-
-    expect(requireOnlyEntity(result)).toEqual({
-      type: "mention",
-      text: "<at>John Doe</at>",
-      mentioned: {
-        id: "28:a1b2c3",
-        name: "John Doe",
-      },
-    });
-  });
-
-  it("handles Japanese characters in mention at start of message", () => {
-    const input = "@[タナカ タロウ](a1b2c3d4-e5f6-7890-abcd-ef1234567890) スキル化完了しました！";
-    const result = parseMentions(input);
-
-    expect(result.text).toBe("<at>タナカ タロウ</at> スキル化完了しました！");
-    expect(requireOnlyEntity(result)).toEqual({
-      type: "mention",
-      text: "<at>タナカ タロウ</at>",
-      mentioned: {
-        id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
-        name: "タナカ タロウ",
-      },
-    });
-
-    // Verify entity text exactly matches what's in the formatted text
-    const entityText = requireFirstEntity(result).text;
-    expect(result.text).toContain(entityText);
-    expect(result.text.indexOf(entityText)).toBe(0);
-  });
-
-  it("skips mention-like patterns with non-Teams IDs (e.g. in code blocks)", () => {
-    // This reproduces the actual failing payload: the message contains a real mention
-    // plus `@[表示名](ユーザーID)` as documentation text inside backticks.
-    const input =
-      "@[タナカ タロウ](a1b2c3d4-e5f6-7890-abcd-ef1234567890) スキル化完了しました！📋\n\n" +
-      "**作成したスキル:** `teams-mention`\n" +
-      "- 機能: Teamsでのメンション形式 `@[表示名](ユーザーID)`\n\n" +
-      "**追加対応:**\n" +
-      "- ユーザーのID `a1b2c3d4-e5f6-7890-abcd-ef1234567890` を登録済み";
-    const result = parseMentions(input);
-
-    // Only the real mention should be parsed; the documentation example should be left as-is
-    const firstEntity = requireOnlyEntity(result);
-    expect(firstEntity.mentioned.id).toBe("a1b2c3d4-e5f6-7890-abcd-ef1234567890");
-    expect(firstEntity.mentioned.name).toBe("タナカ タロウ");
-
-    // The documentation pattern must remain untouched in the text
-    expect(result.text).toContain("`@[表示名](ユーザーID)`");
-  });
-
-  it("accepts Bot Framework IDs (28:xxx)", () => {
-    const result = parseMentions("@[Bot](28:abc-123)");
-    expect(requireOnlyEntity(result).mentioned.id).toBe("28:abc-123");
-  });
-
-  it("accepts Bot Framework IDs with non-hex payloads (29:xxx)", () => {
-    const result = parseMentions("@[Bot](29:08q2j2o3jc09au90eucae)");
-    expect(requireOnlyEntity(result).mentioned.id).toBe("29:08q2j2o3jc09au90eucae");
-  });
-
-  it("accepts org-scoped IDs with extra segments (8:orgid:...)", () => {
-    const result = parseMentions("@[User](8:orgid:2d8c2d2c-1111-2222-3333-444444444444)");
-    expect(requireOnlyEntity(result).mentioned.id).toBe(
-      "8:orgid:2d8c2d2c-1111-2222-3333-444444444444",
-    );
-  });
-
-  it("accepts AAD object IDs (UUIDs)", () => {
-    const result = parseMentions("@[User](a1b2c3d4-e5f6-7890-abcd-ef1234567890)");
-    expect(requireOnlyEntity(result).mentioned.id).toBe("a1b2c3d4-e5f6-7890-abcd-ef1234567890");
-  });
-
-  it("rejects non-ID strings as mention targets", () => {
-    const result = parseMentions("See @[docs](https://example.com) for details");
-    expect(result.entities).toHaveLength(0);
-    // Original text preserved
-    expect(result.text).toBe("See @[docs](https://example.com) for details");
-  });
-});
-
-describe("buildMentionEntities", () => {
-  it("builds entities from mention info", () => {
-    const mentions = [
-      { id: "28:aaa", name: "Alice" },
-      { id: "28:bbb", name: "Bob" },
-    ];
-
-    const entities = buildMentionEntities(mentions);
-
-    expect(entities).toHaveLength(2);
-    expect(entities[0]).toEqual({
-      type: "mention",
-      text: "<at>Alice</at>",
-      mentioned: {
-        id: "28:aaa",
-        name: "Alice",
-      },
-    });
-    expect(entities[1]).toEqual({
-      type: "mention",
-      text: "<at>Bob</at>",
-      mentioned: {
-        id: "28:bbb",
-        name: "Bob",
-      },
-    });
-  });
-
-  it("handles empty list", () => {
-    const entities = buildMentionEntities([]);
-    expect(entities).toHaveLength(0);
-  });
-});
-
-describe("formatMentionText", () => {
-  it("formats text with single mention", () => {
-    const text = "Hello @John!";
-    const mentions = [{ id: "28:xxx", name: "John" }];
-
-    const result = formatMentionText(text, mentions);
-
-    expect(result).toBe("Hello <at>John</at>!");
-  });
-
-  it("formats text with multiple mentions", () => {
-    const text = "Hey @Alice and @Bob";
-    const mentions = [
-      { id: "28:aaa", name: "Alice" },
-      { id: "28:bbb", name: "Bob" },
-    ];
-
-    const result = formatMentionText(text, mentions);
-
-    expect(result).toBe("Hey <at>Alice</at> and <at>Bob</at>");
-  });
-
-  it("handles case-insensitive matching", () => {
-    const text = "Hey @alice and @ALICE";
-    const mentions = [{ id: "28:aaa", name: "Alice" }];
-
-    const result = formatMentionText(text, mentions);
-
-    expect(result).toBe("Hey <at>Alice</at> and <at>Alice</at>");
-  });
-
-  it("handles text without mentions", () => {
-    const text = "Hello world";
-    const mentions = [{ id: "28:xxx", name: "John" }];
-
-    const result = formatMentionText(text, mentions);
-
-    expect(result).toBe("Hello world");
-  });
-
-  it("escapes regex metacharacters in names", () => {
-    const text = "Hey @John(Test) and @Alice.Smith";
-    const mentions = [
-      { id: "28:xxx", name: "John(Test)" },
-      { id: "28:yyy", name: "Alice.Smith" },
-    ];
-
-    const result = formatMentionText(text, mentions);
-
-    expect(result).toBe("Hey <at>John(Test)</at> and <at>Alice.Smith</at>");
-  });
-});

package/src/mentions.ts

@@ -1,114 +0,0 @@
-/**
- * MS Teams mention handling utilities.
- *
- * Mentions in Teams require:
- * 1. Text containing <at>Name</at> tags
- * 2. entities array with mention metadata
- */
-
-type MentionEntity = {
-  type: "mention";
-  text: string;
-  mentioned: {
-    id: string;
-    name: string;
-  };
-};
-
-type MentionInfo = {
-  /** User/bot ID (e.g., "28:xxx" or AAD object ID) */
-  id: string;
-  /** Display name */
-  name: string;
-};
-
-/**
- * Check whether an ID looks like a valid Teams user/bot identifier.
- * Accepts:
- * - Bot Framework IDs: "28:xxx..." / "29:xxx..." / "8:orgid:..."
- * - AAD object IDs (UUIDs): "d5318c29-33ac-4e6b-bd42-57b8b793908f"
- *
- * Keep this permissive enough for real Teams IDs while still rejecting
- * documentation placeholders like `@[表示名](ユーザーID)`.
- */
-const TEAMS_BOT_ID_PATTERN = /^\d+:[a-z0-9._=-]+(?::[a-z0-9._=-]+)*$/i;
-const AAD_OBJECT_ID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
-
-function isValidTeamsId(id: string): boolean {
-  return TEAMS_BOT_ID_PATTERN.test(id) || AAD_OBJECT_ID_PATTERN.test(id);
-}
-
-/**
- * Parse mentions from text in the format @[Name](id).
- * Example: "Hello @[John Doe](28:xxx-yyy-zzz)!"
- *
- * Only matches where the id looks like a real Teams user/bot ID are treated
- * as mentions. This avoids false positives from documentation or code samples
- * embedded in the message (e.g. `@[表示名](ユーザーID)` in backticks).
- *
- * Returns both the formatted text with <at> tags and the entities array.
- */
-export function parseMentions(text: string): {
-  text: string;
-  entities: MentionEntity[];
-} {
-  const mentionPattern = /@\[([^\]]+)\]\(([^)]+)\)/g;
-  const entities: MentionEntity[] = [];
-
-  // Replace @[Name](id) with <at>Name</at> only for valid Teams IDs
-  const formattedText = text.replace(mentionPattern, (match, name, id) => {
-    const trimmedId = id.trim();
-
-    // Skip matches where the id doesn't look like a real Teams identifier
-    if (!isValidTeamsId(trimmedId)) {
-      return match;
-    }
-
-    const trimmedName = name.trim();
-    const mentionTag = `<at>${trimmedName}</at>`;
-    entities.push({
-      type: "mention",
-      text: mentionTag,
-      mentioned: {
-        id: trimmedId,
-        name: trimmedName,
-      },
-    });
-    return mentionTag;
-  });
-
-  return {
-    text: formattedText,
-    entities,
-  };
-}
-
-/**
- * Build mention entities array from a list of mentions.
- * Use this when you already have the mention info and formatted text.
- */
-export function buildMentionEntities(mentions: MentionInfo[]): MentionEntity[] {
-  return mentions.map((mention) => ({
-    type: "mention",
-    text: `<at>${mention.name}</at>`,
-    mentioned: {
-      id: mention.id,
-      name: mention.name,
-    },
-  }));
-}
-
-/**
- * Format text with mentions using <at> tags.
- * This is a convenience function when you want to manually format mentions.
- */
-export function formatMentionText(text: string, mentions: MentionInfo[]): string {
-  let formatted = text;
-  for (const mention of mentions) {
-    // Replace @Name or @name with <at>Name</at>
-    const escapedName = mention.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const namePattern = new RegExp(`@${escapedName}`, "gi");
-    formatted = formatted.replace(namePattern, `<at>${mention.name}</at>`);
-  }
-  return formatted;
-}