codineer_plugins/

manager.rs

use std::collections::BTreeSet;
use std::fs;
use std::path::PathBuf;

use serde_json::Value;

use crate::constants::{
    BUNDLED_MARKETPLACE, EXTERNAL_MARKETPLACE, REGISTRY_FILE_NAME, SETTINGS_FILE_NAME,
};
use crate::definition::{builtin_plugins, load_plugin_definition};
use crate::error::PluginError;
use crate::install::{
    copy_dir_all, describe_install_source, discover_plugin_dirs, ensure_object, materialize_source,
    parse_install_source, plugin_id, resolve_local_source, sanitize_plugin_id, unix_time_ms,
    update_settings_json,
};
use crate::manifest::{load_plugin_from_directory, plugin_manifest_path};
use crate::types::{
    InstallOutcome, InstalledPluginRecord, InstalledPluginRegistry, Plugin, PluginDefinition,
    PluginHooks, PluginInstallSource, PluginKind, PluginManager, PluginManagerConfig,
    PluginManifest, PluginMetadata, PluginRegistry, PluginSummary, PluginTool, RegisteredPlugin,
    UpdateOutcome,
};

impl PluginManager {
    #[must_use]
    pub fn new(config: PluginManagerConfig) -> Self {
        Self { config }
    }

    #[must_use]
    pub fn install_root(&self) -> PathBuf {
        self.config
            .install_root
            .clone()
            .unwrap_or_else(|| self.config.config_home.join("plugins"))
    }

    #[must_use]
    pub fn registry_path(&self) -> PathBuf {
        self.config.registry_path.clone().unwrap_or_else(|| {
            self.config
                .config_home
                .join("plugins")
                .join(REGISTRY_FILE_NAME)
        })
    }

    #[must_use]
    pub fn settings_path(&self) -> PathBuf {
        self.config.config_home.join(SETTINGS_FILE_NAME)
    }

    pub fn plugin_registry(&self) -> Result<PluginRegistry, PluginError> {
        Ok(PluginRegistry::new(
            self.discover_plugins()?
                .into_iter()
                .map(|plugin| {
                    let enabled = self.is_enabled(plugin.metadata());
                    RegisteredPlugin::new(plugin, enabled)
                })
                .collect(),
        ))
    }

    pub fn list_plugins(&self) -> Result<Vec<PluginSummary>, PluginError> {
        Ok(self.plugin_registry()?.summaries())
    }

    pub fn list_installed_plugins(&self) -> Result<Vec<PluginSummary>, PluginError> {
        Ok(self.installed_plugin_registry()?.summaries())
    }

    pub fn discover_plugins(&self) -> Result<Vec<PluginDefinition>, PluginError> {
        self.sync_bundled_plugins()?;
        let mut plugins = builtin_plugins();
        plugins.extend(self.discover_installed_plugins()?);
        plugins.extend(self.discover_external_directory_plugins(&plugins)?);
        Ok(plugins)
    }

    pub fn aggregated_hooks(&self) -> Result<PluginHooks, PluginError> {
        self.plugin_registry()?.aggregated_hooks()
    }

    pub fn aggregated_tools(&self) -> Result<Vec<PluginTool>, PluginError> {
        self.plugin_registry()?.aggregated_tools()
    }

    pub fn validate_plugin_source(&self, source: &str) -> Result<PluginManifest, PluginError> {
        let path = resolve_local_source(source)?;
        load_plugin_from_directory(&path)
    }

