@yeaft/webchat-agent 1.0.416 → 1.0.417

package/local-runtime/server/handlers/client-browser.js

@@ -0,0 +1,290 @@
+import { createHash } from 'node:crypto';
+import { CONFIG } from '../config.js';
+import { agents } from '../context.js';
+import { sendToAgent, sendToWebClient } from '../ws-utils.js';
+import {
+  browserPeerMatchesClient,
+  browserServerIdentity,
+  deleteBrowserPeer,
+  getBrowserPeer,
+  getBrowserRoute,
+  mintBrowserIceServers,
+  registerBrowserCreateRequest,
+  registerBrowserRequest,
+  reserveBrowserPeer,
+} from '../browser-runtime-routes.js';
+
+const CLIENT_BROWSER_TYPES = new Set([
+  'browser_session_create',
+  'browser_session_get',
+  'browser_session_list',
+  'browser_session_close',
+  'browser_peer_attach',
+  'browser_peer_answer',
+  'browser_peer_ice_candidate',
+  'browser_peer_detach',
+]);
+
+function clean(value, max = 512) {
+  return typeof value === 'string' ? value.trim().slice(0, max) : '';
+}
+
+function digest(value) {
+  return createHash('sha256').update(JSON.stringify(value || null)).digest('hex');
+}
+
+async function fail(client, msg, code, safeError = code) {
+  await sendToWebClient(client, {
+    type: String(msg.type || '').startsWith('browser_peer_') ? 'browser_peer_error' : 'browser_session_error',
+    requestId: clean(msg.requestId) || null,
+    browserSessionId: clean(msg.browserSessionId) || null,
+    peerId: clean(msg.peerId) || null,
+    connectionGeneration: Number(msg.connectionGeneration) || null,
+    code,
+    safeError,
+  });
+  return true;
+}
+
+function agentSupportsBrowser(agent) {
+  const capabilities = new Set(agent?.capabilities || []);
+  return capabilities.has('browser_runtime')
+    && capabilities.has('browser_webrtc')
+    && (capabilities.has('browser_capture_tab') || capabilities.has('browser_capture_cdp'));
+}
+
+function safeInitialUrl(value) {
+  const raw = clean(value, 4096) || 'about:blank';
+  if (raw === 'about:blank') return raw;
+  try {
+    const url = new URL(raw);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return null;
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
+function canonicalCreate(msg) {
+  const initialUrl = safeInitialUrl(msg.options?.initialUrl);
+  if (!initialUrl) return null;
+  return {
+    sourceRef: msg.sourceRef && typeof msg.sourceRef === 'object' ? {
+      kind: clean(msg.sourceRef.kind, 32),
+      sessionId: clean(msg.sourceRef.sessionId),
+      conversationId: clean(msg.sourceRef.conversationId),
+      workItemId: clean(msg.sourceRef.workItemId),
+    } : null,
+    options: {
+      initialUrl,
+      viewport: {
+        width: Math.min(1920, Math.max(320, Math.floor(Number(msg.options?.viewport?.width) || 1280))),
+        height: Math.min(1080, Math.max(240, Math.floor(Number(msg.options?.viewport?.height) || 720))),
+        deviceScaleFactor: Math.min(2, Math.max(1, Number(msg.options?.viewport?.deviceScaleFactor) || 1)),
+      },
+      locale: clean(msg.options?.locale, 32) || 'en-US',
+      capturePreference: ['auto', 'tab'].includes(msg.options?.capturePreference)
+        ? msg.options.capturePreference : 'auto',
+    },
+  };
+}
+
+function ownerRoute(client, msg) {
+  const route = getBrowserRoute(msg.agentId, msg.browserSessionId);
+  return route && route.ownerUserId === client.userId ? route : null;
+}
+
+/** Owner-checked Web → Server → Agent Browser lifecycle and signaling relay. */
+export async function handleClientBrowser(client, msg, checkAgentAccess) {
+  if (!CLIENT_BROWSER_TYPES.has(msg?.type)) return false;
+  if (!CONFIG.browserRuntime.enabled) return fail(client, msg, 'browser_runtime_disabled');
+  if (client.browserRuntimeProtocol !== 1) return fail(client, msg, 'browser_protocol_required');
+  const agentId = clean(msg.agentId);
+  if (!await checkAgentAccess(agentId)) return true;
+  const agent = agents.get(agentId);
+  if (!agentSupportsBrowser(agent)) return fail(client, msg, 'browser_runtime_unavailable');
+  const requestId = clean(msg.requestId);
+  const requestRequired = msg.type !== 'browser_peer_answer'
+    && msg.type !== 'browser_peer_ice_candidate';
+  if (requestRequired && !requestId) return fail(client, msg, 'browser_request_id_required');
+  const identity = browserServerIdentity(client);
+
+  if (msg.type === 'browser_session_create') {
+    const canonical = canonicalCreate(msg);
+    if (!canonical) return fail(client, msg, 'browser_url_invalid');
+    const registration = registerBrowserCreateRequest({
+      agentId,
+      client,
+      requestId,
+      digest: digest(canonical),
+    });
+    if (registration.conflict) return fail(client, msg, 'browser_request_conflict');
+    if (registration.capacity) return fail(client, msg, 'browser_request_capacity');
+    if (registration.duplicate) {
+      if (registration.request.response) {
+        await sendToWebClient(client, registration.request.response);
+      }
+      return true;
+    }
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      requestId: registration.request.serverRequestId,
+      ...canonical,
+      serverIdentity: identity,
+    });
+    return true;
+  }
+
+  if (msg.type === 'browser_session_list') {
+    const request = registerBrowserRequest({ agentId, client, requestId, kind: msg.type });
+    if (!request) return fail(client, msg, 'browser_request_conflict');
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      requestId: request.serverRequestId,
+      serverIdentity: identity,
+    });
+    return true;
+  }
+
+  if (msg.type === 'browser_peer_attach') {
+    if (!ownerRoute(client, msg)) return fail(client, msg, 'browser_session_not_found');
+    const connectionGeneration = Number(msg.connectionGeneration);
+    const reserved = reserveBrowserPeer({
+      agentId,
+      browserSessionId: clean(msg.browserSessionId),
+      client,
+      requestId,
+      connectionGeneration,
+      role: 'viewer',
+    });
+    if (reserved.error) return fail(client, msg, reserved.error);
+    const peer = reserved.peer;
+    if (reserved.duplicate) {
+      if (peer.state === 'prepared' || peer.state === 'offered' || peer.state === 'connected') {
+        await sendToWebClient(client, {
+          type: 'browser_peer_prepared',
+          agentId,
+          browserSessionId: peer.browserSessionId,
+          peerId: peer.peerId,
+          requestId: peer.requestId,
+          connectionGeneration: peer.connectionGeneration,
+          iceTransportPolicy: peer.iceTransportPolicy,
+          iceServers: peer.webIceServers || [],
+          role: peer.role,
+        });
+        if (peer.pendingOffer) await sendToWebClient(client, peer.pendingOffer);
+      }
+      return true;
+    }
+    const commonScope = {
+      ownerUserId: client.userId,
+      agentId,
+      browserSessionId: peer.browserSessionId,
+      peerId: peer.peerId,
+      connectionGeneration: peer.connectionGeneration,
+    };
+    try {
+      await sendToAgent(agent, {
+        type: 'browser_peer_prepare',
+        agentId,
+        browserSessionId: peer.browserSessionId,
+        peerId: peer.peerId,
+        requestId,
+        connectionGeneration: peer.connectionGeneration,
+        serverIdentity: identity,
+        routeExpiresAt: peer.expiresAt,
+        iceTransportPolicy: CONFIG.browserRuntime.iceTransportPolicy,
+        agentIceServers: mintBrowserIceServers({ ...commonScope, endpointRole: 'agent' }),
+      });
+      peer.webIceServers = mintBrowserIceServers({ ...commonScope, endpointRole: 'web' });
+      peer.state = 'preparing';
+    } catch (error) {
+      deleteBrowserPeer(peer.peerId);
+      return fail(client, msg, 'browser_peer_prepare_failed', String(error?.message || error).slice(0, 500));
+    }
+    return true;
+  }
+
+  if (msg.type === 'browser_session_get' || msg.type === 'browser_session_close') {
+    const route = ownerRoute(client, msg);
+    if (!route) return fail(client, msg, 'browser_session_not_found');
+    const request = registerBrowserRequest({
+      agentId,
+      client,
+      requestId,
+      kind: msg.type,
+      browserSessionId: route.browserSessionId,
+    });
+    if (!request) return fail(client, msg, 'browser_request_conflict');
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      requestId: request.serverRequestId,
+      browserSessionId: route.browserSessionId,
+      ...(msg.type === 'browser_session_close' ? { expectedRevision: Number(msg.expectedRevision) || route.revision } : {}),
+      serverIdentity: identity,
+    });
+    return true;
+  }
+
+  const peer = getBrowserPeer(msg.peerId);
+  if (!browserPeerMatchesClient(peer, client, msg)) return fail(client, msg, 'browser_peer_stale');
+  if (msg.type === 'browser_peer_answer') {
+    const description = msg.description;
+    if (description?.type !== 'answer' || typeof description.sdp !== 'string' || description.sdp.length > 96 * 1024) {
+      return fail(client, msg, 'browser_sdp_invalid');
+    }
+    peer.state = 'answering';
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      browserSessionId: peer.browserSessionId,
+      peerId: peer.peerId,
+      connectionGeneration: peer.connectionGeneration,
+      description: { type: 'answer', sdp: description.sdp },
+      serverIdentity: identity,
+    });
+    return true;
+  }
+  if (msg.type === 'browser_peer_ice_candidate') {
+    if (peer.webCandidateCount >= 128) return fail(client, msg, 'browser_candidate_limit');
+    const candidate = msg.candidate;
+    if (candidate != null && (typeof candidate !== 'object'
+      || typeof candidate.candidate !== 'string'
+      || candidate.candidate.length > 4096)) return fail(client, msg, 'browser_candidate_invalid');
+    peer.webCandidateCount += 1;
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      browserSessionId: peer.browserSessionId,
+      peerId: peer.peerId,
+      connectionGeneration: peer.connectionGeneration,
+      candidate: candidate == null ? null : {
+        candidate: candidate.candidate,
+        sdpMid: clean(candidate.sdpMid, 256) || null,
+        sdpMLineIndex: Number.isInteger(candidate.sdpMLineIndex) ? candidate.sdpMLineIndex : null,
+        usernameFragment: clean(candidate.usernameFragment, 256) || null,
+      },
+      serverIdentity: identity,
+    });
+    return true;
+  }
+  if (msg.type === 'browser_peer_detach') {
+    deleteBrowserPeer(peer.peerId);
+    await sendToAgent(agent, {
+      type: msg.type,
+      agentId,
+      requestId,
+      browserSessionId: peer.browserSessionId,
+      peerId: peer.peerId,
+      connectionGeneration: peer.connectionGeneration,
+      serverIdentity: identity,
+    });
+    return true;
+  }
+  return false;
+}
+
+export { CLIENT_BROWSER_TYPES };

