Move plugin out of core. (#20348)

codex-rs/core-plugins/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod installed_marketplaces;
 pub mod loader;
+mod manager;
 pub mod manifest;
 pub mod marketplace;
 pub mod marketplace_add;
@@ -8,8 +9,11 @@ pub mod marketplace_upgrade;
 pub mod remote;
 pub mod remote_bundle;
 pub mod remote_legacy;
+pub(crate) mod startup_remote_sync;
 pub mod startup_sync;
 pub mod store;
+#[cfg(test)]
+mod test_support;
 pub mod toggles;
 
 pub const OPENAI_CURATED_MARKETPLACE_NAME: &str = "openai-curated";
@@ -32,3 +36,24 @@ pub const TOOL_SUGGEST_DISCOVERABLE_PLUGIN_ALLOWLIST: &[&str] = &[
     "chrome@openai-bundled",
     "computer-use@openai-bundled",
 ];
+
+pub type LoadedPlugin = codex_plugin::LoadedPlugin<codex_config::McpServerConfig>;
+pub type PluginLoadOutcome = codex_plugin::PluginLoadOutcome<codex_config::McpServerConfig>;
+
+pub use manager::ConfiguredMarketplace;
+pub use manager::ConfiguredMarketplaceListOutcome;
+pub use manager::ConfiguredMarketplacePlugin;
+pub use manager::PluginDetail;
+pub use manager::PluginDetailsUnavailableReason;
+pub use manager::PluginInstallError;
+pub use manager::PluginInstallOutcome;
+pub use manager::PluginInstallRequest;
+pub use manager::PluginReadOutcome;
+pub use manager::PluginReadRequest;
+pub use manager::PluginRemoteSyncError;
+pub use manager::PluginUninstallError;
+pub use manager::PluginsConfigInput;
+pub use manager::PluginsManager;
+pub use manager::RemotePluginSyncResult;
+pub use marketplace_upgrade::ConfiguredMarketplaceUpgradeError as PluginMarketplaceUpgradeError;
+pub use marketplace_upgrade::ConfiguredMarketplaceUpgradeOutcome as PluginMarketplaceUpgradeOutcome;

codex-rs/core-plugins/src/startup_remote_sync.rs

@@ -0,0 +1,100 @@
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::manager::PluginsConfigInput;
+use crate::manager::PluginsManager;
+use crate::startup_sync::has_local_curated_plugins_snapshot;
+use codex_login::AuthManager;
+use tracing::info;
+use tracing::warn;
+
+const STARTUP_REMOTE_PLUGIN_SYNC_MARKER_FILE: &str = ".tmp/app-server-remote-plugin-sync-v1";
+const STARTUP_REMOTE_PLUGIN_SYNC_PREREQUISITE_TIMEOUT: Duration = Duration::from_secs(10);
+
+pub(crate) fn start_startup_remote_plugin_sync_once(
+    manager: Arc<PluginsManager>,
+    codex_home: PathBuf,
+    config: PluginsConfigInput,
+    auth_manager: Arc<AuthManager>,
+) {
+    let marker_path = startup_remote_plugin_sync_marker_path(codex_home.as_path());
+    if marker_path.is_file() {
+        return;
+    }
+
+    tokio::spawn(async move {
+        if marker_path.is_file() {
+            return;
+        }
+
+        if !wait_for_startup_remote_plugin_sync_prerequisites(codex_home.as_path()).await {
+            warn!(
+                codex_home = %codex_home.display(),
+                "skipping startup remote plugin sync because curated marketplace is not ready"
+            );
+            return;
+        }
+
+        let auth = auth_manager.auth().await;
+        match manager
+            .sync_plugins_from_remote(&config, auth.as_ref(), /*additive_only*/ true)
+            .await
+        {
+            Ok(sync_result) => {
+                info!(
+                    installed_plugin_ids = ?sync_result.installed_plugin_ids,
+                    enabled_plugin_ids = ?sync_result.enabled_plugin_ids,
+                    disabled_plugin_ids = ?sync_result.disabled_plugin_ids,
+                    uninstalled_plugin_ids = ?sync_result.uninstalled_plugin_ids,
+                    "completed startup remote plugin sync"
+                );
+                if let Err(err) =
+                    write_startup_remote_plugin_sync_marker(codex_home.as_path()).await
+                {
+                    warn!(
+                        error = %err,
+                        path = %marker_path.display(),
+                        "failed to persist startup remote plugin sync marker"
+                    );
+                }
+            }
+            Err(err) => {
+                warn!(
+                    error = %err,
+                    "startup remote plugin sync failed; will retry on next app-server start"
+                );
+            }
+        }
+    });
+}
+
+fn startup_remote_plugin_sync_marker_path(codex_home: &Path) -> PathBuf {
+    codex_home.join(STARTUP_REMOTE_PLUGIN_SYNC_MARKER_FILE)
+}
+
+async fn wait_for_startup_remote_plugin_sync_prerequisites(codex_home: &Path) -> bool {
+    let deadline = tokio::time::Instant::now() + STARTUP_REMOTE_PLUGIN_SYNC_PREREQUISITE_TIMEOUT;
+    loop {
+        if has_local_curated_plugins_snapshot(codex_home) {
+            return true;
+        }
+        if tokio::time::Instant::now() >= deadline {
+            return false;
+        }
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
+}
+
+async fn write_startup_remote_plugin_sync_marker(codex_home: &Path) -> std::io::Result<()> {
+    let marker_path = startup_remote_plugin_sync_marker_path(codex_home);
+    if let Some(parent) = marker_path.parent() {
+        tokio::fs::create_dir_all(parent).await?;
+    }
+    tokio::fs::write(marker_path, b"ok\n").await
+}
+
+#[cfg(test)]
+#[path = "startup_remote_sync_tests.rs"]
+mod tests;

codex-rs/core-plugins/src/startup_remote_sync_tests.rs

@@ -0,0 +1,91 @@
+use super::*;
+use crate::PluginsManager;
+use crate::startup_sync::curated_plugins_repo_path;
+use crate::test_support::TEST_CURATED_PLUGIN_CACHE_VERSION;
+use crate::test_support::load_plugins_config;
+use crate::test_support::write_curated_plugin_sha;
+use crate::test_support::write_file;
+use crate::test_support::write_openai_curated_marketplace;
+use codex_config::CONFIG_TOML_FILE;
+use codex_login::AuthManager;
+use codex_login::CodexAuth;
+use pretty_assertions::assert_eq;
+use std::sync::Arc;
+use std::time::Duration;
+use tempfile::tempdir;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+#[tokio::test]
+async fn startup_remote_plugin_sync_writes_marker_and_reconciles_state() {
+    let tmp = tempdir().expect("tempdir");
+    let curated_root = curated_plugins_repo_path(tmp.path());
+    write_openai_curated_marketplace(&curated_root, &["linear"]);
+    write_curated_plugin_sha(tmp.path());
+    write_file(
+        &tmp.path().join(CONFIG_TOML_FILE),
+        r#"[features]
+plugins = true
+
+[plugins."linear@openai-curated"]
+enabled = false
+"#,
+    );
+
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path("/backend-api/plugins/list"))
+        .and(header("authorization", "Bearer Access Token"))
+        .and(header("chatgpt-account-id", "account_id"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(
+            r#"[
+  {"id":"1","name":"linear","marketplace_name":"openai-curated","version":"1.0.0","enabled":true}
+]"#,
+        ))
+        .mount(&server)
+        .await;
+
+    let mut config = load_plugins_config(tmp.path(), tmp.path()).await;
+    config.chatgpt_base_url = format!("{}/backend-api/", server.uri());
+    let manager = Arc::new(PluginsManager::new(tmp.path().to_path_buf()));
+    let auth_manager =
+        AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());
+
+    start_startup_remote_plugin_sync_once(
+        Arc::clone(&manager),
+        tmp.path().to_path_buf(),
+        config,
+        auth_manager,
+    );
+
+    let marker_path = tmp.path().join(STARTUP_REMOTE_PLUGIN_SYNC_MARKER_FILE);
+    tokio::time::timeout(Duration::from_secs(5), async {
+        loop {
+            if marker_path.is_file() {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .expect("marker should be written");
+
+    assert!(
+        tmp.path()
+            .join(format!(
+                "plugins/cache/openai-curated/linear/{TEST_CURATED_PLUGIN_CACHE_VERSION}"
+            ))
+            .is_dir()
+    );
+    let config =
+        std::fs::read_to_string(tmp.path().join(CONFIG_TOML_FILE)).expect("config should exist");
+    assert!(config.contains(r#"[plugins."linear@openai-curated"]"#));
+    assert!(config.contains("enabled = true"));
+
+    let marker_contents = std::fs::read_to_string(marker_path).expect("marker should be readable");
+    assert_eq!(marker_contents, "ok\n");
+}

codex-rs/core-plugins/src/test_support.rs

@@ -0,0 +1,139 @@
+use std::fs;
+use std::path::Path;
+
+use crate::OPENAI_CURATED_MARKETPLACE_NAME;
+use crate::PluginsConfigInput;
+use codex_config::CloudRequirementsLoader;
+use codex_config::LoaderOverrides;
+use codex_config::NoopThreadConfigLoader;
+use codex_config::loader::load_config_layers_state;
+use codex_exec_server::LOCAL_FS;
+use codex_utils_absolute_path::AbsolutePathBuf;
+use toml::Value;
+
+pub(crate) const TEST_CURATED_PLUGIN_SHA: &str = "0123456789abcdef0123456789abcdef01234567";
+pub(crate) const TEST_CURATED_PLUGIN_CACHE_VERSION: &str = "01234567";
+
+pub(crate) fn write_file(path: &Path, contents: &str) {
+    fs::create_dir_all(path.parent().expect("file should have a parent")).unwrap();
+    fs::write(path, contents).unwrap();
+}
+
+pub(crate) fn write_curated_plugin(root: &Path, plugin_name: &str) {
+    let plugin_root = root.join("plugins").join(plugin_name);
+    write_file(
+        &plugin_root.join(".codex-plugin/plugin.json"),
+        &format!(
+            r#"{{
+  "name": "{plugin_name}",
+  "description": "Plugin that includes skills, MCP servers, and app connectors"
+}}"#
+        ),
+    );
+    write_file(
+        &plugin_root.join("skills/SKILL.md"),
+        "---\nname: sample\ndescription: sample\n---\n",
+    );
+    write_file(
+        &plugin_root.join(".mcp.json"),
+        r#"{
+  "mcpServers": {
+    "sample-docs": {
+      "type": "http",
+      "url": "https://sample.example/mcp"
+    }
+  }
+}"#,
+    );
+    write_file(
+        &plugin_root.join(".app.json"),
+        r#"{
+  "apps": {
+    "calendar": {
+      "id": "connector_calendar"
+    }
+  }
+}"#,
+    );
+}
+
+pub(crate) fn write_openai_curated_marketplace(root: &Path, plugin_names: &[&str]) {
+    let plugins = plugin_names
+        .iter()
+        .map(|plugin_name| {
+            format!(
+                r#"{{
+      "name": "{plugin_name}",
+      "source": {{
+        "source": "local",
+        "path": "./plugins/{plugin_name}"
+      }}
+    }}"#
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(",\n");
+    write_file(
+        &root.join(".agents/plugins/marketplace.json"),
+        &format!(
+            r#"{{
+  "name": "{OPENAI_CURATED_MARKETPLACE_NAME}",
+  "plugins": [
+{plugins}
+  ]
+}}"#
+        ),
+    );
+    for plugin_name in plugin_names {
+        write_curated_plugin(root, plugin_name);
+    }
+}
+
+pub(crate) fn write_curated_plugin_sha(codex_home: &Path) {
+    write_curated_plugin_sha_with(codex_home, TEST_CURATED_PLUGIN_SHA);
+}
+
+pub(crate) fn write_curated_plugin_sha_with(codex_home: &Path, sha: &str) {
+    write_file(&codex_home.join(".tmp/plugins.sha"), &format!("{sha}\n"));
+}
+
+pub(crate) async fn load_plugins_config(codex_home: &Path, cwd: &Path) -> PluginsConfigInput {
+    let codex_home = AbsolutePathBuf::try_from(codex_home).expect("codex home should be absolute");
+    let cwd = AbsolutePathBuf::try_from(cwd).expect("cwd should be absolute");
+    let config_layer_stack = load_config_layers_state(
+        LOCAL_FS.as_ref(),
+        codex_home.as_path(),
+        Some(cwd),
+        &[],
+        LoaderOverrides::without_managed_config_for_tests(),
+        CloudRequirementsLoader::default(),
+        &NoopThreadConfigLoader,
+    )
+    .await
+    .expect("config should load");
+    let effective_config = config_layer_stack.effective_config();
+    PluginsConfigInput::new(
+        config_layer_stack,
+        feature_enabled(&effective_config, "plugins", /*default_enabled*/ true),
+        feature_enabled(
+            &effective_config,
+            "remote_plugin",
+            /*default_enabled*/ false,
+        ),
+        feature_enabled(
+            &effective_config,
+            "plugin_hooks",
+            /*default_enabled*/ false,
+        ),
+        "https://chatgpt.com/backend-api/".to_string(),
+    )
+}
+
+fn feature_enabled(config: &Value, key: &str, default_enabled: bool) -> bool {
+    config
+        .get("features")
+        .and_then(Value::as_table)
+        .and_then(|features| features.get(key))
+        .and_then(Value::as_bool)
+        .unwrap_or(default_enabled)
+}