cortico-world-wechat 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -2,11 +2,31 @@
 
 本文件的 `## <版本号>` 段落会显示在扩展市场的发布时间线上（索引仓的 Action 按同样规则切段）。
 
+
+## 0.1.4
+
+- **补充作者字段 `author`**（`静音胡闹 <2310468741@qq.com>`），此前漏填，npm 页面上作者为空。
+  说明：npm 的 "published by" 显示的是**账号名**，无法用该字段改写；本字段只影响作者展示。
+- 无功能变化。
+
+## 0.1.3
+
+- **修复：读取失败不会自愈**。此前一旦某次读取失败（并发写、微信正在写库、缓存半成品），
+  扩展会每秒重试、每秒失败，直到重启 Coopanion —— 实测踩到过该状态。
+  现在：缓存不可用即丢弃并全量重建；WAL 合并改为"临时文件 + 验证通过才原子替换"，
+  合并失败只降级为"少一次增量"，不再污染缓存。
+- **修复：多进程共用同一解密缓存会互相踩**（扩展 + 排查脚本同时跑 → 永久 ile is not a database）。
+  缓存目录改为按进程隔离（cache/p<pid>）。
+- **修复：用 mtime 判断"主库是否变化"导致每秒全量解密 20MB**。微信活着时 mtime 每秒都在变；
+  改为按**文件大小**判断全量重建，内容增量靠 WAL 合并补齐。实测二次读取 5224 页库仅需 13ms。
+- 依赖内容自省的 describe.json、	est/ 均未变。
+
 ## 0.1.2
 
 - 文档重写：安装给出三条路径（npm / 离线包 / 源码，按推荐顺序）、配置项逐条说明、
   "没反应时按顺序查"的排查表、以及"消息正文会进入模型上下文"的明确提示。
 - 无功能变化。
+
 ## 0.1.1
 
 - **打包内容调整**（无功能变化）：
@@ -14,6 +34,7 @@
   - npm 包内补上 `test/`，方便使用者自行验证（尤其是微信升级后跑 `test/decrypt-verify.mjs`，
     它用 `PRAGMA integrity_check` 判断页布局是否仍被正确解密）。
 
+
 ## 0.1.0
 
 首个公开版本。
@@ -26,4 +47,6 @@
 - **取密钥**：微信的库密钥只存在于其进程内存中，由 `tools/fetch-keys.py` 按需取出
   （短命进程，取完即退；失效时自动重取）。这是本项目唯一用到 Python 的地方。
 - 实测：真机库解密 `PRAGMA integrity_check = ok`；测试 26 例（7 监听逻辑 + 6 文本格式化 + 13 World 行为）。
-
+
+
+

package/package.json

@@ -1,52 +1,53 @@
-{
-  "name": "cortico-world-wechat",
-  "version": "0.1.2",
-  "description": "把 Windows 微信新消息播报给桌宠：扩展自己解密并轮询微信本地库，把新消息推进桌宠的事件流，由桌宠决定怎么汇报。",
-  "license": "MIT",
-  "type": "module",
-  "main": "src/index.js",
-  "exports": {
-    ".": "./src/index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "src",
-    "tools",
-    "test",
-    "describe.json",
-    "CHANGELOG.md",
-    "README.md"
-  ],
-  "os": [
-    "win32"
-  ],
-  "engines": {
-    "node": "^22.19.0 || >=24.0.0"
-  },
-  "dependencies": {
-    "better-sqlite3-multiple-ciphers": "^13.0.3",
-    "ws": "^8.21.3"
-  },
-  "keywords": [
-    "cortico-world",
-    "cortico",
-    "wechat",
-    "weixin",
-    "notifier"
-  ],
-  "cortico": {
-    "displayName": "微信消息提示",
-    "kind": "world",
-    "api": 6,
-    "describe": "describe.json",
-    "tags": [
-      "im",
-      "external-setup",
-      "experimental",
-      "sensitive-data"
-    ]
-  },
-  "scripts": {
-    "test": "node --test test/format.test.mjs test/world.test.mjs"
-  }
-}
+{
+  "name": "cortico-world-wechat",
+  "version": "0.1.4",
+  "author": "静音胡闹 <2310468741@qq.com>",
+  "description": "把 Windows 微信新消息播报给桌宠：扩展自己解密并轮询微信本地库，把新消息推进桌宠的事件流，由桌宠决定怎么汇报。",
+  "license": "MIT",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "tools",
+    "test",
+    "describe.json",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "os": [
+    "win32"
+  ],
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "dependencies": {
+    "better-sqlite3-multiple-ciphers": "^13.0.3",
+    "ws": "^8.21.3"
+  },
+  "keywords": [
+    "cortico-world",
+    "cortico",
+    "wechat",
+    "weixin",
+    "notifier"
+  ],
+  "cortico": {
+    "displayName": "微信消息提示",
+    "kind": "world",
+    "api": 6,
+    "describe": "describe.json",
+    "tags": [
+      "im",
+      "external-setup",
+      "experimental",
+      "sensitive-data"
+    ]
+  },
+  "scripts": {
+    "test": "node --test test/format.test.mjs test/world.test.mjs"
+  }
+}

