@yeaft/webchat-agent 1.0.186 → 1.0.189

package/local-runtime/server/proxy.js

@@ -0,0 +1,273 @@
+import { randomUUID } from 'crypto';
+import { WebSocket, WebSocketServer } from 'ws';
+import { agents, pendingProxyRequests, proxyWsConnections } from './context.js';
+import { sendToAgent, findAgentByName } from './ws-utils.js';
+
+export function registerProxyRoutes(app) {
+  app.all('/agent/:agentName/:port/*', handleProxyRequest);
+  app.all('/agent/:agentName/:port', handleProxyRequest);
+}
+
+async function handleProxyRequest(req, res) {
+  // No JWT authentication for proxy routes — external services need direct access.
+  // Access control is enforced by the port enable/disable mechanism in ProxyTab.
+
+  const { agentName, port } = req.params;
+  const portNum = parseInt(port);
+  if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+    return res.status(400).send('Invalid port');
+  }
+
+  const found = findAgentByName(agentName);
+  if (!found || found.agent.ws.readyState !== WebSocket.OPEN) {
+    return res.status(502).send('Agent not connected');
+  }
+
+  // Check if this port is enabled for proxy
+  const proxyPorts = found.agent.proxyPorts || [];
+  const portConfig = proxyPorts.find(p => p.port === portNum);
+  if (!portConfig || !portConfig.enabled) {
+    return res.status(403).send('Port not enabled for proxy');
+  }
+
+  // Handle CORS preflight — respond immediately without forwarding to agent
+  if (req.method === 'OPTIONS') {
+    const origin = req.headers.origin || '*';
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', req.headers['access-control-request-headers'] || 'Content-Type, Authorization');
+    res.setHeader('Access-Control-Allow-Credentials', 'true');
+    res.setHeader('Access-Control-Max-Age', '86400');
+    return res.status(204).end();
+  }
+
+  const requestId = randomUUID();
+  const requestOrigin = req.headers.origin || null;
+
+  // Collect raw body
+  const bodyChunks = [];
+  req.on('data', chunk => bodyChunks.push(chunk));
+  req.on('end', async () => {
+    const body = Buffer.concat(bodyChunks);
+
+    // Build proxy path: strip /agent/:name/:port prefix
+    const proxyPath = req.params[0] ? ('/' + req.params[0]) : '/';
+    const queryString = req.url.includes('?') ? req.url.substring(req.url.indexOf('?')) : '';
+
+    // Clean headers for forwarding
+    const fwdHeaders = { ...req.headers };
+    delete fwdHeaders['host'];
+    const proxyHost = portConfig.host || 'localhost';
+    fwdHeaders['host'] = `${proxyHost}:${portNum}`;
+    delete fwdHeaders['connection'];
+
+    // Build publicOrigin so agent can rewrite localhost URLs in responses
+    const protocol = req.headers['x-forwarded-proto'] || req.protocol || 'https';
+    const publicOrigin = `${protocol}://${req.headers.host}`;
+
+    await sendToAgent(found.agent, {
+      type: 'proxy_request',
+      requestId,
+      port: portNum,
+      host: portConfig.host || 'localhost',
+      scheme: portConfig.scheme || 'http',
+      basePath: `/agent/${agentName}/${portNum}`,
+      publicOrigin,
+      method: req.method,
+      path: proxyPath + queryString,
+      headers: fwdHeaders,
+      body: body.length > 0 ? body.toString('base64') : null
+    });
+
+    const timeout = setTimeout(() => {
+      pendingProxyRequests.delete(requestId);
+      if (!res.headersSent) res.status(504).send('Proxy timeout');
+    }, 60000);
+
+    pendingProxyRequests.set(requestId, { res, timeout, streaming: false, origin: requestOrigin });
+  });
+
+  req.on('error', () => {
+    pendingProxyRequests.delete(requestId);
+  });
+}
+
+// Overwrite CORS headers so browser accepts proxied responses
+function applyCorsHeaders(headers, origin) {
+  if (origin) {
+    headers['access-control-allow-origin'] = origin;
+    headers['access-control-allow-credentials'] = 'true';
+  }
+}
+
+// Handle proxy response messages from agent
+export function handleProxyResponse(msg) {
+  const pending = pendingProxyRequests.get(msg.requestId);
+  if (!pending) return;
+  clearTimeout(pending.timeout);
+  pendingProxyRequests.delete(msg.requestId);
+
+  const headers = msg.headers || {};
+  delete headers['transfer-encoding'];
+  delete headers['connection'];
+  applyCorsHeaders(headers, pending.origin);
+
+  try {
+    pending.res.status(msg.statusCode || 500);
+    for (const [k, v] of Object.entries(headers)) {
+      try { pending.res.setHeader(k, v); } catch(e) {}
+    }
+    if (msg.body) {
+      pending.res.end(Buffer.from(msg.body, 'base64'));
+    } else {
+      pending.res.end();
+    }
+  } catch(e) {
+    console.error('[Proxy] Error sending response:', e.message);
+  }
+}
+
+export function handleProxyResponseChunk(msg) {
+  const pending = pendingProxyRequests.get(msg.requestId);
+  if (!pending) return;
+
+  try {
+    if (!pending.streaming) {
+      pending.streaming = true;
+      clearTimeout(pending.timeout);
+      // Set a longer timeout for streaming responses
+      pending.timeout = setTimeout(() => {
+        pendingProxyRequests.delete(msg.requestId);
+        try { pending.res.end(); } catch(e) {}
+      }, 300000); // 5 minutes for streaming
+
+      pending.res.status(msg.statusCode || 200);
+      const headers = msg.headers || {};
+      delete headers['transfer-encoding'];
+      delete headers['connection'];
+      applyCorsHeaders(headers, pending.origin);
+      for (const [k, v] of Object.entries(headers)) {
+        try { pending.res.setHeader(k, v); } catch(e) {}
+      }
+      pending.res.setHeader('X-Accel-Buffering', 'no');
+      pending.res.flushHeaders();
+    }
+
+    if (msg.chunk) {
+      pending.res.write(Buffer.from(msg.chunk, 'base64'));
+    }
+  } catch(e) {
+    console.error('[Proxy] Error writing chunk:', e.message);
+    pendingProxyRequests.delete(msg.requestId);
+  }
+}
+
+export function handleProxyResponseEnd(msg) {
+  const pending = pendingProxyRequests.get(msg.requestId);
+  if (!pending) return;
+  clearTimeout(pending.timeout);
+  pendingProxyRequests.delete(msg.requestId);
+  try { pending.res.end(); } catch(e) {}
+}
+
+// Handle proxy WebSocket messages from agent to browser
+export function handleProxyWsAgentMessage(msg) {
+  const conn = proxyWsConnections.get(msg.proxyWsId);
+  if (!conn || !conn.browserWs) return;
+
+  switch (msg.type) {
+    case 'proxy_ws_opened':
+      break;
+    case 'proxy_ws_message':
+      try {
+        if (msg.isBinary) {
+          conn.browserWs.send(Buffer.from(msg.data, 'base64'));
+        } else {
+          conn.browserWs.send(msg.data);
+        }
+      } catch(e) {}
+      break;
+    case 'proxy_ws_closed':
+      try { conn.browserWs.close(msg.code || 1000); } catch(e) {}
+      proxyWsConnections.delete(msg.proxyWsId);
+      break;
+    case 'proxy_ws_error':
+      try { conn.browserWs.close(1011, msg.error); } catch(e) {}
+      proxyWsConnections.delete(msg.proxyWsId);
+      break;
+  }
+}
+
+// Handle WebSocket upgrade for proxy connections
+export async function handleProxyWebSocketUpgrade(req, socket, head, match) {
+  const agentName = match[1];
+  const port = parseInt(match[2]);
+  const path = match[3] || '/';
+
+  const found = findAgentByName(agentName);
+  if (!found || found.agent.ws.readyState !== WebSocket.OPEN) {
+    socket.destroy();
+    return;
+  }
+
+  // Check if port is enabled
+  const proxyPorts = found.agent.proxyPorts || [];
+  const portConfig = proxyPorts.find(p => p.port === port);
+  if (!portConfig || !portConfig.enabled) {
+    socket.destroy();
+    return;
+  }
+
+  // Create a temporary WSS for this upgrade
+  const proxyWss = new WebSocketServer({ noServer: true });
+  proxyWss.handleUpgrade(req, socket, head, async (browserWs) => {
+    const proxyWsId = randomUUID();
+
+    proxyWsConnections.set(proxyWsId, {
+      browserWs,
+      agentId: found.id
+    });
+
+    // Forward browser messages to agent
+    browserWs.on('message', async (data, isBinary) => {
+      await sendToAgent(found.agent, {
+        type: 'proxy_ws_message',
+        proxyWsId,
+        data: isBinary ? data.toString('base64') : data.toString(),
+        isBinary
+      });
+    });
+
+    browserWs.on('close', async (code) => {
+      proxyWsConnections.delete(proxyWsId);
+      await sendToAgent(found.agent, {
+        type: 'proxy_ws_close',
+        proxyWsId,
+        code
+      });
+    });
+
+    browserWs.on('error', () => {
+      proxyWsConnections.delete(proxyWsId);
+    });
+
+    // Tell agent to open WS connection to localhost:port
+    const fwdHeaders = { ...req.headers };
+    delete fwdHeaders['host'];
+    delete fwdHeaders['upgrade'];
+    delete fwdHeaders['connection'];
+    delete fwdHeaders['sec-websocket-key'];
+    delete fwdHeaders['sec-websocket-version'];
+    delete fwdHeaders['sec-websocket-extensions'];
+
+    await sendToAgent(found.agent, {
+      type: 'proxy_ws_open',
+      proxyWsId,
+      port,
+      host: portConfig.host || 'localhost',
+      scheme: portConfig.scheme || 'http',
+      path,
+      headers: fwdHeaders
+    });
+  });
+}

