@yeaft/webchat-agent 1.0.188 → 1.0.190

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

@@ -0,0 +1,254 @@
+import { agents, userFileTabs } from '../context.js';
+import {
+  sendToWebClient, forwardToAgent, broadcastAgentList
+} from '../ws-utils.js';
+
+/**
+ * Handle miscellaneous messages from web client.
+ * Types: ping, restart_agent, upgrade_agent,
+ *        proxy_update_ports, update_file_tabs, restore_file_tabs
+ */
+export async function handleClientMisc(clientId, client, msg, checkAgentAccess) {
+  switch (msg.type) {
+    case 'ping':
+      await sendToWebClient(client, { type: 'pong' });
+      break;
+
+    case 'restart_agent': {
+      const restartAgentId = msg.agentId;
+      if (!restartAgentId) break;
+      if (!await checkAgentAccess(restartAgentId)) break;
+      await forwardToAgent(restartAgentId, { type: 'restart_agent' });
+      break;
+    }
+
+    case 'upgrade_agent': {
+      const upgradeAgentId = msg.agentId;
+      if (!upgradeAgentId) break;
+      if (!await checkAgentAccess(upgradeAgentId)) break;
+      await forwardToAgent(upgradeAgentId, { type: 'upgrade_agent' });
+      break;
+    }
+
+    case 'proxy_update_ports': {
+      const proxyAgentId = msg.agentId || client.currentAgent;
+      if (!proxyAgentId) break;
+      if (!await checkAgentAccess(proxyAgentId)) break;
+      const agent = agents.get(proxyAgentId);
+      if (agent) agent.proxyPorts = msg.ports || [];
+      await forwardToAgent(proxyAgentId, {
+        type: 'proxy_update_ports',
+        ports: msg.ports || []
+      });
+      break;
+    }
+
+    // File Tab 状态保存/恢复
+    case 'update_file_tabs': {
+      if (client.userId && client.currentAgent) {
+        const key = `${client.userId}:${client.currentAgent}`;
+        userFileTabs.set(key, {
+          files: (msg.openFiles || []).map(f => ({ path: f.path })),
+          activeIndex: msg.activeIndex || 0,
+          timestamp: Date.now()
+        });
+      }
+      break;
+    }
+
+    case 'restore_file_tabs': {
+      const ftAgentId = msg.agentId || client.currentAgent;
+      if (client.userId && ftAgentId) {
+        if (!await checkAgentAccess(ftAgentId)) break;
+        const key = `${client.userId}:${ftAgentId}`;
+        const saved = userFileTabs.get(key);
+        await sendToWebClient(client, {
+          type: 'file_tabs_restored',
+          openFiles: saved?.files || [],
+          activeIndex: saved?.activeIndex || 0
+        });
+      }
+      break;
+    }
+
+    // MCP configuration
+    case 'get_mcp_servers': {
+      const mcpAgentId = msg.agentId || client.currentAgent;
+      if (!mcpAgentId) break;
+      if (!await checkAgentAccess(mcpAgentId)) break;
+      // If server already has cached list, return immediately
+      const mcpAgent = agents.get(mcpAgentId);
+      if (mcpAgent?.mcpServers?.length > 0) {
+        await sendToWebClient(client, {
+          type: 'mcp_servers_list',
+          agentId: mcpAgentId,
+          servers: mcpAgent.mcpServers
+        });
+      } else {
+        await forwardToAgent(mcpAgentId, { type: 'get_mcp_servers' });
+      }
+      break;
+    }
+
+    // Expert roles definition (forward to agent)
+    case 'get_expert_roles': {
+      const expertAgentId = msg.agentId || client.currentAgent;
+      if (!expertAgentId) break;
+      if (!await checkAgentAccess(expertAgentId)) break;
+      await forwardToAgent(expertAgentId, { type: 'get_expert_roles' });
+      break;
+    }
+
+    case 'update_mcp_config': {
+      const configAgentId = msg.agentId || client.currentAgent;
+      if (!configAgentId) break;
+      if (!await checkAgentAccess(configAgentId)) break;
+      await forwardToAgent(configAgentId, {
+        type: 'update_mcp_config',
+        config: msg.config || {}
+      });
+      break;
+    }
+
+    // LLM configuration — this writes only the selected agent's local ~/.yeaft/config.json.
+    case 'get_llm_config': {
+      const llmAgentId = msg.agentId || client.currentAgent;
+      if (!llmAgentId) break;
+      if (!await checkAgentAccess(llmAgentId)) break;
+      await forwardToAgent(llmAgentId, { type: 'get_llm_config' });
+      break;
+    }
+
+    case 'discover_llm_models': {
+      const llmDiscoverAgentId = msg.agentId || client.currentAgent;
+      if (!llmDiscoverAgentId) break;
+      if (!await checkAgentAccess(llmDiscoverAgentId)) break;
+      await forwardToAgent(llmDiscoverAgentId, {
+        type: 'discover_llm_models',
+        agentId: llmDiscoverAgentId,
+        requestId: msg.requestId,
+        providerType: msg.providerType || msg.provider || msg.preset,
+        baseUrl: msg.baseUrl,
+        apiKey: msg.apiKey,
+      });
+      break;
+    }
+
+    case 'update_llm_config': {
+      const llmUpdateAgentId = msg.agentId || client.currentAgent;
+      if (!llmUpdateAgentId) break;
+      if (!await checkAgentAccess(llmUpdateAgentId)) break;
+      await forwardToAgent(llmUpdateAgentId, {
+        type: 'update_llm_config',
+        config: msg.config || {}
+      });
+      break;
+    }
+
+    case 'get_yeaft_settings': {
+      const targetAgentId = msg.agentId || client.currentAgent;
+      if (!targetAgentId) break;
+      if (!await checkAgentAccess(targetAgentId)) break;
+      await forwardToAgent(targetAgentId, { type: 'get_yeaft_settings' });
+      break;
+    }
+
+    case 'update_yeaft_settings': {
+      const targetAgentId = msg.agentId || client.currentAgent;
+      if (!targetAgentId) break;
+      if (!await checkAgentAccess(targetAgentId)) break;
+      await forwardToAgent(targetAgentId, {
+        type: 'update_yeaft_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.
+    case 'get_search_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, { type: 'get_search_settings' });
+      break;
+    }
+
+    case 'update_search_settings': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'update_search_settings',
+        settings: msg.settings || msg.config || {}
+      });
+      break;
+    }
+
+    case 'get_tavily_usage': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, { type: 'get_tavily_usage' });
+      break;
+    }
+
+    // Yeaft MCP CRUD (Claude-Code-style Settings → MCP tab).
+    // Server is a pure relay: agent owns the config file at
+    // `~/.yeaft/config.json` and the live MCPManager + ToolRegistry. We
+    // forward `yeaft_mcp_list/add/remove/reload` to the selected agent
+    // and the response (`yeaft_mcp_*_result` + broadcast
+    // `yeaft_mcp_updated`) flows back via agent-output.
+    case 'yeaft_mcp_list': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'yeaft_mcp_list',
+        requestId: msg.requestId || null,
+      });
+      break;
+    }
+
+    case 'yeaft_mcp_add': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'yeaft_mcp_add',
+        requestId: msg.requestId || null,
+        server: msg.server || {},
+      });
+      break;
+    }
+
+    case 'yeaft_mcp_remove': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'yeaft_mcp_remove',
+        requestId: msg.requestId || null,
+        name: msg.name || '',
+      });
+      break;
+    }
+
+    case 'yeaft_mcp_reload': {
+      const a = msg.agentId || client.currentAgent;
+      if (!a) break;
+      if (!await checkAgentAccess(a)) break;
+      await forwardToAgent(a, {
+        type: 'yeaft_mcp_reload',
+        requestId: msg.requestId || null,
+        name: msg.name || null,
+      });
+      break;
+    }
+
+    default:
+      return false; // Not handled
+  }
+  return true; // Handled
+}

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

