agent-messenger 2.3.0 → 2.5.0

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

@@ -0,0 +1,165 @@
+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 mockFollowersResult = {
+  total: 2,
+  count: 2,
+  openids: ['openid-1', 'openid-2'],
+  next_openid: '',
+}
+
+const mockUserInfo = {
+  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: '',
+}
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login() {
+      return this
+    }
+    getFollowers = mock(() => Promise.resolve(mockFollowersResult))
+    getUserInfo = mock(() => Promise.resolve(mockUserInfo))
+  },
+}))
+
+const { listAction } = await import('@/platforms/wechatbot/commands/user')
+
+const testDirs: string[] = []
+
+function makeCredManager(): WeChatBotCredentialManager {
+  const dir = join(
+    import.meta.dir,
+    `.test-user-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 (user)', () => {
+  test('returns followers list with total, count, openids, next_openid', async () => {
+    const credManager = await makeCredManagerWithCreds()
+    const result = await listAction({ _credManager: credManager })
+
+    expect(result.total).toBe(2)
+    expect(result.count).toBe(2)
+    expect(result.openids).toEqual(['openid-1', 'openid-2'])
+    expect(result.next_openid).toBe('')
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        getFollowers = mock(() => Promise.reject(new Error('API error')))
+      },
+    }))
+
+    const { listAction: listActionFresh } = await import('@/platforms/wechatbot/commands/user')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await listActionFresh({ _credManager: credManager })
+
+    expect(result.error).toBe('API error')
+    expect(result.openids).toBeUndefined()
+  })
+
+  test('passes nextOpenid option to client', async () => {
+    const getFollowersMock = mock(() =>
+      Promise.resolve({ total: 1, count: 1, openids: ['openid-3'], next_openid: '' }),
+    )
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        getFollowers = getFollowersMock
+      },
+    }))
+
+    const { listAction: listActionFresh } = await import('@/platforms/wechatbot/commands/user')
+    const credManager = await makeCredManagerWithCreds()
+    await listActionFresh({ nextOpenid: 'openid-2', _credManager: credManager })
+
+    expect(getFollowersMock).toHaveBeenCalledWith('openid-2')
+  })
+})
+
+describe('getAction', () => {
+  test('returns user info for given openId', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        getUserInfo = mock(() => Promise.resolve(mockUserInfo))
+      },
+    }))
+
+    const { getAction: getActionFresh } = await import('@/platforms/wechatbot/commands/user')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await getActionFresh('openid-123', { _credManager: credManager })
+
+    expect(result.user).toEqual(mockUserInfo)
+    expect(result.user?.openid).toBe('openid-123')
+  })
+
+  test('returns error when client throws', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        getUserInfo = mock(() => Promise.reject(new Error('user not found')))
+      },
+    }))
+
+    const { getAction: getActionFresh } = await import('@/platforms/wechatbot/commands/user')
+    const credManager = await makeCredManagerWithCreds()
+    const result = await getActionFresh('nonexistent-openid', { _credManager: credManager })
+
+    expect(result.error).toBe('user not found')
+    expect(result.user).toBeUndefined()
+  })
+
+  test('passes lang option to client', async () => {
+    const getUserInfoMock = mock(() => Promise.resolve({ ...mockUserInfo, language: 'en' }))
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        getUserInfo = getUserInfoMock
+      },
+    }))
+
+    const { getAction: getActionFresh } = await import('@/platforms/wechatbot/commands/user')
+    const credManager = await makeCredManagerWithCreds()
+    await getActionFresh('openid-123', { lang: 'en', _credManager: credManager })
+
+    expect(getUserInfoMock).toHaveBeenCalledWith('openid-123', 'en')
+  })
+})

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

@@ -0,0 +1,75 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WeChatBotUserInfo } from '../types'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface UserResult {
+  total?: number
+  count?: number
+  openids?: string[]
+  next_openid?: string
+  user?: WeChatBotUserInfo
+  error?: string
+}
+
+type UserOptions = AccountOption & {
+  nextOpenid?: string
+  lang?: string
+}
+
+export async function listAction(options: UserOptions): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const result = await client.getFollowers(options.nextOpenid)
+    return {
+      total: result.total,
+      count: result.count,
+      openids: result.openids,
+      next_openid: result.next_openid,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function getAction(openId: string, options: UserOptions): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const user = await client.getUserInfo(openId, options.lang)
+    return { user }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: UserResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const userCommand = new Command('user')
+  .description('User management commands')
+  .addCommand(
+    new Command('list')
+      .description('List followers')
+      .option('--next-openid <cursor>', 'Cursor for pagination')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: UserOptions) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get user info by OpenID')
+      .argument('<open-id>', 'User OpenID')
+      .option('--lang <lang>', 'Language (zh_CN, zh_TW, en)', 'zh_CN')
+      .option('--account <id>', 'Account ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (openId: string, opts: UserOptions) => {
+        cliOutput(await getAction(openId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockVerifyCredentials = mock(() => Promise.resolve(true))
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login(_credentials?: { appId: string; appSecret: string }) {
+      return this
+    }
+    verifyCredentials = mockVerifyCredentials
+  },
+}))
+
+import { WeChatBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `wechatbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_WECHATBOT_APP_ID
+    delete process.env.E2E_WECHATBOT_APP_SECRET
+    mockVerifyCredentials.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns app_id, account_name, and verified status', async () => {
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'secret123',
+      account_name: 'Test Official Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.app_id).toBe('wx1234567890')
+    expect(result.account_name).toBe('Test Official Account')
+    expect(result.verified).toBe(true)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns info for specific --account', async () => {
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wxAAA',
+      app_secret: 'secretA',
+      account_name: 'Account A',
+    })
+    await manager.setCredentials({
+      app_id: 'wxBBB',
+      app_secret: 'secretB',
+      account_name: 'Account B',
+    })
+
+    const result = await whoamiAction({ account: 'wxAAA', _credManager: manager })
+
+    expect(result.app_id).toBe('wxAAA')
+    expect(result.account_name).toBe('Account A')
+    expect(result.verified).toBe(true)
+  })
+
+  test('returns verified false when credentials are invalid', async () => {
+    mockVerifyCredentials.mockImplementationOnce(() => Promise.resolve(false))
+
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'bad-secret',
+      account_name: 'Test Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.app_id).toBe('wx1234567890')
+    expect(result.verified).toBe(false)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns error when client throws', async () => {
+    mockVerifyCredentials.mockImplementationOnce(() => Promise.reject(new Error('Network error')))
+
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'secret123',
+      account_name: 'Test Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('Network error')
+  })
+})

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

