agent-messenger 2.2.0 → 2.4.0

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/client.ts

@@ -86,6 +86,7 @@ export class WhatsAppClient {
   private pendingResolve: (() => void) | null = null
   private pendingPromise: Promise<void> | null = null
   private authCompleteResolve: (() => void) | null = null
+  private authCompleteReject: ((err: Error) => void) | null = null
 
   private storePath: string | null = null
 
@@ -248,8 +249,9 @@ export class WhatsAppClient {
       this.pendingResolve = resolve
     })
 
-    const authCompletePromise = new Promise<void>((resolve) => {
+    const authCompletePromise = new Promise<void>((resolve, reject) => {
       this.authCompleteResolve = resolve
+      this.authCompleteReject = reject
     })
 
     const cleaned = phoneNumber.replace(/[^0-9]/g, '')
@@ -258,16 +260,24 @@ export class WhatsAppClient {
 
     return new Promise((outerResolve, outerReject) => {
       let codeReturned = false
-      let postPairingRetries = 0
-      const MAX_POST_PAIRING_RETRIES = 5
 
       const overallTimeout = setTimeout(() => {
-        outerReject(new WhatsAppError('Pairing timed out', 'pairing_timeout'))
+        const err = new WhatsAppError('Pairing timed out', 'pairing_timeout')
+        if (codeReturned) {
+          this.authCompleteReject?.(err)
+        } else {
+          outerReject(err)
+        }
       }, 120_000)
 
       const onError = (err: unknown): void => {
         clearTimeout(overallTimeout)
-        outerReject(err instanceof Error ? err : new WhatsAppError(String(err), 'pairing_error'))
+        const error = err instanceof Error ? err : new WhatsAppError(String(err), 'pairing_error')
+        if (codeReturned) {
+          this.authCompleteReject?.(error)
+        } else {
+          outerReject(error)
+        }
       }
 
       const attempt = async (): Promise<void> => {
@@ -294,20 +304,21 @@ export class WhatsAppClient {
 
             const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
 
-            // 401 is normal for fresh credentials — always reconnect during pairing
             if (statusCode === DisconnectReason.forbidden) {
               clearTimeout(overallTimeout)
-              outerReject(new WhatsAppError('Account banned or restricted.', 'forbidden'))
+              const err = new WhatsAppError('Account banned or restricted.', 'forbidden')
+              if (codeReturned) {
+                this.authCompleteReject?.(err)
+              } else {
+                outerReject(err)
+              }
               return
             }
 
             if (codeReturned) {
-              postPairingRetries++
-              if (postPairingRetries > MAX_POST_PAIRING_RETRIES) {
-                clearTimeout(overallTimeout)
-                outerReject(new WhatsAppError('Post-pairing reconnection failed.', 'post_pairing_failed'))
-                return
-              }
+              // Post-pairing: rely on overallTimeout (120s) instead of retry cap.
+              // Baileys cycles the connection during pairing — keep reconnecting
+              // until the user enters the code and the connection opens.
               setTimeout(() => attempt().catch(onError), 2000)
               return
             }