agent-messenger 2.6.3 → 2.8.0

package/src/platforms/telegram/chat-utils.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+
 import { findFuzzyChats, mergeChats, normalizeChatSearchText } from './chat-utils'
 
 describe('normalizeChatSearchText', () => {
@@ -56,7 +57,10 @@ describe('findFuzzyChats', () => {
 
 describe('mergeChats', () => {
   const a = [{ id: 1, title: 'A', type: 'group' }] as any[]
-  const b = [{ id: 1, title: 'A', type: 'group' }, { id: 2, title: 'B', type: 'group' }] as any[]
+  const b = [
+    { id: 1, title: 'A', type: 'group' },
+    { id: 2, title: 'B', type: 'group' },
+  ] as any[]
 
   test('deduplicates by id', () => {
     const result = mergeChats(a, b)

package/src/platforms/telegram/cli.ts

@@ -1,15 +1,13 @@
 #!/usr/bin/env bun
 
 import { Command } from 'commander'
+
 import pkg from '../../../package.json' with { type: 'json' }
 import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands'
 
 const program = new Command()
 
-program
-  .name('agent-telegram')
-  .description('CLI tool for Telegram communication via TDLib')
-  .version(pkg.version)
+program.name('agent-telegram').description('CLI tool for Telegram communication via TDLib').version(pkg.version)
 
 program.addCommand(authCommand)
 program.addCommand(chatCommand)

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

@@ -1,4 +1,5 @@
 import { describe, expect, mock, test } from 'bun:test'
+
 import { TelegramTdlibClient } from './client'
 import type { TelegramAccount, TelegramAccountPaths } from './types'
 
@@ -62,14 +63,20 @@ describe('listChats', () => {
           events.push({ '@type': 'ok', '@extra': request['@extra'] })
         } else {
           // given — third call returns 404 (all chats loaded)
-          events.push({ '@type': 'error', code: 404, message: 'Chat list has been loaded completely', '@extra': request['@extra'] })
+          events.push({
+            '@type': 'error',
+            code: 404,
+            message: 'Chat list has been loaded completely',
+            '@extra': request['@extra'],
+          })
         }
         return
       }
 
       if (request['@type'] === 'getChats') {
         // when — after first two loadChats calls, return partial; after 404, return all
-        const returnCount = loadChatsCallCount >= 3 ? allChatIds.length : Math.min(loadChatsCallCount * 2, allChatIds.length)
+        const returnCount =
+          loadChatsCallCount >= 3 ? allChatIds.length : Math.min(loadChatsCallCount * 2, allChatIds.length)
         events.push({
           '@type': 'chats',
           total_count: returnCount,
@@ -81,7 +88,13 @@ describe('listChats', () => {
 
       if (request['@type'] === 'getChat') {
         const chatId = request.chat_id
-        const typeNames = ['chatTypePrivate', 'chatTypePrivate', 'chatTypeBasicGroup', 'chatTypeSupergroup', 'chatTypeSupergroup']
+        const typeNames = [
+          'chatTypePrivate',
+          'chatTypePrivate',
+          'chatTypeBasicGroup',
+          'chatTypeSupergroup',
+          'chatTypeSupergroup',
+        ]
         const idx = allChatIds.indexOf(chatId)
         events.push({
           '@type': 'chat',

package/src/platforms/telegram/client.ts

@@ -1,4 +1,5 @@
 import { mkdir } from 'node:fs/promises'
+
 import pkg from '../../../package.json' with { type: 'json' }
 import { findFuzzyChats, mergeChats, normalizeChatSearchText } from './chat-utils'
 import { TdjsonBinding } from './tdlib'
@@ -90,7 +91,9 @@ export class TelegramTdlibClient {
         application_version: `agent-messenger/${pkg.version}`,
       })
 
-      state = (await this.waitForAuthorizationStateChange('authorizationStateWaitTdlibParameters')) as TdAuthorizationState
+      state = (await this.waitForAuthorizationStateChange(
+        'authorizationStateWaitTdlibParameters',
+      )) as TdAuthorizationState
     }
 
     return state
@@ -431,7 +434,9 @@ export class TelegramTdlibClient {
       }
 
       const chats = await this.searchChats(reference, 20)
-      const exactMatch = chats.find((chat) => normalizeChatSearchText(chat.title) === normalizeChatSearchText(reference))
+      const exactMatch = chats.find(
+        (chat) => normalizeChatSearchText(chat.title) === normalizeChatSearchText(reference),
+      )
 
       if (exactMatch) {
         return this.call({
@@ -490,7 +495,9 @@ export class TelegramTdlibClient {
       const pending = this.pendingMessages.get(update.old_message_id)
       if (pending) {
         this.pendingMessages.delete(update.old_message_id)
-        pending.reject(new TelegramError(update.error_message ?? 'Message send failed', update.error_code ?? 'send_failed'))
+        pending.reject(
+          new TelegramError(update.error_message ?? 'Message send failed', update.error_code ?? 'send_failed'),
+        )
       }
       return event
     }
@@ -527,7 +534,10 @@ export class TelegramTdlibClient {
       this.handleEvent(event)
     }
 
-    throw new TelegramError(`Timed out waiting for authorization state change from ${previousType ?? 'unknown state'}.`, 'timeout')
+    throw new TelegramError(
+      `Timed out waiting for authorization state change from ${previousType ?? 'unknown state'}.`,
+      'timeout',
+    )
   }
 
   private async waitForAuthorizationState(targetType: string, timeoutMs: number = 15000): Promise<any> {

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

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
 import { getNonInteractiveLoginMessage, promptNextLoginInput } from './auth'
 
 describe('promptNextLoginInput non-interactive', () => {

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

@@ -2,9 +2,10 @@ import { Writable } from 'node:stream'
 
 import { Command } from 'commander'
 
+import { info, error as stderrError } from '@/shared/utils/stderr'
+
 import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
-import { info, error as stderrError } from '@/shared/utils/stderr'
 import { getTelegramAppCredentials } from '../app-config'
 import { TelegramTdlibClient } from '../client'
 import { TelegramCredentialManager } from '../credential-manager'
@@ -226,9 +227,7 @@ async function handleNonInteractiveProvisioning(
   }
 
   if (!options.phone) {
-    console.log(
-      formatOutput({ next_action: 'provide_phone', message: 'Provide --phone flag to start login.' }, pretty),
-    )
+    console.log(formatOutput({ next_action: 'provide_phone', message: 'Provide --phone flag to start login.' }, pretty))
     process.exit(0)
   }
 

package/src/platforms/telegram/commands/chat.test.ts

@@ -11,9 +11,7 @@ const mockSearchChats = mock(() =>
   Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
 )
 
-const mockGetChat = mock(() =>
-  Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
-)
+const mockGetChat = mock(() => Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }))
 
 const mockClient = {
   listChats: mockListChats,
@@ -22,8 +20,7 @@ const mockClient = {
 }
 
 mock.module('./shared', () => ({
-  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
-    fn(mockClient),
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => fn(mockClient),
 }))
 
 import { chatCommand } from './chat'

package/src/platforms/telegram/commands/chat.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander'
+
 import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
 import { parseLimitOption, withTelegramClient } from './shared'

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

@@ -7,9 +7,7 @@ const mockListMessages = mock(() =>
   ]),
 )
 
-const mockSendMessage = mock(() =>
-  Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
-)
+const mockSendMessage = mock(() => Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }))
 
 const mockClient = {
   listMessages: mockListMessages,
@@ -17,8 +15,7 @@ const mockClient = {
 }
 
 mock.module('./shared', () => ({
-  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
-    fn(mockClient),
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => fn(mockClient),
 }))
 
 import { messageCommand } from './message'

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

@@ -1,4 +1,5 @@
 import { Command } from 'commander'
+
 import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
 import { parseLimitOption, withTelegramClient } from './shared'

package/src/platforms/telegram/commands/shared.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+
 import { TelegramError } from '../types'
 import { parseLimitOption } from './shared'
 

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

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
 
 import { TelegramTdlibClient } from '../client'
-import type { TelegramAccount } from '../types'
 import { TelegramCredentialManager } from '../credential-manager'
+import type { TelegramAccount } from '../types'
 import * as sharedModule from './shared'
 import { whoamiAction } from './whoami'
 
@@ -28,12 +28,10 @@ let consoleLogSpy: ReturnType<typeof spyOn>
 describe('whoami command', () => {
   beforeEach(() => {
     getAuthStatusSpy = spyOn(TelegramTdlibClient.prototype, 'getAuthStatus').mockResolvedValue(mockAuthStatus)
-    withTelegramClientSpy = spyOn(sharedModule, 'withTelegramClient').mockImplementation(
-      async (_opts, fn) => {
-        const fakeClient = Object.create(TelegramTdlibClient.prototype) as TelegramTdlibClient
-        return fn(fakeClient, {} as TelegramAccount, new TelegramCredentialManager())
-      },
-    )
+    withTelegramClientSpy = spyOn(sharedModule, 'withTelegramClient').mockImplementation(async (_opts, fn) => {
+      const fakeClient = Object.create(TelegramTdlibClient.prototype) as TelegramTdlibClient
+      return fn(fakeClient, {} as TelegramAccount, new TelegramCredentialManager())
+    })
     consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 

package/src/platforms/telegram/commands/whoami.ts

@@ -13,7 +13,7 @@ export async function whoamiAction(options: { account?: string; pretty?: boolean
         account_id: status.account_id,
         phone_number: status.phone_number,
         authenticated: status.authenticated,
-        ...status.user && { user: status.user },
+        ...(status.user && { user: status.user }),
       }
       console.log(formatOutput(output, options.pretty))
     })

package/src/platforms/telegram/credential-manager.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, describe, expect, test } from 'bun:test'
 import { existsSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
+
 import { TelegramCredentialManager } from './credential-manager'
 
 const testDirs: string[] = []

package/src/platforms/telegram/credential-manager.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
+
 import {
   createAccountId,
   type TelegramAccount,
@@ -87,14 +88,22 @@ export class TelegramCredentialManager {
     const oldPaths = this.getAccountPaths(normalizedOldAccountId)
     const newPaths = this.getAccountPaths(account.account_id)
 
-    if (normalizedOldAccountId !== account.account_id && existsSync(oldPaths.account_dir) && existsSync(newPaths.account_dir)) {
+    if (
+      normalizedOldAccountId !== account.account_id &&
+      existsSync(oldPaths.account_dir) &&
+      existsSync(newPaths.account_dir)
+    ) {
       throw new TelegramError(
         `Can't migrate Telegram account data from "${normalizedOldAccountId}" to "${account.account_id}" because the target TDLib directory already exists: ${newPaths.account_dir}`,
         'account_migration_conflict',
       )
     }
 
-    if (normalizedOldAccountId !== account.account_id && existsSync(oldPaths.account_dir) && !existsSync(newPaths.account_dir)) {
+    if (
+      normalizedOldAccountId !== account.account_id &&
+      existsSync(oldPaths.account_dir) &&
+      !existsSync(newPaths.account_dir)
+    ) {
       await mkdir(this.tdlibRootDir, { recursive: true })
       await rename(oldPaths.account_dir, newPaths.account_dir)
     }

package/src/platforms/telegram/my-telegram-org.ts

@@ -187,8 +187,12 @@ function isCreateApplicationPage(html: string): boolean {
 }
 
 function extractAppCredentials(html: string): { api_id: number; api_hash: string } {
-  const apiIdMatch = html.match(/<span class="form-control input-xlarge uneditable-input"[^>]*><strong>(\d+)<\/strong><\/span>/)
-  const apiHashMatch = html.match(/<span class="form-control input-xlarge uneditable-input"[^>]*>([a-f0-9]{32})<\/span>/)
+  const apiIdMatch = html.match(
+    /<span class="form-control input-xlarge uneditable-input"[^>]*><strong>(\d+)<\/strong><\/span>/,
+  )
+  const apiHashMatch = html.match(
+    /<span class="form-control input-xlarge uneditable-input"[^>]*>([a-f0-9]{32})<\/span>/,
+  )
 
   if (!apiIdMatch?.[1] || !apiHashMatch?.[1]) {
     throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')

package/src/platforms/telegram/types.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+
 import { findFuzzyChats, normalizeChatSearchText } from './chat-utils'
 import { createAccountId, simplifyChat, simplifyMessage, summarizeAuthorizationState } from './types'
 

package/src/platforms/webex/app-config.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
 import { getWebexAppCredentials } from './app-config'
 
 const ENV_KEYS = [

package/src/platforms/webex/cli.ts

@@ -18,10 +18,7 @@ function isAuthCommand(command: CommandType): boolean {
 
 const program = new Command()
 
-program
-  .name('agent-webex')
-  .description('CLI tool for Cisco Webex communication')
-  .version(pkg.version)
+program.name('agent-webex').description('CLI tool for Cisco Webex communication').version(pkg.version)
 
 program.hook('preAction', async (_thisCommand, actionCommand) => {
   if (isAuthCommand(actionCommand)) return

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

@@ -155,9 +155,7 @@ describe('WebexClient', () => {
       const client = await new WebexClient().login({ token: 'test-token' })
       await client.sendMessage('room1', '**bold**', { markdown: true })
 
-      expect(fetchCalls[0].options?.body).toBe(
-        JSON.stringify({ roomId: 'room1', markdown: '**bold**' }),
-      )
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ roomId: 'room1', markdown: '**bold**' }))
     })
   })
 
@@ -168,9 +166,7 @@ describe('WebexClient', () => {
       const client = await new WebexClient().login({ token: 'test-token' })
       await client.sendDirectMessage('user@example.com', 'Hello')
 
-      expect(fetchCalls[0].options?.body).toBe(
-        JSON.stringify({ toPersonEmail: 'user@example.com', text: 'Hello' }),
-      )
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ toPersonEmail: 'user@example.com', text: 'Hello' }))
     })
 
     test('sends markdown direct message when option set', async () => {
@@ -246,9 +242,7 @@ describe('WebexClient', () => {
 
       expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/messages/msg1')
       expect(fetchCalls[0].options?.method).toBe('PUT')
-      expect(fetchCalls[0].options?.body).toBe(
-        JSON.stringify({ roomId: 'room1', text: 'Edited text' }),
-      )
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ roomId: 'room1', text: 'Edited text' }))
     })
 
     test('sends markdown when option set', async () => {
@@ -257,9 +251,7 @@ describe('WebexClient', () => {
       const client = await new WebexClient().login({ token: 'test-token' })
       await client.editMessage('msg1', 'room1', '**edited**', { markdown: true })
 
-      expect(fetchCalls[0].options?.body).toBe(
-        JSON.stringify({ roomId: 'room1', markdown: '**edited**' }),
-      )
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ roomId: 'room1', markdown: '**edited**' }))
     })
   })
 
@@ -483,6 +475,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 +652,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

@@ -1,7 +1,8 @@
-import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from './types'
-import { WebexError } from './types'
 import { WebexCredentialManager } from './credential-manager'
 import { WebexEncryptionService } from './encryption'
+import { markdownToHtml, stripMarkdown } from './markdown-to-html'
+import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from './types'
+import { WebexError } from './types'
 
 const BASE_URL = 'https://webexapis.com/v1'
 const MAX_RETRIES = 3
@@ -35,10 +36,7 @@ export class WebexClient {
     const config = await credManager.loadConfig()
     const token = await credManager.getToken(config?.clientId, config?.clientSecret)
     if (!token) {
-      throw new WebexError(
-        'No Webex credentials found. Run "auth login" to authenticate.',
-        'no_credentials',
-      )
+      throw new WebexError('No Webex credentials found. Run "auth login" to authenticate.', 'no_credentials')
     }
     this.deviceUrl = config?.deviceUrl ?? null
     this.tokenType = config?.tokenType ?? null
@@ -62,10 +60,7 @@ export class WebexClient {
   }
 
   private getBucketKey(method: string, path: string): string {
-    const normalized = path.replace(
-      /\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?=\/|$)/gi,
-      '/{id}',
-    )
+    const normalized = path.replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?=\/|$)/gi, '/{id}')
     return `${method}:${normalized}`
   }
 
@@ -151,10 +146,7 @@ export class WebexClient {
           errors?: Array<{ description: string }>
           trackingId?: string
         } | null
-        const message =
-          errorBody?.message ??
-          errorBody?.errors?.[0]?.description ??
-          `HTTP ${response.status}`
+        const message = errorBody?.message ?? errorBody?.errors?.[0]?.description ?? `HTTP ${response.status}`
         throw new WebexError(message, `http_${response.status}`)
       }
 
@@ -185,11 +177,7 @@ export class WebexClient {
     return this.request<WebexSpace>('GET', `/rooms/${spaceId}`)
   }
 
-  async sendMessage(
-    roomId: string,
-    text: string,
-    options?: { markdown?: boolean },
-  ): Promise<WebexMessage> {
+  async sendMessage(roomId: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
     if (this.useInternalAPI) {
       return this.sendMessageInternal(roomId, text, options)
     }
@@ -226,10 +214,7 @@ export class WebexClient {
 
     if (!response.ok) {
       const errorBody = (await response.json().catch(() => null)) as { message?: string } | null
-      throw new WebexError(
-        errorBody?.message ?? `HTTP ${response.status}`,
-        `http_${response.status}`,
-      )
+      throw new WebexError(errorBody?.message ?? `HTTP ${response.status}`, `http_${response.status}`)
     }
 
     if (response.status === 204) return undefined as T
@@ -237,7 +222,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 +250,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 +259,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(
@@ -312,11 +303,7 @@ export class WebexClient {
     return this.activityToMessage(result, roomId)
   }
 
-  async sendDirectMessage(
-    personEmail: string,
-    text: string,
-    options?: { markdown?: boolean },
-  ): Promise<WebexMessage> {
+  async sendDirectMessage(personEmail: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
     if (this.useInternalAPI) {
       const roomId = await this.findDirectRoomByEmail(personEmail)
       if (!roomId) {
@@ -333,10 +320,7 @@ export class WebexClient {
   private async findDirectRoomByEmail(email: string): Promise<string | null> {
     const rooms = await this.request<{ items: WebexSpace[] }>('GET', `/rooms?type=direct&max=100`)
     for (const room of rooms.items) {
-      const members = await this.request<{ items: WebexMembership[] }>(
-        'GET',
-        `/memberships?roomId=${room.id}&max=10`,
-      )
+      const members = await this.request<{ items: WebexMembership[] }>('GET', `/memberships?roomId=${room.id}&max=10`)
       if (members.items.some((m) => m.personEmail === email)) {
         return room.id
       }
@@ -365,9 +349,7 @@ export class WebexClient {
     if (this.useInternalAPI) {
       const activity = await this.internalRequest<InternalActivity>(`/activities/${messageId}`)
       const convId = activity.target?.id ?? ''
-      const roomId = convId
-        ? Buffer.from(`ciscospark://urn:TEAM:unknown/ROOM/${convId}`).toString('base64')
-        : ''
+      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}`)
@@ -423,11 +405,7 @@ export class WebexClient {
     return this.request<WebexMessage>('PUT', `/messages/${messageId}`, body)
   }
 
-  async listPeople(options?: {
-    email?: string
-    displayName?: string
-    max?: number
-  }): Promise<WebexPerson[]> {
+  async listPeople(options?: { email?: string; displayName?: string; max?: number }): Promise<WebexPerson[]> {
     const params = new URLSearchParams()
     if (options?.email) params.set('email', options.email)
     if (options?.displayName) params.set('displayName', options.displayName)
@@ -441,24 +419,15 @@ export class WebexClient {
   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}`,
-    )
+    const data = await this.request<{ items: WebexMembership[] }>('GET', `/memberships?${params}`)
     return data.items
   }
 
-  async listMemberships(
-    roomId: string,
-    options?: { max?: number },
-  ): Promise<WebexMembership[]> {
+  async listMemberships(roomId: string, options?: { max?: number }): Promise<WebexMembership[]> {
     const params = new URLSearchParams()
     params.set('roomId', roomId)
     if (options?.max) params.set('max', String(options.max))
-    const data = await this.request<{ items: WebexMembership[] }>(
-      'GET',
-      `/memberships?${params}`,
-    )
+    const data = await this.request<{ items: WebexMembership[] }>('GET', `/memberships?${params}`)
     return data.items
   }
 }

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

@@ -90,7 +90,13 @@ describe('auth commands', () => {
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
       expect(WebexCredentialManager.prototype.requestDeviceCode).toHaveBeenCalledWith('my-id')
-      expect(WebexCredentialManager.prototype.pollDeviceToken).toHaveBeenCalledWith('d', 0.01, 300, 'my-id', 'my-secret')
+      expect(WebexCredentialManager.prototype.pollDeviceToken).toHaveBeenCalledWith(
+        'd',
+        0.01,
+        300,
+        'my-id',
+        'my-secret',
+      )
     })
 
     test('saves tokenType as oauth in config', async () => {