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