agent-messenger 2.3.0 → 2.5.0

package/src/platforms/wechatbot/client.ts

@@ -0,0 +1,268 @@
+import type { WeChatBotNewsArticle, WeChatBotTemplate, WeChatBotUserInfo } from './types'
+import { WeChatBotError } from './types'
+
+const BASE_URL = 'https://api.weixin.qq.com'
+const MAX_RETRIES = 3
+const BASE_BACKOFF_MS = 100
+
+export class WeChatBotClient {
+  private appId: string | null = null
+  private appSecret: string | null = null
+  private accessToken: string | null = null
+  private tokenExpiresAt: number = 0
+
+  async login(credentials?: { appId: string; appSecret: string }): Promise<this> {
+    if (credentials) {
+      if (!credentials.appId) {
+        throw new WeChatBotError('App ID is required', 'missing_app_id')
+      }
+      if (!credentials.appSecret) {
+        throw new WeChatBotError('App Secret is required', 'missing_app_secret')
+      }
+      this.appId = credentials.appId
+      this.appSecret = credentials.appSecret
+      return this
+    }
+    const { WeChatBotCredentialManager } = await import('./credential-manager')
+    const credManager = new WeChatBotCredentialManager()
+    const creds = await credManager.getCredentials()
+    if (!creds) {
+      throw new WeChatBotError(
+        'No WeChat Bot credentials found. Run "agent-wechatbot auth set" first.',
+        'no_credentials',
+      )
+    }
+    return this.login({ appId: creds.app_id, appSecret: creds.app_secret })
+  }
+
+  private ensureAuth(): void {
+    if (this.appId === null) {
+      throw new WeChatBotError('Not authenticated. Call .login() first.', 'not_authenticated')
+    }
+  }
+
+  private async ensureAccessToken(): Promise<string> {
+    const now = Date.now()
+    if (this.accessToken && now < this.tokenExpiresAt) {
+      return this.accessToken
+    }
+    const result = await this.fetchAccessToken()
+    this.accessToken = result.access_token
+    this.tokenExpiresAt = now + (result.expires_in - 10) * 1000
+    return this.accessToken
+  }
+
+  private async fetchAccessToken(): Promise<{ access_token: string; expires_in: number }> {
+    const url = `${BASE_URL}/cgi-bin/token?grant_type=client_credential&appid=${this.appId}&secret=${this.appSecret}`
+    let response: Response
+    try {
+      response = await fetch(url)
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      throw new WeChatBotError(`Network error fetching access token: ${msg}`, 'network_error')
+    }
+
+    const data = (await response.json()) as { access_token?: string; expires_in?: number; errcode?: number; errmsg?: string }
+
+    if (data.errcode) {
+      throw new WeChatBotError(data.errmsg ?? `Error ${data.errcode}`, String(data.errcode))
+    }
+
+    if (!data.access_token) {
+      throw new WeChatBotError('Failed to obtain access token', 'token_fetch_failed')
+    }
+
+    return { access_token: data.access_token, expires_in: data.expires_in ?? 7200 }
+  }
+
+  async verifyCredentials(): Promise<boolean> {
+    this.ensureAuth()
+    try {
+      await this.fetchAccessToken()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async sendTextMessage(openId: string, text: string): Promise<void> {
+    await this.request<void>('POST', '/cgi-bin/message/custom/send', {
+      touser: openId,
+      msgtype: 'text',
+      text: { content: text },
+    })
+  }
+
+  async sendImageMessage(openId: string, mediaId: string): Promise<void> {
+    await this.request<void>('POST', '/cgi-bin/message/custom/send', {
+      touser: openId,
+      msgtype: 'image',
+      image: { media_id: mediaId },
+    })
+  }
+
+  async sendNewsMessage(openId: string, articles: WeChatBotNewsArticle[]): Promise<void> {
+    await this.request<void>('POST', '/cgi-bin/message/custom/send', {
+      touser: openId,
+      msgtype: 'news',
+      news: { articles },
+    })
+  }
+
+  async sendTemplateMessage(
+    openId: string,
+    templateId: string,
+    data: Record<string, { value: string }>,
+    url?: string,
+  ): Promise<{ msgid: number }> {
+    return this.request<{ msgid: number }>('POST', '/cgi-bin/message/template/send', {
+      touser: openId,
+      template_id: templateId,
+      url,
+      data,
+    })
+  }
+
+  async listTemplates(): Promise<WeChatBotTemplate[]> {
+    const result = await this.request<{ template_list: WeChatBotTemplate[] }>(
+      'GET',
+      '/cgi-bin/template/get_all_private_template',
+    )
+    return result.template_list
+  }
+
+  async deleteTemplate(templateId: string): Promise<void> {
+    await this.request<void>('POST', '/cgi-bin/template/del_private_template', {
+      template_id: templateId,
+    })
+  }
+
+  async getFollowers(nextOpenId?: string): Promise<{
+    total: number
+    count: number
+    openids: string[]
+    next_openid: string
+  }> {
+    const path = this.buildPath('/cgi-bin/user/get', nextOpenId ? { next_openid: nextOpenId } : undefined)
+    const result = await this.request<{
+      total: number
+      count: number
+      data: { openid: string[] }
+      next_openid: string
+    }>('GET', path)
+    return {
+      total: result.total,
+      count: result.count,
+      openids: result.data?.openid ?? [],
+      next_openid: result.next_openid,
+    }
+  }
+
+  async getUserInfo(openId: string, lang = 'zh_CN'): Promise<WeChatBotUserInfo> {
+    const path = this.buildPath('/cgi-bin/user/info', { openid: openId, lang })
+    return this.request<WeChatBotUserInfo>('GET', path)
+  }
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    this.ensureAuth()
+    let lastError: Error | undefined
+    let tokenInvalidated = false
+
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const token = await this.ensureAccessToken()
+      const url = `${BASE_URL}${path}${path.includes('?') ? '&' : '?'}access_token=${token}`
+
+      const options: RequestInit = {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+
+      if (body !== undefined) {
+        options.body = JSON.stringify(body)
+      }
+
+      let response: Response
+
+      try {
+        response = await fetch(url, options)
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error))
+        if (attempt < MAX_RETRIES && method === 'GET') {
+          await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+          continue
+        }
+        throw new WeChatBotError(`Network error: ${lastError.message}`, 'network_error')
+      }
+
+      if (response.status >= 500 && response.status <= 599) {
+        if (attempt < MAX_RETRIES && method === 'GET') {
+          await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+          continue
+        }
+        throw new WeChatBotError(`HTTP ${response.status}`, `http_${response.status}`)
+      }
+
+      const data = (await response.json()) as {
+        errcode?: number
+        errmsg?: string
+        [key: string]: unknown
+      }
+
+      if (data.errcode === 40001 || data.errcode === 42001) {
+        if (!tokenInvalidated) {
+          tokenInvalidated = true
+          this.accessToken = null
+          this.tokenExpiresAt = 0
+          continue
+        }
+        throw new WeChatBotError(data.errmsg ?? `Error ${data.errcode}`, String(data.errcode))
+      }
+
+      if (data.errcode === -1) {
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+          continue
+        }
+        throw new WeChatBotError('WeChat system busy', '-1')
+      }
+
+      if (data.errcode === 45009) {
+        throw new WeChatBotError('WeChat API frequency limit exceeded', '45009')
+      }
+
+      if (data.errcode && data.errcode !== 0) {
+        throw new WeChatBotError(data.errmsg ?? `Error ${data.errcode}`, String(data.errcode))
+      }
+
+      return data as T
+    }
+
+    throw lastError ?? new WeChatBotError('Request failed after retries', 'max_retries')
+  }
+
+  private buildPath(path: string, params?: Record<string, string | number | undefined>): string {
+    if (!params) {
+      return path
+    }
+
+    const searchParams = new URLSearchParams()
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined) {
+        searchParams.set(key, String(value))
+      }
+    }
+
+    const query = searchParams.toString()
+    if (!query) {
+      return path
+    }
+
+    return `${path}?${query}`
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+}

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

