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