cache: share published catalogs across instances

apps/mcp-server/src/main.rs

@@ -67,6 +67,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         } else {
             RequestRateLimiter::new(api_rate_limit)
         },
+        cache_stores.coordination.clone(),
         std::sync::Arc::new(session_store),
         std::sync::Arc::new(CommunityMachineCredentialVerifier),
     );
@@ -162,7 +163,8 @@ mod tests {
         SaveAgentBindingsRequest,
     };
     use crank_runtime::{
-        RequestRateLimitConfig, RequestRateLimiter, RuntimeExecutor, SecretCrypto,
+        InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter,
+        RuntimeExecutor, SecretCrypto,
     };
     use crank_schema::{Schema, SchemaKind};
     use futures_util::stream;
@@ -181,6 +183,7 @@ mod tests {
             MachineCredentialVerifierError, SharedMachineCredentialVerifier,
             VerifiedMachineCredential,
         },
+        catalog::PublishedToolCatalog,
         session::{InMemorySessionStore, SharedSessionStore, TransportSessionStore},
     };
 
@@ -276,6 +279,7 @@ mod tests {
             SecretCrypto::new("test-master-key").unwrap(),
             RuntimeExecutor::new(),
             RequestRateLimiter::new(rate_limit_config),
+            std::sync::Arc::new(InMemoryCoordinationStateStore::default()),
             sessions,
             credential_verifier,
         )
@@ -1298,6 +1302,63 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn shares_published_catalog_snapshot_across_instances() {
+        let registry = test_registry().await;
+        let upstream_base_url = spawn_upstream_server().await;
+        let operation = test_operation(&upstream_base_url, "crm_catalog_shared");
+        let coordination_store = std::sync::Arc::new(InMemoryCoordinationStateStore::default());
+
+        registry
+            .create_operation(&test_workspace_id(), &operation, Some("alice"))
+            .await
+            .unwrap();
+        registry
+            .publish_operation(PublishRequest {
+                workspace_id: &test_workspace_id(),
+                operation_id: &operation.id,
+                version: 1,
+                published_at: &OffsetDateTime::parse("2026-03-26T10:00:00Z", &Rfc3339).unwrap(),
+                published_by: Some("alice"),
+            })
+            .await
+            .unwrap();
+        publish_agent_for_operation(&registry, &operation, "sales-shared-catalog").await;
+
+        let catalog_a = PublishedToolCatalog::new(
+            registry.clone(),
+            Duration::from_secs(60),
+            coordination_store.clone(),
+        );
+        let tools_a = catalog_a
+            .list_tools(test_workspace_slug(), "sales-shared-catalog")
+            .await
+            .unwrap();
+        assert_eq!(tools_a.len(), 1);
+
+        registry
+            .unpublish_agent(
+                &test_workspace_id(),
+                &test_agent_id("sales-shared-catalog"),
+                &OffsetDateTime::parse("2026-03-26T10:05:00Z", &Rfc3339).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let catalog_b = PublishedToolCatalog::new(
+            registry.clone(),
+            Duration::from_secs(60),
+            coordination_store,
+        );
+        let tools_b = catalog_b
+            .list_tools(test_workspace_slug(), "sales-shared-catalog")
+            .await
+            .unwrap();
+
+        assert_eq!(tools_b.len(), 1);
+        assert_eq!(tools_b[0].tool_name, operation.name);
+    }
+
     #[tokio::test]
     async fn lists_only_bound_tools_for_agent_context() {
         let registry = test_registry().await;