1use std::collections::{BTreeSet, HashMap};
2use std::env;
3use std::fs;
4use std::path::{Path, PathBuf};
5use std::sync::Arc;
6
7use ::fs::{CopyOptions, Fs, RealFs, copy_recursive};
8use anyhow::{Context as _, Result, anyhow, bail};
9use clap::Parser;
10use extension::extension_builder::{CompileExtensionOptions, ExtensionBuilder};
11use extension::{ExtensionManifest, ExtensionSnippets};
12use language::LanguageConfig;
13use reqwest_client::ReqwestClient;
14use rpc::ExtensionProvides;
15use snippet_provider::file_to_snippets;
16use snippet_provider::format::VsSnippetsFile;
17use tokio::process::Command;
18use tree_sitter::{Language, Query, WasmStore};
19
20#[derive(Parser, Debug)]
21#[command(name = "zed-extension")]
22struct Args {
23 /// The path to the extension directory
24 #[arg(long)]
25 source_dir: PathBuf,
26 /// The output directory to place the packaged extension.
27 #[arg(long)]
28 output_dir: PathBuf,
29 /// The path to a directory where build dependencies are downloaded
30 #[arg(long)]
31 scratch_dir: PathBuf,
32}
33
34#[tokio::main]
35async fn main() -> Result<()> {
36 env_logger::init();
37
38 let args = Args::parse();
39 let fs = Arc::new(RealFs::new(None, gpui::background_executor()));
40 let engine = wasmtime::Engine::default();
41 let mut wasm_store = WasmStore::new(&engine)?;
42
43 let extension_path = args
44 .source_dir
45 .canonicalize()
46 .context("failed to canonicalize source_dir")?;
47 let scratch_dir = args
48 .scratch_dir
49 .canonicalize()
50 .context("failed to canonicalize scratch_dir")?;
51 let output_dir = if args.output_dir.is_relative() {
52 env::current_dir()?.join(&args.output_dir)
53 } else {
54 args.output_dir
55 };
56
57 log::info!("loading extension manifest");
58 let mut manifest = ExtensionManifest::load(fs.clone(), &extension_path).await?;
59
60 log::info!("compiling extension");
61
62 let user_agent = format!(
63 "Zed Extension CLI/{} ({}; {})",
64 env!("CARGO_PKG_VERSION"),
65 std::env::consts::OS,
66 std::env::consts::ARCH
67 );
68 let http_client = Arc::new(ReqwestClient::user_agent(&user_agent)?);
69
70 let builder = ExtensionBuilder::new(http_client, scratch_dir);
71 builder
72 .compile_extension(
73 &extension_path,
74 &mut manifest,
75 CompileExtensionOptions { release: true },
76 fs.clone(),
77 )
78 .await
79 .context("failed to compile extension")?;
80
81 let extension_provides = extension_provides(&manifest);
82
83 if extension_provides.is_empty() {
84 bail!("extension does not provide any features");
85 }
86
87 let grammars = test_grammars(&manifest, &extension_path, &mut wasm_store)?;
88 test_languages(&manifest, &extension_path, &grammars)?;
89 test_themes(&manifest, &extension_path, fs.clone()).await?;
90 test_snippets(&manifest, &extension_path, fs.clone()).await?;
91
92 let archive_dir = output_dir.join("archive");
93 fs::remove_dir_all(&archive_dir).ok();
94 copy_extension_resources(&manifest, &extension_path, &archive_dir, fs.clone())
95 .await
96 .context("failed to copy extension resources")?;
97
98 let tar_output = Command::new("tar")
99 .current_dir(&output_dir)
100 .args(["-czvf", "archive.tar.gz", "-C", "archive", "."])
101 .output()
102 .await
103 .context("failed to run tar")?;
104 if !tar_output.status.success() {
105 bail!(
106 "failed to create archive.tar.gz: {}",
107 String::from_utf8_lossy(&tar_output.stderr)
108 );
109 }
110
111 let manifest_json = serde_json::to_string(&rpc::ExtensionApiManifest {
112 name: manifest.name,
113 version: manifest.version,
114 description: manifest.description,
115 authors: manifest.authors,
116 schema_version: Some(manifest.schema_version.0),
117 repository: manifest
118 .repository
119 .context("missing repository in extension manifest")?,
120 wasm_api_version: manifest.lib.version.map(|version| version.to_string()),
121 provides: extension_provides,
122 })?;
123 fs::remove_dir_all(&archive_dir)?;
124 fs::write(output_dir.join("manifest.json"), manifest_json.as_bytes())?;
125
126 Ok(())
127}
128
129/// Returns the set of features provided by the extension.
130fn extension_provides(manifest: &ExtensionManifest) -> BTreeSet<ExtensionProvides> {
131 let mut provides = BTreeSet::default();
132 if !manifest.themes.is_empty() {
133 provides.insert(ExtensionProvides::Themes);
134 }
135
136 if !manifest.icon_themes.is_empty() {
137 provides.insert(ExtensionProvides::IconThemes);
138 }
139
140 if !manifest.languages.is_empty() {
141 provides.insert(ExtensionProvides::Languages);
142 }
143
144 if !manifest.grammars.is_empty() {
145 provides.insert(ExtensionProvides::Grammars);
146 }
147
148 if !manifest.language_servers.is_empty() {
149 provides.insert(ExtensionProvides::LanguageServers);
150 }
151
152 if !manifest.context_servers.is_empty() {
153 provides.insert(ExtensionProvides::ContextServers);
154 }
155
156 if !manifest.agent_servers.is_empty() {
157 provides.insert(ExtensionProvides::AgentServers);
158 }
159
160 if manifest.snippets.is_some() {
161 provides.insert(ExtensionProvides::Snippets);
162 }
163
164 if !manifest.debug_adapters.is_empty() {
165 provides.insert(ExtensionProvides::DebugAdapters);
166 }
167
168 provides
169}
170
171async fn copy_extension_resources(
172 manifest: &ExtensionManifest,
173 extension_path: &Path,
174 output_dir: &Path,
175 fs: Arc<dyn Fs>,
176) -> Result<()> {
177 fs::create_dir_all(output_dir).context("failed to create output dir")?;
178
179 let manifest_toml = toml::to_string(&manifest).context("failed to serialize manifest")?;
180 fs::write(output_dir.join("extension.toml"), &manifest_toml)
181 .context("failed to write extension.toml")?;
182
183 if manifest.lib.kind.is_some() {
184 fs::copy(
185 extension_path.join("extension.wasm"),
186 output_dir.join("extension.wasm"),
187 )
188 .context("failed to copy extension.wasm")?;
189 }
190
191 if !manifest.grammars.is_empty() {
192 let source_grammars_dir = extension_path.join("grammars");
193 let output_grammars_dir = output_dir.join("grammars");
194 fs::create_dir_all(&output_grammars_dir)?;
195 for grammar_name in manifest.grammars.keys() {
196 let mut grammar_filename = PathBuf::from(grammar_name.as_ref());
197 grammar_filename.set_extension("wasm");
198 fs::copy(
199 source_grammars_dir.join(&grammar_filename),
200 output_grammars_dir.join(&grammar_filename),
201 )
202 .with_context(|| format!("failed to copy grammar '{}'", grammar_filename.display()))?;
203 }
204 }
205
206 if !manifest.themes.is_empty() {
207 let output_themes_dir = output_dir.join("themes");
208 fs::create_dir_all(&output_themes_dir)?;
209 for theme_path in &manifest.themes {
210 fs::copy(
211 extension_path.join(theme_path),
212 output_themes_dir.join(theme_path.file_name().context("invalid theme path")?),
213 )
214 .with_context(|| format!("failed to copy theme '{}'", theme_path.display()))?;
215 }
216 }
217
218 if !manifest.icon_themes.is_empty() {
219 let output_icon_themes_dir = output_dir.join("icon_themes");
220 fs::create_dir_all(&output_icon_themes_dir)?;
221 for icon_theme_path in &manifest.icon_themes {
222 fs::copy(
223 extension_path.join(icon_theme_path),
224 output_icon_themes_dir.join(
225 icon_theme_path
226 .file_name()
227 .context("invalid icon theme path")?,
228 ),
229 )
230 .with_context(|| {
231 format!("failed to copy icon theme '{}'", icon_theme_path.display())
232 })?;
233 }
234
235 let output_icons_dir = output_dir.join("icons");
236 fs::create_dir_all(&output_icons_dir)?;
237 copy_recursive(
238 fs.as_ref(),
239 &extension_path.join("icons"),
240 &output_icons_dir,
241 CopyOptions {
242 overwrite: true,
243 ignore_if_exists: false,
244 },
245 )
246 .await
247 .with_context(|| "failed to copy icons")?;
248 }
249
250 for (_, agent_entry) in &manifest.agent_servers {
251 if let Some(icon_path) = &agent_entry.icon {
252 let source_icon = extension_path.join(icon_path);
253 let dest_icon = output_dir.join(icon_path);
254
255 // Create parent directory if needed
256 if let Some(parent) = dest_icon.parent() {
257 fs::create_dir_all(parent)?;
258 }
259
260 fs::copy(&source_icon, &dest_icon)
261 .with_context(|| format!("failed to copy agent server icon '{}'", icon_path))?;
262 }
263 }
264
265 if !manifest.languages.is_empty() {
266 let output_languages_dir = output_dir.join("languages");
267 fs::create_dir_all(&output_languages_dir)?;
268 for language_path in &manifest.languages {
269 copy_recursive(
270 fs.as_ref(),
271 &extension_path.join(language_path),
272 &output_languages_dir
273 .join(language_path.file_name().context("invalid language path")?),
274 CopyOptions {
275 overwrite: true,
276 ignore_if_exists: false,
277 },
278 )
279 .await
280 .with_context(|| {
281 format!("failed to copy language dir '{}'", language_path.display())
282 })?;
283 }
284 }
285
286 if !manifest.debug_adapters.is_empty() {
287 for (debug_adapter, entry) in &manifest.debug_adapters {
288 let schema_path = entry.schema_path.clone().unwrap_or_else(|| {
289 PathBuf::from("debug_adapter_schemas".to_owned())
290 .join(debug_adapter.as_ref())
291 .with_extension("json")
292 });
293 let parent = schema_path
294 .parent()
295 .with_context(|| format!("invalid empty schema path for {debug_adapter}"))?;
296 fs::create_dir_all(output_dir.join(parent))?;
297 copy_recursive(
298 fs.as_ref(),
299 &extension_path.join(&schema_path),
300 &output_dir.join(&schema_path),
301 CopyOptions {
302 overwrite: true,
303 ignore_if_exists: false,
304 },
305 )
306 .await
307 .with_context(|| {
308 format!(
309 "failed to copy debug adapter schema '{}'",
310 schema_path.display()
311 )
312 })?;
313 }
314 }
315
316 if let Some(snippets) = manifest.snippets.as_ref() {
317 for snippets_path in snippets.paths() {
318 let parent = snippets_path.parent();
319 if let Some(parent) = parent.filter(|p| p.components().next().is_some()) {
320 fs::create_dir_all(output_dir.join(parent))?;
321 }
322 copy_recursive(
323 fs.as_ref(),
324 &extension_path.join(&snippets_path),
325 &output_dir.join(&snippets_path),
326 CopyOptions {
327 overwrite: true,
328 ignore_if_exists: false,
329 },
330 )
331 .await
332 .with_context(|| {
333 format!("failed to copy snippets from '{}'", snippets_path.display())
334 })?;
335 }
336 }
337
338 Ok(())
339}
340
341fn test_grammars(
342 manifest: &ExtensionManifest,
343 extension_path: &Path,
344 wasm_store: &mut WasmStore,
345) -> Result<HashMap<String, Language>> {
346 let mut grammars = HashMap::default();
347 let grammars_dir = extension_path.join("grammars");
348
349 for grammar_name in manifest.grammars.keys() {
350 let mut grammar_path = grammars_dir.join(grammar_name.as_ref());
351 grammar_path.set_extension("wasm");
352
353 let wasm = fs::read(&grammar_path)?;
354 let language = wasm_store.load_language(grammar_name, &wasm)?;
355 log::info!("loaded grammar {grammar_name}");
356 grammars.insert(grammar_name.to_string(), language);
357 }
358
359 Ok(grammars)
360}
361
362fn test_languages(
363 manifest: &ExtensionManifest,
364 extension_path: &Path,
365 grammars: &HashMap<String, Language>,
366) -> Result<()> {
367 for relative_language_dir in &manifest.languages {
368 let language_dir = extension_path.join(relative_language_dir);
369 let config_path = language_dir.join("config.toml");
370 let config_content = fs::read_to_string(&config_path)?;
371 let config: LanguageConfig = toml::from_str(&config_content)?;
372 let grammar = if let Some(name) = &config.grammar {
373 Some(
374 grammars
375 .get(name.as_ref())
376 .with_context(|| format!("grammar not found: '{name}'"))?,
377 )
378 } else {
379 None
380 };
381
382 let query_entries = fs::read_dir(&language_dir)?;
383 for entry in query_entries {
384 let entry = entry?;
385 let query_path = entry.path();
386 if query_path.extension() == Some("scm".as_ref()) {
387 let grammar = grammar.with_context(|| {
388 format! {
389 "language {} provides query {} but no grammar",
390 config.name,
391 query_path.display()
392 }
393 })?;
394
395 let query_source = fs::read_to_string(&query_path)?;
396 let _query = Query::new(grammar, &query_source)?;
397 }
398 }
399
400 log::info!("loaded language {}", config.name);
401 }
402
403 Ok(())
404}
405
406async fn test_themes(
407 manifest: &ExtensionManifest,
408 extension_path: &Path,
409 fs: Arc<dyn Fs>,
410) -> Result<()> {
411 for relative_theme_path in &manifest.themes {
412 let theme_path = extension_path.join(relative_theme_path);
413 let theme_family = theme::read_user_theme(&theme_path, fs.clone()).await?;
414 log::info!("loaded theme family {}", theme_family.name);
415
416 for theme in &theme_family.themes {
417 if theme
418 .style
419 .colors
420 .deprecated_scrollbar_thumb_background
421 .is_some()
422 {
423 bail!(
424 r#"Theme "{theme_name}" is using a deprecated style property: scrollbar_thumb.background. Use `scrollbar.thumb.background` instead."#,
425 theme_name = theme.name
426 )
427 }
428 }
429 }
430
431 Ok(())
432}
433
434async fn test_snippets(
435 manifest: &ExtensionManifest,
436 extension_path: &Path,
437 fs: Arc<dyn Fs>,
438) -> Result<()> {
439 for relative_snippet_path in manifest
440 .snippets
441 .as_ref()
442 .map(ExtensionSnippets::paths)
443 .into_iter()
444 .flatten()
445 {
446 let snippet_path = extension_path.join(relative_snippet_path);
447 let snippets_content = fs.load_bytes(&snippet_path).await?;
448 let snippets_file = serde_json_lenient::from_slice::<VsSnippetsFile>(&snippets_content)
449 .with_context(|| anyhow!("Failed to parse snippet file at {snippet_path:?}"))?;
450 let snippet_errors = file_to_snippets(snippets_file, &snippet_path)
451 .flat_map(Result::err)
452 .collect::<Vec<_>>();
453 let error_count = snippet_errors.len();
454
455 anyhow::ensure!(
456 error_count == 0,
457 "Could not parse {error_count} snippet{suffix} in file {snippet_path:?}:\n\n{snippet_errors}",
458 suffix = if error_count == 1 { "" } else { "s" },
459 snippet_errors = snippet_errors
460 .iter()
461 .map(ToString::to_string)
462 .collect::<Vec<_>>()
463 .join("\n")
464 );
465 }
466
467 Ok(())
468}