agent-messenger 1.15.0 → 2.1.0

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

@@ -0,0 +1,303 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { WhatsAppBotCredentialManager } from '@/platforms/whatsappbot/credential-manager'
+
+const testDirs: string[] = []
+
+function setup(): WhatsAppBotCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-whatsappbot-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new WhatsAppBotCredentialManager(testConfigDir)
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('WhatsAppBotCredentialManager', () => {
+  test('load returns default config when file does not exist', async () => {
+    const manager = setup()
+    const config = await manager.load()
+
+    expect(config).toEqual({
+      current: null,
+      accounts: {},
+    })
+  })
+
+  test('save creates file with correct permissions', async () => {
+    const testConfigDir = join(
+      import.meta.dir,
+      `.test-whatsappbot-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    )
+    testDirs.push(testConfigDir)
+    const manager = new WhatsAppBotCredentialManager(testConfigDir)
+    const config = {
+      current: { account_id: '123456789' },
+      accounts: {
+        '123456789': {
+          phone_number_id: '123456789',
+          account_name: 'Test Business',
+          access_token: 'EAAtest123',
+        },
+      },
+    }
+
+    await manager.save(config)
+
+    const credentialsPath = join(testConfigDir, 'whatsappbot-credentials.json')
+    expect(existsSync(credentialsPath)).toBe(true)
+
+    const file = Bun.file(credentialsPath)
+    const content = await file.text()
+    const loaded = JSON.parse(content)
+    expect(loaded).toEqual(config)
+  })
+
+  test('getCredentials returns null when not configured', async () => {
+    const manager = setup()
+    const creds = await manager.getCredentials()
+    expect(creds).toBeNull()
+  })
+
+  test('getCredentials returns credentials from env vars when E2E env vars are set', async () => {
+    const originalAccessToken = process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN
+    const originalPhoneNumberId = process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID
+
+    process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN = 'env-access-token'
+    process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID = '987654321'
+
+    try {
+      const manager = setup()
+      const creds = await manager.getCredentials()
+      expect(creds).toEqual({
+        phone_number_id: '987654321',
+        account_name: 'env',
+        access_token: 'env-access-token',
+      })
+    } finally {
+      if (originalAccessToken === undefined) {
+        delete process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN
+      } else {
+        process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN = originalAccessToken
+      }
+      if (originalPhoneNumberId === undefined) {
+        delete process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID
+      } else {
+        process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID = originalPhoneNumberId
+      }
+    }
+  })
+
+  test('getCredentials ignores env vars when accountId is provided', async () => {
+    const originalAccessToken = process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN
+    const originalPhoneNumberId = process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID
+
+    process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN = 'env-access-token'
+    process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID = '987654321'
+
+    try {
+      const manager = setup()
+      const creds = await manager.getCredentials('nonexistent-id')
+      expect(creds).toBeNull()
+    } finally {
+      if (originalAccessToken === undefined) {
+        delete process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN
+      } else {
+        process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN = originalAccessToken
+      }
+      if (originalPhoneNumberId === undefined) {
+        delete process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID
+      } else {
+        process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID = originalPhoneNumberId
+      }
+    }
+  })
+
+  test('getCredentials returns specific account by accountId', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: 'phone-1',
+      account_name: 'Account One',
+      access_token: 'token-1',
+    })
+    await manager.setCredentials({
+      phone_number_id: 'phone-2',
+      account_name: 'Account Two',
+      access_token: 'token-2',
+    })
+
+    const creds = await manager.getCredentials('phone-1')
+    expect(creds).toEqual({
+      phone_number_id: 'phone-1',
+      account_name: 'Account One',
+      access_token: 'token-1',
+    })
+  })
+
+  test('getCredentials returns null for nonexistent accountId', async () => {
+    const manager = setup()
+    const creds = await manager.getCredentials('nonexistent')
+    expect(creds).toBeNull()
+  })
+
+  test('setCredentials saves and sets as current', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: '123456789',
+      account_name: 'Test Business',
+      access_token: 'EAAtest123',
+    })
+
+    const creds = await manager.getCredentials()
+    expect(creds).toEqual({
+      phone_number_id: '123456789',
+      account_name: 'Test Business',
+      access_token: 'EAAtest123',
+    })
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: '123456789' })
+  })
+
+  test('removeAccount deletes account and adjusts current', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: '123456789',
+      account_name: 'Test Business',
+      access_token: 'EAAtest123',
+    })
+
+    const removed = await manager.removeAccount('123456789')
+    expect(removed).toBe(true)
+
+    const creds = await manager.getCredentials()
+    expect(creds).toBeNull()
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+    expect(config.accounts['123456789']).toBeUndefined()
+  })
+
+  test('removeAccount returns false for non-existent account', async () => {
+    const manager = setup()
+    const removed = await manager.removeAccount('nonexistent')
+    expect(removed).toBe(false)
+  })
+
+  test('removeAccount does not clear current when a different account is removed', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: 'phone-1',
+      account_name: 'Account One',
+      access_token: 'token-1',
+    })
+    await manager.setCredentials({
+      phone_number_id: 'phone-2',
+      account_name: 'Account Two',
+      access_token: 'token-2',
+    })
+
+    const removed = await manager.removeAccount('phone-1')
+    expect(removed).toBe(true)
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: 'phone-2' })
+  })
+
+  test('setCurrent switches active account', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: 'phone-1',
+      account_name: 'Account One',
+      access_token: 'token-1',
+    })
+    await manager.setCredentials({
+      phone_number_id: 'phone-2',
+      account_name: 'Account Two',
+      access_token: 'token-2',
+    })
+
+    const result = await manager.setCurrent('phone-1')
+    expect(result).toBe(true)
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: 'phone-1' })
+  })
+
+  test('setCurrent returns false for non-existent account', async () => {
+    const manager = setup()
+    const result = await manager.setCurrent('nonexistent')
+    expect(result).toBe(false)
+  })
+
+  test('listAll returns all accounts with is_current flag', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: 'phone-1',
+      account_name: 'Account One',
+      access_token: 'token-1',
+    })
+    await manager.setCredentials({
+      phone_number_id: 'phone-2',
+      account_name: 'Account Two',
+      access_token: 'token-2',
+    })
+
+    const accounts = await manager.listAll()
+    expect(accounts).toHaveLength(2)
+
+    const phone1 = accounts.find((a) => a.phone_number_id === 'phone-1')
+    const phone2 = accounts.find((a) => a.phone_number_id === 'phone-2')
+
+    expect(phone1?.is_current).toBe(false)
+    expect(phone2?.is_current).toBe(true)
+  })
+
+  test('listAll returns empty array when no accounts', async () => {
+    const manager = setup()
+    const accounts = await manager.listAll()
+    expect(accounts).toHaveLength(0)
+  })
+
+  test('clearCredentials resets everything', async () => {
+    const manager = setup()
+    await manager.setCredentials({
+      phone_number_id: '123456789',
+      account_name: 'Test Business',
+      access_token: 'EAAtest123',
+    })
+
+    await manager.clearCredentials()
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+    expect(config.accounts).toEqual({})
+  })
+
+  test('round-trip: set → get → remove → get null', async () => {
+    const manager = setup()
+
+    await manager.setCredentials({
+      phone_number_id: '123456789',
+      account_name: 'Test Business',
+      access_token: 'EAAtest123',
+    })
+
+    const creds = await manager.getCredentials()
+    expect(creds?.phone_number_id).toBe('123456789')
+    expect(creds?.access_token).toBe('EAAtest123')
+
+    await manager.removeAccount('123456789')
+
+    const afterRemove = await manager.getCredentials()
+    expect(afterRemove).toBeNull()
+  })
+})

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

@@ -0,0 +1,148 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { WhatsAppBotAccountEntry, WhatsAppBotConfig, WhatsAppBotCredentials } from './types'
+import { WhatsAppBotConfigSchema } from './types'
+
+export class WhatsAppBotCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'whatsappbot-credentials.json')
+  }
+
+  async load(): Promise<WhatsAppBotConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, accounts: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    let json: unknown
+    try {
+      json = JSON.parse(content)
+    } catch {
+      return { current: null, accounts: {} }
+    }
+    const parsed = WhatsAppBotConfigSchema.safeParse(json)
+    if (!parsed.success) {
+      return { current: null, accounts: {} }
+    }
+    return parsed.data
+  }
+
+  async save(config: WhatsAppBotConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getCredentials(accountId?: string): Promise<WhatsAppBotCredentials | null> {
+    const envAccessToken = process.env.E2E_WHATSAPPBOT_ACCESS_TOKEN
+    const envPhoneNumberId = process.env.E2E_WHATSAPPBOT_PHONE_NUMBER_ID
+
+    if (envAccessToken && envPhoneNumberId && !accountId) {
+      return {
+        phone_number_id: envPhoneNumberId,
+        account_name: 'env',
+        access_token: envAccessToken,
+      }
+    }
+
+    const config = await this.load()
+
+    if (accountId) {
+      const account = config.accounts[accountId]
+      if (!account) return null
+      return {
+        phone_number_id: account.phone_number_id,
+        account_name: account.account_name,
+        access_token: account.access_token,
+      }
+    }
+
+    if (!config.current) {
+      return null
+    }
+
+    const account = config.accounts[config.current.account_id]
+    if (!account) return null
+
+    return {
+      phone_number_id: account.phone_number_id,
+      account_name: account.account_name,
+      access_token: account.access_token,
+    }
+  }
+
+  async setCredentials(entry: WhatsAppBotAccountEntry): Promise<void> {
+    const config = await this.load()
+
+    config.accounts[entry.phone_number_id] = {
+      phone_number_id: entry.phone_number_id,
+      account_name: entry.account_name,
+      access_token: entry.access_token,
+    }
+
+    config.current = {
+      account_id: entry.phone_number_id,
+    }
+
+    await this.save(config)
+  }
+
+  async removeAccount(accountId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.accounts[accountId]) {
+      return false
+    }
+
+    delete config.accounts[accountId]
+
+    if (config.current?.account_id === accountId) {
+      config.current = null
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async setCurrent(accountId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.accounts[accountId]) {
+      return false
+    }
+
+    config.current = {
+      account_id: accountId,
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async listAll(): Promise<Array<WhatsAppBotAccountEntry & { is_current: boolean }>> {
+    const config = await this.load()
+    const results: Array<WhatsAppBotAccountEntry & { is_current: boolean }> = []
+
+    for (const account of Object.values(config.accounts)) {
+      results.push({
+        phone_number_id: account.phone_number_id,
+        account_name: account.account_name,
+        access_token: account.access_token,
+        is_current: config.current?.account_id === account.phone_number_id,
+      })
+    }
+
+    return results
+  }
+
+  async clearCredentials(): Promise<void> {
+    await this.save({ current: null, accounts: {} })
+  }
+}

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

@@ -0,0 +1,34 @@
+import { expect, test } from 'bun:test'
+
+import {
+  WhatsAppBotAccountEntrySchema,
+  WhatsAppBotClient,
+  WhatsAppBotConfigSchema,
+  WhatsAppBotCredentialManager,
+  WhatsAppBotCredentialsSchema,
+  WhatsAppBotError,
+} from '@/platforms/whatsappbot/index'
+
+test('WhatsAppBotClient is exported from barrel', () => {
+  expect(typeof WhatsAppBotClient).toBe('function')
+})
+
+test('WhatsAppBotCredentialManager is exported from barrel', () => {
+  expect(typeof WhatsAppBotCredentialManager).toBe('function')
+})
+
+test('WhatsAppBotError is exported from barrel', () => {
+  expect(typeof WhatsAppBotError).toBe('function')
+})
+
+test('WhatsAppBotAccountEntrySchema is exported from barrel', () => {
+  expect(typeof WhatsAppBotAccountEntrySchema.parse).toBe('function')
+})
+
+test('WhatsAppBotConfigSchema is exported from barrel', () => {
+  expect(typeof WhatsAppBotConfigSchema.parse).toBe('function')
+})
+
+test('WhatsAppBotCredentialsSchema is exported from barrel', () => {
+  expect(typeof WhatsAppBotCredentialsSchema.parse).toBe('function')
+})

package/src/platforms/whatsappbot/index.ts

@@ -0,0 +1,18 @@
+export { WhatsAppBotClient } from './client'
+export { WhatsAppBotCredentialManager } from './credential-manager'
+export type {
+  WhatsAppBotAccountEntry,
+  WhatsAppBotConfig,
+  WhatsAppBotCredentials,
+  WhatsAppBotMessageResponse,
+  WhatsAppBotTemplate,
+  WhatsAppBotTemplateComponent,
+} from './types'
+export {
+  WhatsAppBotAccountEntrySchema,
+  WhatsAppBotConfigSchema,
+  WhatsAppBotCredentialsSchema,
+  WhatsAppBotError,
+} from './types'
+
+

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

@@ -0,0 +1,141 @@
+import { expect, test } from 'bun:test'
+
+import {
+  WhatsAppBotAccountEntrySchema,
+  WhatsAppBotConfigSchema,
+  WhatsAppBotCredentialsSchema,
+  WhatsAppBotError,
+} from '@/platforms/whatsappbot/types'
+
+test('WhatsAppBotAccountEntrySchema validates correct data', () => {
+  const result = WhatsAppBotAccountEntrySchema.safeParse({
+    phone_number_id: '123456789',
+    account_name: 'Test Business',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WhatsAppBotAccountEntrySchema rejects missing phone_number_id', () => {
+  const result = WhatsAppBotAccountEntrySchema.safeParse({
+    account_name: 'Test Business',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotAccountEntrySchema rejects missing account_name', () => {
+  const result = WhatsAppBotAccountEntrySchema.safeParse({
+    phone_number_id: '123456789',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotAccountEntrySchema rejects missing access_token', () => {
+  const result = WhatsAppBotAccountEntrySchema.safeParse({
+    phone_number_id: '123456789',
+    account_name: 'Test Business',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotConfigSchema validates with current account', () => {
+  const result = WhatsAppBotConfigSchema.safeParse({
+    current: { account_id: '123456789' },
+    accounts: {
+      '123456789': {
+        phone_number_id: '123456789',
+        account_name: 'Test Business',
+        access_token: 'EAAtest123',
+      },
+    },
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WhatsAppBotConfigSchema validates with current null and empty accounts', () => {
+  const result = WhatsAppBotConfigSchema.safeParse({
+    current: null,
+    accounts: {},
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WhatsAppBotConfigSchema validates with multiple accounts', () => {
+  const result = WhatsAppBotConfigSchema.safeParse({
+    current: { account_id: 'phone-1' },
+    accounts: {
+      'phone-1': { phone_number_id: 'phone-1', account_name: 'Account 1', access_token: 'token-1' },
+      'phone-2': { phone_number_id: 'phone-2', account_name: 'Account 2', access_token: 'token-2' },
+    },
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WhatsAppBotConfigSchema rejects missing accounts field', () => {
+  const result = WhatsAppBotConfigSchema.safeParse({
+    current: null,
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotConfigSchema rejects missing current field', () => {
+  const result = WhatsAppBotConfigSchema.safeParse({
+    accounts: {},
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotCredentialsSchema validates correct data', () => {
+  const result = WhatsAppBotCredentialsSchema.safeParse({
+    phone_number_id: '123456789',
+    account_name: 'Test Business',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WhatsAppBotCredentialsSchema rejects missing phone_number_id', () => {
+  const result = WhatsAppBotCredentialsSchema.safeParse({
+    account_name: 'Test Business',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotCredentialsSchema rejects missing account_name', () => {
+  const result = WhatsAppBotCredentialsSchema.safeParse({
+    phone_number_id: '123456789',
+    access_token: 'EAAtest123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotCredentialsSchema rejects missing access_token', () => {
+  const result = WhatsAppBotCredentialsSchema.safeParse({
+    phone_number_id: '123456789',
+    account_name: 'Test Business',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WhatsAppBotError has correct name', () => {
+  const error = new WhatsAppBotError('Test error', 'TEST_CODE')
+  expect(error.name).toBe('WhatsAppBotError')
+})
+
+test('WhatsAppBotError has correct message', () => {
+  const error = new WhatsAppBotError('Test error', 'TEST_CODE')
+  expect(error.message).toBe('Test error')
+})
+
+test('WhatsAppBotError has correct code', () => {
+  const error = new WhatsAppBotError('Test error', 'TEST_CODE')
+  expect(error.code).toBe('TEST_CODE')
+})
+
+test('WhatsAppBotError is instance of Error', () => {
+  const error = new WhatsAppBotError('Test error', 'TEST_CODE')
+  expect(error instanceof Error).toBe(true)
+})