agent-messenger 1.15.0 → 2.0.0

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

@@ -0,0 +1,206 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { WhatsAppBotClient } from '../client'
+import { WhatsAppBotCredentialManager } from '../credential-manager'
+
+interface ActionOptions {
+  account?: string
+  pretty?: boolean
+  _credManager?: WhatsAppBotCredentialManager
+}
+
+interface ActionResult {
+  success?: boolean
+  error?: string
+  valid?: boolean
+  phone_number_id?: string
+  account_name?: string
+  accounts?: Array<{ phone_number_id: string; account_name: string; is_current: boolean }>
+}
+
+export async function setAction(
+  phoneNumberId: string,
+  accessToken: string,
+  options: ActionOptions,
+): Promise<ActionResult> {
+  try {
+    const client = await new WhatsAppBotClient().login({ phoneNumberId: phoneNumberId, accessToken: accessToken })
+    const result = await client.verifyToken()
+
+    const accountName = result.verified_name
+
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    await credManager.setCredentials({
+      phone_number_id: phoneNumberId,
+      account_name: accountName,
+      access_token: accessToken,
+    })
+
+    return { success: true, phone_number_id: phoneNumberId, account_name: accountName }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function statusAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    const creds = await credManager.getCredentials(options.account)
+
+    if (!creds) {
+      return {
+        valid: false,
+        error: options.account
+          ? `Account "${options.account}" not found. Run "auth list" to see available accounts.`
+          : 'No credentials configured. Run "auth set <phone-number-id> <access-token>" first.',
+      }
+    }
+
+    let valid = false
+    let phoneNumberId: string | undefined
+    let accountName: string | undefined
+
+    try {
+      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
+      accountName = result.verified_name
+    } catch {
+      valid = false
+      phoneNumberId = creds.phone_number_id
+      accountName = creds.account_name
+    }
+
+    return { valid, phone_number_id: phoneNumberId, account_name: accountName }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function clearAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    await credManager.clearCredentials()
+    return { success: true }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function listAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    const all = await credManager.listAll()
+
+    return {
+      accounts: all.map((a) => ({
+        phone_number_id: a.phone_number_id,
+        account_name: a.account_name,
+        is_current: a.is_current,
+      })),
+    }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function useAction(accountId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    const found = await credManager.setCurrent(accountId)
+
+    if (!found) {
+      return { error: `Account "${accountId}" not found. Run "auth list" to see available accounts.` }
+    }
+
+    const creds = await credManager.getCredentials()
+    return {
+      success: true,
+      phone_number_id: creds?.phone_number_id,
+      account_name: creds?.account_name,
+    }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function removeAction(accountId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    const removed = await credManager.removeAccount(accountId)
+
+    if (!removed) {
+      return { error: `Account "${accountId}" not found. Run "auth list" to see available accounts.` }
+    }
+
+    return { success: true }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: ActionResult, pretty?: boolean, exitOnError = true): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error && exitOnError) process.exit(1)
+}
+
+export const authCommand = new Command('auth')
+  .description('Authentication commands')
+  .addCommand(
+    new Command('set')
+      .description('Set account credentials')
+      .argument('<phone-number-id>', 'WhatsApp Business phone number ID')
+      .argument('<access-token>', 'Access token from Meta Business settings')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (phoneNumberId: string, accessToken: string, opts: { pretty?: boolean }) => {
+        cliOutput(await setAction(phoneNumberId, accessToken, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--account <id>', 'Check specific account (default: current)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { account?: string; pretty?: boolean }) => {
+        const result = await statusAction(opts)
+        console.log(formatOutput(result, opts.pretty))
+        if (!result.valid) process.exit(1)
+      }),
+  )
+  .addCommand(
+    new Command('clear')
+      .description('Clear all stored credentials')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await clearAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List all stored accounts')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Switch active account')
+      .argument('<account-id>', 'Account ID (phone number ID)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (accountId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await useAction(accountId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove a stored account')
+      .argument('<account-id>', 'Account ID (phone number ID)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (accountId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await removeAction(accountId, opts), opts.pretty)
+      }),
+  )

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

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

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

