fix(plugins): unregister running driver and verify installed manifest

Stop drivers before install to avoid locked files; validate manifest id
and version; add unit tests

Author: debba

plugins/registry.json

@@ -180,6 +180,17 @@
             "darwin-arm64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.2.0/google-sheets-plugin-darwin-arm64.zip",
             "win-x64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.2.0/google-sheets-plugin-win-x64.zip"
           }
+        },
+        {
+          "version": "0.1.0",
+          "min_tabularis_version": "0.9.21",
+          "assets": {
+            "linux-x64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.1.0/google-sheets-plugin-linux-x64.zip",
+            "linux-arm64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.1.0/google-sheets-plugin-linux-arm64.zip",
+            "darwin-x64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.1.0/google-sheets-plugin-darwin-x64.zip",
+            "darwin-arm64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.1.0/google-sheets-plugin-darwin-arm64.zip",
+            "win-x64": "https://github.com/TabularisDB/tabularis-google-sheets-plugin/releases/download/v0.1.0/google-sheets-plugin-win-x64.zip"
+          }
         }
       ]
     }

src-tauri/src/plugins/commands.rs

@@ -1,10 +1,12 @@
 use std::fs;
+use std::time::Duration;
 
 use crate::drivers::driver_trait::PluginManifest;
 use crate::plugins::installer::{self, InstalledPluginInfo};
 use crate::plugins::manager::ConfigManifest;
 use crate::plugins::registry::{self, RegistryPluginWithStatus, RegistryReleaseWithStatus};
 use tauri::AppHandle;
