Файли
openidea/src-tauri/src/remote_dev.rs
T
Deng Liuтаdengliu 62058d5932 feat(mcp): support the built-in IDE MCP server in remote development (#4380)
In remote development (SSH, WSL, Dev Containers) the built-in IDE MCP server ran only in the desktop
shell: openidea-server never started it or answered --mcp-stdio, MCP status and confirmation commands
ran locally, and the Settings window showed the desktop's mcpServer settings for a remote window.

McpService and the MCP commands move into ide-host, so openidea-server runs its own MCP server per
host with a stable ~/.openidea/bin/openidea-server --mcp-stdio bridge. mcpServer.* settings of a
remote window apply to the remote host only. Remote MCP confirmation requests show only when this
machine trusts the remote project, and their answers route back to the server. Several servers sharing
one data directory (several remote windows on a host) each record a discovery entry; the stdio bridge
picks the one that has the project open by probing tools/list, and a server leaving promotes a live one.

Review follow-ups: the bridge no longer matches the initialize instructions text, a starting server
drops entries of servers that stopped listening, the stdio link is written only when the MCP server
starts, the MCP settings page reloads its status after Apply (a remote server's settings events reach
the project window only), and the unused process-wide MCP executable in ide-agent is gone.

Co-authored-by: dengliu <[email protected]>
2026-11-19 09:01:27 +08:00

1232 рядки
51 KiB
Rust
Неформатований Анотація Історія

Цей файл містить неоднозначні символи Юнікоду
Цей файл містить символи Юнікоду, які можна сплутати з іншими символами. Якщо ви вважаєте, що це зроблено навмисно, можете сміливо ігнорувати це попередження. Щоб показати їх, скористайтеся кнопкою Escape.
//! Remote development (client side): a window whose project lives on another
//! machine. The backend there is `openidea-server`, started over SSH; the
//! frontend's remote-capable commands go through [`remote_invoke`] instead of
//! running locally.
use crate::events::TauriSink;
use crate::state::AppState;
use ide_command::desktop_command;
use ide_core::{EventSink, IdeError, IdeResult};
use ide_host::catalogue::TrustClass;
use ide_host::rpc::{ChannelMessage, EventMessage, Invoke, ServerInfo};
use ide_jsonrpc::{Handler, Peer};
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::collections::HashMap;
use std::sync::Arc;
use tauri::ipc::Channel;
use tauri::{AppHandle, Manager, State, Window};
/// Browse before connecting, using the desktop's SSH configuration even in a remote window.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub async fn remote_bootstrap_list(
state: State<'_, AppState>,
ssh: String,
path: String,
) -> IdeResult<Vec<ide_ssh::RemoteEntry>> {
state.remote.list(&ide_ssh::FsConnection::Sftp { ssh }, &path).await
}
/// Where a remote project lives and how the server there is reached.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum RemoteTarget {
/// The host of SSH configuration `config`.
Ssh { config: String },
/// A WSL distribution on this machine.
Wsl { distro: String },
/// The dev container of local folder `folder`, built and started with the Dev Containers CLI;
/// `config` is its `devcontainer.json`, relative to the folder (empty = the default one).
DevContainer { folder: String, config: String },
}
/// Where the server is installed on the remote host (per version).
fn install_dir(version: &str) -> String {
format!("~/{SERVER_DIR}/{version}")
}
/// Under the remote home: where the server builds are kept, one folder per version.
pub(crate) const SERVER_DIR: &str = ".openidea/server";
/// File name of the server binary on every host.
pub(crate) const SERVER_BIN: &str = "openidea-server";
/// Printed before a probe's answer: shell start-up files and `wsl.exe` may print first.
pub(crate) const PROBE_MARK: &str = "__OPENIDEA_PROBE__";
/// One remote window's connection.
pub struct Connection {
peer: Peer,
pub target: RemoteTarget,
pub root: String,
pub host: String,
/// The server's `std::env::consts::OS`: where the project's commands run.
pub os: String,
/// The version the server reports; another version than this app's lacks newer commands.
pub server_version: String,
pub commands: Vec<String>,
/// Streaming arguments by connection-wide id: the frontend channel and the id
/// it expects (each webview numbers its own, and a settings window shares this
/// connection with its parent).
channels: Channels,
next_channel: std::sync::atomic::AtomicU64,
/// Keeps the SSH connection alive; `None` for WSL and dev containers.
session: Option<Arc<ide_ssh::Session>>,
/// How to reach a dev container's ports; `None` for SSH and WSL.
exec: Option<Arc<ide_remote::container_tunnel::Exec>>,
/// Remote ports forwarded to this machine (Ports tool window), by host (`None`: the remote
/// host itself) and remote port.
forwards: Mutex<Vec<(ForwardKey, Forward)>>,
/// Ports of the remote built-in web server forwarded here, by remote port.
web_forwards: Mutex<Vec<(u16, Forward)>>,
}
/// A forwarded port's host (`None`: the remote host itself) and remote port.
type ForwardKey = (Option<String>, u16);
/// A forwarded port: through the SSH connection, or `docker exec` in a dev container.
enum Forward {
Ssh(ide_ssh::Tunnel),
Container(ide_remote::container_tunnel::Tunnel),
}
impl Forward {
fn port(&self) -> u16 {
match self {
Self::Ssh(t) => t.port(),
Self::Container(t) => t.port(),
}
}
}
type Channels = Arc<Mutex<HashMap<u64, (Channel<ChannelFrame>, u64)>>>;
#[derive(Default)]
pub struct Connections(Mutex<HashMap<String, Arc<Connection>>>);
impl Connection {
/// Commands of a remote window that run on this machine follow this machine's decision about the
/// remote project, never the server's: the server only answers for what runs there. A remote
/// window always has a project, so only `Always` runs before it is trusted.
pub fn authorize(&self, trust: &ide_host::trust::TrustStore, class: TrustClass) -> IdeResult<()> {
if class == TrustClass::Always || self.trusted_here(trust) == Some(true) {
Ok(())
} else {
Err(IdeError::unavailable("Project is in Restricted Mode"))
}
}
/// This machine's decision about the project (`None`: none yet). A dev container is its local
/// folder's project, trusted before it was started.
pub fn trusted_here(&self, trust: &ide_host::trust::TrustStore) -> Option<bool> {
match trust.remote_decision(&self.location()) {
Ok(Some(decision)) => Some(decision),
Ok(None) => match &self.target {
RemoteTarget::DevContainer { folder, .. } => {
trust.trusted(std::path::Path::new(folder)).unwrap_or(false).then_some(true)
}
_ => None,
},
Err(_) => Some(false),
}
}
/// The key of this project's decisions on this machine.
fn location(&self) -> String {
serde_json::to_string(&(&self.target, &self.root)).unwrap_or_default()
}
}
impl Connections {
pub fn get(&self, window: &str) -> Option<Arc<Connection>> {
self.0.lock().get(window).cloned()
}
/// The window connected to folder `root` of `target`.
pub fn window_of(&self, target: &RemoteTarget, root: &str) -> Option<String> {
let root = root.trim_end_matches('/');
self.0
.lock()
.iter()
// A dev container is one project: its folder there is only known once connected.
.find(|(_, c)| {
c.target == *target
&& (matches!(target, RemoteTarget::DevContainer { .. }) || c.root.trim_end_matches('/') == root)
})
.map(|(label, _)| label.clone())
}
/// Every connected window.
pub fn all(&self) -> Vec<(String, Arc<Connection>)> {
self.0.lock().iter().map(|(w, c)| (w.clone(), c.clone())).collect()
}
pub fn disconnect(&self, window: &str) {
if let Some(c) = self.0.lock().remove(window) {
c.peer.kill();
c.forwards.lock().clear();
}
}
}
/// Where [`remote_connect`] is (`fraction`: 0..1 of a download / upload).
#[derive(Clone, Copy, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum RemoteStage {
Connecting,
/// `devcontainer up`: building or starting the container.
Container,
Checking,
Downloading,
Uploading,
Starting,
Opening,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProgress {
pub stage: RemoteStage,
pub fraction: Option<f64>,
}
pub(crate) type Progress = dyn Fn(RemoteStage, Option<f64>) + Send + Sync;
/// A value for one streaming argument of a remote command (`data`: JSON text).
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ChannelFrame {
pub id: u64,
pub data: String,
}
#[derive(Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProject {
pub target: RemoteTarget,
pub root: String,
/// `user@host:port` of the SSH configuration; the distribution name for WSL.
pub host: String,
pub server_version: String,
pub os: String,
/// Commands routed to the server (the rest run locally).
pub commands: Vec<String>,
pub project: ide_host::ops::project::ProjectInfo,
}
struct ClientHandler {
app: AppHandle,
window: String,
channels: Channels,
connection: Arc<std::sync::OnceLock<std::sync::Weak<Connection>>>,
}
impl Handler for ClientHandler {
fn on_notification(&self, method: &str, params: Value) {
match method {
"event" => match serde_json::from_value::<EventMessage>(params) {
Ok(m) => {
let trusted = self
.connection
.get()
.and_then(std::sync::Weak::upgrade)
.is_some_and(|c| c.trusted_here(&self.app.state::<AppState>().host.trust) == Some(true));
if ide_host::rpc::client_accepts(&m.event, trusted) {
// The server's windows are this window.
let _ = m.window;
TauriSink { app: self.app.clone(), window: Some(self.window.clone()) }.emit(m.event);
}
}
Err(e) => tracing::warn!("remote event: {e}"),
},
// Plugin code of this window's project runs on the server.
ide_host::plugins::remote_host::EVENT_NOTIFICATION => {
match serde_json::from_value::<ide_host::plugins::remote_host::PluginEventMessage>(params) {
Ok(m) if ide_host::plugins::remote_host::forwarded(&m.event) => {
crate::commands::plugin::deliver_to(&self.window, m.event)
}
Ok(_) => {}
Err(e) => tracing::warn!("remote plugin event: {e}"),
}
}
"channel" => match serde_json::from_value::<ChannelMessage>(params) {
Ok(m) => {
let channel = self.channels.lock().get(&m.id).cloned();
if let Some((c, id)) = channel {
let _ = c.send(ChannelFrame { id, data: m.data.to_string() });
}
}
Err(e) => tracing::warn!("remote channel: {e}"),
},
_ => {}
}
}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
use ide_host::plugins::remote_host::{
AUTH_REQUEST, AuthRequest, SECRET_REQUEST, SECRET_WRITE, SecretRequest, SecretWrite,
};
match method {
// A remote plugin's request header needs a secret from this machine's keychain.
SECRET_REQUEST => {
let r: SecretRequest =
serde_json::from_value(params).map_err(|e| (ide_jsonrpc::codes::INVALID_PARAMS, e.to_string()))?;
let state = self.app.state::<AppState>();
Ok(serde_json::to_value(state.plugins.declared_secret(&r.plugin, &r.name)).unwrap_or(Value::Null))
}
SECRET_WRITE => {
let request: SecretWrite =
serde_json::from_value(params).map_err(|e| (ide_jsonrpc::codes::INVALID_PARAMS, e.to_string()))?;
Ok(serde_json::to_value(self.app.state::<AppState>().plugins.remote_secret_write(request))
.unwrap_or(Value::Null))
}
AUTH_REQUEST => {
let request: AuthRequest =
serde_json::from_value(params).map_err(|e| (ide_jsonrpc::codes::INVALID_PARAMS, e.to_string()))?;
Ok(serde_json::to_value(self.app.state::<AppState>().plugins.remote_auth(&self.window, request))
.unwrap_or(Value::Null))
}
_ => Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, format!("unhandled method {method}"))),
}
}
}
/// A server binary that is this build for a remote `os`/`arch`: `OPENIDEA_SERVER_BINARY`, then
/// the one next to this app when the platforms match.
fn local_server_binary(os: &str, arch: &str) -> Option<std::path::PathBuf> {
if let Some(p) = std::env::var_os("OPENIDEA_SERVER_BINARY").map(std::path::PathBuf::from).filter(|p| p.is_file()) {
return Some(p);
}
if os == std::env::consts::OS && arch == std::env::consts::ARCH {
let exe = std::env::current_exe().ok()?;
let name = if cfg!(windows) { "openidea-server.exe" } else { "openidea-server" };
let sibling = exe.parent()?.join(name);
if sibling.is_file() {
return Some(sibling);
}
}
None
}
/// `<data dir>/server/<os>-<arch>/openidea-server`, where earlier versions told users to put a
/// server by hand. Nothing says which version it is, so it is only used when this version's server
/// cannot be downloaded.
fn unversioned_server_binary(data: &std::path::Path, os: &str, arch: &str) -> Option<std::path::PathBuf> {
Some(data.join("server").join(format!("{os}-{arch}")).join("openidea-server")).filter(|p| p.is_file())
}
/// The release build of the server for `os`/`arch`, downloaded once into the data dir.
async fn download_server(
state: &AppState,
version: &str,
os: &str,
arch: &str,
progress: Arc<Progress>,
) -> IdeResult<std::path::PathBuf> {
let (data, version, os, arch) = (state.local_data_dir.clone(), version.to_owned(), os.to_owned(), arch.to_owned());
tokio::task::spawn_blocking(move || {
ide_tools::server::fetch(&data, &version, &os, &arch, &ide_core::CancellationToken::new(), &|e| match e {
ide_tools::InstallEvent::Line { text } => tracing::info!("openidea-server download: {text}"),
ide_tools::InstallEvent::Progress { fraction, .. } => progress(RemoteStage::Downloading, fraction),
})
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// `uname -sm` → (`linux` | `macos`, `x86_64` | `aarch64`), as Rust names them.
pub(crate) fn platform(uname: &str) -> (String, String) {
let mut parts = uname.split_whitespace();
let os = match parts.next().unwrap_or_default().to_ascii_lowercase().as_str() {
"darwin" => "macos".to_owned(),
other => other.to_owned(),
};
let arch = match parts.next().unwrap_or_default() {
"arm64" => "aarch64".to_owned(),
"amd64" => "x86_64".to_owned(),
other => other.to_owned(),
};
(os, arch)
}
/// An absolute path on a server (Linux or macOS): never one this machine would read as a network
/// share or a device (`//host/share`, `\\host\share`, `//./pipe`).
fn server_path(path: &str) -> bool {
path.starts_with('/') && !path.starts_with("//") && !path.contains('\\')
}
/// What [`local_server`] settled on.
pub(crate) enum LocalServer {
/// A server binary on this machine and its [`build_id`].
Binary(std::path::PathBuf, String),
/// No binary available (offline): this build of the version already on the host.
Installed(String),
}
/// The server binary to put on a host of `os`/`arch` whose `installed` builds are known.
pub(crate) async fn local_server(
state: &AppState,
version: &str,
os: &str,
arch: &str,
installed: &[String],
progress: Arc<Progress>,
) -> IdeResult<LocalServer> {
// This version's server: this build, or the release download (kept per version, so an
// upgraded app never reuses an older one).
let local = match local_server_binary(os, arch) {
Some(local) => local,
None => match download_server(state, version, os, arch, progress).await {
Ok(local) => local,
// Offline: any build of this version already on the host will do, then a server put
// in the old unversioned place by hand.
Err(e) => {
if let Some(bin) = installed.first() {
return Ok(LocalServer::Installed(bin.clone()));
}
match unversioned_server_binary(&state.local_data_dir, os, arch) {
Some(local) => {
tracing::warn!(
"no openidea-server {version} for {os}-{arch} ({}); using {}, which may be another version",
e.message,
local.display()
);
local
}
None => {
return Err(IdeError::unavailable(format!(
"no openidea-server {version} for {os}-{arch} ({}). Download \
openidea-server-{os}-{arch}.gz from the {version} release, unpack it and put it at {} \
(or build it with `cargo build --release -p ide-host --bin openidea-server` for that \
platform and set OPENIDEA_SERVER_BINARY)",
e.message,
ide_tools::server::cached_path(&state.local_data_dir, version, os, arch).display()
)));
}
}
}
},
};
// One folder per build, so a rebuilt server of the same version is installed again.
let build = tokio::task::spawn_blocking({
let local = local.clone();
move || build_id(&local)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))??;
Ok(LocalServer::Binary(local, build))
}
/// Makes sure this version of the server is installed on the host; returns its path.
async fn ensure_server(state: &AppState, session: &ide_ssh::Session, progress: Arc<Progress>) -> IdeResult<String> {
progress(RemoteStage::Checking, None);
let version = env!("CARGO_PKG_VERSION");
let dir = install_dir(version);
let q = ide_ssh::shell::tilde_quote;
let probe = session
.exec(&format!("echo {PROBE_MARK}; uname -sm; ls -d {}/*/openidea-server 2>/dev/null", q(&dir)), None)
.await?
.stdout_str();
let probe = probe.split_once(PROBE_MARK).map_or(probe.as_str(), |(_, rest)| rest);
let mut lines = probe.lines().map(str::trim).filter(|l| !l.is_empty());
let (os, arch) = platform(lines.next().unwrap_or_default());
let installed: Vec<String> = lines.map(str::to_owned).collect();
let (local, build) = match local_server(state, version, &os, &arch, &installed, progress.clone()).await? {
LocalServer::Installed(bin) => return Ok(bin),
LocalServer::Binary(local, build) => (local, build),
};
if let Some(bin) = installed.iter().find(|b| b.ends_with(&format!("/{build}/openidea-server"))) {
return Ok(bin.to_string());
}
let fs = ide_ssh::RemoteFs::new(session.sftp().await?);
let remote_dir = fs.resolve(&dir).await;
fs.close().await;
let remote_dir = remote_dir?;
let remote_bin = ide_ssh::sftp::join(&ide_ssh::sftp::join(&remote_dir, &build), "openidea-server");
// Per install: another window may be installing the same build right now.
let tmp = format!(
"{remote_bin}.{}-{}.part",
std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_nanos()
);
let started = std::time::Instant::now();
progress(RemoteStage::Uploading, Some(0.0));
session
.put_with_progress(&tmp, &tokio::fs::read(&local).await?, &|f| progress(RemoteStage::Uploading, Some(f)))
.await?;
tracing::info!("installed openidea-server on {} in {:?}", session.label(), started.elapsed());
let q = ide_ssh::shell::quote;
// Older builds of this version go (a running one keeps its open file).
session
.exec(
&format!(
"chmod 755 {tmp} && mv -f {tmp} {bin} && find {dir} -mindepth 1 -maxdepth 1 ! -name {build} -exec rm -rf {{}} +",
tmp = q(&tmp),
bin = q(&remote_bin),
dir = q(&remote_dir),
build = q(&build),
),
None,
)
.await?
.into_stdout("installing openidea-server")?;
Ok(remote_bin)
}
/// A short content hash of the server binary (cached per path, size and time).
fn build_id(path: &std::path::Path) -> IdeResult<String> {
static CACHE: Mutex<Option<(std::path::PathBuf, u64, std::time::SystemTime, String)>> = Mutex::new(None);
let meta = std::fs::metadata(path)?;
let modified = meta.modified()?;
if let Some((p, len, time, id)) = &*CACHE.lock()
&& p == path
&& *len == meta.len()
&& *time == modified
{
return Ok(id.clone());
}
let id = blake3::hash(&std::fs::read(path)?).to_hex()[..16].to_owned();
*CACHE.lock() = Some((path.to_path_buf(), meta.len(), modified, id.clone()));
Ok(id)
}
/// File › Remote Development: opens `path` on `target` (an SSH host, a WSL distribution, or a
/// dev container, whose project folder is the container's own) in this window (installs /
/// starts the server as needed).
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub async fn remote_connect(
window: Window,
state: State<'_, AppState>,
target: RemoteTarget,
mut path: String,
on_progress: Channel<RemoteProgress>,
) -> IdeResult<RemoteProject> {
let progress: Arc<Progress> = Arc::new(move |stage, fraction| {
let _ = on_progress.send(RemoteProgress { stage, fraction });
});
progress(RemoteStage::Connecting, None);
let label = AppState::owner_window(window.label()).to_owned();
let channels: Channels = Arc::default();
let connection_slot: Arc<std::sync::OnceLock<std::sync::Weak<Connection>>> = Arc::default();
let handler = Arc::new(ClientHandler {
app: window.app_handle().clone(),
window: label.clone(),
channels: channels.clone(),
connection: connection_slot.clone(),
});
let tail = crate::remote_wsl::Tail::default();
let mut exec = None;
let (peer, session, host, title_tag) = match &target {
RemoteTarget::Ssh { config: id } => {
let config = state.ssh.config(id)?;
let session = state.ssh.session(id).await?;
let bin = ensure_server(&state, &session, progress.clone()).await?;
progress(RemoteStage::Starting, None);
let stream = session
.exec_stream(&format!("{} --stdio", ide_ssh::shell::tilde_quote(&bin)))
.await
.map_err(|e| IdeError::unavailable(format!("cannot start openidea-server: {e}")))?;
let (reader, writer) = tokio::io::split(stream);
(Peer::connect(reader, writer, handler), Some(session), config.label(), config.label())
}
RemoteTarget::Wsl { distro } => {
let bin = crate::remote_wsl::ensure_server(&state, distro, progress.clone()).await?;
progress(RemoteStage::Starting, None);
let peer = crate::remote_wsl::spawn(distro, &bin, handler, &tail)?;
(peer, None, distro.clone(), format!("WSL: {distro}"))
}
RemoteTarget::DevContainer { folder, config } => {
let (peer, root, run) =
crate::remote_container::connect(&state, folder, config, handler, &tail, &progress).await?;
path = root;
exec = Some(Arc::new(run));
let name = std::path::Path::new(folder)
.file_name()
.map_or_else(|| folder.clone(), |n| n.to_string_lossy().into_owned());
(peer, None, name.clone(), format!("Dev Container: {name}"))
}
};
// A server that dies on start-up says why on stderr (`wsl.exe` prints its own errors too).
let with_output = |e: IdeError| match tail.text() {
t if t.is_empty() => e,
t => IdeError::unavailable(format!("{}: {t}", e.message)),
};
let info: ServerInfo = peer
.request("initialize", serde_json::json!({ "version": ide_host::rpc::PROTOCOL_VERSION }), None)
.await
.map_err(|e| with_output(ide_host::rpc::error_from_reply(e)))?;
if info.protocol != ide_host::rpc::PROTOCOL_VERSION {
return Err(IdeError::unavailable(format!(
"openidea-server {} speaks protocol {}, this app {}",
info.version,
info.protocol,
ide_host::rpc::PROTOCOL_VERSION
)));
}
if info.version != env!("CARGO_PKG_VERSION") {
tracing::warn!(
"{host}: openidea-server {} with OpenIDEA {}: commands added since are not available",
info.version,
env!("CARGO_PKG_VERSION")
);
}
let commands: Vec<String> = crate::commands::routed().into_iter().map(str::to_owned).collect();
let root = if path.trim().is_empty() || path.trim() == "~" {
info.home.clone()
} else if let Some(rest) = path.trim().strip_prefix("~/") {
format!("{}/{rest}", info.home.trim_end_matches('/'))
} else {
path.trim().to_owned()
};
progress(RemoteStage::Opening, None);
let call = Invoke { window: label.clone(), cmd: "open_project".into(), args: serde_json::json!({ "path": root }) };
let project: ide_host::ops::project::ProjectInfo =
peer.request("invoke", call, None).await.map_err(ide_host::rpc::error_from_reply)?;
// As the server resolved it (symlinks, a trailing `/`): the frontend compares it with the project's.
let root = serde_json::to_value(&project.root).ok().and_then(|v| v.as_str().map(str::to_owned)).unwrap_or(root);
if !server_path(&root) {
return Err(IdeError::invalid(format!("openidea-server opened an unexpected project folder: {root}")));
}
let _ = window.set_title(&format!("{} [{title_tag}]", project.display_name));
let connection = Arc::new(Connection {
peer,
target: target.clone(),
root: root.clone(),
host: host.clone(),
os: info.os.clone(),
server_version: info.version.clone(),
commands: commands.clone(),
channels,
next_channel: std::sync::atomic::AtomicU64::new(1),
session,
forwards: Mutex::new(Vec::new()),
web_forwards: Mutex::new(Vec::new()),
exec,
});
let _ = connection_slot.set(Arc::downgrade(&connection));
if let RemoteTarget::DevContainer { folder, config } = &target {
forward_configured_ports(&connection, folder, config).await;
}
state.remote_dev.disconnect(&label);
state.host.close_project(&label);
state.host.mcp_reports.set_remote(&label, std::path::PathBuf::from(&connection.root));
state.remote_dev.0.lock().insert(label.clone(), connection.clone());
let weak = Arc::downgrade(&connection);
let peer = connection.peer.clone();
let auth_plugins = state.plugins.clone();
let auth_window = label.clone();
let app = window.app_handle().clone();
tauri::async_runtime::spawn(async move {
peer.closed().await;
auth_plugins.forget_remote_loopbacks(&auth_window);
let Some(connection) = weak.upgrade() else { return };
connection.forwards.lock().clear();
// Still the window's connection: not a disconnect or a replacement, so the window learns
// its project is unreachable instead of failing every command with "connection closed".
let current = app.state::<AppState>().remote_dev.get(&auth_window);
if current.is_some_and(|c| Arc::ptr_eq(&c, &connection)) {
tracing::warn!("{}: the connection to openidea-server was lost", connection.host);
TauriSink { app, window: Some(auth_window) }
.emit(ide_core::IdeEvent::RemoteConnectionLost { host: connection.host.clone() });
}
});
let plugins = state.plugins.clone();
tauri::async_runtime::spawn(async move {
sync_plugin_languages(&plugins, &connection, &label).await;
sync_plugin_packages(&plugins, &connection, &label).await;
});
Ok(RemoteProject { target, root, host, server_version: info.version, os: info.os, commands, project })
}
/// Sends the desktop's plugin languages, with the programs granted to them, to
/// the window's server: `Workspace` contributions take effect where the project
/// is. A server without the command answers an error, which is logged.
pub async fn sync_plugin_languages(plugins: &ide_host::plugins::PluginHost, c: &Connection, window: &str) {
use ide_host::plugins::remote::{SYNC_COMMAND, SyncReport};
let call = Invoke {
window: window.to_owned(),
cmd: SYNC_COMMAND.into(),
args: serde_json::json!({ "languages": plugins.remote_languages() }),
};
match c.peer.request::<_, SyncReport>("invoke", call, None).await {
Ok(report) => {
for program in &report.unresolved {
tracing::info!("{}: plugin program {program} is not installed", c.host);
}
for rejected in &report.rejected {
tracing::warn!("{}: plugin language rejected: {rejected}", c.host);
}
}
Err(e) => tracing::warn!("{}: syncing plugin languages: {e}", c.host),
}
}
/// Sends the desktop's live code plugins to the window's server, which runs
/// them next to the project: digests and grants first,
/// then the files of the packages the server lacks, one per request.
pub async fn sync_plugin_packages(plugins: &Arc<ide_host::plugins::PluginHost>, c: &Connection, window: &str) {
use ide_host::plugins::remote_host::{PackageSyncReport, SYNC_PACKAGES};
let host = plugins.clone();
let Ok(packages) = tauri::async_runtime::spawn_blocking(move || host.remote_packages()).await else { return };
let sync = |files: serde_json::Value| Invoke {
window: window.to_owned(),
cmd: SYNC_PACKAGES.into(),
args: serde_json::json!({ "packages": packages, "files": files }),
};
let report: PackageSyncReport = match c.peer.request("invoke", sync(Value::Null), None).await {
Ok(r) => r,
Err(e) => return tracing::warn!("{}: syncing plugins: {e}", c.host),
};
let mut failed = report.failed;
for id in report.missing {
let host = plugins.clone();
let pid = id.clone();
let files = match tauri::async_runtime::spawn_blocking(move || host.remote_package_files(&pid)).await {
Ok(Ok(files)) => files,
Ok(Err(e)) => {
failed.push(format!("{id}: {e}"));
continue;
}
Err(e) => {
failed.push(format!("{id}: {e}"));
continue;
}
};
match c
.peer
.request::<_, PackageSyncReport>("invoke", sync(serde_json::json!({ (id.clone()): files })), None)
.await
{
Ok(r) => failed.extend(r.failed),
Err(e) => failed.push(format!("{id}: {e}")),
}
}
for f in failed {
tracing::warn!("{}: plugin not available remotely: {f}", c.host);
}
}
#[derive(Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteSession {
pub target: RemoteTarget,
pub root: String,
pub host: String,
/// `linux`, `macos` or `windows`: the OS the project's commands run on.
pub os: String,
pub commands: Vec<String>,
}
/// The remote session of this window (a settings window: its parent's), if any.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub fn remote_current(window: Window, state: State<'_, AppState>) -> Option<RemoteSession> {
let c = state.remote_dev.get(AppState::owner_window(window.label()))?;
Some(RemoteSession {
target: c.target.clone(),
root: c.root.clone(),
host: c.host.clone(),
os: c.os.clone(),
commands: c.commands.clone(),
})
}
/// This machine's trust decision for the window's remote project (see [`Connection::authorize`]).
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub fn remote_trust_status(window: Window, state: State<'_, AppState>) -> IdeResult<ide_host::trust::TrustStatus> {
let c = connection(&window, &state)?;
let decision = c.trusted_here(&state.host.trust);
Ok(ide_host::trust::TrustStatus {
root: c.root.clone().into(),
trusted: decision == Some(true),
decided: decision.is_some(),
})
}
/// Records the user's trust decision for the window's remote project on this machine.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub fn remote_trust_set(window: Window, state: State<'_, AppState>, trusted: bool) -> IdeResult<()> {
let c = connection(&window, &state)?;
state.host.trust.decide_remote(&c.location(), trusted)
}
/// A port of the remote host reachable on this machine at `localhost:local_port`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ForwardedPort {
pub remote_port: u16,
pub local_port: u16,
/// The host the port belongs to, as a dev container reaches it (a Compose service from
/// `forwardPorts`); `None` for the remote host itself.
pub host: Option<String>,
}
fn forwarded(c: &Connection) -> Vec<ForwardedPort> {
c.forwards
.lock()
.iter()
.map(|((host, remote), t)| ForwardedPort { remote_port: *remote, local_port: t.port(), host: host.clone() })
.collect()
}
fn connection(window: &Window, state: &AppState) -> IdeResult<Arc<Connection>> {
state
.remote_dev
.get(AppState::owner_window(window.label()))
.ok_or_else(|| IdeError::unavailable("This window is not connected to a remote host"))
}
/// The remote ports this window forwards to this machine.
#[desktop_command(trust = trusted)]
#[tauri::command]
#[specta::specta]
pub fn remote_forwarded_ports(window: Window, state: State<'_, AppState>) -> Vec<ForwardedPort> {
connection(&window, &state).map(|c| forwarded(&c)).unwrap_or_default()
}
/// Forwards `localhost:<remote_port>` of the remote host to the same port here when it is free,
/// else to a free one. Nothing needs to listen there yet; connections are opened per use.
#[desktop_command(trust = trusted)]
#[tauri::command]
#[specta::specta]
pub async fn remote_forward_port(
window: Window,
state: State<'_, AppState>,
remote_port: u16,
) -> IdeResult<ForwardedPort> {
if remote_port == 0 {
return Err(IdeError::invalid("Port must be between 1 and 65535"));
}
let c = connection(&window, &state)?;
if let Some(p) = forwarded(&c).into_iter().find(|p| p.host.is_none() && p.remote_port == remote_port) {
return Ok(p);
}
let tunnel = open_forward(&c, None, remote_port).await?;
let port = ForwardedPort { remote_port, local_port: tunnel.port(), host: None };
let mut forwards = c.forwards.lock();
if c.peer.is_closed() {
return Err(IdeError::cancelled());
}
if let Some(existing) = forwards.iter().find(|(key, _)| *key == (None, remote_port)) {
return Ok(ForwardedPort { remote_port, local_port: existing.1.port(), host: None });
}
forwards.push(((None, remote_port), tunnel));
Ok(port)
}
/// Forwards `remote_port` of `host` (`None`: the remote host itself) to the same local port
/// when it is free, else to a free one. Another host is reached from a dev container only.
async fn open_forward(c: &Connection, host: Option<&str>, remote_port: u16) -> IdeResult<Forward> {
if let (Some(session), None) = (c.session.clone(), host) {
let tunnel = ide_ssh::Tunnel::listen_on(session, Some(remote_port), "localhost", remote_port).await?;
return Ok(Forward::Ssh(tunnel));
}
if let Some(exec) = c.exec.clone() {
let host = host.unwrap_or("localhost");
return Ok(Forward::Container(
ide_remote::container_tunnel::Tunnel::listen(exec, remote_port, host, remote_port).await?,
));
}
Err(IdeError::unavailable("Forwarding ports is not supported in a WSL project yet"))
}
/// `web_url` answers with the remote host's built-in web server, on its loopback: the URL's
/// port is forwarded here. A WSL distribution shares this machine's loopback already.
async fn forward_web_url(c: &Connection, url: &str) -> IdeResult<String> {
let Some((port, path)) = url.strip_prefix("http://127.0.0.1:").and_then(|rest| rest.split_once('/')) else {
return Ok(url.to_owned());
};
let Ok(remote) = port.parse::<u16>() else { return Ok(url.to_owned()) };
let existing = c.web_forwards.lock().iter().find(|(p, _)| *p == remote).map(|(_, f)| f.port());
let local = match existing {
Some(local) => local,
None => {
let forward = if let Some(session) = c.session.clone() {
Forward::Ssh(ide_ssh::Tunnel::listen_on(session, Some(remote), "127.0.0.1", remote).await?)
} else if let Some(exec) = c.exec.clone() {
Forward::Container(
ide_remote::container_tunnel::Tunnel::listen(exec, remote, "127.0.0.1", remote).await?,
)
} else {
return Ok(url.to_owned());
};
let local = forward.port();
c.web_forwards.lock().push((remote, forward));
local
}
};
Ok(format!("http://127.0.0.1:{local}/{path}"))
}
/// Forwards the `forwardPorts` of the dev container's configuration (the local folder's).
async fn forward_configured_ports(c: &Connection, folder: &str, config: &str) {
let local = std::path::PathBuf::from(folder);
let config = config.to_owned();
let ports = tokio::task::spawn_blocking(move || {
let path = match config.trim() {
"" => ide_workspace::devcontainer::find(&local),
config => Some(local.join(config)),
};
path.map(|path| {
ide_workspace::devcontainer::load_file(&path).map(|c| {
let own = c.forward_ports.into_iter().map(|port| (None, port));
own.chain(c.forward_host_ports.into_iter().map(|(host, port)| (Some(host), port))).collect::<Vec<_>>()
})
})
.transpose()
})
.await;
let ports = match ports {
Ok(Ok(Some(ports))) => ports,
Ok(Ok(None)) => return,
result => return tracing::warn!("{}: forwardPorts: {result:?}", c.host),
};
for key in ports {
if c.forwards.lock().iter().any(|(forwarded, _)| *forwarded == key) {
continue;
}
let (host, remote_port) = &key;
match open_forward(c, host.as_deref(), *remote_port).await {
Ok(tunnel) => c.forwards.lock().push((key, tunnel)),
Err(e) => {
tracing::warn!("{}: cannot forward {}:{remote_port}: {e}", c.host, host.as_deref().unwrap_or("port"))
}
}
}
}
/// Stops forwarding `remote_port` of `host` (`None`: the remote host itself).
#[desktop_command(trust = trusted)]
#[tauri::command]
#[specta::specta]
pub async fn remote_stop_forwarding(
window: Window,
state: State<'_, AppState>,
remote_port: u16,
host: Option<String>,
) -> IdeResult<()> {
let c = connection(&window, &state)?;
let key = (host, remote_port);
let tunnel = {
let mut forwards = c.forwards.lock();
forwards.iter().position(|(forwarded, _)| *forwarded == key).map(|index| forwards.remove(index).1)
};
if let Some(Forward::Container(tunnel)) = tunnel {
tunnel.close().await;
}
Ok(())
}
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub fn remote_disconnect(window: Window, state: State<'_, AppState>) {
state.host.mcp_reports.remove_remote(AppState::owner_window(window.label()));
state.remote_dev.disconnect(AppState::owner_window(window.label()));
}
/// Runs a command on the window's remote server; `args` and the result are JSON
/// text. Streaming arguments are `{ "$channel": id }`; their values arrive on
/// `on_channel` tagged with the id.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub async fn remote_invoke(
window: Window,
state: State<'_, AppState>,
cmd: String,
args: String,
on_channel: Channel<ChannelFrame>,
) -> IdeResult<String> {
let mut args: Value = serde_json::from_str(&args).map_err(|e| IdeError::invalid(format!("arguments: {e}")))?;
let label = AppState::owner_window(window.label()).to_owned();
let c = state
.remote_dev
.get(&label)
.ok_or_else(|| IdeError::unavailable("this window is not connected to a remote host"))?;
if let Value::Object(map) = &mut args {
for v in map.values_mut() {
if let Some(id) = v.get("$channel").and_then(Value::as_u64) {
let own = c.next_channel.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
c.channels.lock().insert(own, (on_channel.clone(), id));
*v = serde_json::json!({ "$channel": own });
}
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DocumentEdit {
doc: ide_core::DocId,
base_version: u32,
changes: ide_core::ChangeSet,
}
let mirrored = if cmd == "doc_edit" {
let peers = crate::events::document_edit_peers(window.app_handle(), window.label());
if peers.is_empty() {
None
} else {
serde_json::from_value::<DocumentEdit>(args.clone()).ok().map(|edit| (peers, edit))
}
} else {
None
};
let web_url = cmd == "web_url";
let call = Invoke { window: label, cmd, args };
let mut result = invoke_reply(&c.peer, call, std::time::Duration::from_secs(30))
.await
.map_err(|e| lost_connection_error(older_server_error(e, &c.server_version, &c.host), &c))?;
if web_url && let Some(url) = result.as_str() {
result = Value::String(forward_web_url(&c, url).await?);
}
if let (Some((peers, edit)), Some(version)) =
(mirrored, result.as_u64().and_then(|version| u32::try_from(version).ok()))
{
crate::events::emit_document_edit(
window.app_handle(),
peers,
edit.doc,
edit.base_version,
version,
edit.changes.changes,
);
}
Ok(result.to_string())
}
/// A client OS file belongs to this machine even when its destination is remote.
#[desktop_command(trust = trusted)]
#[tauri::command]
#[specta::specta]
pub async fn remote_import_local(
window: Window,
state: State<'_, AppState>,
from: std::path::PathBuf,
to: String,
request: ide_core::RequestId,
) -> IdeResult<Vec<String>> {
let label = AppState::owner_window(window.label());
let c = state.remote_dev.get(label).ok_or_else(|| IdeError::unavailable("Remote project is disconnected"))?;
let Some(session) = c.session.clone() else {
return Err(IdeError::unavailable("Importing local files is not supported in a WSL project yet"));
};
let cancel = state.host.begin_request(request);
let result = async {
let fs = ide_ssh::RemoteFs::new(session.sftp().await?);
let result = ide_remote::import::import_local(&fs, &from, &to, &cancel).await;
fs.close().await;
result
}
.await;
state.host.end_request(request);
result
}
/// A command the server does not know, from a server of another version than this app: says so,
/// instead of the bare JSON-RPC error.
fn older_server_error(e: IdeError, server_version: &str, host: &str) -> IdeError {
let app = env!("CARGO_PKG_VERSION");
if server_version == app || !e.message.contains("is not available remotely") {
return e;
}
IdeError::unavailable(format!(
"openidea-server {server_version} on {host} does not match OpenIDEA {app}: {}. Reopen the remote project to \
install the matching server",
e.message
))
}
/// A request that failed because the transport is gone says so, instead of the bare JSON-RPC
/// "connection closed".
fn lost_connection_error(e: IdeError, c: &Connection) -> IdeError {
if c.peer.is_closed() { IdeError::unavailable(format!("Lost the connection to {}", c.host)) } else { e }
}
// Conversation reads are snapshots; a silent host must not leave them pending forever.
async fn invoke_reply(peer: &Peer, call: Invoke, entries_timeout: std::time::Duration) -> IdeResult<Value> {
let reply = peer.request("invoke", &call, None);
if call.cmd == "agent_entries" {
tokio::time::timeout(entries_timeout, reply)
.await
.map_err(|_| IdeError::unavailable("Loading the conversation timed out. Try again."))?
.map_err(ide_host::rpc::error_from_reply)
} else {
reply.await.map_err(ide_host::rpc::error_from_reply)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_command_missing_on_a_server_of_another_version_says_which_versions() {
let missing = || IdeError::unavailable("-32601: command web_url is not available remotely");
let e = older_server_error(missing(), "0.1.32", "box");
assert_eq!(e.kind, ide_core::error::ErrorKind::Unavailable);
assert!(
e.message.starts_with(&format!(
"openidea-server 0.1.32 on box does not match OpenIDEA {}",
env!("CARGO_PKG_VERSION")
)),
"{}",
e.message
);
assert!(e.message.contains("command web_url is not available remotely"), "{}", e.message);
// The same version, or another error: unchanged.
assert_eq!(older_server_error(missing(), env!("CARGO_PKG_VERSION"), "box").message, missing().message);
let other = older_server_error(IdeError::unavailable("No such file"), "0.1.32", "box");
assert_eq!(other.message, "No such file");
}
#[test]
fn a_server_put_in_the_unversioned_place_is_found_by_platform() {
let data = tempfile::tempdir().unwrap();
assert_eq!(unversioned_server_binary(data.path(), "linux", "x86_64"), None);
let bin = data.path().join("server/linux-x86_64/openidea-server");
std::fs::create_dir_all(bin.parent().unwrap()).unwrap();
std::fs::write(&bin, b"server").unwrap();
assert_eq!(unversioned_server_binary(data.path(), "linux", "x86_64"), Some(bin));
assert_eq!(unversioned_server_binary(data.path(), "linux", "aarch64"), None);
}
#[tokio::test]
async fn conversation_read_times_out_when_the_host_never_replies() {
let (client, _silent_host) = tokio::io::duplex(4096);
let (reader, writer) = tokio::io::split(client);
let peer = Peer::connect(reader, writer, Arc::new(ide_jsonrpc::NoopHandler));
let call = Invoke {
window: "main".into(),
cmd: "agent_entries".into(),
args: serde_json::json!({"task": "saved-codex-task", "subagent": null}),
};
let error = invoke_reply(&peer, call, std::time::Duration::from_millis(10)).await.unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::Unavailable);
assert_eq!(error.message, "Loading the conversation timed out. Try again.");
peer.kill();
}
/// A server that reports its project as trusted.
struct TrustingServer;
impl Handler for TrustingServer {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, _: &str, _: Value) -> Result<Value, (i64, String)> {
Ok(serde_json::to_value(ide_host::ops::project::ProjectInfo {
trusted: true,
root: "/srv/app".into(),
name: "app".into(),
display_name: "app".into(),
is_git: false,
settings: Default::default(),
workspace: None,
unity: None,
})
.unwrap())
}
}
fn connected(target: RemoteTarget, root: &str) -> Connection {
let (client, server) = tokio::io::duplex(1 << 16);
let (reader, writer) = tokio::io::split(client);
let peer = Peer::connect(reader, writer, Arc::new(ide_jsonrpc::NoopHandler));
let (reader, writer) = tokio::io::split(server);
std::mem::forget(Peer::connect(reader, writer, Arc::new(TrustingServer)));
Connection {
peer,
target,
root: root.into(),
host: "host".into(),
os: "linux".into(),
server_version: env!("CARGO_PKG_VERSION").into(),
commands: Vec::new(),
channels: Arc::default(),
next_channel: std::sync::atomic::AtomicU64::new(1),
session: None,
exec: None,
forwards: Mutex::new(Vec::new()),
web_forwards: Mutex::new(Vec::new()),
}
}
#[tokio::test]
async fn the_server_does_not_decide_trust_for_commands_run_here() {
let tmp = tempfile::tempdir().unwrap();
let trust = ide_host::trust::TrustStore::load(&tmp.path().join("config"), &tmp.path().join("data"));
let c = connected(RemoteTarget::Ssh { config: "box".into() }, "/srv/app");
for class in [TrustClass::OutsideRestricted, TrustClass::Trusted] {
let error = c.authorize(&trust, class).unwrap_err();
assert_eq!(error.kind, ide_core::error::ErrorKind::Unavailable);
}
assert!(c.authorize(&trust, TrustClass::Always).is_ok());
trust.decide_remote(&c.location(), true).unwrap();
assert!(c.authorize(&trust, TrustClass::Trusted).is_ok());
let other = connected(RemoteTarget::Ssh { config: "box".into() }, "/srv/other");
assert!(other.authorize(&trust, TrustClass::Trusted).is_err());
trust.decide_remote(&c.location(), false).unwrap();
assert!(c.authorize(&trust, TrustClass::Trusted).is_err());
}
#[tokio::test]
async fn a_dev_container_follows_its_local_folder() {
let tmp = tempfile::tempdir().unwrap();
let folder = tmp.path().join("app");
std::fs::create_dir(&folder).unwrap();
let trust = ide_host::trust::TrustStore::load(&tmp.path().join("config"), &tmp.path().join("data"));
let target =
RemoteTarget::DevContainer { folder: folder.to_string_lossy().into_owned(), config: String::new() };
let c = connected(target, "/workspaces/app");
assert_eq!(c.trusted_here(&trust), None);
trust.decide(&folder, true, false).unwrap();
assert_eq!(c.trusted_here(&trust), Some(true));
assert!(c.authorize(&trust, TrustClass::Trusted).is_ok());
}
#[test]
fn a_server_project_folder_is_never_a_share_or_device_here() {
assert!(server_path("/home/me/app"));
for path in [r"\\host\share", "//host/share", "//./pipe/x", "//?/UNC/host/share", "home/me", r"/home/a\b", ""] {
assert!(!server_path(path), "{path}");
}
}
#[test]
fn maps_uname_to_rust_platform_names() {
assert_eq!(platform("Linux x86_64"), ("linux".into(), "x86_64".into()));
assert_eq!(platform("Darwin arm64"), ("macos".into(), "aarch64".into()));
assert_eq!(platform("Linux aarch64"), ("linux".into(), "aarch64".into()));
}
#[test]
fn a_dev_container_target_is_its_local_folder_and_configuration() {
let target = RemoteTarget::DevContainer { folder: "/Users/me/app".into(), config: String::new() };
let json = serde_json::to_value(&target).unwrap();
assert_eq!(json, serde_json::json!({ "kind": "devContainer", "folder": "/Users/me/app", "config": "" }));
assert_eq!(serde_json::from_value::<RemoteTarget>(json).unwrap(), target);
}
}
ide_command::desktop_domain!(
remote_bootstrap_list,
remote_connect,
remote_current,
remote_disconnect,
remote_forward_port,
remote_forwarded_ports,
remote_import_local,
remote_invoke,
remote_stop_forwarding,
remote_trust_set,
remote_trust_status,
);