fix: harden extensions module with safety and robustness improvements

- Replace per-call Regex::new().unwrap() with once_cell::sync::Lazy statics
  in types.rs for NAME_RE and VERSION_RE patterns
- Replace Mutex::lock().expect() with unwrap_or_else(|e| e.into_inner())
  in wasm/host.rs for all global registry locks (consistent with existing pattern)
- Fix unwrap_or(Ok(...)) to unwrap_or_else(|_| ...) in wasm/mod.rs
- Add manifest validation on extension load in state.rs
- Add zip bomb protection with entry count and total size limits in utils.rs
- Skip symlinks in copy_dir_recursive to prevent symlink attacks
- Add path traversal prevention (reject '..' components) in validate_workspace_path
- Add URI validation in host_get_document_text_by_uri
- Implement graceful shutdown with 5s timeout for Node.js extension host process

Author: echobt

src-tauri/src/extensions/node_host/process.rs

@@ -122,11 +122,29 @@ impl NodeHostProcess {
 
     pub async fn stop(&self) -> Result<(), String> {
         let mut child = self.child.lock().await;
-        child
-            .kill()
-            .await
-            .map_err(|e| format!("Failed to kill extension host: {}", e))?;
-        info!("Node.js extension host stopped");
+
+        // Try graceful shutdown first by closing stdin
+        drop(self.stdin.lock().await);
+
+        // Wait up to 5 seconds for the process to exit gracefully
+        let graceful = tokio::time::timeout(
+            std::time::Duration::from_secs(5),
+            child.wait(),
+        )
+        .await;
+
+        match graceful {
+            Ok(Ok(_)) => {
+                info!("Node.js extension host stopped gracefully");
+            }
+            _ => {
+                warn!("Extension host did not exit gracefully, forcing kill");
+                child
+                    .kill()
+                    .await
+                    .map_err(|e| format!("Failed to kill extension host: {}", e))?;
+            }
+        }
         Ok(())
     }
 

src-tauri/src/extensions/state.rs

@@ -10,7 +10,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tracing::{info, warn};
 
-use super::types::{Extension, ExtensionManifest, ExtensionSource};
+use super::types::{validate_manifest, Extension, ExtensionManifest, ExtensionSource};
 use super::utils::{copy_dir_recursive, extensions_directory_path};
 #[cfg(feature = "wasm-extensions")]
 use super::wasm::WasmRuntime;
@@ -102,6 +102,15 @@ impl ExtensionsManager {
         let manifest: ExtensionManifest = serde_json::from_str(&manifest_content)
             .map_err(|e| format!("Failed to parse extension.json: {}", e))?;
 
+        if let Err(errors) = validate_manifest(&manifest) {
+            let messages: Vec<String> = errors.iter().map(|e| e.message.clone()).collect();
+            warn!(
+                "Manifest validation warnings for '{}': {}",
+                manifest.name,
+                messages.join("; ")
+            );
+        }
+
         let enabled = self
             .enabled_extensions
             .get(&manifest.name)

src-tauri/src/extensions/types.rs

@@ -3,11 +3,22 @@
 //! This module contains all the data structures used to represent extensions,
 //! their manifests, and their contributions.
 
+use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
 
+static NAME_RE: Lazy<Regex> = Lazy::new(|| {
+    #[allow(clippy::unwrap_used)]
+    Regex::new(r"^[a-zA-Z0-9._-]+$").unwrap()
+});
+
+static VERSION_RE: Lazy<Regex> = Lazy::new(|| {
+    #[allow(clippy::unwrap_used)]
+    Regex::new(r"^\d+\.\d+\.\d+$").unwrap()
+});
+
 /// Extension manifest schema - defines the structure of extension.json
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExtensionManifest {
@@ -511,24 +522,20 @@ pub struct ManifestValidationError {
 pub fn validate_manifest(manifest: &ExtensionManifest) -> Result<(), Vec<ManifestValidationError>> {
     let mut errors: Vec<ManifestValidationError> = Vec::new();
 
-    #[allow(clippy::unwrap_used)]
-    let name_re = Regex::new(r"^[a-zA-Z0-9._-]+$").unwrap();
     if manifest.name.is_empty() {
         errors.push(ManifestValidationError {
             field: "name".to_string(),
             message: "name must not be empty".to_string(),
         });
-    } else if !name_re.is_match(&manifest.name) {
+    } else if !NAME_RE.is_match(&manifest.name) {
         errors.push(ManifestValidationError {
             field: "name".to_string(),
             message: "name must contain only alphanumeric characters, dashes, underscores, or dots"
                 .to_string(),
         });
     }
 
-    #[allow(clippy::unwrap_used)]
-    let version_re = Regex::new(r"^\d+\.\d+\.\d+$").unwrap();
-    if !version_re.is_match(&manifest.version) {
+    if !VERSION_RE.is_match(&manifest.version) {
         errors.push(ManifestValidationError {
             field: "version".to_string(),
             message: "version must match semver format X.Y.Z".to_string(),

src-tauri/src/extensions/utils.rs

@@ -13,7 +13,7 @@ pub fn extensions_directory_path() -> PathBuf {
         .join("extensions")
 }
 
-/// Recursively copy a directory
+/// Recursively copy a directory, skipping symlinks to prevent symlink attacks.
 pub fn copy_dir_recursive(src: &PathBuf, dst: &PathBuf) -> std::io::Result<()> {
     if !dst.exists() {
         fs::create_dir_all(dst)?;
@@ -25,6 +25,10 @@ pub fn copy_dir_recursive(src: &PathBuf, dst: &PathBuf) -> std::io::Result<()> {
         let src_path = entry.path();
         let dst_path = dst.join(entry.file_name());
 
+        if file_type.is_symlink() {
+            continue;
+        }
+
         if file_type.is_dir() {
             copy_dir_recursive(&src_path, &dst_path)?;
         } else {
@@ -35,6 +39,9 @@ pub fn copy_dir_recursive(src: &PathBuf, dst: &PathBuf) -> std::io::Result<()> {
     Ok(())
 }
 
+const MAX_ZIP_ENTRIES: usize = 10_000;
+const MAX_ZIP_TOTAL_SIZE: u64 = 512 * 1024 * 1024; // 512 MB
+
 /// Extract a zip package to a directory
 pub fn extract_zip_package(
     zip_path: &std::path::Path,
@@ -45,6 +52,25 @@ pub fn extract_zip_package(
     let mut archive =
         zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip archive: {}", e))?;
 
+    if archive.len() > MAX_ZIP_ENTRIES {
+        return Err(format!(
+            "Zip archive contains too many entries ({}, max {})",
+            archive.len(),
+            MAX_ZIP_ENTRIES
+        ));
+    }
+
+    let total_size: u64 = (0..archive.len())
+        .filter_map(|i| archive.by_index(i).ok())
+        .map(|f| f.size())
+        .sum();
+    if total_size > MAX_ZIP_TOTAL_SIZE {
+        return Err(format!(
+            "Zip archive uncompressed size too large ({} bytes, max {} bytes)",
+            total_size, MAX_ZIP_TOTAL_SIZE
+        ));
+    }
+
     fs::create_dir_all(target_dir)
         .map_err(|e| format!("Failed to create extraction directory: {}", e))?;
 

src-tauri/src/extensions/wasm/host.rs

@@ -330,6 +330,9 @@ fn validate_workspace_path(
     workspace_root: &str,
     relative_path: &str,
 ) -> Result<std::path::PathBuf, String> {
+    if relative_path.contains("..") {
+        return Err("Path must not contain '..' components".to_string());
+    }
     let root = Path::new(workspace_root)
         .canonicalize()
         .map_err(|e| format!("Invalid workspace root: {}", e))?;
@@ -597,7 +600,14 @@ pub fn host_save_document(uri: &str) -> Result<(), String> {
 
 pub fn host_get_document_text_by_uri(uri: &str) -> Result<String, String> {
     debug!("[WasmExt] Get document text: uri='{}'", uri);
-    fs::read_to_string(uri).map_err(|e| format!("Failed to read document '{}': {}", uri, e))
+    if uri.is_empty() {
+        return Err("Document URI must not be empty".to_string());
+    }
+    let path = Path::new(uri);
+    if !path.is_absolute() {
+        return Err(format!("Document URI must be an absolute path: '{}'", uri));
+    }
+    fs::read_to_string(path).map_err(|e| format!("Failed to read document '{}': {}", uri, e))
 }
 
 pub fn host_document_line_at(uri: &str, line: u32) -> Result<String, String> {
@@ -1177,7 +1187,6 @@ static DIAGNOSTICS: Lazy<Mutex<Vec<DiagnosticEntry>>> = Lazy::new(|| Mutex::new(
 static STATUS_BAR_MESSAGES: Lazy<Mutex<Vec<StatusBarEntry>>> = Lazy::new(|| Mutex::new(Vec::new()));
 static CODE_ACTION_PROVIDERS: Lazy<Mutex<Vec<String>>> = Lazy::new(|| Mutex::new(Vec::new()));
 
-#[allow(clippy::expect_used)]
 pub fn host_register_language(language_id: &str, extensions_json: &str) {
     let extensions: Vec<String> = serde_json::from_str(extensions_json).unwrap_or_default();
     let entry = RegisteredLanguage {
@@ -1187,7 +1196,7 @@ pub fn host_register_language(language_id: &str, extensions_json: &str) {
 
     let mut registry = REGISTERED_LANGUAGES
         .lock()
-        .expect("Registered languages lock poisoned");
+        .unwrap_or_else(|e| e.into_inner());
     registry.push(entry);
 
     info!(
@@ -1196,7 +1205,6 @@ pub fn host_register_language(language_id: &str, extensions_json: &str) {
     );
 }
 
-#[allow(clippy::expect_used)]
 pub fn host_register_diagnostic(uri: &str, diagnostics: &str) {
     let entry = DiagnosticEntry {
         uri: uri.to_string(),
@@ -1205,18 +1213,17 @@ pub fn host_register_diagnostic(uri: &str, diagnostics: &str) {
 
     let mut registry = DIAGNOSTICS
         .lock()
-        .expect("Diagnostics registry lock poisoned");
+        .unwrap_or_else(|e| e.into_inner());
     registry.retain(|d| d.uri != uri);
     registry.push(entry);
 
     info!("[WasmExt] Registered diagnostics for uri='{}'", uri);
 }
 
-#[allow(clippy::expect_used)]
 pub fn host_register_code_action_provider(language_id: &str) {
     let mut registry = CODE_ACTION_PROVIDERS
         .lock()
-        .expect("Code action providers lock poisoned");
+        .unwrap_or_else(|e| e.into_inner());
     if !registry.contains(&language_id.to_string()) {
         registry.push(language_id.to_string());
     }
@@ -1231,7 +1238,6 @@ pub fn host_get_workspace_path() -> Option<String> {
     None
 }
 
-#[allow(clippy::expect_used)]
 pub fn host_set_status_bar_message(text: &str, timeout_ms: Option<u32>) {
     let created_at = SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
@@ -1245,7 +1251,7 @@ pub fn host_set_status_bar_message(text: &str, timeout_ms: Option<u32>) {
 
     let mut registry = STATUS_BAR_MESSAGES
         .lock()
-        .expect("Status bar messages lock poisoned");
+        .unwrap_or_else(|e| e.into_inner());
     registry.push(entry);
 
     info!(

src-tauri/src/extensions/wasm/mod.rs

@@ -95,7 +95,7 @@ pub async fn execute_wasm_command(
         .wasm_runtime
         .execute_command(&extension_id, &command, &args_json)?;
 
-    serde_json::from_str(&result).unwrap_or(Ok(serde_json::Value::String(result)))
+    Ok(serde_json::from_str(&result).unwrap_or_else(|_| serde_json::Value::String(result)))
 }
 
 #[cfg(not(feature = "wasm-extensions"))]