Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

wip: plugins progress

Yeachan-Heo799ee3a4ee2d
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 5507dca4..4d45e5ed 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -825,6 +825,14 @@ dependencies = [
"time",
]
+[[package]]
+name = "plugins"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
[[package]]
name = "potential_utf"
version = "0.1.4"
@@ -1181,6 +1189,7 @@ dependencies = [
"commands",
"compat-harness",
"crossterm",
+ "plugins",
"pulldown-cmark",
"runtime",
"rustyline",
diff --git a/rust/crates/commands/src/lib.rs b/rust/crates/commands/src/lib.rs
index e7f8d137..d7616457 100644
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
@@ -90,7 +90,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
SlashCommandSpec {
name: "config",
summary: "Inspect Claude config files or merged sections",
- argument_hint: Some("[env|hooks|model]"),
+ argument_hint: Some("[env|hooks|model|plugins]"),
resume_supported: true,
},
SlashCommandSpec {
@@ -171,6 +171,14 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
argument_hint: Some("[list|switch <session-id>]"),
resume_supported: false,
},
+ SlashCommandSpec {
+ name: "plugins",
+ summary: "List or manage plugins",
+ argument_hint: Some(
+ "[list|install <source>|enable <id>|disable <id>|uninstall <id>|update <id>]",
+ ),
+ resume_supported: false,
+ },
];
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -222,6 +230,10 @@ pub enum SlashCommand {
action: Option<String>,
target: Option<String>,
},
+ Plugins {
+ action: Option<String>,
+ target: Option<String>,
+ },
Unknown(String),
}
@@ -283,6 +295,10 @@ impl SlashCommand {
action: parts.next().map(ToOwned::to_owned),
target: parts.next().map(ToOwned::to_owned),
},
+ "plugins" => Self::Plugins {
+ action: parts.next().map(ToOwned::to_owned),
+ target: parts.next().map(ToOwned::to_owned),
+ },
other => Self::Unknown(other.to_string()),
})
}
@@ -383,6 +399,7 @@ pub fn handle_slash_command(
| SlashCommand::Version
| SlashCommand::Export { .. }
| SlashCommand::Session { .. }
+ | SlashCommand::Plugins { .. }
| SlashCommand::Unknown(_) => None,
}
}
@@ -492,6 +509,13 @@ mod tests {
target: Some("abc123".to_string())
})
);
+ assert_eq!(
+ SlashCommand::parse("/plugins install demo"),
+ Some(SlashCommand::Plugins {
+ action: Some("install".to_string()),
+ target: Some("demo".to_string())
+ })
+ );
}
#[test]
@@ -513,14 +537,17 @@ mod tests {
assert!(help.contains("/clear [--confirm]"));
assert!(help.contains("/cost"));
assert!(help.contains("/resume <session-path>"));
- assert!(help.contains("/config [env|hooks|model]"));
+ assert!(help.contains("/config [env|hooks|model|plugins]"));
assert!(help.contains("/memory"));
assert!(help.contains("/init"));
assert!(help.contains("/diff"));
assert!(help.contains("/version"));
assert!(help.contains("/export [file]"));
assert!(help.contains("/session [list|switch <session-id>]"));
- assert_eq!(slash_command_specs().len(), 22);
+ assert!(help.contains(
+ "/plugins [list|install <source>|enable <id>|disable <id>|uninstall <id>|update <id>]"
+ ));
+ assert_eq!(slash_command_specs().len(), 23);
assert_eq!(resume_supported_slash_commands().len(), 11);
}
@@ -618,5 +645,8 @@ mod tests {
assert!(
handle_slash_command("/session list", &session, CompactionConfig::default()).is_none()
);
+ assert!(
+ handle_slash_command("/plugins list", &session, CompactionConfig::default()).is_none()
+ );
}
}
diff --git a/rust/crates/compat-harness/src/lib.rs b/rust/crates/compat-harness/src/lib.rs
index 7176c27c..1acfec93 100644
--- a/rust/crates/compat-harness/src/lib.rs
+++ b/rust/crates/compat-harness/src/lib.rs
@@ -74,11 +74,7 @@ fn upstream_repo_candidates(primary_repo_root: &Path) -> Vec<PathBuf> {
candidates.push(ancestor.join("clawd-code"));
}
- candidates.push(
- primary_repo_root
- .join("reference-source")
- .join("claw-code"),
- );
+ candidates.push(primary_repo_root.join("reference-source").join("claw-code"));
candidates.push(primary_repo_root.join("vendor").join("claw-code"));
let mut deduped = Vec::new();
diff --git a/rust/crates/plugins/Cargo.toml b/rust/crates/plugins/Cargo.toml
new file mode 100644
index 00000000..1771acc1
--- /dev/null
+++ b/rust/crates/plugins/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "plugins"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[lints]
+workspace = true
diff --git a/rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json b/rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json
new file mode 100644
index 00000000..81a42203
--- /dev/null
+++ b/rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json
@@ -0,0 +1,10 @@
+{
+ "name": "example-bundled",
+ "version": "0.1.0",
+ "description": "Example bundled plugin scaffold for the Rust plugin system",
+ "defaultEnabled": false,
+ "hooks": {
+ "PreToolUse": ["./hooks/pre.sh"],
+ "PostToolUse": ["./hooks/post.sh"]
+ }
+}
diff --git a/rust/crates/plugins/bundled/example-bundled/hooks/post.sh b/rust/crates/plugins/bundled/example-bundled/hooks/post.sh
new file mode 100755
index 00000000..c9eb66fd
--- /dev/null
+++ b/rust/crates/plugins/bundled/example-bundled/hooks/post.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+printf '%s\n' 'example bundled post hook'
diff --git a/rust/crates/plugins/bundled/example-bundled/hooks/pre.sh b/rust/crates/plugins/bundled/example-bundled/hooks/pre.sh
new file mode 100755
index 00000000..af6b46bc
--- /dev/null
+++ b/rust/crates/plugins/bundled/example-bundled/hooks/pre.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+printf '%s\n' 'example bundled pre hook'
diff --git a/rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json b/rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json
new file mode 100644
index 00000000..555f5df3
--- /dev/null
+++ b/rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json
@@ -0,0 +1,10 @@
+{
+ "name": "sample-hooks",
+ "version": "0.1.0",
+ "description": "Bundled sample plugin scaffold for hook integration tests.",
+ "defaultEnabled": false,
+ "hooks": {
+ "PreToolUse": ["./hooks/pre.sh"],
+ "PostToolUse": ["./hooks/post.sh"]
+ }
+}
diff --git a/rust/crates/plugins/bundled/sample-hooks/hooks/post.sh b/rust/crates/plugins/bundled/sample-hooks/hooks/post.sh
new file mode 100755
index 00000000..c968e6d1
--- /dev/null
+++ b/rust/crates/plugins/bundled/sample-hooks/hooks/post.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+printf 'sample bundled post hook'
diff --git a/rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh b/rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh
new file mode 100755
index 00000000..95608810
--- /dev/null
+++ b/rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+printf 'sample bundled pre hook'
diff --git a/rust/crates/plugins/src/lib.rs b/rust/crates/plugins/src/lib.rs
new file mode 100644
index 00000000..319ebe9f
--- /dev/null
+++ b/rust/crates/plugins/src/lib.rs
@@ -0,0 +1,983 @@
+use std::collections::BTreeMap;
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+const EXTERNAL_MARKETPLACE: &str = "external";
+const BUILTIN_MARKETPLACE: &str = "builtin";
+const BUNDLED_MARKETPLACE: &str = "bundled";
+const SETTINGS_FILE_NAME: &str = "settings.json";
+const REGISTRY_FILE_NAME: &str = "installed.json";
+const MANIFEST_RELATIVE_PATH: &str = ".claude-plugin/plugin.json";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PluginKind {
+ Builtin,
+ Bundled,
+ External,
+}
+
+impl Display for PluginKind {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Builtin => write!(f, "builtin"),
+ Self::Bundled => write!(f, "bundled"),
+ Self::External => write!(f, "external"),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginMetadata {
+ pub id: String,
+ pub name: String,
+ pub version: String,
+ pub description: String,
+ pub kind: PluginKind,
+ pub source: String,
+ pub default_enabled: bool,
+ pub root: Option<PathBuf>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PluginHooks {
+ #[serde(rename = "PreToolUse", default)]
+ pub pre_tool_use: Vec<String>,
+ #[serde(rename = "PostToolUse", default)]
+ pub post_tool_use: Vec<String>,
+}
+
+impl PluginHooks {
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.pre_tool_use.is_empty() && self.post_tool_use.is_empty()
+ }
+
+ #[must_use]
+ pub fn merged_with(&self, other: &Self) -> Self {
+ let mut merged = self.clone();
+ merged
+ .pre_tool_use
+ .extend(other.pre_tool_use.iter().cloned());
+ merged
+ .post_tool_use
+ .extend(other.post_tool_use.iter().cloned());
+ merged
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PluginManifest {
+ pub name: String,
+ pub version: String,
+ pub description: String,
+ #[serde(rename = "defaultEnabled", default)]
+ pub default_enabled: bool,
+ #[serde(default)]
+ pub hooks: PluginHooks,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum PluginInstallSource {
+ LocalPath { path: PathBuf },
+ GitUrl { url: String },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InstalledPluginRecord {
+ pub id: String,
+ pub name: String,
+ pub version: String,
+ pub description: String,
+ pub install_path: PathBuf,
+ pub source: PluginInstallSource,
+ pub installed_at_unix_ms: u128,
+ pub updated_at_unix_ms: u128,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InstalledPluginRegistry {
+ #[serde(default)]
+ pub plugins: BTreeMap<String, InstalledPluginRecord>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BuiltinPlugin {
+ metadata: PluginMetadata,
+ hooks: PluginHooks,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BundledPlugin {
+ metadata: PluginMetadata,
+ hooks: PluginHooks,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ExternalPlugin {
+ metadata: PluginMetadata,
+ hooks: PluginHooks,
+}
+
+pub trait Plugin {
+ fn metadata(&self) -> &PluginMetadata;
+ fn hooks(&self) -> &PluginHooks;
+ fn validate(&self) -> Result<(), PluginError>;
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PluginDefinition {
+ Builtin(BuiltinPlugin),
+ Bundled(BundledPlugin),
+ External(ExternalPlugin),
+}
+
+impl Plugin for BuiltinPlugin {
+ fn metadata(&self) -> &PluginMetadata {
+ &self.metadata
+ }
+
+ fn hooks(&self) -> &PluginHooks {
+ &self.hooks
+ }
+
+ fn validate(&self) -> Result<(), PluginError> {
+ Ok(())
+ }
+}
+
+impl Plugin for BundledPlugin {
+ fn metadata(&self) -> &PluginMetadata {
+ &self.metadata
+ }
+
+ fn hooks(&self) -> &PluginHooks {
+ &self.hooks
+ }
+
+ fn validate(&self) -> Result<(), PluginError> {
+ validate_hook_paths(self.metadata.root.as_deref(), &self.hooks)
+ }
+}
+
+impl Plugin for ExternalPlugin {
+ fn metadata(&self) -> &PluginMetadata {
+ &self.metadata
+ }
+
+ fn hooks(&self) -> &PluginHooks {
+ &self.hooks
+ }
+
+ fn validate(&self) -> Result<(), PluginError> {
+ validate_hook_paths(self.metadata.root.as_deref(), &self.hooks)
+ }
+}
+
+impl Plugin for PluginDefinition {
+ fn metadata(&self) -> &PluginMetadata {
+ match self {
+ Self::Builtin(plugin) => plugin.metadata(),
+ Self::Bundled(plugin) => plugin.metadata(),
+ Self::External(plugin) => plugin.metadata(),
+ }
+ }
+
+ fn hooks(&self) -> &PluginHooks {
+ match self {
+ Self::Builtin(plugin) => plugin.hooks(),
+ Self::Bundled(plugin) => plugin.hooks(),
+ Self::External(plugin) => plugin.hooks(),
+ }
+ }
+
+ fn validate(&self) -> Result<(), PluginError> {
+ match self {
+ Self::Builtin(plugin) => plugin.validate(),
+ Self::Bundled(plugin) => plugin.validate(),
+ Self::External(plugin) => plugin.validate(),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginSummary {
+ pub metadata: PluginMetadata,
+ pub enabled: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginManagerConfig {
+ pub config_home: PathBuf,
+ pub enabled_plugins: BTreeMap<String, bool>,
+ pub external_dirs: Vec<PathBuf>,
+ pub install_root: Option<PathBuf>,
+ pub registry_path: Option<PathBuf>,
+ pub bundled_root: Option<PathBuf>,
+}
+
+impl PluginManagerConfig {
+ #[must_use]
+ pub fn new(config_home: impl Into<PathBuf>) -> Self {
+ Self {
+ config_home: config_home.into(),
+ enabled_plugins: BTreeMap::new(),
+ external_dirs: Vec::new(),
+ install_root: None,
+ registry_path: None,
+ bundled_root: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginManager {
+ config: PluginManagerConfig,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InstallOutcome {
+ pub plugin_id: String,
+ pub version: String,
+ pub install_path: PathBuf,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UpdateOutcome {
+ pub plugin_id: String,
+ pub old_version: String,
+ pub new_version: String,
+ pub install_path: PathBuf,
+}
+
+#[derive(Debug)]
+pub enum PluginError {
+ Io(std::io::Error),
+ Json(serde_json::Error),
+ InvalidManifest(String),
+ NotFound(String),
+ CommandFailed(String),
+}
+
+impl Display for PluginError {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Io(error) => write!(f, "{error}"),
+ Self::Json(error) => write!(f, "{error}"),
+ Self::InvalidManifest(message)
+ | Self::NotFound(message)
+ | Self::CommandFailed(message) => write!(f, "{message}"),
+ }
+ }
+}
+
+impl std::error::Error for PluginError {}
+
+impl From<std::io::Error> for PluginError {
+ fn from(value: std::io::Error) -> Self {
+ Self::Io(value)
+ }
+}
+
+impl From<serde_json::Error> for PluginError {
+ fn from(value: serde_json::Error) -> Self {
+ Self::Json(value)
+ }
+}
+
+impl PluginManager {
+ #[must_use]
+ pub fn new(config: PluginManagerConfig) -> Self {
+ Self { config }
+ }
+
+ #[must_use]
+ pub fn bundled_root() -> PathBuf {
+ PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("bundled")
+ }
+
+ #[must_use]
+ pub fn install_root(&self) -> PathBuf {
+ self.config
+ .install_root
+ .clone()
+ .unwrap_or_else(|| self.config.config_home.join("plugins").join("installed"))
+ }
+
+ #[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 list_plugins(&self) -> Result<Vec<PluginSummary>, PluginError> {
+ let mut plugins = self
+ .discover_plugins()?
+ .into_iter()
+ .map(|plugin| PluginSummary {
+ enabled: self.is_enabled(plugin.metadata()),
+ metadata: plugin.metadata().clone(),
+ })
+ .collect::<Vec<_>>();
+ plugins.sort_by(|left, right| left.metadata.id.cmp(&right.metadata.id));
+ Ok(plugins)
+ }
+
+ pub fn discover_plugins(&self) -> Result<Vec<PluginDefinition>, PluginError> {
+ let mut plugins = builtin_plugins();
+ plugins.extend(self.discover_bundled_plugins()?);
+ plugins.extend(self.discover_external_plugins()?);
+ Ok(plugins)
+ }
+
+ pub fn aggregated_hooks(&self) -> Result<PluginHooks, PluginError> {
+ self.discover_plugins()?
+ .into_iter()
+ .filter(|plugin| self.is_enabled(plugin.metadata()))
+ .try_fold(PluginHooks::default(), |acc, plugin| {
+ plugin.validate()?;
+ Ok(acc.merged_with(plugin.hooks()))
+ })
+ }
+
+ pub fn validate_plugin_source(&self, source: &str) -> Result<PluginManifest, PluginError> {
+ let path = resolve_local_source(source)?;
+ load_manifest_from_root(&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_manifest_from_root(&staged_source)?;
+ validate_manifest(&manifest)?;
+
+ 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 {
+ 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.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_manifest_from_root(&staged_source)?;
+ validate_manifest(&manifest)?;
+
+ 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_bundled_plugins(&self) -> Result<Vec<PluginDefinition>, PluginError> {
+ discover_plugin_dirs(
+ &self
+ .config
+ .bundled_root
+ .clone()
+ .unwrap_or_else(Self::bundled_root),
+ )?
+ .into_iter()
+ .map(|root| {
+ load_plugin_definition(
+ &root,
+ PluginKind::Bundled,
+ format!("{BUNDLED_MARKETPLACE}:{}", root.display()),
+ BUNDLED_MARKETPLACE,
+ )
+ })
+ .collect()
+ }
+
+ fn discover_external_plugins(&self) -> Result<Vec<PluginDefinition>, PluginError> {
+ let registry = self.load_registry()?;
+ let mut plugins = registry
+ .plugins
+ .values()
+ .map(|record| {
+ load_plugin_definition(
+ &record.install_path,
+ PluginKind::External,
+ describe_install_source(&record.source),
+ EXTERNAL_MARKETPLACE,
+ )
+ })
+ .collect::<Result<Vec<_>, _>>()?;
+
+ 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 plugins
+ .iter()
+ .all(|existing| existing.metadata().id != plugin.metadata().id)
+ {
+ plugins.push(plugin);
+ }
+ }
+ }
+
+ Ok(plugins)
+ }
+
+ 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
+ .list_plugins()?
+ .iter()
+ .any(|plugin| plugin.metadata.id == plugin_id)
+ {
+ Ok(())
+ } else {
+ Err(PluginError::NotFound(format!(
+ "plugin `{plugin_id}` is not installed or discoverable"
+ )))
+ }
+ }
+
+ fn load_registry(&self) -> Result<InstalledPluginRegistry, PluginError> {
+ let path = self.registry_path();
+ match fs::read_to_string(&path) {
+ 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)),
+ }
+ }
+
+ 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(())
+ }
+
+ 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);
+ }
+ }
+ })
+ }
+}
+
+#[must_use]
+pub fn builtin_plugins() -> Vec<PluginDefinition> {
+ vec![PluginDefinition::Builtin(BuiltinPlugin {
+ metadata: PluginMetadata {
+ id: plugin_id("example-builtin", BUILTIN_MARKETPLACE),
+ name: "example-builtin".to_string(),
+ version: "0.1.0".to_string(),
+ description: "Example built-in plugin scaffold for the Rust plugin system".to_string(),
+ kind: PluginKind::Builtin,
+ source: BUILTIN_MARKETPLACE.to_string(),
+ default_enabled: false,
+ root: None,
+ },
+ hooks: PluginHooks::default(),
+ })]
+}
+
+fn load_plugin_definition(
+ root: &Path,
+ kind: PluginKind,
+ source: String,
+ marketplace: &str,
+) -> Result<PluginDefinition, PluginError> {
+ let manifest = load_manifest_from_root(root)?;
+ validate_manifest(&manifest)?;
+ let metadata = PluginMetadata {
+ id: plugin_id(&manifest.name, marketplace),
+ name: manifest.name,
+ version: manifest.version,
+ description: manifest.description,
+ kind,
+ source,
+ default_enabled: manifest.default_enabled,
+ root: Some(root.to_path_buf()),
+ };
+ let hooks = resolve_hooks(root, &manifest.hooks);
+ Ok(match kind {
+ PluginKind::Builtin => PluginDefinition::Builtin(BuiltinPlugin { metadata, hooks }),
+ PluginKind::Bundled => PluginDefinition::Bundled(BundledPlugin { metadata, hooks }),
+ PluginKind::External => PluginDefinition::External(ExternalPlugin { metadata, hooks }),
+ })
+}
+
+fn validate_manifest(manifest: &PluginManifest) -> Result<(), PluginError> {
+ if manifest.name.trim().is_empty() {
+ return Err(PluginError::InvalidManifest(
+ "plugin manifest name cannot be empty".to_string(),
+ ));
+ }
+ if manifest.version.trim().is_empty() {
+ return Err(PluginError::InvalidManifest(
+ "plugin manifest version cannot be empty".to_string(),
+ ));
+ }
+ if manifest.description.trim().is_empty() {
+ return Err(PluginError::InvalidManifest(
+ "plugin manifest description cannot be empty".to_string(),
+ ));
+ }
+ Ok(())
+}
+
+fn load_manifest_from_root(root: &Path) -> Result<PluginManifest, PluginError> {
+ let manifest_path = root.join(MANIFEST_RELATIVE_PATH);
+ let contents = fs::read_to_string(&manifest_path).map_err(|error| {
+ PluginError::NotFound(format!(
+ "plugin manifest not found at {}: {error}",
+ manifest_path.display()
+ ))
+ })?;
+ Ok(serde_json::from_str(&contents)?)
+}
+
+fn resolve_hooks(root: &Path, hooks: &PluginHooks) -> PluginHooks {
+ PluginHooks {
+ pre_tool_use: hooks
+ .pre_tool_use
+ .iter()
+ .map(|entry| resolve_hook_entry(root, entry))
+ .collect(),
+ post_tool_use: hooks
+ .post_tool_use
+ .iter()
+ .map(|entry| resolve_hook_entry(root, entry))
+ .collect(),
+ }
+}
+
+fn validate_hook_paths(root: Option<&Path>, hooks: &PluginHooks) -> Result<(), PluginError> {
+ let Some(root) = root else {
+ return Ok(());
+ };
+ for entry in hooks.pre_tool_use.iter().chain(hooks.post_tool_use.iter()) {
+ if is_literal_command(entry) {
+ continue;
+ }
+ let path = if Path::new(entry).is_absolute() {
+ PathBuf::from(entry)
+ } else {
+ root.join(entry)
+ };
+ if !path.exists() {
+ return Err(PluginError::InvalidManifest(format!(
+ "hook path `{}` does not exist",
+ path.display()
+ )));
+ }
+ }
+ Ok(())
+}
+
+fn resolve_hook_entry(root: &Path, entry: &str) -> String {
+ if is_literal_command(entry) {
+ entry.to_string()
+ } else {
+ root.join(entry).display().to_string()
+ }
+}
+
+fn is_literal_command(entry: &str) -> bool {
+ !entry.starts_with("./") && !entry.starts_with("../")
+}
+
+fn resolve_local_source(source: &str) -> Result<PathBuf, PluginError> {
+ let path = PathBuf::from(source);
+ if path.exists() {
+ Ok(path)
+ } else {
+ Err(PluginError::NotFound(format!(
+ "plugin source `{source}` was not found"
+ )))
+ }
+}
+
+fn parse_install_source(source: &str) -> Result<PluginInstallSource, PluginError> {
+ if source.starts_with("http://")
+ || source.starts_with("https://")
+ || source.starts_with("git@")
+ || source.ends_with(".git")
+ {
+ Ok(PluginInstallSource::GitUrl {
+ url: source.to_string(),
+ })
+ } else {
+ Ok(PluginInstallSource::LocalPath {
+ path: resolve_local_source(source)?,
+ })
+ }
+}
+
+fn materialize_source(
+ source: &PluginInstallSource,
+ temp_root: &Path,
+) -> Result<PathBuf, PluginError> {
+ fs::create_dir_all(temp_root)?;
+ match source {
+ PluginInstallSource::LocalPath { path } => Ok(path.clone()),
+ PluginInstallSource::GitUrl { url } => {
+ let destination = temp_root.join(format!("plugin-{}", unix_time_ms()));
+ let output = Command::new("git")
+ .arg("clone")
+ .arg("--depth")
+ .arg("1")
+ .arg(url)
+ .arg(&destination)
+ .output()?;
+ if !output.status.success() {
+ return Err(PluginError::CommandFailed(format!(
+ "git clone failed for `{url}`: {}",
+ String::from_utf8_lossy(&output.stderr).trim()
+ )));
+ }
+ Ok(destination)
+ }
+ }
+}
+
+fn discover_plugin_dirs(root: &Path) -> Result<Vec<PathBuf>, PluginError> {
+ match fs::read_dir(root) {
+ Ok(entries) => {
+ let mut paths = Vec::new();
+ for entry in entries {
+ let path = entry?.path();
+ if path.join(MANIFEST_RELATIVE_PATH).exists() {
+ paths.push(path);
+ }
+ }
+ Ok(paths)
+ }
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(Vec::new()),
+ Err(error) => Err(PluginError::Io(error)),
+ }
+}
+
+fn plugin_id(name: &str, marketplace: &str) -> String {
+ format!("{name}@{marketplace}")
+}
+
+fn sanitize_plugin_id(plugin_id: &str) -> String {
+ plugin_id
+ .chars()
+ .map(|ch| match ch {
+ '/' | '\\' | '@' | ':' => '-',
+ other => other,
+ })
+ .collect()
+}
+
+fn describe_install_source(source: &PluginInstallSource) -> String {
+ match source {
+ PluginInstallSource::LocalPath { path } => path.display().to_string(),
+ PluginInstallSource::GitUrl { url } => url.clone(),
+ }
+}
+
+fn unix_time_ms() -> u128 {
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .expect("time should be after epoch")
+ .as_millis()
+}
+
+fn copy_dir_all(source: &Path, destination: &Path) -> Result<(), PluginError> {
+ fs::create_dir_all(destination)?;
+ for entry in fs::read_dir(source)? {
+ let entry = entry?;
+ let target = destination.join(entry.file_name());
+ if entry.file_type()?.is_dir() {
+ copy_dir_all(&entry.path(), &target)?;
+ } else {
+ fs::copy(entry.path(), target)?;
+ }
+ }
+ Ok(())
+}
+
+fn update_settings_json(
+ path: &Path,
+ mut update: impl FnMut(&mut Map<String, Value>),
+) -> Result<(), PluginError> {
+ if let Some(parent) = path.parent() {
+ fs::create_dir_all(parent)?;
+ }
+ let mut root = match fs::read_to_string(path) {
+ Ok(contents) if !contents.trim().is_empty() => serde_json::from_str::<Value>(&contents)?,
+ Ok(_) => Value::Object(Map::new()),
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Value::Object(Map::new()),
+ Err(error) => return Err(PluginError::Io(error)),
+ };
+
+ let object = root.as_object_mut().ok_or_else(|| {
+ PluginError::InvalidManifest(format!(
+ "settings file {} must contain a JSON object",
+ path.display()
+ ))
+ })?;
+ update(object);
+ fs::write(path, serde_json::to_string_pretty(&root)?)?;
+ Ok(())
+}
+
+fn ensure_object<'a>(root: &'a mut Map<String, Value>, key: &str) -> &'a mut Map<String, Value> {
+ if !root.get(key).is_some_and(Value::is_object) {
+ root.insert(key.to_string(), Value::Object(Map::new()));
+ }
+ root.get_mut(key)
+ .and_then(Value::as_object_mut)
+ .expect("object should exist")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn temp_dir(label: &str) -> PathBuf {
+ std::env::temp_dir().join(format!("plugins-{label}-{}", unix_time_ms()))
+ }
+
+ fn write_external_plugin(root: &Path, name: &str, version: &str) {
+ fs::create_dir_all(root.join(".claude-plugin")).expect("manifest dir");
+ fs::create_dir_all(root.join("hooks")).expect("hooks dir");
+ fs::write(
+ root.join("hooks").join("pre.sh"),
+ "#!/bin/sh\nprintf 'pre'\n",
+ )
+ .expect("write pre hook");
+ fs::write(
+ root.join("hooks").join("post.sh"),
+ "#!/bin/sh\nprintf 'post'\n",
+ )
+ .expect("write post hook");
+ fs::write(
+ root.join(MANIFEST_RELATIVE_PATH),
+ format!(
+ "{{\n \"name\": \"{name}\",\n \"version\": \"{version}\",\n \"description\": \"test plugin\",\n \"hooks\": {{\n \"PreToolUse\": [\"./hooks/pre.sh\"],\n \"PostToolUse\": [\"./hooks/post.sh\"]\n }}\n}}"
+ ),
+ )
+ .expect("write manifest");
+ }
+
+ #[test]
+ fn validates_manifest_shape() {
+ let error = validate_manifest(&PluginManifest {
+ name: String::new(),
+ version: "1.0.0".to_string(),
+ description: "desc".to_string(),
+ default_enabled: false,
+ hooks: PluginHooks::default(),
+ })
+ .expect_err("empty name should fail");
+ assert!(error.to_string().contains("name cannot be empty"));
+ }
+
+ #[test]
+ fn discovers_builtin_and_bundled_plugins() {
+ let manager = PluginManager::new(PluginManagerConfig::new(temp_dir("discover")));
+ let plugins = manager.list_plugins().expect("plugins should list");
+ assert!(plugins
+ .iter()
+ .any(|plugin| plugin.metadata.kind == PluginKind::Builtin));
+ assert!(plugins
+ .iter()
+ .any(|plugin| plugin.metadata.kind == PluginKind::Bundled));
+ }
+
+ #[test]
+ fn installs_enables_updates_and_uninstalls_external_plugins() {
+ let config_home = temp_dir("home");
+ let source_root = temp_dir("source");
+ write_external_plugin(&source_root, "demo", "1.0.0");
+
+ let mut manager = PluginManager::new(PluginManagerConfig::new(&config_home));
+ let install = manager
+ .install(source_root.to_str().expect("utf8 path"))
+ .expect("install should succeed");
+ assert_eq!(install.plugin_id, "demo@external");
+ assert!(manager
+ .list_plugins()
+ .expect("list plugins")
+ .iter()
+ .any(|plugin| plugin.metadata.id == "demo@external" && plugin.enabled));
+
+ let hooks = manager.aggregated_hooks().expect("hooks should aggregate");
+ assert_eq!(hooks.pre_tool_use.len(), 1);
+ assert!(hooks.pre_tool_use[0].contains("pre.sh"));
+
+ manager
+ .disable("demo@external")
+ .expect("disable should work");
+ assert!(manager
+ .aggregated_hooks()
+ .expect("hooks after disable")
+ .is_empty());
+ manager.enable("demo@external").expect("enable should work");
+
+ write_external_plugin(&source_root, "demo", "2.0.0");
+ let update = manager.update("demo@external").expect("update should work");
+ assert_eq!(update.old_version, "1.0.0");
+ assert_eq!(update.new_version, "2.0.0");
+
+ manager
+ .uninstall("demo@external")
+ .expect("uninstall should work");
+ assert!(!manager
+ .list_plugins()
+ .expect("list plugins")
+ .iter()
+ .any(|plugin| plugin.metadata.id == "demo@external"));
+
+ fs::remove_dir_all(config_home).expect("cleanup home");
+ fs::remove_dir_all(source_root).expect("cleanup source");
+ }
+
+ #[test]
+ fn validates_plugin_source_before_install() {
+ let config_home = temp_dir("validate-home");
+ let source_root = temp_dir("validate-source");
+ write_external_plugin(&source_root, "validator", "1.0.0");
+ let manager = PluginManager::new(PluginManagerConfig::new(&config_home));
+ let manifest = manager
+ .validate_plugin_source(source_root.to_str().expect("utf8 path"))
+ .expect("manifest should validate");
+ assert_eq!(manifest.name, "validator");
+ fs::remove_dir_all(config_home).expect("cleanup home");
+ fs::remove_dir_all(source_root).expect("cleanup source");
+ }
+}
diff --git a/rust/crates/plugins/src/manager.rs b/rust/crates/plugins/src/manager.rs
new file mode 100644
index 00000000..85a7cd0c
--- /dev/null
+++ b/rust/crates/plugins/src/manager.rs
@@ -0,0 +1,642 @@
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use runtime::{RuntimeConfig, RuntimeHookConfig};
+use serde::{Deserialize, Serialize};
+
+use crate::manifest::{LoadedPlugin, Plugin, PluginHooks, PluginManifest};
+use crate::registry::PluginRegistry;
+use crate::settings::{read_settings_file, write_plugin_state, write_settings_file};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PluginSourceKind {
+ Builtin,
+ Bundled,
+ External,
+}
+
+impl PluginSourceKind {
+ fn suffix(self) -> &'static str {
+ match self {
+ Self::Builtin => "builtin",
+ Self::Bundled => "bundled",
+ Self::External => "external",
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InstalledPluginRecord {
+ pub id: String,
+ pub name: String,
+ pub version: String,
+ pub description: String,
+ pub source_kind: PluginSourceKind,
+ pub source_path: String,
+ pub install_path: String,
+ pub installed_at: String,
+ pub updated_at: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginListEntry {
+ pub plugin: LoadedPlugin,
+ pub enabled: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginOperationResult {
+ pub plugin_id: String,
+ pub message: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginError {
+ message: String,
+}
+
+impl PluginError {
+ #[must_use]
+ pub fn new(message: impl Into<String>) -> Self {
+ Self {
+ message: message.into(),
+ }
+ }
+}
+
+impl Display for PluginError {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}", self.message)
+ }
+}
+
+impl std::error::Error for PluginError {}
+
+impl From<String> for PluginError {
+ fn from(value: String) -> Self {
+ Self::new(value)
+ }
+}
+
+impl From<std::io::Error> for PluginError {
+ fn from(value: std::io::Error) -> Self {
+ Self::new(value.to_string())
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginLoader {
+ registry_path: PathBuf,
+}
+
+impl PluginLoader {
+ #[must_use]
+ pub fn new(config_home: impl Into<PathBuf>) -> Self {
+ let config_home = config_home.into();
+ Self {
+ registry_path: config_home.join("plugins").join("installed.json"),
+ }
+ }
+
+ pub fn discover(&self) -> Result<Vec<LoadedPlugin>, PluginError> {
+ let mut plugins = builtin_plugins();
+ plugins.extend(bundled_plugins());
+ plugins.extend(self.load_external_plugins()?);
+ plugins.sort_by(|left, right| left.id.cmp(&right.id));
+ Ok(plugins)
+ }
+
+ fn load_external_plugins(&self) -> Result<Vec<LoadedPlugin>, PluginError> {
+ let registry = PluginRegistry::load(&self.registry_path)?;
+ registry
+ .plugins
+ .into_iter()
+ .map(|record| {
+ let install_path = PathBuf::from(&record.install_path);
+ let (manifest, root) = load_manifest_from_source(&install_path)?;
+ Ok(LoadedPlugin::new(
+ record.id,
+ PluginSourceKind::External,
+ manifest,
+ Some(root),
+ Some(PathBuf::from(record.source_path)),
+ ))
+ })
+ .collect()
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PluginManager {
+ cwd: PathBuf,
+ config_home: PathBuf,
+}
+
+impl PluginManager {
+ #[must_use]
+ pub fn new(cwd: impl Into<PathBuf>, config_home: impl Into<PathBuf>) -> Self {
+ Self {
+ cwd: cwd.into(),
+ config_home: config_home.into(),
+ }
+ }
+
+ #[must_use]
+ pub fn default_for(cwd: impl Into<PathBuf>) -> Self {
+ let cwd = cwd.into();
+ let config_home = std::env::var_os("CLAUDE_CONFIG_HOME")
+ .map(PathBuf::from)
+ .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude")))
+ .unwrap_or_else(|| PathBuf::from(".claude"));
+ Self { cwd, config_home }
+ }
+
+ #[must_use]
+ pub fn loader(&self) -> PluginLoader {
+ PluginLoader::new(&self.config_home)
+ }
+
+ pub fn discover_plugins(&self) -> Result<Vec<LoadedPlugin>, PluginError> {
+ self.loader().discover()
+ }
+
+ pub fn list_plugins(
+ &self,
+ runtime_config: &RuntimeConfig,
+ ) -> Result<Vec<PluginListEntry>, PluginError> {
+ self.discover_plugins().map(|plugins| {
+ plugins
+ .into_iter()
+ .map(|plugin| {
+ let enabled = is_plugin_enabled(&plugin, runtime_config);
+ PluginListEntry { plugin, enabled }
+ })
+ .collect()
+ })
+ }
+
+ pub fn active_hook_config(
+ &self,
+ runtime_config: &RuntimeConfig,
+ ) -> Result<RuntimeHookConfig, PluginError> {
+ let mut hooks = PluginHooks::default();
+ for plugin in self.list_plugins(runtime_config)? {
+ if plugin.enabled {
+ let resolved = plugin.plugin.resolved_hooks();
+ hooks.pre_tool_use.extend(resolved.pre_tool_use);
+ hooks.post_tool_use.extend(resolved.post_tool_use);
+ }
+ }
+ Ok(RuntimeHookConfig::new(hooks.pre_tool_use, hooks.post_tool_use))
+ }
+
+ pub fn validate_plugin(&self, source: impl AsRef<Path>) -> Result<PluginManifest, PluginError> {
+ let (manifest, _) = load_manifest_from_source(source.as_ref())?;
+ Ok(manifest)
+ }
+
+ pub fn install_plugin(
+ &self,
+ source: impl AsRef<Path>,
+ ) -> Result<PluginOperationResult, PluginError> {
+ let (manifest, root) = load_manifest_from_source(source.as_ref())?;
+ let plugin_id = external_plugin_id(&manifest.name);
+ let install_path = self.installs_root().join(sanitize_plugin_id(&plugin_id));
+ let canonical_source = fs::canonicalize(root)?;
+
+ copy_dir_recursive(&canonical_source, &install_path)?;
+
+ let now = iso8601_now();
+ let mut registry = self.load_registry()?;
+ let installed_at = registry
+ .find(&plugin_id)
+ .map(|record| record.installed_at.clone())
+ .unwrap_or_else(|| now.clone());
+ registry.upsert(InstalledPluginRecord {
+ id: plugin_id.clone(),
+ name: manifest.name.clone(),
+ version: manifest.version.clone(),
+ description: manifest.description.clone(),
+ source_kind: PluginSourceKind::External,
+ source_path: canonical_source.display().to_string(),
+ install_path: install_path.display().to_string(),
+ installed_at,
+ updated_at: now,
+ });
+ self.save_registry(&registry)?;
+ self.write_enabled_state(&plugin_id, Some(true))?;
+
+ Ok(PluginOperationResult {
+ plugin_id: plugin_id.clone(),
+ message: format!(
+ "Installed plugin {} from {}",
+ plugin_id,
+ canonical_source.display()
+ ),
+ })
+ }
+
+ pub fn enable_plugin(&self, plugin_ref: &str) -> Result<PluginOperationResult, PluginError> {
+ let plugin = self.resolve_plugin(plugin_ref)?;
+ self.write_enabled_state(plugin.id(), Some(true))?;
+ Ok(PluginOperationResult {
+ plugin_id: plugin.id().to_string(),
+ message: format!("Enabled plugin {}", plugin.id()),
+ })
+ }
+
+ pub fn disable_plugin(&self, plugin_ref: &str) -> Result<PluginOperationResult, PluginError> {
+ let plugin = self.resolve_plugin(plugin_ref)?;
+ self.write_enabled_state(plugin.id(), Some(false))?;
+ Ok(PluginOperationResult {
+ plugin_id: plugin.id().to_string(),
+ message: format!("Disabled plugin {}", plugin.id()),
+ })
+ }
+
+ pub fn uninstall_plugin(
+ &self,
+ plugin_ref: &str,
+ ) -> Result<PluginOperationResult, PluginError> {
+ let plugin = self.resolve_plugin(plugin_ref)?;
+ if plugin.source_kind != PluginSourceKind::External {
+ return Err(PluginError::new(format!(
+ "plugin {} is {} and cannot be uninstalled",
+ plugin.id(),
+ plugin.source_kind.suffix()
+ )));
+ }
+
+ let mut registry = self.load_registry()?;
+ let Some(record) = registry.remove(plugin.id()) else {
+ return Err(PluginError::new(format!(
+ "plugin {} is not installed",
+ plugin.id()
+ )));
+ };
+ self.save_registry(&registry)?;
+ self.write_enabled_state(plugin.id(), None)?;
+
+ let install_path = PathBuf::from(record.install_path);
+ if install_path.exists() {
+ fs::remove_dir_all(install_path)?;
+ }
+
+ Ok(PluginOperationResult {
+ plugin_id: plugin.id().to_string(),
+ message: format!("Uninstalled plugin {}", plugin.id()),
+ })
+ }
+
+ pub fn update_plugin(&self, plugin_ref: &str) -> Result<PluginOperationResult, PluginError> {
+ let plugin = self.resolve_plugin(plugin_ref)?;
+ match plugin.source_kind {
+ PluginSourceKind::Builtin | PluginSourceKind::Bundled => Ok(PluginOperationResult {
+ plugin_id: plugin.id().to_string(),
+ message: format!(
+ "Plugin {} is {} and already managed by the CLI",
+ plugin.id(),
+ plugin.source_kind.suffix()
+ ),
+ }),
+ PluginSourceKind::External => {
+ let registry = self.load_registry()?;
+ let record = registry.find(plugin.id()).ok_or_else(|| {
+ PluginError::new(format!("plugin {} is not installed", plugin.id()))
+ })?;
+ self.install_plugin(PathBuf::from(&record.source_path)).map(|_| PluginOperationResult {
+ plugin_id: plugin.id().to_string(),
+ message: format!("Updated plugin {}", plugin.id()),
+ })
+ }
+ }
+ }
+
+ fn resolve_plugin(&self, plugin_ref: &str) -> Result<LoadedPlugin, PluginError> {
+ let plugins = self.discover_plugins()?;
+ if let Some(plugin) = plugins.iter().find(|plugin| plugin.id == plugin_ref) {
+ return Ok(plugin.clone());
+ }
+ let mut matches = plugins
+ .into_iter()
+ .filter(|plugin| plugin.name() == plugin_ref)
+ .collect::<Vec<_>>();
+ match matches.len() {
+ 0 => Err(PluginError::new(format!("plugin {plugin_ref} was not found"))),
+ 1 => Ok(matches.remove(0)),
+ _ => Err(PluginError::new(format!(
+ "plugin name {plugin_ref} is ambiguous; use a full plugin id"
+ ))),
+ }
+ }
+
+ fn settings_path(&self) -> PathBuf {
+ let _ = &self.cwd;
+ self.config_home.join("settings.json")
+ }
+
+ fn installs_root(&self) -> PathBuf {
+ self.config_home.join("plugins").join("installs")
+ }
+
+ fn registry_path(&self) -> PathBuf {
+ self.config_home.join("plugins").join("installed.json")
+ }
+
+ fn load_registry(&self) -> Result<PluginRegistry, PluginError> {
+ PluginRegistry::load(&self.registry_path()).map_err(PluginError::from)
+ }
+
+ fn save_registry(&self, registry: &PluginRegistry) -> Result<(), PluginError> {
+ registry.save(&self.registry_path()).map_err(PluginError::from)
+ }
+
+ fn write_enabled_state(
+ &self,
+ plugin_id: &str,
+ enabled: Option<bool>,
+ ) -> Result<(), PluginError> {
+ let settings_path = self.settings_path();
+ let mut settings = read_settings_file(&settings_path)?;
+ write_plugin_state(&mut settings, plugin_id, enabled);
+ write_settings_file(&settings_path, &settings)?;
+ Ok(())
+ }
+}
+
+fn builtin_plugins() -> Vec<LoadedPlugin> {
+ let manifest = PluginManifest {
+ name: "tool-guard".to_string(),
+ description: "Example built-in plugin with optional tool hook messages".to_string(),
+ version: env!("CARGO_PKG_VERSION").to_string(),
+ default_enabled: false,
+ hooks: PluginHooks {
+ pre_tool_use: vec!["printf 'builtin tool-guard saw %s' \"$HOOK_TOOL_NAME\"".to_string()],
+ post_tool_use: Vec::new(),
+ },
+ };
+ vec![LoadedPlugin::new(
+ format!("{}@builtin", manifest.name),
+ PluginSourceKind::Builtin,
+ manifest,
+ None,
+ None,
+ )]
+}
+
+fn bundled_plugins() -> Vec<LoadedPlugin> {
+ let manifest = PluginManifest {
+ name: "tool-audit".to_string(),
+ description: "Example bundled plugin with optional post-tool hooks".to_string(),
+ version: env!("CARGO_PKG_VERSION").to_string(),
+ default_enabled: false,
+ hooks: PluginHooks {
+ pre_tool_use: Vec::new(),
+ post_tool_use: vec!["printf 'bundled tool-audit saw %s' \"$HOOK_TOOL_NAME\"".to_string()],
+ },
+ };
+ vec![LoadedPlugin::new(
+ format!("{}@bundled", manifest.name),
+ PluginSourceKind::Bundled,
+ manifest,
+ None,
+ None,
+ )]
+}
+
+fn is_plugin_enabled(plugin: &LoadedPlugin, runtime_config: &RuntimeConfig) -> bool {
+ runtime_config.plugins().state_for(&plugin.id, plugin.manifest.default_enabled)
+}
+
+fn external_plugin_id(name: &str) -> String {
+ format!("{}@external", name.trim())
+}
+
+fn sanitize_plugin_id(plugin_id: &str) -> String {
+ plugin_id
+ .chars()
+ .map(|character| {
+ if character.is_ascii_alphanumeric() || matches!(character, '-' | '_') {
+ character
+ } else {
+ '-'
+ }
+ })
+ .collect()
+}
+
+fn load_manifest_from_source(source: &Path) -> Result<(PluginManifest, PathBuf), PluginError> {
+ let (manifest_path, root) = resolve_manifest_path(source)?;
+ let contents = fs::read_to_string(&manifest_path).map_err(|error| {
+ PluginError::new(format!(
+ "failed to read plugin manifest {}: {error}",
+ manifest_path.display()
+ ))
+ })?;
+ let manifest: PluginManifest = serde_json::from_str(&contents).map_err(|error| {
+ PluginError::new(format!(
+ "failed to parse plugin manifest {}: {error}",
+ manifest_path.display()
+ ))
+ })?;
+ manifest.validate().map_err(PluginError::new)?;
+ Ok((manifest, root))
+}
+
+fn resolve_manifest_path(source: &Path) -> Result<(PathBuf, PathBuf), PluginError> {
+ if source.is_file() {
+ let file_name = source.file_name().and_then(|name| name.to_str()).unwrap_or_default();
+ if file_name != "plugin.json" {
+ return Err(PluginError::new(format!(
+ "plugin manifest file must be named plugin.json: {}",
+ source.display()
+ )));
+ }
+ let root = source
+ .parent()
+ .and_then(|parent| parent.parent().filter(|candidate| parent.file_name() == Some(std::ffi::OsStr::new(".claude-plugin"))))
+ .map_or_else(
+ || source.parent().unwrap_or_else(|| Path::new(".")).to_path_buf(),
+ Path::to_path_buf,
+ );
+ return Ok((source.to_path_buf(), root));
+ }
+
+ let nested = source.join(".claude-plugin").join("plugin.json");
+ if nested.exists() {
+ return Ok((nested, source.to_path_buf()));
+ }
+
+ let direct = source.join("plugin.json");
+ if direct.exists() {
+ return Ok((direct, source.to_path_buf()));
+ }
+
+ Err(PluginError::new(format!(
+ "plugin manifest not found in {}",
+ source.display()
+ )))
+}
+
+fn copy_dir_recursive(source: &Path, destination: &Path) -> Result<(), PluginError> {
+ if destination.exists() {
+ fs::remove_dir_all(destination)?;
+ }
+ fs::create_dir_all(destination)?;
+ for entry in fs::read_dir(source)? {
+ let entry = entry?;
+ let path = entry.path();
+ let target = destination.join(entry.file_name());
+ if entry.file_type()?.is_dir() {
+ copy_dir_recursive(&path, &target)?;
+ } else {
+ fs::copy(&path, &target)?;
+ }
+ }
+ Ok(())
+}
+
+fn iso8601_now() -> String {
+ let seconds = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs();
+ format!("{seconds}")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{PluginLoader, PluginManager, PluginSourceKind};
+ use runtime::ConfigLoader;
+ use std::fs;
+ use std::path::Path;
+ use std::time::{SystemTime, UNIX_EPOCH};
+
+ fn temp_dir() -> std::path::PathBuf {
+ let nanos = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .expect("time should be after epoch")
+ .as_nanos();
+ std::env::temp_dir().join(format!("plugins-manager-{nanos}"))
+ }
+
+ fn write_external_plugin(root: &Path, version: &str, hook_body: &str) {
+ fs::create_dir_all(root.join(".claude-plugin")).expect("plugin dir should exist");
+ fs::write(
+ root.join(".claude-plugin").join("plugin.json"),
+ format!(
+ r#"{{
+ "name": "sample-plugin",
+ "description": "sample external plugin",
+ "version": "{version}",
+ "hooks": {{
+ "PreToolUse": ["printf 'pre from ${PLUGIN_DIR} {hook_body}'"]
+ }}
+}}"#
+ ),
+ )
+ .expect("plugin manifest should write");
+ fs::write(root.join("README.md"), "sample").expect("payload should write");
+ }
+
+ #[test]
+ fn discovers_builtin_and_bundled_plugins() {
+ let root = temp_dir();
+ let home = root.join("home").join(".claude");
+ let loader = PluginLoader::new(&home);
+ let plugins = loader.discover().expect("plugins should load");
+ assert!(plugins.iter().any(|plugin| plugin.source_kind == PluginSourceKind::Builtin));
+ assert!(plugins.iter().any(|plugin| plugin.source_kind == PluginSourceKind::Bundled));
+ fs::remove_dir_all(root).expect("cleanup");
+ }
+
+ #[test]
+ fn installs_and_lists_external_plugins() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ let source = root.join("source-plugin");
+ fs::create_dir_all(&cwd).expect("cwd should exist");
+ write_external_plugin(&source, "1.0.0", "v1");
+
+ let manager = PluginManager::new(&cwd, &home);
+ let result = manager.install_plugin(&source).expect("install should succeed");
+ assert_eq!(result.plugin_id, "sample-plugin@external");
+
+ let runtime_config = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect("config should load");
+ let plugins = manager
+ .list_plugins(&runtime_config)
+ .expect("plugins should list");
+ let external = plugins
+ .iter()
+ .find(|plugin| plugin.plugin.id == "sample-plugin@external")
+ .expect("external plugin should exist");
+ assert!(external.enabled);
+
+ let hook_config = manager
+ .active_hook_config(&runtime_config)
+ .expect("hook config should build");
+ assert_eq!(hook_config.pre_tool_use().len(), 1);
+ assert!(hook_config.pre_tool_use()[0].contains("sample-plugin-external"));
+
+ fs::remove_dir_all(root).expect("cleanup");
+ }
+
+ #[test]
+ fn disables_enables_updates_and_uninstalls_external_plugins() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ let source = root.join("source-plugin");
+ fs::create_dir_all(&cwd).expect("cwd should exist");
+ write_external_plugin(&source, "1.0.0", "v1");
+
+ let manager = PluginManager::new(&cwd, &home);
+ manager.install_plugin(&source).expect("install should succeed");
+ manager
+ .disable_plugin("sample-plugin")
+ .expect("disable should succeed");
+ let runtime_config = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect("config should load");
+ let plugins = manager
+ .list_plugins(&runtime_config)
+ .expect("plugins should list");
+ assert!(!plugins
+ .iter()
+ .find(|plugin| plugin.plugin.id == "sample-plugin@external")
+ .expect("external plugin should exist")
+ .enabled);
+
+ manager
+ .enable_plugin("sample-plugin@external")
+ .expect("enable should succeed");
+ write_external_plugin(&source, "2.0.0", "v2");
+ manager
+ .update_plugin("sample-plugin@external")
+ .expect("update should succeed");
+
+ let loader = PluginLoader::new(&home);
+ let plugins = loader.discover().expect("plugins should load");
+ let external = plugins
+ .iter()
+ .find(|plugin| plugin.id == "sample-plugin@external")
+ .expect("external plugin should exist");
+ assert_eq!(external.manifest.version, "2.0.0");
+
+ manager
+ .uninstall_plugin("sample-plugin@external")
+ .expect("uninstall should succeed");
+ let plugins = loader.discover().expect("plugins should reload");
+ assert!(!plugins
+ .iter()
+ .any(|plugin| plugin.id == "sample-plugin@external"));
+
+ fs::remove_dir_all(root).expect("cleanup");
+ }
+}
diff --git a/rust/crates/plugins/src/manifest.rs b/rust/crates/plugins/src/manifest.rs
new file mode 100644
index 00000000..449b0be6
--- /dev/null
+++ b/rust/crates/plugins/src/manifest.rs
@@ -0,0 +1,175 @@
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::PluginSourceKind;
+
+pub trait Plugin {
+ fn id(&self) -> &str;
+ fn manifest(&self) -> &PluginManifest;
+ fn source_kind(&self) -> PluginSourceKind;
+ fn root(&self) -> Option<&Path>;
+
+ fn resolved_hooks(&self) -> PluginHooks {
+ self.manifest().hooks.resolve(self.root())
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct PluginHooks {
+ #[serde(rename = "PreToolUse", alias = "preToolUse", default)]
+ pub pre_tool_use: Vec<String>,
+ #[serde(rename = "PostToolUse", alias = "postToolUse", default)]
+ pub post_tool_use: Vec<String>,
+}
+
+impl PluginHooks {
+ #[must_use]
+ pub fn resolve(&self, root: Option<&Path>) -> Self {
+ let Some(root) = root else {
+ return self.clone();
+ };
+ let replacement = root.display().to_string();
+ Self {
+ pre_tool_use: self
+ .pre_tool_use
+ .iter()
+ .map(|value| value.replace("${PLUGIN_DIR}", &replacement))
+ .collect(),
+ post_tool_use: self
+ .post_tool_use
+ .iter()
+ .map(|value| value.replace("${PLUGIN_DIR}", &replacement))
+ .collect(),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PluginManifest {
+ pub name: String,
+ pub description: String,
+ #[serde(default = "default_version")]
+ pub version: String,
+ #[serde(default)]
+ pub default_enabled: bool,
+ #[serde(default)]
+ pub hooks: PluginHooks,
+}
+
+impl PluginManifest {
+ pub fn validate(&self) -> Result<(), String> {
+ if self.name.trim().is_empty() {
+ return Err("plugin manifest name must not be empty".to_string());
+ }
+ if self.description.trim().is_empty() {
+ return Err(format!(
+ "plugin manifest description must not be empty for {}",
+ self.name
+ ));
+ }
+ if self.version.trim().is_empty() {
+ return Err(format!(
+ "plugin manifest version must not be empty for {}",
+ self.name
+ ));
+ }
+ if self
+ .hooks
+ .pre_tool_use
+ .iter()
+ .chain(self.hooks.post_tool_use.iter())
+ .any(|hook| hook.trim().is_empty())
+ {
+ return Err(format!(
+ "plugin manifest hook entries must not be empty for {}",
+ self.name
+ ));
+ }
+ Ok(())
+ }
+}
+
+fn default_version() -> String {
+ "0.1.0".to_string()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LoadedPlugin {
+ pub id: String,
+ pub source_kind: PluginSourceKind,
+ pub manifest: PluginManifest,
+ pub root: Option<PathBuf>,
+ pub origin: Option<PathBuf>,
+}
+
+impl LoadedPlugin {
+ #[must_use]
+ pub fn new(
+ id: String,
+ source_kind: PluginSourceKind,
+ manifest: PluginManifest,
+ root: Option<PathBuf>,
+ origin: Option<PathBuf>,
+ ) -> Self {
+ Self {
+ id,
+ source_kind,
+ manifest,
+ root,
+ origin,
+ }
+ }
+
+ #[must_use]
+ pub fn name(&self) -> &str {
+ &self.manifest.name
+ }
+}
+
+impl Plugin for LoadedPlugin {
+ fn id(&self) -> &str {
+ &self.id
+ }
+
+ fn manifest(&self) -> &PluginManifest {
+ &self.manifest
+ }
+
+ fn source_kind(&self) -> PluginSourceKind {
+ self.source_kind
+ }
+
+ fn root(&self) -> Option<&Path> {
+ self.root.as_deref()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{PluginHooks, PluginManifest};
+ use std::path::Path;
+
+ #[test]
+ fn validates_manifest_fields() {
+ let manifest = PluginManifest {
+ name: "demo".to_string(),
+ description: "demo plugin".to_string(),
+ version: "1.2.3".to_string(),
+ default_enabled: false,
+ hooks: PluginHooks::default(),
+ };
+ assert!(manifest.validate().is_ok());
+ }
+
+ #[test]
+ fn resolves_plugin_dir_placeholders() {
+ let hooks = PluginHooks {
+ pre_tool_use: vec!["echo ${PLUGIN_DIR}/pre".to_string()],
+ post_tool_use: vec!["echo ${PLUGIN_DIR}/post".to_string()],
+ };
+ let resolved = hooks.resolve(Some(Path::new("/tmp/plugin")));
+ assert_eq!(resolved.pre_tool_use, vec!["echo /tmp/plugin/pre"]);
+ assert_eq!(resolved.post_tool_use, vec!["echo /tmp/plugin/post"]);
+ }
+}
diff --git a/rust/crates/plugins/src/registry.rs b/rust/crates/plugins/src/registry.rs
new file mode 100644
index 00000000..a2f021d8
--- /dev/null
+++ b/rust/crates/plugins/src/registry.rs
@@ -0,0 +1,91 @@
+use std::path::Path;
+
+use serde::{Deserialize, Serialize};
+
+use crate::InstalledPluginRecord;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct PluginRegistry {
+ #[serde(default)]
+ pub plugins: Vec<InstalledPluginRecord>,
+}
+
+impl PluginRegistry {
+ pub fn load(path: &Path) -> Result<Self, String> {
+ match std::fs::read_to_string(path) {
+ Ok(contents) => {
+ if contents.trim().is_empty() {
+ return Ok(Self::default());
+ }
+ serde_json::from_str(&contents).map_err(|error| error.to_string())
+ }
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()),
+ Err(error) => Err(error.to_string()),
+ }
+ }
+
+ pub fn save(&self, path: &Path) -> Result<(), String> {
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
+ }
+ std::fs::write(
+ path,
+ serde_json::to_string_pretty(self).map_err(|error| error.to_string())?,
+ )
+ .map_err(|error| error.to_string())
+ }
+
+ #[must_use]
+ pub fn find(&self, plugin_id: &str) -> Option<&InstalledPluginRecord> {
+ self.plugins.iter().find(|plugin| plugin.id == plugin_id)
+ }
+
+ pub fn upsert(&mut self, record: InstalledPluginRecord) {
+ if let Some(existing) = self.plugins.iter_mut().find(|plugin| plugin.id == record.id) {
+ *existing = record;
+ } else {
+ self.plugins.push(record);
+ }
+ self.plugins.sort_by(|left, right| left.id.cmp(&right.id));
+ }
+
+ pub fn remove(&mut self, plugin_id: &str) -> Option<InstalledPluginRecord> {
+ let index = self.plugins.iter().position(|plugin| plugin.id == plugin_id)?;
+ Some(self.plugins.remove(index))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::PluginRegistry;
+ use crate::{InstalledPluginRecord, PluginSourceKind};
+
+ #[test]
+ fn upsert_replaces_existing_entries() {
+ let mut registry = PluginRegistry::default();
+ registry.upsert(InstalledPluginRecord {
+ id: "demo@external".to_string(),
+ name: "demo".to_string(),
+ version: "1.0.0".to_string(),
+ description: "demo".to_string(),
+ source_kind: PluginSourceKind::External,
+ source_path: "/src".to_string(),
+ install_path: "/install".to_string(),
+ installed_at: "t1".to_string(),
+ updated_at: "t1".to_string(),
+ });
+ registry.upsert(InstalledPluginRecord {
+ id: "demo@external".to_string(),
+ name: "demo".to_string(),
+ version: "1.0.1".to_string(),
+ description: "updated".to_string(),
+ source_kind: PluginSourceKind::External,
+ source_path: "/src".to_string(),
+ install_path: "/install".to_string(),
+ installed_at: "t1".to_string(),
+ updated_at: "t2".to_string(),
+ });
+ assert_eq!(registry.plugins.len(), 1);
+ assert_eq!(registry.plugins[0].version, "1.0.1");
+ }
+}
diff --git a/rust/crates/plugins/src/settings.rs b/rust/crates/plugins/src/settings.rs
new file mode 100644
index 00000000..5ce03675
--- /dev/null
+++ b/rust/crates/plugins/src/settings.rs
@@ -0,0 +1,106 @@
+use std::path::Path;
+
+use runtime::RuntimePluginConfig;
+use serde_json::{Map, Value};
+
+pub fn read_settings_file(path: &Path) -> Result<Map<String, Value>, String> {
+ match std::fs::read_to_string(path) {
+ Ok(contents) => {
+ if contents.trim().is_empty() {
+ return Ok(Map::new());
+ }
+ serde_json::from_str::<Value>(&contents)
+ .map_err(|error| error.to_string())?
+ .as_object()
+ .cloned()
+ .ok_or_else(|| "settings file must contain a JSON object".to_string())
+ }
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(Map::new()),
+ Err(error) => Err(error.to_string()),
+ }
+}
+
+pub fn write_settings_file(path: &Path, root: &Map<String, Value>) -> Result<(), String> {
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
+ }
+ std::fs::write(
+ path,
+ serde_json::to_string_pretty(root).map_err(|error| error.to_string())?,
+ )
+ .map_err(|error| error.to_string())
+}
+
+pub fn read_enabled_plugin_map(root: &Map<String, Value>) -> Map<String, Value> {
+ root.get("enabledPlugins")
+ .and_then(Value::as_object)
+ .cloned()
+ .unwrap_or_default()
+}
+
+pub fn write_plugin_state(
+ root: &mut Map<String, Value>,
+ plugin_id: &str,
+ enabled: Option<bool>,
+) {
+ let mut enabled_plugins = read_enabled_plugin_map(root);
+ match enabled {
+ Some(value) => {
+ enabled_plugins.insert(plugin_id.to_string(), Value::Bool(value));
+ }
+ None => {
+ enabled_plugins.remove(plugin_id);
+ }
+ }
+ if enabled_plugins.is_empty() {
+ root.remove("enabledPlugins");
+ } else {
+ root.insert("enabledPlugins".to_string(), Value::Object(enabled_plugins));
+ }
+}
+
+pub fn config_from_settings(root: &Map<String, Value>) -> RuntimePluginConfig {
+ let mut config = RuntimePluginConfig::default();
+ if let Some(enabled_plugins) = root.get("enabledPlugins").and_then(Value::as_object) {
+ for (plugin_id, enabled) in enabled_plugins {
+ match enabled.as_bool() {
+ Some(value) => config.set_plugin_state(plugin_id.clone(), value),
+ None => {}
+ }
+ }
+ }
+ config
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{config_from_settings, write_plugin_state};
+ use serde_json::{json, Map, Value};
+
+ #[test]
+ fn writes_and_removes_enabled_plugin_state() {
+ let mut root = Map::new();
+ write_plugin_state(&mut root, "demo@external", Some(true));
+ assert_eq!(
+ root.get("enabledPlugins"),
+ Some(&json!({"demo@external": true}))
+ );
+ write_plugin_state(&mut root, "demo@external", None);
+ assert_eq!(root.get("enabledPlugins"), None);
+ }
+
+ #[test]
+ fn converts_settings_to_runtime_plugin_config() {
+ let mut root = Map::<String, Value>::new();
+ root.insert(
+ "enabledPlugins".to_string(),
+ json!({"demo@external": true, "off@bundled": false}),
+ );
+ let config = config_from_settings(&root);
+ assert_eq!(
+ config.enabled_plugins().get("demo@external"),
+ Some(&true)
+ );
+ assert_eq!(config.enabled_plugins().get("off@bundled"), Some(&false));
+ }
+}
diff --git a/rust/crates/runtime/src/config.rs b/rust/crates/runtime/src/config.rs
index 368e7c57..dfc4d1a8 100644
--- a/rust/crates/runtime/src/config.rs
+++ b/rust/crates/runtime/src/config.rs
@@ -35,9 +35,19 @@ pub struct RuntimeConfig {
feature_config: RuntimeFeatureConfig,
}
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct RuntimePluginConfig {
+ enabled_plugins: BTreeMap<String, bool>,
+ external_directories: Vec<String>,
+ install_root: Option<String>,
+ registry_path: Option<String>,
+ bundled_root: Option<String>,
+}
+
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct RuntimeFeatureConfig {
hooks: RuntimeHookConfig,
+ plugins: RuntimePluginConfig,
mcp: McpConfigCollection,
oauth: Option<OAuthConfig>,
model: Option<String>,
@@ -174,13 +184,15 @@ impl ConfigLoader {
#[must_use]
pub fn default_for(cwd: impl Into<PathBuf>) -> Self {
let cwd = cwd.into();
- let config_home = std::env::var_os("CLAUDE_CONFIG_HOME")
- .map(PathBuf::from)
- .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude")))
- .unwrap_or_else(|| PathBuf::from(".claude"));
+ let config_home = default_config_home();
Self { cwd, config_home }
}
+ #[must_use]
+ pub fn config_home(&self) -> &Path {
+ &self.config_home
+ }
+
#[must_use]
pub fn discover(&self) -> Vec<ConfigEntry> {
let user_legacy_path = self.config_home.parent().map_or_else(
@@ -229,6 +241,7 @@ impl ConfigLoader {
let feature_config = RuntimeFeatureConfig {
hooks: parse_optional_hooks_config(&merged_value)?,
+ plugins: parse_optional_plugin_config(&merged_value)?,
mcp: McpConfigCollection {
servers: mcp_servers,
},
@@ -291,6 +304,11 @@ impl RuntimeConfig {
&self.feature_config.hooks
}
+ #[must_use]
+ pub fn plugins(&self) -> &RuntimePluginConfig {
+ &self.feature_config.plugins
+ }
+
#[must_use]
pub fn oauth(&self) -> Option<&OAuthConfig> {
self.feature_config.oauth.as_ref()
@@ -319,11 +337,22 @@ impl RuntimeFeatureConfig {
self
}
+ #[must_use]
+ pub fn with_plugins(mut self, plugins: RuntimePluginConfig) -> Self {
+ self.plugins = plugins;
+ self
+ }
+
#[must_use]
pub fn hooks(&self) -> &RuntimeHookConfig {
&self.hooks
}
+ #[must_use]
+ pub fn plugins(&self) -> &RuntimePluginConfig {
+ &self.plugins
+ }
+
#[must_use]
pub fn mcp(&self) -> &McpConfigCollection {
&self.mcp
@@ -350,6 +379,53 @@ impl RuntimeFeatureConfig {
}
}
+impl RuntimePluginConfig {
+ #[must_use]
+ pub fn enabled_plugins(&self) -> &BTreeMap<String, bool> {
+ &self.enabled_plugins
+ }
+
+ #[must_use]
+ pub fn external_directories(&self) -> &[String] {
+ &self.external_directories
+ }
+
+ #[must_use]
+ pub fn install_root(&self) -> Option<&str> {
+ self.install_root.as_deref()
+ }
+
+ #[must_use]
+ pub fn registry_path(&self) -> Option<&str> {
+ self.registry_path.as_deref()
+ }
+
+ #[must_use]
+ pub fn bundled_root(&self) -> Option<&str> {
+ self.bundled_root.as_deref()
+ }
+
+ pub fn set_plugin_state(&mut self, plugin_id: String, enabled: bool) {
+ self.enabled_plugins.insert(plugin_id, enabled);
+ }
+
+ #[must_use]
+ pub fn state_for(&self, plugin_id: &str, default_enabled: bool) -> bool {
+ self.enabled_plugins
+ .get(plugin_id)
+ .copied()
+ .unwrap_or(default_enabled)
+ }
+}
+
+#[must_use]
+pub fn default_config_home() -> PathBuf {
+ std::env::var_os("CLAUDE_CONFIG_HOME")
+ .map(PathBuf::from)
+ .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude")))
+ .unwrap_or_else(|| PathBuf::from(".claude"))
+}
+
impl RuntimeHookConfig {
#[must_use]
pub fn new(pre_tool_use: Vec<String>, post_tool_use: Vec<String>) -> Self {
@@ -368,6 +444,18 @@ impl RuntimeHookConfig {
pub fn post_tool_use(&self) -> &[String] {
&self.post_tool_use
}
+
+ #[must_use]
+ pub fn merged(&self, other: &Self) -> Self {
+ let mut merged = self.clone();
+ merged.extend(other);
+ merged
+ }
+
+ pub fn extend(&mut self, other: &Self) {
+ extend_unique(&mut self.pre_tool_use, other.pre_tool_use());
+ extend_unique(&mut self.post_tool_use, other.post_tool_use());
+ }
}
impl McpConfigCollection {
@@ -484,6 +572,36 @@ fn parse_optional_hooks_config(root: &JsonValue) -> Result<RuntimeHookConfig, Co
})
}
+fn parse_optional_plugin_config(root: &JsonValue) -> Result<RuntimePluginConfig, ConfigError> {
+ let Some(object) = root.as_object() else {
+ return Ok(RuntimePluginConfig::default());
+ };
+
+ let mut config = RuntimePluginConfig::default();
+ if let Some(enabled_plugins) = object.get("enabledPlugins") {
+ config.enabled_plugins = parse_bool_map(enabled_plugins, "merged settings.enabledPlugins")?;
+ }
+
+ let Some(plugins_value) = object.get("plugins") else {
+ return Ok(config);
+ };
+ let plugins = expect_object(plugins_value, "merged settings.plugins")?;
+
+ if let Some(enabled_value) = plugins.get("enabled") {
+ config.enabled_plugins = parse_bool_map(enabled_value, "merged settings.plugins.enabled")?;
+ }
+ config.external_directories =
+ optional_string_array(plugins, "externalDirectories", "merged settings.plugins")?
+ .unwrap_or_default();
+ config.install_root =
+ optional_string(plugins, "installRoot", "merged settings.plugins")?.map(str::to_string);
+ config.registry_path =
+ optional_string(plugins, "registryPath", "merged settings.plugins")?.map(str::to_string);
+ config.bundled_root =
+ optional_string(plugins, "bundledRoot", "merged settings.plugins")?.map(str::to_string);
+ Ok(config)
+}
+
fn parse_optional_permission_mode(
root: &JsonValue,
) -> Result<Option<ResolvedPermissionMode>, ConfigError> {
@@ -716,6 +834,24 @@ fn optional_u16(
}
}
+fn parse_bool_map(value: &JsonValue, context: &str) -> Result<BTreeMap<String, bool>, ConfigError> {
+ let Some(map) = value.as_object() else {
+ return Err(ConfigError::Parse(format!(
+ "{context}: expected JSON object"
+ )));
+ };
+ map.iter()
+ .map(|(key, value)| {
+ value
+ .as_bool()
+ .map(|enabled| (key.clone(), enabled))
+ .ok_or_else(|| {
+ ConfigError::Parse(format!("{context}: field {key} must be a boolean"))
+ })
+ })
+ .collect()
+}
+
fn optional_string_array(
object: &BTreeMap<String, JsonValue>,
key: &str,
@@ -790,6 +926,18 @@ fn deep_merge_objects(
}
}
+fn extend_unique(target: &mut Vec<String>, values: &[String]) {
+ for value in values {
+ push_unique(target, value.clone());
+ }
+}
+
+fn push_unique(target: &mut Vec<String>, value: String) {
+ if !target.iter().any(|existing| existing == &value) {
+ target.push(value);
+ }
+}
+
#[cfg(test)]
mod tests {
use super::{
@@ -1033,6 +1181,96 @@ mod tests {
fs::remove_dir_all(root).expect("cleanup temp dir");
}
+ #[test]
+ fn parses_plugin_config_from_enabled_plugins() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
+ fs::create_dir_all(&home).expect("home config dir");
+
+ fs::write(
+ home.join("settings.json"),
+ r#"{
+ "enabledPlugins": {
+ "tool-guard@builtin": true,
+ "sample-plugin@external": false
+ }
+ }"#,
+ )
+ .expect("write user settings");
+
+ let loaded = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect("config should load");
+
+ assert_eq!(
+ loaded.plugins().enabled_plugins().get("tool-guard@builtin"),
+ Some(&true)
+ );
+ assert_eq!(
+ loaded
+ .plugins()
+ .enabled_plugins()
+ .get("sample-plugin@external"),
+ Some(&false)
+ );
+
+ fs::remove_dir_all(root).expect("cleanup temp dir");
+ }
+
+ #[test]
+ fn parses_plugin_config() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
+ fs::create_dir_all(&home).expect("home config dir");
+
+ fs::write(
+ home.join("settings.json"),
+ r#"{
+ "enabledPlugins": {
+ "core-helpers@builtin": true
+ },
+ "plugins": {
+ "externalDirectories": ["./external-plugins"],
+ "installRoot": "plugin-cache/installed",
+ "registryPath": "plugin-cache/installed.json",
+ "bundledRoot": "./bundled-plugins"
+ }
+ }"#,
+ )
+ .expect("write plugin settings");
+
+ let loaded = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect("config should load");
+
+ assert_eq!(
+ loaded
+ .plugins()
+ .enabled_plugins()
+ .get("core-helpers@builtin"),
+ Some(&true)
+ );
+ assert_eq!(
+ loaded.plugins().external_directories(),
+ &["./external-plugins".to_string()]
+ );
+ assert_eq!(
+ loaded.plugins().install_root(),
+ Some("plugin-cache/installed")
+ );
+ assert_eq!(
+ loaded.plugins().registry_path(),
+ Some("plugin-cache/installed.json")
+ );
+ assert_eq!(loaded.plugins().bundled_root(), Some("./bundled-plugins"));
+
+ fs::remove_dir_all(root).expect("cleanup temp dir");
+ }
+
#[test]
fn rejects_invalid_mcp_server_shapes() {
let root = temp_dir();
diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rs
index 618923fd..edac6665 100644
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -28,7 +28,7 @@ pub use config::{
McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
- ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+ RuntimePluginConfig, ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
};
pub use conversation::{
auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
diff --git a/rust/crates/runtime/src/prompt.rs b/rust/crates/runtime/src/prompt.rs
index 6cfda445..91a3afca 100644
--- a/rust/crates/runtime/src/prompt.rs
+++ b/rust/crates/runtime/src/prompt.rs
@@ -421,7 +421,7 @@ fn render_config_section(config: &RuntimeConfig) -> String {
let mut lines = vec!["# Runtime config".to_string()];
if config.loaded_entries().is_empty() {
lines.extend(prepend_bullets(vec![
- "No Claw Code settings files loaded.".to_string(),
+ "No Claw Code settings files loaded.".to_string()
]));
return lines.join("\n");
}
diff --git a/rust/crates/rusty-claude-cli/Cargo.toml b/rust/crates/rusty-claude-cli/Cargo.toml
index 2ac67014..242ec0f5 100644
--- a/rust/crates/rusty-claude-cli/Cargo.toml
+++ b/rust/crates/rusty-claude-cli/Cargo.toml
@@ -17,6 +17,7 @@ crossterm = "0.28"
pulldown-cmark = "0.13"
rustyline = "15"
runtime = { path = "../runtime" }
+plugins = { path = "../plugins" }
serde_json = "1"
syntect = "5"
tokio = { version = "1", features = ["rt-multi-thread", "time"] }
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index 7cb70dec..313706f5 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -2,7 +2,7 @@ mod init;
mod input;
mod render;
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeSet;
use std::env;
use std::fs;
use std::io::{self, Read, Write};
@@ -22,6 +22,7 @@ use commands::{
};
use compat_harness::{extract_manifest, UpstreamPaths};
use init::initialize_repo;
+use plugins::{PluginListEntry, PluginManager};
use render::{MarkdownStreamState, Spinner, TerminalRenderer};
use runtime::{
clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
@@ -928,6 +929,7 @@ fn run_resume_command(
| SlashCommand::Model { .. }
| SlashCommand::Permissions { .. }
| SlashCommand::Session { .. }
+ | SlashCommand::Plugins { .. }
| SlashCommand::Unknown(_) => Err("unsupported resumed slash command".into()),
}
}
@@ -1217,6 +1219,9 @@ impl LiveCli {
SlashCommand::Session { action, target } => {
self.handle_session_command(action.as_deref(), target.as_deref())?
}
+ SlashCommand::Plugins { action, target } => {
+ self.handle_plugins_command(action.as_deref(), target.as_deref())?
+ }
SlashCommand::Unknown(name) => {
eprintln!("unknown slash command: /{name}");
false
@@ -1479,6 +1484,87 @@ impl LiveCli {
}
}
+ fn handle_plugins_command(
+ &mut self,
+ action: Option<&str>,
+ target: Option<&str>,
+ ) -> Result<bool, Box<dyn std::error::Error>> {
+ let cwd = env::current_dir()?;
+ let runtime_config = ConfigLoader::default_for(&cwd).load()?;
+ let manager = PluginManager::default_for(&cwd);
+
+ match action {
+ None | Some("list") => {
+ let plugins = manager.list_plugins(&runtime_config)?;
+ println!("{}", render_plugins_report(&plugins));
+ }
+ Some("install") => {
+ let Some(target) = target else {
+ println!("Usage: /plugins install <path>");
+ return Ok(false);
+ };
+ let result = manager.install_plugin(PathBuf::from(target))?;
+ println!("Plugins\n Result {}", result.message);
+ self.reload_runtime_features()?;
+ }
+ Some("enable") => {
+ let Some(target) = target else {
+ println!("Usage: /plugins enable <plugin-id>");
+ return Ok(false);
+ };
+ let result = manager.enable_plugin(target)?;
+ println!("Plugins\n Result {}", result.message);
+ self.reload_runtime_features()?;
+ }
+ Some("disable") => {
+ let Some(target) = target else {
+ println!("Usage: /plugins disable <plugin-id>");
+ return Ok(false);
+ };
+ let result = manager.disable_plugin(target)?;
+ println!("Plugins\n Result {}", result.message);
+ self.reload_runtime_features()?;
+ }
+ Some("uninstall") => {
+ let Some(target) = target else {
+ println!("Usage: /plugins uninstall <plugin-id>");
+ return Ok(false);
+ };
+ let result = manager.uninstall_plugin(target)?;
+ println!("Plugins\n Result {}", result.message);
+ self.reload_runtime_features()?;
+ }
+ Some("update") => {
+ let Some(target) = target else {
+ println!("Usage: /plugins update <plugin-id>");
+ return Ok(false);
+ };
+ let result = manager.update_plugin(target)?;
+ println!("Plugins\n Result {}", result.message);
+ self.reload_runtime_features()?;
+ }
+ Some(other) => {
+ println!(
+ "Unknown /plugins action '{other}'. Use list, install, enable, disable, uninstall, or update."
+ );
+ }
+ }
+ Ok(false)
+ }
+
+ fn reload_runtime_features(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+ self.runtime = build_runtime(
+ self.runtime.session().clone(),
+ self.model.clone(),
+ self.system_prompt.clone(),
+ true,
+ true,
+ self.allowed_tools.clone(),
+ self.permission_mode,
+ )?;
+ self.persist_session()
+ }
+
fn compact(&mut self) -> Result<(), Box<dyn std::error::Error>> {
let result = self.runtime.compact(CompactionConfig::default());
let removed = result.removed_message_count;
@@ -1536,6 +1622,7 @@ impl LiveCli {
Ok(())
}
+ #[allow(clippy::unused_self)]
fn run_teleport(&self, target: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
let Some(target) = target.map(str::trim).filter(|value| !value.is_empty()) else {
println!("Usage: /teleport <symbol-or-path>");
@@ -1771,6 +1858,34 @@ fn render_repl_help() -> String {
)
}
+fn render_plugins_report(plugins: &[PluginListEntry]) -> String {
+ let mut lines = vec!["Plugins".to_string()];
+ if plugins.is_empty() {
+ lines.push(" No plugins discovered.".to_string());
+ return lines.join("\n");
+ }
+ for plugin in plugins {
+ let kind = format!("{:?}", plugin.plugin.source_kind).to_lowercase();
+ let location = plugin
+ .plugin
+ .root
+ .as_ref()
+ .map_or_else(|| kind.clone(), |root| root.display().to_string());
+ let enabled = if plugin.enabled {
+ "enabled"
+ } else {
+ "disabled"
+ };
+ lines.push(format!(
+ " {id:<24} {kind:<8} {enabled:<8} v{version:<8} {location}",
+ id = plugin.plugin.id,
+ kind = kind,
+ version = plugin.plugin.manifest.version,
+ ));
+ }
+ lines.join("\n")
+}
+
fn status_context(
session_path: Option<&Path>,
) -> Result<StatusContext, Box<dyn std::error::Error>> {
@@ -1894,9 +2009,12 @@ fn render_config_report(section: Option<&str>) -> Result<String, Box<dyn std::er
"env" => runtime_config.get("env"),
"hooks" => runtime_config.get("hooks"),
"model" => runtime_config.get("model"),
+ "plugins" => runtime_config
+ .get("plugins")
+ .or_else(|| runtime_config.get("enabledPlugins")),
other => {
lines.push(format!(
- " Unsupported config section '{other}'. Use env, hooks, or model."
+ " Unsupported config section '{other}'. Use env, hooks, model, or plugins."
));
return Ok(lines.join(
"
@@ -2309,12 +2427,17 @@ fn build_system_prompt() -> Result<Vec<String>, Box<dyn std::error::Error>> {
fn build_runtime_feature_config(
) -> Result<runtime::RuntimeFeatureConfig, Box<dyn std::error::Error>> {
let cwd = env::current_dir()?;
- Ok(ConfigLoader::default_for(cwd)
- .load()?
+ let loader = ConfigLoader::default_for(&cwd);
+ let runtime_config = loader.load()?;
+ let plugin_manager = PluginManager::default_for(&cwd);
+ let plugin_hooks = plugin_manager.active_hook_config(&runtime_config)?;
+ Ok(runtime_config
.feature_config()
- .clone())
+ .clone()
+ .with_hooks(runtime_config.hooks().merged(&plugin_hooks)))
}
+#[allow(clippy::needless_pass_by_value)]
fn build_runtime(
session: Session,
model: String,
@@ -3449,7 +3572,7 @@ mod tests {
.into_iter()
.map(str::to_string)
.collect();
- let filtered = filter_tool_specs(Some(&allowed));
+ let filtered = filter_tool_specs(&GlobalToolRegistry::builtin(), Some(&allowed));
let names = filtered
.into_iter()
.map(|spec| spec.name)
@@ -3475,13 +3598,16 @@ mod tests {
assert!(help.contains("/clear [--confirm]"));
assert!(help.contains("/cost"));
assert!(help.contains("/resume <session-path>"));
- assert!(help.contains("/config [env|hooks|model]"));
+ assert!(help.contains("/config [env|hooks|model|plugins]"));
assert!(help.contains("/memory"));
assert!(help.contains("/init"));
assert!(help.contains("/diff"));
assert!(help.contains("/version"));
assert!(help.contains("/export [file]"));
assert!(help.contains("/session [list|switch <session-id>]"));
+ assert!(help.contains(
+ "/plugins [list|install <source>|enable <id>|disable <id>|uninstall <id>|update <id>]"
+ ));
assert!(help.contains("/exit"));
}
@@ -3632,6 +3758,9 @@ mod tests {
fn config_report_supports_section_views() {
let report = render_config_report(Some("env")).expect("config report should render");
assert!(report.contains("Merged section: env"));
+ let plugins_report =
+ render_config_report(Some("plugins")).expect("plugins config report should render");
+ assert!(plugins_report.contains("Merged section: plugins"));
}
#[test]