@yeaft/webchat-agent 1.0.387 → 1.0.389

package/connection/index.js

@@ -25,6 +25,7 @@ export function connect(WebSocketImpl = WebSocket) {
     name: ctx.CONFIG.agentName,
     instanceId,
     workDir: ctx.CONFIG.workDir,
+    platform: process.platform,
     capabilities: ctx.agentCapabilities.join(',')
   });
 
@@ -72,7 +73,8 @@ export function connect(WebSocketImpl = WebSocket) {
           tempId: msg.tempId,
           secret: ctx.CONFIG.agentSecret,
           capabilities: ctx.agentCapabilities,
-          version: ctx.agentVersion
+          version: ctx.agentVersion,
+          platform: process.platform
         }));
         return;
       }

package/local-runtime/server/context.js

@@ -37,6 +37,84 @@ export const userFileTabs = new Map();
 // fileId → { buffer, mimeType, filename, createdAt, token }
 export const previewFiles = new Map();
 
+// Debug trace replies may come from an older Agent that does not echo the
+// private browser client id. Keep the correlation on the Server, where the
+// original Agent/Session ownership check happened, and consume it exactly once.
+const YEAFT_DEBUG_REQUEST_TTL_MS = 30_000;
+const YEAFT_DEBUG_REQUEST_MAX_PENDING = 2048;
+export const pendingYeaftDebugRequests = new Map();
+
+function yeaftDebugRequestKey(agentId, requestId) {
+  return `${String(agentId || '')}\u0000${String(requestId || '')}`;
+}
+
+function pruneYeaftDebugRequests(now = Date.now()) {
+  for (const [key, pending] of pendingYeaftDebugRequests) {
+    if (!pending || pending.expiresAt <= now || !webClients.has(pending.clientId)) {
+      pendingYeaftDebugRequests.delete(key);
+    }
+  }
+}
+
+/**
+ * Register one owner-checked browser request before forwarding it to an Agent.
+ * @param {{agentId:string, requestId:string, sessionId:string, clientId:string, userId:string}} request
+ * @returns {boolean}
+ */
+export function registerYeaftDebugRequest({ agentId, requestId, sessionId, clientId, userId }) {
+  if (!agentId || !requestId || !sessionId || !clientId || !userId) return false;
+  const now = Date.now();
+  pruneYeaftDebugRequests(now);
+  const key = yeaftDebugRequestKey(agentId, requestId);
+  if (pendingYeaftDebugRequests.has(key)) return false;
+  if (pendingYeaftDebugRequests.size >= YEAFT_DEBUG_REQUEST_MAX_PENDING) {
+    const oldestKey = pendingYeaftDebugRequests.keys().next().value;
+    if (oldestKey != null) pendingYeaftDebugRequests.delete(oldestKey);
+  }
+  pendingYeaftDebugRequests.set(key, {
+    agentId,
+    requestId,
+    sessionId,
+    clientId,
+    userId,
+    expiresAt: now + YEAFT_DEBUG_REQUEST_TTL_MS,
+  });
+  return true;
+}
+
+/**
+ * Consume a matching, unexpired correlation exactly once.
+ * @param {{agentId:string, requestId:string, sessionId?:string|null}} response
+ * @returns {{agentId:string, requestId:string, sessionId:string, clientId:string, userId:string, expiresAt:number}|null}
+ */
+export function consumeYeaftDebugRequest({ agentId, requestId, sessionId }) {
+  if (!agentId || !requestId) return null;
+  const now = Date.now();
+  pruneYeaftDebugRequests(now);
+  const key = yeaftDebugRequestKey(agentId, requestId);
+  const pending = pendingYeaftDebugRequests.get(key);
+  if (!pending) return null;
+  if (sessionId && pending.sessionId !== sessionId) return null;
+  pendingYeaftDebugRequests.delete(key);
+  return pending;
+}
+
+/** Remove one correlation after forwarding fails. */
+export function deleteYeaftDebugRequest({ agentId, requestId, clientId = null }) {
+  const key = yeaftDebugRequestKey(agentId, requestId);
+  const pending = pendingYeaftDebugRequests.get(key);
+  if (!pending || (clientId && pending.clientId !== clientId)) return false;
+  return pendingYeaftDebugRequests.delete(key);
+}
+
+/** Remove all correlations owned by a disconnected browser client. */
+export function clearYeaftDebugRequestsForClient(clientId) {
+  if (!clientId) return;
+  for (const [key, pending] of pendingYeaftDebugRequests) {
+    if (pending?.clientId === clientId) pendingYeaftDebugRequests.delete(key);
+  }
+}
+
 // Admin dashboard usage stats.
 // userId → { requests, bytesSent, bytesReceived, messages, sessions }
 // `messages` is user turn count. bytesSent/bytesReceived are message traffic

