Get Wasi working

plugins/json_language/src/lib.rs

@@ -1,7 +1,17 @@
 use plugin::prelude::*;
+use std::fs;
+
+#[import]
+fn command(string: String) -> Option<String>;
 
 #[bind]
 pub fn name(_: ()) -> &'static str {
+    println!("huh, let me see...");
+    Command::new("sh")
+        .arg("-c")
+        .arg("echo hello")
+        .output()
+        .expect("failed to execute process");
     "vscode-json-languageserver"
 }
 
@@ -9,3 +19,92 @@ pub fn name(_: ()) -> &'static str {
 pub fn server_args(_: ()) -> Vec<String> {
     vec!["--stdio".into()]
 }
+
+#[bind]
+fn fetch_latest_server_version() -> Option<String> {
+    #[derive(Deserialize)]
+    struct NpmInfo {
+        versions: Vec<String>,
+    }
+
+    let output = command("npm info vscode-json-languageserver --json")?;
+    if !output.status.success() {
+        return None;
+    }
+
+    let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
+    info.versions.pop()
+}
+
+#[bind]
+pub fn fetch_server_binary(version: String) -> Option<PathBuf> {
+    let version_dir = container_dir.join(version.as_str());
+    fs::create_dir_all(&version_dir)
+        .await
+        .context("failed to create version directory")?;
+    let binary_path = version_dir.join(Self::BIN_PATH);
+
+    if fs::metadata(&binary_path).await.is_err() {
+        let output = smol::process::Command::new("npm")
+            .current_dir(&version_dir)
+            .arg("install")
+            .arg(format!("vscode-json-languageserver@{}", version))
+            .output()
+            .await
+            .context("failed to run npm install")?;
+        if !output.status.success() {
+            Err(anyhow!("failed to install vscode-json-languageserver"))?;
+        }
+
+        if let Some(mut entries) = fs::read_dir(&container_dir).await.log_err() {
+            while let Some(entry) = entries.next().await {
+                if let Some(entry) = entry.log_err() {
+                    let entry_path = entry.path();
+                    if entry_path.as_path() != version_dir {
+                        fs::remove_dir_all(&entry_path).await.log_err();
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(binary_path)
+}
+
+#[bind]
+pub fn cached_server_binary(container_dir: PathBuf) -> Option<PathBuf> {
+    let mut last_version_dir = None;
+    let mut entries = fs::read_dir(&container_dir).await?;
+    while let Some(entry) = entries.next().await {
+        let entry = entry?;
+        if entry.file_type().await?.is_dir() {
+            last_version_dir = Some(entry.path());
+        }
+    }
+    let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
+    let bin_path = last_version_dir.join(Self::BIN_PATH);
+    if bin_path.exists() {
+        Ok(bin_path)
+    } else {
+        Err(anyhow!(
+            "missing executable in directory {:?}",
+            last_version_dir
+        ))
+    }
+}
+
+#[bind]
+pub fn initialization_options(_: ()) -> Option<serde_json::Value> {
+    Some(json!({
+        "provideFormatter": true
+    }))
+}
+
+#[bind]
+fn id_for_language(name: String) -> Option<String> {
+    if name == "JSON" {
+        Some("jsonc".into())
+    } else {
+        None
+    }
+}