Skip to main content

glass_dev/development/
cockpit.rs

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/// A loopback-only HTTP cockpit for private local inspection and commands.
568///
569/// The token is part of the URL, the listener binds only to `127.0.0.1`, and
570/// every request is bounded before it reaches the resident workspace. This is
571/// intentionally not a public remote-view transport; use SSH/Mosh port
572/// forwarding when the operator is remote.
573#[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}