feat: Added AGENTS.md

AGENTS.md

@@ -0,0 +1,199 @@
+# Agent Guidelines for Jello
+
+This document provides guidelines for AI coding agents working on the Jello codebase.
+
+## Project Overview
+
+Jello is a WIP video client for Jellyfin written in Rust, focusing on HDR video playback using:
+- **iced** - Primary GUI toolkit
+- **gstreamer** - Video + audio decoding library  
+- **wgpu** - Rendering video from GStreamer in iced
+
+## Build, Test, and Lint Commands
+
+### Building
+```bash
+# Build in release mode
+cargo build --release
+cargo build -r
+
+# Build specific workspace member
+cargo build -p api
+cargo build -p gst
+cargo build -p ui-iced
+
+# Run the application
+cargo run --release -- -vv
+just jello  # Uses justfile
+```
+
+### Testing
+```bash
+# Run all tests in workspace
+cargo test --workspace
+
+# Run tests for a specific package
+cargo test -p gst
+cargo test -p api
+cargo test -p iced-video
+
+# Run a single test by name
+cargo test test_appsink
+cargo test -p gst test_appsink
+
+# Run a specific test in a specific file
+cargo test -p gst --test <test_file_name> <test_function_name>
+
+# Run tests with output
+cargo test -- --nocapture
+cargo test -- --show-output
+```
+
+### Linting and Formatting
+```bash
+# Check code without building
+cargo check
+cargo check --workspace
+
+# Run clippy (linter)
+cargo clippy
+cargo clippy --workspace
+cargo clippy --workspace -- -D warnings
+
+# Format code
+cargo fmt
+cargo fmt --all
+
+# Check formatting without modifying files
+cargo fmt --all -- --check
+```
+
+### Other Tools
+```bash
+# Check for security vulnerabilities and license compliance
+cargo deny check
+
+# Generate Jellyfin type definitions
+just typegen
+```
+
+## Code Style Guidelines
+
+### Rust Edition
+- Use **Rust 2024 edition** (as specified in Cargo.toml files)
+
+### Imports
+- Use `use` statements at the top of files
+- Group imports: std library, external crates, then local modules
+- Use `crate::` for absolute paths within the crate
+- Common pattern: create a `priv_prelude` module for internal imports
+- Use `pub use` to re-export commonly used items
+- Use wildcard imports (`use crate::priv_prelude::*;`) within internal modules when a prelude exists
+
+Example:
+```rust
+use std::sync::Arc;
+
+use reqwest::{Method, header::InvalidHeaderValue};
+use serde::{Deserialize, Serialize};
+
+use crate::errors::*;
+```
+
+### Naming Conventions
+- **Types/Structs/Enums**: PascalCase (e.g., `JellyfinClient`, `Error`, `AppSink`)
+- **Functions/Methods**: snake_case (e.g., `request_builder`, `stream_url`)
+- **Variables**: snake_case (e.g., `access_token`, `device_id`)
+- **Constants**: SCREAMING_SNAKE_CASE (e.g., `NEXT_ID`, `GST`)
+- **Modules**: snake_case (e.g., `priv_prelude`, `error_stack`)
+
+### Error Handling
+- Use **`error-stack`** for error handling with context propagation
+- Use **`thiserror`** for defining error types
+- Standard error type pattern:
+```rust
+pub use error_stack::{Report, ResultExt};
+
+#[derive(Debug, thiserror::Error)]
+#[error("An error occurred")]
+pub struct Error;
+
+pub type Result<T, E = error_stack::Report<Error>> = core::result::Result<T, E>;
+```
+- Attach context to errors using `.change_context(Error)` and `.attach("description")`
+- Use `#[track_caller]` on functions that may panic or error for better error messages
+- Error handling example:
+```rust
+self.inner
+    .set_state(gstreamer::State::Playing)
+    .change_context(Error)
+    .attach("Failed to set pipeline to Playing state")?;
+```
+
+### Types
+- Prefer explicit types over type inference when it improves clarity
+- Use `impl Trait` for function parameters when appropriate (e.g., `impl AsRef<str>`)
+- Use `Option<T>` and `Result<T, E>` idiomatically
+- Use `Arc<T>` for shared ownership
+- Use newtype patterns for semantic clarity (e.g., `ApiKey` wrapping `secrecy::SecretBox<String>`)
+
+### Formatting
+- Use 4 spaces for indentation
+- Line length: aim for 100 characters, but not strictly enforced
+- Use trailing commas in multi-line collections
+- Follow standard Rust formatting conventions (enforced by `cargo fmt`)
+
+### Documentation
+- Add doc comments (`///`) for public APIs
+- Use inline comments (`//`) sparingly, prefer self-documenting code
+- Include examples in doc comments when helpful
+
+### Async/Await
+- Use `tokio` as the async runtime
+- Mark async functions with `async` keyword
+- Use `.await` for async operations
+- Common pattern: `tokio::fs` for file operations
+
+### Module Structure
+- Use `mod.rs` or inline modules as appropriate
+- Keep related functionality together
+- Use `pub(crate)` for internal APIs
+- Re-export commonly used items at crate root
+
+### Macros
+- Custom macros used: `wrap_gst!`, `parent_child!`
+- Use macros for reducing boilerplate, only in the `gst` crate
+
+### Testing
+- Place tests in the same file with `#[test]` or `#[cfg(test)]`
+- Use descriptive test function names (e.g., `test_appsink`, `unique_generates_different_ids`)
+- Initialize tracing in tests when needed for debugging
+
+### Dependencies
+- Prefer well-maintained crates from crates.io
+- Use `workspace.dependencies` for shared dependencies across workspace members
+- Pin versions when stability is important
+
+### Workspace Structure
+The project uses a Cargo workspace with multiple members:
+- `.` - Main jello binary
+- `api` - Jellyfin API client
+- `gst` - GStreamer wrapper
+- `ui-iced` - Iced UI implementation
+- `ui-gpui` - GPUI UI implementation (optional)
+- `store` - Secret/data/storage management
+- `jello-types` - Shared type definitions
+- `typegen` - Jellyfin type generator
+- `crates/iced-video` - Custom iced video widget
+- `examples/hdr-gstreamer-wgpu` - HDR example
+
+### Project-Specific Patterns
+- Use `LazyLock` for global initialization (e.g., GStreamer init)
+- Use the builder pattern with method chaining (e.g., `request_builder()`)
+- Use `tap` crate's `.pipe()` for functional transformations
+- Prefer `BTreeMap`/`BTreeSet` over `HashMap`/`HashSet` when order matters
+- Prefer a functional programming style instead of an imperative one.
+- When building UIs keep the handler and view code in the same module (eg. settings view and settings handle in the same file)
+
+## License
+All code in this project is MIT licensed.

