agent-messenger 1.15.0 → 2.0.0

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

@@ -0,0 +1,205 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { WhatsAppClient } from '../client'
+import { WhatsAppCredentialManager } from '../credential-manager'
+import { createAccountId } from '../types'
+
+interface LoginOptions {
+  phone: string
+  pretty?: boolean
+}
+
+interface StatusOptions {
+  account?: string
+  pretty?: boolean
+}
+
+async function loginAction(options: LoginOptions): Promise<void> {
+  try {
+    const manager = new WhatsAppCredentialManager()
+    const accountId = createAccountId(options.phone)
+    const paths = await manager.ensureAccountPaths(accountId)
+    const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+
+    let code: string
+    let waitForAuth: () => Promise<void>
+
+    try {
+      const result = await client.connectForPairing(options.phone)
+      code = result.code
+      waitForAuth = result.waitForAuth
+    } catch (err) {
+      await client.close()
+      throw err
+    }
+
+    const formatted = code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code
+
+    console.log(formatOutput({
+      pairing_code: formatted,
+      message: 'Enter this code in WhatsApp > Linked Devices > Link with phone number',
+    }, options.pretty))
+
+    try {
+      await waitForAuth()
+    } catch (err) {
+      await client.close()
+      throw err
+    }
+
+    const now = new Date().toISOString()
+    await manager.setAccount({
+      account_id: accountId,
+      phone_number: options.phone,
+      created_at: now,
+      updated_at: now,
+    })
+    await manager.setCurrent(accountId)
+    await client.close()
+
+    console.log(formatOutput({
+      authenticated: true,
+      account_id: accountId,
+      phone_number: options.phone,
+    }, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function statusAction(options: StatusOptions): Promise<void> {
+  try {
+    const manager = new WhatsAppCredentialManager()
+    const account = await manager.getAccount(options.account)
+
+    if (!account) {
+      console.log(formatOutput({
+        error: options.account
+          ? `WhatsApp account "${options.account}" not found.`
+          : 'No WhatsApp account configured. Run "auth login --phone <phone-number>" first.',
+      }, options.pretty))
+      process.exit(1)
+    }
+
+    console.log(formatOutput({
+      account_id: account.account_id,
+      phone_number: account.phone_number,
+      name: account.name,
+      created_at: account.created_at,
+      updated_at: account.updated_at,
+    }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new WhatsAppCredentialManager()
+    const accounts = await manager.listAccounts()
+
+    console.log(formatOutput(
+      accounts.map((account) => ({
+        account_id: account.account_id,
+        phone_number: account.phone_number,
+        name: account.name,
+        created_at: account.created_at,
+        updated_at: account.updated_at,
+        is_current: account.is_current,
+      })),
+      options.pretty,
+    ))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function useAction(accountId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new WhatsAppCredentialManager()
+    const found = await manager.setCurrent(accountId)
+
+    if (!found) {
+      console.log(formatOutput({ error: `WhatsApp account "${accountId}" not found.` }, options.pretty))
+      process.exit(1)
+    }
+
+    const current = await manager.getAccount()
+    console.log(formatOutput({ success: true, account_id: current?.account_id }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function logoutAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new WhatsAppCredentialManager()
+    const account = await manager.getAccount(options.account)
+
+    if (!account) {
+      console.log(formatOutput({
+        error: options.account
+          ? `WhatsApp account "${options.account}" not found.`
+          : 'No WhatsApp account configured.',
+      }, options.pretty))
+      process.exit(1)
+    }
+
+    const paths = manager.getAccountPaths(account.account_id)
+    try {
+      const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+      await client.connect()
+      if (client.getSocket()) {
+        await client.getSocket()!.logout('Logged out via agent-whatsapp CLI')
+      }
+      await client.close()
+    } catch {
+      // Server-side deregister failed — proceed with local cleanup
+    }
+
+    await manager.removeAccount(account.account_id)
+    console.log(formatOutput({ success: true, account_id: account.account_id, logged_out: true }, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('WhatsApp authentication commands')
+  .addCommand(
+    new Command('login')
+      .description('Link as a companion device using a pairing code')
+      .requiredOption('--phone <number>', 'Phone number in international format (e.g. +12025551234)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(loginAction),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List stored WhatsApp accounts')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Switch the current WhatsApp account')
+      .argument('<account>', 'Account identifier')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(useAction),
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Remove stored credentials and auth state')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction),
+  )

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

@@ -0,0 +1,49 @@
+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(options: { account?: string; pretty?: boolean; limit?: string }): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const chats = await withWhatsAppClient(options, (client) => client.listChats(limit))
+    console.log(formatOutput(chats, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchAction(
+  query: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const chats = await withWhatsAppClient(options, (client) => client.searchChats(query, limit))
+    console.log(formatOutput(chats, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const chatCommand = new Command('chat')
+  .description('WhatsApp chat commands')
+  .addCommand(
+    new Command('list')
+      .description('List chats')
+      .option('--limit <n>', 'Number of chats to fetch', '20')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search chats by name')
+      .argument('<query>', 'Search query')
+      .option('--limit <n>', 'Number of results to return', '20')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchAction),
+  )

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

@@ -0,0 +1,3 @@
+export { authCommand } from './auth'
+export { chatCommand } from './chat'
+export { messageCommand } from './message'

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

@@ -0,0 +1,79 @@
+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(
+  chat: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 25)
+    const messages = await withWhatsAppClient(options, (client) => client.getMessages(chat, limit))
+    console.log(formatOutput(messages, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+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))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function reactAction(
+  chat: string,
+  messageId: string,
+  emoji: string,
+  options: { account?: string; pretty?: boolean; fromMe?: boolean },
+): Promise<void> {
+  try {
+    await withWhatsAppClient(options, (client) => client.sendReaction(chat, messageId, emoji, options.fromMe))
+    console.log(formatOutput({ success: true, chat, message_id: messageId, emoji }, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('WhatsApp message commands')
+  .addCommand(
+    new Command('list')
+      .description('List messages from a chat (JID or phone number)')
+      .argument('<chat>', 'Chat JID (e.g. 12025551234@s.whatsapp.net) or phone number')
+      .option('--limit <n>', 'Number of messages to fetch', '25')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a text message to a chat')
+      .argument('<chat>', 'Chat JID or phone number')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )
+  .addCommand(
+    new Command('react')
+      .description('React to a message with an emoji')
+      .argument('<chat>', 'Chat JID or phone number')
+      .argument('<message-id>', 'Message ID to react to')
+      .argument('<emoji>', 'Emoji reaction')
+      .option('--from-me', 'React to your own outgoing message')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(reactAction),
+  )

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

@@ -0,0 +1,61 @@
+import { formatOutput } from '@/shared/utils/output'
+import { WhatsAppClient } from '../client'
+import { WhatsAppCredentialManager } from '../credential-manager'
+import { WhatsAppError } from '../types'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+}
+
+export function parseLimitOption(
+  rawLimit: string | undefined,
+  defaultValue: number,
+  maxValue = 100,
+): number {
+  const trimmed = (rawLimit ?? `${defaultValue}`).trim()
+
+  if (!/^\d+$/.test(trimmed)) {
+    throw new WhatsAppError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  const parsed = Number.parseInt(trimmed, 10)
+
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > maxValue) {
+    throw new WhatsAppError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  return parsed
+}
+
+export async function withWhatsAppClient<T>(
+  options: AccountOption,
+  fn: (client: WhatsAppClient) => Promise<T>,
+): Promise<T> {
+  const manager = new WhatsAppCredentialManager()
+  const account = await manager.getAccount(options.account)
+
+  if (!account) {
+    console.log(
+      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.',
+        },
+        options.pretty,
+      ),
+    )
+    process.exit(1)
+  }
+
+  const paths = await manager.ensureAccountPaths(account.account_id)
+  const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+
+  try {
+    await client.connect()
+    return await fn(client)
+  } finally {
+    await client.close()
+  }
+}

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

@@ -0,0 +1,278 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { WhatsAppCredentialManager } from '@/platforms/whatsapp/credential-manager'
+import type { WhatsAppAccount } from '@/platforms/whatsapp/types'
+
+const testDirs: string[] = []
+
+function setup(): WhatsAppCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-whatsapp-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new WhatsAppCredentialManager(testConfigDir)
+}
+
+function makeAccount(overrides?: Partial<WhatsAppAccount>): WhatsAppAccount {
+  return {
+    account_id: 'test-account',
+    phone_number: '+12025551234',
+    name: 'Test User',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    ...overrides,
+  }
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('WhatsAppCredentialManager', () => {
+  describe('loadConfig', () => {
+    test('returns default config when file does not exist', async () => {
+      const manager = setup()
+      const config = await manager.loadConfig()
+
+      expect(config).toEqual({ current: null, accounts: {} })
+    })
+  })
+
+  describe('saveConfig', () => {
+    test('creates file and can be re-read via loadConfig', async () => {
+      const manager = setup()
+      const config = {
+        current: 'test-account',
+        accounts: {
+          'test-account': makeAccount(),
+        },
+      }
+
+      await manager.saveConfig(config)
+      const loaded = await manager.loadConfig()
+
+      expect(loaded).toEqual(config)
+    })
+  })
+
+  describe('getAccount', () => {
+    test('returns null when no accounts exist', async () => {
+      const manager = setup()
+      const account = await manager.getAccount()
+
+      expect(account).toBeNull()
+    })
+
+    test('returns null for specific accountId when no accounts exist', async () => {
+      const manager = setup()
+      const account = await manager.getAccount('nonexistent')
+
+      expect(account).toBeNull()
+    })
+  })
+
+  describe('setAccount', () => {
+    test('round-trips: set then get returns same account', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const retrieved = await manager.getAccount('test-account')
+
+      expect(retrieved).toEqual(account)
+    })
+
+    test('sets first account as current automatically', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const current = await manager.getAccount()
+
+      expect(current).toEqual(account)
+    })
+
+    test('does not override current when it is already set', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('first-account')
+    })
+
+    test('getAccount with normalized ID lookup via createAccountId', async () => {
+      const manager = setup()
+      const account = makeAccount({ account_id: 'plus-12025551234' })
+
+      await manager.setAccount(account)
+      const retrieved = await manager.getAccount('+12025551234')
+
+      expect(retrieved).toEqual(account)
+    })
+  })
+
+  describe('listAccounts', () => {
+    test('returns empty array when no accounts', async () => {
+      const manager = setup()
+      const accounts = await manager.listAccounts()
+
+      expect(accounts).toEqual([])
+    })
+
+    test('returns all accounts with is_current flag', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const accounts = await manager.listAccounts()
+
+      expect(accounts).toHaveLength(2)
+      const firstResult = accounts.find((a) => a.account_id === 'first-account')
+      const secondResult = accounts.find((a) => a.account_id === 'second-account')
+      expect(firstResult?.is_current).toBe(true)
+      expect(secondResult?.is_current).toBe(false)
+    })
+  })
+
+  describe('setCurrent', () => {
+    test('switches active account and returns true', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const result = await manager.setCurrent('second-account')
+      expect(result).toBe(true)
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('second-account')
+    })
+
+    test('returns false for non-existent account', async () => {
+      const manager = setup()
+
+      const result = await manager.setCurrent('nonexistent')
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('removeAccount', () => {
+    test('removes account and adjusts current to next available', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const result = await manager.removeAccount('first-account')
+      expect(result).toBe(true)
+
+      const accounts = await manager.listAccounts()
+      expect(accounts).toHaveLength(1)
+      expect(accounts[0]?.account_id).toBe('second-account')
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('second-account')
+    })
+
+    test('returns false for non-existent account', async () => {
+      const manager = setup()
+
+      const result = await manager.removeAccount('nonexistent')
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('clearCredentials', () => {
+    test('removes credentials file when it exists', async () => {
+      const manager = setup()
+      const account = makeAccount()
+      await manager.setAccount(account)
+
+      const testConfigDir = testDirs[testDirs.length - 1]!
+      const credentialsPath = join(testConfigDir, 'whatsapp-credentials.json')
+      expect(existsSync(credentialsPath)).toBe(true)
+
+      await manager.clearCredentials()
+
+      expect(existsSync(credentialsPath)).toBe(false)
+    })
+
+    test('does not throw when credentials file does not exist', async () => {
+      const manager = setup()
+
+      await expect(manager.clearCredentials()).resolves.toBeUndefined()
+    })
+  })
+
+  describe('getAccountPaths', () => {
+    test('returns correct paths structure for account ID', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-whatsapp-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new WhatsAppCredentialManager(testConfigDir)
+
+      const paths = manager.getAccountPaths('test-account')
+
+      expect(paths.account_dir).toBe(join(testConfigDir, 'whatsapp', 'test-account'))
+      expect(paths.auth_dir).toBe(join(testConfigDir, 'whatsapp', 'test-account', 'auth'))
+    })
+
+    test('normalizes account ID via createAccountId', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-whatsapp-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new WhatsAppCredentialManager(testConfigDir)
+
+      const paths = manager.getAccountPaths('+12025551234')
+
+      expect(paths.account_dir).toContain('plus-12025551234')
+      expect(paths.auth_dir).toContain('plus-12025551234')
+    })
+  })
+
+  describe('ensureAccountPaths', () => {
+    test('creates directories', async () => {
+      const manager = setup()
+
+      const paths = await manager.ensureAccountPaths('test-account')
+
+      expect(existsSync(paths.auth_dir)).toBe(true)
+    })
+
+    test('returns paths structure', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-whatsapp-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new WhatsAppCredentialManager(testConfigDir)
+
+      const paths = await manager.ensureAccountPaths('my-account')
+
+      expect(paths.account_dir).toBe(join(testConfigDir, 'whatsapp', 'my-account'))
+      expect(paths.auth_dir).toBe(join(testConfigDir, 'whatsapp', 'my-account', 'auth'))
+    })
+  })
+})