agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,134 @@
+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'
+
+export class WhatsAppCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+  private baileysRootDir: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'whatsapp-credentials.json')
+    this.baileysRootDir = join(this.configDir, 'whatsapp')
+  }
+
+  async loadConfig(): Promise<WhatsAppConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, accounts: {} }
+    }
+
+    try {
+      const content = await readFile(this.credentialsPath, 'utf-8')
+      return JSON.parse(content) as WhatsAppConfig
+    } catch {
+      return { current: null, accounts: {} }
+    }
+  }
+
+  async saveConfig(config: WhatsAppConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+  }
+
+  async getAccount(accountId?: string): Promise<WhatsAppAccount | null> {
+    const config = await this.loadConfig()
+
+    if (!accountId) {
+      return config.current ? (config.accounts[config.current] ?? null) : null
+    }
+
+    const direct = config.accounts[accountId]
+    if (direct) {
+      return direct
+    }
+
+    const normalized = createAccountId(accountId)
+    return config.accounts[normalized] ?? null
+  }
+
+  async listAccounts(): Promise<Array<WhatsAppAccount & { is_current: boolean }>> {
+    const config = await this.loadConfig()
+
+    return Object.values(config.accounts).map((account) => ({
+      ...account,
+      is_current: account.account_id === config.current,
+    }))
+  }
+
+  async setAccount(account: WhatsAppAccount): Promise<void> {
+    const config = await this.loadConfig()
+    config.accounts[account.account_id] = account
+
+    if (!config.current) {
+      config.current = account.account_id
+    }
+
+    await this.saveConfig(config)
+  }
+
+  async setCurrent(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    config.current = account.account_id
+    await this.saveConfig(config)
+    return true
+  }
+
+  async removeAccount(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    delete config.accounts[account.account_id]
+
+    if (config.current === account.account_id) {
+      config.current = Object.keys(config.accounts)[0] ?? null
+    }
+
+    await this.saveConfig(config)
+    await rm(this.getAccountPaths(account.account_id).account_dir, { recursive: true, force: true })
+    return true
+  }
+
+  async clearCredentials(): Promise<void> {
+    if (existsSync(this.credentialsPath)) {
+      await rm(this.credentialsPath, { force: true })
+    }
+
+    if (existsSync(this.baileysRootDir)) {
+      await rm(this.baileysRootDir, { recursive: true, force: true })
+    }
+  }
+
+  getAccountPaths(accountId: string): WhatsAppAccountPaths {
+    const safeAccountId = createAccountId(accountId)
+    const accountDir = join(this.baileysRootDir, safeAccountId)
+
+    return {
+      account_dir: accountDir,
+      auth_dir: join(accountDir, 'auth'),
+    }
+  }
+
+  async ensureAccountPaths(accountId: string): Promise<WhatsAppAccountPaths> {
+    const paths = this.getAccountPaths(accountId)
+    await mkdir(paths.auth_dir, { recursive: true })
+    return paths
+  }
+}

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