package/local-runtime/server/handlers/agent-output.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { messageDb, sessionUiMetadataDb, yeaftProjectDb, yeaftSessionDb } from '../database.js';
 import { transaction } from '../db/connection.js';
 import { broadcastAgentList, broadcastSessionCatalog, forwardToClients, sendToAgent, sendToWebClient } from '../ws-utils.js';
-import { webClients, previewFiles } from '../context.js';
+import { consumeYeaftDebugRequest, webClients, previewFiles } from '../context.js';
 import { CONFIG } from '../config.js';
 import { yeaftAssetStore } from '../yeaft-asset-store.js';
 import { recordPerfTraceEvent } from '../perf-trace.js';
@@ -987,32 +987,43 @@ export async function handleAgentOutput(agentId, agent, msg) {
       break;
     }
 
-    case 'yeaft_debug_history':
-      // Relay the file-backed debug trace snapshot from the agent to the web
-      // client that requested it via `yeaft_fetch_debug_history`. Keep the
-      // paging/detail flags intact; otherwise the store cannot distinguish a
-      // bounded index refresh from a single-request detail hydration.
-      for (const [, c] of webClients) {
-        if (c.authenticated && (CONFIG.skipAuth || c.userId === agent.ownerId)) {
-          await sendToWebClient(c, {
-            type: 'yeaft_debug_history',
-            loops: Array.isArray(msg.loops) ? msg.loops : [],
-            turns: Array.isArray(msg.turns) ? msg.turns : [],
-            dreamEvents: Array.isArray(msg.dreamEvents) ? msg.dreamEvents : [],
-            ...(msg.sessionId != null ? { sessionId: msg.sessionId } : {}),
-            ...(msg.threadId != null ? { threadId: msg.threadId } : {}),
-            ...(msg.requestId != null ? { requestId: msg.requestId } : {}),
-            ...(msg.requestKind != null ? { requestKind: msg.requestKind } : {}),
-            ...(msg.search != null ? { search: msg.search } : {}),
-            ...(msg.hasMore != null ? { hasMore: !!msg.hasMore } : {}),
-            ...(msg.limit != null ? { limit: msg.limit } : {}),
-            ...(msg.indexOnly != null ? { indexOnly: !!msg.indexOnly } : {}),
-            ...(msg.detailTurnId != null ? { detailTurnId: msg.detailTurnId } : {}),
-            ...(msg.error != null ? { error: msg.error } : {}),
-          });
-        }
+    case 'yeaft_debug_history': {
+      // Debug history is request/Turn scoped and may contain raw provider or
+      // tool payloads. The Server registered this Agent + requestId after the
+      // compound Session ownership check, so rolling upgrades remain safe even
+      // when an older Agent does not echo the private browser client id.
+      const pending = consumeYeaftDebugRequest({
+        agentId,
+        requestId: msg.requestId,
+        sessionId: msg.sessionId,
+      });
+      const targetClient = pending ? webClients.get(pending.clientId) : null;
+      const ownerMatches = CONFIG.skipAuth || (
+        pending?.userId === agent.ownerId
+        && targetClient?.userId === pending.userId
+      );
+      if (targetClient?.authenticated && ownerMatches) {
+        await sendToWebClient(targetClient, {
+          type: 'yeaft_debug_history',
+          agentId,
+          loops: Array.isArray(msg.loops) ? msg.loops : [],
+          turns: Array.isArray(msg.turns) ? msg.turns : [],
+          dreamEvents: Array.isArray(msg.dreamEvents) ? msg.dreamEvents : [],
+          ...(msg.projection && typeof msg.projection === 'object' ? { projection: msg.projection } : {}),
+          ...(msg.sessionId != null ? { sessionId: msg.sessionId } : {}),
+          ...(msg.threadId != null ? { threadId: msg.threadId } : {}),
+          ...(msg.requestId != null ? { requestId: msg.requestId } : {}),
+          ...(msg.requestKind != null ? { requestKind: msg.requestKind } : {}),
+          ...(msg.search != null ? { search: msg.search } : {}),
+          ...(msg.hasMore != null ? { hasMore: !!msg.hasMore } : {}),
+          ...(msg.limit != null ? { limit: msg.limit } : {}),
+          ...(msg.indexOnly != null ? { indexOnly: !!msg.indexOnly } : {}),
+          ...(msg.detailTurnId != null ? { detailTurnId: msg.detailTurnId } : {}),
+          ...(msg.error != null ? { error: msg.error } : {}),
+        });
       }
       break;
+    }
 
     default:
       return false; // Not handled

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

@@ -8,7 +8,14 @@ import {
   yeaftSessionDb,
   sessionUiMetadataDb,
 } from '../database.js';
-import { agents, pendingFiles, trackUserTurn, webClients } from '../context.js';
+import {
+  agents,
+  deleteYeaftDebugRequest,
+  pendingFiles,
+  registerYeaftDebugRequest,
+  trackUserTurn,
+  webClients,
+} from '../context.js';
 import {
   sendToWebClient, forwardToAgent,
   broadcastAgentList, broadcastSessionCatalog, buildSessionCatalog, buildHiddenSessionCatalog,
@@ -1288,6 +1295,45 @@ export async function handleClientConversation(clientId, client, msg, checkAgent
       break;
     }
 
+    case 'yeaft_fetch_debug_history': {
+      // Debug traces can contain raw prompts, provider payloads, and tool
+      // output. Treat this as a precise Session-owned request instead of the
+      // generic Yeaft relay: require the compound Agent + Session identity and
+      // correlate the response back to the requesting browser tab.
+      const debugAgentId = msg.agentId;
+      const debugSessionId = typeof msg.sessionId === 'string' ? msg.sessionId : '';
+      const debugRequestId = typeof msg.requestId === 'string' ? msg.requestId : '';
+      if (!debugAgentId || !debugSessionId || !debugRequestId) return;
+      if (!await checkAgentAccess(debugAgentId)) return;
+      if (!CONFIG.skipAuth && !yeaftSessionDb.getForAgent(client.userId, debugAgentId, debugSessionId)) return;
+      const registered = registerYeaftDebugRequest({
+        agentId: debugAgentId,
+        requestId: debugRequestId,
+        sessionId: debugSessionId,
+        clientId,
+        userId: client.userId,
+      });
+      if (!registered) return;
+      try {
+        await forwardToAgent(debugAgentId, {
+          type: 'yeaft_fetch_debug_history',
+          sessionId: debugSessionId,
+          requestId: debugRequestId,
+          requestKind: msg.requestKind === 'detail' ? 'detail' : 'list',
+          limit: typeof msg.limit === 'number' ? msg.limit : 10,
+          dreamLimit: typeof msg.dreamLimit === 'number' ? msg.dreamLimit : 5,
+          indexOnly: msg.indexOnly === true,
+          detailTurnId: typeof msg.detailTurnId === 'string' ? msg.detailTurnId : null,
+          search: typeof msg.search === 'string' ? msg.search.slice(0, 500) : '',
+          _requestClientId: clientId,
+        });
+      } catch (err) {
+        deleteYeaftDebugRequest({ agentId: debugAgentId, requestId: debugRequestId, clientId });
+        throw err;
+      }
+      break;
+    }
+
     case 'yeaft_load_history_outline': {
       const outlineAgentId = msg.agentId;
       const outlineSessionId = typeof msg.sessionId === 'string' ? msg.sessionId : '';

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

@@ -8,8 +8,14 @@ import {
 // builds without this capability may still inherit the installed package cwd.
 export const SAFE_REMOTE_UPGRADE_CAPABILITY = 'remote_upgrade_safe';
 
-export function requiresManualUpgradeBridge(capabilities) {
-  return !Array.isArray(capabilities) || !capabilities.includes(SAFE_REMOTE_UPGRADE_CAPABILITY);
+export function requiresManualUpgradeBridge(capabilities, platform = null) {
+  if (Array.isArray(capabilities) && capabilities.includes(SAFE_REMOTE_UPGRADE_CAPABILITY)) return false;
+  const normalizedPlatform = typeof platform === 'string' ? platform.trim().toLowerCase() : '';
+  if (normalizedPlatform) return normalizedPlatform === 'win32';
+  // v1.0.373 predates explicit platform metadata but advertises this Linux-only
+  // capability, so it is safe to distinguish from the affected Windows build.
+  if (Array.isArray(capabilities) && capabilities.includes('work_item_attachments')) return false;
+  return true;
 }
 
 /**
@@ -36,7 +42,7 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       if (!upgradeAgentId) break;
       if (!await checkAgentAccess(upgradeAgentId)) break;
       const upgradeAgent = agents.get(upgradeAgentId);
-      if (requiresManualUpgradeBridge(upgradeAgent?.capabilities)) {
+      if (requiresManualUpgradeBridge(upgradeAgent?.capabilities, upgradeAgent?.platform)) {
         await sendToWebClient(client, {
           type: 'upgrade_agent_ack',
           agentId: upgradeAgentId,

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

@@ -54,6 +54,7 @@ export function handleAgentConnection(ws, url) {
   const agentName = url.searchParams.get('name') || `Agent-${clientAgentId.slice(0, 8)}`;
   const instanceId = url.searchParams.get('instanceId') || clientAgentId;
   const workDir = url.searchParams.get('workDir') || '';
+  const urlPlatform = url.searchParams.get('platform') || null;
 
   // Both authenticated and SKIP_AUTH connections use the existing auth frame
   // for registration metadata. Released Agents already send their version there;
@@ -118,6 +119,9 @@ export function handleAgentConnection(ws, url) {
 
           const capabilities = Array.isArray(msg.capabilities) ? msg.capabilities : urlCapabilities;
           const agentVersion = msg.version || null;
+          const agentPlatform = typeof msg.platform === 'string' && msg.platform
+            ? msg.platform
+            : urlPlatform;
           // Local no-auth mode still has one durable browser owner. This makes
           // the server-side Session catalog persistent without changing generic
           // development-server behavior, which remains ownerless.
@@ -149,6 +153,7 @@ export function handleAgentConnection(ws, url) {
             ownerUsername,
             agentVersion,
             registeredInstanceId,
+            agentPlatform,
           );
           pruneAgentConnectionGenerations();
         }
@@ -233,7 +238,7 @@ function handleAgentDisconnect(agentId, agentName, ws) {
   broadcastAgentList();
 }
 
-function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey, capabilities = [], ownerId = null, ownerUsername = null, agentVersion = null, instanceId = null) {
+function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey, capabilities = [], ownerId = null, ownerUsername = null, agentVersion = null, instanceId = null, agentPlatform = null) {
   // 如果是重连，保留 conversations；否则（server 重启）创建空 Map
   const existingAgent = agents.get(agentId);
   const conversations = existingAgent?.conversations || new Map();
@@ -270,6 +275,7 @@ function completeAgentRegistration(ws, agentId, agentName, workDir, sessionKey,
     ownerId,
     ownerUsername,
     version: agentVersion,
+    platform: agentPlatform,
     encryptOutbound
   });
 

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

@@ -5,7 +5,7 @@ import { generateSkipAuthSession } from './auth.js';
 import { authenticateRequest } from './auth/request-auth.js';
 import { encodeKey } from './encryption.js';
 import { userDb } from './database.js';
-import { agents, webClients, isHeartbeatMessageType, trackRequest } from './context.js';
+import { agents, clearYeaftDebugRequestsForClient, webClients, isHeartbeatMessageType, trackRequest } from './context.js';
 import {
   parseMessage, sendToWebClient, sendToAgent,
   broadcastAgentList, resolveAgentAccessError
@@ -163,6 +163,7 @@ export function handleWebConnection(ws, url, req = {}) {
       }
     }
     clearWorkCenterRequestsForClient(client);
+    clearYeaftDebugRequestsForClient(clientId);
     webClients.delete(clientId);
     console.log(`Web client disconnected: ${clientId}`);
   });

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.387"}
+{"version":"1.0.389"}