    pub fn install(&mut self, source: &str) -> Result<InstallOutcome, PluginError> {
        let install_source = parse_install_source(source)?;
        let temp_root = self.install_root().join(".tmp");
        let staged_source = materialize_source(&install_source, &temp_root)?;
        let cleanup_source = matches!(install_source, PluginInstallSource::GitUrl { .. });
        let manifest = load_plugin_from_directory(&staged_source)?;

        let plugin_id = plugin_id(&manifest.name, EXTERNAL_MARKETPLACE);
        let install_path = self.install_root().join(sanitize_plugin_id(&plugin_id));
        if install_path.exists() {
            fs::remove_dir_all(&install_path)?;
        }
        copy_dir_all(&staged_source, &install_path)?;
        if cleanup_source {
            let _ = fs::remove_dir_all(&staged_source);
        }

        let now = unix_time_ms();
        let record = InstalledPluginRecord {
            kind: PluginKind::External,
            id: plugin_id.clone(),
            name: manifest.name,
            version: manifest.version.clone(),
            description: manifest.description,
            install_path: install_path.clone(),
            source: install_source,
            installed_at_unix_ms: now,
            updated_at_unix_ms: now,
        };

        let mut registry = self.load_registry()?;
        registry.plugins.insert(plugin_id.clone(), record);
        self.store_registry(&registry)?;
        self.write_enabled_state(&plugin_id, Some(true))?;
        self.config.enabled_plugins.insert(plugin_id.clone(), true);

        Ok(InstallOutcome {
            plugin_id,
            version: manifest.version,
            install_path,
        })
    }

    pub fn enable(&mut self, plugin_id: &str) -> Result<(), PluginError> {
        self.ensure_known_plugin(plugin_id)?;
        self.write_enabled_state(plugin_id, Some(true))?;
        self.config
            .enabled_plugins
            .insert(plugin_id.to_string(), true);
        Ok(())
    }

    pub fn disable(&mut self, plugin_id: &str) -> Result<(), PluginError> {
        self.ensure_known_plugin(plugin_id)?;
        self.write_enabled_state(plugin_id, Some(false))?;
        self.config
            .enabled_plugins
            .insert(plugin_id.to_string(), false);
        Ok(())
    }

    pub fn uninstall(&mut self, plugin_id: &str) -> Result<(), PluginError> {
        let mut registry = self.load_registry()?;
        let record = registry.plugins.remove(plugin_id).ok_or_else(|| {
            PluginError::NotFound(format!("plugin `{plugin_id}` is not installed"))
        })?;
        if record.kind == PluginKind::Bundled {
            registry.plugins.insert(plugin_id.to_string(), record);
            return Err(PluginError::CommandFailed(format!(
                "plugin `{plugin_id}` is bundled and managed automatically; disable it instead"
            )));
        }
        if record.install_path.exists() {
            fs::remove_dir_all(&record.install_path)?;
        }
        self.store_registry(&registry)?;
        self.write_enabled_state(plugin_id, None)?;
        self.config.enabled_plugins.remove(plugin_id);
        Ok(())
    }

    pub fn update(&mut self, plugin_id: &str) -> Result<UpdateOutcome, PluginError> {
        let mut registry = self.load_registry()?;
        let record = registry.plugins.get(plugin_id).cloned().ok_or_else(|| {
            PluginError::NotFound(format!("plugin `{plugin_id}` is not installed"))
        })?;

        let temp_root = self.install_root().join(".tmp");
        let staged_source = materialize_source(&record.source, &temp_root)?;
        let cleanup_source = matches!(record.source, PluginInstallSource::GitUrl { .. });
        let manifest = load_plugin_from_directory(&staged_source)?;

        if record.install_path.exists() {
            fs::remove_dir_all(&record.install_path)?;
        }
        copy_dir_all(&staged_source, &record.install_path)?;
        if cleanup_source {
            let _ = fs::remove_dir_all(&staged_source);
        }

        let updated_record = InstalledPluginRecord {
            version: manifest.version.clone(),
            description: manifest.description,
            updated_at_unix_ms: unix_time_ms(),
            ..record.clone()
        };
        registry
            .plugins
            .insert(plugin_id.to_string(), updated_record);
        self.store_registry(&registry)?;

        Ok(UpdateOutcome {
            plugin_id: plugin_id.to_string(),
            old_version: record.version,
            new_version: manifest.version,
            install_path: record.install_path,
        })
    }

