agent-messenger 2.3.0 → 2.5.0

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')
+})

package/src/platforms/wechatbot/index.ts

@@ -0,0 +1,19 @@
+export { WeChatBotClient } from './client'
+export { WeChatBotCredentialManager } from './credential-manager'
+export type {
+  WeChatBotAccountEntry,
+  WeChatBotConfig,
+  WeChatBotCredentials,
+  WeChatBotNewsArticle,
+  WeChatBotTemplate,
+  WeChatBotUserInfo,
+} from './types'
+export {
+  WeChatBotAccountEntrySchema,
+  WeChatBotConfigSchema,
+  WeChatBotCredentialsSchema,
+  WeChatBotError,
+  WeChatBotNewsArticleSchema,
+  WeChatBotTemplateSchema,
+  WeChatBotUserInfoSchema,
+} from './types'

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

@@ -0,0 +1,223 @@
+import { expect, test } from 'bun:test'
+
+import {
+  WeChatBotAccountEntrySchema,
+  WeChatBotConfigSchema,
+  WeChatBotCredentialsSchema,
+  WeChatBotError,
+  WeChatBotNewsArticleSchema,
+  WeChatBotTemplateSchema,
+  WeChatBotUserInfoSchema,
+} from '@/platforms/wechatbot/types'
+
+test('WeChatBotAccountEntrySchema validates correct data', () => {
+  const result = WeChatBotAccountEntrySchema.safeParse({
+    app_id: 'wx123',
+    app_secret: 'secret123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotAccountEntrySchema rejects missing app_id', () => {
+  const result = WeChatBotAccountEntrySchema.safeParse({
+    app_secret: 'secret123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotAccountEntrySchema rejects missing app_secret', () => {
+  const result = WeChatBotAccountEntrySchema.safeParse({
+    app_id: 'wx123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotAccountEntrySchema rejects missing account_name', () => {
+  const result = WeChatBotAccountEntrySchema.safeParse({
+    app_id: 'wx123',
+    app_secret: 'secret123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotConfigSchema validates with current account', () => {
+  const result = WeChatBotConfigSchema.safeParse({
+    current: { account_id: 'wx123' },
+    accounts: {
+      wx123: { app_id: 'wx123', app_secret: 'secret123', account_name: 'My Account' },
+    },
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotConfigSchema validates with current null and empty accounts', () => {
+  const result = WeChatBotConfigSchema.safeParse({
+    current: null,
+    accounts: {},
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotConfigSchema validates with multiple accounts', () => {
+  const result = WeChatBotConfigSchema.safeParse({
+    current: { account_id: 'wx-a' },
+    accounts: {
+      'wx-a': { app_id: 'wx-a', app_secret: 'secret-a', account_name: 'Account A' },
+      'wx-b': { app_id: 'wx-b', app_secret: 'secret-b', account_name: 'Account B' },
+    },
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotConfigSchema rejects missing accounts field', () => {
+  const result = WeChatBotConfigSchema.safeParse({ current: null })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotConfigSchema rejects missing current field', () => {
+  const result = WeChatBotConfigSchema.safeParse({ accounts: {} })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotCredentialsSchema validates correct data', () => {
+  const result = WeChatBotCredentialsSchema.safeParse({
+    app_id: 'wx123',
+    app_secret: 'secret123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotCredentialsSchema rejects missing app_id', () => {
+  const result = WeChatBotCredentialsSchema.safeParse({
+    app_secret: 'secret123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotCredentialsSchema rejects missing app_secret', () => {
+  const result = WeChatBotCredentialsSchema.safeParse({
+    app_id: 'wx123',
+    account_name: 'My Account',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotCredentialsSchema rejects missing account_name', () => {
+  const result = WeChatBotCredentialsSchema.safeParse({
+    app_id: 'wx123',
+    app_secret: 'secret123',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotNewsArticleSchema validates correct data', () => {
+  const result = WeChatBotNewsArticleSchema.safeParse({
+    title: 'Test Article',
+    description: 'Test description',
+    url: 'https://example.com',
+    picurl: 'https://example.com/pic.jpg',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotNewsArticleSchema rejects missing title', () => {
+  const result = WeChatBotNewsArticleSchema.safeParse({
+    description: 'Test description',
+    url: 'https://example.com',
+    picurl: 'https://example.com/pic.jpg',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotTemplateSchema validates correct data', () => {
+  const result = WeChatBotTemplateSchema.safeParse({
+    template_id: 'tmpl-001',
+    title: 'Order Notification',
+    primary_industry: 'IT科技',
+    deputy_industry: '互联网|电子商务',
+    content: 'ORDER_STATUS {{status.DATA}}',
+    example: 'Order shipped',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotTemplateSchema rejects missing template_id', () => {
+  const result = WeChatBotTemplateSchema.safeParse({
+    title: 'Order Notification',
+    primary_industry: 'IT科技',
+    deputy_industry: '互联网|电子商务',
+    content: 'ORDER_STATUS {{status.DATA}}',
+    example: 'Order shipped',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotUserInfoSchema validates correct data', () => {
+  const result = WeChatBotUserInfoSchema.safeParse({
+    subscribe: 1,
+    openid: 'openid-123',
+    language: 'zh_CN',
+    subscribe_time: 1609459200,
+    remark: '',
+    tagid_list: [1, 2],
+    subscribe_scene: 'ADD_SCENE_QR_CODE',
+    qr_scene: 0,
+    qr_scene_str: '',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotUserInfoSchema validates with optional unionid', () => {
+  const result = WeChatBotUserInfoSchema.safeParse({
+    subscribe: 1,
+    openid: 'openid-123',
+    language: 'zh_CN',
+    subscribe_time: 1609459200,
+    unionid: 'union-id-xyz',
+    remark: '',
+    tagid_list: [],
+    subscribe_scene: 'ADD_SCENE_SEARCH',
+    qr_scene: 0,
+    qr_scene_str: '',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('WeChatBotUserInfoSchema rejects missing openid', () => {
+  const result = WeChatBotUserInfoSchema.safeParse({
+    subscribe: 1,
+    language: 'zh_CN',
+    subscribe_time: 1609459200,
+    remark: '',
+    tagid_list: [],
+    subscribe_scene: 'ADD_SCENE_QR_CODE',
+    qr_scene: 0,
+    qr_scene_str: '',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('WeChatBotError has correct name', () => {
+  const error = new WeChatBotError('Test error', 'TEST_CODE')
+  expect(error.name).toBe('WeChatBotError')
+})
+
+test('WeChatBotError has correct message', () => {
+  const error = new WeChatBotError('Test error', 'TEST_CODE')
+  expect(error.message).toBe('Test error')
+})
+
+test('WeChatBotError has correct code', () => {
+  const error = new WeChatBotError('Test error', 'TEST_CODE')
+  expect(error.code).toBe('TEST_CODE')
+})
+
+test('WeChatBotError is instance of Error', () => {
+  const error = new WeChatBotError('Test error', 'TEST_CODE')
+  expect(error instanceof Error).toBe(true)
+})

package/src/platforms/wechatbot/types.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod'
+
+export interface WeChatBotAccountEntry {
+  app_id: string
+  app_secret: string
+  account_name: string
+}
+
+export interface WeChatBotConfig {
+  current: { account_id: string } | null
+  accounts: Record<string, WeChatBotAccountEntry>
+}
+
+export interface WeChatBotCredentials {
+  app_id: string
+  app_secret: string
+  account_name: string
+}
+
+export interface WeChatBotNewsArticle {
+  title: string
+  description: string
+  url: string
+  picurl: string
+}
+
+export interface WeChatBotTemplate {
+  template_id: string
+  title: string
+  primary_industry: string
+  deputy_industry: string
+  content: string
+  example: string
+}
+
+export interface WeChatBotUserInfo {
+  subscribe: number
+  openid: string
+  language: string
+  subscribe_time: number
+  unionid?: string
+  remark: string
+  tagid_list: number[]
+  subscribe_scene: string
+  qr_scene: number
+  qr_scene_str: string
+}
+
+export class WeChatBotError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'WeChatBotError'
+    this.code = code
+  }
+}
+
+export const WeChatBotAccountEntrySchema = z.object({
+  app_id: z.string(),
+  app_secret: z.string(),
+  account_name: z.string(),
+})
+
+export const WeChatBotConfigSchema = z.object({
+  current: z
+    .object({
+      account_id: z.string(),
+    })
+    .nullable(),
+  accounts: z.record(z.string(), WeChatBotAccountEntrySchema),
+})
+
+export const WeChatBotCredentialsSchema = z.object({
+  app_id: z.string(),
+  app_secret: z.string(),
+  account_name: z.string(),
+})
+
+export const WeChatBotNewsArticleSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  url: z.string(),
+  picurl: z.string(),
+})
+
+export const WeChatBotTemplateSchema = z.object({
+  template_id: z.string(),
+  title: z.string(),
+  primary_industry: z.string(),
+  deputy_industry: z.string(),
+  content: z.string(),
+  example: z.string(),
+})
+
+export const WeChatBotUserInfoSchema = z.object({
+  subscribe: z.number(),
+  openid: z.string(),
+  language: z.string(),
+  subscribe_time: z.number(),
+  unionid: z.string().optional(),
+  remark: z.string(),
+  tagid_list: z.array(z.number()),
+  subscribe_scene: z.string(),
+  qr_scene: z.number(),
+  qr_scene_str: z.string(),
+})

package/src/platforms/whatsapp/cli.ts

@@ -5,7 +5,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureWhatsAppAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -32,6 +32,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)