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