agent-messenger 2.3.0 → 2.5.0

package/src/platforms/webex/commands/whoami.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import * as clientModule from '../client'
+import { WebexError } from '../types'
+import { whoamiCommand } from './whoami'
+
+const mockUser = {
+  id: 'person-123',
+  emails: ['test@example.com'],
+  displayName: 'Test User',
+  nickName: 'Testy',
+  firstName: 'Test',
+  lastName: 'User',
+  avatar: 'https://example.com/avatar.jpg',
+  orgId: 'org-123',
+  type: 'person' as const,
+  created: '2024-01-01T00:00:00.000Z',
+}
+
+const makeFakeClient = () => ({
+  login: async function (this: unknown) { return this },
+  testAuth: async () => mockUser,
+})
+
+let webexClientSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  webexClientSpy = spyOn(clientModule, 'WebexClient').mockImplementation(
+    makeFakeClient as unknown as typeof clientModule.WebexClient,
+  )
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  webexClientSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+test('whoami command is defined with correct name and description', () => {
+  expect(whoamiCommand).toBeDefined()
+  expect(whoamiCommand.name()).toBe('whoami')
+  expect(whoamiCommand.description()).toBe('Show current authenticated user')
+})
+
+test('whoami command has --pretty option', () => {
+  const options = whoamiCommand.options
+  const hasPretty = options.some((opt: { long?: string }) => opt.long === '--pretty')
+  expect(hasPretty).toBe(true)
+})
+
+test('whoami calls testAuth and outputs user fields', async () => {
+  // given: authenticated webex user
+  // when: running whoami
+  await whoamiCommand.parseAsync([], { from: 'user' })
+
+  // then: outputs all expected fields
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'person-123',
+      emails: ['test@example.com'],
+      displayName: 'Test User',
+      nickName: 'Testy',
+      firstName: 'Test',
+      lastName: 'User',
+      avatar: 'https://example.com/avatar.jpg',
+      orgId: 'org-123',
+      type: 'person',
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when --pretty flag is passed', async () => {
+  // given: authenticated webex user
+  // when: running whoami with --pretty
+  await whoamiCommand.parseAsync(['--pretty'], { from: 'user' })
+
+  // then: output is pretty-printed
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'person-123',
+        emails: ['test@example.com'],
+        displayName: 'Test User',
+        nickName: 'Testy',
+        firstName: 'Test',
+        lastName: 'User',
+        avatar: 'https://example.com/avatar.jpg',
+        orgId: 'org-123',
+        type: 'person',
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with code 1 when not authenticated', async () => {
+  // given: no credentials
+  webexClientSpy.mockImplementation(() => ({
+    login: async () => { throw new WebexError('No Webex credentials found.', 'no_credentials') },
+    testAuth: async () => mockUser,
+  }) as unknown as clientModule.WebexClient)
+
+  // when: running whoami
+  await whoamiCommand.parseAsync([], { from: 'user' })
+
+  // then: process exits with code 1
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

package/src/platforms/webex/commands/whoami.ts

@@ -0,0 +1,31 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { WebexClient } from '../client'
+
+export async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      emails: user.emails,
+      displayName: user.displayName,
+      nickName: user.nickName,
+      firstName: user.firstName,
+      lastName: user.lastName,
+      avatar: user.avatar,
+      orgId: user.orgId,
+      type: user.type,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

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

@@ -16,7 +16,6 @@ describe('WebexCredentialManager', () => {
 
   afterEach(async () => {
     await rm(tempDir, { recursive: true, force: true })
-    mock.restore()
   })
 
   test('loadConfig returns null when no file exists', async () => {

package/src/platforms/wechatbot/cli.ts

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

package/src/platforms/wechatbot/client.test.ts

@@ -0,0 +1,497 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { WeChatBotClient } from '@/platforms/wechatbot/client'
+import { WeChatBotError } from '@/platforms/wechatbot/types'
+
+describe('WeChatBotClient', () => {
+  const originalFetch = globalThis.fetch
+  let fetchCalls: Array<{ url: string; options?: RequestInit }> = []
+  let fetchResponses: Response[] = []
+  let fetchIndex = 0
+
+  beforeEach(() => {
+    fetchCalls = []
+    fetchResponses = []
+    fetchIndex = 0
+    Object.defineProperty(globalThis, 'fetch', {
+      value: async (url: string | URL | Request, options?: RequestInit): Promise<Response> => {
+        fetchCalls.push({ url: url.toString(), options })
+        const response = fetchResponses[fetchIndex]
+        fetchIndex++
+        if (!response) {
+          throw new Error('No mock response configured')
+        }
+        return response
+      },
+      writable: true,
+      configurable: true,
+    })
+  })
+
+  afterEach(() => {
+    Object.defineProperty(globalThis, 'fetch', {
+      value: originalFetch,
+      writable: true,
+      configurable: true,
+    })
+  })
+
+  const mockResponse = (body: unknown, status = 200) => {
+    fetchResponses.push(
+      new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    )
+  }
+
+  const tokenResponse = () => mockResponse({ access_token: 'test-token', expires_in: 7200 })
+
+  describe('login', () => {
+    test('throws on empty appId', async () => {
+      await expect(new WeChatBotClient().login({ appId: '', appSecret: 'secret' })).rejects.toThrow(WeChatBotError)
+      await expect(new WeChatBotClient().login({ appId: '', appSecret: 'secret' })).rejects.toThrow('App ID is required')
+    })
+
+    test('throws on empty appSecret', async () => {
+      await expect(new WeChatBotClient().login({ appId: 'wx123', appSecret: '' })).rejects.toThrow(WeChatBotError)
+      await expect(new WeChatBotClient().login({ appId: 'wx123', appSecret: '' })).rejects.toThrow('App Secret is required')
+    })
+
+    test('accepts valid credentials and returns client', async () => {
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      expect(client).toBeInstanceOf(WeChatBotClient)
+    })
+  })
+
+  describe('verifyCredentials', () => {
+    test('calls token endpoint and returns true on success', async () => {
+      tokenResponse()
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.verifyCredentials()
+
+      expect(result).toBe(true)
+      expect(fetchCalls.length).toBe(1)
+      expect(fetchCalls[0].url).toContain('/cgi-bin/token')
+      expect(fetchCalls[0].url).toContain('appid=wx123')
+      expect(fetchCalls[0].url).toContain('secret=secret123')
+    })
+
+    test('returns false on token error', async () => {
+      mockResponse({ errcode: 40125, errmsg: 'invalid appsecret' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'bad-secret' })
+      const result = await client.verifyCredentials()
+
+      expect(result).toBe(false)
+    })
+
+    test('returns false on network error', async () => {
+      fetchResponses = []
+      Object.defineProperty(globalThis, 'fetch', {
+        value: async (): Promise<Response> => {
+          throw new Error('network error')
+        },
+        writable: true,
+        configurable: true,
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.verifyCredentials()
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('sendTextMessage', () => {
+    test('sends POST to /cgi-bin/message/custom/send with token in query', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.sendTextMessage('openid-123', 'Hello world')
+
+      expect(fetchCalls.length).toBe(2)
+      const call = fetchCalls[1]
+      expect(call.url).toContain('/cgi-bin/message/custom/send')
+      expect(call.url).toContain('access_token=test-token')
+      expect(call.options?.method).toBe('POST')
+    })
+
+    test('sends correct body shape', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.sendTextMessage('openid-123', 'Hello world')
+
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body).toMatchObject({
+        touser: 'openid-123',
+        msgtype: 'text',
+        text: { content: 'Hello world' },
+      })
+    })
+  })
+
+  describe('sendImageMessage', () => {
+    test('sends POST with image payload', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.sendImageMessage('openid-123', 'media-id-456')
+
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body).toMatchObject({
+        touser: 'openid-123',
+        msgtype: 'image',
+        image: { media_id: 'media-id-456' },
+      })
+    })
+  })
+
+  describe('sendNewsMessage', () => {
+    test('sends POST with news/articles payload', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const articles = [
+        {
+          title: 'Test Article',
+          description: 'Test desc',
+          url: 'https://example.com',
+          picurl: 'https://example.com/pic.jpg',
+        },
+      ]
+      await client.sendNewsMessage('openid-123', articles)
+
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body).toMatchObject({
+        touser: 'openid-123',
+        msgtype: 'news',
+        news: { articles },
+      })
+    })
+  })
+
+  describe('sendTemplateMessage', () => {
+    test('sends POST to /cgi-bin/message/template/send and returns msgid', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok', msgid: 12345 })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.sendTemplateMessage(
+        'openid-123',
+        'template-id-abc',
+        { first: { value: 'Hello' } },
+        'https://example.com',
+      )
+
+      expect(result.msgid).toBe(12345)
+      expect(fetchCalls[1].url).toContain('/cgi-bin/message/template/send')
+
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body).toMatchObject({
+        touser: 'openid-123',
+        template_id: 'template-id-abc',
+        url: 'https://example.com',
+        data: { first: { value: 'Hello' } },
+      })
+    })
+  })
+
+  describe('listTemplates', () => {
+    test('sends GET and unwraps template_list from response', async () => {
+      tokenResponse()
+      mockResponse({
+        errcode: 0,
+        errmsg: 'ok',
+        template_list: [
+          {
+            template_id: 'tmpl-001',
+            title: 'Order Notification',
+            primary_industry: 'IT科技',
+            deputy_industry: '互联网|电子商务',
+            content: 'ORDER_STATUS {{status.DATA}}',
+            example: 'Order shipped',
+          },
+        ],
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const templates = await client.listTemplates()
+
+      expect(templates).toHaveLength(1)
+      expect(templates[0].template_id).toBe('tmpl-001')
+      expect(templates[0].title).toBe('Order Notification')
+      expect(fetchCalls[1].url).toContain('/cgi-bin/template/get_all_private_template')
+    })
+  })
+
+  describe('deleteTemplate', () => {
+    test('sends POST with template_id body', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.deleteTemplate('tmpl-to-delete')
+
+      expect(fetchCalls[1].url).toContain('/cgi-bin/template/del_private_template')
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body).toEqual({ template_id: 'tmpl-to-delete' })
+    })
+  })
+
+  describe('getFollowers', () => {
+    test('sends GET to /cgi-bin/user/get and returns openids array', async () => {
+      tokenResponse()
+      mockResponse({
+        errcode: 0,
+        total: 3,
+        count: 2,
+        data: { openid: ['openid-1', 'openid-2'] },
+        next_openid: 'openid-2',
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.getFollowers()
+
+      expect(result.total).toBe(3)
+      expect(result.count).toBe(2)
+      expect(result.openids).toEqual(['openid-1', 'openid-2'])
+      expect(result.next_openid).toBe('openid-2')
+      expect(fetchCalls[1].url).toContain('/cgi-bin/user/get')
+    })
+
+    test('passes next_openid parameter when provided', async () => {
+      tokenResponse()
+      mockResponse({
+        total: 1,
+        count: 1,
+        data: { openid: ['openid-3'] },
+        next_openid: '',
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.getFollowers('openid-2')
+
+      expect(fetchCalls[1].url).toContain('next_openid=openid-2')
+    })
+
+    test('returns empty openids when data is missing', async () => {
+      tokenResponse()
+      mockResponse({
+        total: 0,
+        count: 0,
+        next_openid: '',
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.getFollowers()
+
+      expect(result.openids).toEqual([])
+    })
+  })
+
+  describe('getUserInfo', () => {
+    test('sends GET with openid and lang params', async () => {
+      tokenResponse()
+      mockResponse({
+        subscribe: 1,
+        openid: 'openid-123',
+        language: 'zh_CN',
+        subscribe_time: 1609459200,
+        remark: '',
+        tagid_list: [],
+        subscribe_scene: 'ADD_SCENE_QR_CODE',
+        qr_scene: 0,
+        qr_scene_str: '',
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const user = await client.getUserInfo('openid-123', 'zh_CN')
+
+      expect(user.openid).toBe('openid-123')
+      expect(user.subscribe).toBe(1)
+      expect(fetchCalls[1].url).toContain('/cgi-bin/user/info')
+      expect(fetchCalls[1].url).toContain('openid=openid-123')
+      expect(fetchCalls[1].url).toContain('lang=zh_CN')
+    })
+
+    test('defaults to zh_CN lang', async () => {
+      tokenResponse()
+      mockResponse({
+        subscribe: 1,
+        openid: 'openid-456',
+        language: 'zh_CN',
+        subscribe_time: 1609459200,
+        remark: '',
+        tagid_list: [],
+        subscribe_scene: 'ADD_SCENE_QR_CODE',
+        qr_scene: 0,
+        qr_scene_str: '',
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.getUserInfo('openid-456')
+
+      expect(fetchCalls[1].url).toContain('lang=zh_CN')
+    })
+  })
+
+  describe('token caching', () => {
+    test('second call does not re-fetch token if not expired', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.sendTextMessage('openid-1', 'msg1')
+      await client.sendTextMessage('openid-2', 'msg2')
+
+      expect(fetchCalls.length).toBe(3)
+      expect(fetchCalls[0].url).toContain('/cgi-bin/token')
+      expect(fetchCalls[1].url).toContain('/cgi-bin/message/custom/send')
+      expect(fetchCalls[2].url).toContain('/cgi-bin/message/custom/send')
+    })
+  })
+
+  describe('token auto-refresh on 40001', () => {
+    test('fetches new token and retries on errcode 40001', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 40001, errmsg: 'invalid credential' })
+      mockResponse({ access_token: 'new-token', expires_in: 7200 })
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await client.sendTextMessage('openid-123', 'Hello')
+
+      expect(fetchCalls.length).toBe(4)
+      expect(fetchCalls[2].url).toContain('/cgi-bin/token')
+      expect(fetchCalls[3].url).toContain('/cgi-bin/message/custom/send')
+      expect(fetchCalls[3].url).toContain('access_token=new-token')
+    })
+  })
+
+  describe('retry on system busy (errcode -1)', () => {
+    test('retries with backoff on errcode -1', async () => {
+      tokenResponse()
+      mockResponse({ errcode: -1, errmsg: 'system busy' })
+      mockResponse({ errcode: -1, errmsg: 'system busy' })
+      mockResponse({ errcode: -1, errmsg: 'system busy' })
+      mockResponse({ errcode: -1, errmsg: 'system busy' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+
+      try {
+        await client.sendTextMessage('openid-123', 'Hello')
+        expect.unreachable('should have thrown')
+      } catch (err) {
+        expect(err).toBeInstanceOf(WeChatBotError)
+        expect((err as WeChatBotError).message).toBe('WeChat system busy')
+      }
+    })
+  })
+
+  describe('network error retry', () => {
+    test('GET retries on fetch throw', async () => {
+      let callCount = 0
+      Object.defineProperty(globalThis, 'fetch', {
+        value: async (url: string | URL | Request, options?: RequestInit): Promise<Response> => {
+          fetchCalls.push({ url: url.toString(), options })
+          callCount++
+          if (callCount === 1) {
+            return new Response(JSON.stringify({ access_token: 'test-token', expires_in: 7200 }), { status: 200 })
+          }
+          if (callCount <= 3) {
+            throw new Error('network error')
+          }
+          return new Response(
+            JSON.stringify({
+              total: 0,
+              count: 0,
+              data: { openid: [] },
+              next_openid: '',
+            }),
+            { status: 200 },
+          )
+        },
+        writable: true,
+        configurable: true,
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      const result = await client.getFollowers()
+
+      expect(result.openids).toEqual([])
+      expect(callCount).toBe(4)
+    })
+
+    test('POST does not retry on fetch throw', async () => {
+      let callCount = 0
+      Object.defineProperty(globalThis, 'fetch', {
+        value: async (url: string | URL | Request, options?: RequestInit): Promise<Response> => {
+          fetchCalls.push({ url: url.toString(), options })
+          callCount++
+          if (callCount === 1) {
+            return new Response(JSON.stringify({ access_token: 'test-token', expires_in: 7200 }), { status: 200 })
+          }
+          throw new Error('network error')
+        },
+        writable: true,
+        configurable: true,
+      })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await expect(client.sendTextMessage('openid-123', 'Hello')).rejects.toThrow(WeChatBotError)
+      expect(callCount).toBe(2)
+    })
+  })
+
+  describe('errcode handling', () => {
+    test('non-zero errcode throws WeChatBotError with correct code', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 48001, errmsg: 'api unauthorized' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+
+      try {
+        await client.sendTextMessage('openid-123', 'Hello')
+        expect.unreachable('should have thrown')
+      } catch (err) {
+        expect(err).toBeInstanceOf(WeChatBotError)
+        expect((err as WeChatBotError).code).toBe('48001')
+        expect((err as WeChatBotError).message).toBe('api unauthorized')
+      }
+    })
+
+    test('errcode 0 does not throw', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 0, errmsg: 'ok' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+      await expect(client.sendTextMessage('openid-123', 'Hello')).resolves.toBeUndefined()
+    })
+  })
+
+  describe('rate limit (errcode 45009)', () => {
+    test('throws WeChatBotError with code 45009 and appropriate message', async () => {
+      tokenResponse()
+      mockResponse({ errcode: 45009, errmsg: 'reach max api daily quota limit' })
+
+      const client = await new WeChatBotClient().login({ appId: 'wx123', appSecret: 'secret123' })
+
+      try {
+        await client.sendTextMessage('openid-123', 'Hello')
+        expect.unreachable('should have thrown')
+      } catch (err) {
+        expect(err).toBeInstanceOf(WeChatBotError)
+        expect((err as WeChatBotError).code).toBe('45009')
+        expect((err as WeChatBotError).message).toContain('frequency limit')
+      }
+    })
+  })
+})