wowok 2.1.39 → 2.1.40

package/dist/esm/w/messenger/server.d.ts

@@ -1,72 +1,26 @@
-/**
- * Messenger 服务器客户端模块
- *
- * 负责与 Messenger 服务器进行通信：
- * 1. 设备注册和预密钥上传
- * 2. 获取对方公钥包
- * 3. 发送和接收消息
- * 4. 同步会话状态
- */
 import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
 import type { ServerRegisterRequest, ServerRegisterResponse, UploadPreKeysRequest, UploadPreKeysResponse, RemoteBundle, SendMessageRequest, SendMessageResponse, PullMessagesResponse, MessengerConfig, PreKeyStatus, SignedRequest, Empty, AddListRequest, AddGuardListRequest, RemoveListRequest, ClearListRequest, ExistListRequest, ListOperationResponse, UpdateSettingsRequest, GetSettingsResponse } from "./types.js";
 export declare class MessengerServerClient {
     private config;
     constructor(config?: Partial<MessengerConfig>);
-    /**
-     * 注册设备并上传预密钥
-     *
-     * 注意：请求必须包含 wowok 私钥签名，证明地址所有权
-     * 服务器会验证签名并返回详细的上传结果
-     *
-     * 如果身份已存在且密钥一致，会自动追加预密钥，不会报错
-     */
     registerDevice(request: ServerRegisterRequest): Promise<ServerRegisterResponse>;
-    /**
-     * 上传额外的预密钥
-     *
-     * 注意：请求必须包含 wowok 私钥签名
-     * 服务器会验证签名并返回详细的上传结果
-     */
     uploadPreKeys(request: UploadPreKeysRequest): Promise<UploadPreKeysResponse>;
-    /**
-     * 获取对方的密钥包（用于建立会话）
-     *
-     * 安全要求：必须提供签名验证
-     */
     fetchRemoteBundle(userAddress: string, myAddress: string, myPublicKey: string, signatureParams: {
         signatureScheme: string;
         signature: string;
         timestamp: number;
         nonce: string;
     }, _deviceId?: number): Promise<RemoteBundle>;
-    /**
-     * 发送加密消息（支持普通发送和强制发送）
-     */
     sendMessage(request: SendMessageRequest): Promise<SendMessageResponse & {
         guard_list?: string[];
     }>;
-    /**
-     * 拉取消息
-     *
-     * 安全要求：必须提供签名验证
-     * @param userAddress 用户地址（用于URL路径）
-     * @param publicKey 用户公钥（用于服务器验签）
-     * @param signatureParams 签名参数
-     */
     pullMessages(userAddress: string, publicKey: string, signatureParams: {
         signatureScheme: string;
         signature: string;
         timestamp: number;
         nonce: string;
     }, limit?: number): Promise<PullMessagesResponse>;
-    /**
-     * 获取预密钥状态
-     */
     getPrekeyStatus(userAddress: string): Promise<PreKeyStatus>;
-    /**
-     * 确认消息已处理（从服务器删除）
-     * 接收方验证 plaintextHash 后发送 ARK
-     */
     acknowledgeMessages(messageIds: string[], senderPublicKey: string, signatureParams: {
         publicKey: string;
         signatureScheme: SignatureScheme;
@@ -74,69 +28,21 @@ export declare class MessengerServerClient {
         timestamp: number;
         nonce: string;
     }): Promise<void>;
-    /**
-     * 黑名单 - 添加地址
-     */
     addToBlacklist(userAddress: string, signedRequest: SignedRequest<AddListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 黑名单 - 移除地址
-     */
     removeFromBlacklist(userAddress: string, signedRequest: SignedRequest<RemoveListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 黑名单 - 清空
-     */
     clearBlacklist(userAddress: string, signedRequest: SignedRequest<ClearListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 黑名单 - 获取列表
-     */
     getBlacklist(userAddress: string, signedRequest: SignedRequest<Empty>): Promise<string[]>;
-    /**
-     * 黑名单 - 检查存在
-     */
     existInBlacklist(userAddress: string, signedRequest: SignedRequest<ExistListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 好友列表 - 添加地址
-     */
     addToFriendsList(userAddress: string, signedRequest: SignedRequest<AddListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 好友列表 - 移除地址
-     */
     removeFromFriendsList(userAddress: string, signedRequest: SignedRequest<RemoveListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 好友列表 - 清空
-     */
     clearFriendsList(userAddress: string, signedRequest: SignedRequest<ClearListRequest>): Promise<ListOperationResponse>;
-    /**
-     * 好友列表 - 获取列表
-     */
     getFriendsList(userAddress: string, signedRequest: SignedRequest<Empty>): Promise<string[]>;
-    /**
-     * 好友列表 - 检查存在
-     */
     existInFriendsList(userAddress: string, signedRequest: SignedRequest<ExistListRequest>): Promise<ListOperationResponse>;
-    /**
-     * Guard 列表 - 添加
-     */
     addToGuardList(userAddress: string, signedRequest: SignedRequest<AddGuardListRequest>): Promise<ListOperationResponse>;
-    /**
-     * Guard 列表 - 移除
-     */
     removeFromGuardList(userAddress: string, signedRequest: SignedRequest<RemoveListRequest>): Promise<ListOperationResponse>;
-    /**
-     * Guard 列表 - 获取列表
-     */
     getGuardList(userAddress: string, signedRequest: SignedRequest<Empty>): Promise<ListOperationResponse>;
-    /**
-     * 更新用户设置
-     */
     updateSettings(userAddress: string, signedRequest: SignedRequest<UpdateSettingsRequest>): Promise<boolean>;
-    /**
-     * 获取用户设置
-     */
     getSettings(userAddress: string, signedRequest: SignedRequest<Record<string, never>>): Promise<GetSettingsResponse>;
-    /**
-     * 内部方法：列表操作
-     */
     private _listOperation;
 }
 export declare const defaultServerClient: MessengerServerClient;

package/dist/esm/w/messenger/server.js

@@ -1,38 +1,22 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
 import { MessengerError, MessengerErrorCode, DEFAULT_MESSENGER_CONFIG, } from "./types.js";
 export class MessengerServerClient {
     config;
     constructor(config) {
         this.config = { ...DEFAULT_MESSENGER_CONFIG, ...config };
     }
-    /**
-     * 注册设备并上传预密钥
-     *
-     * 注意：请求必须包含 wowok 私钥签名，证明地址所有权
-     * 服务器会验证签名并返回详细的上传结果
-     *
-     * 如果身份已存在且密钥一致，会自动追加预密钥，不会报错
-     */
     async registerDevice(request) {
-        //console.log(`[ServerClient] Sending registration request for ${request.userAddress} to ${this.config.serverUrl}/v1/register`);
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/register`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(request),
             });
-            //console.log(`[ServerClient] Registration response status: ${response.status}`);
             if (!response.ok) {
                 const errorText = await response.text();
-                // 如果是 409 Conflict，可能是身份已存在（需要检查错误信息）
                 if (response.status === 409) {
-                    // 如果错误信息包含 "different key"，说明密钥不一致，这是真正的错误
                     if (errorText.includes("different key")) {
                         throw new MessengerError(MessengerErrorCode.IDENTITY_CONFLICT, `Identity already exists with different key: ${errorText}`);
                     }
-                    // 否则认为是身份已存在（相同密钥），视为成功
-                    //console.log(`[ServerClient] Identity already exists, treating as success`);
                     return {
                         success: true,
                         uploadedCount: 0,
@@ -44,12 +28,7 @@ export class MessengerServerClient {
                 throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Registration failed: ${response.status} ${response.statusText} - ${errorText}`);
             }
             const data = (await response.json());
-            // 检查是否有预密钥上传失败
             if (data.failedPrekeys && data.failedPrekeys.length > 0) {
-                /*console.warn(
-                    `[ServerClient] Some prekeys failed to upload:`,
-                    data.failedPrekeys,
-                );*/
             }
             return {
                 success: data.success,
@@ -66,12 +45,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to register device", error);
         }
     }
-    /**
-     * 上传额外的预密钥
-     *
-     * 注意：请求必须包含 wowok 私钥签名
-     * 服务器会验证签名并返回详细的上传结果
-     */
     async uploadPreKeys(request) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/prekeys/upload`, {
@@ -84,7 +57,6 @@ export class MessengerServerClient {
                 throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to upload prekeys: ${response.status} ${response.statusText} - ${errorText}`);
             }
             const data = (await response.json());
-            // 检查是否有预密钥上传失败
             if (data.failedPrekeys && data.failedPrekeys.length > 0) {
                 throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Some prekeys failed to upload: ${JSON.stringify(data.failedPrekeys)}`);
             }
@@ -103,14 +75,8 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to upload prekeys", error);
         }
     }
-    /**
-     * 获取对方的密钥包（用于建立会话）
-     *
-     * 安全要求：必须提供签名验证
-     */
     async fetchRemoteBundle(userAddress, myAddress, myPublicKey, signatureParams, _deviceId) {
         try {
-            // 构建查询参数
             const queryParams = new URLSearchParams({
                 publicKey: myPublicKey,
                 signatureScheme: signatureParams.signatureScheme,
@@ -126,10 +92,6 @@ export class MessengerServerClient {
                 throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to fetch remote bundle: ${response.statusText}`);
             }
             const bundle = (await response.json());
-            /*console.log(
-                `[SERVER DEBUG] fetchRemoteBundle response:`,
-                JSON.stringify(bundle, null, 2),
-            );*/
             return bundle;
         }
         catch (error) {
@@ -138,9 +100,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to fetch remote bundle", error);
         }
     }
-    /**
-     * 发送加密消息（支持普通发送和强制发送）
-     */
     async sendMessage(request) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/message`, {
@@ -150,13 +109,10 @@ export class MessengerServerClient {
             });
             const responseData = await response.json();
             if (!response.ok) {
-                // 错误响应可能包含 guard_list
-                // 服务器返回格式: { error: { code, message, type } }
                 const errorMessage = responseData?.error?.message ||
                     responseData?.message ||
                     response.statusText;
                 const error = new MessengerError(MessengerErrorCode.SERVER_ERROR, errorMessage);
-                // 附加 guard_list 到错误对象（如果存在）
                 error.guardList =
                     responseData?.error?.guard_list || responseData?.guard_list;
                 throw error;
@@ -169,14 +125,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to send message", error);
         }
     }
-    /**
-     * 拉取消息
-     *
-     * 安全要求：必须提供签名验证
-     * @param userAddress 用户地址（用于URL路径）
-     * @param publicKey 用户公钥（用于服务器验签）
-     * @param signatureParams 签名参数
-     */
     async pullMessages(userAddress, publicKey, signatureParams, limit) {
         try {
             const queryParams = new URLSearchParams({
@@ -194,14 +142,6 @@ export class MessengerServerClient {
                 throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to pull messages: ${response.statusText}`);
             }
             const json = (await response.json());