package/src/wechat-db.js

@@ -9,10 +9,10 @@
  * 只读：不写微信库、不动微信进程；解密产物落在自己的缓存目录。
  */
 import { createRequire } from 'node:module';
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, openSync, readSync, closeSync, copyFileSync, renameSync } from 'node:fs';
 import { join, basename } from 'node:path';
 
-import { PAGE_SIZE, decryptPage, decryptFile, readPage1, verifyDbKey } from './wechat-crypto.js';
+import { PAGE_SIZE, decryptPage, decryptFile } from './wechat-crypto.js';
 
 const require = createRequire(import.meta.url);
 
@@ -69,11 +69,17 @@ export function listMessageShards(dbStorage) {
  * 把 -wal 里的加密帧合并进已解密的主库（与上游 _merge_wal 等价）。
  * 帧：24 字节头 + 4096 页，数值全为**大端**；只合并 salt 与 WAL 头一致的帧
  * （checkpoint 会重置 WAL，旧世代帧合并会用过期页覆盖新数据 → 库损坏）。
+ *
+ * ⚠️ 用**临时文件 + 原子替换**：旧实现在正式缓存文件上原地 r+ 覆盖，
+ * 一旦中途被并发读取或异常打断，缓存就变成"半新半旧"的不可用状态，
+ * 并且调用方会每秒重试 → 永久失败（实测踩过）。
  */
 export function mergeWal(decryptedPath, walPath, key, fromFrame = 0) {
   if (!existsSync(decryptedPath) || !existsSync(walPath)) return { applied: 0, frames: 0 };
+  const tempPath = `${decryptedPath}.merge-tmp`;
+  copyFileSync(decryptedPath, tempPath);
   const walFd = openSync(walPath, 'r');
-  const dstFd = openSync(decryptedPath, 'r+');
+  const dstFd = openSync(tempPath, 'r+');
   let applied = 0;
   let last = fromFrame;
   try {
@@ -105,7 +111,7 @@ export function mergeWal(decryptedPath, walPath, key, fromFrame = 0) {
     if (maxPgno > 0) {
       const page1 = Buffer.alloc(PAGE_SIZE);
       readSync(dstFd, page1, 0, PAGE_SIZE, 0);
-      const fileSize = statSync(decryptedPath).size;
+      const fileSize = statSync(tempPath).size;
       const dbPages = Math.ceil(fileSize / PAGE_SIZE);
       const headerPages = page1.readUInt32BE(28);
       const newPages = Math.max(headerPages, maxPgno, dbPages);
@@ -115,11 +121,13 @@ export function mergeWal(decryptedPath, walPath, key, fromFrame = 0) {
         writeFileSync(dstFd, patched, { offset: 0 });
       }
     }
-    return { applied, frames: last };
   } finally {
     closeSync(walFd);
     closeSync(dstFd);
   }
+  // 合并完成才替换正式缓存：中途异常时正式缓存保持原样
+  renameSync(tempPath, decryptedPath);
+  return { applied, frames: last };
 }
 
 /** 读取器：管理"密钥 + 解密缓存 + 增量读消息" */
@@ -130,9 +138,11 @@ export class WeChatReader {
   constructor(options) {
     this.dbStorage = options.dbStorage;
     this.keys = options.keys;           // Map<'contact\\contact.db', Buffer>
-    this.cacheDir = options.cacheDir;
+    // 缓存目录按进程隔离：多个进程（扩展 + 排查脚本）共用同一目录会互相踩
+    // ——一个在 WAL 合并中途写，另一个正好读到半成品，就永久报 "file is not a database"（实测踩过）
+    this.cacheDir = join(options.cacheDir, `p${process.pid}`);
     this.log = options.logger ?? { info: () => {}, warn: () => {}, debug: () => {} };
-    this._stamps = new Map();            // rel -> { mtimeMs, size, walFrames }
+    this._stamps = new Map();            // rel -> { sourceSize, walSize, walFrames }
     mkdirSync(this.cacheDir, { recursive: true });
   }
 
@@ -140,7 +150,16 @@ export class WeChatReader {
     return this.keys.get(rel) ?? null;
   }
 
-  /** 按需解密（含 WAL 合并）；主库或 WAL 变化时增量重做 */
+  /**
+   * 按需解密（含 WAL 合并）；主库或 WAL 变化时增量重做。
+   *
+   * 自愈设计（实测踩过：一次读取失败后每秒重试每秒失败，永久不自愈）：
+   *   ① WAL 合并**不直接改缓存**，先合并到临时文件、验证能打开、才原子替换 ——
+   *      合并中途被打断/读到半成品，都不会污染正式缓存；
+   *   ② 任何一步探测到缓存不可用，就丢弃时间戳与缓存文件，下次全量重建；
+   *   ③ 最坏情况（合并反复失败）退化到"只有主库"的缓存，仍能读到消息——
+   *      少的是最近未 checkpoint 的增量，而不是整个分片废掉。
+   */
   ensureDecrypted(rel) {
     const srcPath = join(this.dbStorage, rel);
     const walPath = `${srcPath}-wal`;
@@ -151,36 +170,56 @@ export class WeChatReader {
     const walStat = existsSync(walPath) ? statSync(walPath) : null;
     const stamp = this._stamps.get(rel);
 
-    const sameMain = stamp && stamp.mtimeMs === srcStat.mtimeMs && stamp.size === srcStat.size;
+    const sameMain = stamp && stamp.sourceSize === srcStat.size;
     const sameWal = stamp && (stamp.walSize ?? 0) === (walStat?.size ?? 0);
-    if (sameMain && sameWal && existsSync(dstPath)) return dstPath;
+    if (sameMain && sameWal && existsSync(dstPath) && this._isUsable(dstPath)) return dstPath;
 
-    if (!sameMain || !existsSync(dstPath)) {
+    // 缓存不可用、或主库大小变了（= 微信做过 checkpoint）：全量重建
+    //
+    // ⚠️ 判断依据是 **size 而不是 mtime**：微信活着时 mtime 几乎每秒都在变
+    //    （WAL 写入/checkpoint 都会碰它），用 mtime 会导致每秒全量解密 20MB。
+    //    内容的新增靠 WAL 增量合并补齐，所以只看 size 既省又能拿到最新消息。
+    if (!sameMain || !existsSync(dstPath) || !this._isUsable(dstPath)) {
+      this._stamps.delete(rel);
       const pages = decryptFile(srcPath, dstPath, key);
       this.log.debug?.(`[reader] 解密 ${rel}（${pages} 页）`);
-      this._stamps.set(rel, { mtimeMs: srcStat.mtimeMs, size: srcStat.size, walSize: 0, walFrames: 0 });
-      this._verifyOrThrow(rel, dstPath);
+      this._stamps.set(rel, { sourceSize: srcStat.size, walSize: 0, walFrames: 0 });
+      if (!this._isUsable(dstPath)) {
+        throw new Error(`解密结果不可用（微信是否正在写入该库？稍后会重试）: ${rel}`);
+      }
     }
+
     if (walStat) {
       const prevFrames = this._stamps.get(rel)?.walFrames ?? 0;
-      const { frames } = mergeWal(dstPath, walPath, key, prevFrames);
-      const current = this._stamps.get(rel) ?? {};
-      this._stamps.set(rel, { ...current, walSize: walStat.size, walFrames: frames });
+      try {
+        const { frames } = mergeWal(dstPath, walPath, key, prevFrames);
+        if (!this._isUsable(dstPath)) {
+          throw new Error('合并 WAL 后缓存不可用，回退到上次可用状态');
+        }
+        const current = this._stamps.get(rel) ?? {};
+        this._stamps.set(rel, { ...current, walSize: walStat.size, walFrames: frames });
+      } catch (error) {
+        // 合并失败不致命：丢掉时间戳，下次全量重建（只损失未 checkpoint 的增量）
+        this.log.warn?.(`[reader] ${rel} WAL 合并失败（下次重建）：${error.message}`);
+        this._stamps.delete(rel);
+      }
     }
     return dstPath;
   }
 
-  /** 解密结果是否真是这个库（防止拿错密钥时静默读出垃圾） */
-  _verifyOrThrow(rel, dstPath) {
-    const page1 = readPage1(dstPath);
-    if (!page1) throw new Error(`解密产物读不到首页: ${rel}`);
-    if (!page1.subarray(0, 16).equals(Buffer.from('SQLite format 3\0', 'latin1'))) {
-      throw new Error(`解密结果不是 SQLite 库（密钥可能已失效）: ${rel}`);
-    }
-    const probe = join(this.dbStorage, rel);
-    const enc = readPage1(probe);
-    if (enc && !verifyDbKey(this.keyFor(rel), enc)) {
-      throw new Error(`密钥已失效（微信可能重新登录过）: ${rel}`);
+  /** 能否被 sqlite 真正打开（只看文件头不够：半成品也可能头是好的） */
+  _isUsable(dbPath) {
+    try {
+      const Sqlite = getDatabase();
+      const db = new Sqlite(dbPath, { readonly: true, fileMustExist: true });
+      try {
+        db.prepare("SELECT count(*) AS c FROM sqlite_master WHERE type='table'").get();
+        return true;
+      } finally {
+        db.close();
+      }
+    } catch {
+      return false;
     }
   }