Simplify cli-config, hotreload -> devtools (drop to 0 deps, fast compile times) (#2975)

* simplify cli-config crate
* clean up configs
* add devtools crate, update cargo imports
* fix serve addr, fix websocket proxy issue
* add comment about opt profiles
* rename hot-reload to devtools

packages/cli/src/serve/mod.rs

@@ -155,9 +155,24 @@ pub async fn serve_all(
                             builder.children.clear();
                         }
 
+                        let asset_dir = dioxus_crate
+                            .dioxus_config
+                            .application
+                            .asset_dir
+                            .canonicalize()
+                            .unwrap_or(std::path::PathBuf::from("./assets"));
+
                         // If we have a build result, open it
                         for build_result in results.iter() {
-                            let child = build_result.open(&serve.server_arguments, server.fullstack_address(), &dioxus_crate.workspace_dir());
+                            let child = build_result.open(
+                                &serve.server_arguments,
+                                server.fullstack_address(),
+                                &dioxus_crate.workspace_dir(),
+                                &asset_dir,
+                                server.ip,
+                                dioxus_crate.dioxus_config.application.name.clone(),
+                                dioxus_crate.out_dir()
+                            );
                             match child {
                                 Ok(Some(child_proc)) => builder.children.push((build_result.target_platform, child_proc)),
                                 Err(e) => {

packages/cli/src/serve/output.rs

@@ -1,3 +1,4 @@
+use crate::config::{AddressArguments, Platform};
 use crate::{
     builder::{BuildResult, UpdateStage},
     builder::{Stage, TargetPlatform, UpdateBuildProgress},
@@ -18,8 +19,7 @@ use crossterm::{
     tty::IsTty,
     ExecutableCommand,
 };
-use dioxus_cli_config::{AddressArguments, Platform};
-use dioxus_hot_reload::ClientMsg;
+use dioxus_devtools::ClientMsg;
 use futures_util::{future::select_all, Future, FutureExt, StreamExt};
 use ratatui::{prelude::*, TerminalOptions, Viewport};
 use std::{

packages/cli/src/serve/output/render.rs

@@ -1,6 +1,6 @@
 use super::{BuildProgress, TraceMsg, TraceSrc};
+use crate::config::Platform;
 use ansi_to_tui::IntoText as _;
-use dioxus_cli_config::Platform;
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Color, Style, Stylize},

packages/cli/src/serve/proxy.rs

@@ -1,10 +1,10 @@
+use crate::config::WebProxyConfig;
 use crate::TraceSrc;
 use crate::{Error, Result};
-use dioxus_cli_config::WebProxyConfig;
 
 use anyhow::{anyhow, Context};
-use axum::body::Body as MyBody;
 use axum::body::Body;
+use axum::{body::Body as MyBody, response::IntoResponse};
 use axum::{
     http::StatusCode,
     routing::{any, MethodRouter},
@@ -97,7 +97,7 @@ pub(crate) fn proxy_to(
     nocache: bool,
     handle_error: fn(Error) -> Response<Body>,
 ) -> MethodRouter {
-    let client = ProxyClient::new(url);
+    let client = ProxyClient::new(url.clone());
 
     any(move |mut req: Request<MyBody>| async move {
         // Prevent request loops
@@ -115,11 +115,54 @@ pub(crate) fn proxy_to(
             "true".parse().expect("header value is valid"),
         );
 
+        // We have to throw a redirect for ws connections since the upgrade handler will not be called
+        // Our _dioxus handler will override this in the default case
+        if req.uri().scheme().map(|f| f.as_str()) == Some("ws")
+            || req.uri().scheme().map(|f| f.as_str()) == Some("wss")
+        {
+            let new_host = url.host().unwrap_or("localhost");
+            let proxied_uri = format!(
+                "{scheme}://{host}:{port}{path_and_query}",
+                scheme = req.uri().scheme_str().unwrap_or("ws"),
+                port = url.port().unwrap(),
+                host = new_host,
+                path_and_query = req
+                    .uri()
+                    .path_and_query()
+                    .map(|f| f.to_string())
+                    .unwrap_or_default()
+            );
+            tracing::info!(dx_src = ?TraceSrc::Dev, "Proxied websocket request {req:?} to {proxied_uri}");
+
+            return Ok(axum::response::Redirect::permanent(&proxied_uri).into_response());
+        }
+
         if nocache {
             crate::serve::insert_no_cache_headers(req.headers_mut());
         }
 
-        client.send(req).await.map_err(handle_error)
+        let uri = req.uri().clone();
+        let res = client.send(req).await.map_err(handle_error);
+
+        match res {
+            Ok(res) => {
+                // log assets at a different log level
+                if uri.path().starts_with("/assets")
+                    || uri.path().starts_with("/_dioxus")
+                    || uri.path().starts_with("/public")
+                {
+                    tracing::trace!(dx_src = ?TraceSrc::Dev, "[{}] {}", res.status().as_u16(), uri);
+                } else {
+                    tracing::info!(dx_src = ?TraceSrc::Dev, "[{}] {}", res.status().as_u16(), uri);
+                }
+
+                Ok(res.into_response())
+            }
+            Err(err) => {
+                tracing::error!(dx_src = ?TraceSrc::Dev, "[{}] {}", err.status().as_u16(), uri);
+                Err(err)
+            }
+        }
     })
 }
 

packages/cli/src/serve/server.rs

@@ -1,3 +1,4 @@
+use crate::config::{Platform, WebHttpsConfig};
 use crate::serve::{next_or_pending, Serve};
 use crate::{dioxus_crate::DioxusCrate, TraceSrc};
 use crate::{Error, Result};
@@ -18,8 +19,7 @@ use axum::{
     Extension, Router,
 };
 use axum_server::tls_rustls::RustlsConfig;
-use dioxus_cli_config::{Platform, WebHttpsConfig};
-use dioxus_hot_reload::{DevserverMsg, HotReloadMsg};
+use dioxus_devtools::{DevserverMsg, HotReloadMsg};
 use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures_util::stream;
 use futures_util::{stream::FuturesUnordered, StreamExt};
@@ -419,6 +419,7 @@ fn setup_router(
                 "/",
                 get(
                     |ws: WebSocketUpgrade, ext: Extension<UnboundedSender<WebSocket>>| async move {
+                        tracing::info!("Incoming hotreload websocket request: {ws:?}");
                         ws.on_upgrade(move |socket| async move { _ = ext.0.unbounded_send(socket) })
                     },
                 ),

packages/cli/src/serve/watcher.rs

@@ -5,7 +5,7 @@ use super::hot_reloading_file_map::HotreloadError;
 use crate::serve::hot_reloading_file_map::FileMap;
 use crate::TraceSrc;
 use crate::{cli::serve::Serve, dioxus_crate::DioxusCrate};
-use dioxus_hot_reload::HotReloadMsg;
+use dioxus_devtools::HotReloadMsg;
 use dioxus_html::HtmlCtx;
 use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures_util::StreamExt;