use std::{ env, fs, net::{IpAddr, SocketAddr}, }; use crate::http_auth::HttpAuth; const DEFAULT_HTTP_HOST: &str = "127.0.0.1"; const DEFAULT_HTTP_PORT: u16 = 5225; const DEFAULT_HTTP_PATH: &str = "/mcp"; #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum McpTransport { Stdio, StreamableHttp, } pub struct RuntimeConfig { pub transport: McpTransport, pub http: Option, } pub struct HttpRuntimeConfig { pub(crate) bind_addr: SocketAddr, pub(crate) path: String, pub(crate) auth: HttpAuth, pub(crate) allowed_hosts: Vec, } impl HttpRuntimeConfig { pub fn new(bind_addr: SocketAddr, path: String, auth: HttpAuth, allowed_hosts: Vec) -> Self { Self { bind_addr, path, auth, allowed_hosts } } pub fn bind_addr(&self) -> SocketAddr { self.bind_addr } } impl RuntimeConfig { /// Parses DBX MCP's small runtime surface without adding a command-line dependency. /// `stdio` remains the default, preserving all existing npm and native launchers. pub fn from_environment_and_args() -> Result { let mut transport = env::var("DBX_MCP_TRANSPORT").ok(); let mut host = env::var("DBX_MCP_HTTP_HOST").ok(); let mut port = env::var("DBX_MCP_HTTP_PORT").ok(); let mut path = env::var("DBX_MCP_HTTP_PATH").ok(); let mut allow_remote = env_flag("DBX_MCP_HTTP_ALLOW_REMOTE")?; let mut explicit_allow_remote = false; let mut arguments = env::args().skip(1); while let Some(argument) = arguments.next() { match argument.as_str() { "--stdio" => transport = Some("stdio".into()), "--http" => transport = Some("streamable-http".into()), "--http-allow-remote" => { allow_remote = true; explicit_allow_remote = true; } "--transport" => transport = Some(required_argument(&mut arguments, "--transport")?), "--http-host" => host = Some(required_argument(&mut arguments, "--http-host")?), "--http-port" => port = Some(required_argument(&mut arguments, "--http-port")?), "--http-path" => path = Some(required_argument(&mut arguments, "--http-path")?), _ => { if let Some(value) = argument.strip_prefix("--transport=") { transport = Some(value.into()); } else if let Some(value) = argument.strip_prefix("--http-host=") { host = Some(value.into()); } else if let Some(value) = argument.strip_prefix("--http-port=") { port = Some(value.into()); } else if let Some(value) = argument.strip_prefix("--http-path=") { path = Some(value.into()); } else { return Err(format!("unknown DBX MCP argument: {argument}")); } } } } let transport = parse_transport(transport.as_deref().unwrap_or("stdio"))?; if transport == McpTransport::Stdio { return Ok(Self { transport, http: None }); } let host = host.unwrap_or_else(|| DEFAULT_HTTP_HOST.into()); let ip = host.parse::().map_err(|_| "DBX_MCP_HTTP_HOST must be an IP address".to_string())?; let port = port .unwrap_or_else(|| DEFAULT_HTTP_PORT.to_string()) .parse::() .map_err(|_| "DBX_MCP_HTTP_PORT must be a valid TCP port".to_string())?; let bind_addr = SocketAddr::new(ip, port); let path = path.unwrap_or_else(|| DEFAULT_HTTP_PATH.into()); validate_path(&path)?; let is_loopback = ip.is_loopback(); if !(is_loopback || (allow_remote && explicit_allow_remote)) { return Err( "non-loopback HTTP binding requires both DBX_MCP_HTTP_ALLOW_REMOTE=1 and --http-allow-remote".into() ); } let allowed_hosts = comma_separated_env("DBX_MCP_HTTP_ALLOWED_HOSTS"); let allowed_origins = comma_separated_env("DBX_MCP_HTTP_ALLOWED_ORIGINS"); if !is_loopback && (allowed_hosts.is_empty() || allowed_origins.is_empty()) { return Err( "non-loopback HTTP binding requires DBX_MCP_HTTP_ALLOWED_HOSTS and DBX_MCP_HTTP_ALLOWED_ORIGINS".into(), ); } let token = http_token_from_environment()?; let allowed_hosts = if is_loopback { // HTTP Host authorities require brackets around IPv6 literals. vec!["localhost".into(), "127.0.0.1".into(), "[::1]".into()] } else { allowed_hosts }; let auth = HttpAuth::new_with_hosts(Some(token), allowed_hosts.clone(), allowed_origins.clone(), is_loopback)?; Ok(Self { transport, http: Some(HttpRuntimeConfig { bind_addr, path, auth, allowed_hosts }) }) } } fn parse_transport(value: &str) -> Result { match value.trim().to_ascii_lowercase().as_str() { "stdio" => Ok(McpTransport::Stdio), "http" | "streamable-http" | "streamable_http" => Ok(McpTransport::StreamableHttp), _ => Err("DBX_MCP_TRANSPORT must be stdio or streamable-http".into()), } } fn required_argument(arguments: &mut impl Iterator, name: &str) -> Result { arguments.next().filter(|value| !value.starts_with("--")).ok_or_else(|| format!("{name} requires a value")) } fn env_flag(name: &str) -> Result { match env::var(name) { Ok(value) => match value.trim().to_ascii_lowercase().as_str() { "1" | "true" | "yes" => Ok(true), "0" | "false" | "no" | "" => Ok(false), _ => Err(format!("{name} must be true or false")), }, Err(env::VarError::NotPresent) => Ok(false), Err(env::VarError::NotUnicode(_)) => Err(format!("{name} must be valid UTF-8")), } } fn comma_separated_env(name: &str) -> Vec { env::var(name) .ok() .into_iter() .flat_map(|value| { value.split(',').map(str::trim).filter(|value| !value.is_empty()).map(ToOwned::to_owned).collect::>() }) .collect() } fn http_token_from_environment() -> Result { let inline_token = env::var("DBX_MCP_HTTP_TOKEN").ok(); let token_file = env::var("DBX_MCP_HTTP_TOKEN_FILE").ok(); match (inline_token, token_file) { (Some(_), Some(_)) => Err("set only one of DBX_MCP_HTTP_TOKEN or DBX_MCP_HTTP_TOKEN_FILE".into()), (Some(token), None) if !token.trim().is_empty() => Ok(token), (None, Some(path)) => fs::read_to_string(&path) .map_err(|error| format!("failed to read DBX_MCP_HTTP_TOKEN_FILE: {error}")) .map(|token| token.trim_end_matches(['\r', '\n']).to_owned()) .and_then(|token| { (!token.is_empty()).then_some(token).ok_or_else(|| "DBX_MCP_HTTP_TOKEN_FILE is empty".into()) }), _ => Err("Streamable HTTP requires DBX_MCP_HTTP_TOKEN or DBX_MCP_HTTP_TOKEN_FILE".into()), } } fn validate_path(path: &str) -> Result<(), String> { if path == "/" || !path.starts_with('/') || path.ends_with('/') || path.contains('?') || path.contains('#') { return Err("DBX_MCP_HTTP_PATH must be an absolute path such as /mcp".into()); } Ok(()) }