agent-messenger 2.6.2 → 2.7.0

package/skills/agent-webex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webex
 description: Interact with Cisco Webex - send messages, read spaces, manage memberships
-version: 2.6.2
+version: 2.7.0
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:
@@ -116,7 +116,7 @@ At the **start of every task**, read `~/.config/agent-messenger/MEMORY.md` using
 After discovering useful information, update `~/.config/agent-messenger/MEMORY.md` using the `Write` tool. Write triggers include:
 
 - After discovering space IDs and titles (from `space list`, `snapshot`, etc.)
-- After discovering member IDs and names (from `member list`, `snapshot`, etc.)
+- After discovering member IDs and names (from `member list`, etc.)
 - After the user gives you an alias or preference ("call this the standup space", "my main space is X")
 - After discovering space structure (group vs direct spaces)
 
@@ -247,25 +247,17 @@ agent-webex member list <space-id> --limit 100
 
 ### Snapshot Command
 
-Get comprehensive workspace state for AI agents:
+Get workspace spaces overview for AI agents:
 
 ```bash
-# Full snapshot
 agent-webex snapshot
-
-# Filtered snapshots
-agent-webex snapshot --spaces-only
-agent-webex snapshot --members-only
-
-# Limit messages per space
-agent-webex snapshot --limit 10
 ```
 
 Returns JSON with:
 
-- Spaces (id, title, type, created)
-- Recent messages (id, text, personEmail, created)
-- Members (id, personDisplayName, personEmail)
+- Spaces (id, title, type, lastActivity) — only spaces you're a member of
+
+For messages or members, use `message list <space-id>` or `member list <space-id>`.
 
 ## Output Format
 

package/skills/agent-webex/references/common-patterns.md

@@ -323,9 +323,9 @@ echo "Found: $(echo "$MATCH" | jq -r '.personDisplayName') ($(echo "$MATCH" | jq
 
 ## Snapshot Patterns
 
-### Pattern 19: Full Workspace Snapshot
+### Pattern 19: Workspace Snapshot
 
-**Use case**: Get complete workspace state for AI context
+**Use case**: Get spaces overview for AI context
 
 ```bash
 #!/bin/bash
@@ -339,36 +339,7 @@ echo "Total spaces: $SPACE_COUNT"
 echo "$SNAPSHOT" | jq -r '.spaces[] | "  \(.title) (\(.type))"'
 ```
 
-### Pattern 20: Spaces-Only Snapshot
-
-**Use case**: Quick overview without messages or members
-
-```bash
-#!/bin/bash
-
-agent-webex snapshot --spaces-only
-```
-
-### Pattern 21: Members-Only Snapshot
-
-**Use case**: Get member lists across all spaces
-
-```bash
-#!/bin/bash
-
-agent-webex snapshot --members-only
-```
-
-### Pattern 22: Snapshot with Message Limit
-
-**Use case**: Control how many messages per space
-
-```bash
-#!/bin/bash
-
-# Get snapshot with last 5 messages per space
-agent-webex snapshot --limit 5
-```
+**When to use**: Quick workspace overview to discover space IDs and titles. Use `message list <space-id>` or `member list <space-id>` for details.
 
 ## Pipeline Patterns
 

package/skills/agent-wechatbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-wechatbot
 description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
-version: 2.6.2
+version: 2.7.0
 allowed-tools: Bash(agent-wechatbot:*)
 metadata:
   openclaw:

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.6.2
+version: 2.7.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.6.2
+version: 2.7.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

package/src/platforms/webex/client.test.ts

@@ -483,6 +483,29 @@ describe('WebexClient', () => {
         expect(message.personEmail).toBe('test@example.com')
         expect(message.created).toBe('2026-01-01T00:00:00.000Z')
       })
