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(fs, cx, |settings, _| {
 49            settings
 50                .agent_servers
 51                .get_or_insert_default()
 52                .claude
 53                .get_or_insert_default()
 54                .default_mode = mode_id.map(|m| m.to_string())
 55        });
 56    }
 57
 58    fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
 59        let settings = cx.read_global(|settings: &SettingsStore, _| {
 60            settings.get::<AllAgentServersSettings>(None).claude.clone()
 61        });
 62
 63        settings
 64            .as_ref()
 65            .and_then(|s| s.default_model.clone().map(|m| acp::ModelId(m.into())))
 66    }
 67
 68    fn set_default_model(&self, model_id: Option<acp::ModelId>, fs: Arc<dyn Fs>, cx: &mut App) {
 69        update_settings_file(fs, cx, |settings, _| {
 70            settings
 71                .agent_servers
 72                .get_or_insert_default()
 73                .claude
 74                .get_or_insert_default()
 75                .default_model = model_id.map(|m| m.to_string())
 76        });
 77    }
 78
 79    fn connect(
 80        &self,
 81        root_dir: Option<&Path>,
 82        delegate: AgentServerDelegate,
 83        cx: &mut App,
 84    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
 85        let name = self.name();
 86        let telemetry_id = self.telemetry_id();
 87        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
 88        let is_remote = delegate.project.read(cx).is_via_remote_server();
 89        let store = delegate.store.downgrade();
 90        let extra_env = load_proxy_env(cx);
 91        let default_mode = self.default_mode(cx);
 92        let default_model = self.default_model(cx);
 93
 94        cx.spawn(async move |cx| {
 95            let (command, root_dir, login) = store
 96                .update(cx, |store, cx| {
 97                    let agent = store
 98                        .get_external_agent(&CLAUDE_CODE_NAME.into())
 99                        .context("Claude Code is not registered")?;
100                    anyhow::Ok(agent.get_command(
101                        root_dir.as_deref(),
102                        extra_env,
103                        delegate.status_tx,
104                        delegate.new_version_available,
105                        &mut cx.to_async(),
106                    ))
107                })??
108                .await?;
109            let connection = crate::acp::connect(
110                name,
111                telemetry_id,
112                command,
113                root_dir.as_ref(),
114                default_mode,
115                default_model,
116                is_remote,
117                cx,
118            )
119            .await?;
120            Ok((connection, login))
121        })
122    }
123
124    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
125        self
126    }
127}