feat(plugin): add secure GitHub plugin lifecycle

Author: yansigit

Cargo.lock

@@ -79,6 +79,13 @@ pub struct ManualToolCompleted {
     pub duration_ms: u64,
 }
 
+#[derive(Clone, Debug)]
+pub struct PluginOperationCompleted {
+    pub session_id: String,
+    pub output: String,
+    pub success: bool,
+}
+
 /// Type of file operation for swarm awareness
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub enum FileOp {
@@ -397,6 +404,8 @@ pub enum BusEvent {
     TodoUpdated(TodoEvent),
     SubagentStatus(SubagentStatus),
     ManualToolCompleted(ManualToolCompleted),
+    /// A local `/plugin` operation completed off the UI thread.
+    PluginOperationCompleted(PluginOperationCompleted),
     BatchProgress(BatchProgress),
     /// File was touched by an agent (for swarm conflict detection)
     FileTouch(FileTouch),

crates/jcode-base/src/bus.rs

@@ -1,5 +1,5 @@
 use super::{ExtensionError, PROVIDER_MANIFEST_FILE, ProviderManifest};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, de::Error as _};
 use std::collections::BTreeSet;
 use std::fs::{self, File};
 use std::io::{self, Read};
@@ -46,7 +46,7 @@ pub struct PluginManifest {
     pub version: String,
     #[serde(default)]
     pub description: Option<String>,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "deserialize_author")]
     pub author: Option<String>,
     #[serde(default)]
     pub homepage: Option<String>,
@@ -62,6 +62,23 @@ fn default_plugin_manifest_version() -> u32 {
     PLUGIN_MANIFEST_VERSION
 }
 
