agent-messenger 2.7.0 → 2.9.0

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**' }))
     })
   })
 

package/src/platforms/webex/client.ts

@@ -1,8 +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
@@ -36,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
@@ -63,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}`
   }
 
@@ -152,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}`)
       }
 
@@ -186,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)
     }
@@ -227,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
@@ -319,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) {
@@ -340,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
       }
@@ -372,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}`)
@@ -430,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)
@@ -448,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 () => {

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

@@ -41,7 +41,12 @@ async function resolveClientCredentials(options: {
   return getWebexAppCredentials()
 }
 
-export async function loginAction(options: { token?: string; clientId?: string; clientSecret?: string; pretty?: boolean }): Promise<void> {
+export async function loginAction(options: {
+  token?: string
+  clientId?: string
+  clientSecret?: string
+  pretty?: boolean
+}): Promise<void> {
   try {
     const credManager = new WebexCredentialManager()
 
@@ -110,9 +115,7 @@ export async function statusAction(options: { pretty?: boolean }): Promise<void>
     const token = await credManager.getToken(config?.clientId, config?.clientSecret)
 
     if (!token) {
-      console.log(
-        formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty),
-      )
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty))
       process.exit(1)
       return
     }
@@ -139,10 +142,7 @@ export async function statusAction(options: { pretty?: boolean }): Promise<void>
 
 export async function extractAction(options: { pretty?: boolean; debug?: boolean }): Promise<void> {
   try {
-    const extractor = new WebexTokenExtractor(
-      undefined,
-      options.debug ? (msg) => debug(`[debug] ${msg}`) : undefined,
-    )
+    const extractor = new WebexTokenExtractor(undefined, options.debug ? (msg) => debug(`[debug] ${msg}`) : undefined)
 
     if (options.debug) {
       debug('[debug] Searching browser profiles for Webex tokens...')
@@ -154,7 +154,8 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       console.log(
         formatOutput(
           {
-            error: 'No Webex token found in any browser. Make sure you are logged in to web.webex.com in Chrome, Edge, Arc, or Brave.',
+            error:
+              'No Webex token found in any browser. Make sure you are logged in to web.webex.com in Chrome, Edge, Arc, or Brave.',
             hint: 'Run "auth login" for OAuth Device Grant flow, or --debug for more info.',
           },
           options.pretty,
@@ -175,9 +176,7 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       tokenType: 'extracted',
       deviceUrl: extracted.deviceUrl,
       userId: extracted.userId,
-      encryptionKeys: extracted.encryptionKeys
-        ? Object.fromEntries(extracted.encryptionKeys)
-        : undefined,
+      encryptionKeys: extracted.encryptionKeys ? Object.fromEntries(extracted.encryptionKeys) : undefined,
     })
 
     console.log(
@@ -201,9 +200,7 @@ export async function logoutAction(options: { pretty?: boolean }): Promise<void>
     const config = await credManager.loadConfig()
 
     if (!config) {
-      console.log(
-        formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty),
-      )
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty))
       process.exit(1)
       return
     }

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

@@ -47,9 +47,7 @@ describe('member commands', () => {
 
   beforeEach(() => {
     mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
-    mockLogin.mockReset().mockImplementation(() =>
-      Promise.resolve({ listMemberships: mockListMemberships }),
-    )
+    mockLogin.mockReset().mockImplementation(() => Promise.resolve({ listMemberships: mockListMemberships }))
     mockHandleError.mockReset().mockImplementation((err: Error) => {
       throw err
     })

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

@@ -5,10 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { WebexClient } from '../client'
 
-export async function listAction(
-  spaceId: string,
-  options: { limit?: number; pretty?: boolean },
-): Promise<void> {
+export async function listAction(spaceId: string, options: { limit?: number; pretty?: boolean }): Promise<void> {
   try {
     const client = await new WebexClient().login()
     const members = await client.listMemberships(spaceId, { max: options.limit })
@@ -28,18 +25,16 @@ export async function listAction(
   }
 }
 
-export const memberCommand = new Command('member')
-  .description('Member commands')
-  .addCommand(
-    new Command('list')
-      .description('List members of a space')
-      .argument('<space-id>', 'Space ID')
-      .option('--limit <n>', 'Number of members to retrieve', '100')
-      .option('--pretty', 'Pretty print JSON output')
-      .action((spaceId, options) =>
-        listAction(spaceId, {
-          limit: parseInt(options.limit, 10),
-          pretty: options.pretty,
-        }),
-      ),
-  )
+export const memberCommand = new Command('member').description('Member commands').addCommand(
+  new Command('list')
+    .description('List members of a space')
+    .argument('<space-id>', 'Space ID')
+    .option('--limit <n>', 'Number of members to retrieve', '100')
+    .option('--pretty', 'Pretty print JSON output')
+    .action((spaceId, options) =>
+      listAction(spaceId, {
+        limit: parseInt(options.limit, 10),
+        pretty: options.pretty,
+      }),
+    ),
+)

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

@@ -29,10 +29,7 @@ export async function sendAction(
   }
 }
 
-export async function listAction(
-  spaceId: string,
-  options: { limit?: number; pretty?: boolean },
-): Promise<void> {
+export async function listAction(spaceId: string, options: { limit?: number; pretty?: boolean }): Promise<void> {
   try {
     const client = await new WebexClient().login()
     const limit = options.limit ?? 50
@@ -52,10 +49,7 @@ export async function listAction(
   }
 }
 
-export async function getAction(
-  messageId: string,
-  options: { pretty?: boolean },
-): Promise<void> {
+export async function getAction(messageId: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const client = await new WebexClient().login()
     const message = await client.getMessage(messageId)
@@ -74,15 +68,10 @@ export async function getAction(
   }
 }
 
-export async function deleteAction(
-  messageId: string,
-  options: { force?: boolean; pretty?: boolean },
-): Promise<void> {
+export async function deleteAction(messageId: string, options: { force?: boolean; pretty?: boolean }): Promise<void> {
   try {
     if (!options.force) {
-      console.log(
-        formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty),
-      )
+      console.log(formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty))
       return process.exit(0)
     }