-            /*console.log(
-                `[ServerClient] 收到服务器响应: ${json.messages.length} 条消息`,
-            );
-            if (json.messages.length > 0) {
-                console.log(
-                    `[ServerClient] 第一条消息 ID: ${json.messages[0].id}`,
-                );
-            }*/
             return json;
         }
         catch (error) {
@@ -210,9 +150,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to pull messages", error);
         }
     }
-    /**
-     * 获取预密钥状态
-     */
     async getPrekeyStatus(userAddress) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/prekeys/${userAddress}/status`);
@@ -233,10 +170,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to get prekey status", error);
         }
     }
-    /**
-     * 确认消息已处理（从服务器删除）
-     * 接收方验证 plaintextHash 后发送 ARK
-     */
     async acknowledgeMessages(messageIds, senderPublicKey, signatureParams) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/messages/ack`, {
@@ -262,27 +195,15 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to acknowledge messages", error);
         }
     }
-    /**
-     * 黑名单 - 添加地址
-     */
     async addToBlacklist(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`, signedRequest, "POST");
     }
-    /**
-     * 黑名单 - 移除地址
-     */
     async removeFromBlacklist(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`, signedRequest, "DELETE");
     }
-    /**
-     * 黑名单 - 清空
-     */
     async clearBlacklist(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/clear`, signedRequest, "POST");
     }
-    /**
-     * 黑名单 - 获取列表
-     */
     async getBlacklist(userAddress, signedRequest) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/get`, {
@@ -303,33 +224,18 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to get blacklist", error);
         }
     }
