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
127
128
129
130
131
132
133
134
|
use super::*;
impl HeadlessServer {
pub(super) fn handle_client_shell_endpoint_request(
&mut self,
client_id: u64,
boot_id: String,
mut request: Box<api::schema::Request>,
) -> bool {
let Some(client) = self.clients.get(&client_id) else {
return false;
};
if !matches!(client.mode, ClientConnectionMode::ClientShell) {
self.remove_client_and_resize_if_needed(client_id);
return true;
}
let request_id = request.id.clone();
if !crate::server::client_commands::supports_client_shell_method(&request.method) {
let message = crate::server::client_commands::error_message(
boot_id,
request_id,
"unsupported_endpoint_command",
"this method is not available through the client shell command lane",
);
self.send_to_client(client_id, message);
return false;
}
if boot_id != self.client_shell_boot_id {
let message = crate::server::client_commands::error_message(
boot_id,
request_id,
"stale_boot",
"endpoint command targeted an earlier server boot",
);
self.send_to_client(client_id, message);
return false;
}
let surface_active = client.shell_surface_active;
if let api::schema::Method::ClientShellSurfaceSet(params) = &request.method {
let Some((changed, projection_revision)) =
self.set_client_shell_surface_active(client_id, params.active)
else {
return false;
};
self.send_to_client(
client_id,
crate::server::client_commands::success_message_with_result(
boot_id,
request_id,
api::schema::ResponseResult::ClientShellSurfaceSet {
active: params.active,
projection_revision,
},
),
);
return changed;
}
if client.shell_endpoint_command_in_flight {
let message = crate::server::client_commands::error_message(
boot_id,
request_id,
"endpoint_busy",
"this endpoint is still processing another command",
);
self.send_to_client(client_id, message);
return false;
}
if !surface_active {
let message = crate::server::client_commands::error_message(
boot_id,
request_id,
"surface_inactive",
"this method requires an active client shell surface",
);
self.send_to_client(client_id, message);
return false;
}
let api_request_id = format!(
"endpoint:{}:{client_id}:{request_id}",
self.client_shell_boot_id
);
request.id = api_request_id.clone();
let (respond_to, response_rx) = std::sync::mpsc::channel();
if let Err(err) = crate::server::client_commands::spawn_response_waiter(
client_id,
boot_id.clone(),
request_id.clone(),
response_rx,
self.server_event_tx.clone(),
) {
let message = crate::server::client_commands::error_message(
boot_id,
request_id,
"server_unavailable",
format!("failed to start endpoint response bridge: {err}"),
);
self.send_to_client(client_id, message);
return false;
}
if let Some(client) = self.clients.get_mut(&client_id) {
client.shell_endpoint_command_in_flight = true;
// A later source restore has a new projection revision. Keep this request's lease
// so a delayed worktree response cannot focus a pane after endpoint switching.
client.shell_endpoint_command_surface_revision = Some(client.shell_projection_revision);
let deferred_worktree = matches!(
&request.method,
api::schema::Method::WorktreeCreate(_)
| api::schema::Method::WorktreeRemove(_)
| api::schema::Method::WorktreeList(_)
| api::schema::Method::WorktreeOpen(_)
);
let deferred_navigation = match &request.method {
api::schema::Method::WorktreeCreate(params) => params.focus,
api::schema::Method::WorktreeOpen(params) => params.focus,
_ => false,
};
client.shell_deferred_navigation_request_id =
deferred_worktree.then(|| api_request_id.clone());
client.shell_deferred_navigation_response = deferred_navigation.then(Vec::new);
}
let foreground_changed = self.promote_client_to_foreground(client_id);
foreground_changed
| self.handle_client_shell_api_request(
client_id,
api::ApiRequestMessage {
request: *request,
respond_to,
response_write_complete: None,
stream_active: None,
},
)
}
}
|
