refactor(app-server): extract mcp domain handlers (R-20 eighth cut)

R-20 eighth cut：提取 mcp domain handlers

改动：
- 新增 processor/mcp.rs（19 个 handler，253 行）
- processor/mod.rs：3215 → 2975 行（-7.5%）

processor 目录结构：
- mod.rs (2975行) — dispatch + 剩余 handlers
- agent_session.rs (237行) — 16 个 handler
- agent_app.rs (155行) — 11 个 handler
- automation.rs (174行) — 13 个 handler
- gateway.rs (148行) — 12 个 handler
- knowledge.rs (139行) — 8 个 handler
- mcp.rs (253行) — 19 个 handler
- media.rs (101行) — 7 个 handler
- model.rs (339行) — 25 个 handler
- skill.rs (303行) — 22 个 handler
- workspace.rs (256行) — 19 个 handler
- project_git.rs (70行) — 4 个 handler

总计提取：156 个 handler（占原始 241 个的 65%）

验证：
- cargo check -p app-server --lib 通过
- 文件体量守卫通过

governance/file-size-baseline.json

@@ -641,8 +641,8 @@
       },
       {
         "path": "lime-rs/crates/app-server/src/processor/mod.rs",
-        "lines": 3216,
-        "comment": "R-20: 10 个 domain 已提取，剩余约 129 个 handler"
+        "lines": 2975,
+        "comment": "R-20: 11 个 domain 已提取，剩余约 104 个 handler"
       },
       {
         "path": "lime-rs/crates/media-runtime/src/lib.rs",

lime-rs/crates/app-server/src/processor/mcp.rs

@@ -0,0 +1,254 @@
+//! mcp domain handlers for the App Server processor.
+
+use super::{dispatch_result, parse_params, to_jsonrpc_error, RequestProcessor, RpcDispatch};
+use app_server_protocol::{
+    JsonRpcError, McpPromptGetParams, McpResourceReadParams, McpServerCreateParams,
+    McpServerDeleteParams, McpServerEnabledSetParams, McpServerImportFromAppParams,
+    McpServerStartParams, McpServerStopParams, McpServerUpdateParams, McpToolCallParams,
+    McpToolCallWithCallerParams, McpToolListForContextParams, McpToolSearchParams,
+};
+use serde_json::Value;
+
+impl RequestProcessor {
+    pub(super) async fn handle_mcp_server_list_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .list_mcp_servers()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_status_list_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .list_mcp_servers_with_status()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_create_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerCreateParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .create_mcp_server(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_update_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerUpdateParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .update_mcp_server(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_delete_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerDeleteParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .delete_mcp_server(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_enabled_set_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerEnabledSetParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .set_mcp_server_enabled(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_import_from_app_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerImportFromAppParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .import_mcp_servers_from_app(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_sync_all_to_live_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .sync_all_mcp_servers_to_live()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_start_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerStartParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .start_mcp_server(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_server_stop_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpServerStopParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .stop_mcp_server(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_tool_list_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .list_mcp_tools()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_tool_list_for_context_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpToolListForContextParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .list_mcp_tools_for_context(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_tool_search_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpToolSearchParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .search_mcp_tools(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_tool_call_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpToolCallParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .call_mcp_tool(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_tool_call_with_caller_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpToolCallWithCallerParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .call_mcp_tool_with_caller(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_prompt_list_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .list_mcp_prompts()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_prompt_get_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpPromptGetParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .get_mcp_prompt(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_resource_list_impl(&self) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let response = self
+            .runtime
+            .list_mcp_resources()
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+
+    pub(super) async fn handle_mcp_resource_read_impl(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<RpcDispatch, JsonRpcError> {
+        self.ensure_initialized()?;
+        let params: McpResourceReadParams = parse_params(params)?;
+        let response = self
+            .runtime
+            .read_mcp_resource(params)
+            .await
+            .map_err(to_jsonrpc_error)?;
+        dispatch_result(response)
+    }
+}

lime-rs/crates/app-server/src/processor/mod.rs

@@ -2,6 +2,7 @@ mod agent_app;
 mod agent_session;
 mod automation;
 mod gateway;
+mod mcp;
 mod media;
 mod model;
 mod knowledge;
@@ -709,27 +710,27 @@ impl RequestProcessor {
             METHOD_AUTOMATION_SCHEDULE_VALIDATE => {
                 self.handle_automation_schedule_validate_impl(params).await
             }
-            METHOD_MCP_SERVER_LIST => self.handle_mcp_server_list().await,
-            METHOD_MCP_SERVER_STATUS_LIST => self.handle_mcp_server_status_list().await,
-            METHOD_MCP_SERVER_CREATE => self.handle_mcp_server_create(params).await,
-            METHOD_MCP_SERVER_UPDATE => self.handle_mcp_server_update(params).await,
-            METHOD_MCP_SERVER_DELETE => self.handle_mcp_server_delete(params).await,
-            METHOD_MCP_SERVER_ENABLED_SET => self.handle_mcp_server_enabled_set(params).await,
+            METHOD_MCP_SERVER_LIST => self.handle_mcp_server_list_impl().await,
+            METHOD_MCP_SERVER_STATUS_LIST => self.handle_mcp_server_status_list_impl().await,
+            METHOD_MCP_SERVER_CREATE => self.handle_mcp_server_create_impl(params).await,
+            METHOD_MCP_SERVER_UPDATE => self.handle_mcp_server_update_impl(params).await,
+            METHOD_MCP_SERVER_DELETE => self.handle_mcp_server_delete_impl(params).await,
+            METHOD_MCP_SERVER_ENABLED_SET => self.handle_mcp_server_enabled_set_impl(params).await,
             METHOD_MCP_SERVER_IMPORT_FROM_APP => {
-                self.handle_mcp_server_import_from_app(params).await
+                self.handle_mcp_server_import_from_app_impl(params).await
             }
-            METHOD_MCP_SERVER_SYNC_ALL_TO_LIVE => self.handle_mcp_server_sync_all_to_live().await,
-            METHOD_MCP_SERVER_START => self.handle_mcp_server_start(params).await,
-            METHOD_MCP_SERVER_STOP => self.handle_mcp_server_stop(params).await,
-            METHOD_MCP_TOOL_LIST => self.handle_mcp_tool_list().await,
-            METHOD_MCP_TOOL_LIST_FOR_CONTEXT => self.handle_mcp_tool_list_for_context(params).await,
-            METHOD_MCP_TOOL_SEARCH => self.handle_mcp_tool_search(params).await,
-            METHOD_MCP_TOOL_CALL => self.handle_mcp_tool_call(params).await,
-            METHOD_MCP_TOOL_CALL_WITH_CALLER => self.handle_mcp_tool_call_with_caller(params).await,
-            METHOD_MCP_PROMPT_LIST => self.handle_mcp_prompt_list().await,
-            METHOD_MCP_PROMPT_GET => self.handle_mcp_prompt_get(params).await,
-            METHOD_MCP_RESOURCE_LIST => self.handle_mcp_resource_list().await,
-            METHOD_MCP_RESOURCE_READ => self.handle_mcp_resource_read(params).await,
+            METHOD_MCP_SERVER_SYNC_ALL_TO_LIVE => self.handle_mcp_server_sync_all_to_live_impl().await,
+            METHOD_MCP_SERVER_START => self.handle_mcp_server_start_impl(params).await,
+            METHOD_MCP_SERVER_STOP => self.handle_mcp_server_stop_impl(params).await,
+            METHOD_MCP_TOOL_LIST => self.handle_mcp_tool_list_impl().await,
+            METHOD_MCP_TOOL_LIST_FOR_CONTEXT => self.handle_mcp_tool_list_for_context_impl(params).await,
+            METHOD_MCP_TOOL_SEARCH => self.handle_mcp_tool_search_impl(params).await,
+            METHOD_MCP_TOOL_CALL => self.handle_mcp_tool_call_impl(params).await,
+            METHOD_MCP_TOOL_CALL_WITH_CALLER => self.handle_mcp_tool_call_with_caller_impl(params).await,
+            METHOD_MCP_PROMPT_LIST => self.handle_mcp_prompt_list_impl().await,
+            METHOD_MCP_PROMPT_GET => self.handle_mcp_prompt_get_impl(params).await,
+            METHOD_MCP_RESOURCE_LIST => self.handle_mcp_resource_list_impl().await,
+            METHOD_MCP_RESOURCE_READ => self.handle_mcp_resource_read_impl(params).await,
             METHOD_PROJECT_MEMORY_READ => self.handle_project_memory_read(params).await,
             METHOD_UNIFIED_MEMORY_LIST => self.handle_unified_memory_list(params).await,
             METHOD_UNIFIED_MEMORY_GET => self.handle_unified_memory_get(params).await,
@@ -1530,248 +1531,7 @@ impl RequestProcessor {
             .map_err(to_jsonrpc_error)?;
         dispatch_result(response)
     }
-
-    async fn handle_mcp_server_list(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .list_mcp_servers()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_status_list(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .list_mcp_servers_with_status()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_create(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerCreateParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .create_mcp_server(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_update(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerUpdateParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .update_mcp_server(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_delete(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerDeleteParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .delete_mcp_server(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_enabled_set(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerEnabledSetParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .set_mcp_server_enabled(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_import_from_app(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerImportFromAppParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .import_mcp_servers_from_app(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_sync_all_to_live(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .sync_all_mcp_servers_to_live()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_start(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerStartParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .start_mcp_server(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_server_stop(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpServerStopParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .stop_mcp_server(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_tool_list(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .list_mcp_tools()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_tool_list_for_context(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpToolListForContextParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .list_mcp_tools_for_context(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_tool_search(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpToolSearchParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .search_mcp_tools(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_tool_call(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpToolCallParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .call_mcp_tool(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_tool_call_with_caller(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpToolCallWithCallerParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .call_mcp_tool_with_caller(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_prompt_list(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .list_mcp_prompts()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_prompt_get(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpPromptGetParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .get_mcp_prompt(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_resource_list(&self) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let response = self
-            .runtime
-            .list_mcp_resources()
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
-
-    async fn handle_mcp_resource_read(
-        &self,
-        params: Option<serde_json::Value>,
-    ) -> Result<RpcDispatch, JsonRpcError> {
-        self.ensure_initialized()?;
-        let params: McpResourceReadParams = parse_params(params)?;
-        let response = self
-            .runtime
-            .read_mcp_resource(params)
-            .await
-            .map_err(to_jsonrpc_error)?;
-        dispatch_result(response)
-    }
+    // mcp handlers 已提取到 processor/mcp.rs
 
     async fn handle_log_list(&self) -> Result<RpcDispatch, JsonRpcError> {
         self.ensure_initialized()?;