1use std::path::PathBuf;
 2use std::sync::Arc;
 3
 4use crate::claude::edit_tool::EditTool;
 5use crate::claude::permission_tool::PermissionTool;
 6use crate::claude::read_tool::ReadTool;
 7use crate::claude::write_tool::WriteTool;
 8use acp_thread::AcpThread;
 9#[cfg(not(test))]
10use anyhow::Context as _;
11use anyhow::Result;
12use collections::HashMap;
13use context_server::types::{
14    Implementation, InitializeParams, InitializeResponse, ProtocolVersion, ServerCapabilities,
15    ToolsCapabilities, requests,
16};
17use gpui::{App, AsyncApp, Task, WeakEntity};
18use project::Fs;
19use serde::Serialize;
20
21pub struct ClaudeZedMcpServer {
22    server: context_server::listener::McpServer,
23}
24
25pub const SERVER_NAME: &str = "zed";
26
27impl ClaudeZedMcpServer {
28    pub async fn new(
29        thread_rx: watch::Receiver<WeakEntity<AcpThread>>,
30        fs: Arc<dyn Fs>,
31        cx: &AsyncApp,
32    ) -> Result<Self> {
33        let mut mcp_server = context_server::listener::McpServer::new(cx).await?;
34        mcp_server.handle_request::<requests::Initialize>(Self::handle_initialize);
35
36        mcp_server.add_tool(PermissionTool::new(fs.clone(), thread_rx.clone()));
37        mcp_server.add_tool(ReadTool::new(thread_rx.clone()));
38        mcp_server.add_tool(EditTool::new(thread_rx.clone()));
39        mcp_server.add_tool(WriteTool::new(thread_rx.clone()));
40
41        Ok(Self { server: mcp_server })
42    }
43
44    pub fn server_config(&self) -> Result<McpServerConfig> {
45        #[cfg(not(test))]
46        let zed_path = std::env::current_exe()
47            .context("finding current executable path for use in mcp_server")?;
48
49        #[cfg(test)]
50        let zed_path = crate::e2e_tests::get_zed_path();
51
52        Ok(McpServerConfig {
53            command: zed_path,
54            args: vec![
55                "--nc".into(),
56                self.server.socket_path().display().to_string(),
57            ],
58            env: None,
59        })
60    }
61
62    fn handle_initialize(_: InitializeParams, cx: &App) -> Task<Result<InitializeResponse>> {
63        cx.foreground_executor().spawn(async move {
64            Ok(InitializeResponse {
65                protocol_version: ProtocolVersion("2025-06-18".into()),
66                capabilities: ServerCapabilities {
67                    experimental: None,
68                    logging: None,
69                    completions: None,
70                    prompts: None,
71                    resources: None,
72                    tools: Some(ToolsCapabilities {
73                        list_changed: Some(false),
74                    }),
75                },
76                server_info: Implementation {
77                    name: SERVER_NAME.into(),
78                    version: "0.1.0".into(),
79                },
80                meta: None,
81            })
82        })
83    }
84}
85
86#[derive(Serialize)]
87#[serde(rename_all = "camelCase")]
88pub struct McpConfig {
89    pub mcp_servers: HashMap<String, McpServerConfig>,
90}
91
92#[derive(Serialize, Clone)]
93#[serde(rename_all = "camelCase")]
94pub struct McpServerConfig {
95    pub command: PathBuf,
96    pub args: Vec<String>,
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub env: Option<HashMap<String, String>>,
99}