@@ -0,0 +1,85 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import * as fs from 'node:fs'
+
+import { WhatsAppCredentialManager } from '@/platforms/whatsapp/credential-manager'
+import { ensureWhatsAppAuth } from '@/platforms/whatsapp/ensure-auth'
+import type { WhatsAppAccount } from '@/platforms/whatsapp/types'
+
+let getAccountSpy: ReturnType<typeof spyOn>
+let getAccountPathsSpy: ReturnType<typeof spyOn>
+let existsSyncSpy: ReturnType<typeof spyOn>
+let exitSpy: ReturnType<typeof spyOn>
+let consoleSpy: ReturnType<typeof spyOn>
+
+const validAccount: WhatsAppAccount = {
+  account_id: 'test-account',
+  phone_number: '+12025551234',
+  name: 'Test User',
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+}
+
+const validPaths = {
+  account_dir: '/tmp/test/whatsapp/test-account',
+  auth_dir: '/tmp/test/whatsapp/test-account/auth',
+}
+
+beforeEach(() => {
+  getAccountSpy = spyOn(WhatsAppCredentialManager.prototype, 'getAccount').mockResolvedValue(null)
+
+  getAccountPathsSpy = spyOn(
+    WhatsAppCredentialManager.prototype,
+    'getAccountPaths',
+  ).mockReturnValue(validPaths)
+
+  existsSyncSpy = spyOn(fs, 'existsSync').mockReturnValue(false)
+
+  exitSpy = spyOn(process, 'exit').mockImplementation((code) => {
+    throw new Error(`process.exit(${code})`)
+  })
+
+  consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+})
+
+afterEach(() => {
+  getAccountSpy?.mockRestore()
+  getAccountPathsSpy?.mockRestore()
+  existsSyncSpy?.mockRestore()
+  exitSpy?.mockRestore()
+  consoleSpy?.mockRestore()
+})
+
+describe('ensureWhatsAppAuth', () => {
+  test('exits with error when no account configured', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(null)
+
+    // when / then
+    await expect(ensureWhatsAppAuth()).rejects.toThrow('process.exit(1)')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+    expect(consoleSpy).toHaveBeenCalled()
+  })
+
+  test('exits with error when creds file missing', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(validAccount)
+    existsSyncSpy.mockReturnValue(false)
+
+    // when / then
+    await expect(ensureWhatsAppAuth()).rejects.toThrow('process.exit(1)')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+    expect(consoleSpy).toHaveBeenCalled()
+  })
+
+  test('succeeds when account and creds file exist', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(validAccount)
+    existsSyncSpy.mockReturnValue(true)
+
+    // when
+    await ensureWhatsAppAuth()
+
+    // then
+    expect(exitSpy).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,26 @@
+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> {
+  const manager = new WhatsAppCredentialManager()
+  const account = await manager.getAccount()
+
+  if (!account) {
+    console.log(formatOutput({
+      error: 'Not authenticated. Run "agent-whatsapp auth login --phone <phone-number>" first.',
+    }))
+    process.exit(1)
+  }
+
+  const paths = manager.getAccountPaths(account.account_id)
+  const credsPath = join(paths.auth_dir, 'creds.json')
+
+  if (!existsSync(credsPath)) {
+    console.log(formatOutput({
+      error: 'Auth credentials missing. Run "agent-whatsapp auth login --phone <phone-number>" to re-authenticate.',
+    }))
+    process.exit(1)
+  }
+}

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

@@ -0,0 +1,39 @@
+import { expect, test } from 'bun:test'
+
+import {
+  createAccountId,
+  extractMessageText,
+  getMessageType,
+  jidToType,
+  WhatsAppClient,
+  WhatsAppCredentialManager,
+  WhatsAppError,
+} from '@/platforms/whatsapp/index'
+
+test('WhatsAppClient is exported from barrel', () => {
+  expect(typeof WhatsAppClient).toBe('function')
+})
+
+test('WhatsAppCredentialManager is exported from barrel', () => {
+  expect(typeof WhatsAppCredentialManager).toBe('function')
+})
+
+test('WhatsAppError is exported from barrel', () => {
+  expect(typeof WhatsAppError).toBe('function')
+})
+
+test('createAccountId is exported from barrel', () => {
+  expect(typeof createAccountId).toBe('function')
+})
+
+test('jidToType is exported from barrel', () => {
+  expect(typeof jidToType).toBe('function')
+})
+
+test('extractMessageText is exported from barrel', () => {
+  expect(typeof extractMessageText).toBe('function')
+})
+
+test('getMessageType is exported from barrel', () => {
+  expect(typeof getMessageType).toBe('function')
+})

package/src/platforms/whatsapp/index.ts

@@ -0,0 +1,16 @@
+export { WhatsAppClient } from './client'
+export { WhatsAppCredentialManager } from './credential-manager'
+export {
+  createAccountId,
+  extractMessageText,
+  getMessageType,
+  jidToType,
+  WhatsAppError,
+  type WhatsAppAccount,
+  type WhatsAppAccountPaths,
+  type WhatsAppChatSummary,
+  type WhatsAppConfig,
+  type WhatsAppMessageSummary,
+} from './types'
+
+

package/src/platforms/whatsapp/suppress-ws-warnings.ts

@@ -0,0 +1,21 @@
+/**
+ * Suppress Bun's ws.WebSocket warnings for unimplemented events ('upgrade', 'unexpected-response').
+ *
+ * Baileys registers listeners for ALL ws events including ones Bun hasn't implemented.
+ * Bun prints native C++ warnings that bypass process.stderr.write.
+ * This patches ws.WebSocket.prototype.on to silently skip those events.
+ *
+ * Must be imported before any Baileys import.
+ */
+const SUPPRESSED_EVENTS = new Set(['upgrade', 'unexpected-response'])
+
+try {
+  const ws = require('ws') as { WebSocket: { prototype: Record<string, Function> } }
+  const origOn = ws.WebSocket.prototype.on
+  ws.WebSocket.prototype.on = function (event: string, ...args: unknown[]) {
+    if (SUPPRESSED_EVENTS.has(event)) return this
+    return origOn.call(this, event, ...args)
+  }
+} catch {
+  // ws not available (e.g. in Node.js without Baileys) — no-op
+}

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

@@ -0,0 +1,190 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  createAccountId,
+  extractMessageText,
+  getMessageType,
+  jidToType,
+  WhatsAppError,
+} from '@/platforms/whatsapp/types'
+
+describe('WhatsAppError', () => {
+  test('name is WhatsAppError', () => {
+    const err = new WhatsAppError('test message')
+    expect(err.name).toBe('WhatsAppError')
+  })
+
+  test('message is set correctly', () => {
+    const err = new WhatsAppError('something went wrong')
+    expect(err.message).toBe('something went wrong')
+  })
+
+  test('default code is whatsapp_error', () => {
+    const err = new WhatsAppError('test')
+    expect(err.code).toBe('whatsapp_error')
+  })
+
+  test('custom string code is preserved', () => {
+    const err = new WhatsAppError('test', 'auth_failed')
+    expect(err.code).toBe('auth_failed')
+  })
+
+  test('numeric code is preserved', () => {
+    const err = new WhatsAppError('test', 404)
+    expect(err.code).toBe(404)
+  })
+
+  test('is instanceof Error', () => {
+    const err = new WhatsAppError('test')
+    expect(err instanceof Error).toBe(true)
+  })
+
+  test('is instanceof WhatsAppError', () => {
+    const err = new WhatsAppError('test')
+    expect(err instanceof WhatsAppError).toBe(true)
+  })
+})
+
+describe('createAccountId', () => {
+  test('converts phone with leading + to plus- prefix', () => {
+    expect(createAccountId('+12025551234')).toBe('plus-12025551234')
+  })
+
+  test('trims and lowercases with spaces becoming dashes', () => {
+    expect(createAccountId('  My Account  ')).toBe('my-account')
+  })
+
+  test('replaces special chars like @ with dashes', () => {
+    expect(createAccountId('hello@world')).toBe('hello-world')
+  })
+
+  test('empty string returns default', () => {
+    expect(createAccountId('')).toBe('default')
+  })
+
+  test('whitespace-only string returns default', () => {
+    expect(createAccountId('   ')).toBe('default')
+  })
+
+  test('already normalized input is unchanged', () => {
+    expect(createAccountId('my-account')).toBe('my-account')
+  })
+
+  test('collapses multiple special chars into single dash', () => {
+    expect(createAccountId('foo!!bar')).toBe('foo-bar')
+  })
+})
+
+describe('jidToType', () => {
+  test('individual JID returns individual', () => {
+    expect(jidToType('1234@s.whatsapp.net')).toBe('individual')
+  })
+
+  test('group JID returns group', () => {
+    expect(jidToType('1234-5678@g.us')).toBe('group')
+  })
+
+  test('status@broadcast returns status', () => {
+    expect(jidToType('status@broadcast')).toBe('status')
+  })
+
+  test('other @broadcast JID returns broadcast', () => {
+    expect(jidToType('1234@broadcast')).toBe('broadcast')
+  })
+})
+
+describe('extractMessageText', () => {
+  test('null returns undefined', () => {
+    expect(extractMessageText(null)).toBeUndefined()
+  })
+
+  test('undefined returns undefined', () => {
+    expect(extractMessageText(undefined)).toBeUndefined()
+  })
+
+  test('conversation returns conversation text', () => {
+    expect(extractMessageText({ conversation: 'hello' })).toBe('hello')
+  })
+
+  test('extendedTextMessage returns text', () => {
+    expect(extractMessageText({ extendedTextMessage: { text: 'hello' } })).toBe('hello')
+  })
+
+  test('imageMessage returns caption', () => {
+    expect(extractMessageText({ imageMessage: { caption: 'photo' } })).toBe('photo')
+  })
+
+  test('videoMessage returns caption', () => {
+    expect(extractMessageText({ videoMessage: { caption: 'vid' } })).toBe('vid')
+  })
+
+  test('reactionMessage returns text', () => {
+    expect(extractMessageText({ reactionMessage: { text: '👍' } })).toBe('👍')
+  })
+
+  test('empty message returns undefined', () => {
+    expect(extractMessageText({})).toBeUndefined()
+  })
+})
+
+describe('getMessageType', () => {
+  test('null returns unknown', () => {
+    expect(getMessageType(null)).toBe('unknown')
+  })
+
+  test('undefined returns unknown', () => {
+    expect(getMessageType(undefined)).toBe('unknown')
+  })
+
+  test('conversation returns text', () => {
+    expect(getMessageType({ conversation: 'hi' })).toBe('text')
+  })
+
+  test('extendedTextMessage returns text', () => {
+    expect(getMessageType({ extendedTextMessage: { text: 'hi' } })).toBe('text')
+  })
+
+  test('imageMessage returns image', () => {
+    expect(getMessageType({ imageMessage: {} })).toBe('image')
+  })
+
+  test('videoMessage returns video', () => {
+    expect(getMessageType({ videoMessage: {} })).toBe('video')
+  })
+
+  test('videoMessage with gifPlayback returns gif', () => {
+    expect(getMessageType({ videoMessage: { gifPlayback: true } })).toBe('gif')
+  })
+
+  test('audioMessage returns audio', () => {
+    expect(getMessageType({ audioMessage: {} })).toBe('audio')
+  })
+
+  test('documentMessage returns document', () => {
+    expect(getMessageType({ documentMessage: {} })).toBe('document')
+  })
+
+  test('stickerMessage returns sticker', () => {
+    expect(getMessageType({ stickerMessage: {} })).toBe('sticker')
+  })
+
+  test('locationMessage returns location', () => {
+    expect(getMessageType({ locationMessage: {} })).toBe('location')
+  })
+
+  test('contactMessage returns contact', () => {
+    expect(getMessageType({ contactMessage: {} })).toBe('contact')
+  })
+
+  test('reactionMessage returns reaction', () => {
+    expect(getMessageType({ reactionMessage: {} })).toBe('reaction')
+  })
+
+  test('pollCreationMessage returns poll', () => {
+    expect(getMessageType({ pollCreationMessage: {} })).toBe('poll')
+  })
+
+  test('empty object returns unknown', () => {
+    expect(getMessageType({})).toBe('unknown')
+  })
+})