@@ -0,0 +1,269 @@
+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 {
+  assertSupportedWorkItemAttachment,
+  assertWorkItemAttachmentSize,
+  MAX_WORK_ITEM_ATTACHMENTS,
+  MAX_WORK_ITEM_ATTACHMENT_BYTES,
+  MAX_WORK_ITEM_INLINE_BYTES,
+} from '../work-item-attachment-policy.js';
+
+const REQUEST_TIMEOUT_MS = 60_000;
+const pendingRequests = new Map();
+
+function decodePreviewBase64(value) {
+  const data = typeof value === 'string' ? value : '';
+  const maxEncodedLength = Math.ceil(MAX_WORK_ITEM_INLINE_BYTES / 3) * 4;
+  if (!data || data.length > maxEncodedLength || data.length % 4 !== 0
+    || !/^[A-Za-z0-9+/]*={0,2}$/.test(data)) {
+    throw new Error('Attachment preview data is not valid base64');
+  }
+  const buffer = Buffer.from(data, 'base64');
+  if (buffer.length > MAX_WORK_ITEM_INLINE_BYTES) {
+    throw new Error(`Attachment preview exceeds ${MAX_WORK_ITEM_INLINE_BYTES} bytes`);
+  }
+  if (buffer.toString('base64') !== data) {
+    throw new Error('Attachment preview data is not canonical base64');
+  }
+  return buffer;
+}
+
+function hasPreviewSignature(buffer, mimeType) {
+  if (mimeType === 'image/png') {
+    return buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+  }
+  if (mimeType === 'image/jpeg') {
+    return buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff;
+  }
+  if (mimeType === 'image/gif') {
+    const signature = buffer.subarray(0, 6).toString('ascii');
+    return signature === 'GIF87a' || signature === 'GIF89a';
+  }
+  if (mimeType === 'image/webp') {
+    return buffer.length >= 12
+      && buffer.subarray(0, 4).toString('ascii') === 'RIFF'
+      && buffer.subarray(8, 12).toString('ascii') === 'WEBP';
+  }
+  if (mimeType === 'application/pdf') return buffer.subarray(0, 5).toString('ascii') === '%PDF-';
+  return true;
+}
+
+export function normalizeWorkItemPreview(previewData, attachment = {}) {
+  if (!previewData || typeof previewData !== 'object' || Array.isArray(previewData)) {
+    throw new Error('Attachment preview data is missing');
+  }
+  const filename = typeof previewData.filename === 'string' && previewData.filename.trim()
+    ? previewData.filename.trim()
+    : typeof attachment.name === 'string' ? attachment.name.trim() : '';
+  const mimeType = typeof previewData.mimeType === 'string' && previewData.mimeType.trim()
+    ? previewData.mimeType.trim().toLowerCase()
+    : typeof attachment.mimeType === 'string' ? attachment.mimeType.trim().toLowerCase() : '';
+  const kind = assertSupportedWorkItemAttachment(filename, mimeType);
+  const buffer = decodePreviewBase64(previewData.data);
+  if (!hasPreviewSignature(buffer, mimeType)) {
+    throw new Error('Attachment preview content does not match its declared type');
+  }
+  return {
+    buffer,
+    filename,
+    mimeType: kind === 'text' ? 'text/plain; charset=utf-8' : mimeType,
+    kind,
+  };
+}
+
+function prunePendingRequests(now = Date.now()) {
+  for (const [requestId, pending] of pendingRequests) {
+    if (pending.expiresAt <= now) pendingRequests.delete(requestId);
+  }
+}
+
+function resolveWorkItemAttachments(client, payload) {
+  const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+  if (attachments.length === 0) return { payload, consumedIds: [] };
+  if (attachments.length > MAX_WORK_ITEM_ATTACHMENTS) {
+    throw new Error(`WorkItem supports at most ${MAX_WORK_ITEM_ATTACHMENTS} attachments`);
+  }
+
+  const resolvedFiles = [];
+  const consumedIds = [];
+  const seen = new Set();
+  let totalBytes = 0;
+  for (const attachment of attachments) {
+    const fileId = typeof attachment?.fileId === 'string' ? attachment.fileId : '';
+    if (!fileId || seen.has(fileId)) throw new Error('Invalid WorkItem attachment reference');
+    seen.add(fileId);
+    const file = pendingFiles.get(fileId);
+    if (!file) throw new Error('WorkItem attachment expired; upload it again');
+    if (file.userId && !CONFIG.skipAuth && file.userId !== client.userId) {
+      throw new Error('WorkItem attachment access denied');
+    }
+    const buffer = Buffer.isBuffer(file.buffer) ? file.buffer : Buffer.from(file.buffer || '');
+    if (buffer.length > CONFIG.maxFileSize) throw new Error('WorkItem attachment exceeds the upload size limit');
+    totalBytes += buffer.length;
+    if (totalBytes > MAX_WORK_ITEM_ATTACHMENT_BYTES) {
+      throw new Error(`WorkItem attachments exceed ${MAX_WORK_ITEM_ATTACHMENT_BYTES} bytes`);
+    }
+    assertSupportedWorkItemAttachment(file.name, file.mimeType);
+    assertWorkItemAttachmentSize(buffer.length);
+    resolvedFiles.push({ file, buffer });
+    consumedIds.push(fileId);
+  }
+  const files = resolvedFiles.map(({ file, buffer }) => ({
+    name: file.name,
+    mimeType: file.mimeType,
+    data: buffer.toString('base64'),
+    isImage: String(file.mimeType || '').startsWith('image/'),
+  }));
+  return {
+    payload: { ...(payload || {}), files },
+    consumedIds,
+  };
+}
+
+/**
+ * Relay Work Center commands to the selected Agent.
+ *
+ * WorkItem data is Agent-local. The server owns authentication and routing.
+ * Request ownership stays server-side; an Agent can never choose which user
+ * receives a response by echoing or forging identity fields.
+ */
+export async function handleClientWorkCenter(client, msg, checkAgentAccess) {
+  if (msg?.type !== 'work_center_request') return false;
+
+  const agentId = typeof msg.agentId === 'string' && msg.agentId.trim()
+    ? msg.agentId.trim()
+    : client.currentAgent;
+  if (!agentId) return true;
+  if (!await checkAgentAccess(agentId)) return true;
+
+  const op = typeof msg.op === 'string' ? msg.op : '';
+  const sourcePayload = msg.payload && typeof msg.payload === 'object' ? msg.payload : {};
+  if (['create', 'action_input', 'guide'].includes(op) && Object.hasOwn(sourcePayload, 'files')) {
+    await sendToWebClient(client, {
+      type: 'work_center_response',
+      requestId: typeof msg.requestId === 'string' ? msg.requestId : null,
+      agentId,
+      op,
+      ok: false,
+      error: 'WorkItem files are server-generated and cannot be supplied by the browser',
+    });
+    return true;
+  }
+
+  const capabilities = agents.get(agentId)?.capabilities;
+  if (!Array.isArray(capabilities) || !capabilities.includes('work_center')) {
+    await sendToWebClient(client, {
+      type: 'work_center_response',
+      requestId: typeof msg.requestId === 'string' ? msg.requestId : null,
+      agentId,
+      op,
+      ok: false,
+      error: 'The selected Agent does not support Work Center; upgrade and restart the Agent',
+    });
+    return true;
+  }
+
+  prunePendingRequests();
+  const requestId = randomUUID();
+  let resolved = { payload: sourcePayload, consumedIds: [] };
+  try {
+    const attachments = Array.isArray(sourcePayload.attachments) ? sourcePayload.attachments : [];
+    if (['create', 'action_input', 'guide'].includes(op) && attachments.length > 0) {
+      const capabilities = agents.get(agentId)?.capabilities;
+      if (!Array.isArray(capabilities) || !capabilities.includes('work_item_attachments')) {
+        throw new Error('The selected Agent does not support WorkItem attachments');
+      }
+    }
+    if (['create', 'action_input', 'guide'].includes(op)) resolved = resolveWorkItemAttachments(client, sourcePayload);
+  } catch (error) {
+    await sendToWebClient(client, {
+      type: 'work_center_response',
+      requestId: typeof msg.requestId === 'string' ? msg.requestId : null,
+      agentId,
+      op,
+      ok: false,
+      error: error?.message || String(error),
+    });
+    return true;
+  }
+
+  // Store the browser correlation id before forwarding. Agent responses can
+  // arrive synchronously for an empty Work Center, so writing it after the
+  // awaited send creates a race where the response deletes this entry first.
+  pendingRequests.set(requestId, {
+    client,
+    agentId,
+    clientRequestId: typeof msg.requestId === 'string' ? msg.requestId : null,
+    attachmentFileIds: resolved.consumedIds,
+    expiresAt: Date.now() + REQUEST_TIMEOUT_MS,
+  });
+
+  try {
+    await forwardToAgent(agentId, {
+      type: 'work_center_request',
+      requestId,
+      op,
+      payload: resolved.payload,
+    });
+  } catch (error) {
+    pendingRequests.delete(requestId);
+    throw error;
+  }
+
+  return true;
+}
+
+export async function deliverWorkCenterResponse(agentId, msg) {
+  prunePendingRequests();
+  const pending = typeof msg?.requestId === 'string' ? pendingRequests.get(msg.requestId) : null;
+  if (!pending || pending.agentId !== agentId) return false;
+  pendingRequests.delete(msg.requestId);
+  if (msg.ok === true) {
+    for (const fileId of pending.attachmentFileIds || []) pendingFiles.delete(fileId);
+  }
+  const { agentId: _untrustedAgentId, requestId: _opaqueRequestId, _requestUserId, ...payload } = msg;
+  let response = payload;
+  if (msg.ok === true && msg.op === 'preview_attachment') {
+    try {
+      const data = payload.data;
+      const preview = normalizeWorkItemPreview(data?.previewData, data?.attachment);
+      const fileId = randomUUID();
+      const token = randomUUID();
+      previewFiles.set(fileId, {
+        ...preview,
+        createdAt: Date.now(),
+        token,
+      });
+      const { previewData: _previewData, ...safeData } = data;
+      response = {
+        ...payload,
+        data: { ...safeData, preview: `/api/preview/${fileId}?token=${encodeURIComponent(token)}` },
+      };
+    } catch (error) {
+      response = {
+        ...payload,
+        ok: false,
+        error: error?.message || String(error),
+        data: undefined,
+      };
+    }
+  }
+  await sendToWebClient(pending.client, {
+    ...response,
+    agentId,
+    requestId: pending.clientRequestId,
+  });
+  return true;
+}
+
+export function clearWorkCenterRequestsForClient(client) {
+  for (const [requestId, pending] of pendingRequests) {
+    if (pending.client === client) pendingRequests.delete(requestId);
+  }
+}
+
+export function __testResetWorkCenterRequests() {
+  pendingRequests.clear();
+}

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

