1. 1//! Screen 3: Remote Administration & Settings Cockpit.
2. 2//!
3. 3//! All data is real:
4. 4//! - Workspace from `/health` cwd
5. 5//! - Permission mode from `/health` + PATCH via server API
6. 6//! - MCP inventory from `GET /config/mcp`
7. 7//! - Gateway/bot status from `GET /gateway/bots` + `GET /gateway/approvals`
8. 8//! - Pending approval queue from SSE `ApprovalRequested` events
9. 9
10. 10use ratatui::buffer::Buffer;
11. 11use ratatui::layout::{Constraint, Direction, Layout, Rect};
12. 12use ratatui::style::Modifier;
13. 13use ratatui::text::{Line, Span};
14. 14use ratatui::widgets::{Block, Borders, Paragraph, Widget};
15. 15
16. 16use crate::api::{GatewayApprovals, HealthReport, McpServerDef, SessionInfo};
17. 17use crate::app::{DeckFocus, McpRow};
18. 18use crate::theme::{Symbols, Theme};
19. 19use std::collections::HashMap;
20. 20
21. 21pub struct AdminView<'a> {
22. 22 pub theme: &'a Theme,
23. 23 pub selected_permission_mode: &'a str,
24. 24 pub approval_mode: &'a str,
25. 25 pub workspace_name: &'a str,
26. 26 pub deck_focus: DeckFocus,
27. 27 pub pending_chat_status: Option<bool>,
28. 28 pub mcp_rows: &'a [McpRow],
29. 29 pub mcp_servers: &'a HashMap<String, McpServerDef>,
30. 30 pub gateway: &'a GatewayApprovals,
31. 31 pub sessions: &'a [SessionInfo],
32. 32 pub pending_chats: &'a [crate::app::PendingChatEntry],
33. 33 pub health: &'a HealthReport,
34. 34 pub connected: bool,
35. 35}
36. 36
37. 37impl<'a> Widget for AdminView<'a> {
38. 38 fn render(self, area: Rect, buf: &mut Buffer) {
39. 39 let left_border = if self.deck_focus == DeckFocus::Left {
40. 40 self.theme.style_border_focus()
41. 41 } else {
42. 42 self.theme.style_border()
43. 43 };
44. 44 let right_border = if self.deck_focus == DeckFocus::Right {
45. 45 self.theme.style_border_focus()
46. 46 } else {
47. 47 self.theme.style_border()
48. 48 };
49. 49
50. 50 let deck_chunks = Layout::default()
51. 51 .direction(Direction::Horizontal)
52. 52 .constraints([Constraint::Percentage(60), Constraint::Percentage(40)])
53. 53 .split(area);
54. 54
55. 55 // -------------------------------------------------------------
56. 56 // LEFT DECK: CorePool Workspaces & Security Engine
57. 57 // -------------------------------------------------------------
58. 58 let left_chunks = Layout::default()
59. 59 .direction(Direction::Vertical)
60. 60 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
61. 61 .split(deck_chunks[0]);
62. 62
63. 63 // CorePool Workspaces — real from sessions/health
64. 64 let ws_lines: Vec<Line> = {
65. 65 let mut lines = vec![Line::from(vec![Span::styled(
66. 66 format!(" {} {} ", Symbols::CARET_EXPANDED, self.workspace_name),
67. 67 self.theme.style_accent().add_modifier(Modifier::BOLD),
68. 68 )])];
69. 69 let session_count = self.sessions.len();
70. 70 lines.push(Line::from(vec![
71. 71 Span::styled(" sessions/ ", self.theme.style_card()),
72. 72 Span::styled(
73. 73 format!("[{} active]", session_count),
74. 74 self.theme.style_info(),
75. 75 ),
76. 76 ]));
77. 77 for s in self.sessions.iter().take(3) {
78. 78 lines.push(Line::from(vec![
79. 79 Span::styled(
80. 80 format!(" ├── {} ", s.session_id),
81. 81 self.theme.style_card(),
82. 82 ),
83. 83 Span::styled(
84. 84 format!("[{}]", s.status()),
85. 85 if s.status() == "active" {
86. 86 self.theme.style_ok()
87. 87 } else {
88. 88 self.theme.style_card()
89. 89 },
90. 90 ),
91. 91 ]));
92. 92 }
93. 93 lines
94. 94 };
95. 95
96. 96 let ws_block = Block::default()
97. 97 .borders(Borders::ALL)
98. 98 .border_style(left_border)
99. 99 .title(" CorePool Multi-Tenant Workspaces [Tab] ")
100. 100 .title_style(self.theme.style_card());
101. 101
102. 102 Paragraph::new(ws_lines)
103. 103 .block(ws_block)
104. 104 .render(left_chunks[0], buf);
105. 105
106. 106 // Security Engine — real permission mode from health
107. 107 let perm_lines = vec![
108. 108 Line::from(vec![Span::styled(
109. 109 "PERMISSION MODES: ",
110. 110 self.theme.style_card().add_modifier(Modifier::BOLD),
111. 111 )]),
112. 112 Line::from(vec![
113. 113 Span::styled(
114. 114 format!(
115. 115 " {} [ WorkspaceWrite ] ",
116. 116 if self.selected_permission_mode == "WorkspaceWrite" {
117. 117 Symbols::STATUS_ACTIVE
118. 118 } else {
119. 119 Symbols::STATUS_IDLE
120. 120 }
121. 121 ),
122. 122 if self.selected_permission_mode == "WorkspaceWrite" {
123. 123 self.theme.style_ok().add_modifier(Modifier::BOLD)
124. 124 } else {
125. 125 self.theme.style_card()
126. 126 },
127. 127 ),
128. 128 Span::styled(
129. 129 "(Permits workspace reads & edits; escapes denied)",
130. 130 self.theme.style_card().add_modifier(Modifier::DIM),
131. 131 ),
132. 132 ]),
133. 133 Line::from(vec![
134. 134 Span::styled(
135. 135 format!(
136. 136 " {} [ ReadOnly ] ",
137. 137 if self.selected_permission_mode == "ReadOnly" {
138. 138 Symbols::STATUS_ACTIVE
139. 139 } else {
140. 140 Symbols::STATUS_IDLE
141. 141 }
142. 142 ),
143. 143 self.theme.style_card(),
144. 144 ),
145. 145 Span::styled(
146. 146 "(Inspection only; all writes fail-closed)",
147. 147 self.theme.style_card().add_modifier(Modifier::DIM),
148. 148 ),
149. 149 ]),
150. 150 Line::from(vec![
151. 151 Span::styled(
152. 152 format!(
153. 153 " {} [ FullAccess ] ",
154. 154 if self.selected_permission_mode == "FullAccess" {
155. 155 Symbols::STATUS_ACTIVE
156. 156 } else {
157. 157 Symbols::STATUS_IDLE
158. 158 }
159. 159 ),
160. 160 self.theme.style_card(),
161. 161 ),
162. 162 Span::styled(
163. 163 "(Human trust decision; unconstrained execution)",
164. 164 self.theme.style_card().add_modifier(Modifier::DIM),
165. 165 ),
166. 166 ]),
167. 167 Line::from(vec![
168. 168 Span::styled(
169. 169 "APPROVALS POLICY: ",
170. 170 self.theme.style_card().add_modifier(Modifier::BOLD),
171. 171 ),
172. 172 Span::styled(
173. 173 format!(
174. 174 " [ {} Ask ] [ {} AutoApprove ]",
175. 175 if self.approval_mode == "Ask" {
176. 176 Symbols::STATUS_ACTIVE
177. 177 } else {
178. 178 Symbols::STATUS_IDLE
179. 179 },
180. 180 if self.approval_mode == "AutoApprove" {
181. 181 Symbols::STATUS_ACTIVE
182. 182 } else {
183. 183 Symbols::STATUS_IDLE
184. 184 }
185. 185 ),
186. 186 self.theme.style_accent(),
187. 187 ),
188. 188 ]),
189. 189 ];
190. 190
191. 191 let perm_block = Block::default()
192. 192 .borders(Borders::ALL)
193. 193 .border_style(left_border)
194. 194 .title(format!(
195. 195 " {} Security & Permissions Engine ",
196. 196 Symbols::STATUS_ACTIVE
197. 197 ))
198. 198 .title_style(self.theme.style_accent());
199. 199
200. 200 Paragraph::new(perm_lines)
201. 201 .block(perm_block)
202. 202 .render(left_chunks[1], buf);
203. 203
204. 204 // -------------------------------------------------------------
205. 205 // RIGHT DECK: MCP Servers, Channel Gateways, Pending Chat Queue
206. 206 // -------------------------------------------------------------
207. 207 let right_chunks = Layout::default()
208. 208 .direction(Direction::Vertical)
209. 209 .constraints([
210. 210 Constraint::Length(7),
211. 211 Constraint::Length(5),
212. 212 Constraint::Min(6),
213. 213 ])
214. 214 .split(deck_chunks[1]);
215. 215
216. 216 // MCP Server Inventory — real from /config/mcp
217. 217 let mcp_lines: Vec<Line> = if self.mcp_rows.is_empty() {
218. 218 vec![
219. 219 Line::from(vec![Span::styled(
220. 220 "SERVER NAME TOOLS MEMORY STATUS",
221. 221 self.theme.style_card().add_modifier(Modifier::BOLD),
222. 222 )]),
223. 223 Line::from(vec![Span::styled(
224. 224 "(no MCP servers configured)",
225. 225 self.theme.style_card().add_modifier(Modifier::DIM),
226. 226 )]),
227. 227 ]
228. 228 } else {
229. 229 let mut lines = vec![Line::from(vec![Span::styled(
230. 230 "SERVER NAME TOOLS MEMORY STATUS",
231. 231 self.theme.style_card().add_modifier(Modifier::BOLD),
232. 232 )])];
233. 233 for row in self.mcp_rows {
234. 234 lines.push(Line::from(vec![
235. 235 Span::styled(format!("{:<14} ", row.name), self.theme.style_card()),
236. 236 Span::styled(format!("{:<8} ", row.tool_count), self.theme.style_card()),
237. 237 Span::styled(
238. 238 format!("{:<5.1}GB ", row.memory_mb),
239. 239 self.theme.style_card(),
240. 240 ),
241. 241 Span::styled(
242. 242 match row.status {
243. 243 crate::app::McpStatus::Ok => "OK",
244. 244 crate::app::McpStatus::Error => "ERR",
245. 245 crate::app::McpStatus::Starting => "…",
246. 246 },
247. 247 match row.status {
248. 248 crate::app::McpStatus::Ok => self.theme.style_ok(),
249. 249 crate::app::McpStatus::Error => self.theme.style_danger(),
250. 250 crate::app::McpStatus::Starting => self.theme.style_warn(),
251. 251 },
252. 252 ),
253. 253 ]));
254. 254 }
255. 255 lines
256. 256 };
257. 257
258. 258 let mcp_block = Block::default()
259. 259 .borders(Borders::ALL)
260. 260 .border_style(right_border)
261. 261 .title(" MCP Server Inventory ")
262. 262 .title_style(self.theme.style_card());
263. 263
264. 264 Paragraph::new(mcp_lines)
265. 265 .block(mcp_block)
266. 266 .render(right_chunks[0], buf);
267. 267
268. 268 // Channel Gateways — real from gateway approvals/bots data
269. 269 let gw_lines: Vec<Line> = {
270. 270 let mode = if self.gateway.enabled {
271. 271 "ENABLED"
272. 272 } else {
273. 273 "DISABLED"
274. 274 };
275. 275 let mode_style = if self.gateway.enabled {
276. 276 self.theme.style_ok()
277. 277 } else {
278. 278 self.theme.style_warn()
279. 279 };
280. 280 vec![
281. 281 Line::from(vec![
282. 282 Span::styled("Mode: ", self.theme.style_card()),
283. 283 Span::styled(mode, mode_style.add_modifier(Modifier::BOLD)),
284. 284 ]),
285. 285 Line::from(vec![
286. 286 Span::styled("Approver: ", self.theme.style_card()),
287. 287 Span::styled(
288. 288 self.gateway.approver.clone().unwrap_or("(none)".into()),
289. 289 self.theme.style_card(),
290. 290 ),
291. 291 ]),
292. 292 Line::from(vec![
293. 293 Span::styled("Forwarding: ", self.theme.style_card()),
294. 294 Span::styled(
295. 295 format!(
296. 296 "{} ({}s)",
297. 297 if self.gateway.forwarding { "ON" } else { "OFF" },
298. 298 self.gateway.timeout_secs
299. 299 ),
300. 300 self.theme.style_info(),
301. 301 ),
302. 302 ]),
303. 303 ]
304. 304 };
305. 305
306. 306 let gw_block = Block::default()
307. 307 .borders(Borders::ALL)
308. 308 .border_style(right_border)
309. 309 .title(" Channel Gateways ")
310. 310 .title_style(self.theme.style_card());
311. 311
312. 312 Paragraph::new(gw_lines)
313. 313 .block(gw_block)
314. 314 .render(right_chunks[1], buf);
315. 315
316. 316 // Pending Authorization Queue — real from pending_chats (SSE-derived)
317. 317 let action_pill = match self.pending_chat_status {
318. 318 None => Line::from(vec![
319. 319 Span::styled(" [ [y] Approve ] ", self.theme.style_tab_active()),
320. 320 Span::raw(" "),
321. 321 Span::styled(
322. 322 " [ [d] Deny ] ",
323. 323 self.theme.style_card().add_modifier(Modifier::BOLD),
324. 324 ),
325. 325 ]),
326. 326 Some(true) => Line::from(vec![Span::styled(
327. 327 " [ ✓ APPROVED & ALLOWED ] ",
328. 328 self.theme.style_ok().add_modifier(Modifier::BOLD),
329. 329 )]),
330. 330 Some(false) => Line::from(vec![Span::styled(
331. 331 " [ ✗ DENIED & BLOCKED ] ",
332. 332 self.theme.style_danger().add_modifier(Modifier::BOLD),
333. 333 )]),
334. 334 };
335. 335
336. 336 let queue_lines: Vec<Line> = if self.pending_chats.is_empty() {
337. 337 vec![
338. 338 Line::from(vec![Span::styled(
339. 339 "INBOUND USER: ",
340. 340 self.theme.style_card(),
341. 341 )]),
342. 342 Line::from(vec![Span::styled(
343. 343 "(no pending approvals)",
344. 344 self.theme.style_card().add_modifier(Modifier::DIM),
345. 345 )]),
346. 346 action_pill,
347. 347 ]
348. 348 } else {
349. 349 let chat = &self.pending_chats[0];
350. 350 vec![
351. 351 Line::from(vec![
352. 352 Span::styled("INBOUND USER: ", self.theme.style_card()),
353. 353 Span::styled(
354. 354 format!("{} ({})", chat.sender, chat.surface),
355. 355 self.theme.style_accent().add_modifier(Modifier::BOLD),
356. 356 ),
357. 357 ]),
358. 358 Line::from(vec![
359. 359 Span::styled("PROVENANCE: ", self.theme.style_card()),
360. 360 Span::styled(&chat.preview, self.theme.style_card()),
361. 361 ]),
362. 362 action_pill,
363. 363 ]
364. 364 };
365. 365
366. 366 let queue_block = Block::default()
367. 367 .borders(Borders::ALL)
368. 368 .border_style(right_border)
369. 369 .title(" Pending Chat Authorization Queue [!] ")
370. 370 .title_style(self.theme.style_accent());
371. 371
372. 372 Paragraph::new(queue_lines)
373. 373 .block(queue_block)
374. 374 .render(right_chunks[2], buf);
375. 375 }
376. 376}
377. 377