    fn discover_installed_plugins(&self) -> Result<Vec<PluginDefinition>, PluginError> {
        let mut registry = self.load_registry()?;
        let mut plugins = Vec::new();
        let mut seen_ids = BTreeSet::<String>::new();
        let mut seen_paths = BTreeSet::<PathBuf>::new();
        let mut stale_registry_ids = Vec::new();

        for install_path in discover_plugin_dirs(&self.install_root())? {
            let matched_record = registry
                .plugins
                .values()
                .find(|record| record.install_path == install_path);
            let kind = matched_record.map_or(PluginKind::External, |record| record.kind);
            let source = matched_record.map_or_else(
                || install_path.display().to_string(),
                |record| describe_install_source(&record.source),
            );
            let plugin = load_plugin_definition(&install_path, kind, source, kind.marketplace())?;
            if seen_ids.insert(plugin.metadata().id.clone()) {
                seen_paths.insert(install_path);
                plugins.push(plugin);
            }
        }

        for record in registry.plugins.values() {
            if seen_paths.contains(&record.install_path) {
                continue;
            }
            if !record.install_path.exists() || plugin_manifest_path(&record.install_path).is_err()
            {
                stale_registry_ids.push(record.id.clone());
                continue;
            }
            let plugin = load_plugin_definition(
                &record.install_path,
                record.kind,
                describe_install_source(&record.source),
                record.kind.marketplace(),
            )?;
            if seen_ids.insert(plugin.metadata().id.clone()) {
                seen_paths.insert(record.install_path.clone());
                plugins.push(plugin);
            }
        }

        if !stale_registry_ids.is_empty() {
            for plugin_id in stale_registry_ids {
                registry.plugins.remove(&plugin_id);
            }
            self.store_registry(&registry)?;
        }

        Ok(plugins)
    }

    fn discover_external_directory_plugins(
        &self,
        existing_plugins: &[PluginDefinition],
    ) -> Result<Vec<PluginDefinition>, PluginError> {
        let mut plugins = Vec::new();

        for directory in &self.config.external_dirs {
            for root in discover_plugin_dirs(directory)? {
                let plugin = load_plugin_definition(
                    &root,
                    PluginKind::External,
                    root.display().to_string(),
                    EXTERNAL_MARKETPLACE,
                )?;
                if existing_plugins
                    .iter()
                    .chain(plugins.iter())
                    .all(|existing| existing.metadata().id != plugin.metadata().id)
                {
                    plugins.push(plugin);
                }
            }
        }

        Ok(plugins)
    }

    fn installed_plugin_registry(&self) -> Result<PluginRegistry, PluginError> {
        self.sync_bundled_plugins()?;
        Ok(PluginRegistry::new(
            self.discover_installed_plugins()?
                .into_iter()
                .map(|plugin| {
                    let enabled = self.is_enabled(plugin.metadata());
                    RegisteredPlugin::new(plugin, enabled)
                })
                .collect(),
        ))
    }

    fn sync_bundled_plugins(&self) -> Result<(), PluginError> {
        let install_root = self.install_root();
        let mut registry = self.load_registry()?;
        let mut changed = false;
        let mut active_ids = BTreeSet::new();

        if let Some(ref bundled_root) = self.config.bundled_root {
            for source_root in discover_plugin_dirs(bundled_root)? {
                let manifest = load_plugin_from_directory(&source_root)?;
                let source = PluginInstallSource::LocalPath {
                    path: source_root.clone(),
                };
                self.sync_one_bundled(
                    &manifest.name,
                    &manifest.version,
                    &manifest.description,
                    &install_root,
                    &mut registry,
                    &mut active_ids,
                    &mut changed,
                    |dest| copy_dir_all(&source_root, dest),
                    source,
                )?;
            }
        } else {
            use crate::bundled::BUNDLED_PLUGINS;
            for bp in BUNDLED_PLUGINS {
                self.sync_one_bundled(
                    bp.name,
                    bp.version,
                    bp.description,
                    &install_root,
                    &mut registry,
                    &mut active_ids,
                    &mut changed,
                    |dest| bp.materialize(dest).map_err(PluginError::Io),
                    PluginInstallSource::Embedded,
                )?;
            }
        }

        // Prune bundled entries no longer present in the source set.
        let stale: Vec<String> = registry
            .plugins
            .iter()
            .filter_map(|(id, r)| {
                (r.kind == PluginKind::Bundled && !active_ids.contains(id)).then_some(id.clone())
            })
            .collect();
        for id in stale {
            if let Some(r) = registry.plugins.remove(&id) {
                if r.install_path.exists() {
                    fs::remove_dir_all(&r.install_path)?;
                }
                changed = true;
            }
        }

        if changed {
            self.store_registry(&registry)?;
        }
        Ok(())
    }

