1use super::{
2 Actor, DEVELOPMENT_SCHEMA_VERSION, DevelopmentError, DevelopmentEvent, DevelopmentEventKind,
3 DevelopmentResult, LocalHarness, ProjectDiff, ProjectWorkspace, Timeline, ToolAuthorization,
4 ToolCall,
5};
6use base64::Engine as _;
7use serde::{Deserialize, Serialize};
8use std::{
9 collections::BTreeMap,
10 fs::{self, OpenOptions},
11 io::{Read, Write},
12 net::{SocketAddr, TcpListener, TcpStream},
13 path::{Path, PathBuf},
14 sync::{
15 Arc,
16 atomic::{AtomicBool, Ordering},
17 },
18 thread::{self, JoinHandle},
19 time::{Duration, Instant, SystemTime, UNIX_EPOCH},
20};
21
22pub const MAX_RESIDENT_SESSIONS: usize = 8;
23pub const DEFAULT_SESSION_IDLE_TIMEOUT: Duration = Duration::from_secs(30 * 60);
24pub const MAX_ATTENTION_ITEMS: usize = 32;
25pub const MAX_VERIFICATION_CHECKS: usize = 16;
26
27#[derive(Debug)]
28struct ResidentEntry {
29 workspace: ProjectWorkspace,
30 harness: LocalHarness,
31 last_used: Instant,
32}
33
34#[derive(Debug)]
35pub struct ResidentDevelopmentSessions {
36 entries: BTreeMap<PathBuf, ResidentEntry>,
37 capacity: usize,
38 idle_timeout: Duration,
39}
40
41impl Default for ResidentDevelopmentSessions {
42 fn default() -> Self {
43 Self::new(MAX_RESIDENT_SESSIONS, DEFAULT_SESSION_IDLE_TIMEOUT)
44 }
45}
46
47impl ResidentDevelopmentSessions {
48 pub fn new(capacity: usize, idle_timeout: Duration) -> Self {
49 Self {
50 entries: BTreeMap::new(),
51 capacity: capacity.clamp(1, MAX_RESIDENT_SESSIONS),
52 idle_timeout,
53 }
54 }
55
56 pub fn with_workspace<T>(
57 &mut self,
58 root: impl AsRef<Path>,
59 operation: impl FnOnce(&mut ProjectWorkspace) -> DevelopmentResult<T>,
60 ) -> DevelopmentResult<T> {
61 self.with_runtime(root, |workspace, _| operation(workspace))
62 }
63
64 pub fn with_runtime<T>(
65 &mut self,
66 root: impl AsRef<Path>,
67 operation: impl FnOnce(&mut ProjectWorkspace, &mut LocalHarness) -> DevelopmentResult<T>,
68 ) -> DevelopmentResult<T> {
69 let root = super::project::canonical_root(root.as_ref())?;
70 self.prune_idle();
71 if !self.entries.contains_key(&root) {
72 self.evict_lru_if_full();
73 self.entries.insert(
74 root.clone(),
75 ResidentEntry {
76 workspace: ProjectWorkspace::open(&root)?,
77 harness: LocalHarness::default(),
78 last_used: Instant::now(),
79 },
80 );
81 }
82 let entry = self
83 .entries
84 .get_mut(&root)
85 .expect("resident entry inserted");
86 entry.last_used = Instant::now();
87 operation(&mut entry.workspace, &mut entry.harness)
88 }
89
90 pub fn contains(&mut self, root: impl AsRef<Path>) -> bool {
91 self.prune_idle();
92 super::project::canonical_root(root.as_ref())
93 .ok()
94 .is_some_and(|root| self.entries.contains_key(&root))
95 }
96
97 pub fn len(&self) -> usize {
98 self.entries.len()
99 }
100
101 pub fn is_empty(&self) -> bool {
102 self.entries.is_empty()
103 }
104
105 pub fn capacity(&self) -> usize {
106 self.capacity
107 }
108
109 pub fn detach(&mut self, root: impl AsRef<Path>) -> DevelopmentResult<bool> {
110 let root = super::project::canonical_root(root.as_ref())?;
111 Ok(self.entries.remove(&root).is_some())
112 }
113
114 pub fn roots(&self) -> Vec<PathBuf> {
115 self.entries.keys().cloned().collect()
116 }
117
118 fn prune_idle(&mut self) {
119 let now = Instant::now();
120 self.entries.retain(|_, entry| {
121 let has_running_process = entry
122 .workspace
123 .processes()
124 .list()
125 .iter()
126 .any(|process| matches!(process.state, super::ProcessState::Running));
127 has_running_process || now.duration_since(entry.last_used) < self.idle_timeout
128 });
129 }
130
131 fn evict_lru_if_full(&mut self) {
132 if self.entries.len() < self.capacity {
133 return;
134 }
135 if let Some(root) = self
136 .entries
137 .iter()
138 .min_by_key(|(_, entry)| entry.last_used)
139 .map(|(root, _)| root.clone())
140 {
141 self.entries.remove(&root);
142 }
143 }
144}
145
146#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
147#[serde(rename_all = "camelCase")]
148pub struct ReconnectCapsule {
149 pub schema_version: String,
150 pub project_root: String,
151 pub event_cursor: Option<String>,
152 pub mobile_view: Option<String>,
153 #[serde(default, skip_serializing_if = "Option::is_none")]
154 pub mobile_scroll: Option<u16>,
155 pub browser_target_id: Option<String>,
156 pub browser_revision: Option<u64>,
157 pub pending_attention: Option<String>,
158 pub live_mode: Option<String>,
159 pub live_quality: Option<String>,
160 pub saved_at_ms: u64,
161}
162
163impl ReconnectCapsule {
164 pub fn new(project_root: impl AsRef<Path>) -> DevelopmentResult<Self> {
165 let root = super::project::canonical_root(project_root.as_ref())?;
166 Ok(Self {
167 schema_version: DEVELOPMENT_SCHEMA_VERSION.into(),
168 project_root: root.display().to_string(),
169 event_cursor: None,
170 mobile_view: None,
171 mobile_scroll: None,
172 browser_target_id: None,
173 browser_revision: None,
174 pending_attention: None,
175 live_mode: None,
176 live_quality: None,
177 saved_at_ms: now_ms(),
178 })
179 }
180
181 pub fn validate(&self) -> DevelopmentResult<()> {
182 if self.schema_version != DEVELOPMENT_SCHEMA_VERSION {
183 return Err(DevelopmentError::InvalidInput(
184 "unsupported reconnect capsule schema".into(),
185 ));
186 }
187 for (name, value, limit) in [
188 ("projectRoot", Some(self.project_root.as_str()), 4096),
189 ("eventCursor", self.event_cursor.as_deref(), 128),
190 ("mobileView", self.mobile_view.as_deref(), 32),
191 ("browserTargetId", self.browser_target_id.as_deref(), 128),
192 ("pendingAttention", self.pending_attention.as_deref(), 256),
193 ("liveMode", self.live_mode.as_deref(), 32),
194 ("liveQuality", self.live_quality.as_deref(), 32),
195 ] {
196 if value.is_some_and(|value| value.len() > limit) {
197 return Err(DevelopmentError::InvalidInput(format!(
198 "{name} exceeds the {limit} byte reconnect capsule limit"
199 )));
200 }
201 }
202 if self.mobile_view.as_deref().is_some_and(|value| {
203 !matches!(
204 value,
205 "home"
206 | "overview"
207 | "agent"
208 | "app"
209 | "browser"
210 | "diff"
211 | "project"
212 | "process"
213 | "logs"
214 )
215 }) {
216 return Err(DevelopmentError::InvalidInput(
217 "reconnect capsule mobileView is not recognized".into(),
218 ));
219 }
220 if self
221 .live_mode
222 .as_deref()
223 .is_some_and(|value| !matches!(value, "off" | "auto" | "on"))
224 {
225 return Err(DevelopmentError::InvalidInput(
226 "reconnect capsule liveMode is not recognized".into(),
227 ));
228 }
229 if self
230 .live_quality
231 .as_deref()
232 .is_some_and(|value| !matches!(value, "auto" | "data" | "balanced" | "smooth"))
233 {
234 return Err(DevelopmentError::InvalidInput(
235 "reconnect capsule liveQuality is not recognized".into(),
236 ));
237 }
238 let root = super::project::canonical_root(Path::new(&self.project_root))?;
239 if root != Path::new(&self.project_root) {
240 return Err(DevelopmentError::InvalidInput(
241 "reconnect capsule project root is not canonical".into(),
242 ));
243 }
244 Ok(())
245 }
246}
247
248pub struct ReconnectCapsuleStore;
249
250impl ReconnectCapsuleStore {
251 pub fn save(capsule: &ReconnectCapsule) -> DevelopmentResult<PathBuf> {
252 capsule.validate()?;
253 let path = capsule_path(Path::new(&capsule.project_root))?;
254 if let Some(parent) = path.parent() {
255 fs::create_dir_all(parent)?;
256 }
257 let temporary = path.with_extension(format!("json.tmp-{}", std::process::id()));
258 let mut file = OpenOptions::new()
259 .create_new(true)
260 .write(true)
261 .open(&temporary)?;
262 serde_json::to_writer_pretty(&mut file, capsule)?;
263 file.write_all(b"\n")?;
264 file.sync_all()?;
265 if let Err(error) = fs::rename(&temporary, &path) {
266 let _ = fs::remove_file(&temporary);
267 return Err(error.into());
268 }
269 Ok(path)
270 }
271
272 pub fn load(root: impl AsRef<Path>) -> DevelopmentResult<Option<ReconnectCapsule>> {
273 let path = capsule_path(root.as_ref())?;
274 if !path.is_file() {
275 return Ok(None);
276 }
277 let metadata = fs::metadata(&path)?;
278 if metadata.len() > 16 * 1024 {
279 return Err(DevelopmentError::InvalidInput(
280 "reconnect capsule exceeds 16384 bytes".into(),
281 ));
282 }
283 let capsule = serde_json::from_slice::<ReconnectCapsule>(&fs::read(path)?)?;
284 capsule.validate()?;
285 Ok(Some(capsule))
286 }
287
288 pub fn clear(root: impl AsRef<Path>) -> DevelopmentResult<bool> {
289 let path = capsule_path(root.as_ref())?;
290 if !path.exists() {
291 return Ok(false);
292 }
293 fs::remove_file(path)?;
294 Ok(true)
295 }
296}
297
298fn capsule_path(root: &Path) -> DevelopmentResult<PathBuf> {
299 let root = super::project::canonical_root(root)?;
300 Ok(Timeline::for_project(&root)?
301 .path()
302 .with_file_name("reconnect-capsule.json"))
303}
304
305#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
306#[serde(rename_all = "camelCase")]
307pub enum AttentionState {
308 NeedsAttention,
309 Running,
310 Recent,
311}
312
313#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
314#[serde(rename_all = "camelCase")]
315pub struct AttentionItem {
316 pub id: String,
317 pub state: AttentionState,
318 pub title: String,
319 pub detail: String,
320 pub occurred_at_ms: u64,
321 pub event_id: String,
322}
323
324pub fn attention_inbox(
325 events: impl DoubleEndedIterator<Item = DevelopmentEvent>,
326) -> Vec<AttentionItem> {
327 let mut items = events
328 .rev()
329 .filter_map(|event| attention_item(&event))
330 .take(MAX_ATTENTION_ITEMS)
331 .collect::<Vec<_>>();
332 items.sort_by_key(|item| std::cmp::Reverse(item.occurred_at_ms));
333 items
334}
335
336fn attention_item(event: &DevelopmentEvent) -> Option<AttentionItem> {
337 let (state, title, detail) = match event.kind {
338 DevelopmentEventKind::ProcessStarted => (
339 AttentionState::Running,
340 "Process running",
341 payload_label(&event.payload, "name", "managed process"),
342 ),
343 DevelopmentEventKind::TestStarted => (
344 AttentionState::Running,
345 "Tests running",
346 payload_label(&event.payload, "name", "test run"),
347 ),
348 DevelopmentEventKind::AgentPrompt => (
349 AttentionState::Running,
350 "Agent working",
351 "bounded local prompt accepted".into(),
352 ),
353 DevelopmentEventKind::DiagnosticsPublished
354 if event
355 .payload
356 .get("count")
357 .and_then(serde_json::Value::as_u64)
358 .unwrap_or(0)
359 > 0 =>
360 {
361 (
362 AttentionState::NeedsAttention,
363 "Diagnostics need attention",
364 payload_label(&event.payload, "path", "project diagnostics"),
365 )
366 }
367 DevelopmentEventKind::SemanticBreakpointHit => (
368 AttentionState::NeedsAttention,
369 "Semantic breakpoint hit",
370 payload_label(&event.payload, "entity", "browser entity changed"),
371 ),
372 DevelopmentEventKind::ProcessExited => {
373 let failed = event_failed(&event.payload);
374 (
375 if failed {
376 AttentionState::NeedsAttention
377 } else {
378 AttentionState::Recent
379 },
380 if failed {
381 "Process failed"
382 } else {
383 "Process completed"
384 },
385 payload_label(&event.payload, "name", "managed process"),
386 )
387 }
388 DevelopmentEventKind::TestCompleted => {
389 let failed = event_failed(&event.payload);
390 (
391 if failed {
392 AttentionState::NeedsAttention
393 } else {
394 AttentionState::Recent
395 },
396 if failed {
397 "Tests failed"
398 } else {
399 "Tests passed"
400 },
401 payload_label(&event.payload, "name", "test run"),
402 )
403 }
404 DevelopmentEventKind::VerificationCompleted => (
405 AttentionState::Recent,
406 "Verification completed",
407 payload_label(&event.payload, "status", "verification evidence updated"),
408 ),
409 DevelopmentEventKind::FileSaved => (
410 AttentionState::Recent,
411 "File saved",
412 payload_label(&event.payload, "path", "project file"),
413 ),
414 _ => return None,
415 };
416 Some(AttentionItem {
417 id: format!("attention:{}", event.id),
418 state,
419 title: title.into(),
420 detail,
421 occurred_at_ms: event.occurred_at_ms,
422 event_id: event.id.clone(),
423 })
424}
425
426fn event_failed(payload: &serde_json::Value) -> bool {
427 if payload.get("success").and_then(serde_json::Value::as_bool) == Some(false)
428 || payload
429 .get("code")
430 .and_then(serde_json::Value::as_i64)
431 .is_some_and(|code| code != 0)
432 || payload
433 .get("status")
434 .and_then(serde_json::Value::as_str)
435 .is_some_and(|status| matches!(status, "failed" | "timeout" | "cancelled"))
436 {
437 return true;
438 }
439 let Some(state) = payload.get("state") else {
440 return false;
441 };
442 state.as_str() == Some("failed")
443 || state
444 .get("exited")
445 .and_then(|exited| exited.get("code"))
446 .and_then(serde_json::Value::as_i64)
447 .is_some_and(|code| code != 0)
448}
449
450fn payload_label(payload: &serde_json::Value, field: &str, fallback: &str) -> String {
451 payload
452 .get(field)
453 .and_then(serde_json::Value::as_str)
454 .filter(|value| value.len() <= 256)
455 .unwrap_or(fallback)
456 .to_string()
457}
458
459#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
460#[serde(rename_all = "camelCase")]
461pub struct VerificationCheck {
462 pub label: String,
463 pub status: String,
464 pub detail: String,
465}
466
467#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
468#[serde(rename_all = "camelCase")]
469pub struct VerificationCard {
470 pub schema_version: String,
471 pub title: String,
472 pub outcome: String,
473 pub checks: Vec<VerificationCheck>,
474 pub changed_files: usize,
475 pub semantic_revision: Option<u64>,
476 pub visual_status: String,
477 pub generated_at_ms: u64,
478}
479
480impl VerificationCard {
481 pub fn from_diff(
482 title: &str,
483 diff: &ProjectDiff,
484 semantic_revision: Option<u64>,
485 ) -> DevelopmentResult<Self> {
486 if title.trim().is_empty() || title.len() > 128 {
487 return Err(DevelopmentError::InvalidInput(
488 "verification card title must be 1-128 bytes".into(),
489 ));
490 }
491 let visual_status = diff
492 .visual
493 .get("status")
494 .and_then(serde_json::Value::as_str)
495 .unwrap_or("not-captured")
496 .to_string();
497 let process_count = diff
498 .runtime
499 .get("processCount")
500 .and_then(serde_json::Value::as_u64)
501 .unwrap_or(0);
502 let link_count = diff
503 .semantic
504 .get("linkCount")
505 .and_then(serde_json::Value::as_u64)
506 .unwrap_or(0);
507 Ok(Self {
508 schema_version: DEVELOPMENT_SCHEMA_VERSION.into(),
509 title: title.into(),
510 outcome: "reviewRequired".into(),
511 checks: vec![
512 VerificationCheck {
513 label: "Code changes".into(),
514 status: if diff.files.is_empty() {
515 "clean"
516 } else {
517 "changed"
518 }
519 .into(),
520 detail: format!("{} changed files", diff.files.len()),
521 },
522 VerificationCheck {
523 label: "Runtime".into(),
524 status: "observed".into(),
525 detail: format!("{process_count} managed processes"),
526 },
527 VerificationCheck {
528 label: "Semantic links".into(),
529 status: "observed".into(),
530 detail: format!("{link_count} source/runtime links"),
531 },
532 VerificationCheck {
533 label: "Visual evidence".into(),
534 status: visual_status.clone(),
535 detail: if visual_status == "not-captured" {
536 "request an explicit screenshot or comparison".into()
537 } else {
538 "explicit visual evidence attached".into()
539 },
540 },
541 ],
542 changed_files: diff.files.len(),
543 semantic_revision,
544 visual_status,
545 generated_at_ms: now_ms(),
546 })
547 }
548
549 pub fn add_check(&mut self, check: VerificationCheck) -> DevelopmentResult<()> {
550 if self.checks.len() == MAX_VERIFICATION_CHECKS {
551 return Err(DevelopmentError::InvalidInput(
552 "verification card check limit reached".into(),
553 ));
554 }
555 if check.label.is_empty() || check.label.len() > 128 || check.detail.len() > 512 {
556 return Err(DevelopmentError::InvalidInput(
557 "verification check exceeds bounded text limits".into(),
558 ));
559 }
560 self.checks.push(check);
561 Ok(())
562 }
563}
564const MAX_COCKPIT_REQUEST_BYTES: usize = 128 * 1024;
565const MAX_COCKPIT_RESPONSE_BYTES: usize = 512 * 1024;
566
567#[derive(Debug)]
574pub struct LocalCockpit {
575 address: SocketAddr,
576 token: String,
577 stop: Arc<AtomicBool>,
578 join: Option<JoinHandle<()>>,
579}
580
581impl LocalCockpit {
582 pub fn start(workspace: crate::SharedDevelopmentWorkspace) -> DevelopmentResult<Self> {
583 let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))?;
584 listener.set_nonblocking(true)?;
585 let address = listener.local_addr()?;
586 let token = cockpit_token()?;
587 let stop = Arc::new(AtomicBool::new(false));
588 let thread_stop = Arc::clone(&stop);
589 let thread_token = token.clone();
590 let join = thread::Builder::new()
591 .name("glass-private-cockpit".into())
592 .spawn(move || cockpit_loop(listener, workspace, thread_token, thread_stop))
593 .map_err(|error| {
594 DevelopmentError::Process(format!("failed to start private cockpit: {error}"))
595 })?;
596 Ok(Self {
597 address,
598 token,
599 stop,
600 join: Some(join),
601 })
602 }
603
604 pub fn address(&self) -> SocketAddr {
605 self.address
606 }
607
608 pub fn token(&self) -> &str {
609 &self.token
610 }
611
612 pub fn local_url(&self) -> String {
613 format!("http://{}/{}/", self.address, self.token)
614 }
615
616 pub fn shutdown(&mut self) {
617 self.stop.store(true, Ordering::Release);
618 if let Some(join) = self.join.take() {
619 let _ = join.join();
620 }
621 }
622}
623
624impl Drop for LocalCockpit {
625 fn drop(&mut self) {
626 self.shutdown();
627 }
628}
629
630#[derive(Debug, Deserialize)]
631#[serde(rename_all = "camelCase")]
632struct CockpitCommandRequest {
633 name: String,
634 #[serde(default)]
635 arguments: serde_json::Value,
636 #[serde(default)]
637 allow_mutation: bool,
638 #[serde(default)]
639 confirmed: bool,
640 expected_generation: Option<u64>,
641 expected_project_revision: Option<u64>,
642}
643
644fn cockpit_loop(
645 listener: TcpListener,
646 workspace: crate::SharedDevelopmentWorkspace,
647 token: String,
648 stop: Arc<AtomicBool>,
649) {
650 let mut github_probe = crate::github::GitHubProbeCache::default();
651 while !stop.load(Ordering::Acquire) {
652 match listener.accept() {
653 Ok((mut stream, _)) => {
654 let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
655 let response =
656 handle_cockpit_connection(&mut stream, &workspace, &token, &mut github_probe);
657 write_http_response(&mut stream, response);
658 }
659 Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
660 thread::sleep(Duration::from_millis(25));
661 }
662 Err(_) => break,
663 }
664 }
665}
666
667fn handle_cockpit_connection(
668 stream: &mut TcpStream,
669 workspace: &crate::SharedDevelopmentWorkspace,
670 token: &str,
671 github_probe: &mut crate::github::GitHubProbeCache,
672) -> (u16, &'static str, Vec<u8>) {
673 let request = match read_http_request(stream) {
674 Ok(request) => request,
675 Err(error) => return json_http(400, serde_json::json!({"error":error})),
676 };
677 let (method, path, body) = request;
678 let prefix = format!("/{token}");
679 if !path.starts_with(&prefix) || !path[prefix.len()..].strip_prefix('/').is_some_and(|_| true) {
680 return json_http(
681 401,
682 serde_json::json!({"error":"private cockpit token required"}),
683 );
684 }
685 let endpoint = path[prefix.len()..].split('?').next().unwrap_or_default();
686 match (method.as_str(), endpoint) {
687 ("GET", "/") => (
688 200,
689 "text/html; charset=utf-8",
690 cockpit_html(&format!("/{token}/")).into_bytes(),
691 ),
692 ("GET", "/v1/health") => json_http(200, serde_json::json!({"ok":true})),
693 ("GET", "/v1/state") => match cockpit_state(workspace, github_probe) {
694 Ok(value) => json_http(200, value),
695 Err(error) => json_http(503, serde_json::json!({"error":error.to_string()})),
696 },
697 ("POST", "/v1/command") => match cockpit_command(workspace, &body) {
698 Ok(value) => json_http(200, value),
699 Err(error) => {
700 let status = if matches!(error, DevelopmentError::Conflict(_)) {
701 409
702 } else {
703 400
704 };
705 json_http(status, serde_json::json!({"error":error.to_string()}))
706 }
707 },
708 _ => json_http(
709 404,
710 serde_json::json!({"error":"cockpit endpoint not found"}),
711 ),
712 }
713}
714
715fn read_http_request(stream: &mut TcpStream) -> Result<(String, String, Vec<u8>), String> {
716 let mut bytes = Vec::with_capacity(4096);
717 let mut chunk = [0_u8; 4096];
718 let header_end = loop {
719 let read = stream.read(&mut chunk).map_err(|error| error.to_string())?;
720 if read == 0 {
721 return Err("request ended before headers".into());
722 }
723 bytes.extend_from_slice(&chunk[..read]);
724 if bytes.len() > MAX_COCKPIT_REQUEST_BYTES {
725 return Err("request exceeds the private cockpit limit".into());
726 }
727 if let Some(index) = bytes.windows(4).position(|window| window == b"\r\n\r\n") {
728 break index + 4;
729 }
730 };
731 let header = std::str::from_utf8(&bytes[..header_end])
732 .map_err(|_| "request headers are not UTF-8".to_string())?;
733 let mut lines = header.split("\r\n");
734 let request_line = lines.next().ok_or("request line missing")?;
735 let mut request_parts = request_line.split_whitespace();
736 let method = request_parts
737 .next()
738 .ok_or("request method missing")?
739 .to_string();
740 let path = request_parts
741 .next()
742 .ok_or("request path missing")?
743 .to_string();
744 if request_parts.next().is_none() {
745 return Err("HTTP version missing".into());
746 }
747 let mut content_length = 0usize;
748 for line in lines {
749 if let Some((name, value)) = line.split_once(':')
750 && name.eq_ignore_ascii_case("content-length")
751 {
752 content_length = value
753 .trim()
754 .parse()
755 .map_err(|_| "invalid content length".to_string())?;
756 }
757 }
758 if content_length > MAX_COCKPIT_REQUEST_BYTES - header_end {
759 return Err("request body exceeds the private cockpit limit".into());
760 }
761 while bytes.len() < header_end + content_length {
762 let read = stream.read(&mut chunk).map_err(|error| error.to_string())?;
763 if read == 0 {
764 return Err("request ended before body".into());
765 }
766 bytes.extend_from_slice(&chunk[..read]);
767 }
768 Ok((
769 method,
770 path,
771 bytes[header_end..header_end + content_length].to_vec(),
772 ))
773}
774
775fn cockpit_state(
776 workspace: &crate::SharedDevelopmentWorkspace,
777 github_probe: &mut crate::github::GitHubProbeCache,
778) -> DevelopmentResult<serde_json::Value> {
779 let (root, generation, revision, trust, agents, tasks, git, proposals) = {
780 let mut locked = workspace.lock()?;
781 let root = locked.root().display().to_string();
782 let generation = locked.generation();
783 let revision = locked.project().revision();
784 let trust = locked.trust().label().to_string();
785 let agents = locked.agents().list().map_err(|error| error.to_string());
786 let tasks = locked.task_snapshots().map_err(|error| error.to_string());
787 let git = locked
788 .git()
789 .map(|git| git.status().map_err(|error| error.to_string()));
790 let proposals = locked
791 .project()
792 .editor_proposals()
793 .into_iter()
794 .take(32)
795 .map(|proposal| {
796 serde_json::json!({
797 "id": proposal.id,
798 "path": proposal.path,
799 "summary": proposal.summary,
800 "state": proposal.state,
801 })
802 })
803 .collect::<Vec<_>>();
804 (
805 root, generation, revision, trust, agents, tasks, git, proposals,
806 )
807 };
808 let github = github_probe.probe(Path::new(&root));
809 let agents = match agents {
810 Ok(value) => serde_json::to_value(value)?,
811 Err(error) => serde_json::json!({"error":error}),
812 };
813 let tasks = match tasks {
814 Ok(value) => serde_json::to_value(value)?,
815 Err(error) => serde_json::json!({"error":error}),
816 };
817 let git = match git {
818 Some(Ok(value)) => serde_json::to_value(value)?,
819 Some(Err(error)) => serde_json::json!({"error":error}),
820 None => serde_json::Value::Null,
821 };
822 Ok(serde_json::json!({
823 "schemaVersion": super::DEVELOPMENT_COCKPIT_SCHEMA_VERSION,
824 "root": root,
825 "generation": generation,
826 "projectRevision": revision,
827 "trust": trust,
828 "agents": agents,
829 "tasks": tasks,
830 "git": git,
831 "github": github,
832 "proposals": proposals,
833 }))
834}
835fn cockpit_command(
836 workspace: &crate::SharedDevelopmentWorkspace,
837 body: &[u8],
838) -> DevelopmentResult<serde_json::Value> {
839 let request: CockpitCommandRequest = serde_json::from_slice(body)?;
840 if request.name.is_empty()
841 || request.name.len() > 128
842 || !request
843 .name
844 .bytes()
845 .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b'_'))
846 {
847 return Err(DevelopmentError::InvalidInput(
848 "cockpit command names must be bounded tool identifiers".into(),
849 ));
850 }
851 let mut locked = workspace.lock()?;
852 let call = ToolCall {
853 id: format!("cockpit-{}", now_ms()),
854 name: request.name,
855 arguments: request.arguments,
856 };
857 let expected_generation = request.expected_generation.unwrap_or(locked.generation());
858 let expected_project_revision = request
859 .expected_project_revision
860 .unwrap_or_else(|| locked.project().revision());
861 let context = crate::tools::DevelopmentToolContext {
862 authorization: ToolAuthorization {
863 actor: Actor::external("cockpit"),
864 allow_mutation: request.allow_mutation && request.confirmed,
865 confirmed: request.confirmed,
866 unrestricted: false,
867 },
868 initiator: None,
869 expected_generation,
870 expected_project_revision,
871 };
872 let result = locked.execute_tool(&call, &context)?;
873 Ok(serde_json::json!({"ok":true,"tool":call.name,"result":result}))
874}
875
876fn write_http_response(stream: &mut TcpStream, response: (u16, &'static str, Vec<u8>)) {
877 let (status, content_type, body) = response;
878 let reason = match status {
879 200 => "OK",
880 400 => "Bad Request",
881 401 => "Unauthorized",
882 404 => "Not Found",
883 409 => "Conflict",
884 503 => "Service Unavailable",
885 _ => "Error",
886 };
887 let header = format!(
888 "HTTP/1.1 {status} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n",
889 body.len()
890 );
891 let _ = stream.write_all(header.as_bytes());
892 let _ = stream.write_all(&body);
893}
894
895fn json_http(status: u16, value: serde_json::Value) -> (u16, &'static str, Vec<u8>) {
896 let body = serde_json::to_vec(&value)
897 .unwrap_or_else(|_| b"{\"error\":\"serialization failure\"}".to_vec());
898 if body.len() > MAX_COCKPIT_RESPONSE_BYTES {
899 return (
900 503,
901 "application/json",
902 b"{\"error\":\"cockpit response exceeded its limit\"}".to_vec(),
903 );
904 }
905 (status, "application/json", body)
906}
907
908fn cockpit_token() -> DevelopmentResult<String> {
909 let mut bytes = [0_u8; 24];
910 getrandom::fill(&mut bytes).map_err(|error| {
911 DevelopmentError::Process(format!("private cockpit token generation failed: {error}"))
912 })?;
913 Ok(base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes))
914}
915
916fn cockpit_html(base: &str) -> String {
917 format!(
918 r##"<!doctype html>
919<meta charset="utf-8">
920<title>Glass private cockpit</title>
921<style>
922body{{font:15px/1.45 system-ui,sans-serif;background:#10131a;color:#e8edf5;margin:2rem;max-width:72rem}}
923pre{{background:#181d27;padding:1rem;border-radius:.6rem;white-space:pre-wrap}}
924button,input{{font:inherit;padding:.45rem .7rem;margin:.2rem 0}}
925button{{cursor:pointer}} code{{color:#9ad1ff}}
926#proposals div{{display:flex;gap:.6rem;align-items:center;margin:.35rem 0;flex-wrap:wrap}}
927</style>
928<h1>Glass private cockpit</h1>
929<p>Loopback-only workspace state. Mutations remain governed by Glass trust and revision checks.</p>
930<p>
931<button id="refresh">Refresh</button>
932<button id="review">Review GitHub PR</button>
933<button id="accept-pack">Accept pack</button>
934</p>
935<div id="proposals"></div>
936<pre id="state">Loading…</pre>
937<script>
938const base = "{}";
939const state = document.querySelector("#state");
940const proposalsEl = document.querySelector("#proposals");
941let lastState = {{}};
942async function load() {{
943 const response = await fetch(base + "v1/state", {{cache:"no-store"}});
944 lastState = await response.json();
945 renderProposals(lastState.proposals || []);
946 state.textContent = JSON.stringify(lastState, null, 2);
947}}
948function renderProposals(proposals) {{
949 const pending = proposals.filter((item) => item.state === "pending");
950 document.querySelector("#accept-pack").disabled = pending.length === 0;
951 proposalsEl.innerHTML = pending.length
952 ? pending.map((item) => `<div><code>${{item.path}}</code> ${{item.summary}} <button data-accept="${{item.id}}">Accept</button> <button data-reject="${{item.id}}">Reject</button></div>`).join("")
953 : "<p>No pending proposals</p>";
954 proposalsEl.querySelectorAll("[data-accept]").forEach((button) => {{
955 button.onclick = () => command("glass.editor.proposal.accept", {{id: button.dataset.accept}}, true);
956 }});
957 proposalsEl.querySelectorAll("[data-reject]").forEach((button) => {{
958 button.onclick = () => command("glass.editor.proposal.reject", {{id: button.dataset.reject}}, true);
959 }});
960}}
961async function command(name, argumentsValue={{}}, mutate=false) {{
962 const response = await fetch(base + "v1/command", {{
963 method:"POST", headers:{{"content-type":"application/json"}},
964 body:JSON.stringify({{
965 name,
966 arguments: argumentsValue,
967 allowMutation: mutate,
968 confirmed: mutate,
969 expectedGeneration: lastState.generation,
970 expectedProjectRevision: lastState.projectRevision
971 }})
972 }});
973 state.textContent = JSON.stringify(await response.json(), null, 2);
974 await load();
975}}
976document.querySelector("#refresh").onclick = load;
977document.querySelector("#review").onclick = () => command("glass.github.review");
978document.querySelector("#accept-pack").onclick = () => command("glass.editor.proposal.accept_pack", {{}}, true);
979load();
980</script>"##,
981 base
982 )
983}
984
985fn now_ms() -> u64 {
986 SystemTime::now()
987 .duration_since(UNIX_EPOCH)
988 .map_or(0, |duration| duration.as_millis() as u64)
989}
990
991#[cfg(test)]
992mod tests {
993 use super::*;
994
995 fn fixture(name: &str) -> PathBuf {
996 let root =
997 std::env::temp_dir().join(format!("glass-cockpit-{name}-{}", std::process::id()));
998 let _ = fs::remove_dir_all(&root);
999 fs::create_dir_all(&root).unwrap();
1000 fs::write(
1001 root.join("Cargo.toml"),
1002 "[package]\nname='demo'\nversion='0.1.0'\n",
1003 )
1004 .unwrap();
1005 root
1006 }
1007
1008 #[test]
1009 fn resident_registry_reuses_and_evicts_bounded_workspaces() {
1010 let first = fixture("first");
1011 let second = fixture("second");
1012 let mut sessions = ResidentDevelopmentSessions::new(1, Duration::from_secs(60));
1013 sessions
1014 .with_workspace(&first, |workspace| {
1015 workspace.attach_actor(super::super::Actor::external("one"))?;
1016 Ok(())
1017 })
1018 .unwrap();
1019 sessions
1020 .with_workspace(&first, |workspace| {
1021 assert!(workspace.actors().any(|actor| actor.id == "external:one"));
1022 Ok(())
1023 })
1024 .unwrap();
1025 sessions.with_workspace(&second, |_| Ok(())).unwrap();
1026 assert_eq!(sessions.len(), 1);
1027 assert!(!sessions.contains(&first));
1028 assert!(sessions.contains(&second));
1029 let _ = fs::remove_dir_all(first);
1030 let _ = fs::remove_dir_all(second);
1031 }
1032
1033 #[test]
1034 fn reconnect_capsule_round_trips_without_payload_fields() {
1035 let root = fixture("capsule");
1036 let mut capsule = ReconnectCapsule::new(&root).unwrap();
1037 capsule.event_cursor = Some("dev-1".into());
1038 capsule.mobile_view = Some("app".into());
1039 capsule.mobile_scroll = Some(20);
1040 ReconnectCapsuleStore::save(&capsule).unwrap();
1041 assert_eq!(ReconnectCapsuleStore::load(&root).unwrap(), Some(capsule));
1042 assert!(ReconnectCapsuleStore::clear(&root).unwrap());
1043 assert_eq!(ReconnectCapsuleStore::load(&root).unwrap(), None);
1044 let _ = fs::remove_dir_all(root);
1045 }
1046
1047 #[test]
1048 fn reconnect_capsule_accepts_current_and_legacy_mobile_views() {
1049 let root = fixture("capsule-mobile-views");
1050 for view in [
1051 "home", "overview", "agent", "app", "browser", "diff", "project", "process", "logs",
1052 ] {
1053 let mut capsule = ReconnectCapsule::new(&root).unwrap();
1054 capsule.mobile_view = Some(view.into());
1055 capsule.validate().unwrap();
1056 }
1057 let mut capsule = ReconnectCapsule::new(&root).unwrap();
1058 capsule.mobile_view = Some("unknown".into());
1059 assert!(capsule.validate().is_err());
1060 let _ = fs::remove_dir_all(root);
1061 }
1062
1063 #[test]
1064 fn resident_registry_expires_idle_state_before_reopening() {
1065 let root = fixture("expiry");
1066 fs::write(root.join("src.rs"), "fn main() {}\n").unwrap();
1067 let mut sessions = ResidentDevelopmentSessions::new(2, Duration::ZERO);
1068 sessions
1069 .with_workspace(&root, |workspace| {
1070 workspace.open_buffer("src.rs", super::super::Actor::local())?;
1071 Ok(())
1072 })
1073 .unwrap();
1074 let retained = sessions
1075 .with_workspace(&root, |workspace| Ok(workspace.buffer("src.rs").is_some()))
1076 .unwrap();
1077 assert!(!retained);
1078 let _ = fs::remove_dir_all(root);
1079 }
1080
1081 #[test]
1082 fn attention_inbox_classifies_only_actionable_runtime_events() {
1083 let events = vec![
1084 DevelopmentEvent::new(
1085 super::super::Actor::local(),
1086 DevelopmentEventKind::WorkspaceOpened,
1087 "/tmp",
1088 serde_json::json!({}),
1089 1,
1090 ),
1091 DevelopmentEvent::new(
1092 super::super::Actor::local(),
1093 DevelopmentEventKind::DiagnosticsPublished,
1094 "/tmp",
1095 serde_json::json!({"count":2,"path":"src/lib.rs"}),
1096 2,
1097 ),
1098 DevelopmentEvent::new(
1099 super::super::Actor::local(),
1100 DevelopmentEventKind::ProcessStarted,
1101 "/tmp",
1102 serde_json::json!({"name":"dev"}),
1103 3,
1104 ),
1105 DevelopmentEvent::new(
1106 super::super::Actor::local(),
1107 DevelopmentEventKind::TestCompleted,
1108 "/tmp",
1109 serde_json::json!({"name":"unit","state":{"exited":{"code":1}}}),
1110 4,
1111 ),
1112 ];
1113 let inbox = attention_inbox(events.into_iter());
1114 assert_eq!(inbox.len(), 3);
1115 assert!(
1116 inbox
1117 .iter()
1118 .any(|item| item.state == AttentionState::Running)
1119 );
1120 assert!(inbox.iter().any(|item| item.title == "Tests failed"));
1121 }
1122
1123 #[test]
1124 fn local_cockpit_requires_token_and_serves_health() {
1125 let root = fixture("http");
1126 let workspace = crate::SharedDevelopmentWorkspace::open(&root).unwrap();
1127 let cockpit = LocalCockpit::start(workspace).unwrap();
1128
1129 let mut unauthorized = TcpStream::connect(cockpit.address()).unwrap();
1130 unauthorized
1131 .write_all(b"GET /v1/health HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
1132 .unwrap();
1133 unauthorized.shutdown(std::net::Shutdown::Write).unwrap();
1134 let mut unauthorized_response = Vec::new();
1135 unauthorized
1136 .read_to_end(&mut unauthorized_response)
1137 .unwrap();
1138 let unauthorized_response = String::from_utf8_lossy(&unauthorized_response);
1139 assert!(unauthorized_response.starts_with("HTTP/1.1 401 Unauthorized"));
1140
1141 let request = format!(
1142 "GET /{}/v1/health HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n",
1143 cockpit.token()
1144 );
1145 let mut authorized = TcpStream::connect(cockpit.address()).unwrap();
1146 authorized.write_all(request.as_bytes()).unwrap();
1147 authorized.shutdown(std::net::Shutdown::Write).unwrap();
1148 let mut authorized_response = Vec::new();
1149 authorized.read_to_end(&mut authorized_response).unwrap();
1150 let authorized_response = String::from_utf8_lossy(&authorized_response);
1151 assert!(authorized_response.starts_with("HTTP/1.1 200 OK"));
1152 assert!(authorized_response.contains("{\"ok\":true}"));
1153 drop(cockpit);
1154 let _ = fs::remove_dir_all(root);
1155 }
1156
1157 #[test]
1158 fn local_cockpit_accepts_the_pending_proposal_pack() {
1159 let root = fixture("accept-pack");
1160 fs::write(root.join("src.rs"), "fn main() {}\n").unwrap();
1161 let workspace = crate::SharedDevelopmentWorkspace::open(&root).unwrap();
1162 {
1163 let mut locked = workspace.lock().unwrap();
1164 locked
1165 .apply_local_trust_decision(crate::LocalTrustDecision::TrustProject)
1166 .unwrap();
1167 locked
1168 .project_mut()
1169 .open_buffer("src.rs", Actor::local())
1170 .unwrap();
1171 locked
1172 .project_mut()
1173 .propose_editor_change(
1174 "src.rs",
1175 "fn main() {}\n".into(),
1176 "fn main() { 1 }\n".into(),
1177 "add one".into(),
1178 Actor::local(),
1179 )
1180 .unwrap();
1181 }
1182 let cockpit = LocalCockpit::start(workspace.clone()).unwrap();
1183
1184 let html_request = format!(
1185 "GET /{}/ HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n",
1186 cockpit.token()
1187 );
1188 let mut html_stream = TcpStream::connect(cockpit.address()).unwrap();
1189 html_stream.write_all(html_request.as_bytes()).unwrap();
1190 html_stream.shutdown(std::net::Shutdown::Write).unwrap();
1191 let mut html = Vec::new();
1192 html_stream.read_to_end(&mut html).unwrap();
1193 let html = String::from_utf8_lossy(&html);
1194 assert!(html.contains("Accept pack"));
1195 assert!(html.contains("glass.editor.proposal.accept_pack"));
1196
1197 let state_request = format!(
1198 "GET /{}/v1/state HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n",
1199 cockpit.token()
1200 );
1201 let mut state_stream = TcpStream::connect(cockpit.address()).unwrap();
1202 state_stream.write_all(state_request.as_bytes()).unwrap();
1203 state_stream.shutdown(std::net::Shutdown::Write).unwrap();
1204 let mut state_body = Vec::new();
1205 state_stream.read_to_end(&mut state_body).unwrap();
1206 let state_body = String::from_utf8_lossy(&state_body);
1207 assert!(state_body.contains("\"path\":\"src.rs\""));
1208 assert!(state_body.contains("\"state\":\"pending\""));
1209 assert!(!state_body.contains("fn main() { 1 }"));
1210
1211 let denied = serde_json::json!({"name":"glass.editor.proposal.accept_pack"}).to_string();
1212 let denied_request = format!(
1213 "POST /{}/v1/command HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{denied}",
1214 cockpit.token(),
1215 denied.len()
1216 );
1217 let mut denied_stream = TcpStream::connect(cockpit.address()).unwrap();
1218 denied_stream.write_all(denied_request.as_bytes()).unwrap();
1219 denied_stream.shutdown(std::net::Shutdown::Write).unwrap();
1220 let mut denied_body = Vec::new();
1221 denied_stream.read_to_end(&mut denied_body).unwrap();
1222 let denied_body = String::from_utf8_lossy(&denied_body);
1223 assert!(denied_body.contains("409") || denied_body.contains("mutation authority"));
1224
1225 let accepted = serde_json::json!({
1226 "name":"glass.editor.proposal.accept_pack",
1227 "allowMutation":true,
1228 "confirmed":true
1229 })
1230 .to_string();
1231 let accept_request = format!(
1232 "POST /{}/v1/command HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{accepted}",
1233 cockpit.token(),
1234 accepted.len()
1235 );
1236 let mut accept_stream = TcpStream::connect(cockpit.address()).unwrap();
1237 accept_stream.write_all(accept_request.as_bytes()).unwrap();
1238 accept_stream.shutdown(std::net::Shutdown::Write).unwrap();
1239 let mut accept_body = Vec::new();
1240 accept_stream.read_to_end(&mut accept_body).unwrap();
1241 let accept_body = String::from_utf8_lossy(&accept_body);
1242 assert!(accept_body.starts_with("HTTP/1.1 200 OK"), "{accept_body}");
1243
1244 let locked = workspace.lock().unwrap();
1245 assert_eq!(
1246 locked.project().buffer("src.rs").unwrap().content,
1247 "fn main() { 1 }\n"
1248 );
1249 assert_eq!(
1250 locked.project().editor_proposals()[0].state,
1251 crate::development::EditorProposalState::Accepted
1252 );
1253 drop(locked);
1254 drop(cockpit);
1255 let _ = fs::remove_dir_all(root);
1256 }
1257
1258 #[test]
1259 fn verification_card_keeps_visual_evidence_explicit() {
1260 let diff = ProjectDiff {
1261 schema_version: DEVELOPMENT_SCHEMA_VERSION.into(),
1262 files: vec![],
1263 runtime: BTreeMap::from([("processCount".into(), serde_json::json!(1))]),
1264 semantic: BTreeMap::from([("linkCount".into(), serde_json::json!(2))]),
1265 visual: BTreeMap::from([("status".into(), serde_json::json!("not-captured"))]),
1266 workflow: BTreeMap::new(),
1267 test_impact: BTreeMap::new(),
1268 };
1269 let card = VerificationCard::from_diff("Checkout fix", &diff, Some(9)).unwrap();
1270 assert_eq!(card.visual_status, "not-captured");
1271 assert_eq!(card.checks.len(), 4);
1272 assert!(card.checks[3].detail.contains("explicit screenshot"));
1273 }
1274}