@yeaft/webchat-agent 1.0.414 → 1.0.415

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

@@ -0,0 +1,180 @@
+import { CONFIG } from './config.js';
+import { agents } from './context.js';
+import { sessionDb } from './db/session-db.js';
+import { yeaftSessionDb } from './db/yeaft-session-db.js';
+
+export const WORKBENCH_SESSION_ROUTE_CAPABILITY = 'workbench_session_routes';
+
+const PROVIDERS = new Set(['yeaft', 'claude-code', 'copilot']);
+const SCOPES = new Set(['main', 'files-folder-picker', 'git-folder-picker']);
+
+function clean(value, maxLength = 300) {
+  if (typeof value !== 'string') return '';
+  const result = value.trim();
+  return result && result.length <= maxLength ? result : '';
+}
+
+export function workbenchRouteKey(route) {
+  const runtimeProvider = clean(route?.runtimeProvider, 32);
+  const agentId = clean(route?.agentId);
+  const sessionId = clean(route?.sessionId);
+  if (!PROVIDERS.has(runtimeProvider) || !agentId || !sessionId) return '';
+  return [runtimeProvider, agentId, sessionId]
+    .map(part => encodeURIComponent(part))
+    .join(':');
+}
+
+function stableWorkspaceHash(value) {
+  let hash = 0xcbf29ce484222325n;
+  for (const char of String(value || '')) {
+    hash ^= BigInt(char.codePointAt(0));
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return hash.toString(16).padStart(16, '0');
+}
+
+export function workbenchWorkspaceGeneration(routeKey, workDir) {
+  const normalizedRouteKey = clean(routeKey, 1200);
+  const normalizedWorkDir = clean(workDir, 4096);
+  if (!normalizedRouteKey || !normalizedWorkDir) return '';
+  return `${normalizedRouteKey}@${stableWorkspaceHash(normalizedWorkDir)}`;
+}
+
+export function workbenchConversationId(route, scope = 'main') {
+  const routeKey = workbenchRouteKey(route);
+  if (!routeKey) return '';
+  const normalizedScope = SCOPES.has(scope) ? scope : 'main';
+  return normalizedScope === 'main'
+    ? `_workbench:${routeKey}`
+    : `_workbench:${routeKey}:${normalizedScope}`;
+}
+
+export function workbenchRouteKeyFromConversationId(conversationId, expectedAgentId = '') {
+  const raw = clean(conversationId, 4096);
+  if (!raw.startsWith('_workbench:')) return '';
+  const parts = raw.slice('_workbench:'.length).split(':');
+  if (parts.length < 3) return '';
+  const routeKey = parts.slice(0, 3).join(':');
+  try {
+    const decodedRoute = {
+      runtimeProvider: decodeURIComponent(parts[0]),
+      agentId: decodeURIComponent(parts[1]),
+      sessionId: decodeURIComponent(parts[2]),
+    };
+    if (expectedAgentId && decodedRoute.agentId !== expectedAgentId) return '';
+    return workbenchRouteKey(decodedRoute) === routeKey ? routeKey : '';
+  } catch {
+    return '';
+  }
+}
+
+function resolveYeaftRow(client, route) {
+  if (client?.userId) {
+    const owned = yeaftSessionDb.getForAgent(client.userId, route.agentId, route.sessionId);
+    if (owned) return owned;
+  }
+  const agent = agents.get(route.agentId);
+  if (!CONFIG.skipAuth) {
+    if (client?.role !== 'admin' || agent?.ownerId) return null;
+    return agent?.yeaftSessions?.get(route.sessionId) || null;
+  }
+  return agent?.yeaftSessions?.get(route.sessionId)
+    || yeaftSessionDb.getByAgent(route.agentId).find(row => row?.id === route.sessionId)
+    || null;
+}
+
+function resolveChatRow(client, route) {
+  const row = sessionDb.get(route.sessionId);
+  if (!row || row.agent_id !== route.agentId) return null;
+  const provider = row.provider === 'copilot' ? 'copilot' : 'claude-code';
+  if (provider !== route.runtimeProvider) return null;
+  if (!CONFIG.skipAuth) {
+    if (!client?.userId) return null;
+    if (row.user_id) {
+      if (row.user_id !== client.userId) return null;
+    } else if (client.role !== 'admin' && agents.get(route.agentId)?.ownerId !== client.userId) {
+      return null;
+    }
+  }
+  return row;
+}
+
+/**
+ * Validate a browser-provided Workbench route against Server-owned Session
+ * metadata and return canonical execution fields. Browser cwd and synthetic
+ * conversation ids are never authoritative.
+ *
+ * `legacy: true` preserves old clients that predate route-scoped Workbench.
+ */
+export function currentWorkbenchWorkspaceGeneration({ route, userId, role }) {
+  if (!route || !userId) return '';
+  const client = { userId, role };
+  const row = route.runtimeProvider === 'yeaft'
+    ? resolveYeaftRow(client, route)
+    : resolveChatRow(client, route);
+  if (!row || row.isArchived) return '';
+  const workDir = clean(route.runtimeProvider === 'yeaft' ? row.workDir : row.work_dir, 4096);
+  return workbenchWorkspaceGeneration(workbenchRouteKey(route), workDir);
+}
+
+export function resolveWorkbenchRequest(client, msg, targetAgentId, { allowMissingSession = false } = {}) {
+  const agent = agents.get(targetAgentId);
+  const agentSupportsRoutes = Array.isArray(agent?.capabilities)
+    && agent.capabilities.includes(WORKBENCH_SESSION_ROUTE_CAPABILITY);
+  const clientSupportsRoutes = client?.workbenchRouteProtocol === 1;
+
+  if (!msg?.workbenchRoute) {
+    // Legacy is a negotiated pairing, not a caller-selected downgrade. Once
+    // either side speaks the route protocol, route-less Workbench is invalid.
+    if (clientSupportsRoutes || agentSupportsRoutes) return null;
+    return {
+      legacy: true,
+      agentId: targetAgentId,
+      conversationId: clean(msg?.conversationId) || null,
+      workDir: clean(msg?.workDir, 4096),
+      routeKey: '',
+    };
+  }
+
+  if (!clientSupportsRoutes || !agentSupportsRoutes) return null;
+  const route = {
+    runtimeProvider: clean(msg.workbenchRoute.runtimeProvider, 32),
+    agentId: clean(msg.workbenchRoute.agentId),
+    sessionId: clean(msg.workbenchRoute.sessionId),
+  };
+  const routeKey = workbenchRouteKey(route);
+  if (!routeKey || route.agentId !== targetAgentId) return null;
+
+  const row = route.runtimeProvider === 'yeaft'
+    ? resolveYeaftRow(client, route)
+    : resolveChatRow(client, route);
+  if (row?.isArchived && !allowMissingSession) return null;
+  if (!row && !allowMissingSession) return null;
+
+  let scope = SCOPES.has(msg.workbenchScope) ? msg.workbenchScope : 'main';
+  if (scope === 'main') {
+    if (msg.conversationId === '_folder_picker') scope = 'files-folder-picker';
+    else if (msg.conversationId === '_git_folder_picker') scope = 'git-folder-picker';
+  }
+  const sessionWorkDir = clean(row
+    ? (route.runtimeProvider === 'yeaft' ? row.workDir : row.work_dir)
+    : '', 4096);
+  const workspaceGeneration = sessionWorkDir
+    ? workbenchWorkspaceGeneration(routeKey, sessionWorkDir)
+    : clean(msg.workbenchWorkspaceGeneration, 1600);
+  if (!workspaceGeneration && !allowMissingSession) return null;
+  return {
+    legacy: false,
+    route,
+    routeKey,
+    scope,
+    agentId: route.agentId,
+    conversationId: workbenchConversationId(route, scope),
+    // Terminal is pinned to this Server-owned cwd. Git and Files retain their
+    // existing Agent-path picker and use requestedWorkDir after route auth.
+    workDir: sessionWorkDir,
+    requestedWorkDir: clean(msg.workDir, 4096) || sessionWorkDir,
+    workspaceGeneration,
+    archived: row?.isArchived === true,
+  };
+}

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

@@ -15,6 +15,7 @@ import { handleAgentWorkCenter } from './handlers/agent-work-center.js';
 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 { markAgentHeartbeatSeen } from './heartbeat-policy.js';
 
 /**
@@ -227,6 +228,7 @@ function handleAgentDisconnect(agentId, agentName, ws) {
   if (!agent || agent.ws !== ws) return;
   // Phase 4: 清理目录缓存
   clearAgentDirCache(agentId);
+  clearWorkbenchCorrelationsForAgent(agentId);
   // Phase 1: 清理同步超时
   if (agent._syncTimeout) {
     clearTimeout(agent._syncTimeout);
@@ -245,6 +247,7 @@ function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey,
   const proxyPorts = (existingAgent?.proxyPorts || []).map(p => ({ ...p, enabled: false }));
   const slashCommands = existingAgent?.slashCommands || [];
   const slashCommandDescriptions = existingAgent?.slashCommandDescriptions || {};
+  const yeaftSessions = existingAgent?.yeaftSessions || new Map();
   if (existingAgent?._syncTimeout) clearTimeout(existingAgent._syncTimeout);
 
   // 兼容旧版 agent：未上报 capabilities 时默认全部开启
@@ -271,6 +274,7 @@ function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey,
     proxyPorts,
     slashCommands,
     slashCommandDescriptions,
+    yeaftSessions,
     status: 'syncing',
     ownerId,
     ownerUsername,

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

@@ -6,6 +6,8 @@ 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 { clearWorkbenchCorrelationsForClient } from './workbench-correlation.js';
 import {
   parseMessage, sendToWebClient, sendToAgent,
   broadcastAgentList, resolveAgentAccessError
@@ -76,7 +78,9 @@ export function handleWebConnection(ws, url, req = {}) {
     // (= old client, encrypt outbound for back-compat). Flipped to
     // `false` when the client sends `client_hello { plaintextOk: true }`
     // — see early dispatch in handleWebMessage.
-    encryptOutbound: true
+    encryptOutbound: true,
+    // Explicit Workbench protocol negotiation. Zero means legacy Web.
+    workbenchRouteProtocol: 0,
   });
 
   // 心跳响应处理
@@ -103,6 +107,7 @@ export function handleWebConnection(ws, url, req = {}) {
       role,
       acceptPlaintext: true,
       yeaftSessionInventoryComplete: true,
+      workbenchRouteProtocol: WORKBENCH_ROUTE_PROTOCOL,
     }));
     setTimeout(() => broadcastAgentList(), 100);
   } else {
@@ -164,6 +169,18 @@ export function handleWebConnection(ws, url, req = {}) {
     }
     clearWorkCenterRequestsForClient(client);
     clearYeaftDebugRequestsForClient(clientId);
+    const ownedTerminals = clearWorkbenchCorrelationsForClient(clientId);
+    for (const owner of ownedTerminals) {
+      const agent = agents.get(owner.agentId);
+      if (!agent) continue;
+      void sendToAgent(agent, {
+        type: 'terminal_close',
+        terminalId: owner.terminalId,
+        conversationId: owner.conversationId,
+        workbenchRouteKey: owner.routeKey,
+        workbenchWorkspaceGeneration: owner.workspaceGeneration,
+      }).catch(error => console.warn('[Workbench] PTY disconnect cleanup failed:', error.message));
+    }
     webClients.delete(clientId);
     console.log(`Web client disconnected: ${clientId}`);
   });
@@ -195,10 +212,15 @@ async function handleWebMessage(clientId, msg) {
   // Old clients never send this; their per-client `encryptOutbound` flag
   // stays `true` and we keep the ciphertext path.
   if (msg.type === 'client_hello') {
-    if (msg.plaintextOk === true) {
-      client.encryptOutbound = false;
+    const wasEncrypted = client.encryptOutbound;
+    applyClientHello(client, msg);
+    if (wasEncrypted && client.encryptOutbound === false) {
       console.log(`[WS] Client ${clientId} negotiated plaintext mode`);
     }
+    await sendToWebClient(client, {
+      type: 'client_hello_ack',
+      workbenchRouteProtocol: client.workbenchRouteProtocol,
+    });
     return;
   }
 

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.414"}
+{"version":"1.0.415"}