Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(agents): allow MCP gateway in Claude cloud environments (#6550)
Eric Hayesea85990240c3
diff --git a/crates/agent_harness/src/domain/claude.rs b/crates/agent_harness/src/domain/claude.rsindex 5157ff5580..c8bad2f54d 100644--- a/crates/agent_harness/src/domain/claude.rs+++ b/crates/agent_harness/src/domain/claude.rs@@ -24,6 +24,7 @@ pub struct ClaudeSessions<P, Repo, External> {provider: Arc<P>,repo: Repo,external: External,+ mcp_gateway_host: String,creation: tokio::sync::Mutex<()>,}@@ -48,11 +49,12 @@ impl<P: CloudProvider, Repo: AgentSessionRepo, External: ExternalSessionRepo>}/// Wire the provider and the owning session repository at the composition root.- pub fn new(provider: Arc<P>, repo: Repo, external: External) -> Self {+ pub fn new(provider: Arc<P>, repo: Repo, external: External, mcp_gateway_host: String) -> Self {Self {provider,repo,external,+ mcp_gateway_host,creation: tokio::sync::Mutex::new(()),}}@@ -98,6 +100,13 @@ impl<P: CloudProvider, Repo: AgentSessionRepo, External: ExternalSessionRepo>}Some(_) => return Err(cloud_error(Error::UncertainCreate)),None => {+ // Network settings are captured when Claude creates its container.+ // Prepare before the durable create intent: a setup failure can+ // safely be retried and must not strand the session as pending.+ client+ .prepare_mcp_access(&self.mcp_gateway_host)+ .await+ .map_err(cloud_error)?;// Write a durable intent before the non-idempotent POST. A crash or// timeout stays visibly pending rather than minting a duplicate VM.self.externaldiff --git a/crates/agent_harness/src/domain/claude/test.rs b/crates/agent_harness/src/domain/claude/test.rsindex b5720828a1..fbe1fdf079 100644--- a/crates/agent_harness/src/domain/claude/test.rs+++ b/crates/agent_harness/src/domain/claude/test.rs@@ -15,12 +15,16 @@ use std::sync::Mutex;struct Provider {calls: Arc<Mutex<Vec<(String, String)>>>,uncertain: bool,+ preparations: Arc<Mutex<Vec<(String, String)>>>,+ preparation_fails: bool,}#[derive(Clone)]struct Client {owner: String,calls: Arc<Mutex<Vec<(String, String)>>>,uncertain: bool,+ preparations: Arc<Mutex<Vec<(String, String)>>>,+ preparation_fails: bool,}impl CloudProvider for Provider {type Client = Client;@@ -29,14 +33,36 @@ impl CloudProvider for Provider {owner: owner.into(),calls: self.calls.clone(),uncertain: self.uncertain,+ preparations: self.preparations.clone(),+ preparation_fails: self.preparation_fails,})}}impl CloudLifecycle for Client {+ async fn prepare_mcp_access(+ &self,+ host: &str,+ ) -> claude_cloud_agents::domain::model::Result<()> {+ self.preparations+ .lock()+ .unwrap()+ .push((self.owner.clone(), host.into()));+ if self.preparation_fails {+ return Err(Error::EnvironmentNetwork);+ }+ Ok(())+ }async fn create(&self,instructions: &str,) -> claude_cloud_agents::domain::model::Result<SessionId> {+ assert!(+ self.preparations+ .lock()+ .unwrap()+ .iter()+ .any(|(owner, host)| owner == &self.owner && host == "dev-gateway.macro.com")+ );self.calls.lock().unwrap()@@ -148,12 +174,18 @@ async fn distinct_agents_keep_their_owner_instructions_model_and_remote_session().await;let provider = Arc::new(Provider::default());- let sessions = ClaudeSessions::new(provider.clone(), repo, mappings());+ let sessions = ClaudeSessions::new(+ provider.clone(),+ repo,+ mappings(),+ "dev-gateway.macro.com".into(),+ );let one = sessions.attach(first).await.unwrap();let two = sessions.attach(second).await.unwrap();assert_ne!(one.id(), two.id());assert_eq!(one.model().await.id(), "claude-default");assert_eq!(sessions.attach(first).await.unwrap().id(), one.id());+ assert_eq!(provider.preparations.lock().unwrap().len(), 2);assert_eq!(*provider.calls.lock().unwrap(),vec![@@ -177,7 +209,12 @@ async fn uncertain_create_remains_pending_and_is_never_retried() {uncertain: true,..Default::default()});- let sessions = ClaudeSessions::new(provider.clone(), repo, mappings());+ let sessions = ClaudeSessions::new(+ provider.clone(),+ repo,+ mappings(),+ "dev-gateway.macro.com".into(),+ );assert!(sessions.attach(id).await.is_err());assert!(sessions.attach(id).await.is_err());assert_eq!(provider.calls.lock().unwrap().len(), 1);@@ -194,7 +231,12 @@ async fn reattach_restores_egress_with_the_saved_agent_selection() {"Review code",).await;- let sessions = ClaudeSessions::new(Arc::new(Provider::default()), repo.clone(), mappings());+ let sessions = ClaudeSessions::new(+ Arc::new(Provider::default()),+ repo.clone(),+ mappings(),+ "dev-gateway.macro.com".into(),+ );let egress = EgressProvisionerMock::default();let token = sessions.refresh_egress(id, &egress).await.unwrap();assert_eq!(token, "test-session-token");@@ -213,3 +255,37 @@ async fn reattach_restores_egress_with_the_saved_agent_selection() {.is_some());}++#[tokio::test]+async fn network_setup_failure_never_creates_or_leaves_a_pending_intent() {+ let repo = InMemoryAgentSessionRepo::new();+ let id = seed(+ &repo,+ bot_id::BotId::TEST_A,+ "macro|[email protected]",+ "Review code",+ )+ .await;+ let provider = Arc::new(Provider {+ preparation_fails: true,+ ..Default::default()+ });+ let sessions = ClaudeSessions::new(+ provider.clone(),+ repo,+ mappings(),+ "dev-gateway.macro.com".into(),+ );+ for _ in 0..2 {+ let error = sessions.attach(id).await.err().unwrap();+ assert!(error.to_string().contains("MCP gateway"));+ assert!(+ ExternalSessionRepo::get(&sessions.external, id)+ .await+ .unwrap()+ .is_none()+ );+ }+ assert!(provider.calls.lock().unwrap().is_empty());+ assert_eq!(provider.preparations.lock().unwrap().len(), 2);+}diff --git a/crates/claude_cloud_agents/src/domain/environment.rs b/crates/claude_cloud_agents/src/domain/environment.rsnew file mode 100644index 0000000000..d563badfda--- /dev/null+++ b/crates/claude_cloud_agents/src/domain/environment.rs@@ -0,0 +1,28 @@+//! Minimal network access required by Macro's session-scoped MCP gateway.+use super::model::{Error, Result};+use serde_json::{Value, json};++/// Add the deployment's exact gateway host to a limited environment's allowlist.+/// Omitted fields in Claude's update API retain their values, so the patch never+/// changes package access, connector access, or any other environment setting.+/// Explicitly disabled or unknown policies require the owner to configure them.+pub fn gateway_network_patch(network: &Value, host: &str) -> Result<Option<Value>> {+ match network["type"].as_str() {+ Some("unrestricted") => return Ok(None),+ Some("limited") => {}+ _ => return Err(Error::EnvironmentNetwork),+ }+ let hosts = network["allowed_hosts"]+ .as_array()+ .filter(|hosts| hosts.iter().all(Value::is_string))+ .ok_or(Error::EnvironmentNetwork)?;+ if hosts.iter().any(|entry| entry.as_str() == Some(host)) {+ return Ok(None);+ }+ let mut hosts = hosts.clone();+ hosts.push(json!(host));+ Ok(Some(json!({"type":"limited", "allowed_hosts":hosts})))+}++#[cfg(test)]+mod test;diff --git a/crates/claude_cloud_agents/src/domain/environment/test.rs b/crates/claude_cloud_agents/src/domain/environment/test.rsnew file mode 100644index 0000000000..32245595b6--- /dev/null+++ b/crates/claude_cloud_agents/src/domain/environment/test.rs@@ -0,0 +1,66 @@+use super::*;++#[test]+fn adds_only_gateway_and_preserves_existing_hosts_and_other_settings() {+ let network = json!({+ "type":"limited", "allowed_hosts":["github.com"],+ "allow_mcp_servers":true, "allow_package_managers":false,+ "future_setting":"preserve"+ });+ let patch = gateway_network_patch(&network, "dev-gateway.macro.com")+ .unwrap()+ .unwrap();+ assert_eq!(+ patch,+ json!({"type":"limited", "allowed_hosts":["github.com", "dev-gateway.macro.com"]})+ );+ let mut merged = network.clone();+ merged+ .as_object_mut()+ .unwrap()+ .extend(patch.as_object().unwrap().clone());+ assert_eq!(merged["allow_mcp_servers"], true);+ assert_eq!(merged["allow_package_managers"], false);+ assert_eq!(merged["future_setting"], "preserve");+ assert!(+ gateway_network_patch(&merged, "dev-gateway.macro.com")+ .unwrap()+ .is_none()+ );+}++#[test]+fn unrestricted_network_needs_no_update() {+ assert!(+ gateway_network_patch(&json!({"type":"unrestricted"}), "gateway.macro.com")+ .unwrap()+ .is_none()+ );+}++#[test]+fn never_broadens_disabled_unknown_or_malformed_policies() {+ for network in [+ json!(null),+ json!({"type":"none"}),+ json!({"type":"future"}),+ json!({"type":"limited"}),+ json!({"type":"limited", "allowed_hosts":[1]}),+ ] {+ assert!(matches!(+ gateway_network_patch(&network, "gateway.macro.com"),+ Err(Error::EnvironmentNetwork)+ ));+ }+}++#[test]+fn uses_the_deployments_host_without_adding_other_environments() {+ let patch = gateway_network_patch(+ &json!({"type":"limited", "allowed_hosts":[]}),+ "gateway.macro.com",+ )+ .unwrap()+ .unwrap();+ assert_eq!(patch["allowed_hosts"], json!(["gateway.macro.com"]));+}diff --git a/crates/claude_cloud_agents/src/domain/mod.rs b/crates/claude_cloud_agents/src/domain/mod.rsindex 1359c043c8..8f7a503df5 100644--- a/crates/claude_cloud_agents/src/domain/mod.rs+++ b/crates/claude_cloud_agents/src/domain/mod.rs@@ -2,6 +2,7 @@/// Owner-bound interactive OAuth connection use cases.pub mod auth;pub mod credentials;+pub mod environment;pub mod mcp;pub mod model;pub mod models;diff --git a/crates/claude_cloud_agents/src/domain/model.rs b/crates/claude_cloud_agents/src/domain/model.rsindex 9f4c6aaadf..d4a00108e3 100644--- a/crates/claude_cloud_agents/src/domain/model.rs+++ b/crates/claude_cloud_agents/src/domain/model.rs@@ -4,6 +4,11 @@ use serde::{Deserialize, Serialize};/// The deliberately bounded failures exposed to Macro. Never includes HTTP bodies.#[derive(Debug, thiserror::Error)]pub enum Error {+ /// The cloud environment cannot safely allow the deployment's MCP gateway.+ #[error(+ "Claude's environment cannot reach Macro's MCP gateway. Check its network settings in Claude Code on the web, then start a new session."+ )]+ EnvironmentNetwork,/// MCP setup failed or the worker did not acknowledge it before prompting.#[error("Claude could not connect the session's MCP servers; check the harness connection and retry"diff --git a/crates/claude_cloud_agents/src/domain/ports.rs b/crates/claude_cloud_agents/src/domain/ports.rsindex 2a40493fd5..bc93523680 100644--- a/crates/claude_cloud_agents/src/domain/ports.rs+++ b/crates/claude_cloud_agents/src/domain/ports.rs@@ -16,6 +16,9 @@ pub trait CloudProvider: Send + Sync + 'static {/// Lifecycle operations kept separate from an attached conversation.pub trait CloudLifecycle: Cloud {+ /// Ensure the owner's selected environment allows this deployment's MCP host.+ /// Must finish before creating a container, whose network policy is fixed.+ fn prepare_mcp_access(&self, host: &str) -> impl Future<Output = Result<()>> + Send;/// Create a conversation with this agent's instructions.fn create(&self, instructions: &str) -> impl Future<Output = Result<SessionId>> + Send;/// Archive the owner's conversation reversibly.diff --git a/crates/claude_cloud_agents/src/outbound/http.rs b/crates/claude_cloud_agents/src/outbound/http.rsindex 88523c70ee..b260cfdab8 100644--- a/crates/claude_cloud_agents/src/outbound/http.rs+++ b/crates/claude_cloud_agents/src/outbound/http.rs@@ -1,6 +1,7 @@//! The experimentally verified OAuth API origin, not the cookie-authenticated web origin.use crate::domain::{credentials::AccountCredentials,+ environment::gateway_network_patch,model::{Error, Event, Result, SessionId},ports::{Cloud, CloudLifecycle, CloudProvider, Events},};@@ -57,12 +58,14 @@ impl Client {checked(response)}- /// Create only in the explicitly selected, active Anthropic cloud environment.- pub async fn create(&self, instructions: &str) -> Result<SessionId> {+ async fn environment_request(&self, path: &str, body: Option<Value>) -> Result<Value> {let credentials = self.credentials.resolve(&self.owner).await?;- let response = self- .http- .get(format!("{API}/v1/environments"))+ let url = format!("{API}{path}");+ let request = match body {+ Some(body) => self.http.post(url).json(&body),+ None => self.http.get(url),+ };+ let response = request.bearer_auth(credentials.access_token.expose()).header("anthropic-version", "2023-06-01").header(@@ -74,29 +77,46 @@ impl Client {.send().await.map_err(|_| Error::Network)?;- let environments: Value = checked(response)?- .json()- .await- .map_err(|_| Error::Protocol)?;- let valid = environments["data"].as_array().is_some_and(|all| {- all.iter().any(|e| {- e["id"].as_str() == Some(&credentials.environment_id)- && e["config"]["type"] == "cloud"- && e["state"] == "active"- && e["archived_at"].is_null()+ checked(response)?.json().await.map_err(|_| Error::Protocol)+ }++ async fn selected_environment(&self) -> Result<Value> {+ let credentials = self.credentials.resolve(&self.owner).await?;+ let environments = self.environment_request("/v1/environments", None).await?;+ environments["data"]+ .as_array()+ .and_then(|all| {+ all.iter().find(|e| {+ e["id"].as_str() == Some(&credentials.environment_id)+ && e["config"]["type"] == "cloud"+ && e["state"] == "active"+ && e["archived_at"].is_null()+ })})- });- if !valid {- return Err(Error::Protocol);- }+ .cloned()+ .ok_or(Error::CloudEnvironment)+ }++ /// Create only in the explicitly selected, active Anthropic cloud environment.+ pub async fn create(&self, instructions: &str) -> Result<SessionId> {+ let environment = self.selected_environment().await?;let mut config = json!({"sources": [], "outcomes": []});if !instructions.is_empty() {config["append_system_prompt"] = json!(instructions);}- let response = self.request("/v1/code/sessions", Some(json!({- "title": "Macro Claude Cloud demo", "environment_id": credentials.environment_id,- "config": config, "events": []- }))).await.map_err(|error| match error { Error::Network => Error::UncertainCreate, other => other })?;+ let response = self+ .request(+ "/v1/code/sessions",+ Some(json!({+ "title": "Macro Claude Cloud demo", "environment_id": environment["id"],+ "config": config, "events": []+ })),+ )+ .await+ .map_err(|error| match error {+ Error::Network => Error::UncertainCreate,+ other => other,+ })?;let data: Value = response.json().await.map_err(|_| Error::UncertainCreate)?;SessionId::parse(data["session"]["id"]@@ -128,6 +148,28 @@ impl CloudProvider for Provider {}impl CloudLifecycle for Client {+ async fn prepare_mcp_access(&self, host: &str) -> Result<()> {+ let environment = self.selected_environment().await?;+ let Some(networking) = gateway_network_patch(&environment["config"]["networking"], host)?+ else {+ return Ok(());+ };+ let id = environment["id"].as_str().ok_or(Error::Protocol)?;+ self.environment_request(+ &format!("/v1/environments/{id}"),+ Some(json!({"config":{"type":"cloud", "networking":networking}})),+ )+ .await?;+ // Do not launch a container if the provider failed to apply the policy.+ let updated = self.selected_environment().await?;+ if updated["id"] != environment["id"]+ || gateway_network_patch(&updated["config"]["networking"], host)?.is_some()+ {+ return Err(Error::EnvironmentNetwork);+ }+ Ok(())+ }+async fn create(&self, instructions: &str) -> Result<SessionId> {Client::create(self, instructions).await}diff --git a/docs/CLAUDE_CLOUD_DEMO.md b/docs/CLAUDE_CLOUD_DEMO.mdindex 020ad05fc9..c3271aa51a 100644--- a/docs/CLAUDE_CLOUD_DEMO.md+++ b/docs/CLAUDE_CLOUD_DEMO.md@@ -196,3 +196,19 @@ cargo run -p claude_cloud_agents --example smoke -- \```Omitting `--session` creates a new cloud conversation. Do not automatically rerun a failed create; inspect the account first. The runner prints only the session identity and outcome, not tokens or private transcript contents.++## MCP gateway networking++Before creating a Claude cloud conversation, the shared Claude harness lifecycle+allows the deployment’s `AgentHarnessEgressUrl` hostname in the connected owner's+selected environment. Limited networking keeps its existing allowed hosts,+package access, and connector settings; only the exact gateway hostname is+added. Unrestricted environments need no update. Disabled or unrecognized+network policies fail before session creation with an environment setup error.+An environment update failure can be retried without creating duplicate sessions.++Claude captures networking when it creates a container. Start a new Macro agent+session after fixing an environment; existing containers keep their old policy.+The earlier MCP HTTP 403 failure was reproduced with an empty allowlist despite+`allow_mcp_servers: true`: adding `dev-gateway.macro.com` let a fresh Claude+session connect `macro`, `macro_internal`, and `linear` and complete a prompt.diff --git a/services/agent_harness_service/src/main.rs b/services/agent_harness_service/src/main.rsindex ff5fa99a1b..540df5d614 100644--- a/services/agent_harness_service/src/main.rs+++ b/services/agent_harness_service/src/main.rs@@ -616,6 +616,10 @@ async fn run() -> anyhow::Result<()> {claude_provider.clone(),session_repo.clone(),session_repo.clone(),+ url::Url::parse(&egress_base_url)?+ .host_str()+ .context("egress URL needs a host")?+ .to_owned(),),EgressProvisioner::new(Arc::clone(&mcp_connections), egress_base_url.clone()),claude_cloud_agents::inbound::acp::attach,