-    /**
-     * 黑名单 - 检查存在
-     */
     async existInBlacklist(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/exist`, signedRequest, "POST");
     }
-    /**
-     * 好友列表 - 添加地址
-     */
     async addToFriendsList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`, signedRequest, "POST");
     }
-    /**
-     * 好友列表 - 移除地址
-     */
     async removeFromFriendsList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`, signedRequest, "DELETE");
     }
-    /**
-     * 好友列表 - 清空
-     */
     async clearFriendsList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/clear`, signedRequest, "POST");
     }
-    /**
-     * 好友列表 - 获取列表
-     */
     async getFriendsList(userAddress, signedRequest) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/get`, {
@@ -348,27 +254,15 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to get friends list", error);
         }
     }
-    /**
-     * 好友列表 - 检查存在
-     */
     async existInFriendsList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/exist`, signedRequest, "POST");
     }
-    /**
-     * Guard 列表 - 添加
-     */
     async addToGuardList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`, signedRequest, "POST");
     }
-    /**
-     * Guard 列表 - 移除
-     */
     async removeFromGuardList(userAddress, signedRequest) {
         return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`, signedRequest, "DELETE");
     }
-    /**
-     * Guard 列表 - 获取列表
-     */
     async getGuardList(userAddress, signedRequest) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list/get`, {
@@ -387,9 +281,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to get guard list", error);
         }
     }
-    /**
-     * 更新用户设置
-     */
     async updateSettings(userAddress, signedRequest) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/settings`, {
@@ -410,9 +301,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to update settings", error);
         }
     }
