From 695d8d01a22d4ec1f71a654266934f7f4b80865c Mon Sep 17 00:00:00 2001 From: ZhuchkaTriplesix Date: Mon, 16 Nov 2026 18:32:08 +0300 Subject: [PATCH] feat(rust): in-process MCP server skeleton Bootstrap an rmcp server inside Tauri on 127.0.0.1 with the same token handshake + endpoint file shape as Flutter, so initialize/ping work and querya-mcp can dial in. Tools come in #1901. Closes #1900 --- apps/tauri/src-tauri/Cargo.lock | 75 ++++- apps/tauri/src-tauri/Cargo.toml | 1 + apps/tauri/src-tauri/src/commands.rs | 22 ++ apps/tauri/src-tauri/src/lib.rs | 9 +- apps/tauri/src-tauri/src/mcp/endpoint.rs | 152 +++++++++ apps/tauri/src-tauri/src/mcp/host.rs | 389 +++++++++++++++++++++++ apps/tauri/src-tauri/src/mcp/mod.rs | 11 + apps/tauri/src-tauri/src/mcp/server.rs | 26 ++ 8 files changed, 681 insertions(+), 4 deletions(-) create mode 100644 apps/tauri/src-tauri/src/mcp/endpoint.rs create mode 100644 apps/tauri/src-tauri/src/mcp/host.rs create mode 100644 apps/tauri/src-tauri/src/mcp/mod.rs create mode 100644 apps/tauri/src-tauri/src/mcp/server.rs diff --git a/apps/tauri/src-tauri/Cargo.lock b/apps/tauri/src-tauri/Cargo.lock index 395d554e..f42b1767 100644 --- a/apps/tauri/src-tauri/Cargo.lock +++ b/apps/tauri/src-tauri/Cargo.lock @@ -3997,6 +3997,12 @@ dependencies = [ "phc", ] +[[package]] +name = "pastey" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4" + [[package]] name = "pbkdf2" version = "0.13.0" @@ -4467,8 +4473,8 @@ dependencies = [ "mac_address", "mongodb", "rand 0.10.4", - "rand_core 0.6.4", "redis", + "rmcp", "rusqlite", "russh", "rust_decimal", @@ -4824,6 +4830,44 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rmcp" +version = "3.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5949e504d5ab9944a168259afc0c39ac0230627b6ec5367ace194c59bcbe163" +dependencies = [ + "base64 0.23.1", + "chrono", + "futures", + "indexmap 2.14.2", + "libc", + "pastey", + "pin-project-lite", + "rmcp-macros", + "schemars 1.2.3", + "serde", + "serde_json", + "sha2 0.11.1", + "thiserror 2.0.21", + "tokio", + "tokio-util", + "tracing", + "uuid", +] + +[[package]] +name = "rmcp-macros" +version = "3.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98a686693ee91b665c6f89f182fca6e141c8a63dc113b11b38c1bf3491606b7" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "serde_json", + "syn 3.0.10", +] + [[package]] name = "rsa" version = "0.9.10" @@ -5101,7 +5145,7 @@ checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615" dependencies = [ "dyn-clone", "indexmap 1.9.3", - "schemars_derive", + "schemars_derive 0.8.22", "serde", "serde_json", "url", @@ -5126,8 +5170,10 @@ version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab508826f74a77ca9d5aba6ff19b522583ee3eaf28a19384ff3d0e5835fadf6e" dependencies = [ + "chrono", "dyn-clone", "ref-cast", + "schemars_derive 1.2.3", "serde", "serde_json", ] @@ -5140,10 +5186,22 @@ checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d" dependencies = [ "proc-macro2", "quote", - "serde_derive_internals", + "serde_derive_internals 0.29.1", "syn 2.0.119", ] +[[package]] +name = "schemars_derive" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1c3a92094fa7d61aa124645844facb6b554dfc797136d0f5fd1f890e2bffc69" +dependencies = [ + "proc-macro2", + "quote", + "serde_derive_internals 0.30.0", + "syn 3.0.10", +] + [[package]] name = "scopeguard" version = "1.2.0" @@ -5321,6 +5379,17 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "serde_derive_internals" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f852137cce035d6a4df67ccce505ff6b3e9fd3a10e3e52b24dc71e650bb1a9bd" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + [[package]] name = "serde_json" version = "1.0.154" diff --git a/apps/tauri/src-tauri/Cargo.toml b/apps/tauri/src-tauri/Cargo.toml index f2950422..82e377be 100644 --- a/apps/tauri/src-tauri/Cargo.toml +++ b/apps/tauri/src-tauri/Cargo.toml @@ -47,6 +47,7 @@ redis = { version = "0.27", features = ["aio", "tokio-comp"] } mongodb = "3.10.1" russh = { version = "0.65.1", features = ["default"] } rand = "0.10.4" +rmcp = { version = "3.10.0", features = ["server", "transport-async-rw"] } [profile.release] codegen-units = 1 diff --git a/apps/tauri/src-tauri/src/commands.rs b/apps/tauri/src-tauri/src/commands.rs index a35a54b8..b9f2fd04 100644 --- a/apps/tauri/src-tauri/src/commands.rs +++ b/apps/tauri/src-tauri/src/commands.rs @@ -938,3 +938,25 @@ pub fn ssh_tunnel_list( ) -> Result, crate::ssh_tunnel::SshTunnelError> { tunnels.list() } + +/// Start the in-process MCP loopback server and write the endpoint file (#1900). +#[tauri::command] +pub fn mcp_start( + mcp: State<'_, crate::mcp::McpController>, +) -> Result { + mcp.start() +} + +#[tauri::command] +pub fn mcp_stop( + mcp: State<'_, crate::mcp::McpController>, +) -> Result { + mcp.stop() +} + +#[tauri::command] +pub fn mcp_status( + mcp: State<'_, crate::mcp::McpController>, +) -> Result { + mcp.status() +} diff --git a/apps/tauri/src-tauri/src/lib.rs b/apps/tauri/src-tauri/src/lib.rs index a67b2414..bd74bdd7 100644 --- a/apps/tauri/src-tauri/src/lib.rs +++ b/apps/tauri/src-tauri/src/lib.rs @@ -1,5 +1,6 @@ mod commands; mod connection; +mod mcp; mod profiles; mod secrets; mod ssh_tunnel; @@ -13,6 +14,7 @@ pub use connection::{ }; pub use profiles::{ConnectionProfile, ProfileStore, ProfileStoreError}; pub use secrets::{KeyringSecretStore, MemorySecretStore, SecretError, SecretStore, SharedSecretStore}; +pub use mcp::{McpController, McpError, McpStatus}; pub use ssh_tunnel::{ SshTunnelError, SshTunnelInfo, SshTunnelOpenRequest, SshTunnelRegistry, }; @@ -31,7 +33,8 @@ use commands::{ mongo_list_databases, mongo_ping, profiles_connect_mongo, profiles_connect_mysql, profiles_connect_postgres, profiles_connect_redis, profiles_connect_sqlite, profiles_delete, profiles_list, profiles_upsert, redis_get, redis_key_metas, redis_ping, redis_read_key, - redis_scan, redis_set, ssh_tunnel_close, ssh_tunnel_list, ssh_tunnel_open, + redis_scan, redis_set, mcp_start, mcp_status, mcp_stop, ssh_tunnel_close, ssh_tunnel_list, + ssh_tunnel_open, }; #[tauri::command] @@ -86,6 +89,7 @@ pub fn run() { .manage(ConnectionRegistry::new()) .manage(KeyringSecretStore::shared()) .manage(SshTunnelRegistry::new()) + .manage(McpController::new()) .setup(|app| { use tauri::Manager; let store = ProfileStore::open_default().map_err(|e| { @@ -138,6 +142,9 @@ pub fn run() { ssh_tunnel_open, ssh_tunnel_close, ssh_tunnel_list, + mcp_start, + mcp_stop, + mcp_status, ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); diff --git a/apps/tauri/src-tauri/src/mcp/endpoint.rs b/apps/tauri/src-tauri/src/mcp/endpoint.rs new file mode 100644 index 00000000..ed041cfd --- /dev/null +++ b/apps/tauri/src-tauri/src/mcp/endpoint.rs @@ -0,0 +1,152 @@ +//! Endpoint file shared with `querya-mcp` (Flutter-compatible shape). + +use serde::{Deserialize, Serialize}; +use std::fs; +use std::io; +use std::path::{Path, PathBuf}; + +/// Overrides the endpoint file location (tests, several app instances). +pub const ENV_OVERRIDE: &str = "QUERYA_MCP_ENDPOINT"; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct McpEndpoint { + pub port: u16, + pub token: String, + pub pid: u32, + pub version: String, +} + +impl McpEndpoint { + /// `$XDG_RUNTIME_DIR/querya/mcp-endpoint.json` on Linux (falls back to + /// `~/.cache/querya`), `~/Library/Caches/Querya` on macOS, + /// `%LOCALAPPDATA%\Querya` on Windows. + pub fn default_path() -> PathBuf { + if let Ok(override_path) = std::env::var(ENV_OVERRIDE) { + let trimmed = override_path.trim(); + if !trimmed.is_empty() { + return PathBuf::from(trimmed); + } + } + #[cfg(target_os = "windows")] + { + let base = std::env::var("LOCALAPPDATA") + .or_else(|_| { + std::env::var("USERPROFILE").map(|h| { + format!("{h}\\AppData\\Local") + }) + }) + .unwrap_or_else(|_| ".".into()); + return PathBuf::from(base).join("Querya").join("mcp-endpoint.json"); + } + #[cfg(target_os = "macos")] + { + let home = std::env::var("HOME").unwrap_or_else(|_| ".".into()); + return PathBuf::from(home) + .join("Library") + .join("Caches") + .join("Querya") + .join("mcp-endpoint.json"); + } + #[cfg(not(any(target_os = "windows", target_os = "macos")))] + { + if let Ok(runtime) = std::env::var("XDG_RUNTIME_DIR") { + if !runtime.trim().is_empty() { + return PathBuf::from(runtime) + .join("querya") + .join("mcp-endpoint.json"); + } + } + let home = std::env::var("HOME").unwrap_or_else(|_| ".".into()); + PathBuf::from(home) + .join(".cache") + .join("querya") + .join("mcp-endpoint.json") + } + } + + /// 32 random bytes as hex (Flutter `McpEndpoint.newToken` parity). + pub fn new_token() -> String { + use rand::Rng; + let mut bytes = [0u8; 32]; + rand::rng().fill_bytes(&mut bytes); + bytes.iter().map(|b| format!("{b:02x}")).collect() + } + + /// Constant-time comparison for the handshake token. + pub fn tokens_equal(a: &str, b: &str) -> bool { + let x = a.as_bytes(); + let y = b.as_bytes(); + let mut diff = x.len() ^ y.len(); + let n = x.len().min(y.len()); + for i in 0..n { + diff |= usize::from(x[i] ^ y[i]); + } + diff == 0 + } + + pub fn write(&self, path: &Path) -> io::Result<()> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent)?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let _ = fs::set_permissions(parent, fs::Permissions::from_mode(0o700)); + } + } + let tmp = path.with_extension("json.tmp"); + fs::write(&tmp, "")?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let _ = fs::set_permissions(&tmp, fs::Permissions::from_mode(0o600)); + } + fs::write(&tmp, serde_json::to_vec(self).expect("endpoint json"))?; + fs::rename(&tmp, path)?; + Ok(()) + } + + pub fn read(path: &Path) -> io::Result> { + match fs::read_to_string(path) { + Ok(raw) => Ok(serde_json::from_str(&raw).ok()), + Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None), + Err(e) => Err(e), + } + } + + pub fn clear(path: &Path) -> io::Result<()> { + match fs::remove_file(path) { + Ok(()) => Ok(()), + Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()), + Err(e) => Err(e), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn tokens_equal_rejects_mismatch() { + assert!(McpEndpoint::tokens_equal("abc", "abc")); + assert!(!McpEndpoint::tokens_equal("abc", "abd")); + assert!(!McpEndpoint::tokens_equal("abc", "ab")); + } + + #[test] + fn write_read_round_trip() { + let dir = std::env::temp_dir().join(format!("querya-mcp-ep-{}", std::process::id())); + let path = dir.join("mcp-endpoint.json"); + let ep = McpEndpoint { + port: 12345, + token: "deadbeef".into(), + pid: 42, + version: "0.1.0".into(), + }; + ep.write(&path).unwrap(); + let back = McpEndpoint::read(&path).unwrap().unwrap(); + assert_eq!(back, ep); + McpEndpoint::clear(&path).unwrap(); + let _ = fs::remove_dir_all(&dir); + } +} diff --git a/apps/tauri/src-tauri/src/mcp/host.rs b/apps/tauri/src-tauri/src/mcp/host.rs new file mode 100644 index 00000000..04dd31ef --- /dev/null +++ b/apps/tauri/src-tauri/src/mcp/host.rs @@ -0,0 +1,389 @@ +//! Loopback TCP host with token handshake (Flutter `McpSocketHost` parity). + +use super::endpoint::McpEndpoint; +use super::server::QueryaMcpServer; +use rmcp::ServiceExt; +use serde::Serialize; +use std::path::PathBuf; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::net::{TcpListener, TcpStream}; +use tokio::task::JoinHandle; + +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct McpStatus { + pub running: bool, + pub port: Option, + pub session_count: u32, + pub endpoint_path: String, +} + +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct McpError { + pub message: String, +} + +impl McpError { + fn new(message: impl Into) -> Self { + Self { + message: message.into(), + } + } +} + +impl std::fmt::Display for McpError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&self.message) + } +} + +impl std::error::Error for McpError {} + +struct RunningHost { + port: u16, + endpoint_path: PathBuf, + session_count: Arc, + stop: Arc, + accept_task: JoinHandle<()>, +} + +/// Starts / stops the in-process MCP loopback server. +#[derive(Default)] +pub struct McpController { + inner: Mutex>, +} + +impl McpController { + pub fn new() -> Self { + Self::default() + } + + pub fn status(&self) -> Result { + let guard = self + .inner + .lock() + .map_err(|_| McpError::new("mcp controller lock poisoned"))?; + let path = McpEndpoint::default_path(); + match guard.as_ref() { + Some(h) => Ok(McpStatus { + running: true, + port: Some(h.port), + session_count: h.session_count.load(Ordering::SeqCst) as u32, + endpoint_path: h.endpoint_path.display().to_string(), + }), + None => Ok(McpStatus { + running: false, + port: None, + session_count: 0, + endpoint_path: path.display().to_string(), + }), + } + } + + pub fn start(&self) -> Result { + crate::connection::runtime::block_on(self.start_async(None)) + } + + pub fn stop(&self) -> Result { + crate::connection::runtime::block_on(self.stop_async()) + } + + async fn start_async( + &self, + endpoint_path: Option, + ) -> Result { + { + let guard = self + .inner + .lock() + .map_err(|_| McpError::new("mcp controller lock poisoned"))?; + if guard.is_some() { + drop(guard); + return self.status(); + } + } + + let listener = TcpListener::bind(("127.0.0.1", 0)) + .await + .map_err(|e| McpError::new(format!("bind MCP loopback: {e}")))?; + let port = listener + .local_addr() + .map_err(|e| McpError::new(format!("MCP local addr: {e}")))? + .port(); + let token = McpEndpoint::new_token(); + let endpoint_path = endpoint_path.unwrap_or_else(McpEndpoint::default_path); + let endpoint = McpEndpoint { + port, + token: token.clone(), + pid: std::process::id(), + version: env!("CARGO_PKG_VERSION").into(), + }; + endpoint + .write(&endpoint_path) + .map_err(|e| McpError::new(format!("write MCP endpoint: {e}")))?; + + let stop = Arc::new(AtomicBool::new(false)); + let session_count = Arc::new(AtomicUsize::new(0)); + let stop_flag = Arc::clone(&stop); + let sessions = Arc::clone(&session_count); + let accept_token = token.clone(); + + let accept_task = tokio::spawn(async move { + loop { + if stop_flag.load(Ordering::SeqCst) { + break; + } + let accept = + tokio::time::timeout(Duration::from_millis(400), listener.accept()).await; + match accept { + Ok(Ok((socket, _))) => { + let token = accept_token.clone(); + let sessions = Arc::clone(&sessions); + let stop_flag = Arc::clone(&stop_flag); + tokio::spawn(async move { + if let Err(e) = + handle_connection(socket, token, sessions, stop_flag).await + { + eprintln!("mcp session error: {e}"); + } + }); + } + Ok(Err(_)) => break, + Err(_) => continue, + } + } + }); + + let mut guard = self + .inner + .lock() + .map_err(|_| McpError::new("mcp controller lock poisoned"))?; + *guard = Some(RunningHost { + port, + endpoint_path: endpoint_path.clone(), + session_count, + stop, + accept_task, + }); + drop(guard); + self.status() + } + + async fn stop_async(&self) -> Result { + let running = { + let mut guard = self + .inner + .lock() + .map_err(|_| McpError::new("mcp controller lock poisoned"))?; + guard.take() + }; + if let Some(h) = running { + h.stop.store(true, Ordering::SeqCst); + h.accept_task.abort(); + let _ = McpEndpoint::clear(&h.endpoint_path); + } + self.status() + } +} + +async fn handle_connection( + mut socket: TcpStream, + expected_token: String, + session_count: Arc, + stop: Arc, +) -> Result<(), McpError> { + if stop.load(Ordering::SeqCst) { + return Ok(()); + } + let line = read_handshake_line(&mut socket).await?; + if !McpEndpoint::tokens_equal(line.trim(), &expected_token) { + let err = serde_json::json!({ + "jsonrpc": "2.0", + "id": null, + "error": { + "code": -32001, + "message": "Invalid Querya MCP token. Restart the MCP client." + } + }); + let _ = socket + .write_all(format!("{err}\n").as_bytes()) + .await; + let _ = socket.shutdown().await; + return Err(McpError::new("invalid MCP token")); + } + + session_count.fetch_add(1, Ordering::SeqCst); + let _guard = SessionGuard(session_count); + + let server = QueryaMcpServer::new(); + let running = server + .serve(socket) + .await + .map_err(|e| McpError::new(format!("MCP serve failed: {e}")))?; + let _ = running.waiting().await; + Ok(()) +} + +struct SessionGuard(Arc); + +impl Drop for SessionGuard { + fn drop(&mut self) { + self.0.fetch_sub(1, Ordering::SeqCst); + } +} + +async fn read_handshake_line(socket: &mut TcpStream) -> Result { + let mut buf = Vec::with_capacity(64); + let mut byte = [0u8; 1]; + let deadline = tokio::time::Instant::now() + Duration::from_secs(5); + loop { + let remaining = deadline.saturating_duration_since(tokio::time::Instant::now()); + if remaining.is_zero() { + return Err(McpError::new("MCP handshake timed out")); + } + tokio::time::timeout(remaining, socket.read_exact(&mut byte)) + .await + .map_err(|_| McpError::new("MCP handshake timed out"))? + .map_err(|e| McpError::new(format!("MCP handshake read: {e}")))?; + if byte[0] == b'\n' { + break; + } + if byte[0] != b'\r' { + buf.push(byte[0]); + } + if buf.len() > 4096 { + return Err(McpError::new("MCP handshake too long")); + } + } + String::from_utf8(buf).map_err(|_| McpError::new("MCP handshake is not UTF-8")) +} + +#[cfg(test)] +mod tests { + use super::*; + use tokio::io::{AsyncBufReadExt, BufReader}; + + #[test] + fn start_initialize_ping_stop() { + if std::env::var_os("QUERYA_SKIP_MCP").is_some() { + eprintln!("skip mcp live test (QUERYA_SKIP_MCP)"); + return; + } + + let dir = std::env::temp_dir().join(format!( + "querya-mcp-host-{}-{}", + std::process::id(), + uuid::Uuid::new_v4() + )); + let ep_path = dir.join("mcp-endpoint.json"); + std::fs::create_dir_all(&dir).unwrap(); + + crate::connection::runtime::block_on(async { + let ctrl = McpController::new(); + let status = ctrl + .start_async(Some(ep_path.clone())) + .await + .expect("start mcp"); + assert!(status.running); + let port = status.port.expect("port"); + + let endpoint = McpEndpoint::read(&ep_path) + .unwrap() + .expect("endpoint file"); + assert_eq!(endpoint.port, port); + + let mut stream = TcpStream::connect(("127.0.0.1", port)) + .await + .expect("connect"); + stream + .write_all(format!("{}\n", endpoint.token).as_bytes()) + .await + .unwrap(); + + let init = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"querya-test","version":"0.0.1"}}}"#; + stream + .write_all(format!("{init}\n").as_bytes()) + .await + .unwrap(); + + let mut reader = BufReader::new(stream); + let mut line = String::new(); + tokio::time::timeout(Duration::from_secs(3), reader.read_line(&mut line)) + .await + .expect("init timeout") + .expect("init read"); + let v: serde_json::Value = serde_json::from_str(line.trim()).unwrap(); + assert_eq!(v["id"], 1); + assert_eq!( + v["result"]["serverInfo"]["name"].as_str().unwrap(), + "querya-desktop" + ); + assert!(v["result"]["protocolVersion"].is_string()); + + let initialized = r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#; + reader + .get_mut() + .write_all(format!("{initialized}\n").as_bytes()) + .await + .unwrap(); + + let ping = r#"{"jsonrpc":"2.0","id":2,"method":"ping"}"#; + reader + .get_mut() + .write_all(format!("{ping}\n").as_bytes()) + .await + .unwrap(); + line.clear(); + tokio::time::timeout(Duration::from_secs(3), reader.read_line(&mut line)) + .await + .expect("ping timeout") + .expect("ping read"); + let ping_v: serde_json::Value = serde_json::from_str(line.trim()).unwrap(); + assert_eq!(ping_v["id"], 2); + assert!(ping_v.get("result").is_some()); + + let stopped = ctrl.stop_async().await.expect("stop"); + assert!(!stopped.running); + assert!(McpEndpoint::read(&ep_path).unwrap().is_none()); + }); + + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn rejects_bad_token() { + if std::env::var_os("QUERYA_SKIP_MCP").is_some() { + return; + } + let dir = std::env::temp_dir().join(format!( + "querya-mcp-bad-{}-{}", + std::process::id(), + uuid::Uuid::new_v4() + )); + let ep_path = dir.join("mcp-endpoint.json"); + std::fs::create_dir_all(&dir).unwrap(); + + crate::connection::runtime::block_on(async { + let ctrl = McpController::new(); + let status = ctrl.start_async(Some(ep_path.clone())).await.unwrap(); + let port = status.port.unwrap(); + let mut stream = TcpStream::connect(("127.0.0.1", port)).await.unwrap(); + stream.write_all(b"not-the-token\n").await.unwrap(); + let mut reader = BufReader::new(stream); + let mut line = String::new(); + tokio::time::timeout(Duration::from_secs(3), reader.read_line(&mut line)) + .await + .unwrap() + .unwrap(); + let v: serde_json::Value = serde_json::from_str(line.trim()).unwrap(); + assert_eq!(v["error"]["code"], -32001); + let _ = ctrl.stop_async().await; + }); + + let _ = std::fs::remove_dir_all(&dir); + } +} diff --git a/apps/tauri/src-tauri/src/mcp/mod.rs b/apps/tauri/src-tauri/src/mcp/mod.rs new file mode 100644 index 00000000..a0545e8f --- /dev/null +++ b/apps/tauri/src-tauri/src/mcp/mod.rs @@ -0,0 +1,11 @@ +//! In-process MCP server (loopback + token) for Querya Desktop. + +mod endpoint; +mod host; +mod server; + +#[allow(unused_imports)] +pub use endpoint::McpEndpoint; +pub use host::{McpController, McpError, McpStatus}; +#[allow(unused_imports)] +pub use server::QueryaMcpServer; diff --git a/apps/tauri/src-tauri/src/mcp/server.rs b/apps/tauri/src-tauri/src/mcp/server.rs new file mode 100644 index 00000000..5a0e3828 --- /dev/null +++ b/apps/tauri/src-tauri/src/mcp/server.rs @@ -0,0 +1,26 @@ +//! Minimal in-process MCP server (initialize / ping). Tools land in #1901. + +use rmcp::handler::server::ServerHandler; +use rmcp::model::{Implementation, ServerCapabilities, ServerConfig}; + +#[derive(Clone, Default)] +pub struct QueryaMcpServer; + +impl QueryaMcpServer { + pub fn new() -> Self { + Self + } +} + +impl ServerHandler for QueryaMcpServer { + fn get_info(&self) -> ServerConfig { + ServerConfig::new(ServerCapabilities::builder().enable_tools().build()) + .with_server_info(Implementation::new( + "querya-desktop", + env!("CARGO_PKG_VERSION"), + )) + .with_instructions( + "Querya Desktop MCP skeleton. Connection/query tools arrive in a follow-up.", + ) + } +}