@yeaft/webchat-agent 1.0.186 → 1.0.189

package/local-runtime/server/handlers/session-pin-router.js

@@ -0,0 +1,61 @@
+/**
+ * session-pin-router.js — pure routing decision for pin_session /
+ * unpin_session WebSocket messages.
+ *
+ * Yeaft and Chat sessions live in two different SQLite tables
+ * (`yeaft_sessions` vs `sessions`) with two different ownership
+ * conventions:
+ *   - yeaft: rows carry their own `user_id` column (yeaft sessions are
+ *     not chat conversations, they don't show up in the `sessions` table)
+ *   - chat:  `verifyConversationOwnership` reads `sessions.user_id`
+ *
+ * This module exposes a single pure decision function that returns a
+ * discriminated outcome. The production handler in
+ * `client-conversation.js` translates the outcome into the actual DB
+ * write + WS reply; tests use the same function to assert routing
+ * behavior without having to import the whole handler graph.
+ *
+ * Outcome shapes:
+ *   { kind: 'noop' }                                       — message had no conversationId
+ *   { kind: 'yeaft', id, isPinned }                        — yeaft DB path
+ *   { kind: 'chat',  id, isPinned }                        — chat DB fallback path
+ *   { kind: 'denied', id, reason: 'yeaft-foreign' | 'chat-foreign' }  — ownership rejection
+ */
+
+/**
+ * @typedef {Object} PinRouteDeps
+ * @property {(id: string) => ({ userId?: string|null }|null)} getYeaftRow  Reads a yeaft session row (or returns null if not yeaft-owned).
+ * @property {(id: string, userId: string) => boolean} verifyChatOwnership  Returns true if `userId` owns the chat conversation `id`.
+ * @property {boolean} [skipAuth]  Skip both ownership checks (dev / single-user).
+ */
+
+/**
+ * Decide where (and whether) a pin_session / unpin_session message
+ * should be applied. Pure — never touches the DB.
+ *
+ * @param {PinRouteDeps} deps
+ * @param {{ userId: string|null }} client
+ * @param {{ type: 'pin_session'|'unpin_session', conversationId?: string }} msg
+ * @returns {
+ *   {kind:'noop'} |
+ *   {kind:'yeaft', id:string, isPinned:boolean} |
+ *   {kind:'chat',  id:string, isPinned:boolean} |
+ *   {kind:'denied', id:string, reason:string}
+ * }
+ */
+export function routeSessionPin(deps, client, msg) {
+  const id = msg && msg.conversationId;
+  if (!id) return { kind: 'noop' };
+  const isPinned = msg.type === 'pin_session';
+  const yeaftRow = deps.getYeaftRow(id);
+  if (yeaftRow) {
+    if (!deps.skipAuth && yeaftRow.userId && yeaftRow.userId !== client.userId) {
+      return { kind: 'denied', id, reason: 'yeaft-foreign' };
+    }
+    return { kind: 'yeaft', id, isPinned };
+  }
+  if (!deps.skipAuth && !deps.verifyChatOwnership(id, client.userId)) {
+    return { kind: 'denied', id, reason: 'chat-foreign' };
+  }
+  return { kind: 'chat', id, isPinned };
+}

package/local-runtime/server/heartbeat-policy.js

