agent-messenger 2.23.1 → 2.23.2

package/src/platforms/webex/client.ts

@@ -1,5 +1,6 @@
 import { WebexCredentialManager } from './credential-manager'
 import { WebexEncryptionService } from './encryption'
+import { decodeWebexId, toRestId } from './id-normalizer'
 import { KmsKeyProvider } from './kms-key-provider'
 import { escapeHtml, markdownToHtml, stripMarkdown } from './markdown-to-html'
 import type { WebexConfig, WebexMembership, WebexMessage, WebexPerson, WebexSpace } from './types'
@@ -15,6 +16,10 @@ interface RateLimitBucket {
   resetAt: number
 }
 
+interface WebexClientOptions {
+  roomResolutionWarningPrefix?: string
+}
+
 export class WebexClient {
   private token: string | null = null
   private deviceUrl: string | null = null
@@ -22,6 +27,13 @@ export class WebexClient {
   private buckets: Map<string, RateLimitBucket> = new Map()
   private globalRateLimitUntil: number = 0
   private encryption: WebexEncryptionService | null = null
+  private clusteredRoomIds = new Map<string, string>()
+  private roomIdLookups = new Map<string, Promise<string>>()
+  private roomResolutionWarningPrefix: string
+
+  constructor(options: WebexClientOptions = {}) {
+    this.roomResolutionWarningPrefix = options.roomResolutionWarningPrefix ?? '[webex]'
+  }
 
   async login(credentials?: { token: string; deviceUrl?: string; tokenType?: string }): Promise<this> {
     if (credentials) {
@@ -245,8 +257,55 @@ export class WebexClient {
     }
   }
 
+  async resolveRoomId(roomId: string): Promise<string> {
+    const decoded = decodeWebexId(roomId)
+    let uuid: string
+    let fallback: string
+
+    if (decoded) {
+      if (decoded.type !== 'ROOM' || decoded.cluster.startsWith('urn:')) return roomId
+      uuid = decoded.uuid
+      fallback = roomId
+    } else if (looksLikeUuid(roomId)) {
+      uuid = roomId
+      fallback = toRestId(roomId, 'ROOM')
+    } else {
+      return roomId
+    }
+
+    const cached = this.clusteredRoomIds.get(uuid)
+    if (cached) return cached
+
+    const inFlight = this.roomIdLookups.get(uuid)
+    if (inFlight) return inFlight
+
+    const lookup = this.lookupRoomId(uuid, fallback)
+    this.roomIdLookups.set(uuid, lookup)
+    try {
+      return await lookup
+    } finally {
+      this.roomIdLookups.delete(uuid)
+    }
+  }
+
+  async resolvePersonId(personId: string): Promise<string> {
+    if (!personId || decodeWebexId(personId)) return personId
+
+    if (looksLikeEmail(personId)) {
+      const [person] = await this.listPeople({ email: personId, max: 1 })
+      if (!person) {
+        throw new WebexError(`Person not found for ref: ${personId}`, 'not_found')
+      }
+      return person.id
+    }
+
+    if (looksLikeUuid(personId)) return toRestId(personId, 'PEOPLE')
+    return personId
+  }
+
   async getSpace(spaceId: string): Promise<WebexSpace> {
-    return this.request<WebexSpace>('GET', `/rooms/${spaceId}`)
+    const resolvedSpaceId = await this.resolveRoomId(spaceId)
+    return this.request<WebexSpace>('GET', `/rooms/${resolvedSpaceId}`)
   }
 
   async sendMessage(
@@ -254,14 +313,17 @@ export class WebexClient {
     text: string,
     options?: { markdown?: boolean; parentId?: string; files?: string[] },
   ): Promise<WebexMessage> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
+    const resolvedOptions = this.resolveMessageOptions(options)
+
     if (this.useInternalAPI) {
-      return this.sendMessageInternal(roomId, text, options)
+      return this.sendMessageInternal(resolvedRoomId, text, resolvedOptions)
     }
-    const body: Record<string, unknown> = { roomId }
-    if (options?.markdown) body.markdown = text
+    const body: Record<string, unknown> = { roomId: resolvedRoomId }
+    if (resolvedOptions?.markdown) body.markdown = text
     else body.text = text
-    if (options?.parentId) body.parentId = options.parentId
-    if (options?.files?.length) body.files = options.files
+    if (resolvedOptions?.parentId) body.parentId = resolvedOptions.parentId
+    if (resolvedOptions?.files?.length) body.files = resolvedOptions.files
     return this.request<WebexMessage>('POST', '/messages', body)
   }
 
@@ -283,7 +345,7 @@ export class WebexClient {
   }
 
   private decodeConvUuid(roomId: string): string {
-    return Buffer.from(roomId, 'base64').toString('utf8').split('/').pop() ?? roomId
+    return decodeWebexId(roomId)?.uuid ?? roomId
   }
 
   private async internalRequest<T>(path: string, init?: RequestInit): Promise<T> {
@@ -315,11 +377,11 @@ export class WebexClient {
     }
 
     return {
-      id: a.id,
+      id: this.normalizeMessageId(a.id),
       roomId,
       roomType: 'group' as const,
       text,
-      personId: a.actor?.entryUUID ?? a.actor?.id ?? '',
+      personId: this.normalizePersonId(a.actor?.entryUUID ?? a.actor?.id ?? ''),
       personEmail: a.actor?.emailAddress ?? '',
       created: a.published,
     }
@@ -425,27 +487,31 @@ export class WebexClient {
     roomId: string,
     options?: { max?: number; mentionedPeople?: string; parentId?: string },
   ): Promise<WebexMessage[]> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
+    const resolvedOptions = await this.resolveListMessageOptions(options)
+
     if (this.useInternalAPI) {
-      const convUuid = this.decodeConvUuid(roomId)
-      const max = options?.max ?? 50
+      const convUuid = this.decodeConvUuid(resolvedRoomId)
+      const max = resolvedOptions?.max ?? 50
       const conv = await this.internalRequest<InternalConversation>(
         `/conversations/${convUuid}?activitiesLimit=${max}&participantsLimit=0`,
       )
       const activities = (conv.activities?.items ?? []).filter((a) => a.verb === 'post')
-      return Promise.all(activities.map((a) => this.activityToMessage(a, roomId)))
+      return Promise.all(activities.map((a) => this.activityToMessage(a, resolvedRoomId)))
     }
     const params = new URLSearchParams()
-    params.set('roomId', roomId)
-    params.set('max', String(options?.max ?? 50))
-    if (options?.mentionedPeople) params.set('mentionedPeople', options.mentionedPeople)
-    if (options?.parentId) params.set('parentId', options.parentId)
+    params.set('roomId', resolvedRoomId)
+    params.set('max', String(resolvedOptions?.max ?? 50))
+    if (resolvedOptions?.mentionedPeople) params.set('mentionedPeople', resolvedOptions.mentionedPeople)
+    if (resolvedOptions?.parentId) params.set('parentId', resolvedOptions.parentId)
     const data = await this.request<{ items: WebexMessage[] }>('GET', `/messages?${params}`)
     return data.items
   }
 
   async getMessage(messageId: string): Promise<WebexMessage> {
     if (this.useInternalAPI) {
-      const activity = await this.internalRequest<InternalActivity>(`/activities/${messageId}`)
+      const activityId = this.toMessageRef(messageId)
+      const activity = await this.internalRequest<InternalActivity>(`/activities/${activityId}`)
       const convId = activity.target?.id ?? ''
       // Internal API responses don't carry the cluster shard (e.g. `us-west-2_r`) the
       // public roomId encoding requires. The `unknown` placeholder is a sentinel — it
@@ -455,25 +521,26 @@ export class WebexClient {
       const roomId = convId ? Buffer.from(`ciscospark://urn:TEAM:unknown/ROOM/${convId}`).toString('base64') : ''
       return this.activityToMessage(activity, roomId)
     }
-    return this.request<WebexMessage>('GET', `/messages/${messageId}`)
+    return this.request<WebexMessage>('GET', `/messages/${this.resolveMessageId(messageId)}`)
   }
 
   async deleteMessage(messageId: string): Promise<void> {
     if (this.useInternalAPI) {
-      const activity = await this.internalRequest<InternalActivity>(`/activities/${messageId}`)
+      const activityId = this.toMessageRef(messageId)
+      const activity = await this.internalRequest<InternalActivity>(`/activities/${activityId}`)
       const convId = activity.target?.id
       if (!convId) throw new WebexError('Cannot determine conversation for activity', 'internal_error')
       await this.internalRequest<unknown>('/activities', {
         method: 'POST',
         body: JSON.stringify({
           verb: 'delete',
-          object: { id: messageId, objectType: 'activity' },
+          object: { id: activityId, objectType: 'activity' },
           target: { id: convId, objectType: 'conversation' },
         }),
       })
       return
     }
-    return this.request<void>('DELETE', `/messages/${messageId}`)
+    return this.request<void>('DELETE', `/messages/${this.resolveMessageId(messageId)}`)
   }
 
   async editMessage(
@@ -482,8 +549,11 @@ export class WebexClient {
     text: string,
     options?: { markdown?: boolean },
   ): Promise<WebexMessage> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
+
     if (this.useInternalAPI) {
-      const convUuid = this.decodeConvUuid(roomId)
+      const activityId = this.toMessageRef(messageId)
+      const convUuid = this.decodeConvUuid(resolvedRoomId)
       const { object, encryptionKeyUrl } = await this.buildEncryptedObject(convUuid, text, {
         ...options,
         forEdit: true,
@@ -493,7 +563,7 @@ export class WebexClient {
         verb: 'post',
         object,
         target: { id: convUuid, objectType: 'conversation' },
-        parent: { id: messageId, type: 'edit' },
+        parent: { id: activityId, type: 'edit' },
         clientTempId: `tmp-${Date.now()}-edit`,
       }
 
@@ -508,17 +578,17 @@ export class WebexClient {
 
       // Tolerate responses that omit `parent` (server may return minimal shape) —
       // only fail on an explicit mismatch between the echoed parent and the edited id.
-      if (result.parent && result.parent.id !== messageId) {
+      if (result.parent && result.parent.id !== activityId) {
         throw new WebexError(
-          `Edit rejected: server linked the new activity ${result.id} to ${result.parent.id} instead of ${messageId}.`,
+          `Edit rejected: server linked the new activity ${result.id} to ${result.parent.id} instead of ${activityId}.`,
           'edit_failed',
         )
       }
 
-      return this.activityToMessage(result, roomId)
+      return this.activityToMessage(result, resolvedRoomId)
     }
-    const body = options?.markdown ? { roomId, markdown: text } : { roomId, text }
-    return this.request<WebexMessage>('PUT', `/messages/${messageId}`, body)
+    const body = options?.markdown ? { roomId: resolvedRoomId, markdown: text } : { roomId: resolvedRoomId, text }
+    return this.request<WebexMessage>('PUT', `/messages/${this.resolveMessageId(messageId)}`, body)
   }
 
   async listPeople(options?: { email?: string; displayName?: string; max?: number }): Promise<WebexPerson[]> {
@@ -533,7 +603,14 @@ export class WebexClient {
   }
 
   async getPerson(personId: string): Promise<WebexPerson> {
-    return this.request<WebexPerson>('GET', `/people/${personId}`)
+    if (!decodeWebexId(personId) && looksLikeEmail(personId)) {
+      const [person] = await this.listPeople({ email: personId, max: 1 })
+      if (!person) {
+        throw new WebexError(`Person not found for ref: ${personId}`, 'not_found')
+      }
+      return person
+    }
+    return this.request<WebexPerson>('GET', `/people/${await this.resolvePersonId(personId)}`)
   }
 
   async listMyMemberships(options?: { max?: number }): Promise<WebexMembership[]> {
@@ -544,8 +621,9 @@ export class WebexClient {
   }
 
   async listMemberships(roomId: string, options?: { max?: number }): Promise<WebexMembership[]> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
     const params = new URLSearchParams()
-    params.set('roomId', roomId)
+    params.set('roomId', resolvedRoomId)
     if (options?.max) params.set('max', String(options.max))
     const data = await this.request<{ items: WebexMembership[] }>('GET', `/memberships?${params}`)
     return data.items
@@ -556,12 +634,14 @@ export class WebexClient {
     file: { content: Blob; filename: string },
     options?: { text?: string; markdown?: boolean; parentId?: string },
   ): Promise<WebexMessage> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
+    const resolvedParentId = options?.parentId ? this.resolveMessageId(options.parentId) : undefined
     const form = new FormData()
-    form.set('roomId', roomId)
+    form.set('roomId', resolvedRoomId)
     if (options?.text) {
       form.set(options.markdown ? 'markdown' : 'text', options.text)
     }
-    if (options?.parentId) form.set('parentId', options.parentId)
+    if (resolvedParentId) form.set('parentId', resolvedParentId)
     form.set('files', file.content, file.filename)
 
     const response = await fetch(`${BASE_URL}/messages`, {
@@ -577,6 +657,80 @@ export class WebexClient {
     return response.json() as Promise<WebexMessage>
   }
 
+  private async lookupRoomId(uuid: string, fallback: string): Promise<string> {
+    try {
+      // Page through every room the account belongs to, stopping as soon as the
+      // trailing UUID matches because room titles are not stable identifiers.
+      for await (const room of this.iterateSpaces({ max: 1000 })) {
+        if (decodeWebexId(room.id)?.uuid === uuid) {
+          this.clusteredRoomIds.set(uuid, room.id)
+          return room.id
+        }
+      }
+    } catch {
+      // Network/auth failure: fail open to the un-corrected id rather than block the call.
+      return fallback
+    }
+
+    console.warn(
+      `${this.roomResolutionWarningPrefix} Could not resolve clustered room id for ${uuid}; falling back to the un-clustered id. ` +
+        'Room-scoped calls may fail if this room lives on a non-default Webex cluster.',
+    )
+    return fallback
+  }
+
+  private resolveMessageOptions(options?: {
+    markdown?: boolean
+    parentId?: string
+    files?: string[]
+  }): { markdown?: boolean; parentId?: string; files?: string[] } | undefined {
+    if (!options?.parentId) return options
+    return { ...options, parentId: this.resolveMessageId(options.parentId) }
+  }
+
+  private async resolveListMessageOptions(options?: {
+    max?: number
+    mentionedPeople?: string
+    parentId?: string
+  }): Promise<{ max?: number; mentionedPeople?: string; parentId?: string } | undefined> {
+    if (!options) return undefined
+    const resolved = { ...options }
+    if (options.mentionedPeople) {
+      resolved.mentionedPeople = await this.resolveMentionedPeople(options.mentionedPeople)
+    }
+    if (options.parentId) {
+      resolved.parentId = this.resolveMessageId(options.parentId)
+    }
+    return resolved
+  }
+
+  private async resolveMentionedPeople(mentionedPeople: string): Promise<string> {
+    if (mentionedPeople === 'me') return mentionedPeople
+    return this.resolvePersonId(mentionedPeople)
+  }
+
+  private resolveMessageId(messageId: string): string {
+    if (!messageId || decodeWebexId(messageId)) return messageId
+    // A lone message UUID does not identify its room cluster, so cluster correction
+    // is not possible without the room context.
+    if (looksLikeUuid(messageId)) return toRestId(messageId, 'MESSAGE')
+    return messageId
+  }
+
+  private toMessageRef(messageId: string): string {
+    return decodeWebexId(messageId)?.uuid ?? messageId
+  }
+
+  private normalizeMessageId(messageId: string): string {
+    if (!messageId || decodeWebexId(messageId)) return messageId
+    return toRestId(messageId, 'MESSAGE')
+  }
+
+  private normalizePersonId(personId: string): string {
+    if (!personId || decodeWebexId(personId)) return personId
+    return toRestId(personId, 'PEOPLE')
+  }
+
   async downloadContent(contentRef: string): Promise<{ data: ArrayBuffer; filename: string; contentType: string }> {
     const url = this.resolveContentUrl(contentRef)
     const response = await fetch(url, {
@@ -638,6 +792,14 @@ function sanitizeFilename(name: string | undefined): string | undefined {
   return base
 }
 
+function looksLikeUuid(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)
+}
+
+function looksLikeEmail(value: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+}
+
 interface InternalActivity {
   id: string
   verb: string

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

@@ -9,6 +9,8 @@ import { WebexTokenExtractor } from '../token-extractor'
 import { WebexError } from '../types'
 import { extractAction, loginAction, logoutAction, oauthAction, statusAction } from './auth'
 
+const personId = Buffer.from('ciscospark://us/PEOPLE/person-1').toString('base64url')
+
 let promptQueue: string[] = []
 mock.module('node:readline/promises', () => ({
   createInterface: () => ({
@@ -33,7 +35,7 @@ describe('auth commands', () => {
   let originalStdinTTY: boolean | undefined
   let originalStdoutTTY: boolean | undefined
   const mockPerson = {
-    id: 'person-1',
+    id: personId,
     displayName: 'Test User',
     emails: ['test@example.com'],
     orgId: 'org-1',

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

@@ -12,6 +12,7 @@ import { info, debug, error as stderrError } from '@/shared/utils/stderr'
 import { getWebexAppCredentials } from '../app-config'
 import { WebexClient } from '../client'
 import { WebexCredentialManager } from '../credential-manager'
+import { toRef } from '../id-normalizer'
 import { loginWithPassword, WEB_CLIENT_ID, WEB_CLIENT_SECRET } from '../password-login'
 import { WebexTokenExtractor } from '../token-extractor'
 import { WebexError } from '../types'
@@ -21,6 +22,10 @@ interface ResolvedCredentials {
   clientSecret: string
 }
 
+function formatAuthUser(person: { id: string; displayName: string; emails: string[] }) {
+  return { id: person.id, ref: toRef(person.id), displayName: person.displayName, emails: person.emails }
+}
+
 async function openBrowser(url: string): Promise<void> {
   const { exec } = await import('node:child_process')
   const command =
@@ -170,7 +175,7 @@ async function loginWithToken(credManager: WebexCredentialManager, token: string
   console.log(
     formatOutput(
       {
-        user: { id: person.id, displayName: person.displayName, emails: person.emails },
+        user: formatAuthUser(person),
         authenticated: true,
       },
       pretty,
@@ -205,7 +210,7 @@ async function loginWithEmailPassword(
     formatOutput(
       {
         authenticated: true,
-        user: { id: person.id, displayName: person.displayName, emails: person.emails },
+        user: formatAuthUser(person),
       },
       options.pretty,
     ),
@@ -259,7 +264,7 @@ export async function oauthAction(options: OAuthOptions): Promise<void> {
     console.log(
       formatOutput(
         {
-          user: { id: person.id, displayName: person.displayName, emails: person.emails },
+          user: formatAuthUser(person),
           authenticated: true,
         },
         options.pretty,
@@ -308,7 +313,7 @@ async function finishDeviceGrant(credManager: WebexCredentialManager, options: O
       formatOutput(
         {
           authenticated: true,
-          user: { id: person.id, displayName: person.displayName, emails: person.emails },
+          user: formatAuthUser(person),
         },
         options.pretty,
       ),
@@ -364,7 +369,7 @@ export async function statusAction(options: { pretty?: boolean }): Promise<void>
         formatOutput(
           {
             authenticated: true,
-            user: { id: person.id, displayName: person.displayName, emails: person.emails },
+            user: formatAuthUser(person),
           },
           options.pretty,
         ),
@@ -436,11 +441,11 @@ export async function extractAction(options: {
       tokenType: 'extracted',
     })
 
-    let person: { id: string; displayName: string; emails: string[] } | null = null
+    let person: ReturnType<typeof formatAuthUser> | null = null
     try {
       const result = await client.testAuth()
       if (result.id) {
-        person = { id: result.id, displayName: result.displayName, emails: result.emails }
+        person = formatAuthUser(result)
       }
     } catch (authError) {
       const isAuthFailure =

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

@@ -3,20 +3,26 @@ import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test'
 import { WebexClient } from '../client'
 import { WebexError } from '../types'
 
+const restId = (type: string, ref: string) => Buffer.from(`ciscospark://us/${type}/${ref}`).toString('base64url')
+const member1Id = restId('MEMBERSHIP', 'person-1:room-1')
+const member2Id = restId('MEMBERSHIP', 'person-2:room-1')
+const person1Id = restId('PEOPLE', 'person-1')
+const person2Id = restId('PEOPLE', 'person-2')
+
 const mockMembers = [
   {
-    id: 'mem-1',
+    id: member1Id,
     roomId: 'room-1',
-    personId: 'person-1',
+    personId: person1Id,
     personEmail: 'alice@example.com',
     personDisplayName: 'Alice',
     isModerator: true,
     created: '2024-01-01T00:00:00.000Z',
   },
   {
-    id: 'mem-2',
+    id: member2Id,
     roomId: 'room-1',
-    personId: 'person-2',
+    personId: person2Id,
     personEmail: 'bob@example.com',
     personDisplayName: 'Bob',
     isModerator: false,
@@ -66,16 +72,20 @@ describe('member commands', () => {
     expect(consoleSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
-          id: 'mem-1',
-          personId: 'person-1',
+          id: member1Id,
+          ref: 'person-1:room-1',
+          personId: person1Id,
+          personRef: 'person-1',
           personEmail: 'alice@example.com',
           personDisplayName: 'Alice',
           isModerator: true,
           created: '2024-01-01T00:00:00.000Z',
         },
         {
-          id: 'mem-2',
-          personId: 'person-2',
+          id: member2Id,
+          ref: 'person-2:room-1',
+          personId: person2Id,
+          personRef: 'person-2',
           personEmail: 'bob@example.com',
           personDisplayName: 'Bob',
           isModerator: false,

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

@@ -4,6 +4,7 @@ import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 
 import { WebexClient } from '../client'
+import { toRef } from '../id-normalizer'
 
 export async function listAction(spaceId: string, options: { limit?: number; pretty?: boolean }): Promise<void> {
   try {
@@ -12,7 +13,9 @@ export async function listAction(spaceId: string, options: { limit?: number; pre
 
     const output = members.map((m) => ({
       id: m.id,
+      ref: toRef(m.id),
       personId: m.personId,
+      personRef: toRef(m.personId),
       personEmail: m.personEmail,
       personDisplayName: m.personDisplayName,
       isModerator: m.isModerator,

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

@@ -1,26 +1,32 @@
 import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
+import { toRestId } from '../id-normalizer'
 import { WebexError } from '../types'
 
+const messageId = toRestId('msg_123', 'MESSAGE')
+const message2Id = toRestId('msg_124', 'MESSAGE')
+const roomId = toRestId('space_456', 'ROOM')
+const personId = toRestId('person_789', 'PEOPLE')
+
 const mockMessage = {
-  id: 'msg_123',
-  roomId: 'space_456',
+  id: messageId,
+  roomId,
   roomType: 'group' as const,
   text: 'Hello world',
   html: '<p>Hello <a href="https://example.com">world</a></p>',
-  personId: 'person_789',
+  personId,
   personEmail: 'user@example.com',
   created: '2025-01-29T10:00:00.000Z',
 }
 
 const mockMessage2 = {
-  id: 'msg_124',
-  roomId: 'space_456',
+  id: message2Id,
+  roomId,
   roomType: 'group' as const,
   text: 'Second message',
   html: '<p>Second message</p>',
-  personId: 'person_789',
+  personId,
   personEmail: 'user@example.com',
   created: '2025-01-29T10:01:00.000Z',
 }
@@ -78,10 +84,12 @@ it('calls sendMessage with correct args and outputs result', async () => {
     markdown: undefined,
   })
   expect(consoleLogSpy).toHaveBeenCalled()
-  const output = consoleLogSpy.mock.calls[0][0]
-  expect(output).toContain('msg_123')
-  expect(output).toContain('space_456')
-  expect(output).toContain('user@example.com')
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+  expect(output.id).toBe(messageId)
+  expect(output.ref).toBe('msg_123')
+  expect(output.roomId).toBe(roomId)
+  expect(output.roomRef).toBe('space_456')
+  expect(output.personEmail).toBe('user@example.com')
   expect(mockDispose).toHaveBeenCalled()
 })
 
@@ -115,8 +123,8 @@ it('calls sendDirectMessage with email and text', async () => {
     markdown: undefined,
   })
   expect(consoleLogSpy).toHaveBeenCalled()
-  const output = consoleLogSpy.mock.calls[0][0]
-  expect(output).toContain('msg_123')
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+  expect(output.ref).toBe('msg_123')
 })
 
 it('passes markdown option to sendDirectMessage when --markdown flag is set', async () => {
@@ -132,10 +140,10 @@ it('calls listMessages with limit and outputs array', async () => {
 
   expect(mockListMessages).toHaveBeenCalledWith('space_456', { max: 50 })
   expect(consoleLogSpy).toHaveBeenCalled()
-  const output = consoleLogSpy.mock.calls[0][0]
-  expect(output).toContain('msg_123')
-  expect(output).toContain('msg_124')
-  expect(output).toContain('https://example.com')
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+  expect(output[0].ref).toBe('msg_123')
+  expect(output[1].ref).toBe('msg_124')
+  expect(output[0].html).toContain('https://example.com')
 })
 
 it('calls getMessage with correct id and outputs result', async () => {
@@ -143,10 +151,10 @@ it('calls getMessage with correct id and outputs result', async () => {
 
   expect(mockGetMessage).toHaveBeenCalledWith('msg_123')
   expect(consoleLogSpy).toHaveBeenCalled()
-  const output = consoleLogSpy.mock.calls[0][0]
-  expect(output).toContain('msg_123')
-  expect(output).toContain('user@example.com')
-  expect(output).toContain('https://example.com')
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+  expect(output.ref).toBe('msg_123')
+  expect(output.personEmail).toBe('user@example.com')
+  expect(output.html).toContain('https://example.com')
 })
 
 it('calls deleteMessage and outputs deleted id when --force flag is set', async () => {
@@ -178,9 +186,9 @@ it('calls editMessage with roomId in args and outputs result', async () => {
     markdown: undefined,
   })
   expect(consoleLogSpy).toHaveBeenCalled()
-  const output = consoleLogSpy.mock.calls[0][0]
-  expect(output).toContain('msg_123')
-  expect(output).toContain('Updated message')
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+  expect(output.ref).toBe('msg_123')
+  expect(output.text).toBe('Updated message')
   expect(mockDispose).toHaveBeenCalled()
 })