agent-messenger 2.2.0 → 2.4.0

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')
+    })
+  })
+})

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

@@ -1,3 +1,4 @@
+import { rm } from 'node:fs/promises'
 import { Command } from 'commander'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
@@ -19,6 +20,9 @@ async function loginAction(options: LoginOptions): 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 })
 
@@ -138,29 +142,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)

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')
+    })
+  })
+})