Add circle cursor option to settings

.github/workflows/ci.yml

@@ -103,9 +103,8 @@ jobs:
         settings:
           - target: aarch64-apple-darwin
             runner: macos-latest
-          # Windows can't take the disk usage lol
-          # - target: x86_64-pc-windows-msvc
-          #   runner: windows-latest
+          - target: x86_64-pc-windows-msvc
+            runner: windows-latest
     runs-on: ${{ matrix.settings.runner }}
     permissions:
       contents: read

.vscode/extensions.json

@@ -1,3 +1,3 @@
 {
-	"recommendations": ["tauri-apps.tauri-vscode", "rust-lang.rust-analyzer"]
+	"recommendations": ["biomejs.biome", "rust-lang.rust-analyzer"]
 }

AGENTS.md

@@ -22,6 +22,26 @@
 - Runtime: Node 20, pnpm 10.x, Rust 1.88+, Docker for MySQL/MinIO.
 - **NO COMMENTS**: Never add comments to code (`//`, `/* */`, `///`, `//!`, `#`, etc.). Code must be self-explanatory through naming, types, and structure. This applies to all languages (TypeScript, Rust, JavaScript, etc.).
 
+## Rust Clippy Rules (Workspace Lints)
+All Rust code must respect these workspace-level lints defined in `Cargo.toml`:
+
+**Rust compiler lints:**
+- `unused_must_use = "deny"` — Always handle `Result`/`Option` or types marked `#[must_use]`; never ignore them.
+
+**Clippy lints (all denied):**
+- `dbg_macro` — Never use `dbg!()` in code; use proper logging instead.
+- `let_underscore_future` — Never write `let _ = async_fn()` which silently drops futures; await or explicitly handle them.
+- `unchecked_duration_subtraction` — Use `saturating_sub` instead of `-` for `Duration` to avoid panics.
+- `collapsible_if` — Merge nested `if` statements: use `if a && b { }` instead of `if a { if b { } }`.
+- `clone_on_copy` — Don't call `.clone()` on `Copy` types; just copy them directly.
+- `redundant_closure` — Use function references directly: `iter.map(foo)` instead of `iter.map(|x| foo(x))`.
+- `ptr_arg` — Accept `&[T]` or `&str` instead of `&Vec<T>` or `&String` in function parameters.
+- `len_zero` — Use `.is_empty()` instead of `.len() == 0` or `.len() > 0`.
+- `let_unit_value` — Don't assign `()` to a variable: write `foo();` instead of `let _ = foo();` when return is unit.
+- `unnecessary_lazy_evaluations` — Use `.unwrap_or(val)` instead of `.unwrap_or_else(|| val)` for cheap values.
+- `needless_range_loop` — Use `for item in &collection` instead of `for i in 0..collection.len()` when index isn't needed.
+- `manual_clamp` — Use `.clamp(min, max)` instead of manual `if` chains or `.min().max()` patterns.
+
 ## Testing
 - TS/JS: Vitest where present (e.g., desktop). Name tests `*.test.ts(x)` near sources.
 - Rust: `cargo test` per crate; tests in `src` or `tests`.

CLAUDE.md

@@ -371,6 +371,66 @@ Minimize `useEffect` usage: compute during render, handle logic in event handler
 - Strict TypeScript; avoid `any`; leverage shared types
 - Use Biome for linting/formatting; match existing formatting
 
