agent-messenger 2.4.0 → 2.6.0

package/src/platforms/whatsapp/cli.ts

@@ -5,7 +5,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureWhatsAppAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -32,6 +32,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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,
@@ -106,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',
       )
     }
@@ -226,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
             }
 
@@ -326,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
             }
 
@@ -362,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 {
@@ -475,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
   }
 
@@ -515,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.ts

@@ -1,13 +1,19 @@
 import { rm } from 'node:fs/promises'
+
 import { Command } from 'commander'
+
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
+import { displayQR } from '@/shared/utils/qr'
+import { info } from '@/shared/utils/stderr'
+
 import { WhatsAppClient } from '../client'
 import { WhatsAppCredentialManager } from '../credential-manager'
 import { createAccountId } from '../types'
 
 interface LoginOptions {
-  phone: string
+  phone?: string
+  qr?: boolean
   pretty?: boolean
 }
 
@@ -16,58 +22,145 @@ interface StatusOptions {
   pretty?: boolean
 }
 
-async function loginAction(options: LoginOptions): Promise<void> {
+function isInteractiveSession(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
+}
+
+async function loginWithPairingCode(options: LoginOptions & { phone: string }): Promise<void> {
+  const manager = new WhatsAppCredentialManager()
+  const accountId = createAccountId(options.phone)
+  const existingPaths = manager.getAccountPaths(accountId)
+  await rm(existingPaths.auth_dir, { recursive: true, force: true })
+  const paths = await manager.ensureAccountPaths(accountId)
+  const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+
+  let code: string
+  let waitForAuth: () => Promise<void>
+
   try {
-    const manager = new WhatsAppCredentialManager()
-    const accountId = createAccountId(options.phone)
-    // Clear stale session files so Baileys starts fresh for pairing
-    const existingPaths = manager.getAccountPaths(accountId)
-    await rm(existingPaths.auth_dir, { recursive: true, force: true })
-    const paths = await manager.ensureAccountPaths(accountId)
-    const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
-
-    let code: string
-    let waitForAuth: () => Promise<void>
-
-    try {
-      const result = await client.connectForPairing(options.phone)
-      code = result.code
-      waitForAuth = result.waitForAuth
-    } catch (err) {
-      await client.close()
-      throw err
-    }
+    const result = await client.connectForPairing(options.phone)
+    code = result.code
+    waitForAuth = result.waitForAuth
+  } catch (err) {
+    await client.close()
+    throw err
+  }
 
-    const formatted = code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code
+  const formatted = code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code
 
-    console.log(formatOutput({
-      pairing_code: formatted,
-      message: 'Enter this code in WhatsApp > Linked Devices > Link with phone number',
-    }, options.pretty))
+  console.log(
+    formatOutput(
+      {
+        pairing_code: formatted,
+        message: 'Enter this code in WhatsApp > Linked Devices > Link with phone number',
+      },
+      options.pretty,
+    ),
+  )
 
-    try {
-      await waitForAuth()
-    } catch (err) {
-      await client.close()
-      throw err
-    }
+  try {
+    await waitForAuth()
+  } catch (err) {
+    await client.close()
+    throw err
+  }
+
+  const now = new Date().toISOString()
+  await manager.setAccount({
+    account_id: accountId,
+    phone_number: options.phone,
+    created_at: now,
+    updated_at: now,
+  })
+  await manager.setCurrent(accountId)
+  await client.close()
+
+  console.log(
+    formatOutput(
+      {
+        authenticated: true,
+        account_id: accountId,
+        phone_number: options.phone,
+      },
+      options.pretty,
+    ),
+  )
+  process.exit(0)
+}
+
+async function loginWithQR(options: LoginOptions): Promise<void> {
+  const manager = new WhatsAppCredentialManager()
+  const accountId = 'qr-default'
+  const existingPaths = manager.getAccountPaths(accountId)
+  await rm(existingPaths.auth_dir, { recursive: true, force: true })
+  const paths = await manager.ensureAccountPaths(accountId)
+  const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+  const interactive = isInteractiveSession()
+
+  let waitForAuth: () => Promise<void>
+  let browserOpened = false
 
-    const now = new Date().toISOString()
-    await manager.setAccount({
-      account_id: accountId,
-      phone_number: options.phone,
-      created_at: now,
-      updated_at: now,
+  try {
+    const result = await client.connectForQR(async (qr) => {
+      await displayQR(qr, {
+        platform: 'WhatsApp',
+        brandColor: '#25D366',
+        scanInstruction: 'Scan with WhatsApp on your phone',
+        interactive,
+        openBrowser: interactive && !browserOpened,
+        formatOutput,
+        pretty: options.pretty,
+      })
+      browserOpened = true
     })
-    await manager.setCurrent(accountId)
+    waitForAuth = result.waitForAuth
+  } catch (err) {
     await client.close()
+    throw err
+  }
 
-    console.log(formatOutput({
-      authenticated: true,
-      account_id: accountId,
-      phone_number: options.phone,
-    }, options.pretty))
-    process.exit(0)
+  if (interactive) {
+    info('\nWaiting for QR code scan...')
+  }
+
+  try {
+    await waitForAuth()
+  } catch (err) {
+    await client.close()
+    throw err
+  }
+
+  const now = new Date().toISOString()
+  await manager.setAccount({
+    account_id: accountId,
+    created_at: now,
+    updated_at: now,
+  })
+  await manager.setCurrent(accountId)
+  await client.close()
+
+  console.log(
+    formatOutput(
+      {
+        authenticated: true,
+        account_id: accountId,
+      },
+      options.pretty,
+    ),
+  )
+  process.exit(0)
+}
+
+async function loginAction(options: LoginOptions): Promise<void> {
+  try {
+    if (options.qr) {
+      await loginWithQR(options)
+    } else if (options.phone) {
+      await loginWithPairingCode(options as LoginOptions & { phone: string })
+    } else {
+      console.error('Error: Either --phone or --qr is required')
+      process.exit(1)
+    }
   } catch (error) {
     handleError(error as Error)
   }
@@ -79,21 +172,31 @@ async function statusAction(options: StatusOptions): Promise<void> {
     const account = await manager.getAccount(options.account)
 
     if (!account) {
-      console.log(formatOutput({
-        error: options.account
-          ? `WhatsApp account "${options.account}" not found.`
-          : 'No WhatsApp account configured. Run "auth login --phone <phone-number>" first.',
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            error: options.account
+              ? `WhatsApp account "${options.account}" not found.`
+              : 'No WhatsApp account configured. Run "auth login --qr" or "auth login --phone <phone-number>" first.',
+          },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 
-    console.log(formatOutput({
-      account_id: account.account_id,
-      phone_number: account.phone_number,
-      name: account.name,
-      created_at: account.created_at,
-      updated_at: account.updated_at,
-    }, options.pretty))
+    console.log(
+      formatOutput(
+        {
+          account_id: account.account_id,
+          phone_number: account.phone_number,
+          name: account.name,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+        },
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }
@@ -104,17 +207,19 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
     const manager = new WhatsAppCredentialManager()
     const accounts = await manager.listAccounts()
 
-    console.log(formatOutput(
-      accounts.map((account) => ({
-        account_id: account.account_id,
-        phone_number: account.phone_number,
-        name: account.name,
-        created_at: account.created_at,
-        updated_at: account.updated_at,
-        is_current: account.is_current,
-      })),
-      options.pretty,
-    ))
+    console.log(
+      formatOutput(
+        accounts.map((account) => ({
+          account_id: account.account_id,
+          phone_number: account.phone_number,
+          name: account.name,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+          is_current: account.is_current,
+        })),
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }
@@ -175,8 +280,9 @@ export const authCommand = new Command('auth')
   .description('WhatsApp authentication commands')
   .addCommand(
     new Command('login')
-      .description('Link as a companion device using a pairing code')
-      .requiredOption('--phone <number>', 'Phone number in international format (e.g. +12025551234)')
+      .description('Link as a companion device via pairing code (--phone) or QR code (--qr)')
+      .option('--phone <number>', 'Phone number in international format (e.g. +12025551234)')
+      .option('--qr', 'Link by scanning a QR code instead of entering a pairing code')
       .option('--pretty', 'Pretty print JSON output')
       .action(loginAction),
   )

package/src/platforms/whatsapp/commands/index.ts

@@ -1,3 +1,4 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
 export { messageCommand } from './message'
+export { whoamiCommand } from './whoami'

package/src/platforms/whatsapp/commands/shared.ts

@@ -40,8 +40,8 @@ export async function withWhatsAppClient<T>(
       formatOutput(
         {
           error: options.account
-            ? `WhatsApp account "${options.account}" not found. Run "agent-whatsapp auth login --phone <phone-number>" first.`
-            : 'Not authenticated. Run "agent-whatsapp auth login --phone <phone-number>" first.',
+            ? `WhatsApp account "${options.account}" not found. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.`
+            : 'Not authenticated. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.',
         },
         options.pretty,
       ),

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

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import type { WhatsAppClient } from '../client'
+import * as sharedModule from './shared'
+import { whoamiAction } from './whoami'
+
+let mockProfileData: { id: string; name: string | null; phone_number: string | null } = {
+  id: '12025551234:1@s.whatsapp.net',
+  name: 'Test User',
+  phone_number: '12025551234',
+}
+
+let withWhatsAppClientSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    mockProfileData = {
+      id: '12025551234:1@s.whatsapp.net',
+      name: 'Test User',
+      phone_number: '12025551234',
+    }
+
+    withWhatsAppClientSpy = spyOn(sharedModule, 'withWhatsAppClient').mockImplementation(
+      async (_opts, fn) => fn({ getProfile: () => Promise.resolve(mockProfileData) } as unknown as WhatsAppClient),
+    )
+    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    withWhatsAppClientSpy?.mockRestore()
+    consoleLogSpy?.mockRestore()
+  })
+
+  test('outputs profile information', async () => {
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.id).toBe('12025551234:1@s.whatsapp.net')
+    expect(output.name).toBe('Test User')
+    expect(output.phone_number).toBe('12025551234')
+  })
+
+  test('outputs profile with null name', async () => {
+    mockProfileData = {
+      id: '12025551234@s.whatsapp.net',
+      name: null,
+      phone_number: '12025551234',
+    }
+
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.id).toBe('12025551234@s.whatsapp.net')
+    expect(output.name).toBeNull()
+  })
+})

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

@@ -0,0 +1,21 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { withWhatsAppClient } from './shared'
+
+export async function whoamiAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const profile = await withWhatsAppClient(options, (client) => client.getProfile())
+    console.log(formatOutput(profile, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--account <id>', 'Use a specific WhatsApp account')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/whatsapp/ensure-auth.ts

@@ -9,7 +9,7 @@ export async function ensureWhatsAppAuth(): Promise<void> {
 
   if (!account) {
     console.log(formatOutput({
-      error: 'Not authenticated. Run "agent-whatsapp auth login --phone <phone-number>" first.',
+      error: 'Not authenticated. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.',
     }))
     process.exit(1)
   }
@@ -19,7 +19,7 @@ export async function ensureWhatsAppAuth(): Promise<void> {
 
   if (!existsSync(credsPath)) {
     console.log(formatOutput({
-      error: 'Auth credentials missing. Run "agent-whatsapp auth login --phone <phone-number>" to re-authenticate.',
+      error: 'Auth credentials missing. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" to re-authenticate.',
     }))
     process.exit(1)
   }