@yeaft/webchat-agent 1.0.370 → 1.0.372

package/connection/buffer.js

@@ -2,7 +2,6 @@ import WebSocket from 'ws';
 import ctx from '../context.js';
 import { encrypt, decrypt, isEncrypted } from '../encryption.js';
 
-// 需要在断连期间缓冲的消息类型（CLI / Session 输出相关的关键消息）
 export const BUFFERABLE_TYPES = new Set([
   'claude_output', 'yeaft_output', 'yeaft_session_output', 'session_output',
   'yeaft_history_chunk',
@@ -10,43 +9,56 @@ export const BUFFERABLE_TYPES = new Set([
   'session_id_update', 'compact_status', 'slash_commands_update',
   'background_task_started', 'background_task_output',
   'subagent_started', 'subagent_message', 'subagent_completed',
-  // Work Center broadcasts are projections over Agent-local SQLite. Buffering
-  // prevents a terminal transition from disappearing during a short reconnect;
-  // clients still refresh with `list` after reconnect for authoritative state.
   'work_center_event'
 ]);
 
+function messageBytes(msg) {
+  try { return Buffer.byteLength(JSON.stringify(msg), 'utf8'); }
+  catch { return 0; }
+}
+
+const TERMINAL_TYPES = new Set(['turn_completed', 'conversation_closed']);
+
+function removeBufferedAt(index) {
+  const [removed] = ctx.messageBuffer.splice(index, 1);
+  ctx.messageBufferBytes = Math.max(0, Number(ctx.messageBufferBytes || 0) - messageBytes(removed));
+}
+
+function removeOutboundAt(index, outcome = 'dropped') {
+  const [removed] = ctx.outboundSendQueue.splice(index, 1);
+  ctx.outboundSendQueueBytes = Math.max(0, Number(ctx.outboundSendQueueBytes || 0) - Number(removed?.bytes || 0));
+  removed?.resolve?.(outcome);
+}
+
 function bufferMessage(msg, reason) {
   if (!BUFFERABLE_TYPES.has(msg.type)) {
     console.warn(`[WS] Cannot send message, WebSocket not open: ${msg.type}`);
     return 'dropped';
   }
-  if (ctx.messageBuffer.length < ctx.messageBufferMaxSize) {
-    ctx.messageBuffer.push(msg);
-    console.log(`[WS] ${reason}, buffered: ${msg.type} (queue: ${ctx.messageBuffer.length})`);
-    return 'buffered';
+  const bytes = messageBytes(msg);
+  const maxBytes = Math.max(1, Number(ctx.messageBufferMaxBytes) || 8 * 1024 * 1024);
+  if (bytes > maxBytes) {
+    console.warn(`[WS] Message exceeds disconnected buffer byte budget, dropping: ${msg.type}`);
+    return 'dropped';
   }
-  // Buffer full: drop oldest non-status messages to make room
-  const dropIdx = ctx.messageBuffer.findIndex(m => m.type !== 'turn_completed');
-  if (dropIdx >= 0) {
-    ctx.messageBuffer.splice(dropIdx, 1);
-    ctx.messageBuffer.push(msg);
-    console.warn(`[WS] Buffer full, dropped oldest to make room for: ${msg.type}`);
-    return 'buffered';
+  while (ctx.messageBuffer.length > 0 && (
+    ctx.messageBuffer.length >= ctx.messageBufferMaxSize
+    || Number(ctx.messageBufferBytes || 0) + bytes > maxBytes
+  )) {
+    const nonTerminal = ctx.messageBuffer.findIndex(m => !TERMINAL_TYPES.has(m.type));
+    if (nonTerminal < 0) break;
+    removeBufferedAt(nonTerminal);
   }
-  console.warn(`[WS] Buffer full (${ctx.messageBufferMaxSize}), dropping: ${msg.type}`);
-  return 'dropped';
+  if (ctx.messageBuffer.length >= ctx.messageBufferMaxSize
+      || Number(ctx.messageBufferBytes || 0) + bytes > maxBytes) return 'dropped';
+  ctx.messageBuffer.push(msg);
+  ctx.messageBufferBytes = Number(ctx.messageBufferBytes || 0) + bytes;
+  console.log(`[WS] ${reason}, buffered: ${msg.type} (queue: ${ctx.messageBuffer.length})`);
+  return 'buffered';
 }
 
 async function sendNow(msg) {
-  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) {
-    return bufferMessage(msg, 'Disconnected');
-  }
-
-  // feat-ws-plaintext-negotiation: encrypt only when the server has
-  // NOT advertised plaintext acceptance. Defaults to encrypted for
-  // back-compat with old servers; flipped to plaintext when the
-  // `registered` frame includes `acceptPlaintext: true`.
+  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) return bufferMessage(msg, 'Disconnected');
   if (ctx.serverEncryptionRequired && ctx.sessionKey) {
     const encrypted = await encrypt(msg, ctx.sessionKey);
     ctx.ws.send(JSON.stringify(encrypted));
@@ -63,6 +75,7 @@ function scheduleOutboundDrain() {
     try {
       while (ctx.outboundSendQueue.length > 0) {
         const item = ctx.outboundSendQueue.shift();
+        ctx.outboundSendQueueBytes = Math.max(0, Number(ctx.outboundSendQueueBytes || 0) - Number(item?.bytes || 0));
         const msg = item?.msg ?? item;
         try {
           const outcome = await sendNow(msg);
@@ -72,8 +85,6 @@ function scheduleOutboundDrain() {
           const outcome = msg ? bufferMessage(msg, 'Send failed') : 'dropped';
           item?.resolve?.(outcome);
         }
-        // Yield between frames so ping/pong, inbound control messages and UI
-        // events cannot be starved by a reconnect flush or a burst of tool output.
         await new Promise(resolve => setImmediate(resolve));
       }
     } finally {
@@ -83,42 +94,45 @@ function scheduleOutboundDrain() {
   });
 }
 
-// Send message to server (with encryption if available)
-// 断连时对关键消息类型进行缓冲，重连后自动 flush
 export async function sendToServer(msg) {
-  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) {
-    return bufferMessage(msg, 'Disconnected');
+  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) return bufferMessage(msg, 'Disconnected');
+  const bytes = messageBytes(msg);
+  const maxBytes = Math.max(1, Number(ctx.outboundSendQueueMaxBytes) || 8 * 1024 * 1024);
+  if (bytes > maxBytes) {
+    console.warn(`[WS] Outbound message exceeds byte budget, dropping: ${msg.type}`);
+    return 'dropped';
+  }
+  while (TERMINAL_TYPES.has(msg.type)
+      && Number(ctx.outboundSendQueueBytes || 0) + bytes > maxBytes) {
+    const nonTerminal = ctx.outboundSendQueue.findIndex(item => !TERMINAL_TYPES.has(item?.msg?.type));
+    if (nonTerminal < 0) break;
+    removeOutboundAt(nonTerminal);
+  }
+  if (Number(ctx.outboundSendQueueBytes || 0) + bytes > maxBytes) {
+    console.warn(`[WS] Outbound queue byte budget exceeded, dropping: ${msg.type}`);
+    return 'dropped';
   }
   const promise = new Promise((resolve, reject) => {
-    ctx.outboundSendQueue.push({ msg, resolve, reject });
+    ctx.outboundSendQueue.push({ msg, bytes, resolve, reject });
+    ctx.outboundSendQueueBytes = Number(ctx.outboundSendQueueBytes || 0) + bytes;
   });
   scheduleOutboundDrain();
   return promise;
 }
 
-// Flush 断连期间缓冲的消息
 export async function flushMessageBuffer() {
   if (ctx.messageBuffer.length === 0) return;
-
   const buffered = ctx.messageBuffer.splice(0);
+  ctx.messageBufferBytes = 0;
   console.log(`[WS] Flushing ${buffered.length} buffered messages...`);
-
-  for (const msg of buffered) {
-    await sendToServer(msg);
-  }
-
-  console.log(`[WS] Flush queued`);
+  for (const msg of buffered) await sendToServer(msg);
+  console.log('[WS] Flush queued');
 }
 
-// Parse incoming message (decrypt if encrypted)
 export async function parseMessage(data) {
   try {
     const parsed = JSON.parse(data.toString());
-
-    if (ctx.sessionKey && isEncrypted(parsed)) {
-      return await decrypt(parsed, ctx.sessionKey);
-    }
-
+    if (ctx.sessionKey && isEncrypted(parsed)) return await decrypt(parsed, ctx.sessionKey);
     return parsed;
   } catch (e) {
     console.error('Failed to parse message:', e);

package/context.js

@@ -47,11 +47,15 @@ export default {
   lastHeartbeatStallAt: 0,
   lastHeartbeatStallMs: 0,
   outboundSendQueue: [],
+  outboundSendQueueBytes: 0,
+  outboundSendQueueMaxBytes: 8 * 1024 * 1024,
   outboundSendQueueActive: false,
   assetOutbox: null,
   // 断连期间的消息缓冲队列（重连后 flush）
   messageBuffer: [],
-  messageBufferMaxSize: 5000, // 防止内存无限增长
+  messageBufferBytes: 0,
+  messageBufferMaxSize: 5000,
+  messageBufferMaxBytes: 8 * 1024 * 1024,
   // 由 connection.js 注册的通信函数
   sendToServer: null,
   // 由 index.js 注册的配置保存函数

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.370"}
+{"version":"1.0.372"}