weflow-cli 1.5.0 → 1.6.1

package/src/services/exportService.ts

@@ -2,35 +2,50 @@ import { join, basename, dirname } from 'path'
 import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import { execFile } from 'child_process'
 import { promisify } from 'util'
-import { fileURLToPath } from 'url'
 import { chatService } from './chatService.js'
 import { configService } from './configService.js'
+import { getPythonCommand } from '../utils/python.js'
+import { createPythonProcessEnv, safeSubprocessError } from '../utils/pythonProcessEnv.js'
 import type { Message } from '../types.js'
+import { createWeFlowEnvelope } from './messageContract.js'
+import { parseLocalDateOrIso } from '../utils/dateRange.js'
+import { resolvePackageRoot } from '../utils/packageRoot.js'
+
+export type ExportContract = 'raw' | 'weflow-v1'
+export interface ExportResult { success: boolean; path?: string; count?: number; error?: string }
 
 const execFileAsync = promisify(execFile)
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
+function getPackageRoot(): string {
+  return resolvePackageRoot(import.meta.url)
+}
 
 export class ExportService {
-  async exportJson(talker: string, outputDir: string, limit = 0): Promise<{ success: boolean; path?: string; error?: string }> {
+  async exportJson(talker: string, outputDir: string, limit = 0, from?: number, to?: number, contract: ExportContract = 'raw'): Promise<ExportResult> {
     try {
-      const messages = await chatService.getMessages(talker, limit)
+      const messages = await chatService.getMessagesInRange(talker, limit, from, to)
       if (messages.length === 0) {
         return { success: false, error: '未找到消息' }
       }
 
       const dir = this.ensureOutputDir(outputDir)
       const filePath = join(dir, `${talker}_messages.json`)
-      writeFileSync(filePath, JSON.stringify(messages, null, 2), 'utf8')
-      return { success: true, path: filePath }
-    } catch (e) {
-      return { success: false, error: String(e) }
+      const payload = contract === 'weflow-v1'
+        ? createWeFlowEnvelope(messages, new Date().toISOString(), {
+          requestedFrom: from,
+          requestedTo: to,
+          requestedLimit: limit,
+        })
+        : messages
+      writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8')
+      return { success: true, path: filePath, count: messages.length }
+    } catch {
+      return { success: false, error: 'JSON 导出失败' }
     }
   }
 
-  async exportTxt(talker: string, outputDir: string, limit = 0): Promise<{ success: boolean; path?: string; error?: string }> {
+  async exportTxt(talker: string, outputDir: string, limit = 0, from?: number, to?: number): Promise<ExportResult> {
     try {
-      const messages = await chatService.getMessages(talker, limit)
+      const messages = await chatService.getMessagesInRange(talker, limit, from, to)
       if (messages.length === 0) {
         return { success: false, error: '未找到消息' }
       }
@@ -45,32 +60,48 @@ export class ExportService {
       const dir = this.ensureOutputDir(outputDir)
       const filePath = join(dir, `${talker}_messages.txt`)
       writeFileSync(filePath, lines.join('\n'), 'utf8')
-      return { success: true, path: filePath }
-    } catch (e) {
-      return { success: false, error: String(e) }
+      return { success: true, path: filePath, count: messages.length }
+    } catch {
+      return { success: false, error: '文本导出失败' }
     }
   }
 
-  async exportHtml(talker: string, outputDir: string, limit = 0): Promise<{ success: boolean; path?: string; error?: string }> {
+  async exportHtml(talker: string, outputDir: string, limit = 0, date = '', from?: number, to?: number, quiet = false, options: { fullImages?: boolean } = {}): Promise<ExportResult> {
     try {
+      if (from !== undefined || to !== undefined) {
+        return this.exportHtmlBasic(talker, outputDir, limit, from, to)
+      }
       // Use Python export_chat_html.py for rich HTML with images
       const cfg = configService.getAll()
       const db = cfg.ntDbPath
       const key = cfg.ntKey
       const salt = cfg.ntSalt
+      // Derives each message shard's key (WeChat 4.1.12.26+). favPassphrase is
+      // the dedicated field, but decryptKey holds the same value and is what
+      // `init` writes - without this fallback the shard merge silently stays
+      // dormant and exports stop at the first shard's last message.
+      const passphrase = configService.get('favPassphrase') || cfg.decryptKey || ''
 
       if (!db || !key || !salt) {
         // Fallback: basic HTML
-        return this.exportHtmlBasic(talker, outputDir, limit)
+        let fallbackFrom: number | undefined = from
+        let fallbackTo: number | undefined = to
+        if (date && fallbackFrom === undefined && fallbackTo === undefined) {
+          fallbackFrom = parseLocalDateOrIso(date)
+          fallbackTo = parseLocalDateOrIso(date, true)
+        }
+        return this.exportHtmlBasic(talker, outputDir, limit, fallbackFrom, fallbackTo)
       }
 
       // Resolve Python script path (dist/src/services → package root)
-      const pkgRoot = join(__dirname, '..', '..', '..')
-      const script = join(pkgRoot, 'scripts', 'export_chat_html.py')
+      const script = join(getPackageRoot(), 'scripts', 'export_chat_html.py')
 
       // Cache dir for image thumbnails
-      const cacheDir = cfg.contactDbPath
-        ? join(dirname(dirname(cfg.contactDbPath)), 'cache')
+      const cacheDir = cfg.ntDbPath
+        ? join(dirname(dirname(dirname(cfg.ntDbPath))), 'cache')
+        : ''
+      const accountDir = cfg.ntDbPath
+        ? dirname(dirname(dirname(cfg.ntDbPath)))
         : ''
 
       // Resolve display name for filename (prefer remark/nickname over wxid)
@@ -85,48 +116,82 @@ export class ExportService {
 
       const args: string[] = [
         script,
-        '--db', db,
-        '--key', key,
-        '--salt', salt,
-        '--talker', talker,
-        '--out', outputDir || `./output`,
-        '--single',
-        '--parts', '1',
+        // Paginate: a whole year of chat in one file makes the browser crawl.
+        '--per-page', '100',
       ]
-      if (displayName) {
-        args.push('--name', displayName)
-      }
-      if (cacheDir && existsSync(cacheDir)) {
-        args.push('--cache-dir', cacheDir)
-      }
-
-      console.log(`  Exporting HTML via Python...`)
-      const { stdout } = await execFileAsync('python', args, {
-        timeout: 300_000,
+      const ownWxid = String(cfg.wxid || '').trim()
+      const exportCacheDir = cacheDir && existsSync(cacheDir) ? cacheDir : undefined
+      const exportAccountDir = accountDir && existsSync(accountDir) ? accountDir : undefined
+      if (!quiet) console.log(`  Exporting HTML via Python...`)
+      const { stdout } = await execFileAsync(getPythonCommand(), args, {
+        // Headroom for the opt-in --full-images path, which resizes hundreds
+        // of multi-MB originals and can take several minutes.
+        timeout: 900_000,
         maxBuffer: 50 * 1024 * 1024,
+        env: createPythonProcessEnv({
+          WEFLOW_DB_PATH: db,
+          WEFLOW_NT_KEY: key,
+          WEFLOW_NT_SALT: salt,
+          WEFLOW_TALKER: talker,
+          WEFLOW_OWN_WXID: ownWxid || undefined,
+          WEFLOW_NT_PASSPHRASE: passphrase || undefined,
+          WEFLOW_EXPORT_NAME: displayName || undefined,
+          WEFLOW_EXPORT_OUTPUT: outputDir || './output',
+          WEFLOW_EXPORT_CACHE_DIR: exportCacheDir,
+          WEFLOW_EXPORT_ACCOUNT_DIR: exportAccountDir,
+          // Lets custom stickers be decrypted from WeChat's local cache.
+          WEFLOW_EMOTICON_SEED: String(cfg.emoticonSeed || '') || undefined,
+          // Group rows identify their sender only by wxid; the contact
+          // database is what turns that into a name.
+          WEFLOW_CONTACT_DB_PATH: cfg.contactDbPath || undefined,
+          WEFLOW_CONTACT_KEY: cfg.contactKey || undefined,
+          WEFLOW_CONTACT_SALT: cfg.contactSalt || undefined,
+          // Off by default: originals are 5-24MB each and downscaling a few
+          // hundred of them costs minutes in PIL.
+          WEFLOW_FULL_IMAGES: options.fullImages ? '1' : undefined,
+          WEFLOW_EXPORT_DATE: date || undefined,
+        }),
       })
 
+      // Surface Python's progress and diagnostics. Only the trailing JSON
+      // summary is machine-read; everything else used to be discarded, so a
+      // multi-minute export showed nothing between "Exporting..." and the
+      // result - and the sticker seed hint never reached the user at all.
+      if (!quiet) {
+        for (const raw of stdout.split('\n')) {
+          const line = raw.trim()
+          if (!line || line.startsWith('{') || line.startsWith('Total messages:')) continue
+          if (/^Fetched \d+\/\d+/.test(line)) continue
+          console.log(`  ${line}`)
+        }
+      }
+
       // Parse JSON result from Python output
       const lines = stdout.split('\n').filter((l: string) => l.trim())
       for (let i = lines.length - 1; i >= 0; i--) {
         try {
           const result = JSON.parse(lines[i])
           if (result.success && result.files?.length > 0) {
-            return { success: true, path: result.files[0] }
+            const total = Number(result.total)
+            return { success: true, path: result.files[0], count: Number.isFinite(total) ? total : undefined }
           }
         } catch {}
       }
 
       return { success: false, error: 'Python export succeeded but no output found' }
     } catch (e: any) {
-      console.error(`  Python export failed: ${e.message}`)
+      const failure = safeSubprocessError(e, 'Python export failed')
+      if (!quiet) console.error(`  ${failure}`)
+      if (date) {
+        return { success: false, error: `指定日期导出失败: ${failure}` }
+      }
       // Fallback to basic HTML
-      return this.exportHtmlBasic(talker, outputDir, limit)
+      return this.exportHtmlBasic(talker, outputDir, limit, from, to)
     }
   }
 
-  private async exportHtmlBasic(talker: string, outputDir: string, limit = 0): Promise<{ success: boolean; path?: string; error?: string }> {
-    const messages = await chatService.getMessages(talker, limit)
+  private async exportHtmlBasic(talker: string, outputDir: string, limit = 0, from?: number, to?: number): Promise<ExportResult> {
+    const messages = await chatService.getMessagesInRange(talker, limit, from, to)
     if (messages.length === 0) {
       return { success: false, error: '未找到消息' }
     }
@@ -135,13 +200,13 @@ export class ExportService {
     const dir = this.ensureOutputDir(outputDir)
     const filePath = join(dir, `${talker}_messages.html`)
     writeFileSync(filePath, html, 'utf8')
-    return { success: true, path: filePath }
+    return { success: true, path: filePath, count: messages.length }
   }
 
-  async exportExcel(talker: string, outputDir: string, limit = 0): Promise<{ success: boolean; path?: string; error?: string }> {
+  async exportExcel(talker: string, outputDir: string, limit = 0, from?: number, to?: number): Promise<ExportResult> {
     try {
       const ExcelJS = await import('exceljs')
-      const messages = await chatService.getMessages(talker, limit)
+      const messages = await chatService.getMessagesInRange(talker, limit, from, to)
       if (messages.length === 0) {
         return { success: false, error: '未找到消息' }
       }
@@ -170,9 +235,9 @@ export class ExportService {
       const dir = this.ensureOutputDir(outputDir)
       const filePath = join(dir, `${talker}_messages.xlsx`)
       await workbook.xlsx.writeFile(filePath)
-      return { success: true, path: filePath }
-    } catch (e) {
-      return { success: false, error: String(e) }
+      return { success: true, path: filePath, count: messages.length }
+    } catch {
+      return { success: false, error: 'Excel 导出失败' }
     }
   }
 

package/src/services/initKeyService.ts

@@ -0,0 +1,83 @@
+/**
+ * init 密钥派生服务 — 较新微信版本（实测 4.1.12.55）密钥体系适配。
+ *
+ * 新版微信进程内存中不再出现 x'<key><salt>' 文本, 内存扫描匹配不到任何密钥;
+ * 但 DLL hook 仍能拿到全库 passphrase, 各库密钥改为本地派生:
+ *   raw_key = PBKDF2-HMAC-SHA512(passphrase, 库文件前16字节盐, 256000轮, 32字节)
+ * 派生后逐库用 sqlcipher 真实打开验证, 通过才写入配置。
+ */
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { NtCore } from '../core/ntCore.js'
+import { configService } from './configService.js'
+
+export interface NtDbEntry {
+  path: string
+  name: string
+  salt: string
+  size: number
+  wxid: string
+}
+
+type Log = (line: string) => void
+
+/** 从已配置的 NT 主库路径推导 favorite.db 路径 */
+export function detectFavDbPath(): string | null {
+  const ntDbPath = configService.get('ntDbPath')
+  if (!ntDbPath) return null
+  const parts = ntDbPath.replace(/\\/g, '/').split('/')
+  const idx = parts.lastIndexOf('db_storage')
+  if (idx < 0) return null
+  const favPath = [...parts.slice(0, idx), 'db_storage', 'favorite', 'favorite.db'].join('/')
+  return existsSync(favPath) ? favPath : null
+}
+
+/**
+ * 派生各 NT 库密钥并验证写入配置 (4.1.12+ 派生模式)。
+ * @returns message_0.db 是否成功配置 (聊天主路径可用)
+ */
+export async function applyDerivedNtKeys(passphrase: string, databases: NtDbEntry[], log: Log = () => {}): Promise<boolean> {
+  const targets = [
+    { name: 'message/message_0.db', pathKey: 'ntDbPath', keyKey: 'ntKey', saltKey: 'ntSalt', label: '聊天主库' },
+    { name: 'contact/contact.db', pathKey: 'contactDbPath', keyKey: 'contactKey', saltKey: 'contactSalt', label: '联系人库' },
+    { name: 'sns/sns.db', pathKey: 'snsDbPath', keyKey: 'snsKey', saltKey: 'snsSalt', label: '朋友圈库' },
+  ] as const
+  let messageSaved = false
+  let anySaved = false
+  for (const t of targets) {
+    const db = databases.find((d) => d.name === t.name)
+    if (!db) continue
+    const derivedKey = NtCore.deriveRawKey(passphrase, db.salt)
+    const verify = await NtCore.verifyDbKey(db.path, derivedKey, db.salt)
+    if (verify.success || verify.cannotVerify) {
+      // cannotVerify = Python/sqlcipher3 环境问题而非密钥错误: 公式确定性派生, 值仍写入
+      configService.set(t.pathKey, db.path)
+      configService.set(t.keyKey, derivedKey)
+      configService.set(t.saltKey, db.salt)
+      const note = verify.success ? '派生密钥已验证' : `已写入但未能验证 (${verify.error})`
+      log(chalk.green(`  ✓ ${t.label}: ${db.name} (${(db.size / 1024 / 1024).toFixed(1)}MB, ${note})`))
+      if (t.name === 'message/message_0.db') messageSaved = true
+      anySaved = true
+    } else {
+      log(chalk.red(`  ✗ ${t.label}: 派生密钥验证失败 (${verify.error || '密钥不匹配'})`))
+    }
+  }
+  if (anySaved) await enableFavorites(passphrase, databases, log)
+  return messageSaved
+}
+
+/** 启用收藏功能: 验证 passphrase 能派生打开 favorite.db 后写入配置 */
+export async function enableFavorites(passphrase: string, databases: NtDbEntry[], log: Log = () => {}): Promise<void> {
+  if (configService.get('favPassphrase')) return
+  const favDb = databases.find((d) => d.name === 'favorite/favorite.db')
+  const favPath = favDb?.path || detectFavDbPath()
+  if (!favPath) return
+  if (favDb) {
+    const derived = NtCore.deriveRawKey(passphrase, favDb.salt)
+    const v = await NtCore.verifyDbKey(favPath, derived, favDb.salt)
+    if (!v.success && !v.cannotVerify) return
+  }
+  configService.set('favDbPath', favPath)
+  configService.set('favPassphrase', passphrase)
+  log(chalk.green('  ✓ 收藏功能已启用 (favorite.db passphrase 已配置)'))
+}

package/src/services/messageContract.ts

@@ -0,0 +1,77 @@
+import type { Message } from '../types.js'
+
+export type WeFlowMessageType =
+  | 'text' | 'image' | 'voice' | 'card' | 'video' | 'emoji'
+  | 'location' | 'link' | 'call' | 'system' | 'quote' | 'other'
+
+const MESSAGE_TYPE_NAMES: Record<number, WeFlowMessageType> = {
+  1: 'text',
+  3: 'image',
+  34: 'voice',
+  42: 'card',
+  43: 'video',
+  47: 'emoji',
+  48: 'location',
+  49: 'link',
+  50: 'call',
+  10000: 'system',
+  10002: 'quote',
+}
+
+export interface WeFlowMessageEnvelope {
+  schema: 'weflow-message/v1'
+  source: 'weflow-cli'
+  generatedAt: string
+  coverage?: WeFlowMessageCoverage
+  messages: Array<Message & { messageType: WeFlowMessageType }>
+}
+
+export interface WeFlowMessageCoverage {
+  requestedFrom?: number
+  requestedTo?: number
+  requestedLimit: number
+  returned: number
+  mayHaveMore: boolean
+  oldestCreateTime?: number
+  newestCreateTime?: number
+}
+
+export function toWeFlowMessages(messages: Message[]): WeFlowMessageEnvelope['messages'] {
+  return messages.map((message) => ({
+    ...message,
+    messageType: MESSAGE_TYPE_NAMES[message.localType] || 'other',
+  }))
+}
+
+export function createWeFlowEnvelope(
+  messages: Message[],
+  generatedAt = new Date().toISOString(),
+  coverage?: Omit<WeFlowMessageCoverage, 'returned' | 'oldestCreateTime' | 'newestCreateTime' | 'mayHaveMore'>,
+): WeFlowMessageEnvelope {
+  let oldestCreateTime: number | undefined
+  let newestCreateTime: number | undefined
+  for (const message of messages) {
+    const timestamp = Number(message.createTime)
+    if (!Number.isFinite(timestamp)) continue
+    oldestCreateTime = oldestCreateTime === undefined ? timestamp : Math.min(oldestCreateTime, timestamp)
+    newestCreateTime = newestCreateTime === undefined ? timestamp : Math.max(newestCreateTime, timestamp)
+  }
+  const result: WeFlowMessageEnvelope = {
+    schema: 'weflow-message/v1',
+    source: 'weflow-cli',
+    generatedAt,
+    messages: toWeFlowMessages(messages),
+  }
+  if (coverage) {
+    result.coverage = {
+      ...coverage,
+      returned: messages.length,
+      mayHaveMore: coverage.requestedLimit > 0 && messages.length >= coverage.requestedLimit,
+      ...(oldestCreateTime !== undefined ? {
+        oldestCreateTime,
+        newestCreateTime,
+      } : {}),
+    }
+  }
+  return result
+}

package/src/services/messageQuery.ts

@@ -0,0 +1,38 @@
+import type { Message } from '../types.js'
+
+export interface MessageTimeRange {
+  from?: number
+  to?: number
+}
+
+export async function collectMessagesInRange(
+  fetchPage: (limit: number, offset: number) => Promise<Message[]>,
+  limit: number,
+  range: MessageTimeRange,
+  pageSize = 500,
+): Promise<Message[]> {
+  const result: Message[] = []
+  let offset = 0
+
+  while (true) {
+    const page = await fetchPage(pageSize, offset)
+    if (page.length === 0) break
+
+    let oldestTimestamp = Number.POSITIVE_INFINITY
+    for (const message of page) {
+      const timestamp = Number(message.createTime)
+      if (!Number.isFinite(timestamp)) continue
+      oldestTimestamp = Math.min(oldestTimestamp, timestamp)
+      if (range.from !== undefined && timestamp < range.from) continue
+      if (range.to !== undefined && timestamp > range.to) continue
+      result.push(message)
+      if (limit > 0 && result.length >= limit) return result
+    }
+
+    offset += page.length
+    if (page.length < pageSize) break
+    if (range.from !== undefined && oldestTimestamp < range.from) break
+  }
+
+  return result
+}