1use 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#[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}