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/Cargo.toml

@@ -16,7 +16,7 @@ thiserror = { workspace = true }
 wasm-bindgen-cli-support = "0.2"
 wasm-bindgen-shared = "0.2"
 colored = "2.0.0"
-dioxus-cli-config = { workspace = true, features = ["cli"], default-features = false }
+dioxus-cli-config = { workspace = true }
 
 # features
 log = "0.4.14"
@@ -78,6 +78,7 @@ toml_edit = "0.22.20"
 
 # bundling
 tauri-bundler = { workspace = true }
+tauri-utils = { workspace = true }
 
 # formatting
 # syn = { workspace = true }
@@ -95,7 +96,7 @@ dioxus-rsx-hotreload = { workspace = true }
 dioxus-html = { workspace = true, features = ["hot-reload-context"] }
 dioxus-core = { workspace = true, features = ["serialize"] }
 dioxus-core-types = { workspace = true }
-dioxus-hot-reload = { workspace = true, features = ["serve"] }
+dioxus-devtools = { workspace = true }
 ignore = "0.4.22"
 env_logger = "0.11.3"
 
@@ -119,9 +120,7 @@ built = { version = "=0.7.4", features = ["git2"] }
 default = []
 plugin = []
 tokio-console = ["dep:console-subscriber"]
-
-# when releasing dioxus, we want to enable wasm-opt
-wasm-opt = ["dep:wasm-opt"]
+# optimizations = ["dep:wasm-opt"]
 
 [[bin]]
 path = "src/main.rs"

packages/cli/src/builder/cargo.rs

@@ -10,11 +10,11 @@ use crate::builder::progress::CargoBuildResult;
 use crate::builder::progress::Stage;
 use crate::builder::progress::UpdateBuildProgress;
 use crate::builder::progress::UpdateStage;
+use crate::config::Platform;
 use crate::link::LinkCommand;
 use crate::Result;
 use crate::TraceSrc;
 use anyhow::Context;
-use dioxus_cli_config::Platform;
 use futures_channel::mpsc::UnboundedSender;
 use manganis_cli_support::AssetManifest;
 use manganis_cli_support::ManganisSupportGuard;
@@ -115,10 +115,6 @@ impl BuildRequest {
             let hash = &hash.trim_start_matches('g')[..4];
             dioxus_version.push_str(&format!("-{hash}"));
         }
-        let _guard = dioxus_cli_config::__private::save_config(
-            &self.dioxus_crate.dioxus_config,
-            &dioxus_version,
-        );
         let _manganis_support = ManganisSupportGuard::default();
         let _asset_guard =
             AssetConfigDropGuard::new(self.dioxus_crate.dioxus_config.web.app.base_path.as_deref());

packages/cli/src/builder/mod.rs

@@ -1,8 +1,8 @@
 use crate::cli::serve::ServeArguments;
+use crate::config::Platform;
 use crate::dioxus_crate::DioxusCrate;
 use crate::Result;
 use crate::{build::Build, TraceSrc};
-use dioxus_cli_config::{Platform, RuntimeCLIArguments};
 use futures_util::stream::select_all;
 use futures_util::StreamExt;
 use std::net::SocketAddr;
@@ -96,7 +96,6 @@ impl BuildRequest {
             Platform::StaticGeneration | Platform::Fullstack => {
                 Self::new_fullstack(dioxus_crate.clone(), build_arguments, serve)?
             }
-            _ => unimplemented!("Unknown platform: {platform:?}"),
         })
     }
 
