Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

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.rs
index 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.external
diff --git a/crates/agent_harness/src/domain/claude/test.rs b/crates/agent_harness/src/domain/claude/test.rs
index 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,
+ "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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.md
index 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.rs
index 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,