package/local-runtime/server/routes/admin-routes.js

@@ -0,0 +1,207 @@
+import { WebSocket } from 'ws';
+import { userStatsDb } from '../database.js';
+import { agents, webClients, userStatsDeltas } from '../context.js';
+
+const toNumber = (value) => Number(value) || 0;
+
+function emptyAgentMetrics() {
+  return {
+    totalTurns: 0,
+    chatTurns: 0,
+    yeaftTurns: 0,
+    sessionsCreated: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    lastUpdatedAt: null,
+  };
+}
+
+function safeAgentMetrics(metrics = {}) {
+  const out = emptyAgentMetrics();
+  for (const key of Object.keys(out)) {
+    if (key === 'lastUpdatedAt') continue;
+    out[key] = toNumber(metrics[key]);
+  }
+  out.lastUpdatedAt = metrics.lastUpdatedAt || null;
+  if (!out.totalTurns) out.totalTurns = out.chatTurns + out.yeaftTurns;
+  if (!out.totalTokens) out.totalTokens = out.inputTokens + out.outputTokens + out.cacheReadTokens + out.cacheWriteTokens;
+  return out;
+}
+
+function sumAgentMetrics() {
+  const totals = emptyAgentMetrics();
+  for (const [, agent] of agents) {
+    const metrics = safeAgentMetrics(agent.metrics || {});
+    totals.totalTurns += metrics.totalTurns;
+    totals.chatTurns += metrics.chatTurns;
+    totals.yeaftTurns += metrics.yeaftTurns;
+    totals.sessionsCreated += metrics.sessionsCreated;
+    totals.inputTokens += metrics.inputTokens;
+    totals.outputTokens += metrics.outputTokens;
+    totals.cacheReadTokens += metrics.cacheReadTokens;
+    totals.cacheWriteTokens += metrics.cacheWriteTokens;
+    totals.totalTokens += metrics.totalTokens;
+    if (metrics.lastUpdatedAt && (!totals.lastUpdatedAt || metrics.lastUpdatedAt > totals.lastUpdatedAt)) {
+      totals.lastUpdatedAt = metrics.lastUpdatedAt;
+    }
+  }
+  return totals;
+}
+
+function mergePendingUserStats(stats) {
+  const byUser = new Map(stats.map(row => [row.user_id, { ...row }]));
+  for (const [userId, delta] of userStatsDeltas) {
+    const row = byUser.get(userId);
+    if (!row) {
+      byUser.set(userId, {
+        user_id: userId,
+        username: userId,
+        display_name: userId,
+        role: 'pro',
+        last_login_at: null,
+        updated_at: Date.now(),
+        message_count: toNumber(delta.messages),
+        session_count: toNumber(delta.sessions),
+        request_count: toNumber(delta.requests),
+        bytes_sent: toNumber(delta.bytesSent),
+        bytes_received: toNumber(delta.bytesReceived),
+      });
+      continue;
+    }
+    row.message_count = toNumber(row.message_count) + toNumber(delta.messages);
+    row.session_count = toNumber(row.session_count) + toNumber(delta.sessions);
+    row.request_count = toNumber(row.request_count) + toNumber(delta.requests);
+    row.bytes_sent = toNumber(row.bytes_sent) + toNumber(delta.bytesSent);
+    row.bytes_received = toNumber(row.bytes_received) + toNumber(delta.bytesReceived);
+  }
+  return Array.from(byUser.values());
+}
+
+function pendingTodayMessages() {
+  let count = 0;
+  for (const delta of userStatsDeltas.values()) count += toNumber(delta.messages);
+  return count;
+}
+
+/**
+ * Register admin-only REST API routes for the dashboard.
+ */
+export function registerAdminRoutes(app, { requireAuth, requireAdmin }) {
+  // GET /api/admin/dashboard — aggregated overview
+  app.get('/api/admin/dashboard', requireAuth, requireAdmin, (req, res) => {
+    try {
+      const totals = userStatsDb.getDashboardTotals();
+      const onlineUsers = new Set();
+      for (const [, client] of webClients) {
+        if (client.authenticated && client.userId) {
+          onlineUsers.add(client.userId);
+        }
+      }
+      let onlineAgents = 0;
+      for (const [, agent] of agents) {
+        if (agent.ws.readyState === WebSocket.OPEN) onlineAgents++;
+      }
+
+      const agentMetrics = sumAgentMetrics();
+      const tokenTotals = userStatsDb.getDashboardTokenTotals();
+      res.json({
+        totalUsers: totals.total_users,
+        totalSessions: totals.total_sessions,
+        totalMessages: totals.total_messages,
+        onlineUsers: onlineUsers.size,
+        onlineAgents,
+        todayActiveUsers: userStatsDb.getTodayActiveUsers(),
+        todayMessages: userStatsDb.getTodayMessages() + pendingTodayMessages(),
+        agentMetrics,
+        totalAgentTurns: agentMetrics.totalTurns,
+        totalTokens: toNumber(tokenTotals.total_tokens)
+      });
+    } catch (e) {
+      console.error('[Admin] Dashboard error:', e.message);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // GET /api/admin/user-stats — per-user stats list (supports ?period=today|week|month|all)
+  app.get('/api/admin/user-stats', requireAuth, requireAdmin, (req, res) => {
+    try {
+      const period = req.query.period || 'all';
+      const validPeriods = ['today', 'week', 'month', 'all'];
+      const stats = mergePendingUserStats(userStatsDb.getByPeriod(validPeriods.includes(period) ? period : 'all'));
+      res.json(stats.map(s => ({
+        userId: s.user_id,
+        username: s.username,
+        displayName: s.display_name,
+        role: s.role,
+        messageCount: s.message_count,
+        sessionCount: s.session_count,
+        requestCount: s.request_count,
+        bytesSent: s.bytes_sent,
+        bytesReceived: s.bytes_received,
+        inputTokens: s.input_tokens,
+        outputTokens: s.output_tokens,
+        cacheReadTokens: s.cache_read_tokens,
+        cacheWriteTokens: s.cache_write_tokens,
+        totalTokens: s.total_tokens,
+        lastLoginAt: s.last_login_at,
+        updatedAt: s.updated_at
+      })));
+    } catch (e) {
+      console.error('[Admin] User stats error:', e.message);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // GET /api/admin/agents — full agent list (no owner filtering)
+  app.get('/api/admin/agents', requireAuth, requireAdmin, (req, res) => {
+    try {
+      const agentList = Array.from(agents.entries()).map(([id, agent]) => ({
+        id,
+        name: agent.name,
+        workDir: agent.workDir,
+        online: agent.ws.readyState === WebSocket.OPEN,
+        status: agent.status || 'ready',
+        latency: agent.latency || null,
+        version: agent.version || null,
+        ownerId: agent.ownerId || null,
+        ownerUsername: agent.ownerUsername || null,
+        capabilities: agent.capabilities || [],
+        conversationCount: agent.conversations?.size || 0,
+        metrics: safeAgentMetrics(agent.metrics || {}),
+        metricsUpdatedAt: agent.metricsUpdatedAt || null
+      }));
+      res.json(agentList);
+    } catch (e) {
+      console.error('[Admin] Agents error:', e.message);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // GET /api/admin/online-users — currently connected web clients
+  app.get('/api/admin/online-users', requireAuth, requireAdmin, (req, res) => {
+    try {
+      // Deduplicate by userId, keep the most active connection
+      const userMap = new Map();
+      for (const [, client] of webClients) {
+        if (!client.authenticated || !client.userId) continue;
+        const existing = userMap.get(client.userId);
+        if (!existing || client.currentAgent) {
+          userMap.set(client.userId, {
+            userId: client.userId,
+            username: client.username,
+            role: client.role,
+            currentAgent: client.currentAgent || null,
+            currentAgentName: client.currentAgent ? (agents.get(client.currentAgent)?.name || null) : null
+          });
+        }
+      }
+      res.json(Array.from(userMap.values()));
+    } catch (e) {
+      console.error('[Admin] Online users error:', e.message);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+}