src-tauri/src/config.rs

@@ -66,7 +66,7 @@ impl AppConfig {
 }
 
 
-pub fn set_auto_launch(is_configured: bool) -> Result<(), SetupError> {
+pub fn set_auto_launch(enable: bool) -> Result<(), SetupError> {
     let path_buf = std::env::current_exe()
         .map_err(|e| auto_launch::Error::Io(e))?;
     let path = path_buf
@@ -75,14 +75,13 @@ pub fn set_auto_launch(is_configured: bool) -> Result<(), SetupError> {
     let auto = AutoLaunchBuilder::new()
         .set_app_name("Creddy")
         .set_app_path(&path)
-        .build().expect("Failed to build");
+        .build()?;
 
-    let is_enabled = auto.is_enabled()?;
-    if is_configured && !is_enabled {
-        auto.enable().expect("Failed to enable");
+    if enable {
+        auto.enable()?;
     }
-    else if !is_configured && is_enabled {
-        auto.disable().expect("Failed to disable");
+    else {
+        auto.disable()?;
     }
 
     Ok(())

src-tauri/src/errors.rs

@@ -89,8 +89,6 @@ pub enum SetupError {
     ConfigParseError(#[from] serde_json::Error),
     #[error("Failed to set up start-on-login: {0}")]
     AutoLaunchError(#[from] auto_launch::Error),
-    #[error("Failed to start listener: {0}")]
-    ServerSetupError(#[from] std::io::Error),
 }
 
 

src-tauri/src/ipc.rs

@@ -73,6 +73,5 @@ pub fn get_config(app_state: State<'_, AppState>) -> AppConfig {
 pub async fn save_config(config: AppConfig, app_state: State<'_, AppState>) -> Result<(), String>  {
     app_state.update_config(config)
         .await
-        .map_err(|e| format!("Error saving config: {e}"))?;
-        Ok(())
+        .map_err(|e| format!("Error saving config to database: {e}"))
 }

src-tauri/src/main.rs

@@ -2,19 +2,8 @@
     all(not(debug_assertions), target_os = "windows"),
     windows_subsystem = "windows"
 )]
-use std::error::Error;
 
-use sqlx::{
-    SqlitePool,
-    sqlite::SqlitePoolOptions,
-    sqlite::SqliteConnectOptions,
-};
-use tauri::{
-    App,
-    AppHandle,
-    Manager,
-    async_runtime as rt,
-};
+use tauri::{AppHandle, Manager, async_runtime as rt};
 use once_cell::sync::OnceCell;
 
 mod config;
@@ -25,44 +14,20 @@ mod state;
 mod server;
 mod tray;
 
-use config::AppConfig;
-use server::Server;
-use errors::*;
+use crate::errors::*;
 use state::AppState;
 
 
 pub static APP: OnceCell<AppHandle> = OnceCell::new();
 
-
-async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
-    APP.set(app.handle()).unwrap();
-
-    let conn_opts = SqliteConnectOptions::new()
-        .filename(config::get_or_create_db_path())
-        .create_if_missing(true);
-    let pool_opts = SqlitePoolOptions::new();
-    let pool: SqlitePool = pool_opts.connect_with(conn_opts).await?;
-    sqlx::migrate!().run(&pool).await?;
-
-    let conf = AppConfig::load(&pool).await?;
-    let session = AppState::load_creds(&pool).await?;
-    let srv = Server::new(conf.listen_addr, conf.listen_port, app.handle()).await?;
-
-    config::set_auto_launch(conf.start_on_login)?;
-    if !conf.start_minimized {
-        app.get_window("main")
-            .ok_or(RequestError::NoMainWindow)?
-            .show()?;
-    }
-
-    let state = AppState::new(conf, session, srv, pool);
-    app.manage(state);
-    Ok(())
-}
-
-
 fn main() {
+    let initial_state = match rt::block_on(AppState::load()) {
+        Ok(state) => state,
+        Err(e) => {eprintln!("{}", e); return;}
+    };
+
     tauri::Builder::default()
+        .manage(initial_state)
         .system_tray(tray::create())
         .on_system_tray_event(tray::handle_event)
         .invoke_handler(tauri::generate_handler![
@@ -73,7 +38,22 @@ fn main() {
             ipc::get_config,
             ipc::save_config,
         ])
-        .setup(|app| rt::block_on(setup(app)))
+        .setup(|app| {
+            APP.set(app.handle()).unwrap();
+            let state = app.state::<AppState>();
+            let config = state.config.read().unwrap();
+            config::set_auto_launch(config.start_on_login)?;
+
+            let addr = std::net::SocketAddrV4::new(config.listen_addr, config.listen_port);
+            tauri::async_runtime::spawn(server::serve(addr, app.handle()));
+
+            if !config.start_minimized {
+                app.get_window("main")
+                    .ok_or(RequestError::NoMainWindow)?
+                    .show()?;
+            }
+            Ok(())
+        })
         .build(tauri::generate_context!())
         .expect("error while running tauri application")
         .run(|app, run_event| match run_event {

src-tauri/src/server.rs

@@ -1,22 +1,12 @@
 use core::time::Duration;
 use std::io;
-use std::net::{
-    Ipv4Addr,
-    SocketAddr,
-    SocketAddrV4,
-    TcpListener as StdTcpListener,
-};
-use tokio::net::{
-    TcpListener, 
-    TcpStream,
-};
+use std::net::{SocketAddr, SocketAddrV4};
+use tokio::net::{TcpListener, TcpStream};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::sync::oneshot;
 use tokio::time::sleep;
 
 use tauri::{AppHandle, Manager};
-use tauri::async_runtime as rt;
-use tauri::async_runtime::JoinHandle;
 
 use crate::{clientinfo, clientinfo::Client};
 use crate::errors::*;
@@ -169,55 +159,17 @@ impl Handler {
 }
 
 
-#[derive(Debug)]
-pub struct Server {
-    addr: Ipv4Addr,
-    port: u16,
-    app_handle: AppHandle,
-    task: JoinHandle<()>,
-}
-
-
-impl Server {
-    pub async fn new(addr: Ipv4Addr, port: u16, app_handle: AppHandle) -> io::Result<Server> {
-        // construct the listener before passing it to the task so that we know if it fails
-        let sock_addr = SocketAddrV4::new(addr, port);
-        let listener = TcpListener::bind(&sock_addr).await?;
-        let task = rt::spawn(Self::serve(listener, app_handle.app_handle()));
-
-        Ok(Server { addr, port, app_handle, task})
-    }
-
-    // this is blocking because it's too much of a paint to juggle mutexes otherwise
-    pub fn rebind(&mut self, addr: Ipv4Addr, port: u16) -> io::Result<()> {
-        if addr == self.addr && port == self.port {
-            return Ok(())
-        }
-
-        let sock_addr = SocketAddrV4::new(addr, port);
-        let std_listener = StdTcpListener::bind(&sock_addr)?;
-        std_listener.set_nonblocking(true)?;
-        let async_listener = TcpListener::from_std(std_listener)?;
-        let new_task = rt::spawn(Self::serve(async_listener, self.app_handle.app_handle()));
-        self.task.abort();
-
-        self.addr = addr;
-        self.port = port;
-        self.task = new_task;
-
-        Ok(())
-    }
-
-    async fn serve(listener: TcpListener, app_handle: AppHandle) {
-        loop {
-            match listener.accept().await {
-                Ok((stream, _)) => {
-                    let handler = Handler::new(stream, app_handle.app_handle());
-                    rt::spawn(handler.handle());
-                },
-                Err(e) => {
-                    eprintln!("Error accepting connection: {e}");
-                }
+pub async fn serve(addr: SocketAddrV4, app_handle: AppHandle) -> io::Result<()> {
+    let listener = TcpListener::bind(&addr).await?;
+    println!("Listening on {addr}");
+    loop {
+        match listener.accept().await {
+            Ok((stream, _)) => {
+                let handler = Handler::new(stream, app_handle.app_handle());
+                tauri::async_runtime::spawn(handler.handle());
+            },
+            Err(e) => {
+                eprintln!("Error accepting connection: {e}");
             }
         }
     }

src-tauri/src/state.rs

@@ -5,7 +5,7 @@ use std::sync::RwLock;
 use serde::{Serialize, Deserialize};
 use tokio::sync::oneshot::Sender;
 use tokio::time::sleep;
-use sqlx::SqlitePool;
+use sqlx::{SqlitePool, sqlite::SqlitePoolOptions, sqlite::SqliteConnectOptions};
 use sodiumoxide::crypto::{
         pwhash,
         pwhash::Salt, 
@@ -19,7 +19,6 @@ use crate::{config, config::AppConfig};
 use crate::ipc;
 use crate::clientinfo::Client;
 use crate::errors::*;
-use crate::server::Server;
 
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -64,50 +63,34 @@ pub struct AppState {
     pub request_count: RwLock<u64>,
     pub open_requests: RwLock<HashMap<u64, Sender<ipc::Approval>>>,
     pub bans: RwLock<std::collections::HashSet<Option<Client>>>,
-    server: RwLock<Server>,
-    pool: sqlx::SqlitePool,
+    pool: SqlitePool,
 }
 
 impl AppState {
-pub fn new(config: AppConfig, session: Session, server: Server, pool: SqlitePool) -> AppState {
-    AppState {
-        config: RwLock::new(config),
-        session: RwLock::new(session),
-        request_count: RwLock::new(0),
-        open_requests: RwLock::new(HashMap::new()),
-        bans: RwLock::new(HashSet::new()),
-        server: RwLock::new(server),
-        pool,
+    pub async fn load() -> Result<Self, SetupError> {
+        let conn_opts = SqliteConnectOptions::new()
+            .filename(config::get_or_create_db_path())
+            .create_if_missing(true);
+        let pool_opts = SqlitePoolOptions::new();
+
+        let pool: SqlitePool = pool_opts.connect_with(conn_opts).await?;
+        sqlx::migrate!().run(&pool).await?;
+        let creds = Self::load_creds(&pool).await?;
+        let conf = AppConfig::load(&pool).await?;
+
+        let state = AppState {
+            config: RwLock::new(conf),
+            session: RwLock::new(creds),
+            request_count: RwLock::new(0),
+            open_requests: RwLock::new(HashMap::new()),
+            bans: RwLock::new(HashSet::new()),
+            pool,
+        };
+
+        Ok(state)
     }
-}
 
-    // pub async fn load(app_handle: AppHandle) -> Result<Self, SetupError> {
-    //     let conn_opts = SqliteConnectOptions::new()
-    //         .filename(config::get_or_create_db_path())
-    //         .create_if_missing(true);
-    //     let pool_opts = SqlitePoolOptions::new();
-
-    //     let pool: SqlitePool = pool_opts.connect_with(conn_opts).await?;
-    //     sqlx::migrate!().run(&pool).await?;
-
-    //     let creds = Self::load_creds(&pool).await?;
-    //     let conf = AppConfig::load(&pool).await?;
-    //     let server = Server::new(conf.listen_addr, conf.listen_port, app_handle)?;
-
-    //     let state = AppState {
-    //         config: RwLock::new(conf),
-    //         session: RwLock::new(creds),
-    //         request_count: RwLock::new(0),
-    //         open_requests: RwLock::new(HashMap::new()),
-    //         bans: RwLock::new(HashSet::new()),
-    //         server: RwLock::new(server),
-    //         pool,
-    //     };
-
-    //     Ok(state)
-    // }
-
-    pub async fn load_creds(pool: &SqlitePool) -> Result<Session, SetupError> {
+    async fn load_creds(pool: &SqlitePool) -> Result<Session, SetupError> {
         let res = sqlx::query!("SELECT * FROM credentials ORDER BY created_at desc")
             .fetch_optional(pool)
             .await?;
@@ -168,22 +151,14 @@ pub fn new(config: AppConfig, session: Session, server: Server, pool: SqlitePool
     }
 
     pub async fn update_config(&self, new_config: AppConfig) -> Result<(), SetupError> {
-        {
-            let orig_config = self.config.read().unwrap();
-            if new_config.start_on_login != orig_config.start_on_login {
-                config::set_auto_launch(new_config.start_on_login)?;
-            }
-            if new_config.listen_addr != orig_config.listen_addr
-                || new_config.listen_port != orig_config.listen_port
-            {
-                let mut sv = self.server.write().unwrap();
-                sv.rebind(new_config.listen_addr, new_config.listen_port)?;
-            }
-        }
-
         new_config.save(&self.pool).await?;
+
         let mut live_config = self.config.write().unwrap();
+        if new_config.start_on_login != live_config.start_on_login {
+            config::set_auto_launch(new_config.start_on_login)?;
+        }
         *live_config = new_config;
+
         Ok(())
     }
 

src/style.css

@@ -1,7 +1,3 @@
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
-
-.btn-alert-error {
-    @apply bg-transparent hover:bg-[#cd5a5a] border border-error-content text-error-content
-}

src/ui/settings/NumericSetting.svelte

@@ -10,37 +10,19 @@
     export let max = null;
     export let decimal = false;
 
-    const dispatch = createEventDispatcher();
-
-    $: localValue = value.toString();
-    let lastInputTime = null;
-    function debounce(event) {
-        lastInputTime = Date.now();
-        localValue = localValue.replace(/[^-0-9.]/g, '');
-
-        const eventTime = lastInputTime;
-        const pendingValue = localValue;
-        window.setTimeout(
-            () => {
-                // if no other inputs have occured since then
-                if (eventTime === lastInputTime) {
-                    updateValue(pendingValue);
-                }
-            },
-            500
-        )
-    }
-
     let error = null;
-    function updateValue(newValue) {
+    let localValue = value.toString();
+    const dispatch = createEventDispatcher();
+    function validate(event) {
+        localValue = localValue.replace(/[^-0-9.]/g, '');
         // Don't update the value, but also don't error, if it's empty
         // or if it could be the start of a negative or decimal number
-        if (newValue.match(/^$|^-$|^\.$/) !== null) {
+        if (localValue.match(/^$|^-$|^\.$/) !== null) {
             error = null;
             return;
         }
 
-        const num = parseFloat(newValue);
+        let num = parseFloat(localValue);
         if (num % 1 !== 0 && !decimal) {
             error = `${num} is not a whole number`;
         }
@@ -71,7 +53,7 @@
                 size="{Math.max(5, localValue.length)}"
                 class:input-error={error} 
                 bind:value={localValue} 
-                on:input="{debounce}"
+                on:input="{validate}"
             />
         </div>
     </div>

src/views/Settings.svelte

@@ -5,18 +5,11 @@
     import Nav from '../ui/Nav.svelte';
     import Link from '../ui/Link.svelte';
     import ErrorAlert from '../ui/ErrorAlert.svelte';
+    // import Setting from '../ui/settings/Setting.svelte';
     import { Setting, ToggleSetting, NumericSetting } from '../ui/settings';
 
-
-    let error = null;
     async function save() {
-        try {
-            await invoke('save_config', {config: $appState.config});
-        }
-        catch (e) {
-            error = e;
-            $appState.config = await invoke('get_config');
-        }
+        await invoke('save_config', {config: $appState.config});
     }
 </script>
 
@@ -64,17 +57,3 @@
         </Setting>
     </div>
 {/await}
-
-{#if error}
-    <div class="toast">
-        <div class="alert alert-error">
-            <div>
-                <span>{error}</span>
-            </div>
-
-            <div>
-                <button class="btn btn-sm btn-alert-error" on:click={() => error = null}>Ok</button>
-            </div>
-        </div>
-    </div>
-{/if}

src/views/ShowApproved.svelte

@@ -49,7 +49,9 @@
             {error}
             <svelte:fragment slot="buttons">
                 <Link target="Home">
-                    <button class="btn btn-sm btn-alert-error" on:click={() => navigate('Home')}>Ok</button>
+                    <button class="btn btn-sm bg-transparent hover:bg-[#cd5a5a] border border-error-content text-error-content">
+                        Ok
+                    </button>
                 </Link>
             </svelte:fragment>
         </ErrorAlert>

src/views/ShowDenied.svelte

@@ -38,7 +38,9 @@
             {error}
             <svelte:fragment slot="buttons">
                 <Link target="Home">
-                    <button class="btn btn-sm btn-alert-error" on:click={() => navigate('Home')}>Ok</button>
+                    <button class="btn btn-sm bg-transparent hover:bg-[#cd5a5a] border border-error-content text-error-content" on:click="{() => navigate('Home')}">
+                        Ok
+                    </button>
                 </Link>
             </svelte:fragment>
         </ErrorAlert>