openclaw-ringcentral 2026.1.29-beta1

package/src/markdown.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+import { toRingCentralMarkdown, needsMarkdownConversion, hasCodeBlocks, markdownToAdaptiveCard } from "./markdown.js";
+
+describe("toRingCentralMarkdown", () => {
+  it("converts single underscore italic to asterisk", () => {
+    expect(toRingCentralMarkdown("_italic_")).toBe("*italic*");
+    expect(toRingCentralMarkdown("This is _italic_ text")).toBe("This is *italic* text");
+  });
+
+  it("preserves double asterisk bold", () => {
+    expect(toRingCentralMarkdown("**bold**")).toBe("**bold**");
+    expect(toRingCentralMarkdown("This is **bold** text")).toBe("This is **bold** text");
+  });
+
+  it("converts double underscore to bold", () => {
+    expect(toRingCentralMarkdown("__bold__")).toBe("**bold**");
+  });
+
+  it("removes strikethrough", () => {
+    expect(toRingCentralMarkdown("~~strikethrough~~")).toBe("strikethrough");
+    expect(toRingCentralMarkdown("This is ~~deleted~~ text")).toBe("This is deleted text");
+  });
+
+  it("removes code blocks", () => {
+    expect(toRingCentralMarkdown("```\ncode\n```")).toBe("code");
+    expect(toRingCentralMarkdown("```javascript\nconst x = 1;\n```")).toBe("const x = 1;");
+  });
+
+  it("removes inline code", () => {
+    expect(toRingCentralMarkdown("`code`")).toBe("code");
+    expect(toRingCentralMarkdown("Use `npm install` to install")).toBe("Use npm install to install");
+  });
+
+  it("converts headings to bold", () => {
+    expect(toRingCentralMarkdown("# Heading 1")).toBe("**Heading 1**");
+    expect(toRingCentralMarkdown("## Heading 2")).toBe("**Heading 2**");
+    expect(toRingCentralMarkdown("### Heading 3")).toBe("**Heading 3**");
+  });
+
+  it("normalizes bullet lists", () => {
+    expect(toRingCentralMarkdown("- item")).toBe("* item");
+    expect(toRingCentralMarkdown("+ item")).toBe("* item");
+    expect(toRingCentralMarkdown("* item")).toBe("* item");
+  });
+
+  it("preserves links", () => {
+    expect(toRingCentralMarkdown("[link](https://example.com)")).toBe("[link](https://example.com)");
+  });
+
+  it("preserves blockquotes", () => {
+    expect(toRingCentralMarkdown("> quote")).toBe("> quote");
+  });
+
+  it("preserves numbered lists", () => {
+    expect(toRingCentralMarkdown("1. first\n2. second")).toBe("1. first\n2. second");
+  });
+
+  it("handles complex markdown", () => {
+    const input = `# Title
+
+This is _italic_ and **bold** text.
+
+- Item 1
+- Item 2
+
+\`\`\`
+code block
+\`\`\`
+
+Use \`inline code\` here.`;
+
+    const expected = `**Title**
+
+This is *italic* and **bold** text.
+
+* Item 1
+* Item 2
+
+code block
+
+Use inline code here.`;
+
+    expect(toRingCentralMarkdown(input)).toBe(expected);
+  });
+
+  it("does not convert underscore in URLs or paths", () => {
+    // URLs with underscores should be preserved in links
+    expect(toRingCentralMarkdown("[link](https://example.com/path_with_underscore)"))
+      .toBe("[link](https://example.com/path_with_underscore)");
+  });
+});
+
+describe("needsMarkdownConversion", () => {
+  it("returns true for text with underscore italic", () => {
+    expect(needsMarkdownConversion("_italic_")).toBe(true);
+  });
+
+  it("returns true for text with strikethrough", () => {
+    expect(needsMarkdownConversion("~~strike~~")).toBe(true);
+  });
+
+  it("returns true for text with code blocks", () => {
+    expect(needsMarkdownConversion("```code```")).toBe(true);
+  });
+
+  it("returns true for text with inline code", () => {
+    expect(needsMarkdownConversion("`code`")).toBe(true);
+  });
+
+  it("returns true for text with headings", () => {
+    expect(needsMarkdownConversion("# Heading")).toBe(true);
+  });
+
+  it("returns false for plain text", () => {
+    expect(needsMarkdownConversion("plain text")).toBe(false);
+  });
+
+  it("returns false for already compatible markdown", () => {
+    expect(needsMarkdownConversion("*italic* and **bold**")).toBe(false);
+  });
+});
+
+describe("hasCodeBlocks", () => {
+  it("returns true for text with code blocks", () => {
+    expect(hasCodeBlocks("```\ncode\n```")).toBe(true);
+    expect(hasCodeBlocks("```js\nconst x = 1;\n```")).toBe(true);
+  });
+
+  it("returns false for text without code blocks", () => {
+    expect(hasCodeBlocks("plain text")).toBe(false);
+    expect(hasCodeBlocks("`inline code`")).toBe(false);
+  });
+});
+
+describe("markdownToAdaptiveCard", () => {
+  it("converts simple text to adaptive card", () => {
+    const result = markdownToAdaptiveCard("Hello world");
+    expect(result.type).toBe("AdaptiveCard");
+    expect(result.version).toBe("1.3");
+    expect(result.body).toHaveLength(1);
+    expect(result.body[0].type).toBe("TextBlock");
+    expect(result.body[0].text).toBe("Hello world");
+  });
+
+  it("converts code blocks with monospace font", () => {
+    const result = markdownToAdaptiveCard("```js\nconst x = 1;\n```");
+    expect(result.body).toHaveLength(1);
+    expect(result.body[0].fontType).toBe("Monospace");
+    expect(result.body[0].text).toBe("const x = 1;");
+  });
+
+  it("handles mixed text and code blocks", () => {
+    const result = markdownToAdaptiveCard("Some text\n\n```\ncode\n```\n\nMore text");
+    expect(result.body).toHaveLength(3);
+    expect(result.body[0].text).toBe("Some text");
+    expect(result.body[1].fontType).toBe("Monospace");
+    expect(result.body[1].text).toBe("code");
+    expect(result.body[2].text).toBe("More text");
+  });
+
+  it("converts headings with bold styling", () => {
+    const result = markdownToAdaptiveCard("# Title");
+    expect(result.body).toHaveLength(1);
+    expect(result.body[0].weight).toBe("Bolder");
+    expect(result.body[0].size).toBe("Medium");
+    expect(result.body[0].text).toBe("Title");
+  });
+});

