Add end-to-end sanity checks for ldk-server-mcp

Build the MCP binary in the e2e harness and exercise its stdio protocol against a live ldk-server so basic MCP functionality is verified without involving an agent.

Co-Authored-By: HAL 9000

Author: tnull

e2e-tests/build.rs

@@ -11,9 +11,13 @@ fn main() {
 		.expect("e2e-tests must be inside workspace")
 		.to_path_buf();
 
+	let outer_target_dir = env::var_os("CARGO_TARGET_DIR")
+		.map(PathBuf::from)
+		.unwrap_or_else(|| workspace_root.join("target"));
+
 	// Use a separate target directory so the inner cargo build doesn't deadlock
 	// waiting for the build directory lock held by the outer cargo.
-	let target_dir = workspace_root.join("target").join("e2e-deps");
+	let target_dir = outer_target_dir.join("e2e-deps");
 
 	let status = Command::new(&cargo)
 		.args([
@@ -24,21 +28,25 @@ fn main() {
 			"experimental-lsps2-support",
 			"-p",
 			"ldk-server-cli",
+			"-p",
+			"ldk-server-mcp",
 		])
 		.current_dir(&workspace_root)
 		.env("CARGO_TARGET_DIR", &target_dir)
 		.env_remove("CARGO_ENCODED_RUSTFLAGS")
 		.status()
 		.expect("failed to run cargo build");
 
-	assert!(status.success(), "cargo build of ldk-server / ldk-server-cli failed");
+	assert!(status.success(), "cargo build of ldk-server / ldk-server-cli / ldk-server-mcp failed");
 
 	let bin_dir = target_dir.join(&profile);
 	let server_bin = bin_dir.join("ldk-server");
 	let cli_bin = bin_dir.join("ldk-server-cli");
+	let mcp_bin = bin_dir.join("ldk-server-mcp");
 
 	println!("cargo:rustc-env=LDK_SERVER_BIN={}", server_bin.display());
 	println!("cargo:rustc-env=LDK_SERVER_CLI_BIN={}", cli_bin.display());
+	println!("cargo:rustc-env=LDK_SERVER_MCP_BIN={}", mcp_bin.display());
 
 	// Rebuild when server or CLI source changes
 	println!("cargo:rerun-if-changed=../ldk-server/src");
@@ -47,4 +55,7 @@ fn main() {
 	println!("cargo:rerun-if-changed=../ldk-server-cli/Cargo.toml");
 	println!("cargo:rerun-if-changed=../ldk-server-grpc/src");
 	println!("cargo:rerun-if-changed=../ldk-server-grpc/Cargo.toml");
+	println!("cargo:rerun-if-changed=../ldk-server-mcp/src");
+	println!("cargo:rerun-if-changed=../ldk-server-mcp/tests");
+	println!("cargo:rerun-if-changed=../ldk-server-mcp/Cargo.toml");
 }

e2e-tests/src/lib.rs

@@ -7,7 +7,7 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-use std::io::{BufRead, BufReader};
+use std::io::{BufRead, BufReader, Write};
 use std::net::TcpListener;
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, Stdio};
@@ -16,6 +16,7 @@ use std::time::Duration;
 use corepc_node::Node;
 use hex_conservative::DisplayHex;
 use ldk_server_client::client::LdkServerClient;
+use serde_json::Value;
 use ldk_server_client::ldk_server_grpc::api::{GetNodeInfoRequest, GetNodeInfoResponse};
 use ldk_server_grpc::api::{
 	GetBalancesRequest, ListChannelsRequest, OnchainReceiveRequest, OpenChannelRequest,
@@ -291,6 +292,69 @@ pub fn cli_binary_path() -> PathBuf {
 	PathBuf::from(env!("LDK_SERVER_CLI_BIN"))
 }
 
+/// Returns the path to the ldk-server-mcp binary (built automatically by build.rs).
+pub fn mcp_binary_path() -> PathBuf {
+	PathBuf::from(env!("LDK_SERVER_MCP_BIN"))
+}
+
+/// Handle to a running ldk-server-mcp child process.
+pub struct McpHandle {
+	child: Option<Child>,
+	stdin: std::process::ChildStdin,
+	stdout: BufReader<std::process::ChildStdout>,
+}
+
+impl McpHandle {
+	pub fn start(server: &LdkServerHandle) -> Self {
+		let mcp_path = mcp_binary_path();
+		let mut child = Command::new(&mcp_path)
+			.env("LDK_BASE_URL", server.base_url())
+			.env("LDK_API_KEY", &server.api_key)
+			.env("LDK_TLS_CERT_PATH", server.tls_cert_path.to_str().unwrap())
+			.stdin(Stdio::piped())
+			.stdout(Stdio::piped())
+			.stderr(Stdio::piped())
+			.spawn()
+			.unwrap_or_else(|e| panic!("Failed to run MCP server at {:?}: {}", mcp_path, e));
+
+		let stdin = child.stdin.take().unwrap();
+		let stdout = BufReader::new(child.stdout.take().unwrap());
+
+		Self { child: Some(child), stdin, stdout }
+	}
+
+	pub fn send(&mut self, request: &Value) {
+		let line = serde_json::to_string(request).unwrap();
+		writeln!(self.stdin, "{}", line).unwrap();
+		self.stdin.flush().unwrap();
+	}
+
+	pub fn recv(&mut self) -> Value {
+		let mut line = String::new();
+		self.stdout.read_line(&mut line).expect("Failed to read MCP stdout");
+		serde_json::from_str(line.trim()).expect("Failed to parse MCP response")
+	}
+
+	pub fn call(&mut self, id: u64, method: &str, params: Value) -> Value {
+		self.send(&serde_json::json!({
+			"jsonrpc": "2.0",
+			"id": id,
+			"method": method,
+			"params": params,
+		}));
+		self.recv()
+	}
+}
+
+impl Drop for McpHandle {
+	fn drop(&mut self) {
+		if let Some(mut child) = self.child.take() {
+			let _ = child.kill();
+			let _ = child.wait();
+		}
+	}
+}
+
 /// Run a CLI command against the given server handle and return raw stdout as a string.
 pub fn run_cli_raw(handle: &LdkServerHandle, args: &[&str]) -> String {
 	let cli_path = cli_binary_path();

e2e-tests/tests/mcp.rs

@@ -0,0 +1,87 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+use e2e_tests::{LdkServerHandle, McpHandle, TestBitcoind};
+use ldk_server_client::ldk_server_grpc::api::Bolt11ReceiveRequest;
+use ldk_server_client::ldk_server_grpc::types::{
+	bolt11_invoice_description, Bolt11InvoiceDescription,
+};
+use serde_json::json;
+
+#[tokio::test]
+async fn test_mcp_initialize_and_list_tools() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start(&bitcoind).await;
+	let mut mcp = McpHandle::start(&server);
+
+	let initialize = mcp.call(
+		1,
+		"initialize",
+		json!({
+			"protocolVersion": "2024-11-05",
+			"capabilities": {},
+			"clientInfo": {"name": "e2e-test", "version": "0.1"}
+		}),
+	);
+	assert_eq!(initialize["result"]["protocolVersion"], "2024-11-05");
+	assert!(initialize["result"]["capabilities"]["tools"].is_object());
+
+	let tools = mcp.call(2, "tools/list", json!({}));
+	let tool_names = tools["result"]["tools"].as_array().unwrap();
+	assert!(tool_names.iter().any(|tool| tool["name"] == "get_node_info"));
+	assert!(tool_names.iter().any(|tool| tool["name"] == "onchain_receive"));
+	assert!(tool_names.iter().any(|tool| tool["name"] == "decode_invoice"));
+}
+
+#[tokio::test]
+async fn test_mcp_live_tool_calls() {
+	let bitcoind = TestBitcoind::new();
+	let server = LdkServerHandle::start(&bitcoind).await;
+	let mut mcp = McpHandle::start(&server);
+
+	let node_info = mcp.call(1, "tools/call", json!({
+		"name": "get_node_info",
+		"arguments": {}
+	}));
+	let node_info_text = node_info["result"]["content"][0]["text"].as_str().unwrap();
+	let node_info_json: serde_json::Value = serde_json::from_str(node_info_text).unwrap();
+	assert_eq!(node_info_json["node_id"], server.node_id());
+
+	let onchain_receive = mcp.call(2, "tools/call", json!({
+		"name": "onchain_receive",
+		"arguments": {}
+	}));
+	let onchain_receive_text = onchain_receive["result"]["content"][0]["text"].as_str().unwrap();
+	let onchain_receive_json: serde_json::Value =
+		serde_json::from_str(onchain_receive_text).unwrap();
+	assert!(onchain_receive_json["address"].as_str().unwrap().starts_with("bcrt1"));
+
+	let invoice = server
+		.client()
+		.bolt11_receive(Bolt11ReceiveRequest {
+			amount_msat: Some(50_000_000),
+			description: Some(Bolt11InvoiceDescription {
+				kind: Some(bolt11_invoice_description::Kind::Direct("mcp decode".to_string())),
+			}),
+			expiry_secs: 3600,
+		})
+		.await
+		.unwrap();
+
+	let decode_invoice = mcp.call(3, "tools/call", json!({
+		"name": "decode_invoice",
+		"arguments": { "invoice": invoice.invoice }
+	}));
+	let decode_invoice_text = decode_invoice["result"]["content"][0]["text"].as_str().unwrap();
+	let decode_invoice_json: serde_json::Value =
+		serde_json::from_str(decode_invoice_text).unwrap();
+	assert_eq!(decode_invoice_json["destination"], server.node_id());
+	assert_eq!(decode_invoice_json["description"], "mcp decode");
+	assert_eq!(decode_invoice_json["amount_msat"], 50_000_000u64);
+}