feat: add --open to deno serve to open server in browser

cli/args/flags.rs

@@ -343,6 +343,7 @@ pub struct ServeFlags {
   pub port: u16,
   pub host: String,
   pub worker_count: Option<usize>,
+  pub open_site: bool,
 }
 
 impl ServeFlags {
@@ -354,6 +355,7 @@ impl ServeFlags {
       port,
       host: host.to_owned(),
       worker_count: None,
+      open_site: false,
     }
   }
 }
@@ -2875,7 +2877,7 @@ Start a server defined in server.ts, watching for changes and running on port 50
         .long("host")
         .help("The TCP address to serve on, defaulting to 0.0.0.0 (all interfaces)")
         .value_parser(serve_host_validator),
-    )
+    ).arg(Arg::new("open_site").long("open").help("Open the browser on the address that the server is running on.").action(ArgAction::SetTrue))
     .arg(
       parallel_arg("multiple server workers")
     )
@@ -4971,6 +4973,7 @@ fn serve_parse(
   let host = matches
     .remove_one::<String>("host")
     .unwrap_or_else(|| "0.0.0.0".to_owned());
+  let open_site = matches.remove_one::<bool>("open_site").unwrap_or(false);
 
   let worker_count = parallel_arg_parse(matches).map(|v| v.get());
 
@@ -5017,6 +5020,7 @@ fn serve_parse(
     port,
     host,
     worker_count,
+    open_site,
   });
 
   Ok(())

cli/tools/serve.rs

@@ -44,10 +44,33 @@ pub async fn serve(
   maybe_npm_install(&factory).await?;
 
   let worker_factory = factory.create_cli_main_worker_factory().await?;
+
+  if serve_flags.open_site {
+    let host: String;
+    if serve_flags.host == "0.0.0.0" || serve_flags.host == "127.0.0.1" {
+      host = "http://127.0.0.1".to_string();
+    } else if serve_flags.host == "localhost" {
+      host = "http://localhost".to_string();
+    } else {
+      host = format!("https://{}", serve_flags.host);
+    }
+    let port = serve_flags.port;
+    let browser_tab_open_result = open::that_detached(format!("{host}:{port}"));
+    if browser_tab_open_result.is_ok() {
+      log::info!(
+        "{}: Opened the browser on the address that the server is running on",
+        crate::colors::green("deno serve")
+      );
+    } else {
+      log::info!("{}: Couldn't open the browser on the address that the server is running on", crate::colors::red("deno serve"));
+    }
+  }
+
   let hmr = serve_flags
     .watch
     .map(|watch_flags| watch_flags.hmr)
     .unwrap_or(false);
+
   do_serve(
     worker_factory,
     main_module.clone(),

tests/integration/serve_tests.rs

@@ -171,6 +171,43 @@ impl ServeClient {
 
     return self.endpoint.borrow().clone().unwrap();
   }
+
+  // Check if a new browser tab has been opened by checking
+  // stderr includes the target output expected
+  fn check_tab_opened(&self) {
+    let mut buffer = self.output_buf.borrow_mut();
+    let mut temp_buf = [0u8; 64];
+    let mut child = self.child.borrow_mut();
+    let stderr = child.stderr.as_mut().unwrap();
+
+    let start = std::time::Instant::now();
+
+    // Loop to check for "hello" in the output
+    loop {
+      if start.elapsed() > Duration::from_secs(5) {
+        panic!("timed out waiting for the browser tab to be opened.");
+      }
+
+      let read = stderr.read(&mut temp_buf).unwrap();
+      buffer.extend_from_slice(&temp_buf[..read]);
+
+      let target_output =
+        "browser on the address that the server is running on".as_bytes();
+      let target_index = buffer
+        .windows(target_output.len())
+        .position(|window| window == target_output);
+      match target_index {
+        Some(_) => {
+          break;
+        }
+        None =>
+        // Sleep for a short duration to avoid busy-waiting
+        {
+          std::thread::sleep(Duration::from_millis(5))
+        }
+      }
+    }
+  }
 }
 
 #[tokio::test]
@@ -198,6 +235,35 @@ async fn deno_serve_no_args() {
   assert_eq!(body, "deno serve with no args in fetch() works!");
 }
 
+#[tokio::test]
+async fn deno_serve_open_browser() {
+  let client = ServeClientBuilder(
+    util::deno_cmd()
+      .current_dir(util::testdata_path())
+      .arg("serve")
+      .arg("--open")
+      .arg("-L")
+      .arg("debug")
+      .arg("-A")
+      .arg("--port")
+      .arg("0")
+      .arg("./serve/no_args.ts")
+      .stdout_piped()
+      .stderr_piped(),
+    None,
+  );
+
+  let serve_client = client.entry_point("./serve/no_args.ts").build();
+  serve_client.check_tab_opened();
+  let result_unwrapped = serve_client.get().send().await;
+  let res = result_unwrapped.unwrap();
+  assert_eq!(200, res.status());
+
+  let body = res.text().await.unwrap();
+  assert_eq!(body, "deno serve with no args in fetch() works!");
+  serve_client.kill();
+}
+
 #[tokio::test]
 async fn deno_serve_parallel() {
   let client = ServeClient::builder()