agent-messenger 2.3.0 → 2.5.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/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/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/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)
   }

package/src/platforms/whatsappbot/cli.ts

@@ -3,7 +3,7 @@
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, messageCommand, templateCommand } from './commands/index'
+import { authCommand, messageCommand, templateCommand, whoamiCommand } from './commands/index'
 
 const program = new Command()
 
@@ -15,6 +15,7 @@ program
   .option('--account <id>', 'Account ID to use')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(messageCommand)
 program.addCommand(templateCommand)
 

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

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

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