-    /**
-     * 获取用户设置
-     */
     async getSettings(userAddress, signedRequest) {
         try {
             const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/settings/get`, {
@@ -432,9 +320,6 @@ export class MessengerServerClient {
             throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, "Failed to get settings", error);
         }
     }
-    /**
-     * 内部方法：列表操作
-     */
     async _listOperation(url, signedRequest, method = "POST") {
         try {
             const response = await fetch(url, {
@@ -455,6 +340,4 @@ export class MessengerServerClient {
         }
     }
 }
-// 导出单例
 export const defaultServerClient = new MessengerServerClient();
-//# sourceMappingURL=server.js.map

package/dist/esm/w/messenger/session.d.ts

@@ -20,64 +20,18 @@ export declare class MessengerSession {
     private config;
     private identity;
     constructor(userAddress: string, config?: Partial<MessengerConfig>);
-    /**
-     * 获取或创建本地身份
-     *
-     * 从 wowok 账户的 ED25519 私钥确定性派生 X25519 密钥对，
-     * 确保恢复钱包后加密身份不变。
-     */
     ensureIdentity(userAddress?: string): Promise<LocalIdentity>;
-    /**
-     * 从公钥确定性派生注册 ID
-     * 确保同一账户的注册 ID 始终相同
-     */
     private deriveRegistrationId;
-    /**
-     * 注册设备到服务器
-     */
     registerDevice(userAddress: string): Promise<void>;
-    /**
-     * 验证注册是否完成
-     * 轮询检查服务器是否已存在该用户
-     */
     private verifyRegistrationComplete;
-    /**
-     * 检查设备是否已在服务器上注册
-     * 通过查询服务器上的预密钥状态来判断
-     */
     isDeviceRegistered(userAddress: string): Promise<boolean>;
-    /**
-     * 生成预密钥批次（One-Time PreKeys）
-     */
     private generatePreKeyBatch;
-    /**
-     * 确保服务器上有足够可用的预密钥
-     */
     ensurePreKeys(userAddress: string, force?: boolean): Promise<void>;
-    /**
-     * 生成随机 nonce
-     */
     private generateNonce;
-    /**
-     * 建立与对方的会话
-     */
     establishSession(myAddress: string, peerAddress: string, peerDeviceId?: number, remoteBundle?: RemoteBundle): Promise<void>;
-    /**
-     * 加密消息
-     * 【改进】使用发送会话key，与接收会话分离
-     */
     encryptMessage(myAddress: string, peerAddress: string, plaintext: string, peerDeviceId?: number): Promise<EncryptedMessage>;
-    /**
-     * 解密消息
-     */
     decryptMessage(myAddress: string, peerAddress: string, ciphertext: ArrayBuffer, msgType: number, peerDeviceId?: number): Promise<string>;
-    /**
-     * 获取本地身份公钥
-     */
     getIdentityKey(): Promise<string>;
-    /**
-     * 获取注册 ID
-     */
     getRegistrationId(): Promise<number>;
 }
 export interface SessionSnapshot {
@@ -87,17 +41,8 @@ export interface SessionSnapshot {
 export declare class SessionStateManager {
     private store;
     constructor(store: SignalProtocolStorage);
-    /**
-     * 保存会话快照
-     */
     snapshotSession(sessionKey: string): Promise<SessionSnapshot>;
-    /**
-     * 回滚会话状态
-     */
     rollbackSession(sessionKey: string, snapshot: SessionSnapshot): Promise<void>;
-    /**
-     * 提交会话状态（保留新会话）
-     */
     commitSession(_sessionKey: string): Promise<void>;
 }
 export interface DecryptResult {
@@ -112,31 +57,10 @@ export declare class DecryptionEngine {
     private sessionManager;
     private store;
     constructor(store: SignalProtocolStorage);
-    /**
-     * 【核心改进】获取接收会话key
-     * 使用 recv: 前缀区分接收会话和发送会话
-     */
     private getRecvSessionKey;
-    /**
-     * 【核心改进】获取发送会话key
-     * 使用 send: 前缀区分发送会话和接收会话
-     */
     private getSendSessionKey;
-    /**
-     * 统一解密入口
-     * 【改进】使用方向区分的sessionKey管理双向会话
-     */
     decryptMessage(myAddress: string, peerAddress: string, ciphertext: ArrayBuffer, msgType: number, peerDeviceId?: number): Promise<DecryptResult>;
-    /**
-     * 处理 PREKEY_MESSAGE
-     * 【核心改进】无论大小地址，都保存接收会话
-     * 小地址优先原则只影响发送会话，不影响接收会话
-     */
     private handlePreKeyMessage;
-    /**
-     * 处理 WHISPER_MESSAGE
-     * 【改进】使用接收会话key查找会话
-     */
     private handleWhisperMessage;
     private arrayBufferToBinary;
 }