use std::sync::Arc;
use anyhow::{Context, Result};
use rmcp::model::ServerConfig;
use rmcp::service::{Peer, RoleClient, RunningService, ServiceExt as _};
use rmcp::transport::{ConfigureCommandExt, TokioChildProcess};
use crate::config::Config;
const UNKNOWN_UPSTREAM: &str = "unknown-upstream";
pub struct Upstream {
service: Option<Arc<RunningService<RoleClient, ()>>>,
peer: Arc<Peer<RoleClient>>,
info: ServerConfig,
child_pid: Option<u32>,
}
impl std::fmt::Debug for Upstream {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Upstream")
.field("child_pid", &self.child_pid)
.field("server", &self.info.server_info.name)
.field("version", &self.info.server_info.version)
.field("protocol", &self.info.protocol_version)
.finish_non_exhaustive()
}
}
impl Upstream {
pub async fn spawn(cfg: &Config) -> Result<Self> {
let argv = cfg.argv();
let (program, child_args) = argv
.split_first()
.context("--command resolved to an empty command")?;
let command = tokio::process::Command::new(program).configure(|c| {
c.args(child_args);
c.envs(cfg.env.iter().map(|(k, v)| (k, v)));
if let Some(cwd) = cfg.cwd.as_ref() {
c.current_dir(cwd);
}
});
let transport = TokioChildProcess::new(command)
.with_context(|| format!("failed to spawn upstream MCP server {program:?}"))?;
let child_pid = transport.id();
let handshake =
tokio::time::timeout(cfg.init_timeout(), async { ().serve(transport).await }).await;
let service = match handshake {
Ok(Ok(service)) => service,
Ok(Err(error)) => {
return Err(error).with_context(|| {
format!("upstream MCP server {program:?} failed to initialize")
});
}
Err(_elapsed) => {
return Err(anyhow::anyhow!(
"upstream MCP server {program:?} did not initialize within {:?}",
cfg.init_timeout()
));
}
};
let peer = Arc::new(service.peer().clone());
let info = peer
.peer_info()
.as_deref()
.map(server_config)
.with_context(|| {
format!("upstream MCP server {program:?} initialized without advertising its info")
})?;
log_upstream(program, child_pid, &info, &peer).await;
Ok(Self {
service: Some(Arc::new(service)),
peer,
info,
child_pid,
})
}
#[must_use]
pub fn peer(&self) -> &Arc<Peer<RoleClient>> {
&self.peer
}
#[must_use]
pub fn info(&self) -> &ServerConfig {
&self.info
}
#[must_use]
pub fn child_pid(&self) -> Option<u32> {
self.child_pid
}
pub async fn shutdown(&mut self) -> anyhow::Result<()> {
let Some(service) = self.service.take() else {
return Ok(());
};
match Arc::try_unwrap(service) {
Ok(mut owned) => {
owned.close().await?;
Ok(())
}
Err(shared) => Err(anyhow::anyhow!(
"upstream child is still referenced {} time(s); cannot close it cleanly",
Arc::strong_count(&shared) - 1
)),
}
}
}
fn server_config(info: &rmcp::model::ServerPeerInfo) -> ServerConfig {
let mut config = ServerConfig::new(info.capabilities.clone())
.with_protocol_version(info.protocol_version.clone());
config.server_info = info
.server_info
.clone()
.unwrap_or_else(|| rmcp::model::Implementation::new(UNKNOWN_UPSTREAM, "unknown"));
config.instructions.clone_from(&info.instructions);
config.meta.clone_from(&info.meta);
config
}
async fn log_upstream(
program: &str,
pid: Option<u32>,
info: &ServerConfig,
peer: &Peer<RoleClient>,
) {
let tool_count = match peer.list_tools(None).await {
Ok(result) => result.tools.len(),
Err(error) => {
tracing::warn!(%error, "could not list upstream tools at startup");
0
}
};
tracing::info!(
pid = ?pid,
server = %info.server_info.name,
version = %info.server_info.version,
protocol = %info.protocol_version,
tools = tool_count,
"upstream MCP server connected"
);
tracing::debug!(program, "upstream command line resolved");
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::Config;
use clap::Parser;
fn config(argv: &[&str]) -> Config {
let mut full = vec!["stdio2http"];
full.extend_from_slice(argv);
Config::parse_from(full)
}
#[tokio::test]
async fn spawning_a_missing_program_is_an_error() {
let cfg = config(&[
"--command",
"/nonexistent/definitely-not-a-real-binary-xyz",
"--init-timeout-ms",
"500",
]);
let error = Upstream::spawn(&cfg).await.expect_err("must fail to spawn");
let rendered = format!("{error:#}");
assert!(
rendered.contains("definitely-not-a-real-binary-xyz"),
"error should name the program: {rendered}"
);
}
#[tokio::test]
async fn spawning_a_non_mcp_program_times_out() {
let cfg = config(&[
"--command",
"sleep",
"--arg",
"30",
"--init-timeout-ms",
"300",
]);
let error = Upstream::spawn(&cfg).await.expect_err("must time out");
let rendered = format!("{error:#}");
assert!(
rendered.contains("did not initialize"),
"error should report a timeout: {rendered}"
);
}
#[tokio::test]
async fn spawning_a_program_that_exits_immediately_is_an_error() {
let cfg = config(&["--command", "true", "--init-timeout-ms", "2000"]);
let error = Upstream::spawn(&cfg).await.expect_err("must fail");
let rendered = format!("{error:#}");
assert!(
rendered.contains("failed to initialize") || rendered.contains("did not initialize"),
"unexpected error: {rendered}"
);
}
#[tokio::test]
async fn child_env_and_cwd_are_applied() {
let dir = std::env::temp_dir().join("stdio2http-upstream-cwd-test");
std::fs::create_dir_all(&dir).expect("create temp dir");
let cfg = config(&[
"--command",
"pwd",
"--child-env",
"STDOUT2HTTP_PROBE=1",
"--cwd",
dir.to_str().expect("utf-8 temp dir"),
"--init-timeout-ms",
"500",
]);
let error = Upstream::spawn(&cfg)
.await
.expect_err("pwd never initializes");
assert!(!format!("{error:#}").contains("failed to spawn upstream"));
std::fs::remove_dir_all(&dir).ok();
}
}