1use anyhow::Result;
2use collections::HashMap;
3use gpui::{AppContext, AsyncApp, SharedString, Task, TestAppContext};
4use node_runtime::NodeRuntime;
5use project::agent_server_store::*;
6use project::worktree_store::WorktreeStore;
7use std::{any::Any, path::PathBuf, sync::Arc};
8
9#[test]
10fn extension_agent_constructs_proper_display_names() {
11 // Verify the display name format for extension-provided agents
12 let name1 = ExternalAgentServerName(SharedString::from("Extension: Agent"));
13 assert!(name1.0.contains(": "));
14
15 let name2 = ExternalAgentServerName(SharedString::from("MyExt: MyAgent"));
16 assert_eq!(name2.0, "MyExt: MyAgent");
17
18 // Non-extension agents shouldn't have the separator
19 let custom = ExternalAgentServerName(SharedString::from("custom"));
20 assert!(!custom.0.contains(": "));
21}
22
23struct NoopExternalAgent;
24
25impl ExternalAgentServer for NoopExternalAgent {
26 fn get_command(
27 &mut self,
28 _root_dir: Option<&str>,
29 _extra_env: HashMap<String, String>,
30 _status_tx: Option<watch::Sender<SharedString>>,
31 _new_version_available_tx: Option<watch::Sender<Option<String>>>,
32 _cx: &mut AsyncApp,
33 ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>> {
34 Task::ready(Ok((
35 AgentServerCommand {
36 path: PathBuf::from("noop"),
37 args: Vec::new(),
38 env: None,
39 },
40 "".to_string(),
41 None,
42 )))
43 }
44
45 fn as_any_mut(&mut self) -> &mut dyn Any {
46 self
47 }
48}
49
50#[test]
51fn sync_removes_only_extension_provided_agents() {
52 let mut store = AgentServerStore::collab();
53
54 // Seed with extension agents (contain ": ") and custom agents (don't contain ": ")
55 store.external_agents.insert(
56 ExternalAgentServerName(SharedString::from("Ext1: Agent1")),
57 ExternalAgentEntry::new(
58 Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
59 ExternalAgentSource::Extension,
60 None,
61 None,
62 ),
63 );
64 store.external_agents.insert(
65 ExternalAgentServerName(SharedString::from("Ext2: Agent2")),
66 ExternalAgentEntry::new(
67 Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
68 ExternalAgentSource::Extension,
69 None,
70 None,
71 ),
72 );
73 store.external_agents.insert(
74 ExternalAgentServerName(SharedString::from("custom-agent")),
75 ExternalAgentEntry::new(
76 Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
77 ExternalAgentSource::Custom,
78 None,
79 None,
80 ),
81 );
82
83 // Simulate removal phase
84 store
85 .external_agents
86 .retain(|_, entry| entry.source != ExternalAgentSource::Extension);
87
88 // Only custom-agent should remain
89 assert_eq!(store.external_agents.len(), 1);
90 assert!(
91 store
92 .external_agents
93 .contains_key(&ExternalAgentServerName(SharedString::from("custom-agent")))
94 );
95}
96
97#[test]
98fn archive_launcher_constructs_with_all_fields() {
99 use extension::AgentServerManifestEntry;
100
101 let mut env = HashMap::default();
102 env.insert("GITHUB_TOKEN".into(), "secret".into());
103
104 let mut targets = HashMap::default();
105 targets.insert(
106 "darwin-aarch64".to_string(),
107 extension::TargetConfig {
108 archive:
109 "https://github.com/owner/repo/releases/download/v1.0.0/agent-darwin-arm64.zip"
110 .into(),
111 cmd: "./agent".into(),
112 args: vec![],
113 sha256: None,
114 env: Default::default(),
115 },
116 );
117
118 let _entry = AgentServerManifestEntry {
119 name: "GitHub Agent".into(),
120 targets,
121 env,
122 icon: None,
123 };
124
125 // Verify display name construction
126 let expected_name = ExternalAgentServerName(SharedString::from("GitHub Agent"));
127 assert_eq!(expected_name.0, "GitHub Agent");
128}
129
130#[gpui::test]
131async fn archive_agent_uses_extension_and_agent_id_for_cache_key(cx: &mut TestAppContext) {
132 let fs = fs::FakeFs::new(cx.background_executor.clone());
133 let http_client = http_client::FakeHttpClient::with_404_response();
134 let worktree_store = cx.new(|_| WorktreeStore::local(false, fs.clone()));
135 let project_environment = cx.new(|cx| {
136 crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
137 });
138
139 let agent = LocalExtensionArchiveAgent {
140 fs,
141 http_client,
142 node_runtime: node_runtime::NodeRuntime::unavailable(),
143 project_environment,
144 extension_id: Arc::from("my-extension"),
145 agent_id: Arc::from("my-agent"),
146 targets: {
147 let mut map = HashMap::default();
148 map.insert(
149 "darwin-aarch64".to_string(),
150 extension::TargetConfig {
151 archive: "https://example.com/my-agent-darwin-arm64.zip".into(),
152 cmd: "./my-agent".into(),
153 args: vec!["--serve".into()],
154 sha256: None,
155 env: Default::default(),
156 },
157 );
158 map
159 },
160 env: {
161 let mut map = HashMap::default();
162 map.insert("PORT".into(), "8080".into());
163 map
164 },
165 };
166
167 // Verify agent is properly constructed
168 assert_eq!(agent.extension_id.as_ref(), "my-extension");
169 assert_eq!(agent.agent_id.as_ref(), "my-agent");
170 assert_eq!(agent.env.get("PORT"), Some(&"8080".to_string()));
171 assert!(agent.targets.contains_key("darwin-aarch64"));
172}
173
174#[test]
175fn sync_extension_agents_registers_archive_launcher() {
176 use extension::AgentServerManifestEntry;
177
178 let expected_name = ExternalAgentServerName(SharedString::from("Release Agent"));
179 assert_eq!(expected_name.0, "Release Agent");
180
181 // Verify the manifest entry structure for archive-based installation
182 let mut env = HashMap::default();
183 env.insert("API_KEY".into(), "secret".into());
184
185 let mut targets = HashMap::default();
186 targets.insert(
187 "linux-x86_64".to_string(),
188 extension::TargetConfig {
189 archive: "https://github.com/org/project/releases/download/v2.1.0/release-agent-linux-x64.tar.gz".into(),
190 cmd: "./release-agent".into(),
191 args: vec!["serve".into()],
192 sha256: None,
193 env: Default::default(),
194 },
195 );
196
197 let manifest_entry = AgentServerManifestEntry {
198 name: "Release Agent".into(),
199 targets: targets.clone(),
200 env,
201 icon: None,
202 };
203
204 // Verify target config is present
205 assert!(manifest_entry.targets.contains_key("linux-x86_64"));
206 let target = manifest_entry.targets.get("linux-x86_64").unwrap();
207 assert_eq!(target.cmd, "./release-agent");
208}
209
210#[gpui::test]
211async fn test_node_command_uses_managed_runtime(cx: &mut TestAppContext) {
212 let fs = fs::FakeFs::new(cx.background_executor.clone());
213 let http_client = http_client::FakeHttpClient::with_404_response();
214 let node_runtime = NodeRuntime::unavailable();
215 let worktree_store = cx.new(|_| WorktreeStore::local(false, fs.clone()));
216 let project_environment = cx.new(|cx| {
217 crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
218 });
219
220 let agent = LocalExtensionArchiveAgent {
221 fs: fs.clone(),
222 http_client,
223 node_runtime,
224 project_environment,
225 extension_id: Arc::from("node-extension"),
226 agent_id: Arc::from("node-agent"),
227 targets: {
228 let mut map = HashMap::default();
229 map.insert(
230 "darwin-aarch64".to_string(),
231 extension::TargetConfig {
232 archive: "https://example.com/node-agent.zip".into(),
233 cmd: "node".into(),
234 args: vec!["index.js".into()],
235 sha256: None,
236 env: Default::default(),
237 },
238 );
239 map
240 },
241 env: HashMap::default(),
242 };
243
244 // Verify that when cmd is "node", it attempts to use the node runtime
245 assert_eq!(agent.extension_id.as_ref(), "node-extension");
246 assert_eq!(agent.agent_id.as_ref(), "node-agent");
247
248 let target = agent.targets.get("darwin-aarch64").unwrap();
249 assert_eq!(target.cmd, "node");
250 assert_eq!(target.args, vec!["index.js"]);
251}
252
253#[gpui::test]
254async fn test_commands_run_in_extraction_directory(cx: &mut TestAppContext) {
255 let fs = fs::FakeFs::new(cx.background_executor.clone());
256 let http_client = http_client::FakeHttpClient::with_404_response();
257 let node_runtime = NodeRuntime::unavailable();
258 let worktree_store = cx.new(|_| WorktreeStore::local(false, fs.clone()));
259 let project_environment = cx.new(|cx| {
260 crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
261 });
262
263 let agent = LocalExtensionArchiveAgent {
264 fs: fs.clone(),
265 http_client,
266 node_runtime,
267 project_environment,
268 extension_id: Arc::from("test-ext"),
269 agent_id: Arc::from("test-agent"),
270 targets: {
271 let mut map = HashMap::default();
272 map.insert(
273 "darwin-aarch64".to_string(),
274 extension::TargetConfig {
275 archive: "https://example.com/test.zip".into(),
276 cmd: "node".into(),
277 args: vec![
278 "server.js".into(),
279 "--config".into(),
280 "./config.json".into(),
281 ],
282 sha256: None,
283 env: Default::default(),
284 },
285 );
286 map
287 },
288 env: Default::default(),
289 };
290
291 // Verify the agent is configured with relative paths in args
292 let target = agent.targets.get("darwin-aarch64").unwrap();
293 assert_eq!(target.args[0], "server.js");
294 assert_eq!(target.args[2], "./config.json");
295 // These relative paths will resolve relative to the extraction directory
296 // when the command is executed
297}
298
299#[test]
300fn test_tilde_expansion_in_settings() {
301 let settings = settings::BuiltinAgentServerSettings {
302 path: Some(PathBuf::from("~/bin/agent")),
303 args: Some(vec!["--flag".into()]),
304 env: None,
305 ignore_system_version: None,
306 default_mode: None,
307 default_model: None,
308 favorite_models: vec![],
309 default_config_options: Default::default(),
310 favorite_config_option_values: Default::default(),
311 };
312
313 let BuiltinAgentServerSettings { path, .. } = settings.into();
314
315 let path = path.unwrap();
316 assert!(
317 !path.to_string_lossy().starts_with("~"),
318 "Tilde should be expanded for builtin agent path"
319 );
320
321 let settings = settings::CustomAgentServerSettings::Custom {
322 path: PathBuf::from("~/custom/agent"),
323 args: vec!["serve".into()],
324 env: Default::default(),
325 default_mode: None,
326 default_model: None,
327 favorite_models: vec![],
328 default_config_options: Default::default(),
329 favorite_config_option_values: Default::default(),
330 };
331
332 let converted: CustomAgentServerSettings = settings.into();
333 let CustomAgentServerSettings::Custom {
334 command: AgentServerCommand { path, .. },
335 ..
336 } = converted
337 else {
338 panic!("Expected Custom variant");
339 };
340
341 assert!(
342 !path.to_string_lossy().starts_with("~"),
343 "Tilde should be expanded for custom agent path"
344 );
345}