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 ::http_client::HttpClientWithProxy;
11use anyhow::{anyhow, bail, Context, Result};
12use clap::Parser;
13use extension::{
14 extension_builder::{CompileExtensionOptions, ExtensionBuilder},
15 ExtensionManifest,
16};
17use language::LanguageConfig;
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::default());
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 = ExtensionManifest::load(fs.clone(), &extension_path).await?;
60
61 log::info!("compiling extension");
62
63 let http_client = Arc::new(HttpClientWithProxy::new(None));
64 let builder = ExtensionBuilder::new(http_client, scratch_dir);
65 builder
66 .compile_extension(
67 &extension_path,
68 &mut manifest,
69 CompileExtensionOptions { release: true },
70 )
71 .await
72 .context("failed to compile extension")?;
73
74 let grammars = test_grammars(&manifest, &extension_path, &mut wasm_store)?;
75 test_languages(&manifest, &extension_path, &grammars)?;
76 test_themes(&manifest, &extension_path, fs.clone()).await?;
77
78 let archive_dir = output_dir.join("archive");
79 fs::remove_dir_all(&archive_dir).ok();
80 copy_extension_resources(&manifest, &extension_path, &archive_dir, fs.clone())
81 .await
82 .context("failed to copy extension resources")?;
83
84 let tar_output = Command::new("tar")
85 .current_dir(&output_dir)
86 .args(&["-czvf", "archive.tar.gz", "-C", "archive", "."])
87 .output()
88 .context("failed to run tar")?;
89 if !tar_output.status.success() {
90 bail!(
91 "failed to create archive.tar.gz: {}",
92 String::from_utf8_lossy(&tar_output.stderr)
93 );
94 }
95
96 let manifest_json = serde_json::to_string(&rpc::ExtensionApiManifest {
97 name: manifest.name,
98 version: manifest.version,
99 description: manifest.description,
100 authors: manifest.authors,
101 schema_version: Some(manifest.schema_version.0),
102 repository: manifest
103 .repository
104 .ok_or_else(|| anyhow!("missing repository in extension manifest"))?,
105 wasm_api_version: manifest.lib.version.map(|version| version.to_string()),
106 })?;
107 fs::remove_dir_all(&archive_dir)?;
108 fs::write(output_dir.join("manifest.json"), manifest_json.as_bytes())?;
109
110 Ok(())
111}
112
113async fn copy_extension_resources(
114 manifest: &ExtensionManifest,
115 extension_path: &Path,
116 output_dir: &Path,
117 fs: Arc<dyn Fs>,
118) -> Result<()> {
119 fs::create_dir_all(&output_dir).context("failed to create output dir")?;
120
121 let manifest_toml = toml::to_string(&manifest).context("failed to serialize manifest")?;
122 fs::write(output_dir.join("extension.toml"), &manifest_toml)
123 .context("failed to write extension.toml")?;
124
125 if manifest.lib.kind.is_some() {
126 fs::copy(
127 extension_path.join("extension.wasm"),
128 output_dir.join("extension.wasm"),
129 )
130 .context("failed to copy extension.wasm")?;
131 }
132
133 if !manifest.grammars.is_empty() {
134 let source_grammars_dir = extension_path.join("grammars");
135 let output_grammars_dir = output_dir.join("grammars");
136 fs::create_dir_all(&output_grammars_dir)?;
137 for grammar_name in manifest.grammars.keys() {
138 let mut grammar_filename = PathBuf::from(grammar_name.as_ref());
139 grammar_filename.set_extension("wasm");
140 fs::copy(
141 &source_grammars_dir.join(&grammar_filename),
142 &output_grammars_dir.join(&grammar_filename),
143 )
144 .with_context(|| format!("failed to copy grammar '{}'", grammar_filename.display()))?;
145 }
146 }
147
148 if !manifest.themes.is_empty() {
149 let output_themes_dir = output_dir.join("themes");
150 fs::create_dir_all(&output_themes_dir)?;
151 for theme_path in &manifest.themes {
152 fs::copy(
153 extension_path.join(theme_path),
154 output_themes_dir.join(
155 theme_path
156 .file_name()
157 .ok_or_else(|| anyhow!("invalid theme path"))?,
158 ),
159 )
160 .with_context(|| format!("failed to copy theme '{}'", theme_path.display()))?;
161 }
162 }
163
164 if !manifest.languages.is_empty() {
165 let output_languages_dir = output_dir.join("languages");
166 fs::create_dir_all(&output_languages_dir)?;
167 for language_path in &manifest.languages {
168 copy_recursive(
169 fs.as_ref(),
170 &extension_path.join(language_path),
171 &output_languages_dir.join(
172 language_path
173 .file_name()
174 .ok_or_else(|| anyhow!("invalid language path"))?,
175 ),
176 CopyOptions {
177 overwrite: true,
178 ignore_if_exists: false,
179 },
180 )
181 .await
182 .with_context(|| {
183 format!("failed to copy language dir '{}'", language_path.display())
184 })?;
185 }
186 }
187
188 Ok(())
189}
190
191fn test_grammars(
192 manifest: &ExtensionManifest,
193 extension_path: &Path,
194 wasm_store: &mut WasmStore,
195) -> Result<HashMap<String, Language>> {
196 let mut grammars = HashMap::default();
197 let grammars_dir = extension_path.join("grammars");
198
199 for grammar_name in manifest.grammars.keys() {
200 let mut grammar_path = grammars_dir.join(grammar_name.as_ref());
201 grammar_path.set_extension("wasm");
202
203 let wasm = fs::read(&grammar_path)?;
204 let language = wasm_store.load_language(grammar_name, &wasm)?;
205 log::info!("loaded grammar {grammar_name}");
206 grammars.insert(grammar_name.to_string(), language);
207 }
208
209 Ok(grammars)
210}
211
212fn test_languages(
213 manifest: &ExtensionManifest,
214 extension_path: &Path,
215 grammars: &HashMap<String, Language>,
216) -> Result<()> {
217 for relative_language_dir in &manifest.languages {
218 let language_dir = extension_path.join(relative_language_dir);
219 let config_path = language_dir.join("config.toml");
220 let config_content = fs::read_to_string(&config_path)?;
221 let config: LanguageConfig = toml::from_str(&config_content)?;
222 let grammar = if let Some(name) = &config.grammar {
223 Some(
224 grammars
225 .get(name.as_ref())
226 .ok_or_else(|| anyhow!("grammar not found: '{name}'"))?,
227 )
228 } else {
229 None
230 };
231
232 let query_entries = fs::read_dir(&language_dir)?;
233 for entry in query_entries {
234 let entry = entry?;
235 let query_path = entry.path();
236 if query_path.extension() == Some("scm".as_ref()) {
237 let grammar = grammar.ok_or_else(|| {
238 anyhow!(
239 "language {} provides query {} but no grammar",
240 config.name,
241 query_path.display()
242 )
243 })?;
244
245 let query_source = fs::read_to_string(&query_path)?;
246 let _query = Query::new(grammar, &query_source)?;
247 }
248 }
249
250 log::info!("loaded language {}", config.name);
251 }
252
253 Ok(())
254}
255
256async fn test_themes(
257 manifest: &ExtensionManifest,
258 extension_path: &Path,
259 fs: Arc<dyn Fs>,
260) -> Result<()> {
261 for relative_theme_path in &manifest.themes {
262 let theme_path = extension_path.join(relative_theme_path);
263 let theme_family = ThemeRegistry::read_user_theme(&theme_path, fs.clone()).await?;
264 log::info!("loaded theme family {}", theme_family.name);
265 }
266
267 Ok(())
268}