agent-messenger 2.23.1 → 2.23.2

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

@@ -4,12 +4,15 @@ import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 
 import { WebexClient } from '../client'
+import { toRef } from '../id-normalizer'
 import type { WebexMessage } from '../types'
 
 function formatMessageOutput(message: WebexMessage) {
   return {
     id: message.id,
+    ref: toRef(message.id),
     roomId: message.roomId,
+    roomRef: toRef(message.roomId),
     text: message.text,
     html: message.html,
     personEmail: message.personEmail,

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

@@ -3,32 +3,38 @@ 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 space1Id = restId('ROOM', 'space-1')
+const space2Id = restId('ROOM', 'space-2')
+const member1Id = restId('MEMBERSHIP', 'person-1:space-1')
+const person1Id = restId('PEOPLE', 'person-1')
+
 const mockSpaces = [
   {
-    id: 'space-1',
+    id: space1Id,
     title: 'General',
     type: 'group',
     isLocked: false,
     lastActivity: '2024-01-15T00:00:00.000Z',
     created: '2024-01-01T00:00:00.000Z',
-    creatorId: 'person-1',
+    creatorId: person1Id,
   },
   {
-    id: 'space-2',
+    id: space2Id,
     title: 'Random',
     type: 'group',
     isLocked: false,
     lastActivity: '2024-01-14T00:00:00.000Z',
     created: '2024-01-01T00:00:00.000Z',
-    creatorId: 'person-1',
+    creatorId: person1Id,
   },
 ]
 
 const mockMyMemberships = [
   {
-    id: 'mem-1',
-    roomId: 'space-1',
-    personId: 'person-1',
+    id: member1Id,
+    roomId: space1Id,
+    personId: person1Id,
     personEmail: 'alice@example.com',
     personDisplayName: 'Alice',
     isModerator: true,
@@ -77,7 +83,8 @@ describe('snapshot command', () => {
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
     expect(output.spaces).toHaveLength(1)
-    expect(output.spaces[0].id).toBe('space-1')
+    expect(output.spaces[0].id).toBe(space1Id)
+    expect(output.spaces[0].ref).toBe('space-1')
     expect(output.spaces[0].title).toBe('General')
     expect(output.spaces[0].type).toBeUndefined()
     expect(output.hint).toBeDefined()
@@ -89,7 +96,8 @@ describe('snapshot command', () => {
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
     expect(output.spaces).toHaveLength(1)
-    expect(output.spaces[0].id).toBe('space-1')
+    expect(output.spaces[0].id).toBe(space1Id)
+    expect(output.spaces[0].ref).toBe('space-1')
     expect(output.spaces[0].title).toBe('General')
     expect(output.spaces[0].type).toBe('group')
     expect(output.spaces[0].lastActivity).toBe('2024-01-15T00:00:00.000Z')
@@ -101,7 +109,7 @@ describe('snapshot command', () => {
 
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
     expect(output.spaces).toHaveLength(1)
-    expect(output.spaces[0].id).toBe('space-1')
+    expect(output.spaces[0].id).toBe(space1Id)
   })
 
   it('exits with code 1 when not authenticated', async () => {

package/src/platforms/webex/commands/snapshot.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 snapshotAction(options: { full?: boolean; pretty?: boolean }): Promise<void> {
   try {
@@ -19,11 +20,12 @@ export async function snapshotAction(options: { full?: boolean; pretty?: boolean
       spaces: options.full
         ? spaces.map((s) => ({
             id: s.id,
+            ref: toRef(s.id),
             title: s.title,
             type: s.type,
             lastActivity: s.lastActivity,
           }))
-        : spaces.map((s) => ({ id: s.id, title: s.title })),
+        : spaces.map((s) => ({ id: s.id, ref: toRef(s.id), title: s.title })),
     }
 
     if (!options.full) {

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

@@ -3,36 +3,43 @@ 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 space1Id = restId('ROOM', 'space-1')
+const space2Id = restId('ROOM', 'space-2')
+const person1Id = restId('PEOPLE', 'person-1')
+const person2Id = restId('PEOPLE', 'person-2')
+const teamId = restId('TEAM', 'team-abc')
+
 const mockSpaces = [
   {
-    id: 'space-1',
+    id: space1Id,
     title: 'General',
     type: 'group' as const,
     isLocked: false,
     lastActivity: '2024-01-02T00:00:00.000Z',
     created: '2024-01-01T00:00:00.000Z',
-    creatorId: 'person-1',
+    creatorId: person1Id,
   },
   {
-    id: 'space-2',
+    id: space2Id,
     title: 'Direct with Alice',
     type: 'direct' as const,
     isLocked: false,
     lastActivity: '2024-01-03T00:00:00.000Z',
     created: '2024-01-01T00:00:00.000Z',
-    creatorId: 'person-2',
+    creatorId: person2Id,
   },
 ]
 
 const mockSpace = {
-  id: 'space-1',
+  id: space1Id,
   title: 'General',
   type: 'group' as const,
   isLocked: false,
-  teamId: 'team-abc',
+  teamId,
   lastActivity: '2024-01-02T00:00:00.000Z',
   created: '2024-01-01T00:00:00.000Z',
-  creatorId: 'person-1',
+  creatorId: person1Id,
 }
 
 import { infoAction, listAction } from './space'
@@ -79,14 +86,16 @@ describe('listAction', () => {
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
-          id: 'space-1',
+          id: space1Id,
+          ref: 'space-1',
           title: 'General',
           type: 'group',
           lastActivity: '2024-01-02T00:00:00.000Z',
           created: '2024-01-01T00:00:00.000Z',
         },
         {
-          id: 'space-2',
+          id: space2Id,
+          ref: 'space-2',
           title: 'Direct with Alice',
           type: 'direct',
           lastActivity: '2024-01-03T00:00:00.000Z',
@@ -115,14 +124,16 @@ describe('listAction', () => {
       JSON.stringify(
         [
           {
-            id: 'space-1',
+            id: space1Id,
+            ref: 'space-1',
             title: 'General',
             type: 'group',
             lastActivity: '2024-01-02T00:00:00.000Z',
             created: '2024-01-01T00:00:00.000Z',
           },
           {
-            id: 'space-2',
+            id: space2Id,
+            ref: 'space-2',
             title: 'Direct with Alice',
             type: 'direct',
             lastActivity: '2024-01-03T00:00:00.000Z',
@@ -152,14 +163,17 @@ describe('infoAction', () => {
     expect(mockGetSpace).toHaveBeenCalledWith('space-1')
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify({
-        id: 'space-1',
+        id: space1Id,
+        ref: 'space-1',
         title: 'General',
         type: 'group',
         isLocked: false,
-        teamId: 'team-abc',
+        teamId,
+        teamRef: 'team-abc',
         lastActivity: '2024-01-02T00:00:00.000Z',
         created: '2024-01-01T00:00:00.000Z',
-        creatorId: 'person-1',
+        creatorId: person1Id,
+        creatorRef: 'person-1',
       }),
     )
   })
@@ -171,8 +185,10 @@ describe('infoAction', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string) as {
       teamId: null
+      teamRef: null
     }
     expect(output.teamId).toBeNull()
+    expect(output.teamRef).toBeNull()
   })
 
   it('outputs pretty-printed JSON when pretty is true', async () => {
@@ -181,14 +197,17 @@ describe('infoAction', () => {
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify(
         {
-          id: 'space-1',
+          id: space1Id,
+          ref: 'space-1',
           title: 'General',
           type: 'group',
           isLocked: false,
-          teamId: 'team-abc',
+          teamId,
+          teamRef: 'team-abc',
           lastActivity: '2024-01-02T00:00:00.000Z',
           created: '2024-01-01T00:00:00.000Z',
-          creatorId: 'person-1',
+          creatorId: person1Id,
+          creatorRef: 'person-1',
         },
         null,
         2,

package/src/platforms/webex/commands/space.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(options: { type?: string; limit?: number; pretty?: boolean }): Promise<void> {
   try {
@@ -11,6 +12,7 @@ export async function listAction(options: { type?: string; limit?: number; prett
     const spaces = await client.listSpaces({ type: options.type, max: options.limit })
     const output = spaces.map((s) => ({
       id: s.id,
+      ref: toRef(s.id),
       title: s.title,
       type: s.type,
       lastActivity: s.lastActivity,
@@ -28,13 +30,16 @@ export async function infoAction(spaceId: string, options: { pretty?: boolean })
     const space = await client.getSpace(spaceId)
     const output = {
       id: space.id,
+      ref: toRef(space.id),
       title: space.title,
       type: space.type,
       isLocked: space.isLocked,
       teamId: space.teamId || null,
+      teamRef: space.teamId ? toRef(space.teamId) : null,
       lastActivity: space.lastActivity,
       created: space.created,
       creatorId: space.creatorId,
+      creatorRef: toRef(space.creatorId),
     }
     console.log(formatOutput(output, options.pretty))
   } catch (error) {

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

@@ -1,18 +1,22 @@
 import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
+import { toRestId } from '../id-normalizer'
 import { WebexError } from '../types'
 import { whoamiCommand } from './whoami'
 
+const orgId = Buffer.from('ciscospark://us/ORGANIZATION/org-123').toString('base64url')
+const personId = toRestId('person-123', 'PEOPLE')
+
 const mockUser = {
-  id: 'person-123',
+  id: personId,
   emails: ['test@example.com'],
   displayName: 'Test User',
   nickName: 'Testy',
   firstName: 'Test',
   lastName: 'User',
   avatar: 'https://example.com/avatar.jpg',
-  orgId: 'org-123',
+  orgId,
   type: 'person' as const,
   created: '2024-01-01T00:00:00.000Z',
 }
@@ -58,14 +62,16 @@ it('whoami calls testAuth and outputs user fields', async () => {
   // then: outputs all expected fields
   expect(consoleLogSpy).toHaveBeenCalledWith(
     JSON.stringify({
-      id: 'person-123',
+      id: personId,
+      ref: 'person-123',
       emails: ['test@example.com'],
       displayName: 'Test User',
       nickName: 'Testy',
       firstName: 'Test',
       lastName: 'User',
       avatar: 'https://example.com/avatar.jpg',
-      orgId: 'org-123',
+      orgId,
+      orgRef: 'org-123',
       type: 'person',
     }),
   )
@@ -80,14 +86,16 @@ it('whoami outputs pretty-printed JSON when --pretty flag is passed', async () =
   expect(consoleLogSpy).toHaveBeenCalledWith(
     JSON.stringify(
       {
-        id: 'person-123',
+        id: personId,
+        ref: 'person-123',
         emails: ['test@example.com'],
         displayName: 'Test User',
         nickName: 'Testy',
         firstName: 'Test',
         lastName: 'User',
         avatar: 'https://example.com/avatar.jpg',
-        orgId: 'org-123',
+        orgId,
+        orgRef: 'org-123',
         type: 'person',
       },
       null,

package/src/platforms/webex/commands/whoami.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 whoamiAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -12,6 +13,7 @@ export async function whoamiAction(options: { pretty?: boolean }): Promise<void>
 
     const output = {
       id: user.id,
+      ref: toRef(user.id),
       emails: user.emails,
       displayName: user.displayName,
       nickName: user.nickName,
@@ -19,6 +21,7 @@ export async function whoamiAction(options: { pretty?: boolean }): Promise<void>
       lastName: user.lastName,
       avatar: user.avatar,
       orgId: user.orgId,
+      orgRef: toRef(user.orgId),
       type: user.type,
     }
     console.log(formatOutput(output, options.pretty))

package/src/platforms/webex/id-normalizer.test.ts

@@ -17,6 +17,7 @@ import {
   normalizeMessage,
   normalizeRoomActivity,
   toRestId,
+  toRef,
 } from './id-normalizer'
 
 const RAW: MercuryActivity = {
@@ -28,6 +29,8 @@ const RAW: MercuryActivity = {
   published: '2024-01-01T00:00:00Z',
 }
 
+const restId = (type: string, ref: string) => Buffer.from(`ciscospark://us/${type}/${ref}`).toString('base64url')
+
 describe('toRestId / fromRestId', () => {
   it('encodes a uuid into a ciscospark REST id round-trippable to the uuid', () => {
     const restId = toRestId('abc-123', 'PEOPLE')
@@ -58,6 +61,40 @@ describe('toRestId / fromRestId', () => {
   })
 })
 
+describe('toRef', () => {
+  it('returns a room uuid ref', () => {
+    const uuid = '12345678-1234-1234-1234-1234567890ab'
+
+    expect(toRef(toRestId(uuid, 'ROOM'))).toBe(uuid)
+  })
+
+  it('returns a person uuid ref', () => {
+    const uuid = '22222222-2222-2222-2222-222222222222'
+
+    expect(toRef(toRestId(uuid, 'PEOPLE'))).toBe(uuid)
+  })
+
+  it('returns a legacy person email ref', () => {
+    expect(toRef(toRestId('legacy@example.com', 'PEOPLE'))).toBe('legacy@example.com')
+  })
+
+  it('returns an organization uuid ref', () => {
+    const uuid = '33333333-3333-3333-3333-333333333333'
+
+    expect(toRef(restId('ORGANIZATION', uuid))).toBe(uuid)
+  })
+
+  it('returns a membership person-room pair ref', () => {
+    const membershipRef = '44444444-4444-4444-4444-444444444444:55555555-5555-5555-5555-555555555555'
+
+    expect(toRef(restId('MEMBERSHIP', membershipRef))).toBe(membershipRef)
+  })
+
+  it('returns empty input unchanged', () => {
+    expect(toRef('')).toBe('')
+  })
+})
+
 describe('normalizeMessage', () => {
   const message: DecryptedMessage = {
     id: 'msg-uuid',

package/src/platforms/webex/id-normalizer.ts

@@ -13,6 +13,27 @@ export { fromRestId }
 // (the resource type behind GET /v1/attachment/actions).
 export type WebexRestIdType = 'MESSAGE' | 'PEOPLE' | 'ROOM' | 'ATTACHMENT_ACTION'
 
+export interface DecodedWebexId {
+  cluster: string
+  type: string
+  uuid: string
+}
+
+export function toRef(id: string): string {
+  if (!id) return id
+  return fromRestId(id)
+}
+
+// Webex REST ids are base64(url) of `ciscospark://<cluster>/<TYPE>/<uuid>`; room
+// cluster correction needs all three parts, not just the trailing ref value.
+export function decodeWebexId(restId: string): DecodedWebexId | null {
+  if (!restId) return null
+  const decoded = Buffer.from(restId, 'base64').toString('utf-8')
+  const match = decoded.match(/^ciscospark:\/\/([^/]+)\/([^/]+)\/(.+)$/)
+  if (!match) return null
+  return { cluster: match[1], type: match[2], uuid: match[3] }
+}
+
 /**
  * Encode a raw Mercury UUID as a Webex REST ID. Empty input is returned unchanged
  * so an absent ID never becomes a bogus `ciscospark://us/{TYPE}/` value.

package/src/platforms/webex/index.ts

@@ -1,7 +1,7 @@
 export { WebexClient } from './client'
 export { WebexCredentialManager } from './credential-manager'
-export { fromRestId, toRestId } from './id-normalizer'
-export type { WebexRestIdType } from './id-normalizer'
+export { decodeWebexId, fromRestId, toRef, toRestId } from './id-normalizer'
+export type { DecodedWebexId, WebexRestIdType } from './id-normalizer'
 export { WebexListener } from './listener'
 export type { WebexListenerClient, WebexListenerEventMap, WebexListenerOptions } from './listener'
 export { loginWithPassword } from './password-login'

package/src/platforms/webexbot/client.ts

@@ -2,33 +2,10 @@ import { WebexClient } from '../webex/client'
 import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from '../webex/types'
 import { WebexBotError } from './types'
 
-interface DecodedWebexId {
-  cluster: string
-  type: string
-  uuid: string
-}
-
-// Webex REST ids are base64(url) of `ciscospark://<cluster>/<TYPE>/<uuid>`; the
-// cluster correction needs all three parts, not just the <uuid> `fromRestId` returns.
-function decodeWebexId(restId: string): DecodedWebexId | null {
-  if (!restId) return null
-  const decoded = Buffer.from(restId, 'base64').toString('utf-8')
-  const match = decoded.match(/^ciscospark:\/\/([^/]+)\/([^/]+)\/(.+)$/)
-  if (!match) return null
-  return { cluster: match[1], type: match[2], uuid: match[3] }
-}
-
 export class WebexBotClient {
-  private client = new WebexClient()
+  private client = new WebexClient({ roomResolutionWarningPrefix: '[webexbot]' })
   private token: string | null = null
 
-  // The listener flattens room ids to `ciscospark://us/ROOM/<uuid>`, but team/group
-  // rooms live on `ciscospark://urn:TEAM:<cluster>/ROOM/<uuid>` — a cluster the bare
-  // uuid cannot recover. Cache the real clustered id per uuid and dedupe concurrent
-  // lookups so a burst of calls triggers a single `listSpaces`.
-  private clusteredRoomIds = new Map<string, string>()
-  private roomIdLookups = new Map<string, Promise<string>>()
-
   async login(credentials?: { token: string }): Promise<this> {
     if (credentials) {
       if (!credentials.token) {
@@ -64,7 +41,7 @@ export class WebexBotClient {
   }
 
   async getSpace(spaceId: string): Promise<WebexSpace> {
-    return this.client.getSpace(await this.resolveRoomId(spaceId))
+    return this.client.getSpace(spaceId)
   }
 
   async sendMessage(
@@ -72,7 +49,7 @@ export class WebexBotClient {
     text: string,
     options?: { markdown?: boolean; parentId?: string; files?: string[] },
   ): Promise<WebexMessage> {
-    return this.client.sendMessage(await this.resolveRoomId(roomId), text, options)
+    return this.client.sendMessage(roomId, text, options)
   }
 
   async sendDirectMessage(personEmail: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
@@ -80,14 +57,14 @@ export class WebexBotClient {
   }
 
   async listMessages(roomId: string, options?: { max?: number; parentId?: string }): Promise<WebexMessage[]> {
-    const resolvedRoomId = await this.resolveRoomId(roomId)
+    const resolvedRoomId = await this.client.resolveRoomId(roomId)
     const space = await this.client.getSpace(resolvedRoomId)
     const messageOptions = space.type === 'group' ? { ...options, mentionedPeople: 'me' } : options
     return this.client.listMessages(resolvedRoomId, messageOptions)
   }
 
   async listReplies(roomId: string, parentId: string, options?: { max?: number }): Promise<WebexMessage[]> {
-    return this.client.listMessages(await this.resolveRoomId(roomId), { ...options, parentId })
+    return this.client.listMessages(roomId, { ...options, parentId })
   }
 
   async getMessage(messageId: string): Promise<WebexMessage> {
@@ -108,7 +85,7 @@ export class WebexBotClient {
     text: string,
     options?: { markdown?: boolean },
   ): Promise<WebexMessage> {
-    return this.client.editMessage(messageId, await this.resolveRoomId(roomId), text, options)
+    return this.client.editMessage(messageId, roomId, text, options)
   }
 
   async listPeople(options?: { email?: string; displayName?: string; max?: number }): Promise<WebexPerson[]> {
@@ -124,7 +101,7 @@ export class WebexBotClient {
   }
 
   async listMemberships(roomId: string, options?: { max?: number }): Promise<WebexMembership[]> {
-    return this.client.listMemberships(await this.resolveRoomId(roomId), options)
+    return this.client.listMemberships(roomId, options)
   }
 
   async uploadFile(
@@ -132,53 +109,10 @@ export class WebexBotClient {
     file: { content: Blob; filename: string },
     options?: { text?: string; markdown?: boolean; parentId?: string },
   ): Promise<WebexMessage> {
-    return this.client.uploadFile(await this.resolveRoomId(roomId), file, options)
+    return this.client.uploadFile(roomId, file, options)
   }
 
   async downloadContent(contentRef: string): Promise<{ data: ArrayBuffer; filename: string; contentType: string }> {
     return this.client.downloadContent(contentRef)
   }
-
-  private async resolveRoomId(roomId: string): Promise<string> {
-    const decoded = decodeWebexId(roomId)
-    // Already cluster-qualified or undecodable: nothing to correct.
-    if (!decoded || decoded.cluster.startsWith('urn:')) return roomId
-
-    const { uuid } = decoded
-    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, roomId)
-    this.roomIdLookups.set(uuid, lookup)
-    try {
-      return await lookup
-    } finally {
-      this.roomIdLookups.delete(uuid)
-    }
-  }
-
-  private async lookupRoomId(uuid: string, fallback: string): Promise<string> {
-    try {
-      // Page through every room the bot belongs to (largest page size, following
-      // `Link` pages), stopping as soon as the trailing UUID matches.
-      for await (const room of this.client.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(
-      `[webexbot] 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
-  }
 }

package/src/platforms/webexbot/commands/file.ts

@@ -5,12 +5,15 @@ import { Command } from 'commander'
 
 import { cliOutput } from '@/shared/utils/cli-output'
 
+import { toRef } from '../../webex/id-normalizer'
 import type { BotOption } from './shared'
 import { getClient } from './shared'
 
 interface FileResult {
   id?: string
+  ref?: string
   roomId?: string
+  roomRef?: string
   files?: string[]
   created?: string
   downloaded?: string
@@ -37,7 +40,9 @@ export async function uploadAction(
 
     return {
       id: message.id,
+      ref: toRef(message.id),
       roomId: message.roomId,
+      roomRef: toRef(message.roomId),
       files: message.files,
       created: message.created,
     }

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

@@ -2,13 +2,16 @@ import { Command } from 'commander'
 
 import { cliOutput } from '@/shared/utils/cli-output'
 
+import { toRef } from '../../webex/id-normalizer'
 import type { BotOption } from './shared'
 import { getClient } from './shared'
 
 interface MemberResult {
   members?: Array<{
     id: string
+    ref: string
     personId: string
+    personRef: string
     personEmail: string
     personDisplayName: string
     isModerator: boolean
@@ -26,7 +29,9 @@ export async function listAction(space: string, options: BotOption & { max?: str
     return {
       members: 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,