@@ -0,0 +1,46 @@
+const DEFAULT_AGENT_HEARTBEAT_TIMEOUT_MS = 180000;
+const DEFAULT_AGENT_HEARTBEAT_STALL_GRACE_MS = 5000;
+
+function parsePositiveInt(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+export const AGENT_HEARTBEAT_TIMEOUT_MS = parsePositiveInt(
+  process.env.AGENT_HEARTBEAT_TIMEOUT_MS,
+  DEFAULT_AGENT_HEARTBEAT_TIMEOUT_MS,
+);
+
+export const AGENT_HEARTBEAT_STALL_GRACE_MS = parsePositiveInt(
+  process.env.AGENT_HEARTBEAT_STALL_GRACE_MS,
+  DEFAULT_AGENT_HEARTBEAT_STALL_GRACE_MS,
+);
+
+export function markAgentHeartbeatSeen(agent, now = Date.now()) {
+  if (!agent) return;
+  agent.isAlive = true;
+  agent.lastSeenAt = now;
+}
+
+export function markAgentHeartbeatPing(agent, now = Date.now()) {
+  if (!agent) return;
+  agent.pingSentAt = now;
+}
+
+export function markAgentHeartbeatStall(agent, driftMs, now = Date.now()) {
+  if (!agent) return;
+  agent.lastHeartbeatStallAt = now;
+  agent.lastHeartbeatStallMs = driftMs;
+}
+
+export function shouldTerminateAgentHeartbeat(
+  agent,
+  now = Date.now(),
+  timeoutMs = AGENT_HEARTBEAT_TIMEOUT_MS,
+  { timerDriftMs = 0, stallGraceMs = AGENT_HEARTBEAT_STALL_GRACE_MS } = {},
+) {
+  if (!agent) return false;
+  if (Number.isFinite(timerDriftMs) && timerDriftMs > stallGraceMs) return false;
+  const lastSeenAt = Number.isFinite(agent.lastSeenAt) ? agent.lastSeenAt : 0;
+  return lastSeenAt > 0 && (now - lastSeenAt) > timeoutMs;
+}

package/local-runtime/server/index.js

@@ -0,0 +1,275 @@
+import { assertNodeVersion } from './check-node-version.js';
+assertNodeVersion({ component: 'yeaft-server' });
+
+import express from 'express';
+import compression from 'compression';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { CONFIG, isEmailConfigured, validateProductionConfig } from './config.js';
+import { agents, webClients, userFileTabs, userStatsDeltas } from './context.js';
+import { invitationDb, userStatsDb, closeDb } from './database.js';
+import { registerApiRoutes } from './api.js';
+import { registerProxyRoutes, handleProxyWebSocketUpgrade } from './proxy.js';
+import { handleAgentConnection } from './ws-agent.js';
+import { handleWebConnection } from './ws-client.js';
+import { sendToWebClient } from './ws-utils.js';
+import { markAgentHeartbeatPing, markAgentHeartbeatStall, shouldTerminateAgentHeartbeat } from './heartbeat-policy.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const app = express();
+app.set('trust proxy', 1);
+const server = createServer(app);
+// maxPayload: defaults to 256 MiB but is env-overridable so operators on
+// constrained VMs can throttle without a redeploy. The Yeaft debug feature
+// ships verbatim LLM raw request/response bodies through this WebSocket
+// (see anthropic.js / openai-responses.js onRawExchange — payloads are
+// never truncated). A pathological tool result or a long SSE stream can
+// plausibly exceed the `ws` library's 100 MiB default. The default 256 MiB
+// covers realistic worst case; the per-tab retention is bounded separately
+// on the client by MAX_YEAFT_DEBUG_LOOPS in web/stores/chat.js.
+//
+// Memory math: with N concurrent agents each delivering one full-frame
+// payload, the server transiently holds N × maxPayload before dispatch.
+// On a small VM (≤1 GiB), set WS_MAX_PAYLOAD_BYTES lower (e.g. 64 MiB).
+const DEFAULT_WS_MAX_PAYLOAD_BYTES = 256 * 1024 * 1024;
+const envOverride = Number(process.env.WS_MAX_PAYLOAD_BYTES);
+const WS_MAX_PAYLOAD_BYTES = Number.isFinite(envOverride) && envOverride > 0
+  ? envOverride
+  : DEFAULT_WS_MAX_PAYLOAD_BYTES;
+const wss = new WebSocketServer({
+  noServer: true,
+  maxPayload: WS_MAX_PAYLOAD_BYTES,
+  // RFC 7692 permessage-deflate. Browsers advertise this natively; the
+  // `ws` library handles compression streaming for the agent. Replaces
+  // the hand-rolled gzip-before-encrypt that ran only on the (now
+  // back-compat) encrypted send path. With plaintext outbound enabled,
+  // this is the only compression layer — payloads in DevTools still show
+  // the uncompressed JSON (browser inflates before exposing the frame).
+  perMessageDeflate: {
+    zlibDeflateOptions: { level: 6, memLevel: 7 },
+    zlibInflateOptions: { chunkSize: 10 * 1024 },
+    clientNoContextTakeover: true,  // bound per-connection memory
+    serverNoContextTakeover: true,
+    threshold: 1024                 // skip compression for tiny frames
+  }
+});
+
+// =====================
+// WebSocket 心跳机制
+// =====================
+const AGENT_HEARTBEAT_INTERVAL = 30000;
+const CLIENT_HEARTBEAT_INTERVAL = 90000;
+
+let lastAgentHeartbeatTickAt = Date.now();
+setInterval(() => {
+  const now = Date.now();
+  const timerDriftMs = Math.max(0, now - lastAgentHeartbeatTickAt - AGENT_HEARTBEAT_INTERVAL);
+  lastAgentHeartbeatTickAt = now;
+
+  for (const [agentId, agent] of agents) {
+    if (timerDriftMs > 5000) {
+      markAgentHeartbeatStall(agent, timerDriftMs, now);
+      console.warn(`[Heartbeat] Server event loop delayed agent heartbeat by ${Math.round(timerDriftMs)}ms; deferring termination for ${agentId}`);
+    }
+
+    if (shouldTerminateAgentHeartbeat(agent, now, undefined, { timerDriftMs })) {
+      console.log(`[Heartbeat] Agent ${agentId} not responding, terminating`);
+      agent.ws.terminate();
+      continue;
+    }
+    markAgentHeartbeatPing(agent, now);
+    agent.ws.ping();
+  }
+}, AGENT_HEARTBEAT_INTERVAL);
+
+setInterval(() => {
+  for (const [clientId, client] of webClients) {
+    if (client.isAlive === false) {
+      console.log(`[Heartbeat] Web client ${clientId} not responding, terminating`);
+      client.ws.terminate();
+      continue;
+    }
+    client.isAlive = false;
+    client.ws.ping();
+  }
+}, CLIENT_HEARTBEAT_INTERVAL);
+
+// ★ Phase 5: 每小时清理超过 24 小时的 file tab 状态
+setInterval(() => {
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const [key, state] of userFileTabs) {
+    if (state.timestamp < cutoff) userFileTabs.delete(key);
+  }
+}, 60 * 60 * 1000);
+
+// ★ Phase 6: 每小时清理过期的未使用邀请码
+setInterval(() => {
+  invitationDb.cleanup();
+}, 60 * 60 * 1000);
+
+// ★ Admin Dashboard: 每 60 秒批量持久化用户统计增量到 DB
+function flushUserStats() {
+  if (userStatsDeltas.size === 0) return;
+  try {
+    userStatsDb.flushDeltas(userStatsDeltas);
+    userStatsDeltas.clear();
+  } catch (e) {
+    console.error('[UserStats] Flush error:', e.message);
+  }
+}
+setInterval(flushUserStats, 60 * 1000);
+
+// Gzip 压缩中间件
+app.use(compression({
+  level: 6,
+  threshold: 1024,
+  filter: (req, res) => {
+    if (req.headers['x-no-compression']) return false;
+    // Skip compression for proxy routes (avoid buffering SSE/streaming)
+    if (req.path.startsWith('/agent/')) return false;
+    return compression.filter(req, res);
+  }
+}));
+
+// 静态文件服务
+const webDir = process.env.WEB_DIR || (process.env.SERVE_DIST === 'true'
+  ? join(__dirname, '../web/dist')
+  : join(__dirname, '../web'));
+app.use(express.static(webDir, {
+  maxAge: process.env.SERVE_DIST === 'true' ? '1y' : 0,
+  etag: true,
+  setHeaders: (res, filePath) => {
+    if (filePath.endsWith('.html')) {
+      res.setHeader('Cache-Control', 'no-cache');
+    }
+  }
+}));
+
+// SPA fallback for OAuth callback routes (MSAL popup redirect)
+app.get('/auth/callback', (req, res) => {
+  res.sendFile(join(webDir, 'index.html'));
+});
+
+// Port proxy routes (must be before express.json() to get raw body)
+registerProxyRoutes(app);
+
+// JSON body parser — after proxy routes
+app.use(express.json());
+
+// API routes (auth, sessions, users, upload)
+registerApiRoutes(app);
+
+// =====================
+// WebSocket 连接处理
+// =====================
+wss.on('connection', (ws, req) => {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  const clientType = url.searchParams.get('type');
+
+  if (clientType === 'agent') {
+    handleAgentConnection(ws, url);
+  } else if (clientType === 'web') {
+    handleWebConnection(ws, url);
+  } else {
+    ws.close(1008, 'Invalid client type');
+  }
+});
+
+// =====================
+// HTTP Upgrade handler
+// =====================
+server.on('upgrade', (req, socket, head) => {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+
+  // Check if this is a proxy WebSocket request
+  const proxyMatch = url.pathname.match(/^\/agent\/([^/]+)\/(\d+)(\/.*)?$/);
+  if (proxyMatch) {
+    handleProxyWebSocketUpgrade(req, socket, head, proxyMatch);
+    return;
+  }
+
+  // Otherwise, hand off to the main WebSocket server
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    wss.emit('connection', ws, req);
+  });
+});
+
+// Validate production configuration before starting
+const configValidation = validateProductionConfig();
+if (!configValidation.valid) {
+  console.error('\n========================================');
+  console.error('SECURITY CONFIGURATION ERROR');
+  console.error('========================================');
+  for (const error of configValidation.errors) {
+    console.error(`  - ${error}`);
+  }
+  console.error('\nServer cannot start with default secrets in production mode.');
+  console.error('Please configure the following environment variables:');
+  console.error('  - JWT_SECRET: A secure random string for JWT signing');
+  console.error('\nOr set SKIP_AUTH=true for development mode (NOT recommended for production).');
+  console.error('========================================\n');
+  process.exit(1);
+}
+if (configValidation.warnings) {
+  console.warn('\n⚠ Configuration warnings:');
+  for (const w of configValidation.warnings) {
+    console.warn(`  - ${w}`);
+  }
+  console.warn('');
+}
+
+server.listen(CONFIG.port, CONFIG.host, () => {
+  console.log(`Server running on http://${CONFIG.host || '0.0.0.0'}:${CONFIG.port}`);
+  console.log(`Auth mode: ${CONFIG.skipAuth ? 'SKIP (development)' : 'ENABLED'}`);
+  if (!CONFIG.skipAuth) {
+    console.log(`Users configured: ${CONFIG.users.length}`);
+    console.log(`Email verification: ${isEmailConfigured() ? 'ENABLED' : 'DISABLED'}`);
+  }
+});
+
+// =====================
+// 优雅关闭（Graceful Shutdown）
+// =====================
+async function gracefulShutdown(signal) {
+  console.log(`\n[Shutdown] Received ${signal}, starting graceful shutdown...`);
+
+  // 1. 通知所有 web client 服务即将更新
+  const updateMsg = { type: 'server_updating' };
+  for (const [, client] of webClients) {
+    try {
+      await sendToWebClient(client, updateMsg);
+    } catch (e) { /* ignore send errors during shutdown */ }
+  }
+
+  // 2. 短暂等待，确保消息发送完毕
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // 3. 关闭所有 WebSocket 连接
+  for (const [, client] of webClients) {
+    try { client.ws.close(1012, 'Server restarting'); } catch (e) {}
+  }
+  for (const [, agent] of agents) {
+    try { agent.ws.close(1012, 'Server restarting'); } catch (e) {}
+  }
+
+  // 4. 停止接受新连接
+  server.close(() => {
+    console.log('[Shutdown] HTTP server closed');
+    // Flush pending user stats before closing DB
+    flushUserStats();
+    closeDb();
+    process.exit(0);
+  });
+
+  // 5. 强制退出兜底（5 秒超时）
+  setTimeout(() => {
+    console.warn('[Shutdown] Forced exit after timeout');
+    process.exit(1);
+  }, 5000);
+}
+
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));