+## Rust Clippy Rules (Workspace Lints)
+All Rust code must respect these workspace-level lints defined in `Cargo.toml`. Violating any of these will fail CI:
+
+**Rust compiler lints:**
+- `unused_must_use = "deny"` — Always handle `Result`/`Option` or types marked `#[must_use]`; never ignore them.
+
+**Clippy lints (all denied — code MUST NOT contain these patterns):**
+- `dbg_macro` — Never use `dbg!()` in code; use proper logging (`tracing::debug!`, etc.) instead.
+- `let_underscore_future` — Never write `let _ = async_fn()` which silently drops futures; await or explicitly handle them.
+- `unchecked_duration_subtraction` — Use `duration.saturating_sub(other)` instead of `duration - other` to avoid panics on underflow.
+- `collapsible_if` — Merge nested `if` statements: write `if a && b { }` instead of `if a { if b { } }`.
+- `clone_on_copy` — Don't call `.clone()` on `Copy` types (integers, bools, etc.); just copy them directly.
+- `redundant_closure` — Use function references directly: `iter.map(foo)` instead of `iter.map(|x| foo(x))`.
+- `ptr_arg` — Accept `&[T]` or `&str` instead of `&Vec<T>` or `&String` in function parameters for flexibility.
+- `len_zero` — Use `.is_empty()` instead of `.len() == 0` or `.len() > 0` / `.len() != 0`.
+- `let_unit_value` — Don't assign `()` to a variable: write `foo();` instead of `let _ = foo();` or `let x = foo();` when return is unit.
+- `unnecessary_lazy_evaluations` — Use `.unwrap_or(val)` instead of `.unwrap_or_else(|| val)` when the default is a simple/cheap value.
+- `needless_range_loop` — Use `for item in &collection` or `for (i, item) in collection.iter().enumerate()` instead of `for i in 0..collection.len()`.
+- `manual_clamp` — Use `value.clamp(min, max)` instead of manual `if` chains or `.min(max).max(min)` patterns.
+
+**Examples of violations to avoid:**
+
+```rust
+dbg!(value);
+let _ = some_async_function();
+let duration = duration_a - duration_b;
+if condition {
+    if other_condition {
+        do_something();
+    }
+}
+let x = 5.clone();
+vec.iter().map(|x| process(x))
+fn example(v: &Vec<i32>) { }
+if vec.len() == 0 { }
+let _ = returns_unit();
+option.unwrap_or_else(|| 42)
+for i in 0..vec.len() { println!("{}", vec[i]); }
+value.min(max).max(min)
+```
+
+**Correct alternatives:**
+
+```rust
+tracing::debug!(?value);
+some_async_function().await;
+let duration = duration_a.saturating_sub(duration_b);
+if condition && other_condition {
+    do_something();
+}
+let x = 5;
+vec.iter().map(process)
+fn example(v: &[i32]) { }
+if vec.is_empty() { }
+returns_unit();
+option.unwrap_or(42)
+for item in &vec { println!("{}", item); }
+value.clamp(min, max)
+```
+
 ## Security & Privacy Considerations
 
 ### Data Handling

Cargo.toml

@@ -1,6 +1,11 @@
 [workspace]
 resolver = "2"
-members = ["apps/cli", "apps/desktop/src-tauri", "crates/*", "crates/workspace-hack"]
+members = [
+    "apps/cli",
+    "apps/desktop/src-tauri",
+    "crates/*",
+    "crates/workspace-hack",
+]
 
 [workspace.dependencies]
 anyhow = { version = "1.0.86" }
@@ -22,6 +27,7 @@ specta = { version = "=2.0.0-rc.20", features = [
     "derive",
     "serde_json",
     "uuid",
+    "chrono"
 ] }
 serde = { version = "1", features = ["derive"] }
 
@@ -40,6 +46,7 @@ sentry = { version = "0.42.0", features = [
 ] }
 tracing = "0.1.41"
 futures = "0.3.31"
