agent-messenger 2.3.0 → 2.5.0

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

@@ -1,12 +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
 }
 
@@ -15,55 +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)
-    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)
+}
 
-    const now = new Date().toISOString()
-    await manager.setAccount({
-      account_id: accountId,
-      phone_number: options.phone,
-      created_at: now,
-      updated_at: now,
+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
+
+  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)
   }
@@ -75,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)
   }
@@ -100,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)
   }
@@ -138,29 +247,29 @@ async function logoutAction(options: { account?: string; pretty?: boolean }): Pr
     const manager = new WhatsAppCredentialManager()
     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.',
-      }, options.pretty))
+    if (!account && !options.account) {
+      console.log(formatOutput({ error: 'No WhatsApp account configured.' }, options.pretty))
       process.exit(1)
     }
 
-    const paths = manager.getAccountPaths(account.account_id)
-    try {
-      const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
-      await client.connect()
-      if (client.getSocket()) {
-        await client.getSocket()!.logout('Logged out via agent-whatsapp CLI')
+    const accountId = account?.account_id ?? options.account!
+
+    if (account) {
+      const paths = manager.getAccountPaths(account.account_id)
+      try {
+        const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+        await client.connect()
+        if (client.getSocket()) {
+          await client.getSocket()!.logout('Logged out via agent-whatsapp CLI')
+        }
+        await client.close()
+      } catch {
+        // Server-side deregister failed — proceed with local cleanup
       }
-      await client.close()
-    } catch {
-      // Server-side deregister failed — proceed with local cleanup
     }
 
-    await manager.removeAccount(account.account_id)
-    console.log(formatOutput({ success: true, account_id: account.account_id, logged_out: true }, options.pretty))
+    await manager.removeAccount(accountId)
+    console.log(formatOutput({ success: true, account_id: accountId, logged_out: true }, options.pretty))
     process.exit(0)
   } catch (error) {
     handleError(error as Error)
@@ -171,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/chat.test.ts

@@ -0,0 +1,198 @@
+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({
+    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',
+  }),
+)
+const mockEnsureAccountPaths = mock(() =>
+  Promise.resolve({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }),
+)
+
+mock.module('../credential-manager', () => ({
+  WhatsAppCredentialManager: class {
+    getAccount = mockGetAccount
+    ensureAccountPaths = mockEnsureAccountPaths
+  },
+}))
+
+const mockListChats = mock(() =>
+  Promise.resolve([
+    {
+      id: 'chat-1',
+      name: 'Alice',
+      lastMessage: 'Hello',
+      unreadCount: 2,
+      timestamp: 1000,
+    },
+  ]),
+)
+
+const mockSearchChats = mock(() =>
+  Promise.resolve([
+    {
+      id: 'chat-2',
+      name: 'Bob',
+      lastMessage: 'Hey',
+      unreadCount: 0,
+      timestamp: 2000,
+    },
+  ]),
+)
+
+const mockConnect = mock(() => Promise.resolve())
+const mockClose = mock(() => Promise.resolve())
+
+mock.module('../client', () => ({
+  WhatsAppClient: class {
+    login = mock(function (this: unknown) { return Promise.resolve(this) })
+    connect = mockConnect
+    close = mockClose
+    listChats = mockListChats
+    searchChats = mockSearchChats
+  },
+}))
+
+import { chatCommand } from './chat'
+
+describe('chat commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockGetAccount.mockReset()
+    mockEnsureAccountPaths.mockReset()
+    mockListChats.mockReset()
+    mockSearchChats.mockReset()
+    mockConnect.mockReset()
+    mockClose.mockReset()
+
+    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',
+      }),
+    )
+    mockEnsureAccountPaths.mockImplementation(() =>
+      Promise.resolve({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }),
+    )
+    mockListChats.mockImplementation(() =>
+      Promise.resolve([
+        {
+          id: 'chat-1',
+          name: 'Alice',
+          lastMessage: 'Hello',
+          unreadCount: 2,
+          timestamp: 1000,
+        },
+      ]),
+    )
+    mockSearchChats.mockImplementation(() =>
+      Promise.resolve([
+        {
+          id: 'chat-2',
+          name: 'Bob',
+          lastMessage: 'Hey',
+          unreadCount: 0,
+          timestamp: 2000,
+        },
+      ]),
+    )
+    mockConnect.mockImplementation(() => Promise.resolve())
+    mockClose.mockImplementation(() => Promise.resolve())
+
+    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()
+  })
+
+  describe('list', () => {
+    test('lists chats with default limit', async () => {
+      await expect(
+        chatCommand.parseAsync(['list'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockListChats).toHaveBeenCalledWith(20)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].id).toBe('chat-1')
+      expect(output[0].name).toBe('Alice')
+    })
+
+    test('respects --limit option', async () => {
+      await expect(
+        chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockListChats).toHaveBeenCalledWith(5)
+    })
+
+    test('passes account option to credential manager', async () => {
+      await expect(
+        chatCommand.parseAsync(['list', '--account', 'my-account'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+
+    test('exits with error when no account configured', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        chatCommand.parseAsync(['list'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+    })
+  })
+
+  describe('search', () => {
+    test('searches chats by query', async () => {
+      await expect(
+        chatCommand.parseAsync(['search', 'Bob'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockSearchChats).toHaveBeenCalledWith('Bob', 20)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].id).toBe('chat-2')
+      expect(output[0].name).toBe('Bob')
+    })
+
+    test('respects --limit option', async () => {
+      await expect(
+        chatCommand.parseAsync(['search', 'Alice', '--limit', '3'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockSearchChats).toHaveBeenCalledWith('Alice', 3)
+    })
+
+    test('passes account option to credential manager', async () => {
+      await expect(
+        chatCommand.parseAsync(['search', 'test', '--account', 'my-account'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+  })
+})

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'