package/local-runtime/server/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@yeaft/webchat-server",
+  "version": "1.0.0",
+  "description": "Central WebSocket server for Yeaft Web Code Agent",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js",
+    "dev:noauth": "cross-env SKIP_AUTH=true nodemon index.js",
+    "dev:auth": "nodemon index.js"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "homepage": "https://github.com/yeaft/claude-web-chat",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yeaft/claude-web-chat.git",
+    "directory": "server"
+  },
+  "bugs": {
+    "url": "https://github.com/yeaft/claude-web-chat/issues"
+  },
+  "license": "MIT",
+  "author": "Yeaft",
+  "devDependencies": {
+    "cross-env": "^10.1.0",
+    "nodemon": "^3.1.14"
+  },
+  "nodemonConfig": {
+    "watch": [
+      "*.js"
+    ],
+    "ignore": [
+      "node_modules",
+      "package-lock.json"
+    ],
+    "ext": "js"
+  },
+  "dependencies": {
+    "bcrypt": "^6.0.0",
+    "compression": "^1.8.1",
+    "dotenv": "^16.3.1",
+    "express": "^4.22.2",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.2.0",
+    "nodemailer": "^9.0.3",
+    "qrcode": "^1.5.4",
+    "speakeasy": "^2.0.0",
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-util": "^0.15.1",
+    "ws": "^8.21.0"
+  }
+}

