agent-messenger 2.3.0 → 2.5.0

package/src/platforms/whatsapp/client.ts

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
+
+import { Boom } from '@hapi/boom'
 import makeWASocket, {
   DisconnectReason,
   fetchLatestBaileysVersion,
@@ -12,8 +14,8 @@ import makeWASocket, {
   type WAMessage,
   type WASocket,
 } from '@whiskeysockets/baileys'
-import { Boom } from '@hapi/boom'
 import pino from 'pino'
+
 import {
   extractMessageText,
   getMessageType,
@@ -28,7 +30,12 @@ const MAX_MESSAGES_PER_CHAT = 500
 function toTimestampMs(ts: unknown): number {
   if (ts == null) return 0
   if (typeof ts === 'number') return ts * 1000
-  if (typeof ts === 'object' && ts !== null && 'toNumber' in ts && typeof (ts as Record<string, unknown>).toNumber === 'function') {
+  if (
+    typeof ts === 'object' &&
+    ts !== null &&
+    'toNumber' in ts &&
+    typeof (ts as Record<string, unknown>).toNumber === 'function'
+  ) {
     return (ts as { toNumber(): number }).toNumber() * 1000
   }
   const n = Number(ts)
@@ -44,11 +51,7 @@ function resolveJid(input: string): string {
 function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
   const jid = msg.key.remoteJid ?? ''
   const isGroup = jid.endsWith('@g.us')
-  const from = msg.key.fromMe
-    ? ''
-    : isGroup
-      ? (msg.key.participant ?? msg.participant ?? jid)
-      : jid
+  const from = msg.key.fromMe ? '' : isGroup ? (msg.key.participant ?? msg.participant ?? jid) : jid
 
   return {
     id: msg.key.id ?? '',
@@ -62,10 +65,7 @@ function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
   }
 }
 
-function summarizeChat(
-  chat: Chat,
-  lastMessage?: WhatsAppMessageSummary,
-): WhatsAppChatSummary {
+function summarizeChat(chat: Chat, lastMessage?: WhatsAppMessageSummary): WhatsAppChatSummary {
   const id = chat.id ?? ''
   return {
     id,
@@ -86,6 +86,7 @@ export class WhatsAppClient {
   private pendingResolve: (() => void) | null = null
   private pendingPromise: Promise<void> | null = null
   private authCompleteResolve: (() => void) | null = null
+  private authCompleteReject: ((err: Error) => void) | null = null
 
   private storePath: string | null = null
 
@@ -105,7 +106,7 @@ export class WhatsAppClient {
     const account = await manager.getAccount()
     if (!account) {
       throw new WhatsAppError(
-        'No WhatsApp credentials found. Run "agent-whatsapp auth login --phone <phone-number>" first.',
+        'No WhatsApp credentials found. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.',
         'no_credentials',
       )
     }
@@ -225,10 +226,12 @@ export class WhatsAppClient {
             retries++
             if (retries > MAX_RETRIES) {
               clearTimeout(timeout)
-              outerReject(new WhatsAppError(
-                `Connection failed after ${MAX_RETRIES} retries: ${lastDisconnect?.error?.message ?? 'unknown'}`,
-                'max_retries',
-              ))
+              outerReject(
+                new WhatsAppError(
+                  `Connection failed after ${MAX_RETRIES} retries: ${lastDisconnect?.error?.message ?? 'unknown'}`,
+                  'max_retries',
+                ),
+              )
               return
             }
 
@@ -248,8 +251,9 @@ export class WhatsAppClient {
       this.pendingResolve = resolve
     })
 
-    const authCompletePromise = new Promise<void>((resolve) => {
+    const authCompletePromise = new Promise<void>((resolve, reject) => {
       this.authCompleteResolve = resolve
+      this.authCompleteReject = reject
     })
 
     const cleaned = phoneNumber.replace(/[^0-9]/g, '')
@@ -258,16 +262,24 @@ export class WhatsAppClient {
 
     return new Promise((outerResolve, outerReject) => {
       let codeReturned = false
-      let postPairingRetries = 0
-      const MAX_POST_PAIRING_RETRIES = 5
 
       const overallTimeout = setTimeout(() => {
-        outerReject(new WhatsAppError('Pairing timed out', 'pairing_timeout'))
+        const err = new WhatsAppError('Pairing timed out', 'pairing_timeout')
+        if (codeReturned) {
+          this.authCompleteReject?.(err)
+        } else {
+          outerReject(err)
+        }
       }, 120_000)
 
       const onError = (err: unknown): void => {
         clearTimeout(overallTimeout)
-        outerReject(err instanceof Error ? err : new WhatsAppError(String(err), 'pairing_error'))
+        const error = err instanceof Error ? err : new WhatsAppError(String(err), 'pairing_error')
+        if (codeReturned) {
+          this.authCompleteReject?.(error)
+        } else {
+          outerReject(error)
+        }
       }
 
       const attempt = async (): Promise<void> => {
@@ -294,20 +306,21 @@ export class WhatsAppClient {
 
             const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
 
-            // 401 is normal for fresh credentials — always reconnect during pairing
             if (statusCode === DisconnectReason.forbidden) {
               clearTimeout(overallTimeout)
-              outerReject(new WhatsAppError('Account banned or restricted.', 'forbidden'))
+              const err = new WhatsAppError('Account banned or restricted.', 'forbidden')
+              if (codeReturned) {
+                this.authCompleteReject?.(err)
+              } else {
+                outerReject(err)
+              }
               return
             }
 
             if (codeReturned) {
-              postPairingRetries++
-              if (postPairingRetries > MAX_POST_PAIRING_RETRIES) {
-                clearTimeout(overallTimeout)
-                outerReject(new WhatsAppError('Post-pairing reconnection failed.', 'post_pairing_failed'))
-                return
-              }
+              // Post-pairing: rely on overallTimeout (120s) instead of retry cap.
+              // Baileys cycles the connection during pairing — keep reconnecting
+              // until the user enters the code and the connection opens.
               setTimeout(() => attempt().catch(onError), 2000)
               return
             }
@@ -315,10 +328,12 @@ export class WhatsAppClient {
             retries++
             if (retries > MAX_RETRIES) {
               clearTimeout(overallTimeout)
-              outerReject(new WhatsAppError(
-                `Connection failed after ${MAX_RETRIES} retries: ${lastDisconnect?.error?.message ?? 'unknown'}`,
-                'max_retries',
-              ))
+              outerReject(
+                new WhatsAppError(
+                  `Connection failed after ${MAX_RETRIES} retries: ${lastDisconnect?.error?.message ?? 'unknown'}`,
+                  'max_retries',
+                ),
+              )
               return
             }
 
@@ -351,8 +366,120 @@ export class WhatsAppClient {
     })
   }
 
+  async connectForQR(onQR: (qr: string) => void | Promise<void>): Promise<{ waitForAuth: () => Promise<void> }> {
+    this.ensureAuth()
+    this.pendingPromise = new Promise<void>((resolve) => {
+      this.pendingResolve = resolve
+    })
+
+    const authCompletePromise = new Promise<void>((resolve, reject) => {
+      this.authCompleteResolve = resolve
+      this.authCompleteReject = reject
+    })
+
+    const MAX_RETRIES = 5
+    let retries = 0
+
+    return new Promise((outerResolve, outerReject) => {
+      let qrEmitted = false
+
+      const overallTimeout = setTimeout(() => {
+        const err = new WhatsAppError('QR auth timed out', 'qr_timeout')
+        if (qrEmitted) {
+          this.authCompleteReject?.(err)
+        } else {
+          outerReject(err)
+        }
+      }, 120_000)
+
+      const onError = (err: unknown): void => {
+        clearTimeout(overallTimeout)
+        const error = err instanceof Error ? err : new WhatsAppError(String(err), 'qr_error')
+        if (qrEmitted) {
+          this.authCompleteReject?.(error)
+        } else {
+          outerReject(error)
+        }
+      }
+
+      const attempt = async (): Promise<void> => {
+        const { sock, saveCreds } = await this.createSocket()
+        this.setupBufferListeners(sock, saveCreds)
+
+        sock.ev.on('connection.update', async (update: Partial<ConnectionState>) => {
+          const { connection, lastDisconnect, qr } = update
+
+          if (qr) {
+            try {
+              await onQR(qr)
+            } catch (err) {
+              onError(err)
+              return
+            }
+            if (!qrEmitted) {
+              qrEmitted = true
+              outerResolve({ waitForAuth: () => authCompletePromise })
+            }
+          }
+
+          if (connection === 'open') {
+            clearTimeout(overallTimeout)
+            this.authCompleteResolve?.()
+            if (!qrEmitted) {
+              qrEmitted = true
+              outerResolve({ waitForAuth: async () => {} })
+            }
+          }
+
+          if (connection === 'close') {
+            this.cleanupSocket(sock)
+
+            const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
+
+            if (statusCode === DisconnectReason.forbidden) {
+              clearTimeout(overallTimeout)
+              const err = new WhatsAppError('Account banned or restricted.', 'forbidden')
+              if (qrEmitted) {
+                this.authCompleteReject?.(err)
+              } else {
+                outerReject(err)
+              }
+              return
+            }
+
+            if (qrEmitted) {
+              // Post-QR scan: keep reconnecting until auth completes
+              setTimeout(() => attempt().catch(onError), 2000)
+              return
+            }
+
+            retries++
+            if (retries > MAX_RETRIES) {
+              clearTimeout(overallTimeout)
+              outerReject(
+                new WhatsAppError(
+                  `Connection failed after ${MAX_RETRIES} retries: ${lastDisconnect?.error?.message ?? 'unknown'}`,
+                  'max_retries',
+                ),
+              )
+              return
+            }
+
+            setTimeout(() => attempt().catch(onError), 1000)
+          }
+        })
+      }
+
+      attempt().catch(onError)
+    })
+  }
+
   private cleanupSocket(sock: WASocket): void {
-    try { sock.end(undefined) } catch { /* already closed */ }
+    try {
+      sock.end(undefined)
+    } catch {
+      /* already closed */
+    }
   }
 
   private setupBufferListeners(sock: WASocket, saveCreds: () => Promise<void>): void {
@@ -464,9 +591,7 @@ export class WhatsAppClient {
   async searchChats(query: string, limit?: number): Promise<WhatsAppChatSummary[]> {
     const allChats = await this.listChats()
     const lower = query.toLowerCase()
-    const filtered = allChats.filter((c) =>
-      c.name.toLowerCase().includes(lower) || c.id.toLowerCase().includes(lower),
-    )
+    const filtered = allChats.filter((c) => c.name.toLowerCase().includes(lower) || c.id.toLowerCase().includes(lower))
     return limit ? filtered.slice(0, limit) : filtered
   }
 
@@ -504,6 +629,24 @@ export class WhatsAppClient {
     return summarizeMessage(result)
   }
 
+  async getProfile(): Promise<{ id: string; name: string | null; phone_number: string | null }> {
+    this.ensureAuth()
+    if (!this.sock) {
+      throw new WhatsAppError('Not connected. Call connect() first.', 'not_connected')
+    }
+    const user = this.sock.user
+    if (!user) {
+      throw new WhatsAppError('Not connected. Call connect() first.', 'not_connected')
+    }
+    const jid = user.id ?? ''
+    const phone = jid.includes(':') ? jid.split(':')[0] : jid.split('@')[0]
+    return {
+      id: jid,
+      name: user.name ?? null,
+      phone_number: phone || null,
+    }
+  }
+
   getSocket(): WASocket | null {
     return this.sock
   }

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

@@ -0,0 +1,311 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: (err: Error) => { throw err },
+}))
+
+const mockGetAccount = mock(() => Promise.resolve(null))
+const mockListAccounts = mock(() => Promise.resolve([]))
+const mockSetCurrent = mock(() => Promise.resolve(false))
+const mockRemoveAccount = mock(() => Promise.resolve(false))
+const mockGetAccountPaths = mock(() => ({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }))
+
+mock.module('../credential-manager', () => ({
+  WhatsAppCredentialManager: class {
+    getAccount = mockGetAccount
+    listAccounts = mockListAccounts
+    setCurrent = mockSetCurrent
+    removeAccount = mockRemoveAccount
+    getAccountPaths = mockGetAccountPaths
+    ensureAccountPaths = mock(() => Promise.resolve({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }))
+    setAccount = mock(() => Promise.resolve())
+  },
+}))
+
+const mockConnect = mock(() => Promise.resolve())
+const mockClose = mock(() => Promise.resolve())
+const mockGetSocket = mock(() => null)
+const mockLogin = mock(function (this: unknown) { return Promise.resolve(this) })
+
+mock.module('../client', () => ({
+  WhatsAppClient: class {
+    login = mockLogin
+    connect = mockConnect
+    close = mockClose
+    getSocket = mockGetSocket
+  },
+}))
+
+import { authCommand } from './auth'
+
+describe('auth commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockGetAccount.mockReset()
+    mockListAccounts.mockReset()
+    mockSetCurrent.mockReset()
+    mockRemoveAccount.mockReset()
+    mockGetAccountPaths.mockReset()
+    mockConnect.mockReset()
+    mockClose.mockReset()
+    mockGetSocket.mockReset()
+    mockLogin.mockReset()
+
+    mockGetAccount.mockImplementation(() => Promise.resolve(null))
+    mockListAccounts.mockImplementation(() => Promise.resolve([]))
+    mockSetCurrent.mockImplementation(() => Promise.resolve(false))
+    mockRemoveAccount.mockImplementation(() => Promise.resolve(false))
+    mockGetAccountPaths.mockImplementation(() => ({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }))
+    mockConnect.mockImplementation(() => Promise.resolve())
+    mockClose.mockImplementation(() => Promise.resolve())
+    mockGetSocket.mockImplementation(() => null)
+    mockLogin.mockImplementation(function (this: unknown) { return Promise.resolve(this) })
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+      throw new Error(`process.exit(${_code})`)
+    })
+    processExitSpy.mockClear()
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+    processExitSpy.mockRestore()
+  })
+
+  // list has no throwing tests — run first to avoid Commander state corruption
+  describe('list', () => {
+    test('outputs empty array when no accounts', async () => {
+      mockListAccounts.mockImplementation(() => Promise.resolve([]))
+
+      await authCommand.parseAsync(['list'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+
+    test('outputs accounts list with is_current flag', async () => {
+      mockListAccounts.mockImplementation(() =>
+        Promise.resolve([
+          {
+            account_id: 'plus-12025551234',
+            phone_number: '+12025551234',
+            name: 'Alice',
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+            is_current: true,
+          },
+          {
+            account_id: 'plus-19995551234',
+            phone_number: '+19995551234',
+            name: null,
+            created_at: '2024-01-02T00:00:00.000Z',
+            updated_at: '2024-01-02T00:00:00.000Z',
+            is_current: false,
+          },
+        ]),
+      )
+
+      await authCommand.parseAsync(['list'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(2)
+      expect(output[0].account_id).toBe('plus-12025551234')
+      expect(output[0].is_current).toBe(true)
+      expect(output[1].account_id).toBe('plus-19995551234')
+      expect(output[1].is_current).toBe(false)
+    })
+  })
+
+  // use: success test first, then throwing test last
+  describe('use', () => {
+    test('switches to specified account and outputs success', async () => {
+      mockSetCurrent.mockImplementation(() => Promise.resolve(true))
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'plus-12025551234',
+          phone_number: '+12025551234',
+          name: 'Alice',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+
+      await authCommand.parseAsync(['use', 'plus-12025551234'], { from: 'user' })
+
+      expect(mockSetCurrent).toHaveBeenCalledWith('plus-12025551234')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.account_id).toBe('plus-12025551234')
+    })
+
+    test('outputs error and exits when account not found', async () => {
+      mockSetCurrent.mockImplementation(() => Promise.resolve(false))
+
+      await expect(
+        authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('nonexistent')
+    })
+  })
+
+  // status: no-account tests first, --account tests last (avoids Commander option caching)
+  describe('status', () => {
+    test('outputs account info when account exists', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'plus-12025551234',
+          phone_number: '+12025551234',
+          name: 'Test User',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+
+      await authCommand.parseAsync(['status'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.account_id).toBe('plus-12025551234')
+      expect(output.phone_number).toBe('+12025551234')
+      expect(output.name).toBe('Test User')
+    })
+
+    test('outputs error and exits when no account configured', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['status'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toBeDefined()
+      expect(output.error).toContain('No WhatsApp account configured')
+    })
+
+    test('passes --account option to getAccount', async () => {
+      mockGetAccount.mockImplementation((id?: string) => {
+        if (id === 'plus-19995551234') {
+          return Promise.resolve({
+            account_id: 'plus-19995551234',
+            phone_number: '+19995551234',
+            name: null,
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+          })
+        }
+        return Promise.resolve(null)
+      })
+
+      await authCommand.parseAsync(['status', '--account', 'plus-19995551234'], { from: 'user' })
+
+      expect(mockGetAccount).toHaveBeenCalledWith('plus-19995551234')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.account_id).toBe('plus-19995551234')
+    })
+
+    test('outputs error for specific missing account', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['status', '--account', 'missing-id'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('missing-id')
+    })
+  })
+
+  // logout: no-account tests first, --account test last (avoids Commander option caching)
+  describe('logout', () => {
+    test('removes current account and outputs success', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'plus-12025551234',
+          phone_number: '+12025551234',
+          name: 'Alice',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+      mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
+
+      await expect(
+        authCommand.parseAsync(['logout'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('plus-12025551234')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.account_id).toBe('plus-12025551234')
+      expect(output.logged_out).toBe(true)
+    })
+
+    test('outputs error and exits when no account configured', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['logout'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toBeDefined()
+    })
+
+    test('proceeds with local cleanup even when client connection fails', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'plus-12025551234',
+          phone_number: '+12025551234',
+          name: 'Alice',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+      mockConnect.mockImplementation(() => Promise.reject(new Error('Connection failed')))
+      mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
+
+      await expect(
+        authCommand.parseAsync(['logout'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('plus-12025551234')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+    })
+
+    test('removes specific account with --account flag', async () => {
+      mockGetAccount.mockImplementation((id?: string) => {
+        if (id === 'plus-19995551234') {
+          return Promise.resolve({
+            account_id: 'plus-19995551234',
+            phone_number: '+19995551234',
+            name: null,
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+          })
+        }
+        return Promise.resolve(null)
+      })
+      mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
+
+      await expect(
+        authCommand.parseAsync(['logout', '--account', 'plus-19995551234'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('plus-19995551234')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.account_id).toBe('plus-19995551234')
+    })
+  })
+})