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