1npm install @wechatbot/wechatbot

1234567891011import { WeChatBot } from '@wechatbot/wechatbot'

const bot = new WeChatBot()
await bot.login()

bot.onMessage(async (msg) => {
  await bot.sendTyping(msg.userId)
  await bot.reply(msg, `Echo: ${msg.text}`)
})

await bot.start()

1234567891011const bot = new WeChatBot({
  storage: 'file',            // 'file' | 'memory' | custom Storage
  storageDir: '~/.wechatbot',
  logLevel: 'info',           // 'debug' | 'info' | 'warn' | 'error' | 'silent'
  botAgent: 'MyApp/1.2 (prod)', // base_info.bot_agent identifier sent on every request
  loginCallbacks: {
    onQrUrl: (url) => renderQrCode(url),
    onScanned: () => console.log('Scanned!'),
    onExpired: () => console.log('Expired...'),
  },
})

1234567891011121314151617181920212223242526// Text (string shorthand)
await bot.reply(msg, 'Hello!')

// Text (object)
await bot.reply(msg, { text: 'Hello!' })

// Image with optional caption
await bot.reply(msg, { image: pngBuffer, caption: 'Screenshot' })

// Video with optional caption
await bot.reply(msg, { video: mp4Buffer, caption: 'Check this out' })

// File — auto-routes by extension:
//   .png/.jpg/.gif/.webp → sent as image
//   .mp4/.mov/.webm      → sent as video
//   everything else      → sent as file attachment
await bot.reply(msg, { file: data, fileName: 'report.pdf' })
await bot.reply(msg, { file: data, fileName: 'photo.png' })   // → image!

// From URL — auto-download + auto-detect type from Content-Type / extension
await bot.reply(msg, { url: 'https://example.com/photo.jpg' })
await bot.reply(msg, { url: 'https://picsum.photos/400/300', caption: 'Random!' })

// send() works the same way, just takes userId instead of message
await bot.send(userId, 'Hello!')
await bot.send(userId, { image: buffer, caption: 'Hi!' })

1234567891011121314151617bot.onMessage(async (msg) => {
  const media = await bot.download(msg)
  if (!media) return  // no media in this message

  console.log(media.type)      // 'image' | 'file' | 'video' | 'voice'
  console.log(media.data)      // Buffer
  console.log(media.fileName)  // 'report.pdf' (for files)
  console.log(media.format)    // 'wav' | 'silk' (for voice)

  // Save to disk
  await writeFile(`/tmp/${media.fileName ?? 'download'}`, media.data)

  // Echo back
  if (media.type === 'image') {
    await bot.reply(msg, { image: media.data, caption: 'Got your image!' })
  }
})

123456789101112131415161718import {
  WeChatBot, loggingMiddleware, rateLimitMiddleware,
  typeFilterMiddleware, filterMiddleware,
} from '@wechatbot/wechatbot'

const bot = new WeChatBot()

bot.use(loggingMiddleware(bot.logger))
bot.use(rateLimitMiddleware({ maxMessages: 10, windowMs: 60_000 }))
bot.use(typeFilterMiddleware('text', 'image'))
bot.use(filterMiddleware(/^\/\w+/))

// Custom middleware
bot.use(async (ctx, next) => {
  const start = Date.now()
  await next()
  console.log(`Processed in ${Date.now() - start}ms`)
})

12345678// File storage (default) — survives restarts
const bot1 = new WeChatBot({ storage: 'file' })

// Memory storage — fast, ephemeral
const bot2 = new WeChatBot({ storage: 'memory' })

// Custom — implement 5 methods
const bot3 = new WeChatBot({ storage: new RedisStorage() })

12345678910111213141516171819202122232425262728293031323334353637383940import type { Storage } from '@wechatbot/wechatbot'
import type { Pool } from 'pg'

export class PostgresStorage implements Storage {
  constructor(private pool: Pool, private tenantId: string) {}

  async get<T>(key: string): Promise<T | undefined> {
    const { rows } = await this.pool.query(
      'SELECT value FROM bot_storage WHERE tenant_id = $1 AND key = $2',
      [this.tenantId, key],
    )
    return rows[0]?.value as T | undefined
  }

  async set<T>(key: string, value: T): Promise<void> {
    await this.pool.query(
      `INSERT INTO bot_storage (tenant_id, key, value) VALUES ($1, $2, $3)
       ON CONFLICT (tenant_id, key) DO UPDATE SET value = $3, updated_at = now()`,
      [this.tenantId, key, JSON.stringify(value)],
    )
  }

  async delete(key: string): Promise<void> {
    await this.pool.query(
      'DELETE FROM bot_storage WHERE tenant_id = $1 AND key = $2',
      [this.tenantId, key],
    )
  }

  async has(key: string): Promise<boolean> {
    return (await this.get(key)) !== undefined
  }

  async clear(): Promise<void> {
    await this.pool.query(
      'DELETE FROM bot_storage WHERE tenant_id = $1',
      [this.tenantId],
    )
  }
}

123456789101112131415161718192021// One instance per tenant, credentials in the database (see PostgresStorage above)
async function startTenantBot(tenantId: string) {
  const bot = new WeChatBot({
    storage: new PostgresStorage(pool, tenantId),
  })

  await bot.login({
    callbacks: {
      onQrUrl: (url) => pushQrToWebUI(tenantId, url),   // render on that user's page
      onScanned: () => notify(tenantId, 'Scanned — waiting for confirmation'),
      onExpired: () => refreshQr(tenantId),
    },
  })

  bot.onMessage(async (msg) => {
    await bot.reply(msg, await agentReply(tenantId, msg))
  })

  await bot.start()
  return bot
}

1234567bot.on('login', (creds) => console.log(`Logged in: ${creds.accountId}`))
bot.on('session:expired', () => console.log('Session expired'))
bot.on('session:restored', (creds) => console.log('Restored'))
bot.on('error', (err) => console.error(err))
bot.on('poll:start', () => { })
bot.on('poll:stop', () => { })
bot.on('close', () => { })

123456const payload = bot.createMessage(userId)
  .text("Here's your report:")
  .file({ media: cdnRef, fileName: 'report.pdf', size: 542188 })
  .build()

await bot.sendRaw(payload)