agent-messenger 2.2.0 → 2.4.0

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

@@ -0,0 +1,231 @@
+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 mockGetMessages = mock(() =>
+  Promise.resolve([
+    {
+      id: 'msg-1',
+      text: 'Hello',
+      from: '12025551234@s.whatsapp.net',
+      timestamp: 1000,
+      fromMe: false,
+    },
+  ]),
+)
+
+const mockSendMessage = mock(() =>
+  Promise.resolve({
+    id: 'msg-2',
+    text: 'Hi there',
+    from: 'me@s.whatsapp.net',
+    timestamp: 2000,
+    fromMe: true,
+  }),
+)
+
+const mockSendReaction = mock(() => Promise.resolve())
+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
+    getMessages = mockGetMessages
+    sendMessage = mockSendMessage
+    sendReaction = mockSendReaction
+  },
+}))
+
+import { messageCommand } from './message'
+
+describe('message commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockGetAccount.mockReset()
+    mockEnsureAccountPaths.mockReset()
+    mockGetMessages.mockReset()
+    mockSendMessage.mockReset()
+    mockSendReaction.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' }),
+    )
+    mockGetMessages.mockImplementation(() =>
+      Promise.resolve([
+        {
+          id: 'msg-1',
+          text: 'Hello',
+          from: '12025551234@s.whatsapp.net',
+          timestamp: 1000,
+          fromMe: false,
+        },
+      ]),
+    )
+    mockSendMessage.mockImplementation(() =>
+      Promise.resolve({
+        id: 'msg-2',
+        text: 'Hi there',
+        from: 'me@s.whatsapp.net',
+        timestamp: 2000,
+        fromMe: true,
+      }),
+    )
+    mockSendReaction.mockImplementation(() => Promise.resolve())
+    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('fetches messages for a chat', async () => {
+      await expect(
+        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetMessages).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 25)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].id).toBe('msg-1')
+      expect(output[0].text).toBe('Hello')
+    })
+
+    test('respects --limit option', async () => {
+      await expect(
+        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--limit', '10'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetMessages).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 10)
+    })
+
+    test('passes account option to credential manager', async () => {
+      await expect(
+        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--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(
+        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(1)')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+    })
+  })
+
+  describe('send', () => {
+    test('sends a message to a chat', async () => {
+      await expect(
+        messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hello world'], { from: 'user' }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockSendMessage).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'Hello world')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.id).toBe('msg-2')
+      expect(output.text).toBe('Hi there')
+    })
+
+    test('passes account option to credential manager', async () => {
+      await expect(
+        messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hi', '--account', 'my-account'], {
+          from: 'user',
+        }),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+  })
+
+  describe('react', () => {
+    test('sends a reaction to a message', async () => {
+      await expect(
+        messageCommand.parseAsync(
+          ['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'],
+          { from: 'user' },
+        ),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockSendReaction).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-1', '👍', undefined)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.chat).toBe('12025551234@s.whatsapp.net')
+      expect(output.message_id).toBe('msg-1')
+      expect(output.emoji).toBe('👍')
+    })
+
+    test('passes --from-me flag to sendReaction', async () => {
+      await expect(
+        messageCommand.parseAsync(
+          ['react', '12025551234@s.whatsapp.net', 'msg-1', '❤️', '--from-me'],
+          { from: 'user' },
+        ),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockSendReaction).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-1', '❤️', true)
+    })
+
+    test('passes account option to credential manager', async () => {
+      await expect(
+        messageCommand.parseAsync(
+          ['react', '12025551234@s.whatsapp.net', 'msg-1', '👍', '--account', 'my-account'],
+          { from: 'user' },
+        ),
+      ).rejects.toThrow('process.exit(0)')
+
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+  })
+})

package/src/platforms/whatsapp/credential-manager.test.ts

@@ -198,6 +198,26 @@ describe('WhatsAppCredentialManager', () => {
 
       expect(result).toBe(false)
     })
+
+    test('deletes session directory even when account is not in config', async () => {
+      const manager = setup()
+
+      const paths = await manager.ensureAccountPaths('orphan-account')
+      expect(existsSync(paths.account_dir)).toBe(true)
+
+      const result = await manager.removeAccount('orphan-account')
+
+      expect(result).toBe(true)
+      expect(existsSync(paths.account_dir)).toBe(false)
+    })
+
+    test('returns false when neither config entry nor directory exists', async () => {
+      const manager = setup()
+
+      const result = await manager.removeAccount('ghost-account')
+
+      expect(result).toBe(false)
+    })
   })
 
   describe('clearCredentials', () => {

package/src/platforms/whatsapp/credential-manager.ts

@@ -91,19 +91,28 @@ export class WhatsAppCredentialManager {
     const config = await this.loadConfig()
     const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
 
-    if (!account) {
-      return false
+    let removedFromConfig = false
+
+    if (account) {
+      delete config.accounts[account.account_id]
+
+      if (config.current === account.account_id) {
+        config.current = Object.keys(config.accounts)[0] ?? null
+      }
+
+      await this.saveConfig(config)
+      removedFromConfig = true
     }
 
-    delete config.accounts[account.account_id]
+    const resolvedId = account?.account_id ?? createAccountId(accountId)
+    const accountDir = this.getAccountPaths(resolvedId).account_dir
+    const dirExisted = existsSync(accountDir)
 
-    if (config.current === account.account_id) {
-      config.current = Object.keys(config.accounts)[0] ?? null
+    if (dirExisted) {
+      await rm(accountDir, { recursive: true, force: true })
     }
 
-    await this.saveConfig(config)
-    await rm(this.getAccountPaths(account.account_id).account_dir, { recursive: true, force: true })
-    return true
+    return removedFromConfig || dirExisted
   }
 
   async clearCredentials(): Promise<void> {

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

@@ -0,0 +1,217 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockVerifyToken = mock(() =>
+  Promise.resolve({
+    verified_name: 'Test Business',
+  }),
+)
+
+mock.module('../client', () => ({
+  WhatsAppBotClient: class MockWhatsAppBotClient {
+    async login(_credentials?: { phoneNumberId: string; accessToken: string }) {
+      return this
+    }
+    verifyToken = mockVerifyToken
+  },
+}))
+
+import { WhatsAppBotCredentialManager } from '../credential-manager'
+import { clearAction, listAction, removeAction, setAction, statusAction, useAction } from './auth'
+
+describe('auth commands', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `whatsappbot-auth-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    mockVerifyToken.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+  })
+
+  describe('setAction', () => {
+    test('validates token and stores credentials', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await setAction('12345678901', 'EAAtest-token', { _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(result.phone_number_id).toBe('12345678901')
+      expect(result.account_name).toBe('Test Business')
+
+      const creds = await manager.getCredentials()
+      expect(creds?.phone_number_id).toBe('12345678901')
+      expect(creds?.access_token).toBe('EAAtest-token')
+    })
+
+    test('returns error when client throws', async () => {
+      mockVerifyToken.mockImplementationOnce(() => Promise.reject(new Error('Invalid token')))
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await setAction('12345678901', 'bad-token', { _credManager: manager })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Invalid token')
+    })
+  })
+
+  describe('statusAction', () => {
+    test('returns invalid status when no credentials set', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await statusAction({ _credManager: manager })
+
+      expect(result.valid).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    test('returns valid status when credentials are set', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '12345678901',
+        account_name: 'Test Business',
+        access_token: 'EAAtest-token',
+      })
+
+      const result = await statusAction({ _credManager: manager })
+
+      expect(result.valid).toBe(true)
+      expect(result.phone_number_id).toBe('12345678901')
+      expect(result.account_name).toBe('Test Business')
+    })
+
+    test('returns invalid status when verifyToken fails', async () => {
+      mockVerifyToken.mockImplementationOnce(() => Promise.reject(new Error('Token expired')))
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '12345678901',
+        account_name: 'Test Business',
+        access_token: 'expired-token',
+      })
+
+      const result = await statusAction({ _credManager: manager })
+
+      expect(result.valid).toBe(false)
+      expect(result.phone_number_id).toBe('12345678901')
+    })
+
+    test('returns error for unknown account', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await statusAction({ account: 'nonexistent', _credManager: manager })
+
+      expect(result.valid).toBe(false)
+      expect(result.error).toContain('nonexistent')
+    })
+  })
+
+  describe('clearAction', () => {
+    test('removes all stored credentials', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '12345678901',
+        account_name: 'Test Business',
+        access_token: 'EAAtest-token',
+      })
+
+      const result = await clearAction({ _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(await manager.getCredentials()).toBeNull()
+    })
+  })
+
+  describe('listAction', () => {
+    test('returns empty accounts when none set', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await listAction({ _credManager: manager })
+
+      expect(result.accounts).toHaveLength(0)
+    })
+
+    test('returns all stored accounts', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '11111111111',
+        account_name: 'Account A',
+        access_token: 'token-a',
+      })
+      await manager.setCredentials({
+        phone_number_id: '22222222222',
+        account_name: 'Account B',
+        access_token: 'token-b',
+      })
+
+      const result = await listAction({ _credManager: manager })
+
+      expect(result.accounts).toHaveLength(2)
+      expect(result.accounts?.find((a) => a.phone_number_id === '11111111111')?.account_name).toBe('Account A')
+      expect(result.accounts?.find((a) => a.phone_number_id === '22222222222')?.is_current).toBe(true)
+    })
+  })
+
+  describe('useAction', () => {
+    test('switches current account', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '11111111111',
+        account_name: 'Account A',
+        access_token: 'token-a',
+      })
+      await manager.setCredentials({
+        phone_number_id: '22222222222',
+        account_name: 'Account B',
+        access_token: 'token-b',
+      })
+
+      const result = await useAction('11111111111', { _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(result.phone_number_id).toBe('11111111111')
+      expect(result.account_name).toBe('Account A')
+    })
+
+    test('returns error for unknown account', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await useAction('nonexistent', { _credManager: manager })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('nonexistent')
+    })
+  })
+
+  describe('removeAction', () => {
+    test('removes a stored account', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+      await manager.setCredentials({
+        phone_number_id: '12345678901',
+        account_name: 'Test Business',
+        access_token: 'EAAtest-token',
+      })
+
+      const result = await removeAction('12345678901', { _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(await manager.getCredentials('12345678901')).toBeNull()
+    })
+
+    test('returns error for unknown account', async () => {
+      const manager = new WhatsAppBotCredentialManager(tempDir)
+
+      const result = await removeAction('nonexistent', { _credManager: manager })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('nonexistent')
+    })
+  })
+})