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