@yeaft/webchat-agent 1.0.351 → 1.0.353

package/connection/message-router.js

@@ -26,7 +26,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { sendAgentMetricsSnapshot } from '../metrics.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
-import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
+import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getTelemetrySettings, updateTelemetrySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
 import { loadConfig } from '../yeaft/config.js';
 import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
@@ -448,6 +448,34 @@ export async function handleMessage(msg) {
       break;
     }
 
+    // Local performance telemetry settings — read/write the `telemetry`
+    // section of config.json. This does not expose trace payloads.
+    case 'get_telemetry_settings': {
+      const settings = getTelemetrySettings(ctx.CONFIG?.yeaftDir);
+      sendToServer({ type: 'telemetry_settings', ...settings });
+      break;
+    }
+
+    case 'update_telemetry_settings': {
+      const result = updateTelemetrySettings(msg.settings || msg.config || {}, ctx.CONFIG?.yeaftDir);
+      if (!result.error) {
+        // Bridge trace producers use the agent-owned config object directly.
+        // The result is the normalized section that was successfully written,
+        // so apply it before refresh can yield and leave no enabled-by-default
+        // gap for diagnostics emitted outside a loaded Session.
+        if (ctx.CONFIG && typeof ctx.CONFIG === 'object') {
+          ctx.CONFIG.telemetry = { ...result };
+        }
+        try {
+          await refreshLiveSessionConfig({});
+        } catch (error) {
+          result.runtimeRefreshError = error?.message || String(error);
+        }
+      }
+      sendToServer({ type: 'telemetry_settings_updated', ...result });
+      break;
+    }
+
     // Search settings (web-search backend + Tavily key) — read/write the
     // `search` section of config.json. `get_tavily_usage` hits Tavily's
     // /usage endpoint with the saved key and is fired from the UI only

package/index.js

