zoi_uninstall/

lib.rs

//! Uninstallation logic for Zoi packages.
//!
//! This crate handles the safe removal of packages, including cleaning up
//! binaries, completion scripts, service units, and dependency management.

/// Logic for automatically removing unused dependencies.
pub mod autoremove;

use std::fs;
use std::io::Write;
use std::path::PathBuf;

use anyhow::anyhow;
use colored::Colorize;
use mlua::Lua;
use zoi_core::{recorder, sysroot, types, utils as core_utils};
use zoi_db as db;
use zoi_deps as dependencies;
use zoi_hooks as hooks;
use zoi_resolver::{local, resolve};
use zoi_telemetry as telemetry;

/// Gets the root directory for binaries based on the installation scope.
fn get_bin_root(scope: types::Scope) -> anyhow::Result<PathBuf> {
    match scope {
        types::Scope::User => core_utils::get_user_bin_dir(),
        types::Scope::System => Ok(core_utils::get_system_bin_dir()),
        types::Scope::Project => {
            let current_dir = std::env::current_dir()?;
            Ok(current_dir.join(".zoi").join("pkgs").join("bin"))
        }
    }
}

/// Gets the root directory for shell completions based on the scope and shell
/// type.
fn get_completions_root(
    scope: types::Scope,
    shell: &str
) -> anyhow::Result<PathBuf> {
    match scope {
        types::Scope::User => core_utils::get_user_completions_dir(shell),
        types::Scope::System => {
            if cfg!(target_os = "windows") {
                Ok(sysroot::apply_sysroot(PathBuf::from(format!(
                    "C:\\ProgramData\\zoi\\pkgs\\shell\\{shell}",
                ))))
            } else {
                let base = match shell {
                    "bash" => "/usr/share/bash-completion/completions",
                    "zsh" => "/usr/share/zsh/site-functions",
                    "fish" => "/usr/share/fish/vendor_completions.d",
                    "elvish" => "/usr/share/elvish/lib",
                    _ => "/usr/local/share/zoi/completions"
                };
                Ok(sysroot::apply_sysroot(PathBuf::from(base)))
            }
        }
        types::Scope::Project => {
            let current_dir = std::env::current_dir()?;
            Ok(current_dir
                .join(".zoi")
                .join("pkgs")
                .join("shell")
                .join(shell))
        }
    }
}

/// Cleans up service unit files or Windows services associated with a package.
fn cleanup_service(
    package_name: &str,
    scope: types::Scope
) -> anyhow::Result<()> {
    let service_name = format!("zoi-{package_name}");
    let is_user = scope != types::Scope::System;

    match std::env::consts::OS {
        "linux" => {
            let unit_path = if is_user {
                let home = core_utils::get_user_home()
                    .ok_or_else(|| anyhow!("Could not find home directory"))?;
                sysroot::apply_sysroot(
                    home.join(".config/systemd/user")
                        .join(format!("{service_name}.service"))
                )
            } else {
                sysroot::apply_sysroot(PathBuf::from(format!(
                    "/etc/systemd/system/{service_name}.service",
                )))
            };
            if unit_path.exists() {
                println!("Removing service unit file: {}", unit_path.display());
                fs::remove_file(&unit_path).map_err(|e| {
                    anyhow!(
                        "Failed to remove unit file: {}: {}",
                        unit_path.display(),
                        e
                    )
                })?;
                if std::env::var("ZOI_TEST_SKIP_SERVICE_COMMANDS").is_err() {
                    let mut cmd = std::process::Command::new("systemctl");
                    if is_user {
                        cmd.arg("--user");
                    }
                    cmd.arg("daemon-reload").status().map_err(|e| {
                        anyhow!("Failed to run systemctl daemon-reload: {e}")
                    })?;
                }
            }
        }
        "macos" => {
            let plist_path = if is_user {
                let home = core_utils::get_user_home()
                    .ok_or_else(|| anyhow!("Could not find home directory"))?;
                sysroot::apply_sysroot(
                    home.join("Library/LaunchAgents")
                        .join(format!("{service_name}.plist"))
                )
            } else {
                sysroot::apply_sysroot(PathBuf::from(format!(
                    "/Library/LaunchDaemons/{service_name}.plist",
                )))
            };
            if plist_path.exists() {
                println!(
                    "Removing service plist file: {}",
                    plist_path.display()
                );
                fs::remove_file(&plist_path).map_err(|e| {
                    anyhow!(
                        "Failed to remove plist file: {}: {}",
                        plist_path.display(),
                        e
                    )
                })?;
            }
        }
        "windows" => {
            let exists = {
                let output = std::process::Command::new("sc")
                    .arg("query")
                    .arg(&service_name)
                    .output()
                    .map_err(|e| anyhow!("Failed to run sc query: {e}"))?;
                output.status.success()
            };
            if std::env::var("ZOI_TEST_SKIP_SERVICE_COMMANDS").is_err()
                && exists
            {
                println!("Removing Windows service: {service_name}");
                std::process::Command::new("sc")
                    .arg("delete")
                    .arg(&service_name)
                    .status()
                    .map_err(|e| anyhow!("Failed to run sc delete: {e}"))?;
            }
        }
        _ => {}
    }

    Ok(())
}