    #[allow(clippy::too_many_arguments)]
    fn sync_one_bundled(
        &self,
        name: &str,
        version: &str,
        description: &str,
        install_root: &std::path::Path,
        registry: &mut InstalledPluginRegistry,
        active_ids: &mut BTreeSet<String>,
        changed: &mut bool,
        write_files: impl FnOnce(&std::path::Path) -> Result<(), PluginError>,
        source: PluginInstallSource,
    ) -> Result<(), PluginError> {
        let pid = plugin_id(name, BUNDLED_MARKETPLACE);
        active_ids.insert(pid.clone());
        let install_path = install_root.join(sanitize_plugin_id(&pid));
        let now = unix_time_ms();
        let existing = registry.plugins.get(&pid);
        let installed_ok =
            install_path.exists() && load_plugin_from_directory(&install_path).is_ok();
        let needs_sync = existing.is_none_or(|r| {
            r.kind != PluginKind::Bundled
                || r.version != version
                || r.name != name
                || r.description != description
                || r.install_path != install_path
                || !r.install_path.exists()
                || !installed_ok
        });
        if !needs_sync {
            return Ok(());
        }

        if install_path.exists() {
            fs::remove_dir_all(&install_path)?;
        }
        write_files(&install_path)?;
        let manifest = load_plugin_from_directory(&install_path)?;

        let installed_at = existing.map_or(now, |r| r.installed_at_unix_ms);
        registry.plugins.insert(
            pid.clone(),
            InstalledPluginRecord {
                kind: PluginKind::Bundled,
                id: pid,
                name: manifest.name,
                version: manifest.version,
                description: manifest.description,
                install_path,
                source,
                installed_at_unix_ms: installed_at,
                updated_at_unix_ms: now,
            },
        );
        *changed = true;
        Ok(())
    }

    fn is_enabled(&self, metadata: &PluginMetadata) -> bool {
        self.config
            .enabled_plugins
            .get(&metadata.id)
            .copied()
            .unwrap_or(match metadata.kind {
                PluginKind::External => false,
                PluginKind::Builtin | PluginKind::Bundled => metadata.default_enabled,
            })
    }

    fn ensure_known_plugin(&self, plugin_id: &str) -> Result<(), PluginError> {
        if self.plugin_registry()?.contains(plugin_id) {
            Ok(())
        } else {
            Err(PluginError::NotFound(format!(
                "plugin `{plugin_id}` is not installed or discoverable"
            )))
        }
    }

    pub(crate) fn load_registry(&self) -> Result<InstalledPluginRegistry, PluginError> {
        let path = self.registry_path();
        match fs::read_to_string(&path) {
            Ok(contents) if contents.trim().is_empty() => Ok(InstalledPluginRegistry::default()),
            Ok(contents) => Ok(serde_json::from_str(&contents)?),
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                Ok(InstalledPluginRegistry::default())
            }
            Err(error) => Err(PluginError::Io(error)),
        }
    }

    pub(crate) fn store_registry(
        &self,
        registry: &InstalledPluginRegistry,
    ) -> Result<(), PluginError> {
        let path = self.registry_path();
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent)?;
        }
        fs::write(path, serde_json::to_string_pretty(registry)?)?;
        Ok(())
    }

    pub(crate) fn write_enabled_state(
        &self,
        plugin_id: &str,
        enabled: Option<bool>,
    ) -> Result<(), PluginError> {
        update_settings_json(&self.settings_path(), |root| {
            let enabled_plugins = ensure_object(root, "enabledPlugins");
            match enabled {
                Some(value) => {
                    enabled_plugins.insert(plugin_id.to_string(), Value::Bool(value));
                }
                None => {
                    enabled_plugins.remove(plugin_id);
                }
            }
        })
    }
}