1use agent_client_protocol as acp;
2use collections::HashSet;
3use fs::Fs;
4use settings::{SettingsStore, update_settings_file};
5use std::path::Path;
6use std::rc::Rc;
7use std::sync::Arc;
8use std::{any::Any, path::PathBuf};
9
10use anyhow::{Context as _, Result};
11use gpui::{App, AppContext as _, SharedString, Task};
12use project::agent_server_store::{AllAgentServersSettings, CLAUDE_CODE_NAME};
13
14use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
15use acp_thread::AgentConnection;
16
17#[derive(Clone)]
18pub struct ClaudeCode;
19
20pub struct AgentServerLoginCommand {
21 pub path: PathBuf,
22 pub arguments: Vec<String>,
23}
24
25impl AgentServer for ClaudeCode {
26 fn name(&self) -> SharedString {
27 "Claude Code".into()
28 }
29
30 fn logo(&self) -> ui::IconName {
31 ui::IconName::AiClaude
32 }
33
34 fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
35 let settings = cx.read_global(|settings: &SettingsStore, _| {
36 settings.get::<AllAgentServersSettings>(None).claude.clone()
37 });
38
39 settings
40 .as_ref()
41 .and_then(|s| s.default_mode.clone().map(acp::SessionModeId::new))
42 }
43
44 fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
45 update_settings_file(fs, cx, |settings, _| {
46 settings
47 .agent_servers
48 .get_or_insert_default()
49 .claude
50 .get_or_insert_default()
51 .default_mode = mode_id.map(|m| m.to_string())
52 });
53 }
54
55 fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
56 let settings = cx.read_global(|settings: &SettingsStore, _| {
57 settings.get::<AllAgentServersSettings>(None).claude.clone()
58 });
59
60 settings
61 .as_ref()
62 .and_then(|s| s.default_model.clone().map(acp::ModelId::new))
63 }
64
65 fn set_default_model(&self, model_id: Option<acp::ModelId>, fs: Arc<dyn Fs>, cx: &mut App) {
66 update_settings_file(fs, cx, |settings, _| {
67 settings
68 .agent_servers
69 .get_or_insert_default()
70 .claude
71 .get_or_insert_default()
72 .default_model = model_id.map(|m| m.to_string())
73 });
74 }
75
76 fn favorite_model_ids(&self, cx: &mut App) -> HashSet<acp::ModelId> {
77 let settings = cx.read_global(|settings: &SettingsStore, _| {
78 settings.get::<AllAgentServersSettings>(None).claude.clone()
79 });
80
81 settings
82 .as_ref()
83 .map(|s| {
84 s.favorite_models
85 .iter()
86 .map(|id| acp::ModelId::new(id.clone()))
87 .collect()
88 })
89 .unwrap_or_default()
90 }
91
92 fn toggle_favorite_model(
93 &self,
94 model_id: acp::ModelId,
95 should_be_favorite: bool,
96 fs: Arc<dyn Fs>,
97 cx: &App,
98 ) {
99 update_settings_file(fs, cx, move |settings, _| {
100 let favorite_models = &mut settings
101 .agent_servers
102 .get_or_insert_default()
103 .claude
104 .get_or_insert_default()
105 .favorite_models;
106
107 let model_id_str = model_id.to_string();
108 if should_be_favorite {
109 if !favorite_models.contains(&model_id_str) {
110 favorite_models.push(model_id_str);
111 }
112 } else {
113 favorite_models.retain(|id| id != &model_id_str);
114 }
115 });
116 }
117
118 fn connect(
119 &self,
120 root_dir: Option<&Path>,
121 delegate: AgentServerDelegate,
122 cx: &mut App,
123 ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
124 let name = self.name();
125 let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
126 let is_remote = delegate.project.read(cx).is_via_remote_server();
127 let store = delegate.store.downgrade();
128 let extra_env = load_proxy_env(cx);
129 let default_mode = self.default_mode(cx);
130 let default_model = self.default_model(cx);
131
132 cx.spawn(async move |cx| {
133 let (command, root_dir, login) = store
134 .update(cx, |store, cx| {
135 let agent = store
136 .get_external_agent(&CLAUDE_CODE_NAME.into())
137 .context("Claude Code is not registered")?;
138 anyhow::Ok(agent.get_command(
139 root_dir.as_deref(),
140 extra_env,
141 delegate.status_tx,
142 delegate.new_version_available,
143 &mut cx.to_async(),
144 ))
145 })??
146 .await?;
147 let connection = crate::acp::connect(
148 name,
149 command,
150 root_dir.as_ref(),
151 default_mode,
152 default_model,
153 is_remote,
154 cx,
155 )
156 .await?;
157 Ok((connection, login))
158 })
159 }
160
161 fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
162 self
163 }
164}