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(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.mdindex 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 thenext append; truncation or replacement requires a reload. Turn boundaries areforwarded 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.rsindex 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.rsindex 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,+ ¤t_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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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());+}