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