package/src/platforms/whatsapp/types.ts

@@ -0,0 +1,95 @@
+export interface WhatsAppAccount {
+  account_id: string
+  phone_number?: string
+  name?: string
+  created_at: string
+  updated_at: string
+}
+
+export interface WhatsAppConfig {
+  current: string | null
+  accounts: Record<string, WhatsAppAccount>
+}
+
+export interface WhatsAppAccountPaths {
+  account_dir: string
+  auth_dir: string
+}
+
+export class WhatsAppError extends Error {
+  code: string | number
+
+  constructor(message: string, code: string | number = 'whatsapp_error') {
+    super(message)
+    this.name = 'WhatsAppError'
+    this.code = code
+  }
+}
+
+export function createAccountId(input: string): string {
+  const normalized = input
+    .trim()
+    .toLowerCase()
+    .replace(/^\+/, 'plus-')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+  return normalized || 'default'
+}
+
+export interface WhatsAppChatSummary {
+  id: string
+  name: string
+  type: 'individual' | 'group' | 'broadcast' | 'status'
+  unread_count: number
+  last_message?: WhatsAppMessageSummary
+}
+
+export interface WhatsAppMessageSummary {
+  id: string
+  chat_id: string
+  from: string
+  from_name?: string
+  timestamp: string
+  is_outgoing: boolean
+  type: string
+  text?: string
+}
+
+import type { proto } from '@whiskeysockets/baileys'
+
+export function jidToType(jid: string): WhatsAppChatSummary['type'] {
+  if (jid.endsWith('@g.us')) return 'group'
+  if (jid.endsWith('@broadcast')) return jid === 'status@broadcast' ? 'status' : 'broadcast'
+  return 'individual'
+}
+
+export function extractMessageText(message: proto.IMessage | null | undefined): string | undefined {
+  if (!message) return undefined
+  if (message.conversation) return message.conversation
+  if (message.extendedTextMessage?.text) return message.extendedTextMessage.text
+  if (message.imageMessage?.caption) return message.imageMessage.caption
+  if (message.videoMessage?.caption) return message.videoMessage.caption
+  if (message.documentMessage?.caption) return message.documentMessage.caption
+  if (message.contactMessage?.displayName) return message.contactMessage.displayName
+  if (message.locationMessage?.name) return message.locationMessage.name
+  if (message.reactionMessage?.text) return message.reactionMessage.text
+  if (message.pollCreationMessage?.name) return message.pollCreationMessage.name
+  return undefined
+}
+
+export function getMessageType(message: proto.IMessage | null | undefined): string {
+  if (!message) return 'unknown'
+  if (message.conversation || message.extendedTextMessage) return 'text'
+  if (message.imageMessage) return 'image'
+  if (message.videoMessage) return message.videoMessage.gifPlayback ? 'gif' : 'video'
+  if (message.audioMessage) return 'audio'
+  if (message.documentMessage) return 'document'
+  if (message.stickerMessage) return 'sticker'
+  if (message.locationMessage || message.liveLocationMessage) return 'location'
+  if (message.contactMessage || message.contactsArrayMessage) return 'contact'
+  if (message.reactionMessage) return 'reaction'
+  if (message.pollCreationMessage) return 'poll'
+  if (message.pollUpdateMessage) return 'poll_update'
+  return 'unknown'
+}

package/src/platforms/whatsappbot/cli.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, messageCommand, templateCommand } from './commands/index'
+
+const program = new Command()
+
+program
+  .name('agent-whatsappbot')
+  .description('CLI tool for WhatsApp Business Cloud API integration')
+  .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
+  .option('--account <id>', 'Account ID to use')
+
+program.addCommand(authCommand)
+program.addCommand(messageCommand)
+program.addCommand(templateCommand)
+
+program.parseAsync(process.argv)
+
+export default program