lightclawbot 1.2.3 → 1.2.6-beta.0

package/dist/src/utils/common.js

@@ -1,4 +1,7 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { X_PRODUCT } from '../config.js';
+import { resolveOpenClawHome } from '../history/session-store.js';
 /**
  * 将长文本按指定长度拆分为多个文本块。
  *
@@ -47,13 +50,15 @@ export function buildAuthHeaders(apiKey) {
     };
 }
 /**
- * 统一的信号发送出口，收敛 typing / stream / tool 控制帧的构造逻辑。
+ * 统一的信号发送出口，收敛 typing / stream / tool / usage 控制帧的构造逻辑。
  *
  * - typing_start 不带 replyToMsgId（协议要求）；其余帧都携带。
- * - extra 用于透传 kind 相关字段（如 tool_start 的 toolName/toolPhase、tool_end 的 toolIsError）。
+ * - topLevelExtra 用于透传顶层 kind 相关字段（如 tool_start 的 toolName/toolPhase、tool_end 的 toolIsError）。
+ * - innerExtra 用于在 PrivateMessageData.extra 内追加自定义字段（如 usage 帧的 usage 对象）。
+ *   chatId 始终由本函数管理，调用方无需也不能在 innerExtra 中传 chatId（会被覆盖）。
  */