@@ -0,0 +1,43 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { WeChatBotCredentialManager } from '../credential-manager'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  app_id?: string | null
+  account_name?: string | null
+  verified?: boolean
+  error?: string
+}
+
+export async function whoamiAction(options: AccountOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const verified = await client.verifyCredentials()
+    const credManager = options._credManager ?? new WeChatBotCredentialManager()
+    const creds = await credManager.getCredentials(options.account)
+    return {
+      app_id: creds?.app_id ?? null,
+      account_name: creds?.account_name ?? null,
+      verified,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--account <id>', 'Account ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: AccountOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

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

@@ -0,0 +1,255 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { WeChatBotCredentialManager } from '@/platforms/wechatbot/credential-manager'
+
+const testDirs: string[] = []
+
+function setup(): WeChatBotCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-wechatbot-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new WeChatBotCredentialManager(testConfigDir)
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('WeChatBotCredentialManager', () => {
+  test('load returns default config when file does not exist', async () => {
+    const manager = setup()
+    const config = await manager.load()
+
+    expect(config).toEqual({
+      current: null,
+      accounts: {},
+    })
+  })
+
+  test('save creates file with correct content', async () => {
+    const testConfigDir = join(
+      import.meta.dir,
+      `.test-wechatbot-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    )
+    testDirs.push(testConfigDir)
+    const manager = new WeChatBotCredentialManager(testConfigDir)
+    const config = {
+      current: { account_id: 'wx123' },
+      accounts: {
+        wx123: {
+          app_id: 'wx123',
+          app_secret: 'secret123',
+          account_name: 'Test Account',
+        },
+      },
+    }
+
+    await manager.save(config)
+
+    const credentialsPath = join(testConfigDir, 'wechatbot-credentials.json')
+    expect(existsSync(credentialsPath)).toBe(true)
+
+    const file = Bun.file(credentialsPath)
+    const content = await file.text()
+    const loaded = JSON.parse(content)
+    expect(loaded).toEqual(config)
+  })
+
+  test('getCredentials returns null when not configured', async () => {
+    const manager = setup()
+    const creds = await manager.getCredentials()
+    expect(creds).toBeNull()
+  })
+
+  test('getCredentials returns credentials from env vars when E2E env vars are set', async () => {
+    const originalAppId = process.env.E2E_WECHATBOT_APP_ID
+    const originalAppSecret = process.env.E2E_WECHATBOT_APP_SECRET
+
+    process.env.E2E_WECHATBOT_APP_ID = 'env-app-id'
+    process.env.E2E_WECHATBOT_APP_SECRET = 'env-app-secret'
+
+    try {
+      const manager = setup()
+      const creds = await manager.getCredentials()
+      expect(creds).toEqual({
+        app_id: 'env-app-id',
+        app_secret: 'env-app-secret',
+        account_name: 'env',
+      })
+    } finally {
+      if (originalAppId === undefined) {
+        delete process.env.E2E_WECHATBOT_APP_ID
+      } else {
+        process.env.E2E_WECHATBOT_APP_ID = originalAppId
+      }
+      if (originalAppSecret === undefined) {
+        delete process.env.E2E_WECHATBOT_APP_SECRET
+      } else {
+        process.env.E2E_WECHATBOT_APP_SECRET = originalAppSecret
+      }
+    }
+  })
+
+  test('getCredentials ignores env vars when accountId is provided', async () => {
+    const originalAppId = process.env.E2E_WECHATBOT_APP_ID
+    const originalAppSecret = process.env.E2E_WECHATBOT_APP_SECRET
+
+    process.env.E2E_WECHATBOT_APP_ID = 'env-app-id'
+    process.env.E2E_WECHATBOT_APP_SECRET = 'env-app-secret'
+
+    try {
+      const manager = setup()
+      const creds = await manager.getCredentials('nonexistent-id')
+      expect(creds).toBeNull()
+    } finally {
+      if (originalAppId === undefined) {
+        delete process.env.E2E_WECHATBOT_APP_ID
+      } else {
+        process.env.E2E_WECHATBOT_APP_ID = originalAppId
+      }
+      if (originalAppSecret === undefined) {
+        delete process.env.E2E_WECHATBOT_APP_SECRET
+      } else {
+        process.env.E2E_WECHATBOT_APP_SECRET = originalAppSecret
+      }
+    }
+  })
+
+  test('getCredentials returns specific account by accountId', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await manager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const creds = await manager.getCredentials('wx-a')
+    expect(creds).toEqual({
+      app_id: 'wx-a',
+      app_secret: 'secret-a',
+      account_name: 'Account A',
+    })
+  })
+
+  test('getCredentials returns null for nonexistent accountId', async () => {
+    const manager = setup()
+    const creds = await manager.getCredentials('nonexistent')
+    expect(creds).toBeNull()
+  })
+
+  test('setCredentials saves and sets as current', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const creds = await manager.getCredentials()
+    expect(creds).toEqual({
+      app_id: 'wx123',
+      app_secret: 'secret123',
+      account_name: 'My Account',
+    })
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: 'wx123' })
+  })
+
+  test('removeAccount deletes account and adjusts current', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const removed = await manager.removeAccount('wx123')
+    expect(removed).toBe(true)
+
+    const creds = await manager.getCredentials()
+    expect(creds).toBeNull()
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+    expect(config.accounts['wx123']).toBeUndefined()
+  })
+
+  test('removeAccount returns false for non-existent account', async () => {
+    const manager = setup()
+    const removed = await manager.removeAccount('nonexistent')
+    expect(removed).toBe(false)
+  })
+
+  test('removeAccount does not clear current when a different account is removed', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await manager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const removed = await manager.removeAccount('wx-a')
+    expect(removed).toBe(true)
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: 'wx-b' })
+  })
+
+  test('setCurrent switches active account', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await manager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const result = await manager.setCurrent('wx-a')
+    expect(result).toBe(true)
+
+    const config = await manager.load()
+    expect(config.current).toEqual({ account_id: 'wx-a' })
+  })
+
+  test('setCurrent returns false for non-existent account', async () => {
+    const manager = setup()
+    const result = await manager.setCurrent('nonexistent')
+    expect(result).toBe(false)
+  })
+
+  test('listAll returns all accounts with is_current flag', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await manager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const accounts = await manager.listAll()
+    expect(accounts).toHaveLength(2)
+
+    const acctA = accounts.find((a) => a.app_id === 'wx-a')
+    const acctB = accounts.find((a) => a.app_id === 'wx-b')
+
+    expect(acctA?.is_current).toBe(false)
+    expect(acctB?.is_current).toBe(true)
+  })
+
+  test('listAll returns empty array when no accounts', async () => {
+    const manager = setup()
+    const accounts = await manager.listAll()
+    expect(accounts).toHaveLength(0)
+  })
+
+  test('clearCredentials resets everything', async () => {
+    const manager = setup()
+    await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    await manager.clearCredentials()
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+    expect(config.accounts).toEqual({})
+  })
+
+  test('round-trip: set → get → remove → get null', async () => {
+    const manager = setup()
+
+    await manager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const creds = await manager.getCredentials()
+    expect(creds?.app_id).toBe('wx123')
+    expect(creds?.app_secret).toBe('secret123')
+
+    await manager.removeAccount('wx123')
+
+    const afterRemove = await manager.getCredentials()
+    expect(afterRemove).toBeNull()
+  })
+})