package/src/markdown.ts

@@ -0,0 +1,158 @@
+/**
+ * Convert standard Markdown to RingCentral Mini-Markdown format.
+ * 
+ * RingCentral Mini-Markdown differences:
+ * - `_text_` = underline (not italic)
+ * - `*text*` = italic
+ * - `**text**` = bold
+ * - `[text](url)` = link
+ * - `> quote` = blockquote
+ * - `* item` = bullet list
+ * 
+ * Not supported: strikethrough (~~), code blocks (```), headings (#), etc.
+ */
+
+/**
+ * Convert standard markdown to RingCentral mini-markdown
+ */
+export function toRingCentralMarkdown(text: string): string {
+  let result = text;
+
+  // 1. Preserve links - temporarily replace them to avoid modifying URLs
+  const linkPlaceholders: string[] = [];
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match) => {
+    const idx = linkPlaceholders.length;
+    linkPlaceholders.push(match);
+    return `\x00LINK_${idx}\x00`;
+  });
+
+  // 2. Convert __text__ (some markdown bold) to **text**
+  result = result.replace(/__([^_]+)__/g, "**$1**");
+
+  // 3. Convert single _text_ to *text* for italic
+  //    Match _text_ but not inside words (e.g., snake_case_name)
+  result = result.replace(/(?<=^|[\s\p{P}])_([^_\n]+)_(?=$|[\s\p{P}])/gu, "*$1*");
+
+  // 4. Remove strikethrough ~~text~~ (not supported)
+  result = result.replace(/~~([^~]+)~~/g, "$1");
+
+  // 5. Convert code blocks to plain text (not well supported)
+  // Remove triple backtick code blocks
+  result = result.replace(/```[\s\S]*?```/g, (match) => {
+    // Extract content without the backticks and language identifier
+    const content = match.replace(/```\w*\n?/, "").replace(/\n?```$/, "");
+    return content;
+  });
+
+  // Convert inline code `text` to plain text
+  result = result.replace(/`([^`]+)`/g, "$1");
+
+  // 6. Convert headings to bold (# Heading -> **Heading**)
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "**$1**");
+
+  // 7. Convert horizontal rules (---, ***, ___) to simple separator
+  result = result.replace(/^[-*_]{3,}$/gm, "---");
+
+  // 8. Normalize bullet lists (-, +, *) to * for consistency
+  result = result.replace(/^(\s*)[-+]\s+/gm, "$1* ");
+
+  // 9. Restore links
+  result = result.replace(/\x00LINK_(\d+)\x00/g, (_match, idx) => {
+    return linkPlaceholders[Number(idx)];
+  });
+
+  // 10. Keep numbered lists as-is (1. item)
+  // 11. Keep blockquotes as-is (> quote)
+
+  return result;
+}
+
+/**
+ * Check if text contains markdown that needs conversion
+ */
+export function needsMarkdownConversion(text: string): boolean {
+  // Check for patterns that need conversion
+  return (
+    // Single underscore italic
+    /(?<![\\*_])_[^_\n]+_(?![_])/.test(text) ||
+    // Strikethrough
+    /~~[^~]+~~/.test(text) ||
+    // Code blocks
+    /```[\s\S]*?```/.test(text) ||
+    // Inline code
+    /`[^`]+`/.test(text) ||
+    // Headings
+    /^#{1,6}\s+.+$/m.test(text)
+  );
+}
+
+/**
+ * Check if text contains code blocks that would benefit from Adaptive Card formatting
+ */
+export function hasCodeBlocks(text: string): boolean {
+  return /```[\s\S]*?```/.test(text);
+}
+
+/**
+ * Convert markdown text to an Adaptive Card structure.
+ * This preserves code blocks with proper formatting.
+ */
+export function markdownToAdaptiveCard(text: string): {
+  type: "AdaptiveCard";
+  $schema: string;
+  version: string;
+  body: Array<{ type: string; text?: string; wrap?: boolean; fontType?: string; size?: string; weight?: string }>;
+} {
+  const body: Array<{ type: string; text?: string; wrap?: boolean; fontType?: string; size?: string; weight?: string }> = [];
+  
+  // Split by code blocks
+  const parts = text.split(/(```[\s\S]*?```)/g);
+  
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    
+    if (part.startsWith("```")) {
+      // Extract language and code
+      const match = part.match(/```(\w*)\n?([\s\S]*?)\n?```/);
+      if (match) {
+        const [, , code] = match;
+        // Add code block with monospace font
+        body.push({
+          type: "TextBlock",
+          text: code.trim(),
+          wrap: true,
+          fontType: "Monospace",
+        });
+      }
+    } else {
+      // Regular text - convert markdown
+      const converted = toRingCentralMarkdown(part.trim());
+      if (converted) {
+        // Check if it's a heading (starts with **)
+        const headingMatch = converted.match(/^\*\*(.+)\*\*$/);
+        if (headingMatch && !converted.includes("\n")) {
+          body.push({
+            type: "TextBlock",
+            text: headingMatch[1],
+            wrap: true,
+            size: "Medium",
+            weight: "Bolder",
+          });
+        } else {
+          body.push({
+            type: "TextBlock",
+            text: converted,
+            wrap: true,
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    type: "AdaptiveCard",
+    $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+    version: "1.3",
+    body,
+  };
+}

package/src/monitor.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { isSenderAllowed } from "./monitor.js";
+
+describe("isSenderAllowed", () => {
+  it("returns true when allowFrom contains wildcard", () => {
+    expect(isSenderAllowed("12345", ["*"])).toBe(true);
+    expect(isSenderAllowed("any-user", ["*"])).toBe(true);
+  });
+
+  it("returns true when sender ID matches exactly", () => {
+    expect(isSenderAllowed("12345", ["12345"])).toBe(true);
+    expect(isSenderAllowed("12345", ["other", "12345"])).toBe(true);
+  });
+
+  it("returns true when sender ID matches with ringcentral: prefix", () => {
+    expect(isSenderAllowed("12345", ["ringcentral:12345"])).toBe(true);
+    expect(isSenderAllowed("12345", ["RINGCENTRAL:12345"])).toBe(true);
+  });
+
+  it("returns true when sender ID matches with rc: prefix", () => {
+    expect(isSenderAllowed("12345", ["rc:12345"])).toBe(true);
+    expect(isSenderAllowed("12345", ["RC:12345"])).toBe(true);
+  });
+
+  it("returns true when sender ID matches with user: prefix", () => {
+    expect(isSenderAllowed("12345", ["user:12345"])).toBe(true);
+    expect(isSenderAllowed("12345", ["USER:12345"])).toBe(true);
+  });
+
+  it("returns false when sender ID not in allowFrom", () => {
+    expect(isSenderAllowed("12345", ["67890"])).toBe(false);
+    expect(isSenderAllowed("12345", [])).toBe(false);
+  });
+
+  it("handles case-insensitive matching", () => {
+    expect(isSenderAllowed("ABC123", ["abc123"])).toBe(true);
+    expect(isSenderAllowed("abc123", ["ABC123"])).toBe(true);
+  });
+
+  it("handles whitespace in allowFrom entries", () => {
+    expect(isSenderAllowed("12345", ["  12345  "])).toBe(true);
+  });
+
+  it("ignores empty entries in allowFrom", () => {
+    expect(isSenderAllowed("12345", ["", "12345", "  "])).toBe(true);
+  });
+});