/// Uninstalls a collection and its associated dependencies.
fn uninstall_collection(
    pkg: &types::Package,
    manifest: &types::InstallManifest,
    scope: types::Scope,
    registry_handle: Option<&str>,
    yes: bool,
    quiet: bool,
    dry_run: bool
) -> anyhow::Result<types::InstallManifest> {
    if !quiet {
        println!("Uninstalling collection '{}'...", pkg.name.bold());
    }

    if dry_run {
        return Ok(manifest.clone());
    }

    let dependencies_to_uninstall = &manifest.installed_dependencies;

    if dependencies_to_uninstall.is_empty() {
        if !quiet {
            println!("Collection has no dependencies to uninstall.");
        }
    } else {
        if !quiet {
            println!("Uninstalling dependencies of the collection...");
        }
        for dep_str in dependencies_to_uninstall {
            let dep = dependencies::parse_dependency_string(dep_str)?;

            if dep.manager == "zoi" {
                if !quiet {
                    println!(
                        "\n{} Uninstalling zoi dependency: {}...",
                        "::".bold().blue(),
                        dep_str.bold()
                    );
                }
            } else {
                let prompt = format!(
                    "Uninstall native dependency '{}' ({})?",
                    dep.package.cyan(),
                    dep.manager.yellow()
                );
                let warning = "Warning: Zoi cannot track if other non-Zoi \
                               applications depend on this package.";

                if yes {
                    if !quiet {
                        println!(
                            "\n{} Uninstalling native dependency: {}...",
                            "::".bold().blue(),
                            dep_str.bold()
                        );
                        println!("{}: {}", "Note".yellow(), warning);
                    }
                } else if core_utils::ask_for_confirmation(
                    &format!("{}\n   {}", prompt, warning.dimmed()),
                    false
                ) {
                    if !quiet {
                        println!(
                            "\n{} Uninstalling dependency: {}...",
                            "::".bold().blue(),
                            dep_str.bold()
                        );
                    }
                } else {
                    if !quiet {
                        println!(
                            "Skipping uninstallation of native dependency: {}",
                            dep.package.yellow()
                        );
                    }
                    continue;
                }
            }

            if let Err(e) =
                dependencies::uninstall_dependency(dep_str, &move |name| {
                    run(name, Some(scope), yes, quiet, dry_run).map(|_| ())
                })
                && !quiet
            {
                eprintln!(
                    "Warning: Could not uninstall dependency '{dep_str}': {e}"
                );
            }
        }
    }

    let handle = registry_handle.unwrap_or("local");
    let package_dir =
        local::get_package_dir(scope, handle, &pkg.repo, &pkg.name)?;
    if package_dir.exists() {
        let _ = cleanup_service(&pkg.name, scope);
        fs::remove_dir_all(&package_dir)?;
    }
    if let Err(e) = recorder::remove_package_from_record(manifest)
        && !quiet
    {
        eprintln!(
            "{} Failed to remove package from lockfile: {}",
            "Warning:".yellow(),
            e
        );
    }

    if let Ok(conn) = db::open_connection("local") {
        let _ =
            db::delete_package(&conn, &pkg.name, None, &pkg.repo, Some(scope));
    }

    if let Ok(true) = telemetry::posthog_capture_event(
        "uninstall",
        pkg,
        env!("CARGO_PKG_VERSION"),
        registry_handle.unwrap_or("local"),
        None
    ) && !quiet
    {
        println!("{} telemetry sent", "Info:".green());
    }

    Ok(manifest.clone())
}

