agent-messenger 2.0.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/app-config.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { getWebexAppCredentials } from './app-config'
+
+const ENV_KEYS = [
+  'AGENT_WEBEX_CLIENT_ID',
+  'AGENT_WEBEX_CLIENT_SECRET',
+  'AGENT_MESSENGER_WEBEX_CLIENT_ID',
+  'AGENT_MESSENGER_WEBEX_CLIENT_SECRET',
+] as const
+
+describe('webex app config', () => {
+  let savedEnv: Record<string, string | undefined> = {}
+
+  beforeEach(() => {
+    savedEnv = {}
+    for (const key of ENV_KEYS) {
+      savedEnv[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = savedEnv[key]
+      }
+    }
+  })
+
+  test('returns env credentials when primary env vars are set', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'my-client-id'
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'my-client-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'my-client-id',
+      clientSecret: 'my-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('returns env credentials when legacy env vars are set', () => {
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID = 'legacy-client-id'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET = 'legacy-client-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'legacy-client-id',
+      clientSecret: 'legacy-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('returns builtin credentials when nothing is configured', () => {
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+    expect(result.clientId).toBeTruthy()
+    expect(result.clientSecret).toBeTruthy()
+  })
+
+  test('returns builtin when only clientId is set', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'my-client-id'
+
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+  })
+
+  test('returns builtin when only clientSecret is set', () => {
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'my-client-secret'
+
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+  })
+
+  test('trims whitespace from clientId and clientSecret', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = '  my-client-id  '
+    process.env.AGENT_WEBEX_CLIENT_SECRET = '  my-client-secret  '
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'my-client-id',
+      clientSecret: 'my-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('primary env takes precedence over legacy env', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'primary-id'
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'primary-secret'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID = 'legacy-id'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET = 'legacy-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'primary-id',
+      clientSecret: 'primary-secret',
+      source: 'env',
+    })
+  })
+})

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

@@ -0,0 +1,31 @@
+const BUILTIN_CLIENT_ID = 'C720341c19d8dfb4cab8a5db78be4bc6d5c3983fbe84df94be34c8aa69a695583'
+const BUILTIN_CLIENT_SECRET = 'e90806657443a7f16093c0846690aeeea96cd2b3ed9b79cf544297c526b4f9af'
+
+export interface WebexAppCredentials {
+  clientId: string
+  clientSecret: string
+  source: 'env' | 'builtin'
+}
+
+function parseTrimmed(value: string | undefined): string | undefined {
+  const normalized = value?.trim()
+  return normalized ? normalized : undefined
+}
+
+export function getWebexAppCredentials(): WebexAppCredentials {
+  const envClientId = parseTrimmed(process.env.AGENT_WEBEX_CLIENT_ID)
+  const envClientSecret = parseTrimmed(process.env.AGENT_WEBEX_CLIENT_SECRET)
+
+  if (envClientId && envClientSecret) {
+    return { clientId: envClientId, clientSecret: envClientSecret, source: 'env' }
+  }
+
+  const legacyClientId = parseTrimmed(process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID)
+  const legacyClientSecret = parseTrimmed(process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET)
+
+  if (legacyClientId && legacyClientSecret) {
+    return { clientId: legacyClientId, clientSecret: legacyClientSecret, source: 'env' }
+  }
+
+  return { clientId: BUILTIN_CLIENT_ID, clientSecret: BUILTIN_CLIENT_SECRET, source: 'builtin' }
+}

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

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+
+import { spawn } from 'bun'
+
+import pkg from '../../../package.json' with { type: 'json' }
+
+describe('Webex CLI program structure', () => {
+  test('--help shows all commands', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('auth')
+    expect(output).toContain('member')
+    expect(output).toContain('message')
+    expect(output).toContain('snapshot')
+    expect(output).toContain('space')
+  })
+
+  test('--version shows package version', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', '--version'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+    expect(output.trim()).toBe(pkg.version)
+  })
+
+  test('auth login --help shows Device Grant options', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', 'auth', 'login', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('--token')
+    expect(output).toContain('--client-id')
+    expect(output).toContain('--client-secret')
+    expect(output).toContain('--pretty')
+  })
+
+  test('message dm --help shows email argument', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', 'message', 'dm', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('email')
+    expect(output).toContain('--markdown')
+  })
+})

package/src/platforms/webex/cli.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env bun
+
+import type { Command as CommandType } from 'commander'
+import { Command } from 'commander'
+
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, memberCommand, messageCommand, snapshotCommand, spaceCommand } from './commands'
+import { ensureWebexAuth } from './ensure-auth'
+
+function isAuthCommand(command: CommandType): boolean {
+  let cmd: CommandType | null = command
+  while (cmd) {
+    if (cmd.name() === 'auth') return true
+    cmd = cmd.parent
+  }
+  return false
+}
+
+const program = new Command()
+
+program
+  .name('agent-webex')
+  .description('CLI tool for Cisco Webex communication')
+  .version(pkg.version)
+
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) return
+  await ensureWebexAuth()
+})
+
+program.addCommand(authCommand)
+program.addCommand(memberCommand)
+program.addCommand(messageCommand)
+program.addCommand(snapshotCommand)
+program.addCommand(spaceCommand)
+
+program.parse(process.argv)
+
+export default program