+use tokio::time::sleep;
 
 #[tauri::command]
 pub async fn fetch_plugin_registry(
@@ -71,6 +73,12 @@ pub async fn install_plugin(
     plugin_id: String,
     version: Option<String>,
 ) -> Result<(), String> {
+    // Updating an installed plugin must stop the existing process first,
+    // otherwise the OS may keep files locked while we replace the directory.
+    crate::drivers::registry::unregister_driver(&plugin_id).await;
+    crate::drivers::registry::unregister_manifest(&plugin_id).await;
+    sleep(Duration::from_millis(500)).await;
+
     let config = crate::config::load_config_internal(&app);
     let remote = registry::fetch_registry(config.custom_registry_url.as_deref()).await?;
     let platform = registry::get_current_platform();
@@ -102,6 +110,20 @@ pub async fn install_plugin(
 
     installer::download_and_install(&plugin_id, download_url).await?;
 
+    let installed_plugin = installer::read_installed_plugin(&plugin_id)?;
+    if installed_plugin.id != plugin_id {
+        return Err(format!(
+            "Plugin archive mismatch: registry expected id '{}' but installed manifest reports '{}'",
+            plugin_id, installed_plugin.id
+        ));
+    }
+    if installed_plugin.version != target_version {
+        return Err(format!(
+            "Plugin archive version mismatch: registry expected version '{}' but installed manifest reports '{}'. The published asset appears inconsistent.",
+            target_version, installed_plugin.version
+        ));
+    }
+
     // Hot-register the new driver (no restart needed)
     let plugin_cfg = config.plugins.as_ref().and_then(|m| m.get(&plugin_id));
     let interpreter_override = plugin_cfg.and_then(|c| c.interpreter.clone());

src-tauri/src/plugins/installer.rs

@@ -1,6 +1,6 @@
 use std::fs;
 use std::io::Read;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use directories::ProjectDirs;
 use serde::{Deserialize, Serialize};
@@ -13,6 +13,14 @@ pub struct InstalledPluginInfo {
     pub description: String,
 }
 
+#[derive(Deserialize)]
+struct InstalledPluginManifest {
+    id: String,
+    name: String,
+    version: String,
+    description: String,
+}
+
 pub fn get_plugins_dir() -> Result<PathBuf, String> {
     let proj_dirs = ProjectDirs::from("com", "debba", "tabularis")
         .ok_or_else(|| "Could not determine project directories".to_string())?;
@@ -24,6 +32,27 @@ pub fn get_plugins_dir() -> Result<PathBuf, String> {
     Ok(plugins_dir)
 }
 
+pub(crate) fn read_plugin_info_from_dir(path: &Path) -> Result<InstalledPluginInfo, String> {
+    let manifest_path = path.join("manifest.json");
+    let manifest_str = fs::read_to_string(&manifest_path)
+        .map_err(|e| format!("Failed to read plugin manifest {:?}: {}", manifest_path, e))?;
+
+    let manifest: InstalledPluginManifest = serde_json::from_str(&manifest_str)
+        .map_err(|e| format!("Failed to parse plugin manifest {:?}: {}", manifest_path, e))?;
+
+    Ok(InstalledPluginInfo {
+        id: manifest.id,
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+    })
+}
+
+pub fn read_installed_plugin(plugin_id: &str) -> Result<InstalledPluginInfo, String> {
+    let plugins_dir = get_plugins_dir()?;
+    read_plugin_info_from_dir(&plugins_dir.join(plugin_id))
+}
+
 pub async fn download_and_install(plugin_id: &str, download_url: &str) -> Result<(), String> {
     let plugins_dir = get_plugins_dir()?;
     let tmp_dir = plugins_dir.join(format!(".tmp-{}", plugin_id));
@@ -210,30 +239,9 @@ pub fn list_installed() -> Result<Vec<InstalledPluginInfo>, String> {
             continue;
         }
 
-        let manifest_str = match fs::read_to_string(&manifest_path) {
-            Ok(s) => s,
-            Err(_) => continue,
-        };
-
-        #[derive(Deserialize)]
-        struct Manifest {
-            id: String,
-            name: String,
-            version: String,
-            description: String,
+        if let Ok(plugin) = read_plugin_info_from_dir(&path) {
+            plugins.push(plugin);
         }
-
-        let manifest: Manifest = match serde_json::from_str(&manifest_str) {
-            Ok(m) => m,
-            Err(_) => continue,
-        };
-
-        plugins.push(InstalledPluginInfo {
-            id: manifest.id,
-            name: manifest.name,
-            version: manifest.version,
-            description: manifest.description,
-        });
     }
 
     Ok(plugins)

src-tauri/src/plugins/mod.rs

@@ -4,3 +4,6 @@ pub mod installer;
 pub mod manager;
 pub mod registry;
 pub mod rpc;
+
+#[cfg(test)]
+mod tests;

src-tauri/src/plugins/tests.rs

@@ -0,0 +1,39 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+use super::installer::read_plugin_info_from_dir;
+
+#[test]
+fn reads_installed_plugin_info_from_manifest() {
+    let dir = tempdir().expect("temp dir");
+    let manifest_path = dir.path().join("manifest.json");
+    fs::write(
+        &manifest_path,
+        r#"{
+  "id": "google-sheets",
+  "name": "Google Sheets",
+  "version": "0.2.0",
+  "description": "Query Sheets"
+}"#,
+    )
+    .expect("write manifest");
+
+    let plugin = read_plugin_info_from_dir(dir.path()).expect("read manifest");
+
+    assert_eq!(plugin.id, "google-sheets");
+    assert_eq!(plugin.name, "Google Sheets");
+    assert_eq!(plugin.version, "0.2.0");
+    assert_eq!(plugin.description, "Query Sheets");
+}
+
+#[test]
+fn returns_error_for_invalid_manifest() {
+    let dir = tempdir().expect("temp dir");
+    let manifest_path = dir.path().join("manifest.json");
+    fs::write(&manifest_path, "{ invalid json").expect("write manifest");
+
+    let error = read_plugin_info_from_dir(dir.path()).expect_err("invalid manifest");
+
+    assert!(error.contains("Failed to parse plugin manifest"));
+}