wowok 2.1.39 → 2.1.40

package/dist/cjs/w/messenger/storage.js

@@ -1,25 +1,10 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Messenger 存储模块
- *
- * 使用与 wowok SDK 相同的 SQLite 存储方案
- * 数据库文件：messenger.db（位于 ~/.wow/ 目录）
- *
- * 存储内容：
- * 1. Signal Protocol 状态（身份密钥、预密钥、会话）
- * 2. 消息记录
- * 3. 会话状态（Merkle Tree 根哈希等）
- */
 import Database from "better-sqlite3";
 import * as path from "path";
 import * as fs from "fs";
 import { getWowDir } from "../local/util.js";
-// 动态获取数据目录（支持测试时通过环境变量覆盖）
 function getWowDirDynamic() {
     return getWowDir();
 }
-// 按用户分库的数据库目录（动态计算）
 function getMessengerDbDir() {
     return path.join(getWowDirDynamic(), "messenger");
 }
@@ -28,9 +13,7 @@ function ensureDirExists(dir) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
-// 获取用户特定的数据库路径
 function getUserDbPath(userAddress) {
-    // 使用用户地址的前16位作为数据库文件名
     const shortAddress = userAddress
         .toLowerCase()
         .replace(/^0x/, "")
@@ -39,35 +22,26 @@ function getUserDbPath(userAddress) {
     ensureDirExists(messengerDbDir);
     return path.join(messengerDbDir, `${shortAddress}.db`);
 }
-// 获取全局数据库路径（用于 MessengerManager 状态和 SSE 锁）
 function getGlobalDbPath() {
     const messengerDbDir = getMessengerDbDir();
     ensureDirExists(messengerDbDir);
     return path.join(messengerDbDir, "global.db");
 }
-// 用户数据库实例缓存
 const userDbInstances = new Map();
-// 全局数据库实例缓存
 let globalDbInstance = null;
 function getDatabase(userAddress) {
     if (!userAddress) {
         throw new Error("userAddress is required to get database");
     }
-    // 检查缓存
     const cached = userDbInstances.get(userAddress);
     if (cached) {
         return cached;
     }
-    // 创建新连接
     const dbPath = getUserDbPath(userAddress);
     const db = new Database(dbPath);
-    // 启用 WAL 模式以支持多进程访问
     db.pragma("journal_mode = WAL");
-    // 设置同步模式为 NORMAL 以平衡性能和安全性
     db.pragma("synchronous = NORMAL");
-    // 启用内存共享缓存
     db.pragma("cache_size = -64000");
-    // Signal Protocol 存储表
     db.exec(`
     CREATE TABLE IF NOT EXISTS signal_store (
       store_type TEXT NOT NULL,
@@ -78,7 +52,6 @@ function getDatabase(userAddress) {
     );
     CREATE INDEX IF NOT EXISTS idx_signal_store_type ON signal_store(store_type);
   `);
-    // 消息表 - 分开创建，先不创建索引
     try {
         db.exec(`
       CREATE TABLE IF NOT EXISTS messages (
@@ -109,71 +82,57 @@ function getDatabase(userAddress) {
     `);
     }
     catch (e) {
-        // 表可能已存在，忽略错误
     }
-    // 安全地添加新列（如果还不存在）
     try {
         db.exec("ALTER TABLE messages ADD COLUMN guard_address TEXT");
     }
     catch (e) {
-        // 列可能已存在，忽略错误
     }
     try {
         db.exec("ALTER TABLE messages ADD COLUMN passport_address TEXT");
     }
     catch (e) {
-        // 列可能已存在，忽略错误
     }
     try {
         db.exec("ALTER TABLE messages ADD COLUMN last_received_leaf_index INTEGER");
     }
     catch (e) {
-        // 列可能已存在，忽略错误
     }
     try {
         db.exec("ALTER TABLE messages ADD COLUMN viewed_at INTEGER");
     }
     catch (e) {
-        // 列可能已存在，忽略错误
     }
-    // 安全地创建索引
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_from_to ON messages(from_address, to_address)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_status ON messages(status)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_leaf ON messages(leaf_index)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_server_ts ON messages(server_timestamp)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
     try {
         db.exec("CREATE INDEX IF NOT EXISTS idx_messages_received_at ON messages(received_at)");
     }
     catch (e) {
-        // 索引可能已存在，忽略错误
     }
-    // 会话状态表
     db.exec(`
     CREATE TABLE IF NOT EXISTS session_states (
       session_id TEXT PRIMARY KEY,
@@ -190,86 +149,63 @@ function getDatabase(userAddress) {
     );
     CREATE INDEX IF NOT EXISTS idx_session_my_peer ON session_states(my_address, peer_address);
   `);
-    // 缓存实例
     userDbInstances.set(userAddress, db);
     return db;
 }
-// 获取全局数据库实例（用于 MessengerManager 状态和 SSE 锁）
 function getGlobalDatabase() {
     if (globalDbInstance) {
         return globalDbInstance;
     }
-    // 创建新连接
     const dbPath = getGlobalDbPath();
     const db = new Database(dbPath);
-    // 启用 WAL 模式以支持多进程访问
     db.pragma("journal_mode = WAL");
-    // 设置同步模式为 NORMAL 以平衡性能和安全性
     db.pragma("synchronous = NORMAL");
-    // 设置缓存大小
     db.pragma("cache_size = -10000");
-    // 设置忙等待超时（5秒）
     db.pragma("busy_timeout = 5000");
-    // 缓存实例
     globalDbInstance = db;
     return db;
 }
-/**
- * 重置数据库连接
- * 用于测试时清理数据后重新创建连接
- */
 export function resetDbConnection() {
-    // 先切换到 DELETE 模式，这样就不会有 WAL 文件
     for (const [_, db] of userDbInstances) {
         try {
             db.pragma("journal_mode = DELETE");
         }
         catch (e) {
-            // 忽略模式切换错误
         }
     }
-    // 关闭所有用户的数据库连接
     for (const [_, db] of userDbInstances) {
         try {
             db.close();
         }
         catch (e) {
-            // 忽略关闭错误
         }
     }
     userDbInstances.clear();
-    // 关闭全局数据库连接
     if (globalDbInstance) {
         try {
             globalDbInstance.pragma("journal_mode = DELETE");
         }
         catch (e) {
-            // 忽略模式切换错误
         }
         try {
             globalDbInstance.close();
         }
         catch (e) {
-            // 忽略关闭错误
         }
         globalDbInstance = null;
     }
 }
-// 注册进程退出时的清理函数
 process.on("exit", () => {
     resetDbConnection();
 });
-// 处理 SIGINT (Ctrl+C)
 process.on("SIGINT", () => {
     resetDbConnection();
     process.exit(0);
 });
-// 处理 SIGTERM
 process.on("SIGTERM", () => {
     resetDbConnection();
     process.exit(0);
 });
-// ========== Signal Protocol 存储 ==========
 const STORE_TYPES = {
     IDENTITY: "identity",
     REGISTRATION_ID: "registration_id",
@@ -297,10 +233,6 @@ function bufferEqual(a, b) {
     }
     return true;
 }
-/**
- * Signal Protocol SQLite 存储
- * 兼容 libsignal-protocol-typescript 的 StorageType 接口
- */
 export class SignalProtocolStorage {
     storePrefix;
     userAddress;
@@ -311,7 +243,6 @@ export class SignalProtocolStorage {
     get db() {
         return getDatabase(this.userAddress);
     }
-    // Identity
     async setIdentity(identity, registrationId) {
         const persisted = {
             pubKey: arrayBufferToBase64(identity.pubKey),
@@ -334,7 +265,6 @@ export class SignalProtocolStorage {
         const value = this.getValue(STORE_TYPES.REGISTRATION_ID);
         return value ? parseInt(value, 10) : undefined;
     }
-    // Identity verification
     async isTrustedIdentity(identifier, identityKey) {
         const key = `${STORE_TYPES.IDENTITIES}:${identifier}`;
         const existing = this.getValue(key);
@@ -356,7 +286,6 @@ export class SignalProtocolStorage {
         const value = this.getValue(key);
         return value ? base64ToArrayBuffer(value) : undefined;
     }
-    // PreKeys
     async loadPreKey(keyId) {
         const key = `${STORE_TYPES.PREKEYS}:${keyId}`;
         const value = this.getValue(key);
@@ -380,7 +309,6 @@ export class SignalProtocolStorage {
         const key = `${STORE_TYPES.PREKEYS}:${keyId}`;
         this.delValue(key);
     }
-    // Signed PreKeys
     async loadSignedPreKey(keyId) {
         const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
         const value = this.getValue(key);
@@ -404,14 +332,12 @@ export class SignalProtocolStorage {
         const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
         this.delValue(key);
     }
-    // Signed PreKeys with Signature (new methods)
     async loadSignedPreKeyWithSignature(keyId) {
         const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
         const value = this.getValue(key);
         if (!value)
             return undefined;
         const persisted = JSON.parse(value);
-        // 检查必需的字段是否存在
         if (!persisted.pubKey || !persisted.privKey || !persisted.signature) {
             console.warn(`[Storage] SignedPreKey ${keyId} has missing fields, treating as not found`);
             return undefined;
@@ -431,32 +357,21 @@ export class SignalProtocolStorage {
         };
         this.putValue(key, JSON.stringify(persisted));
     }
-    // Sessions
-    /**
-     * 【核心改进】加载会话，支持发送/接收会话映射
-     * encodedAddress 格式: "peerAddress.deviceId"
-     * 我们会同时检查默认key和带前缀的key
-     */
     async loadSession(encodedAddress) {
         const defaultKey = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
-        // 首先检查默认key
         const defaultValue = this.getValue(defaultKey);
         if (defaultValue) {
             return defaultValue;
         }
-        // 如果没有默认key，检查是否是发送/接收key格式
-        // 格式: send:peerAddress.deviceId 或 recv:peerAddress.deviceId
         if (encodedAddress.startsWith("send:") ||
             encodedAddress.startsWith("recv:")) {
             return undefined;
         }
-        // 尝试加载发送会话
         const sendKey = `${STORE_TYPES.SESSIONS}:send:${encodedAddress}`;
         const sendValue = this.getValue(sendKey);
         if (sendValue) {
             return sendValue;
         }
-        // 尝试加载接收会话
         const recvKey = `${STORE_TYPES.SESSIONS}:recv:${encodedAddress}`;
         const recvValue = this.getValue(recvKey);
         if (recvValue) {
@@ -464,36 +379,24 @@ export class SignalProtocolStorage {
         }
         return undefined;
     }
-    /**
-     * 【关键修复】保存会话时，如果是默认key格式，同时保存到接收会话key
-     * 这样Signal Protocol的SessionCipher保存的会话可以被我们的recv:key找到
-     */
     async storeSession(encodedAddress, record) {
-        // 保存到请求的key
         const key = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
         this.putValue(key, record);
-        // 【关键】如果是默认key格式（不是send:/recv:前缀），同时保存到recv:key
-        // 这样我们的解密逻辑使用recv:key时可以找到会话
         if (!encodedAddress.startsWith("send:") &&
             !encodedAddress.startsWith("recv:")) {
             const recvKey = `${STORE_TYPES.SESSIONS}:recv:${encodedAddress}`;
             this.putValue(recvKey, record);
         }
     }
-    /**
-     * 【关键修复】删除会话时，同时删除对应的recv:key
-     */
     async removeSession(encodedAddress) {
         const key = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
         this.delValue(key);
-        // 同时删除recv:key（如果存在）
         if (!encodedAddress.startsWith("send:") &&
             !encodedAddress.startsWith("recv:")) {
             const recvKey = `${STORE_TYPES.SESSIONS}:recv:${encodedAddress}`;
             this.delValue(recvKey);
         }
     }
-    // Meta
     async getMeta() {
         const value = this.getValue(STORE_TYPES.META);
         if (!value)
@@ -514,7 +417,6 @@ export class SignalProtocolStorage {
             return Number(id);
         });
     }
-    // Private helpers
     getValue(key) {
         const row = this.db
             .prepare("SELECT value FROM signal_store WHERE store_type = ? AND key = ?")
@@ -538,7 +440,6 @@ export class SignalProtocolStorage {
             .run(this.storePrefix, key);
     }
 }
-// ========== 消息存储 ==========
 export class MessageStorage {
     userAddress;
     constructor(userAddress) {
@@ -548,7 +449,6 @@ export class MessageStorage {
         return getDatabase(this.userAddress);
     }
     saveMessage(message) {
-        // 如果是接收消息且没有 receivedAt，设置当前时间
         const receivedAt = message.direction === "received" && !message.receivedAt
             ? Date.now()
             : message.receivedAt;
@@ -667,14 +567,6 @@ export class MessageStorage {
     `)
             .run(...values);
     }
-    /**
-     * 更新消息查看状态
-     * 将消息标记为已查看，设置 viewed_at 为当前时间戳
-     *
-     * @param messageId 消息 ID
-     * @param viewedAt 查看时间戳（可选，默认当前时间）
-     * @returns 是否更新成功
-     */
     updateMessageViewed(messageId, viewedAt) {
         const timestamp = viewedAt ?? Date.now();
         const result = this.db
@@ -686,13 +578,6 @@ export class MessageStorage {
             .run(timestamp, messageId);
         return result.changes > 0;
     }
-    /**
-     * 批量更新消息查看状态
-     *
-     * @param messageIds 消息 ID 列表
-     * @param viewedAt 查看时间戳（可选，默认当前时间）
-     * @returns 成功更新的消息数量
-     */
     updateMessagesViewed(messageIds, viewedAt) {
         if (messageIds.length === 0)
             return 0;
@@ -707,12 +592,6 @@ export class MessageStorage {
             .run(timestamp, ...messageIds);
         return result.changes;
     }
-    /**
-     * 获取用户的所有消息
-     *
-     * @param userAddress 用户地址
-     * @returns 所有相关消息（发送和接收的）
-     */
     getAllMessages(userAddress) {
         const userAddrLower = userAddress.toLowerCase();
         const rows = this.db
@@ -724,12 +603,6 @@ export class MessageStorage {
             .all(userAddrLower, userAddrLower);
         return rows.map((r) => this.rowToMessage(r));
     }
-    /**
-     * 通过消息 ID 获取消息
-     *
-     * @param messageId 消息 ID
-     * @returns 消息对象或 undefined
-     */
     getMessageById(messageId) {
         const row = this.db
             .prepare(`
@@ -741,30 +614,17 @@ export class MessageStorage {
             return undefined;
         return this.rowToMessage(row);
     }
-    /**
-     * 更新消息 ID（用于 Guard 消息确认后更新 messageId）
-     *
-     * 由于 message_id 是主键，需要通过删除旧记录并插入新记录来实现
-     *
-     * @param oldMessageId 旧消息 ID（internal_id）
-     * @param newMessageId 新消息 ID（正式的 message_id）
-     * @param updates 可选的更新字段
-     * @returns 是否成功更新
-     */
     updateMessageId(oldMessageId, newMessageId, updates) {
         const row = this.db
             .prepare("SELECT * FROM messages WHERE message_id = ?")
             .get(oldMessageId);
         if (!row)
             return false;
-        // 辅助函数：获取更新值，优先使用 updates 中的值，但不使用 ?? 避免改写数据
-        // 如果 updates 中有定义该字段（包括 null），使用 updates 的值；否则使用原值
         const getUpdatedValue = (updateValue, originalValue) => {
             if (updateValue !== undefined)
                 return updateValue;
             return originalValue === null ? undefined : originalValue;
         };
-        // 构建更新后的消息对象
         const message = {
             messageId: newMessageId,
             fromAddress: row.from_address,
@@ -799,13 +659,10 @@ export class MessageStorage {
             receivedAt: row.received_at === null ? undefined : row.received_at,
             viewedAt: row.viewed_at === null ? undefined : row.viewed_at,
         };
-        // 使用事务确保原子性
         const transaction = this.db.transaction(() => {
-            // 删除旧记录
             this.db
                 .prepare("DELETE FROM messages WHERE message_id = ?")
                 .run(oldMessageId);
-            // 插入新记录
             this.saveMessage(message);
         });
         try {
@@ -813,7 +670,6 @@ export class MessageStorage {
             return true;
         }
         catch (error) {
-            //console.error("Failed to update message ID:", error);
             return false;
         }
     }
@@ -865,20 +721,7 @@ export class MessageStorage {
             viewedAt: row.viewed_at === null ? undefined : row.viewed_at,
         };
     }
-    /**
-     * 获取最后收到的消息序号（用于消息同步确认）
-     *
-     * 查询指定会话中，用户作为接收者时，发送者最后收到的消息序号
-     * 用于在发送新消息时，告诉对方我已经收到了哪些消息
-     *
-     * @param myAddress 当前用户地址
-     * @param peerAddress 对方地址
-     * @returns 最后收到的消息序号（leafIndex），如果没有则返回 -1
-     */
     getLastReceivedLeafIndex(myAddress, peerAddress) {
-        // 查询从 peerAddress 发送给 myAddress 的消息中，
-        // 最大的 leaf_index（这是我作为接收方，已经解密成功的对方发来的消息的最大序号）
-        // 注意：from_address 和 to_address 已经确定了消息方向，无需检查 direction 字段
         const myAddrLower = myAddress.toLowerCase();
         const peerAddrLower = peerAddress.toLowerCase();
         const row = this.db
@@ -893,7 +736,6 @@ export class MessageStorage {
         return row?.max_index ?? -1;
     }
 }
-// ========== 会话状态存储 ==========
 export class SessionStateStorage {
     userAddress;
     constructor(userAddress) {
@@ -965,11 +807,6 @@ export class SessionStateStorage {
         return state?.currentRoot ?? "0".repeat(64);
     }
 }
-/**
- * MessengerManager 持久化存储类
- *
- * 使用 SQLite 存储 MessengerManager 的配置和状态
- */
 export class MessengerPersistStorage {
     initialized = false;
     get db() {
@@ -980,9 +817,6 @@ export class MessengerPersistStorage {
         }
         return db;
     }
-    /**
-     * 初始化存储表
-     */
     initTable(db) {
         db.exec(`
 			CREATE TABLE IF NOT EXISTS messenger_manager_state (
@@ -1013,12 +847,6 @@ export class MessengerPersistStorage {
 			CREATE INDEX IF NOT EXISTS idx_polling_lock_heartbeat ON polling_connection_locks(last_heartbeat);
 		`);
     }
-    /**
-     * 保存 Messenger 配置和账号信息
-     *
-     * @param instanceId 实例标识（用于区分不同的 MessengerManager 实例）
-     * @param state 要保存的状态
-     */
     saveState(instanceId, state) {
         const data = JSON.stringify(state);
         const now = Date.now();
@@ -1032,12 +860,6 @@ export class MessengerPersistStorage {
 			`)
             .run(instanceId, data, now);
     }
-    /**
-     * 加载 Messenger 配置和账号信息
-     *
-     * @param instanceId 实例标识
-     * @returns 保存的状态，如果不存在返回 null
-     */
     loadState(instanceId) {
         const row = this.db
             .prepare("SELECT state_data FROM messenger_manager_state WHERE instance_id = ?")
@@ -1048,23 +870,14 @@ export class MessengerPersistStorage {
             return JSON.parse(row.state_data);
         }
         catch (error) {
-            //console.error("Failed to parse persisted state:", error);
             return null;
         }
     }
-    /**
-     * 删除保存的状态
-     *
-     * @param instanceId 实例标识
-     */
     deleteState(instanceId) {
         this.db
             .prepare("DELETE FROM messenger_manager_state WHERE instance_id = ?")
             .run(instanceId);
     }
-    /**
-     * 获取所有实例ID列表
-     */
     getAllInstanceIds() {
         const rows = this.db
             .prepare("SELECT instance_id FROM messenger_manager_state ORDER BY updated_at DESC")
@@ -1074,12 +887,6 @@ export class MessengerPersistStorage {
     get processId() {
         return `pid_${process.pid}_${Date.now()}`;
     }
-    /**
-     * 尝试获取指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否成功获取锁
-     */
     tryAcquireSSELock(accountAddress, instanceId) {
         const now = Date.now();
         const heartbeatTimeout = 15000;
@@ -1119,11 +926,6 @@ export class MessengerPersistStorage {
             return false;
         }
     }
-    /**
-     * 更新 SSE 连接锁的心跳
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     updateSSELockHeartbeat(accountAddress, instanceId) {
         const now = Date.now();
         try {
@@ -1135,11 +937,6 @@ export class MessengerPersistStorage {
             console.warn("Failed to update SSE lock heartbeat:", error);
         }
     }
-    /**
-     * 释放指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     releaseSSELock(accountAddress, instanceId) {
         try {
             this.db
@@ -1150,24 +947,12 @@ export class MessengerPersistStorage {
             console.warn("Failed to release SSE lock:", error);
         }
     }
-    /**
-     * 检查是否持有指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否持有锁
-     */
     holdsSSELock(accountAddress, instanceId) {
         const row = this.db
             .prepare("SELECT * FROM sse_connection_locks WHERE account_address = ? AND instance_id = ?")
             .get(accountAddress.toLowerCase(), instanceId);
         return !!row;
     }
-    /**
-     * 尝试获取指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否成功获取锁
-     */
     tryAcquirePollingLock(accountAddress, instanceId) {
         const now = Date.now();
         const heartbeatTimeout = 60000;
@@ -1207,11 +992,6 @@ export class MessengerPersistStorage {
             return false;
         }
     }
-    /**
-     * 更新 Polling 连接锁的心跳
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     updatePollingLockHeartbeat(accountAddress, instanceId) {
         const now = Date.now();
         try {
@@ -1223,11 +1003,6 @@ export class MessengerPersistStorage {
             console.warn("Failed to update polling lock heartbeat:", error);
         }
     }
-    /**
-     * 释放指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     releasePollingLock(accountAddress, instanceId) {
         try {
             this.db
@@ -1238,12 +1013,6 @@ export class MessengerPersistStorage {
             console.warn("Failed to release polling lock:", error);
         }
     }
-    /**
-     * 检查是否持有指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否持有锁
-     */
     holdsPollingLock(accountAddress, instanceId) {
         const row = this.db
             .prepare("SELECT * FROM polling_connection_locks WHERE account_address = ? AND instance_id = ?")
@@ -1251,6 +1020,4 @@ export class MessengerPersistStorage {
         return !!row;
     }
 }
-// 默认持久化存储实例
 export const defaultPersistStorage = new MessengerPersistStorage();
-//# sourceMappingURL=storage.js.map