@yeaft/webchat-agent 1.0.532 → 1.0.534

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, getPluginConfig, updatePluginConfig, getTelemetrySettings, updateTelemetrySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
+import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getPluginConfig, updatePluginConfig, getTelemetrySettings, updateTelemetrySettings, getWorkCenterFeatureSettings, updateWorkCenterFeatureSettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
 import { loadConfig } from '../yeaft/config.js';
 import { mutateAgentConfig } from '../yeaft/config-store.js';
 import { discoverLlmModels } from '../llm-model-discovery.js';
@@ -96,6 +96,68 @@ export function applyRegisteredTransport(msg) {
   }
 }
 
+let workCenterFeatureTransition = Promise.resolve();
+
+export async function applyWorkCenterFeatureUpdate(msg, dependencies = {}) {
+  const run = async () => {
+    const update = dependencies.updateWorkCenterFeatureSettings || updateWorkCenterFeatureSettings;
+    const getSettings = dependencies.getWorkCenterFeatureSettings || getWorkCenterFeatureSettings;
+    const bridge = dependencies.bridge || await import('../yeaft/work-center/bridge.js');
+    const refreshCapabilities = dependencies.refreshAgentCapabilities || ctx.refreshAgentCapabilities;
+    const yeaftDir = dependencies.yeaftDir ?? ctx.CONFIG?.yeaftDir;
+    // Read inside the transition queue so the previous request is observable.
+    const previous = getSettings(yeaftDir);
+    const persisted = update(msg.settings || {}, yeaftDir);
+    if (persisted.error) return { ...persisted, persisted: false, effective: previous.enabled === true };
+
+    bridge.setWorkCenterFeatureEnabled(persisted.enabled);
+    try {
+      if (persisted.enabled) await bridge.bootWorkCenter();
+      else await bridge.shutdownWorkCenter();
+      if (ctx.CONFIG) ctx.CONFIG.workCenterEnabled = persisted.enabled;
+      ctx.workCenterStartupError = null;
+      await refreshCapabilities?.();
+      return {
+        ...persisted,
+        persisted: true,
+        effective: persisted.enabled,
+        sessionTools: persisted.enabled ? 'new_sessions_only' : 'disabled_immediately',
+      };
+    } catch (error) {
+      const rollback = previous.error ? previous : update({ enabled: previous.enabled === true }, yeaftDir);
+      const restored = !rollback.error;
+      let rollbackRuntimeError = null;
+      if (restored) {
+        bridge.setWorkCenterFeatureEnabled(previous.enabled === true);
+        try {
+          if (previous.enabled === true) await bridge.bootWorkCenter();
+          else await bridge.shutdownWorkCenter();
+        } catch (rollbackError) {
+          rollbackRuntimeError = rollbackError?.message || String(rollbackError);
+          bridge.setWorkCenterFeatureEnabled(false);
+        }
+        if (ctx.CONFIG) ctx.CONFIG.workCenterEnabled = previous.enabled === true && !rollbackRuntimeError;
+        try { await refreshCapabilities?.(); } catch { /* original transition error remains authoritative */ }
+      } else {
+        bridge.setWorkCenterFeatureEnabled(false);
+        if (ctx.CONFIG) ctx.CONFIG.workCenterEnabled = false;
+      }
+      const effective = restored && !rollbackRuntimeError ? previous.enabled === true : false;
+      return {
+        ...persisted,
+        enabled: restored ? previous.enabled === true : persisted.enabled,
+        error: `Failed to apply Work Center runtime transition: ${error?.message || error}${rollbackRuntimeError ? `; rollback runtime failed: ${rollbackRuntimeError}` : ''}`,
+        persisted: !restored,
+        effective,
+        rolledBack: restored && !rollbackRuntimeError,
+      };
+    }
+  };
+  const result = workCenterFeatureTransition.then(run, run);
+  workCenterFeatureTransition = result.catch(() => {});
+  return result;
+}
+
 export async function handleMessage(msg) {
   if (await handleBrowserRuntimeMessage(msg)) return;
   switch (msg.type) {
@@ -532,6 +594,28 @@ export async function handleMessage(msg) {
       break;
     }
 
+
+    case 'get_work_center_feature_settings': {
+      const settings = getWorkCenterFeatureSettings(ctx.CONFIG?.yeaftDir);
+      sendToServer({
+        type: 'work_center_feature_settings', requestId: msg.requestId, clientId: msg.clientId, ...settings,
+        effective: ctx.CONFIG?.workCenterEnabled === true,
+        ...(ctx.workCenterStartupError ? { runtimeError: ctx.workCenterStartupError } : {}),
+      });
+      break;
+    }
+
+    case 'update_work_center_feature_settings': {
+      let result;
+      try {
+        result = await applyWorkCenterFeatureUpdate(msg);
+      } catch (error) {
+        result = { error: `Failed to apply Work Center setting: ${error?.message || error}`, persisted: false, effective: ctx.CONFIG?.workCenterEnabled === true };
+      }
+      sendToServer({ type: 'work_center_feature_settings_updated', requestId: msg.requestId, clientId: msg.clientId, ...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

@@ -25,7 +25,7 @@ import {
 } from './upgrade-command.js';
 import { loadConfig as loadYeaftConfig } from './yeaft/config.js';
 import { initYeaftDir } from './yeaft/init.js';
-import { isWorkCenterEnabled } from './yeaft/work-center/feature.js';
+import { isWorkCenterEnabled, startWorkCenterFeature } from './yeaft/work-center/feature.js';
 import { updateBrowserRuntimeSettings } from './yeaft/config-api.js';
 import { bootBrowserRuntime, shutdownBrowserRuntime } from './browser-runtime/index.js';
 import {
@@ -139,7 +139,7 @@ const CONFIG = {
   workDir: WORK_DIR,
   yeaftDir: YEAFT_DIR,
   telemetry: loadYeaftConfig({ dir: YEAFT_DIR }).telemetry,
-  workCenterEnabled: isWorkCenterEnabled(),
+  workCenterEnabled: isWorkCenterEnabled(process.env, loadYeaftConfig({ dir: YEAFT_DIR })),
   reconnectInterval: fileConfig.reconnectInterval,
   agentSecret,
   // 显式禁用的工具（非 MCP 相关）
@@ -177,9 +177,9 @@ async function detectCapabilities() {
   // agent build can speak plaintext WS frames. New servers see this and
   // flip `agent.encryptOutbound = false`, stopping outbound encryption
   // to this peer. Old servers ignore the unknown capability token.
-  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', 'workbench_session_routes', 'workbench_request_correlation', 'workbench_terminal_cleanup_fence', 'workbench_file_content_chunks', 'workbench_video_stream', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch', 'file_reference_resolution', 'response_image_preview', 'yeaft_plugins', 'yeaft_managed_skills', 'settings_request_correlation'];
+  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', 'workbench_session_routes', 'workbench_request_correlation', 'workbench_terminal_cleanup_fence', 'workbench_file_content_chunks', 'workbench_video_stream', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch', 'file_reference_resolution', 'response_image_preview', 'yeaft_plugins', 'yeaft_managed_skills', 'settings_request_correlation', 'work_center_feature_settings'];
   capabilities.push(getAgentUpgradeCapability());
-  if (isWorkCenterEnabled()) {
+  if (ctx.CONFIG?.workCenterEnabled === true) {
     capabilities.push('work_center', 'work_center_message_v2');
     if (process.platform === 'linux') capabilities.push('work_item_attachments');
   }
@@ -193,6 +193,12 @@ async function detectCapabilities() {
   return capabilities;
 }
 
+ctx.refreshAgentCapabilities = async () => {
+  ctx.agentCapabilities = await detectCapabilities();
+  ctx.sendToServer?.({ type: 'agent_capabilities_updated', capabilities: ctx.agentCapabilities });
+  return ctx.agentCapabilities;
+};
+
 // 确保依赖已安装。node-pty 已被 @homebridge/node-pty-prebuilt-multiarch
 // 取代（regular dep + 全平台预编译），不再需要 optionalDependency 的特判。
 async function ensureDependencies() {
@@ -459,7 +465,6 @@ process.on('SIGTERM', async () => {
   } catch (err) {
     console.warn(`[BrowserRuntime] startup probe failed: ${err?.message || err}`);
   }
-  ctx.agentCapabilities = await detectCapabilities();
   // Prime the models.dev community catalog so the Yeaft engine's *synchronous*
   // hot path (engine.js / config.js / cli.js all read context-window inline)
   // can resolve real per-model limits without bubbling async up through every
@@ -472,16 +477,21 @@ process.on('SIGTERM', async () => {
   } catch (err) {
     console.warn(`[Agent] models.dev prime failed (will use config/defaults): ${err?.message || err}`);
   }
-  if (isWorkCenterEnabled()) {
-    try {
-      const { bootWorkCenter } = await import('./yeaft/work-center/bridge.js');
-      await bootWorkCenter();
+  if (ctx.CONFIG?.workCenterEnabled === true) {
+    const bridge = await import('./yeaft/work-center/bridge.js');
+    const startup = await startWorkCenterFeature(true, bridge.bootWorkCenter);
+    ctx.CONFIG.workCenterEnabled = startup.effective;
+    ctx.workCenterStartupError = startup.runtimeError;
+    if (startup.effective) {
       console.log('[Agent] Work Center watcher started');
-    } catch (err) {
-      console.warn(`[Agent] Work Center failed to start: ${err?.message || err}`);
+    } else {
+      bridge.setWorkCenterFeatureEnabled(false);
+      console.warn(`[Agent] Work Center failed to start: ${startup.runtimeError}`);
     }
   } else {
     console.log('[Agent] Work Center disabled; watcher not started');
   }
+  // Runtime capabilities must reflect the effective startup state.
+  ctx.agentCapabilities = await detectCapabilities();
   connect();
 })();

package/local-runtime/server/db/yeaft-project-db.js

@@ -196,6 +196,23 @@ export const yeaftProjectDb = {
     })();
   },
 
+  /**
+   * Assign a newly registered fork to the source's Project. The caller owns the
+   * Session-registration transaction and replay fence; this is one insert, not
+   * moveSession's independent transaction or a user-requested Project move.
+   */
+  inheritSessionProject(userId, agentId, sourceSessionId, targetSessionId) {
+    const ownerId = requireUserId(userId);
+    const targetAgentId = requireId(agentId, 'invalid_agent_id', 'Agent id');
+    const sourceId = requireId(sourceSessionId, 'invalid_session_id', 'Source Session id');
+    const targetId = requireId(targetSessionId, 'invalid_session_id', 'Fork Session id');
+    if (sourceId === targetId) throw new YeaftProjectDbError('invalid_session_id', 'Fork must have a new identity');
+    const project = stmts.getYeaftProjectForSession.get(ownerId, targetAgentId, sourceId);
+    if (!project) return null;
+    stmts.insertYeaftProjectSessionMembership.run(ownerId, project.id, targetAgentId, targetId, Date.now());
+    return project.id;
+  },
+
   reconcileAgentSessions(userId, agentId, sessionIds) {
     const ownerId = requireUserId(userId);
     const targetAgentId = requireId(agentId, 'invalid_agent_id', 'Agent id');

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

@@ -83,6 +83,30 @@ function syncYeaftSessionMetadata(agentId, agent, event) {
     }
     return { ...event, sessions: decorateYeaftSessionsWithPinned(agentId, event.sessions) };
   }
+  // A fork is a new Session on the same Agent, not a new Project. Resolve
+  // membership here (never from browser/Agent project metadata) before the
+  // successful acknowledgement can focus the new Session in the browser.
+  if (event.ok && ownerId && op === 'copy' && event.sourceSessionId && event.session?.id) {
+    try {
+      if (event.sourceSessionId === event.session.id) throw new Error('Fork must have a new Session identity');
+      transaction(() => {
+        // Replayed acknowledgements must not undo a later user Project move.
+        if (yeaftSessionDb.getForAgent(ownerId, agentId, event.session.id)) return;
+        yeaftSessionDb.upsertFromSnapshot(ownerId, agentId, event.session);
+        yeaftProjectDb.inheritSessionProject(ownerId, agentId, event.sourceSessionId, event.session.id);
+      })();
+    } catch (e) {
+      console.warn('[Server] Fork Project inheritance failed:', e?.message || e);
+      return {
+        ...event,
+        ok: false,
+        error: {
+          code: 'project_inheritance_failed',
+          message: `Fork ${event.session.id} was created, but its Project could not be saved.`,
+        },
+      };
+    }
+  }
   if (!event.ok || !ownerId || !sessionId || (op !== 'archive' && op !== 'delete')) return event;
 
   if (op === 'archive') {

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

@@ -409,14 +409,20 @@ export async function handleAgentSync(agentId, agent, msg) {
     // Local telemetry settings relay. Only bounded config is forwarded;
     // trace payloads stay on the Agent.
     case 'telemetry_settings':
-    case 'telemetry_settings_updated': {
+    case 'telemetry_settings_updated':
+    case 'work_center_feature_settings':
+    case 'work_center_feature_settings_updated': {
       const operation = msg.type === 'yeaft_plugins_updated'
         ? 'plugins:update'
         : msg.type === 'yeaft_plugins'
           ? 'plugins:load'
           : msg.type === 'telemetry_settings_updated'
             ? 'telemetry:update'
-            : 'telemetry:load';
+            : msg.type === 'telemetry_settings'
+              ? 'telemetry:load'
+              : msg.type === 'work_center_feature_settings_updated'
+                ? 'work-center-feature:update'
+                : 'work-center-feature:load';
       await sendAgentSettingsReply(agentId, agent, operation, msg, { ...msg, agentId });
       break;
     }

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

@@ -19,6 +19,8 @@ import {
 // builds without this capability may still inherit the installed package cwd.
 export const SAFE_REMOTE_UPGRADE_CAPABILITY = 'remote_upgrade_safe';
 export const CONTAINER_AGENT_CAPABILITY = 'container_agent';
+export const WORK_CENTER_FEATURE_SETTINGS_CAPABILITY = 'work_center_feature_settings';
+export const WORK_CENTER_FEATURE_SETTINGS_UNSUPPORTED_ERROR = 'This Agent must be upgraded to manage Work Center settings.';
 export const CONTAINER_IMAGE_UPGRADE_REASON = 'container_image_upgrade_required';
 export { YEAFT_PLUGINS_CAPABILITY, YEAFT_PLUGINS_UNSUPPORTED_ERROR };
 
@@ -52,6 +54,19 @@ async function forwardRegisteredAgentRequest({ client, clientId, agentId, operat
   return false;
 }
 
+
+async function rejectUnsupportedWorkCenterFeatureSettings(client, msg, agentId) {
+  await sendToWebClient(client, {
+    type: msg.type === 'update_work_center_feature_settings'
+      ? 'work_center_feature_settings_updated'
+      : 'work_center_feature_settings',
+    agentId,
+    requestId: msg.requestId || null,
+    error: WORK_CENTER_FEATURE_SETTINGS_UNSUPPORTED_ERROR,
+    unsupported: true,
+  });
+}
+
 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() : '';
@@ -352,6 +367,31 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       break;
     }
 
+
+    case 'get_work_center_feature_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a || !await checkAgentAccess(a)) break;
+      if (!agents.get(a)?.capabilities?.includes(WORK_CENTER_FEATURE_SETTINGS_CAPABILITY)) {
+        await rejectUnsupportedWorkCenterFeatureSettings(client, msg, a);
+        break;
+      }
+      await forwardRegisteredAgentRequest({ client, clientId, agentId: a, operation: 'work-center-feature:load', requestId: msg.requestId,
+        message: { type: 'get_work_center_feature_settings', requestId: msg.requestId, clientId }, responseType: 'work_center_feature_settings' });
+      break;
+    }
+
+    case 'update_work_center_feature_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a || !await checkAgentAccess(a)) break;
+      if (!agents.get(a)?.capabilities?.includes(WORK_CENTER_FEATURE_SETTINGS_CAPABILITY)) {
+        await rejectUnsupportedWorkCenterFeatureSettings(client, msg, a);
+        break;
+      }
+      await forwardRegisteredAgentRequest({ client, clientId, agentId: a, operation: 'work-center-feature:update', requestId: msg.requestId,
+        message: { type: 'update_work_center_feature_settings', requestId: msg.requestId, clientId, settings: msg.settings || {} }, responseType: 'work_center_feature_settings_updated' });
+      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

@@ -316,6 +316,8 @@ function handleAgentDisconnect(agentId, agentName, ws) {
       restart: 'restart_agent_ack', dream: 'dream_enabled_changed', upgrade: 'upgrade_agent_ack',
       'plugins:load': 'yeaft_plugins', 'plugins:update': 'yeaft_plugins_updated',
       'telemetry:load': 'telemetry_settings', 'telemetry:update': 'telemetry_settings_updated',
+      'work-center-feature:load': 'work_center_feature_settings',
+      'work-center-feature:update': 'work_center_feature_settings_updated',
     };
     void sendToWebClient(client, {
       type: responseTypes[pending.operation] || 'agent_request_error',

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.532"}
+{"version":"1.0.534"}