@@ -14,6 +14,7 @@ import { getDefaultAgentName, getDefaultYeaftDir, resolveRuntimeIdentity, getCon
 import { loadNodePty } from './terminal.js';
 import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
+import { loadConfig as loadYeaftConfig } from './yeaft/config.js';
 import {
   ensureManagedCliTools,
   prepareManagedCliToolEnvironment,
@@ -105,6 +106,7 @@ const CONFIG = {
   agentName: AGENT_NAME,
   workDir: process.env.WORK_DIR || fileConfig.workDir || process.cwd(),
   yeaftDir: YEAFT_DIR,
+  telemetry: loadYeaftConfig({ dir: YEAFT_DIR }).telemetry,
   reconnectInterval: fileConfig.reconnectInterval,
   agentSecret: process.env.AGENT_SECRET || fileConfig.agentSecret,
   // 显式禁用的工具（非 MCP 相关）

package/local-runtime/server/context.js

@@ -16,7 +16,7 @@ export const pendingProxyRequests = new Map(); // requestId → { res, timeout,
 export const proxyWsConnections = new Map(); // proxyWsId → { browserWs, agentId }
 
 // Store pending agent connections (waiting for auth message)
-// tempId -> { ws, agentId, agentName, workDir, timeout }
+// tempId -> { ws, agentId, agentName, instanceId, workDir, skipAgentAuth, connectionGeneration, timeout }
 export const pendingAgentConnections = new Map();
 
 // ★ Phase 3: Server-side message queues

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

@@ -356,6 +356,20 @@ export async function handleAgentSync(agentId, agent, msg) {
       break;
     }
 
+    // Local telemetry settings relay. Only bounded config is forwarded;
+    // trace payloads stay on the Agent.
+    case 'telemetry_settings':
+    case 'telemetry_settings_updated':
+      for (const [, client] of webClients) {
+        if (client.authenticated && (CONFIG.skipAuth ||
+          (agent.ownerId && client.userId === agent.ownerId) ||
+          (!agent.ownerId && client.role === 'admin')
+        )) {
+          await sendToWebClient(client, { ...msg, agentId });
+        }
+      }
+      break;
+
     // Search settings + Tavily usage relays. We pass the whole msg
     // through (minus agentId, which we set ourselves) — the payload
     // shapes differ per type and the front-end already filters on

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

@@ -3,6 +3,25 @@ import {
   sendToWebClient, forwardToAgent, broadcastAgentList
 } from '../ws-utils.js';
 
+// v1.0.342 is the first release with the bootstrap -> detached runner handoff.
+// Older Windows Agents can lose their updater to PM2 tree-kill before npm runs.
+export const MIN_SAFE_REMOTE_UPGRADE_VERSION = '1.0.342';
+
+function parseVersion(version) {
+  const match = String(version || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)$/u);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+export function requiresManualUpgradeBridge(version) {
+  const current = parseVersion(version);
+  const minimum = parseVersion(MIN_SAFE_REMOTE_UPGRADE_VERSION);
+  if (!current || !minimum) return true;
+  for (let index = 0; index < minimum.length; index++) {
+    if (current[index] !== minimum[index]) return current[index] < minimum[index];
+  }
+  return false;
+}
+
 /**
  * Handle miscellaneous messages from web client.
  * Types: ping, restart_agent, upgrade_agent,
@@ -26,6 +45,19 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       const upgradeAgentId = msg.agentId;
       if (!upgradeAgentId) break;
       if (!await checkAgentAccess(upgradeAgentId)) break;
+      const upgradeAgent = agents.get(upgradeAgentId);
+      if (requiresManualUpgradeBridge(upgradeAgent?.version)) {
+        await sendToWebClient(client, {
+          type: 'upgrade_agent_ack',
+          agentId: upgradeAgentId,
+          success: false,
+          reason: 'manual_upgrade_required',
+          version: upgradeAgent?.version || null,
+          minimumVersion: MIN_SAFE_REMOTE_UPGRADE_VERSION,
+          error: `Agent ${upgradeAgent?.version || 'unknown'} predates the safe remote-upgrade handoff; manually install ${MIN_SAFE_REMOTE_UPGRADE_VERSION} or newer once`,
+        });
+        break;
+      }
       await forwardToAgent(upgradeAgentId, { type: 'upgrade_agent' });
       break;
     }
@@ -166,6 +198,27 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       break;
     }
 
+    // Local performance telemetry settings. The agent owns the config file;
+    // the server only checks access and relays the request.
+    case 'get_telemetry_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, { type: 'get_telemetry_settings' });
+      break;
+    }
+
+    case 'update_telemetry_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'update_telemetry_settings',
+        settings: msg.settings || msg.config || {},
+      });
+      break;
+    }
+
     // Search settings (web-search backend + Tavily key + on-demand usage probe).
     // Mirrors the get/update_yeaft_settings pair: the agent owns the
     // config file, server is just a relay.

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

@@ -25,60 +25,45 @@ function buildAgentMapKey(ownerId, agentName) {
   return `${prefix}:${agentName}`;
 }
 
+let nextAgentConnectionGeneration = 0;
+// Keep the latest generation as a tombstone while an older auth may still arrive.
+const latestAgentConnectionGenerations = new Map();
+
+function claimAgentConnection(agentId, generation) {
+  const latestGeneration = latestAgentConnectionGenerations.get(agentId);
+  if (latestGeneration !== undefined && latestGeneration > generation) return false;
+  latestAgentConnectionGenerations.set(agentId, generation);
+  return true;
+}
+
+function pruneAgentConnectionGenerations() {
+  for (const [agentId, generation] of latestAgentConnectionGenerations) {
+    if (agents.has(agentId)) continue;
+    const hasPotentiallyOlderConnection = [...pendingAgentConnections.values()].some(pending => {
+      if (pending.connectionGeneration >= generation) return false;
+      return pending.skipAgentAuth ? pending.agentId === agentId : true;
+    });
+    if (!hasPotentiallyOlderConnection) latestAgentConnectionGenerations.delete(agentId);
+  }
+}
+
 export function handleAgentConnection(ws, url) {
   const clientAgentId = url.searchParams.get('id') || randomUUID();
   const agentName = url.searchParams.get('name') || `Agent-${clientAgentId.slice(0, 8)}`;
   const instanceId = url.searchParams.get('instanceId') || clientAgentId;
   const workDir = url.searchParams.get('workDir') || '';
 
-  // In development mode (SKIP_AUTH), register immediately
-  if (CONFIG.skipAuth) {
-    // Dev mode: no owner isolation, use clientAgentId as-is for backward compat
-    const capabilities = (url.searchParams.get('capabilities') || '').split(',').filter(Boolean);
-    completeAgentRegistration(ws, clientAgentId, agentName, workDir, null, capabilities, null, null, null, instanceId);
+  // Both authenticated and SKIP_AUTH connections use the existing auth frame
+  // for registration metadata. Released Agents already send their version there;
+  // SKIP_AUTH only bypasses secret validation and owner scoping.
+  const skipAgentAuth = CONFIG.skipAuth;
+  const urlCapabilities = (url.searchParams.get('capabilities') || '').split(',').filter(Boolean);
+  const connectionGeneration = ++nextAgentConnectionGeneration;
 
-    ws.on('message', async (data) => {
-      const agent = agents.get(clientAgentId);
-      if (!agent || agent.ws !== ws) {
-        if (!agent) console.error(`[Agent] No agent found for id: ${clientAgentId}`);
-        return;
-      }
-      markAgentHeartbeatSeen(agent);
-      const msg = await parseMessage(data, agent.sessionKey);
-      if (msg) {
-        console.log(`[Agent] Received message from ${clientAgentId}: ${msg.type}`);
-        if (msg.perfTraceId) {
-          recordPerfTraceEvent({
-            traceId: msg.perfTraceId,
-            source: 'server',
-            phase: 'websocket.agent_received',
-            at: Date.now(),
-            agentId: clientAgentId,
-            sessionId: msg.sessionId || null,
-            vpId: msg.vpId || null,
-            turnId: msg.turnId || null,
-            threadId: msg.threadId || null,
-            messageType: msg.type,
-            bytes: data.length || 0,
-          });
-        }
-        handleAgentMessage(clientAgentId, msg, ws);
-      } else {
-        console.error(`[Agent] Failed to parse message from ${clientAgentId}`);
-      }
-    });
+  // SKIP_AUTH has a complete identity at connect time. Authenticated connections
+  // can only claim an owner-scoped identity after their secret is verified.
+  if (skipAgentAuth) claimAgentConnection(clientAgentId, connectionGeneration);
 
-    ws.on('close', () => {
-      handleAgentDisconnect(clientAgentId, agentName, ws);
-    });
-
-    ws.on('error', (err) => {
-      console.error(`Agent error (${agentName}):`, err.message);
-    });
-    return;
-  }
-
-  // In production mode, wait for auth message with secret
   const tempId = randomUUID();
   // Mutable: will be updated to the owner-scoped key after auth succeeds
   let resolvedAgentId = null;
@@ -86,6 +71,7 @@ export function handleAgentConnection(ws, url) {
   const authTimeout = setTimeout(() => {
     console.log(`Agent auth timeout: ${agentName}`);
     pendingAgentConnections.delete(tempId);
+    pruneAgentConnectionGenerations();
     ws.close(1008, 'Authentication timeout');
   }, 30000);
 
@@ -95,10 +81,12 @@ export function handleAgentConnection(ws, url) {
     agentName,
     instanceId,
     workDir,
+    skipAgentAuth,
+    connectionGeneration,
     timeout: authTimeout
   });
 
-  // Request authentication
+  // Request the existing registration frame. SKIP_AUTH ignores its secret.
   ws.send(JSON.stringify({
     type: 'auth_required',
     tempId
@@ -114,22 +102,34 @@ export function handleAgentConnection(ws, url) {
           clearTimeout(pending.timeout);
           pendingAgentConnections.delete(tempId);
 
-          const authResult = verifyAgent(msg.secret);
+          const authResult = skipAgentAuth
+            ? { valid: true, sessionKey: null, userId: null, username: null }
+            : verifyAgent(msg.secret);
           if (!authResult.valid) {
+            pruneAgentConnectionGenerations();
             console.log(`Agent auth failed: ${agentName}`);
             ws.close(1008, 'Invalid agent secret');
             return;
           }
 
-          const capabilities = msg.capabilities || [];
+          const capabilities = Array.isArray(msg.capabilities) ? msg.capabilities : urlCapabilities;
           const agentVersion = msg.version || null;
-          // Build owner-scoped key to prevent cross-user collision. New agents
-          // identify local service instances separately from display names;
-          // old agents keep using their name as the stable id.
-          resolvedAgentId = buildAgentMapKey(authResult.userId, pending.instanceId || pending.agentId || pending.agentName);
+          // Authenticated Agents use an owner-scoped key. SKIP_AUTH preserves
+          // its historical unscoped id while still receiving version metadata.
+          resolvedAgentId = skipAgentAuth
+            ? clientAgentId
+            : buildAgentMapKey(authResult.userId, pending.instanceId || pending.agentId || pending.agentName);
+          if (!claimAgentConnection(resolvedAgentId, connectionGeneration)) {
+            resolvedAgentId = null;
+            pruneAgentConnectionGenerations();
+            ws.close(1008, 'Superseded by a newer Agent connection');
+            return;
+          }
           completeAgentRegistration(ws, resolvedAgentId, pending.agentName, pending.workDir, authResult.sessionKey, capabilities, authResult.userId, authResult.username, agentVersion, pending.instanceId || pending.agentId || pending.agentName);
+          pruneAgentConnectionGenerations();
         }
       } catch (e) {
+        pruneAgentConnectionGenerations();
         console.error('Failed to parse agent auth message:', e.message);
       }
     } else {
@@ -171,6 +171,7 @@ export function handleAgentConnection(ws, url) {
     if (pending) {
       clearTimeout(pending.timeout);
       pendingAgentConnections.delete(tempId);
+      pruneAgentConnectionGenerations();
     }
     // Use resolvedAgentId if auth completed, otherwise nothing to clean
     if (resolvedAgentId) {
@@ -199,6 +200,7 @@ function handleAgentDisconnect(agentId, agentName, ws) {
   }
   // Remove agent entirely — eliminates zombie agents from broadcastAgentList
   agents.delete(agentId);
+  pruneAgentConnectionGenerations();
   console.log(`Agent disconnected: ${agentName}`);
   broadcastAgentList();
 }

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.351"}
+{"version":"1.0.353"}