+
+      test('markdown option converts content to HTML and strips displayName', async () => {
+        mockResponse(mockActivity('bold text'))
+
+        const client = await createExtractedClient()
+        await client.sendMessage(TEST_ROOM_ID, '**bold text**', { markdown: true })
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.object.displayName).toBe('bold text')
+        expect(body.object.content).toBe('<strong>bold text</strong>')
+        expect(body.object.markdown).toBeUndefined()
+      })
+
+      test('markdown option does not affect plain text messages', async () => {
+        mockResponse(mockActivity('Hello world'))
+
+        const client = await createExtractedClient()
+        await client.sendMessage(TEST_ROOM_ID, 'Hello world')
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.object.displayName).toBe('Hello world')
+        expect(body.object.content).toBe('Hello world')
+      })
     })
 
     describe('listMessages', () => {
@@ -637,6 +660,18 @@ describe('WebexClient', () => {
         const body = JSON.parse(fetchCalls[0].options?.body as string)
         expect(body.target.id).toBe(TEST_CONV_UUID)
       })
+
+      test('markdown option converts content to HTML and strips displayName', async () => {
+        mockResponse(mockActivity('italic text'))
+
+        const client = await createExtractedClient()
+        await client.editMessage('activity-123', TEST_ROOM_ID, '_italic text_', { markdown: true })
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.object.displayName).toBe('italic text')
+        expect(body.object.content).toBe('<em>italic text</em>')
+        expect(body.object.markdown).toBeUndefined()
+      })
     })
 
     describe('sendDirectMessage', () => {

package/src/platforms/webex/client.ts

@@ -2,6 +2,7 @@ import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from './t
 import { WebexError } from './types'
 import { WebexCredentialManager } from './credential-manager'
 import { WebexEncryptionService } from './encryption'
+import { markdownToHtml, stripMarkdown } from './markdown-to-html'
 
 const BASE_URL = 'https://webexapis.com/v1'
 const MAX_RETRIES = 3
@@ -237,7 +238,7 @@ export class WebexClient {
   }
 
   private async activityToMessage(a: InternalActivity, roomId: string): Promise<WebexMessage> {
-    let text = a.object?.content ?? a.object?.displayName
+    let text = a.object?.displayName ?? a.object?.content
 
     if (this.encryption && text?.startsWith('eyJ')) {
       const keyUrl = a.encryptionKeyUrl ?? a.object?.encryptionKeyUrl
@@ -265,10 +266,8 @@ export class WebexClient {
     text: string,
     options?: { markdown?: boolean },
   ): Promise<{ object: Record<string, string>; encryptionKeyUrl?: string }> {
-    const buildObject = (content: string): Record<string, string> =>
-      options?.markdown
-        ? { objectType: 'comment', displayName: content, content, markdown: content }
-        : { objectType: 'comment', displayName: content, content }
+    const displayName = options?.markdown ? stripMarkdown(text) : text
+    const content = options?.markdown ? markdownToHtml(text) : text
 
     if (this.encryption) {
       const conv = await this.internalRequest<InternalConversation>(
@@ -276,14 +275,22 @@ export class WebexClient {
       )
       const keyUri = conv.defaultActivityEncryptionKeyUrl
       if (keyUri) {
-        const encrypted = await this.encryption.encryptText(keyUri, text)
-        if (encrypted) {
-          return { object: buildObject(encrypted), encryptionKeyUrl: keyUri }
+        const encryptedDisplayName = await this.encryption.encryptText(keyUri, displayName)
+        const encryptedContent = await this.encryption.encryptText(keyUri, content)
+        if (encryptedDisplayName && encryptedContent) {
+          return {
+            object: {
+              objectType: 'comment',
+              displayName: encryptedDisplayName,
+              content: encryptedContent,
+            },
+            encryptionKeyUrl: keyUri,
+          }
         }
       }
     }
 
-    return { object: buildObject(text) }
+    return { object: { objectType: 'comment', displayName, content } }
   }
 
   private async sendMessageInternal(
@@ -438,6 +445,16 @@ export class WebexClient {
     return data.items
   }
 
+  async listMyMemberships(options?: { max?: number }): Promise<WebexMembership[]> {
+    const params = new URLSearchParams()
+    params.set('max', String(options?.max ?? 100))
+    const data = await this.request<{ items: WebexMembership[] }>(
+      'GET',
+      `/memberships?${params}`,
+    )
+    return data.items
+  }
+
   async listMemberships(
     roomId: string,
     options?: { max?: number },

package/src/platforms/webex/commands/snapshot.test.ts

@@ -11,24 +11,19 @@ mock.module('@/shared/utils/error-handler', () => ({
 
 const mockSpaces = [
   { id: 'space-1', title: 'General', type: 'group', isLocked: false, lastActivity: '2024-01-15T00:00:00.000Z', created: '2024-01-01T00:00:00.000Z', creatorId: 'person-1' },
+  { id: 'space-2', title: 'Random', type: 'group', isLocked: false, lastActivity: '2024-01-14T00:00:00.000Z', created: '2024-01-01T00:00:00.000Z', creatorId: 'person-1' },
 ]
 
-const mockMessages = [
-  { id: 'msg-1', roomId: 'space-1', roomType: 'group', text: 'Hello', personId: 'person-1', personEmail: 'alice@example.com', created: '2024-01-15T00:00:00.000Z' },
-]
-
-const mockMembers = [
+const mockMyMemberships = [
   { id: 'mem-1', roomId: 'space-1', personId: 'person-1', personEmail: 'alice@example.com', personDisplayName: 'Alice', isModerator: true, created: '2024-01-01T00:00:00.000Z' },
 ]
 
 const mockListSpaces = mock(() => Promise.resolve(mockSpaces as any))
-const mockListMessages = mock(() => Promise.resolve(mockMessages as any))
-const mockListMemberships = mock(() => Promise.resolve(mockMembers as any))
+const mockListMyMemberships = mock(() => Promise.resolve(mockMyMemberships as any))
 
 const mockClient = {
   listSpaces: mockListSpaces,
-  listMessages: mockListMessages,
-  listMemberships: mockListMemberships,
+  listMyMemberships: mockListMyMemberships,
 }
 
 const mockLogin = mock(() => Promise.resolve(mockClient))
@@ -46,8 +41,7 @@ describe('snapshot command', () => {
 
   beforeEach(() => {
     mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces as any))
-    mockListMessages.mockReset().mockImplementation(() => Promise.resolve(mockMessages as any))
-    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers as any))
+    mockListMyMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMyMemberships as any))
     mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
     mockHandleError.mockReset().mockImplementation((err: Error) => {
       throw err
@@ -60,40 +54,24 @@ describe('snapshot command', () => {
     consoleSpy.mockRestore()
   })
 
-  test('full snapshot includes spaces, recent_messages, members', async () => {
+  test('returns spaces with id, title, type, lastActivity', async () => {
     await snapshotAction({})
 
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
-    expect(output.spaces).toBeDefined()
+    expect(output.spaces).toHaveLength(1)
     expect(output.spaces[0].id).toBe('space-1')
     expect(output.spaces[0].title).toBe('General')
-    expect(output.recent_messages).toBeDefined()
-    expect(output.recent_messages[0].id).toBe('msg-1')
-    expect(output.recent_messages[0].author).toBe('alice@example.com')
-    expect(output.members).toBeDefined()
-    expect(output.members[0].personEmail).toBe('alice@example.com')
-  })
-
-  test('--spaces-only includes only spaces (no messages, no members)', async () => {
-    await snapshotAction({ spacesOnly: true })
-
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
-    expect(output.spaces).toBeDefined()
-    expect(output.recent_messages).toBeUndefined()
-    expect(output.members).toBeUndefined()
+    expect(output.spaces[0].type).toBe('group')
+    expect(output.spaces[0].lastActivity).toBe('2024-01-15T00:00:00.000Z')
   })
 
-  test('--members-only includes only members (no spaces, no messages)', async () => {
-    await snapshotAction({ membersOnly: true })
+  test('filters spaces to only those in my memberships', async () => {
+    await snapshotAction({})
 
-    expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
-    expect(output.spaces).toBeUndefined()
-    expect(output.recent_messages).toBeUndefined()
-    expect(output.members).toBeDefined()
-    expect(output.members[0].personEmail).toBe('alice@example.com')
+    expect(output.spaces).toHaveLength(1)
+    expect(output.spaces[0].id).toBe('space-1')
   })
 
   test('not authenticated outputs error', async () => {
@@ -105,10 +83,4 @@ describe('snapshot command', () => {
 
     expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
-
-  test('passes limit option to listMessages', async () => {
-    await snapshotAction({ limit: 5 })
-
-    expect(mockListMessages).toHaveBeenCalledWith('space-1', { max: 5 })
-  })
 })

package/src/platforms/webex/commands/snapshot.ts

@@ -1,72 +1,27 @@
 import { Command } from 'commander'
-import { parallelMap } from '@/shared/utils/concurrency'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { WebexClient } from '../client'
-import type { WebexSpace } from '../types'
 
 export async function snapshotAction(options: {
-  spacesOnly?: boolean
-  membersOnly?: boolean
-  limit?: number
   pretty?: boolean
 }): Promise<void> {
   try {
     const client = await new WebexClient().login()
-    const messageLimit = options.limit || 20
-    const snapshot: Record<string, unknown> = {}
 
-    if (!options.membersOnly) {
-      const spaces = await client.listSpaces({ max: 50 })
-      snapshot.spaces = spaces.map((s) => ({
+    const myMemberships = await client.listMyMemberships({ max: 100 })
+    const myRoomIds = new Set(myMemberships.map((m) => m.roomId))
+
+    const allSpaces = await client.listSpaces({ max: 100 })
+    const spaces = allSpaces.filter((s) => myRoomIds.has(s.id))
+
+    const snapshot = {
+      spaces: spaces.map((s) => ({
         id: s.id,
         title: s.title,
         type: s.type,
         lastActivity: s.lastActivity,
-      }))
-
-      if (!options.spacesOnly) {
-        const spaceMessages = await parallelMap(
-          spaces,
-          async (space: WebexSpace) => {
-            const messages = await client.listMessages(space.id, { max: messageLimit })
-            return messages.map((msg) => ({
-              ...msg,
-              space_title: space.title,
-            }))
-          },
-          5,
-        )
-
-        snapshot.recent_messages = spaceMessages.flat().map((msg) => ({
-          space_id: msg.roomId,
-          space_title: msg.space_title,
-          id: msg.id,
-          author: msg.personEmail,
-          text: msg.text || msg.markdown || '',
-          created: msg.created,
-        }))
-      }
-    }
-
-    if (!options.spacesOnly) {
-      // Get members for the first few spaces (avoid massive API calls)
-      const spaces = await client.listSpaces({ max: 10 })
-      const spaceMembers = await parallelMap(
-        spaces,
-        async (space: WebexSpace) => {
-          const members = await client.listMemberships(space.id, { max: 100 })
-          return members.map((m) => ({
-            space_id: space.id,
-            space_title: space.title,
-            personEmail: m.personEmail,
-            personDisplayName: m.personDisplayName,
-            isModerator: m.isModerator,
-          }))
-        },
-        5,
-      )
-      snapshot.members = spaceMembers.flat()
+      })),
     }
 
     console.log(formatOutput(snapshot, options.pretty))
@@ -76,16 +31,10 @@ export async function snapshotAction(options: {
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get comprehensive workspace state for AI agents')
-  .option('--spaces-only', 'Include only spaces (exclude messages and members)')
-  .option('--members-only', 'Include only members (exclude spaces and messages)')
-  .option('--limit <n>', 'Number of recent messages per space (default: 20)', '20')
+  .description('Get workspace spaces overview for AI agents')
   .option('--pretty', 'Pretty print JSON output')
   .action(async (options) => {
     await snapshotAction({
-      spacesOnly: options.spacesOnly,
-      membersOnly: options.membersOnly,
-      limit: parseInt(options.limit, 10),
       pretty: options.pretty,
     })
   })

package/src/platforms/webex/markdown-to-html.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from 'bun:test'
+
+import { markdownToHtml, stripMarkdown } from './markdown-to-html'
+
+describe('markdownToHtml', () => {
+  test('converts bold text', () => {
+    expect(markdownToHtml('**bold**')).toBe('<strong>bold</strong>')
+  })
+
+  test('converts italic text', () => {
+    expect(markdownToHtml('_italic_')).toBe('<em>italic</em>')
+  })
+
+  test('does not italicize mid-word underscores', () => {
+    expect(markdownToHtml('some_variable_name')).toBe('some_variable_name')
+  })
+
+  test('converts bold and italic text', () => {
+    expect(markdownToHtml('***both***')).toBe('<strong><em>both</em></strong>')
+  })
+
+  test('converts inline code', () => {
+    expect(markdownToHtml('Use `code` here')).toBe('Use <code>code</code> here')
+  })
+
+  test('converts code blocks with language', () => {
+    expect(markdownToHtml('```ts\nconst x = 1 < 2\n```')).toBe(
+      '<pre><code class="language-ts">const x = 1 &lt; 2</code></pre>',
+    )
+  })
+
+  test('converts code blocks without language', () => {
+    expect(markdownToHtml('```\nconst x = 1 & 2\n```')).toBe(
+      '<pre><code>const x = 1 &amp; 2</code></pre>',
+    )
+  })
+
+  test('does not process markdown inside code blocks', () => {
+    expect(markdownToHtml('```\n**bold** _italic_\n```')).toBe(
+      '<pre><code>**bold** _italic_</code></pre>',
+    )
+  })
+
+  test('converts links', () => {
+    expect(markdownToHtml('[Webex](https://example.com?a=1&b=2)')).toBe(
+      '<a href="https://example.com?a=1&amp;b=2">Webex</a>',
+    )
+  })
+
+  test('strips unsafe javascript: URLs to plain text', () => {
+    expect(markdownToHtml('[click](javascript:void)')).toBe('click')
+  })
+
+  test('strips unsafe data: URLs to plain text', () => {
+    expect(markdownToHtml('[x](data:text/html,payload)')).toBe('x')
+  })
+
+  test('allows mailto: links', () => {
+    expect(markdownToHtml('[email](mailto:a@b.com)')).toBe(
+      '<a href="mailto:a@b.com">email</a>',
+    )
+  })
+
+  test('escapes quotes in URLs to prevent attribute breakout', () => {
+    expect(markdownToHtml('[x](https://a.com?q="test")')).toBe(
+      '<a href="https://a.com?q=&quot;test&quot;">x</a>',
+    )
+  })
+
+  test('converts unordered lists', () => {
+    expect(markdownToHtml('- one\n- two')).toBe('<ul><li>one</li><li>two</li></ul>')
+  })
+
+  test('converts ordered lists', () => {
+    expect(markdownToHtml('1. one\n2. two')).toBe('<ol><li>one</li><li>two</li></ol>')
+  })
+
+  test('converts blockquotes', () => {
+    expect(markdownToHtml('> one\n> two')).toBe('<blockquote>one<br/>two</blockquote>')
+  })
+
+  test('converts headings', () => {
+    expect(markdownToHtml('# one\n###### six')).toBe('<h1>one</h1><br/><br/><h6>six</h6>')
+  })
+
+  test('converts horizontal rules', () => {
+    expect(markdownToHtml('before\n---\nafter')).toBe('before<br/><br/><hr><br/><br/>after')
+  })
+
+  test('converts paragraph newlines to br', () => {
+    expect(markdownToHtml('one\ntwo')).toBe('one<br/>two')
+  })
+
+  test('supports nested formatting', () => {
+    expect(markdownToHtml('**bold _and italic_**')).toBe(
+      '<strong>bold <em>and italic</em></strong>',
+    )
+  })
+
+  test('escapes html special characters in text', () => {
+    expect(markdownToHtml('5 < 7 & 8 > 3')).toBe('5 &lt; 7 &amp; 8 &gt; 3')
+  })
+
+  test('separates multiple paragraphs with br', () => {
+    expect(markdownToHtml('first\n\nsecond')).toBe('first<br/><br/>second')
+  })
+
+  test('renders mixed content', () => {
+    expect(markdownToHtml('Hello **team**\n\n- one\n- two\n\n```js\nconst x = 1\n```')).toBe(
+      'Hello <strong>team</strong><br/><br/><ul><li>one</li><li>two</li></ul><br/><br/><pre><code class="language-js">const x = 1</code></pre>',
+    )
+  })
+
+  test('returns empty string for empty input', () => {
+    expect(markdownToHtml('')).toBe('')
+  })
+
+  test('returns plain text when there is no markdown', () => {
+    expect(markdownToHtml('hello world')).toBe('hello world')
+  })
+
+  test('preserves whitespace-only input', () => {
+    expect(markdownToHtml('   ')).toBe('   ')
+  })
+})
+
+describe('stripMarkdown', () => {
+  test('strips inline markdown syntax', () => {
+    expect(stripMarkdown('**bold** _italic_ `code`')).toBe('bold italic code')
+  })
+
+  test('strips links to their labels', () => {
+    expect(stripMarkdown('[Webex](https://example.com)')).toBe('Webex')
+  })
+
+  test('strips block markdown syntax', () => {
+    expect(stripMarkdown('# Title\n> quote\n- item\n1. first\n---')).toBe(
+      'Title\nquote\nitem\nfirst\n',
+    )
+  })
+
+  test('keeps code block content', () => {
+    expect(stripMarkdown('```ts\nconst x = 1\n```')).toBe('const x = 1')
+  })
+
+  test('handles nested formatting', () => {
+    expect(stripMarkdown('**bold _and italic_**')).toBe('bold and italic')
+  })
+
+  test('returns plain text unchanged', () => {
+    expect(stripMarkdown('hello world')).toBe('hello world')
+  })
+})