feat(api): return (Self, AuthenticationResult) from authenticate

api/src/lib.rs

@@ -34,10 +34,10 @@ impl JellyfinClient {
         username: impl AsRef<str>,
         password: impl AsRef<str>,
         config: JellyfinConfig,
-    ) -> Result<Self> {
+    ) -> Result<(Self, jellyfin::AuthenticationResult)> {
         let url = format!("{}/Users/AuthenticateByName", config.server_url);
         let client = reqwest::Client::new();
-        let token = client
+        let auth_result = client
             .post(url)
             .json(&jellyfin::AuthenticateUserByName {
                 username: Some(username.as_ref().to_string()),
@@ -47,10 +47,14 @@ impl JellyfinClient {
             .await?
             .error_for_status()?
             .json::<jellyfin::AuthenticationResult>()
-            .await?
+            .await?;
+
+        let token = auth_result
             .access_token
+            .as_ref()
             .ok_or_else(|| std::io::Error::other("No field access_token in auth response"))?;
-        Self::pre_authenticated(token, config)
+
+        Ok((Self::pre_authenticated(token, config)?, auth_result))
     }
 
     pub fn pre_authenticated(token: impl AsRef<str>, config: JellyfinConfig) -> Result<Self> {
@@ -80,6 +84,10 @@ impl JellyfinClient {
         }
     }
 
+    pub fn access_token(&self) -> Option<&str> {
+        self.access_token.as_deref().map(|s| &*s)
+    }
+
     pub async fn save_token(&self, path: impl AsRef<std::path::Path>) -> std::io::Result<()> {
         if let Some(token) = &self.access_token {
             tokio::fs::write(path, &**token).await
@@ -104,6 +112,19 @@ impl JellyfinClient {
         self.access_token = Some(token.as_ref().into());
     }
 
+    pub async fn me(&self) -> Result<jellyfin::UserDto> {
+        let uri = "Users/Me";
+        let text = self
+            .request_builder(reqwest::Method::GET, uri)
+            .send()
+            .await?
+            .error_for_status()?
+            .text()
+            .await?;
+        let out: jellyfin::UserDto = serde_json::from_str(&text)?;
+        Ok(out)
+    }
+
     pub fn request_builder(
         &self,
         method: reqwest::Method,

flake.lock

@@ -3,11 +3,11 @@
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1768679419,
+        "lastModified": 1766435619,
-        "narHash": "sha256-l9rM4lXBeS2mIAJsJjVfl0UABx3S3zg5tul7bv+bn50=",
+        "narHash": "sha256-3A5Z5K28YB45REOHMWtyQ24cEUXW76MOtbT6abPrARE=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "c700e1cd023ca87343cbd9217d50d47023e9adc7",
+        "rev": "a98dbc80b16730a64c612c6ab5d5fecb4ebb79ba",
         "type": "github"
       },
       "original": {
@@ -18,11 +18,11 @@
     },
     "crane": {
       "locked": {
-        "lastModified": 1768873933,
+        "lastModified": 1766194365,
-        "narHash": "sha256-CfyzdaeLNGkyAHp3kT5vjvXhA1pVVK7nyDziYxCPsNk=",
+        "narHash": "sha256-4AFsUZ0kl6MXSm4BaQgItD0VGlEKR3iq7gIaL7TjBvc=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "0bda7e7d005ccb5522a76d11ccfbf562b71953ca",
+        "rev": "7d8ec2c71771937ab99790b45e6d9b93d15d9379",
         "type": "github"
       },
       "original": {
@@ -34,10 +34,10 @@
     "crates-io-index": {
       "flake": false,
       "locked": {
-        "lastModified": 1769614137,
+        "lastModified": 1763363725,
-        "narHash": "sha256-3Td8fiv6iFVxeS0hYq3xdd10ZvUkC9INMAiQx/mECas=",
+        "narHash": "sha256-cxr5xIKZFP45yV1ZHFTB1sHo5YGiR3FA8D9vAfDizMo=",
         "ref": "refs/heads/master",
-        "rev": "c7e7d6394bc95555d6acd5c6783855f47d64c90d",
+        "rev": "0382002e816a4cbd17d8d5b172f08b848aa22ff6",
         "shallow": true,
         "type": "git",
         "url": "https://github.com/rust-lang/crates.io-index"
@@ -50,9 +50,7 @@
     },
     "crates-nix": {
       "inputs": {
-        "crates-io-index": [
+        "crates-io-index": "crates-io-index"
-          "crates-io-index"
-        ]
       },
       "locked": {
         "lastModified": 1763364255,
@@ -108,11 +106,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1768564909,
+        "lastModified": 1766309749,
-        "narHash": "sha256-Kell/SpJYVkHWMvnhqJz/8DqQg2b6PguxVWOuadbHCc=",
+        "narHash": "sha256-3xY8CZ4rSnQ0NqGhMKAy5vgC+2IVK0NoVEzDoOh4DA4=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "e4bae1bd10c9c57b2cf517953ab70060a828ee6f",
+        "rev": "a6531044f6d0bef691ea18d4d4ce44d0daa6e816",
         "type": "github"
       },
       "original": {
@@ -126,7 +124,6 @@
       "inputs": {
         "advisory-db": "advisory-db",
         "crane": "crane",
-        "crates-io-index": "crates-io-index",
         "crates-nix": "crates-nix",
         "flake-utils": "flake-utils",
         "nix-github-actions": "nix-github-actions",
@@ -141,11 +138,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1768877311,
+        "lastModified": 1766371695,
-        "narHash": "sha256-abSDl0cNr0B+YCsIDpO1SjXD9JMxE4s8EFnhLEFVovI=",
+        "narHash": "sha256-W7CX9vy7H2Jj3E8NI4djHyF8iHSxKpb2c/7uNQ/vGFU=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "59e4ab96304585fde3890025fd59bd2717985cc1",
+        "rev": "d81285ba8199b00dc31847258cae3c655b605e8c",
         "type": "github"
       },
       "original": {

flake.nix

@@ -9,14 +9,7 @@
       url = "github:nix-community/nix-github-actions";
       inputs.nixpkgs.follows = "nixpkgs";
     };
-    crates-io-index = {
+    crates-nix.url = "github:uttarayan21/crates.nix";
-      url = "git+https://github.com/rust-lang/crates.io-index?shallow=1";
-      flake = false;
-    };
-    crates-nix = {
-      url = "github:uttarayan21/crates.nix";
-      inputs.crates-io-index.follows = "crates-io-index";
-    };
     rust-overlay = {
       url = "github:oxalica/rust-overlay";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -186,38 +179,28 @@
         devShells = rec {
           rust-shell =
             pkgs.mkShell.override {
-              stdenv = pkgs.clangStdenv;
+              stdenv =
-              # if pkgs.stdenv.isLinux
+                if pkgs.stdenv.isLinux
-              # then (pkgs.stdenvAdapters.useMoldLinker pkgs.clangStdenv)
+                then (pkgs.stdenvAdapters.useMoldLinker pkgs.clangStdenv)
-              # else pkgs.clangStdenv;
+                else pkgs.clangStdenv;
-            }
+            } (commonArgs
-            (commonArgs
               // {
                 # GST_PLUGIN_PATH = "/run/current-system/sw/lib/gstreamer-1.0/";
                 GIO_EXTRA_MODULES = "${pkgs.glib-networking}/lib/gio/modules";
                 packages = with pkgs;
                   [
                     toolchainWithRustAnalyzer
-                    bacon
+                    cargo-nextest
-                    cargo-audit
                     cargo-deny
                     cargo-expand
-                    cargo-hack
+                    bacon
                     cargo-make
-                    cargo-nextest
+                    cargo-hack
                     cargo-outdated
                     lld
                     lldb
+                    cargo-audit
                     (crates.buildCrate "cargo-with" {doCheck = false;})
-                    (crates.buildCrate "dioxus-cli" {
-                      nativeBuildInputs = with pkgs; [pkg-config];
-                      buildInputs = [openssl];
-                      doCheck = false;
-                    })
-                    (crates.buildCrate "cargo-hot" {
-                      nativeBuildInputs = with pkgs; [pkg-config];
-                      buildInputs = [openssl];
-                    })
                   ]
                   ++ (lib.optionals pkgs.stdenv.isDarwin [
                     apple-sdk_26
@@ -228,7 +211,7 @@
                     samply
                     cargo-flamegraph
                     perf
-                    # mold
+                    mold
                   ]);
               });
           default = rust-shell;

store/Cargo.toml

@@ -8,7 +8,6 @@ bson = { version = "3.1.0", features = ["serde"] }
 futures = "0.3.31"
 parking_lot = "0.12.5"
 redb = { version = "3.1.0", features = ["uuid"] }
-secrecy = "0.10.3"
 serde = "1.0.228"
 tokio = { version = "1.48.0", features = ["rt"] }
-uuid = { version = "1.18.1", features = ["v4"] }
+uuid = "1.18.1"

store/src/lib.rs

@@ -1,10 +1,10 @@
-use std::collections::BTreeMap;
+pub mod redb;
+pub mod sqlite;
+pub mod toml;
 
-use uuid::Uuid;
+pub trait Store {
+    fn image(&self, id: &str) -> Option<Vec<u8>>;
+    fn save_image(&mut self, id: &str, data: &[u8]);
+}
 
-pub struct ApiKey {
+pub struct Settings {}
-    inner: secrecy::SecretBox<String>,
-}
-pub struct SecretStore {
-    api_keys: BTreeMap<Uuid, ApiKey>,
-}

store/src/redb.rs

@@ -1,225 +1,225 @@
-// use std::{
+use std::{
-//     borrow::Borrow,
+    borrow::Borrow,
-//     collections::VecDeque,
+    collections::VecDeque,
-//     marker::PhantomData,
+    marker::PhantomData,
-//     path::Path,
+    path::Path,
-//     sync::{Arc, RwLock, atomic::AtomicBool},
+    sync::{Arc, RwLock, atomic::AtomicBool},
+};
+
+use futures::task::AtomicWaker;
+use redb::{Error, Key, ReadableDatabase, TableDefinition, Value};
+use serde::{Serialize, de::DeserializeOwned};
+
+const USERS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("users");
+const SERVERS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("servers");
+const SETTINGS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("settings");
+
+#[derive(Debug)]
+pub struct TableInner<T> {
+    db: Arc<T>,
+}
+
+impl<T> Clone for TableInner<T> {
+    fn clone(&self) -> Self {
+        Self {
+            db: Arc::clone(&self.db),
+        }
+    }
+}
+
+impl<T> TableInner<T> {
+    fn new(db: Arc<T>) -> Self {
+        Self { db }
+    }
+}
+
+impl TableInner<DatabaseHandle> {
+    async fn get<'a, K: Key, V: Serialize + DeserializeOwned>(
+        &self,
+        table: TableDefinition<'static, K, Vec<u8>>,
+        key: impl Borrow<K::SelfType<'a>>,
+    ) -> Result<Option<V>> {
+        let db: &redb::Database = &self.db.as_ref().database;
+        let db_reader = db.begin_read()?;
+        let table = db_reader.open_table(table)?;
+        table
+            .get(key)?
+            .map(|value| bson::deserialize_from_slice(&value.value()))
+            .transpose()
+            .map_err(|e| redb::Error::Io(std::io::Error::other(e)))
+    }
+
+    async fn insert<
+        'a,
+        'b,
+        K: Key + Send + Sync,
+        V: Serialize + DeserializeOwned + Send + Sync + 'a,
+    >(
+        &'b self,
+        table: TableDefinition<'static, K, Vec<u8>>,
+        key: impl Borrow<K::SelfType<'a>> + Send + 'b,
+        value: V,
+    ) -> Result<Option<V>> {
+        let db: &redb::Database = &self.db.as_ref().database;
+        // self.db
+        //     .writing
+        //     .store(true, std::sync::atomic::Ordering::SeqCst);
+
+        // let out = tokio::task::spawn_blocking(move || -> Result<Option<V>>
+
+        let out = tokio::task::spawn_blocking(|| -> Result<Option<V>> {
+            let db_writer = db.begin_write()?;
+            let out = {
+                let mut table = db_writer.open_table(table)?;
+                let serialized_value = bson::serialize_to_vec(&value)
+                    .map_err(|e| redb::Error::Io(std::io::Error::other(e)))?;
+                let previous = table.insert(key, &serialized_value)?;
+                let out = previous
+                    .map(|value| bson::deserialize_from_slice(&value.value()))
+                    .transpose()
+                    .map_err(|e| redb::Error::Io(std::io::Error::other(e)));
+                out
+            };
+            db_writer.commit()?;
+            out
+        })
+        .await
+        .expect("Task panicked");
+
+        out
+    }
+}
+
+// impl<K: Key, V: Serialize + DeserializeOwned> Table<K, V> for TableInner {
+//     async fn get(&self, key: K) -> Result<Option<Value>> {}
+//     async fn insert(&self, key: K, value: V) -> Result<Option<Value>> {}
+//     async fn modify(&self, key: K, v: FnOnce(V) -> V) -> Result<bool> {}
+//     async fn remove(&self, key: K) -> Result<Option<Value>> {}
+// }
+
+#[derive(Debug)]
+pub struct Users<T>(TableInner<T>);
+
+impl<T> Clone for Users<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+impl<T> Users<T> {
+    const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = USERS;
+}
+
+#[derive(Debug)]
+pub struct Servers<T>(TableInner<T>);
+impl<T> Clone for Servers<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+impl<T> Servers<T> {
+    const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = SERVERS;
+}
+
+#[derive(Debug)]
+pub struct Settings<T>(TableInner<T>);
+impl<T> Clone for Settings<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+impl<T> Settings<T> {
+    const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = SETTINGS;
+}
+
+#[derive(Debug, Clone)]
+pub struct Database {
+    users: Users<DatabaseHandle>,
+    servers: Servers<DatabaseHandle>,
+    settings: Settings<DatabaseHandle>,
+    handle: Arc<DatabaseHandle>,
+}
+
+#[derive(Debug)]
+pub struct DatabaseHandle {
+    database: redb::Database,
+    writing: AtomicBool,
+    wakers: RwLock<VecDeque<AtomicWaker>>,
+}
+
+#[derive(Debug)]
+pub struct DatabaseWriterGuard<'a> {
+    handle: &'a DatabaseHandle,
+    dropper: Arc<AtomicBool>,
+}
+
+// impl Drop for DatabaseWriterGuard<'_> {
+//     fn drop(&mut self) {
+//         self.handle
+//             .writing
+//             .store(false, std::sync::atomic::Ordering::SeqCst);
+//         let is_panicking = std::thread::panicking();
+//         let Ok(writer) = self.handle.wakers.write() else {
+//             if is_panicking {
+//                 return;
+//             } else {
+//                 panic!("Wakers lock poisoned");
+//             }
+//         }
+//         if let Some(waker) = (self.handle.wakers.write()).pop() {
+//             waker.wake();
 //         };
-//
+//         // let mut wakers = self.handle.wakers.write().expect();
-// use futures::task::AtomicWaker;
+//         // if let Some(waker) = self.handle.wakers.write().expect("Wakers lock poisoned").pop_front() {
-// use redb::{Error, Key, ReadableDatabase, TableDefinition, Value};
-// use serde::{Serialize, de::DeserializeOwned};
-//
-// const USERS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("users");
-// const SERVERS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("servers");
-// const SETTINGS: TableDefinition<uuid::Uuid, Vec<u8>> = TableDefinition::new("settings");
-//
-// #[derive(Debug)]
-// pub struct TableInner<T> {
-//     db: Arc<T>,
-// }
-//
-// impl<T> Clone for TableInner<T> {
-//     fn clone(&self) -> Self {
-//         Self {
-//             db: Arc::clone(&self.db),
-//         }
-//     }
-// }
-//
-// impl<T> TableInner<T> {
-//     fn new(db: Arc<T>) -> Self {
-//         Self { db }
-//     }
-// }
-//
-// impl TableInner<DatabaseHandle> {
-//     async fn get<'a, K: Key, V: Serialize + DeserializeOwned>(
-//         &self,
-//         table: TableDefinition<'static, K, Vec<u8>>,
-//         key: impl Borrow<K::SelfType<'a>>,
-//     ) -> Result<Option<V>> {
-//         let db: &redb::Database = &self.db.as_ref().database;
-//         let db_reader = db.begin_read()?;
-//         let table = db_reader.open_table(table)?;
-//         table
-//             .get(key)?
-//             .map(|value| bson::deserialize_from_slice(&value.value()))
-//             .transpose()
-//             .map_err(|e| redb::Error::Io(std::io::Error::other(e)))
-//     }
-//
-//     async fn insert<
-//         'a,
-//         'b,
-//         K: Key + Send + Sync,
-//         V: Serialize + DeserializeOwned + Send + Sync + 'a,
-//     >(
-//         &'b self,
-//         table: TableDefinition<'static, K, Vec<u8>>,
-//         key: impl Borrow<K::SelfType<'a>> + Send + 'b,
-//         value: V,
-//     ) -> Result<Option<V>> {
-//         let db: &redb::Database = &self.db.as_ref().database;
-//         // self.db
-//         //     .writing
-//         //     .store(true, std::sync::atomic::Ordering::SeqCst);
-//
-//         // let out = tokio::task::spawn_blocking(move || -> Result<Option<V>>
-//
-//         let out = tokio::task::spawn_blocking(|| -> Result<Option<V>> {
-//             let db_writer = db.begin_write()?;
-//             let out = {
-//                 let mut table = db_writer.open_table(table)?;
-//                 let serialized_value = bson::serialize_to_vec(&value)
-//                     .map_err(|e| redb::Error::Io(std::io::Error::other(e)))?;
-//                 let previous = table.insert(key, &serialized_value)?;
-//                 let out = previous
-//                     .map(|value| bson::deserialize_from_slice(&value.value()))
-//                     .transpose()
-//                     .map_err(|e| redb::Error::Io(std::io::Error::other(e)));
-//                 out
-//             };
-//             db_writer.commit()?;
-//             out
-//         })
-//         .await
-//         .expect("Task panicked");
-//
-//         out
-//     }
-// }
-//
-// // impl<K: Key, V: Serialize + DeserializeOwned> Table<K, V> for TableInner {
-// //     async fn get(&self, key: K) -> Result<Option<Value>> {}
-// //     async fn insert(&self, key: K, value: V) -> Result<Option<Value>> {}
-// //     async fn modify(&self, key: K, v: FnOnce(V) -> V) -> Result<bool> {}
-// //     async fn remove(&self, key: K) -> Result<Option<Value>> {}
-// // }
-//
-// #[derive(Debug)]
-// pub struct Users<T>(TableInner<T>);
-//
-// impl<T> Clone for Users<T> {
-//     fn clone(&self) -> Self {
-//         Self(self.0.clone())
-//     }
-// }
-// impl<T> Users<T> {
-//     const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = USERS;
-// }
-//
-// #[derive(Debug)]
-// pub struct Servers<T>(TableInner<T>);
-// impl<T> Clone for Servers<T> {
-//     fn clone(&self) -> Self {
-//         Self(self.0.clone())
-//     }
-// }
-// impl<T> Servers<T> {
-//     const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = SERVERS;
-// }
-//
-// #[derive(Debug)]
-// pub struct Settings<T>(TableInner<T>);
-// impl<T> Clone for Settings<T> {
-//     fn clone(&self) -> Self {
-//         Self(self.0.clone())
-//     }
-// }
-// impl<T> Settings<T> {
-//     const TABLE: TableDefinition<'static, uuid::Uuid, Vec<u8>> = SETTINGS;
-// }
-//
-// #[derive(Debug, Clone)]
-// pub struct Database {
-//     users: Users<DatabaseHandle>,
-//     servers: Servers<DatabaseHandle>,
-//     settings: Settings<DatabaseHandle>,
-//     handle: Arc<DatabaseHandle>,
-// }
-//
-// #[derive(Debug)]
-// pub struct DatabaseHandle {
-//     database: redb::Database,
-//     writing: AtomicBool,
-//     wakers: RwLock<VecDeque<AtomicWaker>>,
-// }
-//
-// #[derive(Debug)]
-// pub struct DatabaseWriterGuard<'a> {
-//     handle: &'a DatabaseHandle,
-//     dropper: Arc<AtomicBool>,
-// }
-//
-// // impl Drop for DatabaseWriterGuard<'_> {
-// //     fn drop(&mut self) {
-// //         self.handle
-// //             .writing
-// //             .store(false, std::sync::atomic::Ordering::SeqCst);
-// //         let is_panicking = std::thread::panicking();
-// //         let Ok(writer) = self.handle.wakers.write() else {
-// //             if is_panicking {
-// //                 return;
-// //             } else {
-// //                 panic!("Wakers lock poisoned");
-// //             }
-// //         }
-// //         if let Some(waker) = (self.handle.wakers.write()).pop() {
 //         //     waker.wake();
-// //         };
-// //         // let mut wakers = self.handle.wakers.write().expect();
-// //         // if let Some(waker) = self.handle.wakers.write().expect("Wakers lock poisoned").pop_front() {
-// //         //     waker.wake();
-// //         // }
-// //         // while let Some(waker) = wakers.pop_front() {
-// //         //     waker.wake();
-// //         // }
 //         // }
+//         // while let Some(waker) = wakers.pop_front() {
+//         //     waker.wake();
 //         // }
-//
-// type Result<O, E = redb::Error> = core::result::Result<O, E>;
-//
-// pub trait Table<K: Key> {
-//     fn insert<V: Serialize + DeserializeOwned>(
-//         &self,
-//         key: K,
-//         value: V,
-//     ) -> impl Future<Output = Result<Option<V>>> + Send;
-//     fn modify<V: Serialize + DeserializeOwned, O: Serialize + DeserializeOwned>(
-//         &self,
-//         key: K,
-//         v: impl FnOnce(V) -> O,
-//     ) -> impl Future<Output = Result<bool>> + Send;
-//     fn remove<V: Serialize + DeserializeOwned>(
-//         &self,
-//         key: K,
-//     ) -> impl Future<Output = Result<Option<V>>> + Send;
-//     fn get<V: Serialize + DeserializeOwned>(
-//         &self,
-//         key: K,
-//     ) -> impl Future<Output = Result<Option<V>>> + Send;
-// }
-//
-// impl Database {
-//     pub fn create(path: impl AsRef<Path>) -> Result<Self, Error> {
-//         let writing = AtomicBool::new(false);
-//         let wakers = RwLock::new(VecDeque::new());
-//         let db = redb::Database::create(path)?;
-//         let db = Arc::new(DatabaseHandle {
-//             database: db,
-//             writing,
-//             wakers,
-//         });
-//         let table_inner = TableInner::new(Arc::clone(&db));
-//         let users = Users(table_inner.clone());
-//         let servers = Servers(table_inner.clone());
-//         let settings = Settings(table_inner.clone());
-//         Ok(Self {
-//             servers,
-//             users,
-//             settings,
-//             handle: db,
-//         })
 //     }
 // }
+
+type Result<O, E = redb::Error> = core::result::Result<O, E>;
+
+pub trait Table<K: Key> {
+    fn insert<V: Serialize + DeserializeOwned>(
+        &self,
+        key: K,
+        value: V,
+    ) -> impl Future<Output = Result<Option<V>>> + Send;
+    fn modify<V: Serialize + DeserializeOwned, O: Serialize + DeserializeOwned>(
+        &self,
+        key: K,
+        v: impl FnOnce(V) -> O,
+    ) -> impl Future<Output = Result<bool>> + Send;
+    fn remove<V: Serialize + DeserializeOwned>(
+        &self,
+        key: K,
+    ) -> impl Future<Output = Result<Option<V>>> + Send;
+    fn get<V: Serialize + DeserializeOwned>(
+        &self,
+        key: K,
+    ) -> impl Future<Output = Result<Option<V>>> + Send;
+}
+
+impl Database {
+    pub fn create(path: impl AsRef<Path>) -> Result<Self, Error> {
+        let writing = AtomicBool::new(false);
+        let wakers = RwLock::new(VecDeque::new());
+        let db = redb::Database::create(path)?;
+        let db = Arc::new(DatabaseHandle {
+            database: db,
+            writing,
+            wakers,
+        });
+        let table_inner = TableInner::new(Arc::clone(&db));
+        let users = Users(table_inner.clone());
+        let servers = Servers(table_inner.clone());
+        let settings = Settings(table_inner.clone());
+        Ok(Self {
+            servers,
+            users,
+            settings,
+            handle: db,
+        })
+    }
+}

ui-iced/Cargo.toml

@@ -21,10 +21,9 @@ iced = { workspace = true, features = [
 
 
 iced-video = { workspace = true }
-iced_aw = "0.13.0"
 iced_wgpu = "0.14.0"
 iced_winit = "0.14.0"
-reqwest = "0.13"
+reqwest = "0.12.24"
 tap = "1.0.1"
 toml = "0.9.8"
 tracing = "0.1.41"

ui-iced/src/lib.rs

@@ -4,7 +4,6 @@ mod video;
 mod shared_string;
 use iced_video::{Ready, Video, VideoHandle};
 use shared_string::SharedString;
-use tap::Pipe as _;
 
 use std::sync::Arc;
 
@@ -26,8 +25,6 @@ pub struct ItemCache {
     pub tree: BTreeMap<Option<uuid::Uuid>, BTreeSet<uuid::Uuid>>,
 }
 
-const BACKGROUND_COLOR: iced::Color = iced::Color::from_rgba8(30, 30, 30, 0.7);
-
 impl ItemCache {
     pub fn insert(&mut self, parent: impl Into<Option<uuid::Uuid>>, item: Item) {
         let parent = parent.into();
@@ -144,6 +141,7 @@ struct State {
     settings: settings::SettingsState,
     is_authenticated: bool,
     video: Option<Arc<VideoHandle<Message, Ready>>>,
+    user: Option<api::jellyfin::UserDto>,
 }
 
 impl State {
@@ -158,14 +156,18 @@ impl State {
             query: None,
             screen: Screen::Home,
             settings: settings::SettingsState::default(),
+            // username_input: String::new(),
+            // password_input: String::new(),
             is_authenticated: false,
             video: None,
+            user: None,
         }
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
 pub enum Message {
+    Noop,
     Settings(settings::SettingsMessage),
     Refresh,
     Search,
@@ -173,11 +175,33 @@ pub enum Message {
     OpenItem(Option<uuid::Uuid>),
     LoadedItem(Option<uuid::Uuid>, Vec<Item>),
     Error(String),
+    SetToken(String),
     Back,
     Home,
     Video(video::VideoMessage),
 }
 
+// impl std::fmt::Debug for Message {
+//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//         match self {
+//             Message::Settings(msg) => f.debug_tuple("Settings").field(msg).finish(),
+//             Message::Refresh => f.write_str("Refresh"),
+//             Message::Search => f.write_str("Search"),
+//             Message::SearchQueryChanged(q) => f.debug_tuple("SearchQueryChanged").field(q).finish(),
+//             Message::OpenItem(id) => f.debug_tuple("OpenItem").field(id).finish(),
+//             Message::LoadedItem(id, items) => {
+//                 f.debug_tuple("LoadedItem").field(id).field(items).finish()
+//             }
+//             Message::Error(e) => f.debug_tuple("Error").field(e).finish(),
+//             Message::SetToken(_t) => f.debug_tuple("SetToken").field(&"...").finish(), // Mask token
+//             Message::Back => f.write_str("Back"),
+//             Message::Home => f.write_str("Home"),
+//             Message::Video(msg) => f.debug_tuple("Video").field(msg).finish(),
+//             Message::Noop => f.write_str("Noop"),
+//         }
+//     }
+// }
+
 fn update(state: &mut State, message: Message) -> Task<Message> {
     match message {
         Message::Settings(msg) => settings::update(state, msg),
@@ -241,6 +265,15 @@ fn update(state: &mut State, message: Message) -> Task<Message> {
             state.messages.push(err);
             Task::none()
         }
+        Message::SetToken(token) => {
+            tracing::info!("Authenticated with token: {}", token);
+            state
+                .jellyfin_client
+                .as_mut()
+                .map(|mut client| client.set_token(token));
+            state.is_authenticated = true;
+            Task::none()
+        }
         Message::Back => {
             state.current = state.history.pop().unwrap_or(None);
             Task::none()
@@ -251,6 +284,7 @@ fn update(state: &mut State, message: Message) -> Task<Message> {
         }
         Message::SearchQueryChanged(query) => {
             state.query = Some(query);
+            // Handle search query change
             Task::none()
         }
         Message::Search => {
@@ -270,34 +304,40 @@ fn update(state: &mut State, message: Message) -> Task<Message> {
             }
         }
         Message::Video(msg) => video::update(state, msg),
-        _ => todo!(),
+        Message::Noop => Task::none(),
     }
 }
 
 fn view(state: &State) -> Element<'_, Message> {
     let content = home(state);
-    match state.screen {
+
-        Screen::Settings => {
+    if matches!(state.screen, Screen::Settings) {
-            let settings = settings::settings(state);
+        stack![
-            let settings = container(settings)
+            content,
-                .width(Length::FillPortion(4))
+            mouse_area(
-                .height(Length::FillPortion(4))
+                container(mouse_area(settings::settings(state)).on_press(Message::Refresh))
-                .style(container::rounded_box)
-                .pipe(mouse_area)
-                .on_press(Message::Refresh)
-                .pipe(|c| iced::widget::column![space::vertical(), c, space::vertical()])
-                .pipe(container)
                     .width(Length::Fill)
-                .width(Length::Fill)
+                    .height(Length::Fill)
-                .align_y(Alignment::Center)
                     .align_x(Alignment::Center)
-                .style(|_| container::background(BACKGROUND_COLOR))
+                    .align_y(Alignment::Center)
-                .padding(50)
+                    .style(|_theme| {
-                .pipe(mouse_area)
+                        container::Style {
-                .on_press(Message::Settings(settings::SettingsMessage::Close));
+                            background: Some(
-            stack![content, settings].into()
+                                iced::Color {
+                                    a: 0.3,
+                                    ..iced::Color::BLACK
                                 }
-        Screen::Home | _ => content,
+                                .into(),
+                            ),
+                            ..container::Style::default()
+                        }
+                    })
+            )
+            .on_press(Message::Settings(settings::SettingsMessage::Close)),
+        ]
+        .into()
+    } else {
+        content
     }
 }
 
@@ -312,23 +352,25 @@ fn body(state: &State) -> Element<'_, Message> {
     if let Some(ref video) = state.video {
         video::player(video)
     } else {
+        scrollable(
+            container(
                 Grid::with_children(state.cache.items_of(state.current).into_iter().map(card))
                     .fluid(400)
-            .spacing(50)
+                    .spacing(50),
-            .pipe(container)
+            )
             .padding(50)
             .align_x(Alignment::Center)
             // .align_y(Alignment::Center)
             .height(Length::Fill)
-            .width(Length::Fill)
+            .width(Length::Fill),
-            .pipe(scrollable)
+        )
         .height(Length::Fill)
         .into()
     }
 }
 
 fn header(state: &State) -> Element<'_, Message> {
-    row([
+    let mut left_content = row![
         text(
             state
                 .jellyfin_client
@@ -336,10 +378,16 @@ fn header(state: &State) -> Element<'_, Message> {
                 .map(|c| c.config.server_url.as_str())
                 .unwrap_or("No Server"),
         )
-        .align_x(Alignment::Start)
+        .align_x(Alignment::Start),
-        .pipe(button)
+    ];
-        .on_press(Message::Home)
+
-        .pipe(container)
+    if let Some(user) = &state.user {
+        left_content =
+            left_content.push(text(format!(" | {}", user.name.as_deref().unwrap_or("?"))));
+    }
+
+    row([
+        container(Button::new(left_content).on_press(Message::Home))
             .padding(10)
             .width(Length::Fill)
             .height(Length::Fill)
@@ -348,6 +396,7 @@ fn header(state: &State) -> Element<'_, Message> {
             .style(container::rounded_box)
             .into(),
         search(state),
+        container(
             row([
                 button("Refresh").on_press(Message::Refresh).into(),
                 button("Settings")
@@ -357,8 +406,8 @@ fn header(state: &State) -> Element<'_, Message> {
                     .on_press(Message::Video(video::VideoMessage::Test))
                     .into(),
             ])
-        .spacing(10)
+            .spacing(10),
-        .pipe(container)
+        )
         .padding(10)
         .width(Length::Fill)
         .height(Length::Fill)
@@ -374,13 +423,14 @@ fn header(state: &State) -> Element<'_, Message> {
 }
 
 fn search(state: &State) -> Element<'_, Message> {
+    container(
         TextInput::new("Search...", state.query.as_deref().unwrap_or_default())
             .padding(10)
             .size(16)
             .width(Length::Fill)
             .on_input(Message::SearchQueryChanged)
-        .on_submit(Message::Search)
+            .on_submit(Message::Search),
-        .pipe(container)
+    )
     .padding(10)
     .width(Length::Fill)
     .height(Length::Shrink)
@@ -470,8 +520,14 @@ fn init() -> (State, Task<Message>) {
                 match std::fs::read_to_string(".session") {
                     Ok(token) => {
                         let client = api::JellyfinClient::pre_authenticated(token.trim(), config)?;
+
+                        // We need to fetch the current user to fully restore state
+                        // let _user_id = client.user_id.unwrap_or_default(); // user_id field doesn't exist on client
+
+                        // We will fetch the user info in the chain if we are authenticated
                         Ok((client, true))
                     }
+
                     Err(_) => {
                         // No cached token, create unauthenticated client
                         let client = api::JellyfinClient::new_with_config(config);
@@ -480,12 +536,10 @@ fn init() -> (State, Task<Message>) {
                 }
             },
             |result: Result<_, api::JellyfinApiError>| match result {
-                // Ok((client, is_authenticated)) => Message::LoadedClient(client, is_authenticated),
+                Ok((client, is_auth)) => Message::LoadedClient(client, is_auth),
                 Err(e) => Message::Error(format!("Initialization failed: {}", e)),
-                _ => Message::Error("Login Unimplemented".to_string()),
             },
-        )
+        ), // .chain(Task::done(Message::Refresh)),
-        .chain(Task::done(Message::Refresh)),
     )
 }
 

ui-iced/src/settings.rs

@@ -10,20 +10,61 @@ pub fn update(state: &mut State, message: SettingsMessage) -> Task<Message> {
         SettingsMessage::Open => {
             tracing::trace!("Opening settings");
             state.screen = Screen::Settings;
+            Task::none()
         }
         SettingsMessage::Close => {
             tracing::trace!("Closing settings");
             state.screen = Screen::Home;
+            Task::none()
         }
         SettingsMessage::Select(screen) => {
             tracing::trace!("Switching settings screen to {:?}", screen);
             state.settings.screen = screen;
+            Task::none()
+        }
+        // LoginResult(Result<(api::JellyfinClient, api::jellyfin::AuthenticationResult), String>),
+        // LoadedClient(api::JellyfinClient, bool),
+        // UserLoaded(Result<api::jellyfin::UserDto, String>),
+        // ConfigSaved(Result<api::JellyfinConfig, String>),
+        // Logout,
+        SettingsMessage::User(user) => {
+            if let UserMessage::Add = user {
+                // Handle adding user / login
+                let username = state.settings.login_form.username.clone();
+                let password = state.settings.login_form.password.clone();
+
+                let mut config = api::JellyfinConfig {
+                    server_url: "http://localhost:8096".parse().unwrap(), // Default fallback
+                    device_id: "jello-iced".to_string(),
+                    device_name: "Jello Iced".to_string(),
+                    client_name: "Jello".to_string(),
+                    version: "0.1.0".to_string(),
+                };
+
+                // Try to use existing config if possible
+                if let Some(client) = &state.jellyfin_client {
+                    config = client.config.as_ref().clone();
+                } else if let Ok(config_str) = std::fs::read_to_string("config.toml") {
+                    if let Ok(loaded_config) = toml::from_str(&config_str) {
+                        config = loaded_config;
+                    }
+                }
+
+                return Task::perform(
+                    async move {
+                        api::JellyfinClient::authenticate(username, password, config)
+                            .await
+                            .map_err(|e| e.to_string())
+                    },
+                    Message::LoginResult,
+                );
+            }
+            state.settings.login_form.update(user);
+            Task::none()
         }
-        SettingsMessage::User(user) => state.settings.login_form.update(user),
 
         SettingsMessage::Server(server) => state.settings.server_form.update(server),
     }
-    Task::none()
 }
 
 pub fn empty() -> Element<'static, Message> {
@@ -32,9 +73,9 @@ pub fn empty() -> Element<'static, Message> {
 
 #[derive(Debug, Clone, Default)]
 pub struct SettingsState {
-    login_form: LoginForm,
+    pub login_form: LoginForm,
-    server_form: ServerForm,
+    pub server_form: ServerForm,
-    screen: SettingsScreen,
+    pub screen: SettingsScreen,
 }
 
 #[derive(Debug, Clone)]
@@ -54,6 +95,7 @@ pub enum UserMessage {
     // Edit(uuid::Uuid),
     // Delete(uuid::Uuid),
     Clear,
+    Error(String),
 }
 
 #[derive(Debug, Clone)]
@@ -66,7 +108,7 @@ pub enum ServerMessage {
     Clear,
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[derive(Debug, Clone, Default)]
 pub enum SettingsScreen {
     #[default]
     Main,
@@ -90,8 +132,9 @@ pub struct UserItem {
 
 #[derive(Debug, Clone, Default)]
 pub struct LoginForm {
-    username: String,
+    pub username: String,
-    password: String,
+    pub password: String,
+    pub error: Option<String>,
 }
 
 impl LoginForm {
@@ -99,9 +142,11 @@ impl LoginForm {
         match message {
             UserMessage::UsernameChanged(data) => {
                 self.username = data;
+                self.error = None; // Clear error on input
             }
             UserMessage::PasswordChanged(data) => {
                 self.password = data;
+                self.error = None; // Clear error on input
             }
             UserMessage::Add => {
                 // Handle adding user
@@ -109,12 +154,18 @@ impl LoginForm {
             UserMessage::Clear => {
                 self.username.clear();
                 self.password.clear();
+                self.error = None;
+            }
+            UserMessage::Error(msg) => {
+                self.error = Some(msg);
             }
         }
     }
-    pub fn view(&self) -> Element<'_, Message> {
+    pub fn view(&self, is_authenticated: bool) -> Element<'_, Message> {
-        iced::widget::column![
+        let mut col = iced::widget::column![text("Login Form"),];
-            text("Login Form"),
+
+        if !is_authenticated {
+            let mut inputs = iced::widget::column![
                 text_input("Enter Username", &self.username).on_input(|data| {
                     Message::Settings(SettingsMessage::User(UserMessage::UsernameChanged(data)))
                 }),
@@ -123,16 +174,28 @@ impl LoginForm {
                     .on_input(|data| {
                         Message::Settings(SettingsMessage::User(UserMessage::PasswordChanged(data)))
                     }),
+            ]
+            .spacing(10);
+
+            if let Some(err) = &self.error {
+                inputs = inputs.push(text(err).style(|_| text::Style {
+                    color: Some(iced::Color::from_rgb(0.8, 0.0, 0.0)),
+                }));
+            }
+
+            col = col.push(inputs).push(
                 row![
-                button(text("Add User")).on_press_maybe(self.validate()),
+                    button(text("Login")).on_press_maybe(self.validate()),
                     button(text("Cancel"))
                         .on_press(Message::Settings(SettingsMessage::User(UserMessage::Clear))),
                 ]
                 .spacing(10),
-        ]
+            );
-        .spacing(10)
+        } else {
-        .padding([10, 0])
+            col = col.push(row![button(text("Logout")).on_press(Message::Logout)].spacing(10));
-        .into()
+        }
+
+        col.spacing(10).padding([10, 0]).into()
     }
 
     pub fn validate(&self) -> Option<Message> {
@@ -148,7 +211,7 @@ pub struct ServerForm {
 }
 
 impl ServerForm {
-    pub fn update(&mut self, message: ServerMessage) {
+    pub fn update(&mut self, message: ServerMessage) -> Task<Message> {
         match message {
             ServerMessage::NameChanged(data) => {
                 self.name = data;
@@ -157,7 +220,36 @@ impl ServerForm {
                 self.url = data;
             }
             ServerMessage::Add => {
-                // Handle adding server
+                // Handle adding server (saving config)
+                let name = self.name.clone();
+                let url_str = self.url.clone();
+
+                return Task::perform(
+                    async move {
+                        // Try to parse the URL
+                        let url_parsed = url::Url::parse(&url_str)
+                            .or_else(|_| url::Url::parse(&format!("http://{}", url_str)))
+                            .map_err(|e| format!("Invalid URL: {}", e))?;
+
+                        // Create new config
+                        let config = api::JellyfinConfig {
+                            server_url: url_parsed.to_string().parse().unwrap(),
+                            device_id: "jello-iced".to_string(),
+                            device_name: name,
+                            client_name: "Jello".to_string(),
+                            version: "0.1.0".to_string(),
+                        };
+
+                        // Save to config.toml
+                        let toml_str = toml::to_string(&config)
+                            .map_err(|e| format!("Failed to serialize config: {}", e))?;
+                        std::fs::write("config.toml", toml_str)
+                            .map_err(|e| format!("Failed to write config file: {}", e))?;
+
+                        Ok(config)
+                    },
+                    Message::ConfigSaved,
+                );
             }
             ServerMessage::Clear => {
                 self.name.clear();
@@ -165,6 +257,7 @@ impl ServerForm {
             }
             _ => {}
         }
+        Task::none()
     }
     pub fn view(&self) -> Element<'_, Message> {
         iced::widget::column![
@@ -195,27 +288,16 @@ impl ServerForm {
 }
 
 mod screens {
-    use iced_aw::Tabs;
-
     use super::*;
     pub fn settings(state: &State) -> Element<'_, Message> {
-        Tabs::new(|f| Message::Settings(SettingsMessage::Select(f)))
+        container(
-            .push(
+            row([settings_list(state), settings_screen(state)])
-                SettingsScreen::Main,
+                .spacing(20)
-                iced_aw::TabLabel::Text("General".into()),
+                .width(Length::Fixed(800.0))
-                main(state),
+                .height(Length::Fixed(600.0)),
         )
-            .push(
+        .padding(20)
-                SettingsScreen::Servers,
+        .style(container::rounded_box)
-                iced_aw::TabLabel::Text("Servers".into()),
-                server(state),
-            )
-            .push(
-                SettingsScreen::Users,
-                iced_aw::TabLabel::Text("Users".into()),
-                user(state),
-            )
-            .set_active_tab(&state.settings.screen)
         .into()
     }
 
@@ -226,64 +308,77 @@ mod screens {
             SettingsScreen::Users => user(state),
         })
         .width(Length::FillPortion(10))
-        .height(Length::Fill)
-        .style(|theme| container::background(theme.extended_palette().background.base.color))
-        .pipe(container)
-        .padding(10)
-        .style(|theme| container::background(theme.extended_palette().secondary.base.color))
-        .width(Length::FillPortion(10))
         .into()
     }
 
     pub fn settings_list(state: &State) -> Element<'_, Message> {
+        scrollable(
             column(
                 [
-                button(center_text("General")).on_press(Message::Settings(
+                    button(center_text("Main")).on_press(Message::Settings(
                         SettingsMessage::Select(SettingsScreen::Main),
                     )),
                     button(center_text("Servers")).on_press(Message::Settings(
                         SettingsMessage::Select(SettingsScreen::Servers),
                     )),
-                button(center_text("Users")).on_press(Message::Settings(SettingsMessage::Select(
+                    button(center_text("Users")).on_press(Message::Settings(
-                    SettingsScreen::Users,
+                        SettingsMessage::Select(SettingsScreen::Users),
-                ))),
+                    )),
                 ]
                 .map(|p| p.clip(true).width(Length::Fill).into()),
             )
             .width(Length::FillPortion(2))
             .spacing(10)
-        .padding(10)
+            .padding(10),
-        .pipe(scrollable)
+        )
         .into()
     }
 
     pub fn main(state: &State) -> Element<'_, Message> {
+        // placeholder for now
+        container(
             Column::new()
                 .push(text("Main Settings"))
-            .push(toggler(true).label("HDR"))
+                .push(toggler(true).label("Foobar"))
                 .spacing(20)
-            .padding(20)
+                .padding(20),
-            .pipe(container)
+        )
         .into()
     }
-
     pub fn server(state: &State) -> Element<'_, Message> {
+        container(
             Column::new()
                 .push(text("Server Settings"))
                 .push(state.settings.server_form.view())
+                // .push(toggler(false).label("Enable Server"))
                 .spacing(20)
-            .padding(20)
+                .padding(20),
-            .pipe(container)
+        )
         .into()
     }
-
     pub fn user(state: &State) -> Element<'_, Message> {
+        let user_display = if let Some(user) = &state.user {
+            iced::widget::column![
+                text(format!(
+                    "Logged in as: {}",
+                    user.name.as_deref().unwrap_or("Unknown")
+                )),
+                // We could add an avatar here if we had image loading for it
+            ]
+            .spacing(10)
+        } else {
+            iced::widget::column![].into()
+        };
+
+        container(
             Column::new()
                 .push(text("User Settings"))
-            .push(state.settings.login_form.view())
+                .push(user_display)
+                .push(state.settings.login_form.view(state.is_authenticated))
+                // .push(userlist(&state))
                 .spacing(20)
-            .padding(20)
+                .padding(20),
-            .pipe(container)
+        )
         .into()
     }
 }
@@ -294,3 +389,100 @@ pub fn center_text(content: &str) -> Element<'_, Message> {
         .width(Length::Fill)
         .into()
 }
+
+// Message::ConfigSaved(result) => {
+//             match result {
+//                 Ok(config) => {
+//                     tracing::info!("Configuration saved successfully.");
+//                     state.messages.push("Configuration saved.".to_string());
+//
+//                     // Re-initialize client with new config
+//                     // This invalidates the current session as the server might have changed
+//                     state.jellyfin_client = Some(api::JellyfinClient::new_with_config(config));
+//                     state.is_authenticated = false;
+//                     state.user = None;
+//
+//                     // Clear session file as it likely belongs to the old server
+//                     let _ = std::fs::remove_file(".session");
+//
+//                     // Reset cache
+//                     state.cache = ItemCache::default();
+//                     state.current = None;
+//                     state.history.clear();
+//
+//                     Task::none()
+//                 }
+//                 Err(e) => {
+//                     tracing::error!("Failed to save configuration: {}", e);
+//                     state.messages.push(format!("Failed to save config: {}", e));
+//                     Task::none()
+//                 }
+//             }
+//         }
+//         Message::LoadedClient(client, is_auth) => {
+//             state.jellyfin_client = Some(client.clone());
+//             state.is_authenticated = is_auth;
+//             if is_auth {
+//                 // Fetch user if authenticated
+//                 Task::perform(
+//                     async move { client.me().await.map_err(|e| e.to_string()) },
+//                     Message::UserLoaded,
+//                 )
+//             } else {
+//                 Task::done(Message::Refresh)
+//             }
+//         }
+//         Message::UserLoaded(result) => {
+//             match result {
+//                 Ok(user) => {
+//                     state.user = Some(user);
+//                 }
+//                 Err(e) => {
+//                     tracing::warn!("Failed to load user profile: {}", e);
+//                 }
+//             }
+//             Task::done(Message::Refresh)
+//         }
+//         Message::LoginResult(result) => {
+//             match result {
+//                 Ok((client, auth)) => {
+//                     if let Some(token) = client.access_token() {
+//                         if let Err(e) = std::fs::write(".session", token) {
+//                             tracing::error!("Failed to save session token: {}", e);
+//                         }
+//                     }
+//                     // Fetch user here too since authentication just succeeded
+//                     state.jellyfin_client = Some(client.clone());
+//                     state.is_authenticated = true;
+//                     state.settings.login_form = settings::LoginForm::default();
+//
+//                     // We can use the auth.user if present, or fetch it.
+//                     if let Some(user_dto) = auth.user {
+//                         state.user = Some(user_dto);
+//                         Task::none()
+//                     } else {
+//                         Task::perform(
+//                             async move { client.me().await.map_err(|e| e.to_string()) },
+//                             Message::UserLoaded,
+//                         )
+//                     }
+//                 }
+//                 Err(e) => {
+//                     tracing::error!("Login failed: {}", e);
+//                     state.messages.push(format!("Login failed: {}", e));
+//                     // Pass the error to the settings/login form so it can be displayed
+//                     state
+//                         .settings
+//                         .login_form
+//                         .update(settings::UserMessage::Error(e));
+//                     Task::none()
+//                 }
+//             }
+//         }
+//         Message::Logout => {
+//             state.jellyfin_client = None;
+//             state.is_authenticated = false;
+//             state.user = None;
+//             let _ = std::fs::remove_file(".session");
+//             Task::none()
+//         }