Cargo.lock

@@ -212,7 +212,7 @@ dependencies = [
  "bytes",
  "iref",
  "jiff",
- "reqwest 0.12.28",
+ "reqwest",
  "serde",
  "serde_json",
  "tap",
@@ -635,28 +635,6 @@ dependencies = [
  "arrayvec",
 ]
 
-[[package]]
-name = "aws-lc-rs"
-version = "1.15.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7b6141e96a8c160799cc2d5adecd5cbbe5054cb8c7c4af53da0f83bb7ad256"
-dependencies = [
- "aws-lc-sys",
- "zeroize",
-]
-
-[[package]]
-name = "aws-lc-sys"
-version = "0.37.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c34dda4df7017c8db52132f0f8a2e0f8161649d15723ed63fc00c82d0f2081a"
-dependencies = [
- "cc",
- "cmake",
- "dunce",
- "fs_extra",
-]
-
 [[package]]
 name = "backtrace"
 version = "0.3.76"
@@ -1129,19 +1107,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "chrono"
-version = "0.4.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
-dependencies = [
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-link 0.2.1",
-]
-
 [[package]]
 name = "ciborium"
 version = "0.2.2"
@@ -1290,15 +1255,6 @@ dependencies = [
  "x11rb",
 ]
 
-[[package]]
-name = "cmake"
-version = "0.1.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "cocoa"
 version = "0.25.0"
@@ -2342,12 +2298,6 @@ dependencies = [
  "pkg-config",
 ]
 
-[[package]]
-name = "fs_extra"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
-
 [[package]]
 name = "futf"
 version = "0.1.5"
@@ -3423,30 +3373,6 @@ dependencies = [
  "windows-registry 0.6.1",
 ]
 
-[[package]]
-name = "iana-time-zone"
-version = "0.1.65"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "log",
- "wasm-bindgen",
- "windows-core 0.62.2",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "iced"
 version = "0.14.0"
@@ -3458,7 +3384,7 @@ dependencies = [
  "iced_futures",
  "iced_renderer",
  "iced_runtime 0.14.0 (git+https://github.com/uttarayan21/iced?branch=0.14)",
- "iced_widget 0.14.2 (git+https://github.com/uttarayan21/iced?branch=0.14)",
+ "iced_widget",
  "iced_winit 0.14.0 (git+https://github.com/uttarayan21/iced?branch=0.14)",
  "image",
  "thiserror 2.0.18",
@@ -3483,22 +3409,6 @@ dependencies = [
  "wgpu",
 ]
 
-[[package]]
-name = "iced_aw"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cc84cc77dcb1c384c60792de025fb4a72e23c3d8c65c4a34691684875fc5403"
-dependencies = [
- "cfg-if",
- "chrono",
- "iced_core",
- "iced_fonts",
- "iced_widget 0.14.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "num-format",
- "num-traits",
- "web-time",
-]
-
 [[package]]
 name = "iced_beacon"
 version = "0.14.0"
@@ -3562,33 +3472,10 @@ source = "git+https://github.com/uttarayan21/iced?branch=0.14#6fbe1ec83722c67cf7
 dependencies = [
  "iced_debug 0.14.0 (git+https://github.com/uttarayan21/iced?branch=0.14)",
  "iced_program 0.14.0 (git+https://github.com/uttarayan21/iced?branch=0.14)",
- "iced_widget 0.14.2 (git+https://github.com/uttarayan21/iced?branch=0.14)",
+ "iced_widget",
  "log",
 ]
 
-[[package]]
-name = "iced_fonts"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214cff7c8499e328774216690e58e315a1a5f8f6fdd1035aed6298e62ffc4c1d"
-dependencies = [
- "iced_core",
- "iced_fonts_macros",
- "iced_widget 0.14.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "iced_fonts_macros"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef5125e110cb19cd1910a28298661c98c5d9ab02eef43594968352940e8752e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.114",
- "ttf-parser 0.25.1",
-]
-
 [[package]]
 name = "iced_futures"
 version = "0.14.0"
@@ -3736,20 +3623,6 @@ dependencies = [
  "wgpu",
 ]
 
-[[package]]
-name = "iced_widget"
-version = "0.14.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1596afa0d3109c2618e8bc12bae6c11d3064df8f95c42dfce570397dbe957ab"
-dependencies = [
- "iced_renderer",
- "log",
- "num-traits",
- "rustc-hash 2.1.1",
- "thiserror 2.0.18",
- "unicode-segmentation",
-]
-
 [[package]]
 name = "iced_widget"
 version = "0.14.2"
@@ -4127,6 +4000,14 @@ dependencies = [
  "ui-iced",
 ]
 
+[[package]]
+name = "jello-types"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "uuid",
+]
+
 [[package]]
 name = "jiff"
 version = "0.2.18"
@@ -4914,16 +4795,6 @@ dependencies = [
  "syn 2.0.114",
 ]
 
-[[package]]
-name = "num-format"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3"
-dependencies = [
- "arrayvec",
- "itoa",
-]
-
 [[package]]
 name = "num-integer"
 version = "0.1.46"
@@ -5984,7 +5855,6 @@ version = "0.11.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
 dependencies = [
- "aws-lc-rs",
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
@@ -6347,44 +6217,6 @@ dependencies = [
  "web-sys",
 ]
 
-[[package]]
-name = "reqwest"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04e9018c9d814e5f30cc16a0f03271aeab3571e609612d9fe78c1aa8d11c2f62"
-dependencies = [
- "base64",
- "bytes",
- "encoding_rs",
- "futures-core",
- "h2",
- "http",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-rustls",
- "hyper-util",
- "js-sys",
- "log",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "quinn",
- "rustls",
- "rustls-pki-types",
- "rustls-platform-verifier",
- "sync_wrapper",
- "tokio",
- "tokio-rustls",
- "tower",
- "tower-http",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
 [[package]]
 name = "resvg"
 version = "0.45.1"
@@ -6522,7 +6354,6 @@ version = "0.23.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
 dependencies = [
- "aws-lc-rs",
  "once_cell",
  "ring",
  "rustls-pki-types",
@@ -6562,40 +6393,12 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "rustls-platform-verifier"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
-dependencies = [
- "core-foundation 0.10.0",
- "core-foundation-sys",
- "jni",
- "log",
- "once_cell",
- "rustls",
- "rustls-native-certs",
- "rustls-platform-verifier-android",
- "rustls-webpki",
- "security-framework 3.5.1",
- "security-framework-sys",
- "webpki-root-certs",
- "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "rustls-platform-verifier-android"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
-
 [[package]]
 name = "rustls-webpki"
 version = "0.103.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
 dependencies = [
- "aws-lc-rs",
  "ring",
  "rustls-pki-types",
  "untrusted",
@@ -8088,10 +7891,9 @@ dependencies = [
  "gpui_util",
  "iced",
  "iced-video",
- "iced_aw",
  "iced_wgpu",
  "iced_winit 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "reqwest 0.13.1",
+ "reqwest",
  "tap",
  "toml 0.9.11+spec-1.1.0",
  "tracing",
@@ -8669,15 +8471,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "webpki-root-certs"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36a29fc0408b113f68cf32637857ab740edfafdf460c326cd2afaa2d84cc05dc"
-dependencies = [
- "rustls-pki-types",
-]
-
 [[package]]
 name = "weezl"
 version = "0.1.12"

Cargo.toml

@@ -1,20 +1,21 @@
 [workspace]
 members = [
   ".",
+  "api",
   "typegen",
   "ui-gpui",
   "ui-iced",
-  "crates/api",
+  "store",
-  "crates/gst",
+  "jello-types",
-  "crates/iced-video",
+  "gst",
-  "crates/store",
   "examples/hdr-gstreamer-wgpu",
+  "crates/iced-video",
 ]
 [workspace.dependencies]
 iced = { version = "0.14.0" }
-gst = { version = "0.1.0", path = "crates/gst" }
+gst = { version = "0.1.0", path = "gst" }
+iced_wgpu = { version = "0.14.0" }
 iced-video = { version = "0.1.0", path = "crates/iced-video" }
-api = { version = "0.1.0", path = "crates/api" }
 
 [patch.crates-io]
 iced_wgpu = { git = "https://github.com/uttarayan21/iced", branch = "0.14" }
@@ -30,7 +31,7 @@ edition = "2024"
 license = "MIT"
 
 [dependencies]
-api = { version = "0.1.0", path = "crates/api" }
+api = { version = "0.1.0", path = "api" }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 clap = { version = "4.5", features = ["derive"] }
 clap-verbosity-flag = { version = "3.0.4", features = ["tracing"] }

crates/iced-video/Cargo.toml

@@ -19,3 +19,11 @@ wgpu = { version = "27.0.1", features = ["vulkan"] }
 [dev-dependencies]
 iced.workspace = true
 tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+
+[profile.dev]
+debug = true
+[profile.release]
+debug = true
+
+# [patch.crates-io]
+# iced_wgpu = { git = "https://github.com/uttarayan21/iced", branch = "0.14" }

crates/iced-video/src/source.rs

@@ -1,11 +1,12 @@
 use crate::{Error, Result, ResultExt};
 use gst::{
-    Bus, Gst, Sink,
+    Bus, Gst, MessageType, MessageView, Sink, Source,
     app::AppSink,
     caps::{Caps, CapsType},
     element::ElementExt,
     pipeline::PipelineExt,
     playback::{PlayFlags, Playbin3},
+    videoconvertscale::VideoConvert,
 };
 use std::sync::{Arc, Mutex, atomic::AtomicBool};
 

examples/hdr-gstreamer-wgpu/Cargo.toml

@@ -15,3 +15,6 @@ anyhow = "*"
 pollster = "0.4.0"
 tracing = { version = "0.1.43", features = ["log"] }
 tracing-subscriber = "0.3.22"
+
+[profile.release]
+debug = true

flake.lock

@@ -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,
@@ -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",

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;

gst/.github/workflows/build.yaml

@@ -0,0 +1,62 @@
+name: build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  checks-matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - id: set-matrix
+        name: Generate Nix Matrix
+        run: |
+          set -Eeu
+          matrix="$(nix eval --json '.#githubActions.matrix')"
+          echo "matrix=$matrix" >> "$GITHUB_OUTPUT"
+
+  checks-build:
+    needs: checks-matrix
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix: ${{fromJSON(needs.checks-matrix.outputs.matrix)}}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - run: nix build -L '.#${{ matrix.attr }}'
+
+  codecov:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: "write"
+      contents: "read"
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: DeterminateSystems/nix-installer-action@main
+    - uses: DeterminateSystems/magic-nix-cache-action@main
+
+    - name: Run codecov
+      run: nix build .#checks.x86_64-linux.hello-llvm-cov
+
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v4.0.1
+      with:
+        flags: unittests
+        name: codecov-hello
+        fail_ci_if_error: true
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: ./result
+        verbose: true
+

gst/.github/workflows/docs.yaml

@@ -0,0 +1,38 @@
+name: docs
+
+on:
+  push:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: "write"
+      contents: "read"
+      pages: "write"
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: DeterminateSystems/nix-installer-action@main
+    - uses: DeterminateSystems/magic-nix-cache-action@main
+    - uses: DeterminateSystems/flake-checker-action@main
+
+    - name: Generate docs
+      run: nix build .#checks.x86_64-linux.hello-docs
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v5
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: result/share/doc
+
+    - name: Deploy to gh-pages
+      id: deployment
+      uses: actions/deploy-pages@v4
+

jello-types/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "jello-types"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+serde = { version = "1.0.228", features = ["derive"] }
+uuid = { version = "1.18.1", features = ["serde"] }

jello-types/src/lib.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct User {
+    id: uuid::Uuid,
+    name: Option<String>,
+    primary_image_tag: Option<String>,
+}

src/errors.rs

@@ -1,4 +1,4 @@
-pub use error_stack::ResultExt;
+pub use error_stack::{Report, ResultExt};
 #[derive(Debug, thiserror::Error)]
 #[error("An error occurred")]
 pub struct Error;

src/main.rs

@@ -1,5 +1,6 @@
 mod cli;
 mod errors;
+use api::JellyfinConfig;
 use errors::*;
 
 fn main() -> Result<()> {

ui-iced/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 license = "MIT"
 
 [dependencies]
-api = { workspace = true }
+api = { version = "0.1.0", path = "../api" }
 blurhash = "0.2.3"
 bytes = "1.11.0"
 gpui_util = "0.2.2"
@@ -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

@@ -26,8 +26,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();
@@ -158,6 +156,8 @@ impl State {
             query: None,
             screen: Screen::Home,
             settings: settings::SettingsState::default(),
+            // username_input: String::new(),
+            // password_input: String::new(),
             is_authenticated: false,
             video: None,
         }
@@ -173,8 +173,17 @@ pub enum Message {
     OpenItem(Option<uuid::Uuid>),
     LoadedItem(Option<uuid::Uuid>, Vec<Item>),
     Error(String),
+    SetToken(String),
     Back,
     Home,
+    // Login {
+    //     username: String,
+    //     password: String,
+    //     config: api::JellyfinConfig,
+    // },
+    // LoginSuccess(String),
+    // LoadedClient(api::JellyfinClient, bool),
+    // Logout,
     Video(video::VideoMessage),
 }
 
@@ -241,6 +250,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 +269,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,6 +289,7 @@ fn update(state: &mut State, message: Message) -> Task<Message> {
             }
         }
         Message::Video(msg) => video::update(state, msg),
+        _ => todo!(),
     }
 }
 
@@ -290,10 +310,10 @@ fn view(state: &State) -> Element<'_, Message> {
                 .width(Length::Fill)
                 .align_y(Alignment::Center)
                 .align_x(Alignment::Center)
-                .style(|_| container::background(BACKGROUND_COLOR))
                 .padding(50)
                 .pipe(mouse_area)
                 .on_press(Message::Settings(settings::SettingsMessage::Close));
+            // let content = mouse_area(content).on_press(Message::Home);
             stack![content, settings].into()
         }
         Screen::Home | _ => content,
@@ -328,17 +348,19 @@ fn body(state: &State) -> Element<'_, Message> {
 
 fn header(state: &State) -> Element<'_, Message> {
     row([
-        text(
+        container(
-            state
+            Button::new(
-                .jellyfin_client
+                Text::new(
-                .as_ref()
+                    state
-                .map(|c| c.config.server_url.as_str())
+                        .jellyfin_client
-                .unwrap_or("No Server"),
+                        .as_ref()
+                        .map(|c| c.config.server_url.as_str())
+                        .unwrap_or("No Server"),
+                )
+                .align_x(Alignment::Start),
+            )
+            .on_press(Message::Home),
         )
-        .align_x(Alignment::Start)
-        .pipe(button)
-        .on_press(Message::Home)
-        .pipe(container)
         .padding(10)
         .width(Length::Fill)
         .height(Length::Fill)
@@ -347,17 +369,18 @@ fn header(state: &State) -> Element<'_, Message> {
         .style(container::rounded_box)
         .into(),
         search(state),
-        row([
+        container(
-            button("Refresh").on_press(Message::Refresh).into(),
+            row([
-            button("Settings")
+                button("Refresh").on_press(Message::Refresh).into(),
-                .on_press(Message::Settings(settings::SettingsMessage::Open))
+                button("Settings")
-                .into(),
+                    .on_press(Message::Settings(settings::SettingsMessage::Open))
-            button("TestVideo")
+                    .into(),
-                .on_press(Message::Video(video::VideoMessage::Test))
+                button("TestVideo")
-                .into(),
+                    .on_press(Message::Video(video::VideoMessage::Test))
-        ])
+                    .into(),
-        .spacing(10)
+            ])
-        .pipe(container)
+            .spacing(10),
+        )
         .padding(10)
         .width(Length::Fill)
         .height(Length::Fill)
@@ -441,7 +464,51 @@ fn card(item: &Item) -> Element<'_, Message> {
 }
 
 fn init() -> (State, Task<Message>) {
-    (State::new(), Task::done(Message::Refresh))
+    // Create a default config for initial state
+
+    // let default_config = api::JellyfinConfig {
+    //     server_url: "http://localhost:8096".parse().expect("Valid URL"),
+    //     device_id: "jello-iced".to_string(),
+    //     device_name: "Jello Iced".to_string(),
+    //     client_name: "Jello".to_string(),
+    //     version: "0.1.0".to_string(),
+    // };
+    // let default_client = api::JellyfinClient::new_with_config(default_config);
+
+    (
+        State::new(),
+        Task::perform(
+            async move {
+                let config_str = std::fs::read_to_string("config.toml")
+                    .map_err(|e| api::JellyfinApiError::IoError(e))?;
+                let config: api::JellyfinConfig = toml::from_str(&config_str).map_err(|e| {
+                    api::JellyfinApiError::IoError(std::io::Error::new(
+                        std::io::ErrorKind::InvalidData,
+                        e,
+                    ))
+                })?;
+
+                // Try to load cached token and authenticate
+                match std::fs::read_to_string(".session") {
+                    Ok(token) => {
+                        let client = api::JellyfinClient::pre_authenticated(token.trim(), config)?;
+                        Ok((client, true))
+                    }
+                    Err(_) => {
+                        // No cached token, create unauthenticated client
+                        let client = api::JellyfinClient::new_with_config(config);
+                        Ok((client, false))
+                    }
+                }
+            },
+            |result: Result<_, api::JellyfinApiError>| match result {
+                // Ok((client, is_authenticated)) => Message::LoadedClient(client, is_authenticated),
+                Err(e) => Message::Error(format!("Initialization failed: {}", e)),
+                _ => Message::Error("Login Unimplemented".to_string()),
+            },
+        )
+        .chain(Task::done(Message::Refresh)),
+    )
 }
 
 pub fn ui() -> iced::Result {

ui-iced/src/settings.rs

@@ -18,10 +18,10 @@ pub fn update(state: &mut State, message: SettingsMessage) -> Task<Message> {
         SettingsMessage::Select(screen) => {
             tracing::trace!("Switching settings screen to {:?}", screen);
             state.settings.screen = screen;
-        } //
+        }
-          // SettingsMessage::User(user) => state.settings.login_form.update(user),
+        SettingsMessage::User(user) => state.settings.login_form.update(user),
-          //
+
-          // SettingsMessage::Server(server) => state.settings.server_page.update(server),
+        SettingsMessage::Server(server) => state.settings.server_form.update(server),
     }
     Task::none()
 }
@@ -30,16 +30,43 @@ pub fn empty() -> Element<'static, Message> {
     column([]).into()
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct SettingsState {
+    login_form: LoginForm,
+    server_form: ServerForm,
+    screen: SettingsScreen,
+}
+
 #[derive(Debug, Clone)]
 pub enum SettingsMessage {
     Open,
     Close,
     Select(SettingsScreen),
-    // User(UserMessage),
+    User(UserMessage),
-    // Server(ServerMessage),
+    Server(ServerMessage),
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[derive(Debug, Clone)]
+pub enum UserMessage {
+    Add,
+    UsernameChanged(String),
+    PasswordChanged(String),
+    // Edit(uuid::Uuid),
+    // Delete(uuid::Uuid),
+    Clear,
+}
+
+#[derive(Debug, Clone)]
+pub enum ServerMessage {
+    Add,
+    NameChanged(String),
+    UrlChanged(String),
+    // Edit(uuid::Uuid),
+    // Delete(uuid::Uuid),
+    Clear,
+}
+
+#[derive(Debug, Clone, Default)]
 pub enum SettingsScreen {
     #[default]
     Main,
@@ -47,34 +74,130 @@ pub enum SettingsScreen {
     Servers,
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[derive(Debug, Clone)]
-pub struct SettingsState {
+pub struct ServerItem {
-    pub screen: SettingsScreen,
+    pub id: uuid::Uuid,
+    pub name: SharedString,
+    pub url: SharedString,
+    pub users: Vec<uuid::Uuid>,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserItem {
+    pub id: uuid::Uuid,
+    pub name: SharedString,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct LoginForm {
+    username: String,
+    password: String,
+}
+
+impl LoginForm {
+    pub fn update(&mut self, message: UserMessage) {
+        match message {
+            UserMessage::UsernameChanged(data) => {
+                self.username = data;
+            }
+            UserMessage::PasswordChanged(data) => {
+                self.password = data;
+            }
+            UserMessage::Add => {
+                // Handle adding user
+            }
+            UserMessage::Clear => {
+                self.username.clear();
+                self.password.clear();
+            }
+        }
+    }
+    pub fn view(&self) -> Element<'_, Message> {
+        iced::widget::column![
+            text("Login Form"),
+            text_input("Enter Username", &self.username).on_input(|data| {
+                Message::Settings(SettingsMessage::User(UserMessage::UsernameChanged(data)))
+            }),
+            text_input("Enter Password", &self.password)
+                .secure(true)
+                .on_input(|data| {
+                    Message::Settings(SettingsMessage::User(UserMessage::PasswordChanged(data)))
+                }),
+            row![
+                button(text("Add User")).on_press_maybe(self.validate()),
+                button(text("Cancel"))
+                    .on_press(Message::Settings(SettingsMessage::User(UserMessage::Clear))),
+            ]
+            .spacing(10),
+        ]
+        .spacing(10)
+        .padding([10, 0])
+        .into()
+    }
+
+    pub fn validate(&self) -> Option<Message> {
+        (!self.username.is_empty() && !self.password.is_empty())
+            .then(|| Message::Settings(SettingsMessage::User(UserMessage::Add)))
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ServerForm {
+    name: String,
+    url: String,
+}
+
+impl ServerForm {
+    pub fn update(&mut self, message: ServerMessage) {
+        match message {
+            ServerMessage::NameChanged(data) => {
+                self.name = data;
+            }
+            ServerMessage::UrlChanged(data) => {
+                self.url = data;
+            }
+            ServerMessage::Add => {
+                // Handle adding server
+            }
+            ServerMessage::Clear => {
+                self.name.clear();
+                self.url.clear();
+            }
+            _ => {}
+        }
+    }
+    pub fn view(&self) -> Element<'_, Message> {
+        iced::widget::column![
+            text("Add New Server"),
+            text_input("Enter server name", &self.name).on_input(|data| {
+                Message::Settings(SettingsMessage::Server(ServerMessage::NameChanged(data)))
+            }),
+            text_input("Enter server URL", &self.url).on_input(|data| {
+                Message::Settings(SettingsMessage::Server(ServerMessage::UrlChanged(data)))
+            }),
+            row![
+                button(text("Add Server")).on_press_maybe(self.validate()),
+                button(text("Cancel")).on_press(Message::Settings(SettingsMessage::Server(
+                    ServerMessage::Clear
+                ))),
+            ]
+            .spacing(10),
+        ]
+        .spacing(10)
+        .padding([10, 0])
+        .into()
+    }
+
+    pub fn validate(&self) -> Option<Message> {
+        (!self.name.is_empty() && !self.url.is_empty())
+            .then(|| Message::Settings(SettingsMessage::Server(ServerMessage::Add)))
+    }
 }
 
 mod screens {
-    use iced_aw::Tabs;
-
     use super::*;
     pub fn settings(state: &State) -> Element<'_, Message> {
-        Tabs::new(|f| Message::Settings(SettingsMessage::Select(f)))
+        row([settings_list(state), settings_screen(state)]).into()
-            .push(
-                SettingsScreen::Main,
-                iced_aw::TabLabel::Text("General".into()),
-                main(state),
-            )
-            .push(
-                SettingsScreen::Servers,
-                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()
     }
 
     pub fn settings_screen(state: &State) -> Element<'_, Message> {
@@ -84,66 +207,64 @@ 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> {
-        column(
+        scrollable(
-            [
+            column(
-                button(center_text("General")).on_press(Message::Settings(
+                [
-                    SettingsMessage::Select(SettingsScreen::Main),
+                    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("Servers")).on_press(Message::Settings(
-                )),
+                        SettingsMessage::Select(SettingsScreen::Servers),
-                button(center_text("Users")).on_press(Message::Settings(SettingsMessage::Select(
+                    )),
-                    SettingsScreen::Users,
+                    button(center_text("Users")).on_press(Message::Settings(
-                ))),
+                        SettingsMessage::Select(SettingsScreen::Users),
-            ]
+                    )),
-            .map(|p| p.clip(true).width(Length::Fill).into()),
+                ]
+                .map(|p| p.clip(true).width(Length::Fill).into()),
+            )
+            .width(Length::FillPortion(2))
+            .spacing(10)
+            .padding(10),
         )
-        .width(Length::FillPortion(2))
-        .spacing(10)
-        .padding(10)
-        .pipe(scrollable)
         .into()
     }
 
     pub fn main(state: &State) -> Element<'_, Message> {
-        Column::new()
+        // placeholder for now
-            .push(text("Main Settings"))
+        container(
-            .push(toggler(true).label("HDR"))
+            Column::new()
-            .push(toggler(true).label("Enable Notifications"))
+                .push(text("Main Settings"))
-            .spacing(20)
+                .push(toggler(true).label("Foobar"))
-            .padding(20)
+                .spacing(20)
-            .pipe(container)
+                .padding(20),
-            .into()
+        )
+        .into()
     }
-
     pub fn server(state: &State) -> Element<'_, Message> {
-        Column::new()
+        container(
-            .push(text("Server Settings"))
+            Column::new()
-            // .push(ServerPage::view(state))
+                .push(text("Server Settings"))
-            .spacing(20)
+                .push(state.settings.server_form.view())
-            .padding(20)
+                // .push(toggler(false).label("Enable Server"))
-            .pipe(container)
+                .spacing(20)
-            .into()
+                .padding(20),
+        )
+        .into()
     }
-
     pub fn user(state: &State) -> Element<'_, Message> {
-        Column::new()
+        container(
-            .push(text("User Settings"))
+            Column::new()
-            // .push(LoginForm::view(&state.settings.login_form))
+                .push(text("User Settings"))
-            .spacing(20)
+                .push(state.settings.login_form.view())
-            .padding(20)
+                // .push(userlist(&state))
-            .pipe(container)
+                .spacing(20)
-            .into()
+                .padding(20),
+        )
+        .into()
     }
 }