mountaineer 0.20.0.dev1__tar.gz → 0.20.0.dev2__tar.gz

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/Cargo.lock

@@ -724,7 +724,7 @@ dependencies = [
 
 [[package]]
 name = "mountaineer"
-version = "0.20.0-dev1"
+version = "0.20.0-dev2"
 dependencies = [
  "clap",
  "console",

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/Cargo.toml

@@ -19,7 +19,7 @@ resolver = "2"
 
 [package]
 name = "mountaineer"
-version = "0.20.0-dev1"
+version = "0.20.0-dev2"
 edition = "2021"
 readme = "README.md"
 

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mountaineer
-Version: 0.20.0.dev1
+Version: 0.20.0.dev2
 Requires-Dist: pydantic>=2.5.3,<3.0.0
 Requires-Dist: fastapi>=0.114.1,<1.0.0
 Requires-Dist: inflection>=0.5.1,<1.0.0

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/crates/lib/vite/assets/entrypoints.mjs

@@ -35,18 +35,18 @@ export function mountaineerEntrypoints(entrypoints, target) {
   };
 }
 
-export function developmentClientSource(views, styles) {
+export function developmentClientSource(views, styles, base) {
   return `
-import "/@vite/client";
-import RefreshRuntime from "/@react-refresh";
+import "${base}@vite/client";
+import RefreshRuntime from "${base}@react-refresh";
 RefreshRuntime.injectIntoGlobalHook(window);
 window.$RefreshReg$ = () => {};
 window.$RefreshSig$ = () => (type) => type;
 window.__vite_plugin_react_preamble_installed__ = true;
 await Promise.all(${JSON.stringify(styles)}.map((source) => import(source)));
-const ReactModule = await import("/@id/react");
+const ReactModule = await import("${base}@id/react");
 const React = ReactModule.default ?? ReactModule;
-const ReactDOMModule = await import("/@id/react-dom/client");
+const ReactDOMModule = await import("${base}@id/react-dom/client");
 const { hydrateRoot } = ReactDOMModule.default ?? ReactDOMModule;
 const components = await Promise.all(
   ${JSON.stringify(views)}.map((source) => import(source)),

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/crates/lib/vite/assets/vite.config.mjs

@@ -29,6 +29,7 @@ const react = (
 
 const development =
   mountaineer.mode === "development" ? mountaineer : undefined;
+const developmentBase = development?.base;
 const clientBuild =
   mountaineer.mode === "build_client" ? mountaineer : undefined;
 const ssrBuild = mountaineer.mode === "build_ssr" ? mountaineer : undefined;
@@ -49,7 +50,7 @@ const styleEntries = Object.fromEntries(
 export default defineConfig({
   root: mountaineer.frontend_root,
   appType: "custom",
-  base: "./",
+  base: developmentBase ?? "./",
   clearScreen: false,
   resolve: {
     alias: [
@@ -89,7 +90,7 @@ export default defineConfig({
             name: "mountaineer:development",
             configureServer(server) {
               server.middlewares.use(
-                "/@mountaineer/client",
+                `${developmentBase}@mountaineer/client`,
                 (request, response) => {
                   const params = new URL(
                     request.url ?? "",
@@ -97,10 +98,16 @@ export default defineConfig({
                   ).searchParams;
                   const views = params
                     .getAll("view")
-                    .map((view) => `/@fs/${view.replaceAll("\\", "/")}`);
+                    .map(
+                      (view) =>
+                        `${developmentBase}@fs/${view.replaceAll("\\", "/")}`,
+                    );
                   const styles = params
                     .getAll("style")
-                    .map((style) => `/@fs/${style.replaceAll("\\", "/")}`);
+                    .map(
+                      (style) =>
+                        `${developmentBase}@fs/${style.replaceAll("\\", "/")}`,
+                    );
                   if (views.length === 0) {
                     response.statusCode = 400;
                     response.end("Missing Mountaineer view");
@@ -108,7 +115,9 @@ export default defineConfig({
                   }
 
                   response.setHeader("Content-Type", "text/javascript");
-                  response.end(developmentClientSource(views, styles));
+                  response.end(
+                    developmentClientSource(views, styles, developmentBase),
+                  );
                 },
               );
 
@@ -130,15 +139,9 @@ export default defineConfig({
   ],
   server: development
     ? {
-        host: development.host,
+        host: "127.0.0.1",
         port: development.port,
         strictPort: true,
-        cors: true,
-        origin: `http://${development.public_host}:${development.port}`,
-        hmr: {
-          host: development.public_host,
-          port: development.port,
-        },
         watch: {
           ignored: ["**/.mountaineer/**", "**/.mountaineer-vite/**"],
         },

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/crates/lib/vite/src/lib.rs

@@ -59,8 +59,8 @@ pub struct DevelopmentConfig {
     /// Root directory containing the application's frontend source.
     pub frontend_root: PathBuf,
 
-    /// Host interface Vite should listen on.
-    pub host: String,
+    /// Browser-visible path prefix routed to Vite by the public development server.
+    pub base: String,
 }
 
 /// One named Mountaineer page and its ordered layout hierarchy.
@@ -145,7 +145,7 @@ pub struct StyleBuildConfig {
 pub struct DevelopmentServer {
     child: Child,
     _directory: TempDir,
-    origin: String,
+    address: SocketAddr,
     backend_signal: PathBuf,
 }
 
@@ -157,11 +157,7 @@ impl DevelopmentServer {
         let javascript_runtime = javascript_runtime().await?;
         let directory = tempfile::tempdir()?;
         let port = reserve_loopback_port()?;
-        let public_host = match config.host.as_str() {
-            "0.0.0.0" | "::" => "127.0.0.1",
-            host => host,
-        };
-        let origin = format!("http://{public_host}:{port}");
+        let address = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);
         let backend_signal = directory.path().join("backend-generation");
         fs::write(&backend_signal, b"1")?;
         write_config(
@@ -170,8 +166,7 @@ impl DevelopmentServer {
                 frontend_root: &frontend_root,
                 toolchain_package_json: toolchain_root.join("package.json"),
                 mode: Mode::Development {
-                    host: &config.host,
-                    public_host,
+                    base: &config.base,
                     port,
                     backend_signal: &backend_signal,
                 },
@@ -189,7 +184,6 @@ impl DevelopmentServer {
         .stderr(Stdio::inherit())
         .kill_on_drop(true)
         .spawn()?;
-        let address = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);
         let ready = tokio::select! {
             result = wait_until_ready(address, Duration::from_secs(15)) => result,
             status = child.wait() => {
@@ -208,14 +202,14 @@ impl DevelopmentServer {
         Ok(Self {
             child,
             _directory: directory,
-            origin,
+            address,
             backend_signal,
         })
     }
 
-    /// Browser-visible origin of the running Vite server.
-    pub fn origin(&self) -> &str {
-        &self.origin
+    /// Loopback address of the running Vite server.
+    pub fn address(&self) -> SocketAddr {
+        self.address
     }
 
     /// Invalidates Vite's backend-dependent modules and reloads connected browsers.
@@ -381,8 +375,7 @@ struct Config<'a> {
 #[serde(tag = "mode", rename_all = "snake_case")]
 enum Mode<'a> {
     Development {
-        host: &'a str,
-        public_host: &'a str,
+        base: &'a str,
         port: u16,
         backend_signal: &'a Path,
     },

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mountaineer"
-version = "0.20.0.dev1"
+version = "0.20.0.dev2"
 description = "Mountaineer is a batteries-included webapp framework for Python."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"

{mountaineer-0.20.0.dev1 → mountaineer-0.20.0.dev2}/src/cli/development/mod.rs

@@ -3,7 +3,7 @@ mod proxy;
 
 use self::{
     hot_reload::{discover_imports, ActiveWorker, PythonHotReload},
-    proxy::{reserve_loopback_port, serve_proxy, wait_until_ready},
+    proxy::{reserve_loopback_port, serve_proxy, wait_until_ready, VITE_PROXY_PREFIX},
 };
 use super::{
     config::{write_payload, LaunchConfig, RuntimeMode, ServerConfig},
@@ -65,7 +65,7 @@ pub(super) async fn run(args: &[String], python: String) -> Result<()> {
     let payload_dir = tempfile::tempdir()?;
     let mut vite = ViteDevServer::spawn(ViteConfig {
         frontend_root: config.frontend_root.clone(),
-        host: config.host.clone(),
+        base: VITE_PROXY_PREFIX.to_string(),
     })
     .await?;
     let mut generation = 1;
@@ -77,7 +77,7 @@ pub(super) async fn run(args: &[String], python: String) -> Result<()> {
         &payload_dir,
         &mut hot_reload,
         generation,
-        vite.origin(),
+        VITE_PROXY_PREFIX.trim_end_matches('/'),
         true,
     )
     .await?;
@@ -90,7 +90,7 @@ pub(super) async fn run(args: &[String], python: String) -> Result<()> {
         debounce: Duration::from_millis(debounce_ms),
     })?;
 
-    let mut proxy_task = tokio::spawn(serve_proxy(listener, active_target.clone()));
+    let mut proxy_task = tokio::spawn(serve_proxy(listener, active_target.clone(), vite.address()));
     finish_startup_spinner();
     status(
         Tone::Accent,
@@ -166,7 +166,7 @@ pub(super) async fn run(args: &[String], python: String) -> Result<()> {
                             &payload_dir,
                             &mut hot_reload,
                             generation,
-                            vite.origin(),
+                            VITE_PROXY_PREFIX.trim_end_matches('/'),
                             refresh_imports,
                         ).await {
                             Ok((candidate, target)) => {
@@ -219,7 +219,7 @@ pub(super) async fn run(args: &[String], python: String) -> Result<()> {
                             &payload_dir,
                             &mut candidate_strategy,
                             generation,
-                            vite.origin(),
+                            VITE_PROXY_PREFIX.trim_end_matches('/'),
                             true,
                         ).await {
                             Ok((candidate, target)) => {

mountaineer-0.20.0.dev2/src/cli/development/proxy.rs

@@ -0,0 +1,148 @@
+use crate::cli::{
+    invalid,
+    output::{status, Tone},
+    Result,
+};
+use std::{
+    net::{Ipv4Addr, SocketAddr},
+    sync::Arc,
+    time::Duration,
+};
+use tokio::{
+    io::{copy_bidirectional, AsyncReadExt, AsyncWriteExt},
+    net::{TcpListener, TcpStream},
+    sync::RwLock,
+    time::{sleep, Instant},
+};
+
+pub(super) const VITE_PROXY_PREFIX: &str = "/__mountaineer__/";
+
+pub(super) async fn wait_until_ready(address: SocketAddr, wait: Duration) -> Result<()> {
+    let deadline = Instant::now() + wait;
+    loop {
+        if TcpStream::connect(address).await.is_ok() {
+            return Ok(());
+        }
+        if Instant::now() >= deadline {
+            return Err(invalid(format!(
+                "timed out waiting for backend at {address}"
+            )));
+        }
+        sleep(Duration::from_millis(50)).await;
+    }
+}
+
+pub(super) async fn serve_proxy(
+    listener: TcpListener,
+    active_target: Arc<RwLock<Option<SocketAddr>>>,
+    vite_target: SocketAddr,
+) -> Result<()> {
+    loop {
+        let (inbound, _) = listener.accept().await?;
+        let active_target = active_target.clone();
+        tokio::spawn(async move {
+            if let Err(error) = proxy_connection(inbound, active_target, vite_target).await {
+                status(
+                    Tone::Warning,
+                    "Warning",
+                    format!("development proxy connection failed: {error}"),
+                );
+            }
+        });
+    }
+}
+
+async fn proxy_connection(
+    mut inbound: TcpStream,
+    active_target: Arc<RwLock<Option<SocketAddr>>>,
+    vite_target: SocketAddr,
+) -> std::io::Result<()> {
+    let mut request = Vec::with_capacity(1024);
+    let mut chunk = [0_u8; 1024];
+    while !request.windows(4).any(|window| window == b"\r\n\r\n") && request.len() < 65536 {
+        let read = inbound.read(&mut chunk).await?;
+        if read == 0 {
+            return Ok(());
+        }
+        request.extend_from_slice(&chunk[..read]);
+    }
+
+    let vite_request = is_vite_request(&request);
+    let target = if vite_request {
+        Some(vite_target)
+    } else {
+        *active_target.read().await
+    };
+    let Some(target) = target else {
+        inbound
+            .write_all(
+                b"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 23\r\n\r\nBackend is starting up.",
+            )
+            .await?;
+        return Ok(());
+    };
+
+    let mut outbound = TcpStream::connect(target).await?;
+    if vite_request {
+        rewrite_host(&mut request, vite_target);
+    }
+    if !is_websocket_upgrade(&request) {
+        close_after_response(&mut request);
+    }
+    outbound.write_all(&request).await?;
+    copy_bidirectional(&mut inbound, &mut outbound).await?;
+    Ok(())
+}
+
+fn rewrite_host(request: &mut Vec<u8>, host: SocketAddr) {
+    let Some(host_start) = request
+        .windows(b"\r\nhost:".len())
+        .position(|window| window.eq_ignore_ascii_case(b"\r\nhost:"))
+        .map(|position| position + 2)
+    else {
+        return;
+    };
+    let Some(host_end) = request[host_start..]
+        .windows(2)
+        .position(|window| window == b"\r\n")
+        .map(|position| host_start + position)
+    else {
+        return;
+    };
+    request.splice(host_start..host_end, format!("Host: {host}").bytes());
+}
+
+fn is_websocket_upgrade(request: &[u8]) -> bool {
+    std::str::from_utf8(request)
+        .is_ok_and(|request| request.to_ascii_lowercase().contains("upgrade: websocket"))
+}
+
+fn close_after_response(request: &mut Vec<u8>) {
+    if let Some(headers_end) = request.windows(4).position(|window| window == b"\r\n\r\n") {
+        request.splice(
+            headers_end..headers_end,
+            b"\r\nConnection: close".iter().copied(),
+        );
+    }
+}
+
+fn is_vite_request(request: &[u8]) -> bool {
+    let Some(line_end) = request.iter().position(|byte| *byte == b'\n') else {
+        return false;
+    };
+    let Ok(request_line) = std::str::from_utf8(&request[..line_end]) else {
+        return false;
+    };
+    request_line
+        .split_ascii_whitespace()
+        .nth(1)
+        .is_some_and(|path| path.starts_with(VITE_PROXY_PREFIX))
+}
+
+pub(super) fn reserve_loopback_port() -> Result<u16> {
+    // ponytail: a short bind/drop race is acceptable; pass an open socket to
+    // Python if real-world collisions make this observable.
+    Ok(std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?
+        .local_addr()?
+        .port())
+}

mountaineer-0.20.0.dev1/src/cli/development/proxy.rs

@@ -1,69 +0,0 @@
-use crate::cli::{
-    invalid,
-    output::{status, Tone},
-    Result,
-};
-use std::{
-    net::{Ipv4Addr, SocketAddr},
-    sync::Arc,
-    time::Duration,
-};
-use tokio::{
-    io::{copy_bidirectional, AsyncWriteExt},
-    net::{TcpListener, TcpStream},
-    sync::RwLock,
-    time::{sleep, Instant},
-};
-
-pub(super) async fn wait_until_ready(address: SocketAddr, wait: Duration) -> Result<()> {
-    let deadline = Instant::now() + wait;
-    loop {
-        if TcpStream::connect(address).await.is_ok() {
-            return Ok(());
-        }
-        if Instant::now() >= deadline {
-            return Err(invalid(format!(
-                "timed out waiting for backend at {address}"
-            )));
-        }
-        sleep(Duration::from_millis(50)).await;
-    }
-}
-
-pub(super) async fn serve_proxy(
-    listener: TcpListener,
-    active_target: Arc<RwLock<Option<SocketAddr>>>,
-) -> Result<()> {
-    loop {
-        let (mut inbound, _) = listener.accept().await?;
-        let target = *active_target.read().await;
-        tokio::spawn(async move {
-            let Some(target) = target else {
-                let _ = inbound
-                    .write_all(
-                        b"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 23\r\n\r\nBackend is starting up.",
-                    )
-                    .await;
-                return;
-            };
-            match TcpStream::connect(target).await {
-                Ok(mut outbound) => {
-                    let _ = copy_bidirectional(&mut inbound, &mut outbound).await;
-                }
-                Err(error) => status(
-                    Tone::Warning,
-                    "Warning",
-                    format!("backend proxy connection failed: {error}"),
-                ),
-            }
-        });
-    }
-}
-
-pub(super) fn reserve_loopback_port() -> Result<u16> {
-    // ponytail: a short bind/drop race is acceptable; pass an open socket to
-    // Python if real-world collisions make this observable.
-    Ok(std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?
-        .local_addr()?
-        .port())
-}