package/local-runtime/server/perf-trace.js

@@ -0,0 +1,154 @@
+import { appendFileSync, mkdirSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const MAX_QUEUE_SIZE = 5000;
+const MAX_STRING_LENGTH = 512;
+const DEFAULT_FLUSH_INTERVAL_MS = 1000;
+const DEFAULT_TRACE_DIR = process.env.SERVER_DATA_DIR
+  ? join(process.env.SERVER_DATA_DIR, 'perf-traces')
+  : join(__dirname, 'data', 'perf-traces');
+const DEFAULT_RETENTION_DAYS = 3;
+let lastCleanupDay = null;
+
+let flushTimer = null;
+const queue = [];
+
+function enabled() {
+  return process.env.PERF_TRACE_DISABLED !== 'true';
+}
+
+function traceDir() {
+  return process.env.PERF_TRACE_DIR || DEFAULT_TRACE_DIR;
+}
+
+function retentionDays() {
+  const raw = Number(process.env.PERF_TRACE_RETENTION_DAYS || DEFAULT_RETENTION_DAYS);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_RETENTION_DAYS;
+}
+
+function cleanupOldTraceFiles(dir) {
+  const day = new Date().toISOString().slice(0, 10);
+  if (lastCleanupDay === day) return;
+  lastCleanupDay = day;
+  const cutoff = Date.now() - retentionDays() * 24 * 60 * 60 * 1000;
+  try {
+    for (const file of readdirSync(dir)) {
+      const match = file.match(/^(\d{4}-\d{2}-\d{2})\.jsonl$/);
+      if (!match) continue;
+      const ts = Date.parse(`${match[1]}T00:00:00.000Z`);
+      if (Number.isFinite(ts) && ts < cutoff) rmSync(join(dir, file), { force: true });
+    }
+  } catch {
+    // best-effort; trace writes must never break relay
+  }
+}
+
+function nowWall() {
+  return Date.now();
+}
+
+function sanitizeString(value, max = MAX_STRING_LENGTH) {
+  if (typeof value !== 'string') return value;
+  return value.length > max ? `${value.slice(0, max)}...[truncated]` : value;
+}
+
+function sanitizeValue(value, depth = 0) {
+  if (value == null) return value;
+  if (typeof value === 'string') return sanitizeString(value);
+  if (typeof value === 'number' || typeof value === 'boolean') return value;
+  if (Array.isArray(value)) {
+    if (depth >= 4) return `[array:${value.length}]`;
+    return value.slice(0, 50).map(v => sanitizeValue(v, depth + 1));
+  }
+  if (typeof value === 'object') {
+    if (depth >= 4) return '[object]';
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (key === 'text' || key === 'prompt' || key === 'content' || key === 'data' || key === 'apiKey' || key === 'token') continue;
+      out[key] = sanitizeValue(item, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+
+function normalizeEvent(event = {}) {
+  const traceId = typeof event.traceId === 'string' && event.traceId.trim()
+    ? event.traceId.trim()
+    : (typeof event.perfTraceId === 'string' && event.perfTraceId.trim() ? event.perfTraceId.trim() : null);
+  const phase = typeof event.phase === 'string' && event.phase.trim() ? event.phase.trim() : 'unknown';
+  const source = typeof event.source === 'string' && event.source.trim() ? event.source.trim() : 'unknown';
+  return {
+    traceId,
+    source,
+    phase,
+    at: Number.isFinite(event.at) ? event.at : nowWall(),
+    monotonicMs: Number.isFinite(event.monotonicMs) ? event.monotonicMs : null,
+    durationMs: Number.isFinite(event.durationMs) ? event.durationMs : null,
+    userId: event.userId || null,
+    agentId: event.agentId || null,
+    sessionId: event.sessionId || null,
+    vpId: event.vpId || null,
+    turnId: event.turnId || null,
+    threadId: event.threadId || null,
+    messageType: event.messageType || null,
+    bytes: Number.isFinite(event.bytes) ? event.bytes : null,
+    ok: typeof event.ok === 'boolean' ? event.ok : null,
+    detail: sanitizeValue(event.detail || null),
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function scheduleFlush() {
+  if (flushTimer || !enabled()) return;
+  const delay = Number(process.env.PERF_TRACE_FLUSH_INTERVAL_MS || DEFAULT_FLUSH_INTERVAL_MS);
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    try { flushPerfTraceEvents(); }
+    catch (err) { console.warn('[PerfTrace] flush failed:', err?.message || err); }
+  }, Number.isFinite(delay) && delay >= 0 ? delay : DEFAULT_FLUSH_INTERVAL_MS);
+  if (typeof flushTimer.unref === 'function') flushTimer.unref();
+}
+
+export function recordPerfTraceEvent(event) {
+  if (!enabled()) return false;
+  const normalized = normalizeEvent(event);
+  if (!normalized.traceId) return false;
+  if (queue.length >= MAX_QUEUE_SIZE) queue.shift();
+  queue.push(normalized);
+  scheduleFlush();
+  return true;
+}
+
+export function flushPerfTraceEvents() {
+  if (!enabled() || queue.length === 0) return 0;
+  const batch = queue.splice(0, queue.length);
+  const day = new Date().toISOString().slice(0, 10);
+  const dir = traceDir();
+  mkdirSync(dir, { recursive: true });
+  cleanupOldTraceFiles(dir);
+  const file = join(dir, `${day}.jsonl`);
+  appendFileSync(file, batch.map(row => JSON.stringify(row)).join('\n') + '\n');
+  return batch.length;
+}
+
+export async function closePerfTraceStore() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  try { flushPerfTraceEvents(); } catch { /* best-effort */ }
+}
+
+export const __perfTraceForTest = {
+  normalizeEvent,
+  sanitizeValue,
+  queue,
+  traceDir,
+  cleanupOldTraceFiles,
+};