1use agent_client_protocol as acp;
 2use fs::Fs;
 3use settings::{SettingsStore, update_settings_file};
 4use std::path::Path;
 5use std::rc::Rc;
 6use std::sync::Arc;
 7use std::{any::Any, path::PathBuf};
 8
 9use anyhow::{Context as _, Result};
10use gpui::{App, AppContext as _, SharedString, Task};
11use project::agent_server_store::{AllAgentServersSettings, CLAUDE_CODE_NAME};
12
13use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
14use acp_thread::AgentConnection;
15
16#[derive(Clone)]
17pub struct ClaudeCode;
18
19pub struct AgentServerLoginCommand {
20    pub path: PathBuf,
21    pub arguments: Vec<String>,
22}
23
24impl AgentServer for ClaudeCode {
25    fn telemetry_id(&self) -> &'static str {
26        "claude-code"
27    }
28
29    fn name(&self) -> SharedString {
30        "Claude Code".into()
31    }
32
33    fn logo(&self) -> ui::IconName {
34        ui::IconName::AiClaude
35    }
36
37    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
38        let settings = cx.read_global(|settings: &SettingsStore, _| {
39            settings.get::<AllAgentServersSettings>(None).claude.clone()
40        });
41
42        settings
43            .as_ref()
44            .and_then(|s| s.default_mode.clone().map(|m| acp::SessionModeId(m.into())))
45    }
46
47    fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
48        update_settings_file::<AllAgentServersSettings>(fs, cx, |settings, _| {
49            settings.claude.get_or_insert_default().default_mode = mode_id.map(|m| m.to_string())
50        });
51    }
52
53    fn connect(
54        &self,
55        root_dir: Option<&Path>,
56        delegate: AgentServerDelegate,
57        cx: &mut App,
58    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
59        let name = self.name();
60        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
61        let is_remote = delegate.project.read(cx).is_via_remote_server();
62        let store = delegate.store.downgrade();
63        let extra_env = load_proxy_env(cx);
64        let default_mode = self.default_mode(cx);
65
66        cx.spawn(async move |cx| {
67            let (command, root_dir, login) = store
68                .update(cx, |store, cx| {
69                    let agent = store
70                        .get_external_agent(&CLAUDE_CODE_NAME.into())
71                        .context("Claude Code is not registered")?;
72                    anyhow::Ok(agent.get_command(
73                        root_dir.as_deref(),
74                        extra_env,
75                        delegate.status_tx,
76                        delegate.new_version_available,
77                        &mut cx.to_async(),
78                    ))
79                })??
80                .await?;
81            let connection = crate::acp::connect(
82                name,
83                command,
84                root_dir.as_ref(),
85                default_mode,
86                is_remote,
87                cx,
88            )
89            .await?;
90            Ok((connection, login))
91        })
92    }
93
94    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
95        self
96    }
97}