+aho-corasick = "1.1.4"
 
 cidre = { git = "https://github.com/CapSoftware/cidre", rev = "bf84b67079a8", features = [
     "macos_12_7",

apps/desktop/src-tauri/Cargo.toml

@@ -20,11 +20,11 @@ swift-rs = { version = "1.0.6", features = ["build"] }
 
 [dependencies]
 tauri = { workspace = true, features = [
-	"macos-private-api",
-	"protocol-asset",
-	"tray-icon",
-	"image-png",
-	"devtools",
+    "macos-private-api",
+    "protocol-asset",
+    "tray-icon",
+    "image-png",
+    "devtools",
 ] }
 tauri-specta = { version = "=2.0.0-rc.20", features = ["derive", "typescript"] }
 tauri-plugin-dialog = "2.2.0"
@@ -60,6 +60,7 @@ tracing.workspace = true
 tempfile = "3.9.0"
 ffmpeg.workspace = true
 chrono = { version = "0.4.31", features = ["serde"] }
+regex = "1.10.4"
 rodio = "0.19.0"
 png = "0.17.13"
 device_query = "4.0.1"
@@ -106,22 +107,24 @@ tauri-plugin-sentry = "0.5.0"
 thiserror.workspace = true
 bytes = "1.10.1"
 async-stream = "0.3.6"
+sanitize-filename = "0.6.0"
 tracing-futures = { version = "0.2.5", features = ["futures-03"] }
 tracing-opentelemetry = "0.32.0"
 opentelemetry = "0.31.0"
-opentelemetry-otlp = "0.31.0" #{ version = , features = ["http-proto", "reqwest-client"] }
+opentelemetry-otlp = "0.31.0"                                                 #{ version = , features = ["http-proto", "reqwest-client"] }
 opentelemetry_sdk = { version = "0.31.0", features = ["rt-tokio", "trace"] }
 posthog-rs = "0.3.7"
 workspace-hack = { version = "0.1", path = "../../../crates/workspace-hack" }
+aho-corasick.workspace = true
 
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.24.0"
 core-foundation = "0.10.0"
 objc2-app-kit = { version = "0.3.0", features = [
-	"NSWindow",
-	"NSResponder",
-	"NSHapticFeedback",
+    "NSWindow",
+    "NSResponder",
+    "NSHapticFeedback",
 ] }
 cocoa = "0.26.0"
 objc = "0.2.7"
@@ -131,10 +134,10 @@ cidre = { workspace = true }
 
 [target.'cfg(target_os= "windows")'.dependencies]
 windows = { workspace = true, features = [
-	"Win32_Foundation",
-	"Win32_System",
-	"Win32_UI_WindowsAndMessaging",
-	"Win32_Graphics_Gdi",
+    "Win32_Foundation",
+    "Win32_System",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_Graphics_Gdi",
 ] }
 windows-sys = { workspace = true }
 

apps/desktop/src-tauri/src/audio_meter.rs

@@ -140,6 +140,6 @@ fn samples_to_f64(samples: &MicrophoneSamples) -> impl Iterator<Item = f64> + us
             SampleFormat::F64 => f64::from_ne_bytes([
                 data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
             ]),
-            _ => todo!(),
+            _ => 0.0,
         })
 }

apps/desktop/src-tauri/src/camera.rs

@@ -17,8 +17,9 @@ use tokio::{
     runtime::Runtime,
     sync::{broadcast, oneshot},
     task::LocalSet,
+    time::{Duration, Instant},
 };
-use tracing::{error, info, trace};
+use tracing::{error, info, trace, warn};
 use wgpu::{CompositeAlphaMode, SurfaceTexture};
 
 static TOOLBAR_HEIGHT: f32 = 56.0; // also defined in Typescript
@@ -43,9 +44,9 @@ pub enum CameraPreviewShape {
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Type)]
 pub struct CameraPreviewState {
-    size: f32,
-    shape: CameraPreviewShape,
-    mirrored: bool,
+    pub size: f32,
+    pub shape: CameraPreviewShape,
+    pub mirrored: bool,
 }
 
 impl Default for CameraPreviewState {
@@ -496,8 +497,23 @@ impl Renderer {
             return;
         };
 
+        let start_time = Instant::now();
+        let startup_timeout = Duration::from_secs(5);
+        let mut received_first_frame = false;
+
         let mut state = default_state;
         while let Some(event) = loop {
+            let timeout_remaining = if received_first_frame {
+                Duration::MAX
+            } else {
+                startup_timeout.saturating_sub(start_time.elapsed())
+            };
+
+            if timeout_remaining.is_zero() {
+                warn!("Camera preview timed out waiting for first frame, closing window");
+                break None;
+            }
+
             tokio::select! {
                 frame = camera_rx.recv_async() => break frame.ok().map(Ok),
                 result = reconfigure.recv() => {
@@ -507,10 +523,15 @@ impl Renderer {
                         continue;
                     }
                 },
+                _ = tokio::time::sleep(timeout_remaining) => {
+                    warn!("Camera preview timed out waiting for first frame, closing window");
+                    break None;
+                }
             }
         } {
             match event {
                 Ok(frame) => {
+                    received_first_frame = true;
                     let aspect_ratio = frame.inner.width() as f32 / frame.inner.height() as f32;
                     self.sync_ratio_uniform_and_resize_window_to_it(&window, &state, aspect_ratio);