handle pre_remove hook

Author: QaidVoid

crates/soar-cli/src/apply.rs

@@ -25,7 +25,7 @@ use crate::{
     install::{create_install_context, perform_installation},
     state::AppState,
     update::perform_update,
-    utils::{display_settings, icon_or, Colored, Icons},
+    utils::{display_settings, get_package_hooks, icon_or, Colored, Icons},
 };
 
 /// Result of comparing declared packages vs installed packages
@@ -547,8 +547,12 @@ async fn execute_apply(state: &AppState, diff: ApplyDiff, no_verify: bool) -> So
         info!("\nRemoving {} package(s)...", diff.to_remove.len());
 
         for pkg in diff.to_remove {
+            // Look up hooks from packages config (may not exist for pruned packages)
+            let (hooks, sandbox) = get_package_hooks(&pkg.pkg_name);
             match PackageRemover::new(pkg.clone(), diesel_db.clone())
                 .await
+                .with_hooks(hooks)
+                .with_sandbox(sandbox)
                 .remove()
                 .await
             {

crates/soar-cli/src/health.rs

@@ -17,7 +17,7 @@ use tracing::info;
 
 use crate::{
     state::AppState,
-    utils::{icon_or, term_width, Colored, Icons},
+    utils::{get_package_hooks, icon_or, term_width, Colored, Icons},
 };
 
 pub async fn display_health() -> SoarResult<()> {
@@ -156,8 +156,12 @@ pub async fn remove_broken_packages() -> SoarResult<()> {
     for package in broken_packages {
         let pkg_name = package.pkg_name.clone();
         let pkg_id = package.pkg_id.clone();
+        let (hooks, sandbox) = get_package_hooks(&pkg_name);
         let installed_pkg = package.into();
-        let remover = PackageRemover::new(installed_pkg, diesel_db.clone()).await;
+        let remover = PackageRemover::new(installed_pkg, diesel_db.clone())
+            .await
+            .with_hooks(hooks)
+            .with_sandbox(sandbox);
         remover.remove().await?;
 
         info!("Removed {}#{}", pkg_name, pkg_id);

crates/soar-cli/src/remove.rs

@@ -8,7 +8,7 @@ use tracing::{debug, error, info, trace, warn};
 
 use crate::{
     state::AppState,
-    utils::{confirm_action, select_package_interactively, Colored},
+    utils::{confirm_action, get_package_hooks, select_package_interactively, Colored},
 };
 
 pub async fn remove_packages(packages: &[String], yes: bool, all: bool) -> SoarResult<()> {
@@ -55,7 +55,11 @@ pub async fn remove_packages(packages: &[String], yes: bool, all: bool) -> SoarR
                     pkg_id = pkg.pkg_id,
                     "removing package variant"
                 );
-                let remover = PackageRemover::new(pkg.clone(), diesel_db.clone()).await;
+                let (hooks, sandbox) = get_package_hooks(&pkg.pkg_name);
+                let remover = PackageRemover::new(pkg.clone(), diesel_db.clone())
+                    .await
+                    .with_hooks(hooks)
+                    .with_sandbox(sandbox);
                 remover.remove().await?;
 
                 info!(
@@ -154,7 +158,11 @@ pub async fn remove_packages(packages: &[String], yes: bool, all: bool) -> SoarR
                         pkg_id = pkg.pkg_id,
                         "removing package"
                     );
-                    let remover = PackageRemover::new(pkg.clone(), diesel_db.clone()).await;
+                    let (hooks, sandbox) = get_package_hooks(&pkg.pkg_name);
+                    let remover = PackageRemover::new(pkg.clone(), diesel_db.clone())
+                        .await
+                        .with_hooks(hooks)
+                        .with_sandbox(sandbox);
                     remover.remove().await?;
 
                     info!(
@@ -218,7 +226,11 @@ pub async fn remove_packages(packages: &[String], yes: bool, all: bool) -> SoarR
                 installed_path = installed_pkg.installed_path,
                 "removing package"
             );
-            let remover = PackageRemover::new(installed_pkg.clone(), diesel_db.clone()).await;
+            let (hooks, sandbox) = get_package_hooks(&installed_pkg.pkg_name);
+            let remover = PackageRemover::new(installed_pkg.clone(), diesel_db.clone())
+                .await
+                .with_hooks(hooks)
+                .with_sandbox(sandbox);
             remover.remove().await?;
 
             info!(

crates/soar-cli/src/utils.rs

@@ -12,7 +12,9 @@ use indicatif::HumanBytes;
 use nu_ansi_term::Color::{self, Blue, Cyan, Green, LightRed, Magenta, Red};
 use serde::Serialize;
 use soar_config::{
-    config::get_config, display::DisplaySettings, packages::BinaryMapping,
+    config::get_config,
+    display::DisplaySettings,
+    packages::{BinaryMapping, PackageHooks, PackagesConfig, SandboxConfig},
     repository::get_platform_repositories,
 };
 use soar_core::{
@@ -520,3 +522,19 @@ pub fn parse_default_repos_arg(arg: &str) -> SoarResult<String> {
         )))
     }
 }
+
+/// Look up hooks and sandbox configuration for a package from packages.toml.
+/// Returns (None, None) if packages.toml doesn't exist or the package isn't found.
+pub fn get_package_hooks(pkg_name: &str) -> (Option<PackageHooks>, Option<SandboxConfig>) {
+    let config = match PackagesConfig::load(None) {
+        Ok(c) => c,
+        Err(_) => return (None, None),
+    };
+
+    config
+        .resolved_packages()
+        .into_iter()
+        .find(|p| p.name == pkg_name)
+        .map(|p| (p.hooks, p.sandbox))
+        .unwrap_or((None, None))
+}

crates/soar-core/src/package/hooks.rs

@@ -0,0 +1,88 @@
+use std::path::Path;
+
+use soar_config::{config::get_config, packages::SandboxConfig};
+use tracing::{debug, warn};
+
+use crate::{error::ErrorContext, sandbox, SoarError, SoarResult};
+
+/// Environment variables passed to hook commands.
+pub struct HookEnv<'a> {
+    pub install_dir: &'a Path,
+    pub pkg_name: &'a str,
+    pub pkg_id: &'a str,
+    pub pkg_version: &'a str,
+}
+
+/// Run a hook command with environment variables set.
+///
+/// This is the shared hook execution logic used by both package installation
+/// and removal operations.
+pub fn run_hook(
+    hook_name: &str,
+    command: &str,
+    env: &HookEnv,
+    sandbox_config: Option<&SandboxConfig>,
+) -> SoarResult<()> {
+    debug!("running {} hook: {}", hook_name, command);
+
+    let bin_dir = get_config().get_bin_path()?;
+
+    let env_vars: Vec<(&str, &str)> = vec![
+        ("INSTALL_DIR", env.install_dir.to_str().unwrap_or("")),
+        ("BIN_DIR", bin_dir.to_str().unwrap_or("")),
+        ("PKG_NAME", env.pkg_name),
+        ("PKG_ID", env.pkg_id),
+        ("PKG_VERSION", env.pkg_version),
+    ];
+
+    let status = if sandbox::is_landlock_supported() {
+        debug!("running {} hook with Landlock sandbox", hook_name);
+        let mut cmd = sandbox::SandboxedCommand::new(command)
+            .working_dir(env.install_dir)
+            .read_path(&bin_dir)
+            .envs(env_vars);
+
+        if let Some(s) = sandbox_config {
+            let config = sandbox::SandboxConfig::new().with_network(if s.network {
+                sandbox::NetworkConfig::allow_all()
+            } else {
+                sandbox::NetworkConfig::default()
+            });
+            cmd = cmd.config(config);
+            for path in &s.fs_read {
+                cmd = cmd.read_path(path);
+            }
+            for path in &s.fs_write {
+                cmd = cmd.write_path(path);
+            }
+        }
+        cmd.run()?
+    } else {
+        use std::process::Command;
+        warn!(
+            "Landlock not supported, running {} hook without sandbox",
+            hook_name
+        );
+        Command::new("sh")
+            .arg("-c")
+            .arg(command)
+            .env("INSTALL_DIR", env.install_dir)
+            .env("BIN_DIR", &bin_dir)
+            .env("PKG_NAME", env.pkg_name)
+            .env("PKG_ID", env.pkg_id)
+            .env("PKG_VERSION", env.pkg_version)
+            .current_dir(env.install_dir)
+            .status()
+            .with_context(|| format!("executing {} hook", hook_name))?
+    };
+
+    if !status.success() {
+        return Err(SoarError::Custom(format!(
+            "{} hook failed with exit code: {}",
+            hook_name,
+            status.code().unwrap_or(-1)
+        )));
+    }
+
+    Ok(())
+}

crates/soar-core/src/package/install.rs

@@ -210,70 +210,16 @@ impl PackageInstaller {
 
     /// Run a hook command with environment variables set.
     fn run_hook(&self, hook_name: &str, command: &str) -> SoarResult<()> {
-        use crate::sandbox;
-
-        debug!("running {} hook: {}", hook_name, command);
-
-        let bin_dir = get_config().get_bin_path()?;
+        use super::hooks::{run_hook, HookEnv};
 
-        let env_vars: Vec<(&str, &str)> = vec![
-            ("INSTALL_DIR", self.install_dir.to_str().unwrap_or("")),
-            ("BIN_DIR", bin_dir.to_str().unwrap_or("")),
-            ("PKG_NAME", &self.package.pkg_name),
-            ("PKG_ID", &self.package.pkg_id),
-            ("PKG_VERSION", &self.package.version),
-        ];
-
-        let status = if sandbox::is_landlock_supported() {
-            debug!("running {} hook with Landlock sandbox", hook_name);
-            let mut cmd = sandbox::SandboxedCommand::new(command)
-                .working_dir(&self.install_dir)
-                .read_path(&bin_dir)
-                .envs(env_vars);
-
-            if let Some(s) = &self.sandbox {
-                let config = sandbox::SandboxConfig::new().with_network(if s.network {
-                    sandbox::NetworkConfig::allow_all()
-                } else {
-                    sandbox::NetworkConfig::default()
-                });
-                cmd = cmd.config(config);
-                for path in &s.fs_read {
-                    cmd = cmd.read_path(path);
-                }
-                for path in &s.fs_write {
-                    cmd = cmd.write_path(path);
-                }
-            }
-            cmd.run()?
-        } else {
-            use std::process::Command;
-            warn!(
-                "Landlock not supported, running {} hook without sandbox",
-                hook_name
-            );
-            Command::new("sh")
-                .arg("-c")
-                .arg(command)
-                .env("INSTALL_DIR", &self.install_dir)
-                .env("BIN_DIR", &bin_dir)
-                .env("PKG_NAME", &self.package.pkg_name)
-                .env("PKG_ID", &self.package.pkg_id)
-                .env("PKG_VERSION", &self.package.version)
-                .current_dir(&self.install_dir)
-                .status()
-                .with_context(|| format!("executing {} hook", hook_name))?
+        let env = HookEnv {
+            install_dir: &self.install_dir,
+            pkg_name: &self.package.pkg_name,
+            pkg_id: &self.package.pkg_id,
+            pkg_version: &self.package.version,
         };
 
-        if !status.success() {
-            return Err(SoarError::Custom(format!(
-                "{} hook failed with exit code: {}",
-                hook_name,
-                status.code().unwrap_or(-1)
-            )));
-        }
-
-        Ok(())
+        run_hook(hook_name, command, &env, self.sandbox.as_ref())
     }
 
     /// Run post_download hook if configured.

crates/soar-core/src/package/mod.rs

@@ -1,3 +1,4 @@
+pub mod hooks;
 pub mod install;
 pub mod query;
 pub mod remote_update;

crates/soar-core/src/package/remove.rs

@@ -4,11 +4,16 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use soar_config::config::get_config;
+use soar_config::{
+    config::get_config,
+    packages::{PackageHooks, SandboxConfig},
+};
 use soar_db::{models::types::ProvideStrategy, repository::core::CoreRepository};
 use soar_utils::{error::FileSystemResult, fs::walk_dir, path::desktop_dir};
 use tracing::{debug, trace, warn};
 
+use super::hooks::{run_hook, HookEnv};
+
 /// Formats bytes into human-readable string (e.g., "1.5 MiB")
 fn format_size(bytes: u64) -> String {
     const KIB: u64 = 1024;
@@ -35,6 +40,8 @@ use crate::{
 pub struct PackageRemover {
     package: InstalledPackage,
     db: DieselDatabase,
+    hooks: Option<PackageHooks>,
+    sandbox: Option<SandboxConfig>,
 }
 
 impl PackageRemover {
@@ -47,9 +54,47 @@ impl PackageRemover {
         Self {
             package,
             db,
+            hooks: None,
+            sandbox: None,
         }
     }
 
+    /// Set hooks configuration for the package removal.
+    pub fn with_hooks(mut self, hooks: Option<PackageHooks>) -> Self {
+        self.hooks = hooks;
+        self
+    }
+
+    /// Set sandbox configuration for hook execution.
+    pub fn with_sandbox(mut self, sandbox: Option<SandboxConfig>) -> Self {
+        self.sandbox = sandbox;
+        self
+    }
+
+    /// Run a hook command with environment variables set.
+    fn run_hook(&self, hook_name: &str, command: &str) -> SoarResult<()> {
+        let install_dir = PathBuf::from(&self.package.installed_path);
+        let env = HookEnv {
+            install_dir: &install_dir,
+            pkg_name: &self.package.pkg_name,
+            pkg_id: &self.package.pkg_id,
+            pkg_version: &self.package.version,
+        };
+
+        run_hook(hook_name, command, &env, self.sandbox.as_ref())
+    }
+
+    /// Run pre_remove hook if configured.
+    /// This should be called before any file deletions during package removal.
+    pub fn run_pre_remove_hook(&self) -> SoarResult<()> {
+        if let Some(ref hooks) = self.hooks {
+            if let Some(ref cmd) = hooks.pre_remove {
+                self.run_hook("pre_remove", cmd)?;
+            }
+        }
+        Ok(())
+    }
+
     pub async fn remove(&self) -> SoarResult<()> {
         debug!(
             pkg_name = self.package.pkg_name,
@@ -63,6 +108,9 @@ impl PackageRemover {
             self.package.repo_name,
             self.package.version
         );
+
+        self.run_pre_remove_hook()?;
+
         // Track removed symlinks for logging
         let mut removed_symlinks: Vec<PathBuf> = Vec::new();