1use std::{
2 collections::HashMap,
3 env, fs,
4 path::{Path, PathBuf},
5 process::Command,
6 sync::Arc,
7};
8
9use ::fs::{copy_recursive, CopyOptions, Fs, RealFs};
10use anyhow::{anyhow, bail, Context, Result};
11use clap::Parser;
12use extension::{
13 extension_builder::{CompileExtensionOptions, ExtensionBuilder},
14 ExtensionLibraryKind, ExtensionManifest, ExtensionStore, GrammarManifestEntry,
15};
16use language::LanguageConfig;
17use serde::Deserialize;
18use theme::ThemeRegistry;
19use tree_sitter::{Language, Query, WasmStore};
20
21#[derive(Parser, Debug)]
22#[command(name = "zed-extension")]
23struct Args {
24 /// The path to the extension directory
25 #[arg(long)]
26 source_dir: PathBuf,
27 /// The output directory to place the packaged extension.
28 #[arg(long)]
29 output_dir: PathBuf,
30 /// The path to a directory where build dependencies are downloaded
31 #[arg(long)]
32 scratch_dir: PathBuf,
33}
34
35#[tokio::main]
36async fn main() -> Result<()> {
37 env_logger::init();
38
39 let args = Args::parse();
40 let fs = Arc::new(RealFs);
41 let engine = wasmtime::Engine::default();
42 let mut wasm_store = WasmStore::new(engine)?;
43
44 let extension_path = args
45 .source_dir
46 .canonicalize()
47 .context("failed to canonicalize source_dir")?;
48 let scratch_dir = args
49 .scratch_dir
50 .canonicalize()
51 .context("failed to canonicalize scratch_dir")?;
52 let output_dir = if args.output_dir.is_relative() {
53 env::current_dir()?.join(&args.output_dir)
54 } else {
55 args.output_dir
56 };
57
58 log::info!("loading extension manifest");
59 let mut manifest = ExtensionStore::load_extension_manifest(fs.clone(), &extension_path).await?;
60 populate_default_paths(&mut manifest, &extension_path)?;
61
62 log::info!("compiling extension");
63 let builder = ExtensionBuilder::new(scratch_dir);
64 builder
65 .compile_extension(
66 &extension_path,
67 &manifest,
68 CompileExtensionOptions { release: true },
69 )
70 .await
71 .context("failed to compile extension")?;
72
73 let grammars = test_grammars(&manifest, &extension_path, &mut wasm_store)?;
74 test_languages(&manifest, &extension_path, &grammars)?;
75 test_themes(&manifest, &extension_path, fs.clone()).await?;
76
77 let archive_dir = output_dir.join("archive");
78 fs::remove_dir_all(&archive_dir).ok();
79 copy_extension_resources(&manifest, &extension_path, &archive_dir, fs.clone())
80 .await
81 .context("failed to copy extension resources")?;
82
83 let tar_output = Command::new("tar")
84 .current_dir(&output_dir)
85 .args(&["-czvf", "archive.tar.gz", "-C", "archive", "."])
86 .output()
87 .context("failed to run tar")?;
88 if !tar_output.status.success() {
89 bail!(
90 "failed to create archive.tar.gz: {}",
91 String::from_utf8_lossy(&tar_output.stderr)
92 );
93 }
94
95 let manifest_json = serde_json::to_string(&rpc::ExtensionApiManifest {
96 name: manifest.name,
97 version: manifest.version.to_string(),
98 description: manifest.description,
99 authors: manifest.authors,
100 schema_version: Some(manifest.schema_version),
101 repository: manifest
102 .repository
103 .ok_or_else(|| anyhow!("missing repository in extension manifest"))?,
104 })?;
105 fs::remove_dir_all(&archive_dir)?;
106 fs::write(output_dir.join("manifest.json"), manifest_json.as_bytes())?;
107
108 Ok(())
109}
110
111fn populate_default_paths(manifest: &mut ExtensionManifest, extension_path: &Path) -> Result<()> {
112 // For legacy extensions on the v0 schema (aka, using `extension.json`), clear out any existing
113 // contents of the computed fields, since we don't care what the existing values are.
114 if manifest.schema_version == 0 {
115 manifest.languages.clear();
116 manifest.grammars.clear();
117 manifest.themes.clear();
118 }
119
120 let cargo_toml_path = extension_path.join("Cargo.toml");
121 if cargo_toml_path.exists() {
122 manifest.lib.kind = Some(ExtensionLibraryKind::Rust);
123 }
124
125 let languages_dir = extension_path.join("languages");
126 if languages_dir.exists() {
127 for entry in fs::read_dir(&languages_dir).context("failed to list languages dir")? {
128 let entry = entry?;
129 let language_dir = entry.path();
130 let config_path = language_dir.join("config.toml");
131 if config_path.exists() {
132 let relative_language_dir =
133 language_dir.strip_prefix(extension_path)?.to_path_buf();
134 if !manifest.languages.contains(&relative_language_dir) {
135 manifest.languages.push(relative_language_dir);
136 }
137 }
138 }
139 }
140
141 let themes_dir = extension_path.join("themes");
142 if themes_dir.exists() {
143 for entry in fs::read_dir(&themes_dir).context("failed to list themes dir")? {
144 let entry = entry?;
145 let theme_path = entry.path();
146 if theme_path.extension() == Some("json".as_ref()) {
147 let relative_theme_path = theme_path.strip_prefix(extension_path)?.to_path_buf();
148 if !manifest.themes.contains(&relative_theme_path) {
149 manifest.themes.push(relative_theme_path);
150 }
151 }
152 }
153 }
154
155 // For legacy extensions on the v0 schema (aka, using `extension.json`), we want to populate the grammars in
156 // the manifest using the contents of the `grammars` directory.
157 if manifest.schema_version == 0 {
158 let grammars_dir = extension_path.join("grammars");
159 if grammars_dir.exists() {
160 for entry in fs::read_dir(&grammars_dir).context("failed to list grammars dir")? {
161 let entry = entry?;
162 let grammar_path = entry.path();
163 if grammar_path.extension() == Some("toml".as_ref()) {
164 #[derive(Deserialize)]
165 struct GrammarConfigToml {
166 pub repository: String,
167 pub commit: String,
168 }
169
170 let grammar_config = fs::read_to_string(&grammar_path)?;
171 let grammar_config: GrammarConfigToml = toml::from_str(&grammar_config)?;
172
173 let grammar_name = grammar_path
174 .file_stem()
175 .and_then(|stem| stem.to_str())
176 .ok_or_else(|| anyhow!("no grammar name"))?;
177 if !manifest.grammars.contains_key(grammar_name) {
178 manifest.grammars.insert(
179 grammar_name.into(),
180 GrammarManifestEntry {
181 repository: grammar_config.repository,
182 rev: grammar_config.commit,
183 },
184 );
185 }
186 }
187 }
188 }
189 }
190
191 Ok(())
192}
193
194async fn copy_extension_resources(
195 manifest: &ExtensionManifest,
196 extension_path: &Path,
197 output_dir: &Path,
198 fs: Arc<dyn Fs>,
199) -> Result<()> {
200 fs::create_dir_all(&output_dir).context("failed to create output dir")?;
201
202 let manifest_toml = toml::to_string(&manifest).context("failed to serialize manifest")?;
203 fs::write(output_dir.join("extension.toml"), &manifest_toml)
204 .context("failed to write extension.toml")?;
205
206 if manifest.lib.kind.is_some() {
207 fs::copy(
208 extension_path.join("extension.wasm"),
209 output_dir.join("extension.wasm"),
210 )
211 .context("failed to copy extension.wasm")?;
212 }
213
214 if !manifest.grammars.is_empty() {
215 let source_grammars_dir = extension_path.join("grammars");
216 let output_grammars_dir = output_dir.join("grammars");
217 fs::create_dir_all(&output_grammars_dir)?;
218 for grammar_name in manifest.grammars.keys() {
219 let mut grammar_filename = PathBuf::from(grammar_name.as_ref());
220 grammar_filename.set_extension("wasm");
221 fs::copy(
222 &source_grammars_dir.join(&grammar_filename),
223 &output_grammars_dir.join(&grammar_filename),
224 )
225 .with_context(|| format!("failed to copy grammar '{}'", grammar_filename.display()))?;
226 }
227 }
228
229 if !manifest.themes.is_empty() {
230 let output_themes_dir = output_dir.join("themes");
231 fs::create_dir_all(&output_themes_dir)?;
232 for theme_path in &manifest.themes {
233 fs::copy(
234 extension_path.join(theme_path),
235 output_themes_dir.join(
236 theme_path
237 .file_name()
238 .ok_or_else(|| anyhow!("invalid theme path"))?,
239 ),
240 )
241 .with_context(|| format!("failed to copy theme '{}'", theme_path.display()))?;
242 }
243 }
244
245 if !manifest.languages.is_empty() {
246 let output_languages_dir = output_dir.join("languages");
247 fs::create_dir_all(&output_languages_dir)?;
248 for language_path in &manifest.languages {
249 copy_recursive(
250 fs.as_ref(),
251 &extension_path.join(language_path),
252 &output_languages_dir.join(
253 language_path
254 .file_name()
255 .ok_or_else(|| anyhow!("invalid language path"))?,
256 ),
257 CopyOptions {
258 overwrite: true,
259 ignore_if_exists: false,
260 },
261 )
262 .await
263 .with_context(|| {
264 format!("failed to copy language dir '{}'", language_path.display())
265 })?;
266 }
267 }
268
269 Ok(())
270}
271
272fn test_grammars(
273 manifest: &ExtensionManifest,
274 extension_path: &Path,
275 wasm_store: &mut WasmStore,
276) -> Result<HashMap<String, Language>> {
277 let mut grammars = HashMap::default();
278 let grammars_dir = extension_path.join("grammars");
279
280 for grammar_name in manifest.grammars.keys() {
281 let mut grammar_path = grammars_dir.join(grammar_name.as_ref());
282 grammar_path.set_extension("wasm");
283
284 let wasm = fs::read(&grammar_path)?;
285 let language = wasm_store.load_language(grammar_name, &wasm)?;
286 log::info!("loaded grammar {grammar_name}");
287 grammars.insert(grammar_name.to_string(), language);
288 }
289
290 Ok(grammars)
291}
292
293fn test_languages(
294 manifest: &ExtensionManifest,
295 extension_path: &Path,
296 grammars: &HashMap<String, Language>,
297) -> Result<()> {
298 for relative_language_dir in &manifest.languages {
299 let language_dir = extension_path.join(relative_language_dir);
300 let config_path = language_dir.join("config.toml");
301 let config_content = fs::read_to_string(&config_path)?;
302 let config: LanguageConfig = toml::from_str(&config_content)?;
303 let grammar = if let Some(name) = &config.grammar {
304 Some(
305 grammars
306 .get(name.as_ref())
307 .ok_or_else(|| anyhow!("grammar not found: '{name}'"))?,
308 )
309 } else {
310 None
311 };
312
313 let query_entries = fs::read_dir(&language_dir)?;
314 for entry in query_entries {
315 let entry = entry?;
316 let query_path = entry.path();
317 if query_path.extension() == Some("scm".as_ref()) {
318 let grammar = grammar.ok_or_else(|| {
319 anyhow!(
320 "language {} provides query {} but no grammar",
321 config.name,
322 query_path.display()
323 )
324 })?;
325
326 let query_source = fs::read_to_string(&query_path)?;
327 let _query = Query::new(grammar, &query_source)?;
328 }
329 }
330
331 log::info!("loaded language {}", config.name);
332 }
333
334 Ok(())
335}
336
337async fn test_themes(
338 manifest: &ExtensionManifest,
339 extension_path: &Path,
340 fs: Arc<dyn Fs>,
341) -> Result<()> {
342 for relative_theme_path in &manifest.themes {
343 let theme_path = extension_path.join(relative_theme_path);
344 let theme_family = ThemeRegistry::read_user_theme(&theme_path, fs.clone()).await?;
345 log::info!("loaded theme family {}", theme_family.name);
346 }
347
348 Ok(())
349}