/// Finds an installed manifest matching the given package request.
fn find_installed_manifest(
    request: &resolve::PackageRequest,
    scope_override: Option<types::Scope>
) -> anyhow::Result<(types::InstallManifest, types::Scope)> {
    let scopes = if let Some(scope) = scope_override {
        vec![scope]
    } else {
        vec![
            types::Scope::Project,
            types::Scope::User,
            types::Scope::System,
        ]
    };

    for scope in scopes {
        let mut matches =
            local::find_installed_manifests_matching(request, scope)?;
        match matches.len() {
            0 => {}
            1 => return Ok((matches.remove(0), scope)),
            _ => {
                return Err(anyhow!(
                    "Package '{}' is ambiguous in {:?} scope. Use an explicit \
                     source like '#handle@repo/name[:sub]@version'.",
                    request.name,
                    scope
                ));
            }
        }
    }

    if scope_override.is_some() {
        Err(anyhow!(
            "Package '{}' is not installed in the specified scope.",
            request.name
        ))
    } else {
        Err(anyhow!(
            "Package '{}' is not installed by Zoi.",
            request.name
        ))
    }
}

/// Loads an installed package definition and its Lua source path from a
/// manifest.
fn load_installed_package(
    manifest: &types::InstallManifest,
    yes: bool
) -> anyhow::Result<(types::Package, PathBuf)> {
    let installed_source_path = local::get_package_source_path(manifest)?;
    if installed_source_path.exists() {
        let path = installed_source_path.to_str().ok_or_else(|| {
            anyhow!("Stored package source path contains invalid UTF-8")
        })?;
        let mut pkg = zoi_lua::parser::parse_lua_package(
            path,
            Some(&manifest.version),
            Some(manifest.scope),
            true
        )?;
        pkg.repo.clone_from(&manifest.repo);
        pkg.scope = manifest.scope;
        pkg.registry_handle = Some(manifest.registry_handle.clone());
        pkg.sub_package.clone_from(&manifest.sub_package);
        return Ok((pkg, installed_source_path));
    }

    let source = local::installed_manifest_source(manifest);
    let (mut pkg, _, _, pkg_lua_path, _, _, _) =
        resolve::resolve_package_and_version(
            &source,
            Some(manifest.scope),
            true,
            yes
        )?;
    pkg.scope = manifest.scope;
    pkg.sub_package.clone_from(&manifest.sub_package);
    Ok((pkg, pkg_lua_path))
}

