feat(panel): implement wizard setup

README.md

@@ -34,22 +34,25 @@ send direct messages to the bot, which creates dedicated channels for staff to r
 
 ## Quick Start
 
-### 1. Generate your configuration
+### 1. Download and run
 
-Use the online configurator to create your `config.toml` file:
+Download the latest release for your platform from [Releases](https://github.com/Rustmail/rustmail/releases), then run the executable:
 
-**[config.rustmail.rs](https://config.rustmail.rs)**
-
-The configurator guides you through all required settings and generates a ready-to-use configuration file.
+```bash
+./rustmail
+```
 
-### 2. Download and run
+### 2. Follow the setup wizard
 
-Download the latest release for your platform from [Releases](https://github.com/Rustmail/rustmail/releases), then:
+If no `config.toml` is found, Rustmail launches a built-in setup wizard and prints a one-time URL to the console:
 
-```bash
-# Place config.toml in the same directory as the executable
-./rustmail
 ```
+No configuration found.
+Setup wizard available at http://0.0.0.0:3002/setup?token=...
+```
+
+Open that URL in your browser to configure your bot token, server mode, ticket settings, web panel, and language — the
+wizard writes a ready-to-use `config.toml` for you and restarts the bot automatically once you're done.
 
 The bot creates its SQLite database automatically on first run.
 

crates/rustmail/Cargo.toml

@@ -31,10 +31,11 @@ base64 = "0.22"
 moka = { version = "0.12.15", features = ["future"] }
 tower-http = { version = "0.7.0", features = ["compression-gzip", "compression-br"] }
 strum = { version = "0.28.0", features = ["derive"] }
+chrono-tz = "0.10.4"
 
 [dependencies.uuid]
 version = "1.23.3"
 features = ["v4"]
 
 [dev-dependencies]
-cargo-husky = { version = "1.5.0", default-features = false, features = ["run-for-all", "run-cargo-fmt", "precommit-hook", "run-cargo-test", "run-cargo-check"] }
+cargo-husky = { version = "1.5.0", default-features = false, features = ["run-for-all", "run-cargo-fmt", "precommit-hook", "run-cargo-test", "run-cargo-check"] }

crates/rustmail/src/api/handler/admin/permissions.rs

@@ -58,20 +58,18 @@ pub async fn handle_list_permissions(
             row.try_get::<String, _>("permission"),
             row.try_get::<String, _>("granted_by"),
             row.try_get::<i64, _>("granted_at"),
+        ) && let (Some(st), Some(perm)) = (
+            SubjectType::from_str(&subject_type),
+            PanelPermission::from_str(&permission),
         ) {
-            if let (Some(st), Some(perm)) = (
-                SubjectType::from_str(&subject_type),
-                PanelPermission::from_str(&permission),
-            ) {
-                permissions.push(PanelPermissionEntry {
-                    id,
-                    subject_type: st,
-                    subject_id,
-                    permission: perm,
-                    granted_by,
-                    granted_at,
-                });
-            }
+            permissions.push(PanelPermissionEntry {
+                id,
+                subject_type: st,
+                subject_id,
+                permission: perm,
+                granted_by,
+                granted_at,
+            });
         }
     }
 

crates/rustmail/src/api/handler/auth/logout.rs

@@ -24,7 +24,7 @@ pub async fn handle_logout(
 
     if let Some(session_cookie) = session_cookie {
         let session_id = session_cookie.value();
-        let user_id = get_user_id_from_session(&session_id, &db_pool).await;
+        let user_id = get_user_id_from_session(session_id, &db_pool).await;
 
         if let Some(db_pool) = &state_lock.db_pool {
             let _ = sqlx::query("DELETE FROM sessions_panel WHERE session_id = ? AND user_id = ?")

crates/rustmail/src/api/handler/bot/config.rs

@@ -1,10 +1,9 @@
-use crate::config::{Config, LanguageConfigExt, load_config};
+use crate::config::{Config, load_config, save_config_with_backup, validate_config};
 use crate::prelude::types::*;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use rustmail_types::ConfigResponse;
-use std::fs;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
@@ -105,57 +104,3 @@ pub async fn handle_update_config(
         "message": "Configuration saved successfully. Restart the bot to apply changes."
     })))
 }
-
-fn validate_config(config: &Config) -> Result<(), String> {
-    if u64::from_str_radix(&config.thread.user_message_color, 16).is_err() {
-        return Err("Invalid user message color format (must be hex)".to_string());
-    }
-
-    if u64::from_str_radix(&config.thread.staff_message_color, 16).is_err() {
-        return Err("Invalid staff message color format (must be hex)".to_string());
-    }
-
-    if u64::from_str_radix(&config.reminders.embed_color, 16).is_err() {
-        return Err("Invalid reminder embed color format (must be hex)".to_string());
-    }
-
-    config.bot.validate_logs_config()?;
-    config.bot.validate_features_config()?;
-
-    if !config
-        .language
-        .is_language_supported(config.language.get_default_language())
-    {
-        return Err(format!(
-            "Default language '{}' is not in supported languages list",
-            config.language.default_language
-        ));
-    }
-
-    Ok(())
-}
-
-async fn save_config_with_backup(config: &Config, path: &str) -> Result<(), String> {
-    if std::path::Path::new(path).exists() {
-        let backup_path = format!("{}.backup", path);
-        fs::copy(path, &backup_path).map_err(|e| format!("Failed to create backup: {}", e))?;
-    }
-
-    let config_response = ConfigResponse {
-        bot: config.bot.clone(),
-        command: config.command.clone(),
-        thread: config.thread.clone(),
-        language: config.language.clone(),
-        error_handling: config.error_handling.clone(),
-        notifications: config.notifications.clone(),
-        reminders: config.reminders.clone(),
-        logs: config.logs.clone(),
-    };
-
-    let toml_content = toml::to_string_pretty(&config_response)
-        .map_err(|e| format!("Failed to serialize config: {}", e))?;
-
-    fs::write(path, toml_content).map_err(|e| format!("Failed to write config file: {}", e))?;
-
-    Ok(())
-}

crates/rustmail/src/api/handler/bot/tickets.rs

@@ -240,37 +240,36 @@ pub async fn handle_tickets_bot(
             messages,
         };
 
-        if !is_admin {
-            if let Some(ref category_id) = complete.category_id {
-                if !category_id.is_empty() {
-                    match get_user_permissions_in_category(
-                        &user_id,
-                        guild_id,
-                        category_id,
-                        bot_http.clone(),
-                    )
-                    .await
-                    {
-                        Some(perms) => {
-                            if !can_view_channel(perms) {
-                                return (
-                                    StatusCode::FORBIDDEN,
-                                    Json(serde_json::json!({
-                                        "error": "You don't have permission to view this ticket"
-                                    })),
-                                );
-                            }
-                        }
-                        None => {
-                            return (
-                                StatusCode::FORBIDDEN,
-                                Json(serde_json::json!({
-                                    "error": "Failed to check permissions"
-                                })),
-                            );
-                        }
+        if !is_admin
+            && let Some(ref category_id) = complete.category_id
+            && !category_id.is_empty()
+        {
+            match get_user_permissions_in_category(
+                &user_id,
+                guild_id,
+                category_id,
+                bot_http.clone(),
+            )
+            .await
+            {
+                Some(perms) => {
+                    if !can_view_channel(perms) {
+                        return (
+                            StatusCode::FORBIDDEN,
+                            Json(serde_json::json!({
+                                "error": "You don't have permission to view this ticket"
+                            })),
+                        );
                     }
                 }
+                None => {
+                    return (
+                        StatusCode::FORBIDDEN,
+                        Json(serde_json::json!({
+                            "error": "Failed to check permissions"
+                        })),
+                    );
+                }
             }
         }
 
@@ -444,7 +443,7 @@ pub async fn handle_tickets_bot(
     for msg in all_messages {
         messages_by_thread
             .entry(msg.1.clone())
-            .or_insert_with(Vec::new)
+            .or_default()
             .push(ThreadMessage {
                 id: msg.0,
                 thread_id: msg.1.clone(),

crates/rustmail/src/api/handler/categories/categories.rs

@@ -150,37 +150,37 @@ pub async fn update_category_handler(
             return Err((StatusCode::BAD_REQUEST, "Name required".to_string()));
         }
 
-        if let Some(conflict) = get_category_by_name(name, &p).await.map_err(internal)? {
-            if conflict.id != existing.id {
-                return Err((
-                    StatusCode::CONFLICT,
-                    "Category with this name already exists".to_string(),
-                ));
-            }
-        }
-    }
-
-    if let Some(true) = req.enabled {
-        if !existing.enabled {
-            let enabled_count = count_enabled_categories(&p).await.map_err(internal)?;
-            if enabled_count as usize >= CATEGORY_BUTTON_HARD_LIMIT {
-                return Err((
-                    StatusCode::BAD_REQUEST,
-                    format!("Maximum {} enabled categories", CATEGORY_BUTTON_HARD_LIMIT),
-                ));
-            }
+        if let Some(conflict) = get_category_by_name(name, &p).await.map_err(internal)?
+            && conflict.id != existing.id
+        {
+            return Err((
+                StatusCode::CONFLICT,
+                "Category with this name already exists".to_string(),
+            ));
         }
     }
 
-    if let Some(ref did) = req.discord_category_id {
-        if did.parse::<u64>().is_err() {
+    if let Some(true) = req.enabled
+        && !existing.enabled
+    {
+        let enabled_count = count_enabled_categories(&p).await.map_err(internal)?;
+        if enabled_count as usize >= CATEGORY_BUTTON_HARD_LIMIT {
             return Err((
                 StatusCode::BAD_REQUEST,
-                "Invalid discord_category_id".to_string(),
+                format!("Maximum {} enabled categories", CATEGORY_BUTTON_HARD_LIMIT),
             ));
         }
     }
 
+    if let Some(ref did) = req.discord_category_id
+        && did.parse::<u64>().is_err()
+    {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "Invalid discord_category_id".to_string(),
+        ));
+    }
+
     update_category(
         &id,
         trimmed_name,

crates/rustmail/src/api/handler/health.rs

@@ -12,10 +12,10 @@ pub async fn handle_health(State(bot_state): State<Arc<Mutex<BotState>>>) -> imp
     let state_lock = bot_state.lock().await;
 
     let mut db_ok = false;
-    if let Some(pool) = &state_lock.db_pool {
-        if sqlx::query("SELECT 1").execute(pool).await.is_ok() {
-            db_ok = true;
-        }
+    if let Some(pool) = &state_lock.db_pool
+        && sqlx::query("SELECT 1").execute(pool).await.is_ok()
+    {
+        db_ok = true;
     }
 
     let bot_running = matches!(state_lock.status, BotStatus::Running { .. });