-export function emitSignal(ctx, kind, content = '', extra) {
-    const { emitter, targetId, replyMsgId, originalMsgId, agentId } = ctx;
+export function emitSignal(ctx, kind, content = '', topLevelExtra, innerExtra) {
+    const { emitter, targetId, replyMsgId, originalMsgId, agentId, chatId } = ctx;
     return emitter.emit({
         msgId: replyMsgId,
         from: emitter.botClientId,
@@ -62,7 +67,157 @@ export function emitSignal(ctx, kind, content = '', extra) {
         timestamp: Date.now(),
         kind,
         ...(kind !== 'typing_start' ? { replyToMsgId: originalMsgId } : {}),
-        ...extra,
+        ...topLevelExtra,
         agentId,
+        // chatId 始终位于 extra.chatId；innerExtra 在前展开，确保 chatId 不被覆盖
+        extra: { ...(innerExtra ?? {}), chatId: chatId ?? '' },
     });
 }
+/**
+ * 构建 chats.json 的绝对路径：
+ * `~/.openclaw/agents/<agentId>/chats/<userId>/chats.json`
+ */
+export function resolveChatsFilePath(agentId, userId) {
+    const home = resolveOpenClawHome();
+    return path.join(home, 'agents', agentId, 'chats', userId, 'chats.json');
+}
+/**
+ * 读取 chats.json 并返回 chats 列表（**纯只读**，无任何文件落盘副作用）。
+ *
+ * - 文件不存在 → 返回空数组
+ * - JSON 解析失败或结构不合法 → 返回空数组
+ * - 合法记录按 `updatedAt` 倒序排序，未提供则按 `createdAt` 兜底
+ *
+ */
+export function readChatsFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    if (!raw.trim())
+        return [];
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.chats))
+        return [];
+    // 过滤出字段合法的记录
+    const valid = parsed.chats.filter((c) => !!c &&
+        typeof c.chatId === 'string' &&
+        typeof c.title === 'string' &&
+        typeof c.createdAt === 'number' &&
+        typeof c.updatedAt === 'number');
+    // 按 updatedAt 倒序，便于前端直接渲染
+    return valid.sort((a, b) => (b.updatedAt ?? b.createdAt) - (a.updatedAt ?? a.createdAt));
+}
+/**
+ * 读取 chats.json；若文件不存在则**兜底创建一条 chatId='' 的默认对话**并落盘。
+ *
+ * 与 {@link readChatsFile} 的差异：本函数有写盘副作用，专供"必须保证存在默认对话
+ * 兜底条目"的调用方（典型场景：sessionId 登记入口 ensureSessionInHistory）。
+ *
+ * 拆分原因：原 readChatsFile 兼任只读与兜底创建两种语义，导致 history:request 等
+ * 纯查询路径在用户尚未发任何消息前就把 chats.json 写到磁盘上，违反单一职责。
+ *
+ * 行为：
+ *   - 文件不存在 → 落盘 [{ chatId: '', title: '默认会话', ... }] 并返回；
+ *   - 文件存在但解析失败 / 结构不合法 → 沿用 readChatsFile 的容错（返回 []，不创建）；
+ *   - 文件存在但内容合法 → 等价于 readChatsFile。
+ */
+export function readChatsFileOrInitDefault(filePath) {
+    if (!fs.existsSync(filePath)) {
+        const now = Date.now();
+        const defaultChat = {
+            chatId: '',
+            title: '默认会话',
+            createdAt: now,
+            updatedAt: now,
+            titleLocked: false,
+            pinned: false,
+            sessionIdHistory: [],
+        };
+        writeChatsFile(filePath, [defaultChat]);
+        return [defaultChat];
+    }
+    return readChatsFile(filePath);
+}
+/**
+ * 将 chats 列表原子写入 `chats.json`。
+ *
+ * 写入策略：
+ *   1. 目录不存在时逐级创建（recursive: true）
+ *   2. 先写入同目录下的 `.tmp` 文件，再 rename 覆盖目标，
+ *      避免写入过程中进程崩溃导致 json 文件损坏
+ *   3. schema 固定 `version: 1`，为未来平滑升级预留字段
+ *
+ * @param filePath 目标 chats.json 绝对路径
+ * @param chats    完整的 ChatMeta 列表（调用方自行保证顺序与合法性）
+ */
+export function writeChatsFile(filePath, chats) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const payload = { version: 1, chats };
+    const tmpPath = `${filePath}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, filePath);
+}
+/**
+ * 把当前生效的 sessionId 幂等地登记到 `chats.json` 中对应 chatId 的 `sessionIdHistory` 数组。
+ *
+ * 语义说明：
+ *   - sessionIdHistory 记录该 chat 见过的所有 sessionId（含当前在用），按时间序末尾追加；
+ *   - 同一 sessionId 若已存在则跳过（幂等，不会重复 push）；
+ *   - 列表最后一项 ≈ 该 chat 当前在用的 sessionId（前提是调用方在每次消息进入时都调用本函数）。
+ *
+ * 关于 chatId 为空（''）的处理：
+ *   - 空 chatId 是**合法**的"默认对话"会话标识——`readChatsFile` 在 chats.json
+ *     不存在时会主动写入一条 `chatId: ''` 的兜底记录；
+ *   - 因此本函数对空 chatId 同样登记，目标条目就是 `chatId === ''` 那一条；
+ *   - 若 chats.json 文件不存在 → 通过 readChatsFile 自动创建兜底记录；
+ *   - 若 chats.json 已存在但缺失目标 chatId 条目 → 跳过登记并告警（避免污染他人数据）。
+ *
+ * 容错策略：
+ *   - chatId 为 undefined/null → 跳过；空字符串 '' 视为合法（默认会话）；
+ *   - sessionId 为空 → 跳过；
+ *   - 任意 IO/解析异常 → 静默吞错 + 日志，绝不抛出影响主流程。
+ *
+ * @param agentId   - Agent ID（chats/<agentId> 目录段）
+ * @param userId    - 用户 ID（chats/<agentId>/chats/<userId> 目录段）
+ * @param chatId    - 会话 ID（ChatMeta.chatId）；undefined/null 时跳过；空字符串视为默认会话
+ * @param sessionId - 当前生效的 sessionId（来自 sessions.json 索引）；为空时直接 return
+ * @returns 是否实际写盘（true=本次新增了一个 sessionId；false=跳过 / 已存在 / 出错）
+ */
+export function ensureSessionInHistory(agentId, userId, chatId, sessionId) {
+    // chatId 必须是 string（含空字符串 '' —— 默认会话的合法标识）；undefined/null 跳过
+    if (typeof chatId !== 'string')
+        return false;
+    if (!sessionId || !sessionId.trim())
+        return false;
+    const chatsPath = resolveChatsFilePath(agentId, userId);
+    try {
+        // 登记入口需要兜底：默认对话首次消息时 chats.json 尚不存在，
+        // 走 readChatsFileOrInitDefault 让其落盘一条 chatId='' 的默认对话，
+        // 然后正常走"查找+追加"流程。
+        const chats = readChatsFileOrInitDefault(chatsPath);
+        const idx = chats.findIndex((c) => c.chatId === chatId);
+        if (idx < 0) {
+            return false;
+        }
+        const target = chats[idx];
+        const history = Array.isArray(target.sessionIdHistory) ? target.sessionIdHistory : [];
+        if (history.includes(sessionId)) {
+            // 已存在，幂等跳过，不写盘
+            return false;
+        }
+        // 末尾追加，写回。
+        // 把默认对话/具名对话无端"置顶"，扰乱前端按 updatedAt 倒序的列表排序。
+        const updated = {
+            ...target,
+            sessionIdHistory: [...history, sessionId],
+        };
+        const nextChats = [...chats];
+        nextChats[idx] = updated;
+        writeChatsFile(chatsPath, nextChats);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}

package/node_modules/ws/lib/receiver.js

@@ -40,6 +40,10 @@ class Receiver extends Writable {
    *     extensions
    * @param {Boolean} [options.isServer=false] Specifies whether to operate in
    *     client or server mode
+   * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+   *     buffered data chunks
+   * @param {Number} [options.maxFragments=0] The maximum number of message
+   *     fragments
    * @param {Number} [options.maxPayload=0] The maximum allowed message length
    * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
    *     not to skip UTF-8 validation for text and close messages
@@ -54,6 +58,8 @@ class Receiver extends Writable {
     this._binaryType = options.binaryType || BINARY_TYPES[0];
     this._extensions = options.extensions || {};
     this._isServer = !!options.isServer;
+    this._maxBufferedChunks = options.maxBufferedChunks | 0;
+    this._maxFragments = options.maxFragments | 0;
     this._maxPayload = options.maxPayload | 0;
     this._skipUTF8Validation = !!options.skipUTF8Validation;
     this[kWebSocket] = undefined;
@@ -89,6 +95,22 @@ class Receiver extends Writable {
   _write(chunk, encoding, cb) {
     if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
 
+    if (
+      this._maxBufferedChunks > 0 &&
+      this._buffers.length >= this._maxBufferedChunks
+    ) {
+      cb(
+        this.createError(
+          RangeError,
+          'Too many buffered chunks',
+          false,
+          1008,
+          'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+        )
+      );
+      return;
+    }
+
     this._bufferedBytes += chunk.length;
     this._buffers.push(chunk);
     this.startLoop(cb);
@@ -485,6 +507,22 @@ class Receiver extends Writable {
     }
 
     if (data.length) {
+      if (
+        this._maxFragments > 0 &&
+        this._fragments.length >= this._maxFragments
+      ) {
+        const error = this.createError(
+          RangeError,
+          'Too many message fragments',
+          false,
+          1008,
+          'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+        );
+
+        cb(error);
+        return;
+      }
+
       //
       // This message is not compressed so its length is the sum of the payload
       // length of all fragments.
@@ -524,6 +562,22 @@ class Receiver extends Writable {
           return;
         }
 
+        if (
+          this._maxFragments > 0 &&
+          this._fragments.length >= this._maxFragments
+        ) {
+          const error = this.createError(
+            RangeError,
+            'Too many message fragments',
+            false,
+            1008,
+            'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+          );
+
+          cb(error);
+          return;
+        }
+
         this._fragments.push(buf);
       }
 

package/node_modules/ws/lib/sender.js

@@ -4,6 +4,9 @@
 
 const { Duplex } = require('stream');
 const { randomFillSync } = require('crypto');
+const {
+  types: { isUint8Array }
+} = require('util');
 
 const PerMessageDeflate = require('./permessage-deflate');
 const { EMPTY_BUFFER, kWebSocket, NOOP } = require('./constants');
@@ -200,8 +203,10 @@ class Sender {
 
       if (typeof data === 'string') {
         buf.write(data, 2);
-      } else {
+      } else if (isUint8Array(data)) {
         buf.set(data, 2);
+      } else {
+        throw new TypeError('Second argument must be a string or a Uint8Array');
       }
     }
 

package/node_modules/ws/lib/websocket-server.js

@@ -43,6 +43,10 @@ class WebSocketServer extends EventEmitter {
    *     called
    * @param {Function} [options.handleProtocols] A hook to handle protocols
    * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+   *     buffered data chunks
+   * @param {Number} [options.maxFragments=131072] The maximum number of message
+   *     fragments
    * @param {Number} [options.maxPayload=104857600] The maximum allowed message
    *     size
    * @param {Boolean} [options.noServer=false] Enable no server mode
@@ -65,6 +69,8 @@ class WebSocketServer extends EventEmitter {
     options = {
       allowSynchronousEvents: true,
       autoPong: true,
+      maxBufferedChunks: 1024 * 1024,
+      maxFragments: 128 * 1024,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,
@@ -424,6 +430,8 @@ class WebSocketServer extends EventEmitter {
 
     ws.setSocket(socket, head, {
       allowSynchronousEvents: this.options.allowSynchronousEvents,
+      maxBufferedChunks: this.options.maxBufferedChunks,
+      maxFragments: this.options.maxFragments,
       maxPayload: this.options.maxPayload,
       skipUTF8Validation: this.options.skipUTF8Validation
     });

package/node_modules/ws/lib/websocket.js

@@ -201,6 +201,10 @@ class WebSocket extends EventEmitter {
    *     multiple times in the same tick
    * @param {Function} [options.generateMask] The function used to generate the
    *     masking key
+   * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+   *     buffered data chunks
+   * @param {Number} [options.maxFragments=0] The maximum number of message
+   *     fragments
    * @param {Number} [options.maxPayload=0] The maximum allowed message size
    * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
    *     not to skip UTF-8 validation for text and close messages
@@ -212,6 +216,8 @@ class WebSocket extends EventEmitter {
       binaryType: this.binaryType,
       extensions: this._extensions,
       isServer: this._isServer,
+      maxBufferedChunks: options.maxBufferedChunks,
+      maxFragments: options.maxFragments,
       maxPayload: options.maxPayload,
       skipUTF8Validation: options.skipUTF8Validation
     });
@@ -640,6 +646,10 @@ module.exports = WebSocket;
  *     masking key
  * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
  *     handshake request
+ * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+ *     buffered data chunks
+ * @param {Number} [options.maxFragments=131072] The maximum number of message
+ *     fragments
  * @param {Number} [options.maxPayload=104857600] The maximum allowed message
  *     size
  * @param {Number} [options.maxRedirects=10] The maximum number of redirects
@@ -660,6 +670,8 @@ function initAsClient(websocket, address, protocols, options) {
     autoPong: true,
     closeTimeout: CLOSE_TIMEOUT,
     protocolVersion: protocolVersions[1],
+    maxBufferedChunks: 1024 * 1024,
+    maxFragments: 128 * 1024,
     maxPayload: 100 * 1024 * 1024,
     skipUTF8Validation: false,
     perMessageDeflate: true,
@@ -1017,6 +1029,8 @@ function initAsClient(websocket, address, protocols, options) {
     websocket.setSocket(socket, head, {
       allowSynchronousEvents: opts.allowSynchronousEvents,
       generateMask: opts.generateMask,
+      maxBufferedChunks: opts.maxBufferedChunks,
+      maxFragments: opts.maxFragments,
       maxPayload: opts.maxPayload,
       skipUTF8Validation: opts.skipUTF8Validation
     });

package/node_modules/ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ws",
-  "version": "8.20.0",
+  "version": "8.21.0",
   "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
   "keywords": [
     "HyBi",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightclawbot",
-  "version": "1.2.3",
+  "version": "1.2.6-beta.0",
   "description": "LightClawBot channel plugin with message support, cron jobs, and proactive messaging",
   "type": "module",
   "files": [