/// Uninstalls one or more packages from the system.
///
/// This is a complex multi-stage operation:
/// - Dependent Check: Verifies if any other package requires this one (via the
///   `dependents/` directory). Blocks if busy.
/// - Hook Execution: Runs the `pre_remove` hook defined in `.pkg.lua`.
/// - Lua Cleanup: Executes the `uninstall()` function and `zrm` operations.
/// - File Removal: Deletes every file recorded in the package's
///   `InstallManifest`.
/// - Shim/Completion Cleanup: Unlinks binaries and completions if no other
///   package provides them (ref-counting via the database).
///
/// If `recursive` is true, Zoi also attempts to uninstall any dependencies
/// that are no longer needed by any other package.
///
/// # Errors
///
/// Returns an error if:
/// - The package is not found or is ambiguous.
/// - The package has dependents that must be uninstalled first.
/// - Hook execution fails.
/// - File system operations (removal, backup) fail.
/// - Escalation to root fails.
///
/// # Panics
///
/// Panics if internal dependency consistency checks fail.
pub fn run(
    package_name: &str,
    scope_override: Option<types::Scope>,
    yes: bool,
    quiet: bool,
    dry_run: bool
) -> anyhow::Result<types::InstallManifest> {
    let request = resolve::parse_source_string(package_name)?;
    let (manifest, scope) = find_installed_manifest(&request, scope_override)?;
    let sub_package_to_uninstall = manifest.sub_package.clone();
    let registry_handle = Some(manifest.registry_handle.clone());
    let (pkg, pkg_lua_path) = load_installed_package(&manifest, yes)?;

    if pkg.package_type == types::PackageType::Collection {
        return uninstall_collection(
            &pkg,
            &manifest,
            scope,
            registry_handle.as_deref(),
            yes,
            quiet,
            dry_run
        );
    }

    if dry_run {
        return Ok(manifest);
    }

    let handle = manifest.registry_handle.as_str();
    let package_dir =
        local::get_package_dir(scope, handle, &pkg.repo, &pkg.name)?;
    let version_dir = package_dir.join(&manifest.version);

    let dependents = local::get_dependents(&package_dir)?;
    if !dependents.is_empty() {
        return Err(anyhow::anyhow!(
            "Cannot uninstall '{}' because other packages depend on it:\n  \
             -{}\n\nPlease uninstall these packages first.",
            pkg.name,
            dependents.join("\n  - ")
        ));
    }

    let needs_escalation =
        scope == types::Scope::System && !core_utils::is_admin();

    if needs_escalation {
        let escalator =
            core_utils::get_privilege_escalator().ok_or_else(|| {
                anyhow!(
                    "Root privileges required to remove system package, but \
                     neither 'sudo' nor 'doas' was found."
                )
            })?;

        if !quiet {
            println!(
                "{} Escalating to root via {} to remove system package...",
                "::".bold().blue(),
                escalator
            );
        }
        let manifest_json = serde_json::to_string(&manifest)?;
        let mut temp_file = tempfile::NamedTempFile::new()?;
        temp_file.write_all(manifest_json.as_bytes())?;
        let temp_path = temp_file.path();

        let mut cmd = std::process::Command::new(escalator);
        cmd.arg(std::env::current_exe()?);
        cmd.arg("helper").arg("elevate-uninstall");
        cmd.arg("--manifest-json").arg(temp_path);
        if yes {
            cmd.arg("--yes");
        }

        let status = cmd.status().map_err(|e| {
            anyhow::anyhow!("Failed to spawn privilege escalator: {e}")
        })?;
        if !status.success() {
            return Err(anyhow::anyhow!("Escalated uninstallation failed."));
        }
    } else {
        if let Some(hooks) = &pkg.hooks
            && let Err(e) =
                hooks::run_hooks(hooks, hooks::HookType::PreRemove, scope)
        {
            return Err(anyhow::anyhow!("Pre-remove hook failed: {e}"));
        }

        let lua = Lua::new();
        zoi_lua::functions::setup_lua_environment(
            &lua,
            &core_utils::get_platform()?,
            Some(&manifest.version),
            pkg_lua_path.to_str(),
            None,
            None,
            None,
            sub_package_to_uninstall.as_deref(),
            Some(scope),
            None,
            true
        )
        .map_err(|e| anyhow!(e.to_string()))?;
        let lua_code = fs::read_to_string(pkg_lua_path)?;
        lua.load(&lua_code)
            .exec()
            .map_err(|e| anyhow!(e.to_string()))?;

        if let Ok(uninstall_fn) =
            lua.globals().get::<mlua::Function>("uninstall")
        {
            if !quiet {
                println!("Running uninstall() script...");
            }
            uninstall_fn
                .call::<()>(())
                .map_err(|e| anyhow!(e.to_string()))?;
        }

        if let Ok(uninstall_ops) =
            lua.globals().get::<mlua::Table>("__ZoiUninstallOperations")
        {
            for op in uninstall_ops.sequence_values::<mlua::Table>() {
                let op = op.map_err(|e| anyhow!(e.to_string()))?;
                if let Ok(op_type) = op.get::<String>("op")
                    && op_type == "zrm"
                {
                    let mut path_to_remove: String =
                        op.get("path").map_err(|e| anyhow!(e.to_string()))?;

                    path_to_remove = path_to_remove
                        .replace("${pkgstore}", &version_dir.to_string_lossy());

                    if let Some(home_dir) = core_utils::get_user_home() {
                        path_to_remove = path_to_remove
                            .replace("${usrhome}", &home_dir.to_string_lossy());
                    }
                    path_to_remove = path_to_remove.replace(
                        "${usrroot}",
                        &sysroot::apply_sysroot(PathBuf::from("/"))
                            .to_string_lossy()
                    );

                    let path = std::path::PathBuf::from(path_to_remove);
                    if path.exists() {
                        if !quiet {
                            println!("Removing {}...", path.display());
                        }
                        if path.is_dir() {
                            fs::remove_dir_all(path)?;
                        } else {
                            fs::remove_file(path)?;
                        }
                    }
                }
            }
        }

        if let Some(backup_files) = &manifest.backup {
            if !quiet {
                println!("Saving configuration files...");
            }
            for backup_file_rel in backup_files {
                let expanded_path = zoi_core::utils::expand_placeholders(
                    backup_file_rel,
                    &version_dir,
                    manifest.scope
                )?;
                let backup_src = PathBuf::from(expanded_path);

                if backup_src.exists() {
                    let backup_filename = backup_src
                        .file_name()
                        .ok_or_else(|| anyhow!("Invalid backup source name"))?
                        .to_string_lossy();
                    let backup_dest = version_dir
                        .parent()
                        .ok_or_else(|| {
                            anyhow!(
                                "version_dir should have a parent \
                                 (package_dir)"
                            )
                        })?
                        .join(format!("{backup_filename}.zoisave"));

                    if let Some(p) = backup_dest.parent()
                        && let Err(e) = fs::create_dir_all(p)
                    {
                        if !quiet {
                            eprintln!(
                                "Warning: could not create backup directory \
                                 {}: {}",
                                p.display(),
                                e
                            );
                        }
                        continue;
                    }
                    if !quiet {
                        println!(
                            "Saving {} to {}",
                            backup_src.display(),
                            backup_dest.display()
                        );
                    }
                    // Use copy + remove for potential cross-device moves
                    if let Err(e) = fs::copy(&backup_src, &backup_dest) {
                        if !quiet {
                            eprintln!(
                                "Warning: failed to copy backup {}: {}",
                                backup_src.display(),
                                e
                            );
                        }
                    } else {
                        let _ = fs::remove_file(&backup_src);
                    }
                }
            }
        }

        if !quiet {
            println!(
                "Uninstalling '{}'...",
                if let Some(sub) = &manifest.sub_package {
                    format!("{}:{}", pkg.name, sub)
                } else {
                    pkg.name.clone()
                }
                .bold()
            );
        }

        if let Some(bins) = &manifest.bins {
            let bin_root = get_bin_root(scope)?;
            for bin in bins {
                let symlink_path = bin_root.join(bin);
                if symlink_path.is_symlink() || symlink_path.exists() {
                    let other_providers = db::find_provides("local", bin)?;
                    let still_provided =
                        other_providers.iter().any(|(p, _)| {
                            p.name != pkg.name
                                || (p.sub_package != manifest.sub_package)
                        });

                    if still_provided {
                        if !quiet {
                            println!(
                                "Keeping shim for {} as it is still provided \
                                 by other packages.",
                                bin.cyan()
                            );
                        }
                    } else {
                        if !quiet {
                            println!(
                                "Removing shim for {} from {}...",
                                bin.cyan(),
                                symlink_path.display()
                            );
                        }
                        fs::remove_file(&symlink_path)?;
                    }
                }
            }
        } else if manifest.sub_package.is_none() {
            let bin = &pkg.name;
            let symlink_path = get_bin_root(scope)?.join(bin);
            if symlink_path.is_symlink() || symlink_path.exists() {
                let other_providers = db::find_provides("local", bin)?;
                let still_provided = other_providers.iter().any(|(p, _)| {
                    p.name != pkg.name
                        || (p.sub_package != manifest.sub_package)
                });

                if !still_provided {
                    if !quiet {
                        println!(
                            "Removing shim for {} from {}...",
                            bin.cyan(),
                            symlink_path.display()
                        );
                    }
                    fs::remove_file(symlink_path)?;
                }
            }
        }

        if let Some(completions) = &manifest.completions {
            for completion in completions {
                let completions_root =
                    get_completions_root(scope, &completion.shell)?;
                let pkg_dir = completions_root.join(&pkg.name);
                let symlink_path = pkg_dir.join(&completion.filename);
                if symlink_path.is_symlink() || symlink_path.exists() {
                    let other_providers =
                        db::find_provides("local", &completion.filename)?;
                    let still_provided =
                        other_providers.iter().any(|(p, _)| {
                            p.name != pkg.name
                                || (p.sub_package != manifest.sub_package)
                        });

                    if !still_provided {
                        if !quiet {
                            println!(
                                "Removing {} completion for {} from {}...",
                                completion.shell.cyan(),
                                completion.filename.cyan(),
                                symlink_path.display()
                            );
                        }
                        fs::remove_file(&symlink_path)?;
                    } else if !quiet {
                        println!(
                            "Keeping {} completion for {} as it is still \
                             provided by other packages.",
                            completion.shell.cyan(),
                            completion.filename.cyan()
                        );
                    }
                }
            }

            let shells: std::collections::HashSet<String> =
                completions.iter().map(|c| c.shell.clone()).collect();
            for shell_name in shells {
                let pkg_dir =
                    get_completions_root(scope, &shell_name)?.join(&pkg.name);
                if pkg_dir.exists()
                    && fs::read_dir(&pkg_dir)
                        .is_ok_and(|mut e| e.next().is_none())
                {
                    let _ = fs::remove_dir(&pkg_dir);
                }
            }
        }

        let pkg_id_opt = if let Ok(conn) = db::open_connection("local") {
            db::get_package_id(
                &conn,
                &pkg.name,
                manifest.sub_package.as_deref(),
                &pkg.repo,
                handle
            )
            .ok()
        } else {
            None
        };

        for file_path_str in &manifest.installed_files {
            let expanded = core_utils::expand_placeholders(
                file_path_str,
                &version_dir,
                scope
            )?;
            let file_path = PathBuf::from(&expanded);

            if let Some(pkg_id) = pkg_id_opt
                && let Ok(conn) = db::open_connection("local")
                && let Ok(true) =
                    db::has_other_owners(&conn, file_path_str, pkg_id)
            {
                if !quiet {
                    println!(
                        "Keeping {} as it is still owned by other packages.",
                        file_path_str.dimmed()
                    );
                }
                continue;
            }

            // Use symlink_metadata so links are removed even when they dangle
            // or point to a non-empty directory; only the link is deleted.
            let Ok(meta) = fs::symlink_metadata(&file_path) else {
                continue;
            };

            if let Some(pkg_id) = pkg_id_opt
                && let Ok(conn) = db::open_connection("local")
                && let Ok(true) =
                    db::has_other_owners(&conn, file_path_str, pkg_id)
            {
                if !quiet {
                    println!(
                        "Keeping {} as it is still owned by other packages.",
                        file_path_str.dimmed()
                    );
                }
                continue;
            }

            if meta.file_type().is_symlink() {
                let _ = fs::remove_file(&file_path);
            } else if meta.is_dir() {
                // Only remove if empty to be safe
                if fs::read_dir(&file_path)
                    .is_ok_and(|mut e| e.next().is_none())
                {
                    let _ = fs::remove_dir(&file_path);
                }
            } else {
                let _ = fs::remove_file(&file_path);
            }
        }

        let manifest_filename = if let Some(sub) = &sub_package_to_uninstall {
            format!("manifest-{sub}.yaml")
        } else {
            "manifest.yaml".to_string()
        };

        let manifest_path = version_dir.join(manifest_filename);
        if manifest_path.exists() {
            fs::remove_file(manifest_path)?;
        }

        if version_dir.exists() {
            let mut has_other_manifests = false;
            if let Ok(entries) = fs::read_dir(&version_dir) {
                for entry in entries.flatten() {
                    let name = entry.file_name().to_string_lossy().to_string();
                    if name.starts_with("manifest")
                        && std::path::Path::new(&name)
                            .extension()
                            .is_some_and(|ext| ext.eq_ignore_ascii_case("yaml"))
                    {
                        has_other_manifests = true;
                        break;
                    }
                }
            }
            if !has_other_manifests {
                if !quiet {
                    println!(
                        "Removing empty version directory: {}",
                        version_dir.display()
                    );
                }
                fs::remove_dir_all(&version_dir)?;
            }
        }

        if package_dir.exists() {
            let _ = cleanup_service(&pkg.name, scope);
            let mut has_other_versions = false;
            if let Ok(entries) = fs::read_dir(&package_dir) {
                for entry in entries.flatten() {
                    let name = entry.file_name().to_string_lossy().to_string();
                    if name != "latest" && name != "dependents" {
                        has_other_versions = true;
                        break;
                    }
                }
            }
            if !has_other_versions {
                if !quiet {
                    println!(
                        "Removing package store: {}",
                        package_dir.display()
                    );
                }
                fs::remove_dir_all(&package_dir)?;
            }
        }

        let parent_id = format!(
            "#{}@{}/{}@{}",
            manifest.registry_handle,
            manifest.repo,
            manifest.name,
            manifest.version
        );
        for dep_str in &manifest.installed_dependencies {
            if let Ok(dep) = dependencies::parse_dependency_string(dep_str)
                && dep.manager == "zoi"
            {
                let dep_req = resolve::parse_source_string(dep.package)?;
                let dep_matches =
                    local::find_installed_manifests_matching(&dep_req, scope)?;
                if dep_matches.len() == 1 {
                    let dep_manifest =
                        dep_matches.first().expect("Already checked length");
                    match local::get_package_dir(
                        dep_manifest.scope,
                        &dep_manifest.registry_handle,
                        &dep_manifest.repo,
                        &dep_manifest.name
                    ) {
                        Ok(dep_pkg_dir) => {
                            if let Err(e) = local::remove_dependent(
                                &dep_pkg_dir,
                                &parent_id
                            ) && !quiet
                            {
                                eprintln!(
                                    "Warning: failed to remove dependent link \
                                     for {}: {}",
                                    dep.package, e
                                );
                            }
                        }
                        Err(e) => {
                            if !quiet {
                                eprintln!(
                                    "Warning: failed to get package dir for \
                                     {}: {}",
                                    dep.package, e
                                );
                            }
                        }
                    }
                }
            }
        }

        if let Some(hooks) = &pkg.hooks
            && let Err(e) =
                hooks::run_hooks(hooks, hooks::HookType::PostRemove, scope)
            && !quiet
        {
            eprintln!("{} post-remove hook failed: {}", "Warning:".yellow(), e);
        }
    }

    if let Err(e) = recorder::remove_package_from_record(&manifest)
        && !quiet
    {
        eprintln!(
            "{} Failed to remove package from lockfile: {}",
            "Warning:".yellow(),
            e
        );
    }

    if let Ok(conn) = db::open_connection("local") {
        let _ = db::delete_package(
            &conn,
            &pkg.name,
            sub_package_to_uninstall.as_deref(),
            &pkg.repo,
            Some(scope)
        );
    }

    if !quiet {
        println!("Removed manifest for '{}'.", pkg.name);
    }

    if let Ok(true) = telemetry::posthog_capture_event(
        "uninstall",
        &pkg,
        env!("CARGO_PKG_VERSION"),
        &manifest.registry_handle,
        None
    ) && !quiet
    {
        println!("{} telemetry sent", "Info:".green());
    }

    Ok(manifest)
}