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(macrod): harden native controls and configure Codex MCP (#7365)

Eric Hayes0103f71b50f4
diff --git a/crates/coding_agent_worker/README.md b/crates/coding_agent_worker/README.md
index 0e4b4e5ec7..c856a42004 100644
--- a/crates/coding_agent_worker/README.md
+++ b/crates/coding_agent_worker/README.md
@@ -26,3 +26,26 @@ A background reader forwards local TUI turns even without a Macro prompt.
Complete JSONL records are read in bounded batches. Partial lines wait for the
next append; truncation or replacement requires a reload. Turn boundaries are
forwarded in order, including multiple local turns between polls.
+
+### Native controls and MCP
+
+Model selection from Macro applies before native launch. Change a running
+session's model in its native TUI; macrod rejects remote model changes it cannot
+confirm. Unconfirmed prompt submission is reported as an error, never retried by
+pressing Enter. Cancellation sends Escape without a delayed input-clearing key.
+
+Remote permission answers require a recognized approval shortcut, the same
+visible dialog, and the same Herdr state generation. Sign-in prompts and other
+unknown dialogs require native interaction. Herdr does not offer an atomic
+compare-and-send-key operation, so native interaction remains the authority.
+
+Claude receives MCP configuration in a private file. Codex receives per-launch
+MCP overrides; HTTP credentials come from private environment files sourced in
+the native pane, and stdio servers use private launch scripts. This requires a
+Bourne-compatible pane shell. User-wide Codex configuration is unchanged. SSE MCP
+servers are rejected for Codex; use streamable HTTP. Credentials are refreshed on
+native launch/resume, not injected into an already-running process.
+
+Codex's documented [MCP configuration](https://learn.chatgpt.com/docs/extend/mcp?surface=cli)
+and [configuration reference](https://learn.chatgpt.com/docs/config-file/config-reference)
+describe `env_http_headers` and per-server configuration.
diff --git a/crates/coding_agent_worker/src/herdr.rs b/crates/coding_agent_worker/src/herdr.rs
index 0dd47401b9..730f5982a9 100644
--- a/crates/coding_agent_worker/src/herdr.rs
+++ b/crates/coding_agent_worker/src/herdr.rs
@@ -17,7 +17,9 @@
pub(crate) mod acp_agent;
pub(crate) mod cli;
+mod controls;
mod hub;
+mod mcp;
pub(crate) mod repositories;
mod store;
mod tail;
diff --git a/crates/coding_agent_worker/src/herdr/acp_agent.rs b/crates/coding_agent_worker/src/herdr/acp_agent.rs
index 8b79cabe4a..41f1cd454e 100644
--- a/crates/coding_agent_worker/src/herdr/acp_agent.rs
+++ b/crates/coding_agent_worker/src/herdr/acp_agent.rs
@@ -62,11 +62,6 @@ const STATUS_EVERY: u32 = 4;
const SETTLED_CHECKS: u32 = 3;
const QUIET_START: Duration = Duration::from_secs(20);
const MISSING_AGENT_CHECKS: u32 = 5;
-/// How long a submitted prompt may show no sign of a turn before the
-/// adapter presses Enter again: a TUI still settling after launch can take
-/// the pasted text but drop the Enter that follows it.
-const SUBMIT_GRACE: Duration = Duration::from_secs(5);
-
/// Which coding-agent TUI each session runs.
#[derive(
Debug,
@@ -291,6 +286,13 @@ struct Session {
cancel: Mutex<Option<CancellationToken>>,
}
+struct PermissionEpoch(Arc<AtomicU64>);
+impl Drop for PermissionEpoch {
+ fn drop(&mut self) {
+ self.0.fetch_add(1, Ordering::SeqCst);
+ }
+}
+
struct PromptCancellation<'a>(&'a Mutex<Option<CancellationToken>>);
impl Drop for PromptCancellation<'_> {
@@ -305,7 +307,6 @@ struct Live {
cwd: PathBuf,
started: std::time::SystemTime,
name: String,
- model: String,
log: Transcript,
path: Option<PathBuf>,
cursor: Cursor,
@@ -376,12 +377,31 @@ impl Adapter {
.ok_or_else(|| RpcError::invalid(format!("unknown session {id}")))
}
- fn cancel(&self, params: &Value) {
- if let Ok(session) = self.session(params)
- && let Some(cancel) = lock(&session.cancel).as_ref()
- {
+ fn cancel(self: &Arc<Self>, params: &Value) {
+ let Ok(session) = self.session(params) else {
+ return;
+ };
+ if let Some(cancel) = lock(&session.cancel).as_ref() {
cancel.cancel();
+ return;
}
+ let Some(herdr) = self.herdr.clone() else {
+ return;
+ };
+ let name = agent_name(&session.id);
+ let native_id = lock(&session.native_id).clone();
+ tokio::spawn(async move {
+ let Ok(info) = herdr.agent_info(&name).await else {
+ return;
+ };
+ if native_id.is_some()
+ && info.session_id == native_id
+ && matches!(info.status.as_str(), "working" | "blocked")
+ && let Err(error) = herdr.send_keys(&name, &["esc"]).await
+ {
+ tracing::warn!(%error, "could not interrupt native turn");
+ }
+ });
}
async fn request(self: &Arc<Self>, method: &str, params: Value) -> Result<Value, RpcError> {
@@ -410,7 +430,17 @@ impl Adapter {
.iter()
.any(|(id, _)| *id == model) =>
{
+ let live = session
+ .live
+ .try_lock()
+ .map_err(|_| RpcError::invalid("cannot change model during a turn"))?;
+ if live.is_some() && model != *lock(&session.model) {
+ return Err(RpcError::invalid(
+ "change the model in the native Herdr session, or select it when starting a new session",
+ ));
+ }
model.clone_into(&mut lock(&session.model));
+ self.save(&session, live.as_ref())?;
Ok(json!({"configOptions": config_options(self.options.kind, model)}))
}
_ => Err(RpcError::invalid("unsupported configuration option")),
@@ -512,7 +542,6 @@ impl Adapter {
cwd: record.cwd.clone(),
started: std::time::UNIX_EPOCH + Duration::from_secs(record.started),
name: agent_name(id),
- model: record.model.clone(),
log: self.options.kind.log(),
path: record.transcript,
cursor: Cursor::default(),
@@ -646,14 +675,6 @@ impl Adapter {
return Err(RpcError::internal("the Claude Code window did not start"));
};
- let model = lock(&session.model).clone();
- if model != live.model && self.options.kind == TuiAgent::Claude {
- herdr
- .prompt_agent(&live.name, &format!("/model {model}"))
- .await?;
- live.model = model;
- tokio::time::sleep(Duration::from_secs(1)).await;
- }
if live.pending.is_empty() {
live.pending = self.drain(live)?.into();
}
@@ -729,6 +750,23 @@ impl Adapter {
]);
}
}
+ if kind == TuiAgent::Codex && !session.mcp_servers.is_empty() {
+ let prepared = super::mcp::codex(
+ &self.store.0.join("mcp").join(&session.id),
+ &session.mcp_servers,
+ )
+ .map_err(|error| RpcError::internal(error.to_string()))?;
+ herdr
+ .run_in_pane(
+ &window.pane_id,
+ &format!(
+ ". {}",
+ shell_words::quote(&prepared.environment.to_string_lossy())
+ ),
+ )
+ .await?;
+ args.extend(prepared.args);
+ }
args.extend(self.options.agent_args.iter().cloned());
let name = agent_name(&session.id);
let started = std::time::SystemTime::now();
@@ -749,7 +787,6 @@ impl Adapter {
cwd: session.cwd.clone(),
started,
name,
- model,
log: self.options.kind.log(),
path: None,
cursor: Cursor::default(),
@@ -764,7 +801,7 @@ impl Adapter {
if servers.is_empty() {
return Ok(None);
}
- let dir = std::env::temp_dir().join("macrod-herdr");
+ let dir = self.store.0.join("mcp");
std::fs::create_dir_all(&dir).map_err(|error| RpcError::internal(error.to_string()))?;
let path = dir.join(format!("{}.mcp.json", session.id));
let body = json!({"mcpServers": servers}).to_string();
@@ -791,25 +828,23 @@ impl Adapter {
// answer from Macro never presses keys into a different dialog.
let generation = Arc::new(AtomicU64::new(0));
let mut asking = false;
- let mut resubmitted = false;
+ let mut last_output = Instant::now();
+ let mut asked_seq = None;
+ let _epoch = PermissionEpoch(generation.clone());
loop {
tokio::select! {
() = cancel.cancelled() => {
herdr.send_keys(&live.name, &["esc"]).await?;
tokio::time::sleep(Duration::from_secs(1)).await;
- if self.options.kind == TuiAgent::Claude {
- // Claude Code puts an interrupted prompt back in its
- // input box; left there, the next prompt is appended
- // to it. One Ctrl+C clears the box (two would quit).
- herdr.send_keys(&live.name, &["ctrl+c"]).await?;
- }
self.forward(session, live, &mut open_tool)?;
return Ok("cancelled");
}
() = tokio::time::sleep(POLL) => {}
}
let (moved, ended) = self.forward(session, live, &mut open_tool)?;
- active |= moved;
+ if moved {
+ last_output = Instant::now();
+ }
if let Some(stop) = ended {
return Ok(stop);
}
@@ -818,7 +853,7 @@ impl Adapter {
if !ticks.is_multiple_of(STATUS_EVERY) {
continue;
}
- let status = match herdr.agent_info(&live.name).await {
+ let info = match herdr.agent_info(&live.name).await {
Ok(info) => {
missing = 0;
if info.session_id.is_some() {
@@ -828,7 +863,7 @@ impl Adapter {
live.path = self.locate(live, info.session_id.as_deref());
}
self.save(session, Some(live))?;
- info.status
+ info
}
Err(error) => {
missing += 1;
@@ -840,6 +875,11 @@ impl Adapter {
continue;
}
};
+ let status = info.status;
+ if asked_seq.is_some_and(|seq| seq != info.state_change_seq) {
+ asking = false;
+ generation.fetch_add(1, Ordering::SeqCst);
+ }
if status != "blocked" && std::mem::take(&mut asking) {
generation.fetch_add(1, Ordering::SeqCst);
}
@@ -851,21 +891,25 @@ impl Adapter {
"blocked" => {
settled = 0;
if !std::mem::replace(&mut asking, true) {
+ asked_seq = Some(info.state_change_seq);
let current = generation.fetch_add(1, Ordering::SeqCst) + 1;
self.ask_permission(session, live, open_tool.clone(), current, &generation);
}
}
- "idle" | "done" if !active && !resubmitted && started.elapsed() >= SUBMIT_GRACE => {
- resubmitted = true;
- tracing::warn!(agent = %live.name, "prompt shows no activity; pressing Enter again");
- herdr.send_keys(&live.name, &["enter"]).await?;
- }
"idle" | "done" => {
settled += 1;
- if settled >= SETTLED_CHECKS && (active || started.elapsed() > QUIET_START) {
+ if active
+ && settled >= SETTLED_CHECKS
+ && last_output.elapsed() >= Duration::from_secs(3)
+ {
self.forward(session, live, &mut open_tool)?;
return Ok("end_turn");
}
+ if !active && started.elapsed() > QUIET_START {
+ return Err(RpcError::internal(
+ "the native TUI did not confirm prompt submission; check its input in Herdr",
+ ));
+ }
}
_ => {}
}
@@ -925,15 +969,25 @@ impl Adapter {
let blocked = blocked.clone();
let kind = self.options.kind;
tokio::spawn(async move {
+ let Ok(before) = herdr.agent_info(&name).await else {
+ return;
+ };
+ let Ok(screen) = herdr.read_agent(&name).await else {
+ return;
+ };
+ let Some(approve_key) = super::controls::approve_key(kind, &screen) else {
+ adapter.notify_update(&session_id, json!({"sessionUpdate":"agent_message_chunk", "content":{"type":"text", "text":"The native agent needs input in Herdr."}}));
+ return;
+ };
+ if before.status != "blocked" {
+ return;
+ }
let (tool_id, title) = match tool {
Some(tool) => tool,
- None => {
- let screen = herdr.read_agent(&name).await.unwrap_or_default();
- (
- format!("herdr-permission-{generation}"),
- permission_title(kind, &screen),
- )
- }
+ None => (
+ format!("herdr-permission-{generation}"),
+ permission_title(kind, &screen),
+ ),
};
let answer = adapter
.call(
@@ -951,12 +1005,33 @@ impl Adapter {
if blocked.load(Ordering::SeqCst) != generation {
return;
}
- let allowed = answer
+ let Ok(after) = herdr.agent_info(&name).await else {
+ return;
+ };
+ let Ok(current_screen) = herdr.read_agent(&name).await else {
+ return;
+ };
+ if !super::controls::same_dialog(
+ &screen,
+ &current_screen,
+ before.state_change_seq,
+ after.state_change_seq,
+ &after.status,
+ ) {
+ return;
+ }
+ let key = match answer
.as_ref()
.and_then(|answer| answer.pointer("/result/outcome/optionId"))
.and_then(Value::as_str)
- == Some("allow");
- let key = if allowed { "enter" } else { "esc" };
+ {
+ Some("allow") => approve_key,
+ Some("reject") => "esc",
+ _ => return,
+ };
+ if blocked.load(Ordering::SeqCst) != generation {
+ return;
+ }
if let Err(error) = herdr.send_keys(&name, &[key]).await {
tracing::warn!(error = %error, "could not answer the agent's permission dialog");
}
diff --git a/crates/coding_agent_worker/src/herdr/acp_agent/test.rs b/crates/coding_agent_worker/src/herdr/acp_agent/test.rs
index efc7a85301..3b09024d35 100644
--- a/crates/coding_agent_worker/src/herdr/acp_agent/test.rs
+++ b/crates/coding_agent_worker/src/herdr/acp_agent/test.rs
@@ -303,3 +303,61 @@ async fn observer_waits_until_the_macro_prompt_response_has_been_sent() {
);
adapter.shutdown.cancel();
}
+
+#[tokio::test]
+async fn a_live_native_session_does_not_pretend_to_change_its_model() {
+ let root = tempfile::tempdir().unwrap();
+ let id = uuid::Uuid::new_v4().to_string();
+ save_transcript(root.path(), &id);
+ let (adapter, _) = test_adapter(root.path());
+ adapter
+ .load_session(&json!({"sessionId":id,"cwd":root.path()}))
+ .await
+ .unwrap();
+ assert!(
+ adapter
+ .request(
+ "session/set_config_option",
+ json!({"sessionId":id,"configId":"model","value":"opus"})
+ )
+ .await
+ .is_err()
+ );
+ assert_eq!(adapter.store.load(&id).unwrap().model, "sonnet");
+ adapter.shutdown.cancel();
+}
+
+#[tokio::test]
+async fn an_unconfirmed_submission_never_sends_an_extra_enter_or_reports_success() {
+ use std::os::unix::fs::PermissionsExt as _;
+ let root = tempfile::tempdir().unwrap();
+ let calls = root.path().join("calls");
+ let script = root.path().join("herdr");
+ std::fs::write(&script, format!("#!/bin/sh\nprintf '%s\\n' \"$*\" >> {}\nprintf '%s\\n' '{{\"result\":{{\"agent\":{{\"agent_status\":\"idle\"}}}}}}'\n", shell_words::quote(&calls.to_string_lossy()))).unwrap();
+ std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o700)).unwrap();
+ let id = uuid::Uuid::new_v4().to_string();
+ save_transcript(root.path(), &id);
+ let (adapter, _) = test_adapter(root.path());
+ adapter
+ .load_session(&json!({"sessionId":id,"cwd":root.path()}))
+ .await
+ .unwrap();
+ let session = adapter.session(&json!({"sessionId":id})).unwrap();
+ let mut guard = session.live.lock().await;
+ let error = adapter
+ .follow(
+ &HerdrCli::new(script, None),
+ &session,
+ guard.as_mut().unwrap(),
+ &CancellationToken::new(),
+ )
+ .await
+ .unwrap_err();
+ assert!(error.message.contains("did not confirm"));
+ assert!(
+ !std::fs::read_to_string(calls)
+ .unwrap()
+ .contains("send-keys")
+ );
+ adapter.shutdown.cancel();
+}
diff --git a/crates/coding_agent_worker/src/herdr/cli.rs b/crates/coding_agent_worker/src/herdr/cli.rs
index ac7ecf274f..3d0187e854 100644
--- a/crates/coding_agent_worker/src/herdr/cli.rs
+++ b/crates/coding_agent_worker/src/herdr/cli.rs
@@ -17,6 +17,9 @@ const REPORT_AGENT: &str = "macro";
/// A failure running a herdr command.
#[derive(Debug, thiserror::Error)]
pub(crate) enum HerdrError {
+ /// The Herdr command did not finish within its deadline.
+ #[error("herdr command timed out")]
+ Timeout,
/// The binary could not be started.
#[error("could not run herdr")]
Spawn(#[source] std::io::Error),
@@ -298,13 +301,17 @@ impl HerdrCli {
}
async fn run<Arg: AsRef<str>>(&self, args: &[Arg]) -> Result<String, HerdrError> {
- let output = tokio::process::Command::new(&self.bin)
- .args(args.iter().map(AsRef::as_ref))
- .stdin(std::process::Stdio::null())
- .kill_on_drop(true)
- .output()
- .await
- .map_err(HerdrError::Spawn)?;
+ let output = tokio::time::timeout(
+ std::time::Duration::from_secs(150),
+ tokio::process::Command::new(&self.bin)
+ .args(args.iter().map(AsRef::as_ref))
+ .stdin(std::process::Stdio::null())
+ .kill_on_drop(true)
+ .output(),
+ )
+ .await
+ .map_err(|_| HerdrError::Timeout)?
+ .map_err(HerdrError::Spawn)?;
if !output.status.success() {
return Err(HerdrError::Refused {
command: describe(args),
diff --git a/crates/coding_agent_worker/src/herdr/controls.rs b/crates/coding_agent_worker/src/herdr/controls.rs
new file mode 100644
index 0000000000..ed595f5b4b
--- /dev/null
+++ b/crates/coding_agent_worker/src/herdr/controls.rs
@@ -0,0 +1,35 @@
+//! Conservative native control decisions, independent of terminal I/O.
+
+use super::acp_agent::TuiAgent;
+
+#[cfg(test)]
+mod test;
+
+/// Only dialogs with an explicit, known affirmative shortcut can be answered
+/// remotely. Other questions remain interactive in the native TUI.
+pub(crate) fn approve_key(kind: TuiAgent, screen: &str) -> Option<&'static str> {
+ match kind {
+ TuiAgent::Codex
+ if screen.contains("Would you like to") && screen.contains("1. Yes, proceed (y)") =>
+ {
+ Some("y")
+ }
+ TuiAgent::Claude
+ if screen.contains("Do you want to proceed?") && screen.contains("1. Yes") =>
+ {
+ Some("1")
+ }
+ _ => None,
+ }
+}
+
+/// A reply may affect only the same visible dialog and native state generation.
+pub(crate) fn same_dialog(
+ before: &str,
+ after: &str,
+ expected_seq: u64,
+ actual_seq: u64,
+ status: &str,
+) -> bool {
+ status == "blocked" && expected_seq == actual_seq && before == after
+}
diff --git a/crates/coding_agent_worker/src/herdr/controls/test.rs b/crates/coding_agent_worker/src/herdr/controls/test.rs
new file mode 100644
index 0000000000..671db10e8f
--- /dev/null
+++ b/crates/coding_agent_worker/src/herdr/controls/test.rs
@@ -0,0 +1,25 @@
+use super::*;
+
+#[test]
+fn unknown_questions_cannot_be_approved_by_pressing_enter() {
+ assert_eq!(approve_key(TuiAgent::Codex, "Please sign in"), None);
+ assert_eq!(
+ approve_key(TuiAgent::Claude, "Which repository?\n1. Yes"),
+ None
+ );
+ assert_eq!(
+ approve_key(
+ TuiAgent::Codex,
+ "Would you like to run this?\n1. Yes, proceed (y)"
+ ),
+ Some("y")
+ );
+}
+
+#[test]
+fn local_answers_and_replaced_dialogs_invalidate_remote_replies() {
+ assert!(same_dialog("approve A", "approve A", 3, 3, "blocked"));
+ assert!(!same_dialog("approve A", "approve A", 3, 4, "blocked"));
+ assert!(!same_dialog("approve A", "approve B", 3, 3, "blocked"));
+ assert!(!same_dialog("approve A", "approve A", 3, 3, "working"));
+}
diff --git a/crates/coding_agent_worker/src/herdr/mcp.rs b/crates/coding_agent_worker/src/herdr/mcp.rs
new file mode 100644
index 0000000000..5c4d77e0b0
--- /dev/null
+++ b/crates/coding_agent_worker/src/herdr/mcp.rs
@@ -0,0 +1,119 @@
+//! Native Codex MCP launch configuration. Credentials stay in private files,
+//! never in the shell command, command arguments, or a user's global config.
+
+use super::store::write_private;
+use serde_json::Value;
+use std::path::{Path, PathBuf};
+
+#[cfg(test)]
+mod test;
+
+pub(crate) struct CodexMcp {
+ pub args: Vec<String>,
+ pub environment: PathBuf,
+}
+
+pub(crate) fn codex(dir: &Path, servers: &[Value]) -> rootcause::Result<CodexMcp> {
+ use std::os::unix::fs::DirBuilderExt as _;
+ std::fs::DirBuilder::new()
+ .recursive(true)
+ .mode(0o700)
+ .create(dir)?;
+ let mut args = Vec::new();
+ let mut environment = String::new();
+ for (index, server) in servers.iter().enumerate() {
+ let name = server["name"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("MCP server needs a name"))?;
+ let mut config = toml_edit::InlineTable::new();
+ if let Some(url) = server["url"].as_str() {
+ if server["type"].as_str() != Some("http") {
+ rootcause::bail!("Codex native MCP requires streamable HTTP, not SSE");
+ }
+ let parsed = reqwest::Url::parse(url)?;
+ if !parsed.username().is_empty()
+ || parsed.password().is_some()
+ || parsed.query().is_some()
+ {
+ rootcause::bail!("MCP URL credentials must be supplied through headers");
+ }
+ config.insert("url", url.into());
+ let mut headers = toml_edit::InlineTable::new();
+ for (header_index, header) in server["headers"]
+ .as_array()
+ .into_iter()
+ .flatten()
+ .enumerate()
+ {
+ let name = header["name"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("invalid MCP header name"))?;
+ let value = header["value"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("invalid MCP header value"))?;
+ let variable = format!("MACROD_MCP_{index}_{header_index}");
+ headers.insert(name, variable.clone().into());
+ environment.push_str(&format!(
+ "export {variable}={}\n",
+ shell_words::quote(value)
+ ));
+ }
+ config.insert("env_http_headers", headers.into());
+ } else {
+ let command = server["command"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("MCP server needs a command or URL"))?;
+ let mut script = String::new();
+ for entry in server["env"].as_array().into_iter().flatten() {
+ let name = entry["name"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("invalid MCP environment name"))?;
+ if !valid_variable(name) {
+ rootcause::bail!("invalid MCP environment variable");
+ }
+ let value = entry["value"]
+ .as_str()
+ .ok_or_else(|| rootcause::report!("invalid MCP environment value"))?;
+ script.push_str(&format!("export {name}={}\n", shell_words::quote(value)));
+ }
+ let mut command_line = vec![command.to_owned()];
+ for arg in server["args"].as_array().into_iter().flatten() {
+ command_line.push(
+ arg.as_str()
+ .ok_or_else(|| rootcause::report!("invalid MCP argument"))?
+ .to_owned(),
+ );
+ }
+ script.push_str(&format!("exec {}\n", shell_words::join(&command_line)));
+ let launcher = dir.join(format!("mcp-{index}.sh"));
+ write_private(&launcher, script.as_bytes())?;
+ config.insert("command", "/bin/sh".into());
+ let mut launch_args = toml_edit::Array::new();
+ launch_args.push(launcher.to_string_lossy().as_ref());
+ config.insert("args", launch_args.into());
+ }
+ // TOML quotes both the server key and the inline table's strings.
+ args.extend([
+ "--config".to_owned(),
+ format!(
+ "mcp_servers.{}={}",
+ toml_edit::Value::from(name),
+ toml_edit::Value::InlineTable(config)
+ ),
+ ]);
+ }
+ let environment_path = dir.join("mcp-environment.sh");
+ write_private(&environment_path, environment.as_bytes())?;
+ Ok(CodexMcp {
+ args,
+ environment: environment_path,
+ })
+}
+
+fn valid_variable(name: &str) -> bool {
+ let mut chars = name.chars();
+ chars
+ .next()
+ .is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_')
+ && chars.all(|ch| ch.is_ascii_alphanumeric() || ch == '_')
+}
diff --git a/crates/coding_agent_worker/src/herdr/mcp/test.rs b/crates/coding_agent_worker/src/herdr/mcp/test.rs
new file mode 100644
index 0000000000..e51f232dff
--- /dev/null
+++ b/crates/coding_agent_worker/src/herdr/mcp/test.rs
@@ -0,0 +1,45 @@
+use super::*;
+use serde_json::json;
+
+#[test]
+fn native_codex_mcp_keeps_headers_and_stdio_secrets_out_of_arguments() {
+ use std::os::unix::fs::PermissionsExt as _;
+ let root = tempfile::tempdir().unwrap();
+ let prepared = codex(root.path(), &[
+ json!({"name":"macro.tools", "type":"http", "url":"https://example.com/mcp", "headers":[{"name":"Authorization","value":"Bearer private-test-token"}]}),
+ json!({"name":"local", "command":"example", "args":["private-argument"], "env":[{"name":"TOKEN","value":"private-environment"}]}),
+ ]).unwrap();
+ assert!(!prepared.args.join(" ").contains("private-"));
+ for pair in prepared.args.chunks_exact(2) {
+ let config: toml::Value = toml::from_str(&pair[1]).unwrap();
+ assert!(config["mcp_servers"].is_table());
+ }
+ let environment = std::fs::read_to_string(&prepared.environment).unwrap();
+ assert!(environment.contains("Bearer private-test-token"));
+ assert_eq!(
+ std::fs::metadata(&prepared.environment)
+ .unwrap()
+ .permissions()
+ .mode()
+ & 0o777,
+ 0o600
+ );
+ assert!(
+ std::fs::read_to_string(root.path().join("mcp-1.sh"))
+ .unwrap()
+ .contains("private-argument")
+ );
+}
+
+#[test]
+fn unsupported_transport_and_shell_injection_are_rejected() {
+ let root = tempfile::tempdir().unwrap();
+ assert!(
+ codex(
+ root.path(),
+ &[json!({"name":"old", "type":"sse", "url":"https://example.com/sse"})]
+ )
+ .is_err()
+ );
+ assert!(codex(root.path(), &[json!({"name":"bad", "command":"example", "env":[{"name":"X; echo bad", "value":"value"}]})]).is_err());
+}