+fn deserialize_author<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
+    match value {
+        None => Ok(None),
+        Some(serde_json::Value::String(author)) => Ok(Some(author)),
+        Some(serde_json::Value::Object(author)) => author
+            .get("name")
+            .and_then(serde_json::Value::as_str)
+            .map(|name| Some(name.to_string()))
+            .ok_or_else(|| D::Error::custom("author object must contain a string name")),
+        Some(_) => Err(D::Error::custom("author must be a string or object")),
+    }
+}
+
 impl PluginManifest {
     fn validate(&self) -> Result<(), BundleError> {
         if self.manifest_version != PLUGIN_MANIFEST_VERSION {
@@ -184,11 +201,10 @@ impl PluginBundle {
         .into_iter()
         .filter(|path| path.is_file())
         .collect::<Vec<_>>();
-        let manifest_path = match manifest_candidates.as_slice() {
-            [] => return Err(BundleError::MissingManifest),
-            [path] => path.clone(),
-            paths => return Err(BundleError::AmbiguousManifest(paths.to_vec())),
-        };
+        let manifest_path = manifest_candidates
+            .first()
+            .cloned()
+            .ok_or(BundleError::MissingManifest)?;
 
         let manifest_bytes = read_bounded(&manifest_path, MAX_PLUGIN_MANIFEST_BYTES).map_err(
             |error| match error {
@@ -210,6 +226,29 @@ impl PluginBundle {
                 }
             })?;
         manifest.validate()?;
+        for candidate in manifest_candidates.iter().skip(1) {
+            let candidate_bytes = read_bounded(candidate, MAX_PLUGIN_MANIFEST_BYTES).map_err(
+                |error| match error {
+                    BoundedReadError::TooLarge => BundleError::ManifestTooLarge {
+                        path: candidate.clone(),
+                        limit: MAX_PLUGIN_MANIFEST_BYTES,
+                    },
+                    BoundedReadError::Io(source) => BundleError::Read {
+                        path: candidate.clone(),
+                        source,
+                    },
+                },
+            )?;
+            let candidate_manifest: PluginManifest = serde_json::from_slice(&candidate_bytes)
+                .map_err(|source| BundleError::ParseManifest {
+                    path: candidate.clone(),
+                    source,
+                })?;
+            candidate_manifest.validate()?;
+            if !compatible_manifests(&manifest, &candidate_manifest) {
+                return Err(BundleError::AmbiguousManifest(manifest_candidates));
+            }
+        }
 
         let provider_path = root.join(PROVIDER_MANIFEST_FILE);
         let provider_manifest = if provider_path.is_file() {
@@ -236,6 +275,22 @@ impl PluginBundle {
     }
 }
 
+fn compatible_manifests(left: &PluginManifest, right: &PluginManifest) -> bool {
+    left.manifest_version == right.manifest_version
+        && left.name == right.name
+        && left.version == right.version
+        && optional_field_matches(&left.homepage, &right.homepage)
+        && optional_field_matches(&left.repository, &right.repository)
+        && optional_field_matches(&left.license, &right.license)
+}
+
+fn optional_field_matches(left: &Option<String>, right: &Option<String>) -> bool {
+    match (left, right) {
+        (Some(left), Some(right)) => left == right,
+        _ => true,
+    }
+}
+
 fn discover_skills(root: &Path) -> Result<Vec<SkillMetadata>, BundleError> {
     let skills_root = root.join("skills");
     if !skills_root.is_dir() {
@@ -474,4 +529,50 @@ mod tests {
             Err(BundleError::AmbiguousManifest(_))
         ));
     }
+
+    #[test]
+    fn accepts_equivalent_claude_and_codex_manifests() {
+        let dir = tempdir().unwrap();
+        fs::create_dir_all(dir.path().join(".claude-plugin")).unwrap();
+        fs::create_dir_all(dir.path().join(".codex-plugin")).unwrap();
+        let manifest = r#"{"name":"shared-plugin","version":"1.0.0"}"#;
+        fs::write(dir.path().join(".claude-plugin/plugin.json"), manifest).unwrap();
+        fs::write(dir.path().join(".codex-plugin/plugin.json"), manifest).unwrap();
+
+        let bundle = PluginBundle::load(dir.path()).unwrap();
+        assert_eq!(bundle.manifest.name, "shared-plugin");
+    }
+
+    #[test]
+    fn accepts_platform_specific_metadata_for_same_plugin_identity() {
+        let dir = tempdir().unwrap();
+        fs::create_dir_all(dir.path().join(".claude-plugin")).unwrap();
+        fs::create_dir_all(dir.path().join(".codex-plugin")).unwrap();
+        fs::write(
+            dir.path().join(".codex-plugin/plugin.json"),
+            r#"{"name":"shared-plugin","version":"1.0.0","description":"Codex description","keywords":["codex"],"repository":"https://github.com/example/shared-plugin"}"#,
+        )
+        .unwrap();
+        fs::write(
+            dir.path().join(".claude-plugin/plugin.json"),
+            r#"{"name":"shared-plugin","version":"1.0.0","description":"Claude description","keywords":["claude"],"repository":"https://github.com/example/shared-plugin"}"#,
+        )
+        .unwrap();
+
+        let bundle = PluginBundle::load(dir.path()).unwrap();
+        assert_eq!(bundle.manifest.name, "shared-plugin");
+    }
+
+    #[test]
+    fn accepts_structured_author_metadata() {
+        let dir = tempdir().unwrap();
+        fs::write(
+            dir.path().join("plugin.json"),
+            r#"{"name":"structured-author","version":"1.0.0","author":{"name":"Jesse Vincent","email":"jesse@example.com"}}"#,
+        )
+        .unwrap();
+
+        let bundle = PluginBundle::load(dir.path()).unwrap();
+        assert_eq!(bundle.manifest.author.as_deref(), Some("Jesse Vincent"));
+    }
 }

crates/jcode-provider-extensions/src/bundle.rs

@@ -5,12 +5,17 @@
 //! deadlines, cancellation, and frame limits outside the persistence layer.
 
 mod bundle;
+mod remote;
 mod runtime;
 
 pub use bundle::{
     BundleComponents, BundleError, PLUGIN_MANIFEST_VERSION, PluginBundle, PluginManifest,
     SkillMetadata,
 };
+pub use remote::{
+    InstalledPlugin, PluginInstallMetadata, PluginSource, PluginStore, PluginStoreSnapshot,
+    RemotePluginError,
+};
 pub use runtime::{
     EmbeddedExtension, EmbeddedExtensionManifest, ExtensionBackend, ExtensionEvent,
     ExtensionInvocation, ExtensionRequest, ExtensionRuntimeRegistry,
@@ -86,6 +91,8 @@ pub enum ExtensionError {
     RequestFailed(String),
     #[error("extension cancellation is not supported by '{0}'")]
     CancellationUnsupported(String),
+    #[error("plugin operation failed: {0}")]
+    Plugin(#[from] RemotePluginError),
 }
 
 #[derive(Debug, Clone, Default)]
@@ -498,6 +505,41 @@ impl ProviderRegistry {
         Ok(())
     }
 
+    /// Register a provider from an installed plugin, or update that plugin's
+    /// existing provider while preserving its enabled and trust state.
+    ///
+    /// A provider ID may only be replaced when the previous source is inside
+    /// the same plugin root. This prevents a plugin install from silently
+    /// taking over an unrelated user-managed provider with the same ID.
+    pub fn register_or_update_plugin(
+        &mut self,
+        manifest: ProviderManifest,
+        source: PathBuf,
+        plugin_root: &Path,
+        trusted: bool,
+    ) -> Result<(), ExtensionError> {
+        manifest.validate()?;
+        if !source.starts_with(plugin_root) {
+            return Err(ExtensionError::InvalidManifest(
+                "plugin provider source must remain inside its plugin root".to_string(),
+            ));
+        }
+        if let Some(existing) = self.providers.get_mut(&manifest.id) {
+            if !existing
+                .source
+                .as_deref()
+                .is_some_and(|path| path.starts_with(plugin_root))
+            {
+                return Err(ExtensionError::DuplicateProvider(manifest.id));
+            }
+            existing.manifest = manifest;
+            existing.source = Some(source);
+            existing.trusted |= trusted;
+            return Ok(());
+        }
+        self.register(manifest, Some(source), trusted)
+    }
+
     pub fn remove(&mut self, id: &str) -> Result<ProviderRecord, ExtensionError> {
         self.providers
             .remove(id)
@@ -513,6 +555,15 @@ impl ProviderRegistry {
         Ok(())
     }
 
+    pub fn set_trusted(&mut self, id: &str, trusted: bool) -> Result<(), ExtensionError> {
+        let record = self
+            .providers
+            .get_mut(id)
+            .ok_or_else(|| ExtensionError::MissingProvider(id.to_string()))?;
+        record.trusted = trusted;
+        Ok(())
+    }
+
     pub fn save(&self) -> Result<(), ExtensionError> {
         if let Some(parent) = self.path.parent() {
             fs::create_dir_all(parent).map_err(|source| ExtensionError::Write {
@@ -628,6 +679,35 @@ permissions = ["network"]
         assert_eq!(loaded.list().count(), 0);
     }
 
+    #[test]
+    fn plugin_provider_update_preserves_state_and_rejects_foreign_owner() {
+        let dir = tempdir().unwrap();
+        let plugin_root = dir.path().join("plugin");
+        let old_source = plugin_root.join("versions/1.0.0+old");
+        let new_source = plugin_root.join("versions/1.1.0+new");
+        let foreign_source = dir.path().join("other/versions/1.1.0+new");
+        let mut registry = ProviderRegistry::open(dir.path().join("providers.json")).unwrap();
+        registry
+            .register(manifest("fixture-provider"), Some(old_source), true)
+            .unwrap();
+        registry.set_enabled("fixture-provider", false).unwrap();
+
+        let mut updated = manifest("fixture-provider");
+        updated.version = "1.1.0".to_string();
+        registry
+            .register_or_update_plugin(updated.clone(), new_source, &plugin_root, false)
+            .unwrap();
+        let record = registry.get("fixture-provider").unwrap();
+        assert_eq!(record.manifest.version, "1.1.0");
+        assert!(!record.enabled);
+        assert!(record.trusted);
+
+        assert!(matches!(
+            registry.register_or_update_plugin(updated, foreign_source, &plugin_root, false,),
+            Err(ExtensionError::InvalidManifest(_))
+        ));
+    }
+
     #[test]
     fn missing_registry_starts_empty() {
         let dir = tempdir().unwrap();