mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 06:59:22 +01:00
Keep remote agent secrets out of launcher arguments (#65174)
Closes https://github.com/zed-industries/zed/issues/64511 Release Notes: - Fixed remote agent secrets exposed in the launcher arguments
This commit is contained in:
Generated
+2
@@ -14999,6 +14999,7 @@ dependencies = [
|
||||
"action_log",
|
||||
"agent",
|
||||
"agent-client-protocol",
|
||||
"agent_servers",
|
||||
"anyhow",
|
||||
"askpass",
|
||||
"async-channel 2.5.0",
|
||||
@@ -15027,6 +15028,7 @@ dependencies = [
|
||||
"language_extension",
|
||||
"language_model",
|
||||
"languages",
|
||||
"libc",
|
||||
"log",
|
||||
"lsp",
|
||||
"net",
|
||||
|
||||
@@ -6,10 +6,10 @@ use futures::{
|
||||
};
|
||||
use gpui::{AsyncApp, Entity};
|
||||
use project::{Project, agent_server_store::AgentServerCommand};
|
||||
use remote::remote_client::Interactive;
|
||||
use remote::command::RemoteCommand;
|
||||
use std::{io, pin::Pin, process::Stdio};
|
||||
use task::{Shell, ShellBuilder};
|
||||
use util::{ResultExt as _, process::Child};
|
||||
use util::process::Child;
|
||||
|
||||
pub(super) struct StdioProcess {
|
||||
pub child: Child,
|
||||
@@ -32,32 +32,32 @@ pub(super) fn spawn_stdio(
|
||||
.next()
|
||||
.cloned()
|
||||
});
|
||||
let (path, arguments, environment) = project
|
||||
.read_with(cx, |project, cx| {
|
||||
project.remote_client().and_then(|client| {
|
||||
let template = client
|
||||
.read(cx)
|
||||
.build_command(
|
||||
Some(command.path.display().to_string()),
|
||||
&command.args,
|
||||
&command.env.clone().into_iter().flatten().collect(),
|
||||
root_dir.as_ref().map(|path| path.display().to_string()),
|
||||
None,
|
||||
Interactive::No,
|
||||
)
|
||||
.log_err()?;
|
||||
Some((template.program, template.args, template.env))
|
||||
let remote_command = project.read_with(cx, |project, cx| {
|
||||
project
|
||||
.remote_client()
|
||||
.map(|client| {
|
||||
client.read(cx).build_stdio_command(RemoteCommand {
|
||||
program: command.path.display().to_string(),
|
||||
args: command.args.clone(),
|
||||
env: command.env.clone().unwrap_or_default(),
|
||||
working_dir: root_dir.as_ref().map(|path| path.display().to_string()),
|
||||
})
|
||||
})
|
||||
})
|
||||
.unwrap_or_else(|| {
|
||||
(
|
||||
command.path.display().to_string(),
|
||||
command.args,
|
||||
command.env.unwrap_or_default(),
|
||||
)
|
||||
});
|
||||
.transpose()
|
||||
})?;
|
||||
let (path, arguments, environment, command_input) = match remote_command {
|
||||
Some((template, input)) => (template.program, template.args, template.env, Some(input)),
|
||||
None => (
|
||||
command.path.display().to_string(),
|
||||
command.args,
|
||||
command.env.unwrap_or_default(),
|
||||
None,
|
||||
),
|
||||
};
|
||||
|
||||
let builder = ShellBuilder::new(&Shell::System, cfg!(windows)).non_interactive();
|
||||
let builder = ShellBuilder::new(&Shell::System, cfg!(windows))
|
||||
.non_interactive()
|
||||
.literal_args();
|
||||
let mut child = builder.build_std_command(Some(path.clone()), &arguments);
|
||||
child.envs(environment);
|
||||
if let Some(cwd) = project.read_with(cx, |project, _cx| {
|
||||
@@ -96,13 +96,16 @@ pub(super) fn spawn_stdio(
|
||||
.boxed();
|
||||
|
||||
let outgoing = Box::pin(futures::sink::unfold(
|
||||
(Box::pin(stdin), debug_log.clone()),
|
||||
async move |(mut writer, debug_log), line: String| {
|
||||
(Box::pin(stdin), debug_log.clone(), command_input),
|
||||
async move |(mut writer, debug_log, mut command_input), line: String| {
|
||||
if let Some(input) = command_input.take() {
|
||||
writer.write_all(&input).await?;
|
||||
}
|
||||
debug_log.record_line(AcpDebugMessageDirection::Outgoing, &line);
|
||||
let mut bytes = line.into_bytes();
|
||||
bytes.push(b'\n');
|
||||
writer.write_all(&bytes).await?;
|
||||
Ok::<_, io::Error>((writer, debug_log))
|
||||
Ok::<_, io::Error>((writer, debug_log, command_input))
|
||||
},
|
||||
));
|
||||
|
||||
|
||||
@@ -160,6 +160,17 @@ pub struct ModelContextServerBinary {
|
||||
pub args: Vec<String>,
|
||||
pub env: Option<HashMap<String, String>>,
|
||||
pub timeout: Option<u64>,
|
||||
#[serde(skip)]
|
||||
pub stdin_prefix: Option<StdinPrefix>,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
pub struct StdinPrefix(pub Vec<u8>);
|
||||
|
||||
impl std::fmt::Debug for StdinPrefix {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "StdinPrefix([REDACTED {} bytes])", self.0.len())
|
||||
}
|
||||
}
|
||||
|
||||
impl Client {
|
||||
|
||||
@@ -15,7 +15,7 @@ use std::time::Duration;
|
||||
use std::{fmt::Display, path::PathBuf};
|
||||
|
||||
use anyhow::Result;
|
||||
use client::Client;
|
||||
use client::{Client, StdinPrefix};
|
||||
use gpui::AsyncApp;
|
||||
use parking_lot::RwLock;
|
||||
pub use settings::ContextServerCommand;
|
||||
@@ -34,7 +34,7 @@ impl Display for ContextServerId {
|
||||
}
|
||||
|
||||
enum ContextServerTransport {
|
||||
Stdio(ContextServerCommand, Option<PathBuf>),
|
||||
Stdio(ContextServerCommand, Option<PathBuf>, Option<StdinPrefix>),
|
||||
Custom(Arc<dyn crate::transport::Transport>),
|
||||
}
|
||||
|
||||
@@ -50,6 +50,7 @@ impl ContextServer {
|
||||
id: ContextServerId,
|
||||
command: ContextServerCommand,
|
||||
working_directory: Option<Arc<Path>>,
|
||||
stdin_prefix: Option<StdinPrefix>,
|
||||
) -> Self {
|
||||
Self {
|
||||
id,
|
||||
@@ -57,6 +58,7 @@ impl ContextServer {
|
||||
configuration: ContextServerTransport::Stdio(
|
||||
command,
|
||||
working_directory.map(|directory| directory.to_path_buf()),
|
||||
stdin_prefix,
|
||||
),
|
||||
request_timeout: None,
|
||||
}
|
||||
@@ -123,17 +125,20 @@ impl ContextServer {
|
||||
|
||||
fn new_client(&self, cx: &AsyncApp) -> Result<Client> {
|
||||
Ok(match &self.configuration {
|
||||
ContextServerTransport::Stdio(command, working_directory) => Client::stdio(
|
||||
client::ContextServerId(self.id.0.clone()),
|
||||
client::ModelContextServerBinary {
|
||||
executable: Path::new(&command.path).to_path_buf(),
|
||||
args: command.args.clone(),
|
||||
env: command.env.clone(),
|
||||
timeout: command.timeout,
|
||||
},
|
||||
working_directory,
|
||||
cx.clone(),
|
||||
)?,
|
||||
ContextServerTransport::Stdio(command, working_directory, stdin_prefix) => {
|
||||
Client::stdio(
|
||||
client::ContextServerId(self.id.0.clone()),
|
||||
client::ModelContextServerBinary {
|
||||
executable: Path::new(&command.path).to_path_buf(),
|
||||
args: command.args.clone(),
|
||||
env: command.env.clone(),
|
||||
timeout: command.timeout,
|
||||
stdin_prefix: stdin_prefix.clone(),
|
||||
},
|
||||
working_directory,
|
||||
cx.clone(),
|
||||
)?
|
||||
}
|
||||
ContextServerTransport::Custom(transport) => Client::new(
|
||||
client::ContextServerId(self.id.0.clone()),
|
||||
self.id().0,
|
||||
|
||||
@@ -14,7 +14,7 @@ use util::process::Child;
|
||||
use util::shell::Shell;
|
||||
use util::shell_builder::ShellBuilder;
|
||||
|
||||
use crate::client::ModelContextServerBinary;
|
||||
use crate::client::{ModelContextServerBinary, StdinPrefix};
|
||||
use crate::transport::Transport;
|
||||
|
||||
pub struct StdioTransport {
|
||||
@@ -30,7 +30,9 @@ impl StdioTransport {
|
||||
working_directory: &Option<PathBuf>,
|
||||
cx: &AsyncApp,
|
||||
) -> Result<Self> {
|
||||
let builder = ShellBuilder::new(&Shell::System, cfg!(windows)).non_interactive();
|
||||
let builder = ShellBuilder::new(&Shell::System, cfg!(windows))
|
||||
.non_interactive()
|
||||
.literal_args();
|
||||
let mut command =
|
||||
builder.build_std_command(Some(binary.executable.display().to_string()), &binary.args);
|
||||
|
||||
@@ -55,8 +57,13 @@ impl StdioTransport {
|
||||
let (stdout_sender, stdout_receiver) = async_channel::unbounded::<String>();
|
||||
let (stderr_sender, stderr_receiver) = async_channel::unbounded::<String>();
|
||||
|
||||
cx.spawn(async move |_| Self::handle_output(stdin, stdout_receiver).log_err().await)
|
||||
.detach();
|
||||
let stdin_prefix = binary.stdin_prefix;
|
||||
cx.spawn(async move |_| {
|
||||
Self::handle_output(stdin, stdin_prefix, stdout_receiver)
|
||||
.log_err()
|
||||
.await
|
||||
})
|
||||
.detach();
|
||||
|
||||
cx.spawn(async move |_| Self::handle_input(stdout, stdin_sender).await)
|
||||
.detach();
|
||||
@@ -91,12 +98,17 @@ impl StdioTransport {
|
||||
|
||||
async fn handle_output<Stdin>(
|
||||
stdin: Stdin,
|
||||
stdin_prefix: Option<StdinPrefix>,
|
||||
outbound_rx: async_channel::Receiver<String>,
|
||||
) -> Result<()>
|
||||
where
|
||||
Stdin: AsyncWrite + Unpin + Send + 'static,
|
||||
{
|
||||
let mut stdin = BufWriter::new(stdin);
|
||||
if let Some(StdinPrefix(prefix)) = stdin_prefix {
|
||||
stdin.write_all(&prefix).await?;
|
||||
stdin.flush().await?;
|
||||
}
|
||||
let mut pinned_rx = Box::pin(outbound_rx);
|
||||
while let Some(message) = pinned_rx.next().await {
|
||||
log::trace!("outgoing message: {}", message);
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
pub mod extension;
|
||||
pub mod registry;
|
||||
|
||||
use std::path::Path;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::{Context as _, Result};
|
||||
use collections::{HashMap, HashSet};
|
||||
use context_server::client::StdinPrefix;
|
||||
use context_server::oauth::{self, McpOAuthTokenProvider, OAuthDiscovery, OAuthSession};
|
||||
use context_server::transport::HttpTransport;
|
||||
use context_server::{ContextServer, ContextServerCommand, ContextServerId};
|
||||
@@ -20,7 +21,7 @@ use http_client::HttpClient;
|
||||
use itertools::Itertools;
|
||||
use rand::Rng as _;
|
||||
use registry::ContextServerDescriptorRegistry;
|
||||
use remote::{Interactive, RemoteClient};
|
||||
use remote::{RemoteClient, command::RemoteCommand};
|
||||
use rpc::{AnyProtoClient, TypedEnvelope, proto};
|
||||
use settings::{Settings as _, SettingsLocation, SettingsStore, WorktreeId};
|
||||
use util::{ResultExt as _, rel_path::RelPath};
|
||||
@@ -161,6 +162,7 @@ pub enum ContextServerConfiguration {
|
||||
Custom {
|
||||
command: ContextServerCommand,
|
||||
remote: bool,
|
||||
launcher: Option<RemoteStdioLauncher>,
|
||||
},
|
||||
Extension {
|
||||
command: ContextServerCommand,
|
||||
@@ -175,6 +177,12 @@ pub enum ContextServerConfiguration {
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct RemoteStdioLauncher {
|
||||
pub command: ContextServerCommand,
|
||||
pub stdin_prefix: StdinPrefix,
|
||||
}
|
||||
|
||||
impl ContextServerConfiguration {
|
||||
pub fn command(&self) -> Option<&ContextServerCommand> {
|
||||
match self {
|
||||
@@ -215,7 +223,11 @@ impl ContextServerConfiguration {
|
||||
enabled: _,
|
||||
command,
|
||||
remote,
|
||||
} => Some(ContextServerConfiguration::Custom { command, remote }),
|
||||
} => Some(ContextServerConfiguration::Custom {
|
||||
command,
|
||||
remote,
|
||||
launcher: None,
|
||||
}),
|
||||
ContextServerSettings::Extension {
|
||||
enabled: _,
|
||||
settings,
|
||||
@@ -446,6 +458,7 @@ impl ContextServerStore {
|
||||
timeout: None,
|
||||
},
|
||||
remote: false,
|
||||
launcher: None,
|
||||
});
|
||||
self.run_server(server, configuration, cx);
|
||||
}
|
||||
@@ -956,25 +969,35 @@ impl ContextServerStore {
|
||||
})
|
||||
.await?;
|
||||
|
||||
let remote_command = upstream_client.update(cx, |client, _| {
|
||||
client.build_command(
|
||||
Some(response.path),
|
||||
&response.args,
|
||||
&response.env.into_iter().collect(),
|
||||
root_dir,
|
||||
None,
|
||||
Interactive::Yes,
|
||||
)
|
||||
})?;
|
||||
|
||||
let command = ContextServerCommand {
|
||||
path: remote_command.program.into(),
|
||||
args: remote_command.args,
|
||||
env: Some(remote_command.env.into_iter().collect()),
|
||||
path: PathBuf::from(&response.path),
|
||||
args: response.args.clone(),
|
||||
env: Some(response.env.clone().into_iter().collect()),
|
||||
timeout: None,
|
||||
};
|
||||
|
||||
Arc::new(ContextServerConfiguration::Custom { command, remote })
|
||||
let (launcher_command, stdin_prefix) = upstream_client.update(cx, |client, _| {
|
||||
client.build_stdio_command(RemoteCommand {
|
||||
program: response.path,
|
||||
args: response.args,
|
||||
env: response.env.into_iter().collect(),
|
||||
working_dir: root_dir,
|
||||
})
|
||||
})?;
|
||||
|
||||
Arc::new(ContextServerConfiguration::Custom {
|
||||
command,
|
||||
remote,
|
||||
launcher: Some(RemoteStdioLauncher {
|
||||
command: ContextServerCommand {
|
||||
path: launcher_command.program.into(),
|
||||
args: launcher_command.args,
|
||||
env: Some(launcher_command.env.into_iter().collect()),
|
||||
timeout: None,
|
||||
},
|
||||
stdin_prefix: StdinPrefix(stdin_prefix),
|
||||
}),
|
||||
})
|
||||
} else {
|
||||
configuration
|
||||
};
|
||||
@@ -1044,10 +1067,22 @@ impl ContextServerStore {
|
||||
)))
|
||||
}
|
||||
_ => {
|
||||
let mut command = configuration
|
||||
.command()
|
||||
.context("Missing command configuration for stdio context server")?
|
||||
.clone();
|
||||
let (mut command, stdin_prefix) = match configuration.as_ref() {
|
||||
ContextServerConfiguration::Custom {
|
||||
launcher: Some(launcher),
|
||||
..
|
||||
} => (
|
||||
launcher.command.clone(),
|
||||
Some(launcher.stdin_prefix.clone()),
|
||||
),
|
||||
_ => (
|
||||
configuration
|
||||
.command()
|
||||
.context("Missing command configuration for stdio context server")?
|
||||
.clone(),
|
||||
None,
|
||||
),
|
||||
};
|
||||
command.timeout = Some(
|
||||
command
|
||||
.timeout
|
||||
@@ -1061,6 +1096,7 @@ impl ContextServerStore {
|
||||
id,
|
||||
command,
|
||||
working_directory,
|
||||
stdin_prefix,
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1542,6 +1542,7 @@ async fn test_context_server_stdio_timeout(cx: &mut TestAppContext) {
|
||||
timeout: Some(180000),
|
||||
},
|
||||
remote: false,
|
||||
launcher: None,
|
||||
}),
|
||||
&mut async_cx,
|
||||
)
|
||||
|
||||
@@ -0,0 +1,226 @@
|
||||
use anyhow::{Context as _, Result, ensure};
|
||||
use collections::HashMap;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::io::Read;
|
||||
use util::shell::ShellKind;
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct RemoteCommand {
|
||||
pub program: String,
|
||||
pub args: Vec<String>,
|
||||
pub env: HashMap<String, String>,
|
||||
pub working_dir: Option<String>,
|
||||
}
|
||||
|
||||
impl RemoteCommand {
|
||||
pub fn retain_valid_env(&mut self) {
|
||||
self.env.retain(|name, _| {
|
||||
let valid = !name.is_empty() && !name.contains(['=', '\0']);
|
||||
if !valid {
|
||||
log::warn!("Skipping environment variable with invalid name");
|
||||
}
|
||||
valid
|
||||
});
|
||||
}
|
||||
|
||||
pub fn encode(&self) -> Result<Vec<u8>> {
|
||||
let mut buffer = vec![0; size_of::<u32>()];
|
||||
serde_json::to_writer(&mut buffer, self)?;
|
||||
let len = buffer.len() - size_of::<u32>();
|
||||
ensure!(len <= MAX_COMMAND_SIZE, "Remote command exceeds 16 MiB");
|
||||
buffer[..size_of::<u32>()].copy_from_slice(&(len as u32).to_le_bytes());
|
||||
Ok(buffer)
|
||||
}
|
||||
|
||||
pub fn read(reader: &mut impl Read) -> Result<Self> {
|
||||
let mut len = [0; size_of::<u32>()];
|
||||
reader
|
||||
.read_exact(&mut len)
|
||||
.context("Failed to read remote command length")?;
|
||||
let len = u32::from_le_bytes(len) as usize;
|
||||
ensure!(len <= MAX_COMMAND_SIZE, "Remote command exceeds 16 MiB");
|
||||
let mut buffer = vec![0; len];
|
||||
reader
|
||||
.read_exact(&mut buffer)
|
||||
.context("Failed to read remote command")?;
|
||||
serde_json::from_slice(&buffer).map_err(|_| anyhow::anyhow!("Invalid remote command"))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn stdio_launcher_command(shell_kind: ShellKind, remote_binary_path: &str) -> Result<String> {
|
||||
let helper = shell_kind
|
||||
.try_quote(remote_binary_path)
|
||||
.context("shell quoting")?;
|
||||
Ok(format!("exec {helper} exec"))
|
||||
}
|
||||
|
||||
pub fn home_stdio_launcher_command(
|
||||
shell_kind: ShellKind,
|
||||
home_dir: Option<&str>,
|
||||
relative_binary_path: &str,
|
||||
) -> Result<String> {
|
||||
match home_dir {
|
||||
Some(home_dir) => stdio_launcher_command(
|
||||
shell_kind,
|
||||
&format!("{}/{relative_binary_path}", home_dir.trim_end_matches('/')),
|
||||
),
|
||||
None => Ok(format!(
|
||||
"exec {} exec",
|
||||
home_relative_path(shell_kind, Some(relative_binary_path))?
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn home_relative_path(shell_kind: ShellKind, relative_path: Option<&str>) -> Result<String> {
|
||||
let quoted = relative_path
|
||||
.map(|relative_path| shell_kind.try_quote(relative_path).context("shell quoting"))
|
||||
.transpose()?;
|
||||
Ok(match (shell_kind, quoted) {
|
||||
(ShellKind::Nushell, Some(quoted)) => format!("($env.HOME | path join {quoted})"),
|
||||
(ShellKind::Nushell, None) => String::from("$env.HOME"),
|
||||
(_, Some(quoted)) => format!("\"$HOME\"/{quoted}"),
|
||||
(_, None) => String::from("\"$HOME\""),
|
||||
})
|
||||
}
|
||||
|
||||
const MAX_COMMAND_SIZE: usize = 16 * 1024 * 1024;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Cursor;
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_frame() -> Result<()> {
|
||||
let json = br#"{"program":"agent","args":["","--acp"],"env":{"TOKEN":"'\"\n\r\t\\$()=secret\n"},"working_dir":"~/project with spaces"}"#;
|
||||
let mut input = (json.len() as u32).to_le_bytes().to_vec();
|
||||
input.extend_from_slice(json);
|
||||
let remaining = b"{\"jsonrpc\":\"2.0\",\"id\":1}\n\0\xff";
|
||||
input.extend_from_slice(remaining);
|
||||
let mut input = Cursor::new(input);
|
||||
let command = RemoteCommand::read(&mut input)?;
|
||||
assert_eq!(command.program, "agent");
|
||||
assert_eq!(command.args, ["", "--acp"]);
|
||||
assert_eq!(
|
||||
command.env,
|
||||
HashMap::from_iter([(
|
||||
String::from("TOKEN"),
|
||||
String::from("'\"\n\r\t\\$()=secret\n")
|
||||
)])
|
||||
);
|
||||
assert_eq!(
|
||||
command.working_dir.as_deref(),
|
||||
Some("~/project with spaces")
|
||||
);
|
||||
let mut output = Vec::new();
|
||||
input.read_to_end(&mut output)?;
|
||||
assert_eq!(output, remaining);
|
||||
let encoded = command.encode()?;
|
||||
assert_eq!(&encoded[4..], json);
|
||||
assert_eq!(&encoded[..4], &(json.len() as u32).to_le_bytes());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_size_limit() -> Result<()> {
|
||||
let mut command = RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: Vec::new(),
|
||||
env: HashMap::default(),
|
||||
working_dir: None,
|
||||
};
|
||||
let overhead = command.encode()?.len() - size_of::<u32>();
|
||||
command
|
||||
.program
|
||||
.push_str(&"a".repeat(MAX_COMMAND_SIZE - overhead));
|
||||
let encoded = command.encode()?;
|
||||
assert_eq!(encoded.len(), MAX_COMMAND_SIZE + size_of::<u32>());
|
||||
assert_eq!(
|
||||
RemoteCommand::read(&mut &encoded[..])?.program,
|
||||
command.program
|
||||
);
|
||||
command.program.push('a');
|
||||
assert_eq!(
|
||||
command.encode().unwrap_err().to_string(),
|
||||
"Remote command exceeds 16 MiB"
|
||||
);
|
||||
let oversized = (MAX_COMMAND_SIZE as u32 + 1).to_le_bytes();
|
||||
let error = RemoteCommand::read(&mut &oversized[..]).err().unwrap();
|
||||
assert_eq!(error.to_string(), "Remote command exceeds 16 MiB");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_retain_valid_env() {
|
||||
let mut command = RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: Vec::new(),
|
||||
env: HashMap::from_iter(
|
||||
[
|
||||
("", "empty"),
|
||||
("NAME=VALUE", "equals"),
|
||||
("NAME\0NUL", "nul"),
|
||||
("LINE\nBREAK", "kept"),
|
||||
("TAB\tKEY", "kept"),
|
||||
("KEY-WITH-DASH", "kept"),
|
||||
("GH_TOKEN", "kept"),
|
||||
]
|
||||
.map(|(name, value)| (name.to_owned(), value.to_owned())),
|
||||
),
|
||||
working_dir: None,
|
||||
};
|
||||
command.retain_valid_env();
|
||||
assert_eq!(
|
||||
command.env,
|
||||
HashMap::from_iter([
|
||||
(String::from("LINE\nBREAK"), String::from("kept")),
|
||||
(String::from("TAB\tKEY"), String::from("kept")),
|
||||
(String::from("KEY-WITH-DASH"), String::from("kept")),
|
||||
(String::from("GH_TOKEN"), String::from("kept")),
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_home_relative_path() -> Result<()> {
|
||||
assert_eq!(home_relative_path(ShellKind::Posix, None)?, "\"$HOME\"");
|
||||
assert_eq!(
|
||||
home_relative_path(ShellKind::Posix, Some("a b/c"))?,
|
||||
"\"$HOME\"/'a b/c'"
|
||||
);
|
||||
assert_eq!(
|
||||
home_relative_path(ShellKind::Tcsh, Some("bang!"))?,
|
||||
"\"$HOME\"/'bang'\\!"
|
||||
);
|
||||
assert_eq!(home_relative_path(ShellKind::Nushell, None)?, "$env.HOME");
|
||||
assert_eq!(
|
||||
home_relative_path(ShellKind::Nushell, Some("a b/O'Brien"))?,
|
||||
"($env.HOME | path join \"a b/O'Brien\")"
|
||||
);
|
||||
assert_eq!(
|
||||
home_stdio_launcher_command(ShellKind::Nushell, None, ".zed_server/server")?,
|
||||
"exec ($env.HOME | path join .zed_server/server) exec"
|
||||
);
|
||||
assert_eq!(
|
||||
home_stdio_launcher_command(ShellKind::Nushell, Some("/home/u/"), "x y")?,
|
||||
"exec '/home/u/x y' exec"
|
||||
);
|
||||
assert_eq!(
|
||||
home_stdio_launcher_command(ShellKind::Posix, None, "x y")?,
|
||||
"exec \"$HOME\"/'x y' exec"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_invalid_input() {
|
||||
for input in [&b""[..], &[1, 0, 0], &[1, 0, 0, 0]] {
|
||||
assert!(RemoteCommand::read(&mut &input[..]).is_err());
|
||||
}
|
||||
let json = br#"{"program":"agent","args":"secret"}"#;
|
||||
let mut input = (json.len() as u32).to_le_bytes().to_vec();
|
||||
input.extend_from_slice(json);
|
||||
let error = RemoteCommand::read(&mut &input[..]).err().unwrap();
|
||||
assert_eq!(error.to_string(), "Invalid remote command");
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
pub mod command;
|
||||
pub mod json_log;
|
||||
pub mod protocol;
|
||||
pub mod proxy;
|
||||
@@ -23,5 +24,6 @@ pub use transport::wsl::wsl_path_to_windows_path;
|
||||
|
||||
#[cfg(any(test, feature = "test-support"))]
|
||||
pub use transport::mock::{
|
||||
MockConnection, MockConnectionOptions, MockConnectionRegistry, MockDelegate,
|
||||
MOCK_STDIO_FRAME_HEX, MockConnection, MockConnectionOptions, MockConnectionRegistry,
|
||||
MockDelegate,
|
||||
};
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
use crate::transport::mock::ConnectGuard;
|
||||
use crate::{
|
||||
SshConnectionOptions,
|
||||
command::RemoteCommand,
|
||||
protocol::MessageId,
|
||||
proxy::ProxyLaunchError,
|
||||
transport::{
|
||||
@@ -981,6 +982,16 @@ impl RemoteClient {
|
||||
connection.build_command(program, args, env, working_dir, port_forward, interactive)
|
||||
}
|
||||
|
||||
pub fn build_stdio_command(
|
||||
&self,
|
||||
command: RemoteCommand,
|
||||
) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
let Some(connection) = self.remote_connection() else {
|
||||
return Err(anyhow!("no remote connection"));
|
||||
};
|
||||
connection.build_stdio_command(command)
|
||||
}
|
||||
|
||||
pub fn build_forward_ports_command(
|
||||
&self,
|
||||
forwards: Vec<(u16, String, u16)>,
|
||||
@@ -1652,6 +1663,11 @@ pub trait RemoteConnection: Send + Sync {
|
||||
port_forward: Option<(u16, String, u16)>,
|
||||
interactive: Interactive,
|
||||
) -> Result<CommandTemplate>;
|
||||
fn build_stdio_command(&self, _command: RemoteCommand) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
Err(anyhow!(
|
||||
"stdio commands are not supported by this remote connection"
|
||||
))
|
||||
}
|
||||
fn build_forward_ports_command(
|
||||
&self,
|
||||
forwards: Vec<(u16, String, u16)>,
|
||||
|
||||
@@ -125,6 +125,26 @@ fn parse_shell(output: &str, fallback_shell: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
const HOME_DIR_PROGRAM: &str = "/bin/sh";
|
||||
const HOME_DIR_ARGS: [&str; 2] = [
|
||||
"-c",
|
||||
"printf ZED_HOME_BEGIN; echo; pwd; printf ZED_HOME_END",
|
||||
];
|
||||
|
||||
fn parse_home_dir(output: &str) -> Option<String> {
|
||||
let (_, output) = output.split_once("ZED_HOME_BEGIN")?;
|
||||
let (home_dir, _) = output.rsplit_once("ZED_HOME_END")?;
|
||||
let line_ending = if home_dir.starts_with("\r\n") {
|
||||
"\r\n"
|
||||
} else {
|
||||
"\n"
|
||||
};
|
||||
let home_dir = home_dir
|
||||
.strip_prefix(line_ending)?
|
||||
.strip_suffix(line_ending)?;
|
||||
(home_dir.starts_with('/') && !home_dir.contains('\u{FFFD}')).then(|| home_dir.to_owned())
|
||||
}
|
||||
|
||||
fn handle_rpc_messages_over_child_process_stdio(
|
||||
mut remote_proxy_process: Child,
|
||||
incoming_tx: UnboundedSender<Envelope>,
|
||||
@@ -632,4 +652,106 @@ mod tests {
|
||||
assert_eq!(parse_shell("", "sh"), "sh");
|
||||
assert_eq!(parse_shell("\n", "sh"), "sh");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_home_dir() {
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/user\nZED_HOME_END"),
|
||||
Some(String::from("/home/user"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir(
|
||||
"some shell init output\r\nZED_HOME_BEGIN\r\n/home/user\r\nZED_HOME_END\r\n"
|
||||
),
|
||||
Some(String::from("/home/user"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/user\r\nZED_HOME_END"),
|
||||
Some(String::from("/home/user\r"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\r\n/home/user\r\r\nZED_HOME_END"),
|
||||
Some(String::from("/home/user\r"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/user \nZED_HOME_END"),
|
||||
Some(String::from("/home/user "))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/user\n\nZED_HOME_END"),
|
||||
Some(String::from("/home/user\n"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/ZED_HOME_BEGIN/user\nZED_HOME_END"),
|
||||
Some(String::from("/home/ZED_HOME_BEGIN/user"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/ZED_HOME_END/user\nZED_HOME_END"),
|
||||
Some(String::from("/home/ZED_HOME_END/user"))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/ZED_HOME_ENDZED_HOME_BEGIN\nZED_HOME_END\n"),
|
||||
Some(String::from("/ZED_HOME_ENDZED_HOME_BEGIN"))
|
||||
);
|
||||
assert_eq!(parse_home_dir(""), None);
|
||||
assert_eq!(parse_home_dir("/home/user\n"), None);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN/home/user\nZED_HOME_END"),
|
||||
None
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\n/home/userZED_HOME_END"),
|
||||
None
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir("ZED_HOME_BEGIN\nrelative/output\nZED_HOME_END"),
|
||||
None
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir(&format!(
|
||||
"ZED_HOME_BEGIN\n{}\nZED_HOME_END",
|
||||
String::from_utf8_lossy(b"/home/user-\xff")
|
||||
)),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_home_dir_probe_without_path_lookup() {
|
||||
let temp_dir = tempfile::tempdir().unwrap();
|
||||
for home_name in [
|
||||
"ZED_HOME_BEGIN/ZED_HOME_END dir",
|
||||
"carriage return\r",
|
||||
"trailing\n",
|
||||
] {
|
||||
let home = temp_dir.path().join(home_name);
|
||||
std::fs::create_dir_all(&home).unwrap();
|
||||
let mut args = vec![
|
||||
String::from("-c"),
|
||||
String::from("cd; exec \"$0\" \"$@\""),
|
||||
String::from(HOME_DIR_PROGRAM),
|
||||
];
|
||||
args.extend(HOME_DIR_ARGS.map(str::to_owned));
|
||||
let output = smol::block_on(
|
||||
smol::process::Command::new("/bin/sh")
|
||||
.args(args)
|
||||
.env_clear()
|
||||
.env("HOME", &home)
|
||||
.env("PATH", "/nonexistent")
|
||||
.output(),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{home_name:?}: {}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
assert_eq!(
|
||||
parse_home_dir(&String::from_utf8(output.stdout).unwrap()),
|
||||
Some(home.display().to_string()),
|
||||
"{home_name:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -29,6 +29,7 @@ use rpc::proto::Envelope;
|
||||
use crate::{
|
||||
RemoteArch, RemoteClientDelegate, RemoteConnection, RemoteConnectionOptions, RemoteOs,
|
||||
RemotePlatform,
|
||||
command::RemoteCommand,
|
||||
remote_client::{CommandTemplate, Interactive},
|
||||
transport::parse_platform,
|
||||
};
|
||||
@@ -844,6 +845,64 @@ impl RemoteConnection for DockerExecConnection {
|
||||
})
|
||||
}
|
||||
|
||||
fn build_stdio_command(
|
||||
&self,
|
||||
mut command: RemoteCommand,
|
||||
) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
let remote_binary_relpath = self
|
||||
.remote_binary_relpath
|
||||
.as_ref()
|
||||
.context("Remote binary path not set")?;
|
||||
let mut env = self
|
||||
.connection_options
|
||||
.remote_env
|
||||
.iter()
|
||||
.map(|(name, value)| (name.clone(), value.clone()))
|
||||
.collect::<HashMap<_, _>>();
|
||||
env.extend(command.env);
|
||||
command.env = env;
|
||||
command.retain_valid_env();
|
||||
if let Some(working_dir) = command.working_dir.take() {
|
||||
let working_dir = RemotePathBuf::new(working_dir, self.path_style()).to_string();
|
||||
command.working_dir = Some(match working_dir.strip_prefix("~/") {
|
||||
Some(remainder) => format!(
|
||||
"{}/{}",
|
||||
self.remote_dir_for_server.trim_end_matches('/'),
|
||||
remainder.trim_start_matches('/')
|
||||
),
|
||||
None => working_dir,
|
||||
});
|
||||
}
|
||||
let remote_binary_path = format!(
|
||||
"{}/{}",
|
||||
self.remote_dir_for_server.trim_end_matches('/'),
|
||||
remote_binary_relpath.display(PathStyle::Unix),
|
||||
);
|
||||
let mut args = vec![
|
||||
String::from("exec"),
|
||||
String::from("-u"),
|
||||
self.connection_options.remote_user.clone(),
|
||||
];
|
||||
if let Some(working_dir) = &command.working_dir {
|
||||
args.push(String::from("-w"));
|
||||
args.push(working_dir.clone());
|
||||
}
|
||||
args.extend([
|
||||
String::from("-i"),
|
||||
self.connection_options.container_id.clone(),
|
||||
remote_binary_path,
|
||||
String::from("exec"),
|
||||
]);
|
||||
Ok((
|
||||
CommandTemplate {
|
||||
program: self.docker_cli().to_string(),
|
||||
args,
|
||||
env: HashMap::default(),
|
||||
},
|
||||
command.encode()?,
|
||||
))
|
||||
}
|
||||
|
||||
fn build_forward_ports_command(
|
||||
&self,
|
||||
_forwards: Vec<(u16, String, u16)>,
|
||||
@@ -1052,6 +1111,73 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_stdio_command() -> Result<()> {
|
||||
let mut connection = connection(&[("API_KEY", "remote-secret"), ("NAME\0NUL", "dropped")]);
|
||||
let command = |env, working_dir: Option<&str>| RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: vec![String::from("--token=argument-secret")],
|
||||
env,
|
||||
working_dir: working_dir.map(str::to_owned),
|
||||
};
|
||||
assert_eq!(
|
||||
connection
|
||||
.build_stdio_command(command(HashMap::default(), None))
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"Remote binary path not set"
|
||||
);
|
||||
|
||||
connection.remote_binary_relpath = Some(Arc::from(RelPath::from_unix_str(
|
||||
".local/share/zed/remote server",
|
||||
)?));
|
||||
for (env_override, working_dir, expected_working_dir, use_podman, expected_program) in [
|
||||
(None, None, None, false, "docker"),
|
||||
(
|
||||
Some("agent-secret"),
|
||||
Some("~/project"),
|
||||
Some("/tmp/zed/project"),
|
||||
true,
|
||||
"podman",
|
||||
),
|
||||
(
|
||||
None,
|
||||
Some("/workspace"),
|
||||
Some("/workspace"),
|
||||
false,
|
||||
"docker",
|
||||
),
|
||||
] {
|
||||
connection.connection_options.use_podman = use_podman;
|
||||
let expected_env = HashMap::from_iter([(
|
||||
String::from("API_KEY"),
|
||||
String::from(env_override.unwrap_or("remote-secret")),
|
||||
)]);
|
||||
let expected_payload = command(expected_env, expected_working_dir).encode()?;
|
||||
let mut env = env_override
|
||||
.map(|value| (String::from("API_KEY"), value.to_owned()))
|
||||
.into_iter()
|
||||
.collect::<HashMap<_, _>>();
|
||||
env.insert(String::from("NAME=VALUE"), String::from("dropped"));
|
||||
let (template, payload) = connection.build_stdio_command(command(env, working_dir))?;
|
||||
assert_eq!(template.program, expected_program);
|
||||
let mut expected_args = vec!["exec", "-u", "user"];
|
||||
if let Some(expected_working_dir) = expected_working_dir {
|
||||
expected_args.extend(["-w", expected_working_dir]);
|
||||
}
|
||||
expected_args.extend([
|
||||
"-i",
|
||||
"container_id",
|
||||
"/tmp/zed/.local/share/zed/remote server",
|
||||
"exec",
|
||||
]);
|
||||
assert_eq!(template.args, expected_args);
|
||||
assert_eq!(template.env, HashMap::default());
|
||||
assert_eq!(payload, expected_payload);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn connection(remote_env: &[(&str, &str)]) -> DockerExecConnection {
|
||||
DockerExecConnection {
|
||||
proxy_process: Mutex::new(None),
|
||||
|
||||
@@ -29,9 +29,12 @@
|
||||
//! }
|
||||
//! ```
|
||||
|
||||
use crate::remote_client::{
|
||||
ChannelClient, CommandTemplate, Interactive, RemoteClientDelegate, RemoteConnection,
|
||||
RemoteConnectionOptions,
|
||||
use crate::{
|
||||
command::RemoteCommand,
|
||||
remote_client::{
|
||||
ChannelClient, CommandTemplate, Interactive, RemoteClientDelegate, RemoteConnection,
|
||||
RemoteConnectionOptions,
|
||||
},
|
||||
};
|
||||
use anyhow::Result;
|
||||
use async_trait::async_trait;
|
||||
@@ -213,6 +216,10 @@ impl RemoteConnection for MockRemoteConnection {
|
||||
})
|
||||
}
|
||||
|
||||
fn build_stdio_command(&self, command: RemoteCommand) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
stdio_bootstrap_command(command)
|
||||
}
|
||||
|
||||
fn build_forward_ports_command(
|
||||
&self,
|
||||
forwards: Vec<(u16, String, u16)>,
|
||||
@@ -316,6 +323,108 @@ impl RemoteConnection for MockRemoteConnection {
|
||||
}
|
||||
}
|
||||
|
||||
pub const MOCK_STDIO_FRAME_HEX: &str = "MOCK_STDIO_FRAME_HEX";
|
||||
|
||||
fn stdio_bootstrap_command(command: RemoteCommand) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
let payload = command.encode()?;
|
||||
let script = format!(
|
||||
"{MOCK_STDIO_FRAME_HEX}=\"$(command -p dd bs=1 count={} 2>/dev/null | command -p od -An -v -tx1 | command -p tr -d ' \\n')\" || exit 1; [ \"${{#{MOCK_STDIO_FRAME_HEX}}}\" -eq {} ] || {{ printf 'mock stdio bootstrap read %s hex digits, expected {}\\n' \"${{#{MOCK_STDIO_FRAME_HEX}}}\" >&2; exit 1; }}; export {MOCK_STDIO_FRAME_HEX}; exec \"$@\"",
|
||||
payload.len(),
|
||||
payload.len() * 2,
|
||||
payload.len() * 2,
|
||||
);
|
||||
let mut args = vec![
|
||||
String::from("-c"),
|
||||
script,
|
||||
String::from("sh"),
|
||||
command.program,
|
||||
];
|
||||
args.extend(command.args);
|
||||
Ok((
|
||||
CommandTemplate {
|
||||
program: String::from("/bin/sh"),
|
||||
args,
|
||||
env: command.env,
|
||||
},
|
||||
payload,
|
||||
))
|
||||
}
|
||||
|
||||
#[cfg(all(test, unix))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use futures::{AsyncReadExt as _, AsyncWriteExt as _};
|
||||
use smol::process::{Command, Stdio};
|
||||
|
||||
#[test]
|
||||
fn test_stdio_bootstrap_without_target_path() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let (template, payload) = stdio_bootstrap_command(RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![
|
||||
String::from("-c"),
|
||||
format!("printf '%s\\n' \"${MOCK_STDIO_FRAME_HEX}\"; exec /bin/cat"),
|
||||
],
|
||||
env: HashMap::from_iter([(String::from("PATH"), String::from("/nonexistent"))]),
|
||||
working_dir: None,
|
||||
})?;
|
||||
let expected_hex = payload
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect::<String>();
|
||||
let message = b"{\"jsonrpc\":\"2.0\",\"id\":1}\n\0\xff";
|
||||
|
||||
let mut child = spawn(&template)?;
|
||||
let mut stdin = child.stdin.take().unwrap();
|
||||
stdin.write_all(&payload).await?;
|
||||
stdin.write_all(message).await?;
|
||||
drop(stdin);
|
||||
let output = child.output().await?;
|
||||
assert_eq!(String::from_utf8_lossy(&output.stderr), "");
|
||||
assert!(output.status.success());
|
||||
assert_eq!(
|
||||
output.stdout,
|
||||
[expected_hex.as_bytes(), b"\n", message].concat()
|
||||
);
|
||||
|
||||
let mut child = spawn(&template)?;
|
||||
let mut stdin = child.stdin.take().unwrap();
|
||||
stdin.write_all(&payload[..payload.len() / 2]).await?;
|
||||
drop(stdin);
|
||||
let mut stdout = Vec::new();
|
||||
child
|
||||
.stdout
|
||||
.take()
|
||||
.unwrap()
|
||||
.read_to_end(&mut stdout)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert_eq!(output.status.code(), Some(1));
|
||||
assert_eq!(stdout, b"");
|
||||
assert_eq!(
|
||||
String::from_utf8_lossy(&output.stderr),
|
||||
format!(
|
||||
"mock stdio bootstrap read {} hex digits, expected {}\n",
|
||||
payload.len() / 2 * 2,
|
||||
payload.len() * 2
|
||||
)
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
fn spawn(template: &CommandTemplate) -> Result<smol::process::Child> {
|
||||
Ok(Command::new(&template.program)
|
||||
.args(&template.args)
|
||||
.env_clear()
|
||||
.envs(&template.env)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?)
|
||||
}
|
||||
}
|
||||
|
||||
/// Mock delegate for tests that don't need delegate functionality.
|
||||
pub struct MockDelegate;
|
||||
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
use crate::{
|
||||
RemoteArch, RemoteClientDelegate, RemoteOs, RemotePlatform,
|
||||
command::{RemoteCommand, home_relative_path, home_stdio_launcher_command},
|
||||
remote_client::{CommandTemplate, Interactive, RemoteConnection, RemoteConnectionOptions},
|
||||
transport::{parse_platform, parse_shell},
|
||||
transport::{HOME_DIR_ARGS, HOME_DIR_PROGRAM, parse_home_dir, parse_platform, parse_shell},
|
||||
};
|
||||
use anyhow::{Context as _, Result, anyhow};
|
||||
use async_trait::async_trait;
|
||||
@@ -20,6 +21,7 @@ use semver::Version;
|
||||
pub use settings_content::SshPortForwardOption;
|
||||
use smol::fs;
|
||||
use std::{
|
||||
fmt::Write as _,
|
||||
net::IpAddr,
|
||||
path::{Path, PathBuf},
|
||||
sync::{
|
||||
@@ -52,6 +54,7 @@ pub(crate) struct SshRemoteConnection {
|
||||
ssh_shell: String,
|
||||
ssh_shell_kind: ShellKind,
|
||||
ssh_default_system_shell: String,
|
||||
ssh_home_dir: Option<String>,
|
||||
_temp_dir: TempDir,
|
||||
}
|
||||
|
||||
@@ -378,6 +381,47 @@ impl RemoteConnection for SshRemoteConnection {
|
||||
}
|
||||
}
|
||||
|
||||
fn build_stdio_command(
|
||||
&self,
|
||||
mut command: RemoteCommand,
|
||||
) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
if self.ssh_platform.os.is_windows() {
|
||||
let template = self.build_command(
|
||||
Some(command.program),
|
||||
&command.args,
|
||||
&HashMap::default(),
|
||||
command.working_dir,
|
||||
None,
|
||||
Interactive::No,
|
||||
)?;
|
||||
return Ok((template, Vec::new()));
|
||||
}
|
||||
let remote_binary_path = self
|
||||
.remote_binary_path
|
||||
.as_ref()
|
||||
.context("Remote binary path not set")?;
|
||||
command.retain_valid_env();
|
||||
let mut exec = posix_working_dir_prefix(
|
||||
command.working_dir.take(),
|
||||
self.ssh_path_style,
|
||||
self.ssh_shell_kind,
|
||||
)?;
|
||||
exec.push_str(&home_stdio_launcher_command(
|
||||
self.ssh_shell_kind,
|
||||
self.ssh_home_dir.as_deref(),
|
||||
&remote_binary_path.display(PathStyle::Unix),
|
||||
)?);
|
||||
let template = ssh_command_template(
|
||||
self.socket.ssh_command_options(),
|
||||
None,
|
||||
Interactive::No,
|
||||
&self.socket.connection_options.ssh_destination(),
|
||||
exec,
|
||||
self.socket.envs.clone(),
|
||||
);
|
||||
Ok((template, command.encode()?))
|
||||
}
|
||||
|
||||
fn build_forward_ports_command(
|
||||
&self,
|
||||
forwards: Vec<(u16, String, u16)>,
|
||||
@@ -805,6 +849,13 @@ impl SshRemoteConnection {
|
||||
let ssh_os_version = socket.os_version(ssh_platform.os, ssh_shell_kind).await;
|
||||
log::info!("Remote OS version discovered: {:?}", ssh_os_version);
|
||||
|
||||
let ssh_home_dir = if is_windows {
|
||||
None
|
||||
} else {
|
||||
socket.home_dir(ssh_shell_kind).await
|
||||
};
|
||||
log::info!("Remote home directory discovered: {:?}", ssh_home_dir);
|
||||
|
||||
let (ssh_path_style, ssh_default_system_shell) = match ssh_platform.os {
|
||||
RemoteOs::Windows => (PathStyle::Windows, ssh_shell.clone()),
|
||||
_ => (PathStyle::Unix, String::from("/bin/sh")),
|
||||
@@ -822,6 +873,7 @@ impl SshRemoteConnection {
|
||||
ssh_shell,
|
||||
ssh_shell_kind,
|
||||
ssh_default_system_shell,
|
||||
ssh_home_dir,
|
||||
};
|
||||
|
||||
let (release_channel, version) =
|
||||
@@ -1490,6 +1542,25 @@ impl SshSocket {
|
||||
}
|
||||
}
|
||||
|
||||
async fn home_dir(&self, shell: ShellKind) -> Option<String> {
|
||||
match self
|
||||
.run_command(shell, HOME_DIR_PROGRAM, &HOME_DIR_ARGS, false)
|
||||
.await
|
||||
{
|
||||
Ok(output) => {
|
||||
let home_dir = parse_home_dir(&output);
|
||||
if home_dir.is_none() {
|
||||
log::warn!("Failed to parse remote home directory from {output:?}");
|
||||
}
|
||||
home_dir
|
||||
}
|
||||
Err(error) => {
|
||||
log::warn!("Failed to determine remote home directory: {error:#}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn platform_windows(&self, shell: ShellKind) -> Result<RemotePlatform> {
|
||||
let output = self
|
||||
.run_command(
|
||||
@@ -1865,51 +1936,7 @@ fn build_command_posix(
|
||||
ssh_destination: &str,
|
||||
interactive: Interactive,
|
||||
) -> Result<CommandTemplate> {
|
||||
use std::fmt::Write as _;
|
||||
|
||||
let mut exec = String::new();
|
||||
if let Some(working_dir) = working_dir {
|
||||
let working_dir = RemotePathBuf::new(working_dir, ssh_path_style).to_string();
|
||||
|
||||
// For paths starting with ~/, we need $HOME to expand, but the remainder
|
||||
// must be properly quoted to prevent command injection.
|
||||
// Pattern: cd "$HOME"/'quoted/remainder' - $HOME expands, rest is single-quoted
|
||||
const TILDE_PREFIX: &str = "~/";
|
||||
if working_dir.starts_with(TILDE_PREFIX) {
|
||||
let remainder = working_dir.trim_start_matches(TILDE_PREFIX);
|
||||
if remainder.is_empty() {
|
||||
write!(
|
||||
exec,
|
||||
"cd \"$HOME\" {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
} else {
|
||||
let quoted_remainder = ssh_shell_kind
|
||||
.try_quote(remainder)
|
||||
.context("shell quoting")?;
|
||||
write!(
|
||||
exec,
|
||||
"cd \"$HOME\"/{quoted_remainder} {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
}
|
||||
} else {
|
||||
let quoted_dir = ssh_shell_kind
|
||||
.try_quote(&working_dir)
|
||||
.context("shell quoting")?;
|
||||
write!(
|
||||
exec,
|
||||
"cd {quoted_dir} {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
}
|
||||
} else {
|
||||
write!(
|
||||
exec,
|
||||
"cd {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
};
|
||||
let mut exec = posix_working_dir_prefix(working_dir, ssh_path_style, ssh_shell_kind)?;
|
||||
write!(exec, "exec env ")?;
|
||||
|
||||
for (k, v) in input_env.iter() {
|
||||
@@ -1936,6 +1963,65 @@ fn build_command_posix(
|
||||
write!(exec, "{ssh_shell} -l")?;
|
||||
};
|
||||
|
||||
Ok(ssh_command_template(
|
||||
ssh_options,
|
||||
port_forward,
|
||||
interactive,
|
||||
ssh_destination,
|
||||
exec,
|
||||
ssh_env,
|
||||
))
|
||||
}
|
||||
|
||||
fn posix_working_dir_prefix(
|
||||
working_dir: Option<String>,
|
||||
ssh_path_style: PathStyle,
|
||||
ssh_shell_kind: ShellKind,
|
||||
) -> Result<String> {
|
||||
let mut exec = String::new();
|
||||
if let Some(working_dir) = working_dir {
|
||||
let working_dir = RemotePathBuf::new(working_dir, ssh_path_style).to_string();
|
||||
|
||||
// For paths starting with ~/, we need $HOME to expand, but the remainder
|
||||
// must be properly quoted to prevent command injection.
|
||||
// Pattern: cd "$HOME"/'quoted/remainder' - $HOME expands, rest is single-quoted
|
||||
const TILDE_PREFIX: &str = "~/";
|
||||
if working_dir.starts_with(TILDE_PREFIX) {
|
||||
let remainder = working_dir.trim_start_matches(TILDE_PREFIX);
|
||||
write!(
|
||||
exec,
|
||||
"cd {} {} ",
|
||||
home_relative_path(ssh_shell_kind, (!remainder.is_empty()).then_some(remainder))?,
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
} else {
|
||||
let quoted_dir = ssh_shell_kind
|
||||
.try_quote(&working_dir)
|
||||
.context("shell quoting")?;
|
||||
write!(
|
||||
exec,
|
||||
"cd {quoted_dir} {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
}
|
||||
} else {
|
||||
write!(
|
||||
exec,
|
||||
"cd {} ",
|
||||
ssh_shell_kind.sequential_and_commands_separator()
|
||||
)?;
|
||||
};
|
||||
Ok(exec)
|
||||
}
|
||||
|
||||
fn ssh_command_template(
|
||||
ssh_options: Vec<String>,
|
||||
port_forward: Option<(u16, String, u16)>,
|
||||
interactive: Interactive,
|
||||
ssh_destination: &str,
|
||||
exec: String,
|
||||
ssh_env: HashMap<String, String>,
|
||||
) -> CommandTemplate {
|
||||
let mut args = Vec::new();
|
||||
args.extend(ssh_options);
|
||||
|
||||
@@ -1962,11 +2048,11 @@ fn build_command_posix(
|
||||
args.push(ssh_destination.into());
|
||||
args.push(exec);
|
||||
|
||||
Ok(CommandTemplate {
|
||||
CommandTemplate {
|
||||
program: "ssh".into(),
|
||||
args,
|
||||
env: ssh_env,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn build_command_windows(
|
||||
@@ -2076,6 +2162,170 @@ fn build_command_windows(
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[test]
|
||||
fn test_build_stdio_command() -> Result<()> {
|
||||
let mut connection = SshRemoteConnection {
|
||||
socket: SshSocket {
|
||||
connection_options: SshConnectionOptions {
|
||||
host: SshConnectionHost::from("host"),
|
||||
username: Some(String::from("user")),
|
||||
port: Some(2222),
|
||||
..SshConnectionOptions::default()
|
||||
},
|
||||
socket_path: PathBuf::from("/tmp/zed-test.sock"),
|
||||
envs: HashMap::from_iter([(
|
||||
String::from("SSH_ASKPASS_REQUIRE"),
|
||||
String::from("force"),
|
||||
)]),
|
||||
},
|
||||
master_process: Mutex::new(None),
|
||||
killed: AtomicBool::new(false),
|
||||
remote_binary_path: None,
|
||||
ssh_platform: RemotePlatform {
|
||||
os: RemoteOs::Linux,
|
||||
arch: RemoteArch::X86_64,
|
||||
},
|
||||
ssh_os_version: None,
|
||||
ssh_path_style: PathStyle::Unix,
|
||||
ssh_shell: String::from("/bin/bash"),
|
||||
ssh_shell_kind: ShellKind::Posix,
|
||||
ssh_default_system_shell: String::from("/bin/sh"),
|
||||
ssh_home_dir: None,
|
||||
_temp_dir: TempDir::new()?,
|
||||
};
|
||||
let command = |env: HashMap<String, String>, working_dir: Option<&str>| RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: vec![String::from("--token=argument-secret")],
|
||||
env,
|
||||
working_dir: working_dir.map(str::to_owned),
|
||||
};
|
||||
let valid_env =
|
||||
HashMap::from_iter([(String::from("API_KEY"), String::from("agent-secret"))]);
|
||||
assert_eq!(
|
||||
connection
|
||||
.build_stdio_command(command(valid_env.clone(), Some("~/project")))
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"Remote binary path not set"
|
||||
);
|
||||
|
||||
connection.remote_binary_path = Some(Arc::from(RelPath::from_unix_str(
|
||||
".local/share/zed/remote server",
|
||||
)?));
|
||||
for (home_dir, working_dir, shell_kind, expected_exec) in [
|
||||
(
|
||||
None,
|
||||
Some("~/project"),
|
||||
ShellKind::Posix,
|
||||
"cd \"$HOME\"/project && exec \"$HOME\"/'.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
None,
|
||||
Some("/srv/project!"),
|
||||
ShellKind::Tcsh,
|
||||
"cd '/srv/project'\\! && exec \"$HOME\"/'.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
Some("/home/user/"),
|
||||
Some("~/project"),
|
||||
ShellKind::Posix,
|
||||
"cd \"$HOME\"/project && exec '/home/user/.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
Some("/home/bang!user"),
|
||||
Some("/srv/project!"),
|
||||
ShellKind::Tcsh,
|
||||
"cd '/srv/project'\\! && exec '/home/bang'\\!'user/.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
Some("/home/user/"),
|
||||
Some("/srv/project 'x'"),
|
||||
ShellKind::Fish,
|
||||
"cd \"/srv/project 'x'\" && exec '/home/user/.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
Some("/home/user/"),
|
||||
Some("/srv/project"),
|
||||
ShellKind::Nushell,
|
||||
"cd /srv/project ; exec '/home/user/.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
None,
|
||||
Some("~/project 'x'"),
|
||||
ShellKind::Nushell,
|
||||
"cd ($env.HOME | path join \"project 'x'\") ; exec ($env.HOME | path join '.local/share/zed/remote server') exec",
|
||||
),
|
||||
(
|
||||
None,
|
||||
Some("~/"),
|
||||
ShellKind::Nushell,
|
||||
"cd $env.HOME ; exec ($env.HOME | path join '.local/share/zed/remote server') exec",
|
||||
),
|
||||
(
|
||||
Some("/home/a^b"),
|
||||
Some("/srv/O'Brien $x"),
|
||||
ShellKind::Nushell,
|
||||
"cd \"/srv/O'Brien $x\" ; exec '/home/a^b/.local/share/zed/remote server' exec",
|
||||
),
|
||||
(
|
||||
Some("/home/user/"),
|
||||
None,
|
||||
ShellKind::Posix,
|
||||
"cd && exec '/home/user/.local/share/zed/remote server' exec",
|
||||
),
|
||||
] {
|
||||
connection.ssh_home_dir = home_dir.map(String::from);
|
||||
connection.ssh_shell_kind = shell_kind;
|
||||
let expected_payload = command(valid_env.clone(), None).encode()?;
|
||||
let mut env = valid_env.clone();
|
||||
env.insert(String::from("NAME\0NUL"), String::from("dropped"));
|
||||
let (template, payload) = connection.build_stdio_command(command(env, working_dir))?;
|
||||
assert_eq!(template.program, "ssh");
|
||||
assert_eq!(
|
||||
template.args,
|
||||
[
|
||||
"-p",
|
||||
"2222",
|
||||
"-o",
|
||||
"ControlMaster=no",
|
||||
"-o",
|
||||
"ControlPath=/tmp/zed-test.sock",
|
||||
"-o",
|
||||
"LogLevel=ERROR",
|
||||
"-T",
|
||||
"user@host",
|
||||
expected_exec,
|
||||
]
|
||||
);
|
||||
assert_eq!(template.env, connection.socket.envs);
|
||||
assert_eq!(payload, expected_payload);
|
||||
}
|
||||
|
||||
connection.ssh_platform.os = RemoteOs::Windows;
|
||||
connection.ssh_path_style = PathStyle::Windows;
|
||||
let command = RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: vec![String::from("--acp")],
|
||||
env: HashMap::from_iter([(String::from("API_KEY"), String::from("agent-secret"))]),
|
||||
working_dir: Some(String::from(r"C:\project")),
|
||||
};
|
||||
let expected = connection.build_command(
|
||||
Some(command.program.clone()),
|
||||
&command.args,
|
||||
&HashMap::default(),
|
||||
command.working_dir.clone(),
|
||||
None,
|
||||
Interactive::No,
|
||||
)?;
|
||||
let (template, payload) = connection.build_stdio_command(command)?;
|
||||
assert_eq!(template.program, expected.program);
|
||||
assert_eq!(template.args, expected.args);
|
||||
assert_eq!(template.env, expected.env);
|
||||
assert_eq!(payload, Vec::<u8>::new());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_command() -> Result<()> {
|
||||
let mut input_env = HashMap::default();
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
use crate::{
|
||||
RemoteArch, RemoteClientDelegate, RemoteOs, RemotePlatform,
|
||||
command::{RemoteCommand, home_stdio_launcher_command},
|
||||
remote_client::{CommandTemplate, Interactive, RemoteConnection, RemoteConnectionOptions},
|
||||
transport::{parse_platform, parse_shell},
|
||||
transport::{HOME_DIR_ARGS, HOME_DIR_PROGRAM, parse_home_dir, parse_platform, parse_shell},
|
||||
};
|
||||
use anyhow::{Context, Result, anyhow, bail};
|
||||
use async_trait::async_trait;
|
||||
@@ -57,6 +58,7 @@ pub(crate) struct WslRemoteConnection {
|
||||
shell_kind: ShellKind,
|
||||
default_system_shell: String,
|
||||
has_wsl_interop: bool,
|
||||
home_dir: Option<String>,
|
||||
connection_options: WslConnectionOptions,
|
||||
}
|
||||
|
||||
@@ -86,6 +88,7 @@ impl WslRemoteConnection {
|
||||
shell_kind: ShellKind::Posix,
|
||||
default_system_shell: String::from("/bin/sh"),
|
||||
has_wsl_interop: false,
|
||||
home_dir: None,
|
||||
};
|
||||
delegate.set_status(Some("Detecting WSL environment"), cx);
|
||||
this.shell = this
|
||||
@@ -110,6 +113,8 @@ impl WslRemoteConnection {
|
||||
log::info!("Remote platform discovered: {:?}", this.platform);
|
||||
this.os_version = this.detect_os_version().await;
|
||||
log::info!("Remote OS version discovered: {:?}", this.os_version);
|
||||
this.home_dir = this.detect_home_dir().await;
|
||||
log::info!("Remote home directory discovered: {:?}", this.home_dir);
|
||||
this.remote_binary_path = Some(
|
||||
this.ensure_server_binary(&delegate, release_channel, version, cx)
|
||||
.await
|
||||
@@ -140,6 +145,26 @@ impl WslRemoteConnection {
|
||||
}
|
||||
}
|
||||
|
||||
async fn detect_home_dir(&self) -> Option<String> {
|
||||
let program = self.shell_kind.prepend_command_prefix(HOME_DIR_PROGRAM);
|
||||
match self
|
||||
.run_wsl_command_with_output(&program, &HOME_DIR_ARGS)
|
||||
.await
|
||||
{
|
||||
Ok(output) => {
|
||||
let home_dir = parse_home_dir(&output);
|
||||
if home_dir.is_none() {
|
||||
log::warn!("Failed to parse remote home directory from {output:?}");
|
||||
}
|
||||
home_dir
|
||||
}
|
||||
Err(error) => {
|
||||
log::warn!("Failed to determine remote home directory: {error:#}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn detect_shell(&self) -> Result<String> {
|
||||
const DEFAULT_SHELL: &str = "sh";
|
||||
match self
|
||||
@@ -598,6 +623,47 @@ impl RemoteConnection for WslRemoteConnection {
|
||||
})
|
||||
}
|
||||
|
||||
fn build_stdio_command(
|
||||
&self,
|
||||
mut command: RemoteCommand,
|
||||
) -> Result<(CommandTemplate, Vec<u8>)> {
|
||||
let remote_binary_path = self
|
||||
.remote_binary_path
|
||||
.as_ref()
|
||||
.context("Remote binary path not set")?;
|
||||
command.retain_valid_env();
|
||||
let startup_dir = command
|
||||
.working_dir
|
||||
.take()
|
||||
.map(|working_dir| RemotePathBuf::new(working_dir, PathStyle::Unix).to_string())
|
||||
.unwrap_or_else(|| String::from("~"));
|
||||
let exec = home_stdio_launcher_command(
|
||||
self.shell_kind,
|
||||
self.home_dir.as_deref(),
|
||||
&remote_binary_path.display(PathStyle::Unix),
|
||||
)?;
|
||||
let (shell, shell_args) =
|
||||
ShellBuilder::new(&Shell::Program(self.shell.clone()), false).build(Some(exec), &[]);
|
||||
let mut args = vec![
|
||||
String::from("--distribution"),
|
||||
self.connection_options.distro_name.clone(),
|
||||
];
|
||||
if let Some(user) = &self.connection_options.user {
|
||||
args.push(String::from("--user"));
|
||||
args.push(user.clone());
|
||||
}
|
||||
args.extend([String::from("--cd"), startup_dir, String::from("--"), shell]);
|
||||
args.extend(shell_args);
|
||||
Ok((
|
||||
CommandTemplate {
|
||||
program: String::from("wsl.exe"),
|
||||
args,
|
||||
env: HashMap::default(),
|
||||
},
|
||||
command.encode()?,
|
||||
))
|
||||
}
|
||||
|
||||
fn build_forward_ports_command(
|
||||
&self,
|
||||
_: Vec<(u16, String, u16)>,
|
||||
@@ -755,3 +821,174 @@ fn wsl_command_impl(
|
||||
log::debug!("wsl {:?}", command);
|
||||
command
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_build_stdio_command() -> Result<()> {
|
||||
let mut connection = WslRemoteConnection {
|
||||
remote_binary_path: None,
|
||||
platform: RemotePlatform {
|
||||
os: RemoteOs::Linux,
|
||||
arch: RemoteArch::X86_64,
|
||||
},
|
||||
os_version: None,
|
||||
shell: String::from("/bin/fish"),
|
||||
shell_kind: ShellKind::Fish,
|
||||
default_system_shell: String::from("/bin/sh"),
|
||||
has_wsl_interop: false,
|
||||
home_dir: None,
|
||||
connection_options: WslConnectionOptions {
|
||||
distro_name: String::from("Ubuntu"),
|
||||
user: None,
|
||||
},
|
||||
};
|
||||
let command = |env: HashMap<String, String>, working_dir: Option<&str>| RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: vec![String::from("--token=argument-secret")],
|
||||
env,
|
||||
working_dir: working_dir.map(str::to_owned),
|
||||
};
|
||||
let valid_env =
|
||||
HashMap::from_iter([(String::from("API_KEY"), String::from("agent-secret"))]);
|
||||
assert_eq!(
|
||||
connection
|
||||
.build_stdio_command(command(valid_env.clone(), Some("~/project")))
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"Remote binary path not set"
|
||||
);
|
||||
|
||||
connection.remote_binary_path = Some(Arc::from(RelPath::from_unix_str(
|
||||
".local/share/zed/remote server",
|
||||
)?));
|
||||
for (home_dir, user, working_dir, shell, shell_kind, expected_args) in [
|
||||
(
|
||||
None,
|
||||
None,
|
||||
Some("~/project"),
|
||||
"/bin/bash",
|
||||
ShellKind::Posix,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--cd",
|
||||
"~/project",
|
||||
"--",
|
||||
"/bin/bash",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec \"$HOME\"/'.local/share/zed/remote server' exec",
|
||||
],
|
||||
),
|
||||
(
|
||||
Some("/home/user"),
|
||||
None,
|
||||
Some("/home/user$UNSET/project 'x'"),
|
||||
"/bin/fish",
|
||||
ShellKind::Fish,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--cd",
|
||||
"/home/user$UNSET/project 'x'",
|
||||
"--",
|
||||
"/bin/fish",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec '/home/user/.local/share/zed/remote server' exec",
|
||||
],
|
||||
),
|
||||
(
|
||||
Some("/home/user"),
|
||||
Some(String::from("user")),
|
||||
None,
|
||||
"/usr/bin/nu",
|
||||
ShellKind::Nushell,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--user",
|
||||
"user",
|
||||
"--cd",
|
||||
"~",
|
||||
"--",
|
||||
"/usr/bin/nu",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec '/home/user/.local/share/zed/remote server' exec",
|
||||
],
|
||||
),
|
||||
(
|
||||
Some("/home/a^b"),
|
||||
None,
|
||||
None,
|
||||
"/usr/bin/nu",
|
||||
ShellKind::Nushell,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--cd",
|
||||
"~",
|
||||
"--",
|
||||
"/usr/bin/nu",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec '/home/a^b/.local/share/zed/remote server' exec",
|
||||
],
|
||||
),
|
||||
(
|
||||
None,
|
||||
None,
|
||||
Some("~/project"),
|
||||
"/usr/bin/nu",
|
||||
ShellKind::Nushell,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--cd",
|
||||
"~/project",
|
||||
"--",
|
||||
"/usr/bin/nu",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec ($env.HOME | path join '.local/share/zed/remote server') exec",
|
||||
],
|
||||
),
|
||||
(
|
||||
Some("/home/bang!user"),
|
||||
None,
|
||||
None,
|
||||
"/bin/tcsh",
|
||||
ShellKind::Tcsh,
|
||||
vec![
|
||||
"--distribution",
|
||||
"Ubuntu",
|
||||
"--cd",
|
||||
"~",
|
||||
"--",
|
||||
"/bin/tcsh",
|
||||
"-i",
|
||||
"-c",
|
||||
"exec '/home/bang'\\!'user/.local/share/zed/remote server' exec",
|
||||
],
|
||||
),
|
||||
] {
|
||||
connection.home_dir = home_dir.map(String::from);
|
||||
connection.connection_options.user = user;
|
||||
connection.shell = String::from(shell);
|
||||
connection.shell_kind = shell_kind;
|
||||
let expected_payload = command(valid_env.clone(), None).encode()?;
|
||||
let mut env = valid_env.clone();
|
||||
env.insert(String::from("NAME=VALUE"), String::from("dropped"));
|
||||
let (template, payload) = connection.build_stdio_command(command(env, working_dir))?;
|
||||
assert_eq!(template.program, "wsl.exe");
|
||||
assert_eq!(template.args, expected_args);
|
||||
assert_eq!(template.env, HashMap::default());
|
||||
assert_eq!(payload, expected_payload);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -75,6 +75,9 @@ thiserror.workspace = true
|
||||
rayon.workspace = true
|
||||
uuid = { workspace = true, features = ["v4"] }
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
libc.workspace = true
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows.workspace = true
|
||||
gpui = { workspace = true, features = ["windows-manifest"] }
|
||||
@@ -84,6 +87,7 @@ acp_thread.workspace = true
|
||||
action_log.workspace = true
|
||||
agent = { workspace = true, features = ["test-support"] }
|
||||
agent-client-protocol.workspace = true
|
||||
agent_servers.workspace = true
|
||||
client = { workspace = true, features = ["test-support"] }
|
||||
clock = { workspace = true, features = ["test-support"] }
|
||||
editor = { workspace = true, features = ["test-support"] }
|
||||
|
||||
@@ -56,7 +56,11 @@ fn main() -> anyhow::Result<()> {
|
||||
res
|
||||
} else {
|
||||
std::io::stderr()
|
||||
.write_all(b"usage: remote <run|proxy|version>\n")
|
||||
.write_all(if cfg!(unix) {
|
||||
b"usage: remote <run|proxy|version|exec>\n"
|
||||
} else {
|
||||
b"usage: remote <run|proxy|version>\n"
|
||||
})
|
||||
.ok();
|
||||
std::process::exit(1);
|
||||
}
|
||||
|
||||
@@ -40,6 +40,11 @@ use lsp::{
|
||||
LanguageServerId, LanguageServerName,
|
||||
};
|
||||
use node_runtime::NodeRuntime;
|
||||
#[cfg(not(windows))]
|
||||
use project::{
|
||||
AgentId,
|
||||
context_server_store::{ContextServerStatus, ServerStatusChangedEvent},
|
||||
};
|
||||
use project::{
|
||||
CompletionSource, LanguageServerLogType, ProgressToken, Project, ProjectPath,
|
||||
agent_server_store::AgentServerCommand,
|
||||
@@ -51,6 +56,8 @@ use project::{
|
||||
search::{SearchQuery, SearchResult},
|
||||
};
|
||||
use remote::{ConnectionState, RemoteClient, RemoteClientEvent};
|
||||
#[cfg(not(windows))]
|
||||
use remote::{MOCK_STDIO_FRAME_HEX, command::RemoteCommand};
|
||||
use rpc::proto;
|
||||
use serde_json::json;
|
||||
use settings::{
|
||||
@@ -5014,6 +5021,183 @@ async fn test_remote_external_agent_server(
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[gpui::test]
|
||||
async fn test_remote_external_agent_receives_env_over_stdin(
|
||||
cx: &mut TestAppContext,
|
||||
server_cx: &mut TestAppContext,
|
||||
) {
|
||||
let fs = FakeFs::new(server_cx.executor());
|
||||
fs.insert_tree(path!("/project"), json!({})).await;
|
||||
let (project, _headless_project) = init_test(&fs, cx, server_cx).await;
|
||||
project
|
||||
.update(cx, |project, cx| {
|
||||
project.find_or_create_worktree(path!("/project"), true, cx)
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
cx.executor().allow_parking();
|
||||
|
||||
let output_dir = tempfile::tempdir().unwrap();
|
||||
let output_path = output_dir.path().join("launch");
|
||||
let args = stdio_launch_args(
|
||||
&output_path,
|
||||
r#"{"protocolVersion":1,"agentCapabilities":{},"authMethods":[]}"#,
|
||||
);
|
||||
server_cx.update_global(|settings_store: &mut SettingsStore, cx| {
|
||||
settings_store
|
||||
.set_server_settings(
|
||||
&json!({
|
||||
"agent_servers": {
|
||||
"foo": {
|
||||
"type": "custom",
|
||||
"command": "/bin/sh",
|
||||
"args": args,
|
||||
"env": { "AGENT_TOKEN": "agent-secret-sentinel" }
|
||||
}
|
||||
}
|
||||
})
|
||||
.to_string(),
|
||||
cx,
|
||||
)
|
||||
.unwrap();
|
||||
});
|
||||
server_cx.run_until_parked();
|
||||
cx.run_until_parked();
|
||||
|
||||
let agent_server_store =
|
||||
project.read_with(cx, |project, _| project.agent_server_store().clone());
|
||||
let command = agent_server_store
|
||||
.update(cx, |store, cx| {
|
||||
store
|
||||
.get_external_agent(&"foo".into())
|
||||
.unwrap()
|
||||
.get_command(vec![], HashMap::default(), &mut cx.to_async())
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let connection = agent_servers::AcpConnection::stdio(
|
||||
AgentId::new("foo"),
|
||||
project.clone(),
|
||||
command,
|
||||
agent_server_store.downgrade(),
|
||||
None,
|
||||
HashMap::default(),
|
||||
&mut cx.to_async(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let (launched, first_message) = read_stdio_launch(&output_path);
|
||||
assert_eq!(launched.program, "/bin/sh");
|
||||
assert_eq!(launched.args, args);
|
||||
assert_eq!(
|
||||
launched.env,
|
||||
HashMap::from_iter([
|
||||
(String::from("NO_BROWSER"), String::from("1")),
|
||||
(
|
||||
String::from("AGENT_TOKEN"),
|
||||
String::from("agent-secret-sentinel")
|
||||
),
|
||||
])
|
||||
);
|
||||
assert_eq!(launched.working_dir.as_deref(), Some(path!("/project")));
|
||||
assert_eq!(first_message["method"], "initialize");
|
||||
drop(connection);
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[gpui::test]
|
||||
async fn test_remote_context_server_receives_env_over_stdin(
|
||||
cx: &mut TestAppContext,
|
||||
server_cx: &mut TestAppContext,
|
||||
) {
|
||||
let fs = FakeFs::new(server_cx.executor());
|
||||
fs.insert_tree(path!("/project"), json!({})).await;
|
||||
let (project, _headless_project) = init_test(&fs, cx, server_cx).await;
|
||||
project
|
||||
.update(cx, |project, cx| {
|
||||
project.find_or_create_worktree(path!("/project"), true, cx)
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
cx.executor().allow_parking();
|
||||
|
||||
let store = project.read_with(cx, |project, _| project.context_server_store());
|
||||
let (status_tx, mut status_rx) = futures::channel::mpsc::unbounded();
|
||||
let _subscription = cx.update(|cx| {
|
||||
cx.subscribe(&store, move |_, event: &ServerStatusChangedEvent, _| {
|
||||
status_tx.unbounded_send(event.status.clone()).ok();
|
||||
})
|
||||
});
|
||||
|
||||
let output_dir = tempfile::tempdir().unwrap();
|
||||
let output_path = output_dir.path().join("launch");
|
||||
let args = stdio_launch_args(
|
||||
&output_path,
|
||||
r#"{"protocolVersion":"2024-11-05","capabilities":{},"serverInfo":{"name":"test-server","version":"1.0.0"}}"#,
|
||||
);
|
||||
let settings = json!({
|
||||
"context_servers": {
|
||||
"mcp": {
|
||||
"source": "custom",
|
||||
"remote": true,
|
||||
"command": "/bin/sh",
|
||||
"args": args,
|
||||
"env": { "MCP_TOKEN": "mcp-secret-sentinel" }
|
||||
}
|
||||
}
|
||||
})
|
||||
.to_string();
|
||||
server_cx.update_global(|settings_store: &mut SettingsStore, cx| {
|
||||
settings_store.set_server_settings(&settings, cx).unwrap();
|
||||
});
|
||||
server_cx.run_until_parked();
|
||||
cx.run_until_parked();
|
||||
cx.update_global(|settings_store: &mut SettingsStore, cx| {
|
||||
settings_store.set_user_settings(&settings, cx).unwrap();
|
||||
});
|
||||
|
||||
let statuses = async {
|
||||
let mut statuses = Vec::new();
|
||||
while let Some(status) = status_rx.next().await {
|
||||
let starting = status == ContextServerStatus::Starting;
|
||||
statuses.push(status);
|
||||
if !starting {
|
||||
break;
|
||||
}
|
||||
}
|
||||
statuses
|
||||
}
|
||||
.fuse();
|
||||
let timeout = cx
|
||||
.background_executor
|
||||
.timer(std::time::Duration::from_secs(30))
|
||||
.fuse();
|
||||
futures::pin_mut!(statuses, timeout);
|
||||
let statuses = futures::select! {
|
||||
statuses = statuses => statuses,
|
||||
_ = timeout => panic!("timed out waiting for the context server status"),
|
||||
};
|
||||
assert_eq!(
|
||||
statuses,
|
||||
[ContextServerStatus::Starting, ContextServerStatus::Running]
|
||||
);
|
||||
|
||||
let (launched, first_message) = read_stdio_launch(&output_path);
|
||||
assert_eq!(launched.program, "/bin/sh");
|
||||
assert_eq!(launched.args, args);
|
||||
assert_eq!(
|
||||
launched.env,
|
||||
HashMap::from_iter([(
|
||||
String::from("MCP_TOKEN"),
|
||||
String::from("mcp-secret-sentinel")
|
||||
)])
|
||||
);
|
||||
assert_eq!(launched.working_dir.as_deref(), Some(path!("/project")));
|
||||
assert_eq!(first_message["method"], "initialize");
|
||||
}
|
||||
|
||||
#[gpui::test]
|
||||
async fn test_remote_apply_code_action_skips_unadvertised_command(
|
||||
cx: &mut TestAppContext,
|
||||
@@ -6095,6 +6279,39 @@ fn init_logger() {
|
||||
zlog::init_test();
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn stdio_launch_args(output_path: &Path, initialize_result: &str) -> Vec<String> {
|
||||
let script = format!(
|
||||
r#"printf '%s\n' "${MOCK_STDIO_FRAME_HEX}" > "$1"
|
||||
IFS= read -r line
|
||||
printf '%s\n' "$line" >> "$1"
|
||||
id=$(printf '%s' "$line" | sed -nE 's/^\{{"jsonrpc":"2.0","id":("[^"]*"|[0-9]+),.*/\1/p')
|
||||
printf '{{"jsonrpc":"2.0","id":%s,"result":%s}}\n' "$id" "$2"
|
||||
exec cat >/dev/null"#
|
||||
);
|
||||
vec![
|
||||
String::from("-c"),
|
||||
script,
|
||||
String::from("sh"),
|
||||
output_path.display().to_string(),
|
||||
String::from(initialize_result),
|
||||
]
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn read_stdio_launch(output_path: &Path) -> (RemoteCommand, serde_json::Value) {
|
||||
let output = std::fs::read_to_string(output_path).unwrap();
|
||||
let (frame_hex, first_line) = output.trim_end().split_once('\n').unwrap();
|
||||
let frame = (0..frame_hex.len())
|
||||
.step_by(2)
|
||||
.map(|index| u8::from_str_radix(&frame_hex[index..index + 2], 16).unwrap())
|
||||
.collect::<Vec<_>>();
|
||||
let mut frame = &frame[..];
|
||||
let command = RemoteCommand::read(&mut frame).unwrap();
|
||||
assert_eq!(frame, b"");
|
||||
(command, serde_json::from_str(first_line).unwrap())
|
||||
}
|
||||
|
||||
fn build_project(ssh: Entity<RemoteClient>, cx: &mut TestAppContext) -> Entity<Project> {
|
||||
cx.update(|cx| {
|
||||
if !cx.has_global::<SettingsStore>() {
|
||||
|
||||
@@ -30,6 +30,8 @@ use paths::logs_dir;
|
||||
use project::{project_settings::ProjectSettings, trusted_worktrees};
|
||||
use proto::CrashReport;
|
||||
use release_channel::{AppCommitSha, AppVersion, RELEASE_CHANNEL, ReleaseChannel};
|
||||
#[cfg(unix)]
|
||||
use remote::command::RemoteCommand;
|
||||
use remote::{
|
||||
RemoteClient,
|
||||
json_log::LogRecord,
|
||||
@@ -56,6 +58,14 @@ use std::{
|
||||
sync::{Arc, LazyLock},
|
||||
time::Instant,
|
||||
};
|
||||
#[cfg(unix)]
|
||||
use std::{
|
||||
ffi::OsString,
|
||||
os::{
|
||||
fd::AsFd as _,
|
||||
unix::{ffi::OsStrExt as _, process::CommandExt as _},
|
||||
},
|
||||
};
|
||||
use thiserror::Error;
|
||||
use util::{ResultExt, command::new_command};
|
||||
|
||||
@@ -80,6 +90,8 @@ pub enum Commands {
|
||||
identifier: String,
|
||||
},
|
||||
Version,
|
||||
#[cfg(unix)]
|
||||
Exec,
|
||||
}
|
||||
|
||||
pub fn run(command: Commands) -> anyhow::Result<()> {
|
||||
@@ -104,6 +116,8 @@ pub fn run(command: Commands) -> anyhow::Result<()> {
|
||||
identifier,
|
||||
reconnect,
|
||||
} => execute_proxy(identifier, reconnect).context("running proxy on the remote server"),
|
||||
#[cfg(unix)]
|
||||
Commands::Exec => execute_command(),
|
||||
Commands::Version => {
|
||||
let release_channel = *RELEASE_CHANNEL;
|
||||
match release_channel {
|
||||
@@ -139,6 +153,105 @@ pub static VERSION: LazyLock<String> = LazyLock::new(|| match *RELEASE_CHANNEL {
|
||||
}
|
||||
});
|
||||
|
||||
#[cfg(unix)]
|
||||
fn execute_command() -> Result<()> {
|
||||
let mut stdin = File::from(std::io::stdin().as_fd().try_clone_to_owned()?);
|
||||
let descriptor = RemoteCommand::read(&mut stdin)?;
|
||||
drop(stdin);
|
||||
|
||||
let working_dir = descriptor
|
||||
.working_dir
|
||||
.as_deref()
|
||||
.map(|working_dir| shellexpand::tilde(working_dir).into_owned());
|
||||
if let Some(working_dir) = &working_dir {
|
||||
std::env::set_current_dir(working_dir)
|
||||
.with_context(|| format!("Failed to change directory to {working_dir}"))?;
|
||||
}
|
||||
let error = exec_with_script_fallback(&descriptor, working_dir.as_deref(), |mut command| {
|
||||
command.exec()
|
||||
});
|
||||
Err(error).with_context(|| format!("Failed to execute {}", descriptor.program))
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn exec_with_script_fallback(
|
||||
descriptor: &RemoteCommand,
|
||||
working_dir: Option<&str>,
|
||||
mut exec: impl FnMut(std::process::Command) -> std::io::Error,
|
||||
) -> std::io::Error {
|
||||
let error = exec(exec_command(
|
||||
descriptor,
|
||||
working_dir,
|
||||
&descriptor.program,
|
||||
&descriptor.args,
|
||||
));
|
||||
if error.raw_os_error() != Some(libc::ENOEXEC) {
|
||||
return error;
|
||||
}
|
||||
let path = descriptor
|
||||
.env
|
||||
.get("PATH")
|
||||
.map(OsString::from)
|
||||
.or_else(|| std::env::var_os("PATH"));
|
||||
for candidate in script_candidates(&descriptor.program, path.as_deref()) {
|
||||
let candidate_error = exec(exec_command(
|
||||
descriptor,
|
||||
working_dir,
|
||||
&candidate,
|
||||
&descriptor.args,
|
||||
));
|
||||
match candidate_error.raw_os_error() {
|
||||
Some(libc::ENOEXEC) => {
|
||||
let args = std::iter::once(candidate.into_os_string())
|
||||
.chain(descriptor.args.iter().map(OsString::from))
|
||||
.collect::<Vec<_>>();
|
||||
return exec(exec_command(descriptor, working_dir, "/bin/sh", &args));
|
||||
}
|
||||
Some(libc::ENOENT | libc::ENOTDIR | libc::EACCES) => {}
|
||||
_ => return candidate_error,
|
||||
}
|
||||
}
|
||||
error
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn script_candidates(program: &str, path: Option<&OsStr>) -> Vec<PathBuf> {
|
||||
let explicit = |candidate: PathBuf| {
|
||||
if candidate.is_absolute() {
|
||||
candidate
|
||||
} else {
|
||||
Path::new(".").join(candidate)
|
||||
}
|
||||
};
|
||||
if program.contains('/') {
|
||||
return vec![explicit(PathBuf::from(program))];
|
||||
}
|
||||
path.unwrap_or(OsStr::new(DEFAULT_PATH))
|
||||
.as_bytes()
|
||||
.split(|byte| *byte == b':')
|
||||
.map(|directory| explicit(Path::new(OsStr::from_bytes(directory)).join(program)))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
const DEFAULT_PATH: &str = "/usr/local/bin:/bin:/usr/bin";
|
||||
|
||||
#[cfg(unix)]
|
||||
fn exec_command(
|
||||
descriptor: &RemoteCommand,
|
||||
working_dir: Option<&str>,
|
||||
program: impl AsRef<OsStr>,
|
||||
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
|
||||
) -> std::process::Command {
|
||||
let mut command = std::process::Command::new(program);
|
||||
command.args(args);
|
||||
if let Some(working_dir) = working_dir {
|
||||
command.env("PWD", working_dir);
|
||||
}
|
||||
command.envs(&descriptor.env);
|
||||
command
|
||||
}
|
||||
|
||||
fn init_logging_proxy() {
|
||||
env_logger::builder()
|
||||
.format(|buf, record| {
|
||||
@@ -1557,4 +1670,137 @@ mod tests {
|
||||
new_contents
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn script_candidates_never_start_with_a_dash() {
|
||||
assert_eq!(
|
||||
script_candidates("agent", Some(OsStr::new("/usr/bin:bin::-bin"))),
|
||||
[
|
||||
PathBuf::from("/usr/bin/agent"),
|
||||
PathBuf::from("./bin/agent"),
|
||||
PathBuf::from("./agent"),
|
||||
PathBuf::from("./-bin/agent"),
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
script_candidates("-a", Some(OsStr::new("/opt/bin"))),
|
||||
[PathBuf::from("/opt/bin/-a")]
|
||||
);
|
||||
assert_eq!(
|
||||
script_candidates("-x/agent", Some(OsStr::new("/opt/bin"))),
|
||||
[PathBuf::from("./-x/agent")]
|
||||
);
|
||||
assert_eq!(
|
||||
script_candidates("/srv/agent", Some(OsStr::new("/opt/bin"))),
|
||||
[PathBuf::from("/srv/agent")]
|
||||
);
|
||||
assert_eq!(
|
||||
script_candidates("agent", Some(OsStr::from_bytes(b"/not-utf8-\xff"))),
|
||||
[PathBuf::from(OsStr::from_bytes(b"/not-utf8-\xff/agent"))]
|
||||
);
|
||||
assert_eq!(
|
||||
script_candidates("agent", None),
|
||||
[
|
||||
PathBuf::from("/usr/local/bin/agent"),
|
||||
PathBuf::from("/bin/agent"),
|
||||
PathBuf::from("/usr/bin/agent"),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn script_fallback_runs_option_like_wrapper_instead_of_its_arguments() {
|
||||
use std::cell::RefCell;
|
||||
use std::os::unix::fs::PermissionsExt as _;
|
||||
|
||||
let directory = tempfile::tempdir().expect("create temp dir");
|
||||
let missing_directory = directory.path().join("missing");
|
||||
let binary_directory = directory.path().join("bin");
|
||||
std::fs::create_dir(&binary_directory).expect("create bin dir");
|
||||
let wrapper = binary_directory.join("-a");
|
||||
std::fs::write(
|
||||
&wrapper,
|
||||
"printf 'WRAPPER_RAN|%s|%s|%s|%s\\n' \"$TOKEN\" \"$#\" \"$1\" \"$2\"\n",
|
||||
)
|
||||
.expect("write wrapper");
|
||||
std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755))
|
||||
.expect("chmod wrapper");
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("-a"),
|
||||
args: vec![
|
||||
String::from("spoofed-argv0"),
|
||||
String::from("/usr/bin/printf"),
|
||||
String::from("OPTION_INTERPRETED"),
|
||||
],
|
||||
env: HashMap::from_iter([
|
||||
(String::from("TOKEN"), String::from("controlled")),
|
||||
(
|
||||
String::from("PATH"),
|
||||
format!(
|
||||
"{}:{}",
|
||||
missing_directory.display(),
|
||||
binary_directory.display()
|
||||
),
|
||||
),
|
||||
]),
|
||||
working_dir: None,
|
||||
};
|
||||
|
||||
let attempts = RefCell::new(Vec::new());
|
||||
let shell_output = RefCell::new(None);
|
||||
let error = exec_with_script_fallback(&descriptor, None, |command| {
|
||||
let program = command.get_program().to_owned();
|
||||
if program == "/bin/sh" {
|
||||
let output = smol::block_on(smol::process::Command::from(command).output())
|
||||
.expect("run /bin/sh");
|
||||
*shell_output.borrow_mut() = Some(output);
|
||||
return std::io::Error::from_raw_os_error(libc::EIO);
|
||||
}
|
||||
attempts.borrow_mut().push(program.clone());
|
||||
if program == "-a" || program == wrapper.as_os_str() {
|
||||
std::io::Error::from_raw_os_error(libc::ENOEXEC)
|
||||
} else {
|
||||
std::io::Error::from_raw_os_error(libc::ENOENT)
|
||||
}
|
||||
});
|
||||
assert_eq!(error.raw_os_error(), Some(libc::EIO));
|
||||
assert_eq!(
|
||||
attempts.into_inner(),
|
||||
[
|
||||
OsString::from("-a"),
|
||||
missing_directory.join("-a").into_os_string(),
|
||||
wrapper.into_os_string(),
|
||||
]
|
||||
);
|
||||
let shell_output = shell_output.into_inner().expect("shell fallback ran");
|
||||
assert_eq!(
|
||||
String::from_utf8_lossy(&shell_output.stderr),
|
||||
"",
|
||||
"{shell_output:?}"
|
||||
);
|
||||
assert_eq!(
|
||||
String::from_utf8_lossy(&shell_output.stdout),
|
||||
"WRAPPER_RAN|controlled|3|spoofed-argv0|/usr/bin/printf\n"
|
||||
);
|
||||
assert_eq!(shell_output.status.code(), Some(0));
|
||||
|
||||
let attempts = RefCell::new(0);
|
||||
let error = exec_with_script_fallback(&descriptor, None, |_| {
|
||||
*attempts.borrow_mut() += 1;
|
||||
std::io::Error::from_raw_os_error(libc::EACCES)
|
||||
});
|
||||
assert_eq!(error.raw_os_error(), Some(libc::EACCES));
|
||||
assert_eq!(attempts.into_inner(), 1);
|
||||
|
||||
let error = exec_with_script_fallback(&descriptor, None, |command| {
|
||||
if command.get_program() == "-a" {
|
||||
std::io::Error::from_raw_os_error(libc::ENOEXEC)
|
||||
} else {
|
||||
std::io::Error::from_raw_os_error(libc::ELOOP)
|
||||
}
|
||||
});
|
||||
assert_eq!(error.raw_os_error(), Some(libc::ELOOP));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,776 @@
|
||||
#![cfg(unix)]
|
||||
|
||||
use anyhow::{Context as _, Result};
|
||||
use collections::HashMap;
|
||||
use futures::{AsyncReadExt as _, AsyncWriteExt as _};
|
||||
use remote::command::{
|
||||
RemoteCommand, home_relative_path, home_stdio_launcher_command, stdio_launcher_command,
|
||||
};
|
||||
use smol::process::{Command, Stdio};
|
||||
use std::borrow::Cow;
|
||||
use std::ffi::OsStr;
|
||||
use std::os::unix::ffi::OsStrExt as _;
|
||||
use std::os::unix::fs::PermissionsExt as _;
|
||||
use util::shell::{Shell, ShellKind};
|
||||
use util::shell_builder::ShellBuilder;
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_preserves_agent_stdin() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/cat"),
|
||||
args: Vec::new(),
|
||||
env: HashMap::default(),
|
||||
working_dir: None,
|
||||
};
|
||||
let mut child = launcher().spawn()?;
|
||||
let mut stdin = child.stdin.take().context("missing stdin")?;
|
||||
let mut stdout = child.stdout.take().context("missing stdout")?;
|
||||
let message = b"{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\"}\n\0\xff";
|
||||
let mut input = descriptor.encode()?;
|
||||
input.extend_from_slice(message);
|
||||
stdin.write_all(&input).await?;
|
||||
stdin.flush().await?;
|
||||
let mut output = vec![0; message.len()];
|
||||
stdout.read_exact(&mut output).await?;
|
||||
assert_eq!(output, message);
|
||||
drop(stdin);
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success());
|
||||
assert_eq!(output.stderr, b"");
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_preserves_environment() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let marker = directory.path().join("injected");
|
||||
let environment = HashMap::from_iter([
|
||||
(
|
||||
String::from("TOKEN"),
|
||||
String::from("'\"\n\r\t\\$()=secret\n"),
|
||||
),
|
||||
(String::from("EMPTY"), String::new()),
|
||||
(String::from("UNICODE"), String::from("钥匙🔑")),
|
||||
(String::from("LARGE"), "s".repeat(32 * 1024)),
|
||||
(
|
||||
format!("KEY$(touch {})", marker.display()),
|
||||
String::from("literal"),
|
||||
),
|
||||
(String::from("KEY-WITH-DASH"), String::from("preserved")),
|
||||
]);
|
||||
for (key, value) in &environment {
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/usr/bin/printenv"),
|
||||
args: vec![key.clone()],
|
||||
env: environment.clone(),
|
||||
working_dir: None,
|
||||
};
|
||||
let mut child = launcher().spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{key}: {:?}", output.stderr);
|
||||
assert_eq!(output.stdout, format!("{value}\n").as_bytes());
|
||||
assert_eq!(output.stderr, b"");
|
||||
}
|
||||
assert!(!marker.exists());
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_working_directory_and_exit_status() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
let project = home.path().join("project 'with spaces'");
|
||||
std::fs::create_dir(&project)?;
|
||||
for (env, expected_pwd) in [
|
||||
(HashMap::default(), project.display().to_string()),
|
||||
(
|
||||
HashMap::from_iter([(String::from("PWD"), String::from("explicit"))]),
|
||||
String::from("explicit"),
|
||||
),
|
||||
] {
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/usr/bin/printenv"),
|
||||
args: vec![String::from("PWD")],
|
||||
env,
|
||||
working_dir: Some(String::from("~/project 'with spaces'")),
|
||||
};
|
||||
let mut child = launcher().env("HOME", home.path()).spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{:?}", output.stderr);
|
||||
assert_eq!(output.stdout, format!("{expected_pwd}\n").as_bytes());
|
||||
}
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![String::from("-c"), String::from("pwd -P; exit 37")],
|
||||
env: HashMap::from_iter([(
|
||||
String::from("HOME"),
|
||||
String::from("/not-the-bootstrap-home"),
|
||||
)]),
|
||||
working_dir: Some(String::from("~/project 'with spaces'")),
|
||||
};
|
||||
let mut child = launcher().env("HOME", home.path()).spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert_eq!(output.status.code(), Some(37));
|
||||
assert_eq!(
|
||||
output.stdout,
|
||||
format!("{}\n", project.canonicalize()?.display()).as_bytes()
|
||||
);
|
||||
assert_eq!(output.stderr, b"");
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_inherits_shell_environment() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
let shell_only_binary = home.path().join("shell-only-printenv");
|
||||
std::os::unix::fs::symlink("/usr/bin/printenv", &shell_only_binary)?;
|
||||
let home_path = home.path().display().to_string();
|
||||
let quoted_home = ShellKind::Posix
|
||||
.try_quote(&home_path)
|
||||
.context("shell quoting")?;
|
||||
std::fs::write(
|
||||
home.path().join(".bashrc"),
|
||||
format!(
|
||||
"export PATH={quoted_home}:/usr/bin:/bin\nexport SHELL_SECRET=only-in-shell-startup\n"
|
||||
),
|
||||
)?;
|
||||
for (program, env, expected) in [
|
||||
(
|
||||
"shell-only-printenv",
|
||||
HashMap::default(),
|
||||
"only-in-shell-startup",
|
||||
),
|
||||
(
|
||||
"/usr/bin/printenv",
|
||||
HashMap::from_iter([(String::from("SHELL_SECRET"), String::from("from-payload"))]),
|
||||
"from-payload",
|
||||
),
|
||||
] {
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from(program),
|
||||
args: vec![String::from("SHELL_SECRET")],
|
||||
env,
|
||||
working_dir: None,
|
||||
};
|
||||
let exec =
|
||||
stdio_launcher_command(ShellKind::Posix, env!("CARGO_BIN_EXE_remote_server"))?;
|
||||
let mut child = shell_launcher(home.path(), &exec).spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{program}: {:?}", output.stderr);
|
||||
assert_eq!(output.stdout, format!("{expected}\n").as_bytes());
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_inherits_default_shell_startup_environment() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
let helper = install_helper(home.path())?;
|
||||
let startup_script = home.path().join("startup env");
|
||||
std::fs::write(
|
||||
&startup_script,
|
||||
"export STARTUP_TOKEN=only-in-default-shell-startup\n",
|
||||
)?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/usr/bin/printenv"),
|
||||
args: vec![String::from("STARTUP_TOKEN")],
|
||||
env: HashMap::default(),
|
||||
working_dir: None,
|
||||
};
|
||||
let (inner_shell, inner_args) =
|
||||
ShellBuilder::new(&Shell::Program(String::from("/bin/bash")), false).build(
|
||||
Some(stdio_launcher_command(ShellKind::Posix, &helper)?),
|
||||
&[],
|
||||
);
|
||||
let default_shell_command = std::iter::once(inner_shell)
|
||||
.chain(inner_args)
|
||||
.map(|argument| {
|
||||
ShellKind::Posix
|
||||
.try_quote(&argument)
|
||||
.map(Cow::into_owned)
|
||||
.context("shell quoting")
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?
|
||||
.join(" ");
|
||||
let mut child = Command::new("/bin/bash")
|
||||
.args(["-c", &default_shell_command])
|
||||
.env_clear()
|
||||
.env("HOME", home.path())
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.env("BASH_ENV", &startup_script)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{:?}", output.stderr);
|
||||
assert_eq!(output.stdout, b"only-in-default-shell-startup\n");
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_survives_shell_startup_changing_directory() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
let project = home.path().join("project");
|
||||
std::fs::create_dir(&project)?;
|
||||
let helper = install_helper(home.path())?;
|
||||
std::fs::write(
|
||||
home.path().join(".bashrc"),
|
||||
"cd /tmp\nexport HOME=/not-the-real-home\n",
|
||||
)?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/pwd"),
|
||||
args: vec![String::from("-P")],
|
||||
env: HashMap::default(),
|
||||
working_dir: Some(project.display().to_string()),
|
||||
};
|
||||
let exec = stdio_launcher_command(ShellKind::Posix, &helper)?;
|
||||
let mut child = shell_launcher(home.path(), &exec)
|
||||
.current_dir(&project)
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{:?}", output.stderr);
|
||||
assert_eq!(
|
||||
output.stdout,
|
||||
format!("{}\n", project.canonicalize()?.display()).as_bytes()
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_runs_shell_directory_hooks() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
let project = home.path().join("project 'with spaces'");
|
||||
let application = project.join("application");
|
||||
std::fs::create_dir_all(&application)?;
|
||||
let helper = install_helper(home.path())?;
|
||||
let project_path = project.display().to_string();
|
||||
let quoted_project = ShellKind::Posix
|
||||
.try_quote(&project_path)
|
||||
.context("shell quoting")?;
|
||||
std::fs::write(
|
||||
home.path().join(".bashrc"),
|
||||
format!(
|
||||
"cd() {{ builtin cd \"$@\" || return; if [ \"$PWD\" = {quoted_project} ]; then export PROJECT_SECRET=project-only; builtin cd application; else unset PROJECT_SECRET; fi; }}\n"
|
||||
),
|
||||
)?;
|
||||
for (working_dir, expected) in [
|
||||
(
|
||||
Some(project_path.clone()),
|
||||
format!("project-only\n{}\n", application.canonicalize()?.display()),
|
||||
),
|
||||
(
|
||||
None,
|
||||
format!("\n{}\n", home.path().canonicalize()?.display()),
|
||||
),
|
||||
] {
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![
|
||||
String::from("-c"),
|
||||
String::from("printf '%s\\n%s\\n' \"$PROJECT_SECRET\" \"$(pwd -P)\""),
|
||||
],
|
||||
env: HashMap::default(),
|
||||
working_dir: None,
|
||||
};
|
||||
let prefix = match &working_dir {
|
||||
Some(working_dir) => format!(
|
||||
"cd {} && ",
|
||||
ShellKind::Posix
|
||||
.try_quote(working_dir)
|
||||
.context("shell quoting")?
|
||||
),
|
||||
None => String::from("cd && "),
|
||||
};
|
||||
let exec = format!(
|
||||
"{prefix}{}",
|
||||
stdio_launcher_command(ShellKind::Posix, &helper)?
|
||||
);
|
||||
let mut child = shell_launcher(home.path(), &exec)
|
||||
.current_dir(home.path())
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{working_dir:?}: {:?}",
|
||||
output.stderr
|
||||
);
|
||||
assert_eq!(output.stdout, expected.as_bytes(), "{working_dir:?}");
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_runs_scripts_without_shebang() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let binary_directory = directory.path().join("bin");
|
||||
std::fs::create_dir(&binary_directory)?;
|
||||
let script = binary_directory.join("agent-wrapper");
|
||||
for script in [&script, &binary_directory.join("-a")] {
|
||||
std::fs::write(
|
||||
script,
|
||||
"printf '%s|%s|%s\\n' \"$WRAPPER_TOKEN\" \"$1\" \"$(pwd -P)\"\n",
|
||||
)?;
|
||||
std::fs::set_permissions(script, std::fs::Permissions::from_mode(0o755))?;
|
||||
}
|
||||
let stale_directory = directory.path().join("stale");
|
||||
std::fs::create_dir(&stale_directory)?;
|
||||
let stale_script = stale_directory.join("agent-wrapper");
|
||||
std::fs::write(
|
||||
&stale_script,
|
||||
"#!/nonexistent/interpreter\nprintf 'stale\\n'\n",
|
||||
)?;
|
||||
std::fs::set_permissions(&stale_script, std::fs::Permissions::from_mode(0o755))?;
|
||||
let expected = format!(
|
||||
"wrapper-secret|--acp|{}\n",
|
||||
directory.path().canonicalize()?.display()
|
||||
);
|
||||
for program in [
|
||||
script.display().to_string(),
|
||||
String::from("agent-wrapper"),
|
||||
String::from("-a"),
|
||||
] {
|
||||
let descriptor = RemoteCommand {
|
||||
program,
|
||||
args: vec![String::from("--acp")],
|
||||
env: HashMap::from_iter([
|
||||
(
|
||||
String::from("WRAPPER_TOKEN"),
|
||||
String::from("wrapper-secret"),
|
||||
),
|
||||
(
|
||||
String::from("PATH"),
|
||||
format!(
|
||||
"{}:{}:/usr/bin:/bin",
|
||||
stale_directory.display(),
|
||||
binary_directory.display()
|
||||
),
|
||||
),
|
||||
]),
|
||||
working_dir: Some(directory.path().display().to_string()),
|
||||
};
|
||||
let mut child = launcher().env("PATH", "/usr/bin:/bin").spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{}: {:?}",
|
||||
descriptor.program,
|
||||
output.stderr
|
||||
);
|
||||
assert_eq!(output.stdout, expected.as_bytes(), "{}", descriptor.program);
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_matches_native_path_lookup() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let binary_directory = directory.path().join("bin");
|
||||
std::fs::create_dir(&binary_directory)?;
|
||||
let agent = binary_directory.join("agent");
|
||||
std::fs::write(&agent, "#!/bin/sh\nprintf 'found\\n'\n")?;
|
||||
std::fs::set_permissions(&agent, std::fs::Permissions::from_mode(0o755))?;
|
||||
let loop_directory = directory.path().join("loop");
|
||||
std::fs::create_dir(&loop_directory)?;
|
||||
std::os::unix::fs::symlink("agent", loop_directory.join("agent"))?;
|
||||
let binary_directory = binary_directory.as_os_str().as_bytes();
|
||||
let overlong_directory = [
|
||||
directory.path().as_os_str().as_bytes(),
|
||||
b"/",
|
||||
&[b'x'; 300][..],
|
||||
]
|
||||
.concat();
|
||||
for (label, path, must_succeed) in [
|
||||
(
|
||||
"non-UTF-8 entry",
|
||||
[&b"/not-present-\xff:"[..], binary_directory].concat(),
|
||||
true,
|
||||
),
|
||||
(
|
||||
"symlink loop",
|
||||
[
|
||||
loop_directory.as_os_str().as_bytes(),
|
||||
b":",
|
||||
binary_directory,
|
||||
]
|
||||
.concat(),
|
||||
false,
|
||||
),
|
||||
(
|
||||
"overlong entry",
|
||||
[&overlong_directory[..], b":", binary_directory].concat(),
|
||||
false,
|
||||
),
|
||||
] {
|
||||
let path = OsStr::from_bytes(&path);
|
||||
let native = Command::new("/usr/bin/env")
|
||||
.arg("agent")
|
||||
.env_clear()
|
||||
.env("PATH", path)
|
||||
.output()
|
||||
.await?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("agent"),
|
||||
args: Vec::new(),
|
||||
env: HashMap::default(),
|
||||
working_dir: None,
|
||||
};
|
||||
let mut child = launcher().env_clear().env("PATH", path).spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert_eq!(
|
||||
(output.status.success(), output.stdout.clone()),
|
||||
(native.status.success(), native.stdout),
|
||||
"{label}: {:?}",
|
||||
output.stderr
|
||||
);
|
||||
if must_succeed {
|
||||
assert_eq!(output.stdout, b"found\n", "{label}");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_launcher_expands_home_in_shell() -> Result<()> {
|
||||
smol::block_on(async {
|
||||
let home = tempfile::tempdir()?;
|
||||
install_helper(home.path())?;
|
||||
std::fs::write(home.path().join(".bashrc"), "cd /tmp\n")?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/usr/bin/printenv"),
|
||||
args: vec![String::from("LINE\nBREAK")],
|
||||
env: HashMap::from_iter([(String::from("LINE\nBREAK"), String::from("kept"))]),
|
||||
working_dir: None,
|
||||
};
|
||||
let exec = format!(
|
||||
"cd && {}",
|
||||
home_stdio_launcher_command(ShellKind::Posix, None, ".local/share/zed/remote server")?
|
||||
);
|
||||
assert_eq!(
|
||||
exec,
|
||||
"cd && exec \"$HOME\"/'.local/share/zed/remote server' exec"
|
||||
);
|
||||
let mut child = shell_launcher(home.path(), &exec).spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{:?}", output.stderr);
|
||||
assert_eq!(output.stdout, b"kept\n");
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_launcher_quoting_in_tcsh() -> Result<()> {
|
||||
let Some(tcsh) = ["/bin/tcsh", "/usr/bin/tcsh"]
|
||||
.into_iter()
|
||||
.find(|tcsh| std::path::Path::new(tcsh).exists())
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let home = directory.path().join("bang!home");
|
||||
let project = home.join("O'Brien !1 project\\'; /usr/bin/printf INJECTED; true \\'");
|
||||
std::fs::create_dir_all(&project)?;
|
||||
let helper = install_helper(&home)?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![
|
||||
String::from("-c"),
|
||||
String::from("printf '%s\\n%s\\n' \"$AGENT_TOKEN\" \"$(pwd -P)\""),
|
||||
],
|
||||
env: HashMap::from_iter([(String::from("AGENT_TOKEN"), String::from("secret!"))]),
|
||||
working_dir: None,
|
||||
};
|
||||
let expected = format!("secret!\n{}\n", project.canonicalize()?.display());
|
||||
let project_path = project.display().to_string();
|
||||
for setting in [
|
||||
"",
|
||||
"set backslash_quote\n",
|
||||
"set histchars = ''\n",
|
||||
"set backslash_quote\nset histchars = ''\n",
|
||||
] {
|
||||
let exec = format!(
|
||||
"{setting}cd {} && {}",
|
||||
ShellKind::Tcsh
|
||||
.try_quote(&project_path)
|
||||
.context("shell quoting")?,
|
||||
stdio_launcher_command(ShellKind::Tcsh, &helper)?
|
||||
);
|
||||
let remote_shell = [String::from("-f"), String::from("-c"), exec.clone()];
|
||||
let direct = {
|
||||
let mut command = Command::new(tcsh);
|
||||
command.args(&remote_shell);
|
||||
command
|
||||
};
|
||||
let through_local_shell = Command::from(
|
||||
ShellBuilder::new(&Shell::Program(String::from(tcsh)), false)
|
||||
.non_interactive()
|
||||
.build_std_command(Some(String::from(tcsh)), &remote_shell),
|
||||
);
|
||||
for mut command in [direct, through_local_shell] {
|
||||
let mut child = command
|
||||
.env_clear()
|
||||
.env("HOME", &home)
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{exec}: {:?}", output.stderr);
|
||||
assert_eq!(String::from_utf8_lossy(&output.stdout), expected, "{exec}");
|
||||
assert_eq!(output.stderr, b"");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_launcher_expands_home_in_nushell() -> Result<()> {
|
||||
let Some(nu) = ["/opt/homebrew/bin/nu", "/usr/local/bin/nu", "/usr/bin/nu"]
|
||||
.into_iter()
|
||||
.find(|nu| std::path::Path::new(nu).exists())
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let home = directory.path().join("home a^b");
|
||||
let project = home.join("O'Brien project");
|
||||
std::fs::create_dir_all(&project)?;
|
||||
install_helper(&home)?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![
|
||||
String::from("-c"),
|
||||
String::from("printf '%s\\n%s\\n' \"$AGENT_TOKEN\" \"$(pwd -P)\""),
|
||||
],
|
||||
env: HashMap::from_iter([(String::from("AGENT_TOKEN"), String::from("secret!"))]),
|
||||
working_dir: None,
|
||||
};
|
||||
let expected = format!("secret!\n{}\n", project.canonicalize()?.display());
|
||||
let project_path = project.display().to_string();
|
||||
for (working_dir, home_dir) in [
|
||||
(Some("~/O'Brien project"), None),
|
||||
(Some(project_path.as_str()), None),
|
||||
(Some("~/O'Brien project"), Some(home.display().to_string())),
|
||||
] {
|
||||
let exec = format!(
|
||||
"cd {} {} {}",
|
||||
match working_dir.and_then(|working_dir| working_dir.strip_prefix("~/")) {
|
||||
Some(remainder) => home_relative_path(ShellKind::Nushell, Some(remainder))?,
|
||||
None => ShellKind::Nushell
|
||||
.try_quote(working_dir.context("working dir")?)
|
||||
.context("shell quoting")?
|
||||
.into_owned(),
|
||||
},
|
||||
ShellKind::Nushell.sequential_and_commands_separator(),
|
||||
home_stdio_launcher_command(
|
||||
ShellKind::Nushell,
|
||||
home_dir.as_deref(),
|
||||
".local/share/zed/remote server"
|
||||
)?
|
||||
);
|
||||
let mut child = Command::new(nu)
|
||||
.args(["--no-config-file", "-c", &exec])
|
||||
.env_clear()
|
||||
.env("HOME", &home)
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{exec}: {:?}", output.stderr);
|
||||
assert_eq!(String::from_utf8_lossy(&output.stdout), expected, "{exec}");
|
||||
assert_eq!(output.stderr, b"");
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remote_command_launcher_survives_local_nushell() -> Result<()> {
|
||||
let Some(nu) = ["/opt/homebrew/bin/nu", "/usr/local/bin/nu", "/usr/bin/nu"]
|
||||
.into_iter()
|
||||
.find(|nu| std::path::Path::new(nu).exists())
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
smol::block_on(async {
|
||||
let directory = tempfile::tempdir()?;
|
||||
let home = directory.path().join("home$REMOTE_PART");
|
||||
let project = home.join("project");
|
||||
std::fs::create_dir_all(&project)?;
|
||||
install_helper(&home)?;
|
||||
let descriptor = RemoteCommand {
|
||||
program: String::from("/bin/sh"),
|
||||
args: vec![
|
||||
String::from("-c"),
|
||||
String::from("printf '%s\\n%s\\n' \"$AGENT_TOKEN\" \"$(pwd -P)\""),
|
||||
],
|
||||
env: HashMap::from_iter([(String::from("AGENT_TOKEN"), String::from("secret"))]),
|
||||
working_dir: None,
|
||||
};
|
||||
let expected = format!("secret\n{}\n", project.canonicalize()?.display());
|
||||
for home_dir in [None, Some(home.display().to_string())] {
|
||||
let exec = format!(
|
||||
"cd {} && {}",
|
||||
home_relative_path(ShellKind::Posix, Some("project"))?,
|
||||
home_stdio_launcher_command(
|
||||
ShellKind::Posix,
|
||||
home_dir.as_deref(),
|
||||
".local/share/zed/remote server"
|
||||
)?
|
||||
);
|
||||
let remote_shell = [String::from("-c"), exec.clone()];
|
||||
let mut child = Command::from(
|
||||
ShellBuilder::new(&Shell::Program(String::from(nu)), false)
|
||||
.non_interactive()
|
||||
.literal_args()
|
||||
.build_std_command(Some(String::from("/bin/bash")), &remote_shell),
|
||||
)
|
||||
.env_clear()
|
||||
.env("HOME", &home)
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.current_dir(directory.path())
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?;
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.context("missing stdin")?
|
||||
.write_all(&descriptor.encode()?)
|
||||
.await?;
|
||||
let output = child.output().await?;
|
||||
assert!(output.status.success(), "{exec}: {:?}", output.stderr);
|
||||
assert_eq!(String::from_utf8_lossy(&output.stdout), expected, "{exec}");
|
||||
assert_eq!(output.stderr, b"");
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
fn launcher() -> Command {
|
||||
let mut command = Command::new(env!("CARGO_BIN_EXE_remote_server"));
|
||||
command
|
||||
.arg("exec")
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
command
|
||||
}
|
||||
|
||||
fn install_helper(home: &std::path::Path) -> Result<String> {
|
||||
let helper_directory = home.join(".local/share/zed");
|
||||
std::fs::create_dir_all(&helper_directory)?;
|
||||
let helper = helper_directory.join("remote server");
|
||||
std::os::unix::fs::symlink(env!("CARGO_BIN_EXE_remote_server"), &helper)?;
|
||||
Ok(helper.display().to_string())
|
||||
}
|
||||
|
||||
fn shell_launcher(home: &std::path::Path, exec: &str) -> Command {
|
||||
let mut command = Command::new("/bin/bash");
|
||||
command
|
||||
.args(["-i", "-c", exec])
|
||||
.env_clear()
|
||||
.env("HOME", home)
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.env("TERM", "dumb")
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
command
|
||||
}
|
||||
@@ -72,3 +72,6 @@ rand.workspace = true
|
||||
tempfile.workspace = true
|
||||
util_macros.workspace = true
|
||||
path = { workspace = true, features = ["test-support"] }
|
||||
|
||||
[target.'cfg(unix)'.dev-dependencies]
|
||||
which.workspace = true
|
||||
|
||||
+305
-5
@@ -438,12 +438,11 @@ impl ShellKind {
|
||||
ShellKind::PowerShell => Some(Self::quote_powershell(arg)),
|
||||
ShellKind::Pwsh => Some(Self::quote_pwsh(arg)),
|
||||
ShellKind::Cmd => Some(Self::quote_cmd(arg)),
|
||||
ShellKind::Csh | ShellKind::Tcsh => Self::quote_csh(arg),
|
||||
ShellKind::Nushell => Self::quote_nushell(arg),
|
||||
ShellKind::Posix
|
||||
| ShellKind::Csh
|
||||
| ShellKind::Tcsh
|
||||
| ShellKind::Rc
|
||||
| ShellKind::Fish
|
||||
| ShellKind::Nushell
|
||||
| ShellKind::Xonsh
|
||||
| ShellKind::Elvish => shlex::try_quote(arg).ok(),
|
||||
}
|
||||
@@ -585,6 +584,75 @@ impl ShellKind {
|
||||
Cow::Owned(Self::escape_powershell_quotes(arg))
|
||||
}
|
||||
|
||||
pub fn quote_csh(arg: &str) -> Option<Cow<'_, str>> {
|
||||
if arg.contains('\0') {
|
||||
return None;
|
||||
}
|
||||
if Self::is_unquoted_safe(arg) && !arg.starts_with('%') {
|
||||
return Some(Cow::Borrowed(arg));
|
||||
}
|
||||
if arg.is_empty() {
|
||||
return Some(Cow::Borrowed("''"));
|
||||
}
|
||||
let mut quoted = String::with_capacity(arg.len() + 2);
|
||||
let mut in_quotes = false;
|
||||
for character in arg.chars() {
|
||||
match character {
|
||||
'\'' | '!' | '\\' => {
|
||||
if in_quotes {
|
||||
quoted.push('\'');
|
||||
in_quotes = false;
|
||||
}
|
||||
quoted.push('\\');
|
||||
quoted.push(character);
|
||||
}
|
||||
character => {
|
||||
if !in_quotes {
|
||||
quoted.push('\'');
|
||||
in_quotes = true;
|
||||
}
|
||||
if character == '\n' {
|
||||
quoted.push('\\');
|
||||
}
|
||||
quoted.push(character);
|
||||
}
|
||||
}
|
||||
}
|
||||
if in_quotes {
|
||||
quoted.push('\'');
|
||||
}
|
||||
Some(Cow::Owned(quoted))
|
||||
}
|
||||
|
||||
pub fn quote_nushell(arg: &str) -> Option<Cow<'_, str>> {
|
||||
if arg.contains('\0') {
|
||||
return None;
|
||||
}
|
||||
if Self::is_unquoted_safe(arg) {
|
||||
return Some(Cow::Borrowed(arg));
|
||||
}
|
||||
if !arg.contains('\'') {
|
||||
return Some(Cow::Owned(format!("'{arg}'")));
|
||||
}
|
||||
let mut quoted = String::with_capacity(arg.len() + 2);
|
||||
quoted.push('"');
|
||||
for character in arg.chars() {
|
||||
if character == '\\' || character == '"' {
|
||||
quoted.push('\\');
|
||||
}
|
||||
quoted.push(character);
|
||||
}
|
||||
quoted.push('"');
|
||||
Some(Cow::Owned(quoted))
|
||||
}
|
||||
|
||||
fn is_unquoted_safe(arg: &str) -> bool {
|
||||
!arg.is_empty()
|
||||
&& arg
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_alphanumeric() || b"-_./:,+@%".contains(&byte))
|
||||
}
|
||||
|
||||
pub fn quote_cmd(arg: &str) -> Cow<'_, str> {
|
||||
let crt_quoted = Self::quote_windows(arg, true);
|
||||
|
||||
@@ -707,6 +775,8 @@ impl ShellKind {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[cfg(unix)]
|
||||
use crate::shell_builder::ShellBuilder;
|
||||
|
||||
// Examples
|
||||
// WSL
|
||||
@@ -875,7 +945,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("^'uname'").unwrap().into_owned(),
|
||||
"'^'\"'uname\'\"".to_string()
|
||||
"\"^'uname'\"".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind
|
||||
@@ -897,7 +967,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("^'uname a'").unwrap().into_owned(),
|
||||
"'^'\"'uname a'\"".to_string()
|
||||
"\"^'uname a'\"".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind
|
||||
@@ -919,6 +989,236 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_try_quote_csh() {
|
||||
for shell_kind in [ShellKind::Csh, ShellKind::Tcsh] {
|
||||
assert_eq!(shell_kind.try_quote("plain").unwrap(), "plain");
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("--flag=a/b.c").unwrap(),
|
||||
"'--flag=a/b.c'"
|
||||
);
|
||||
assert_eq!(shell_kind.try_quote("=0").unwrap(), "'=0'");
|
||||
assert_eq!(shell_kind.try_quote("%agent").unwrap(), "'%agent'");
|
||||
assert_eq!(shell_kind.try_quote("50%").unwrap(), "50%");
|
||||
assert_eq!(shell_kind.try_quote("").unwrap(), "''");
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("/home/bang!home/x").unwrap(),
|
||||
"'/home/bang'\\!'home/x'"
|
||||
);
|
||||
assert_eq!(shell_kind.try_quote("a\\!b c").unwrap(), "'a'\\\\\\!'b c'");
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("O'Brien!").unwrap(),
|
||||
"'O'\\''Brien'\\!"
|
||||
);
|
||||
assert_eq!(shell_kind.try_quote("!").unwrap(), "\\!");
|
||||
assert_eq!(shell_kind.try_quote("\\'").unwrap(), "\\\\\\'");
|
||||
assert_eq!(
|
||||
shell_kind
|
||||
.try_quote("/tmp/a\\'; echo INJECTED; true \\'")
|
||||
.unwrap(),
|
||||
"'/tmp/a'\\\\\\''; echo INJECTED; true '\\\\\\'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("say \\\"hi\\\"").unwrap(),
|
||||
"'say '\\\\'\"hi'\\\\'\"'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("line\nbreak").unwrap(),
|
||||
"'line\\\nbreak'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("line\rbreak").unwrap(),
|
||||
"'line\rbreak'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("~/*$HOME `id`").unwrap(),
|
||||
"'~/*$HOME `id`'"
|
||||
);
|
||||
assert_eq!(shell_kind.try_quote("nul\0byte"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_try_quote_nushell() {
|
||||
let shell_kind = ShellKind::Nushell;
|
||||
assert_eq!(shell_kind.try_quote("plain").unwrap(), "plain");
|
||||
assert_eq!(shell_kind.try_quote("").unwrap(), "''");
|
||||
assert_eq!(shell_kind.try_quote("=").unwrap(), "'='");
|
||||
assert_eq!(shell_kind.try_quote("=a").unwrap(), "'=a'");
|
||||
assert_eq!(shell_kind.try_quote("+=").unwrap(), "'+='");
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("--flag=a/b.c").unwrap(),
|
||||
"'--flag=a/b.c'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind
|
||||
.try_quote("/home/a^b/.zed_server/server")
|
||||
.unwrap(),
|
||||
"'/home/a^b/.zed_server/server'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("$env.HOME (1 + 1) `id` a\\b").unwrap(),
|
||||
"'$env.HOME (1 + 1) `id` a\\b'"
|
||||
);
|
||||
assert_eq!(
|
||||
shell_kind.try_quote("O'Brien \\ \"x\" $y").unwrap(),
|
||||
"\"O'Brien \\\\ \\\"x\\\" $y\""
|
||||
);
|
||||
assert_eq!(shell_kind.try_quote("nul\0byte"), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_quoted_arguments_survive_real_shells() {
|
||||
let arguments = [
|
||||
"SAFE; /usr/bin/printf INJECTED\r",
|
||||
"/tmp/a\\'; /usr/bin/printf INJECTED; true \\'",
|
||||
"a\\\\b \\\"c\\\" \\'d\\' \\$e \\!f",
|
||||
"line\nbreak",
|
||||
"bang!\nnew\\line",
|
||||
"O'Brien!",
|
||||
"a\\!b",
|
||||
"a\\\\!b",
|
||||
"!1x",
|
||||
"!",
|
||||
"!!",
|
||||
"!$ !* !:1 !-1 !# !?x?",
|
||||
"ending!",
|
||||
"trailing\\",
|
||||
"~/*$HOME `id` $(id) (1 + 1) \"quoted\"",
|
||||
"\t tab # hash",
|
||||
"=",
|
||||
"=a",
|
||||
"=0",
|
||||
"=1",
|
||||
"+=",
|
||||
"-=",
|
||||
"/=",
|
||||
"a=b",
|
||||
"--flag=a/b.c",
|
||||
"1..3",
|
||||
"/home/a^b/.zed_server/server",
|
||||
"钥匙🔑",
|
||||
"",
|
||||
];
|
||||
let csh_settings = [
|
||||
"",
|
||||
"set backslash_quote\n",
|
||||
"set histchars = ''\n",
|
||||
"set histchars = \\!^\n",
|
||||
"set backslash_quote\nset histchars = ''\n",
|
||||
"set backslash_quote\nunset histchars\nset history = 100\n",
|
||||
];
|
||||
let shells = [
|
||||
("tcsh", ShellKind::Tcsh, &["-f"][..], &csh_settings[..]),
|
||||
("csh", ShellKind::Csh, &["-f"][..], &csh_settings[..]),
|
||||
(
|
||||
"nu",
|
||||
ShellKind::Nushell,
|
||||
&["--no-config-file"][..],
|
||||
&[""][..],
|
||||
),
|
||||
];
|
||||
for (shell_name, shell_kind, shell_options, settings) in shells {
|
||||
let Ok(shell) = which::which(shell_name) else {
|
||||
continue;
|
||||
};
|
||||
let shell = shell.to_string_lossy().into_owned();
|
||||
let separator = shell_kind.sequential_and_commands_separator();
|
||||
let printf = shell_kind.prepend_command_prefix("/usr/bin/printf");
|
||||
for (setting, argument) in settings
|
||||
.iter()
|
||||
.flat_map(|setting| arguments.iter().map(move |argument| (*setting, *argument)))
|
||||
{
|
||||
let quoted = shell_kind.try_quote(argument).unwrap();
|
||||
let inner = format!("{setting}cd /{separator} {printf} %s {quoted}");
|
||||
let mut inner_arguments = shell_options.to_vec();
|
||||
inner_arguments.extend(["-c", &inner]);
|
||||
let nested = format!(
|
||||
"{setting}{} {}",
|
||||
shell_kind.prepend_command_prefix(&shell),
|
||||
inner_arguments
|
||||
.iter()
|
||||
.map(|inner_argument| shell_kind.try_quote(inner_argument).unwrap())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
);
|
||||
for script in [inner.clone(), nested] {
|
||||
let output = smol::block_on(
|
||||
smol::process::Command::new(&shell)
|
||||
.args(shell_options)
|
||||
.args(["-c", &script])
|
||||
.env_clear()
|
||||
.env("HOME", "/")
|
||||
.env("PATH", "/usr/bin:/bin")
|
||||
.output(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(
|
||||
output.status.success(),
|
||||
String::from_utf8_lossy(&output.stdout).into_owned(),
|
||||
String::from_utf8_lossy(&output.stderr).into_owned(),
|
||||
),
|
||||
(true, argument.to_owned(), String::new()),
|
||||
"{shell} {script:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn test_quoted_csh_commands_survive_real_shells() {
|
||||
use std::os::unix::fs::PermissionsExt as _;
|
||||
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let binary_directory = directory.path().join("bin");
|
||||
std::fs::create_dir(&binary_directory).unwrap();
|
||||
for program in ["%agent", "50%", "agent"] {
|
||||
let script = binary_directory.join(program);
|
||||
std::fs::write(&script, "#!/bin/sh\nprintf '%s' \"$1\"\n").unwrap();
|
||||
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
}
|
||||
for (shell_name, shell_kind) in [("tcsh", ShellKind::Tcsh), ("csh", ShellKind::Csh)] {
|
||||
let Ok(shell) = which::which(shell_name) else {
|
||||
continue;
|
||||
};
|
||||
for program in ["%agent", "50%", "agent"] {
|
||||
let (shell_program, shell_arguments) =
|
||||
ShellBuilder::new(&Shell::Program(shell.display().to_string()), false)
|
||||
.non_interactive()
|
||||
.literal_args()
|
||||
.build(Some(program.to_owned()), &[String::from("OK")]);
|
||||
let script = shell_arguments.last().unwrap();
|
||||
assert_eq!(
|
||||
script,
|
||||
&format!("{} OK", shell_kind.try_quote(program).unwrap())
|
||||
);
|
||||
let output = smol::block_on(
|
||||
smol::process::Command::new(&shell_program)
|
||||
.arg("-f")
|
||||
.args(&shell_arguments)
|
||||
.env_clear()
|
||||
.env("HOME", "/")
|
||||
.env("PATH", &binary_directory)
|
||||
.output(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(
|
||||
output.status.success(),
|
||||
String::from_utf8_lossy(&output.stdout).into_owned(),
|
||||
String::from_utf8_lossy(&output.stderr).into_owned(),
|
||||
),
|
||||
(true, String::from("OK"), String::new()),
|
||||
"{shell_program} {shell_arguments:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_try_quote_single_quote_paths() {
|
||||
let path_with_quote = r"C:\Temp\O'Brien\repo";
|
||||
|
||||
@@ -12,6 +12,7 @@ pub struct ShellBuilder {
|
||||
interactive: bool,
|
||||
/// Whether to redirect stdin to /dev/null for the spawned command as a subshell.
|
||||
redirect_stdin: bool,
|
||||
substitute_variables: bool,
|
||||
kind: ShellKind,
|
||||
}
|
||||
|
||||
@@ -31,6 +32,7 @@ impl ShellBuilder {
|
||||
interactive: true,
|
||||
kind,
|
||||
redirect_stdin: false,
|
||||
substitute_variables: true,
|
||||
}
|
||||
}
|
||||
pub fn non_interactive(mut self) -> Self {
|
||||
@@ -38,6 +40,11 @@ impl ShellBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn literal_args(mut self) -> Self {
|
||||
self.substitute_variables = false;
|
||||
self
|
||||
}
|
||||
|
||||
/// Returns the label to show in the terminal tab
|
||||
pub fn command_label(&self, command_to_use_in_label: &str) -> String {
|
||||
if command_to_use_in_label.trim().is_empty() {
|
||||
@@ -90,10 +97,14 @@ impl ShellBuilder {
|
||||
};
|
||||
let mut combined_command = task_args.iter().fold(task_command, |mut command, arg| {
|
||||
command.push(' ');
|
||||
let shell_variable = self.kind.to_shell_variable(arg);
|
||||
let shell_variable = if self.substitute_variables {
|
||||
Cow::Owned(self.kind.to_shell_variable(arg))
|
||||
} else {
|
||||
Cow::Borrowed(arg.as_str())
|
||||
};
|
||||
command.push_str(&match self.kind.try_quote(&shell_variable) {
|
||||
Some(shell_variable) => shell_variable,
|
||||
None => Cow::Owned(shell_variable),
|
||||
None => shell_variable,
|
||||
});
|
||||
command
|
||||
});
|
||||
@@ -272,6 +283,31 @@ mod test {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_literal_args_skip_variable_substitution() {
|
||||
let shell = Shell::Program("nu".to_owned());
|
||||
let (program, args) = ShellBuilder::new(&shell, false)
|
||||
.non_interactive()
|
||||
.literal_args()
|
||||
.build(
|
||||
Some("ssh".into()),
|
||||
&[
|
||||
"host".to_string(),
|
||||
"cd \"$HOME\"/project && exec \"$HOME\"/'a b' exec".to_string(),
|
||||
"${braced}".to_string(),
|
||||
],
|
||||
);
|
||||
|
||||
assert_eq!(program, "nu");
|
||||
assert_eq!(
|
||||
args,
|
||||
vec![
|
||||
"-c",
|
||||
"ssh host \"cd \\\"$HOME\\\"/project && exec \\\"$HOME\\\"/'a b' exec\" '${braced}'"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn redirect_stdin_to_dev_null_precedence() {
|
||||
let shell = Shell::Program("nu".to_owned());
|
||||
|
||||
Reference in New Issue
Block a user