Skip to content

The design language that makes your AI harness better at design.

JavaScript

live-generate: the dev-server watch answers https and every address

Abdul Wahab2f4d4fb4fc9c
diff --git a/crates/live/src/dev_url.rs b/crates/live/src/dev_url.rs
index 2fdbe60e0..4d0824230 100644
--- a/crates/live/src/dev_url.rs
+++ b/crates/live/src/dev_url.rs
@@ -49,37 +49,47 @@ pub fn probe(candidates: &[String], token: &str) -> Option<String> {
/// Whether something accepts connections at the URL's host and port: the
/// liveness check `live-generate` runs while it waits for a page, cheap
-/// enough for every few seconds and immune to a slow first render.
+/// enough for every few seconds and immune to a slow first render. Any
+/// scheme: a dev server behind https accepts the TCP connection like any
+/// other, so no TLS is needed to know it is up.
pub fn answers(url: &str) -> bool {
- let Some(rest) = url.strip_prefix("http://") else {
- return false;
- };
- let Some(host_port) = rest.split('/').next() else {
- return false;
+ endpoint(url).is_some_and(|(host, port, _)| connect(host, port).is_some())
+}
+
+/// `(host, port, host:port as written)` from an `http://` or `https://`
+/// origin; None for anything else.
+fn endpoint(url: &str) -> Option<(&str, u16, &str)> {
+ let (rest, default_port) = match url.strip_prefix("http://") {
+ Some(rest) => (rest, 80),
+ None => (url.strip_prefix("https://")?, 443),
};
+ let host_port = rest.split('/').next()?;
let (host, port) = match host_port.rsplit_once(':') {
- Some((h, p)) => match p.parse::<u16>() {
- Ok(port) => (h, port),
- Err(_) => return false,
- },
- None => (host_port, 80),
- };
- let Some(addr) = (host, port).to_socket_addrs().ok().and_then(|mut a| a.next()) else {
- return false;
+ Some((h, p)) => (h, p.parse::<u16>().ok()?),
+ None => (host_port, default_port),
};
- TcpStream::connect_timeout(&addr, Duration::from_millis(300)).is_ok()
+ Some((host.trim_start_matches('[').trim_end_matches(']'), port, host_port))
+}
+
+/// A connection to the first address the host resolves to that accepts
+/// one: `localhost` can resolve to `::1` ahead of `127.0.0.1` while the dev
+/// server listens on only one of them.
+fn connect(host: &str, port: u16) -> Option<TcpStream> {
+ (host, port)
+ .to_socket_addrs()
+ .ok()?
+ .find_map(|addr| TcpStream::connect_timeout(&addr, Duration::from_millis(300)).ok())
}
/// A minimal HTTP/1.0 GET of `/`; returns the response body on any 2xx.
+/// Plain http only: the tag check needs the document, and an https dev
+/// server would need TLS to hand it over.
fn fetch_root(url: &str) -> Option<String> {
- let rest = url.strip_prefix("http://")?;
- let host_port = rest.split('/').next()?;
- let (host, port) = match host_port.rsplit_once(':') {
- Some((h, p)) => (h, p.parse::<u16>().ok()?),
- None => (host_port, 80),
- };
- let addr = (host, port).to_socket_addrs().ok()?.next()?;
- let mut stream = TcpStream::connect_timeout(&addr, Duration::from_millis(300)).ok()?;
+ if !url.starts_with("http://") {
+ return None;
+ }
+ let (host, port, host_port) = endpoint(url)?;
+ let mut stream = connect(host, port)?;
stream.set_read_timeout(Some(Duration::from_millis(1500))).ok()?;
stream.set_write_timeout(Some(Duration::from_millis(300))).ok()?;
stream
@@ -138,6 +148,29 @@ mod tests {
assert_eq!(probe(&[theirs], "abc-123"), None);
}
+ #[test]
+ fn answers_whatever_scheme_the_page_uses() {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let port = listener.local_addr().unwrap().port();
+ assert!(answers(&format!("http://127.0.0.1:{}/", port)));
+ assert!(
+ answers(&format!("https://127.0.0.1:{}/", port)),
+ "an https dev server accepts the connection like any other"
+ );
+ assert!(!answers(&format!("ftp://127.0.0.1:{}/", port)));
+ drop(listener);
+ assert!(!answers(&format!("https://127.0.0.1:{}/", port)));
+ }
+
+ #[test]
+ fn answers_tries_every_address_the_host_resolves_to() {
+ // `localhost` resolves to ::1 ahead of 127.0.0.1 on some hosts; a
+ // server listening on just one of them still answers.
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let port = listener.local_addr().unwrap().port();
+ assert!(answers(&format!("http://localhost:{}/", port)));
+ }
+
#[test]
fn env_override_replaces_the_default_list() {
let c = candidates(Some("http://localhost:9999, http://127.0.0.1:7777/"));