@@ -0,0 +1,146 @@
+import { CONFIG } from '../config.js';
+import {
+  sendToWebClient, forwardToAgent,
+  verifyConversationOwnership, getCachedDir
+} from '../ws-utils.js';
+
+/**
+ * Handle workbench messages from web client (terminal, file, git operations).
+ * Types: terminal_create, terminal_input, terminal_resize, terminal_close,
+ *        read_file, write_file, list_directory,
+ *        git_status, git_diff, git_add, git_reset, git_restore, git_commit, git_push,
+ *        file_search, create_file, delete_files, move_files, copy_files, upload_to_dir
+ */
+/**
+ * Yeaft sessions use an agent-generated virtual conversationId
+ * ('yeaft-<timestamp>', see agent/yeaft/web-bridge.js) that exists neither in
+ * agent.conversations nor in the sessions DB table, so
+ * verifyConversationOwnership always falls through to "not found → deny".
+ * For these ids the ownership boundary is the Agent itself: by the time we
+ * get here the pro/admin workbench role gate (ws-client.js) and
+ * checkAgentAccess → verifyAgentOwnership have both passed — the same trust
+ * model already used by read_file and '_'-prefixed agent-level writes.
+ */
+function isYeaftVirtualConversation(conversationId) {
+  return typeof conversationId === 'string' && conversationId.startsWith('yeaft-');
+}
+
+export async function handleClientWorkbench(clientId, client, msg, checkAgentAccess) {
+  switch (msg.type) {
+    // Terminal messages (forward to agent)
+    case 'terminal_create':
+    case 'terminal_input':
+    case 'terminal_resize':
+    case 'terminal_close': {
+      const termAgentId = msg.agentId || client.currentAgent;
+      if (!termAgentId) return;
+      if (!await checkAgentAccess(termAgentId)) return;
+      const termConvId = msg.conversationId || client.currentConversation;
+      if (!termConvId) return;
+      if (!CONFIG.skipAuth && !isYeaftVirtualConversation(termConvId) && !verifyConversationOwnership(termConvId, client.userId)) {
+        console.warn(`[Security] User ${client.userId} terminal access denied for ${termConvId}`);
+        await sendToWebClient(client, { type: 'error', message: 'Permission denied' });
+        return;
+      }
+      await forwardToAgent(termAgentId, { ...msg, conversationId: termConvId });
+      break;
+    }
+
+    case 'read_file': {
+      const fileAgentId = msg.agentId || client.currentAgent;
+      if (!fileAgentId) { console.warn('[Server] read_file: no agentId'); return; }
+      if (!await checkAgentAccess(fileAgentId)) return;
+      const fileConvId = msg.conversationId || client.currentConversation || '_explorer';
+      console.log(`[Server] Forwarding read_file to agent ${fileAgentId}, conv=${fileConvId}, path=${msg.filePath}`);
+      await forwardToAgent(fileAgentId, { ...msg, conversationId: fileConvId, _requestUserId: client.userId });
+      break;
+    }
+
+    case 'write_file': {
+      const writeAgentId = msg.agentId || client.currentAgent;
+      if (!writeAgentId) return;
+      if (!await checkAgentAccess(writeAgentId)) return;
+      const writeConvId = msg.conversationId || client.currentConversation || '_explorer';
+      const isAgentLevelWrite = writeConvId.startsWith('_') || isYeaftVirtualConversation(writeConvId);
+      if (!isAgentLevelWrite) {
+        if (!CONFIG.skipAuth && !verifyConversationOwnership(writeConvId, client.userId)) {
+          console.warn(`[Security] User ${client.userId} file write denied for ${writeConvId}`);
+          await sendToWebClient(client, { type: 'error', message: 'Permission denied' });
+          return;
+        }
+      }
+      await forwardToAgent(writeAgentId, { ...msg, conversationId: writeConvId, _requestUserId: client.userId });
+      break;
+    }
+
+    case 'list_directory': {
+      const dirAgentId = msg.agentId || client.currentAgent;
+      if (!dirAgentId) return;
+      if (!await checkAgentAccess(dirAgentId)) return;
+
+      // 先查缓存
+      const cached = getCachedDir(dirAgentId, msg.dirPath);
+      if (cached) {
+        await sendToWebClient(client, {
+          type: 'directory_listing',
+          conversationId: msg.conversationId,
+          requestId: msg.requestId,
+          dirPath: msg.dirPath,
+          entries: cached,
+          fromCache: true
+        });
+        return;
+      }
+
+      await forwardToAgent(dirAgentId, {
+        type: 'list_directory',
+        dirPath: msg.dirPath,
+        workDir: msg.workDir,
+        conversationId: msg.conversationId || client.currentConversation,
+        requestId: msg.requestId,
+        _requestUserId: client.userId,
+        _requestClientId: clientId
+      });
+      break;
+    }
+
+    case 'git_status':
+    case 'git_diff':
+    case 'git_add':
+    case 'git_reset':
+    case 'git_restore':
+    case 'git_commit':
+    case 'git_push':
+    case 'file_search': {
+      const gitAgentId = msg.agentId || client.currentAgent;
+      if (!gitAgentId) return;
+      if (!await checkAgentAccess(gitAgentId)) return;
+      await forwardToAgent(gitAgentId, {
+        ...msg,
+        conversationId: msg.conversationId || client.currentConversation,
+        _requestUserId: client.userId
+      });
+      break;
+    }
+
+    case 'create_file':
+    case 'delete_files':
+    case 'move_files':
+    case 'copy_files':
+    case 'upload_to_dir': {
+      const fopAgentId = msg.agentId || client.currentAgent;
+      if (!fopAgentId) return;
+      if (!await checkAgentAccess(fopAgentId)) return;
+      await forwardToAgent(fopAgentId, {
+        ...msg,
+        conversationId: msg.conversationId || client.currentConversation,
+        _requestUserId: client.userId
+      });
+      break;
+    }
+
+    default:
+      return false; // Not handled
+  }
+  return true; // Handled
+}