1use anyhow::{Context as _, Result, bail};
2use collections::{BTreeMap, HashMap};
3use fs::Fs;
4use language::LanguageName;
5use lsp::LanguageServerName;
6use semantic_version::SemanticVersion;
7use serde::{Deserialize, Serialize};
8use std::{
9 ffi::OsStr,
10 fmt,
11 path::{Path, PathBuf},
12 sync::Arc,
13};
14
15/// This is the old version of the extension manifest, from when it was `extension.json`.
16#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
17pub struct OldExtensionManifest {
18 pub name: String,
19 pub version: Arc<str>,
20
21 #[serde(default)]
22 pub description: Option<String>,
23 #[serde(default)]
24 pub repository: Option<String>,
25 #[serde(default)]
26 pub authors: Vec<String>,
27
28 #[serde(default)]
29 pub themes: BTreeMap<Arc<str>, PathBuf>,
30 #[serde(default)]
31 pub languages: BTreeMap<Arc<str>, PathBuf>,
32 #[serde(default)]
33 pub grammars: BTreeMap<Arc<str>, PathBuf>,
34}
35
36/// The schema version of the [`ExtensionManifest`].
37#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
38pub struct SchemaVersion(pub i32);
39
40impl fmt::Display for SchemaVersion {
41 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42 write!(f, "{}", self.0)
43 }
44}
45
46impl SchemaVersion {
47 pub const ZERO: Self = Self(0);
48
49 pub fn is_v0(&self) -> bool {
50 self == &Self::ZERO
51 }
52}
53
54#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
55pub struct ExtensionManifest {
56 pub id: Arc<str>,
57 pub name: String,
58 pub version: Arc<str>,
59 pub schema_version: SchemaVersion,
60
61 #[serde(default)]
62 pub description: Option<String>,
63 #[serde(default)]
64 pub repository: Option<String>,
65 #[serde(default)]
66 pub authors: Vec<String>,
67 #[serde(default)]
68 pub lib: LibManifestEntry,
69
70 #[serde(default)]
71 pub themes: Vec<PathBuf>,
72 #[serde(default)]
73 pub icon_themes: Vec<PathBuf>,
74 #[serde(default)]
75 pub languages: Vec<PathBuf>,
76 #[serde(default)]
77 pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
78 #[serde(default)]
79 pub language_servers: BTreeMap<LanguageServerName, LanguageServerManifestEntry>,
80 #[serde(default)]
81 pub context_servers: BTreeMap<Arc<str>, ContextServerManifestEntry>,
82 #[serde(default)]
83 pub slash_commands: BTreeMap<Arc<str>, SlashCommandManifestEntry>,
84 #[serde(default)]
85 pub indexed_docs_providers: BTreeMap<Arc<str>, IndexedDocsProviderEntry>,
86 #[serde(default)]
87 pub snippets: Option<PathBuf>,
88 #[serde(default)]
89 pub capabilities: Vec<ExtensionCapability>,
90 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
91 pub debug_adapters: BTreeMap<Arc<str>, DebugAdapterManifestEntry>,
92 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
93 pub debug_locators: BTreeMap<Arc<str>, DebugLocatorManifestEntry>,
94}
95
96impl ExtensionManifest {
97 pub fn allow_exec(
98 &self,
99 desired_command: &str,
100 desired_args: &[impl AsRef<str> + std::fmt::Debug],
101 ) -> Result<()> {
102 let is_allowed = self.capabilities.iter().any(|capability| match capability {
103 ExtensionCapability::ProcessExec { command, args } if command == desired_command => {
104 for (ix, arg) in args.iter().enumerate() {
105 if arg == "**" {
106 return true;
107 }
108
109 if ix >= desired_args.len() {
110 return false;
111 }
112
113 if arg != "*" && arg != desired_args[ix].as_ref() {
114 return false;
115 }
116 }
117 if args.len() < desired_args.len() {
118 return false;
119 }
120 true
121 }
122 _ => false,
123 });
124
125 if !is_allowed {
126 bail!(
127 "capability for process:exec {desired_command} {desired_args:?} was not listed in the extension manifest",
128 );
129 }
130
131 Ok(())
132 }
133
134 pub fn allow_remote_load(&self) -> bool {
135 !self.language_servers.is_empty()
136 || !self.debug_adapters.is_empty()
137 || !self.debug_locators.is_empty()
138 }
139}
140
141pub fn build_debug_adapter_schema_path(
142 adapter_name: &Arc<str>,
143 meta: &DebugAdapterManifestEntry,
144) -> PathBuf {
145 meta.schema_path.clone().unwrap_or_else(|| {
146 Path::new("debug_adapter_schemas")
147 .join(Path::new(adapter_name.as_ref()).with_extension("json"))
148 })
149}
150
151/// A capability for an extension.
152#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
153#[serde(tag = "kind")]
154pub enum ExtensionCapability {
155 #[serde(rename = "process:exec")]
156 ProcessExec {
157 /// The command to execute.
158 command: String,
159 /// The arguments to pass to the command. Use `*` for a single wildcard argument.
160 /// If the last element is `**`, then any trailing arguments are allowed.
161 args: Vec<String>,
162 },
163}
164
165#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
166pub struct LibManifestEntry {
167 pub kind: Option<ExtensionLibraryKind>,
168 pub version: Option<SemanticVersion>,
169}
170
171#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
172pub enum ExtensionLibraryKind {
173 Rust,
174}
175
176#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
177pub struct GrammarManifestEntry {
178 pub repository: String,
179 #[serde(alias = "commit")]
180 pub rev: String,
181 #[serde(default)]
182 pub path: Option<String>,
183}
184
185#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
186pub struct LanguageServerManifestEntry {
187 /// Deprecated in favor of `languages`.
188 #[serde(default)]
189 language: Option<LanguageName>,
190 /// The list of languages this language server should work with.
191 #[serde(default)]
192 languages: Vec<LanguageName>,
193 #[serde(default)]
194 pub language_ids: HashMap<String, String>,
195 #[serde(default)]
196 pub code_action_kinds: Option<Vec<lsp::CodeActionKind>>,
197}
198
199impl LanguageServerManifestEntry {
200 /// Returns the list of languages for the language server.
201 ///
202 /// Prefer this over accessing the `language` or `languages` fields directly,
203 /// as we currently support both.
204 ///
205 /// We can replace this with just field access for the `languages` field once
206 /// we have removed `language`.
207 pub fn languages(&self) -> impl IntoIterator<Item = LanguageName> + '_ {
208 let language = if self.languages.is_empty() {
209 self.language.clone()
210 } else {
211 None
212 };
213 self.languages.iter().cloned().chain(language)
214 }
215}
216
217#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
218pub struct ContextServerManifestEntry {}
219
220#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
221pub struct SlashCommandManifestEntry {
222 pub description: String,
223 pub requires_argument: bool,
224}
225
226#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
227pub struct IndexedDocsProviderEntry {}
228
229#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
230pub struct DebugAdapterManifestEntry {
231 pub schema_path: Option<PathBuf>,
232}
233
234#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
235pub struct DebugLocatorManifestEntry {}
236
237impl ExtensionManifest {
238 pub async fn load(fs: Arc<dyn Fs>, extension_dir: &Path) -> Result<Self> {
239 let extension_name = extension_dir
240 .file_name()
241 .and_then(OsStr::to_str)
242 .context("invalid extension name")?;
243
244 let mut extension_manifest_path = extension_dir.join("extension.json");
245 if fs.is_file(&extension_manifest_path).await {
246 let manifest_content = fs
247 .load(&extension_manifest_path)
248 .await
249 .with_context(|| format!("failed to load {extension_name} extension.json"))?;
250 let manifest_json = serde_json::from_str::<OldExtensionManifest>(&manifest_content)
251 .with_context(|| {
252 format!("invalid extension.json for extension {extension_name}")
253 })?;
254
255 Ok(manifest_from_old_manifest(manifest_json, extension_name))
256 } else {
257 extension_manifest_path.set_extension("toml");
258 let manifest_content = fs
259 .load(&extension_manifest_path)
260 .await
261 .with_context(|| format!("failed to load {extension_name} extension.toml"))?;
262 toml::from_str(&manifest_content)
263 .with_context(|| format!("invalid extension.toml for extension {extension_name}"))
264 }
265 }
266}
267
268fn manifest_from_old_manifest(
269 manifest_json: OldExtensionManifest,
270 extension_id: &str,
271) -> ExtensionManifest {
272 ExtensionManifest {
273 id: extension_id.into(),
274 name: manifest_json.name,
275 version: manifest_json.version,
276 description: manifest_json.description,
277 repository: manifest_json.repository,
278 authors: manifest_json.authors,
279 schema_version: SchemaVersion::ZERO,
280 lib: Default::default(),
281 themes: {
282 let mut themes = manifest_json.themes.into_values().collect::<Vec<_>>();
283 themes.sort();
284 themes.dedup();
285 themes
286 },
287 icon_themes: Vec::new(),
288 languages: {
289 let mut languages = manifest_json.languages.into_values().collect::<Vec<_>>();
290 languages.sort();
291 languages.dedup();
292 languages
293 },
294 grammars: manifest_json
295 .grammars
296 .into_keys()
297 .map(|grammar_name| (grammar_name, Default::default()))
298 .collect(),
299 language_servers: Default::default(),
300 context_servers: BTreeMap::default(),
301 slash_commands: BTreeMap::default(),
302 indexed_docs_providers: BTreeMap::default(),
303 snippets: None,
304 capabilities: Vec::new(),
305 debug_adapters: Default::default(),
306 debug_locators: Default::default(),
307 }
308}
309
310#[cfg(test)]
311mod tests {
312 use super::*;
313
314 fn extension_manifest() -> ExtensionManifest {
315 ExtensionManifest {
316 id: "test".into(),
317 name: "Test".to_string(),
318 version: "1.0.0".into(),
319 schema_version: SchemaVersion::ZERO,
320 description: None,
321 repository: None,
322 authors: vec![],
323 lib: Default::default(),
324 themes: vec![],
325 icon_themes: vec![],
326 languages: vec![],
327 grammars: BTreeMap::default(),
328 language_servers: BTreeMap::default(),
329 context_servers: BTreeMap::default(),
330 slash_commands: BTreeMap::default(),
331 indexed_docs_providers: BTreeMap::default(),
332 snippets: None,
333 capabilities: vec![],
334 debug_adapters: Default::default(),
335 debug_locators: Default::default(),
336 }
337 }
338
339 #[test]
340 fn test_build_adapter_schema_path_with_schema_path() {
341 let adapter_name = Arc::from("my_adapter");
342 let entry = DebugAdapterManifestEntry {
343 schema_path: Some(PathBuf::from("foo/bar")),
344 };
345
346 let path = build_debug_adapter_schema_path(&adapter_name, &entry);
347 assert_eq!(path, PathBuf::from("foo/bar"));
348 }
349
350 #[test]
351 fn test_build_adapter_schema_path_without_schema_path() {
352 let adapter_name = Arc::from("my_adapter");
353 let entry = DebugAdapterManifestEntry { schema_path: None };
354
355 let path = build_debug_adapter_schema_path(&adapter_name, &entry);
356 assert_eq!(
357 path,
358 PathBuf::from("debug_adapter_schemas").join("my_adapter.json")
359 );
360 }
361
362 #[test]
363 fn test_allow_exact_match() {
364 let manifest = ExtensionManifest {
365 capabilities: vec![ExtensionCapability::ProcessExec {
366 command: "ls".to_string(),
367 args: vec!["-la".to_string()],
368 }],
369 ..extension_manifest()
370 };
371
372 assert!(manifest.allow_exec("ls", &["-la"]).is_ok());
373 assert!(manifest.allow_exec("ls", &["-l"]).is_err());
374 assert!(manifest.allow_exec("pwd", &[] as &[&str]).is_err());
375 }
376
377 #[test]
378 fn test_allow_wildcard_arg() {
379 let manifest = ExtensionManifest {
380 capabilities: vec![ExtensionCapability::ProcessExec {
381 command: "git".to_string(),
382 args: vec!["*".to_string()],
383 }],
384 ..extension_manifest()
385 };
386
387 assert!(manifest.allow_exec("git", &["status"]).is_ok());
388 assert!(manifest.allow_exec("git", &["commit"]).is_ok());
389 assert!(manifest.allow_exec("git", &["status", "-s"]).is_err()); // too many args
390 assert!(manifest.allow_exec("npm", &["install"]).is_err()); // wrong command
391 }
392
393 #[test]
394 fn test_allow_double_wildcard() {
395 let manifest = ExtensionManifest {
396 capabilities: vec![ExtensionCapability::ProcessExec {
397 command: "cargo".to_string(),
398 args: vec!["test".to_string(), "**".to_string()],
399 }],
400 ..extension_manifest()
401 };
402
403 assert!(manifest.allow_exec("cargo", &["test"]).is_ok());
404 assert!(manifest.allow_exec("cargo", &["test", "--all"]).is_ok());
405 assert!(
406 manifest
407 .allow_exec("cargo", &["test", "--all", "--no-fail-fast"])
408 .is_ok()
409 );
410 assert!(manifest.allow_exec("cargo", &["build"]).is_err()); // wrong first arg
411 }
412
413 #[test]
414 fn test_allow_mixed_wildcards() {
415 let manifest = ExtensionManifest {
416 capabilities: vec![ExtensionCapability::ProcessExec {
417 command: "docker".to_string(),
418 args: vec!["run".to_string(), "*".to_string(), "**".to_string()],
419 }],
420 ..extension_manifest()
421 };
422
423 assert!(manifest.allow_exec("docker", &["run", "nginx"]).is_ok());
424 assert!(manifest.allow_exec("docker", &["run"]).is_err());
425 assert!(
426 manifest
427 .allow_exec("docker", &["run", "ubuntu", "bash"])
428 .is_ok()
429 );
430 assert!(
431 manifest
432 .allow_exec("docker", &["run", "alpine", "sh", "-c", "echo hello"])
433 .is_ok()
434 );
435 assert!(manifest.allow_exec("docker", &["ps"]).is_err()); // wrong first arg
436 }
437}