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 let cargo_toml_path = extension_path.join("Cargo.toml");
113 if cargo_toml_path.exists() {
114 manifest.lib.kind = Some(ExtensionLibraryKind::Rust);
115 }
116
117 let languages_dir = extension_path.join("languages");
118 if languages_dir.exists() {
119 for entry in fs::read_dir(&languages_dir).context("failed to list languages dir")? {
120 let entry = entry?;
121 let language_dir = entry.path();
122 let config_path = language_dir.join("config.toml");
123 if config_path.exists() {
124 let relative_language_dir =
125 language_dir.strip_prefix(extension_path)?.to_path_buf();
126 if !manifest.languages.contains(&relative_language_dir) {
127 manifest.languages.push(relative_language_dir);
128 }
129 }
130 }
131 }
132
133 let themes_dir = extension_path.join("themes");
134 if themes_dir.exists() {
135 for entry in fs::read_dir(&themes_dir).context("failed to list themes dir")? {
136 let entry = entry?;
137 let theme_path = entry.path();
138 if theme_path.extension() == Some("json".as_ref()) {
139 let relative_theme_path = theme_path.strip_prefix(extension_path)?.to_path_buf();
140 if !manifest.themes.contains(&relative_theme_path) {
141 manifest.themes.push(relative_theme_path);
142 }
143 }
144 }
145 }
146
147 // For legacy extensions on the v0 schema (aka, using `extension.json`), we want to populate the grammars in
148 // the manifest using the contents of the `grammars` directory.
149 if manifest.schema_version == 0 {
150 let grammars_dir = extension_path.join("grammars");
151 if grammars_dir.exists() {
152 for entry in fs::read_dir(&grammars_dir).context("failed to list grammars dir")? {
153 let entry = entry?;
154 let grammar_path = entry.path();
155 if grammar_path.extension() == Some("toml".as_ref()) {
156 #[derive(Deserialize)]
157 struct GrammarConfigToml {
158 pub repository: String,
159 pub commit: String,
160 }
161
162 let grammar_config = fs::read_to_string(&grammar_path)?;
163 let grammar_config: GrammarConfigToml = toml::from_str(&grammar_config)?;
164
165 let grammar_name = grammar_path
166 .file_stem()
167 .and_then(|stem| stem.to_str())
168 .ok_or_else(|| anyhow!("no grammar name"))?;
169 if !manifest.grammars.contains_key(grammar_name) {
170 manifest.grammars.insert(
171 grammar_name.into(),
172 GrammarManifestEntry {
173 repository: grammar_config.repository,
174 rev: grammar_config.commit,
175 },
176 );
177 }
178 }
179 }
180 }
181 }
182
183 Ok(())
184}
185
186async fn copy_extension_resources(
187 manifest: &ExtensionManifest,
188 extension_path: &Path,
189 output_dir: &Path,
190 fs: Arc<dyn Fs>,
191) -> Result<()> {
192 fs::create_dir_all(&output_dir).context("failed to create output dir")?;
193
194 let manifest_toml = toml::to_string(&manifest).context("failed to serialize manifest")?;
195 fs::write(output_dir.join("extension.toml"), &manifest_toml)
196 .context("failed to write extension.toml")?;
197
198 if manifest.lib.kind.is_some() {
199 fs::copy(
200 extension_path.join("extension.wasm"),
201 output_dir.join("extension.wasm"),
202 )
203 .context("failed to copy extension.wasm")?;
204 }
205
206 if !manifest.grammars.is_empty() {
207 let source_grammars_dir = extension_path.join("grammars");
208 let output_grammars_dir = output_dir.join("grammars");
209 fs::create_dir_all(&output_grammars_dir)?;
210 for grammar_name in manifest.grammars.keys() {
211 let mut grammar_filename = PathBuf::from(grammar_name.as_ref());
212 grammar_filename.set_extension("wasm");
213 fs::copy(
214 &source_grammars_dir.join(&grammar_filename),
215 &output_grammars_dir.join(&grammar_filename),
216 )
217 .with_context(|| format!("failed to copy grammar '{}'", grammar_filename.display()))?;
218 }
219 }
220
221 if !manifest.themes.is_empty() {
222 let output_themes_dir = output_dir.join("themes");
223 fs::create_dir_all(&output_themes_dir)?;
224 for theme_path in &manifest.themes {
225 fs::copy(
226 extension_path.join(theme_path),
227 output_themes_dir.join(
228 theme_path
229 .file_name()
230 .ok_or_else(|| anyhow!("invalid theme path"))?,
231 ),
232 )
233 .with_context(|| format!("failed to copy theme '{}'", theme_path.display()))?;
234 }
235 }
236
237 if !manifest.languages.is_empty() {
238 let output_languages_dir = output_dir.join("languages");
239 fs::create_dir_all(&output_languages_dir)?;
240 for language_path in &manifest.languages {
241 copy_recursive(
242 fs.as_ref(),
243 &extension_path.join(language_path),
244 &output_languages_dir.join(
245 language_path
246 .file_name()
247 .ok_or_else(|| anyhow!("invalid language path"))?,
248 ),
249 CopyOptions {
250 overwrite: true,
251 ignore_if_exists: false,
252 },
253 )
254 .await
255 .with_context(|| {
256 format!("failed to copy language dir '{}'", language_path.display())
257 })?;
258 }
259 }
260
261 Ok(())
262}
263
264fn test_grammars(
265 manifest: &ExtensionManifest,
266 extension_path: &Path,
267 wasm_store: &mut WasmStore,
268) -> Result<HashMap<String, Language>> {
269 let mut grammars = HashMap::default();
270 let grammars_dir = extension_path.join("grammars");
271
272 for grammar_name in manifest.grammars.keys() {
273 let mut grammar_path = grammars_dir.join(grammar_name.as_ref());
274 grammar_path.set_extension("wasm");
275
276 let wasm = fs::read(&grammar_path)?;
277 let language = wasm_store.load_language(grammar_name, &wasm)?;
278 log::info!("loaded grammar {grammar_name}");
279 grammars.insert(grammar_name.to_string(), language);
280 }
281
282 Ok(grammars)
283}
284
285fn test_languages(
286 manifest: &ExtensionManifest,
287 extension_path: &Path,
288 grammars: &HashMap<String, Language>,
289) -> Result<()> {
290 for relative_language_dir in &manifest.languages {
291 let language_dir = extension_path.join(relative_language_dir);
292 let config_path = language_dir.join("config.toml");
293 let config_content = fs::read_to_string(&config_path)?;
294 let config: LanguageConfig = toml::from_str(&config_content)?;
295 let grammar = if let Some(name) = &config.grammar {
296 Some(
297 grammars
298 .get(name.as_ref())
299 .ok_or_else(|| anyhow!("grammar not found: '{name}'"))?,
300 )
301 } else {
302 None
303 };
304
305 let query_entries = fs::read_dir(&language_dir)?;
306 for entry in query_entries {
307 let entry = entry?;
308 let query_path = entry.path();
309 if query_path.extension() == Some("scm".as_ref()) {
310 let grammar = grammar.ok_or_else(|| {
311 anyhow!(
312 "language {} provides query {} but no grammar",
313 config.name,
314 query_path.display()
315 )
316 })?;
317
318 let query_source = fs::read_to_string(&query_path)?;
319 let _query = Query::new(grammar, &query_source)?;
320 }
321 }
322
323 log::info!("loaded language {}", config.name);
324 }
325
326 Ok(())
327}
328
329async fn test_themes(
330 manifest: &ExtensionManifest,
331 extension_path: &Path,
332 fs: Arc<dyn Fs>,
333) -> Result<()> {
334 for relative_theme_path in &manifest.themes {
335 let theme_path = extension_path.join(relative_theme_path);
336 let theme_family = ThemeRegistry::read_user_theme(&theme_path, fs.clone()).await?;
337 log::info!("loaded theme family {}", theme_family.name);
338 }
339
340 Ok(())
341}