@@ -159,11 +158,16 @@ pub(crate) struct BuildResult {
 
 impl BuildResult {
     /// Open the executable if this is a native build
+    #[allow(clippy::too_many_arguments)]
     pub fn open(
         &self,
         serve: &ServeArguments,
         fullstack_address: Option<SocketAddr>,
         workspace: &std::path::Path,
+        asset_root: &std::path::Path,
+        devserver_addr: SocketAddr,
+        app_title: String,
+        out_dir: PathBuf,
     ) -> std::io::Result<Option<Child>> {
         match self.target_platform {
             TargetPlatform::Web => {
@@ -174,13 +178,7 @@ impl BuildResult {
                 tracing::info!(dx_src = ?TraceSrc::Dev, "Launching desktop app at {} 🎉", self.executable.display());
             }
             TargetPlatform::Server => {
-                if let Some(fullstack_address) = fullstack_address {
-                    tracing::info!(
-                        dx_src = ?TraceSrc::Dev,
-                        "Launching fullstack server on http://{:?} 🎉",
-                        fullstack_address
-                    );
-                }
+                // shut this up for now - the web app will take priority in logging
             }
             TargetPlatform::Liveview => {
                 if let Some(fullstack_address) = fullstack_address {
@@ -195,19 +193,36 @@ impl BuildResult {
 
         tracing::info!(dx_src = ?TraceSrc::Dev, "Press [o] to open the app manually.");
 
-        let arguments = RuntimeCLIArguments::new(serve.address.address(), fullstack_address);
         let executable = self.executable.canonicalize()?;
         let mut cmd = Command::new(executable);
-        cmd
-            // When building the fullstack server, we need to forward the serve arguments (like port) to the fullstack server through env vars
-            .env(
-                dioxus_cli_config::__private::SERVE_ENV,
-                serde_json::to_string(&arguments).unwrap(),
-            )
-            .stderr(Stdio::piped())
+
+        // Set the env vars that the clients will expect
+        // These need to be stable within a release version (ie 0.6.0)
+        cmd.env(dioxus_cli_config::CLI_ENABLED_ENV, "true");
+        if let Some(addr) = fullstack_address {
+            cmd.env(dioxus_cli_config::SERVER_IP_ENV, addr.ip().to_string());
+            cmd.env(dioxus_cli_config::SERVER_PORT_ENV, addr.port().to_string());
+        }
+        cmd.env(
+            dioxus_cli_config::ALWAYS_ON_TOP_ENV,
+            serve.always_on_top.unwrap_or(true).to_string(),
+        );
+        cmd.env(
+            dioxus_cli_config::ASSET_ROOT_ENV,
+            asset_root.display().to_string(),
+        );
+        cmd.env(
+            dioxus_cli_config::DEVSERVER_RAW_ADDR_ENV,
+            devserver_addr.to_string(),
+        );
+        cmd.env(dioxus_cli_config::APP_TITLE_ENV, app_title);
+        cmd.env(dioxus_cli_config::OUT_DIR, out_dir.display().to_string());
+
+        cmd.stderr(Stdio::piped())
             .stdout(Stdio::piped())
             .kill_on_drop(true)
             .current_dir(workspace);
+
         Ok(Some(cmd.spawn()?))
     }
 }

packages/cli/src/builder/web.rs

@@ -132,11 +132,11 @@ impl BuildRequest {
 
         // Only run wasm-opt if the feature is enabled
         // Wasm-opt has an expensive build script that makes it annoying to keep enabled for iterative dev
-        #[cfg(feature = "wasm-opt")]
+        #[cfg(feature = "optimizations")]
         {
             // Run wasm-opt if this is a release build
             if self.build_arguments.release {
-                use dioxus_cli_config::WasmOptLevel;
+                use crate::config::WasmOptLevel;
 
                 tracing::info!(dx_src = ?TraceSrc::Build, "Running optimization with wasm-opt...");
                 let mut options = match self.dioxus_crate.dioxus_config.web.wasm_opt.level {

packages/cli/src/cli/build.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
+use crate::config::Platform;
 use anyhow::Context;
-use dioxus_cli_config::Platform;
 
 use crate::{
     builder::{BuildRequest, TargetPlatform},

packages/cli/src/cli/serve.rs

@@ -1,7 +1,7 @@
+use crate::config::AddressArguments;
 use crate::{settings, tracer::CLILogControl, DioxusCrate};
 use anyhow::Context;
 use build::Build;
-use dioxus_cli_config::AddressArguments;
 use std::ops::Deref;
 
 use super::*;

packages/cli/src/config.rs

@@ -0,0 +1,668 @@
+use clap::Parser;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt::Display;
+use std::net::{IpAddr, SocketAddr};
+use std::path::PathBuf;
+use std::str::FromStr;
+
+#[derive(
+    Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Debug, Default,
+)]
+#[derive(clap::ValueEnum)]
+#[non_exhaustive]
+pub enum Platform {
+    /// Targeting the web platform using WASM
+    #[clap(name = "web")]
+    #[serde(rename = "web")]
+    #[default]
+    Web,
+
+    /// Targeting the desktop platform using Tao/Wry-based webview
+    #[clap(name = "desktop")]
+    #[serde(rename = "desktop")]
+    Desktop,
+
+    /// Targeting the server platform using Axum and Dioxus-Fullstack
+    #[clap(name = "fullstack")]
+    #[serde(rename = "fullstack")]
+    Fullstack,
+
+    /// Targeting the static generation platform using SSR and Dioxus-Fullstack
+    #[ clap(name = "static-generation")]
+    #[serde(rename = "static-generation")]
+    StaticGeneration,
+
+    /// Targeting the static generation platform using SSR and Dioxus-Fullstack
+    #[clap(name = "liveview")]
+    #[serde(rename = "liveview")]
+    Liveview,
+}
+
+/// An error that occurs when a platform is not recognized
+pub struct UnknownPlatformError;
+
+impl std::error::Error for UnknownPlatformError {}
+
+impl std::fmt::Debug for UnknownPlatformError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Unknown platform")
+    }
+}
+impl std::fmt::Display for UnknownPlatformError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Unknown platform")
+    }
+}
+
+impl FromStr for Platform {
+    type Err = UnknownPlatformError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "web" => Ok(Self::Web),
+            "desktop" => Ok(Self::Desktop),
+            "fullstack" => Ok(Self::Fullstack),
+            "static-generation" => Ok(Self::StaticGeneration),
+            "liveview" => Ok(Self::Liveview),
+            _ => Err(UnknownPlatformError),
+        }
+    }
+}
+
+impl Display for Platform {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let feature = self.feature_name();
+        f.write_str(feature)
+    }
+}
+
+impl Platform {
+    /// All platforms the dioxus CLI supports
+    pub const ALL: &'static [Self] = &[
+        Platform::Web,
+        Platform::Desktop,
+        Platform::Fullstack,
+        Platform::StaticGeneration,
+    ];
+
+    /// Get the feature name for the platform in the dioxus crate
+    pub fn feature_name(&self) -> &str {
+        match self {
+            Platform::Web => "web",
+            Platform::Desktop => "desktop",
+            Platform::Fullstack => "fullstack",
+            Platform::StaticGeneration => "static-generation",
+            Platform::Liveview => "liveview",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DioxusConfig {
+    pub application: ApplicationConfig,
+
+    #[serde(default)]
+    pub web: WebConfig,
+
+    #[serde(default)]
+    pub desktop: DesktopConfig,
+
+    #[serde(default)]
+    pub bundle: BundleConfig,
+}
+
+impl Default for DioxusConfig {
+    fn default() -> Self {
+        let name = default_name();
+        Self {
+            application: ApplicationConfig {
+                name: name.clone(),
+                default_platform: default_platform(),
+                out_dir: out_dir_default(),
+                asset_dir: asset_dir_default(),
+
+                sub_package: None,
+            },
+            web: WebConfig {
+                app: WebAppConfig {
+                    title: default_title(),
+                    base_path: None,
+                },
+                proxy: vec![],
+                watcher: Default::default(),
+                resource: WebResourceConfig {
+                    dev: WebDevResourceConfig {
+                        style: vec![],
+                        script: vec![],
+                    },
+                    style: Some(vec![]),
+                    script: Some(vec![]),
+                },
+                https: WebHttpsConfig {
+                    enabled: None,
+                    mkcert: None,
+                    key_path: None,
+                    cert_path: None,
+                },
+                pre_compress: true,
+                wasm_opt: Default::default(),
+            },
+            desktop: DesktopConfig::default(),
+            bundle: BundleConfig {
+                identifier: Some(format!("io.github.{name}")),
+                publisher: Some(name),
+                ..Default::default()
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApplicationConfig {
+    #[serde(default = "default_name")]
+    pub name: String,
+
+    #[serde(default = "default_platform")]
+    pub default_platform: Platform,
+
+    #[serde(default = "out_dir_default")]
+    pub out_dir: PathBuf,
+
+    #[serde(default = "asset_dir_default")]
+    pub asset_dir: PathBuf,
+
+    #[serde(default)]
+    pub sub_package: Option<String>,
+}
+
+fn default_name() -> String {
+    "my-cool-project".into()
+}
+
+fn default_platform() -> Platform {
+    Platform::Web
+}
+
+fn asset_dir_default() -> PathBuf {
+    PathBuf::from("public")
+}
+
+fn out_dir_default() -> PathBuf {
+    PathBuf::from("dist")
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebConfig {
+    #[serde(default)]
+    pub app: WebAppConfig,
+    #[serde(default)]
+    pub proxy: Vec<WebProxyConfig>,
+    #[serde(default)]
+    pub watcher: WebWatcherConfig,
+    #[serde(default)]
+    pub resource: WebResourceConfig,
+    #[serde(default)]
+    pub https: WebHttpsConfig,
+    /// Whether to enable pre-compression of assets and wasm during a web build in release mode
+    #[serde(default = "true_bool")]
+    pub pre_compress: bool,
+    /// The wasm-opt configuration
+    #[serde(default)]
+    pub wasm_opt: WasmOptConfig,
+}
+
+impl Default for WebConfig {
+    fn default() -> Self {
+        Self {
+            pre_compress: true_bool(),
+            app: Default::default(),
+            https: Default::default(),
+            wasm_opt: Default::default(),
+            proxy: Default::default(),
+            watcher: Default::default(),
+            resource: Default::default(),
+        }
+    }
+}
+
+/// Represents configuration items for the desktop platform.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DesktopConfig {
+    /// Describes whether a debug-mode desktop app should be always-on-top.
+    #[serde(default)]
+    pub always_on_top: bool,
+}
+
+impl Default for DesktopConfig {
+    fn default() -> Self {
+        Self {
+            always_on_top: true,
+        }
+    }
+}
+
+/// The wasm-opt configuration
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct WasmOptConfig {
+    /// The wasm-opt level to use for release builds [default: s]
+    /// Options:
+    /// - z: optimize aggressively for size
+    /// - s: optimize for size
+    /// - 1: optimize for speed
+    /// - 2: optimize for more for speed
+    /// - 3: optimize for even more for speed
+    /// - 4: optimize aggressively for speed
+    #[serde(default)]
+    pub level: WasmOptLevel,
+
+    /// Keep debug symbols in the wasm file
+    #[serde(default = "false_bool")]
+    pub debug: bool,
+}
+
+/// The wasm-opt level to use for release web builds [default: 4]
+#[derive(Default, Debug, Copy, Clone, Serialize, Deserialize)]
+pub enum WasmOptLevel {
+    /// Optimize aggressively for size
+    #[serde(rename = "z")]
+    Z,
+    /// Optimize for size
+    #[serde(rename = "s")]
+    S,
+    /// Don't optimize
+    #[serde(rename = "0")]
+    Zero,
+    /// Optimize for speed
+    #[serde(rename = "1")]
+    One,
+    /// Optimize for more for speed
+    #[serde(rename = "2")]
+    Two,
+    /// Optimize for even more for speed
+    #[serde(rename = "3")]
+    Three,
+    /// Optimize aggressively for speed
+    #[serde(rename = "4")]
+    #[default]
+    Four,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebAppConfig {
+    #[serde(default = "default_title")]
+    pub title: String,
+    pub base_path: Option<String>,
+}
+
+impl WebAppConfig {
+    /// Get the normalized base path for the application with `/` trimmed from both ends. If the base path is not set, this will return `.`.
+    pub fn base_path(&self) -> &str {
+        match &self.base_path {
+            Some(path) => path.trim_matches('/'),
+            None => ".",
+        }
+    }
+}
+
+impl Default for WebAppConfig {
+    fn default() -> Self {
+        Self {
+            title: default_title(),
+            base_path: None,
+        }
+    }
+}
+
+fn default_title() -> String {
+    "dioxus | ⛺".into()
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebProxyConfig {
+    pub backend: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebWatcherConfig {
+    #[serde(default = "watch_path_default")]
+    pub watch_path: Vec<PathBuf>,
+
+    #[serde(default)]
+    pub reload_html: bool,
+
+    #[serde(default = "true_bool")]
+    pub index_on_404: bool,
+}
+
+impl Default for WebWatcherConfig {
+    fn default() -> Self {
+        Self {
+            watch_path: watch_path_default(),
+            reload_html: false,
+            index_on_404: true,
+        }
+    }
+}
+
+fn watch_path_default() -> Vec<PathBuf> {
+    vec![PathBuf::from("src"), PathBuf::from("examples")]
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct WebResourceConfig {
+    pub dev: WebDevResourceConfig,
+    pub style: Option<Vec<PathBuf>>,
+    pub script: Option<Vec<PathBuf>>,
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct WebDevResourceConfig {
+    #[serde(default)]
+    pub style: Vec<PathBuf>,
+    #[serde(default)]
+    pub script: Vec<PathBuf>,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct WebHttpsConfig {
+    pub enabled: Option<bool>,
+    pub mkcert: Option<bool>,
+    pub key_path: Option<String>,
+    pub cert_path: Option<String>,
+}
+
+fn true_bool() -> bool {
+    true
+}
+
+fn false_bool() -> bool {
+    false
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct BundleConfig {
+    pub identifier: Option<String>,
+    pub publisher: Option<String>,
+    pub icon: Option<Vec<String>>,
+    pub resources: Option<Vec<String>>,
+    pub copyright: Option<String>,
+    pub category: Option<String>,
+    pub short_description: Option<String>,
+    pub long_description: Option<String>,
+    pub external_bin: Option<Vec<String>>,
+    pub deb: Option<DebianSettings>,
+    pub macos: Option<MacOsSettings>,
+    pub windows: Option<WindowsSettings>,
+}
+
+impl From<BundleConfig> for tauri_bundler::BundleSettings {
+    fn from(val: BundleConfig) -> Self {
+        tauri_bundler::BundleSettings {
+            identifier: val.identifier,
+            publisher: val.publisher,
+            icon: val.icon,
+            resources: val.resources,
+            copyright: val.copyright,
+            category: val.category.and_then(|c| c.parse().ok()),
+            short_description: val.short_description,
+            long_description: val.long_description,
+            external_bin: val.external_bin,
+            deb: val.deb.map(Into::into).unwrap_or_default(),
+            macos: val.macos.map(Into::into).unwrap_or_default(),
+            windows: val.windows.map(Into::into).unwrap_or_default(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct DebianSettings {
+    pub depends: Option<Vec<String>>,
+    pub files: HashMap<PathBuf, PathBuf>,
+    pub nsis: Option<NsisSettings>,
+}
+
+impl From<DebianSettings> for tauri_bundler::DebianSettings {
+    fn from(val: DebianSettings) -> Self {
+        tauri_bundler::DebianSettings {
+            depends: val.depends,
+            files: val.files,
+            desktop_template: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct WixSettings {
+    pub language: Vec<(String, Option<PathBuf>)>,
+    pub template: Option<PathBuf>,
+    pub fragment_paths: Vec<PathBuf>,
+    pub component_group_refs: Vec<String>,
+    pub component_refs: Vec<String>,
+    pub feature_group_refs: Vec<String>,
+    pub feature_refs: Vec<String>,
+    pub merge_refs: Vec<String>,
+    pub skip_webview_install: bool,
+    pub license: Option<PathBuf>,
+    pub enable_elevated_update_task: bool,
+    pub banner_path: Option<PathBuf>,
+    pub dialog_image_path: Option<PathBuf>,
+    pub fips_compliant: bool,
+}
+
+impl From<WixSettings> for tauri_bundler::WixSettings {
+    fn from(val: WixSettings) -> Self {
+        tauri_bundler::WixSettings {
+            language: tauri_bundler::bundle::WixLanguage({
+                let mut languages: Vec<_> = val
+                    .language
+                    .iter()
+                    .map(|l| {
+                        (
+                            l.0.clone(),
+                            tauri_bundler::bundle::WixLanguageConfig {
+                                locale_path: l.1.clone(),
+                            },
+                        )
+                    })
+                    .collect();
+                if languages.is_empty() {
+                    languages.push(("en-US".into(), Default::default()));
+                }
+                languages
+            }),
+            template: val.template,
+            fragment_paths: val.fragment_paths,
+            component_group_refs: val.component_group_refs,
+            component_refs: val.component_refs,
+            feature_group_refs: val.feature_group_refs,
+            feature_refs: val.feature_refs,
+            merge_refs: val.merge_refs,
+            skip_webview_install: val.skip_webview_install,
+            license: val.license,
+            enable_elevated_update_task: val.enable_elevated_update_task,
+            banner_path: val.banner_path,
+            dialog_image_path: val.dialog_image_path,
+            fips_compliant: val.fips_compliant,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct MacOsSettings {
+    pub frameworks: Option<Vec<String>>,
+    pub minimum_system_version: Option<String>,
+    pub license: Option<String>,
+    pub exception_domain: Option<String>,
+    pub signing_identity: Option<String>,
+    pub provider_short_name: Option<String>,
+    pub entitlements: Option<String>,
+    pub info_plist_path: Option<PathBuf>,
+}
+
+impl From<MacOsSettings> for tauri_bundler::MacOsSettings {
+    fn from(val: MacOsSettings) -> Self {
+        tauri_bundler::MacOsSettings {
+            frameworks: val.frameworks,
+            minimum_system_version: val.minimum_system_version,
+            license: val.license,
+            exception_domain: val.exception_domain,
+            signing_identity: val.signing_identity,
+            provider_short_name: val.provider_short_name,
+            entitlements: val.entitlements,
+            info_plist_path: val.info_plist_path,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WindowsSettings {
+    pub digest_algorithm: Option<String>,
+    pub certificate_thumbprint: Option<String>,
+    pub timestamp_url: Option<String>,
+    pub tsp: bool,
+    pub wix: Option<WixSettings>,
+    pub icon_path: Option<PathBuf>,
+    pub webview_install_mode: WebviewInstallMode,
+    pub webview_fixed_runtime_path: Option<PathBuf>,
+    pub allow_downgrades: bool,
+    pub nsis: Option<NsisSettings>,
+}
+
+impl From<WindowsSettings> for tauri_bundler::WindowsSettings {
+    fn from(val: WindowsSettings) -> Self {
+        tauri_bundler::WindowsSettings {
+            digest_algorithm: val.digest_algorithm,
+            certificate_thumbprint: val.certificate_thumbprint,
+            timestamp_url: val.timestamp_url,
+            tsp: val.tsp,
+            wix: val.wix.map(Into::into),
+            icon_path: val.icon_path.unwrap_or("icons/icon.ico".into()),
+            webview_install_mode: val.webview_install_mode.into(),
+            webview_fixed_runtime_path: val.webview_fixed_runtime_path,
+            allow_downgrades: val.allow_downgrades,
+            nsis: val.nsis.map(Into::into),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NsisSettings {
+    pub template: Option<PathBuf>,
+    pub license: Option<PathBuf>,
+    pub header_image: Option<PathBuf>,
+    pub sidebar_image: Option<PathBuf>,
+    pub installer_icon: Option<PathBuf>,
+    pub install_mode: NSISInstallerMode,
+    pub languages: Option<Vec<String>>,
+    pub custom_language_files: Option<HashMap<String, PathBuf>>,
+    pub display_language_selector: bool,
+}
+
+impl From<NsisSettings> for tauri_bundler::NsisSettings {
+    fn from(val: NsisSettings) -> Self {
+        tauri_bundler::NsisSettings {
+            license: val.license,
+            header_image: val.header_image,
+            sidebar_image: val.sidebar_image,
+            installer_icon: val.installer_icon,
+            install_mode: val.install_mode.into(),
+            languages: val.languages,
+            display_language_selector: val.display_language_selector,
+            custom_language_files: None,
+            template: None,
+            compression: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum NSISInstallerMode {
+    CurrentUser,
+    PerMachine,
+    Both,
+}
+
+impl From<NSISInstallerMode> for tauri_utils::config::NSISInstallerMode {
+    fn from(val: NSISInstallerMode) -> Self {
+        match val {
+            NSISInstallerMode::CurrentUser => tauri_utils::config::NSISInstallerMode::CurrentUser,
+            NSISInstallerMode::PerMachine => tauri_utils::config::NSISInstallerMode::PerMachine,
+            NSISInstallerMode::Both => tauri_utils::config::NSISInstallerMode::Both,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum WebviewInstallMode {
+    Skip,
+    DownloadBootstrapper { silent: bool },
+    EmbedBootstrapper { silent: bool },
+    OfflineInstaller { silent: bool },
+    FixedRuntime { path: PathBuf },
+}
+
+impl WebviewInstallMode {
+    fn into(self) -> tauri_utils::config::WebviewInstallMode {
+        match self {
+            Self::Skip => tauri_utils::config::WebviewInstallMode::Skip,
+            Self::DownloadBootstrapper { silent } => {
+                tauri_utils::config::WebviewInstallMode::DownloadBootstrapper { silent }
+            }
+            Self::EmbedBootstrapper { silent } => {
+                tauri_utils::config::WebviewInstallMode::EmbedBootstrapper { silent }
+            }
+            Self::OfflineInstaller { silent } => {
+                tauri_utils::config::WebviewInstallMode::OfflineInstaller { silent }
+            }
+            Self::FixedRuntime { path } => {
+                tauri_utils::config::WebviewInstallMode::FixedRuntime { path }
+            }
+        }
+    }
+}
+
+impl Default for WebviewInstallMode {
+    fn default() -> Self {
+        Self::OfflineInstaller { silent: false }
+    }
+}
+
+/// The arguments for the address the server will run on
+
+#[derive(Clone, Debug, Parser)]
+pub struct AddressArguments {
+    /// The port the server will run on
+    #[clap(long)]
+    #[clap(default_value_t = default_port())]
+    pub port: u16,
+
+    /// The address the server will run on
+    #[clap(long, default_value_t = default_address())]
+    pub addr: std::net::IpAddr,
+}
+
+impl Default for AddressArguments {
+    fn default() -> Self {
+        Self {
+            port: default_port(),
+            addr: default_address(),
+        }
+    }
+}
+
+impl AddressArguments {
+    /// Get the address the server should run on
+    pub fn address(&self) -> SocketAddr {
+        SocketAddr::new(self.addr, self.port)
+    }
+}
+
+fn default_port() -> u16 {
+    8080
+}
+
+fn default_address() -> IpAddr {
+    IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1))
+}

packages/cli/src/dioxus_crate.rs

@@ -1,6 +1,6 @@
 use crate::build::TargetArgs;
-use dioxus_cli_config::{DioxusConfig, Platform};
-use krates::cm::Target;
+use crate::config::{DioxusConfig, Platform};
+use krates::{cm::Target, KrateDetails};
 use krates::{cm::TargetKind, Cmd, Krates, NodeId};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -84,16 +84,26 @@ fn find_main_package(package: Option<String>, krates: &Krates) -> Result<NodeId,
     let kid = match package {
         Some(package) => {
             let mut workspace_members = krates.workspace_members();
-            workspace_members
-                .find_map(|node| {
-                    if let krates::Node::Krate { id, krate, .. } = node {
-                        if krate.name == package {
-                            return Some(id);
-                        }
+            let found = workspace_members.find_map(|node| {
+                if let krates::Node::Krate { id, krate, .. } = node {
+                    if krate.name == package {
+                        return Some(id);
                     }
-                    None
-                })
-                .ok_or_else(|| CrateConfigError::PackageNotFound(package.clone()))?
+                }
+                None
+            });
+
+            if found.is_none() {
+                eprintln!("Could not find package {package} in the workspace. Did you forget to add it to the workspace?");
+                eprintln!("Packages in the workspace:");
+                for package in krates.workspace_members() {
+                    if let krates::Node::Krate { krate, .. } = package {
+                        eprintln!("{}", krate.name());
+                    }
+                }
+            }
+
+            found.ok_or_else(|| CrateConfigError::PackageNotFound(package.clone()))?
         }
         None => {
             // Otherwise find the package that is the closest parent of the current directory
@@ -144,6 +154,7 @@ impl DioxusCrate {
         cmd.features(target.features.clone());
         let builder = krates::Builder::new();
         let krates = builder.build(cmd, |_| {})?;
+
         let package = find_main_package(target.package.clone(), &krates)?;
 
         let dioxus_config = load_dioxus_config(&krates, package)?.unwrap_or_default();

packages/cli/src/main.rs

@@ -5,6 +5,7 @@
 pub mod assets;
 pub mod builder;
 pub mod cli;
+pub mod config;
 pub mod dioxus_crate;
 pub mod dx_build_info;
 pub mod error;

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;