agent-messenger 2.1.0 → 2.2.0

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

@@ -16,6 +16,140 @@ const mockPaths: TelegramAccountPaths = {
   files_dir: '/tmp/test-files',
 }
 
+function createMockClient(sendHandler: (request: any, events: any[]) => void) {
+  const events: any[] = []
+  const createClientId = mock(() => 1)
+  const send = mock((_clientId: number, request: any) => sendHandler(request, events))
+  const receive = mock(() => events.shift() ?? null)
+
+  const client = new (TelegramTdlibClient as unknown as new (
+    account: TelegramAccount,
+    paths: TelegramAccountPaths,
+    tdjson: any,
+  ) => TelegramTdlibClient)(mockAccount, mockPaths, {
+    createClientId,
+    send,
+    receive,
+    libraryPath: '/mock/lib',
+  })
+
+  return { client, events, send }
+}
+
+function pushAuthReady(events: any[], extra: string) {
+  events.push({
+    '@type': 'updateAuthorizationState',
+    authorization_state: { '@type': 'authorizationStateReady' },
+    '@extra': extra,
+  })
+}
+
+describe('listChats', () => {
+  test('loads chats across multiple loadChats calls until 404', async () => {
+    let loadChatsCallCount = 0
+    const allChatIds = [1, 2, 3, 4, 5]
+
+    const { client } = createMockClient((request, events) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        pushAuthReady(events, request['@extra'])
+        return
+      }
+
+      if (request['@type'] === 'loadChats') {
+        loadChatsCallCount += 1
+        if (loadChatsCallCount <= 2) {
+          // given — first two calls succeed (simulate partial loading)
+          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'] })
+        }
+        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)
+        events.push({
+          '@type': 'chats',
+          total_count: returnCount,
+          chat_ids: allChatIds.slice(0, returnCount),
+          '@extra': request['@extra'],
+        })
+        return
+      }
+
+      if (request['@type'] === 'getChat') {
+        const chatId = request.chat_id
+        const typeNames = ['chatTypePrivate', 'chatTypePrivate', 'chatTypeBasicGroup', 'chatTypeSupergroup', 'chatTypeSupergroup']
+        const idx = allChatIds.indexOf(chatId)
+        events.push({
+          '@type': 'chat',
+          id: chatId,
+          title: `Chat ${chatId}`,
+          type: { '@type': typeNames[idx] ?? 'chatTypePrivate' },
+          unread_count: 0,
+          '@extra': request['@extra'],
+        })
+        return
+      }
+    })
+
+    const chats = await client.listChats(5)
+
+    // then — all 5 chats returned including groups
+    expect(chats).toHaveLength(5)
+    expect(chats.map((c) => c.type)).toEqual(['private', 'private', 'basicgroup', 'supergroup', 'supergroup'])
+    expect(loadChatsCallCount).toBe(3)
+  })
+
+  test('stops loading when enough chats are cached before 404', async () => {
+    let loadChatsCallCount = 0
+
+    const { client } = createMockClient((request, events) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        pushAuthReady(events, request['@extra'])
+        return
+      }
+
+      if (request['@type'] === 'loadChats') {
+        loadChatsCallCount += 1
+        events.push({ '@type': 'ok', '@extra': request['@extra'] })
+        return
+      }
+
+      if (request['@type'] === 'getChats') {
+        // given — always return 3 chats (enough for limit=3)
+        events.push({
+          '@type': 'chats',
+          total_count: 3,
+          chat_ids: [10, 20, 30],
+          '@extra': request['@extra'],
+        })
+        return
+      }
+
+      if (request['@type'] === 'getChat') {
+        events.push({
+          '@type': 'chat',
+          id: request.chat_id,
+          title: `Chat ${request.chat_id}`,
+          type: { '@type': 'chatTypeSupergroup' },
+          unread_count: 0,
+          '@extra': request['@extra'],
+        })
+        return
+      }
+    })
+
+    const chats = await client.listChats(3)
+
+    // then — stops after first loop iteration since we have enough
+    expect(chats).toHaveLength(3)
+    expect(loadChatsCallCount).toBe(1)
+  })
+})
+
 describe('sendMessage confirmation', () => {
   test('returns confirmed message id when updateMessageSendSucceeded arrives', async () => {
     const tempId = 100

package/src/platforms/telegram/client.ts

@@ -162,16 +162,37 @@ export class TelegramTdlibClient {
   async listChats(limit: number = 20): Promise<TelegramChatSummary[]> {
     await this.ensureReady()
 
-    try {
-      await this.call({
-        '@type': 'loadChats',
+    // loadChats may load fewer chats than requested per call. Loop until TDLib
+    // signals 404 ("chat list fully loaded") or we have enough cached entries.
+    for (;;) {
+      try {
+        await this.call({
+          '@type': 'loadChats',
+          chat_list: {
+            '@type': 'chatListMain',
+          },
+          limit,
+        })
+      } catch (error) {
+        // TDLib signals 404 when the entire chat list has been loaded.
+        if (error instanceof TelegramError && error.code === 404) {
+          break
+        }
+
+        break
+      }
+
+      const partial = (await this.call({
+        '@type': 'getChats',
         chat_list: {
           '@type': 'chatListMain',
         },
         limit,
-      })
-    } catch {
-      // Best-effort cache warmup only.
+      })) as TdChats
+
+      if ((partial.chat_ids ?? []).length >= limit) {
+        break
+      }
     }
 
     const response = (await this.call({

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

@@ -4,6 +4,7 @@ import { Command } from 'commander'
 
 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'
@@ -126,8 +127,8 @@ async function fillMissingBootstrappingInputs(
   if (!resolved.apiId && !existing?.api_id) {
     if (shouldUseInteractivePrompts()) {
       try {
-        console.error('No API credentials found. Provisioning via my.telegram.org...')
-        console.error('A verification code will be sent to your Telegram account.\n')
+        info('No API credentials found. Provisioning via my.telegram.org...')
+        info('A verification code will be sent to your Telegram account.\n')
 
         const phone = resolved.phone || (await promptText('Phone number (e.g. +14155551234)'))
         if (!phone) {
@@ -148,10 +149,10 @@ async function fillMissingBootstrappingInputs(
 
         resolved.apiId = String(app.api_id)
         resolved.apiHash = app.api_hash
-        console.error(`\n✓ API credentials obtained (api_id: ${app.api_id})`)
+        info(`\n✓ API credentials obtained (api_id: ${app.api_id})`)
       } catch (error) {
-        console.error(`\nAuto-provisioning failed: ${error instanceof Error ? error.message : error}`)
-        console.error('Enter your API credentials manually (from https://my.telegram.org/apps):\n')
+        stderrError(`\nAuto-provisioning failed: ${error instanceof Error ? error.message : error}`)
+        info('Enter your API credentials manually (from https://my.telegram.org/apps):\n')
         resolved.apiId = await promptText('Telegram API ID')
         resolved.apiHash = await promptHidden('Telegram API hash')
       }

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

@@ -388,6 +388,320 @@ describe('WebexClient', () => {
     })
   })
 
+  describe('internal conversation API', () => {
+    const TEST_DEVICE_URL = 'https://wdm-r.wbx2.com/wdm/api/v1/devices/test-device-id'
+    const CONV_BASE = 'https://conv-r.wbx2.com/conversation/api/v1'
+    const TEST_ROOM_ID = Buffer.from('ciscospark://urn:TEAM:us-west-2_r/ROOM/abc123-def456').toString('base64')
+    const TEST_CONV_UUID = 'abc123-def456'
+
+    const mockActivity = (text: string, overrides?: Partial<Record<string, unknown>>) => ({
+      id: 'activity-123',
+      verb: 'post',
+      actor: { displayName: 'Test User', emailAddress: 'test@example.com', entryUUID: 'user-uuid' },
+      object: { objectType: 'comment', content: text, displayName: text },
+      target: { id: TEST_CONV_UUID },
+      published: '2026-01-01T00:00:00.000Z',
+      ...overrides,
+    })
+
+    const mockConversation = (activities: ReturnType<typeof mockActivity>[]) => ({
+      id: TEST_CONV_UUID,
+      activities: { items: activities },
+    })
+
+    const createExtractedClient = async () => {
+      const client = await new WebexClient().login({ token: 'extracted-token' })
+      ;(client as any).deviceUrl = TEST_DEVICE_URL
+      ;(client as any).tokenType = 'extracted'
+      return client
+    }
+
+    describe('sendMessage', () => {
+      test('posts activity to /activities with POST method', async () => {
+        mockResponse(mockActivity('Hello world'))
+
+        const client = await createExtractedClient()
+        await client.sendMessage(TEST_ROOM_ID, 'Hello world')
+
+        expect(fetchCalls[0].url).toBe(`${CONV_BASE}/activities`)
+        expect(fetchCalls[0].options?.method).toBe('POST')
+      })
+
+      test('body has verb, object type, displayName, and content', 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.verb).toBe('post')
+        expect(body.object.objectType).toBe('comment')
+        expect(body.object.displayName).toBe('Hello world')
+        expect(body.object.content).toBe('Hello world')
+      })
+
+      test('body has target with decoded conv UUID and conversation type', 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.target.id).toBe(TEST_CONV_UUID)
+        expect(body.target.objectType).toBe('conversation')
+      })
+
+      test('body has clientTempId starting with tmp-', 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.clientTempId).toStartWith('tmp-')
+      })
+
+      test('includes cisco-device-url header', async () => {
+        mockResponse(mockActivity('Hello world'))
+
+        const client = await createExtractedClient()
+        await client.sendMessage(TEST_ROOM_ID, 'Hello world')
+
+        expect(fetchCalls[0].options?.headers).toMatchObject({
+          'cisco-device-url': TEST_DEVICE_URL,
+        })
+      })
+
+      test('returns WebexMessage mapped from activity response', async () => {
+        mockResponse(mockActivity('Hello world'))
+
+        const client = await createExtractedClient()
+        const message = await client.sendMessage(TEST_ROOM_ID, 'Hello world')
+
+        expect(message.id).toBe('activity-123')
+        expect(message.text).toBe('Hello world')
+        expect(message.personEmail).toBe('test@example.com')
+        expect(message.created).toBe('2026-01-01T00:00:00.000Z')
+      })
+    })
+
+    describe('listMessages', () => {
+      test('calls GET on conversations endpoint with activitiesLimit and participantsLimit', async () => {
+        mockResponse(mockConversation([mockActivity('Hello')]))
+
+        const client = await createExtractedClient()
+        await client.listMessages(TEST_ROOM_ID)
+
+        expect(fetchCalls[0].url).toBe(
+          `${CONV_BASE}/conversations/${TEST_CONV_UUID}?activitiesLimit=50&participantsLimit=0`,
+        )
+      })
+
+      test('filters activities to only those with verb post', async () => {
+        mockResponse(
+          mockConversation([
+            mockActivity('Hello'),
+            { ...mockActivity('Deleted'), verb: 'delete' },
+            mockActivity('World'),
+          ]),
+        )
+
+        const client = await createExtractedClient()
+        const messages = await client.listMessages(TEST_ROOM_ID)
+
+        expect(messages).toHaveLength(2)
+        expect(messages[0].text).toBe('Hello')
+        expect(messages[1].text).toBe('World')
+      })
+
+      test('maps each activity to WebexMessage format', async () => {
+        mockResponse(mockConversation([mockActivity('Hello')]))
+
+        const client = await createExtractedClient()
+        const messages = await client.listMessages(TEST_ROOM_ID)
+
+        expect(messages[0].id).toBe('activity-123')
+        expect(messages[0].text).toBe('Hello')
+        expect(messages[0].personEmail).toBe('test@example.com')
+        expect(messages[0].created).toBe('2026-01-01T00:00:00.000Z')
+      })
+
+      test('passes custom max to activitiesLimit', async () => {
+        mockResponse(mockConversation([]))
+
+        const client = await createExtractedClient()
+        await client.listMessages(TEST_ROOM_ID, { max: 25 })
+
+        expect(fetchCalls[0].url).toContain('activitiesLimit=25')
+      })
+
+      test('includes cisco-device-url header', async () => {
+        mockResponse(mockConversation([]))
+
+        const client = await createExtractedClient()
+        await client.listMessages(TEST_ROOM_ID)
+
+        expect(fetchCalls[0].options?.headers).toMatchObject({
+          'cisco-device-url': TEST_DEVICE_URL,
+        })
+      })
+    })
+
+    describe('getMessage', () => {
+      test('calls GET on activities endpoint', async () => {
+        mockResponse(mockActivity('Hello'))
+
+        const client = await createExtractedClient()
+        await client.getMessage('activity-123')
+
+        expect(fetchCalls[0].url).toBe(`${CONV_BASE}/activities/activity-123`)
+      })
+
+      test('maps activity to WebexMessage format', async () => {
+        mockResponse(mockActivity('Hello'))
+
+        const client = await createExtractedClient()
+        const message = await client.getMessage('activity-123')
+
+        expect(message.id).toBe('activity-123')
+        expect(message.text).toBe('Hello')
+        expect(message.personEmail).toBe('test@example.com')
+      })
+    })
+
+    describe('deleteMessage', () => {
+      test('first GETs the activity then POSTs a delete activity', async () => {
+        mockResponse(mockActivity('Hello'))
+        mockResponse({})
+
+        const client = await createExtractedClient()
+        await client.deleteMessage('activity-123')
+
+        expect(fetchCalls[0].url).toBe(`${CONV_BASE}/activities/activity-123`)
+        expect(fetchCalls[1].url).toBe(`${CONV_BASE}/activities`)
+        expect(fetchCalls[1].options?.method).toBe('POST')
+      })
+
+      test('delete activity body has correct verb, object, and target', async () => {
+        mockResponse(mockActivity('Hello'))
+        mockResponse({})
+
+        const client = await createExtractedClient()
+        await client.deleteMessage('activity-123')
+
+        const body = JSON.parse(fetchCalls[1].options?.body as string)
+        expect(body.verb).toBe('delete')
+        expect(body.object.id).toBe('activity-123')
+        expect(body.object.objectType).toBe('activity')
+        expect(body.target.id).toBe(TEST_CONV_UUID)
+      })
+
+      test('throws WebexError when activity has no target', async () => {
+        mockResponse({ ...mockActivity('Hello'), target: undefined })
+
+        const client = await createExtractedClient()
+        await expect(client.deleteMessage('activity-123')).rejects.toThrow(WebexError)
+      })
+    })
+
+    describe('editMessage', () => {
+      test('posts activity with verb post and parent edit reference', async () => {
+        mockResponse(mockActivity('Edited text'))
+
+        const client = await createExtractedClient()
+        await client.editMessage('activity-123', TEST_ROOM_ID, 'Edited text')
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.verb).toBe('post')
+        expect(body.parent).toEqual({ id: 'activity-123', type: 'edit' })
+      })
+
+      test('body has object with comment type and new text', async () => {
+        mockResponse(mockActivity('Edited text'))
+
+        const client = await createExtractedClient()
+        await client.editMessage('activity-123', TEST_ROOM_ID, 'Edited text')
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.object.objectType).toBe('comment')
+        expect(body.object.displayName).toBe('Edited text')
+        expect(body.object.content).toBe('Edited text')
+      })
+
+      test('target has decoded conv UUID', async () => {
+        mockResponse(mockActivity('Edited text'))
+
+        const client = await createExtractedClient()
+        await client.editMessage('activity-123', TEST_ROOM_ID, 'Edited text')
+
+        const body = JSON.parse(fetchCalls[0].options?.body as string)
+        expect(body.target.id).toBe(TEST_CONV_UUID)
+      })
+    })
+
+    describe('sendDirectMessage', () => {
+      test('calls public rooms and memberships API to find room, then sends via internal API', async () => {
+        mockResponse({ items: [{ id: TEST_ROOM_ID, title: 'DM', type: 'direct' }] })
+        mockResponse({
+          items: [{ id: 'm1', roomId: TEST_ROOM_ID, personEmail: 'target@example.com', isModerator: false }],
+        })
+        mockResponse(mockActivity('Hello'))
+
+        const client = await createExtractedClient()
+        const message = await client.sendDirectMessage('target@example.com', 'Hello')
+
+        expect(fetchCalls[0].url).toContain('/rooms?type=direct&max=100')
+        expect(fetchCalls[1].url).toContain('/memberships?roomId=')
+        expect(fetchCalls[2].url).toBe(`${CONV_BASE}/activities`)
+        expect(message.id).toBe('activity-123')
+      })
+
+      test('throws WebexError when no existing direct conversation found', async () => {
+        mockResponse({ items: [{ id: 'room-x', title: 'DM', type: 'direct' }] })
+        mockResponse({
+          items: [{ id: 'm1', roomId: 'room-x', personEmail: 'other@example.com', isModerator: false }],
+        })
+
+        const client = await createExtractedClient()
+        await expect(client.sendDirectMessage('target@example.com', 'Hello')).rejects.toThrow(WebexError)
+      })
+    })
+
+    describe('error handling', () => {
+      test('throws WebexError when internal API returns non-OK response', async () => {
+        fetchResponses.push(
+          new Response(JSON.stringify({ message: 'Activity not found' }), {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        )
+
+        const client = await createExtractedClient()
+        await expect(client.getMessage('bad-activity')).rejects.toThrow(WebexError)
+      })
+
+      test('error message extracted from internal API response body', async () => {
+        fetchResponses.push(
+          new Response(JSON.stringify({ message: 'Activity not found' }), {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        )
+
+        const client = await createExtractedClient()
+        let error: WebexError | null = null
+        try {
+          await client.getMessage('bad-activity')
+        } catch (err) {
+          error = err as WebexError
+        }
+
+        expect(error).toBeInstanceOf(WebexError)
+        expect(error?.message).toBe('Activity not found')
+      })
+    })
+  })
+
   describe('error handling', () => {
     test('throws WebexError with parsed message from response body', async () => {
       mockResponse({ message: 'The requested resource could not be found.', trackingId: 'abc' }, 404)