1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
pub(crate) const REATTACH_COMMAND_ENV_VAR: &str = "HERDR_REATTACH_COMMAND";
pub(crate) const REMOTE_KEYBINDINGS_ENV_VAR: &str = "HERDR_REMOTE_KEYBINDINGS";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum RemoteKeybindings {
Local,
Server,
}
impl RemoteKeybindings {
pub(super) fn parse(value: &str) -> Result<Self, String> {
match value {
"local" => Ok(Self::Local),
"server" => Ok(Self::Server),
_ => Err("--remote-keybindings must be 'local' or 'server'".to_string()),
}
}
pub(super) fn as_str(self) -> &'static str {
match self {
Self::Local => "local",
Self::Server => "server",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct RemoteLaunch {
pub(crate) target: String,
pub(crate) keybindings: RemoteKeybindings,
pub(crate) live_handoff: bool,
}
pub(crate) fn extract_remote_args(
args: &[String],
) -> Result<(Vec<String>, Option<RemoteLaunch>), String> {
let mut cleaned = Vec::with_capacity(args.len());
if let Some(program) = args.first() {
cleaned.push(program.clone());
}
let mut remote_target = None;
let mut keybindings = RemoteKeybindings::Local;
let mut keybindings_seen = false;
let mut live_handoff = false;
let mut index = 1;
while index < args.len() {
let arg = &args[index];
if arg == "--" {
cleaned.extend_from_slice(&args[index..]);
break;
}
if arg == "--handoff" {
live_handoff = true;
index += 1;
continue;
}
if arg == "--remote" {
if remote_target.is_some() {
return Err("--remote can only be specified once".to_string());
}
let Some(value) = args.get(index + 1) else {
return Err("missing value for --remote".to_string());
};
remote_target = Some(validate_remote_target(value)?.to_owned());
index += 2;
continue;
}
if let Some(value) = arg.strip_prefix("--remote=") {
if remote_target.is_some() {
return Err("--remote can only be specified once".to_string());
}
remote_target = Some(validate_remote_target(value)?.to_owned());
index += 1;
continue;
}
if arg == "--remote-keybindings" {
if keybindings_seen {
return Err("--remote-keybindings can only be specified once".to_string());
}
let Some(value) = args.get(index + 1) else {
return Err("missing value for --remote-keybindings".to_string());
};
keybindings = RemoteKeybindings::parse(value)?;
keybindings_seen = true;
index += 2;
continue;
}
if let Some(value) = arg.strip_prefix("--remote-keybindings=") {
if keybindings_seen {
return Err("--remote-keybindings can only be specified once".to_string());
}
keybindings = RemoteKeybindings::parse(value)?;
keybindings_seen = true;
index += 1;
continue;
}
cleaned.push(arg.clone());
index += 1;
}
let remote = remote_target.map(|target| RemoteLaunch {
target,
keybindings,
live_handoff,
});
if remote.is_none() && keybindings_seen {
return Err("--remote-keybindings requires --remote".to_string());
}
if remote.is_none() && live_handoff {
cleaned.push("--handoff".to_string());
}
Ok((cleaned, remote))
}
pub(crate) fn validate_remote_target(target: &str) -> Result<&str, String> {
if target.is_empty() {
return Err("missing value for --remote".to_string());
}
if target.starts_with('-') {
return Err("--remote target must not start with '-'".to_string());
}
Ok(target)
}
|
