systemprompt_cli/commands/core/plugins/

validate.rs

//! `plugins validate` subcommand.
//!
//! Checks one or all plugin `config.yaml` files for parse errors, id/directory
//! mismatches, missing skill references, and missing script sources, returning
//! a per-plugin pass/fail report.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

use anyhow::{Context, Result, anyhow};
use clap::Args;
use std::path::Path;

use crate::CliConfig;
use crate::shared::CommandOutput;

use super::types::{PluginValidateAllOutput, PluginValidateOutput};

#[derive(Debug, Clone, Args)]
pub struct ValidateArgs {
    #[arg(help = "Plugin ID to validate (validates all if omitted)")]
    pub id: Option<String>,
}

pub(super) fn execute(args: ValidateArgs, _config: &CliConfig) -> Result<CommandOutput> {
    let profile = systemprompt_config::ProfileBootstrap::get().context("Failed to get profile")?;
    let plugins_path = std::path::PathBuf::from(profile.paths.plugins());
    let skills_path = std::path::PathBuf::from(profile.paths.skills());

    let plugin_ids = match args.id {
        Some(id) => {
            let plugin_dir = plugins_path.join(&id);
            if !plugin_dir.exists() {
                return Err(anyhow!("Plugin '{}' not found", id));
            }
            vec![id]
        },
        None => collect_plugin_ids(&plugins_path)?,
    };

    let mut results = Vec::new();

    for plugin_id in &plugin_ids {
        let result = validate_plugin(plugin_id, &plugins_path, &skills_path);
        results.push(result);
    }

    let output = PluginValidateAllOutput { results };

    Ok(CommandOutput::table_of(
        vec!["plugin_id", "valid", "errors", "warnings"],
        &output.results,
    )
    .with_title("Plugin Validation Results"))
}

pub fn collect_plugin_ids(plugins_path: &Path) -> Result<Vec<String>> {
    if !plugins_path.exists() {
        return Ok(Vec::new());
    }

    let mut ids = Vec::new();
    for entry in std::fs::read_dir(plugins_path)? {
        let entry = entry?;
        if entry.path().is_dir()
            && entry.path().join("config.yaml").exists()
            && let Some(name) = entry.file_name().to_str()
        {
            ids.push(name.to_owned());
        }
    }
    ids.sort();
    Ok(ids)
}

pub fn validate_plugin(
    plugin_id: &str,
    plugins_path: &Path,
    skills_path: &Path,
) -> PluginValidateOutput {
    let mut errors = Vec::new();
    let mut warnings = Vec::new();

    let config_path = plugins_path.join(plugin_id).join("config.yaml");
    let content = match std::fs::read_to_string(&config_path) {
        Ok(c) => c,
        Err(e) => {
            errors.push(format!("Failed to read config.yaml: {}", e));
            return PluginValidateOutput {
                plugin_id: systemprompt_identifiers::PluginId::new(plugin_id),
                valid: false,
                errors,
                warnings,
            };
        },
    };

    let plugin_file: systemprompt_models::PluginConfigFile = match serde_yaml::from_str(&content) {
        Ok(p) => p,
        Err(e) => {
            errors.push(format!("Failed to parse config.yaml: {}", e));
            return PluginValidateOutput {
                plugin_id: systemprompt_identifiers::PluginId::new(plugin_id),
                valid: false,
                errors,
                warnings,
            };
        },
    };

    let plugin = &plugin_file.plugin;

    if let Err(e) = plugin.validate(plugin_id) {
        errors.push(format!("{}", e));
    }

    if plugin.id != plugin_id {
        warnings.push(format!(
            "Plugin id '{}' does not match directory name '{}'",
            plugin.id, plugin_id
        ));
    }

    validate_skill_refs(plugin, skills_path, &mut errors, &mut warnings);
    validate_scripts(plugin, plugins_path, plugin_id, &mut errors);

    PluginValidateOutput {
        plugin_id: systemprompt_identifiers::PluginId::new(plugin_id),
        valid: errors.is_empty(),
        errors,
        warnings,
    }
}

fn validate_skill_refs(
    plugin: &systemprompt_models::PluginConfig,
    skills_path: &Path,
    errors: &mut Vec<String>,
    warnings: &mut Vec<String>,
) {
    if plugin.skills.source == systemprompt_models::ComponentSource::Explicit {
        let skills = declared_skills(skills_path);
        for skill_id in &plugin.skills.include {
            match skills.get(skill_id.as_str()) {
                None => errors.push(format!(
                    "Referenced skill '{}' does not exist (no skill declares that id)",
                    skill_id
                )),
                Some(false) => warnings.push(format!(
                    "Referenced skill '{}' is disabled and will not be delivered",
                    skill_id
                )),
                Some(true) => {},
            }
        }
    }

    if !skills_path.exists()
        && plugin.skills.source == systemprompt_models::ComponentSource::Instance
    {
        warnings.push("Skills directory does not exist".to_owned());
    }
}

fn declared_skills(skills_path: &Path) -> std::collections::HashMap<String, bool> {
    let mut skills = std::collections::HashMap::new();
    let Ok(entries) = std::fs::read_dir(skills_path) else {
        return skills;
    };
    for entry in entries.flatten() {
        let dir = entry.path();
        if !dir.is_dir() {
            continue;
        }
        let Ok(content) = std::fs::read_to_string(dir.join("config.yaml")) else {
            continue;
        };
        let Ok(config) = serde_yaml::from_str::<systemprompt_models::DiskSkillConfig>(&content)
        else {
            continue;
        };
        let id = if config.id.as_str().is_empty() {
            entry.file_name().to_string_lossy().into_owned()
        } else {
            config.id.as_str().to_owned()
        };
        skills.insert(id, config.enabled);
    }
    skills
}

fn validate_scripts(
    plugin: &systemprompt_models::PluginConfig,
    plugins_path: &Path,
    plugin_id: &str,
    errors: &mut Vec<String>,
) {
    for script in &plugin.scripts {
        let script_path = plugins_path.join(plugin_id).join(&script.source);
        if !script_path.exists() {
            errors.push(format!(
                "Script '{}' not found at {}",
                script.name,
                script_path.display()
            ));
        }
    }
}