weflow-cli 1.5.0

package/src/core/wechatClient.ts

@@ -0,0 +1,204 @@
+/**
+ * WeChat ilink API HTTP client.
+ *
+ * Communicates with WeChat's bridge service (default https://ilinkai.weixin.qq.com)
+ * for QR login, message send/receive, and CDN media upload/download.
+ *
+ * References:
+ *   AstrBot - weixin_oc_client.py / weixin_oc_adapter.py
+ */
+import crypto from 'crypto'
+import fs from 'fs/promises'
+import type { WechatOCConfig } from '../types.js'
+
+const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com'
+const DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c'
+const DEFAULT_TIMEOUT_MS = 15_000
+
+export class WechatClient {
+  private baseUrl: string
+  private cdnBaseUrl: string
+  private apiTimeoutMs: number
+  token?: string
+
+  constructor(config: WechatOCConfig = {}) {
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL
+    this.cdnBaseUrl = config.cdnBaseUrl || DEFAULT_CDN_BASE_URL
+    this.apiTimeoutMs = config.apiTimeoutMs || DEFAULT_TIMEOUT_MS
+    this.token = config.token
+  }
+
+  // ====== Core HTTP ======
+
+  async requestJson(
+    method: 'GET' | 'POST',
+    endpoint: string,
+    options: {
+      payload?: Record<string, any>
+      params?: Record<string, any>
+      tokenRequired?: boolean
+      timeoutMs?: number
+      extraHeaders?: Record<string, string>
+    } = {},
+  ): Promise<Record<string, any>> {
+    const url = new URL(`${this.baseUrl}/${endpoint}`)
+    if (options.params) {
+      for (const [k, v] of Object.entries(options.params)) {
+        url.searchParams.set(k, String(v))
+      }
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      AuthorizationType: 'ilink_bot_token',
+      'X-WECHAT-UIN': Buffer.from(String(crypto.randomInt(2 ** 32))).toString('base64'),
+      ...options.extraHeaders,
+    }
+
+    if (options.tokenRequired && this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`
+    }
+
+    const controller = new AbortController()
+    const timeout = options.timeoutMs || this.apiTimeoutMs
+    const timer = setTimeout(() => controller.abort(), timeout)
+
+    try {
+      let response: Response
+      if (method === 'GET') {
+        response = await fetch(url.toString(), { headers, signal: controller.signal })
+      } else {
+        response = await fetch(url.toString(), {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(options.payload || {}),
+          signal: controller.signal,
+        })
+      }
+
+      if (response.status >= 400) {
+        const text = await response.text().catch(() => '')
+        throw new Error(`HTTP ${response.status}: ${text.slice(0, 200)}`)
+      }
+
+      const text = await response.text()
+      if (!text) return {}
+      return JSON.parse(text)
+    } catch (e: any) {
+      if (e.name === 'AbortError') {
+        throw new Error(`Request timeout: ${method} ${endpoint}`)
+      }
+      throw e
+    } finally {
+      clearTimeout(timer)
+    }
+  }
+
+  // ====== CDN Media ======
+
+  async uploadToCdn(
+    uploadFullUrl: string,
+    uploadParam: string,
+    fileKey: string,
+    aesKeyHex: string,
+    fileBuffer: Buffer,
+  ): Promise<string> {
+    const padded = WechatClient.pkcs7Pad(fileBuffer)
+    const keyBuffer = Buffer.from(aesKeyHex, 'hex')
+    const cipher = crypto.createCipheriv('aes-128-ecb', keyBuffer, null)
+    cipher.setAutoPadding(false)
+    const encrypted = Buffer.concat([cipher.update(padded), cipher.final()])
+
+    const url = `${uploadFullUrl}?${uploadParam}`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), this.apiTimeoutMs)
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: encrypted,
+        signal: controller.signal,
+      })
+
+      if (response.status !== 200) {
+        const text = await response.text().catch(() => '')
+        throw new Error(`CDN upload failed: HTTP ${response.status} ${text.slice(0, 200)}`)
+      }
+
+      const encryptedParam = response.headers.get('x-encrypted-param')
+      if (!encryptedParam) {
+        throw new Error('CDN upload response missing x-encrypted-param header')
+      }
+      return encryptedParam
+    } finally {
+      clearTimeout(timer)
+    }
+  }
+
+  async downloadMedia(
+    encryptedQueryParam: string,
+    aesKeyValue: string,
+  ): Promise<Buffer> {
+    const url = `${this.cdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`
+    const keyBuffer = WechatClient.parseMediaAesKey(aesKeyValue)
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), this.apiTimeoutMs)
+
+    try {
+      const response = await fetch(url.toString(), { signal: controller.signal })
+      if (response.status !== 200) {
+        throw new Error(`CDN download failed: HTTP ${response.status}`)
+      }
+      const encrypted = Buffer.from(await response.arrayBuffer())
+
+      const decipher = crypto.createDecipheriv('aes-128-ecb', keyBuffer, null)
+      decipher.setAutoPadding(false)
+      const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()])
+      return WechatClient.pkcs7Unpad(decrypted)
+    } finally {
+      clearTimeout(timer)
+    }
+  }
+
+  // ====== Static Utils ======
+
+  static pkcs7Pad(data: Buffer, blockSize: number = 16): Buffer {
+    const padLen = blockSize - (data.length % blockSize)
+    const pad = Buffer.alloc(padLen, padLen)
+    return Buffer.concat([data, pad])
+  }
+
+  static pkcs7Unpad(data: Buffer, blockSize: number = 16): Buffer {
+    if (data.length === 0) return data
+    const padLen = data[data.length - 1]
+    if (padLen < 1 || padLen > blockSize) return data
+    return data.subarray(0, data.length - padLen)
+  }
+
+  static parseMediaAesKey(aesKeyStr: string): Buffer {
+    // Try base64 first
+    try {
+      let b64 = aesKeyStr.replace(/-/g, '+').replace(/_/g, '/')
+      while (b64.length % 4 !== 0) b64 += '='
+      const buf = Buffer.from(b64, 'base64')
+      if (buf.length === 16) return buf
+    } catch {}
+
+    // Try hex (32 chars = 16 bytes)
+    if (aesKeyStr.length === 32 && /^[0-9a-fA-F]+$/.test(aesKeyStr)) {
+      return Buffer.from(aesKeyStr, 'hex')
+    }
+
+    throw new Error(`Cannot parse AES key: ${aesKeyStr.slice(0, 20)}...`)
+  }
+
+  static aesPaddedSize(size: number): number {
+    return size + (16 - (size % 16)) % 16
+  }
+
+  async close(): Promise<void> {
+    // no persistent connection to close with fetch API
+  }
+}

package/src/lz4.d.ts

@@ -0,0 +1,10 @@
+declare module 'lz4' {
+  export function decodeBlock(
+    input: Buffer,
+    output?: Buffer,
+    sIdx?: number,
+    eIdx?: number
+  ): number
+
+  export function decodeBound(size: number): number
+}

package/src/services/chatService.ts

@@ -0,0 +1,296 @@
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { existsSync } from 'fs'
+import { WcdbCore } from '../core/wcdbCore.js'
+import { SqlcipherCore } from '../core/sqlcipherCore.js'
+import { NtCore } from '../core/ntCore.js'
+import { configService } from './configService.js'
+import type { ChatSession, Message, Contact, DataVersion } from '../types.js'
+
+// 创建单例
+const wcdbCore = new WcdbCore()
+const sqlcipherCore = new SqlcipherCore()
+
+export class ChatService {
+  private connected = false
+  private activeVersion: DataVersion | null = null
+  /** 4.x 是否通过原始 SQLite 连接 (而非 WCDB API) */
+  private useRawSqlite4x = false
+  /** NT 格式数据库访问 (通过 Python sqlcipher3) */
+  private ntCore: NtCore | null = null
+
+  /**
+   * 检测数据版本: 3.x 或 4.x
+   */
+  private detectVersion(): DataVersion | null {
+    const version = configService.get('dataVersion')
+    if (version === '3.x' || version === '4.x') return version as DataVersion
+
+    // 自动检测: 检查已配置的路径
+    const dbPath4x = configService.get('dbPath')
+    const dbPath3x = configService.get('dbPath3x')
+    const key4x = configService.get('decryptKey')
+    const key3x = configService.get('decryptKey3x')
+
+    if (dbPath3x && key3x) return '3.x'
+    if (dbPath4x && key4x) return '4.x'
+
+    return null
+  }
+
+  async connect(): Promise<{ success: boolean; error?: string }> {
+    if (this.connected) return { success: true }
+
+    const version = this.detectVersion()
+    if (!version) {
+      return { success: false, error: '请先运行 weflow-cli init 完成配置' }
+    }
+
+    if (version === '4.x') {
+      return this.connect4x()
+    } else {
+      return this.connect3x()
+    }
+  }
+
+  private async connect4x(): Promise<{ success: boolean; error?: string }> {
+    const dbPath = configService.get('dbPath')
+    const wxid = configService.get('wxid')
+    const decryptKey = configService.get('decryptKey')
+
+    if (!dbPath || !decryptKey) {
+      return { success: false, error: '4.x 配置不完整，请运行 weflow-cli init' }
+    }
+
+    // 方案 1: 使用已解密的 MSG0_decrypted.db (纯 SQLite)
+    const rawMsg0Path = join(dbPath, wxid || '', 'Msg', 'Multi', 'MSG0_decrypted.db')
+    if (existsSync(rawMsg0Path)) {
+      const result = await sqlcipherCore.openRaw(rawMsg0Path, wxid || '')
+      if (result.success) {
+        this.connected = true
+        this.activeVersion = '4.x'
+        this.useRawSqlite4x = true
+        return { success: true }
+      }
+    }
+
+    // 方案 2: 尝试直接解密 MSG0.db (需要正确的密钥和盐值)
+    const msg0Path = join(dbPath, wxid || '', 'Msg', 'Multi', 'MSG0.db')
+    if (existsSync(msg0Path) && decryptKey) {
+      const result = await sqlcipherCore.open4x(msg0Path, decryptKey, wxid || '')
+      if (result.success) {
+        this.connected = true
+        this.activeVersion = '4.x'
+        this.useRawSqlite4x = true
+        return { success: true }
+      }
+    }
+
+    // 方案 3: 尝试 NT 格式数据库 (xwechat_files/*/db_storage/message/message_0.db)
+    const ntDbPath = configService.get('ntDbPath')
+    const ntKey = configService.get('ntKey')
+    const ntSalt = configService.get('ntSalt')
+    if (ntDbPath && ntKey && ntSalt && existsSync(ntDbPath)) {
+      this.ntCore = new NtCore(ntDbPath, ntKey, ntSalt)
+      // 自动发现 contact.db 路径
+      if (this.ntCore.autoDetectContactDb()) {
+        const allConfig = configService.getAll()
+        if (allConfig.contactKey && allConfig.contactSalt) {
+          this.ntCore.contactKey = allConfig.contactKey
+          this.ntCore.contactSalt = allConfig.contactSalt
+        }
+      }
+      // 快速验证: 尝试获取会话列表
+      const testResult = await this.ntCore.getSessions()
+      if (testResult.success) {
+        this.connected = true
+        this.activeVersion = '4.x'
+        return { success: true }
+      }
+      this.ntCore = null
+    }
+
+    // 方案 4: 尝试 WCDB API 连接 (需要 db_storage/session.db 结构，仅 3.x 兼容)
+    // Use package root instead of cwd for global install support
+    const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..')
+    const resourcesPath = join(pkgRoot, 'resources')
+    wcdbCore.setPaths(resourcesPath, '')
+
+    const ok = await wcdbCore.open(dbPath, decryptKey, wxid || '')
+    if (ok) {
+      this.connected = true
+      this.activeVersion = '4.x'
+      this.useRawSqlite4x = false
+      return { success: true }
+    }
+
+    // 所有方案失败，给出明确的指导
+    const msgDir = join(dbPath, wxid || '', 'Msg', 'Multi')
+    return {
+      success: false,
+      error: [
+        '4.x 数据库连接失败，请尝试以下方案之一：',
+        '',
+        '方案 A - 使用解密工具 (推荐):',
+        `  python scripts/scan_decrypt_4x.py --db "${msg0Path}" --out "${rawMsg0Path}"`,
+        '',
+        '方案 B - NT 格式数据库 (微信 4.x 新版):',
+        '  1. 确保微信正在运行',
+        '  2. 运行: weflow-cli init (将自动扫描 NT 数据库)',
+        '',
+        '方案 C - 重新提取密钥 (需要重启微信):',
+        '  1. 关闭微信 4.x (Weixin.exe)',
+        '  2. 运行: weflow-cli dbkey --timeout 120000',
+        '  3. 启动微信并登录，密钥将在登录时自动捕获',
+        '  4. 保存密钥: weflow-cli config set decryptKey <64位密钥>',
+        '',
+        '方案 D - 手动指定已解密数据库路径:',
+        `  将已解密的数据库放到: ${rawMsg0Path}`,
+      ].join('\n'),
+    }
+  }
+
+  private async connect3x(): Promise<{ success: boolean; error?: string }> {
+    const dbPath = configService.get('dbPath3x')
+    const wxid = configService.get('wxid')
+    const decryptKey = configService.get('decryptKey3x')
+
+    if (!dbPath || !decryptKey) {
+      return { success: false, error: '3.x 配置不完整，请运行 weflow-cli init' }
+    }
+
+    const ok = await sqlcipherCore.open(dbPath, decryptKey, wxid || '')
+    if (ok.success) {
+      this.connected = true
+      this.activeVersion = '3.x'
+      return { success: true }
+    }
+    return { success: false, error: ok.error || '3.x 数据库连接失败' }
+  }
+
+  async listSessions(keyword?: string, limit = 50): Promise<ChatSession[]> {
+    const conn = await this.connect()
+    if (!conn.success) return []
+
+    let sessions: ChatSession[] = []
+
+    if (this.ntCore) {
+      const result = await this.ntCore.getSessions(keyword)
+      if (!result.success || !result.sessions) return []
+      sessions = result.sessions
+    } else if (this.activeVersion === '4.x') {
+      if (this.useRawSqlite4x) {
+        const result = await sqlcipherCore.getSessions()
+        if (!result.success || !result.sessions) return []
+        sessions = result.sessions
+      } else {
+        const result = await wcdbCore.getSessions()
+        if (!result.success || !result.sessions) return []
+        sessions = result.sessions
+      }
+    } else if (this.activeVersion === '3.x') {
+      const result = await sqlcipherCore.getSessions()
+      if (!result.success || !result.sessions) return []
+      sessions = result.sessions
+    }
+
+    if (keyword) {
+      const kw = keyword.toLowerCase()
+      sessions = sessions.filter(s =>
+        (s.username || '').toLowerCase().includes(kw) ||
+        (s.displayName || '').toLowerCase().includes(kw) ||
+        (s.summary || '').toLowerCase().includes(kw)
+      )
+    }
+
+    return sessions.slice(0, limit)
+  }
+
+  async getMessages(
+    talker: string,
+    limit = 0,
+    offset = 0
+  ): Promise<Message[]> {
+    const conn = await this.connect()
+    if (!conn.success) return []
+
+    if (this.ntCore) {
+      const result = await this.ntCore.getMessages(talker, limit, offset)
+      if (!result.success || !result.messages) return []
+      return result.messages
+    } else if (this.activeVersion === '4.x') {
+      if (this.useRawSqlite4x) {
+        const result = await sqlcipherCore.getMessages(talker, limit, offset)
+        if (!result.success || !result.messages) return []
+        return result.messages
+      }
+      const result = await wcdbCore.getMessages(talker, limit, offset)
+      if (!result.success || !result.messages) return []
+      return result.messages
+    } else if (this.activeVersion === '3.x') {
+      const result = await sqlcipherCore.getMessages(talker, limit, offset)
+      if (!result.success || !result.messages) return []
+      return result.messages
+    }
+
+    return []
+  }
+
+  async listContacts(keyword?: string, limit = 200): Promise<Contact[]> {
+    const conn = await this.connect()
+    if (!conn.success) return []
+
+    let contacts: Contact[] = []
+
+    if (this.ntCore) {
+      const result = await this.ntCore.getContacts(keyword, limit)
+      if (!result.success || !result.contacts) return []
+      contacts = result.contacts
+    } else if (this.activeVersion === '4.x') {
+      if (this.useRawSqlite4x) {
+        const result = await sqlcipherCore.getContacts()
+        if (!result.success || !result.contacts) return []
+        contacts = result.contacts
+      } else {
+        const result = await wcdbCore.getContactsCompact()
+        if (!result.success || !result.contacts) return []
+        contacts = result.contacts
+      }
+    } else if (this.activeVersion === '3.x') {
+      const result = await sqlcipherCore.getContacts()
+      if (!result.success || !result.contacts) return []
+      contacts = result.contacts
+    }
+
+    if (keyword) {
+      const kw = keyword.toLowerCase()
+      contacts = contacts.filter(c =>
+        (c.username || '').toLowerCase().includes(kw) ||
+        (c.displayName || '').toLowerCase().includes(kw) ||
+        (c.remark || '').toLowerCase().includes(kw) ||
+        (c.nickname || '').toLowerCase().includes(kw)
+      )
+    }
+
+    return contacts.slice(0, limit)
+  }
+
+  disconnect(): void {
+    if (this.ntCore) {
+      this.ntCore = null
+    }
+    if (this.activeVersion === '4.x') {
+      if (this.useRawSqlite4x) {
+        try { sqlcipherCore.close() } catch { }
+      }
+      try { wcdbCore.close() } catch { }
+    } else if (this.activeVersion === '3.x') {
+      try { sqlcipherCore.close() } catch { }
+    }
+    this.connected = false
+    this.activeVersion = null
+    this.useRawSqlite4x = false
+  }
+}
+
+export const chatService = new ChatService()