agent-messenger 2.6.3 → 2.8.0

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

@@ -3,7 +3,9 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:
 const originalConsoleLog = console.log
 
 mock.module('@/shared/utils/error-handler', () => ({
-  handleError: (err: Error) => { throw err },
+  handleError: (err: Error) => {
+    throw err
+  },
 }))
 
 const mockGetAccount = mock(() =>
@@ -15,9 +17,7 @@ const mockGetAccount = mock(() =>
     updated_at: '2024-01-01T00:00:00.000Z',
   }),
 )
-const mockEnsureAccountPaths = mock(() =>
-  Promise.resolve({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }),
-)
+const mockEnsureAccountPaths = mock(() => Promise.resolve({ account_dir: '/tmp/test', auth_dir: '/tmp/test/auth' }))
 
 mock.module('../credential-manager', () => ({
   WhatsAppCredentialManager: class {
@@ -54,7 +54,9 @@ const mockClose = mock(() => Promise.resolve())
 
 mock.module('../client', () => ({
   WhatsAppClient: class {
-    login = mock(function (this: unknown) { return Promise.resolve(this) })
+    login = mock(function (this: unknown) {
+      return Promise.resolve(this)
+    })
     connect = mockConnect
     close = mockClose
     getMessages = mockGetMessages
@@ -114,7 +116,8 @@ describe('message commands', () => {
     mockConnect.mockImplementation(() => Promise.resolve())
     mockClose.mockImplementation(() => Promise.resolve())
 
-    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
     processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
       throw new Error(`process.exit(${_code})`)
     })
@@ -128,9 +131,9 @@ describe('message commands', () => {
 
   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)')
+      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])
@@ -158,9 +161,9 @@ describe('message commands', () => {
     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)')
+      await expect(messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' })).rejects.toThrow(
+        'process.exit(1)',
+      )
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
     })
@@ -192,10 +195,7 @@ describe('message commands', () => {
   describe('react', () => {
     test('sends a reaction to a message', async () => {
       await expect(
-        messageCommand.parseAsync(
-          ['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'],
-          { from: 'user' },
-        ),
+        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)
@@ -208,10 +208,9 @@ describe('message commands', () => {
 
     test('passes --from-me flag to sendReaction', async () => {
       await expect(
-        messageCommand.parseAsync(
-          ['react', '12025551234@s.whatsapp.net', 'msg-1', '❤️', '--from-me'],
-          { from: 'user' },
-        ),
+        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)
@@ -219,10 +218,9 @@ describe('message commands', () => {
 
     test('passes account option to credential manager', async () => {
       await expect(
-        messageCommand.parseAsync(
-          ['react', '12025551234@s.whatsapp.net', 'msg-1', '👍', '--account', 'my-account'],
-          { from: 'user' },
-        ),
+        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/message.ts

@@ -1,6 +1,8 @@
 import { Command } from 'commander'
+
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
+
 import { parseLimitOption, withWhatsAppClient } from './shared'
 
 async function listAction(
@@ -17,11 +19,7 @@ async function listAction(
   }
 }
 
-async function sendAction(
-  chat: string,
-  text: string,
-  options: { account?: string; pretty?: boolean },
-): Promise<void> {
+async function sendAction(chat: string, text: string, options: { account?: string; pretty?: boolean }): Promise<void> {
   try {
     const message = await withWhatsAppClient(options, (client) => client.sendMessage(chat, text))
     console.log(formatOutput(message, options.pretty))

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

@@ -1,4 +1,5 @@
 import { formatOutput } from '@/shared/utils/output'
+
 import { WhatsAppClient } from '../client'
 import { WhatsAppCredentialManager } from '../credential-manager'
 import { WhatsAppError } from '../types'
@@ -8,11 +9,7 @@ export interface AccountOption {
   pretty?: boolean
 }
 
-export function parseLimitOption(
-  rawLimit: string | undefined,
-  defaultValue: number,
-  maxValue = 100,
-): number {
+export function parseLimitOption(rawLimit: string | undefined, defaultValue: number, maxValue = 100): number {
   const trimmed = (rawLimit ?? `${defaultValue}`).trim()
 
   if (!/^\d+$/.test(trimmed)) {

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

@@ -21,8 +21,8 @@ describe('whoami command', () => {
       phone_number: '12025551234',
     }
 
-    withWhatsAppClientSpy = spyOn(sharedModule, 'withWhatsAppClient').mockImplementation(
-      async (_opts, fn) => fn({ getProfile: () => Promise.resolve(mockProfileData) } as unknown as WhatsAppClient),
+    withWhatsAppClientSpy = spyOn(sharedModule, 'withWhatsAppClient').mockImplementation(async (_opts, fn) =>
+      fn({ getProfile: () => Promise.resolve(mockProfileData) } as unknown as WhatsAppClient),
     )
     consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
   })

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

@@ -2,12 +2,8 @@ import { existsSync } from 'node:fs'
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import {
-  createAccountId,
-  type WhatsAppAccount,
-  type WhatsAppAccountPaths,
-  type WhatsAppConfig,
-} from './types'
+
+import { createAccountId, type WhatsAppAccount, type WhatsAppAccountPaths, type WhatsAppConfig } from './types'
 
 export class WhatsAppCredentialManager {
   private configDir: string

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

@@ -27,10 +27,7 @@ const validPaths = {
 beforeEach(() => {
   getAccountSpy = spyOn(WhatsAppCredentialManager.prototype, 'getAccount').mockResolvedValue(null)
 
-  getAccountPathsSpy = spyOn(
-    WhatsAppCredentialManager.prototype,
-    'getAccountPaths',
-  ).mockReturnValue(validPaths)
+  getAccountPathsSpy = spyOn(WhatsAppCredentialManager.prototype, 'getAccountPaths').mockReturnValue(validPaths)
 
   existsSyncSpy = spyOn(fs, 'existsSync').mockReturnValue(false)
 

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

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
+
 import { formatOutput } from '@/shared/utils/output'
+
 import { WhatsAppCredentialManager } from './credential-manager'
 
 export async function ensureWhatsAppAuth(): Promise<void> {
@@ -8,9 +10,12 @@ export async function ensureWhatsAppAuth(): Promise<void> {
   const account = await manager.getAccount()
 
   if (!account) {
-    console.log(formatOutput({
-      error: 'Not authenticated. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.',
-    }))
+    console.log(
+      formatOutput({
+        error:
+          'Not authenticated. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" first.',
+      }),
+    )
     process.exit(1)
   }
 
@@ -18,9 +23,12 @@ export async function ensureWhatsAppAuth(): Promise<void> {
   const credsPath = join(paths.auth_dir, 'creds.json')
 
   if (!existsSync(credsPath)) {
-    console.log(formatOutput({
-      error: 'Auth credentials missing. Run "agent-whatsapp auth login --qr" or "agent-whatsapp auth login --phone <phone-number>" to re-authenticate.',
-    }))
+    console.log(
+      formatOutput({
+        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/whatsapp/index.ts

@@ -12,5 +12,3 @@ export {
   type WhatsAppConfig,
   type WhatsAppMessageSummary,
 } from './types'
-
-

package/src/platforms/whatsappbot/client.test.ts

@@ -51,13 +51,21 @@ describe('WhatsAppBotClient', () => {
 
   describe('login', () => {
     test('throws on empty phoneNumberId', async () => {
-      await expect(new WhatsAppBotClient().login({ phoneNumberId: '', accessToken: 'access-token' })).rejects.toThrow(WhatsAppBotError)
-      await expect(new WhatsAppBotClient().login({ phoneNumberId: '', accessToken: 'access-token' })).rejects.toThrow('Phone number ID is required')
+      await expect(new WhatsAppBotClient().login({ phoneNumberId: '', accessToken: 'access-token' })).rejects.toThrow(
+        WhatsAppBotError,
+      )
+      await expect(new WhatsAppBotClient().login({ phoneNumberId: '', accessToken: 'access-token' })).rejects.toThrow(
+        'Phone number ID is required',
+      )
     })
 
     test('throws on empty accessToken', async () => {
-      await expect(new WhatsAppBotClient().login({ phoneNumberId: 'phone-123', accessToken: '' })).rejects.toThrow(WhatsAppBotError)
-      await expect(new WhatsAppBotClient().login({ phoneNumberId: 'phone-123', accessToken: '' })).rejects.toThrow('Access token is required')
+      await expect(new WhatsAppBotClient().login({ phoneNumberId: 'phone-123', accessToken: '' })).rejects.toThrow(
+        WhatsAppBotError,
+      )
+      await expect(new WhatsAppBotClient().login({ phoneNumberId: 'phone-123', accessToken: '' })).rejects.toThrow(
+        'Access token is required',
+      )
     })
 
     test('accepts valid phoneNumberId and accessToken', async () => {
@@ -275,9 +283,7 @@ describe('WhatsAppBotClient', () => {
   describe('getTemplate', () => {
     test('sends GET with name filter and returns first match', async () => {
       mockResponse({
-        data: [
-          { name: 'hello_world', status: 'APPROVED', category: 'UTILITY', language: 'en_US', components: [] },
-        ],
+        data: [{ name: 'hello_world', status: 'APPROVED', category: 'UTILITY', language: 'en_US', components: [] }],
       })
 
       const client = await new WhatsAppBotClient().login({ phoneNumberId: 'phone-123', accessToken: 'my-token' })

package/src/platforms/whatsappbot/client.ts

@@ -101,7 +101,12 @@ export class WhatsAppBotClient {
   }
 
   async listTemplates(params?: { limit?: number }): Promise<WhatsAppBotTemplate[]> {
-    return this.request<WhatsAppBotTemplate[]>('GET', this.buildPath(`/${this.phoneNumberId}/message_templates`, params), undefined, 'data')
+    return this.request<WhatsAppBotTemplate[]>(
+      'GET',
+      this.buildPath(`/${this.phoneNumberId}/message_templates`, params),
+      undefined,
+      'data',
+    )
   }
 
   async getTemplate(templateName: string): Promise<WhatsAppBotTemplate> {
@@ -136,7 +141,16 @@ export class WhatsAppBotClient {
     const usageHeader = response.headers.get('x-business-use-case-usage')
     if (usageHeader) {
       try {
-        const usage = JSON.parse(usageHeader) as Record<string, Array<{ call_count: number; total_cputime: number; total_time: number; type: string; estimated_time_to_regain_access: number }>>
+        const usage = JSON.parse(usageHeader) as Record<
+          string,
+          Array<{
+            call_count: number
+            total_cputime: number
+            total_time: number
+            type: string
+            estimated_time_to_regain_access: number
+          }>
+        >
         for (const entries of Object.values(usage)) {
           for (const entry of entries) {
             if (entry.call_count >= 100) {
@@ -199,7 +213,7 @@ export class WhatsAppBotClient {
           continue
         }
 
-        const errorBody = await response.json().catch(() => ({})) as {
+        const errorBody = (await response.json().catch(() => ({}))) as {
           error?: { message?: string; code?: number }
         }
         const msg = errorBody.error?.message || `HTTP ${response.status}`
@@ -208,7 +222,7 @@ export class WhatsAppBotClient {
       }
 
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => ({})) as {
+        const errorBody = (await response.json().catch(() => ({}))) as {
           error?: { message?: string; code?: number }
         }
         const msg = errorBody.error?.message || `HTTP ${response.status}`

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

@@ -63,7 +63,10 @@ export async function statusAction(options: ActionOptions): Promise<ActionResult
     let accountName: string | undefined
 
     try {
-      const client = await new WhatsAppBotClient().login({ phoneNumberId: creds.phone_number_id, accessToken: creds.access_token })
+      const client = await new WhatsAppBotClient().login({
+        phoneNumberId: creds.phone_number_id,
+        accessToken: creds.access_token,
+      })
       const result = await client.verifyToken()
       valid = true
       phoneNumberId = creds.phone_number_id

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

@@ -174,7 +174,12 @@ describe('message commands', () => {
 
       expect(result.messaging_product).toBe('whatsapp')
       expect(result.messages?.[0].id).toBe('wamid.doc123')
-      expect(mockSendDocumentMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/doc.pdf', undefined, undefined)
+      expect(mockSendDocumentMessage).toHaveBeenCalledWith(
+        '+1234567890',
+        'https://example.com/doc.pdf',
+        undefined,
+        undefined,
+      )
     })
 
     test('passes filename and caption when provided', async () => {
@@ -183,7 +188,12 @@ describe('message commands', () => {
         caption: 'Monthly report',
       })
 
-      expect(mockSendDocumentMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/doc.pdf', 'report.pdf', 'Monthly report')
+      expect(mockSendDocumentMessage).toHaveBeenCalledWith(
+        '+1234567890',
+        'https://example.com/doc.pdf',
+        'report.pdf',
+        'Monthly report',
+      )
       expect(result.error).toBeUndefined()
     })
 

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

@@ -29,7 +29,11 @@ export async function sendAction(to: string, text: string, options: MessageOptio
   }
 }
 
-export async function sendTemplateAction(to: string, templateName: string, options: MessageOptions): Promise<MessageResult> {
+export async function sendTemplateAction(
+  to: string,
+  templateName: string,
+  options: MessageOptions,
+): Promise<MessageResult> {
   try {
     const client = await getClient(options)
     const languageCode = options.language ?? 'en_US'
@@ -48,7 +52,12 @@ export async function sendTemplateAction(to: string, templateName: string, optio
   }
 }
 
-export async function sendReactionAction(to: string, messageId: string, emoji: string, options: MessageOptions): Promise<MessageResult> {
+export async function sendReactionAction(
+  to: string,
+  messageId: string,
+  emoji: string,
+  options: MessageOptions,
+): Promise<MessageResult> {
   try {
     const client = await getClient(options)
     const response = await client.sendReaction(to, messageId, emoji)
@@ -68,7 +77,11 @@ export async function sendImageAction(to: string, imageUrl: string, options: Mes
   }
 }
 
-export async function sendDocumentAction(to: string, documentUrl: string, options: MessageOptions): Promise<MessageResult> {
+export async function sendDocumentAction(
+  to: string,
+  documentUrl: string,
+  options: MessageOptions,
+): Promise<MessageResult> {
   try {
     const client = await getClient(options)
     const response = await client.sendDocumentMessage(to, documentUrl, options.filename, options.caption)

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

@@ -14,7 +14,9 @@ export async function getClient(options: AccountOption): Promise<WhatsAppBotClie
   const creds = await credManager.getCredentials(options.account)
 
   if (!creds) {
-    console.log(formatOutput({ error: 'No credentials. Run "auth set <phone-number-id> <access-token>" first.' }, options.pretty))
+    console.log(
+      formatOutput({ error: 'No credentials. Run "auth set <phone-number-id> <access-token>" first.' }, options.pretty),
+    )
     process.exit(1)
   }
 

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

@@ -4,9 +4,7 @@ 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' }),
-)
+const mockVerifyToken = mock(() => Promise.resolve({ verified_name: 'Test Business' }))
 
 mock.module('../client', () => ({
   WhatsAppBotClient: class MockWhatsAppBotClient {

package/src/platforms/whatsappbot/index.ts

@@ -14,5 +14,3 @@ export {
   WhatsAppBotCredentialsSchema,
   WhatsAppBotError,
 } from './types'
-
-