@yeaft/webchat-agent 1.0.550 → 1.0.551

package/index.js

@@ -180,7 +180,7 @@ async function detectCapabilities() {
   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 (ctx.CONFIG?.workCenterEnabled === true) {
-    capabilities.push('work_center', 'work_center_message_v2');
+    capabilities.push('work_center', 'work_center_message_v2', 'work_center_workbench');
     if (process.platform === 'linux') capabilities.push('work_item_attachments');
   }
   const pty = await loadNodePty();

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

@@ -1,4 +1,5 @@
 export const WORKBENCH_ROUTE_PROTOCOL = 1;
+export const WORK_CENTER_WORKBENCH_PROTOCOL = 1;
 export const BROWSER_RUNTIME_PROTOCOL = 1;
 export const BROWSER_RUNTIME_SETUP_PROTOCOL = 1;
 
@@ -12,6 +13,9 @@ export function applyClientHello(client, message) {
   if (message.workbenchRouteProtocol === WORKBENCH_ROUTE_PROTOCOL) {
     client.workbenchRouteProtocol = WORKBENCH_ROUTE_PROTOCOL;
   }
+  if (message.workCenterWorkbenchProtocol === WORK_CENTER_WORKBENCH_PROTOCOL) {
+    client.workCenterWorkbenchProtocol = WORK_CENTER_WORKBENCH_PROTOCOL;
+  }
   if (message.browserRuntimeProtocol === BROWSER_RUNTIME_PROTOCOL) {
     client.browserRuntimeProtocol = BROWSER_RUNTIME_PROTOCOL;
   }

package/local-runtime/server/handlers/agent-work-center.js

@@ -1,3 +1,4 @@
+import { updateWorkItemWorkspaces } from '../work-center-workspace-cache.js';
 import { forwardAgentEvent } from '../ws-utils.js';
 import { deliverWorkCenterResponse } from './client-work-center.js';
 
@@ -21,6 +22,7 @@ export async function handleAgentWorkCenter(agentId, msg) {
   }
 
   const { agentId: _untrustedAgentId, _requestUserId, ...payload } = msg;
+  updateWorkItemWorkspaces(agentId, payload.event);
   const outgoing = { ...payload, agentId };
   await forwardAgentEvent(agentId, outgoing);
   return true;

package/local-runtime/server/handlers/client-work-center.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { CONFIG } from '../config.js';
 import { agents, pendingFiles, previewFiles } from '../context.js';
 import { forwardToAgent, sendToWebClient } from '../ws-utils.js';
+import { forgetWorkItemWorkspace, rememberWorkItemWorkspace } from '../work-center-workspace-cache.js';
 import {
   assertSupportedWorkItemAttachment,
   assertWorkItemAttachmentSize,
@@ -204,6 +205,7 @@ export async function handleClientWorkCenter(client, msg, checkAgentAccess) {
     agentId,
     clientRequestId: typeof msg.requestId === 'string' ? msg.requestId : null,
     attachmentFileIds: resolved.consumedIds,
+    workItemId: typeof resolved.payload?.id === 'string' ? resolved.payload.id : null,
     expiresAt: Date.now() + REQUEST_TIMEOUT_MS,
   });
 
@@ -233,6 +235,11 @@ export async function deliverWorkCenterResponse(agentId, msg) {
   // able to resolve the original fileId and reach the Agent receipt preflight.
   const { agentId: _untrustedAgentId, requestId: _opaqueRequestId, _requestUserId, ...payload } = msg;
   let response = payload;
+  if (msg.ok === true && msg.op === 'delete') {
+    forgetWorkItemWorkspace(pending.client?.userId, agentId, pending.workItemId);
+  } else if (msg.ok === true && msg.data?.id) {
+    rememberWorkItemWorkspace(pending.client?.userId, agentId, msg.data);
+  }
   if (msg.ok === true && msg.op === 'preview_attachment') {
     try {
       const data = payload.data;

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

@@ -7,6 +7,7 @@ import {
 import {
   agentSupportsWorkbenchRequestCorrelation,
   resolveWorkbenchRequest,
+  workbenchPathWithinWorkspace,
 } from '../workbench-route.js';
 import {
   deleteWorkbenchRequest,
@@ -157,6 +158,35 @@ function workbenchFailureResponse({ agentId, msg, resolved, error }) {
   };
 }
 
+const WORKBENCH_PATH_FIELDS = Object.freeze({
+  read_file: ['filePath'],
+  video_metadata: ['filePath'],
+  write_file: ['filePath'],
+  list_directory: ['dirPath'],
+  git_diff: ['filePath'],
+  git_add: ['filePath'],
+  git_reset: ['filePath'],
+  git_restore: ['filePath'],
+  file_search: ['dirPath'],
+  create_file: ['filePath'],
+  delete_files: ['paths'],
+  move_files: ['paths', 'destination'],
+  copy_files: ['paths', 'destination'],
+  upload_to_dir: ['dirPath'],
+});
+
+function workCenterPathsAreConfined(msg, resolved) {
+  if (resolved.route?.runtimeProvider !== 'work-center') return true;
+  for (const field of WORKBENCH_PATH_FIELDS[msg.type] || []) {
+    const values = Array.isArray(msg[field]) ? msg[field] : [msg[field]];
+    for (const value of values) {
+      if (value == null || value === '') continue;
+      if (!workbenchPathWithinWorkspace(value, resolved.workDir)) return false;
+    }
+  }
+  return true;
+}
+
 function canonicalWorkbenchMessage(msg, resolved, { canonicalWorkDir = false } = {}) {
   const {
     _requestUserId: _ignoredUserId,
@@ -168,6 +198,7 @@ function canonicalWorkbenchMessage(msg, resolved, { canonicalWorkDir = false } =
     ...clientFields,
     ...(resolved.conversationId ? { conversationId: resolved.conversationId } : {}),
   };
+  if (!workCenterPathsAreConfined(clientFields, resolved)) return null;
   return {
     ...clientFields,
     agentId: resolved.agentId,
@@ -233,6 +264,10 @@ function correlateWorkbenchRequest({ agentId, clientId, client, msg, resolved, c
 }
 
 async function forwardCorrelatedWorkbenchRequest({ agentId, clientId, client, msg, resolved, canonical }) {
+  if (!canonical) {
+    await denyWorkbenchRoute(client, msg);
+    return true;
+  }
   const outbound = correlateWorkbenchRequest({ agentId, clientId, client, msg, resolved, canonical });
   if (!outbound) return false;
   try {
@@ -465,7 +500,7 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
         client,
         msg,
         resolved,
-        canonical: { ...canonical, type: 'list_directory' },
+        canonical: canonical ? { ...canonical, type: 'list_directory' } : null,
       });
       break;
     }

package/local-runtime/server/work-center-workspace-cache.js

@@ -0,0 +1,63 @@
+import { agents } from './context.js';
+
+// Ephemeral routing metadata, never a second WorkItem catalog. A fresh detail
+// request repopulates it after reconnect/restart; old Agent connections expire.
+const workspaces = new Map();
+const MAX_WORKSPACES = 1000;
+
+function clean(value, maxLength = 4096) {
+  if (typeof value !== 'string') return '';
+  const result = value.trim();
+  return result && result.length <= maxLength ? result : '';
+}
+
+function key(userId, agentId, workItemId) {
+  const parts = [userId, agentId, workItemId].map(value => clean(value, 300));
+  return parts.every(Boolean) ? JSON.stringify(parts) : '';
+}
+
+/** Remember Agent-projected workspace metadata only after an owner-scoped request. */
+export function rememberWorkItemWorkspace(userId, agentId, detail) {
+  const cacheKey = key(userId, agentId, detail?.id);
+  const workDir = clean(detail?.workbench?.workDir);
+  if (!cacheKey) return false;
+  workspaces.delete(cacheKey);
+  if (!workDir || !agents.has(agentId)) return false;
+  workspaces.set(cacheKey, { id: detail.id, agentId, agent: agents.get(agentId), workDir, isArchived: false });
+  while (workspaces.size > MAX_WORKSPACES) workspaces.delete(workspaces.keys().next().value);
+  return true;
+}
+
+export function getWorkItemWorkspace(userId, agentId, workItemId) {
+  const cacheKey = key(userId, agentId, workItemId);
+  const row = workspaces.get(cacheKey);
+  if (!row || row.agent !== agents.get(agentId)) {
+    workspaces.delete(cacheKey);
+    return null;
+  }
+  return row;
+}
+
+export function forgetWorkItemWorkspace(userId, agentId, workItemId) {
+  workspaces.delete(key(userId, agentId, workItemId));
+}
+
+/** Events may refresh existing owner grants, never create grants for new users. */
+export function updateWorkItemWorkspaces(agentId, event) {
+  const detail = event?.workItem;
+  if (!detail?.id) return;
+  for (const [cacheKey, row] of workspaces) {
+    if (row.agentId !== agentId || row.id !== detail.id) continue;
+    if (event.type === 'work_item.deleted' || row.agent !== agents.get(agentId)) {
+      workspaces.delete(cacheKey);
+    } else if (Object.hasOwn(detail, 'workbench')) {
+      const workDir = clean(detail.workbench?.workDir);
+      if (!workDir) workspaces.delete(cacheKey);
+      else row.workDir = workDir;
+    }
+  }
+}
+
+export function __testResetWorkItemWorkspaces() {
+  workspaces.clear();
+}

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

@@ -65,7 +65,7 @@ function authorize(source) {
   if (!CONFIG.skipAuth && (!user || user.deletion_state !== 'active' || !['pro', 'admin'].includes(user.role))) {
     throw failure(403, 'Preview access denied');
   }
-  const client = { userId: source.userId, role: user?.role, workbenchRouteProtocol: 1 };
+  const client = { userId: source.userId, role: user?.role, workbenchRouteProtocol: 1, workCenterWorkbenchProtocol: 1 };
   const accessError = resolveAgentAccessError(source.agentId, client.userId, client.role);
   if (accessError) throw failure(accessError === 'Agent access denied' ? 403 : 503, accessError);
   const generation = currentWorkbenchWorkspaceGeneration({ ...client, route: source.route });

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

@@ -1,11 +1,14 @@
+import { posix, win32 } from 'node:path';
 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';
+import { getWorkItemWorkspace } from './work-center-workspace-cache.js';
 
 export const WORKBENCH_SESSION_ROUTE_CAPABILITY = 'workbench_session_routes';
 export const WORKBENCH_REQUEST_CORRELATION_CAPABILITY = 'workbench_request_correlation';
 export const WORKBENCH_TERMINAL_CLEANUP_FENCE_CAPABILITY = 'workbench_terminal_cleanup_fence';
+export const WORK_CENTER_WORKBENCH_CAPABILITY = 'work_center_workbench';
 
 function agentHasCapability(agent, capability) {
   return Array.isArray(agent?.capabilities) && agent.capabilities.includes(capability);
@@ -19,7 +22,7 @@ export function agentSupportsWorkbenchTerminalCleanupFence(agent) {
   return agentHasCapability(agent, WORKBENCH_TERMINAL_CLEANUP_FENCE_CAPABILITY);
 }
 
-const PROVIDERS = new Set(['yeaft', 'claude-code', 'copilot']);
+const PROVIDERS = new Set(['yeaft', 'claude-code', 'copilot', 'work-center']);
 const SCOPES = new Set(['main', 'files-folder-picker', 'git-folder-picker']);
 
 function clean(value, maxLength = 300) {
@@ -31,9 +34,11 @@ function clean(value, maxLength = 300) {
 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]
+  const ownerId = runtimeProvider === 'work-center'
+    ? clean(route?.workItemId)
+    : clean(route?.sessionId);
+  if (!PROVIDERS.has(runtimeProvider) || !agentId || !ownerId) return '';
+  return [runtimeProvider, agentId, ownerId]
     .map(part => encodeURIComponent(part))
     .join(':');
 }
@@ -73,7 +78,9 @@ export function workbenchRouteKeyFromConversationId(conversationId, expectedAgen
     const decodedRoute = {
       runtimeProvider: decodeURIComponent(parts[0]),
       agentId: decodeURIComponent(parts[1]),
-      sessionId: decodeURIComponent(parts[2]),
+      ...(decodeURIComponent(parts[0]) === 'work-center'
+        ? { workItemId: decodeURIComponent(parts[2]) }
+        : { sessionId: decodeURIComponent(parts[2]) }),
     };
     if (expectedAgentId && decodedRoute.agentId !== expectedAgentId) return '';
     return workbenchRouteKey(decodedRoute) === routeKey ? routeKey : '';
@@ -102,6 +109,7 @@ function resolveYeaftRow(client, route) {
 // never the browser's cwd or the Server process cwd.
 function resolveSessionWorkDir(row, route) {
   if (!row) return '';
+  if (route.runtimeProvider === 'work-center') return clean(row.workDir, 4096);
   return clean(route.runtimeProvider === 'yeaft' ? row.workDir : row.work_dir, 4096)
     || clean(agents.get(route.agentId)?.workDir, 4096);
 }
@@ -122,9 +130,40 @@ function resolveChatRow(client, route) {
   return row;
 }
 
+function resolveWorkCenterRoute(client, agent, route) {
+  if (client?.workCenterWorkbenchProtocol !== 1
+      || !agentHasCapability(agent, WORK_CENTER_WORKBENCH_CAPABILITY)
+      || !agentSupportsWorkbenchRequestCorrelation(agent)
+      || !agentSupportsWorkbenchTerminalCleanupFence(agent)) return null;
+  const row = getWorkItemWorkspace(client?.userId, route.agentId, route.workItemId);
+  return row?.workDir ? row : null;
+}
+
+export function workbenchPathWithinWorkspace(filePath, workDir) {
+  const path = clean(filePath, 4096);
+  const root = clean(workDir, 4096);
+  if (!path || !root) return false;
+  // The Agent can run a different OS from the Server. Never use Server cwd.
+  const paths = /^(?:[a-z]:[\\/]|\\\\)/i.test(root) ? win32 : posix;
+  if (!paths.isAbsolute(root)) return false;
+  const resolvedRoot = paths.resolve(root);
+  const candidate = paths.resolve(resolvedRoot, path);
+  const relativePath = paths.relative(resolvedRoot, candidate);
+  return relativePath !== '..'
+    && !relativePath.startsWith(`..${paths.sep}`)
+    && !paths.isAbsolute(relativePath);
+}
+
+function resolveRouteRow(client, route, agent) {
+  if (route.runtimeProvider === 'work-center') return resolveWorkCenterRoute(client, agent, route);
+  return route.runtimeProvider === 'yeaft'
+    ? resolveYeaftRow(client, route)
+    : resolveChatRow(client, route);
+}
+
 /**
  * Validate a browser-provided Workbench route against Server-owned Session
- * metadata and return canonical execution fields. Browser cwd and synthetic
+ * metadata or owner-scoped, Agent-projected WorkItem workspace 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.
@@ -135,10 +174,9 @@ function resolveChatRow(client, route) {
  */
 export function currentWorkbenchWorkspaceGeneration({ route, userId, role }) {
   if (!route || !userId) return null;
-  const client = { userId, role };
-  const row = route.runtimeProvider === 'yeaft'
-    ? resolveYeaftRow(client, route)
-    : resolveChatRow(client, route);
+  const client = { userId, role, workCenterWorkbenchProtocol: 1 };
+  const agent = agents.get(route.agentId);
+  const row = resolveRouteRow(client, route, agent);
   if (!row || row.isArchived) return null;
   const workDir = resolveSessionWorkDir(row, route);
   if (!workDir) return '';
@@ -165,17 +203,18 @@ export function resolveWorkbenchRequest(client, msg, targetAgentId, { allowMissi
   }
 
   if (!clientSupportsRoutes || !agentSupportsRoutes) return null;
+  const runtimeProvider = clean(msg.workbenchRoute.runtimeProvider, 32);
   const route = {
-    runtimeProvider: clean(msg.workbenchRoute.runtimeProvider, 32),
+    runtimeProvider,
     agentId: clean(msg.workbenchRoute.agentId),
-    sessionId: clean(msg.workbenchRoute.sessionId),
+    ...(runtimeProvider === 'work-center'
+      ? { workItemId: clean(msg.workbenchRoute.workItemId) }
+      : { 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);
+  const row = resolveRouteRow(client, route, agent);
   if (row?.isArchived && !allowMissingSession) return null;
   if (!row && !allowMissingSession) return null;
 
@@ -189,6 +228,9 @@ export function resolveWorkbenchRequest(client, msg, targetAgentId, { allowMissi
     ? workbenchWorkspaceGeneration(routeKey, sessionWorkDir)
     : clean(msg.workbenchWorkspaceGeneration, 1600);
   if (!workspaceGeneration && !allowMissingSession) return null;
+  if (runtimeProvider === 'work-center' && !allowMissingSession
+      && msg.workbenchWorkspaceGeneration
+      && msg.workbenchWorkspaceGeneration !== workspaceGeneration) return null;
   return {
     legacy: false,
     route,
@@ -196,10 +238,12 @@ export function resolveWorkbenchRequest(client, msg, targetAgentId, { allowMissi
     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.
+    // A WorkItem owns one canonical workspace. Unlike Session Workbench routes,
+    // Files/Git cannot switch this route to an arbitrary browser-provided cwd.
     workDir: sessionWorkDir,
-    requestedWorkDir: clean(msg.workDir, 4096) || sessionWorkDir,
+    requestedWorkDir: route.runtimeProvider === 'work-center'
+      ? sessionWorkDir
+      : clean(msg.workDir, 4096) || sessionWorkDir,
     workspaceGeneration,
     archived: row?.isArchived === true,
   };

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

@@ -16,6 +16,7 @@ import {
   BROWSER_RUNTIME_PROTOCOL,
   BROWSER_RUNTIME_SETUP_PROTOCOL,
   WORKBENCH_ROUTE_PROTOCOL,
+  WORK_CENTER_WORKBENCH_PROTOCOL,
 } from './client-protocol.js';
 import {
   clearWorkbenchCorrelationsForClient,
@@ -112,6 +113,7 @@ export function handleWebConnection(ws, url, req = {}) {
     encryptOutbound: true,
     // Explicit protocols have no omission-based downgrade for security fields.
     workbenchRouteProtocol: 0,
+    workCenterWorkbenchProtocol: 0,
     browserRuntimeProtocol: 0,
     browserRuntimeSetupProtocol: 0,
   });
@@ -141,6 +143,7 @@ export function handleWebConnection(ws, url, req = {}) {
       acceptPlaintext: true,
       yeaftSessionInventoryComplete: true,
       workbenchRouteProtocol: WORKBENCH_ROUTE_PROTOCOL,
+      workCenterWorkbenchProtocol: WORK_CENTER_WORKBENCH_PROTOCOL,
       browserRuntimeProtocol: BROWSER_RUNTIME_PROTOCOL,
       browserRuntimeSetupProtocol: BROWSER_RUNTIME_SETUP_PROTOCOL,
       browserRuntimeEnabled: CONFIG.browserRuntime.enabled,
@@ -259,6 +262,7 @@ async function handleWebMessage(clientId, msg) {
     await sendToWebClient(client, {
       type: 'client_hello_ack',
       workbenchRouteProtocol: client.workbenchRouteProtocol,
+      workCenterWorkbenchProtocol: client.workCenterWorkbenchProtocol,
       browserRuntimeProtocol: client.browserRuntimeProtocol,
       browserRuntimeSetupProtocol: client.browserRuntimeSetupProtocol,
       browserRuntimeEnabled: CONFIG.browserRuntime.enabled,

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.550"}
+{"version":"1.0.551"}