use crate::core::ProjectConfig;
use crate::plugins::{register_default_plugins, PluginRegistry};
use super::{PluginAction, PluginArgs};
use anyhow::{Context, Result};
use colored::*;
use std::path::PathBuf;
pub fn run(args: &PluginArgs) -> Result<()> {
let config = ProjectConfig::from_default_location();
let mut registry =
PluginRegistry::new(&config).context("Failed to initialize plugin registry")?;
register_default_plugins(&mut registry);
match &args.action {
Some(action) => match action {
PluginAction::List => list_plugins(®istry),
PluginAction::Install { name, source } => install_plugin(name, source.as_deref()),
PluginAction::Remove { name } => remove_plugin(name),
PluginAction::Enable { name } => enable_plugin(&mut registry, name),
PluginAction::Disable { name } => disable_plugin(&mut registry, name),
PluginAction::New { name } => create_plugin_scaffold(name),
},
None => list_plugins(®istry),
}
}
fn list_plugins(registry: &PluginRegistry) -> Result<()> {
let plugins = registry.list_plugins();
println!("{}", "🔌 Installed Plugins".bold());
println!("{}", "─────────────────────".dimmed());
if plugins.is_empty() {
println!(" No plugins installed.");
println!(" Use `forge-guard plugins install <name>` to add one.");
return Ok(());
}
println!(
" {} total ({} built-in, {} external)",
plugins.len().to_string().bold(),
plugins
.iter()
.filter(|p| matches!(p.plugin_type, crate::plugins::PluginType::Builtin))
.count(),
plugins
.iter()
.filter(|p| matches!(p.plugin_type, crate::plugins::PluginType::External))
.count(),
);
println!();
for plugin in &plugins {
let status = if plugin.enabled {
"✅ enabled".green()
} else {
"⛔ disabled".dimmed()
};
let kind = match plugin.plugin_type {
crate::plugins::PluginType::Builtin => "[built-in]".dimmed(),
crate::plugins::PluginType::External => "[external]".cyan(),
};
let path_display = plugin
.path
.as_ref()
.map(|p| format!(" at {}", p.display()))
.unwrap_or_default();
println!(
" {} {:30} v{:<8} {} {}",
status,
plugin.name.bold(),
plugin.version,
kind,
plugin.description,
);
if !path_display.is_empty() {
println!(" {:>6}{}", "", path_display.dimmed());
}
}
Ok(())
}
fn install_plugin(name: &str, source: Option<&str>) -> Result<()> {
eprintln!("📦 Installing plugin: {}...", name.bold());
let plugin_dir = PathBuf::from(".forge-guard").join("plugins").join(name);
if plugin_dir.exists() {
anyhow::bail!(
"Plugin '{}' is already installed at {}",
name,
plugin_dir.display()
);
}
std::fs::create_dir_all(&plugin_dir).with_context(|| {
format!(
"Failed to create plugin directory: {}",
plugin_dir.display()
)
})?;
if let Some(src) = source {
eprintln!(" From: {}", src);
if src.ends_with(".git") || src.starts_with("https://") || src.starts_with("git@") {
let status = std::process::Command::new("git")
.args(["clone", src, &plugin_dir.to_string_lossy()])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.context("Failed to run git clone — is git installed?")?;
if !status.success() {
anyhow::bail!("Failed to clone plugin from '{}'", src);
}
eprintln!(" ✅ Cloned from {}", src);
} else {
let status = std::process::Command::new("curl")
.args([
"-sSL",
"-o",
&plugin_dir.join("plugin.tar.gz").to_string_lossy(),
src,
])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
match status {
Ok(s) if s.success() => {
eprintln!(" ✅ Downloaded from {}", src);
}
_ => {
anyhow::bail!(
"Could not install from '{}'. Provide a git URL or use `forge-guard plugins new {}` to create a scaffold.",
src, name
);
}
}
}
} else {
let plugin_toml = format!(
"[package]\nname = \"{}\"\nversion = \"0.1.0\"\ndescription = \"A forge-guard plugin\"\n\n# Binary to execute (relative to this directory)\nbinary = \"target/release/{}\"\n",
name, name
);
std::fs::write(plugin_dir.join("plugin.toml"), &plugin_toml)
.context("Failed to write plugin.toml")?;
eprintln!(" ✅ Created plugin.toml scaffold");
}
eprintln!(
"{} Plugin '{}' installed at {}.",
"✅".green(),
name,
plugin_dir.display()
);
if source.is_none() {
eprintln!(
" {}",
"Edit plugin.toml and implement your plugin logic.".dimmed()
);
eprintln!(
" {}",
"Plugins communicate via JSON IPC on stdin/stdout.".dimmed()
);
eprintln!(
" {}",
"See forge-guard docs for the protocol specification.".dimmed()
);
}
Ok(())
}
fn remove_plugin(name: &str) -> Result<()> {
eprintln!("🗑️ Removing plugin: {}...", name.bold());
let plugin_dir = PathBuf::from(".forge-guard").join("plugins").join(name);
if !plugin_dir.exists() {
anyhow::bail!(
"Plugin '{}' is not installed at {}",
name,
plugin_dir.display()
);
}
if name.starts_with("forge-guard-") && name != "forge-guard-example" {
anyhow::bail!(
"Plugin '{}' is a built-in plugin and cannot be removed.",
name
);
}
std::fs::remove_dir_all(&plugin_dir).with_context(|| {
format!(
"Failed to remove plugin directory: {}",
plugin_dir.display()
)
})?;
eprintln!("{} Plugin '{}' removed.", "✅".green(), name);
Ok(())
}
fn enable_plugin(registry: &mut PluginRegistry, name: &str) -> Result<()> {
if registry.enable_plugin(name) {
eprintln!("{} Plugin '{}' enabled.", "✅".green(), name);
} else {
anyhow::bail!(
"Plugin '{}' not found. Use `forge-guard plugins list` to see all plugins.",
name
);
}
Ok(())
}
fn disable_plugin(registry: &mut PluginRegistry, name: &str) -> Result<()> {
if registry.disable_plugin(name) {
eprintln!("{} Plugin '{}' disabled.", "⛔".yellow(), name);
} else {
anyhow::bail!(
"Plugin '{}' not found. Use `forge-guard plugins list` to see all plugins.",
name
);
}
Ok(())
}
fn create_plugin_scaffold(name: &str) -> Result<()> {
let dir = PathBuf::from(".forge-guard").join("plugins").join(name);
if dir.exists() {
anyhow::bail!("Plugin directory already exists: {}", dir.display());
}
std::fs::create_dir_all(&dir)?;
let plugin_toml = format!(
"[package]\nname = \"{}\"\nversion = \"0.1.0\"\ndescription = \"A custom forge-guard plugin\"\n\n# Binary to execute (relative to this directory)\nbinary = \"target/release/{}\"\n\n# Protocol version\nprotocol-version = \"1.0\"\n",
name, name
);
std::fs::write(dir.join("plugin.toml"), &plugin_toml)?;
let _name_camel: String = name
.split('-')
.map(|s| {
let mut c = s.chars();
match c.next() {
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
None => String::new(),
}
})
.collect();
let plugin_rs = format!(
r#"//! {} — Forge Guard plugin
//!
//! Generated by `forge-guard plugins new {}`
//!
//! This plugin communicates with forge-guard via JSON IPC:
//! - Reads PluginIpcInput from stdin
//! - Writes PluginIpcOutput to stdout
//!
//! Run `cargo build --release` to compile, then the plugin
//! will be automatically discovered by forge-guard.
use serde::{{Deserialize, Serialize}};
use std::io::{{self, Read, Write}};
/// Input received from forge-guard.
#[derive(Debug, Deserialize)]
struct PluginInput {{
protocol_version: String,
plugin_name: String,
context: serde_json::Value,
}}
/// Output sent back to forge-guard.
#[derive(Debug, Serialize)]
struct PluginOutput {{
success: bool,
#[serde(default)]
findings: Vec<PluginFinding>,
#[serde(default)]
error: Option<String>,
#[serde(default)]
stats: PluginStats,
}}
#[derive(Debug, Serialize)]
struct PluginFinding {{
title: String,
description: String,
severity: String,
#[serde(default)]
file: Option<String>,
#[serde(default)]
line: Option<usize>,
#[serde(default)]
column: Option<usize>,
#[serde(default)]
code_snippet: Option<String>,
#[serde(default)]
recommendation: Option<String>,
#[serde(default)]
category: Option<String>,
#[serde(default)]
blocks_deployment: bool,
#[serde(default)]
references: Vec<String>,
}}
#[derive(Debug, Serialize, Default)]
struct PluginStats {{
files_analyzed: u32,
duration_ms: u64,
}}
fn main() {{
// Read the JSON input from stdin
let mut input = String::new();
io::stdin().read_to_string(&mut input).expect("Failed to read stdin");
let _input: PluginInput = match serde_json::from_str(&input) {{
Ok(i) => i,
Err(e) => {{
let output = PluginOutput {{
success: false,
findings: Vec::new(),
error: Some(format!("Failed to parse input: {{}}", e)),
stats: PluginStats::default(),
}};
let json = serde_json::to_string(&output).unwrap();
println!("{{}}", json);
return;
}}
}};
// TODO: Implement your analysis logic here
// The `input.context` field contains project configuration and file paths
let output = PluginOutput {{
success: true,
findings: Vec::new(),
error: None,
stats: PluginStats {{
files_analyzed: 0,
duration_ms: 0,
}},
}};
let json = serde_json::to_string(&output).unwrap();
println!("{{}}", json);
}}
"#,
name, name
);
std::fs::write(dir.join("main.rs"), &plugin_rs)?;
let cargo_toml = format!(
"[package]\nname = \"forge-guard-plugin-{}\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[[bin]]\nname = \"{}\"\npath = \"main.rs\"\n\n[dependencies]\nserde = {{ version = \"1\", features = [\"derive\"] }}\nserde_json = \"1\"\n",
name, name
);
std::fs::write(dir.join("Cargo.toml"), &cargo_toml)?;
eprintln!(
"{} Plugin scaffold created at {}",
"✅".green(),
dir.display()
);
eprintln!(" 📄 plugin.toml — Plugin metadata");
eprintln!(" 📄 Cargo.toml — Rust project configuration");
eprintln!(" 📄 main.rs — Plugin implementation");
eprintln!();
eprintln!(" Next steps:");
eprintln!(" cd {}", dir.display());
eprintln!(" cargo build --release");
eprintln!(" forge-guard plugins list (should show your plugin)");
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_plugins_arg_defaults() {
let args = PluginArgs {
shared: super::super::SharedFlags {
chain: "ethereum".into(),
project: std::path::PathBuf::from("."),
json: false,
markdown: false,
html: false,
strict: false,
offline: false,
production: false,
report: false,
parallelism: 4,
},
action: None,
};
assert!(args.action.is_none());
}
#[test]
fn test_plugin_action_list() {
let action = PluginAction::List;
assert!(matches!(action, PluginAction::List));
}
#[test]
fn test_plugin_action_install() {
let action = PluginAction::Install {
name: "my-plugin".into(),
source: None,
};
assert!(matches!(action, PluginAction::Install { .. }));
if let PluginAction::Install { name, .. } = &action {
assert_eq!(name, "my-plugin");
}
}
#[test]
fn test_plugin_action_install_with_source() {
let action = PluginAction::Install {
name: "external-plugin".into(),
source: Some("https://github.com/user/plugin".into()),
};
if let PluginAction::Install { name, source } = &action {
assert_eq!(name, "external-plugin");
assert_eq!(source.as_deref(), Some("https://github.com/user/plugin"));
} else {
panic!("Expected Install action");
}
}
#[test]
fn test_plugin_action_remove() {
let action = PluginAction::Remove {
name: "old-plugin".into(),
};
if let PluginAction::Remove { name } = &action {
assert_eq!(name, "old-plugin");
} else {
panic!("Expected Remove action");
}
}
#[test]
fn test_plugin_action_enable() {
let action = PluginAction::Enable {
name: "security-plus".into(),
};
if let PluginAction::Enable { name } = &action {
assert_eq!(name, "security-plus");
} else {
panic!("Expected Enable action");
}
}
#[test]
fn test_plugin_action_disable() {
let action = PluginAction::Disable {
name: "noisy-plugin".into(),
};
if let PluginAction::Disable { name } = &action {
assert_eq!(name, "noisy-plugin");
} else {
panic!("Expected Disable action");
}
}
#[test]
fn test_plugin_action_new() {
let action = PluginAction::New {
name: "my-awesome-plugin".into(),
};
if let PluginAction::New { name } = &action {
assert_eq!(name, "my-awesome-plugin");
} else {
panic!("Expected New action");
}
}
#[test]
fn test_list_plugins_empty_registry() {
let config = ProjectConfig::default();
let registry = PluginRegistry::new(&config).unwrap();
let plugins = registry.list_plugins();
assert!(plugins.is_empty());
}
#[test]
fn test_list_plugins_with_builtins() {
let config = ProjectConfig::default();
let mut registry = PluginRegistry::new(&config).unwrap();
register_default_plugins(&mut registry);
let plugins = registry.list_plugins();
assert_eq!(plugins.len(), 2);
assert!(plugins.iter().any(|p| p.name == "forge-guard-example"));
assert!(plugins
.iter()
.any(|p| p.name == "forge-guard-offline-guard"));
}
#[test]
fn test_plugin_enable_and_disable_roundtrip() {
let config = ProjectConfig::default();
let mut registry = PluginRegistry::new(&config).unwrap();
register_default_plugins(&mut registry);
assert!(registry.disable_plugin("forge-guard-example"));
let plugins = registry.list_plugins();
let example = plugins
.iter()
.find(|p| p.name == "forge-guard-example")
.unwrap();
assert!(!example.enabled);
assert!(registry.enable_plugin("forge-guard-example"));
let plugins = registry.list_plugins();
let example = plugins
.iter()
.find(|p| p.name == "forge-guard-example")
.unwrap();
assert!(example.enabled);
}
#[test]
fn test_plugin_enable_nonexistent_returns_false() {
let config = ProjectConfig::default();
let mut registry = PluginRegistry::new(&config).unwrap();
assert!(!registry.enable_plugin("nonexistent"));
assert!(!registry.disable_plugin("nonexistent"));
}
#[test]
fn test_install_plugin_dir_does_not_exist_initially() {
let plugin_dir = std::path::PathBuf::from(".forge-guard")
.join("plugins")
.join("test-plugin");
assert!(!plugin_dir.exists());
}
#[test]
fn test_create_plugin_scaffold_creates_files() {
let dir = std::path::PathBuf::from("/tmp/forge-guard-test-plugin-scaffold");
let _ = std::fs::remove_dir_all(&dir);
let plugin_dir = dir.join(".forge-guard").join("plugins").join("integ-test");
std::fs::create_dir_all(&plugin_dir).unwrap();
let plugin_toml = format!(
"[package]\nname = \"integ-test\"\nversion = \"0.1.0\"\ndescription = \"A custom forge-guard plugin\"\n\n# Binary to execute (relative to this directory)\nbinary = \"target/release/integ-test\"\n\n# Protocol version\nprotocol-version = \"1.0\"\n"
);
std::fs::write(plugin_dir.join("plugin.toml"), &plugin_toml).unwrap();
assert!(plugin_dir.join("plugin.toml").exists());
let content = std::fs::read_to_string(plugin_dir.join("plugin.toml")).unwrap();
assert!(content.contains("integ-test"));
assert!(content.contains("protocol-version"));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_scaffold_name_conversion() {
let name = "my-custom-plugin";
let camel: String = name
.split('-')
.map(|s| {
let mut c = s.chars();
match c.next() {
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
None => String::new(),
}
})
.collect();
assert_eq!(camel, "MyCustomPlugin");
}
#[test]
fn test_scaffold_name_conversion_single_word() {
let name = "plugin";
let camel: String = name
.split('-')
.map(|s| {
let mut c = s.chars();
match c.next() {
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
None => String::new(),
}
})
.collect();
assert_eq!(camel, "Plugin");
}
#[test]
fn test_remove_nonexistent_bails() {
let name = "nonexistent-plugin";
let plugin_dir = std::path::PathBuf::from(".forge-guard")
.join("plugins")
.join(name);
assert!(!plugin_dir.exists());
}
}