@@ -0,0 +1,211 @@
+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'
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login() {
+      return this
+    }
+    verifyCredentials = mock(() => Promise.resolve(true))
+  },
+}))
+
+const { setAction, statusAction, clearAction, listAction, useAction, removeAction } = await import(
+  '@/platforms/wechatbot/commands/auth'
+)
+
+const testDirs: string[] = []
+
+function makeCredManager(): WeChatBotCredentialManager {
+  const dir = join(
+    import.meta.dir,
+    `.test-auth-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(dir)
+  return new WeChatBotCredentialManager(dir)
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('setAction', () => {
+  test('returns success with app_id when credentials are valid', async () => {
+    const credManager = makeCredManager()
+    const result = await setAction('wx123', 'secret123', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+    expect(result.app_id).toBe('wx123')
+    expect(result.account_name).toBe('wx123')
+  })
+
+  test('saves credentials to credManager', async () => {
+    const credManager = makeCredManager()
+    await setAction('wx456', 'secret456', { _credManager: credManager })
+
+    const creds = await credManager.getCredentials()
+    expect(creds?.app_id).toBe('wx456')
+  })
+
+  test('returns error when verifyCredentials returns false', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        verifyCredentials = mock(() => Promise.resolve(false))
+      },
+    }))
+
+    const { setAction: setActionFresh } = await import('@/platforms/wechatbot/commands/auth')
+    const credManager = makeCredManager()
+    const result = await setActionFresh('wx-bad', 'bad-secret', { _credManager: credManager })
+
+    expect(result.error).toBeDefined()
+    expect(result.success).toBeUndefined()
+  })
+})
+
+describe('statusAction', () => {
+  test('returns valid: false when no credentials configured', async () => {
+    const credManager = makeCredManager()
+    const result = await statusAction({ _credManager: credManager })
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toBeDefined()
+  })
+
+  test('returns valid: true when credentials exist and are valid', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        verifyCredentials = mock(() => Promise.resolve(true))
+      },
+    }))
+
+    const { statusAction: statusActionFresh } = await import('@/platforms/wechatbot/commands/auth')
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const result = await statusActionFresh({ _credManager: credManager })
+
+    expect(result.valid).toBe(true)
+    expect(result.app_id).toBe('wx123')
+  })
+
+  test('returns valid: false when credentials exist but are invalid', async () => {
+    mock.module('../client', () => ({
+      WeChatBotClient: class MockWeChatBotClient {
+        async login() {
+          return this
+        }
+        verifyCredentials = mock(() => Promise.resolve(false))
+      },
+    }))
+
+    const { statusAction: statusActionFresh } = await import('@/platforms/wechatbot/commands/auth')
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx123', app_secret: 'bad-secret', account_name: 'My Account' })
+
+    const result = await statusActionFresh({ _credManager: credManager })
+
+    expect(result.valid).toBe(false)
+  })
+
+  test('returns error message when account not found', async () => {
+    const credManager = makeCredManager()
+    const result = await statusAction({ account: 'nonexistent', _credManager: credManager })
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toContain('nonexistent')
+  })
+})
+
+describe('clearAction', () => {
+  test('clears all credentials and returns success', async () => {
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const result = await clearAction({ _credManager: credManager })
+
+    expect(result.success).toBe(true)
+
+    const creds = await credManager.getCredentials()
+    expect(creds).toBeNull()
+  })
+})
+
+describe('listAction', () => {
+  test('returns empty accounts array when none configured', async () => {
+    const credManager = makeCredManager()
+    const result = await listAction({ _credManager: credManager })
+
+    expect(result.accounts).toEqual([])
+  })
+
+  test('returns all accounts with is_current flag', async () => {
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await credManager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const result = await listAction({ _credManager: credManager })
+
+    expect(result.accounts).toHaveLength(2)
+    const acctA = result.accounts?.find((a) => a.app_id === 'wx-a')
+    const acctB = result.accounts?.find((a) => a.app_id === 'wx-b')
+    expect(acctA?.is_current).toBe(false)
+    expect(acctB?.is_current).toBe(true)
+  })
+})
+
+describe('useAction', () => {
+  test('switches to specified account and returns success', async () => {
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' })
+    await credManager.setCredentials({ app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' })
+
+    const result = await useAction('wx-a', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+    expect(result.app_id).toBe('wx-a')
+  })
+
+  test('returns error when account not found', async () => {
+    const credManager = makeCredManager()
+    const result = await useAction('nonexistent', { _credManager: credManager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('nonexistent')
+    expect(result.success).toBeUndefined()
+  })
+})
+
+describe('removeAction', () => {
+  test('removes specified account and returns success', async () => {
+    const credManager = makeCredManager()
+    await credManager.setCredentials({ app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' })
+
+    const result = await removeAction('wx123', { _credManager: credManager })
+
+    expect(result.success).toBe(true)
+
+    const creds = await credManager.getCredentials()
+    expect(creds).toBeNull()
+  })
+
+  test('returns error when account not found', async () => {
+    const credManager = makeCredManager()
+    const result = await removeAction('nonexistent', { _credManager: credManager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('nonexistent')
+    expect(result.success).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,203 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { WeChatBotClient } from '../client'
+import { WeChatBotCredentialManager } from '../credential-manager'
+
+interface ActionOptions {
+  account?: string
+  pretty?: boolean
+  _credManager?: WeChatBotCredentialManager
+}
+
+interface ActionResult {
+  success?: boolean
+  error?: string
+  valid?: boolean
+  app_id?: string
+  account_name?: string
+  accounts?: Array<{ app_id: string; account_name: string; is_current: boolean }>
+}
+
+export async function setAction(appId: string, appSecret: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const client = await new WeChatBotClient().login({ appId, appSecret })
+    const valid = await client.verifyCredentials()
+
+    if (!valid) {
+      return { error: 'Invalid credentials. Could not obtain access token.' }
+    }
+
+    const credManager = options._credManager ?? new WeChatBotCredentialManager()
+    await credManager.setCredentials({
+      app_id: appId,
+      app_secret: appSecret,
+      account_name: appId,
+    })
+
+    return { success: true, app_id: appId, account_name: appId }
+  } catch (error: unknown) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function statusAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WeChatBotCredentialManager()
+    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 <app-id> <app-secret>" first.',
+      }
+    }
+
+    let valid = false
+    let appId: string | undefined
+    let accountName: string | undefined
+
+    try {
+      const client = await new WeChatBotClient().login({ appId: creds.app_id, appSecret: creds.app_secret })
+      valid = await client.verifyCredentials()
+      appId = creds.app_id
+      accountName = creds.account_name
+    } catch {
+      valid = false
+      appId = creds.app_id
+      accountName = creds.account_name
+    }
+
+    return { valid, app_id: appId, 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 WeChatBotCredentialManager()
+    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 WeChatBotCredentialManager()
+    const all = await credManager.listAll()
+
+    return {
+      accounts: all.map((a) => ({
+        app_id: a.app_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 WeChatBotCredentialManager()
+    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,
+      app_id: creds?.app_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 WeChatBotCredentialManager()
+    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('<app-id>', 'WeChat Official Account App ID')
+      .argument('<app-secret>', 'WeChat Official Account App Secret')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (appId: string, appSecret: string, opts: { pretty?: boolean }) => {
+        cliOutput(await setAction(appId, appSecret, 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 (App 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 (App ID)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (accountId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await removeAction(accountId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,5 @@
+export { authCommand } from './auth'
+export { messageCommand } from './message'
+export { templateCommand } from './template'
+export { userCommand } from './user'
+export { whoamiCommand } from './whoami'