agent-messenger 2.2.0 → 2.4.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/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()
+  })
+})

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

@@ -0,0 +1,148 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { WeChatBotAccountEntry, WeChatBotConfig, WeChatBotCredentials } from './types'
+import { WeChatBotConfigSchema } from './types'
+
+export class WeChatBotCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'wechatbot-credentials.json')
+  }
+
+  async load(): Promise<WeChatBotConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, accounts: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    let json: unknown
+    try {
+      json = JSON.parse(content)
+    } catch {
+      return { current: null, accounts: {} }
+    }
+    const parsed = WeChatBotConfigSchema.safeParse(json)
+    if (!parsed.success) {
+      return { current: null, accounts: {} }
+    }
+    return parsed.data
+  }
+
+  async save(config: WeChatBotConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getCredentials(accountId?: string): Promise<WeChatBotCredentials | null> {
+    const envAppId = process.env.E2E_WECHATBOT_APP_ID
+    const envAppSecret = process.env.E2E_WECHATBOT_APP_SECRET
+
+    if (envAppId && envAppSecret && !accountId) {
+      return {
+        app_id: envAppId,
+        app_secret: envAppSecret,
+        account_name: 'env',
+      }
+    }
+
+    const config = await this.load()
+
+    if (accountId) {
+      const account = config.accounts[accountId]
+      if (!account) return null
+      return {
+        app_id: account.app_id,
+        app_secret: account.app_secret,
+        account_name: account.account_name,
+      }
+    }
+
+    if (!config.current) {
+      return null
+    }
+
+    const account = config.accounts[config.current.account_id]
+    if (!account) return null
+
+    return {
+      app_id: account.app_id,
+      app_secret: account.app_secret,
+      account_name: account.account_name,
+    }
+  }
+
+  async setCredentials(entry: WeChatBotAccountEntry): Promise<void> {
+    const config = await this.load()
+
+    config.accounts[entry.app_id] = {
+      app_id: entry.app_id,
+      app_secret: entry.app_secret,
+      account_name: entry.account_name,
+    }
+
+    config.current = {
+      account_id: entry.app_id,
+    }
+
+    await this.save(config)
+  }
+
+  async removeAccount(accountId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.accounts[accountId]) {
+      return false
+    }
+
+    delete config.accounts[accountId]
+
+    if (config.current?.account_id === accountId) {
+      config.current = null
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async setCurrent(accountId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.accounts[accountId]) {
+      return false
+    }
+
+    config.current = {
+      account_id: accountId,
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async listAll(): Promise<Array<WeChatBotAccountEntry & { is_current: boolean }>> {
+    const config = await this.load()
+    const results: Array<WeChatBotAccountEntry & { is_current: boolean }> = []
+
+    for (const account of Object.values(config.accounts)) {
+      results.push({
+        app_id: account.app_id,
+        app_secret: account.app_secret,
+        account_name: account.account_name,
+        is_current: config.current?.account_id === account.app_id,
+      })
+    }
+
+    return results
+  }
+
+  async clearCredentials(): Promise<void> {
+    await this.save({ current: null, accounts: {} })
+  }
+}

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

@@ -0,0 +1,49 @@
+import { expect, test } from 'bun:test'
+
+import {
+  WeChatBotAccountEntrySchema,
+  WeChatBotClient,
+  WeChatBotConfigSchema,
+  WeChatBotCredentialManager,
+  WeChatBotCredentialsSchema,
+  WeChatBotError,
+  WeChatBotNewsArticleSchema,
+  WeChatBotTemplateSchema,
+  WeChatBotUserInfoSchema,
+} from '@/platforms/wechatbot/index'
+
+test('WeChatBotClient is exported from barrel', () => {
+  expect(typeof WeChatBotClient).toBe('function')
+})
+
+test('WeChatBotCredentialManager is exported from barrel', () => {
+  expect(typeof WeChatBotCredentialManager).toBe('function')
+})
+
+test('WeChatBotError is exported from barrel', () => {
+  expect(typeof WeChatBotError).toBe('function')
+})
+
+test('WeChatBotAccountEntrySchema is exported from barrel', () => {
+  expect(typeof WeChatBotAccountEntrySchema.parse).toBe('function')
+})
+
+test('WeChatBotConfigSchema is exported from barrel', () => {
+  expect(typeof WeChatBotConfigSchema.parse).toBe('function')
+})
+
+test('WeChatBotCredentialsSchema is exported from barrel', () => {
+  expect(typeof WeChatBotCredentialsSchema.parse).toBe('function')
+})
+
+test('WeChatBotNewsArticleSchema is exported from barrel', () => {
+  expect(typeof WeChatBotNewsArticleSchema.parse).toBe('function')
+})
+
+test('WeChatBotTemplateSchema is exported from barrel', () => {
+  expect(typeof WeChatBotTemplateSchema.parse).toBe('function')
+})
+
+test('WeChatBotUserInfoSchema is exported from barrel', () => {
+  expect(typeof WeChatBotUserInfoSchema.parse).toBe('function')
+})