@@ -0,0 +1,148 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface MessageResult {
+  messaging_product?: string
+  contacts?: Array<{ input: string; wa_id: string }>
+  messages?: Array<{ id: string }>
+  error?: string
+}
+
+type MessageOptions = AccountOption & {
+  language?: string
+  components?: string
+  caption?: string
+  filename?: string
+}
+
+export async function sendAction(to: string, text: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const response = await client.sendTextMessage(to, text)
+    return response
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function sendTemplateAction(to: string, templateName: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const languageCode = options.language ?? 'en_US'
+    let components: unknown[] | undefined
+    if (options.components) {
+      try {
+        components = JSON.parse(options.components) as unknown[]
+      } catch {
+        return { error: 'Invalid --components JSON' }
+      }
+    }
+    const response = await client.sendTemplateMessage(to, templateName, languageCode, components)
+    return response
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+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)
+    return response
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function sendImageAction(to: string, imageUrl: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const response = await client.sendImageMessage(to, imageUrl, options.caption)
+    return response
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+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)
+    return response
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: MessageResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send a text message')
+      .argument('<to>', 'Recipient phone number')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (to: string, text: string, opts: MessageOptions) => {
+        cliOutput(await sendAction(to, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-template')
+      .description('Send a template message')
+      .argument('<to>', 'Recipient phone number')
+      .argument('<template-name>', 'Template name')
+      .option('--language <code>', 'Language code', 'en_US')
+      .option('--components <json>', 'Template components as JSON string')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (to: string, templateName: string, opts: MessageOptions) => {
+        cliOutput(await sendTemplateAction(to, templateName, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-reaction')
+      .description('Send a reaction to a message')
+      .argument('<to>', 'Recipient phone number')
+      .argument('<message-id>', 'Message ID to react to')
+      .argument('<emoji>', 'Emoji reaction')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (to: string, messageId: string, emoji: string, opts: MessageOptions) => {
+        cliOutput(await sendReactionAction(to, messageId, emoji, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-image')
+      .description('Send an image message')
+      .argument('<to>', 'Recipient phone number')
+      .argument('<image-url>', 'Image URL')
+      .option('--caption <text>', 'Image caption')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (to: string, imageUrl: string, opts: MessageOptions) => {
+        cliOutput(await sendImageAction(to, imageUrl, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-document')
+      .description('Send a document message')
+      .argument('<to>', 'Recipient phone number')
+      .argument('<document-url>', 'Document URL')
+      .option('--filename <name>', 'Document filename')
+      .option('--caption <text>', 'Document caption')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (to: string, documentUrl: string, opts: MessageOptions) => {
+        cliOutput(await sendDocumentAction(to, documentUrl, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,22 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import { WhatsAppBotClient } from '../client'
+import { WhatsAppBotCredentialManager } from '../credential-manager'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+  _credManager?: WhatsAppBotCredentialManager
+}
+
+export async function getClient(options: AccountOption): Promise<WhatsAppBotClient> {
+  const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+  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))
+    process.exit(1)
+  }
+
+  return await new WhatsAppBotClient().login({ phoneNumberId: creds.phone_number_id, accessToken: creds.access_token })
+}

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

@@ -0,0 +1,69 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WhatsAppBotTemplate } from '../types'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface TemplateResult {
+  templates?: WhatsAppBotTemplate[]
+  template?: WhatsAppBotTemplate
+  error?: string
+}
+
+type TemplateOptions = AccountOption & {
+  limit?: string
+}
+
+export async function listAction(options: TemplateOptions): Promise<TemplateResult> {
+  try {
+    const client = await getClient(options)
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined
+    if (limit !== undefined && (Number.isNaN(limit) || limit < 1)) {
+      return { error: 'Invalid --limit value. Must be a positive integer.' }
+    }
+    const templates = await client.listTemplates(limit !== undefined ? { limit } : undefined)
+    return { templates }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function getAction(templateName: string, options: TemplateOptions): Promise<TemplateResult> {
+  try {
+    const client = await getClient(options)
+    const template = await client.getTemplate(templateName)
+    return { template }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: TemplateResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const templateCommand = new Command('template')
+  .description('Template commands')
+  .addCommand(
+    new Command('list')
+      .description('List message templates')
+      .option('--limit <n>', 'Number of templates to fetch')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: TemplateOptions) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a specific template by name')
+      .argument('<template-name>', 'Template name')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (templateName: string, opts: TemplateOptions) => {
+        cliOutput(await getAction(templateName, opts), opts.pretty)
+      }),
+  )