agent-messenger 2.2.0 → 2.4.0

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

@@ -0,0 +1,155 @@
+import { afterAll, describe, expect, mock, test } from 'bun:test'
+import { rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { WeChatBotCredentialManager } from '@/platforms/wechatbot/credential-manager'
+
+const sendTextMessageMock = mock(() => Promise.resolve())
+const sendImageMessageMock = mock(() => Promise.resolve())
+const sendNewsMessageMock = mock(() => Promise.resolve())
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login() {
+      return this
+    }
+    sendTextMessage = sendTextMessageMock
+    sendImageMessage = sendImageMessageMock
+    sendNewsMessage = sendNewsMessageMock
+  },
+}))
+
+const { sendAction, sendNewsAction } = await import('@/platforms/wechatbot/commands/message')
+
+const testDirs: string[] = []
+
+function makeCredManager(): WeChatBotCredentialManager {
+  const dir = join(
+    import.meta.dir,
+    `.test-message-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(dir)
+  const manager = new WeChatBotCredentialManager(dir)
+  return manager
+}
+
+async function makeCredManagerWithCreds(): Promise<WeChatBotCredentialManager> {
+  const manager = makeCredManager()
+  await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+  return manager
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('sendAction', () => {
+  test('sends text message and returns success', async () => {
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendAction('openid-123', 'Hello world', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+    expect(sendTextMessageMock).toHaveBeenCalledWith('openid-123', 'Hello world')
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendTextMessage = mock(() => Promise.reject(new Error('API error')))
+      },
+    }))
+
+    const { sendAction: sendActionFresh } = await import('@/platforms/wechatbot/commands/message')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendActionFresh('openid-123', 'Hello', { _credManager: credManager })
+
+    expect(result.error).toBe('API error')
+    expect(result.success).toBeUndefined()
+  })
+})
+
+describe('sendImageAction', () => {
+  test('sends image message and returns success', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendImageMessage = mock(() => Promise.resolve())
+      },
+    }))
+
+    const { sendImageAction: sendImageActionFresh } = await import('@/platforms/wechatbot/commands/message')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendImageActionFresh('openid-123', 'media-id-456', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendImageMessage = mock(() => Promise.reject(new Error('image upload failed')))
+      },
+    }))
+
+    const { sendImageAction: sendImageActionFresh } = await import('@/platforms/wechatbot/commands/message')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendImageActionFresh('openid-123', 'bad-media-id', { _credManager: credManager })
+
+    expect(result.error).toBe('image upload failed')
+  })
+})
+
+describe('sendNewsAction', () => {
+  test('returns error when required options are missing', async () => {
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendNewsAction('openid-123', { _credManager: credManager })
+
+    expect(result.error).toContain('--title')
+    expect(result.success).toBeUndefined()
+  })
+
+  test('returns error when title is missing', async () => {
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendNewsAction('openid-123', {
+      description: 'Test desc',
+      url: 'https://example.com',
+      picurl: 'https://example.com/pic.jpg',
+      _credManager: credManager,
+    })
+
+    expect(result.error).toContain('--title')
+  })
+
+  test('sends news message with all required options', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendNewsMessage = mock(() => Promise.resolve())
+      },
+    }))
+
+    const { sendNewsAction: sendNewsActionFresh } = await import('@/platforms/wechatbot/commands/message')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendNewsActionFresh('openid-123', {
+      title: 'Test Article',
+      description: 'Test description',
+      url: 'https://example.com',
+      picurl: 'https://example.com/pic.jpg',
+      _credManager: credManager,
+    })
+
+    expect(result.success).toBe(true)
+  })
+})

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

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WeChatBotNewsArticle } from '../types'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface MessageResult {
+  success?: boolean
+  error?: string
+}
+
+type MessageOptions = AccountOption & {
+  title?: string
+  description?: string
+  url?: string
+  picurl?: string
+}
+
+export async function sendAction(openId: string, text: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    await client.sendTextMessage(openId, text)
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function sendImageAction(openId: string, mediaId: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    await client.sendImageMessage(openId, mediaId)
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function sendNewsAction(openId: string, options: MessageOptions): Promise<MessageResult> {
+  try {
+    if (!options.title || !options.description || !options.url || !options.picurl) {
+      return { error: '--title, --description, --url, and --picurl are required' }
+    }
+
+    const article: WeChatBotNewsArticle = {
+      title: options.title,
+      description: options.description,
+      url: options.url,
+      picurl: options.picurl,
+    }
+
+    const client = await getClient(options)
+    await client.sendNewsMessage(openId, [article])
+    return { success: true }
+  } 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 (customer service)')
+      .argument('<open-id>', 'Recipient OpenID')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (openId: string, text: string, opts: MessageOptions) => {
+        cliOutput(await sendAction(openId, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-image')
+      .description('Send an image message (customer service)')
+      .argument('<open-id>', 'Recipient OpenID')
+      .argument('<media-id>', 'Media ID of the image')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (openId: string, mediaId: string, opts: MessageOptions) => {
+        cliOutput(await sendImageAction(openId, mediaId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send-news')
+      .description('Send a news/article message (customer service)')
+      .argument('<open-id>', 'Recipient OpenID')
+      .requiredOption('--title <title>', 'Article title')
+      .requiredOption('--description <description>', 'Article description')
+      .requiredOption('--url <url>', 'Article URL')
+      .requiredOption('--picurl <picurl>', 'Article picture URL')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (openId: string, opts: MessageOptions) => {
+        cliOutput(await sendNewsAction(openId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,22 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import { WeChatBotClient } from '../client'
+import { WeChatBotCredentialManager } from '../credential-manager'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+  _credManager?: WeChatBotCredentialManager
+}
+
+export async function getClient(options: AccountOption): Promise<WeChatBotClient> {
+  const credManager = options._credManager ?? new WeChatBotCredentialManager()
+  const creds = await credManager.getCredentials(options.account)
+
+  if (!creds) {
+    console.log(formatOutput({ error: 'No credentials. Run "auth set <app-id> <app-secret>" first.' }, options.pretty))
+    process.exit(1)
+  }
+
+  return await new WeChatBotClient().login({ appId: creds.app_id, appSecret: creds.app_secret })
+}

package/src/platforms/wechatbot/commands/template.test.ts

@@ -0,0 +1,199 @@
+import { afterAll, describe, expect, mock, test } from 'bun:test'
+import { rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { WeChatBotCredentialManager } from '@/platforms/wechatbot/credential-manager'
+
+const mockTemplates = [
+  {
+    template_id: 'tmpl-001',
+    title: 'Order Notification',
+    primary_industry: 'IT科技',
+    deputy_industry: '互联网|电子商务',
+    content: 'ORDER_STATUS {{status.DATA}}',
+    example: 'Order shipped',
+  },
+]
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login() {
+      return this
+    }
+    listTemplates = mock(() => Promise.resolve(mockTemplates))
+    sendTemplateMessage = mock(() => Promise.resolve({ msgid: 12345 }))
+    deleteTemplate = mock(() => Promise.resolve())
+  },
+}))
+
+const { listAction } = await import('@/platforms/wechatbot/commands/template')
+
+const testDirs: string[] = []
+
+function makeCredManager(): WeChatBotCredentialManager {
+  const dir = join(
+    import.meta.dir,
+    `.test-template-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(dir)
+  return new WeChatBotCredentialManager(dir)
+}
+
+async function makeCredManagerWithCreds(): Promise<WeChatBotCredentialManager> {
+  const manager = makeCredManager()
+  await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+  return manager
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('listAction', () => {
+  test('returns templates list', async () => {
+    const credManager = await makeCredManagerWithCreds()
+    const result = await listAction({ _credManager: credManager })
+
+    expect(result.templates).toHaveLength(1)
+    expect(result.templates?.[0].template_id).toBe('tmpl-001')
+    expect(result.templates?.[0].title).toBe('Order Notification')
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        listTemplates = mock(() => Promise.reject(new Error('API error')))
+      },
+    }))
+
+    const { listAction: listActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await listActionFresh({ _credManager: credManager })
+
+    expect(result.error).toBe('API error')
+    expect(result.templates).toBeUndefined()
+  })
+})
+
+describe('sendAction (template)', () => {
+  test('sends template message and returns msgid', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendTemplateMessage = mock(() => Promise.resolve({ msgid: 99999 }))
+      },
+    }))
+
+    const { sendAction: sendActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendActionFresh('openid-123', 'tmpl-001', {
+      data: JSON.stringify({ first: { value: 'Hello' } }),
+      url: 'https://example.com',
+      _credManager: credManager,
+    })
+
+    expect(result.msgid).toBe(99999)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns error when data is invalid JSON', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendTemplateMessage = mock(() => Promise.resolve({ msgid: 1 }))
+      },
+    }))
+
+    const { sendAction: sendActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendActionFresh('openid-123', 'tmpl-001', {
+      data: '{invalid json}',
+      _credManager: credManager,
+    })
+
+    expect(result.error).toContain('Invalid --data JSON')
+    expect(result.msgid).toBeUndefined()
+  })
+
+  test('sends without data when not provided', async () => {
+    const sendTemplateMsg = mock(() => Promise.resolve({ msgid: 777 }))
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendTemplateMessage = sendTemplateMsg
+      },
+    }))
+
+    const { sendAction: sendActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendActionFresh('openid-123', 'tmpl-001', { _credManager: credManager })
+
+    expect(result.msgid).toBe(777)
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        sendTemplateMessage = mock(() => Promise.reject(new Error('template send failed')))
+      },
+    }))
+
+    const { sendAction: sendActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await sendActionFresh('openid-123', 'tmpl-001', { _credManager: credManager })
+
+    expect(result.error).toBe('template send failed')
+  })
+})
+
+describe('deleteAction', () => {
+  test('deletes template and returns success', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        deleteTemplate = mock(() => Promise.resolve())
+      },
+    }))
+
+    const { deleteAction: deleteActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await deleteActionFresh('tmpl-to-delete', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        deleteTemplate = mock(() => Promise.reject(new Error('template not found')))
+      },
+    }))
+
+    const { deleteAction: deleteActionFresh } = await import('@/platforms/wechatbot/commands/template')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await deleteActionFresh('nonexistent-tmpl', { _credManager: credManager })
+
+    expect(result.error).toBe('template not found')
+    expect(result.success).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,102 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WeChatBotTemplate } from '../types'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface TemplateResult {
+  templates?: WeChatBotTemplate[]
+  msgid?: number
+  success?: boolean
+  error?: string
+}
+
+type TemplateOptions = AccountOption & {
+  data?: string
+  url?: string
+}
+
+export async function listAction(options: TemplateOptions): Promise<TemplateResult> {
+  try {
+    const client = await getClient(options)
+    const templates = await client.listTemplates()
+    return { templates }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function sendAction(
+  openId: string,
+  templateId: string,
+  options: TemplateOptions,
+): Promise<TemplateResult> {
+  try {
+    let data: Record<string, { value: string }> = {}
+    if (options.data) {
+      try {
+        data = JSON.parse(options.data) as Record<string, { value: string }>
+      } catch {
+        return { error: 'Invalid --data JSON' }
+      }
+    }
+
+    const client = await getClient(options)
+    const result = await client.sendTemplateMessage(openId, templateId, data, options.url)
+    return { msgid: result.msgid }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function deleteAction(templateId: string, options: TemplateOptions): Promise<TemplateResult> {
+  try {
+    const client = await getClient(options)
+    await client.deleteTemplate(templateId)
+    return { success: true }
+  } 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 message commands')
+  .addCommand(
+    new Command('list')
+      .description('List all private templates')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: TemplateOptions) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a template message')
+      .argument('<open-id>', 'Recipient OpenID')
+      .argument('<template-id>', 'Template ID')
+      .option('--data <json>', 'Template data as JSON object')
+      .option('--url <url>', 'URL to redirect when message is clicked')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (openId: string, templateId: string, opts: TemplateOptions) => {
+        cliOutput(await sendAction(openId, templateId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a private template')
+      .argument('<template-id>', 'Template ID to delete')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (templateId: string, opts: TemplateOptions) => {
+        cliOutput(await deleteAction(templateId, opts), opts.pretty)
+      }),
+  )