@yeaft/webchat-agent 1.0.413 → 1.0.415

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

@@ -2,6 +2,7 @@ import { agents, userFileTabs } from '../context.js';
 import {
   sendToWebClient, forwardToAgent, broadcastAgentList
 } from '../ws-utils.js';
+import { resolveWorkbenchRequest } from '../workbench-route.js';
 
 // Only Agents that explicitly advertise the package-replacement-safe updater
 // may receive remote upgrade commands. Version thresholds are insufficient:
@@ -73,11 +74,18 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
 
     // File Tab 状态保存/恢复
     case 'update_file_tabs': {
-      if (client.userId && client.currentAgent) {
-        const key = `${client.userId}:${client.currentAgent}`;
+      const ftAgentId = msg.agentId || client.currentAgent;
+      if (client.userId && ftAgentId) {
+        if (!await checkAgentAccess(ftAgentId)) break;
+        const resolved = resolveWorkbenchRequest(client, msg, ftAgentId);
+        if (!resolved) break;
+        const identity = resolved.routeKey
+          ? `${resolved.routeKey}\u0000${resolved.workspaceGeneration}`
+          : ftAgentId;
+        const key = `${client.userId}:${identity}`;
         userFileTabs.set(key, {
           files: (msg.openFiles || []).map(f => ({ path: f.path })),
-          activeIndex: msg.activeIndex || 0,
+          activeIndex: Number.isFinite(msg.activeIndex) ? msg.activeIndex : 0,
           timestamp: Date.now()
         });
       }
@@ -88,10 +96,19 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       const ftAgentId = msg.agentId || client.currentAgent;
       if (client.userId && ftAgentId) {
         if (!await checkAgentAccess(ftAgentId)) break;
-        const key = `${client.userId}:${ftAgentId}`;
+        const resolved = resolveWorkbenchRequest(client, msg, ftAgentId);
+        if (!resolved) break;
+        const identity = resolved.routeKey
+          ? `${resolved.routeKey}\u0000${resolved.workspaceGeneration}`
+          : ftAgentId;
+        const key = `${client.userId}:${identity}`;
         const saved = userFileTabs.get(key);
         await sendToWebClient(client, {
           type: 'file_tabs_restored',
+          agentId: ftAgentId,
+          conversationId: resolved.conversationId || msg.conversationId || client.currentConversation,
+          workbenchRouteKey: resolved.routeKey,
+          workbenchWorkspaceGeneration: resolved.workspaceGeneration,
           openFiles: saved?.files || [],
           activeIndex: saved?.activeIndex || 0
         });

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

@@ -3,6 +3,13 @@ import {
   sendToWebClient, forwardToAgent,
   verifyConversationOwnership, getCachedDir
 } from '../ws-utils.js';
+import { resolveWorkbenchRequest } from '../workbench-route.js';
+import {
+  deleteWorkbenchRequest,
+  getWorkbenchTerminalOwner,
+  registerWorkbenchRequest,
+  registerWorkbenchTerminalOwner,
+} from '../workbench-correlation.js';
 
 /**
  * Handle workbench messages from web client (terminal, file, git operations).
@@ -25,6 +32,101 @@ function isYeaftVirtualConversation(conversationId) {
   return typeof conversationId === 'string' && conversationId.startsWith('yeaft-');
 }
 
+async function denyWorkbenchRoute(client, msg) {
+  console.warn(`[Security] Invalid Workbench route for ${msg?.type || 'unknown'}`);
+  await sendToWebClient(client, { type: 'error', message: 'Invalid Workbench Session route' });
+}
+
+const RESPONSE_TYPES = Object.freeze({
+  terminal_create: ['terminal_created', 'terminal_error'],
+  read_file: ['file_content'],
+  write_file: ['file_saved'],
+  list_directory: ['directory_listing'],
+  git_status: ['git_status_result'],
+  git_diff: ['git_diff_result'],
+  git_add: ['git_op_result'],
+  git_reset: ['git_op_result'],
+  git_restore: ['git_op_result'],
+  git_commit: ['git_op_result'],
+  git_push: ['git_op_result'],
+  file_search: ['file_search_result'],
+  create_file: ['file_op_result'],
+  delete_files: ['file_op_result'],
+  move_files: ['file_op_result'],
+  copy_files: ['file_op_result'],
+  upload_to_dir: ['file_op_result'],
+});
+
+function canonicalWorkbenchMessage(msg, resolved, { canonicalWorkDir = false } = {}) {
+  const {
+    _requestUserId: _ignoredUserId,
+    _requestClientId: _ignoredClientId,
+    _workbenchRequestId: _ignoredRequestId,
+    ...clientFields
+  } = msg || {};
+  if (resolved.legacy) return {
+    ...clientFields,
+    ...(resolved.conversationId ? { conversationId: resolved.conversationId } : {}),
+  };
+  return {
+    ...clientFields,
+    agentId: resolved.agentId,
+    conversationId: resolved.conversationId,
+    workDir: canonicalWorkDir ? resolved.workDir : resolved.requestedWorkDir,
+    workbenchRoute: resolved.route,
+    workbenchRouteKey: resolved.routeKey,
+    workbenchWorkspaceGeneration: resolved.workspaceGeneration,
+  };
+}
+
+function correlateWorkbenchRequest({ agentId, clientId, client, msg, resolved, canonical }) {
+  if (resolved.legacy) {
+    return {
+      ...canonical,
+      _requestUserId: client.userId,
+      _requestClientId: clientId,
+    };
+  }
+  const expectedResponseTypes = RESPONSE_TYPES[msg.type];
+  if (!expectedResponseTypes) return canonical;
+  const registration = {
+    agentId,
+    clientId,
+    userId: client.userId,
+    routeKey: resolved.routeKey,
+    conversationId: resolved.conversationId,
+    workspaceGeneration: resolved.workspaceGeneration,
+    route: resolved.route,
+    role: client.role,
+    requestType: msg.type,
+    expectedResponseTypes,
+    publicRequestId: typeof msg.requestId === 'string' ? msg.requestId : null,
+    terminalId: msg.terminalId || null,
+  };
+  const requestId = registerWorkbenchRequest(registration);
+  if (!requestId) return null;
+  if (msg.type === 'terminal_create'
+      && !registerWorkbenchTerminalOwner({ ...registration, requestId })) {
+    deleteWorkbenchRequest({ agentId, requestId });
+    return null;
+  }
+  return { ...canonical, _workbenchRequestId: requestId };
+}
+
+async function forwardCorrelatedWorkbenchRequest({ agentId, clientId, client, msg, resolved, canonical }) {
+  const outbound = correlateWorkbenchRequest({ agentId, clientId, client, msg, resolved, canonical });
+  if (!outbound) return false;
+  try {
+    await forwardToAgent(agentId, outbound);
+    return true;
+  } catch (error) {
+    if (outbound._workbenchRequestId) {
+      deleteWorkbenchRequest({ agentId, requestId: outbound._workbenchRequestId });
+    }
+    throw error;
+  }
+}
+
 export async function handleClientWorkbench(clientId, client, msg, checkAgentAccess) {
   switch (msg.type) {
     // Terminal messages (forward to agent)
@@ -35,19 +137,56 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       const termAgentId = msg.agentId || client.currentAgent;
       if (!termAgentId) return;
       if (!await checkAgentAccess(termAgentId)) return;
-      const termConvId = msg.conversationId || client.currentConversation;
+      const resolved = resolveWorkbenchRequest(client, msg, termAgentId, {
+        allowMissingSession: msg.type === 'terminal_close',
+      });
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      const termConvId = resolved.conversationId || msg.conversationId || client.currentConversation;
       if (!termConvId) return;
-      if (!CONFIG.skipAuth && !isYeaftVirtualConversation(termConvId) && !verifyConversationOwnership(termConvId, client.userId, client.role)) {
+      if (resolved.legacy && !CONFIG.skipAuth && !isYeaftVirtualConversation(termConvId) && !verifyConversationOwnership(termConvId, client.userId, client.role)) {
         console.warn(`[Security] User ${client.userId} terminal access denied for ${termConvId}`);
         await sendToWebClient(client, { type: 'error', message: 'Permission denied' });
         return;
       }
-      await forwardToAgent(termAgentId, {
-        ...msg,
-        conversationId: termConvId,
-        _requestUserId: client.userId,
-        _requestClientId: clientId,
+      let terminalResolved = { ...resolved, conversationId: termConvId };
+      if (!resolved.legacy && msg.type !== 'terminal_create') {
+        const owner = getWorkbenchTerminalOwner(termAgentId, msg.terminalId);
+        const ownerMatches = owner
+          && owner.clientId === clientId
+          && owner.userId === client.userId
+          && owner.routeKey === resolved.routeKey
+          && owner.conversationId === termConvId;
+        const generationMatches = msg.type === 'terminal_close'
+          ? msg.workbenchWorkspaceGeneration === owner?.workspaceGeneration
+          : owner?.workspaceGeneration === resolved.workspaceGeneration;
+        if (!ownerMatches || !generationMatches) {
+          await denyWorkbenchRoute(client, msg);
+          return;
+        }
+        if (msg.type === 'terminal_close') {
+          terminalResolved = {
+            ...terminalResolved,
+            workspaceGeneration: owner.workspaceGeneration,
+          };
+        }
+      }
+      const forwarded = await forwardCorrelatedWorkbenchRequest({
+        agentId: termAgentId,
+        clientId,
+        client,
+        msg,
+        resolved: terminalResolved,
+        canonical: canonicalWorkbenchMessage(msg, terminalResolved, {
+          canonicalWorkDir: msg.type === 'terminal_create',
+        }),
       });
+      if (!forwarded) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
       break;
     }
 
@@ -55,13 +194,20 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       const fileAgentId = msg.agentId || client.currentAgent;
       if (!fileAgentId) { console.warn('[Server] read_file: no agentId'); return; }
       if (!await checkAgentAccess(fileAgentId)) return;
-      const fileConvId = msg.conversationId || client.currentConversation || '_explorer';
+      const resolved = resolveWorkbenchRequest(client, msg, fileAgentId);
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      const fileConvId = resolved.conversationId || msg.conversationId || client.currentConversation || '_explorer';
       console.log(`[Server] Forwarding read_file to agent ${fileAgentId}, conv=${fileConvId}, path=${msg.filePath}`);
-      await forwardToAgent(fileAgentId, {
-        ...msg,
-        conversationId: fileConvId,
-        _requestUserId: client.userId,
-        _requestClientId: clientId,
+      await forwardCorrelatedWorkbenchRequest({
+        agentId: fileAgentId,
+        clientId,
+        client,
+        msg,
+        resolved,
+        canonical: canonicalWorkbenchMessage(msg, { ...resolved, conversationId: fileConvId }),
       });
       break;
     }
@@ -70,20 +216,27 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       const writeAgentId = msg.agentId || client.currentAgent;
       if (!writeAgentId) return;
       if (!await checkAgentAccess(writeAgentId)) return;
-      const writeConvId = msg.conversationId || client.currentConversation || '_explorer';
+      const resolved = resolveWorkbenchRequest(client, msg, writeAgentId);
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      const writeConvId = resolved.conversationId || msg.conversationId || client.currentConversation || '_explorer';
       const isAgentLevelWrite = writeConvId.startsWith('_') || isYeaftVirtualConversation(writeConvId);
-      if (!isAgentLevelWrite) {
+      if (resolved.legacy && !isAgentLevelWrite) {
         if (!CONFIG.skipAuth && !verifyConversationOwnership(writeConvId, client.userId, client.role)) {
           console.warn(`[Security] User ${client.userId} file write denied for ${writeConvId}`);
           await sendToWebClient(client, { type: 'error', message: 'Permission denied' });
           return;
         }
       }
-      await forwardToAgent(writeAgentId, {
-        ...msg,
-        conversationId: writeConvId,
-        _requestUserId: client.userId,
-        _requestClientId: clientId,
+      await forwardCorrelatedWorkbenchRequest({
+        agentId: writeAgentId,
+        clientId,
+        client,
+        msg,
+        resolved,
+        canonical: canonicalWorkbenchMessage(msg, { ...resolved, conversationId: writeConvId }),
       });
       break;
     }
@@ -93,28 +246,40 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       if (!dirAgentId) return;
       if (!await checkAgentAccess(dirAgentId)) return;
 
-      // 先查缓存
-      const cached = getCachedDir(dirAgentId, msg.dirPath);
+      const resolved = resolveWorkbenchRequest(client, msg, dirAgentId);
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      const canonical = canonicalWorkbenchMessage(msg, {
+        ...resolved,
+        conversationId: resolved.conversationId || msg.conversationId || client.currentConversation || '_explorer',
+      });
+
+      // Route-scoped requests bypass the legacy Agent/path cache. Relative
+      // paths can mean different directories in sibling Sessions.
+      const cached = resolved.legacy ? getCachedDir(dirAgentId, canonical.dirPath) : null;
       if (cached) {
         await sendToWebClient(client, {
           type: 'directory_listing',
-          conversationId: msg.conversationId,
-          requestId: msg.requestId,
-          dirPath: msg.dirPath,
+          agentId: dirAgentId,
+          conversationId: canonical.conversationId,
+          requestId: canonical.requestId,
+          workbenchRouteKey: canonical.workbenchRouteKey,
+          dirPath: canonical.dirPath,
           entries: cached,
           fromCache: true
         });
         return;
       }
 
-      await forwardToAgent(dirAgentId, {
-        type: 'list_directory',
-        dirPath: msg.dirPath,
-        workDir: msg.workDir,
-        conversationId: msg.conversationId || client.currentConversation,
-        requestId: msg.requestId,
-        _requestUserId: client.userId,
-        _requestClientId: clientId
+      await forwardCorrelatedWorkbenchRequest({
+        agentId: dirAgentId,
+        clientId,
+        client,
+        msg,
+        resolved,
+        canonical: { ...canonical, type: 'list_directory' },
       });
       break;
     }
@@ -130,10 +295,18 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       const gitAgentId = msg.agentId || client.currentAgent;
       if (!gitAgentId) return;
       if (!await checkAgentAccess(gitAgentId)) return;
-      await forwardToAgent(gitAgentId, {
-        ...msg,
-        conversationId: msg.conversationId || client.currentConversation,
-        _requestUserId: client.userId
+      const resolved = resolveWorkbenchRequest(client, msg, gitAgentId);
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      await forwardCorrelatedWorkbenchRequest({
+        agentId: gitAgentId,
+        clientId,
+        client,
+        msg,
+        resolved,
+        canonical: canonicalWorkbenchMessage(msg, resolved),
       });
       break;
     }
@@ -146,10 +319,18 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
       const fopAgentId = msg.agentId || client.currentAgent;
       if (!fopAgentId) return;
       if (!await checkAgentAccess(fopAgentId)) return;
-      await forwardToAgent(fopAgentId, {
-        ...msg,
-        conversationId: msg.conversationId || client.currentConversation,
-        _requestUserId: client.userId
+      const resolved = resolveWorkbenchRequest(client, msg, fopAgentId);
+      if (!resolved) {
+        await denyWorkbenchRoute(client, msg);
+        return;
+      }
+      await forwardCorrelatedWorkbenchRequest({
+        agentId: fopAgentId,
+        clientId,
+        client,
+        msg,
+        resolved,
+        canonical: canonicalWorkbenchMessage(msg, resolved),
       });
       break;
     }

package/local-runtime/server/workbench-correlation.js

@@ -0,0 +1,184 @@
+import { randomUUID } from 'node:crypto';
+
+const REQUEST_TTL_MS = 2 * 60 * 1000;
+const MAX_PENDING = 4096;
+
+const pendingRequests = new Map();
+const terminalOwners = new Map();
+
+function requestKey(agentId, requestId) {
+  return `${String(agentId || '')}\u0000${String(requestId || '')}`;
+}
+
+function terminalKey(agentId, terminalId) {
+  return `${String(agentId || '')}\u0000${String(terminalId || '')}`;
+}
+
+function releasePendingTerminalReservation(pending) {
+  if (pending?.timeout) clearTimeout(pending.timeout);
+  if (!pending?.terminalId) return;
+  const key = terminalKey(pending.agentId, pending.terminalId);
+  const owner = terminalOwners.get(key);
+  if (owner?.pendingRequestId === pending.requestId) terminalOwners.delete(key);
+}
+
+function prune(now = Date.now()) {
+  for (const [key, pending] of pendingRequests) {
+    if (pending && pending.expiresAt > now) continue;
+    pendingRequests.delete(key);
+    releasePendingTerminalReservation(pending);
+  }
+}
+
+export function registerWorkbenchRequest({
+  agentId,
+  clientId,
+  userId,
+  routeKey,
+  conversationId,
+  workspaceGeneration,
+  route,
+  role = null,
+  requestType,
+  expectedResponseTypes,
+  publicRequestId = null,
+  terminalId = null,
+}) {
+  if (!agentId || !clientId || !userId || !routeKey || !conversationId
+      || !workspaceGeneration || !requestType) return null;
+  const expected = Array.isArray(expectedResponseTypes)
+    ? expectedResponseTypes.filter(Boolean)
+    : [];
+  if (expected.length === 0) return null;
+  prune();
+  while (pendingRequests.size >= MAX_PENDING) {
+    const oldest = pendingRequests.keys().next().value;
+    if (oldest == null) break;
+    const evicted = pendingRequests.get(oldest);
+    pendingRequests.delete(oldest);
+    releasePendingTerminalReservation(evicted);
+  }
+  const requestId = randomUUID();
+  const key = requestKey(agentId, requestId);
+  const pending = {
+    agentId,
+    requestId,
+    clientId,
+    userId,
+    routeKey,
+    conversationId,
+    workspaceGeneration,
+    route: route ? { ...route } : null,
+    role,
+    requestType,
+    expectedResponseTypes: new Set(expected),
+    publicRequestId,
+    terminalId,
+    expiresAt: Date.now() + REQUEST_TTL_MS,
+    timeout: null,
+  };
+  pending.timeout = setTimeout(() => {
+    const current = pendingRequests.get(key);
+    if (current !== pending) return;
+    pendingRequests.delete(key);
+    releasePendingTerminalReservation(pending);
+  }, REQUEST_TTL_MS);
+  pending.timeout.unref?.();
+  pendingRequests.set(key, pending);
+  return requestId;
+}
+
+export function consumeWorkbenchRequest({ agentId, requestId, responseType, routeKey = null }) {
+  if (!agentId || !requestId || !responseType) return null;
+  prune();
+  const key = requestKey(agentId, requestId);
+  const pending = pendingRequests.get(key);
+  if (!pending || !pending.expectedResponseTypes.has(responseType)) return null;
+  if (routeKey && pending.routeKey !== routeKey) return null;
+  pendingRequests.delete(key);
+  if (pending.timeout) clearTimeout(pending.timeout);
+  pending.timeout = null;
+  return pending;
+}
+
+export function deleteWorkbenchRequest({ agentId, requestId }) {
+  const key = requestKey(agentId, requestId);
+  const pending = pendingRequests.get(key);
+  const deleted = pendingRequests.delete(key);
+  if (deleted) releasePendingTerminalReservation(pending);
+  return deleted;
+}
+
+export function registerWorkbenchTerminalOwner(pending) {
+  if (!pending?.agentId || !pending?.terminalId || !pending?.clientId
+      || !pending?.userId || !pending?.routeKey || !pending?.workspaceGeneration) return false;
+  const key = terminalKey(pending.agentId, pending.terminalId);
+  const existing = terminalOwners.get(key);
+  if (existing && (
+    existing.clientId !== pending.clientId
+    || existing.userId !== pending.userId
+    || existing.routeKey !== pending.routeKey
+    || existing.workspaceGeneration !== pending.workspaceGeneration
+    || existing.conversationId !== pending.conversationId
+  )) return false;
+  terminalOwners.set(key, {
+    agentId: pending.agentId,
+    terminalId: pending.terminalId,
+    clientId: pending.clientId,
+    userId: pending.userId,
+    routeKey: pending.routeKey,
+    conversationId: pending.conversationId,
+    workspaceGeneration: pending.workspaceGeneration,
+    pendingRequestId: pending.requestId || pending.pendingRequestId || null,
+  });
+  return true;
+}
+
+export function getWorkbenchTerminalOwner(agentId, terminalId) {
+  return terminalOwners.get(terminalKey(agentId, terminalId)) || null;
+}
+
+export function deleteWorkbenchTerminalOwner(agentId, terminalId) {
+  return terminalOwners.delete(terminalKey(agentId, terminalId));
+}
+
+export function clearWorkbenchCorrelationsForClient(clientId) {
+  if (!clientId) return [];
+  for (const [key, pending] of pendingRequests) {
+    if (pending?.clientId !== clientId) continue;
+    pendingRequests.delete(key);
+    releasePendingTerminalReservation(pending);
+  }
+  const terminals = [];
+  for (const [key, owner] of terminalOwners) {
+    if (owner?.clientId !== clientId) continue;
+    terminals.push(owner);
+    terminalOwners.delete(key);
+  }
+  return terminals;
+}
+
+export function clearWorkbenchCorrelationsForAgent(agentId) {
+  if (!agentId) return;
+  for (const [key, pending] of pendingRequests) {
+    if (pending?.agentId !== agentId) continue;
+    pendingRequests.delete(key);
+    releasePendingTerminalReservation(pending);
+  }
+  for (const [key, owner] of terminalOwners) {
+    if (owner?.agentId === agentId) terminalOwners.delete(key);
+  }
+}
+
+export function __testResetWorkbenchCorrelations() {
+  for (const pending of pendingRequests.values()) releasePendingTerminalReservation(pending);
+  pendingRequests.clear();
+  terminalOwners.clear();
+}
+
+export function __testExpireWorkbenchRequest(agentId, requestId) {
+  const pending = pendingRequests.get(requestKey(agentId, requestId));
+  if (!pending) return false;
+  pending.expiresAt = 0;
+  return true;
+}