package/local-runtime/server/ws-agent.js

@@ -16,6 +16,8 @@ import { handleAgentFileTerminal } from './handlers/agent-file-terminal.js';
 import { handleAgentSync } from './handlers/agent-sync.js';
 import { recordPerfTraceEvent } from './perf-trace.js';
 import { clearWorkbenchCorrelationsForAgent } from './workbench-correlation.js';
+import { clearBrowserRuntimeForAgent } from './browser-runtime-routes.js';
+import { handleAgentBrowser } from './handlers/agent-browser.js';
 import { markAgentHeartbeatSeen } from './heartbeat-policy.js';
 
 /**
@@ -229,6 +231,7 @@ function handleAgentDisconnect(agentId, agentName, ws) {
   // Phase 4: 清理目录缓存
   clearAgentDirCache(agentId);
   clearWorkbenchCorrelationsForAgent(agentId);
+  clearBrowserRuntimeForAgent(agentId);
   // Phase 1: 清理同步超时
   if (agent._syncTimeout) {
     clearTimeout(agent._syncTimeout);
@@ -294,6 +297,7 @@ function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey,
   agents.get(agentId)._syncTimeout = syncTimeout;
 
   if (existingAgent?.ws && existingAgent.ws !== ws) {
+    clearBrowserRuntimeForAgent(agentId);
     existingAgent.ws.close(1008, 'Superseded by a newer Agent connection');
   }
 
@@ -347,7 +351,9 @@ async function handleAgentMessage(agentId, msg, ws) {
     'yeaft_history_chunk', 'yeaft_history_outline', 'yeaft_history_search_result', 'yeaft_history_window', 'slash_commands_update', 'agent_metrics',
     'file_content', 'file_saved', 'file_op_result', 'file_search_result',
     'git_status_result', 'git_diff_result', 'git_op_result',
-    'terminal_created', 'terminal_output', 'terminal_closed', 'terminal_error'
+    'terminal_created', 'terminal_output', 'terminal_closed', 'terminal_error',
+    'browser_session_created', 'browser_session_error', 'browser_session_snapshot', 'browser_session_list_result',
+    'browser_peer_prepared', 'browser_peer_offer', 'browser_peer_ice_candidate', 'browser_peer_state', 'browser_peer_error'
   ]);
   if (msg.conversationId && !CONV_EXEMPT_TYPES.has(msg.type)) {
     if (!agent.conversations.has(msg.conversationId)) {
@@ -358,6 +364,7 @@ async function handleAgentMessage(agentId, msg, ws) {
 
   // Dispatch to handler sub-modules
   if (await handleAgentConversation(agentId, agent, msg)) return;
+  if (await handleAgentBrowser(agentId, agent, msg)) return;
   if (await handleAgentWorkCenter(agentId, msg)) return;
   if (await handleAgentOutput(agentId, agent, msg)) return;
   if (await handleAgentFileTerminal(agentId, agent, msg)) return;

package/local-runtime/server/ws-client.js

@@ -6,14 +6,16 @@ import { authenticateRequest } from './auth/request-auth.js';
 import { encodeKey } from './encryption.js';
 import { userDb } from './database.js';
 import { agents, clearYeaftDebugRequestsForClient, webClients, isHeartbeatMessageType, trackRequest } from './context.js';
-import { applyClientHello, WORKBENCH_ROUTE_PROTOCOL } from './client-protocol.js';
+import { applyClientHello, BROWSER_RUNTIME_PROTOCOL, WORKBENCH_ROUTE_PROTOCOL } from './client-protocol.js';
 import { clearWorkbenchCorrelationsForClient } from './workbench-correlation.js';
+import { clearBrowserRuntimeForClient } from './browser-runtime-routes.js';
 import {
   parseMessage, sendToWebClient, sendToAgent,
   broadcastAgentList, resolveAgentAccessError
 } from './ws-utils.js';
 import { handleClientConversation } from './handlers/client-conversation.js';
 import { handleClientWorkbench } from './handlers/client-workbench.js';
+import { CLIENT_BROWSER_TYPES, handleClientBrowser } from './handlers/client-browser.js';
 import { handleClientMisc } from './handlers/client-misc.js';
 import { clearWorkCenterRequestsForClient, handleClientWorkCenter } from './handlers/client-work-center.js';
 import { recordPerfTraceEvent } from './perf-trace.js';
@@ -64,7 +66,11 @@ export function handleWebConnection(ws, url, req = {}) {
     }
   }
 
+  const connectionId = randomUUID();
   webClients.set(clientId, {
+    id: clientId,
+    connectionId,
+    connectionGeneration: connectionId,
     ws,
     authenticated,
     username,
@@ -79,8 +85,9 @@ export function handleWebConnection(ws, url, req = {}) {
     // `false` when the client sends `client_hello { plaintextOk: true }`
     // — see early dispatch in handleWebMessage.
     encryptOutbound: true,
-    // Explicit Workbench protocol negotiation. Zero means legacy Web.
+    // Explicit protocols have no omission-based downgrade for security fields.
     workbenchRouteProtocol: 0,
+    browserRuntimeProtocol: 0,
   });
 
   // 心跳响应处理
@@ -108,6 +115,8 @@ export function handleWebConnection(ws, url, req = {}) {
       acceptPlaintext: true,
       yeaftSessionInventoryComplete: true,
       workbenchRouteProtocol: WORKBENCH_ROUTE_PROTOCOL,
+      browserRuntimeProtocol: BROWSER_RUNTIME_PROTOCOL,
+      browserRuntimeEnabled: CONFIG.browserRuntime.enabled,
     }));
     setTimeout(() => broadcastAgentList(), 100);
   } else {
@@ -169,6 +178,24 @@ export function handleWebConnection(ws, url, req = {}) {
     }
     clearWorkCenterRequestsForClient(client);
     clearYeaftDebugRequestsForClient(clientId);
+    const browserPeers = clearBrowserRuntimeForClient(client);
+    for (const peer of browserPeers) {
+      const agent = agents.get(peer.agentId);
+      if (!agent) continue;
+      void sendToAgent(agent, {
+        type: 'browser_peer_detach',
+        agentId: peer.agentId,
+        browserSessionId: peer.browserSessionId,
+        peerId: peer.peerId,
+        connectionGeneration: peer.connectionGeneration,
+        serverIdentity: {
+          ownerUserId: peer.ownerUserId,
+          clientId: peer.clientId,
+          webConnectionId: peer.webConnectionId,
+          webConnectionGeneration: peer.webConnectionGeneration,
+        },
+      }).catch(error => console.warn('[BrowserRuntime] peer disconnect cleanup failed:', error.message));
+    }
     const ownedTerminals = clearWorkbenchCorrelationsForClient(clientId);
     for (const owner of ownedTerminals) {
       const agent = agents.get(owner.agentId);
@@ -192,6 +219,7 @@ export function handleWebConnection(ws, url, req = {}) {
 
 // Workbench 功能（terminal、file、git、proxy）仅 admin/pro 可用
 const WORKBENCH_TYPES = new Set([
+  ...CLIENT_BROWSER_TYPES,
   'terminal_create', 'terminal_input', 'terminal_resize', 'terminal_close',
   'read_file', 'write_file', 'create_file', 'delete_files', 'move_files', 'copy_files', 'upload_to_dir', 'file_search',
   'git_status', 'git_diff', 'git_add', 'git_reset', 'git_restore', 'git_commit', 'git_push',
@@ -220,6 +248,8 @@ async function handleWebMessage(clientId, msg) {
     await sendToWebClient(client, {
       type: 'client_hello_ack',
       workbenchRouteProtocol: client.workbenchRouteProtocol,
+      browserRuntimeProtocol: client.browserRuntimeProtocol,
+      browserRuntimeEnabled: CONFIG.browserRuntime.enabled,
     });
     return;
   }
@@ -246,6 +276,7 @@ async function handleWebMessage(clientId, msg) {
 
   // Dispatch to handler sub-modules
   if (await handleClientConversation(clientId, client, msg, checkAgentAccess)) return;
+  if (await handleClientBrowser(client, msg, checkAgentAccess)) return;
   if (await handleClientWorkbench(clientId, client, msg, checkAgentAccess)) return;
   if (await handleClientWorkCenter(client, msg, checkAgentAccess)) return;
   if (await handleClientMisc(clientId, client, msg, checkAgentAccess)) return;

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.416"}
+{"version":"1.0.417"}