diff --git a/apps/desktop/src/components/plugins/PluginContributionsPanel.vue b/apps/desktop/src/components/plugins/PluginContributionsPanel.vue index 37e58867e6..e61bfdee1f 100644 --- a/apps/desktop/src/components/plugins/PluginContributionsPanel.vue +++ b/apps/desktop/src/components/plugins/PluginContributionsPanel.vue @@ -867,6 +867,10 @@ async function uninstallSelectedPlugin() { selectFirstProvider(); } catch (cause) { toast(cause instanceof Error ? cause.message : String(cause), 5000); + // A failed uninstall can still have changed the store (the container is renamed out of the + // plugin store before its physical delete, for instance), so re-read the installed list + // instead of leaving the panel on state it may no longer describe. + await refreshAfterBatch(); } finally { operating.value = false; } diff --git a/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts b/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts index 71eb7c0b22..61994220b9 100644 --- a/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts +++ b/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts @@ -854,3 +854,37 @@ describe("PluginContributionsPanel marketplace sort", () => { expect(renderedOrder()).toEqual(["a.older", "b.newer"]); }); }); + +describe("PluginContributionsPanel single uninstall outcomes", () => { + it("re-reads the installed list and notifies listeners when a single uninstall fails", async () => { + const changed = vi.fn(); + window.addEventListener("dbx:plugins-changed", changed); + const failure = "The process cannot access the file because it is being used by another process. (os error 32)"; + mocks.uninstallPlugin.mockRejectedValueOnce(new Error(failure)); + // The backend kept the plugin installed (the uninstall never committed), and the panel has to + // show exactly that instead of the state it guessed before the call. + mocks.listPlugins.mockResolvedValueOnce([installed("a"), installed("b", "9.9.9")]); + + try { + await state.uninstallSelectedPlugin(); + } finally { + window.removeEventListener("dbx:plugins-changed", changed); + } + + expect(mocks.toast).toHaveBeenLastCalledWith(failure, 5000); + expect(mocks.listPlugins).toHaveBeenCalledOnce(); + expect(state.installedPlugins.map((plugin) => `${plugin.manifest.id}@${plugin.manifest.version}`)).toEqual(["a@1.0.0", "b@9.9.9"]); + expect(changed).toHaveBeenCalledOnce(); + expect(state.error).toBe(""); + }); + + it("keeps the uninstall failure visible when the follow-up refresh also fails", async () => { + mocks.uninstallPlugin.mockRejectedValueOnce(new Error("denied")); + mocks.listPlugins.mockRejectedValueOnce(new Error("refresh offline")); + + await state.uninstallSelectedPlugin(); + + expect(mocks.toast).toHaveBeenLastCalledWith("denied", 5000); + expect(state.error).toBe('pluginPlatform.batchRefreshFailed:{"error":"refresh offline"}'); + }); +}); diff --git a/crates/dbx-plugin-runtime/src/plugins.rs b/crates/dbx-plugin-runtime/src/plugins.rs index c58cec4236..40ef3baa2c 100644 --- a/crates/dbx-plugin-runtime/src/plugins.rs +++ b/crates/dbx-plugin-runtime/src/plugins.rs @@ -198,6 +198,11 @@ impl PluginRegistry { let mut plugins = Vec::new(); for entry in entries { let entry = entry.map_err(|err| err.to_string())?; + if entry.file_name() == std::ffi::OsStr::new(installer::PLUGIN_TRASH_DIR) { + // Logical uninstall tombstones are not plugin containers: never discover one, not + // even while its physical delete is still pending. + continue; + } let container_path = entry.path(); if !container_path.is_dir() { continue; @@ -292,6 +297,12 @@ impl PluginRegistry { let plugin = self.find_driver(driver_id)?.ok_or_else(|| format!("Plugin driver '{driver_id}' is not installed"))?; ensure_plugin_compatible(&plugin)?; + // This is a short-lived, one-shot driver invocation: it starts its own sidecar instead of + // going through `PluginHost`, so it is not in `PluginHost::sessions` and needs its own + // lease. `begin_operation` matches those semantics (not a connection the user keeps open) + // and makes the whole start -> invoke -> shutdown sequence mutually exclusive with an + // install, rollback, or uninstall of the same plugin. + let _operation = self.lifecycle.begin_operation(&plugin.manifest.id)?; let env = env.with_plugin_data_dir(&self.plugin_data_dir(&plugin.manifest.id)); let session = PluginSidecarSession::start(plugin, self.app_version.clone(), env).await?; let result = session.invoke_with_timeout(method, params, Some(driver_id), timeout_duration).await; @@ -694,6 +705,65 @@ sleep 30 let _ = std::fs::remove_dir_all(root); } + #[tokio::test] + async fn driver_invocations_are_gated_by_the_update_lease_for_their_whole_session() { + let root = std::env::temp_dir().join(format!("dbx-plugin-driver-lease-test-{}", uuid::Uuid::new_v4())); + let plugin_dir = root.join("sample"); + std::fs::create_dir_all(&plugin_dir).unwrap(); + std::fs::write( + plugin_dir.join("manifest.json"), + // External drivers only exist on the legacy manifest shape, which is what + // `PluginRegistry::find_driver` resolves. + serde_json::json!({ + "id": "sample", + "name": "Sample", + "version": "1.0.0", + "publisher": "example", + "protocol_version": 1, + "executable": "plugin.sh", + "drivers": [{ "id": "sample-driver", "label": "Sample", "kind": "external", "database_type": "sample" }] + }) + .to_string(), + ) + .unwrap(); + // Present but never executable: the manifest stays compatible so the invocation gets past + // the lease, while starting the sidecar fails immediately and deterministically on every + // platform (no exec bit on unix, not a valid image on Windows). + std::fs::write(plugin_dir.join("plugin.sh"), "#!/bin/sh\nexit 1\n").unwrap(); + let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67"); + + let update = registry.lifecycle().begin_update("sample").unwrap(); + let refused = registry + .invoke_driver_with_env_and_timeout::( + "sample-driver", + "testConnection", + serde_json::json!({}), + PluginRuntimeEnv::default(), + None, + ) + .await + .unwrap_err(); + assert!(refused.contains("Plugin update is in progress"), "{refused}"); + drop(update); + + // Once the update released the lease the invocation runs, and because the sidecar cannot + // start it must report that instead of the update error: the guard covered the start + // attempt and was released on the way out. + let failed_start = registry + .invoke_driver_with_env_and_timeout::( + "sample-driver", + "testConnection", + serde_json::json!({}), + PluginRuntimeEnv::default(), + None, + ) + .await + .unwrap_err(); + assert!(!failed_start.contains("Plugin update is in progress"), "{failed_start}"); + assert!(registry.lifecycle().begin_update("sample").is_ok(), "a failed invocation must not leak its lease"); + let _ = std::fs::remove_dir_all(root); + } + #[test] fn installed_plugin_info_hides_runtime_paths() { let plugin = InstalledPlugin::new( diff --git a/crates/dbx-plugin-runtime/src/plugins/host.rs b/crates/dbx-plugin-runtime/src/plugins/host.rs index 828b96872c..0fe4b6ecbc 100644 --- a/crates/dbx-plugin-runtime/src/plugins/host.rs +++ b/crates/dbx-plugin-runtime/src/plugins/host.rs @@ -10,9 +10,9 @@ use tokio::sync::{broadcast, Mutex, RwLock}; use super::{ InstalledPlugin, PluginBinaryMessage, PluginConnectionActionContribution, PluginConnectionCapability, PluginConnectionProviderContribution, PluginEvent, PluginFormFieldBinding, PluginFormFieldDefinition, - PluginFormFieldType, PluginRegistry, PluginRuntimeEnv, PluginSessionState, PluginSidecarSession, - PLUGIN_CONNECTION_ACTION_METHOD, PLUGIN_CONNECTION_CONNECT_METHOD, PLUGIN_CONNECTION_DISCONNECT_METHOD, - PLUGIN_CONNECTION_TEST_METHOD, + PluginFormFieldType, PluginPackageInstaller, PluginRegistry, PluginRuntimeEnv, PluginSessionState, + PluginSidecarSession, PluginTrustStore, PLUGIN_CONNECTION_ACTION_METHOD, PLUGIN_CONNECTION_CONNECT_METHOD, + PLUGIN_CONNECTION_DISCONNECT_METHOD, PLUGIN_CONNECTION_TEST_METHOD, }; #[derive(Debug, Clone, Serialize)] @@ -352,6 +352,25 @@ impl PluginHost { } } + /// Runtime-aware uninstall. The lifecycle update lease is taken *before* the sidecar is stopped + /// and held until the store-level uninstall committed, so nothing can re-activate the plugin + /// and re-lock its container between the runtime stop and the filesystem rename. It also keeps + /// `PluginHost::sessions` and the plugin store consistent: the session is removed and the + /// container gone before the lease is released. + /// + /// Callers drain the plugin's connection pools and external driver pools first: the lease is + /// refused while the plugin still has an active connection or operation. + pub async fn uninstall_plugin(&self, plugin_id: &str) -> Result<(), String> { + let _update = self.inner.registry.lifecycle.begin_update(plugin_id)?; + self.stop(plugin_id).await; + let root_dir = self.inner.registry.root_dir().to_path_buf(); + let app_version = self.inner.registry.app_version().to_string(); + // Uninstall never validates a package signature, so it must not load the user trust store. + let installer = PluginPackageInstaller::with_trust_store(root_dir, app_version, PluginTrustStore::default()); + let plugin_id = plugin_id.to_string(); + tokio::task::spawn_blocking(move || installer.uninstall(&plugin_id)).await.map_err(|error| error.to_string())? + } + async fn running_session(&self, plugin_id: &str) -> Option> { let session = self.inner.sessions.read().await.get(plugin_id).cloned()?; (session.status().state == PluginSessionState::Running).then_some(session) @@ -836,6 +855,43 @@ mod tests { use crate::models::connection::ConnectionConfig; use crate::plugins::PluginConnectionProviderContribution; + #[tokio::test] + async fn uninstall_plugin_holds_one_update_lease_across_the_runtime_and_the_store() { + use crate::plugins::installer::PLUGIN_TRASH_DIR; + use crate::plugins::{PluginHost, PluginRegistry}; + + let temp = tempfile::tempdir().unwrap(); + let root = temp.path().join("plugins"); + let plugin_dir = root.join("sample.hello"); + std::fs::create_dir_all(&plugin_dir).unwrap(); + std::fs::write( + plugin_dir.join("manifest.json"), + serde_json::json!({ "id": "sample.hello", "name": "Sample", "version": "1.0.0", "protocol_version": 1 }) + .to_string(), + ) + .unwrap(); + let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67"); + let lifecycle = registry.lifecycle(); + let host = PluginHost::new(registry); + + // An active operation refuses the uninstall before anything is stopped or deleted, so the + // caller still sees a complete, discoverable plugin. + let operation = lifecycle.begin_operation("sample.hello").unwrap(); + let refused = host.uninstall_plugin("sample.hello").await.unwrap_err(); + assert!(refused.contains("active operations"), "{refused}"); + assert!(plugin_dir.join("manifest.json").is_file(), "a refused uninstall must not touch the container"); + drop(operation); + + host.uninstall_plugin("sample.hello").await.unwrap(); + assert!(!plugin_dir.exists()); + let tombstones = std::fs::read_dir(root.join(PLUGIN_TRASH_DIR)).map(|entries| entries.count()).unwrap_or(0); + assert_eq!(tombstones, 0, "a successful uninstall sweeps its tombstone"); + + // The lease is released again, and it was scoped to just this plugin. + assert!(lifecycle.begin_update("sample.hello").is_ok()); + assert!(lifecycle.begin_update("sample.other").is_ok()); + } + #[tokio::test] async fn ui_only_connections_hold_update_guards_but_saved_configs_do_not() { let root = tempfile::tempdir().unwrap(); diff --git a/crates/dbx-plugin-runtime/src/plugins/installer.rs b/crates/dbx-plugin-runtime/src/plugins/installer.rs index db41b2b887..abcce1af24 100644 --- a/crates/dbx-plugin-runtime/src/plugins/installer.rs +++ b/crates/dbx-plugin-runtime/src/plugins/installer.rs @@ -25,6 +25,10 @@ const MAX_UNCOMPRESSED_BYTES: u64 = 1024 * 1024 * 1024; const MAX_FILE_BYTES: u64 = 256 * 1024 * 1024; const MAX_ARCHIVE_ENTRIES: usize = 10_000; const INSTALL_LOCK_FILE: &str = ".install.lock"; +/// Where a logically uninstalled plugin container waits for its physical delete. The directory is +/// no plugin container of its own (no manifest, no activations), so installed plugin discovery +/// skips it, and `validate_plugin_id` rejects a leading dot, so no plugin id can collide with it. +pub(super) const PLUGIN_TRASH_DIR: &str = ".trash"; const VERSIONS_DIR: &str = "versions"; const ACTIVATIONS_DIR: &str = "activations"; const TRUST_DIR: &str = ".trust"; @@ -409,6 +413,10 @@ impl PluginPackageInstaller { let lock = open_install_lock(&self.root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; let result = self.install_bytes_locked(package, policy, expectation, source, allow_source_change); + if result.is_ok() { + // Opportunistic cleanup of tombstones an earlier uninstall could not delete yet. + self.sweep_plugin_trash(&TRANSIENT_LOCK_RETRY_DELAYS, |path: &Path| std::fs::remove_dir_all(path)); + } let _ = FileExt::unlock(&lock); result } @@ -423,20 +431,81 @@ impl PluginPackageInstaller { result } + /// Store-level logical uninstall: the official `plugins/` container is renamed into + /// `.trash` (that rename *is* the commit) and only then physically deleted. `remove_dir_all` is + /// not atomic, so deleting the container in place could leave a partially deleted tree behind; + /// a failed rename instead leaves the container exactly as it was and reports a clean failure. pub fn uninstall(&self, plugin_id: &str) -> Result<(), String> { + self.uninstall_with_ops( + plugin_id, + &TRANSIENT_LOCK_RETRY_DELAYS, + |src: &Path, dst: &Path| std::fs::rename(src, dst), + |path: &Path| std::fs::remove_dir_all(path), + ) + } + + /// The uninstall body, parameterised for tests: `delays` is the transient Windows lock retry + /// window, and the two filesystem primitives are injected so error 5 / 32 failures can be + /// reproduced deterministically on every platform instead of depending on a real scanner. + fn uninstall_with_ops( + &self, + plugin_id: &str, + delays: &[Duration], + mut rename: impl FnMut(&Path, &Path) -> std::io::Result<()>, + mut remove_dir_all: impl FnMut(&Path) -> std::io::Result<()>, + ) -> Result<(), String> { validate_plugin_id(plugin_id)?; let lock = open_install_lock(&self.root_dir)?; lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?; - let plugin_dir = self.root_dir.join(plugin_id); - let result = match std::fs::remove_dir_all(&plugin_dir) { - Ok(()) => Ok(()), - Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()), - Err(error) => Err(format!("Failed to uninstall plugin '{plugin_id}': {error}")), - }; + let result = (|| { + let plugin_dir = self.root_dir.join(plugin_id); + if plugin_dir.exists() { + let trash_dir = self.root_dir.join(PLUGIN_TRASH_DIR); + std::fs::create_dir_all(&trash_dir) + .map_err(|error| format!("Failed to prepare plugin trash '{}': {error}", trash_dir.display()))?; + let tombstone = unique_plugin_tombstone(&trash_dir, plugin_id); + // From here on the plugin is uninstalled: the container is out of the store root + // and discovery does not see it any more. An antivirus scanner holding a freshly + // extracted binary may fail this rename with error 5 / 32, hence the retry, and a + // rename that keeps failing leaves the container untouched for a clean failure. + retry_transient_lock(delays, || rename(&plugin_dir, &tombstone)) + .map_err(|error| format!("Failed to uninstall plugin '{plugin_id}': {error}"))?; + } + self.sweep_plugin_trash(delays, &mut remove_dir_all); + Ok(()) + })(); let _ = FileExt::unlock(&lock); result } + /// Best-effort physical delete of every `.trash` tombstone: the one the caller just committed + /// plus leftovers from an earlier uninstall whose delete failed. Callers hold `.install.lock`, + /// every entry in there is already logically uninstalled, and a tombstone that still cannot be + /// removed only logs a warning — the plugin is uninstalled either way, and a later install or + /// uninstall sweeps it again. + fn sweep_plugin_trash(&self, delays: &[Duration], mut remove_dir_all: impl FnMut(&Path) -> std::io::Result<()>) { + let trash_dir = self.root_dir.join(PLUGIN_TRASH_DIR); + let entries = match std::fs::read_dir(&trash_dir) { + Ok(entries) => entries, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return, + Err(error) => { + log::warn!("Failed to scan plugin trash '{}': {error}", trash_dir.display()); + return; + } + }; + for entry in entries.flatten() { + let tombstone = entry.path(); + let removed = retry_transient_lock(delays, || match remove_dir_all(&tombstone) { + // Already gone (or not a directory): nothing left to clean up. + Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()), + result => result, + }); + if let Err(error) = removed { + log::warn!("Failed to remove plugin tombstone '{}': {error}", tombstone.display()); + } + } + } + /// Recorded provenance of one container's active installation, if any. pub(super) fn read_container_provenance(container_dir: &Path) -> Result, String> { Ok(read_latest_activation(container_dir)?.and_then(|record| record.provenance)) @@ -1088,6 +1157,19 @@ fn is_windows_lock_error(error: &std::io::Error) -> bool { matches!(error.raw_os_error(), Some(5 | 32)) } +/// Tombstone path for one logical uninstall: `.trash/`, or `.trash/-`, the +/// same suffix convention `install_bytes_locked` uses for replaced versions, when an earlier +/// tombstone of that plugin is still waiting for its physical delete. +fn unique_plugin_tombstone(trash_dir: &Path, plugin_id: &str) -> PathBuf { + let mut candidate = trash_dir.join(plugin_id); + let mut suffix = 0u32; + while candidate.exists() { + suffix = suffix.saturating_add(1); + candidate = trash_dir.join(format!("{plugin_id}-{suffix}")); + } + candidate +} + fn make_backend_executable(path: &Option) -> Result<(), String> { #[cfg(unix)] if let Some(path) = path { @@ -1198,7 +1280,7 @@ fn sync_directory(_path: &Path) -> Result<(), String> { mod tests { use std::collections::{BTreeMap, BTreeSet}; use std::io::{Cursor, Write}; - use std::path::Path; + use std::path::{Path, PathBuf}; use std::time::Duration; use base64::Engine; @@ -1208,8 +1290,8 @@ mod tests { use super::{ is_activation_record_file, read_install_identity, retry_transient_lock, sha256_hex, validate_package_expectation, PluginInstallPolicy, PluginPackageExpectation, PluginPackageInstaller, - PluginSignatureStatus, PluginTrustStore, ACTIVATIONS_DIR, PLUGIN_CHECKSUMS_FILE, PLUGIN_SIGNATURE_FILE, - VERSIONS_DIR, + PluginSignatureStatus, PluginTrustStore, ACTIVATIONS_DIR, INSTALL_LOCK_FILE, PLUGIN_CHECKSUMS_FILE, + PLUGIN_SIGNATURE_FILE, PLUGIN_TRASH_DIR, VERSIONS_DIR, }; use crate::plugins::{PluginManifest, PluginRegistry}; @@ -2093,4 +2175,168 @@ mod tests { assert_eq!(attempts.load(Ordering::SeqCst), 1); assert_eq!(result.unwrap_err().raw_os_error(), Some(5)); } + + /// Sorted `.trash` entries, so tombstone assertions are deterministic. + fn trash_entries(root: &Path) -> Vec { + let mut names = std::fs::read_dir(root.join(PLUGIN_TRASH_DIR)) + .map(|entries| { + entries + .filter_map(|entry| entry.ok()) + .map(|entry| entry.file_name().to_string_lossy().into_owned()) + .collect::>() + }) + .unwrap_or_default(); + names.sort(); + names + } + + /// Installs `sample.hello` into a store rooted at `/plugins`, so `/plugin-data` + /// sits next to it exactly like the real registry layout does. + fn uninstall_fixture(temp: &tempfile::TempDir, version: &str) -> (PluginPackageInstaller, PathBuf) { + let root = temp.path().join("plugins"); + let installer = PluginPackageInstaller::with_trust_store(root.clone(), "0.5.67", PluginTrustStore::default()); + installer.install_bytes(&package(version, None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); + (installer, root) + } + + #[test] + fn uninstall_commits_logically_and_sweeps_its_own_tombstone() { + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + let plugin_data = temp.path().join("plugin-data").join("sample.hello"); + std::fs::create_dir_all(&plugin_data).unwrap(); + std::fs::write(plugin_data.join("preferences.json"), "{}").unwrap(); + let container = root.join("sample.hello"); + assert!(container.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file()); + + installer.uninstall("sample.hello").unwrap(); + + assert!(!container.exists(), "the official container must be gone"); + assert!(trash_entries(&root).is_empty(), "a successful uninstall sweeps its own tombstone"); + assert!(root.join(INSTALL_LOCK_FILE).is_file(), "the store lock file stays in place"); + assert!(plugin_data.join("preferences.json").is_file(), "plugin data survives an uninstall"); + let registry = PluginRegistry::new_with_app_version(root, "0.5.67"); + assert!(registry.list_installed().unwrap().is_empty()); + assert!(registry.find_plugin("sample.hello").unwrap().is_none()); + + // Uninstalling a plugin that is already gone stays idempotent. + installer.uninstall("sample.hello").unwrap(); + } + + #[test] + #[cfg(windows)] + fn uninstall_retries_transient_windows_locks_on_the_commit_rename() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + let attempts = AtomicUsize::new(0); + installer + .uninstall_with_ops( + "sample.hello", + &[Duration::ZERO, Duration::ZERO, Duration::ZERO], + |src: &Path, dst: &Path| match attempts.fetch_add(1, Ordering::SeqCst) { + 0 => Err(std::io::Error::from_raw_os_error(5)), + 1 => Err(std::io::Error::from_raw_os_error(32)), + _ => std::fs::rename(src, dst), + }, + |path: &Path| std::fs::remove_dir_all(path), + ) + .unwrap(); + + assert_eq!(attempts.load(Ordering::SeqCst), 3, "two lock errors then one successful rename"); + assert!(!root.join("sample.hello").exists()); + assert!(trash_entries(&root).is_empty()); + } + + #[test] + fn uninstall_reports_a_clean_failure_and_keeps_the_container_when_the_rename_keeps_failing() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + let container = root.join("sample.hello"); + let attempts = AtomicUsize::new(0); + let error = installer + .uninstall_with_ops( + "sample.hello", + &[Duration::ZERO, Duration::ZERO, Duration::ZERO], + |_: &Path, _: &Path| { + attempts.fetch_add(1, Ordering::SeqCst); + Err(std::io::Error::from_raw_os_error(32)) + }, + |path: &Path| std::fs::remove_dir_all(path), + ) + .unwrap_err(); + + assert!(error.contains("Failed to uninstall plugin 'sample.hello'"), "{error}"); + assert_eq!(attempts.load(Ordering::SeqCst), if cfg!(windows) { 4 } else { 1 }); + // A failed logical commit must leave the container exactly as it was: the plugin has to + // stay installed, discoverable, and loadable after a restart. + assert!(container.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file()); + assert_eq!(activation_record_count(&container), 1); + assert!(trash_entries(&root).is_empty(), "a failed commit must not leave a tombstone behind"); + let registry = PluginRegistry::new_with_app_version(root, "0.5.67"); + assert_eq!(registry.list_installed().unwrap().len(), 1); + assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0"); + } + + #[test] + fn uninstall_stays_a_logical_success_when_the_tombstone_cannot_be_deleted() { + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + + installer + .uninstall_with_ops( + "sample.hello", + &[Duration::ZERO, Duration::ZERO, Duration::ZERO], + |src: &Path, dst: &Path| std::fs::rename(src, dst), + |_: &Path| Err(std::io::Error::from_raw_os_error(32)), + ) + .unwrap(); + + assert!(!root.join("sample.hello").exists()); + assert_eq!(trash_entries(&root), vec!["sample.hello".to_string()]); + let registry = PluginRegistry::new_with_app_version(root, "0.5.67"); + assert!(registry.list_installed().unwrap().is_empty()); + assert!(registry.find_plugin("sample.hello").unwrap().is_none()); + } + + #[test] + fn install_and_uninstall_sweep_tombstones_left_by_an_earlier_attempt() { + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + let stale = root.join(PLUGIN_TRASH_DIR).join("sample.hello"); + std::fs::create_dir_all(stale.join(VERSIONS_DIR).join("1.0.0")).unwrap(); + std::fs::write(stale.join(VERSIONS_DIR).join("1.0.0").join("manifest.json"), "{}").unwrap(); + + installer.install_bytes(&package("1.1.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); + assert!(!stale.exists(), "an install sweeps leftovers of an earlier uninstall"); + + std::fs::create_dir_all(&stale).unwrap(); + std::fs::write(stale.join("leftover.bin"), b"still locked").unwrap(); + installer.uninstall("sample.hello").unwrap(); + assert!(!root.join("sample.hello").exists()); + assert!(!stale.exists(), "an uninstall sweeps old tombstones as well"); + } + + #[test] + fn tombstone_containers_are_never_discovered_as_installed_plugins() { + let temp = tempfile::tempdir().unwrap(); + let (installer, root) = uninstall_fixture(&temp, "1.0.0"); + let tombstone = root.join(PLUGIN_TRASH_DIR).join("sample.hello"); + std::fs::create_dir_all(root.join(PLUGIN_TRASH_DIR)).unwrap(); + std::fs::rename(root.join("sample.hello"), &tombstone).unwrap(); + // The tombstone still holds a complete container: versions/, activations/, manifest.json. + assert!(tombstone.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file()); + assert_eq!(activation_record_count(&tombstone), 1); + + let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67"); + assert!(registry.list_installed().unwrap().is_empty()); + assert!(registry.find_plugin("sample.hello").unwrap().is_none()); + + // The store stays usable: a reinstall does not collide with the pending tombstone. + installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap(); + assert_eq!(registry.list_installed().unwrap().len(), 1); + } } diff --git a/crates/dbx-web/src/routes/plugins.rs b/crates/dbx-web/src/routes/plugins.rs index 0f55898afc..91ed7ff655 100644 --- a/crates/dbx-web/src/routes/plugins.rs +++ b/crates/dbx-web/src/routes/plugins.rs @@ -353,22 +353,15 @@ pub async fn uninstall_plugin( } let plugin = state.app.plugins.find_plugin(&request.plugin_id).map_err(AppError::from)?; state.app.remove_plugin_connection_pools(&request.plugin_id).await; - state.app.plugin_host.stop(&request.plugin_id).await; if let Some(plugin) = &plugin { stop_external_driver_pools(&state, plugin).await; } - let root_dir = state.app.plugins.root_dir().to_path_buf(); - let app_version = state.app.plugins.app_version().to_string(); - let plugin_id = request.plugin_id.clone(); - tokio::task::spawn_blocking(move || { - PluginPackageInstaller::new(root_dir, app_version)?.uninstall(&request.plugin_id) - }) - .await - .map_err(|error| AppError::internal(error.to_string()))? - .map_err(AppError::bad_request)?; + // Stops the runtime and uninstalls the store under one lifecycle update lease, so a plugin + // call cannot re-activate the sidecar (and re-lock its container) in between. + state.app.plugin_host.uninstall_plugin(&request.plugin_id).await.map_err(AppError::bad_request)?; // A reinstall must ask for AI tool access and data grants again. - if let Err(error) = state.app.storage.forget_plugin_permissions(&plugin_id).await { - log::warn!("Failed to clear permissions of uninstalled plugin {plugin_id}: {error}"); + if let Err(error) = state.app.storage.forget_plugin_permissions(&request.plugin_id).await { + log::warn!("Failed to clear permissions of uninstalled plugin {}: {error}", request.plugin_id); } list_plugins(State(state)).await } diff --git a/src-tauri/src/commands/plugins.rs b/src-tauri/src/commands/plugins.rs index 041e78de56..b64a2e1cdc 100644 --- a/src-tauri/src/commands/plugins.rs +++ b/src-tauri/src/commands/plugins.rs @@ -276,18 +276,12 @@ pub async fn uninstall_plugin( } let plugin = state.plugins.find_plugin(&plugin_id)?; state.remove_plugin_connection_pools(&plugin_id).await; - state.plugin_host.stop(&plugin_id).await; if let Some(plugin) = &plugin { stop_external_driver_pools(&state, plugin).await; } - let root_dir = state.plugins.root_dir().to_path_buf(); - let app_version = state.plugins.app_version().to_string(); - let uninstalled_id = plugin_id.clone(); - tauri::async_runtime::spawn_blocking(move || { - PluginPackageInstaller::new(root_dir, app_version)?.uninstall(&uninstalled_id) - }) - .await - .map_err(|error| error.to_string())??; + // Stops the runtime and uninstalls the store under one lifecycle update lease, so a plugin + // call cannot re-activate the sidecar (and re-lock its container) in between. + state.plugin_host.uninstall_plugin(&plugin_id).await?; // A reinstall must ask for AI tool access and data grants again. if let Err(error) = state.storage.forget_plugin_permissions(&plugin_id).await { log::warn!("Failed to clear permissions of uninstalled plugin {plugin_id}: {error}");