@yeaft/webchat-agent 0.0.233 → 0.0.235

package/connection/buffer.js

@@ -0,0 +1,87 @@
+import WebSocket from 'ws';
+import ctx from '../context.js';
+import { encrypt, decrypt, isEncrypted } from '../encryption.js';
+
+// 需要在断连期间缓冲的消息类型（Claude 输出相关的关键消息）
+export const BUFFERABLE_TYPES = new Set([
+  'claude_output', 'turn_completed', 'conversation_closed',
+  'session_id_update', 'compact_status', 'slash_commands_update',
+  'background_task_started', 'background_task_output',
+  'crew_output', 'crew_status', 'crew_turn_completed',
+  'crew_session_created', 'crew_session_restored', 'crew_human_needed',
+  'crew_role_added', 'crew_role_removed',
+  'crew_role_compact', 'crew_context_usage'
+]);
+
+// Send message to server (with encryption if available)
+// 断连时对关键消息类型进行缓冲，重连后自动 flush
+export async function sendToServer(msg) {
+  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) {
+    // 缓冲关键消息
+    if (BUFFERABLE_TYPES.has(msg.type)) {
+      if (ctx.messageBuffer.length < ctx.messageBufferMaxSize) {
+        ctx.messageBuffer.push(msg);
+        console.log(`[WS] Buffered message: ${msg.type} (queue: ${ctx.messageBuffer.length})`);
+      } else {
+        // Buffer full: drop oldest non-status messages to make room
+        const dropIdx = ctx.messageBuffer.findIndex(m => m.type !== 'crew_status' && 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}`);
+        } else {
+          console.warn(`[WS] Buffer full (${ctx.messageBufferMaxSize}), dropping: ${msg.type}`);
+        }
+      }
+    } else {
+      console.warn(`[WS] Cannot send message, WebSocket not open: ${msg.type}`);
+    }
+    return;
+  }
+
+  try {
+    if (ctx.sessionKey) {
+      const encrypted = await encrypt(msg, ctx.sessionKey);
+      ctx.ws.send(JSON.stringify(encrypted));
+    } else {
+      ctx.ws.send(JSON.stringify(msg));
+    }
+  } catch (e) {
+    console.error(`[WS] Error sending message ${msg.type}:`, e.message);
+    // 发送失败也缓冲
+    if (BUFFERABLE_TYPES.has(msg.type) && ctx.messageBuffer.length < ctx.messageBufferMaxSize) {
+      ctx.messageBuffer.push(msg);
+      console.log(`[WS] Send failed, buffered: ${msg.type}`);
+    }
+  }
+}
+
+// Flush 断连期间缓冲的消息
+export async function flushMessageBuffer() {
+  if (ctx.messageBuffer.length === 0) return;
+
+  const buffered = ctx.messageBuffer.splice(0);
+  console.log(`[WS] Flushing ${buffered.length} buffered messages...`);
+
+  for (const msg of buffered) {
+    await sendToServer(msg);
+  }
+
+  console.log(`[WS] Flush complete`);
+}
+
+// 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);
+    }
+
+    return parsed;
+  } catch (e) {
+    console.error('Failed to parse message:', e);
+    return null;
+  }
+}

package/connection/heartbeat.js

@@ -0,0 +1,47 @@
+import WebSocket from 'ws';
+import ctx from '../context.js';
+
+export function startAgentHeartbeat() {
+  stopAgentHeartbeat();
+  ctx.lastPongAt = Date.now();
+
+  // 监听 pong 帧
+  if (ctx.ws) {
+    ctx.ws.on('pong', () => {
+      ctx.lastPongAt = Date.now();
+    });
+  }
+
+  ctx.agentHeartbeatTimer = setInterval(() => {
+    if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) return;
+
+    // 检查上次 pong 是否超时
+    const sincePong = Date.now() - ctx.lastPongAt;
+    if (sincePong > 45000) {
+      console.warn(`[Heartbeat] No pong for ${Math.round(sincePong / 1000)}s, reconnecting...`);
+      ctx.ws.terminate();
+      return;
+    }
+
+    try {
+      ctx.ws.ping();
+    } catch (e) {
+      console.warn('[Heartbeat] Failed to send ping:', e.message);
+    }
+  }, 25000);
+}
+
+export function stopAgentHeartbeat() {
+  if (ctx.agentHeartbeatTimer) {
+    clearInterval(ctx.agentHeartbeatTimer);
+    ctx.agentHeartbeatTimer = null;
+  }
+}
+
+export function scheduleReconnect(connectFn) {
+  clearTimeout(ctx.reconnectTimer);
+  ctx.reconnectTimer = setTimeout(() => {
+    console.log('Attempting to reconnect...');
+    connectFn();
+  }, ctx.CONFIG.reconnectInterval);
+}

package/connection/index.js

@@ -0,0 +1,89 @@
+import WebSocket from 'ws';
+import ctx from '../context.js';
+import { sendToServer, parseMessage } from './buffer.js';
+import { startAgentHeartbeat, stopAgentHeartbeat, scheduleReconnect } from './heartbeat.js';
+import { handleMessage } from './message-router.js';
+
+export function connect() {
+  // Don't include secret in URL - it will be sent via WebSocket message after connection
+  // 使用 agentName 作为唯一标识（不再使用随机 UUID）
+  const params = new URLSearchParams({
+    type: 'agent',
+    id: ctx.CONFIG.agentName,  // 直接用名称作为 ID
+    name: ctx.CONFIG.agentName,
+    workDir: ctx.CONFIG.workDir,
+    capabilities: ctx.agentCapabilities.join(',')
+  });
+
+  const url = `${ctx.CONFIG.serverUrl}?${params.toString()}`;
+  console.log(`Connecting to server: ${ctx.CONFIG.serverUrl}`);
+  if (ctx.CONFIG.disallowedTools.length > 0) {
+    console.log(`Disallowed tools: ${ctx.CONFIG.disallowedTools.join(', ')}`);
+  }
+
+  ctx.ws = new WebSocket(url);
+
+  ctx.ws.on('open', () => {
+    console.log('Connected to server, waiting for auth challenge...');
+    clearTimeout(ctx.reconnectTimer);
+    // 启动 agent 端心跳: 每 25 秒发一次 ping 帧
+    startAgentHeartbeat();
+  });
+
+  ctx.ws.on('message', async (data) => {
+    // 收到任何消息都说明连接活着
+    ctx.lastPongAt = Date.now();
+
+    // Check for auth_required message (unencrypted)
+    try {
+      const msg = JSON.parse(data.toString());
+      if (msg.type === 'auth_required' && msg.tempId) {
+        console.log('Received auth challenge, sending credentials...');
+        ctx.pendingAuthTempId = msg.tempId;
+        // Send authentication via WebSocket (not URL)
+        ctx.ws.send(JSON.stringify({
+          type: 'auth',
+          tempId: msg.tempId,
+          secret: ctx.CONFIG.agentSecret,
+          capabilities: ctx.agentCapabilities,
+          version: ctx.agentVersion
+        }));
+        return;
+      }
+    } catch (e) {
+      // Not JSON or parse error - continue to normal handling
+    }
+
+    const msg = await parseMessage(data);
+    if (msg) {
+      handleMessage(msg);
+    }
+  });
+
+  ctx.ws.on('close', (code, reason) => {
+    console.log(`Disconnected from server: ${code} ${reason}`);
+    ctx.sessionKey = null;
+    ctx.pendingAuthTempId = null;
+    stopAgentHeartbeat();
+
+    if (code === 1008) {
+      console.error('Authentication failed. Check AGENT_SECRET configuration.');
+      return;
+    }
+
+    scheduleReconnect(connect);
+  });
+
+  ctx.ws.on('error', (err) => {
+    console.error('WebSocket error:', err.message);
+  });
+}
+
+// 注册 sendToServer 到 ctx 供其他模块使用
+ctx.sendToServer = sendToServer;
+
+// Re-export submodule functions for backward compatibility
+export { sendToServer, flushMessageBuffer, parseMessage, BUFFERABLE_TYPES } from './buffer.js';
+export { startAgentHeartbeat, stopAgentHeartbeat, scheduleReconnect } from './heartbeat.js';
+export { handleMessage } from './message-router.js';
+export { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';

package/connection/message-router.js

@@ -0,0 +1,271 @@
+import ctx from '../context.js';
+import { decodeKey } from '../encryption.js';
+import { handleTerminalCreate, handleTerminalInput, handleTerminalResize, handleTerminalClose } from '../terminal.js';
+import { handleProxyHttpRequest, handleProxyWsOpen, handleProxyWsMessage, handleProxyWsClose } from '../proxy.js';
+import {
+  handleReadFile, handleWriteFile, handleListDirectory,
+  handleGitStatus, handleGitDiff, handleGitAdd, handleGitReset, handleGitRestore, handleGitCommit, handleGitPush,
+  handleFileSearch, handleCreateFile, handleDeleteFiles, handleMoveFiles, handleCopyFiles, handleUploadToDir, handleTransferFiles
+} from '../workbench.js';
+import { handleListHistorySessions, handleListFolders } from '../history.js';
+import {
+  createConversation, resumeConversation, deleteConversation,
+  handleRefreshConversation, handleCancelExecution,
+  handleUserInput, handleUpdateConversationSettings, handleAskUserAnswer,
+  sendConversationList
+} from '../conversation.js';
+import {
+  createCrewSession, handleCrewHumanInput, handleCrewControl,
+  addRoleToSession, removeRoleFromSession,
+  handleListCrewSessions, handleCheckCrewExists, handleDeleteCrewDir, resumeCrewSession, removeFromCrewIndex,
+  handleLoadCrewHistory
+} from '../crew.js';
+import { sendToServer, flushMessageBuffer } from './buffer.js';
+import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
+
+export async function handleMessage(msg) {
+  switch (msg.type) {
+    case 'registered':
+      if (msg.sessionKey) {
+        ctx.sessionKey = decodeKey(msg.sessionKey);
+        console.log('Encryption enabled');
+      }
+
+      // 只保存基本配置（不再保存 agentId，因为现在用 agentName 作为 ID）
+      ctx.saveConfig({
+        serverUrl: ctx.CONFIG.serverUrl,
+        agentName: ctx.CONFIG.agentName,
+        workDir: ctx.CONFIG.workDir,
+        reconnectInterval: ctx.CONFIG.reconnectInterval
+        // 不保存 agentSecret 到配置文件（安全考虑）
+      });
+      console.log(`Registered as agent: ${msg.agentId} (name: ${ctx.CONFIG.agentName})`);
+
+      // Check server-pushed upgrade notification
+      if (msg.upgradeAvailable) {
+        console.log(`\n  Update available: ${ctx.agentVersion} → ${msg.upgradeAvailable}`);
+        console.log(`  Run "yeaft-agent upgrade" to update\n`);
+      }
+
+      sendConversationList();
+
+      // ★ Flush 断连期间缓冲的消息
+      await flushMessageBuffer();
+
+      // ★ Phase 1: 通知 server 同步完成
+      sendToServer({ type: 'agent_sync_complete' });
+      break;
+
+    case 'create_conversation':
+      await createConversation(msg);
+      break;
+
+    case 'resume_conversation':
+      await resumeConversation(msg);
+      break;
+
+    case 'delete_conversation':
+      deleteConversation(msg);
+      break;
+
+    case 'get_conversations':
+      sendConversationList();
+      break;
+
+    case 'list_history_sessions':
+      await handleListHistorySessions(msg);
+      break;
+
+    case 'list_folders':
+      await handleListFolders(msg);
+      break;
+
+    case 'transfer_files':
+      await handleTransferFiles(msg);
+      break;
+
+    case 'execute':
+      await handleUserInput(msg);
+      break;
+
+    case 'cancel_execution':
+      await handleCancelExecution(msg);
+      break;
+
+    // clear_queue 和 cancel_queued_message 已移至 server 端管理 (Phase 3.6)
+
+    case 'refresh_conversation':
+      await handleRefreshConversation(msg);
+      break;
+
+    // Terminal (PTY) messages
+    case 'terminal_create':
+      await handleTerminalCreate(msg);
+      break;
+
+    case 'terminal_input':
+      handleTerminalInput(msg);
+      break;
+
+    case 'terminal_resize':
+      handleTerminalResize(msg);
+      break;
+
+    case 'terminal_close':
+      handleTerminalClose(msg);
+      break;
+
+    // File operation messages
+    case 'read_file':
+      await handleReadFile(msg);
+      break;
+
+    case 'write_file':
+      await handleWriteFile(msg);
+      break;
+
+    case 'list_directory':
+      await handleListDirectory(msg);
+      break;
+
+    case 'git_status':
+      await handleGitStatus(msg);
+      break;
+
+    case 'git_diff':
+      await handleGitDiff(msg);
+      break;
+
+    case 'git_add':
+      await handleGitAdd(msg);
+      break;
+
+    case 'git_reset':
+      await handleGitReset(msg);
+      break;
+
+    case 'git_restore':
+      await handleGitRestore(msg);
+      break;
+
+    case 'git_commit':
+      await handleGitCommit(msg);
+      break;
+
+    case 'git_push':
+      await handleGitPush(msg);
+      break;
+
+    case 'file_search':
+      await handleFileSearch(msg);
+      break;
+
+    case 'create_file':
+      await handleCreateFile(msg);
+      break;
+
+    case 'delete_files':
+      await handleDeleteFiles(msg);
+      break;
+
+    case 'move_files':
+      await handleMoveFiles(msg);
+      break;
+
+    case 'copy_files':
+      await handleCopyFiles(msg);
+      break;
+
+    case 'upload_to_dir':
+      await handleUploadToDir(msg);
+      break;
+
+    case 'update_conversation_settings':
+      handleUpdateConversationSettings(msg);
+      break;
+
+    case 'ask_user_answer':
+      handleAskUserAnswer(msg);
+      break;
+
+    // Crew (multi-agent) messages
+    case 'create_crew_session':
+      await createCrewSession(msg);
+      break;
+
+    case 'crew_human_input':
+      await handleCrewHumanInput(msg);
+      break;
+
+    case 'crew_control':
+      await handleCrewControl(msg);
+      break;
+
+    case 'crew_add_role':
+      await addRoleToSession(msg);
+      break;
+
+    case 'crew_remove_role':
+      await removeRoleFromSession(msg);
+      break;
+
+    case 'list_crew_sessions':
+      await handleListCrewSessions(msg);
+      break;
+
+    case 'check_crew_exists':
+      await handleCheckCrewExists(msg);
+      break;
+
+    case 'delete_crew_dir':
+      await handleDeleteCrewDir(msg);
+      break;
+
+    case 'resume_crew_session':
+      await resumeCrewSession(msg);
+      break;
+
+    case 'delete_crew_session':
+      await removeFromCrewIndex(msg.sessionId);
+      (await import('../conversation.js')).sendConversationList();
+      break;
+
+    case 'update_crew_session':
+      await (await import('../crew.js')).handleUpdateCrewSession(msg);
+      break;
+
+    case 'crew_load_history':
+      await handleLoadCrewHistory(msg);
+      break;
+
+    // Port proxy
+    case 'proxy_request':
+      handleProxyHttpRequest(msg);
+      break;
+
+    case 'proxy_ws_open':
+      handleProxyWsOpen(msg);
+      break;
+
+    case 'proxy_ws_message':
+      handleProxyWsMessage(msg);
+      break;
+
+    case 'proxy_ws_close':
+      handleProxyWsClose(msg);
+      break;
+
+    case 'proxy_update_ports':
+      ctx.proxyPorts = msg.ports || [];
+      sendToServer({ type: 'proxy_ports_update', ports: ctx.proxyPorts });
+      break;
+
+    case 'restart_agent':
+      handleRestartAgent();
+      break;
+
+    case 'upgrade_agent':
+      await handleUpgradeAgent();
+      break;
+  }
+}

package/connection/upgrade-worker-template.js

@@ -0,0 +1,103 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const { execFileSync } = require('child_process');
+const os = require('os');
+
+const PKG = process.argv[2];
+const TARGET = process.argv[3];
+const LOGFILE = process.argv[4];
+
+function log(msg) {
+  const line = '[Upgrade-Worker] ' + msg;
+  console.log(line);
+  try { fs.appendFileSync(LOGFILE, line + '\n'); } catch {}
+}
+
+function parseTar(buf) {
+  const files = [];
+  let offset = 0;
+  while (offset < buf.length - 512) {
+    const header = buf.slice(offset, offset + 512);
+    if (header.every(b => b === 0)) break;
+    const name = header.slice(0, 100).toString('utf8').replace(/\0.*/, '');
+    const sizeStr = header.slice(124, 136).toString('utf8').replace(/\0.*/, '').trim();
+    const size = parseInt(sizeStr, 8) || 0;
+    const typeFlag = header[156];
+    offset += 512;
+    if (size > 0) {
+      const data = buf.slice(offset, offset + size);
+      const relPath = name.replace(/^package\//, '');
+      if (typeFlag === 48 || typeFlag === 0) {
+        files.push({ path: relPath, data });
+      }
+      offset += Math.ceil(size / 512) * 512;
+    }
+  }
+  return files;
+}
+
+function rmDirContents(dir, keep) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir)) {
+    if (keep && keep.includes(entry)) continue;
+    const full = path.join(dir, entry);
+    const stat = fs.statSync(full, { throwIfNoEntry: false });
+    if (!stat) continue;
+    if (stat.isDirectory()) {
+      fs.rmSync(full, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(full);
+    }
+  }
+}
+
+try {
+  log('Starting upgrade: ' + PKG + ' -> ' + TARGET);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'yeaft-upgrade-'));
+  log('Temp dir: ' + tmpDir);
+
+  const packOutput = execFileSync('npm', ['pack', PKG, '--pack-destination', tmpDir], {
+    shell: true, encoding: 'utf8', cwd: tmpDir, timeout: 120000
+  }).trim();
+  const tgzName = packOutput.split('\n').pop().trim();
+  const tgzPath = path.join(tmpDir, tgzName);
+  log('Downloaded: ' + tgzPath);
+
+  const gzBuf = fs.readFileSync(tgzPath);
+  const tarBuf = zlib.gunzipSync(gzBuf);
+  const files = parseTar(tarBuf);
+  log('Extracted ' + files.length + ' files from archive');
+
+  log('Removing old files from: ' + TARGET);
+  rmDirContents(TARGET, ['node_modules']);
+
+  for (const f of files) {
+    const dest = path.join(TARGET, f.path);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, f.data);
+  }
+  log('Copied ' + files.length + ' files to target');
+
+  log('Installing dependencies...');
+  try {
+    execFileSync('npm', ['install', '--omit=dev'], {
+      shell: true, cwd: TARGET, encoding: 'utf8', timeout: 120000
+    });
+    log('Dependencies installed');
+  } catch (depErr) {
+    log('WARN: npm install deps failed: ' + depErr.message);
+  }
+
+  const newPkg = JSON.parse(fs.readFileSync(path.join(TARGET, 'package.json'), 'utf8'));
+  log('Upgrade complete. New version: ' + newPkg.version);
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  process.exit(0);
+} catch (err) {
+  log('FATAL: ' + err.message);
+  log(err.stack || '');
+  process.exit(1);
+}