Skip to main content

glass_dev/
browser.rs

1//! Resident browser and workflow ownership for the Glass development workspace.
2
3use crate::development::{DevelopmentError, DevelopmentResult};
4use crate::development::{RemoteFrame, RemoteInput, RemoteView};
5use glass_browser::browser::policy::BrowserPolicy;
6use glass_browser::browser::session::{
7    BrowserSession, SemanticObservationLevel, SessionOptions, WorkflowCheckpoint,
8    WorkflowDefinition, WorkflowRunResult,
9};
10use serde::{Deserialize, Serialize};
11use serde_json::Value;
12use std::collections::BTreeMap;
13use std::path::{Path, PathBuf};
14use std::sync::mpsc::{self, SyncSender};
15use std::time::Duration;
16
17const COMMAND_QUEUE: usize = 32;
18const COMMAND_TIMEOUT: Duration = Duration::from_secs(180);
19
20#[derive(Debug, Clone, Serialize, Deserialize)]
21#[serde(default, rename_all = "camelCase")]
22pub struct BrowserStartConfig {
23    pub port: u16,
24    pub attach: bool,
25    pub incognito: bool,
26    pub headed: bool,
27    pub profile: String,
28    pub chrome_path: Option<PathBuf>,
29}
30
31impl Default for BrowserStartConfig {
32    fn default() -> Self {
33        Self {
34            port: default_port(),
35            attach: false,
36            incognito: true,
37            headed: false,
38            profile: default_profile(),
39            chrome_path: None,
40        }
41    }
42}
43
44fn default_port() -> u16 {
45    9222
46}
47
48fn default_profile() -> String {
49    "default".into()
50}
51
52#[derive(Debug, Clone, Serialize)]
53#[serde(rename_all = "camelCase")]
54pub struct BrowserRuntimeState {
55    pub connected: bool,
56    pub browser_process_id: Option<u32>,
57    pub browser_revision: Option<u64>,
58    pub workflow_state: String,
59    pub active_workflow: Option<String>,
60}
61
62enum BrowserCommand {
63    Start(BrowserStartConfig),
64    Reconnect,
65    Stop,
66    State,
67    Observe,
68    Snapshot,
69    Semantic(SemanticObservationLevel),
70    Diff,
71    Targets,
72    SelectTarget(String),
73    Navigate {
74        url: String,
75        expected_revision: u64,
76        timeout: Duration,
77    },
78    Back(u64),
79    Forward(u64),
80    Reload(u64),
81    StopLoading(u64),
82    Highlight {
83        target: String,
84        expected_revision: u64,
85    },
86    Click {
87        target: String,
88        expected_revision: u64,
89    },
90    Type {
91        text: String,
92        target: Option<String>,
93        expected_revision: u64,
94    },
95    Scroll {
96        dx: f64,
97        dy: f64,
98        expected_revision: u64,
99    },
100    Screenshot,
101    RunWorkflow {
102        definition: Value,
103        inputs: BTreeMap<String, Value>,
104    },
105    PauseWorkflow,
106    ResumeWorkflow {
107        definition: Value,
108        inputs: BTreeMap<String, Value>,
109        checkpoint: Value,
110    },
111    ListWorkflows,
112    CancelWorkflow,
113    VerifyWorkflow,
114    RemoteViewOpen,
115    RemoteViewStatus,
116    RemoteViewRevoke,
117}
118
119type Reply = SyncSender<DevelopmentResult<Value>>;
120
121/// Cloneable command handle for the one authoritative browser worker.
122#[derive(Clone)]
123pub struct BrowserService {
124    commands: SyncSender<(BrowserCommand, Reply)>,
125}
126
127impl BrowserService {
128    pub fn new(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
129        let root = root.as_ref().to_path_buf();
130        let (commands, receiver) = mpsc::sync_channel::<(BrowserCommand, Reply)>(COMMAND_QUEUE);
131        std::thread::Builder::new()
132            .name("glass-browser-workspace".into())
133            .spawn(move || {
134                let runtime = tokio::runtime::Builder::new_current_thread()
135                    .enable_all()
136                    .build();
137                let Ok(runtime) = runtime else {
138                    return;
139                };
140                let mut worker = BrowserWorker::new(root);
141                while let Ok((command, reply)) = receiver.recv() {
142                    let result = runtime.block_on(worker.execute(command));
143                    let _ = reply.send(result);
144                }
145                runtime.block_on(worker.shutdown());
146            })
147            .map_err(|error| DevelopmentError::Process(error.to_string()))?;
148        Ok(Self { commands })
149    }
150
151    fn call(&self, command: BrowserCommand) -> DevelopmentResult<Value> {
152        let (reply, receiver) = mpsc::sync_channel(1);
153        self.commands
154            .send((command, reply))
155            .map_err(|_| DevelopmentError::Process("resident browser worker stopped".into()))?;
156        receiver.recv_timeout(COMMAND_TIMEOUT).map_err(|error| {
157            DevelopmentError::Process(format!("resident browser command timed out: {error}"))
158        })?
159    }
160
161    pub fn start(&self, config: BrowserStartConfig) -> DevelopmentResult<Value> {
162        self.call(BrowserCommand::Start(config))
163    }
164
165    pub fn stop(&self) -> DevelopmentResult<Value> {
166        self.call(BrowserCommand::Stop)
167    }
168
169    pub fn reconnect(&self) -> DevelopmentResult<Value> {
170        self.call(BrowserCommand::Reconnect)
171    }
172
173    pub fn state(&self) -> DevelopmentResult<Value> {
174        self.call(BrowserCommand::State)
175    }
176
177    pub fn observe(&self) -> DevelopmentResult<Value> {
178        self.call(BrowserCommand::Observe)
179    }
180
181    pub fn snapshot(&self) -> DevelopmentResult<Value> {
182        self.call(BrowserCommand::Snapshot)
183    }
184
185    pub fn semantic(&self, level: SemanticObservationLevel) -> DevelopmentResult<Value> {
186        self.call(BrowserCommand::Semantic(level))
187    }
188
189    pub fn diff(&self) -> DevelopmentResult<Value> {
190        self.call(BrowserCommand::Diff)
191    }
192
193    pub fn targets(&self) -> DevelopmentResult<Value> {
194        self.call(BrowserCommand::Targets)
195    }
196
197    pub fn select_target(&self, target: String) -> DevelopmentResult<Value> {
198        self.call(BrowserCommand::SelectTarget(target))
199    }
200
201    pub fn navigate(
202        &self,
203        url: String,
204        expected_revision: u64,
205        timeout: Duration,
206    ) -> DevelopmentResult<Value> {
207        self.call(BrowserCommand::Navigate {
208            url,
209            expected_revision,
210            timeout,
211        })
212    }
213
214    pub fn back(&self, expected_revision: u64) -> DevelopmentResult<Value> {
215        self.call(BrowserCommand::Back(expected_revision))
216    }
217
218    pub fn forward(&self, expected_revision: u64) -> DevelopmentResult<Value> {
219        self.call(BrowserCommand::Forward(expected_revision))
220    }
221
222    pub fn reload(&self, expected_revision: u64) -> DevelopmentResult<Value> {
223        self.call(BrowserCommand::Reload(expected_revision))
224    }
225
226    pub fn stop_loading(&self, expected_revision: u64) -> DevelopmentResult<Value> {
227        self.call(BrowserCommand::StopLoading(expected_revision))
228    }
229
230    pub fn highlight(&self, target: String, expected_revision: u64) -> DevelopmentResult<Value> {
231        self.call(BrowserCommand::Highlight {
232            target,
233            expected_revision,
234        })
235    }
236
237    pub fn click(&self, target: String, expected_revision: u64) -> DevelopmentResult<Value> {
238        self.call(BrowserCommand::Click {
239            target,
240            expected_revision,
241        })
242    }
243
244    pub fn type_text(
245        &self,
246        text: String,
247        target: Option<String>,
248        expected_revision: u64,
249    ) -> DevelopmentResult<Value> {
250        self.call(BrowserCommand::Type {
251            text,
252            target,
253            expected_revision,
254        })
255    }
256
257    pub fn scroll(&self, dx: f64, dy: f64, expected_revision: u64) -> DevelopmentResult<Value> {
258        self.call(BrowserCommand::Scroll {
259            dx,
260            dy,
261            expected_revision,
262        })
263    }
264
265    pub fn screenshot(&self) -> DevelopmentResult<Value> {
266        self.call(BrowserCommand::Screenshot)
267    }
268
269    pub fn run_workflow(
270        &self,
271        definition: Value,
272        inputs: BTreeMap<String, Value>,
273    ) -> DevelopmentResult<Value> {
274        self.call(BrowserCommand::RunWorkflow { definition, inputs })
275    }
276
277    pub fn pause_workflow(&self) -> DevelopmentResult<Value> {
278        self.call(BrowserCommand::PauseWorkflow)
279    }
280
281    pub fn resume_workflow(
282        &self,
283        definition: Value,
284        inputs: BTreeMap<String, Value>,
285        checkpoint: Value,
286    ) -> DevelopmentResult<Value> {
287        self.call(BrowserCommand::ResumeWorkflow {
288            definition,
289            inputs,
290            checkpoint,
291        })
292    }
293
294    pub fn list_workflows(&self) -> DevelopmentResult<Value> {
295        self.call(BrowserCommand::ListWorkflows)
296    }
297
298    pub fn cancel_workflow(&self) -> DevelopmentResult<Value> {
299        self.call(BrowserCommand::CancelWorkflow)
300    }
301
302    pub fn verify_workflow(&self) -> DevelopmentResult<Value> {
303        self.call(BrowserCommand::VerifyWorkflow)
304    }
305
306    pub fn open_remote_view(&self) -> DevelopmentResult<Value> {
307        self.call(BrowserCommand::RemoteViewOpen)
308    }
309
310    pub fn remote_view_status(&self) -> DevelopmentResult<Value> {
311        self.call(BrowserCommand::RemoteViewStatus)
312    }
313
314    pub fn revoke_remote_view(&self) -> DevelopmentResult<Value> {
315        self.call(BrowserCommand::RemoteViewRevoke)
316    }
317}
318
319struct BrowserWorker {
320    root: PathBuf,
321    session: Option<BrowserSession>,
322    revision: Option<u64>,
323    workflow_state: String,
324    active_workflow: Option<String>,
325    last_workflow: Option<(WorkflowDefinition, WorkflowRunResult)>,
326    last_config: Option<BrowserStartConfig>,
327    remote_view: Option<RemoteView>,
328}
329
330impl BrowserWorker {
331    fn new(root: PathBuf) -> Self {
332        Self {
333            root,
334            session: None,
335            revision: None,
336            workflow_state: "idle".into(),
337            active_workflow: None,
338            last_workflow: None,
339            last_config: None,
340            remote_view: None,
341        }
342    }
343
344    fn state(&self) -> BrowserRuntimeState {
345        BrowserRuntimeState {
346            connected: self.session.is_some(),
347            browser_process_id: self
348                .session
349                .as_ref()
350                .and_then(BrowserSession::owned_chrome_pid),
351            browser_revision: self.revision,
352            workflow_state: self.workflow_state.clone(),
353            active_workflow: self.active_workflow.clone(),
354        }
355    }
356
357    fn session(&self) -> DevelopmentResult<&BrowserSession> {
358        self.session.as_ref().ok_or_else(|| {
359            DevelopmentError::Conflict(
360                "browser is not connected; call glass.browser.start first".into(),
361            )
362        })
363    }
364
365    async fn shutdown(&mut self) {
366        if let Some(view) = self.remote_view.take() {
367            view.revoke().await;
368        }
369        if let Some(session) = self.session.take() {
370            let _ = session.close().await;
371        }
372        self.revision = None;
373        self.workflow_state = "idle".into();
374        self.active_workflow = None;
375        self.last_workflow = None;
376    }
377
378    async fn start_session(&mut self, config: BrowserStartConfig) -> DevelopmentResult<Value> {
379        if self.session.is_some() {
380            return Err(DevelopmentError::Conflict(
381                "browser workspace already has a connected session".into(),
382            ));
383        }
384        let policy = BrowserPolicy::development(&self.root)
385            .map_err(|error| DevelopmentError::Process(error.to_string()))?;
386        let mut builder = SessionOptions::builder()
387            .port(config.port)
388            .attach(config.attach)
389            .incognito(config.incognito)
390            .headed(config.headed)
391            .profile(config.profile.clone())
392            .policy(policy);
393        if let Some(path) = config.chrome_path.clone() {
394            builder = builder.chrome_path(path);
395        }
396        let options = builder
397            .build()
398            .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
399        let session = BrowserSession::start(&options)
400            .await
401            .map_err(|error| DevelopmentError::Process(error.to_string()))?;
402        self.revision = Some(1);
403        self.session = Some(session);
404        self.last_config = Some(config);
405        serde_json::to_value(self.state()).map_err(Into::into)
406    }
407
408    async fn execute(&mut self, command: BrowserCommand) -> DevelopmentResult<Value> {
409        self.apply_remote_inputs().await?;
410        match command {
411            BrowserCommand::Start(config) => self.start_session(config).await,
412            BrowserCommand::Reconnect => {
413                let config = self.last_config.clone().ok_or_else(|| {
414                    DevelopmentError::Conflict(
415                        "browser has no prior connection configuration to reconnect".into(),
416                    )
417                })?;
418                self.shutdown().await;
419                self.start_session(config).await
420            }
421            BrowserCommand::Stop => {
422                self.shutdown().await;
423                serde_json::to_value(self.state()).map_err(Into::into)
424            }
425            BrowserCommand::State => serde_json::to_value(self.state()).map_err(Into::into),
426            BrowserCommand::Observe => {
427                let context = self
428                    .session()?
429                    .observe_fresh()
430                    .await
431                    .map_err(browser_error)?;
432                self.revision = Some(context.consistency.end_revision);
433                serde_json::to_value(context).map_err(Into::into)
434            }
435            BrowserCommand::Snapshot => {
436                let snapshot = self.session()?.snapshot().await.map_err(browser_error)?;
437                serde_json::to_value(snapshot).map_err(Into::into)
438            }
439            BrowserCommand::Semantic(level) => {
440                let observation = self
441                    .session()?
442                    .semantic_observe(level)
443                    .await
444                    .map_err(browser_error)?;
445                serde_json::to_value(observation).map_err(Into::into)
446            }
447            BrowserCommand::Diff => {
448                let delta = self
449                    .session()?
450                    .observe_delta()
451                    .await
452                    .map_err(browser_error)?;
453                self.revision = Some(delta.to_revision);
454                serde_json::to_value(delta).map_err(Into::into)
455            }
456            BrowserCommand::Targets => {
457                let targets = self
458                    .session()?
459                    .list_targets()
460                    .await
461                    .map_err(browser_error)?;
462                serde_json::to_value(targets).map_err(Into::into)
463            }
464            BrowserCommand::SelectTarget(target) => {
465                let selected = self
466                    .session()?
467                    .select_target(&target)
468                    .await
469                    .map_err(browser_error)?;
470                let observation = self
471                    .session()?
472                    .observe_fresh()
473                    .await
474                    .map_err(browser_error)?;
475                self.revision = Some(observation.consistency.end_revision);
476                Ok(serde_json::json!({"target":selected,"observation":observation}))
477            }
478            BrowserCommand::Navigate {
479                url,
480                expected_revision,
481                timeout,
482            } => {
483                let outcome = self
484                    .session()?
485                    .navigate_with_revision(&url, timeout, expected_revision)
486                    .await
487                    .map_err(browser_error)?;
488                let value = serde_json::to_value(outcome)?;
489                self.revision = value.get("currentRevision").and_then(Value::as_u64);
490                Ok(value)
491            }
492            BrowserCommand::Back(expected_revision) => {
493                let outcome = self
494                    .session()?
495                    .go_back_with_revision(expected_revision)
496                    .await
497                    .map_err(browser_error)?;
498                self.revision = Some(outcome.current_revision);
499                serde_json::to_value(outcome).map_err(Into::into)
500            }
501            BrowserCommand::Forward(expected_revision) => {
502                let outcome = self
503                    .session()?
504                    .go_forward_with_revision(expected_revision)
505                    .await
506                    .map_err(browser_error)?;
507                self.revision = Some(outcome.current_revision);
508                serde_json::to_value(outcome).map_err(Into::into)
509            }
510            BrowserCommand::Reload(expected_revision) => {
511                let outcome = self
512                    .session()?
513                    .reload_with_revision(expected_revision)
514                    .await
515                    .map_err(browser_error)?;
516                self.revision = Some(outcome.current_revision);
517                serde_json::to_value(outcome).map_err(Into::into)
518            }
519            BrowserCommand::StopLoading(expected_revision) => {
520                let outcome = self
521                    .session()?
522                    .stop_loading_with_revision(expected_revision)
523                    .await
524                    .map_err(browser_error)?;
525                self.revision = Some(outcome.current_revision);
526                serde_json::to_value(outcome).map_err(Into::into)
527            }
528            BrowserCommand::Highlight {
529                target,
530                expected_revision,
531            } => {
532                self.session()?
533                    .highlight_target_with_revision(&target, expected_revision)
534                    .await
535                    .map_err(browser_error)?;
536                Ok(serde_json::json!({"highlighted":target,"browserRevision":expected_revision}))
537            }
538            BrowserCommand::Click {
539                target,
540                expected_revision,
541            } => {
542                let outcome = self
543                    .session()?
544                    .click_with_revision(&target, expected_revision)
545                    .await
546                    .map_err(browser_error)?;
547                self.revision = Some(outcome.current_revision);
548                serde_json::to_value(outcome).map_err(Into::into)
549            }
550            BrowserCommand::Type {
551                text,
552                target,
553                expected_revision,
554            } => {
555                let outcome = self
556                    .session()?
557                    .type_text_with_expected_revision(
558                        &text,
559                        target.as_deref(),
560                        Some(expected_revision),
561                    )
562                    .await
563                    .map_err(browser_error)?;
564                self.revision = Some(outcome.current_revision);
565                serde_json::to_value(outcome).map_err(Into::into)
566            }
567            BrowserCommand::Scroll {
568                dx,
569                dy,
570                expected_revision,
571            } => {
572                let outcome = self
573                    .session()?
574                    .scroll_with_revision(dx, dy, Some(expected_revision))
575                    .await
576                    .map_err(browser_error)?;
577                self.revision = Some(outcome.current_revision);
578                serde_json::to_value(outcome).map_err(Into::into)
579            }
580            BrowserCommand::Screenshot => {
581                let png = self
582                    .session()?
583                    .screenshot_png()
584                    .await
585                    .map_err(browser_error)?;
586                Ok(serde_json::json!({
587                    "mimeType":"image/png",
588                    "bytes":png.len(),
589                    "base64":base64::Engine::encode(&base64::engine::general_purpose::STANDARD, png)
590                }))
591            }
592            BrowserCommand::RunWorkflow { definition, inputs } => {
593                let workflow = WorkflowDefinition::from_value(definition)
594                    .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
595                self.workflow_state = "running".into();
596                self.active_workflow = Some(workflow.name.clone());
597                let result = self.session()?.run_workflow(&workflow, &inputs).await;
598                self.workflow_state = if result.is_ok() {
599                    "completed"
600                } else {
601                    "failed"
602                }
603                .into();
604                let result = result.map_err(browser_error)?;
605                self.revision = Some(result.final_revision);
606                self.last_workflow = Some((workflow, result.clone()));
607                serde_json::to_value(result).map_err(Into::into)
608            }
609            BrowserCommand::PauseWorkflow => {
610                let (workflow, result) = self.last_workflow.as_ref().ok_or_else(|| {
611                    DevelopmentError::Conflict(
612                        "no workflow result is available to checkpoint".into(),
613                    )
614                })?;
615                let checkpoint = self
616                    .session()?
617                    .export_workflow_checkpoint(workflow, result)
618                    .await
619                    .map_err(browser_error)?;
620                self.workflow_state = "paused".into();
621                serde_json::to_value(checkpoint).map_err(Into::into)
622            }
623            BrowserCommand::ResumeWorkflow {
624                definition,
625                inputs,
626                checkpoint,
627            } => {
628                let workflow = WorkflowDefinition::from_value(definition)
629                    .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
630                let checkpoint: WorkflowCheckpoint = serde_json::from_value(checkpoint)?;
631                self.workflow_state = "running".into();
632                self.active_workflow = Some(workflow.name.clone());
633                let result = self
634                    .session()?
635                    .resume_workflow(&workflow, &inputs, &checkpoint)
636                    .await;
637                self.workflow_state = if result.is_ok() {
638                    "completed"
639                } else {
640                    "failed"
641                }
642                .into();
643                let result = result.map_err(browser_error)?;
644                self.revision = Some(result.final_revision);
645                self.last_workflow = Some((workflow, result.clone()));
646                serde_json::to_value(result).map_err(Into::into)
647            }
648            BrowserCommand::ListWorkflows => Ok(serde_json::json!({
649                "state":self.workflow_state,
650                "active":self.active_workflow,
651                "last":self.last_workflow.as_ref().map(|(definition, result)| serde_json::json!({
652                    "name":definition.name,
653                    "version":definition.workflow_version,
654                    "result":result
655                }))
656            })),
657            BrowserCommand::CancelWorkflow => {
658                if self.workflow_state == "running" {
659                    return Err(DevelopmentError::Conflict(
660                        "workflow cancellation cannot preempt an in-flight synchronous browser command"
661                            .into(),
662                    ));
663                }
664                let previous = self.workflow_state.clone();
665                self.workflow_state = "cancelled".into();
666                self.active_workflow = None;
667                Ok(serde_json::json!({"cancelled":true,"previousState":previous}))
668            }
669            BrowserCommand::VerifyWorkflow => {
670                let (definition, result) = self.last_workflow.as_ref().ok_or_else(|| {
671                    DevelopmentError::Conflict("no workflow result is available to verify".into())
672                })?;
673                Ok(serde_json::json!({
674                    "verified":self.workflow_state == "completed",
675                    "name":definition.name,
676                    "version":definition.workflow_version,
677                    "finalRevision":result.final_revision,
678                    "result":result
679                }))
680            }
681            BrowserCommand::RemoteViewOpen => {
682                if self.remote_view.is_some() {
683                    return Err(DevelopmentError::Conflict("Remote View is already open".into()));
684                }
685                self.session()?;
686                let view = RemoteView::bind().await?;
687                let response = serde_json::json!({
688                    "active":true,
689                    "localUrl":view.local_url(),
690                    "sshForwardHint":view.ssh_forward_hint(),
691                    "loopbackOnly":true,
692                });
693                self.remote_view = Some(view);
694                self.publish_remote_frame().await?;
695                Ok(response)
696            }
697            BrowserCommand::RemoteViewStatus => Ok(self.remote_view.as_ref().map_or_else(
698                || serde_json::json!({"active":false,"loopbackOnly":true}),
699                |view| serde_json::json!({"active":true,"localUrl":view.local_url(),"sshForwardHint":view.ssh_forward_hint(),"loopbackOnly":true}),
700            )),
701            BrowserCommand::RemoteViewRevoke => {
702                if let Some(view) = self.remote_view.take() {
703                    view.revoke().await;
704                    Ok(serde_json::json!({"revoked":true}))
705                } else {
706                    Ok(serde_json::json!({"revoked":false}))
707                }
708            }
709        }
710    }
711
712    async fn publish_remote_frame(&self) -> DevelopmentResult<()> {
713        let (Some(view), Some(session), Some(revision)) = (
714            self.remote_view.as_ref(),
715            self.session.as_ref(),
716            self.revision,
717        ) else {
718            return Ok(());
719        };
720        let png = session.screenshot_png().await.map_err(browser_error)?;
721        let published = view.publish(RemoteFrame {
722            browser_revision: revision,
723            mime_type: "image/png".into(),
724            data: base64::Engine::encode(&base64::engine::general_purpose::STANDARD, png),
725        });
726        if !published {
727            return Err(DevelopmentError::Process(
728                "Remote View rejected the bounded frame".into(),
729            ));
730        }
731        Ok(())
732    }
733
734    async fn apply_remote_inputs(&mut self) -> DevelopmentResult<()> {
735        let mut inputs = Vec::new();
736        if let Some(view) = self.remote_view.as_mut() {
737            while let Ok(input) = view.try_recv_input() {
738                inputs.push(input);
739                if inputs.len() == 64 {
740                    break;
741                }
742            }
743        }
744        for input in inputs {
745            let session = self.session()?;
746            let revision = input.expected_revision();
747            let current_revision = match input {
748                RemoteInput::Click { x, y, .. } => {
749                    let (width, height) = session.viewport_size().await.map_err(browser_error)?;
750                    session
751                        .click_at_with_revision(x * width, y * height, Some(revision))
752                        .await
753                        .map_err(browser_error)?
754                        .revision
755                }
756                RemoteInput::Scroll { dx, dy, .. } => {
757                    session
758                        .scroll_with_revision(dx, dy, Some(revision))
759                        .await
760                        .map_err(browser_error)?
761                        .current_revision
762                }
763                RemoteInput::Key { key, .. } => {
764                    session
765                        .key_press_with_revision(&key, Some(revision))
766                        .await
767                        .map_err(browser_error)?
768                        .current_revision
769                }
770                RemoteInput::Text { text, .. } => {
771                    session
772                        .type_text_with_expected_revision(&text, None, Some(revision))
773                        .await
774                        .map_err(browser_error)?
775                        .current_revision
776                }
777            };
778            self.revision = Some(current_revision);
779        }
780        if self.remote_view.is_some() {
781            self.publish_remote_frame().await?;
782        }
783        Ok(())
784    }
785}
786
787fn browser_error(error: Box<dyn std::error::Error>) -> DevelopmentError {
788    DevelopmentError::Process(error.to_string())
789}
790
791#[cfg(test)]
792mod tests {
793    use super::*;
794    use std::io::{Read, Write};
795    use std::net::{TcpListener, TcpStream};
796    use std::sync::Arc;
797    use std::sync::atomic::{AtomicBool, Ordering};
798
799    #[test]
800    fn disconnected_service_reports_authoritative_state() {
801        let service = BrowserService::new(std::env::temp_dir()).unwrap();
802        let state = service.state().unwrap();
803        assert_eq!(state["connected"], false);
804        assert_eq!(state["workflowState"], "idle");
805        let error = service.observe().unwrap_err();
806        assert!(error.to_string().contains("glass.browser.start"));
807        assert_eq!(service.remote_view_status().unwrap()["active"], false);
808        assert!(
809            service
810                .open_remote_view()
811                .unwrap_err()
812                .to_string()
813                .contains("browser")
814        );
815        assert_eq!(service.revoke_remote_view().unwrap()["revoked"], false);
816    }
817
818    #[test]
819    fn resident_browser_executes_revision_safe_fixture_flow() {
820        if std::env::var("GLASS_E2E").as_deref() != Ok("1") {
821            return;
822        }
823        let chrome_path =
824            std::env::var("GLASS_CHROME_PATH").expect("GLASS_E2E=1 requires GLASS_CHROME_PATH");
825        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
826        listener.set_nonblocking(true).unwrap();
827        let address = listener.local_addr().unwrap();
828        let running = Arc::new(AtomicBool::new(true));
829        let server_running = Arc::clone(&running);
830        let server = std::thread::spawn(move || {
831            let html = br#"<!doctype html><title>Resident Glass</title><label>Name<input id="name"></label><button id="save" onclick="document.querySelector('p').textContent='Saved '+document.querySelector('#name').value">Save</button><p></p>"#;
832            while server_running.load(Ordering::Relaxed) {
833                match listener.accept() {
834                    Ok((mut stream, _)) => {
835                        let mut request = [0; 4096];
836                        let _ = stream.read(&mut request);
837                        let header = format!(
838                            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
839                            html.len()
840                        );
841                        let _ = stream.write_all(header.as_bytes());
842                        let _ = stream.write_all(html);
843                    }
844                    Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
845                        std::thread::sleep(Duration::from_millis(5));
846                    }
847                    Err(_) => break,
848                }
849            }
850        });
851        let port_probe = TcpListener::bind("127.0.0.1:0").unwrap();
852        let browser_port = port_probe.local_addr().unwrap().port();
853        drop(port_probe);
854
855        let service = BrowserService::new(std::env::temp_dir()).unwrap();
856        let started = service
857            .start(BrowserStartConfig {
858                port: browser_port,
859                chrome_path: Some(chrome_path.into()),
860                ..BrowserStartConfig::default()
861            })
862            .unwrap();
863        let browser_pid = started["browserProcessId"].as_u64().unwrap() as u32;
864        let initial = service.observe().unwrap();
865        let initial_revision = initial["consistency"]["end_revision"]
866            .as_u64()
867            .or_else(|| initial["consistency"]["endRevision"].as_u64())
868            .unwrap();
869        service
870            .navigate(
871                format!("http://{address}/fixture.html"),
872                initial_revision,
873                Duration::from_secs(30),
874            )
875            .unwrap();
876        assert!(
877            service
878                .navigate(
879                    format!("http://{address}/stale"),
880                    initial_revision,
881                    Duration::from_secs(30),
882                )
883                .unwrap_err()
884                .to_string()
885                .contains("revision")
886        );
887        let observed = service.observe().unwrap();
888        assert_eq!(observed["page"]["title"], "Resident Glass");
889        assert!(
890            service
891                .snapshot()
892                .unwrap()
893                .as_object()
894                .is_some_and(|snapshot| !snapshot.is_empty())
895        );
896        assert_eq!(
897            service
898                .semantic(SemanticObservationLevel::Structured)
899                .unwrap()["page"]["title"],
900            "Resident Glass"
901        );
902        assert!(service.diff().unwrap()["toRevision"].as_u64().is_some());
903        let revision = observed["consistency"]["end_revision"]
904            .as_u64()
905            .or_else(|| observed["consistency"]["endRevision"].as_u64())
906            .unwrap();
907        let typed = service
908            .type_text("Ada".into(), Some("Name".into()), revision)
909            .unwrap();
910        let revision = typed["currentRevision"].as_u64().unwrap();
911        service.click("Save".into(), revision).unwrap();
912        assert!(
913            service.observe().unwrap()["text"]
914                .as_str()
915                .unwrap()
916                .contains("Saved Ada")
917        );
918        let remote = service.open_remote_view().unwrap();
919        assert_eq!(remote["active"], true);
920        assert!(
921            remote["localUrl"]
922                .as_str()
923                .unwrap()
924                .starts_with("http://127.0.0.1:")
925        );
926        assert_eq!(service.remote_view_status().unwrap()["active"], true);
927        assert_eq!(service.revoke_remote_view().unwrap()["revoked"], true);
928        let observed = service.observe().unwrap();
929        let revision = observed["consistency"]["end_revision"]
930            .as_u64()
931            .or_else(|| observed["consistency"]["endRevision"].as_u64())
932            .unwrap();
933        assert_eq!(service.reload(revision).unwrap()["action"], "reload");
934        service.stop().unwrap();
935        #[cfg(unix)]
936        assert!(unsafe { libc::kill(browser_pid as i32, 0) } == -1);
937        let port_closed = (0..100).any(|_| {
938            if TcpStream::connect(("127.0.0.1", browser_port)).is_err() {
939                true
940            } else {
941                std::thread::sleep(Duration::from_millis(10));
942                false
943            }
944        });
945        assert!(port_closed, "owned browser endpoint survived resident stop");
946        running.store(false, Ordering::Relaxed);
947        server.join().unwrap();
948    }
949}