chore: release version 2.0.0-alpha

Reviewed-on: #64

.github/workflows/release.yml

@@ -152,11 +152,23 @@ jobs:
           echo "Artifacts structure:"
           find artifacts -type f -exec ls -la {} \;
 
+      - name: Generate SHA256SUMS
+        run: |
+          # One `<sha256>  <path>` line per artifact. The in-app updater reads
+          # this to verify a download before installing it, so it must be
+          # published alongside every release. Written outside the directory
+          # being hashed so the checksums file never includes itself.
+          find artifacts -type f ! -name SHA256SUMS -print0 \
+            | sort -z \
+            | xargs -0 sha256sum > SHA256SUMS.raw
+          mv SHA256SUMS.raw artifacts/SHA256SUMS
+          cat artifacts/SHA256SUMS
+
       - name: Create draft release
         id: create_release
         uses: akkuman/gitea-release-action@v1
         with:
-          server_url: "https://git.reya.su/"
+          server_url: "https://git.reya.info/"
           repository: "reya/coop"
           token: ${{ secrets.GITEA_TOKEN }}
           draft: true

AGENTS.md

@@ -0,0 +1,155 @@
+# Rust coding guidelines
+
+* Prioritize code correctness and clarity. Speed and efficiency are secondary priorities unless otherwise specified.
+* Do not write organizational or comments that summarize the code. Comments should only be written in order to explain "why" the code is written in some way in the case there is a reason that is tricky / non-obvious.
+* Keep doc comments and comments simple, one line, straightforward, and unbloated.
+* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
+* Prefer `impl` blocks over standalone functions: place functionality as methods or associated functions on the relevant type, extending the type's existing `impl` block instead of creating a duplicate one in another file.
+* Bind a global store handle to a local before using it (`let state = GlobalState::global(cx);` then `state.update(...)`) instead of chaining on `GlobalState::global(cx)` inline.
+* Avoid using functions that panic like `unwrap()`, instead use mechanisms like `?` to propagate errors.
+* Be careful with operations like indexing which may panic if the indexes are out of bounds.
+* Never silently discard errors with `let _ =` on fallible operations. Always handle errors appropriately:
+  - Propagate errors with `?` when the calling function should handle them
+  - Use `.log_err()` or similar when you need to ignore errors but want visibility
+  - Use explicit error handling with `match` or `if let Err(...)` when you need custom logic
+  - Example: avoid `let _ = client.request(...).await?;` - use `client.request(...).await?;` instead
+* When implementing async operations that may fail, ensure errors propagate to the UI layer so users get meaningful feedback.
+* Avoid creative additions unless explicitly requested
+* Use full words for variable names (no abbreviations like "q" for "queue")
+* Use variable shadowing to scope clones in async contexts for clarity, minimizing the lifetime of borrowed references.
+  Example:
+  ```rust
+  executor.spawn({
+      let task_ran = task_ran.clone();
+      async move {
+          *task_ran.borrow_mut() = true;
+      }
+  });
+  ```
+
+# Timers in tests
+
+* In GPUI tests, prefer GPUI executor timers over `smol::Timer::after(...)` when you need timeouts, delays, or to drive `run_until_parked()`:
+  - Use `cx.background_executor().timer(duration).await` (or `cx.background_executor.timer(duration).await` in `TestAppContext`) so the work is scheduled on GPUI's dispatcher.
+  - Avoid `smol::Timer::after(...)` for test timeouts when you rely on `run_until_parked()`, because it may not be tracked by GPUI's scheduler and can lead to "nothing left to run" when pumping.
+
+# GPUI
+
+GPUI is a UI framework which also provides primitives for state and concurrency management.
+
+## Context
+
+Context types allow interaction with global state, windows, entities, and system services. They are typically passed to functions as the argument named `cx`. When a function takes callbacks they come after the `cx` parameter.
+
+* `App` is the root context type, providing access to global state and read and update of entities.
+* `Context<T>` is provided when updating an `Entity<T>`. This context dereferences into `App`, so functions which take `&App` can also take `&Context<T>`.
+* `AsyncApp` and `AsyncWindowContext` are provided by `cx.spawn` and `cx.spawn_in`. These can be held across await points.
+
+## `Window`
+
+`Window` provides access to the state of an application window. It is passed to functions as an argument named `window` and comes before `cx` when present. It is used for managing focus, dispatching actions, directly drawing, getting user input state, etc.
+
+## Entities
+
+An `Entity<T>` is a handle to state of type `T`. With `thing: Entity<T>`:
+
+* `thing.entity_id()` returns `EntityId`
+* `thing.downgrade()` returns `WeakEntity<T>`
+* `thing.read(cx: &App)` returns `&T`.
+* `thing.read_with(cx, |thing: &T, cx: &App| ...)` returns the closure's return value.
+* `thing.update(cx, |thing: &mut T, cx: &mut Context<T>| ...)` allows the closure to mutate the state, and provides a `Context<T>` for interacting with the entity. It returns the closure's return value.
+* `thing.update_in(cx, |thing: &mut T, window: &mut Window, cx: &mut Context<T>| ...)` takes a `AsyncWindowContext` or `VisualTestContext`. It's the same as `update` while also providing the `Window`.
+
+Within the closures, the inner `cx` provided to the closure must be used instead of the outer `cx` to avoid issues with multiple borrows.
+
+Trying to update an entity while it's already being updated must be avoided as this will cause a panic.
+
+`WeakEntity<T>` is a weak handle. It has `read_with`, `update`, and `update_in` methods that work the same, but always return an `anyhow::Result` so that they can fail if the entity no longer exists. This can be useful to avoid memory leaks - if entities have mutually recursive handles to each other they will never be dropped.
+
+## Concurrency
+
+All use of entities and UI rendering occurs on a single foreground thread.
+
+`cx.spawn(async move |cx| ...)` runs an async closure on the foreground thread. Within the closure, `cx` is `&mut AsyncApp`.
+
+When the outer cx is a `Context<T>`, the use of `spawn` instead looks like `cx.spawn(async move |this, cx| ...)`, where `this: WeakEntity<T>` and `cx: &mut AsyncApp`.
+
+To do work on other threads, `cx.background_spawn(async move { ... })` is used. Often this background task is awaited on by a foreground task which uses the results to update state.
+
+Both `cx.spawn` and `cx.background_spawn` return a `Task<R>`, which is a future that can be awaited upon. If this task is dropped, then its work is cancelled. To prevent this one of the following must be done:
+
+* Awaiting the task in some other async context.
+* Detaching the task via `task.detach()` or `task.detach_and_log_err(cx)`, allowing it to run indefinitely.
+* Storing the task in a field, if the work should be halted when the struct is dropped.
+
+A task which doesn't do anything but provide a value can be created with `Task::ready(value)`.
+
+Prefer keeping a task in a field over `.detach()` when the work belongs to a view or store. A detached task outlives the view that started it (for example, a repository panel the user has closed), while a task stored in a field is cancelled when that struct drops. A finished `Task` held in a container is not reaped by GPUI - it stays alive until its handle is dropped - so if the container can accumulate many runs, either drop the finished handles before pushing a new one, or hold a single `Option<Task<_>>` and replace it.
+
+## Elements
+
+The `Render` trait is used to render some state into an element tree that is laid out using flexbox layout. An `Entity<T>` where `T` implements `Render` is sometimes called a "view".
+
+Example:
+
+```
+struct TextWithBorder(SharedString);
+
+impl Render for TextWithBorder {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div().border_1().child(self.0.clone())
+    }
+}
+```
+
+Since `impl IntoElement for SharedString` exists, it can be used as an argument to `child`. `SharedString` is used to avoid copying strings, and is either an `&'static str` or `Arc<str>`.
+
+UI components that are constructed just to be turned into elements can instead implement the `RenderOnce` trait, which is similar to `Render`, but its `render` method takes ownership of `self` and receives `&mut App` instead of `&mut Context<Self>`. Types that implement this trait can use `#[derive(IntoElement)]` to use them directly as children.
+
+The style methods on elements are similar to those used by Tailwind CSS.
+
+If some attributes or children of an element tree are conditional, `.when(condition, |this| ...)` can be used to run the closure only when `condition` is true. Similarly, `.when_some(option, |this, value| ...)` runs the closure when the `Option` has a value.
+
+## Input events
+
+Input event handlers can be registered on an element via methods like `.on_click(|event, window, cx: &mut App| ...)`.
+
+Often event handlers will want to update the entity that's in the current `Context<T>`. The `cx.listener` method provides this - its use looks like `.on_click(cx.listener(|this: &mut T, event, window, cx: &mut Context<T>| ...)`.
+
+## Actions
+
+Actions are dispatched via user keyboard interaction or in code via `window.dispatch_action(SomeAction.boxed_clone(), cx)` or `focus_handle.dispatch_action(&SomeAction, window, cx)`.
+
+Actions with no data are defined with the `actions!(some_namespace, [SomeAction, AnotherAction])` macro call. Otherwise the `Action` derive macro is used. Doc comments on actions are displayed to the user.
+
+Action handlers can be registered on an element via the event handler `.on_action(|action, window, cx| ...)`. Like other event handlers, this is often used with `cx.listener`.
+
+## Notify
+
+When a view's state has changed in a way that may affect its rendering, it should call `cx.notify()`. This will cause the view to be rerendered. It will also cause any observe callbacks registered for the entity with `cx.observe` to be called.
+
+## Entity events
+
+While updating an entity (`cx: Context<T>`), it can emit an event using `cx.emit(event)`. Entities register which events they can emit by declaring `impl EventEmitter<EventType> for EntityType {}`.
+
+Other entities can then register a callback to handle these events by doing `cx.subscribe(other_entity, |this, other_entity, event, cx| ...)`. This will return a `Subscription` which deregisters the callback when dropped.  Typically `cx.subscribe` happens when creating a new entity and the subscriptions are stored in a `_subscriptions: Vec<Subscription>` field.
+
+# Pull request hygiene
+
+When an agent opens or updates a pull request, it must:
+
+- Use a clear, correctly capitalized, imperative PR title (for example, `fix crash in project panel`).
+- Avoid conventional commit prefixes in PR titles (`fix:`, `feat:`, `docs:`, etc.).
+- Avoid trailing punctuation in PR titles.
+- Optionally prefix the title with a crate name when one crate is the clear scope (for example, `workspace: add history view`).
+- Include a `Release Notes:` section as the final section in the PR body.
+- Use one bullet under `Release Notes:`:
+  - `- Added ...`, `- Fixed ...`, or `- Improved ...` for user-facing changes, or
+  - `- N/A` for docs-only and other non-user-facing changes.
+- Format release notes exactly with a blank line after the heading, for example:
+
+```
+Release Notes:
+
+- N/A
+```

Cargo.toml

@@ -4,19 +4,21 @@ members = ["crates/*", "desktop", "web"]
 default-members = ["desktop"]
 
 [workspace.package]
-version = "1.0.1"
+version = "2.0.0-alpha"
 edition = "2024"
 publish = false
 
 [workspace.dependencies]
-# GPUI
-gpui = { git = "https://github.com/zed-industries/zed" }
-gpui_platform = { git = "https://github.com/zed-industries/zed", features = ["font-kit", "x11", "wayland"] }
-gpui_linux = { git = "https://github.com/zed-industries/zed" }
-gpui_windows = { git = "https://github.com/zed-industries/zed" }
-gpui_macos = { git = "https://github.com/zed-industries/zed" }
-gpui_tokio = { git = "https://github.com/zed-industries/zed" }
-reqwest_client = { git = "https://github.com/zed-industries/zed" }
+gpui = { package = "gpui-pre", version = "0.3.8" }
+gpui_platform = { package = "gpui-pre-platform", version = "0.3.8", features = ["font-kit", "x11", "wayland"] }
+gpui_linux = { package = "gpui-pre-linux", version = "0.3.8" }
+gpui_windows = { package = "gpui-pre-windows", version = "0.3.8" }
+gpui_macos = { package = "gpui-pre-macos", version = "0.3.8" }
+gpui_web = { package = "gpui-pre-web", version = "0.3.8" }
+gpui_util = { package = "gpui-pre-util", version = "0.3.8" }
+reqwest_client = { package = "gpui-pre-reqwest-client", version = "0.3.8" }
+gpui_tokio = { path = "crates/gpui_tokio" }
+gpui-base = "0.7.1"
 
 # Nostr
 nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
@@ -25,7 +27,19 @@ nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
 nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
 nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
 nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ] }
+nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44", "nip98" ] }
+
+# Crypto (NIP-17 encrypted file messages)
+aes-gcm = "0.10"
+base64 = "0.22"
+sha2 = "0.10"
+data-encoding = "2"
+hkdf = "0.12"
+# Pinned to the instances `nostr` already builds: the NIP-44 message-key disclosure
+chacha20 = "0.9"
+hmac = "0.12"
+# Pinned to the instance `nostr-sdk` already builds, so NIP-44 nonces share it
+rand = { version = "0.10", default-features = false, features = [ "std", "sys_rng", "thread_rng" ] }
 
 # Others
 anyhow = "1.0.44"
@@ -33,7 +47,6 @@ chrono = { version = "0.4.38", features = ["wasmbind"] }
 futures = "0.3"
 itertools = "0.13.0"
 log = "0.4"
-oneshot = "0.1.10"
 flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
 rust-embed = { version = "8.5", features = ["include-exclude"] }
 serde = { version = "1.0", features = ["derive"] }
@@ -43,13 +56,8 @@ smallvec = "1.14.0"
 smol = "2"
 webbrowser = "1.0.4"
 tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
-errno = { version = "0.3.14", default-features = false }
 instant = "0.1"
 
-[patch.crates-io]
-# Use stacker's psm version which may have better WASM support
-psm = { git = "https://github.com/rust-lang/stacker", branch = "master" }
-
 [profile.release]
 strip = true
 opt-level = "z"

assets/icons/arrow-down-circle.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M2.75 12C2.75 17.1086 6.89137 21.25 12 21.25C17.1086 21.25 21.25 17.1086 21.25 12C21.25 6.89137 17.1086 2.75 12 2.75C6.89137 2.75 2.75 6.89137 2.75 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15.25 13L12 16.25L8.75 13" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M12 7.75V15.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/ban.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M21.25 12C21.25 17.1086 17.1086 21.25 12 21.25C9.44568 21.25 7.13318 20.2147 5.45926 18.5407C3.78534 16.8668 2.75 14.5543 2.75 12C2.75 6.89137 6.89137 2.75 12 2.75C14.5543 2.75 16.8668 3.78534 18.5407 5.45926C20.2147 7.13318 21.25 9.44568 21.25 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="square"/><path d="M18 6L6 18" stroke="currentColor" stroke-width="1.5" stroke-linecap="square"/> </svg>

assets/icons/book.svg

@@ -1,3 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<path d="M4.75 20V4.75C4.75 3.64543 5.64543 2.75 6.75 2.75H19.25V18.75H6C5.30964 18.75 4.75 19.3096 4.75 20ZM4.75 20C4.75 20.6904 5.30964 21.25 6 21.25H19.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M12 12.25C9.75 12.25 9.75 13.75 9.75 13.75H14.25C14.25 13.75 14.25 12.25 12 12.25Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M13 9.25C13 9.80228 12.5523 10.25 12 10.25C11.4477 10.25 11 9.80228 11 9.25C11 8.69772 11.4477 8.25 12 8.25C12.5523 8.25 13 8.69772 13 9.25Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M11.5 9.25H12.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M9.25 9.75C7.317 9.75 5.75 8.183 5.75 6.25C5.75 4.317 7.317 2.75 9.25 2.75C11.183 2.75 12.75 4.317 12.75 6.25C12.75 8.183 11.183 9.75 9.25 9.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15 2.75C16.933 2.75 18.5 4.317 18.5 6.25C18.5 8.183 16.933 9.75 15 9.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M9.24806 12.75C5.46395 12.75 2.27489 15.1517 1.30259 18.2496C0.971822 19.3035 1.89349 20.2187 2.99806 20.2188H15.4981C16.6026 20.2188 17.5243 19.3035 17.1935 18.2496C16.2212 15.1517 13.0322 12.75 9.24806 12.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M20.75 20.25H21.25C22.3546 20.25 23.2748 19.3347 22.9405 18.2819C22.2598 16.1389 20.512 14.31 18.25 13.5088" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/> </svg>

assets/icons/compass.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<circle cx="12" cy="12" r="9.25" stroke="currentColor" stroke-width="1.5"/><ellipse cx="12" cy="12" rx="3.5" ry="9.25" stroke="currentColor" stroke-width="1.5"/><path d="M3.5 9.25H20.5" stroke="currentColor" stroke-width="1.5"/><path d="M3.5 14.75H20.5" stroke="currentColor" stroke-width="1.5"/>
+</svg>

assets/icons/edit.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M12.75 11.2499V8.24994L17.3358 3.66416C18.1168 2.88311 19.3832 2.88311 20.1642 3.66416L20.3358 3.83573C21.1168 4.61678 21.1168 5.88311 20.3358 6.66416L15.75 11.2499H12.75Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M11.25 3.75H6.95C5.8299 3.75 5.26984 3.75 4.84202 3.96799C4.46569 4.15973 4.15973 4.46569 3.96799 4.84202C3.75 5.26984 3.75 5.8299 3.75 6.95V17.05C3.75 18.1701 3.75 18.7302 3.96799 19.158C4.15973 19.5343 4.46569 19.8403 4.84202 20.032C5.26984 20.25 5.8299 20.25 6.95 20.25H17.05C18.1701 20.25 18.7302 20.25 19.158 20.032C19.5343 19.8403 19.8403 19.5343 20.032 19.158C20.25 18.7302 20.25 18.1701 20.25 17.05V12.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/> </svg>

assets/icons/folder.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M2.75 5.75V17.25C2.75 18.3546 3.64543 19.25 4.75 19.25H19.25C20.3546 19.25 21.25 18.3546 21.25 17.25V8.75C21.25 7.64543 20.3546 6.75 19.25 6.75H13.0704C12.4017 6.75 11.7772 6.4158 11.4063 5.8594L10.5937 4.6406C10.2228 4.0842 9.59834 3.75 8.92963 3.75H4.75C3.64543 3.75 2.75 4.64543 2.75 5.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/hashtag.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M8.75 3.75L6.75 20.25M17.25 3.75L15.25 20.25M3.75 7.75H20.25M20.25 16.25H3.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/history.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M12 7.75V12L15.5 15.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M2.75 4.75V8.75H6.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M3.25 15.0833C4.52169 18.676 7.95303 21.25 11.9864 21.25C17.1026 21.25 21.25 17.1086 21.25 12C21.25 6.89137 17.1026 2.75 11.9864 2.75C8.14808 2.75 4.85497 5.08106 3.44947 8.40278" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/lock.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M12 8.75003C11.1716 8.75003 10.5 9.4216 10.5 10.25C10.5 11.0785 11.1716 11.75 12 11.75C12.8284 11.75 13.5 11.0785 13.5 10.25C13.5 9.4216 12.8284 8.75003 12 8.75003ZM12 8.75003V14.75M20.25 11.9124V6.94155C20.25 6.08069 19.6991 5.31641 18.8825 5.04418L12.6325 2.96085C12.2219 2.824 11.7781 2.824 11.3675 2.96085L5.11754 5.04418C4.30086 5.31641 3.75 6.08069 3.75 6.94155V11.9124C3.75 16.8848 8 19.25 12 21.4079C16 19.25 20.25 16.8848 20.25 11.9124Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/login.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M14.75 3.75L18.25 3.75C19.3546 3.75 20.25 4.64543 20.25 5.75V18.25C20.25 19.3546 19.3546 20.25 18.25 20.25H14.75M15 12H3.75M15 12L11.5 15.5M15 12L11.5 8.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/> </svg>

assets/icons/logout.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M20.25 12L9 12M20.25 12L15.75 16.5M20.25 12L15.75 7.5M11.25 20.25H5.75C4.64543 20.25 3.75 19.3546 3.75 18.25L3.75 5.75C3.75 4.64543 4.64543 3.75 5.75 3.75L11.25 3.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/> </svg>

assets/icons/message.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M21.75 12C21.75 6.84375 17.9583 3.75 12 3.75C6.04167 3.75 2.25 6.84375 2.25 12C2.25 13.3368 3.17054 15.6055 3.3145 15.9522C3.32742 15.9833 3.34021 16.0117 3.3518 16.0433C3.45089 16.3136 3.85722 17.7527 2.25 19.8828C4.41667 20.914 6.71766 19.2188 6.71766 19.2188C8.30963 20.0597 10.2038 20.25 12 20.25C17.9583 20.25 21.75 17.1562 21.75 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="square" stroke-linejoin="round"/>
+</svg>

assets/icons/panel-left-open.svg

@@ -1,3 +1,3 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M9 5.5V18.5H19.25C19.9404 18.5 20.5 17.9404 20.5 17.25V6.75C20.5 6.05964 19.9404 5.5 19.25 5.5H9ZM2 6.75C2 5.23122 3.23122 4 4.75 4H19.25C20.7688 4 22 5.23122 22 6.75V17.25C22 18.7688 20.7688 20 19.25 20H4.75C3.23122 20 2 18.7688 2 17.25V6.75Z" fill="currentColor"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M4.75 4C3.23122 4 2 5.23122 2 6.75V17.25C2 18.7688 3.23122 20 4.75 20H19.25C20.7688 20 22 18.7688 22 17.25V6.75C22 5.23122 20.7688 4 19.25 4H4.75ZM3.5 6.75C3.5 6.05964 4.05964 5.5 4.75 5.5H10.5V18.5H4.75C4.05964 18.5 3.5 17.9404 3.5 17.25V6.75Z" fill="currentColor"/><path fill-rule="evenodd" clip-rule="evenodd" d="M7 9.5C6.44772 9.5 6 9.05228 6 8.5C6 7.94772 6.44772 7.5 7 7.5C7.55228 7.5 8 7.94772 8 8.5C8 9.05228 7.55228 9.5 7 9.5ZM7 13C6.44772 13 6 12.5523 6 12C6 11.4477 6.44772 11 7 11C7.55228 11 8 11.4477 8 12C8 12.5523 7.55228 13 7 13ZM7 16.5C6.44772 16.5 6 16.0523 6 15.5C6 14.9477 6.44772 14.5 7 14.5C7.55228 14.5 8 14.9477 8 15.5C8 16.0523 7.55228 16.5 7 16.5Z" fill="currentColor"/>
 </svg>

assets/icons/panel-left.svg

@@ -1,3 +1,3 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<path d="M2.75 6.75C2.75 5.64543 3.64543 4.75 4.75 4.75H19.25C20.3546 4.75 21.25 5.64543 21.25 6.75V17.25C21.25 18.3546 20.3546 19.25 19.25 19.25H4.75C3.64543 19.25 2.75 18.3546 2.75 17.25V6.75Z" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/><path d="M8.25 5V12V19" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/>
+<path d="M11.25 4.75H4.75C3.64543 4.75 2.75 5.64543 2.75 6.75V17.25C2.75 18.3546 3.64543 19.25 4.75 19.25H11.25M11.25 4.75H19.25C20.3546 4.75 21.25 5.64543 21.25 6.75V17.25C21.25 18.3546 20.3546 19.25 19.25 19.25H11.25M11.25 4.75V19.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="square" stroke-linejoin="round"/><path d="M6.25 8.5C6.25 8.91421 6.58579 9.25 7 9.25C7.41421 9.25 7.75 8.91421 7.75 8.5C7.75 8.08579 7.41421 7.75 7 7.75C6.58579 7.75 6.25 8.08579 6.25 8.5ZM6.25 12C6.25 12.4142 6.58579 12.75 7 12.75C7.41421 12.75 7.75 12.4142 7.75 12C7.75 11.5858 7.41421 11.25 7 11.25C6.58579 11.25 6.25 11.5858 6.25 12ZM6.25 15.5C6.25 15.9142 6.58579 16.25 7 16.25C7.41421 16.25 7.75 15.9142 7.75 15.5C7.75 15.0858 7.41421 14.75 7 14.75C6.58579 14.75 6.25 15.0858 6.25 15.5Z" fill="currentColor" stroke="currentColor" stroke-width="0.5"/>
 </svg>

assets/icons/plus-chat.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M21.75 12C21.75 6.84375 17.9583 3.75 12 3.75C6.04167 3.75 2.25 6.84375 2.25 12C2.25 13.3368 3.17054 15.6055 3.3145 15.9522C3.32742 15.9833 3.34021 16.0117 3.3518 16.0433C3.45089 16.3136 3.85722 17.7527 2.25 19.8828C4.41667 20.914 6.71766 19.2188 6.71766 19.2188C8.30963 20.0597 10.2038 20.25 12 20.25C17.9583 20.25 21.75 17.1562 21.75 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="square" stroke-linejoin="round"/><path d="M12 8.75V15.25M8.75 12H15.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/> </svg>

assets/icons/upload.svg

@@ -1,3 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<path d="M12 19.25V13L14.5 15.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M12 13L9.5 15.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M7.375 19.25H4.75C3.64543 19.25 2.75 18.3546 2.75 17.25V5.75C2.75 4.64543 3.64543 3.75 4.75 3.75H8.92963C9.59834 3.75 10.2228 4.0842 10.5937 4.6406L11.7031 6.3047C11.8886 6.5829 12.2008 6.75 12.5352 6.75H19.25C20.3546 6.75 21.25 7.64543 21.25 8.75V17.25C21.25 18.3546 20.3546 19.25 19.25 19.25H16.625" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"> <path d="M11.25 20.25H5.75C4.64543 20.25 3.75 19.3546 3.75 18.25V5.75C3.75 4.64543 4.64543 3.75 5.75 3.75H18.25C19.3546 3.75 20.25 4.64543 20.25 5.75V11.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M3.75 16.25L6.58579 13.4142C7.36683 12.6332 8.63317 12.6332 9.41421 13.4142L12 16" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M14.5 11.5C15.6046 11.5 16.5 10.6046 16.5 9.5C16.5 8.39543 15.6046 7.5 14.5 7.5C13.3954 7.5 12.5 8.39543 12.5 9.5C12.5 10.6046 13.3954 11.5 14.5 11.5Z" stroke="currentColor" stroke-width="1.5"/><path d="M15.75 18.5H21.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M18.5 15.75V21.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/> </svg>

assets/themes/aurora.json

@@ -1,144 +0,0 @@
-{
-  "id": "aurora",
-  "name": "Aurora",
-  "author": "Coop",
-  "url": "https://github.com/lumehq/coop",
-  "light": {
-    "background": "#fdfcfeff",
-    "surface_background": "#f8f8ffff",
-    "elevated_surface_background": "#f0f1feff",
-    "panel_background": "#fdfcfeff",
-    "overlay": "#211f4300",
-    "title_bar": "#f0f1feff",
-    "title_bar_inactive": "#fdfcfeff",
-    "window_border": "#dadcffff",
-    "border": "#dadcffff",
-    "border_variant": "#cbcdffff",
-    "border_focused": "#5b5bd6ff",
-    "border_selected": "#5b5bd6ff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#e6e7ffff",
-    "ring": "#5151cdff",
-    "text": "#1f2d5cff",
-    "text_muted": "#5753c6ff",
-    "text_placeholder": "#9b9ef0ff",
-    "text_accent": "#5b5bd6ff",
-    "text_danger": "#e54d2eff",
-    "text_warning": "#f76b15ff",
-    "icon": "#5753c6ff",
-    "icon_muted": "#9b9ef0ff",
-    "icon_accent": "#5151cdff",
-    "element_foreground": "#ffffffff",
-    "element_background": "#5b5bd6ff",
-    "element_hover": "#5151cdff",
-    "element_active": "#6e56cfff",
-    "element_selected": "#654dc4ff",
-    "element_disabled": "#5b5bd64d",
-    "secondary_foreground": "#1f2d5cff",
-    "secondary_background": "#f0f1feff",
-    "secondary_hover": "#e6e7ffff",
-    "secondary_active": "#dadcffff",
-    "secondary_selected": "#dadcffff",
-    "secondary_disabled": "#5b5bd64d",
-    "danger_foreground": "#ffffffff",
-    "danger_background": "#feebe7ff",
-    "danger_hover": "#ffcdc2ff",
-    "danger_active": "#fdbdafff",
-    "danger_selected": "#fdbdafff",
-    "danger_disabled": "#e54d2e4d",
-    "warning_foreground": "#ffffffff",
-    "warning_background": "#fff7edff",
-    "warning_hover": "#ffd19aff",
-    "warning_active": "#ffc182ff",
-    "warning_selected": "#ffc182ff",
-    "warning_disabled": "#f76b154d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#f0f1feff",
-    "ghost_element_hover": "#211f430d",
-    "ghost_element_active": "#211f431a",
-    "ghost_element_selected": "#211f431a",
-    "ghost_element_disabled": "#211f4305",
-    "tab_background": "#f0f1feff",
-    "tab_foreground": "#5753c6ff",
-    "tab_hover_background": "#211f430d",
-    "tab_active_background": "#fdfcfeff",
-    "tab_active_foreground": "#1f2d5cff",
-    "scrollbar_thumb_background": "#211f431a",
-    "scrollbar_thumb_hover_background": "#211f4326",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#5b5bd61a",
-    "cursor": "#5b5bd6ff",
-    "selection": "#5b5bd640"
-  },
-  "dark": {
-    "background": "#14121fff",
-    "surface_background": "#1b1525ff",
-    "elevated_surface_background": "#291f43ff",
-    "panel_background": "#14121fff",
-    "overlay": "#baa7ff1a",
-    "title_bar": "#291f43ff",
-    "title_bar_inactive": "#14121fff",
-    "window_border": "#473876ff",
-    "border": "#473876ff",
-    "border_variant": "#3c2e69ff",
-    "border_focused": "#7d66d9ff",
-    "border_selected": "#7d66d9ff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#33255bff",
-    "ring": "#6e56cfff",
-    "text": "#e2ddfeff",
-    "text_muted": "#baa7ffff",
-    "text_placeholder": "#6958adff",
-    "text_accent": "#baa7ffff",
-    "text_danger": "#ff977dff",
-    "text_warning": "#ffa057ff",
-    "icon": "#baa7ffff",
-    "icon_muted": "#6958adff",
-    "icon_accent": "#6e56cfff",
-    "element_foreground": "#14121fff",
-    "element_background": "#7d66d9ff",
-    "element_hover": "#baa7ffff",
-    "element_active": "#6e56cfff",
-    "element_selected": "#654dc4ff",
-    "element_disabled": "#7d66d94d",
-    "secondary_foreground": "#e2ddfeff",
-    "secondary_background": "#291f43ff",
-    "secondary_hover": "#33255bff",
-    "secondary_active": "#3c2e69ff",
-    "secondary_selected": "#3c2e69ff",
-    "secondary_disabled": "#7d66d94d",
-    "danger_foreground": "#181111ff",
-    "danger_background": "#391714ff",
-    "danger_hover": "#5e1c16ff",
-    "danger_active": "#6e2920ff",
-    "danger_selected": "#6e2920ff",
-    "danger_disabled": "#ff977d4d",
-    "warning_foreground": "#17120eff",
-    "warning_background": "#331e0bff",
-    "warning_hover": "#562800ff",
-    "warning_active": "#66350cff",
-    "warning_selected": "#66350cff",
-    "warning_disabled": "#ffa0574d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#291f43ff",
-    "ghost_element_hover": "#baa7ff0d",
-    "ghost_element_active": "#baa7ff1a",
-    "ghost_element_selected": "#baa7ff1a",
-    "ghost_element_disabled": "#baa7ff05",
-    "tab_background": "#291f43ff",
-    "tab_foreground": "#baa7ffff",
-    "tab_hover_background": "#baa7ff0d",
-    "tab_active_background": "#14121fff",
-    "tab_active_foreground": "#e2ddfeff",
-    "scrollbar_thumb_background": "#baa7ff1a",
-    "scrollbar_thumb_hover_background": "#baa7ff26",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#baa7ff1a",
-    "cursor": "#baa7ffff",
-    "selection": "#baa7ff40"
-  }
-}

assets/themes/catppuccin-frappe.json

@@ -1,144 +0,0 @@
-{
-  "id": "catppuccin-frappe",
-  "name": "Catppuccin Frappé",
-  "author": "Catppuccin Org (ported by Coop)",
-  "url": "https://catppuccin.com",
-  "light": {
-    "background": "#303446",
-    "surface_background": "#292c3c",
-    "elevated_surface_background": "#232634",
-    "panel_background": "#303446",
-    "overlay": "#c6d0f51a",
-    "title_bar": "#232634",
-    "title_bar_inactive": "#303446",
-    "window_border": "#51576d",
-    "border": "#51576d",
-    "border_variant": "#414559",
-    "border_focused": "#8caaee",
-    "border_selected": "#8caaee",
-    "border_transparent": "#c6d0f500",
-    "border_disabled": "#292c3c",
-    "ring": "#babbf1",
-    "text": "#c6d0f5",
-    "text_muted": "#a5adce",
-    "text_placeholder": "#838ba7",
-    "text_accent": "#8caaee",
-    "text_danger": "#e78284",
-    "text_warning": "#ef9f76",
-    "icon": "#a5adce",
-    "icon_muted": "#838ba7",
-    "icon_accent": "#babbf1",
-    "element_foreground": "#303446",
-    "element_background": "#8caaee",
-    "element_hover": "#babbf1",
-    "element_active": "#99d1db",
-    "element_selected": "#85c1dc",
-    "element_disabled": "#8caaee4d",
-    "secondary_foreground": "#c6d0f5",
-    "secondary_background": "#414559",
-    "secondary_hover": "#51576d",
-    "secondary_active": "#626880",
-    "secondary_selected": "#626880",
-    "secondary_disabled": "#8caaee4d",
-    "danger_foreground": "#303446",
-    "danger_background": "#e78284",
-    "danger_hover": "#ea999c",
-    "danger_active": "#ef9f76",
-    "danger_selected": "#e5c890",
-    "danger_disabled": "#e782844d",
-    "warning_foreground": "#303446",
-    "warning_background": "#ef9f76",
-    "warning_hover": "#e5c890",
-    "warning_active": "#a6d189",
-    "warning_selected": "#81c8be",
-    "warning_disabled": "#ef9f764d",
-    "ghost_element_background": "#c6d0f500",
-    "ghost_element_background_alt": "#292c3c",
-    "ghost_element_hover": "#c6d0f50d",
-    "ghost_element_active": "#c6d0f51a",
-    "ghost_element_selected": "#c6d0f51a",
-    "ghost_element_disabled": "#c6d0f505",
-    "tab_background": "#232634",
-    "tab_foreground": "#a5adce",
-    "tab_hover_background": "#c6d0f50d",
-    "tab_active_background": "#303446",
-    "tab_active_foreground": "#c6d0f5",
-    "scrollbar_thumb_background": "#c6d0f51a",
-    "scrollbar_thumb_hover_background": "#c6d0f526",
-    "scrollbar_thumb_border": "#c6d0f500",
-    "scrollbar_track_background": "#c6d0f500",
-    "scrollbar_track_border": "#c6d0f500",
-    "drop_target_background": "#8caaee1a",
-    "cursor": "#8caaee",
-    "selection": "#8caaee40"
-  },
-  "dark": {
-    "background": "#303446",
-    "surface_background": "#292c3c",
-    "elevated_surface_background": "#232634",
-    "panel_background": "#303446",
-    "overlay": "#c6d0f51a",
-    "title_bar": "#232634",
-    "title_bar_inactive": "#303446",
-    "window_border": "#51576d",
-    "border": "#51576d",
-    "border_variant": "#414559",
-    "border_focused": "#8caaee",
-    "border_selected": "#8caaee",
-    "border_transparent": "#c6d0f500",
-    "border_disabled": "#292c3c",
-    "ring": "#babbf1",
-    "text": "#c6d0f5",
-    "text_muted": "#a5adce",
-    "text_placeholder": "#838ba7",
-    "text_accent": "#8caaee",
-    "text_danger": "#e78284",
-    "text_warning": "#ef9f76",
-    "icon": "#a5adce",
-    "icon_muted": "#838ba7",
-    "icon_accent": "#babbf1",
-    "element_foreground": "#303446",
-    "element_background": "#8caaee",
-    "element_hover": "#babbf1",
-    "element_active": "#99d1db",
-    "element_selected": "#85c1dc",
-    "element_disabled": "#8caaee4d",
-    "secondary_foreground": "#c6d0f5",
-    "secondary_background": "#414559",
-    "secondary_hover": "#51576d",
-    "secondary_active": "#626880",
-    "secondary_selected": "#626880",
-    "secondary_disabled": "#8caaee4d",
-    "danger_foreground": "#303446",
-    "danger_background": "#e78284",
-    "danger_hover": "#ea999c",
-    "danger_active": "#ef9f76",
-    "danger_selected": "#e5c890",
-    "danger_disabled": "#e782844d",
-    "warning_foreground": "#303446",
-    "warning_background": "#ef9f76",
-    "warning_hover": "#e5c890",
-    "warning_active": "#a6d189",
-    "warning_selected": "#81c8be",
-    "warning_disabled": "#ef9f764d",
-    "ghost_element_background": "#c6d0f500",
-    "ghost_element_background_alt": "#292c3c",
-    "ghost_element_hover": "#c6d0f50d",
-    "ghost_element_active": "#c6d0f51a",
-    "ghost_element_selected": "#c6d0f51a",
-    "ghost_element_disabled": "#c6d0f505",
-    "tab_background": "#232634",
-    "tab_foreground": "#a5adce",
-    "tab_hover_background": "#c6d0f50d",
-    "tab_active_background": "#303446",
-    "tab_active_foreground": "#c6d0f5",
-    "scrollbar_thumb_background": "#c6d0f51a",
-    "scrollbar_thumb_hover_background": "#c6d0f526",
-    "scrollbar_thumb_border": "#c6d0f500",
-    "scrollbar_track_background": "#c6d0f500",
-    "scrollbar_track_border": "#c6d0f500",
-    "drop_target_background": "#8caaee1a",
-    "cursor": "#8caaee",
-    "selection": "#8caaee40"
-  }
-}

assets/themes/catppuccin-latte.json

@@ -1,144 +0,0 @@
-{
-  "id": "catppuccin-latte",
-  "name": "Catppuccin Latte",
-  "author": "Catppuccin Org (ported by Coop)",
-  "url": "https://catppuccin.com",
-  "light": {
-    "background": "#eff1f5",
-    "surface_background": "#e6e9ef",
-    "elevated_surface_background": "#dce0e8",
-    "panel_background": "#eff1f5",
-    "overlay": "#4c4f691a",
-    "title_bar": "#dce0e8",
-    "title_bar_inactive": "#eff1f5",
-    "window_border": "#bcc0cc",
-    "border": "#bcc0cc",
-    "border_variant": "#ccd0da",
-    "border_focused": "#1e66f5",
-    "border_selected": "#1e66f5",
-    "border_transparent": "#4c4f6900",
-    "border_disabled": "#e6e9ef",
-    "ring": "#7287fd",
-    "text": "#4c4f69",
-    "text_muted": "#6c6f85",
-    "text_placeholder": "#8c8fa1",
-    "text_accent": "#1e66f5",
-    "text_danger": "#d20f39",
-    "text_warning": "#fe640b",
-    "icon": "#6c6f85",
-    "icon_muted": "#8c8fa1",
-    "icon_accent": "#7287fd",
-    "element_foreground": "#eff1f5",
-    "element_background": "#1e66f5",
-    "element_hover": "#7287fd",
-    "element_active": "#04a5e5",
-    "element_selected": "#209fb5",
-    "element_disabled": "#1e66f54d",
-    "secondary_foreground": "#4c4f69",
-    "secondary_background": "#ccd0da",
-    "secondary_hover": "#bcc0cc",
-    "secondary_active": "#acb0be",
-    "secondary_selected": "#acb0be",
-    "secondary_disabled": "#1e66f54d",
-    "danger_foreground": "#eff1f5",
-    "danger_background": "#d20f39",
-    "danger_hover": "#e64553",
-    "danger_active": "#fe640b",
-    "danger_selected": "#df8e1d",
-    "danger_disabled": "#d20f394d",
-    "warning_foreground": "#eff1f5",
-    "warning_background": "#fe640b",
-    "warning_hover": "#df8e1d",
-    "warning_active": "#40a02b",
-    "warning_selected": "#179299",
-    "warning_disabled": "#fe640b4d",
-    "ghost_element_background": "#4c4f6900",
-    "ghost_element_background_alt": "#e6e9ef",
-    "ghost_element_hover": "#4c4f690d",
-    "ghost_element_active": "#4c4f691a",
-    "ghost_element_selected": "#4c4f691a",
-    "ghost_element_disabled": "#4c4f6905",
-    "tab_background": "#e6e9ef",
-    "tab_foreground": "#6c6f85",
-    "tab_hover_background": "#4c4f690d",
-    "tab_active_background": "#eff1f5",
-    "tab_active_foreground": "#4c4f69",
-    "scrollbar_thumb_background": "#4c4f691a",
-    "scrollbar_thumb_hover_background": "#4c4f6926",
-    "scrollbar_thumb_border": "#4c4f6900",
-    "scrollbar_track_background": "#4c4f6900",
-    "scrollbar_track_border": "#4c4f6900",
-    "drop_target_background": "#1e66f51a",
-    "cursor": "#1e66f5",
-    "selection": "#1e66f540"
-  },
-  "dark": {
-    "background": "#eff1f5",
-    "surface_background": "#e6e9ef",
-    "elevated_surface_background": "#dce0e8",
-    "panel_background": "#eff1f5",
-    "overlay": "#4c4f691a",
-    "title_bar": "#dce0e8",
-    "title_bar_inactive": "#eff1f5",
-    "window_border": "#bcc0cc",
-    "border": "#bcc0cc",
-    "border_variant": "#ccd0da",
-    "border_focused": "#1e66f5",
-    "border_selected": "#1e66f5",
-    "border_transparent": "#4c4f6900",
-    "border_disabled": "#e6e9ef",
-    "ring": "#7287fd",
-    "text": "#4c4f69",
-    "text_muted": "#6c6f85",
-    "text_placeholder": "#8c8fa1",
-    "text_accent": "#1e66f5",
-    "text_danger": "#d20f39",
-    "text_warning": "#fe640b",
-    "icon": "#6c6f85",
-    "icon_muted": "#8c8fa1",
-    "icon_accent": "#7287fd",
-    "element_foreground": "#eff1f5",
-    "element_background": "#1e66f5",
-    "element_hover": "#7287fd",
-    "element_active": "#04a5e5",
-    "element_selected": "#209fb5",
-    "element_disabled": "#1e66f54d",
-    "secondary_foreground": "#4c4f69",
-    "secondary_background": "#ccd0da",
-    "secondary_hover": "#bcc0cc",
-    "secondary_active": "#acb0be",
-    "secondary_selected": "#acb0be",
-    "secondary_disabled": "#1e66f54d",
-    "danger_foreground": "#eff1f5",
-    "danger_background": "#d20f39",
-    "danger_hover": "#e64553",
-    "danger_active": "#fe640b",
-    "danger_selected": "#df8e1d",
-    "danger_disabled": "#d20f394d",
-    "warning_foreground": "#eff1f5",
-    "warning_background": "#fe640b",
-    "warning_hover": "#df8e1d",
-    "warning_active": "#40a02b",
-    "warning_selected": "#179299",
-    "warning_disabled": "#fe640b4d",
-    "ghost_element_background": "#4c4f6900",
-    "ghost_element_background_alt": "#e6e9ef",
-    "ghost_element_hover": "#4c4f690d",
-    "ghost_element_active": "#4c4f691a",
-    "ghost_element_selected": "#4c4f691a",
-    "ghost_element_disabled": "#4c4f6905",
-    "tab_background": "#e6e9ef",
-    "tab_foreground": "#6c6f85",
-    "tab_hover_background": "#4c4f690d",
-    "tab_active_background": "#eff1f5",
-    "tab_active_foreground": "#4c4f69",
-    "scrollbar_thumb_background": "#4c4f691a",
-    "scrollbar_thumb_hover_background": "#4c4f6926",
-    "scrollbar_thumb_border": "#4c4f6900",
-    "scrollbar_track_background": "#4c4f6900",
-    "scrollbar_track_border": "#4c4f6900",
-    "drop_target_background": "#1e66f51a",
-    "cursor": "#1e66f5",
-    "selection": "#1e66f540"
-  }
-}

assets/themes/catppuccin-macchiato.json

@@ -1,144 +0,0 @@
-{
-  "id": "catppuccin-macchiato",
-  "name": "Catppuccin Macchiato",
-  "author": "Catppuccin Org (ported by Coop)",
-  "url": "https://catppuccin.com",
-  "light": {
-    "background": "#24273a",
-    "surface_background": "#1e2030",
-    "elevated_surface_background": "#181926",
-    "panel_background": "#24273a",
-    "overlay": "#cad3f51a",
-    "title_bar": "#181926",
-    "title_bar_inactive": "#24273a",
-    "window_border": "#494d64",
-    "border": "#494d64",
-    "border_variant": "#363a4f",
-    "border_focused": "#8aadf4",
-    "border_selected": "#8aadf4",
-    "border_transparent": "#cad3f500",
-    "border_disabled": "#1e2030",
-    "ring": "#b7bdf8",
-    "text": "#cad3f5",
-    "text_muted": "#a5adcb",
-    "text_placeholder": "#8087a2",
-    "text_accent": "#8aadf4",
-    "text_danger": "#ed8796",
-    "text_warning": "#f5a97f",
-    "icon": "#a5adcb",
-    "icon_muted": "#8087a2",
-    "icon_accent": "#b7bdf8",
-    "element_foreground": "#24273a",
-    "element_background": "#8aadf4",
-    "element_hover": "#b7bdf8",
-    "element_active": "#91d7e3",
-    "element_selected": "#7dc4e4",
-    "element_disabled": "#8aadf44d",
-    "secondary_foreground": "#cad3f5",
-    "secondary_background": "#363a4f",
-    "secondary_hover": "#494d64",
-    "secondary_active": "#5b6078",
-    "secondary_selected": "#5b6078",
-    "secondary_disabled": "#8aadf44d",
-    "danger_foreground": "#24273a",
-    "danger_background": "#ed8796",
-    "danger_hover": "#ee99a0",
-    "danger_active": "#f5a97f",
-    "danger_selected": "#eed49f",
-    "danger_disabled": "#ed87964d",
-    "warning_foreground": "#24273a",
-    "warning_background": "#f5a97f",
-    "warning_hover": "#eed49f",
-    "warning_active": "#a6da95",
-    "warning_selected": "#8bd5ca",
-    "warning_disabled": "#f5a97f4d",
-    "ghost_element_background": "#cad3f500",
-    "ghost_element_background_alt": "#1e2030",
-    "ghost_element_hover": "#cad3f50d",
-    "ghost_element_active": "#cad3f51a",
-    "ghost_element_selected": "#cad3f51a",
-    "ghost_element_disabled": "#cad3f505",
-    "tab_background": "#181926",
-    "tab_foreground": "#a5adcb",
-    "tab_hover_background": "#cad3f50d",
-    "tab_active_background": "#24273a",
-    "tab_active_foreground": "#cad3f5",
-    "scrollbar_thumb_background": "#cad3f51a",
-    "scrollbar_thumb_hover_background": "#cad3f526",
-    "scrollbar_thumb_border": "#cad3f500",
-    "scrollbar_track_background": "#cad3f500",
-    "scrollbar_track_border": "#cad3f500",
-    "drop_target_background": "#8aadf41a",
-    "cursor": "#8aadf4",
-    "selection": "#8aadf440"
-  },
-  "dark": {
-    "background": "#24273a",
-    "surface_background": "#1e2030",
-    "elevated_surface_background": "#181926",
-    "panel_background": "#24273a",
-    "overlay": "#cad3f51a",
-    "title_bar": "#181926",
-    "title_bar_inactive": "#24273a",
-    "window_border": "#494d64",
-    "border": "#494d64",
-    "border_variant": "#363a4f",
-    "border_focused": "#8aadf4",
-    "border_selected": "#8aadf4",
-    "border_transparent": "#cad3f500",
-    "border_disabled": "#1e2030",
-    "ring": "#b7bdf8",
-    "text": "#cad3f5",
-    "text_muted": "#a5adcb",
-    "text_placeholder": "#8087a2",
-    "text_accent": "#8aadf4",
-    "text_danger": "#ed8796",
-    "text_warning": "#f5a97f",
-    "icon": "#a5adcb",
-    "icon_muted": "#8087a2",
-    "icon_accent": "#b7bdf8",
-    "element_foreground": "#24273a",
-    "element_background": "#8aadf4",
-    "element_hover": "#b7bdf8",
-    "element_active": "#91d7e3",
-    "element_selected": "#7dc4e4",
-    "element_disabled": "#8aadf44d",
-    "secondary_foreground": "#cad3f5",
-    "secondary_background": "#363a4f",
-    "secondary_hover": "#494d64",
-    "secondary_active": "#5b6078",
-    "secondary_selected": "#5b6078",
-    "secondary_disabled": "#8aadf44d",
-    "danger_foreground": "#24273a",
-    "danger_background": "#ed8796",
-    "danger_hover": "#ee99a0",
-    "danger_active": "#f5a97f",
-    "danger_selected": "#eed49f",
-    "danger_disabled": "#ed87964d",
-    "warning_foreground": "#24273a",
-    "warning_background": "#f5a97f",
-    "warning_hover": "#eed49f",
-    "warning_active": "#a6da95",
-    "warning_selected": "#8bd5ca",
-    "warning_disabled": "#f5a97f4d",
-    "ghost_element_background": "#cad3f500",
-    "ghost_element_background_alt": "#1e2030",
-    "ghost_element_hover": "#cad3f50d",
-    "ghost_element_active": "#cad3f51a",
-    "ghost_element_selected": "#cad3f51a",
-    "ghost_element_disabled": "#cad3f505",
-    "tab_background": "#181926",
-    "tab_foreground": "#a5adcb",
-    "tab_hover_background": "#cad3f50d",
-    "tab_active_background": "#24273a",
-    "tab_active_foreground": "#cad3f5",
-    "scrollbar_thumb_background": "#cad3f51a",
-    "scrollbar_thumb_hover_background": "#cad3f526",
-    "scrollbar_thumb_border": "#cad3f500",
-    "scrollbar_track_background": "#cad3f500",
-    "scrollbar_track_border": "#cad3f500",
-    "drop_target_background": "#8aadf41a",
-    "cursor": "#8aadf4",
-    "selection": "#8aadf440"
-  }
-}

assets/themes/catppuccin-mocha.json

@@ -1,144 +0,0 @@
-{
-  "id": "catppuccin-mocha",
-  "name": "Catppuccin Mocha",
-  "author": "Catppuccin Org (ported by Coop)",
-  "url": "https://catppuccin.com",
-  "light": {
-    "background": "#1e1e2e",
-    "surface_background": "#181825",
-    "elevated_surface_background": "#11111b",
-    "panel_background": "#1e1e2e",
-    "overlay": "#cdd6f41a",
-    "title_bar": "#11111b",
-    "title_bar_inactive": "#1e1e2e",
-    "window_border": "#45475a",
-    "border": "#45475a",
-    "border_variant": "#313244",
-    "border_focused": "#89b4fa",
-    "border_selected": "#89b4fa",
-    "border_transparent": "#cdd6f400",
-    "border_disabled": "#181825",
-    "ring": "#b4befe",
-    "text": "#cdd6f4",
-    "text_muted": "#a6adc8",
-    "text_placeholder": "#7f849c",
-    "text_accent": "#89b4fa",
-    "text_danger": "#f38ba8",
-    "text_warning": "#fab387",
-    "icon": "#a6adc8",
-    "icon_muted": "#7f849c",
-    "icon_accent": "#b4befe",
-    "element_foreground": "#1e1e2e",
-    "element_background": "#89b4fa",
-    "element_hover": "#b4befe",
-    "element_active": "#89dceb",
-    "element_selected": "#74c7ec",
-    "element_disabled": "#89b4fa4d",
-    "secondary_foreground": "#cdd6f4",
-    "secondary_background": "#313244",
-    "secondary_hover": "#45475a",
-    "secondary_active": "#585b70",
-    "secondary_selected": "#585b70",
-    "secondary_disabled": "#89b4fa4d",
-    "danger_foreground": "#1e1e2e",
-    "danger_background": "#f38ba8",
-    "danger_hover": "#eba0ac",
-    "danger_active": "#fab387",
-    "danger_selected": "#f9e2af",
-    "danger_disabled": "#f38ba84d",
-    "warning_foreground": "#1e1e2e",
-    "warning_background": "#fab387",
-    "warning_hover": "#f9e2af",
-    "warning_active": "#a6e3a1",
-    "warning_selected": "#94e2d5",
-    "warning_disabled": "#fab3874d",
-    "ghost_element_background": "#cdd6f400",
-    "ghost_element_background_alt": "#181825",
-    "ghost_element_hover": "#cdd6f40d",
-    "ghost_element_active": "#cdd6f41a",
-    "ghost_element_selected": "#cdd6f41a",
-    "ghost_element_disabled": "#cdd6f405",
-    "tab_background": "#11111b",
-    "tab_foreground": "#a6adc8",
-    "tab_hover_background": "#cdd6f40d",
-    "tab_active_background": "#1e1e2e",
-    "tab_active_foreground": "#cdd6f4",
-    "scrollbar_thumb_background": "#cdd6f41a",
-    "scrollbar_thumb_hover_background": "#cdd6f426",
-    "scrollbar_thumb_border": "#cdd6f400",
-    "scrollbar_track_background": "#cdd6f400",
-    "scrollbar_track_border": "#cdd6f400",
-    "drop_target_background": "#89b4fa1a",
-    "cursor": "#89b4fa",
-    "selection": "#89b4fa40"
-  },
-  "dark": {
-    "background": "#1e1e2e",
-    "surface_background": "#181825",
-    "elevated_surface_background": "#11111b",
-    "panel_background": "#1e1e2e",
-    "overlay": "#cdd6f41a",
-    "title_bar": "#11111b",
-    "title_bar_inactive": "#1e1e2e",
-    "window_border": "#45475a",
-    "border": "#45475a",
-    "border_variant": "#313244",
-    "border_focused": "#89b4fa",
-    "border_selected": "#89b4fa",
-    "border_transparent": "#cdd6f400",
-    "border_disabled": "#181825",
-    "ring": "#b4befe",
-    "text": "#cdd6f4",
-    "text_muted": "#a6adc8",
-    "text_placeholder": "#7f849c",
-    "text_accent": "#89b4fa",
-    "text_danger": "#f38ba8",
-    "text_warning": "#fab387",
-    "icon": "#a6adc8",
-    "icon_muted": "#7f849c",
-    "icon_accent": "#b4befe",
-    "element_foreground": "#1e1e2e",
-    "element_background": "#89b4fa",
-    "element_hover": "#b4befe",
-    "element_active": "#89dceb",
-    "element_selected": "#74c7ec",
-    "element_disabled": "#89b4fa4d",
-    "secondary_foreground": "#cdd6f4",
-    "secondary_background": "#313244",
-    "secondary_hover": "#45475a",
-    "secondary_active": "#585b70",
-    "secondary_selected": "#585b70",
-    "secondary_disabled": "#89b4fa4d",
-    "danger_foreground": "#1e1e2e",
-    "danger_background": "#f38ba8",
-    "danger_hover": "#eba0ac",
-    "danger_active": "#fab387",
-    "danger_selected": "#f9e2af",
-    "danger_disabled": "#f38ba84d",
-    "warning_foreground": "#1e1e2e",
-    "warning_background": "#fab387",
-    "warning_hover": "#f9e2af",
-    "warning_active": "#a6e3a1",
-    "warning_selected": "#94e2d5",
-    "warning_disabled": "#fab3874d",
-    "ghost_element_background": "#cdd6f400",
-    "ghost_element_background_alt": "#181825",
-    "ghost_element_hover": "#cdd6f40d",
-    "ghost_element_active": "#cdd6f41a",
-    "ghost_element_selected": "#cdd6f41a",
-    "ghost_element_disabled": "#cdd6f405",
-    "tab_background": "#11111b",
-    "tab_foreground": "#a6adc8",
-    "tab_hover_background": "#cdd6f40d",
-    "tab_active_background": "#1e1e2e",
-    "tab_active_foreground": "#cdd6f4",
-    "scrollbar_thumb_background": "#cdd6f41a",
-    "scrollbar_thumb_hover_background": "#cdd6f426",
-    "scrollbar_thumb_border": "#cdd6f400",
-    "scrollbar_track_background": "#cdd6f400",
-    "scrollbar_track_border": "#cdd6f400",
-    "drop_target_background": "#89b4fa1a",
-    "cursor": "#89b4fa",
-    "selection": "#89b4fa40"
-  }
-}

assets/themes/flexoki.json

@@ -1,144 +0,0 @@
-{
-  "id": "flexoki",
-  "name": "Flexoki",
-  "author": "Steph Ango (ported by Coop)",
-  "url": "https://stephango.com/flexoki",
-  "light": {
-    "background": "#FFFCF0",
-    "surface_background": "#F2F0E5",
-    "elevated_surface_background": "#E6E4D9",
-    "panel_background": "#FFFCF0",
-    "overlay": "#100F0F1A",
-    "title_bar": "#E6E4D9",
-    "title_bar_inactive": "#FFFCF0",
-    "window_border": "#CECDC3",
-    "border": "#CECDC3",
-    "border_variant": "#DAD8CE",
-    "border_focused": "#24837B",
-    "border_selected": "#24837B",
-    "border_transparent": "#100F0F00",
-    "border_disabled": "#E6E4D9",
-    "ring": "#3AA99F",
-    "text": "#100F0F",
-    "text_muted": "#6F6E69",
-    "text_placeholder": "#B7B5AC",
-    "text_accent": "#24837B",
-    "text_danger": "#AF3029",
-    "text_warning": "#BC5215",
-    "icon": "#6F6E69",
-    "icon_muted": "#B7B5AC",
-    "icon_accent": "#3AA99F",
-    "element_foreground": "#FFFCF0",
-    "element_background": "#24837B",
-    "element_hover": "#3AA99F",
-    "element_active": "#1C1B1A",
-    "element_selected": "#100F0F",
-    "element_disabled": "#24837B4D",
-    "secondary_foreground": "#100F0F",
-    "secondary_background": "#E6E4D9",
-    "secondary_hover": "#DAD8CE",
-    "secondary_active": "#CECDC3",
-    "secondary_selected": "#CECDC3",
-    "secondary_disabled": "#24837B4D",
-    "danger_foreground": "#FFFCF0",
-    "danger_background": "#AF3029",
-    "danger_hover": "#D14D41",
-    "danger_active": "#1C1B1A",
-    "danger_selected": "#100F0F",
-    "danger_disabled": "#AF30294D",
-    "warning_foreground": "#FFFCF0",
-    "warning_background": "#BC5215",
-    "warning_hover": "#DA702C",
-    "warning_active": "#1C1B1A",
-    "warning_selected": "#100F0F",
-    "warning_disabled": "#BC52154D",
-    "ghost_element_background": "#100F0F00",
-    "ghost_element_background_alt": "#F2F0E5",
-    "ghost_element_hover": "#100F0F0D",
-    "ghost_element_active": "#100F0F1A",
-    "ghost_element_selected": "#100F0F1A",
-    "ghost_element_disabled": "#100F0F05",
-    "tab_background": "#E6E4D9",
-    "tab_foreground": "#6F6E69",
-    "tab_hover_background": "#100F0F0D",
-    "tab_active_background": "#FFFCF0",
-    "tab_active_foreground": "#100F0F",
-    "scrollbar_thumb_background": "#100F0F1A",
-    "scrollbar_thumb_hover_background": "#100F0F26",
-    "scrollbar_thumb_border": "#100F0F00",
-    "scrollbar_track_background": "#100F0F00",
-    "scrollbar_track_border": "#100F0F00",
-    "drop_target_background": "#24837B1A",
-    "cursor": "#24837B",
-    "selection": "#24837B40"
-  },
-  "dark": {
-    "background": "#100F0F",
-    "surface_background": "#1C1B1A",
-    "elevated_surface_background": "#282726",
-    "panel_background": "#100F0F",
-    "overlay": "#FFFCF01A",
-    "title_bar": "#282726",
-    "title_bar_inactive": "#100F0F",
-    "window_border": "#403E3C",
-    "border": "#403E3C",
-    "border_variant": "#343331",
-    "border_focused": "#3AA99F",
-    "border_selected": "#3AA99F",
-    "border_transparent": "#100F0F00",
-    "border_disabled": "#282726",
-    "ring": "#24837B",
-    "text": "#CECDC3",
-    "text_muted": "#878580",
-    "text_placeholder": "#575653",
-    "text_accent": "#3AA99F",
-    "text_danger": "#D14D41",
-    "text_warning": "#DA702C",
-    "icon": "#878580",
-    "icon_muted": "#575653",
-    "icon_accent": "#24837B",
-    "element_foreground": "#100F0F",
-    "element_background": "#3AA99F",
-    "element_hover": "#24837B",
-    "element_active": "#CECDC3",
-    "element_selected": "#F2F0E5",
-    "element_disabled": "#3AA99F4D",
-    "secondary_foreground": "#CECDC3",
-    "secondary_background": "#1C1B1A",
-    "secondary_hover": "#282726",
-    "secondary_active": "#343331",
-    "secondary_selected": "#343331",
-    "secondary_disabled": "#3AA99F4D",
-    "danger_foreground": "#100F0F",
-    "danger_background": "#D14D41",
-    "danger_hover": "#AF3029",
-    "danger_active": "#CECDC3",
-    "danger_selected": "#F2F0E5",
-    "danger_disabled": "#D14D414D",
-    "warning_foreground": "#100F0F",
-    "warning_background": "#DA702C",
-    "warning_hover": "#BC5215",
-    "warning_active": "#CECDC3",
-    "warning_selected": "#F2F0E5",
-    "warning_disabled": "#DA702C4D",
-    "ghost_element_background": "#100F0F00",
-    "ghost_element_background_alt": "#1C1B1A",
-    "ghost_element_hover": "#FFFCF00D",
-    "ghost_element_active": "#FFFCF01A",
-    "ghost_element_selected": "#FFFCF01A",
-    "ghost_element_disabled": "#FFFCF005",
-    "tab_background": "#282726",
-    "tab_foreground": "#878580",
-    "tab_hover_background": "#FFFCF00D",
-    "tab_active_background": "#100F0F",
-    "tab_active_foreground": "#CECDC3",
-    "scrollbar_thumb_background": "#FFFCF01A",
-    "scrollbar_thumb_hover_background": "#FFFCF026",
-    "scrollbar_thumb_border": "#100F0F00",
-    "scrollbar_track_background": "#100F0F00",
-    "scrollbar_track_border": "#100F0F00",
-    "drop_target_background": "#3AA99F1A",
-    "cursor": "#3AA99F",
-    "selection": "#3AA99F40"
-  }
-}

assets/themes/forest.json

@@ -1,144 +0,0 @@
-{
-  "id": "forest",
-  "name": "Forest",
-  "author": "Coop",
-  "url": "https://github.com/lumehq/coop",
-  "light": {
-    "background": "#fbfefcff",
-    "surface_background": "#f4fbf6ff",
-    "elevated_surface_background": "#e9f6e9ff",
-    "panel_background": "#fbfefcff",
-    "overlay": "#193b2d1a",
-    "title_bar": "#e9f6e9ff",
-    "title_bar_inactive": "#fbfefcff",
-    "window_border": "#c4e8d1ff",
-    "border": "#c4e8d1ff",
-    "border_variant": "#b2ddb5ff",
-    "border_focused": "#30a46cff",
-    "border_selected": "#30a46cff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#e0f3e6ff",
-    "ring": "#2b9a66ff",
-    "text": "#193b2dff",
-    "text_muted": "#2f7c57ff",
-    "text_placeholder": "#8eceaaff",
-    "text_accent": "#30a46cff",
-    "text_danger": "#e54d2eff",
-    "text_warning": "#f76b15ff",
-    "icon": "#2f7c57ff",
-    "icon_muted": "#8eceaaff",
-    "icon_accent": "#2b9a66ff",
-    "element_foreground": "#ffffffff",
-    "element_background": "#30a46cff",
-    "element_hover": "#2b9a66ff",
-    "element_active": "#2a7e3bff",
-    "element_selected": "#218358ff",
-    "element_disabled": "#30a46c4d",
-    "secondary_foreground": "#193b2dff",
-    "secondary_background": "#e9f6e9ff",
-    "secondary_hover": "#daf1dbff",
-    "secondary_active": "#c4e8d1ff",
-    "secondary_selected": "#c4e8d1ff",
-    "secondary_disabled": "#30a46c4d",
-    "danger_foreground": "#ffffffff",
-    "danger_background": "#feebe7ff",
-    "danger_hover": "#ffcdc2ff",
-    "danger_active": "#fdbdafff",
-    "danger_selected": "#fdbdafff",
-    "danger_disabled": "#e54d2e4d",
-    "warning_foreground": "#ffffffff",
-    "warning_background": "#fff7edff",
-    "warning_hover": "#ffd19aff",
-    "warning_active": "#ffc182ff",
-    "warning_selected": "#ffc182ff",
-    "warning_disabled": "#f76b154d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#e9f6e9ff",
-    "ghost_element_hover": "#193b2d0d",
-    "ghost_element_active": "#193b2d1a",
-    "ghost_element_selected": "#193b2d1a",
-    "ghost_element_disabled": "#193b2d05",
-    "tab_background": "#e9f6e9ff",
-    "tab_foreground": "#2f7c57ff",
-    "tab_hover_background": "#193b2d0d",
-    "tab_active_background": "#fbfefcff",
-    "tab_active_foreground": "#193b2dff",
-    "scrollbar_thumb_background": "#193b2d1a",
-    "scrollbar_thumb_hover_background": "#193b2d26",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#30a46c1a",
-    "cursor": "#30a46cff",
-    "selection": "#30a46c40"
-  },
-  "dark": {
-    "background": "#0e1512ff",
-    "surface_background": "#121b17ff",
-    "elevated_surface_background": "#132d21ff",
-    "panel_background": "#0e1512ff",
-    "overlay": "#b1f1cb1a",
-    "title_bar": "#132d21ff",
-    "title_bar_inactive": "#0e1512ff",
-    "window_border": "#20573eff",
-    "border": "#20573eff",
-    "border_variant": "#174933ff",
-    "border_focused": "#33b074ff",
-    "border_selected": "#33b074ff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#113b29ff",
-    "ring": "#33b074ff",
-    "text": "#b1f1cbff",
-    "text_muted": "#71d083ff",
-    "text_placeholder": "#2f7c57ff",
-    "text_accent": "#3dd68cff",
-    "text_danger": "#ff977dff",
-    "text_warning": "#ffa057ff",
-    "icon": "#71d083ff",
-    "icon_muted": "#2f7c57ff",
-    "icon_accent": "#33b074ff",
-    "element_foreground": "#0e1512ff",
-    "element_background": "#3dd68cff",
-    "element_hover": "#71d083ff",
-    "element_active": "#33b074ff",
-    "element_selected": "#30a46cff",
-    "element_disabled": "#3dd68c4d",
-    "secondary_foreground": "#b1f1cbff",
-    "secondary_background": "#132d21ff",
-    "secondary_hover": "#113b29ff",
-    "secondary_active": "#174933ff",
-    "secondary_selected": "#174933ff",
-    "secondary_disabled": "#3dd68c4d",
-    "danger_foreground": "#181111ff",
-    "danger_background": "#391714ff",
-    "danger_hover": "#5e1c16ff",
-    "danger_active": "#6e2920ff",
-    "danger_selected": "#6e2920ff",
-    "danger_disabled": "#ff977d4d",
-    "warning_foreground": "#17120eff",
-    "warning_background": "#331e0bff",
-    "warning_hover": "#562800ff",
-    "warning_active": "#66350cff",
-    "warning_selected": "#66350cff",
-    "warning_disabled": "#ffa0574d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#132d21ff",
-    "ghost_element_hover": "#b1f1cb0d",
-    "ghost_element_active": "#b1f1cb1a",
-    "ghost_element_selected": "#b1f1cb1a",
-    "ghost_element_disabled": "#b1f1cb05",
-    "tab_background": "#132d21ff",
-    "tab_foreground": "#71d083ff",
-    "tab_hover_background": "#b1f1cb0d",
-    "tab_active_background": "#0e1512ff",
-    "tab_active_foreground": "#b1f1cbff",
-    "scrollbar_thumb_background": "#b1f1cb1a",
-    "scrollbar_thumb_hover_background": "#b1f1cb26",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#3dd68c1a",
-    "cursor": "#3dd68cff",
-    "selection": "#3dd68c40"
-  }
-}

assets/themes/ocean.json

@@ -1,144 +0,0 @@
-{
-  "id": "ocean",
-  "name": "Ocean",
-  "author": "Coop",
-  "url": "https://github.com/lumehq/coop",
-  "light": {
-    "background": "#fafefeff",
-    "surface_background": "#f2fbfaff",
-    "elevated_surface_background": "#e6f7f7ff",
-    "panel_background": "#fafefeff",
-    "overlay": "#00333f1a",
-    "title_bar": "#e6f7f7ff",
-    "title_bar_inactive": "#fafefeff",
-    "window_border": "#cce5e9ff",
-    "border": "#cce5e9ff",
-    "border_variant": "#b8dde3ff",
-    "border_focused": "#00a2c7ff",
-    "border_selected": "#00a2c7ff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#e0f0f2ff",
-    "ring": "#0797b9ff",
-    "text": "#0d3c48ff",
-    "text_muted": "#107d98ff",
-    "text_placeholder": "#60b3d7ff",
-    "text_accent": "#00a2c7ff",
-    "text_danger": "#e54d2eff",
-    "text_warning": "#f76b15ff",
-    "icon": "#107d98ff",
-    "icon_muted": "#60b3d7ff",
-    "icon_accent": "#0797b9ff",
-    "element_foreground": "#ffffffff",
-    "element_background": "#00a2c7ff",
-    "element_hover": "#0797b9ff",
-    "element_active": "#12667eff",
-    "element_selected": "#0d4a5cff",
-    "element_disabled": "#00a2c74d",
-    "secondary_foreground": "#0d4a5cff",
-    "secondary_background": "#ddf9f2ff",
-    "secondary_hover": "#c8f4e9ff",
-    "secondary_active": "#b3ecdeff",
-    "secondary_selected": "#b3ecdeff",
-    "secondary_disabled": "#00a2c74d",
-    "danger_foreground": "#ffffffff",
-    "danger_background": "#feebe7ff",
-    "danger_hover": "#ffcdc2ff",
-    "danger_active": "#fdbdafff",
-    "danger_selected": "#fdbdafff",
-    "danger_disabled": "#e54d2e4d",
-    "warning_foreground": "#ffffffff",
-    "warning_background": "#fff7edff",
-    "warning_hover": "#ffd19aff",
-    "warning_active": "#ffc182ff",
-    "warning_selected": "#ffc182ff",
-    "warning_disabled": "#f76b154d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#e6f7f7ff",
-    "ghost_element_hover": "#00333f0d",
-    "ghost_element_active": "#00333f1a",
-    "ghost_element_selected": "#00333f1a",
-    "ghost_element_disabled": "#00333f05",
-    "tab_background": "#e6f7f7ff",
-    "tab_foreground": "#107d98ff",
-    "tab_hover_background": "#00333f0d",
-    "tab_active_background": "#fafefeff",
-    "tab_active_foreground": "#0d3c48ff",
-    "scrollbar_thumb_background": "#00333f1a",
-    "scrollbar_thumb_hover_background": "#00333f26",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#00a2c71a",
-    "cursor": "#00a2c7ff",
-    "selection": "#00a2c740"
-  },
-  "dark": {
-    "background": "#0b161aff",
-    "surface_background": "#101b20ff",
-    "elevated_surface_background": "#082c36ff",
-    "panel_background": "#0b161aff",
-    "overlay": "#c2f3ff1a",
-    "title_bar": "#082c36ff",
-    "title_bar_inactive": "#0b161aff",
-    "window_border": "#1b537bff",
-    "border": "#1b537bff",
-    "border_variant": "#154467ff",
-    "border_focused": "#00a2c7ff",
-    "border_selected": "#00a2c7ff",
-    "border_transparent": "#00000000",
-    "border_disabled": "#112840ff",
-    "ring": "#23afd0ff",
-    "text": "#b6ecf7ff",
-    "text_muted": "#4ccce6ff",
-    "text_placeholder": "#197caeff",
-    "text_accent": "#7ce2feff",
-    "text_danger": "#ff977dff",
-    "text_warning": "#ffa057ff",
-    "icon": "#4ccce6ff",
-    "icon_muted": "#197caeff",
-    "icon_accent": "#23afd0ff",
-    "element_foreground": "#0b161aff",
-    "element_background": "#7ce2feff",
-    "element_hover": "#a8eeffff",
-    "element_active": "#23afd0ff",
-    "element_selected": "#00a2c7ff",
-    "element_disabled": "#7ce2fe4d",
-    "secondary_foreground": "#adf0ddff",
-    "secondary_background": "#0d2d2aff",
-    "secondary_hover": "#023b37ff",
-    "secondary_active": "#084843ff",
-    "secondary_selected": "#084843ff",
-    "secondary_disabled": "#7ce2fe4d",
-    "danger_foreground": "#181111ff",
-    "danger_background": "#391714ff",
-    "danger_hover": "#5e1c16ff",
-    "danger_active": "#6e2920ff",
-    "danger_selected": "#6e2920ff",
-    "danger_disabled": "#ff977d4d",
-    "warning_foreground": "#17120eff",
-    "warning_background": "#331e0bff",
-    "warning_hover": "#562800ff",
-    "warning_active": "#66350cff",
-    "warning_selected": "#66350cff",
-    "warning_disabled": "#ffa0574d",
-    "ghost_element_background": "#00000000",
-    "ghost_element_background_alt": "#082c36ff",
-    "ghost_element_hover": "#c2f3ff0d",
-    "ghost_element_active": "#c2f3ff1a",
-    "ghost_element_selected": "#c2f3ff1a",
-    "ghost_element_disabled": "#c2f3ff05",
-    "tab_background": "#082c36ff",
-    "tab_foreground": "#4ccce6ff",
-    "tab_hover_background": "#c2f3ff0d",
-    "tab_active_background": "#0b161aff",
-    "tab_active_foreground": "#b6ecf7ff",
-    "scrollbar_thumb_background": "#c2f3ff1a",
-    "scrollbar_thumb_hover_background": "#c2f3ff26",
-    "scrollbar_thumb_border": "#00000000",
-    "scrollbar_track_background": "#00000000",
-    "scrollbar_track_border": "#00000000",
-    "drop_target_background": "#7ce2fe1a",
-    "cursor": "#7ce2feff",
-    "selection": "#7ce2fe40"
-  }
-}

crates/assets/Cargo.toml

@@ -7,5 +7,4 @@ publish.workspace = true
 [dependencies]
 gpui.workspace = true
 anyhow.workspace = true
-log.workspace = true
 rust-embed.workspace = true

crates/assets/src/lib.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use gpui::{App, AssetSource, Result, SharedString};
+use gpui::{AssetSource, Result, SharedString};
 use rust_embed::RustEmbed;
 
 #[derive(RustEmbed)]
@@ -7,7 +7,6 @@ use rust_embed::RustEmbed;
 #[include = "fonts/**/*"]
 #[include = "brand/**/*"]
 #[include = "icons/**/*"]
-#[include = "themes/**/*"]
 #[exclude = "*.DS_Store"]
 pub struct Assets;
 
@@ -30,22 +29,3 @@ impl AssetSource for Assets {
             .collect())
     }
 }
-
-impl Assets {
-    /// Populate the [`TextSystem`] of the given [`AppContext`] with all `.ttf` fonts in the `fonts` directory.
-    pub fn load_fonts(&self, cx: &App) -> anyhow::Result<()> {
-        let font_paths = self.list("fonts")?;
-        let mut embedded_fonts = Vec::new();
-        for font_path in font_paths {
-            if font_path.ends_with(".ttf") {
-                let font_bytes = cx
-                    .asset_source()
-                    .load(&font_path)?
-                    .expect("Assets should never return None");
-                embedded_fonts.push(font_bytes);
-            }
-        }
-
-        cx.text_system().add_fonts(embedded_fonts)
-    }
-}

crates/auto_update/Cargo.toml

@@ -6,7 +6,12 @@ publish.workspace = true
 
 [dependencies]
 gpui.workspace = true
-instant.workspace = true
 log.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+futures.workspace = true
 
-gpui-updater = { git = "https://github.com/AprilNEA/gpui-updater", tag = "v0.0.6", features = ["gpui"] }
+gpui-updater-pre = "0.2"
+
+[dev-dependencies]
+reqwest_client.workspace = true

crates/auto_update/src/lib.rs

@@ -1,187 +1,161 @@
 #![cfg(not(target_arch = "wasm32"))]
 
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Subscription, Window};
-use gpui_updater::{EngineConfig, GitHubSource, UpdateStatus, Updater, Version};
-use instant::{Duration, Instant};
+use std::time::Duration;
+
+use gpui::{App, AppContext, Context, Entity, Global, SharedString, Task};
+use gpui_updater_pre::{EngineConfig, UpdateStatus, Updater, Verification, Version};
+
+use crate::source::{AssetFilter, GiteaSource, asset_filter_for};
+
+mod source;
+
+const GITEA_API_BASE: &str = "https://git.reya.info/api/v1";
+const GITEA_REPO_OWNER: &str = "reya";
+const GITEA_REPO_NAME: &str = "coop";
+
+/// Delay before the automatic check that runs on startup.
+const AUTO_CHECK_DELAY: Duration = Duration::from_secs(120);
+/// How long a failure stays visible before the status reverts to "Up to date".
+const ERROR_DISPLAY_DURATION: Duration = Duration::from_secs(5);
 
 const COOP_UPDATE_EXPLANATION: &str = "COOP_UPDATE_EXPLANATION";
 const COOP_BUNDLE_TYPE: &str = "COOP_BUNDLE_TYPE";
 
-fn get_github_repo_owner() -> String {
-    std::env::var("COOP_GITHUB_REPO_OWNER").unwrap_or_else(|_| "reyakov".to_string())
-}
-
-fn get_github_repo_name() -> String {
-    std::env::var("COOP_GITHUB_REPO_NAME").unwrap_or_else(|_| "coop".to_string())
-}
-
-/// Whether updates are managed by an external distribution channel
-/// (Flatpak/Snap), in which case the in-app updater must not run.
 fn uses_managed_updates() -> bool {
     // The Flatpak runtime exports `FLATPAK_ID` inside the sandbox.
     std::env::var("FLATPAK_ID").is_ok()
         // Allow opting out of in-app updates via an explicit environment variable.
         || std::env::var(COOP_UPDATE_EXPLANATION).is_ok()
         // The Snap package sets `COOP_BUNDLE_TYPE=snap` (see snapcraft.yaml.in).
-        || std::env::var(COOP_BUNDLE_TYPE).is_ok_and(|value| value == "snap")
+        || std::env::var(COOP_BUNDLE_TYPE).is_ok_and(|value | value == "snap")
 }
 
 /// Initialize the auto-update system.
-///
-/// Skips initialization when updates are handled by an external distribution
-/// channel (Flatpak/Snap). Otherwise creates the global [`AutoUpdater`]
-/// entity and schedules a check for updates after a 2-minute delay.
-pub fn init(window: &mut Window, cx: &mut App) {
+pub fn init(cx: &mut App) {
     if uses_managed_updates() {
         log::info!(
-            "Skipping auto-update initialization: App is installed via a managed distribution channel (Flatpak/Snap)"
+            "Skipping auto-update initialization: updates are managed by the installed distribution channel (Flatpak/Snap)"
         );
         return;
     }
 
-    AutoUpdater::set_global(cx.new(|cx| AutoUpdater::new(window, cx)), cx);
+    let (os, arch) = (std::env::consts::OS, std::env::consts::ARCH);
+
+    let Some(filter) = asset_filter_for(os, arch) else {
+        log::info!(
+            "Skipping auto-update initialization: no installable release artifact is published for {os}/{arch}"
+        );
+        return;
+    };
+
+    let Ok(version) = Version::parse(env!("CARGO_PKG_VERSION")) else {
+        log::error!(
+            "Skipping auto-update initialization: crate version {:?} is not valid semver",
+            env!("CARGO_PKG_VERSION")
+        );
+        return;
+    };
+
+    AutoUpdater::set_global(cx.new(|cx| AutoUpdater::new(version, filter, cx)), cx);
 }
 
 struct GlobalAutoUpdater(Entity<AutoUpdater>);
 
 impl Global for GlobalAutoUpdater {}
 
-/// Observable auto-update status — re-exported from [`gpui_updater::UpdateStatus`].
-pub use gpui_updater::UpdateStatus as AutoUpdateStatus;
-
-/// The global auto-updater entity.
-///
-/// Wraps [`gpui_updater::Updater`] with Coop-specific configuration
-/// (GitHub repo, Flatpak detection, delayed auto-check).
-///
-/// Retrieve the global instance via [`AutoUpdater::global`].
 pub struct AutoUpdater {
-    /// The underlying gpui-updater entity that does the heavy lifting.
-    pub updater: Entity<Updater>,
-    /// Currently running app version.
-    pub version: Version,
-    /// Keeps the observer subscription alive.
-    _subscription: Subscription,
-    /// When the last error was recorded, so we can reset to idle after 5s.
-    error_time: Option<Instant>,
+    updater: Entity<Updater>,
+    status: UpdateStatus,
+    /// The pending revert of an `Errored` status back to `Idle`, if any.
+    error_revert: Option<Task<()>>,
 }
 
 impl AutoUpdater {
-    /// Whether auto-update is available for this installation.
-    ///
-    /// Returns `false` on managed distribution channels (Flatpak/Snap), where
-    /// updates are handled by the channel and no global updater is created.
-    pub fn is_available(cx: &App) -> bool {
-        cx.try_global::<GlobalAutoUpdater>().is_some()
-    }
-
     /// Retrieve the global auto updater instance, if one was initialized.
     pub fn try_global(cx: &App) -> Option<Entity<Self>> {
         cx.try_global::<GlobalAutoUpdater>()
             .map(|global| global.0.clone())
     }
 
-    /// Retrieve the global auto updater instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics when auto-update is not available for this installation. Prefer
-    /// [`AutoUpdater::try_global`] when the installation type is not known at
-    /// compile time (e.g. Flatpak/Snap).
-    pub fn global(cx: &App) -> Entity<Self> {
-        cx.global::<GlobalAutoUpdater>().0.clone()
-    }
-
     fn set_global(state: Entity<Self>, cx: &mut App) {
         cx.set_global(GlobalAutoUpdater(state));
     }
 
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
+    fn new(version: Version, filter: AssetFilter, cx: &mut Context<Self>) -> Self {
+        let source = GiteaSource::new(
+            GITEA_API_BASE,
+            GITEA_REPO_OWNER,
+            GITEA_REPO_NAME,
+            filter,
+            cx.http_client(),
+        );
+        let config = EngineConfig::new(version).verification(Verification::Checksum);
+        let updater = cx.new(|cx| Updater::new(source, config, cx));
 
-        let repo_owner = get_github_repo_owner();
-        let repo_name = get_github_repo_name();
+        cx.observe(&updater, |this, _, cx| this.observe_status(cx))
+            .detach();
 
-        let source =
-            GitHubSource::new(&repo_owner, &repo_name).asset_contains(match std::env::consts::OS {
-                "macos" => "macos",
-                "linux" => "linux",
-                _ => "",
-            });
-
-        let updater: Entity<Updater> =
-            cx.new(|cx| Updater::new(source, EngineConfig::new(version.clone()), cx));
-
-        // When an update becomes available, automatically download and install it.
-        let subscription = cx.observe(&updater, |this: &mut AutoUpdater, _updater, cx| {
-            let status = this.updater.read(cx).status().clone();
-
-            if matches!(status, UpdateStatus::Available(_)) {
-                this.updater.update(cx, |updater, cx| {
-                    updater.download_and_install(cx);
-                });
-            }
-
-            if matches!(status, UpdateStatus::Errored(_)) {
-                this.error_time = Some(Instant::now());
-                cx.spawn(async move |this, cx| {
-                    cx.background_executor().timer(Duration::from_secs(5)).await;
-                    this.update(cx, |_this, cx| cx.notify()).ok();
-                })
-                .detach();
-            } else {
-                this.error_time = None;
-            }
-
-            cx.notify();
-        });
-
-        // Schedule an auto-check after a 2-minute delay (deferred to run at the
-        // end of the current frame so the window is fully set up).
-        cx.defer_in(window, |_this, _window, cx| {
-            let duration = Duration::from_secs(120);
-            cx.spawn(async move |this, cx| {
-                cx.background_executor().timer(duration).await;
-                this.update(cx, |this, cx| {
-                    this.updater.update(cx, |updater, cx| {
-                        updater.check(cx);
-                    });
-                })
-                .ok();
+        // Schedule an auto-check after a 2-minute delay
+        let entity = cx.entity().downgrade();
+        cx.defer(move |cx| {
+            cx.spawn(async move |cx| {
+                cx.background_executor().timer(AUTO_CHECK_DELAY).await;
+                entity.update(cx, |this, cx| this.check(cx)).ok();
             })
             .detach();
         });
 
         Self {
             updater,
-            version,
-            _subscription: subscription,
-            error_time: None,
+            status: UpdateStatus::Idle,
+            error_revert: None,
         }
     }
 
-    pub fn idle(&self, cx: &App) -> bool {
-        let status = self.updater.read(cx).status();
-        if status == &UpdateStatus::Idle {
-            return true;
+    fn observe_status(&mut self, cx: &mut Context<Self>) {
+        let status = self.updater.read(cx).status().clone();
+        self.status = status.clone();
+
+        self.error_revert = if matches!(status, UpdateStatus::Errored(_)) {
+            Some(cx.spawn(async move |this, cx| {
+                cx.background_executor().timer(ERROR_DISPLAY_DURATION).await;
+                this.update(cx, |this, cx| {
+                    if matches!(this.status, UpdateStatus::Errored(_)) {
+                        this.status = UpdateStatus::Idle;
+                        cx.notify();
+                    }
+                })
+                .ok();
+            }))
+        } else {
+            None
+        };
+
+        // The adapter stops at `Available`; continue into the download.
+        if matches!(status, UpdateStatus::Available(_)) {
+            self.updater.update(cx, |updater, cx| {
+                updater.download_and_install(cx);
+            });
         }
-        if matches!(status, UpdateStatus::Errored(_))
-            && self
-                .error_time
-                .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-        {
-            return true;
-        }
-        false
+
+        cx.notify();
     }
 
-    pub fn status(&self, cx: &App) -> SharedString {
-        let status = self.updater.read(cx).status();
+    /// Whether the running version is the newest release, so the status line can be hidden.
+    pub fn up_to_date(&self) -> bool {
+        matches!(self.status, UpdateStatus::Idle | UpdateStatus::UpToDate)
+    }
 
-        match status {
-            UpdateStatus::Idle => "Up to date".into(),
+    /// Whether a verified update is installed and waiting for a restart.
+    pub fn staged(&self) -> bool {
+        matches!(self.status, UpdateStatus::Staged(_))
+    }
+
+    /// A short, human-readable description of the current status.
+    pub fn status(&self) -> SharedString {
+        match &self.status {
+            UpdateStatus::Idle | UpdateStatus::UpToDate => "Up to date".into(),
             UpdateStatus::Checking => "Checking for updates…".into(),
-            UpdateStatus::UpToDate => "Up to date".into(),
             UpdateStatus::Available(version) => format!("Version {version} available").into(),
             UpdateStatus::Downloading { downloaded, total } => {
                 let total_mb = total.map(|t| t as f64 / 1_048_576.0);
@@ -195,16 +169,25 @@ impl AutoUpdater {
             UpdateStatus::Staged(version) => {
                 format!("Version {version} ready — restart to apply").into()
             }
-            UpdateStatus::Errored(msg) => {
-                if self
-                    .error_time
-                    .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-                {
-                    "Up to date".into()
-                } else {
-                    format!("Update failed: {msg}").into()
-                }
-            }
+            UpdateStatus::Errored(message) => format!("Update failed: {message}").into(),
         }
     }
+
+    /// Check the release host for a newer version, then download and install it.
+    pub fn check(&mut self, cx: &mut Context<Self>) {
+        self.updater.update(cx, |updater, cx| {
+            updater.check(cx);
+        });
+    }
+
+    /// Relaunch into the staged update.
+    pub fn restart(&mut self, cx: &mut Context<Self>) {
+        if !self.staged() {
+            log::warn!("Ignoring restart request: no update is staged");
+            return;
+        }
+        self.updater.update(cx, |updater, cx| {
+            updater.restart(cx);
+        });
+    }
 }

crates/auto_update/src/source.rs

@@ -0,0 +1,378 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use futures::AsyncReadExt;
+use futures::executor::block_on;
+use gpui::http_client::{AsyncBody, HttpClient, HttpRequestExt, RedirectPolicy, Request};
+use gpui_updater_pre::{Asset, Error, Release, Result, UpdateSource, parse_tag};
+use serde::Deserialize;
+use serde::de::DeserializeOwned;
+
+const CHECKSUMS_ASSET: &str = "SHA256SUMS";
+const RELEASE_PAGE_SIZE: usize = 20;
+const USER_AGENT: &str = concat!("coop-updater/", env!("CARGO_PKG_VERSION"));
+/// Deadline for the complete metadata request, including its body.
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Which published artifact belongs to a target platform.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AssetFilter {
+    extension: &'static str,
+    arch: &'static str,
+}
+
+impl AssetFilter {
+    /// Whether `name` is the installable artifact for this target.
+    fn matches(&self, name: &str) -> bool {
+        let name = name.to_ascii_lowercase();
+        name.ends_with(self.extension) && name.contains(self.arch)
+    }
+}
+
+pub fn asset_filter_for(os: &str, arch: &str) -> Option<AssetFilter> {
+    let extension = match os {
+        "macos" => ".dmg",
+        "linux" => ".tar.gz",
+        _ => return None,
+    };
+
+    let arch = match (os, arch) {
+        // cargo-packager names the disk images `aarch64`/`x64`.
+        ("macos", "aarch64") => "aarch64",
+        ("macos", "x86_64") => "x64",
+        // `script/bundle-linux` names the tarballs `aarch64`/`x86_64`.
+        ("linux", "aarch64") => "aarch64",
+        ("linux", "x86_64") => "x86_64",
+        _ => return None,
+    };
+
+    Some(AssetFilter { extension, arch })
+}
+
+/// A release as returned by the Gitea API.
+#[derive(Debug, Deserialize)]
+struct GiteaRelease {
+    tag_name: String,
+    #[serde(default)]
+    name: Option<String>,
+    #[serde(default)]
+    body: Option<String>,
+    #[serde(default)]
+    draft: bool,
+    #[serde(default)]
+    prerelease: bool,
+    #[serde(default)]
+    assets: Vec<GiteaAsset>,
+}
+
+/// A release asset as returned by the Gitea API.
+#[derive(Debug, Deserialize)]
+struct GiteaAsset {
+    name: String,
+    browser_download_url: String,
+    #[serde(default)]
+    size: u64,
+}
+
+/// Reads releases from a Gitea repository's Releases.
+pub struct GiteaSource {
+    api_base: String,
+    owner: String,
+    repo: String,
+    filter: AssetFilter,
+    http_client: Arc<dyn HttpClient>,
+}
+
+impl GiteaSource {
+    /// Build a source for `owner/repo` on the Gitea instance at `api_base`
+    /// (e.g. `https://git.reya.info/api/v1`).
+    pub fn new(
+        api_base: impl Into<String>,
+        owner: impl Into<String>,
+        repo: impl Into<String>,
+        filter: AssetFilter,
+        http_client: Arc<dyn HttpClient>,
+    ) -> Self {
+        Self {
+            api_base: api_base.into().trim_end_matches('/').to_string(),
+            owner: owner.into(),
+            repo: repo.into(),
+            filter,
+            http_client,
+        }
+    }
+
+    fn releases_url(&self) -> String {
+        format!(
+            "{}/repos/{}/{}/releases?limit={RELEASE_PAGE_SIZE}",
+            self.api_base, self.owner, self.repo
+        )
+    }
+
+    async fn get_bytes(&self, url: &str) -> Result<Vec<u8>> {
+        let request = Request::get(url)
+            .header("User-Agent", USER_AGENT)
+            .timeout(REQUEST_TIMEOUT)
+            .follow_redirects(RedirectPolicy::FollowAll)
+            .body(AsyncBody::empty())
+            .map_err(|error| Error::Http(format!("GET {url}: {error}")))?;
+
+        let mut response = self
+            .http_client
+            .send(request)
+            .await
+            .map_err(|error| Error::Http(format!("GET {url}: {error}")))?;
+
+        let status = response.status();
+        if !status.is_success() {
+            return Err(Error::Http(format!("GET {url} -> {status}")));
+        }
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .map_err(|error| Error::Http(format!("GET {url}: {error}")))?;
+        Ok(body)
+    }
+
+    async fn get_json<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
+        let body = self.get_bytes(url).await?;
+        serde_json::from_slice(&body).map_err(|error| Error::Parse(error.to_string()))
+    }
+
+    async fn get_string(&self, url: &str) -> Result<String> {
+        let body = self.get_bytes(url).await?;
+        String::from_utf8(body).map_err(|error| Error::Parse(error.to_string()))
+    }
+}
+
+impl UpdateSource for GiteaSource {
+    fn fetch_latest(&self) -> Result<Release> {
+        let releases: Vec<GiteaRelease> = block_on(self.get_json(&self.releases_url()))?;
+        let release = newest_published(&releases)
+            .ok_or_else(|| Error::Parse("repository has no published releases".to_string()))?;
+
+        let asset = release
+            .assets
+            .iter()
+            .find(|asset| self.filter.matches(&asset.name))
+            .ok_or(Error::NoMatchingAsset {
+                target_os: std::env::consts::OS,
+                target_arch: std::env::consts::ARCH,
+            })?;
+
+        // Resolve the published checksum so the engine can reject a truncated or substituted download.
+        let sha256 = release
+            .assets
+            .iter()
+            .find(|candidate| candidate.name.eq_ignore_ascii_case(CHECKSUMS_ASSET))
+            .map(|sums| block_on(self.get_string(&sums.browser_download_url)))
+            .transpose()?
+            .and_then(|sums| sha256_for(&sums, &asset.name));
+
+        let notes = release
+            .body
+            .clone()
+            .filter(|body| !body.trim().is_empty())
+            .or_else(|| release.name.clone());
+
+        let mut update = Release::new(
+            parse_tag(&release.tag_name)?,
+            Asset::new(&asset.name, &asset.browser_download_url, asset.size),
+        );
+        if let Some(notes) = notes {
+            update = update.with_notes(notes);
+        }
+        if let Some(sha256) = sha256 {
+            update = update.with_sha256(sha256);
+        }
+        Ok(update)
+    }
+}
+
+fn newest_published(releases: &[GiteaRelease]) -> Option<&GiteaRelease> {
+    releases
+        .iter()
+        .filter(|release| !release.draft && !release.prerelease)
+        .filter_map(|release| {
+            parse_tag(&release.tag_name)
+                .ok()
+                .map(|version| (version, release))
+        })
+        .max_by(|(left, _), (right, _)| left.cmp(right))
+        .map(|(_, release)| release)
+}
+
+/// The SHA-256 recorded for `asset_name` in a `shasum`-style checksums file.
+fn sha256_for(sums: &str, asset_name: &str) -> Option<String> {
+    sums.lines().find_map(|line| {
+        let mut parts = line.split_whitespace();
+        let (hash, path) = (parts.next()?, parts.next()?);
+        let path = path.strip_prefix('*').unwrap_or(path);
+        let base = path.rsplit(['/', '\\']).next().unwrap_or(path);
+        (base == asset_name).then(|| hash.to_ascii_lowercase())
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use gpui_updater_pre::Version;
+
+    use super::*;
+
+    const PUBLISHED: &[&str] = &[
+        "Coop_1.0.1_aarch64.dmg",
+        "Coop_1.0.1_x64.dmg",
+        "coop-linux-aarch64.tar.gz",
+        "coop-linux-x86_64.tar.gz",
+        "coop_1.0.1_aarch64.snap",
+        "coop_1.0.1_arm64-setup.exe",
+        "coop_1.0.1_x64-setup.exe",
+        "coop_1.0.1_x86_64.snap",
+        "su.reya.coop_aarch64.flatpak",
+        "su.reya.coop_x86_64.flatpak",
+    ];
+
+    fn selected(os: &str, arch: &str) -> Option<&'static str> {
+        let filter = asset_filter_for(os, arch)?;
+        PUBLISHED.iter().copied().find(|name| filter.matches(name))
+    }
+
+    #[test]
+    fn picks_the_artifact_matching_os_and_architecture() {
+        assert_eq!(selected("macos", "aarch64"), Some("Coop_1.0.1_aarch64.dmg"));
+        assert_eq!(selected("macos", "x86_64"), Some("Coop_1.0.1_x64.dmg"));
+        assert_eq!(
+            selected("linux", "aarch64"),
+            Some("coop-linux-aarch64.tar.gz")
+        );
+        assert_eq!(
+            selected("linux", "x86_64"),
+            Some("coop-linux-x86_64.tar.gz")
+        );
+    }
+
+    #[test]
+    fn has_no_target_for_windows_or_unknown_platforms() {
+        assert_eq!(asset_filter_for("windows", "x86_64"), None);
+        assert_eq!(asset_filter_for("freebsd", "x86_64"), None);
+        assert_eq!(asset_filter_for("macos", "riscv64"), None);
+    }
+
+    #[test]
+    fn ignores_package_formats_and_sidecars_that_are_not_the_artifact() {
+        let macos = asset_filter_for("macos", "aarch64").unwrap();
+        assert!(!macos.matches("coop_1.0.1_aarch64.snap"));
+        assert!(!macos.matches("su.reya.coop_aarch64.flatpak"));
+        assert!(!macos.matches("Coop_1.0.1_aarch64.dmg.minisig"));
+
+        let linux = asset_filter_for("linux", "x86_64").unwrap();
+        assert!(!linux.matches("coop_1.0.1_x64-setup.exe"));
+        assert!(!linux.matches("coop_1.0.1_x86_64.snap"));
+    }
+
+    #[test]
+    fn reads_checksums_by_basename_ignoring_directory_prefix() {
+        let sums = "\
+abcdef  macos-arm64-artifacts/Coop_1.0.1_aarch64.dmg
+123456  *linux-x64-artifacts/coop-linux-x86_64.tar.gz
+789abc  SHA256SUMS
+";
+        assert_eq!(
+            sha256_for(sums, "Coop_1.0.1_aarch64.dmg").as_deref(),
+            Some("abcdef")
+        );
+        assert_eq!(
+            sha256_for(sums, "coop-linux-x86_64.tar.gz").as_deref(),
+            Some("123456")
+        );
+        assert_eq!(sha256_for(sums, "coop_1.0.1_x64-setup.exe"), None);
+    }
+
+    #[test]
+    fn newest_published_skips_drafts_prereleases_and_bad_tags() {
+        let releases: Vec<GiteaRelease> = serde_json::from_str(
+            r#"[
+                {
+                    "tag_name": "v1.0.2",
+                    "draft": true,
+                    "assets": []
+                },
+                {
+                    "tag_name": "v2.0.0-rc.1",
+                    "prerelease": true,
+                    "assets": []
+                },
+                {
+                    "tag_name": "nightly",
+                    "assets": []
+                },
+                {
+                    "tag_name": "v1.0.0",
+                    "assets": [
+                        {
+                            "name": "coop-linux-x86_64.tar.gz",
+                            "browser_download_url": "https://git.reya.info/reya/coop/releases/download/v1.0.0/coop-linux-x86_64.tar.gz",
+                            "size": 26160329
+                        }
+                    ]
+                },
+                {
+                    "tag_name": "v1.0.1",
+                    "name": "v1.0.1",
+                    "body": "Fixed app panic on flatpak installations",
+                    "assets": [
+                        {
+                            "name": "coop-linux-x86_64.tar.gz",
+                            "browser_download_url": "https://git.reya.info/reya/coop/releases/download/v1.0.1/coop-linux-x86_64.tar.gz",
+                            "size": 26160329
+                        }
+                    ]
+                }
+            ]"#,
+        )
+        .unwrap();
+
+        let newest = newest_published(&releases).unwrap();
+        assert_eq!(newest.tag_name, "v1.0.1");
+        assert_eq!(parse_tag(&newest.tag_name).unwrap().to_string(), "1.0.1");
+        assert_eq!(newest.assets.len(), 1);
+        assert_eq!(newest.assets[0].size, 26160329);
+    }
+
+    #[test]
+    #[ignore = "requires network access to the release host"]
+    fn live_release_source_resolves_the_running_platform() {
+        let filter = asset_filter_for(std::env::consts::OS, std::env::consts::ARCH)
+            .expect("this platform should be supported");
+        let source = GiteaSource::new(
+            "https://git.reya.info/api/v1",
+            "reya",
+            "coop",
+            filter,
+            Arc::new(reqwest_client::ReqwestClient::new()),
+        );
+
+        let release = source
+            .fetch_latest()
+            .expect("release lookup should succeed");
+
+        assert!(
+            release.version >= Version::new(1, 0, 0),
+            "unexpected version {}",
+            release.version
+        );
+        assert!(
+            source.filter.matches(&release.asset.name),
+            "unexpected artifact {}",
+            release.asset.name
+        );
+        assert!(
+            release.asset.url.starts_with("https://"),
+            "{} ",
+            release.asset.url
+        );
+    }
+}

crates/browser-signer-proxy/src/lib.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::future::Future;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
@@ -49,8 +49,6 @@ impl Message {
 enum RequestMethod {
     GetPublicKey,
     SignEvent,
-    Nip04Encrypt,
-    Nip04Decrypt,
     Nip44Encrypt,
     Nip44Decrypt,
 }
@@ -60,8 +58,6 @@ impl RequestMethod {
         match self {
             Self::GetPublicKey => "get_public_key",
             Self::SignEvent => "sign_event",
-            Self::Nip04Encrypt => "nip04_encrypt",
-            Self::Nip04Decrypt => "nip04_decrypt",
             Self::Nip44Encrypt => "nip44_encrypt",
             Self::Nip44Decrypt => "nip44_decrypt",
         }
@@ -205,36 +201,6 @@ impl Default for BrowserSignerProxyOptions {
     }
 }
 
-impl BrowserSignerProxyOptions {
-    /// Sets the timeout duration.
-    pub const fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
-        self
-    }
-
-    /// Sets the IP address.
-    pub const fn ip_addr(mut self, new_ip: IpAddr) -> Self {
-        self.addr = SocketAddr::new(new_ip, self.addr.port());
-        self
-    }
-
-    /// Sets the port number.
-    pub const fn port(mut self, new_port: u16) -> Self {
-        self.addr = SocketAddr::new(self.addr.ip(), new_port);
-        self
-    }
-
-    /// Sets a custom html page.
-    ///
-    /// The page must include `/proxy.js` script (`<script src="/proxy.js"></script>`)
-    /// which will handle communication with the server and update the element
-    /// with id `nip07-proxy-status` with the status.
-    pub const fn custom_html_page(mut self, custom_html: &'static str) -> Self {
-        self.custom_html = custom_html;
-        self
-    }
-}
-
 impl BrowserSignerProxy {
     /// Construct a new browser signer proxy
     pub fn new(options: BrowserSignerProxyOptions) -> Self {
@@ -255,14 +221,8 @@ impl BrowserSignerProxy {
         }
     }
 
-    /// Indicates whether the server is currently running.
-    #[inline]
-    pub fn is_started(&self) -> bool {
-        self.inner.is_started.load(Ordering::SeqCst)
-    }
-
-    /// Checks if there is an open browser tab ready to respond to requests by
-    /// verifying the time since the last pending request.
+    /// Checks if there is an open browser tab ready to respond
+    /// to requests by verifying the time since the last pending request.
     #[inline]
     pub fn is_session_active(&self) -> bool {
         current_time() - self.inner.state.last_pending_request.load(Ordering::SeqCst) < 2
@@ -419,20 +379,6 @@ impl BrowserSignerProxy {
         Ok(event)
     }
 
-    #[inline]
-    async fn _nip04_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Encrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip04_decrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Decrypt, serde_json::to_value(params)?)
-            .await
-    }
-
     #[inline]
     async fn _nip44_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
         let params = CryptoParams::new(public_key, content);
@@ -471,26 +417,6 @@ impl AsyncSignEvent for BrowserSignerProxy {
     }
 }
 
-impl AsyncNip04 for BrowserSignerProxy {
-    type Error = Error;
-
-    fn nip04_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_encrypt(public_key, content).await })
-    }
-
-    fn nip04_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        encrypted_content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_decrypt(public_key, encrypted_content).await })
-    }
-}
-
 impl AsyncNip44 for BrowserSignerProxy {
     type Error = Error;
 

crates/chat/Cargo.toml

@@ -7,7 +7,7 @@ publish.workspace = true
 [dependencies]
 common = { path = "../common" }
 state = { path = "../state" }
-device = { path = "../device" }
+nip4e = { path = "../nip4e" }
 person = { path = "../person" }
 settings = { path = "../settings" }
 
@@ -17,6 +17,7 @@ instant.workspace = true
 
 anyhow.workspace = true
 itertools.workspace = true
+rand.workspace = true
 smallvec.workspace = true
 log.workspace = true
 flume.workspace = true

crates/chat/src/lib.rs

@@ -9,24 +9,30 @@ use fuzzy_matcher::FuzzyMatcher;
 use fuzzy_matcher::skim::SkimMatcherV2;
 use gpui::{
     App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Subscription, Task,
-    WeakEntity, Window,
+    WeakEntity,
 };
 use instant::Duration;
+use nip4e::{DeviceEvent, DeviceRegistry};
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
-use state::{DEVICE_GIFTWRAP, NostrRegistry, USER_GIFTWRAP, UniversalSigner};
+use state::{DEVICE_GIFTWRAP, NostrRegistry, USER_GIFTWRAP};
 
 mod message;
 mod room;
+mod search;
 
 pub use message::*;
 pub use room::*;
+pub use search::SearchMessage;
+pub use state::FileAttachment;
+
+use crate::search::MessageSearchIndex;
 
 /// A static keypair used only for signing locally-cached rumor events.
 static LOCAL_KEYS: LazyLock<Keys> = LazyLock::new(Keys::generate);
 
-pub fn init(window: &mut Window, cx: &mut App) {
-    ChatRegistry::set_global(cx.new(|cx| ChatRegistry::new(window, cx)), cx);
+pub fn init(cx: &mut App) {
+    ChatRegistry::set_global(cx.new(ChatRegistry::new), cx);
 }
 
 struct GlobalChatRegistry(Entity<ChatRegistry>);
@@ -36,15 +42,8 @@ impl Global for GlobalChatRegistry {}
 /// Chat event.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ChatEvent {
-    /// An event to open a room by its ID
-    OpenRoom(u64),
-    /// An event to close a room by its ID
-    CloseRoom(u64),
-    /// An event to notify UI about a new chat request
     Ping,
-    /// No Inbox Relays found, the app is not ready to subscribe messages
     InboxRelayNotFound,
-    /// An error occurred
     Error(String),
 }
 
@@ -79,41 +78,30 @@ impl Signal {
 pub struct ChatRegistry {
     /// Chat rooms
     rooms: Vec<Entity<Room>>,
-
     /// O(1) room lookup by room ID
     room_index: HashMap<u64, Entity<Room>>,
-
     /// Events that failed to unwrap for any reason
     trash: Entity<BTreeSet<FailedMessage>>,
-
     /// Tracking events seen on which relays in the current session
     seen: Arc<RwLock<HashMap<EventId, HashSet<RelayUrl>>>>,
-
     /// Mapping of unwrapped event ids to their gift wrap event ids
     event_map: Arc<RwLock<HashMap<EventId, EventId>>>,
-
+    /// In-memory message content index for search
+    search: Arc<RwLock<MessageSearchIndex>>,
     /// True while the initial event backlog is still loading
     tracking: Arc<AtomicBool>,
-
     /// Channel for sending signals to the UI.
     signal_tx: flume::Sender<Signal>,
-
     /// Channel for receiving signals from the UI.
     signal_rx: flume::Receiver<Signal>,
-
     /// Async tasks
     tasks: SmallVec<[Task<Result<(), Error>>; 2]>,
-
     /// Notification listener task (cancelled on signer change)
     notification_listener: Option<Task<Result<(), Error>>>,
-
     /// Signal consumer task (cancelled on signer change)
     signal_consumer: Option<Task<Result<(), Error>>>,
-
     /// Fuzzy matcher for room search (cached; intentionally excluded from Debug)
-    #[allow(dead_code)]
     matcher: CachedMatcher,
-
     /// Subscriptions
     _subscriptions: SmallVec<[Subscription; 2]>,
 }
@@ -149,26 +137,36 @@ impl ChatRegistry {
     }
 
     /// Create a new chat registry instance
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
+        let entity = cx.entity().downgrade();
+
         let (tx, rx) = flume::unbounded::<Signal>();
         let mut subscriptions = smallvec![];
 
-        subscriptions.push(
-            // Subscribe to the signer event
-            cx.subscribe(&nostr, |this, _nostr, event, cx| {
-                if event.signer_changed() {
-                    this.reset(cx);
-                    this.handle_notifications(cx);
-                    this.get_metadata(cx);
-                    this.get_rooms(cx);
-                };
-            }),
-        );
+        let device = DeviceRegistry::global(cx);
 
-        // Run at the end of the current cycle
-        cx.defer_in(window, |this, _window, cx| {
-            this.get_rooms(cx);
+        subscriptions.push(cx.subscribe(&nostr, |this, _nostr, event, cx| {
+            if event.signer_changed() {
+                this.reset(cx);
+                this.handle_notifications(cx);
+                this.get_metadata(cx);
+                this.get_rooms(cx);
+            };
+        }));
+
+        subscriptions.push(cx.subscribe(&device, |this, _device, event, cx| {
+            if matches!(event, DeviceEvent::Set) {
+                this.handle_notifications(cx);
+                this.get_messages(cx);
+                this.reprocess_trash(cx);
+            }
+        }));
+
+        cx.defer(move |cx| {
+            let _ = entity.update(cx, |this, cx| {
+                this.get_rooms(cx);
+            });
         });
 
         Self {
@@ -177,6 +175,7 @@ impl ChatRegistry {
             trash: cx.new(|_| BTreeSet::default()),
             seen: Arc::new(RwLock::new(HashMap::default())),
             event_map: Arc::new(RwLock::new(HashMap::default())),
+            search: Arc::default(),
             tracking: Arc::new(AtomicBool::new(true)),
             matcher: CachedMatcher(SkimMatcherV2::default()),
             signal_rx: rx,
@@ -198,6 +197,9 @@ impl ChatRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
+        let device = DeviceRegistry::global(cx);
+        let device_signer = device.read(cx).signer(cx);
+
         let seen = self.seen.clone();
         let event_map = self.event_map.clone();
         let trash = self.trash.downgrade();
@@ -220,11 +222,26 @@ impl ChatRegistry {
                 };
 
                 match *message {
-                    RelayMessage::Event { event, .. } => {
+                    RelayMessage::Event {
+                        subscription_id,
+                        event,
+                        ..
+                    } => {
+                        let chat_sub = subscription_id.as_str() != sub_id1.as_str();
+                        let device_sub = subscription_id.as_str() != sub_id2.as_str();
+
+                        // Concord wraps are also kind 1059.
+                        //
+                        // Only the two gift wrap subscriptions carry NIP-59 wraps for this account.
+                        if event.kind == Kind::GiftWrap && chat_sub && device_sub {
+                            continue;
+                        }
+
                         // Prune the dedup set before it grows unbounded
                         if processed_events.len() >= MAX_PROCESSED {
                             processed_events.clear();
                         }
+
                         if !processed_events.insert(event.id) {
                             continue;
                         }
@@ -249,7 +266,14 @@ impl ChatRegistry {
                         }
 
                         // Extract the rumor from the gift wrap event
-                        match extract_rumor(&client, &signer, event.as_ref()).await {
+                        match extract_rumor(
+                            &client,
+                            &signer,
+                            device_signer.as_ref(),
+                            event.as_ref(),
+                        )
+                        .await
+                        {
                             Ok(rumor) => {
                                 let Some(rumor_id) = rumor.id else {
                                     log::error!("Rumor missing id after ensure_id");
@@ -385,6 +409,9 @@ impl ChatRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
+        let device = DeviceRegistry::global(cx);
+        let device_signer = device.read(cx).signer(cx);
+
         self.tasks.push(cx.spawn(async move |this, cx| {
             let task: Task<Result<(), Error>> = cx.background_spawn(async move {
                 let public_key = signer.get_public_key_async().await?;
@@ -417,6 +444,20 @@ impl ChatRegistry {
 
                 client.subscribe(target).with_id(id).await?;
 
+                // Also pick up gift wraps addressed to this account's decoupled encryption key
+                if let Some(device_signer) = device_signer.as_ref() {
+                    let device_public_key = device_signer.get_public_key_async().await?;
+
+                    let filter = Filter::new().kind(Kind::GiftWrap).pubkey(device_public_key);
+                    let id = SubscriptionId::new(DEVICE_GIFTWRAP);
+
+                    let target: HashMap<RelayUrl, Filter> = nip17::extract_relay_list(&event)
+                        .map(|relay| (relay, filter.clone()))
+                        .collect();
+
+                    client.subscribe(target).with_id(id).await?;
+                }
+
                 Ok(())
             });
 
@@ -430,6 +471,49 @@ impl ChatRegistry {
         }));
     }
 
+    /// Retry unwrapping trashed gift wraps with the newly available encryption key.
+    fn reprocess_trash(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+        let device_signer = DeviceRegistry::global(cx).read(cx).signer(cx);
+
+        let failed: Vec<FailedMessage> = self.trash.read(cx).iter().cloned().collect();
+
+        if failed.is_empty() {
+            return;
+        }
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            for message in failed {
+                let Ok(event) = Event::from_json(message.raw_event.as_str()) else {
+                    continue;
+                };
+
+                if extract_rumor(&client, &signer, device_signer.as_ref(), &event)
+                    .await
+                    .is_err()
+                {
+                    continue;
+                }
+
+                let Ok(rumor) = get_rumor(&client, event.id).await else {
+                    continue;
+                };
+
+                this.update(cx, |this, cx| {
+                    this.trash.update(cx, |trash, cx| {
+                        trash.remove(&message);
+                        cx.notify();
+                    });
+                    this.new_message(NewMessage::new(event.id, rumor), cx);
+                })?;
+            }
+
+            Ok(())
+        }));
+    }
+
     /// Reload the chat registry, fetching messages and contact list from relays.
     pub fn reload(&mut self, cx: &mut Context<Self>) {
         self.reset(cx);
@@ -464,26 +548,6 @@ impl ChatRegistry {
             .count()
     }
 
-    /// Count the number of messages seen by a given relay.
-    pub fn count_messages(&self, relay_url: &RelayUrl) -> usize {
-        self.seen
-            .read()
-            .unwrap()
-            .values()
-            .filter(|s| s.contains(relay_url))
-            .count()
-    }
-
-    /// Count the number of trash messages.
-    pub fn count_trash_messages(&self, cx: &App) -> usize {
-        self.trash.read(cx).len()
-    }
-
-    /// Get the trash messages entity.
-    pub fn trash(&self) -> Entity<BTreeSet<FailedMessage>> {
-        self.trash.clone()
-    }
-
     /// Get the relays that have seen a given rumor id.
     pub fn rumor_seen_on(&self, id: &EventId) -> Option<HashSet<RelayUrl>> {
         self.event_map
@@ -494,7 +558,7 @@ impl ChatRegistry {
     }
 
     /// Get the relays that have seen a given gift wrap id.
-    pub fn seen_on(&self, id: &EventId) -> HashSet<RelayUrl> {
+    pub(crate) fn seen_on(&self, id: &EventId) -> HashSet<RelayUrl> {
         self.seen
             .read()
             .unwrap()
@@ -504,7 +568,7 @@ impl ChatRegistry {
     }
 
     /// Add a new room to the start of list.
-    pub fn add_room<I>(&mut self, room: I, cx: &mut Context<Self>)
+    pub(crate) fn add_room<I>(&mut self, room: I, cx: &mut Context<Self>)
     where
         I: Into<Room>,
     {
@@ -516,6 +580,7 @@ impl ChatRegistry {
         let room: Room = room.into().organize(&public_key);
         let room_id = room.id;
         let entity = cx.new(|_| room);
+        entity.update(cx, |room, cx| room.ensure_directory(cx));
 
         self.room_index.insert(room_id, entity.clone());
         self.rooms.insert(0, entity);
@@ -524,39 +589,21 @@ impl ChatRegistry {
         cx.notify();
     }
 
-    /// Emit an open room event.
-    ///
-    /// If the room is new, add it to the registry.
-    pub fn emit_room(&mut self, room: &Entity<Room>, window: &mut Window, cx: &mut Context<Self>) {
-        // Get the room's ID.
+    /// Track a room so it is listed and can be looked up by id.
+    pub fn track_room(&mut self, room: &Entity<Room>, cx: &mut Context<Self>) {
         let id = room.read(cx).id;
 
-        // If the room is new, add it to the registry and index.
         if let hash_map::Entry::Vacant(e) = self.room_index.entry(id) {
-            let entity = room.to_owned();
-            e.insert(entity.clone());
-            self.rooms.insert(0, entity);
-        }
+            room.update(cx, |room, cx| room.ensure_directory(cx));
+            e.insert(room.clone());
 
-        // Emit the open room event deferred to avoid re-entrant reads
-        cx.defer_in(window, move |_this, _window, cx| {
-            cx.emit(ChatEvent::OpenRoom(id));
-        });
-    }
-
-    /// Close a room.
-    pub fn close_room(&mut self, id: u64, window: &mut Window, cx: &mut Context<Self>) {
-        if self.room_index.contains_key(&id) {
-            self.room_index.remove(&id);
-            self.rooms.retain(|r| r.read(cx).id != id);
-            cx.defer_in(window, move |_this, _window, cx| {
-                cx.emit(ChatEvent::CloseRoom(id));
-            });
+            self.rooms.insert(0, room.clone());
+            cx.notify();
         }
     }
 
     /// Sort rooms by their created at. Only notifies if order changed.
-    pub fn sort(&mut self, cx: &mut Context<Self>) {
+    pub(crate) fn sort(&mut self, cx: &mut Context<Self>) {
         let before: Vec<_> = self.rooms.iter().map(|ev| ev.read(cx).id).collect();
         self.rooms.sort_by_key(|ev| Reverse(ev.read(cx).created_at));
         let after: Vec<_> = self.rooms.iter().map(|ev| ev.read(cx).id).collect();
@@ -586,10 +633,16 @@ impl ChatRegistry {
         }
     }
 
+    /// Search the content of all indexed messages, newest first.
+    pub fn search_messages(&self, terms: &[String], limit: usize) -> Vec<SearchMessage> {
+        self.search.read().unwrap().search(terms, limit)
+    }
+
     /// Reset the registry.
-    pub fn reset(&mut self, cx: &mut Context<Self>) {
+    pub(crate) fn reset(&mut self, cx: &mut Context<Self>) {
         self.rooms.clear();
         self.room_index.clear();
+        self.search.write().unwrap().clear();
         self.trash.update(cx, |this, cx| {
             this.clear();
             cx.notify();
@@ -618,6 +671,7 @@ impl ChatRegistry {
             } else {
                 let new_room_id = new_room.id;
                 let entity = cx.new(|_| new_room);
+                entity.update(cx, |room, cx| room.ensure_directory(cx));
                 self.room_index.insert(new_room_id, entity.clone());
                 self.rooms.push(entity);
 
@@ -628,8 +682,8 @@ impl ChatRegistry {
     }
 
     /// Load all rooms from the database.
-    pub fn get_rooms(&mut self, cx: &mut Context<Self>) {
-        let task = self.get_rooms_task(cx);
+    pub(crate) fn get_rooms(&mut self, cx: &mut Context<Self>) {
+        let task = self.query_chat_rooms(cx);
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
@@ -650,11 +704,12 @@ impl ChatRegistry {
         }));
     }
 
-    /// Create a task to load rooms from the database
-    fn get_rooms_task(&self, cx: &App) -> Task<Result<HashSet<Room>, Error>> {
+    /// Query the chat rooms from the database
+    fn query_chat_rooms(&self, cx: &App) -> Task<Result<HashSet<Room>, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
+        let search = self.search.clone();
 
         cx.background_spawn(async move {
             let public_key = signer.get_public_key_async().await?;
@@ -677,7 +732,7 @@ impl ChatRegistry {
 
             let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
-                .custom_tag(SingleLetterTag::LOWERCASE_K, "14");
+                .custom_tags(SingleLetterTag::LOWERCASE_K, ["7", "14", "15"]);
 
             let events = client.database().query(filter).await?;
             let mut grouped: HashMap<u64, Vec<UnsignedEvent>> = HashMap::new();
@@ -686,6 +741,7 @@ impl ChatRegistry {
                 if let Ok(rumor) = UnsignedEvent::from_json(&raw.content)
                     && rumor.tags.public_keys().next().is_some()
                 {
+                    search.write().unwrap().insert(&rumor);
                     if rumor.pubkey != public_key
                         && !rumor.tags.public_keys().any(|k| k == public_key)
                     {
@@ -719,9 +775,11 @@ impl ChatRegistry {
 
     /// Parse a nostr event into a message and push it to the belonging room
     ///
-    /// If the room doesn't exist, it will be created.
-    /// Updates room ordering based on the most recent messages.
-    pub fn new_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
+    /// - If the room doesn't exist, it will be created.
+    /// - Updates room ordering based on the most recent messages.
+    pub(crate) fn new_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
+        self.search.write().unwrap().insert(&message.rumor);
+
         let nostr = NostrRegistry::global(cx);
 
         let Some(public_key) = nostr.read(cx).current_user() else {
@@ -744,32 +802,33 @@ impl ChatRegistry {
             }
         }
     }
-
-    /// Trigger a refresh of the opened chat rooms by their IDs
-    pub fn refresh_rooms(&mut self, ids: &[u64], cx: &mut Context<Self>) {
-        for room in self.rooms.iter() {
-            if ids.contains(&room.read(cx).id) {
-                room.update(cx, |this, cx| {
-                    this.emit_refresh(cx);
-                });
-            }
-        }
-    }
 }
 
 /// Unwraps a gift-wrapped event and processes its contents.
-async fn extract_rumor(
+async fn extract_rumor<S, D>(
     client: &Client,
-    signer: &UniversalSigner,
+    signer: &S,
+    device_signer: Option<&D>,
     gift_wrap: &Event,
-) -> Result<UnsignedEvent, Error> {
+) -> Result<UnsignedEvent, Error>
+where
+    S: AsyncNip44 + ?Sized,
+    D: AsyncNip44 + ?Sized,
+{
     // Try to get cached rumor first
     if let Ok(rumor) = get_rumor(client, gift_wrap.id).await {
         return Ok(rumor);
     }
 
-    // Try to unwrap with the available signer
-    let unwrapped = try_unwrap_with(signer, gift_wrap).await?;
+    let unwrapped = match try_unwrap_with(signer, gift_wrap).await {
+        Ok(unwrapped) => unwrapped,
+        Err(error) => {
+            let Some(device_signer) = device_signer else {
+                return Err(error);
+            };
+            try_unwrap_with(device_signer, gift_wrap).await?
+        }
+    };
     let mut rumor = unwrapped.rumor;
 
     // Verify rumor author matches the seal sender (as per mobile implementation)
@@ -789,10 +848,10 @@ async fn extract_rumor(
 }
 
 /// Attempts to unwrap a gift wrap event with a given signer.
-async fn try_unwrap_with(
-    signer: &UniversalSigner,
-    gift_wrap: &Event,
-) -> Result<UnwrappedGift, Error> {
+async fn try_unwrap_with<S>(signer: &S, gift_wrap: &Event) -> Result<UnwrappedGift, Error>
+where
+    S: AsyncNip44 + ?Sized,
+{
     // Get the sealed event
     let seal = signer
         .nip44_decrypt_async(&gift_wrap.pubkey, &gift_wrap.content)
@@ -802,9 +861,17 @@ async fn try_unwrap_with(
     let seal: Event = Event::from_json(seal)?;
     seal.verify()?;
 
+    let sender_encryption_key = seal
+        .tags
+        .iter()
+        .find(|tag| tag.kind() == "n")
+        .and_then(|tag| tag.content())
+        .and_then(|content| PublicKey::parse(content).ok())
+        .unwrap_or(seal.pubkey);
+
     // Get the rumor event
     let rumor = signer
-        .nip44_decrypt_async(&seal.pubkey, &seal.content)
+        .nip44_decrypt_async(&sender_encryption_key, &seal.content)
         .await?;
 
     let rumor = UnsignedEvent::from_json(rumor)?;
@@ -823,7 +890,7 @@ async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Resul
         Tag::identifier(id),
         Tag::public_key(rumor.pubkey),
         Tag::custom("r", [room_id]),
-        Tag::custom("k", ["14"]),
+        Tag::custom("k", [rumor.kind.to_string()]),
     ];
 
     let event = EventBuilder::new(Kind::ApplicationSpecificData, rumor.as_json())

crates/chat/src/message.rs

@@ -1,9 +1,15 @@
 use std::hash::Hash;
 use std::ops::Range;
 
-use common::{EventExt, NostrParser, extract_and_remove_media_urls};
+use common::{EventExt, NostrParser, emojis_from_tags, extract_and_remove_media_urls};
 use gpui::{SharedString, SharedUri};
 use nostr_sdk::prelude::*;
+use state::FileAttachment;
+
+pub(crate) const KIND_FILE_MESSAGE: Kind = Kind::Custom(15);
+
+const SCHEME_WITH_COLON: &str = "nostr:";
+const NEVENT_PREFIX: &str = "nevent1";
 
 /// Rendered message.
 #[derive(Debug, Clone)]
@@ -19,63 +25,96 @@ pub struct Message {
     pub created_at: Timestamp,
     /// List of mentioned public keys in the message
     pub mentions: Vec<Mention>,
+    /// Custom emoji (NIP-30) declared by this message's `emoji` tags
+    pub emojis: Vec<(String, Url)>,
     /// List of event of the message this message is a reply to
     pub replies_to: Vec<EventId>,
+    /// Encrypted file attachment
+    pub file: Option<FileAttachment>,
 }
 
 impl From<&Event> for Message {
     fn from(val: &Event) -> Self {
-        let mentions = extract_mentions(&val.content);
-        let replies_to = extract_reply_ids(&val.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.content);
-
-        Self {
-            id: val.id,
-            author: val.pubkey,
-            content: string,
-            media,
-            created_at: val.created_at,
-            mentions,
-            replies_to,
-        }
+        from_parts(
+            val.id,
+            val.pubkey,
+            val.created_at,
+            val.kind,
+            &val.content,
+            &val.tags,
+        )
     }
 }
 
 impl From<&UnsignedEvent> for Message {
     fn from(val: &UnsignedEvent) -> Self {
-        let mentions = extract_mentions(&val.content);
-        let replies_to = extract_reply_ids(&val.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.content);
-
-        Self {
+        from_parts(
             // Event ID must be known
-            id: val.id.unwrap(),
-            author: val.pubkey,
-            content: string,
-            media,
-            created_at: val.created_at,
-            mentions,
-            replies_to,
-        }
+            val.id.unwrap(),
+            val.pubkey,
+            val.created_at,
+            val.kind,
+            &val.content,
+            &val.tags,
+        )
     }
 }
 
 impl From<&NewMessage> for Message {
     fn from(val: &NewMessage) -> Self {
-        let mentions = extract_mentions(&val.rumor.content);
-        let replies_to = extract_reply_ids(&val.rumor.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.rumor.content);
-
-        Self {
+        from_parts(
             // Event ID must be known
-            id: val.rumor.id.unwrap(),
-            author: val.rumor.pubkey,
-            content: string,
-            media,
-            created_at: val.rumor.created_at,
-            mentions,
-            replies_to,
-        }
+            val.rumor.id.unwrap(),
+            val.rumor.pubkey,
+            val.rumor.created_at,
+            val.rumor.kind,
+            &val.rumor.content,
+            &val.rumor.tags,
+        )
+    }
+}
+
+fn from_parts(
+    id: EventId,
+    author: PublicKey,
+    created_at: Timestamp,
+    kind: Kind,
+    content: &str,
+    tags: &Tags,
+) -> Message {
+    let file = if kind == KIND_FILE_MESSAGE {
+        FileAttachment::from_tags(content, tags)
+    } else {
+        None
+    };
+    let has_file = file.is_some();
+
+    let replies_to = extract_reply_ids(tags);
+    let emojis = emojis_from_tags(tags);
+
+    // For file messages `.content` is the encrypted blob URL, not text or media
+    let mentions = if has_file {
+        Vec::new()
+    } else {
+        extract_mentions(content)
+    };
+
+    let (media, content) = if has_file {
+        (Vec::new(), String::new())
+    } else {
+        extract_and_remove_media_urls(content)
+    };
+
+    Message {
+        id,
+        author,
+        content,
+        media,
+        created_at,
+        mentions,
+        emojis,
+        replies_to,
+        file,
     }
 }
 
@@ -105,35 +144,74 @@ impl Hash for Message {
     }
 }
 
+impl Message {
+    /// Single-line representation for reply previews, notifications and copy.
+    pub fn preview(&self) -> SharedString {
+        if let Some(file) = &self.file {
+            return format!("[File] {}", file.display_name()).into();
+        }
+
+        // Media-only messages carry their URLs outside `.content`
+        if self.content.is_empty() && !self.media.is_empty() {
+            return self
+                .media
+                .iter()
+                .map(|url| url.to_string())
+                .collect::<Vec<_>>()
+                .join(" ")
+                .into();
+        }
+
+        let references = nevent_refs(&self.content);
+        if references.is_empty() {
+            return self.content.clone().into();
+        }
+
+        let mut preview = String::with_capacity(self.content.len());
+        let mut last = 0;
+
+        for reference in references {
+            preview.push_str(&self.content[last..reference.range.start]);
+            preview.push_str(&reference.label);
+            last = reference.range.end;
+        }
+        preview.push_str(&self.content[last..]);
+
+        preview.into()
+    }
+
+    /// Image URL of a `:shortcode:` reaction, if the shortcode is declared
+    pub fn reaction_image(content: &str, emojis: &[(String, Url)]) -> Option<Url> {
+        let shortcode = content.strip_prefix(':')?.strip_suffix(':')?;
+        let (_, url) = emojis.iter().find(|(name, _)| name == shortcode)?;
+        Some(url.clone())
+    }
+}
+
 /// New message.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NewMessage {
     pub room: u64,
-    pub gift_wrap: EventId,
     pub rumor: UnsignedEvent,
 }
 
 impl NewMessage {
-    pub fn new(gift_wrap: EventId, rumor: UnsignedEvent) -> Self {
+    pub fn new(_gift_wrap: EventId, rumor: UnsignedEvent) -> Self {
         let room = rumor.uniq_id();
 
-        Self {
-            room,
-            gift_wrap,
-            rumor,
-        }
+        Self { room, rumor }
     }
 }
 
 /// Trash message.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct FailedMessage {
+pub(crate) struct FailedMessage {
     pub raw_event: SharedString,
     pub reason: SharedString,
 }
 
 impl FailedMessage {
-    pub fn new<T>(event: &Event, reason: T) -> Self
+    pub(crate) fn new<T>(event: &Event, reason: T) -> Self
     where
         T: Into<SharedString>,
     {
@@ -151,7 +229,7 @@ pub struct Mention {
 }
 
 impl Mention {
-    pub fn new(public_key: PublicKey, range: Range<usize>) -> Self {
+    pub(crate) fn new(public_key: PublicKey, range: Range<usize>) -> Self {
         Self { public_key, range }
     }
 }
@@ -170,6 +248,61 @@ fn extract_mentions(content: &str) -> Vec<Mention> {
         .collect()
 }
 
+/// A `nevent` reference found in a content string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NeventRef {
+    /// Range of the reference, including the optional `nostr:` scheme
+    pub range: Range<usize>,
+    /// Compact display label, like `https://njump.me/nevent1...d9sp`
+    pub label: String,
+}
+
+/// Extracts valid `nevent1...` and `nostr:nevent1...` references from content.
+pub fn nevent_refs(content: &str) -> Vec<NeventRef> {
+    let mut references = Vec::new();
+
+    for (match_start, _) in content.match_indices(NEVENT_PREFIX) {
+        // Only lowercase references are matched, matching NIP-19 encodings in practice
+        let start = if content[..match_start].ends_with(SCHEME_WITH_COLON) {
+            match_start - SCHEME_WITH_COLON.len()
+        } else {
+            match_start
+        };
+
+        // Skip matches glued to word characters, like the `nevent1` in `xnevent1...`
+        if content[..start].ends_with(char::is_alphanumeric) {
+            continue;
+        }
+
+        let end = match_start
+            + content[match_start..]
+                .bytes()
+                .take_while(u8::is_ascii_alphanumeric)
+                .count();
+
+        // The bech32 token excludes the optional `nostr:` scheme
+        let bech32 = &content[match_start..end];
+        if Nip19Event::from_bech32(bech32).is_err() {
+            continue;
+        }
+
+        references.push(NeventRef {
+            range: start..end,
+            label: nevent_label(bech32),
+        });
+    }
+
+    references
+}
+
+/// Compact display of a nevent link, like `https://njump.me/nevent1...d9sp`.
+fn nevent_label(bech32: &str) -> String {
+    match bech32.len() {
+        0..=4 => format!("https://njump.me/{bech32}"),
+        _ => format!("https://njump.me/nevent1...{}", &bech32[bech32.len() - 4..]),
+    }
+}
+
 /// Extracts all reply (ids) from the event tags.
 fn extract_reply_ids(inner: &Tags) -> Vec<EventId> {
     let mut replies_to = vec![];
@@ -188,3 +321,78 @@ fn extract_reply_ids(inner: &Tags) -> Vec<EventId> {
 
     replies_to
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rumor(kind: Kind, content: &str, tags: Tags) -> UnsignedEvent {
+        let sender = Keys::generate();
+
+        let mut rumor = EventBuilder::new(kind, content)
+            .tags(tags)
+            .finalize_unsigned(sender.public_key());
+        rumor.ensure_id();
+        rumor
+    }
+
+    fn emoji_tag(shortcode: &str, url: &str) -> Tag {
+        Tag::parse(vec!["emoji", shortcode, url]).expect("valid emoji tag")
+    }
+
+    #[test]
+    fn message_parses_emoji_tags() {
+        let tags = Tags::from_list(vec![emoji_tag(
+            "soapbox",
+            "https://example.com/soapbox.png",
+        )]);
+
+        let message = Message::from(&rumor(Kind::PrivateDirectMessage, "hi :soapbox:", tags));
+
+        assert_eq!(message.emojis.len(), 1);
+        assert_eq!(message.emojis[0].0, "soapbox");
+    }
+
+    #[test]
+    fn reaction_image_matches_declared_shortcode() {
+        let emojis = vec![(
+            String::from("soapbox"),
+            Url::parse("https://example.com/soapbox.png").unwrap(),
+        )];
+
+        assert_eq!(
+            Message::reaction_image(":soapbox:", &emojis),
+            Some(Url::parse("https://example.com/soapbox.png").unwrap())
+        );
+        assert_eq!(Message::reaction_image("😂", &emojis), None);
+        assert_eq!(Message::reaction_image(":unknown:", &emojis), None);
+    }
+
+    fn valid_nevent() -> String {
+        Nip19Event::new(EventId::from_byte_array([7; 32]))
+            .to_bech32()
+            .expect("valid nevent")
+    }
+
+    #[test]
+    fn image_only_messages_preview_their_url() {
+        let url = "https://example.com/picture.png";
+        let message = Message::from(&rumor(Kind::PrivateDirectMessage, url, Tags::new()));
+
+        assert!(message.content.is_empty());
+        assert_eq!(message.preview().to_string(), url);
+    }
+
+    #[test]
+    fn preview_compacts_nevent_references() {
+        let nevent = valid_nevent();
+        let message = Message::from(&rumor(
+            Kind::PrivateDirectMessage,
+            &format!("see nostr:{nevent}"),
+            Tags::new(),
+        ));
+
+        let label = format!("https://njump.me/nevent1...{}", &nevent[nevent.len() - 4..]);
+        assert_eq!(message.preview().to_string(), format!("see {label}"));
+    }
+}

crates/chat/src/room.rs

@@ -3,99 +3,52 @@ use std::hash::{Hash, Hasher};
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
-use device::DeviceRegistry;
-use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
+use gpui::{App, AppContext, Context, Entity, EventEmitter, SharedString, Task};
 use instant::Duration;
 use itertools::Itertools;
+use nip4e::DeviceRegistry;
 use nostr_sdk::prelude::*;
-use person::{Person, PersonRegistry};
+use person::{Directory, Person};
 use settings::{RoomConfig, SignerKind};
 use state::{NostrRegistry, TIMEOUT, UniversalSigner};
 
-use crate::NewMessage;
+use crate::{FileAttachment, KIND_FILE_MESSAGE, NewMessage};
 
 const NO_DEKEY: &str = "User hasn't set up a decoupled encryption key yet.";
-const USER_NO_DEKEY: &str = "You haven't set up a decoupled encryption key or it's not available.";
+const USER_NO_DEKEY: &str = "You haven't set up a decoupled encryption key yet. Set one up in the settings to message them.";
 
+/// The outcome of delivering an encrypted rumor to a single receiver.
 #[derive(Debug, Clone)]
 pub struct SendReport {
+    /// The receiver the rumor was addressed to.
     pub receiver: PublicKey,
-    pub gift_wrap_id: Option<EventId>,
-    pub error: Option<SharedString>,
-    pub output: Option<Output<EventId, EventSendStatus>>,
+    /// The per-relay send output, or the error that prevented the send.
+    result: Result<Output<EventId, EventSendStatus>, SharedString>,
 }
 
 impl SendReport {
-    pub fn new(receiver: PublicKey) -> Self {
-        Self {
-            receiver,
-            gift_wrap_id: None,
-            error: None,
-            output: None,
-        }
+    /// The error that prevented the send, if any.
+    pub fn error(&self) -> Option<&SharedString> {
+        self.result.as_ref().err()
     }
 
-    /// Set the gift wrap ID.
-    pub fn gift_wrap_id(mut self, gift_wrap_id: EventId) -> Self {
-        self.gift_wrap_id = Some(gift_wrap_id);
-        self
+    /// The per-relay send output, if the gift wrap was dispatched.
+    pub fn output(&self) -> Option<&Output<EventId, EventSendStatus>> {
+        self.result.as_ref().ok()
     }
 
-    /// Set the output.
-    pub fn output(mut self, output: Output<EventId, EventSendStatus>) -> Self {
-        self.output = Some(output);
-        self
-    }
-
-    /// Set the error message.
-    pub fn error<T>(mut self, error: T) -> Self
-    where
-        T: Into<SharedString>,
-    {
-        self.error = Some(error.into());
-        self
-    }
-
-    /// Returns true if the send is pending.
-    pub fn pending(&self) -> bool {
-        self.error.is_none()
-            && self
-                .output
-                .as_ref()
-                .is_some_and(|o| o.success.is_empty() && o.failed.is_empty())
-    }
-
-    /// Returns true if the send was successful.
+    /// Whether at least one relay accepted the event.
     pub fn success(&self) -> bool {
-        self.error.is_none() && self.output.as_ref().is_some_and(|o| !o.success.is_empty())
+        self.output()
+            .is_some_and(|output| !output.success.is_empty())
     }
 
-    /// Returns true if the send failed.
+    /// Whether no relay accepted the event.
     pub fn failed(&self) -> bool {
-        self.error.is_some() && self.output.as_ref().is_some_and(|o| !o.failed.is_empty())
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum SendStatus {
-    Ok {
-        id: EventId,
-        relay: RelayUrl,
-    },
-    Failed {
-        id: EventId,
-        relay: RelayUrl,
-        message: String,
-    },
-}
-
-impl SendStatus {
-    pub fn ok(id: EventId, relay: RelayUrl) -> Self {
-        Self::Ok { id, relay }
-    }
-
-    pub fn failed(id: EventId, relay: RelayUrl, message: String) -> Self {
-        Self::Failed { id, relay, message }
+        match &self.result {
+            Err(_) => true,
+            Ok(output) => output.success.is_empty(),
+        }
     }
 }
 
@@ -125,7 +78,7 @@ pub struct Room {
     pub created_at: Timestamp,
 
     /// Subject of the room
-    pub subject: Option<SharedString>,
+    pub(crate) subject: Option<SharedString>,
 
     /// All members of the room
     pub(super) members: Vec<PublicKey>,
@@ -135,6 +88,9 @@ pub struct Room {
 
     /// Configuration
     config: RoomConfig,
+
+    /// Person directory, attached when the room is registered
+    directory: Option<Entity<Directory>>,
 }
 
 impl Ord for Room {
@@ -183,6 +139,7 @@ impl From<&UnsignedEvent> for Room {
             members,
             kind: RoomKind::default(),
             config: RoomConfig::new(),
+            directory: None,
         }
     }
 }
@@ -233,13 +190,16 @@ impl Room {
     }
 
     /// Sets this room is ongoing conversation
-    pub fn set_ongoing(&mut self, cx: &mut Context<Self>) {
+    pub(crate) fn set_ongoing(&mut self, cx: &mut Context<Self>) {
         self.kind = RoomKind::Ongoing;
         cx.notify();
     }
 
     /// Updates the creation timestamp of the room
-    pub fn set_created_at(&mut self, created_at: impl Into<Timestamp>, cx: &mut Context<Self>) {
+    pub(crate) fn set_created_at<T>(&mut self, created_at: T, cx: &mut Context<Self>)
+    where
+        T: Into<Timestamp>,
+    {
         self.created_at = created_at.into();
         cx.notify();
     }
@@ -280,6 +240,32 @@ impl Room {
         self.members.len() > 2
     }
 
+    /// The room's person directory, attached when the room is registered
+    pub fn directory(&self) -> Option<Entity<Directory>> {
+        self.directory.clone()
+    }
+
+    /// Attach the person directory, tracking the room's members
+    pub(crate) fn ensure_directory(&mut self, cx: &mut Context<Self>) {
+        if self.directory.is_some() {
+            return;
+        }
+
+        let directory = Directory::new(cx);
+        let members = self.members.clone();
+        directory.update(cx, |directory, cx| directory.track(members, cx));
+        self.directory = Some(directory);
+    }
+
+    /// The person for a room member
+    fn member(&self, public_key: &PublicKey, cx: &App) -> Person {
+        let Some(directory) = self.directory.as_ref() else {
+            return Person::new(*public_key, Metadata::default());
+        };
+
+        directory.read(cx).person(public_key, cx)
+    }
+
     /// Gets the display name for the room
     pub fn display_name(&self, cx: &App) -> SharedString {
         if let Some(value) = self.subject.clone() {
@@ -289,12 +275,21 @@ impl Room {
         }
     }
 
-    /// Gets the display image for the room
-    pub fn display_image(&self, cx: &App) -> SharedString {
-        if !self.is_group() {
-            self.display_member(cx).avatar()
+    /// Gets the display picture for the room, if it has one
+    pub fn display_image(&self, cx: &App) -> Option<SharedString> {
+        if self.is_group() {
+            None
         } else {
-            SharedString::from("brand/group.png")
+            self.display_member(cx).avatar()
+        }
+    }
+
+    /// A stable seed for the room's generated avatar
+    pub fn display_image_seed(&self, cx: &App) -> String {
+        if self.is_group() {
+            self.id.to_string()
+        } else {
+            self.display_member(cx).avatar_seed()
         }
     }
 
@@ -302,19 +297,16 @@ impl Room {
     ///
     /// Display member is always different from the current user.
     pub fn display_member(&self, cx: &App) -> Person {
-        let persons = PersonRegistry::global(cx);
-        persons.read(cx).get(&self.members[0], cx)
+        self.member(&self.members[0], cx)
     }
 
     /// Merge the names of the first two members of the room.
     fn merged_name(&self, cx: &App) -> SharedString {
-        let persons = PersonRegistry::global(cx);
-
         if self.is_group() {
             let profiles: Vec<Person> = self
                 .members
                 .iter()
-                .map(|public_key| persons.read(cx).get(public_key, cx))
+                .map(|public_key| self.member(public_key, cx))
                 .collect();
 
             let mut name = profiles
@@ -335,7 +327,7 @@ impl Room {
     }
 
     /// Push a new message to the current room
-    pub fn push_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
+    pub(crate) fn push_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
         let created_at = message.rumor.created_at;
         let new_message = created_at > self.created_at;
 
@@ -347,11 +339,6 @@ impl Room {
         }
     }
 
-    /// Emits a signal to reload the current room's messages.
-    pub fn emit_refresh(&mut self, cx: &mut Context<Self>) {
-        cx.emit(RoomEvent::Reload);
-    }
-
     /// Get gossip relays for each member
     pub fn connect(&self, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
@@ -439,36 +426,16 @@ impl Room {
         let content: String = content.into();
         let replies: Vec<EventId> = replies.into_iter().collect();
 
-        let persons = PersonRegistry::global(cx);
-        let nostr = NostrRegistry::global(cx);
-
         // Get current user's public key
+        let nostr = NostrRegistry::global(cx);
         let sender = nostr.read(cx).current_user()?;
 
-        // Construct event's tags
-        let mut tags = vec![];
-
-        // Add subject tag if present
-        if let Some(value) = self.subject.as_ref() {
-            tags.push(Tag::custom("subject", vec![value.to_string()]));
-        }
-
-        // Add all reply tags
-        for id in replies.into_iter() {
-            tags.push(Tag::event(id))
-        }
-
-        // Add all receiver tags (no intermediate allocation)
-        for public_key in self.members.iter().filter(|pk| *pk != &sender) {
-            let member = persons.read(cx).get(public_key, cx);
-            tags.push(Tag::from(Nip01Tag::PublicKey {
-                public_key: member.public_key(),
-                relay_hint: member.messaging_relay_hint(),
-            }));
-        }
-
         // Construct a direct message rumor event
+        //
         // WARNING: never sign and send this event to relays
+        let mut tags = self.conversation_tags(&replies, sender, cx);
+        tags.extend(self.member(&sender, cx).emoji_tags(&content));
+
         let mut event = EventBuilder::new(kind, content)
             .tags(tags)
             .finalize_unsigned(sender);
@@ -479,31 +446,60 @@ impl Room {
         Some(event)
     }
 
-    /// Select the appropriate signer based on signer kind and available keys.
-    fn select_signer(
-        signer_kind: &SignerKind,
-        has_announcement: bool,
-        encryption_signer: &Option<UniversalSigner>,
-        user_signer: &UniversalSigner,
-    ) -> UniversalSigner {
-        match signer_kind {
-            SignerKind::Auto => {
-                if has_announcement {
-                    encryption_signer
-                        .clone()
-                        .unwrap_or_else(|| user_signer.clone())
-                } else {
-                    user_signer.clone()
-                }
-            }
-            SignerKind::Encryption => encryption_signer
-                .clone()
-                .expect("encryption signer must be set"),
-            SignerKind::User => user_signer.clone(),
-        }
+    // Construct a rumor event for an encrypted file message (NIP-17 kind 15)
+    pub fn file_rumor<I>(&self, file: FileAttachment, replies: I, cx: &App) -> Option<UnsignedEvent>
+    where
+        I: IntoIterator<Item = EventId>,
+    {
+        let replies: Vec<EventId> = replies.into_iter().collect();
+
+        // Get current user's public key
+        let nostr = NostrRegistry::global(cx);
+        let sender = nostr.read(cx).current_user()?;
+
+        let mut tags = self.conversation_tags(&replies, sender, cx);
+        tags.extend(file.tags());
+
+        // Construct a file message rumor event
+        // WARNING: never sign and send this event to relays
+        let mut event = EventBuilder::new(KIND_FILE_MESSAGE, file.url.to_string())
+            .tags(tags)
+            .finalize_unsigned(sender);
+
+        // Ensure that the ID is set
+        event.ensure_id();
+
+        Some(event)
     }
 
-    /// Send rumor event to all members's messaging relays
+    // Build the `subject` + reply `e` tags + receiver `p` tags (excluding `sender`)
+    fn conversation_tags(&self, replies: &[EventId], sender: PublicKey, cx: &App) -> Vec<Tag> {
+        // Construct event's tags
+        let mut tags = vec![];
+
+        // Add subject tag if present
+        if let Some(value) = self.subject.as_ref() {
+            tags.push(Tag::custom("subject", vec![value.to_string()]));
+        }
+
+        // Add all reply tags
+        for id in replies {
+            tags.push(Tag::event(*id))
+        }
+
+        // Add all receiver tags (no intermediate allocation)
+        for public_key in self.members.iter().filter(|pk| *pk != &sender) {
+            let member = self.member(public_key, cx);
+            tags.push(Tag::from(Nip01Tag::PublicKey {
+                public_key: member.public_key(),
+                relay_hint: member.messaging_relay_hint(),
+            }));
+        }
+
+        tags
+    }
+
+    /// Send the rumor to every member's messaging relays.
     pub fn send(&self, rumor: UnsignedEvent, cx: &App) -> Option<Task<Vec<SendReport>>> {
         let config = self.config.clone();
 
@@ -516,84 +512,47 @@ impl Room {
         let current_user = nostr.read(cx).current_user()?;
 
         // Get sender's profile
-        let persons = PersonRegistry::global(cx);
-        let sender = persons.read(cx).get(&current_user, cx);
+        let sender = self.member(&current_user, cx);
 
         // Get all members (excluding sender)
-        let members: Vec<Person> = self
+        let receivers: Vec<Person> = self
             .members
             .iter()
             .filter(|public_key| public_key != &&sender.public_key())
-            .map(|member| persons.read(cx).get(member, cx))
+            .map(|member| self.member(member, cx))
             .collect();
 
         Some(cx.background_spawn(async move {
             let signer_kind = config.signer_kind();
-            let backup = config.backup();
 
-            let mut sents = 0;
-            let mut reports = Vec::new();
-
-            // Process each member
-            for member in members {
-                let announcement = member.announcement();
-                let public_key = member.public_key();
-
-                // Handle encryption signer requirements
-                if signer_kind.encryption() {
-                    // Receiver didn't set up a decoupled encryption key
-                    if announcement.is_none() {
-                        reports.push(SendReport::new(public_key).error(NO_DEKEY));
-                        continue;
-                    }
-
-                    // Sender didn't set up a decoupled encryption key
-                    if encryption_signer.is_none() {
-                        reports.push(SendReport::new(sender.public_key()).error(USER_NO_DEKEY));
-                        continue;
-                    }
-                }
-
-                // Determine the signer to use
-                let signer = Self::select_signer(
+            // Deliver to every receiver concurrently
+            let sends = receivers.into_iter().map(|receiver| {
+                deliver(
+                    &client,
                     signer_kind,
-                    announcement.is_some(),
-                    &encryption_signer,
+                    receiver,
+                    &rumor,
+                    encryption_signer.as_ref(),
                     &user_signer,
+                )
+            });
+
+            let mut reports: Vec<SendReport> = futures::future::join_all(sends).await;
+            let minimum_success = reports.iter().any(SendReport::success);
+
+            // Back up the message to ourselves once at least one receiver got it
+            if config.backup() && minimum_success {
+                reports.push(
+                    deliver(
+                        &client,
+                        signer_kind,
+                        sender,
+                        &rumor,
+                        encryption_signer.as_ref(),
+                        &user_signer,
+                    )
+                    .await,
                 );
-
-                // Send the gift wrap event and collect the report
-                match send_gift_wrap(&client, &signer, &member, &rumor, signer_kind).await {
-                    Ok(report) => {
-                        reports.push(report);
-                        sents += 1;
-                    }
-                    Err(error) => {
-                        let report = SendReport::new(public_key).error(error.to_string());
-                        reports.push(report);
-                    }
-                }
-            }
-
-            // Send backup to current user if needed
-            if backup && sents >= 1 {
-                let public_key = sender.public_key();
-
-                // Determine the signer to use
-                let signer = Self::select_signer(
-                    signer_kind,
-                    sender.announcement().is_some(),
-                    &encryption_signer,
-                    &user_signer,
-                );
-
-                match send_gift_wrap(&client, &signer, &sender, &rumor, signer_kind).await {
-                    Ok(report) => reports.push(report),
-                    Err(error) => {
-                        let report = SendReport::new(public_key).error(error.to_string());
-                        reports.push(report);
-                    }
-                }
             }
 
             reports
@@ -601,55 +560,151 @@ impl Room {
     }
 }
 
-// Helper function to send a gift-wrapped event
-async fn send_gift_wrap(
+/// Deliver a rumor to a single receiver.
+async fn deliver<S>(
+    client: &Client,
+    signer_kind: &SignerKind,
+    receiver: Person,
+    rumor: &UnsignedEvent,
+    encryption_signer: Option<&UniversalSigner>,
+    user_signer: &S,
+) -> SendReport
+where
+    S: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44,
+{
+    let public_key = receiver.public_key();
+    let announcement = receiver.announcement();
+
+    if signer_kind.encryption() {
+        // Receiver didn't set up a decoupled encryption key
+        if announcement.is_none() {
+            return SendReport {
+                receiver: public_key,
+                result: Err(NO_DEKEY.into()),
+            };
+        }
+
+        // Sender didn't set up a decoupled encryption key
+        if encryption_signer.is_none() {
+            return SendReport {
+                receiver: public_key,
+                result: Err(USER_NO_DEKEY.into()),
+            };
+        }
+    }
+
+    match send_gift_wrap(
+        client,
+        &receiver,
+        rumor,
+        signer_kind,
+        encryption_signer,
+        user_signer,
+    )
+    .await
+    {
+        Ok(output) => SendReport {
+            receiver: public_key,
+            result: Ok(output),
+        },
+        Err(error) => SendReport {
+            receiver: public_key,
+            result: Err(error.to_string().into()),
+        },
+    }
+}
+
+/// Build the gift-wrapped event for a rumor and send it.
+async fn send_gift_wrap<S>(
     client: &Client,
-    signer: &UniversalSigner,
     receiver: &Person,
     rumor: &UnsignedEvent,
     config: &SignerKind,
-) -> Result<SendReport, Error> {
-    let k_tag = Tag::custom("k", vec!["14"]);
-    let mut extra_tags = vec![k_tag];
+    encryption_signer: Option<&UniversalSigner>,
+    user_signer: &S,
+) -> Result<Output<EventId, EventSendStatus>, Error>
+where
+    S: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44,
+{
+    let mut extra_tags = vec![Tag::custom("k", [rumor.kind.to_string()])];
 
     // Determine the receiver public key based on the config
-    let receiver = match config {
-        SignerKind::Auto => {
-            if let Some(announcement) = receiver.announcement().as_ref() {
+    let receiver_key = match config {
+        SignerKind::Auto => match receiver.announcement().as_ref() {
+            Some(announcement) => {
                 extra_tags.push(Tag::public_key(receiver.public_key()));
                 announcement.public_key()
-            } else {
-                receiver.public_key()
             }
-        }
-        SignerKind::Encryption => {
-            if let Some(announcement) = receiver.announcement().as_ref() {
+            None => receiver.public_key(),
+        },
+        SignerKind::Encryption => match receiver.announcement().as_ref() {
+            Some(announcement) => {
                 extra_tags.push(Tag::public_key(receiver.public_key()));
                 announcement.public_key()
-            } else {
-                return Err(anyhow!("User has no encryption announcement"));
             }
-        }
+            None => return Err(anyhow!("User has no encryption announcement")),
+        },
         SignerKind::User => receiver.public_key(),
     };
 
-    // Construct the gift wrap event
-    let event = nip59::GiftWrapBuilder::new(receiver, rumor.clone())
-        .extra_tags(extra_tags)
-        .finalize_async(signer)
-        .await?;
+    // Make sure the rumor carries an event ID before it's serialized
+    let mut rumor = rumor.clone();
+    rumor.ensure_id();
 
-    // Send the gift wrap event and collect the report
-    let report = client
+    let rumor_json = rumor.as_json();
+    let has_encryption_announcement = receiver.announcement().is_some();
+
+    let seal: Event = match (encryption_signer, has_encryption_announcement) {
+        (Some(encryption_signer), true) => {
+            let encryption_pubkey = encryption_signer.get_public_key_async().await?;
+            let content = encryption_signer
+                .nip44_encrypt_async(&receiver_key, &rumor_json)
+                .await?;
+
+            EventBuilder::new(Kind::Seal, content)
+                .tags(vec![Tag::custom("n", [encryption_pubkey.to_hex()])])
+                .custom_created_at(tweaked_timestamp())
+                .finalize_async(user_signer)
+                .await?
+        }
+        _ => {
+            let content = user_signer
+                .nip44_encrypt_async(&receiver_key, &rumor_json)
+                .await?;
+
+            EventBuilder::new(Kind::Seal, content)
+                .custom_created_at(tweaked_timestamp())
+                .finalize_async(user_signer)
+                .await?
+        }
+    };
+
+    let ephemeral_keys = Keys::generate();
+    let content = nip44::encrypt(
+        ephemeral_keys.secret_key(),
+        &receiver_key,
+        seal.as_json(),
+        nip44::Version::default(),
+    )?;
+    extra_tags.push(Tag::public_key(receiver_key));
+
+    let event = EventBuilder::new(Kind::GiftWrap, content)
+        .tags(extra_tags)
+        .custom_created_at(tweaked_timestamp())
+        .finalize(&ephemeral_keys)?;
+
+    // Send to the receiver's NIP-17 relays.
+    client
         .send_event(&event)
         .to_nip17()
-        .ack_policy(AckPolicy::none())
         .await
-        .map(|output| {
-            SendReport::new(receiver)
-                .gift_wrap_id(event.id)
-                .output(output)
-        })?;
+        .map_err(Into::into)
+}
 
-    Ok(report)
+/// A tweaked timestamp to thwart time-analysis attacks, per NIP-59
+fn tweaked_timestamp() -> Timestamp {
+    const MAX_TWEAK_SECONDS: u64 = 2 * 24 * 60 * 60;
+
+    let seconds = rand::random_range(0..=MAX_TWEAK_SECONDS);
+    Timestamp::from_secs(Timestamp::now().as_secs().saturating_sub(seconds))
 }

crates/chat/src/search.rs

@@ -0,0 +1,133 @@
+use std::cmp::Reverse;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use common::EventExt;
+use nostr_sdk::prelude::*;
+
+/// A chat message kept in memory for content search.
+#[derive(Debug, Clone)]
+pub struct SearchMessage {
+    /// ID of the room the message belongs to
+    pub room: u64,
+    /// Author of the message
+    pub author: PublicKey,
+    /// The content of the message
+    pub content: Arc<str>,
+    /// When the message was created
+    pub created_at: Timestamp,
+}
+
+#[derive(Debug)]
+struct IndexedMessage {
+    message: SearchMessage,
+    /// Lowercase content so repeated searches don't re-allocate per message
+    normalized: Arc<str>,
+}
+
+/// In-memory index of chat message rumors, keyed by room and rumor id.
+#[derive(Debug, Default)]
+pub struct MessageSearchIndex(BTreeMap<u64, BTreeMap<EventId, Arc<IndexedMessage>>>);
+
+impl MessageSearchIndex {
+    /// Index a rumor for search, ignoring reactions and empty content.
+    pub fn insert(&mut self, rumor: &UnsignedEvent) {
+        if !is_chat(rumor.kind) || rumor.content.trim().is_empty() {
+            return;
+        }
+
+        let Some(id) = rumor.id else { return };
+
+        let indexed = Arc::new(IndexedMessage {
+            message: SearchMessage {
+                room: rumor.uniq_id(),
+                author: rumor.pubkey,
+                content: rumor.content.as_str().into(),
+                created_at: rumor.created_at,
+            },
+            normalized: rumor.content.to_lowercase().into(),
+        });
+
+        self.0
+            .entry(rumor.uniq_id())
+            .or_default()
+            .entry(id)
+            .or_insert(indexed);
+    }
+
+    /// Find messages whose content contains all of the terms, newest first.
+    pub fn search(&self, terms: &[String], limit: usize) -> Vec<SearchMessage> {
+        let mut matches: Vec<&Arc<IndexedMessage>> = self
+            .0
+            .values()
+            .flat_map(|messages| messages.values())
+            .filter(|indexed| terms.iter().all(|term| indexed.normalized.contains(term)))
+            .collect();
+
+        matches.sort_by_key(|indexed| Reverse(indexed.message.created_at));
+        matches.truncate(limit);
+
+        matches
+            .into_iter()
+            .map(|indexed| indexed.message.clone())
+            .collect()
+    }
+
+    /// Drop all indexed messages.
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+}
+
+fn is_chat(kind: Kind) -> bool {
+    kind == Kind::PrivateDirectMessage || kind == Kind::Custom(15)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rumor(kind: Kind, content: &str, created_at: u64) -> UnsignedEvent {
+        let sender = Keys::generate();
+        let peer = Keys::generate().public_key();
+
+        let mut rumor = EventBuilder::new(kind, content)
+            .tag(Tag::public_key(peer))
+            .finalize_unsigned(sender.public_key());
+        rumor.ensure_id();
+        rumor.created_at = Timestamp::from(created_at);
+        rumor
+    }
+
+    #[test]
+    fn search_matches_all_terms_newest_first_and_deduplicates() {
+        let mut index = MessageSearchIndex::default();
+        let first = rumor(Kind::PrivateDirectMessage, "Hello ALICE", 10);
+        let second = rumor(Kind::PrivateDirectMessage, "hello again", 20);
+        let reaction = rumor(Kind::Reaction, "hello world", 30);
+
+        index.insert(&first);
+        index.insert(&first);
+        index.insert(&second);
+        index.insert(&reaction);
+
+        let hits = index.search(&["hello".to_owned()], 10);
+        assert_eq!(hits.len(), 2);
+        assert_eq!(&*hits[0].content, "hello again");
+        assert_eq!(hits[0].created_at, Timestamp::from(20));
+
+        let hits = index.search(&["hello".to_owned(), "again".to_owned()], 10);
+        assert_eq!(hits.len(), 1);
+
+        let hits = index.search(&["hello".to_owned()], 1);
+        assert_eq!(hits.len(), 1);
+    }
+
+    #[test]
+    fn empty_content_is_not_indexed() {
+        let mut index = MessageSearchIndex::default();
+        index.insert(&rumor(Kind::PrivateDirectMessage, "   ", 10));
+
+        assert!(index.search(&["hello".to_owned()], 10).is_empty());
+    }
+}

crates/chat_ui/Cargo.toml

@@ -18,12 +18,6 @@ nostr-sdk.workspace = true
 anyhow.workspace = true
 itertools.workspace = true
 smallvec.workspace = true
-flume.workspace = true
-futures.workspace = true
-log.workspace = true
 serde.workspace = true
 
-linkify = "0.10.0"
-pulldown-cmark = "0.13.1"
 regex = "1"
-

crates/chat_ui/src/actions.rs

@@ -6,7 +6,7 @@ use settings::SignerKind;
 #[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 #[action(namespace = chat, no_json)]
 pub enum Command {
-    Insert(&'static str),
+    Insert(String),
     ChangeSubject(String),
     ChangeSigner(SignerKind),
     ToggleBackup,

crates/chat_ui/src/file.rs

@@ -0,0 +1,32 @@
+use std::path::{Path, PathBuf};
+
+use chat::FileAttachment;
+use gpui::SharedString;
+use nostr_sdk::prelude::*;
+
+/// A file attachment that has been uploaded, but not sent yet.
+///
+/// The local `path` is kept around so the composer can preview
+/// the file without downloading and decrypting it again.
+pub(crate) struct PendingFile {
+    pub file: FileAttachment,
+    pub path: PathBuf,
+}
+
+/// State of the encrypted file attachment of a message
+pub(crate) enum DecryptedFile {
+    Loading,
+    Ready(PathBuf),
+    Failed(SharedString),
+}
+
+/// Result of an upload, either plain or encrypted
+pub(crate) enum Uploaded {
+    Url(Url),
+    File(FileAttachment, PathBuf),
+}
+
+/// A `file://` url for a decrypted file, so it can be opened by the OS
+pub(crate) fn file_url(path: &Path) -> String {
+    format!("file://{}", path.display())
+}

crates/chat_ui/src/text.rs

@@ -1,399 +1,63 @@
-use std::ops::Range;
-use std::sync::Arc;
+use chat::{Mention, nevent_refs};
+use gpui::{App, Entity};
+use nostr_sdk::prelude::Url;
+use person::Directory;
+use ui::markdown::InlineReplacement;
+pub use ui::markdown::RenderedText;
 
-use chat::Mention;
-use common::RangeExt;
-use gpui::{
-    AnyElement, App, ElementId, Entity, FontStyle, FontWeight, HighlightStyle, InteractiveText,
-    IntoElement, SharedString, StrikethroughStyle, StyledText, UnderlineStyle, Window,
-};
-use person::PersonRegistry;
-use theme::ActiveTheme;
-
-#[allow(clippy::enum_variant_names)]
-#[allow(dead_code)]
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Highlight {
-    Code,
-    InlineCode(bool),
-    Highlight(HighlightStyle),
-    Mention,
-}
-
-impl From<HighlightStyle> for Highlight {
-    fn from(style: HighlightStyle) -> Self {
-        Self::Highlight(style)
-    }
-}
-
-#[derive(Default)]
-pub struct RenderedText {
-    pub text: SharedString,
-    pub highlights: Vec<(Range<usize>, Highlight)>,
-    pub link_ranges: Vec<Range<usize>>,
-    pub link_urls: Arc<[String]>,
-}
-
-impl RenderedText {
-    pub fn new(
-        content: &str,
-        mentions: &[Mention],
-        persons: &Entity<PersonRegistry>,
-        cx: &App,
-    ) -> Self {
-        let mut text = String::new();
-        let mut highlights = Vec::new();
-        let mut link_ranges = Vec::new();
-        let mut link_urls = Vec::new();
-
-        render_plain_text_mut(
-            content,
-            mentions,
-            &mut text,
-            &mut highlights,
-            &mut link_ranges,
-            &mut link_urls,
-            persons,
-            cx,
-        );
-
-        text.truncate(text.trim_end().len());
-
-        RenderedText {
-            text: SharedString::from(text),
-            link_urls: link_urls.into(),
-            link_ranges,
-            highlights,
-        }
-    }
-
-    pub fn element(&self, id: ElementId, window: &Window, cx: &App) -> AnyElement {
-        let code_background = cx.theme().elevated_surface_background;
-        let color = cx.theme().text_accent;
-
-        InteractiveText::new(
-            id,
-            StyledText::new(self.text.clone()).with_default_highlights(
-                &window.text_style(),
-                self.highlights.iter().map(|(range, highlight)| {
-                    (
-                        range.clone(),
-                        match highlight {
-                            Highlight::Code => HighlightStyle {
-                                background_color: Some(code_background),
-                                ..Default::default()
-                            },
-                            Highlight::InlineCode(link) => {
-                                if *link {
-                                    HighlightStyle {
-                                        background_color: Some(code_background),
-                                        underline: Some(UnderlineStyle {
-                                            thickness: 1.0.into(),
-                                            ..Default::default()
-                                        }),
-                                        ..Default::default()
-                                    }
-                                } else {
-                                    HighlightStyle {
-                                        background_color: Some(code_background),
-                                        ..Default::default()
-                                    }
-                                }
-                            }
-                            Highlight::Mention => HighlightStyle {
-                                color: Some(color),
-                                underline: Some(UnderlineStyle {
-                                    thickness: 1.0.into(),
-                                    ..Default::default()
-                                }),
-                                ..Default::default()
-                            },
-                            Highlight::Highlight(highlight) => *highlight,
-                        },
-                    )
-                }),
-            ),
-        )
-        .on_click(self.link_ranges.clone(), {
-            let link_urls = self.link_urls.clone();
-            move |ix, _, cx| {
-                let url = &link_urls[ix];
-                if url.starts_with("http") {
-                    cx.open_url(url);
-                }
-            }
-        })
-        .into_any_element()
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-fn render_plain_text_mut(
-    block: &str,
-    mut mentions: &[Mention],
-    text: &mut String,
-    highlights: &mut Vec<(Range<usize>, Highlight)>,
-    link_ranges: &mut Vec<Range<usize>>,
-    link_urls: &mut Vec<String>,
-    persons: &Entity<PersonRegistry>,
+pub fn rendered_text(
+    content: &str,
+    mentions: &[Mention],
+    emojis: &[(String, Url)],
+    persons: &Entity<Directory>,
     cx: &App,
-) {
-    use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
+) -> RenderedText {
+    let mut replacements = mentions
+        .iter()
+        .map(|mention| {
+            InlineReplacement::new(
+                mention.range.clone(),
+                format!(
+                    "@{}",
+                    persons.read(cx).person(&mention.public_key, cx).name()
+                ),
+            )
+        })
+        .collect::<Vec<_>>();
 
-    let mut bold_depth = 0;
-    let mut italic_depth = 0;
-    let mut strikethrough_depth = 0;
-    let mut link_url = None;
-    let mut list_stack = Vec::new();
+    replacements.extend(emoji_replacements(content, emojis));
+    replacements.extend(
+        nevent_refs(content)
+            .into_iter()
+            .map(|reference| InlineReplacement::new(reference.range, reference.label)),
+    );
+    replacements.sort_by_key(|replacement| replacement.range.start);
 
-    let mut options = Options::all();
-    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
-
-    for (event, source_range) in Parser::new_ext(block, options).into_offset_iter() {
-        let prev_len = text.len();
-
-        match event {
-            Event::Text(t) => {
-                // Process text with mention replacements
-                let t_str = t.as_ref();
-                let mut last_processed = 0;
-
-                while let Some(mention) = mentions.first() {
-                    if !source_range.contains_inclusive(&mention.range) {
-                        break;
-                    }
-
-                    // Calculate positions within the current text
-                    let mention_start_in_text = mention.range.start - source_range.start;
-                    let mention_end_in_text = mention.range.end - source_range.start;
-
-                    // Add text before this mention
-                    if mention_start_in_text > last_processed {
-                        let before_mention = &t_str[last_processed..mention_start_in_text];
-                        process_text_segment(
-                            before_mention,
-                            prev_len + last_processed,
-                            bold_depth,
-                            italic_depth,
-                            strikethrough_depth,
-                            link_url.clone(),
-                            text,
-                            highlights,
-                            link_ranges,
-                            link_urls,
-                        );
-                    }
-
-                    // Process the mention replacement
-                    let profile = persons.read(cx).get(&mention.public_key, cx);
-                    let replacement_text = format!("@{}", profile.name());
-
-                    let replacement_start = text.len();
-                    text.push_str(&replacement_text);
-                    let replacement_end = text.len();
-
-                    highlights.push((replacement_start..replacement_end, Highlight::Mention));
-
-                    last_processed = mention_end_in_text;
-                    mentions = &mentions[1..];
-                }
-
-                // Add any remaining text after the last mention
-                if last_processed < t_str.len() {
-                    let remaining_text = &t_str[last_processed..];
-                    process_text_segment(
-                        remaining_text,
-                        prev_len + last_processed,
-                        bold_depth,
-                        italic_depth,
-                        strikethrough_depth,
-                        link_url.clone(),
-                        text,
-                        highlights,
-                        link_ranges,
-                        link_urls,
-                    );
-                }
-            }
-            Event::Code(t) => {
-                text.push_str(t.as_ref());
-                let is_link = link_url.is_some();
-
-                if let Some(link_url) = link_url.clone() {
-                    link_ranges.push(prev_len..text.len());
-                    link_urls.push(link_url);
-                }
-
-                highlights.push((prev_len..text.len(), Highlight::InlineCode(is_link)))
-            }
-            Event::Start(tag) => match tag {
-                Tag::Paragraph => new_paragraph(text, &mut list_stack),
-                Tag::Heading { .. } => {
-                    new_paragraph(text, &mut list_stack);
-                    bold_depth += 1;
-                }
-                Tag::CodeBlock(_kind) => {
-                    new_paragraph(text, &mut list_stack);
-                }
-                Tag::Emphasis => italic_depth += 1,
-                Tag::Strong => bold_depth += 1,
-                Tag::Strikethrough => strikethrough_depth += 1,
-                Tag::Link { dest_url, .. } => link_url = Some(dest_url.to_string()),
-                Tag::List(number) => {
-                    list_stack.push((number, false));
-                }
-                Tag::Item => {
-                    let len = list_stack.len();
-                    if let Some((list_number, has_content)) = list_stack.last_mut() {
-                        *has_content = false;
-                        if !text.is_empty() && !text.ends_with('\n') {
-                            text.push('\n');
-                        }
-                        for _ in 0..len - 1 {
-                            text.push_str("  ");
-                        }
-                        if let Some(number) = list_number {
-                            text.push_str(&format!("{}. ", number));
-                            *number += 1;
-                            *has_content = false;
-                        } else {
-                            text.push_str("- ");
-                        }
-                    }
-                }
-                _ => {}
-            },
-            Event::End(tag) => match tag {
-                TagEnd::Heading(_) => bold_depth -= 1,
-                TagEnd::Emphasis => italic_depth -= 1,
-                TagEnd::Strong => bold_depth -= 1,
-                TagEnd::Strikethrough => strikethrough_depth -= 1,
-                TagEnd::Link => link_url = None,
-                TagEnd::List(_) => drop(list_stack.pop()),
-                _ => {}
-            },
-            Event::HardBreak => text.push('\n'),
-            Event::SoftBreak => text.push('\n'),
-            _ => {}
-        }
-    }
+    RenderedText::new(content, &replacements)
 }
 
-#[allow(clippy::too_many_arguments)]
-fn process_text_segment(
-    segment: &str,
-    segment_start: usize,
-    bold_depth: i32,
-    italic_depth: i32,
-    strikethrough_depth: i32,
-    link_url: Option<String>,
-    text: &mut String,
-    highlights: &mut Vec<(Range<usize>, Highlight)>,
-    link_ranges: &mut Vec<Range<usize>>,
-    link_urls: &mut Vec<String>,
-) {
-    // Build the style for this segment
-    let mut style = HighlightStyle::default();
-    if bold_depth > 0 {
-        style.font_weight = Some(FontWeight::BOLD);
-    }
-    if italic_depth > 0 {
-        style.font_style = Some(FontStyle::Italic);
-    }
-    if strikethrough_depth > 0 {
-        style.strikethrough = Some(StrikethroughStyle {
-            thickness: 1.0.into(),
-            ..Default::default()
-        });
-    }
+fn emoji_replacements(content: &str, emojis: &[(String, Url)]) -> Vec<InlineReplacement> {
+    let mut replacements = Vec::new();
 
-    // Add the text
-    text.push_str(segment);
-    let text_end = text.len();
+    for (shortcode, url) in emojis {
+        let pattern = format!(":{shortcode}:");
+        for (start, _) in content.match_indices(&pattern) {
+            let range = start..start + pattern.len();
 
-    if let Some(link_url) = link_url {
-        // Handle as a markdown link
-        link_ranges.push(segment_start..text_end);
-        link_urls.push(link_url);
-        style.underline = Some(UnderlineStyle {
-            thickness: 1.0.into(),
-            ..Default::default()
-        });
-
-        // Add highlight for the entire linked segment
-        if style != HighlightStyle::default() {
-            highlights.push((segment_start..text_end, Highlight::Highlight(style)));
-        }
-    } else {
-        // Handle link detection within the segment
-        let mut finder = linkify::LinkFinder::new();
-        finder.kinds(&[linkify::LinkKind::Url]);
-        let mut last_link_pos = 0;
-
-        for link in finder.links(segment) {
-            let start = link.start();
-            let end = link.end();
-
-            // Add non-link text before this link
-            if start > last_link_pos {
-                let non_link_start = segment_start + last_link_pos;
-                let non_link_end = segment_start + start;
-
-                if style != HighlightStyle::default() {
-                    highlights.push((non_link_start..non_link_end, Highlight::Highlight(style)));
-                }
+            // Skip matches glued to word characters, like the `30` in `12:30:45`
+            if content[..start].ends_with(char::is_alphanumeric)
+                || content[range.end..].starts_with(char::is_alphanumeric)
+            {
+                continue;
             }
 
-            // Add the link
-            let range = (segment_start + start)..(segment_start + end);
-            link_ranges.push(range.clone());
-            link_urls.push(link.as_str().to_string());
-
-            // Apply link styling (underline + existing style)
-            let mut link_style = style;
-            link_style.underline = Some(UnderlineStyle {
-                thickness: 1.0.into(),
-                ..Default::default()
-            });
-
-            highlights.push((range, Highlight::Highlight(link_style)));
-
-            last_link_pos = end;
-        }
-
-        // Add any remaining text after the last link
-        if last_link_pos < segment.len() {
-            let remaining_start = segment_start + last_link_pos;
-            let remaining_end = segment_start + segment.len();
-
-            if style != HighlightStyle::default() {
-                highlights.push((remaining_start..remaining_end, Highlight::Highlight(style)));
-            }
+            replacements.push(InlineReplacement::image(
+                range,
+                shortcode.clone(),
+                url.to_string(),
+            ));
         }
     }
-}
 
-fn new_paragraph(text: &mut String, list_stack: &mut [(Option<u64>, bool)]) {
-    let mut is_subsequent_paragraph_of_list = false;
-    if let Some((_, has_content)) = list_stack.last_mut() {
-        if *has_content {
-            is_subsequent_paragraph_of_list = true;
-        } else {
-            *has_content = true;
-            return;
-        }
-    }
-
-    if !text.is_empty() {
-        if !text.ends_with('\n') {
-            text.push('\n');
-        }
-        text.push('\n');
-    }
-    for _ in 0..list_stack.len().saturating_sub(1) {
-        text.push_str("  ");
-    }
-    if is_subsequent_paragraph_of_list {
-        text.push_str("  ");
-    }
+    replacements
 }

crates/common/Cargo.toml

@@ -13,8 +13,6 @@ nostr-sdk.workspace = true
 itertools.workspace = true
 chrono.workspace = true
 futures.workspace = true
-log.workspace = true
 
 dirs = "5.0"
-qrcode = "0.14.1"
 regex = "1.10"

crates/common/src/caching.rs

@@ -1,135 +0,0 @@
-use std::collections::{HashMap, VecDeque};
-use std::mem::take;
-
-use futures::FutureExt;
-use gpui::{
-    App, AppContext, Asset, AssetLogger, ElementId, Entity, ImageAssetLoader, ImageCache,
-    ImageCacheItem, ImageCacheProvider, ImageSource, Resource, hash,
-};
-
-pub fn coop_cache(id: impl Into<ElementId>, max_items: usize) -> CoopImageCacheProvider {
-    CoopImageCacheProvider {
-        id: id.into(),
-        max_items,
-    }
-}
-
-pub struct CoopImageCacheProvider {
-    id: ElementId,
-    max_items: usize,
-}
-
-impl ImageCacheProvider for CoopImageCacheProvider {
-    fn provide(&mut self, window: &mut gpui::Window, cx: &mut App) -> gpui::AnyImageCache {
-        window
-            .with_global_id(self.id.clone(), |id, window| {
-                window.with_element_state(id, |cache, _| {
-                    let cache = cache.unwrap_or_else(|| CoopImageCache::new(self.max_items, cx));
-                    (cache.clone(), cache)
-                })
-            })
-            .into()
-    }
-}
-
-pub struct CoopImageCache {
-    max_items: usize,
-    usage_list: VecDeque<u64>,
-    cache: HashMap<u64, (ImageCacheItem, Resource)>,
-}
-
-impl CoopImageCache {
-    pub fn new(max_items: usize, cx: &mut App) -> Entity<Self> {
-        cx.new(|cx| {
-            log::info!("Creating CoopImageCache");
-            cx.on_release(|this: &mut Self, cx| {
-                for (ix, (mut image, resource)) in take(&mut this.cache) {
-                    if let Some(Ok(image)) = image.get() {
-                        log::info!("Dropping image {ix}");
-                        cx.drop_image(image, None);
-                    }
-                    ImageSource::Resource(resource).remove_asset(cx);
-                }
-            })
-            .detach();
-
-            CoopImageCache {
-                max_items,
-                usage_list: VecDeque::with_capacity(max_items),
-                cache: HashMap::with_capacity(max_items),
-            }
-        })
-    }
-}
-
-impl ImageCache for CoopImageCache {
-    fn load(
-        &mut self,
-        resource: &Resource,
-        window: &mut gpui::Window,
-        cx: &mut gpui::App,
-    ) -> Option<Result<std::sync::Arc<gpui::RenderImage>, gpui::ImageCacheError>> {
-        let hash = hash(resource);
-
-        if let Some(item) = self.cache.get_mut(&hash) {
-            let current_idx = self
-                .usage_list
-                .iter()
-                .position(|item| *item == hash)
-                .expect("cache has an item usage_list doesn't");
-
-            self.usage_list.remove(current_idx);
-            self.usage_list.push_front(hash);
-
-            return item.0.get();
-        }
-
-        let load_future = AssetLogger::<ImageAssetLoader>::load(resource.clone(), cx);
-        let task = cx.background_executor().spawn(load_future).shared();
-
-        if self.usage_list.len() >= self.max_items {
-            log::info!("Image cache is full, evicting oldest item");
-
-            if let Some(oldest) = self.usage_list.pop_back() {
-                let mut image = self
-                    .cache
-                    .remove(&oldest)
-                    .expect("usage_list has an item cache doesn't");
-
-                if let Some(Ok(image)) = image.0.get() {
-                    log::info!("requesting image to be dropped");
-                    cx.drop_image(image, Some(window));
-                }
-
-                ImageSource::Resource(image.1).remove_asset(cx);
-            }
-        }
-
-        self.cache.insert(
-            hash,
-            (
-                gpui::ImageCacheItem::Loading(task.clone()),
-                resource.clone(),
-            ),
-        );
-        self.usage_list.push_front(hash);
-
-        let entity = window.current_view();
-
-        window
-            .spawn(cx, async move |cx| {
-                let result = task.await;
-
-                if let Err(err) = result {
-                    log::error!("error loading image into cache: {:?}", err);
-                }
-
-                cx.on_next_frame(move |_, cx| {
-                    cx.notify(entity);
-                });
-            })
-            .detach();
-
-        None
-    }
-}

crates/common/src/debounced_delay.rs

@@ -1,9 +1,9 @@
 use std::marker::PhantomData;
-use instant::Duration;
 
-use futures::channel::oneshot;
 use futures::FutureExt;
+use futures::channel::oneshot;
 use gpui::{Context, Task, Window};
+use instant::Duration;
 
 pub struct DebouncedDelay<E: 'static> {
     task: Option<Task<()>>,
@@ -11,12 +11,6 @@ pub struct DebouncedDelay<E: 'static> {
     _phantom_data: PhantomData<E>,
 }
 
-impl<E: 'static> Default for DebouncedDelay<E> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl<E: 'static> DebouncedDelay<E> {
     pub fn new() -> Self {
         Self {
@@ -64,3 +58,9 @@ impl<E: 'static> DebouncedDelay<E> {
         }));
     }
 }
+
+impl<E: 'static> Default for DebouncedDelay<E> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/common/src/display.rs

@@ -1,10 +1,6 @@
-use std::sync::Arc;
-
 use chrono::{Local, TimeZone};
-use gpui::{Image, ImageFormat, SharedString};
+use gpui::SharedString;
 use nostr_sdk::prelude::*;
-use qrcode::QrCode;
-use qrcode::render::svg;
 
 const NOW: &str = "now";
 const SECONDS_IN_MINUTE: i64 = 60;
@@ -59,25 +55,3 @@ impl TimestampExt for Timestamp {
         }
     }
 }
-
-pub trait StringExt {
-    fn to_qr(&self) -> Option<Arc<Image>>;
-}
-
-impl<T: AsRef<str>> StringExt for T {
-    fn to_qr(&self) -> Option<Arc<Image>> {
-        let s = self.as_ref();
-        let code = QrCode::new(s).unwrap();
-        let svg = code
-            .render()
-            .min_dimensions(256, 256)
-            .dark_color(svg::Color("#000000"))
-            .light_color(svg::Color("#FFFFFF"))
-            .build();
-
-        Some(Arc::new(Image::from_bytes(
-            ImageFormat::Svg,
-            svg.into_bytes(),
-        )))
-    }
-}

crates/common/src/event.rs

@@ -51,3 +51,53 @@ impl EventExt for UnsignedEvent {
         public_keys.into_iter().unique().sorted().collect()
     }
 }
+
+/// Custom emoji (NIP-30) declared by `emoji` tags, first per shortcode wins
+pub fn emojis_from_tags(tags: &Tags) -> Vec<(String, Url)> {
+    let mut emojis: Vec<(String, Url)> = Vec::new();
+
+    for tag in tags.iter() {
+        let Ok(Nip30Tag::Emoji {
+            shortcode,
+            image_url,
+            ..
+        }) = Nip30Tag::try_from(tag)
+        else {
+            continue;
+        };
+
+        if !emojis.iter().any(|(existing, _)| *existing == shortcode) {
+            emojis.push((shortcode, image_url));
+        }
+    }
+
+    emojis
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn emojis_from_tags_parses_and_deduplicates() {
+        let tags = Tags::from_list(vec![
+            Tag::parse(vec!["emoji", "soapbox", "https://example.com/soapbox.png"]).unwrap(),
+            Tag::parse(vec!["emoji", "soapbox", "https://example.com/other.png"]).unwrap(),
+            Tag::parse(vec![
+                "emoji",
+                "bad shortcode",
+                "https://example.com/bad.png",
+            ])
+            .unwrap(),
+        ]);
+
+        let emojis = emojis_from_tags(&tags);
+
+        assert_eq!(emojis.len(), 1);
+        assert_eq!(emojis[0].0, "soapbox");
+        assert_eq!(
+            emojis[0].1,
+            Url::parse("https://example.com/soapbox.png").unwrap()
+        );
+    }
+}

crates/common/src/lib.rs

@@ -1,17 +1,13 @@
-pub use caching::*;
 pub use debounced_delay::*;
 pub use display::*;
 pub use event::*;
 pub use media_extractor::*;
 pub use parser::*;
 pub use paths::*;
-pub use range::*;
 
-mod caching;
 mod debounced_delay;
 mod display;
 mod event;
 mod media_extractor;
 mod parser;
 mod paths;
-mod range;

crates/common/src/media_extractor.rs

@@ -1,30 +1,25 @@
 use gpui::SharedUri;
 use regex::Regex;
 
-/// Extracts media URLs from a string and returns both the extracted URLs
-/// and the string with media URLs removed
-pub struct MediaExtractor {
+/// Extracts media URLs from a string and returns both
+/// the extracted URLs and the string with media URLs removed
+struct MediaExtractor {
     image_regex: Regex,
-    video_regex: Regex,
 }
 
 impl MediaExtractor {
     /// Creates a new MediaExtractor with compiled regex patterns
-    pub fn new() -> Self {
+    fn new() -> Self {
         MediaExtractor {
             // Match common image extensions
             image_regex: Regex::new(
                 r#"(?i)\bhttps?://[^\s<>"']+\.(?:jpg|jpeg|png|gif|bmp|webp|svg|ico)(?:\?[^\s<>"']*)?\b"#,
             ).unwrap(),
-            // Match common video extensions
-            video_regex: Regex::new(
-                r#"(?i)\bhttps?://[^\s<>"']+\.(?:mp4|mov|avi|mkv|webm|flv|wmv|m4v|3gp)(?:\?[^\s<>"']*)?\b"#,
-            ).unwrap(),
         }
     }
 
     /// Extracts all media URLs from a string
-    pub fn extract_media_urls(&self, text: &str) -> Vec<SharedUri> {
+    fn extract_media_urls(&self, text: &str) -> Vec<SharedUri> {
         let mut urls = Vec::new();
 
         // Extract image URLs
@@ -32,30 +27,22 @@ impl MediaExtractor {
             urls.push(capture.as_str().to_string().into());
         }
 
-        // Extract video URLs
-        // for capture in self.video_regex.find_iter(text) {
-        //     urls.push(capture.as_str().to_string().into());
-        // }
-
         urls
     }
 
     /// Removes all media URLs from a string and returns the cleaned text
-    pub fn remove_media_urls(&self, text: &str) -> String {
+    fn remove_media_urls(&self, text: &str) -> String {
         let mut result = text.to_string();
 
         // Remove image URLs
         result = self.image_regex.replace_all(&result, "").to_string();
 
-        // Remove video URLs
-        // result = self.video_regex.replace_all(&result, "").to_string();
-
         // Clean up extra whitespace that might result from removal
         self.cleanup_text(&result)
     }
 
     /// Extracts media URLs and removes them from the string, returning both
-    pub fn extract_and_remove(&self, text: &str) -> (Vec<SharedUri>, String) {
+    fn extract_and_remove(&self, text: &str) -> (Vec<SharedUri>, String) {
         let urls = self.extract_media_urls(text);
         let cleaned_text = self.remove_media_urls(text);
         (urls, cleaned_text)
@@ -69,33 +56,6 @@ impl MediaExtractor {
         let re = Regex::new(r"\s+").unwrap();
         re.replace_all(text, " ").trim().to_string()
     }
-
-    /// Validates if a URL is a valid media URL
-    pub fn is_media_url(&self, url: &str) -> bool {
-        self.image_regex.is_match(url) || self.video_regex.is_match(url)
-    }
-
-    /// Categorizes extracted URLs into images and videos
-    pub fn categorize_urls(&self, urls: &[SharedUri]) -> (Vec<SharedUri>, Vec<SharedUri>) {
-        let mut images = Vec::new();
-        let mut videos = Vec::new();
-
-        for url in urls {
-            if self.image_regex.is_match(url) {
-                images.push(url.clone());
-            } else if self.video_regex.is_match(url) {
-                videos.push(url.clone());
-            }
-        }
-
-        (images, videos)
-    }
-}
-
-impl Default for MediaExtractor {
-    fn default() -> Self {
-        Self::new()
-    }
 }
 
 /// Convenience function for one-time extraction and removal
@@ -103,15 +63,3 @@ pub fn extract_and_remove_media_urls(text: &str) -> (Vec<SharedUri>, String) {
     let extractor = MediaExtractor::new();
     extractor.extract_and_remove(text)
 }
-
-/// Convenience function for just extracting media URLs
-pub fn extract_media_urls(text: &str) -> Vec<SharedUri> {
-    let extractor = MediaExtractor::new();
-    extractor.extract_media_urls(text)
-}
-
-/// Convenience function for just removing media URLs
-pub fn remove_media_urls(text: &str) -> String {
-    let extractor = MediaExtractor::new();
-    extractor.remove_media_urls(text)
-}

crates/common/src/parser.rs

@@ -26,12 +26,6 @@ struct Match {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct NostrParser;
 
-impl Default for NostrParser {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl NostrParser {
     /// Create new parser
     pub const fn new() -> Self {
@@ -44,6 +38,12 @@ impl NostrParser {
     }
 }
 
+impl Default for NostrParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 struct FindMatches<'a> {
     bytes: &'a [u8],
     pos: usize,

crates/common/src/paths.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 use std::sync::OnceLock;
 
 /// Returns the path to the user's home directory.
-pub fn home_dir() -> &'static PathBuf {
+fn home_dir() -> &'static PathBuf {
     static HOME_DIR: OnceLock<PathBuf> = OnceLock::new();
     HOME_DIR.get_or_init(|| dirs::home_dir().expect("failed to determine home directory"))
 }
@@ -36,30 +36,3 @@ pub fn config_dir() -> &'static PathBuf {
         home_dir().join(".config").join("coop")
     })
 }
-
-/// Returns the path to the support directory used by Coop.
-pub fn support_dir() -> &'static PathBuf {
-    static SUPPORT_DIR: OnceLock<PathBuf> = OnceLock::new();
-    SUPPORT_DIR.get_or_init(|| {
-        if cfg!(target_os = "macos") {
-            return home_dir().join("Library/Application Support/Coop");
-        }
-
-        if cfg!(any(target_os = "linux", target_os = "freebsd")) {
-            return if let Ok(flatpak_xdg_data) = std::env::var("FLATPAK_XDG_DATA_HOME") {
-                flatpak_xdg_data.into()
-            } else {
-                dirs::data_local_dir().expect("failed to determine XDG_DATA_HOME directory")
-            }
-            .join("coop");
-        }
-
-        if cfg!(target_os = "windows") {
-            return dirs::data_local_dir()
-                .expect("failed to determine LocalAppData directory")
-                .join("coop");
-        }
-
-        config_dir().clone()
-    })
-}

crates/common/src/range.rs

@@ -1,45 +0,0 @@
-use std::cmp::{self};
-use std::ops::{Range, RangeInclusive};
-
-pub trait RangeExt<T> {
-    fn sorted(&self) -> Self;
-    fn to_inclusive(&self) -> RangeInclusive<T>;
-    fn overlaps(&self, other: &Range<T>) -> bool;
-    fn contains_inclusive(&self, other: &Range<T>) -> bool;
-}
-
-impl<T: Ord + Clone> RangeExt<T> for Range<T> {
-    fn sorted(&self) -> Self {
-        cmp::min(&self.start, &self.end).clone()..cmp::max(&self.start, &self.end).clone()
-    }
-
-    fn to_inclusive(&self) -> RangeInclusive<T> {
-        self.start.clone()..=self.end.clone()
-    }
-
-    fn overlaps(&self, other: &Range<T>) -> bool {
-        self.start < other.end && other.start < self.end
-    }
-
-    fn contains_inclusive(&self, other: &Range<T>) -> bool {
-        self.start <= other.start && other.end <= self.end
-    }
-}
-
-impl<T: Ord + Clone> RangeExt<T> for RangeInclusive<T> {
-    fn sorted(&self) -> Self {
-        cmp::min(self.start(), self.end()).clone()..=cmp::max(self.start(), self.end()).clone()
-    }
-
-    fn to_inclusive(&self) -> RangeInclusive<T> {
-        self.clone()
-    }
-
-    fn overlaps(&self, other: &Range<T>) -> bool {
-        self.start() < &other.end && &other.start <= self.end()
-    }
-
-    fn contains_inclusive(&self, other: &Range<T>) -> bool {
-        self.start() <= &other.start && &other.end <= self.end()
-    }
-}

crates/gpui_tokio/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "gpui_tokio"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+gpui.workspace = true
+gpui_util.workspace = true
+tokio = { version = "1", features = ["rt", "rt-multi-thread"] }

crates/gpui_tokio/src/lib.rs

@@ -0,0 +1,84 @@
+use std::future::Future;
+
+use gpui::{App, AppContext, Global, Task};
+use gpui_util::defer;
+use tokio::task::JoinError;
+
+/// Initializes the Tokio wrapper using a new Tokio runtime with 2 worker threads.
+pub fn init(cx: &mut App) {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        // Since we now have two executors, let's try to keep our footprint small
+        .worker_threads(2)
+        .enable_all()
+        .build()
+        .expect("Failed to initialize Tokio");
+
+    let handle = runtime.handle().clone();
+    cx.set_global(GlobalTokio {
+        owned_runtime: Some(runtime),
+        handle,
+    });
+}
+
+struct GlobalTokio {
+    owned_runtime: Option<tokio::runtime::Runtime>,
+    handle: tokio::runtime::Handle,
+}
+
+impl Global for GlobalTokio {}
+
+impl Drop for GlobalTokio {
+    fn drop(&mut self) {
+        if let Some(runtime) = self.owned_runtime.take() {
+            runtime.shutdown_background();
+        }
+    }
+}
+
+pub struct Tokio {}
+
+impl Tokio {
+    /// Spawns the given future on Tokio's thread pool, and returns it via a GPUI task
+    /// Note that the Tokio task will be cancelled if the GPUI task is dropped
+    pub fn spawn<C, Fut, R>(cx: &C, f: Fut) -> Task<Result<R, JoinError>>
+    where
+        C: AppContext,
+        Fut: Future<Output = R> + Send + 'static,
+        R: Send + 'static,
+    {
+        cx.read_global(|tokio: &GlobalTokio, cx| {
+            let join_handle = tokio.handle.spawn(f);
+            let abort_handle = join_handle.abort_handle();
+            let cancel = defer(move || {
+                abort_handle.abort();
+            });
+            cx.background_spawn(async move {
+                let result = join_handle.await;
+                drop(cancel);
+                result
+            })
+        })
+    }
+
+    /// Spawns the given future on Tokio's thread pool, and returns it via a GPUI task
+    /// Note that the Tokio task will be cancelled if the GPUI task is dropped
+    pub fn spawn_result<C, Fut, R>(cx: &C, f: Fut) -> Task<anyhow::Result<R>>
+    where
+        C: AppContext,
+        Fut: Future<Output = anyhow::Result<R>> + Send + 'static,
+        R: Send + 'static,
+    {
+        cx.read_global(|tokio: &GlobalTokio, cx| {
+            let join_handle = tokio.handle.spawn(f);
+            let abort_handle = join_handle.abort_handle();
+            let cancel = defer(move || {
+                abort_handle.abort();
+            });
+            cx.background_spawn(async move {
+                let result = join_handle.await?;
+                drop(cancel);
+                result
+            })
+        })
+    }
+}

crates/nip29/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "nip29"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+nostr-sdk.workspace = true
+anyhow.workspace = true
+futures.workspace = true
+serde_json.workspace = true
+state = { path = "../state" }
+common = { path = "../common" }
+person = { path = "../person" }
+chat = { path = "../chat" }
+
+gpui.workspace = true
+flume.workspace = true
+log.workspace = true
+smallvec.workspace = true

crates/nip29/src/discovery.rs

@@ -0,0 +1,287 @@
+use std::collections::{HashMap, HashSet};
+
+use futures::future::join_all;
+use nostr_sdk::prelude::*;
+
+use crate::protocol::{GroupCandidate, GroupId, GroupKey, GroupList, GroupMetadata};
+use crate::utils::parse_members;
+
+#[derive(Default, Clone, Debug)]
+pub struct Discovery {
+    refs: HashMap<RelayUrl, HashSet<GroupId>>,
+    discovered: Vec<GroupCandidate>,
+    members: HashMap<GroupKey, (Timestamp, usize)>,
+}
+
+impl Discovery {
+    /// The discovered groups, sorted by name.
+    pub fn discovered(&self) -> &[GroupCandidate] {
+        &self.discovered
+    }
+
+    /// The member count of a group, when its member list is known.
+    pub fn members(&self, key: &GroupKey) -> Option<usize> {
+        self.members.get(key).map(|(_, members)| *members)
+    }
+
+    /// The (relay, group) references, for asking the relays for metadata.
+    pub(crate) fn refs(&self) -> &HashMap<RelayUrl, HashSet<GroupId>> {
+        &self.refs
+    }
+
+    /// Absorb the references of a group list, skipping the joined groups.
+    pub(crate) fn absorb_list(&mut self, list: &GroupList, joined: &HashSet<(RelayUrl, GroupId)>) {
+        for entry in list.entries() {
+            if joined.contains(&(entry.relay.clone(), entry.id.clone())) {
+                continue;
+            }
+
+            self.refs
+                .entry(entry.relay.clone())
+                .or_default()
+                .insert(entry.id.clone());
+        }
+    }
+
+    /// Absorb the newest group list of every author.
+    pub(crate) fn absorb_lists(
+        &mut self,
+        lists: Vec<Event>,
+        joined: &HashSet<(RelayUrl, GroupId)>,
+    ) {
+        let newest: HashMap<PublicKey, Event> =
+            lists.into_iter().fold(HashMap::new(), |mut newest, event| {
+                match newest.get(&event.pubkey) {
+                    Some(current) if current.created_at >= event.created_at => newest,
+                    _ => {
+                        newest.insert(event.pubkey, event);
+                        newest
+                    }
+                }
+            });
+
+        for event in newest.into_values() {
+            let Ok(list) = GroupList::parse(&event) else {
+                log::warn!("ignoring a malformed group list from {}", event.pubkey);
+                continue;
+            };
+
+            self.absorb_list(&list, joined);
+        }
+    }
+
+    /// Add a discovered group, keeping the newest metadata.
+    pub(crate) fn upsert(&mut self, candidate: GroupCandidate) {
+        match self.discovered.iter_mut().find(|d| d.key == candidate.key) {
+            Some(existing) if existing.created_at <= candidate.created_at => {
+                *existing = candidate;
+            }
+            Some(_) => return,
+            None => self.discovered.push(candidate),
+        }
+
+        self.discovered.sort_by(|a, b| {
+            a.display_name()
+                .to_lowercase()
+                .cmp(&b.display_name().to_lowercase())
+        });
+    }
+
+    /// Apply a member count, keeping the newest list.
+    pub fn set_members(&mut self, key: GroupKey, created_at: Timestamp, members: usize) {
+        if self
+            .members
+            .get(&key)
+            .is_some_and(|(current, _)| *current > created_at)
+        {
+            return;
+        }
+
+        self.members.insert(key, (created_at, members));
+    }
+
+    /// Seed the discoveries from the cached group metadata.
+    pub(crate) fn absorb_cached_previews(&mut self, previews: Vec<Event>) {
+        let newest: HashMap<GroupId, (Timestamp, GroupMetadata)> =
+            previews
+                .into_iter()
+                .fold(HashMap::new(), |mut newest, event| {
+                    let metadata = match GroupMetadata::parse(&event) {
+                        Ok(metadata) => metadata,
+                        Err(error) => {
+                            log::warn!("ignoring malformed cached group metadata: {error}");
+                            return newest;
+                        }
+                    };
+
+                    let Some(id) = metadata.id().cloned() else {
+                        return newest;
+                    };
+
+                    match newest.get(&id) {
+                        Some((created_at, _)) if *created_at >= event.created_at => newest,
+                        _ => {
+                            newest.insert(id, (event.created_at, metadata));
+                            newest
+                        }
+                    }
+                });
+
+        for (relay, ids) in self.refs.clone() {
+            for id in ids {
+                let Some((created_at, metadata)) = newest.get(&id) else {
+                    continue;
+                };
+
+                // Hidden groups are not discoverable (NIP-29).
+                if metadata.hidden {
+                    continue;
+                }
+
+                self.upsert(GroupCandidate {
+                    key: GroupKey::new(relay.clone(), id.clone()),
+                    created_at: *created_at,
+                    metadata: metadata.clone(),
+                });
+            }
+        }
+    }
+
+    /// Seed the member counts from the cached member lists.
+    pub(crate) fn absorb_cached_members(&mut self, members: Vec<Event>) {
+        let newest: HashMap<GroupId, (Timestamp, usize)> =
+            members
+                .into_iter()
+                .fold(HashMap::new(), |mut newest, event| {
+                    let Some((id, created_at, count)) = parse_members(&event) else {
+                        return newest;
+                    };
+
+                    match newest.get(&id) {
+                        Some((current, _)) if *current >= created_at => newest,
+                        _ => {
+                            newest.insert(id, (created_at, count));
+                            newest
+                        }
+                    }
+                });
+
+        for (relay, ids) in self.refs.clone() {
+            for id in ids {
+                let Some((created_at, count)) = newest.get(&id) else {
+                    continue;
+                };
+
+                self.set_members(
+                    GroupKey::new(relay.clone(), id.clone()),
+                    *created_at,
+                    *count,
+                );
+            }
+        }
+    }
+
+    /// Load the discoverable groups from the local database only.
+    pub async fn cached(client: Client, joined: HashSet<(RelayUrl, GroupId)>) -> Self {
+        let mut discovery = Self::default();
+
+        // The group lists of every cached author.
+        let lists: Vec<Event> = client
+            .database()
+            .query(Filter::new().kind(Kind::SimpleGroups))
+            .await
+            .map(|events| events.into_iter().collect())
+            .unwrap_or_default();
+
+        discovery.absorb_lists(lists, &joined);
+
+        let refs = discovery.refs().clone();
+
+        if refs.is_empty() {
+            return discovery;
+        }
+
+        let ids: HashSet<&str> = refs.values().flatten().map(GroupId::as_str).collect();
+
+        // The cached metadata of the referenced groups.
+        let previews: Vec<Event> = client
+            .database()
+            .query(
+                Filter::new()
+                    .kind(Kind::GroupMetadata)
+                    .identifiers(ids.clone()),
+            )
+            .await
+            .map(|events| events.into_iter().collect())
+            .unwrap_or_default();
+
+        discovery.absorb_cached_previews(previews);
+
+        // The cached member lists of the referenced groups.
+        let members: Vec<Event> = client
+            .database()
+            .query(Filter::new().kind(Kind::GroupMembers).identifiers(ids))
+            .await
+            .map(|events| events.into_iter().collect())
+            .unwrap_or_default();
+
+        discovery.absorb_cached_members(members);
+
+        discovery
+    }
+
+    /// Reconcile the discoverable groups with the relays.
+    pub async fn sync(
+        &mut self,
+        client: Client,
+        me: PublicKey,
+        joined: HashSet<(RelayUrl, GroupId)>,
+    ) {
+        let filter = Filter::new().author(me).kind(Kind::ContactList).limit(1);
+
+        let authors: HashSet<PublicKey> = client
+            .database()
+            .query(filter)
+            .await
+            .ok()
+            .and_then(|events| events.into_iter().next())
+            .map(|event| event.tags.public_keys().collect())
+            .unwrap_or_default();
+
+        let urls: Vec<RelayUrl> = client.relays().await.into_keys().collect();
+        let filter = Filter::new().authors(authors).kind(Kind::SimpleGroups);
+        client.sync(filter.clone()).with(urls).await.ok();
+
+        let lists: Vec<Event> = client
+            .database()
+            .query(filter)
+            .await
+            .map(|events| events.into_iter().collect())
+            .unwrap_or_default();
+
+        self.absorb_lists(lists, &joined);
+
+        // The pool-wide sweep of the group metadata and members.
+        let urls: Vec<RelayUrl> = client.relays().await.into_keys().collect();
+        let filter = Filter::new().kinds([Kind::GroupMetadata, Kind::GroupMembers]);
+        client.sync(filter).with(urls).await.ok();
+
+        // The previews cover the relays the lists just referenced.
+        let fetches = self.refs.clone().into_iter().map(|(relay, ids)| {
+            let client = client.clone();
+
+            async move {
+                client.add_relay(relay.clone()).and_connect().await.ok();
+
+                let filter = Filter::new()
+                    .kinds([Kind::GroupMetadata, Kind::GroupMembers])
+                    .identifiers(ids.iter().map(GroupId::as_str));
+
+                let urls = vec![relay];
+                client.sync(filter).with(urls).await.ok();
+            }
+        });
+
+        join_all(fetches).await;
+    }
+}

crates/nip29/src/group.rs

@@ -0,0 +1,855 @@
+use std::collections::{HashMap, HashSet};
+use std::time::Duration;
+
+use anyhow::{Result, anyhow, bail};
+use chat::Message;
+use common::emojis_from_tags;
+use gpui::{App, AppContext, Context, EventEmitter, SharedString, SharedUri, Task};
+use nostr_sdk::prelude::*;
+use smallvec::{SmallVec, smallvec};
+use state::NostrRegistry;
+
+use crate::LOCAL_KEYS;
+use crate::protocol::{
+    ACTIVITY_KINDS, Activity, GroupAdmins, GroupId, GroupKey, GroupMembers, GroupMetadata,
+    GroupPins, GroupRoles, MEMBERSHIP_KINDS, Membership, PIN_LIST, Pin, RENDER_KINDS, STATE_KINDS,
+    TimelineWindow, tag_value,
+};
+
+const REPLAY_LIMIT: usize = 100;
+const PAGE_LIMIT: usize = 50;
+const PAGE_TIMEOUT: Duration = Duration::from_secs(10);
+const LEAVE_WINDOW_SECS: u64 = 5 * 60;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Absorbed {
+    Ignored,
+    Shown { fresh: bool, updated: bool },
+    Updated,
+}
+
+#[derive(Debug, Clone)]
+pub struct Reaction {
+    pub id: EventId,
+    pub emoji: String,
+    pub image: Option<SharedUri>,
+    pub author: PublicKey,
+}
+
+#[derive(Debug, Clone)]
+pub struct Invite {
+    pub id: EventId,
+    pub code: String,
+    pub created_at: Timestamp,
+}
+
+#[derive(Debug, Clone)]
+pub enum Row {
+    Message(Box<Message>),
+    Activity(Activity),
+}
+
+impl Row {
+    pub fn id(&self) -> EventId {
+        match self {
+            Self::Message(message) => message.id,
+            Self::Activity(activity) => activity.id,
+        }
+    }
+
+    pub fn author(&self) -> PublicKey {
+        match self {
+            Self::Message(message) => message.author,
+            Self::Activity(activity) => activity.author,
+        }
+    }
+
+    pub fn created_at(&self) -> Timestamp {
+        match self {
+            Self::Message(message) => message.created_at,
+            Self::Activity(activity) => activity.created_at,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GroupEvent {
+    Incoming(Event),
+    Sent(Event),
+    Updated,
+    Eose,
+    Refused(String),
+}
+
+pub struct Group {
+    key: GroupKey,
+    metadata: Option<GroupMetadata>,
+    members: GroupMembers,
+    admins: GroupAdmins,
+    roles: GroupRoles,
+    pins: GroupPins,
+    membership: Membership,
+    membership_events: Vec<Event>,
+    elsewhere: Option<GroupKey>,
+    state_ids: HashMap<Kind, EventId>,
+    rows: Vec<Row>,
+    index: HashSet<EventId>,
+    reactions: HashMap<EventId, Vec<Reaction>>,
+    /// Active invite codes; revocations arrive as 9005 deletions.
+    invites: Vec<Invite>,
+    leave_requests: HashMap<PublicKey, Timestamp>,
+    window: TimelineWindow,
+    oldest: Option<Timestamp>,
+    loading: bool,
+    loading_more: bool,
+    active: bool,
+    refused: Option<String>,
+    tasks: SmallVec<[Task<()>; 2]>,
+}
+
+impl EventEmitter<GroupEvent> for Group {}
+
+impl Group {
+    pub(crate) fn new(key: GroupKey) -> Self {
+        Self {
+            key,
+            metadata: None,
+            members: GroupMembers::default(),
+            admins: GroupAdmins::default(),
+            roles: GroupRoles::default(),
+            pins: GroupPins::default(),
+            membership: Membership::Unknown,
+            membership_events: Vec::new(),
+            elsewhere: None,
+            state_ids: HashMap::new(),
+            rows: Vec::new(),
+            index: HashSet::new(),
+            reactions: HashMap::new(),
+            invites: Vec::new(),
+            leave_requests: HashMap::new(),
+            window: TimelineWindow::new(),
+            oldest: None,
+            loading: true,
+            loading_more: false,
+            active: false,
+            refused: None,
+            tasks: smallvec![],
+        }
+    }
+
+    pub fn key(&self) -> &GroupKey {
+        &self.key
+    }
+
+    pub fn metadata(&self) -> Option<&GroupMetadata> {
+        self.metadata.as_ref()
+    }
+
+    pub fn display_name(&self) -> SharedString {
+        let name = self
+            .metadata
+            .as_ref()
+            .and_then(|metadata| metadata.name())
+            .unwrap_or_else(|| self.key.id().as_str());
+
+        SharedString::from(name.to_owned())
+    }
+
+    pub fn display_image(&self) -> Option<SharedString> {
+        self.metadata
+            .as_ref()
+            .and_then(|metadata| metadata.picture.clone())
+            .map(SharedString::from)
+    }
+
+    pub fn total_members(&self) -> usize {
+        self.members.len()
+    }
+
+    pub fn members(&self) -> &GroupMembers {
+        &self.members
+    }
+
+    pub fn admins(&self) -> &GroupAdmins {
+        &self.admins
+    }
+
+    pub fn roles(&self) -> &GroupRoles {
+        &self.roles
+    }
+
+    pub fn pins(&self) -> &GroupPins {
+        &self.pins
+    }
+
+    pub fn membership(&self) -> &Membership {
+        &self.membership
+    }
+
+    pub fn elsewhere(&self) -> Option<&GroupKey> {
+        self.elsewhere.as_ref()
+    }
+
+    pub fn rows(&self) -> &[Row] {
+        &self.rows
+    }
+
+    pub fn message(&self, id: EventId) -> Option<&Message> {
+        self.rows.iter().find_map(|row| match row {
+            Row::Message(message) if message.id == id => Some(message.as_ref()),
+            _ => None,
+        })
+    }
+
+    pub fn reactions(&self, id: &EventId) -> &[Reaction] {
+        self.reactions.get(id).map(Vec::as_slice).unwrap_or(&[])
+    }
+
+    pub fn invites(&self) -> &[Invite] {
+        &self.invites
+    }
+
+    pub fn loading_more(&self) -> bool {
+        self.loading_more
+    }
+
+    pub(crate) fn is_active(&self) -> bool {
+        self.active
+    }
+
+    pub(crate) fn activate(&mut self) {
+        self.active = true;
+    }
+
+    pub fn oldest(&self) -> Option<Timestamp> {
+        self.oldest
+    }
+
+    pub fn refused(&self) -> Option<&str> {
+        self.refused.as_deref()
+    }
+
+    pub fn send_message(
+        &mut self,
+        content: &str,
+        replies: Vec<EventId>,
+        emojis: Vec<Tag>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.dispatch(
+            move |id, prev| id.message(content, &replies, &emojis, prev),
+            cx,
+        )
+    }
+
+    pub fn send_reaction(
+        &mut self,
+        target: EventId,
+        emoji: String,
+        emojis: Vec<Tag>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.dispatch(
+            move |id, prev| id.reaction(target, &emoji, &emojis, prev),
+            cx,
+        )
+    }
+
+    pub fn remove_user(
+        &mut self,
+        public_key: PublicKey,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.dispatch(move |id, prev| id.remove_user(public_key, prev), cx)
+    }
+
+    pub fn put_user(
+        &mut self,
+        public_key: PublicKey,
+        roles: Vec<String>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.dispatch(move |id, prev| id.put_user(public_key, &roles, prev), cx)
+    }
+
+    pub fn edit_metadata(
+        &mut self,
+        metadata: &GroupMetadata,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.dispatch(move |id, prev| id.edit_metadata(metadata, prev), cx)
+    }
+
+    pub fn delete_event(&mut self, id: EventId, cx: &mut Context<Self>) -> Task<Result<()>> {
+        self.dispatch(move |gid, prev| gid.delete_event(id, prev), cx)
+    }
+
+    pub fn delete_group(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
+        self.dispatch(GroupId::delete_group, cx)
+    }
+
+    pub fn create_invite(&mut self, code: &str, cx: &mut Context<Self>) -> Task<Result<()>> {
+        self.dispatch(move |id, prev| id.create_invite(code, prev), cx)
+    }
+
+    pub fn update_pins(&mut self, pins: Vec<Pin>, cx: &mut Context<Self>) -> Task<Result<()>> {
+        self.dispatch(move |id, prev| id.update_pin_list(&pins, prev), cx)
+    }
+
+    fn dispatch<F>(&mut self, build: F, cx: &mut Context<Self>) -> Task<Result<()>>
+    where
+        F: FnOnce(&GroupId, Option<Tag>) -> EventBuilder,
+    {
+        let nostr = NostrRegistry::global(cx);
+
+        let Some(me) = nostr.read(cx).current_user() else {
+            return Task::ready(Err(anyhow!("nip29: no signed-in account")));
+        };
+
+        let builder = build(self.key.id(), self.window.previous_tag(me));
+        let published = self.publish(builder, cx);
+
+        cx.spawn(async move |this, cx| {
+            let event = published.await?;
+
+            this.update(cx, |_this, cx| {
+                cx.emit(GroupEvent::Sent(event));
+            })?;
+
+            Ok(())
+        })
+    }
+
+    pub(crate) fn publish(&self, builder: EventBuilder, cx: &App) -> Task<Result<Event>> {
+        let nostr = NostrRegistry::global(cx).read(cx);
+        let client = nostr.client();
+        let signer = nostr.signer();
+        let relay = self.key.relay().clone();
+
+        cx.background_spawn(async move {
+            if let Err(error) = client.add_relay(relay.clone()).and_connect().await {
+                log::warn!("nip29: connecting {relay} failed: {error}");
+            }
+
+            let event = builder.finalize_async(&signer).await?;
+            let output = client.send_event(&event).to([relay]).await?;
+
+            if let Some(reason) = output.failed.into_values().next() {
+                bail!("{reason}");
+            }
+
+            Ok(event)
+        })
+    }
+
+    pub(crate) fn mark_pending(&mut self, since: Timestamp, cx: &mut Context<Self>) {
+        if self.membership != Membership::Member {
+            self.membership = Membership::Pending { since };
+            cx.emit(GroupEvent::Updated);
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn mark_member(&mut self, cx: &mut Context<Self>) {
+        if self.membership == Membership::Member {
+            return;
+        }
+        self.membership = Membership::Member;
+        cx.emit(GroupEvent::Updated);
+        cx.notify();
+    }
+
+    pub(crate) fn mark_refused(&mut self, reason: String, cx: &mut Context<Self>) {
+        if self.membership == Membership::Member {
+            return;
+        }
+        self.membership = Membership::Refused {
+            reason: Some(reason),
+        };
+        cx.emit(GroupEvent::Updated);
+        cx.notify();
+    }
+
+    pub(crate) fn set_elsewhere(&mut self, elsewhere: Option<GroupKey>, cx: &mut Context<Self>) {
+        if self.elsewhere == elsewhere {
+            return;
+        }
+        self.elsewhere = elsewhere;
+        cx.emit(GroupEvent::Updated);
+        cx.notify();
+    }
+
+    pub(crate) fn connect(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(me) = nostr.read(cx).current_user() else {
+            return;
+        };
+
+        let key = self.key.clone();
+        let id = crate::subscription_id(&key);
+        let relay = key.relay().clone();
+
+        self.tasks.push(cx.background_spawn(async move {
+            if let Err(error) = client.add_relay(relay.clone()).and_connect().await {
+                log::warn!("nip29: connecting {relay} failed: {error}");
+            }
+
+            let filters = [
+                key.id().timeline_filter(REPLAY_LIMIT),
+                key.id().membership_filter(me),
+                key.id().moderation_filter(REPLAY_LIMIT),
+            ]
+            .into_iter()
+            .chain(key.id().state_filters())
+            .collect::<Vec<_>>();
+
+            if let Err(error) = client
+                .subscribe(ReqTarget::single(relay, filters))
+                .with_id(id)
+                .await
+            {
+                log::warn!("nip29: subscribing to {} failed: {error}", key.id());
+            }
+        }));
+    }
+
+    pub(crate) fn load_page(&mut self, cx: &mut Context<Self>) {
+        let Some(until) = self.oldest else {
+            return;
+        };
+
+        self.loading_more = true;
+        cx.notify();
+
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let id = crate::page_subscription(&self.key);
+        let relay = self.key.relay().clone();
+        let filter = self.key.id().timeline_page(PAGE_LIMIT, until);
+
+        self.tasks.push(cx.background_spawn(async move {
+            client.add_relay(relay.clone()).and_connect().await.ok();
+
+            let opts = SubscribeAutoCloseOptions::default()
+                .exit_policy(ReqExitPolicy::ExitOnEOSE)
+                .timeout(Some(PAGE_TIMEOUT));
+
+            if let Err(error) = client
+                .subscribe(ReqTarget::single(relay, [filter]))
+                .with_id(id)
+                .close_on(opts)
+                .await
+            {
+                log::warn!("nip29: loading older messages failed: {error}");
+            }
+        }));
+    }
+
+    pub(crate) fn page_finished(&mut self, cx: &mut Context<Self>) {
+        self.loading_more = false;
+        cx.emit(GroupEvent::Updated);
+        cx.notify();
+    }
+
+    pub(crate) fn save_envelope(&self, event: Event, cx: &App) -> Task<Result<()>> {
+        let cache_tag = self.key.cache_tag();
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        cx.background_spawn(async move {
+            let tags = vec![
+                Tag::identifier(event.id),
+                Tag::custom("r", [cache_tag]),
+                Tag::custom("k", [event.kind.to_string()]),
+            ];
+
+            let envelope = EventBuilder::new(Kind::ApplicationSpecificData, event.as_json())
+                .tags(tags)
+                .finalize_async(&*LOCAL_KEYS)
+                .await?;
+
+            client.database().save_event(&envelope).await?;
+
+            Ok(())
+        })
+    }
+
+    pub(crate) fn load_envelopes(&self, cx: &App, state_only: bool) -> Task<Result<Vec<Event>>> {
+        let cache_tag = self.key.cache_tag();
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        cx.background_spawn(async move {
+            let mut filter = Filter::new()
+                .kind(Kind::ApplicationSpecificData)
+                .custom_tag(SingleLetterTag::LOWERCASE_R, cache_tag);
+
+            if state_only {
+                let kinds = STATE_KINDS
+                    .iter()
+                    .chain(MEMBERSHIP_KINDS.iter())
+                    .map(|kind| kind.to_string());
+
+                filter = filter.custom_tags(SingleLetterTag::LOWERCASE_K, kinds);
+            }
+
+            let mut events: Vec<Event> = client
+                .database()
+                .query(filter)
+                .await?
+                .into_iter()
+                .filter_map(|envelope| Event::from_json(&envelope.content).ok())
+                .collect();
+
+            events.sort_by_key(|event| event.created_at);
+
+            Ok(events)
+        })
+    }
+
+    pub(crate) fn hydrate(&mut self, events: Vec<Event>, me: PublicKey, cx: &mut Context<Self>) {
+        if events.is_empty() {
+            return;
+        }
+
+        let mut rendered = Vec::new();
+        let mut changed = false;
+
+        for event in &events {
+            match self.absorb(event, me) {
+                Absorbed::Shown {
+                    fresh: true,
+                    updated,
+                } => {
+                    rendered.push(event.clone());
+                    changed |= updated;
+                }
+                Absorbed::Shown {
+                    fresh: false,
+                    updated,
+                } => changed |= updated,
+                Absorbed::Updated => changed = true,
+                Absorbed::Ignored => {}
+            }
+        }
+
+        for event in rendered {
+            cx.emit(GroupEvent::Incoming(event));
+        }
+
+        if changed {
+            cx.emit(GroupEvent::Updated);
+        }
+
+        cx.notify();
+    }
+
+    pub(crate) fn forget(&mut self, id: EventId, cx: &mut Context<Self>) {
+        if self.retract(id) {
+            cx.emit(GroupEvent::Updated);
+            cx.notify();
+        }
+    }
+
+    /// Remove an event and everything attached to it.
+    fn retract(&mut self, id: EventId) -> bool {
+        self.window.remove(id);
+
+        if !self.index.remove(&id) {
+            return false;
+        }
+
+        self.rows.retain(|row| row.id() != id);
+        self.invites.retain(|invite| invite.id != id);
+        self.reactions.remove(&id);
+
+        for reactions in self.reactions.values_mut() {
+            reactions.retain(|reaction| reaction.id != id);
+        }
+
+        self.reactions.retain(|_, reactions| !reactions.is_empty());
+
+        true
+    }
+
+    pub(crate) fn eose(&mut self, cx: &mut Context<Self>) {
+        self.loading = false;
+        cx.emit(GroupEvent::Eose);
+        cx.notify();
+    }
+
+    pub(crate) fn refuse(&mut self, reason: String, cx: &mut Context<Self>) {
+        self.loading = false;
+        self.refused = Some(reason.clone());
+        cx.emit(GroupEvent::Refused(reason));
+        cx.notify();
+    }
+
+    fn absorb(&mut self, event: &Event, me: PublicKey) -> Absorbed {
+        if STATE_KINDS.contains(&event.kind) {
+            self.window.note(event);
+
+            return if self.absorb_state(event, me) {
+                Absorbed::Updated
+            } else {
+                Absorbed::Ignored
+            };
+        }
+
+        // NIP-29: relays must reject events whose
+        // `previous` references are absent from their database.
+        let previous = event.tags.iter().find(|tag| tag.kind() == "previous");
+        if self.window.references_seen(previous) == Some(false) {
+            log::warn!(
+                "nip29: event {} carries previous references not seen on {}",
+                event.id,
+                self.key.relay()
+            );
+        }
+
+        self.track(event);
+
+        let updated = self.absorb_membership(event, me);
+
+        if ACTIVITY_KINDS.contains(&event.kind) {
+            return Absorbed::Shown {
+                fresh: self.push_activity(event),
+                updated,
+            };
+        }
+
+        if event.kind == Kind::Reaction {
+            return if self.push_reaction(event) {
+                Absorbed::Updated
+            } else {
+                Absorbed::Ignored
+            };
+        }
+
+        if event.kind == Kind::GroupCreateInvite {
+            return if self.push_invite(event) {
+                Absorbed::Updated
+            } else {
+                Absorbed::Ignored
+            };
+        }
+
+        if event.kind == Kind::GroupDeleteEvent {
+            let retracted = event
+                .tags
+                .event_ids()
+                .next()
+                .is_some_and(|target| self.retract(target));
+
+            return if retracted {
+                Absorbed::Updated
+            } else {
+                Absorbed::Ignored
+            };
+        }
+
+        if RENDER_KINDS.contains(&event.kind) {
+            return Absorbed::Shown {
+                fresh: self.push_row(event),
+                updated,
+            };
+        }
+
+        if updated {
+            Absorbed::Updated
+        } else {
+            Absorbed::Ignored
+        }
+    }
+
+    fn absorb_membership(&mut self, event: &Event, me: PublicKey) -> bool {
+        if !MEMBERSHIP_KINDS.contains(&event.kind) {
+            return false;
+        }
+
+        if !event.tags.public_keys().any(|key| key == me) {
+            return false;
+        }
+
+        if !self
+            .membership_events
+            .iter()
+            .any(|existing| existing.id == event.id)
+        {
+            self.membership_events.push(event.clone());
+        }
+
+        self.refresh_membership(me)
+    }
+
+    fn track(&mut self, event: &Event) {
+        self.window.push(event.clone());
+
+        if self.oldest.is_none_or(|oldest| event.created_at < oldest) {
+            self.oldest = Some(event.created_at);
+        }
+    }
+
+    fn absorb_state(&mut self, event: &Event, me: PublicKey) -> bool {
+        match event.kind {
+            Kind::GroupMetadata => match GroupMetadata::parse(event) {
+                Ok(metadata) => self.metadata = Some(metadata),
+                Err(_) => return false,
+            },
+            Kind::GroupAdmins => match GroupAdmins::parse(event) {
+                Ok(admins) => {
+                    self.admins = admins;
+                    self.adopt_roster_membership(me);
+                }
+                Err(_) => return false,
+            },
+            Kind::GroupMembers => match GroupMembers::parse(event) {
+                Ok(members) => {
+                    self.members = members;
+                    self.adopt_roster_membership(me);
+                }
+                Err(_) => return false,
+            },
+            Kind::GroupRoles => match GroupRoles::parse(event) {
+                Ok(roles) => self.roles = roles,
+                Err(_) => return false,
+            },
+            Kind::Custom(PIN_LIST) => match GroupPins::parse(event) {
+                Ok(pins) => self.pins = pins,
+                Err(_) => return false,
+            },
+            _ => return false,
+        }
+
+        self.state_ids.insert(event.kind, event.id) != Some(event.id)
+    }
+
+    fn adopt_roster_membership(&mut self, me: PublicKey) -> bool {
+        if self.membership != Membership::Unknown {
+            return false;
+        }
+
+        let listed = self.admins.contains(&me) || self.members.iter().any(|member| *member == me);
+
+        if !listed {
+            return false;
+        }
+
+        self.membership = Membership::Member;
+        true
+    }
+
+    fn push_row(&mut self, event: &Event) -> bool {
+        if !self.index.insert(event.id) {
+            return false;
+        }
+
+        let message = Message::from(event);
+        let position = self
+            .rows
+            .partition_point(|row| row.created_at() <= message.created_at);
+
+        self.rows.insert(position, Row::Message(Box::new(message)));
+
+        true
+    }
+
+    fn push_reaction(&mut self, event: &Event) -> bool {
+        let Some(target) = event.tags.event_ids().next() else {
+            return false;
+        };
+
+        if !self.index.insert(event.id) {
+            return false;
+        }
+
+        let emojis = emojis_from_tags(&event.tags);
+        let image = Message::reaction_image(&event.content, &emojis)
+            .map(|url| SharedUri::from(url.to_string()));
+
+        self.reactions.entry(target).or_default().push(Reaction {
+            id: event.id,
+            emoji: event.content.clone(),
+            image,
+            author: event.pubkey,
+        });
+
+        true
+    }
+
+    fn push_invite(&mut self, event: &Event) -> bool {
+        let Some(code) = tag_value(&event.tags, "code") else {
+            return false;
+        };
+
+        if !self.index.insert(event.id) {
+            return false;
+        }
+
+        self.invites.push(Invite {
+            id: event.id,
+            code: code.to_owned(),
+            created_at: event.created_at,
+        });
+
+        true
+    }
+
+    fn push_activity(&mut self, event: &Event) -> bool {
+        let activity = match Activity::parse(event) {
+            Ok(activity) => activity,
+            Err(error) => {
+                log::warn!("nip29: ignoring a malformed group activity: {error}");
+                return false;
+            }
+        };
+
+        if activity.kind == Kind::GroupPutUser && activity.roles.is_empty() {
+            return false;
+        }
+
+        if activity.kind == Kind::GroupRemoveUser
+            && self
+                .leave_requests
+                .get(&activity.subject())
+                .is_some_and(|left| {
+                    activity.created_at >= *left
+                        && activity.created_at.as_secs().saturating_sub(left.as_secs())
+                            <= LEAVE_WINDOW_SECS
+                })
+        {
+            return false;
+        }
+
+        if !self.index.insert(activity.id) {
+            return false;
+        }
+
+        if activity.kind == Kind::GroupLeaveRequest {
+            self.leave_requests
+                .insert(activity.subject(), activity.created_at);
+        }
+
+        let position = self
+            .rows
+            .partition_point(|row| row.created_at() <= activity.created_at);
+
+        self.rows.insert(position, Row::Activity(activity));
+
+        true
+    }
+
+    fn refresh_membership(&mut self, me: PublicKey) -> bool {
+        let derived = Membership::from_events(&self.membership_events, me);
+
+        if derived != Membership::Unknown && derived != self.membership {
+            self.membership = derived;
+            return true;
+        }
+
+        false
+    }
+}

crates/nip29/src/utils.rs

@@ -0,0 +1,101 @@
+use std::collections::HashSet;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+
+use nostr_sdk::prelude::*;
+
+use crate::{GroupId, GroupKey};
+
+const LIST_SUBSCRIPTION: &str = "nip29-list";
+const FORK_SUBSCRIPTION: &str = "nip29-forks";
+const GROUP_PREFIX: &str = "grp-";
+const BROWSE_PREFIX: &str = "brw-";
+const PAGE_PREFIX: &str = "pg-";
+
+pub(crate) fn list_subscription_id() -> SubscriptionId {
+    SubscriptionId::new(LIST_SUBSCRIPTION)
+}
+
+pub(crate) fn fork_subscription_id() -> SubscriptionId {
+    SubscriptionId::new(FORK_SUBSCRIPTION)
+}
+
+pub(crate) fn subscription_id(key: &GroupKey) -> SubscriptionId {
+    SubscriptionId::new(format!("{GROUP_PREFIX}{:08x}", key.uniq_id() as u32))
+}
+
+pub(crate) fn browse_subscription(relay: &RelayUrl) -> SubscriptionId {
+    let mut hasher = DefaultHasher::new();
+    relay.hash(&mut hasher);
+
+    SubscriptionId::new(format!("{BROWSE_PREFIX}{:08x}", hasher.finish() as u32))
+}
+
+pub(crate) fn page_subscription(key: &GroupKey) -> SubscriptionId {
+    SubscriptionId::new(format!("{PAGE_PREFIX}{:08x}", key.uniq_id() as u32))
+}
+
+pub(crate) fn is_page(id: &SubscriptionId) -> bool {
+    id.as_str().starts_with(PAGE_PREFIX)
+}
+
+pub(crate) fn is_own_subscription(id: &SubscriptionId) -> bool {
+    let id = id.as_str();
+    id == LIST_SUBSCRIPTION
+        || id == FORK_SUBSCRIPTION
+        || id.starts_with(GROUP_PREFIX)
+        || id.starts_with(BROWSE_PREFIX)
+        || id.starts_with(PAGE_PREFIX)
+}
+
+pub(crate) fn parse_members(event: &Event) -> Option<(GroupId, Timestamp, usize)> {
+    if event.kind != Kind::GroupMembers {
+        return None;
+    }
+
+    let id = GroupId::new(event.tags.identifier()?).ok()?;
+    let members = event.tags.public_keys().collect::<HashSet<_>>().len();
+
+    Some((id, event.created_at, members))
+}
+
+const ONSETS: [&str; 34] = [
+    "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "r", "s", "t", "v", "br", "cr",
+    "dr", "fr", "gr", "pr", "tr", "bl", "cl", "fl", "gl", "pl", "sl", "sh", "ch", "th", "st", "sk",
+];
+const NUCLEI: [&str; 9] = ["a", "e", "i", "o", "u", "ae", "ei", "io", "ou"];
+const CODAS: [&str; 11] = ["", "", "", "n", "r", "s", "t", "d", "l", "m", "k"];
+
+/// A short pronounceable id for new groups, seeded from a fresh key.
+pub(crate) fn readable_id() -> String {
+    let mut picks = SecretKey::generate().secret_bytes().into_iter();
+
+    let mut id = String::with_capacity(18);
+
+    for _ in 0..3 {
+        let onset = ONSETS[usize::from(picks.next().unwrap_or(0)) % ONSETS.len()];
+        let nucleus = NUCLEI[usize::from(picks.next().unwrap_or(0)) % NUCLEI.len()];
+        let coda = CODAS[usize::from(picks.next().unwrap_or(0)) % CODAS.len()];
+
+        id.push_str(onset);
+        id.push_str(nucleus);
+        id.push_str(coda);
+    }
+
+    id
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_readable_id() {
+        for _ in 0..32 {
+            let id = readable_id();
+
+            assert!((6..=15).contains(&id.len()));
+            assert!(id.chars().all(|character| character.is_ascii_lowercase()));
+        }
+    }
+}

crates/nip29_ui/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "nip29_ui"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+chat = { path = "../chat" }
+chat_ui = { path = "../chat_ui" }
+common = { path = "../common" }
+nip29 = { path = "../nip29" }
+person = { path = "../person" }
+settings = { path = "../settings" }
+state = { path = "../state" }
+theme = { path = "../theme" }
+ui = { path = "../ui" }
+
+gpui.workspace = true
+nostr-sdk.workspace = true
+anyhow.workspace = true
+log.workspace = true
+serde.workspace = true
+smallvec.workspace = true

crates/nip29_ui/src/details.rs

@@ -0,0 +1,215 @@
+use gpui::{
+    AnyElement, App, IntoElement, ParentElement, SharedString, Styled, WeakEntity, Window, div, px,
+    relative,
+};
+use nip29::{Group, GroupMetadata};
+use theme::{ActiveTheme, TextStyle, Typeset as _, control_radius};
+use ui::avatar::Avatar;
+use ui::{Sizable, StyledExt, WindowExtension, h_flex, v_flex};
+
+pub(crate) fn open(group: WeakEntity<Group>, window: &mut Window, cx: &mut App) {
+    window.open_dialog(cx, move |this, _window, cx| {
+        this.max_h(px(600.))
+            .show_close(true)
+            .title("About Group")
+            .child(body(&group, cx))
+    });
+}
+
+fn body(group: &WeakEntity<Group>, cx: &App) -> AnyElement {
+    let Some(entity) = group.upgrade() else {
+        return div().into_any_element();
+    };
+
+    let group = entity.read(cx);
+    let mut body = v_flex().gap_3().text_style(TextStyle::Callout).child(header(group, cx));
+
+    if let Some(metadata) = group.metadata() {
+        if let Some(about) = metadata.about.as_ref() {
+            body = body.child(
+                div()
+                    .text_color(cx.theme().text_muted)
+                    .child(SharedString::from(about.clone())),
+            );
+        }
+
+        let flags = flags(metadata);
+
+        if !flags.is_empty() {
+            body = body.child(section(
+                "Flags",
+                wrap(flags.into_iter().map(|f| chip(f, cx))),
+                cx,
+            ));
+        }
+
+        if let Some(parent) = metadata.parent.as_ref() {
+            body = body.child(section(
+                "Parent",
+                div()
+                    .child(SharedString::from(parent.as_str().to_owned()))
+                    .into_any_element(),
+                cx,
+            ));
+        }
+
+        if !metadata.children.is_empty() {
+            body = body.child(section(
+                "Children",
+                wrap(
+                    metadata
+                        .children
+                        .iter()
+                        .map(|child| chip(child.as_str().to_owned(), cx)),
+                ),
+                cx,
+            ));
+        }
+
+        if let Some(kinds) = metadata.supported_kinds.as_ref() {
+            let items: Vec<AnyElement> = kinds
+                .iter()
+                .map(|kind| chip(kind.to_string(), cx))
+                .collect();
+
+            body = body.child(section(
+                "Supported kinds",
+                if items.is_empty() {
+                    div()
+                        .text_color(cx.theme().text_faint)
+                        .child("None")
+                        .into_any_element()
+                } else {
+                    wrap(items)
+                },
+                cx,
+            ));
+        }
+    }
+
+    let roles = group.roles().roles();
+    if !roles.is_empty() {
+        body = body.child(section(
+            "Roles",
+            wrap(roles.iter().map(|role| chip(role.name.clone(), cx))),
+            cx,
+        ));
+    }
+
+    let pins = group.pins().pins();
+    if !pins.is_empty() {
+        body = body.child(section(
+            "Pinned",
+            v_flex()
+                .gap_1()
+                .children(
+                    pins.iter()
+                        .map(|pin| {
+                            div()
+                                .truncate()
+                                .text_color(cx.theme().text_muted)
+                                .child(crate::util::pin_label(group, pin))
+                                .into_any_element()
+                        })
+                        .collect::<Vec<_>>(),
+                )
+                .into_any_element(),
+            cx,
+        ));
+    }
+
+    body.into_any_element()
+}
+
+fn header(group: &Group, cx: &App) -> AnyElement {
+    let key = group.key();
+
+    h_flex()
+        .gap_3()
+        .items_center()
+        .child(
+            Avatar::from_source(group.display_image())
+                .seed(key.cache_tag())
+                .large(),
+        )
+        .child(
+            v_flex()
+                .min_w_0()
+                .child(
+                    div()
+                        .text_style(TextStyle::Body)
+                        .font_semibold()
+                        .truncate()
+                        .child(group.display_name()),
+                )
+                .child(
+                    div()
+                        .text_style(TextStyle::Caption)
+                        .text_color(cx.theme().text_faint)
+                        .truncate()
+                        .child(SharedString::from(format!(
+                            "{} · {}",
+                            key.id().as_str(),
+                            key.relay().as_str()
+                        ))),
+                ),
+        )
+        .into_any_element()
+}
+
+fn section(label: &'static str, content: AnyElement, cx: &App) -> AnyElement {
+    v_flex()
+        .gap_1()
+        .child(
+            div()
+                .text_style(TextStyle::Caption)
+                .font_medium()
+                .text_color(cx.theme().text_muted)
+                .child(label),
+        )
+        .child(content)
+        .into_any_element()
+}
+
+fn wrap(items: impl IntoIterator<Item = AnyElement>) -> AnyElement {
+    h_flex()
+        .flex_wrap()
+        .gap_1()
+        .children(items)
+        .into_any_element()
+}
+
+fn chip(label: impl Into<SharedString>, cx: &App) -> AnyElement {
+    div()
+        .px_2()
+        .py_1()
+        .rounded(px(control_radius()))
+        .bg(cx.theme().surface_raised)
+        .text_color(cx.theme().text)
+        .text_style(TextStyle::Caption)
+        .line_height(relative(1.))
+        .child(label.into())
+        .into_any_element()
+}
+
+fn flags(metadata: &GroupMetadata) -> Vec<&'static str> {
+    let mut flags = Vec::new();
+
+    if metadata.private {
+        flags.push("Private");
+    }
+    if metadata.restricted {
+        flags.push("Restricted");
+    }
+    if metadata.hidden {
+        flags.push("Hidden");
+    }
+    if metadata.closed {
+        flags.push("Closed");
+    }
+    if metadata.livekit {
+        flags.push("LiveKit");
+    }
+
+    flags
+}

crates/nip29_ui/src/invite.rs

@@ -0,0 +1,210 @@
+use anyhow::Result;
+use common::TimestampExt;
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    App, AppContext, ClipboardItem, Entity, IntoElement, ParentElement, SharedString, Styled,
+    WeakEntity, Window, div, px,
+};
+use nip29::{Group, Invite};
+use nostr_sdk::prelude::SecretKey;
+use theme::{ActiveTheme, TextStyle, Typeset as _};
+use ui::button::{Button, ButtonVariants};
+use ui::input::InputState;
+use ui::notification::Notification;
+use ui::{Sizable, WindowExtension, h_flex, v_flex};
+
+use crate::util::{field, report};
+
+const CODE_LEN: usize = 12;
+
+pub(crate) fn open(group: WeakEntity<Group>, window: &mut Window, cx: &mut App) {
+    let input = cx.new(|cx| {
+        InputState::new(window, cx)
+            .placeholder("Invite code")
+            .default_value(random_code())
+    });
+
+    window.open_dialog(cx, move |this, _window, cx| {
+        this.max_h(px(600.))
+            .show_close(true)
+            .title("Invites")
+            .child(body(group.clone(), input.clone(), cx))
+    });
+}
+
+fn random_code() -> String {
+    SecretKey::generate()
+        .to_secret_hex()
+        .chars()
+        .take(CODE_LEN)
+        .collect()
+}
+
+fn body(group: WeakEntity<Group>, input: Entity<InputState>, cx: &App) -> impl IntoElement {
+    let invites = group
+        .upgrade()
+        .map(|entity| entity.read(cx).invites().to_vec())
+        .unwrap_or_default();
+
+    v_flex()
+        .gap_3()
+        .text_style(TextStyle::Callout)
+        .child(
+            div()
+                .text_color(cx.theme().text_muted)
+                .child("Anyone with a code can ask to join. Revoking a code stops new joins, it doesn't remove anyone."),
+        )
+        .when(invites.is_empty(), |this| {
+            this.child(
+                div()
+                    .text_color(cx.theme().text_faint)
+                    .child("No active invites"),
+            )
+        })
+        .children(invites.iter().map(|invite| invite_row(group.clone(), invite, cx)))
+        .child(create_row(group, input, cx))
+}
+
+fn invite_row(group: WeakEntity<Group>, invite: &Invite, cx: &App) -> impl IntoElement {
+    let created = div()
+        .flex_shrink_0()
+        .text_style(TextStyle::Caption)
+        .text_color(cx.theme().text_faint)
+        .child(invite.created_at.to_ago());
+
+    h_flex()
+        .justify_between()
+        .gap_2()
+        .child(
+            h_flex()
+                .min_w_0()
+                .gap_2()
+                .items_center()
+                .child(
+                    div()
+                        .min_w_0()
+                        .truncate()
+                        .child(SharedString::from(invite.code.clone())),
+                )
+                .child(created),
+        )
+        .child(
+            h_flex()
+                .flex_shrink_0()
+                .gap_1()
+                .child(copy_button(&group, &invite.code))
+                .child(revoke_button(&group, invite.id, &invite.code)),
+        )
+}
+
+fn copy_button(group: &WeakEntity<Group>, code: &str) -> Button {
+    let group = group.clone();
+    let code = code.to_owned();
+
+    Button::new(SharedString::from(format!("invite-copy-{code}")))
+        .label("Copy")
+        .ghost()
+        .small()
+        .on_click(move |_event, window, cx| {
+            let Some(link) = group
+                .read_with(cx, |group, _cx| invite_link(group, &code))
+                .ok()
+                .flatten()
+            else {
+                window.push_notification(
+                    Notification::error(
+                        "The relay doesn't publish group details, so no invite link can be made",
+                    ),
+                    cx,
+                );
+                return;
+            };
+
+            cx.write_to_clipboard(ClipboardItem::new_string(link));
+            window.push_notification(Notification::success("Invite link copied"), cx);
+        })
+}
+
+fn revoke_button(group: &WeakEntity<Group>, id: nostr_sdk::prelude::EventId, code: &str) -> Button {
+    let group = group.clone();
+
+    Button::new(SharedString::from(format!("invite-revoke-{code}")))
+        .label("Revoke")
+        .ghost()
+        .small()
+        .on_click(move |_event, window, cx| {
+            match group.update(cx, |group, cx| group.delete_event(id, cx)) {
+                Ok(task) => report(window, cx, task),
+                Err(error) => log::warn!("nip29: revoking an invite failed: {error}"),
+            }
+        })
+}
+
+fn create_row(group: WeakEntity<Group>, input: Entity<InputState>, cx: &App) -> impl IntoElement {
+    h_flex()
+        .items_end()
+        .gap_2()
+        .child(field("New code", &input, cx).flex_1())
+        .child(
+            Button::new("invite-create")
+                .label("Create & copy link")
+                .on_click(move |_event, window, cx| {
+                    create(group.clone(), input.clone(), window, cx);
+                }),
+        )
+}
+
+fn invite_link(group: &Group, code: &str) -> Option<String> {
+    group
+        .metadata()
+        .and_then(|metadata| metadata.naddr(group.key().relay(), Some(code)).ok())
+}
+
+fn create(group: WeakEntity<Group>, input: Entity<InputState>, window: &mut Window, cx: &mut App) {
+    let code = input.read(cx).value().trim().to_owned();
+
+    if code.is_empty() {
+        window.push_notification(Notification::error("The invite code is empty"), cx);
+        return;
+    }
+
+    let Some(link) = group
+        .read_with(cx, |group, _cx| invite_link(group, &code))
+        .ok()
+        .flatten()
+    else {
+        window.push_notification(
+            Notification::error(
+                "The relay doesn't publish group details, so no invite link can be made",
+            ),
+            cx,
+        );
+        return;
+    };
+
+    match group.update(cx, |group, cx| group.create_invite(&code, cx)) {
+        Ok(task) => {
+            window
+                .spawn(cx, async move |cx| -> Result<()> {
+                    if let Err(error) = task.await {
+                        cx.update(|window, cx| {
+                            window.push_notification(Notification::error(error.to_string()), cx);
+                        })?;
+                        return Ok(());
+                    }
+
+                    cx.update(|window, cx| {
+                        input.update(cx, |input, cx| {
+                            input.set_value("", window, cx);
+                        });
+                        cx.write_to_clipboard(ClipboardItem::new_string(link));
+                        window.push_notification(Notification::success("Invite link copied"), cx);
+                    })?;
+
+                    Ok(())
+                })
+                .detach();
+        }
+        Err(error) => log::warn!("nip29: creating an invite failed: {error}"),
+    }
+}

crates/nip29_ui/src/message.rs

@@ -0,0 +1,329 @@
+use chat::Message;
+use common::TimestampExt;
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    AnyElement, App, Entity, InteractiveElement, IntoElement, ParentElement, SharedString, Styled,
+    WeakEntity, div, px,
+};
+use nip29::{Activity, Group, Reaction};
+use nostr_sdk::prelude::{EventId, Kind};
+use person::Directory;
+use settings::AppSettings;
+use state::NostrRegistry;
+use theme::{ActiveTheme, TextStyle, Typeset as _};
+use ui::avatar::Avatar;
+use ui::menu::{ContextMenu, PopupMenu, PopupMenuItem};
+use ui::message::{MessageMedia, MessageRow, ReactionBar, ReplyPreview, group_reactions};
+use ui::{Icon, IconName, Sizable, StyledExt, h_flex};
+
+use crate::GroupPanel;
+
+const REACTIONS: [&str; 6] = ["👍", "❤️", "😂", "🎉", "😮", "😢"];
+
+pub(crate) struct Actions {
+    pub group: WeakEntity<Group>,
+    pub panel: WeakEntity<GroupPanel>,
+    pub admin: bool,
+    pub pinned: bool,
+    pub persons: Entity<Directory>,
+}
+
+pub(crate) fn render(
+    ix: usize,
+    message: &Message,
+    content: AnyElement,
+    show_author: bool,
+    reactions: &[Reaction],
+    actions: Actions,
+    cx: &App,
+) -> AnyElement {
+    let nostr = NostrRegistry::global(cx);
+    let hide_avatar = AppSettings::get_hide_avatar(cx);
+
+    let persons = actions.persons.clone();
+    let author = persons.read(cx).person(&message.author, cx);
+
+    let reaction_groups = group_reactions(
+        reactions.iter().map(|reaction| {
+            (
+                SharedString::from(reaction.emoji.as_str()),
+                reaction.image.clone(),
+                reaction.author,
+            )
+        }),
+        nostr.read(cx).current_user(),
+    );
+
+    let row = MessageRow::new(ix)
+        .show_author(show_author)
+        .hide_avatar(hide_avatar)
+        .avatar(
+            Avatar::new(author.avatar())
+                .seed(author.avatar_seed())
+                .flex_shrink_0(),
+        )
+        .author(author.name())
+        .timestamp(message.created_at.to_human_time())
+        .when(!message.replies_to.is_empty(), |this| {
+            this.children(replies(
+                &message.replies_to,
+                &persons,
+                &actions.group,
+                &actions.panel,
+                cx,
+            ))
+        })
+        .child(content)
+        .when(!message.media.is_empty(), |this| {
+            this.child(MessageMedia::new(&message.media))
+        })
+        .when(!reaction_groups.is_empty(), |this| {
+            this.child(ReactionBar::new(reaction_groups))
+        })
+        .into_any_element();
+
+    let id = message.id;
+    let admin = actions.admin;
+    let pinned = actions.pinned;
+    let group = actions.group;
+    let panel = actions.panel;
+
+    ContextMenu::new(
+        format!("message-menu-{}", id.to_hex()),
+        row,
+        move |menu, window, cx| {
+            let menu = menu
+                .item({
+                    let panel = panel.clone();
+
+                    PopupMenuItem::new("Reply").on_click(move |_event, _window, cx| {
+                        let _ = panel.update_in(cx, |panel, window, cx| {
+                            panel.start_reply(id, window, cx);
+                        });
+                    })
+                })
+                .submenu("React", window, cx, {
+                    let group = group.clone();
+                    let panel = panel.clone();
+
+                    move |menu, _window, cx| react_menu(menu, group.clone(), panel.clone(), id, cx)
+                });
+
+            if !admin {
+                return menu;
+            }
+
+            menu.separator()
+                .item({
+                    let group = group.clone();
+                    let panel = panel.clone();
+
+                    PopupMenuItem::new(if pinned { "Unpin" } else { "Pin" }).on_click(
+                        move |_event, _window, cx| {
+                            let _ = panel.update_in(cx, |panel, window, cx| {
+                                panel.toggle_pin(group.clone(), id, window, cx);
+                            });
+                        },
+                    )
+                })
+                .item({
+                    let group = group.clone();
+                    let panel = panel.clone();
+
+                    PopupMenuItem::new("Delete message").on_click(move |_event, _window, cx| {
+                        let _ = panel.update_in(cx, |panel, window, cx| {
+                            panel.delete_message(group.clone(), id, window, cx);
+                        });
+                    })
+                })
+        },
+    )
+    .into_any_element()
+}
+
+fn react_menu(
+    menu: PopupMenu,
+    group: WeakEntity<Group>,
+    panel: WeakEntity<GroupPanel>,
+    id: EventId,
+    cx: &App,
+) -> PopupMenu {
+    let menu = REACTIONS.iter().fold(menu, |menu, emoji| {
+        let emoji = *emoji;
+        let group = group.clone();
+        let panel = panel.clone();
+
+        menu.item(
+            PopupMenuItem::new(emoji).on_click(move |_event, _window, cx| {
+                if let Err(error) = panel.update_in(cx, |panel, window, cx| {
+                    panel.react(group.clone(), id, emoji.to_owned(), window, cx);
+                }) {
+                    log::warn!("nip29: sending a reaction failed: {error}");
+                }
+            }),
+        )
+    });
+
+    let emojis = panel
+        .upgrade()
+        .and_then(|panel| {
+            let current_user = NostrRegistry::global(cx).read(cx).current_user()?;
+            Some(
+                panel
+                    .read(cx)
+                    .directory
+                    .read(cx)
+                    .person(&current_user, cx)
+                    .emojis()
+                    .to_vec(),
+            )
+        })
+        .unwrap_or_default();
+
+    if emojis.is_empty() {
+        return menu;
+    }
+
+    let menu = menu.separator();
+    emojis.into_iter().fold(menu, |menu, (shortcode, _)| {
+        let emoji = format!(":{shortcode}:");
+        let group = group.clone();
+        let panel = panel.clone();
+
+        menu.item(
+            PopupMenuItem::new(emoji.clone()).on_click(move |_event, _window, cx| {
+                if let Err(error) = panel.update_in(cx, |panel, window, cx| {
+                    panel.react(group.clone(), id, emoji.clone(), window, cx);
+                }) {
+                    log::warn!("nip29: sending a reaction failed: {error}");
+                }
+            }),
+        )
+    })
+}
+
+pub(crate) fn render_activity(
+    ix: usize,
+    activity: &Activity,
+    persons: &Entity<Directory>,
+    cx: &App,
+) -> AnyElement {
+    let subject = persons.read(cx).person(&activity.subject(), cx);
+    let hide_avatar = AppSettings::get_hide_avatar(cx);
+
+    h_flex()
+        .id(ix)
+        .w_full()
+        .gap(px(theme::SPACE))
+        .py_1()
+        .px_3()
+        .hover(|this| this.bg(cx.theme().element_hover))
+        .child(badge(activity, cx))
+        .when(!hide_avatar, |this| {
+            this.child(
+                Avatar::new(subject.avatar())
+                    .seed(subject.avatar_seed())
+                    .small()
+                    .flex_shrink_0(),
+            )
+        })
+        .child(
+            div()
+                .min_w_0()
+                .truncate()
+                .text_style(TextStyle::Callout)
+                .font_semibold()
+                .child(subject.name()),
+        )
+        .child(
+            div()
+                .min_w_0()
+                .truncate()
+                .text_style(TextStyle::Callout)
+                .text_color(cx.theme().text_faint)
+                .child(SharedString::from(action(activity))),
+        )
+        .child(
+            div()
+                .flex_shrink_0()
+                .ml_1()
+                .text_style(TextStyle::Caption)
+                .text_color(cx.theme().text_faint)
+                .child(activity.created_at.to_ago()),
+        )
+        .into_any_element()
+}
+
+fn badge(activity: &Activity, cx: &App) -> AnyElement {
+    let (icon, color) = match activity.kind {
+        Kind::GroupJoinRequest => (IconName::Login, cx.theme().accent),
+        Kind::GroupPutUser => (IconName::Login, cx.theme().accent),
+        Kind::GroupLeaveRequest => (IconName::Logout, cx.theme().danger),
+        Kind::GroupRemoveUser => (IconName::Ban, cx.theme().danger),
+        _ => (IconName::Info, cx.theme().text_faint),
+    };
+
+    h_flex()
+        .flex_shrink_0()
+        .justify_center()
+        .size_8()
+        .child(Icon::new(icon).small().text_color(color))
+        .into_any_element()
+}
+
+fn action(activity: &Activity) -> String {
+    match activity.kind {
+        Kind::GroupJoinRequest => "joined the group".to_owned(),
+        Kind::GroupLeaveRequest => "left the group".to_owned(),
+        Kind::GroupRemoveUser => "was removed from the group".to_owned(),
+        Kind::GroupPutUser => format!("is now {}", activity.roles.join(", ")),
+        _ => String::new(),
+    }
+}
+
+fn replies(
+    targets: &[EventId],
+    persons: &Entity<Directory>,
+    group: &WeakEntity<Group>,
+    panel: &WeakEntity<GroupPanel>,
+    cx: &App,
+) -> Vec<AnyElement> {
+    let Some(entity) = group.upgrade() else {
+        return Vec::new();
+    };
+
+    let mut items = Vec::with_capacity(targets.len());
+
+    for (ix, id) in targets.iter().enumerate() {
+        let context = entity.read_with(cx, |group, cx| {
+            let message = group.message(*id)?;
+            let author = persons.read(cx).person(&message.author, cx);
+
+            Some((author.name(), message.preview()))
+        });
+
+        let (author, preview) = context.unwrap_or_else(|| {
+            (
+                SharedString::from("Message"),
+                SharedString::from("original not loaded"),
+            )
+        });
+
+        let id = *id;
+        let panel = panel.clone();
+
+        items.push(
+            ReplyPreview::new(ix, author, preview)
+                .on_click(move |_event, _window, cx| {
+                    if let Err(error) = panel.update(cx, |panel, cx| {
+                        panel.scroll_to(&id, cx);
+                    }) {
+                        log::warn!("nip29: scrolling to message failed: {error}");
+                    }
+                })
+                .into_any_element(),
+        );
+    }
+
+    items
+}

crates/nip29_ui/src/metadata.rs

@@ -0,0 +1,346 @@
+use std::sync::Arc;
+
+use gpui::http_client::{AsyncBody, HttpClient};
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    AnyElement, App, AppContext, Entity, IntoElement, ParentElement, SharedString, Styled,
+    WeakEntity, Window, div, px,
+};
+use nip29::{Group, GroupId, GroupMetadata};
+use nostr_sdk::prelude::RelayUrl;
+use theme::{ActiveTheme, TextStyle, Typeset as _};
+use ui::button::{Button, ButtonVariants};
+use ui::dialog::DialogButtonProps;
+use ui::input::InputState;
+use ui::notification::Notification;
+use ui::switch::Switch;
+use ui::{Sizable, WindowExtension, h_flex, v_flex};
+
+use crate::util::field;
+
+#[derive(Clone, Copy, Default)]
+struct Flags {
+    private: bool,
+    restricted: bool,
+    hidden: bool,
+    closed: bool,
+    livekit: bool,
+}
+
+impl Flags {
+    fn of(metadata: &GroupMetadata) -> Self {
+        Self {
+            private: metadata.private,
+            restricted: metadata.restricted,
+            hidden: metadata.hidden,
+            closed: metadata.closed,
+            livekit: metadata.livekit,
+        }
+    }
+}
+
+pub(crate) fn open(group: WeakEntity<Group>, window: &mut Window, cx: &mut App) {
+    let base = group
+        .read_with(cx, |group, _cx| group.metadata().cloned())
+        .ok()
+        .flatten()
+        .unwrap_or_default();
+
+    let name = cx.new(|cx| {
+        InputState::new(window, cx)
+            .placeholder("Group name")
+            .default_value(base.name.clone().unwrap_or_default())
+    });
+
+    let about = cx.new(|cx| {
+        InputState::new(window, cx)
+            .placeholder("About")
+            .default_value(base.about.clone().unwrap_or_default())
+    });
+
+    let picture = cx.new(|cx| {
+        InputState::new(window, cx)
+            .placeholder("https://example.com/picture.png")
+            .default_value(base.picture.clone().unwrap_or_default())
+    });
+
+    let parent = cx.new(|cx| {
+        InputState::new(window, cx)
+            .placeholder("Parent group id, empty for a root group")
+            .default_value(
+                base.parent
+                    .as_ref()
+                    .map(|id| id.as_str().to_owned())
+                    .unwrap_or_default(),
+            )
+    });
+
+    let children = cx.new(|_cx| base.children.clone());
+    let flags = cx.new(|_cx| Flags::of(&base));
+    let livekit = cx.new(|_cx| None);
+
+    if let Ok(relay) = group.read_with(cx, |group, _cx| group.key().relay().clone()) {
+        let http = cx.http_client();
+        let probe = cx.background_spawn(async move { probe_livekit(http, relay).await });
+        let livekit = livekit.clone();
+
+        cx.spawn(async move |cx| {
+            let supported = probe.await;
+
+            livekit.update(cx, |livekit, cx| {
+                *livekit = Some(supported);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    window.open_dialog(cx, move |this, _window, cx| {
+        let current = *flags.read(cx);
+        let supported = *livekit.read(cx) != Some(false);
+
+        this.confirm()
+            .title("Edit Group")
+            .button_props(
+                DialogButtonProps::default()
+                    .cancel_text("Cancel")
+                    .ok_text("Save"),
+            )
+            .child(
+                v_flex()
+                    .gap_3()
+                    .child(field("Name", &name, cx))
+                    .child(field("About", &about, cx))
+                    .child(field("Picture", &picture, cx))
+                    .child(field("Parent", &parent, cx))
+                    .child(children_section(&children, cx))
+                    .child(
+                        v_flex()
+                            .gap(px(theme::SPACE))
+                            .child(
+                                Switch::new("private")
+                                    .label("Private")
+                                    .description("Only members can read group messages")
+                                    .checked(current.private)
+                                    .on_click(toggle(&flags, |flags| &mut flags.private)),
+                            )
+                            .child(
+                                Switch::new("restricted")
+                                    .label("Restricted")
+                                    .description("Only members can post messages")
+                                    .checked(current.restricted)
+                                    .on_click(toggle(&flags, |flags| &mut flags.restricted)),
+                            )
+                            .child(
+                                Switch::new("hidden")
+                                    .label("Hidden")
+                                    .description("Hidden from non-members, not discoverable")
+                                    .checked(current.hidden)
+                                    .on_click(toggle(&flags, |flags| &mut flags.hidden)),
+                            )
+                            .child(
+                                Switch::new("closed")
+                                    .label("Closed")
+                                    .description("Join requests are ignored (invite-only)")
+                                    .checked(current.closed)
+                                    .on_click(toggle(&flags, |flags| &mut flags.closed)),
+                            )
+                            .child(
+                                Switch::new("livekit")
+                                    .label("LiveKit")
+                                    .description(if supported {
+                                        "Announce audio and video support."
+                                    } else {
+                                        "The relay doesn't announce LiveKit support."
+                                    })
+                                    .checked(current.livekit)
+                                    .on_click({
+                                        let flags = flags.clone();
+                                        let livekit = livekit.clone();
+
+                                        move |next, _window, cx| {
+                                            if *next && *livekit.read(cx) == Some(false) {
+                                                return;
+                                            }
+                                            flags.update(cx, |flags, cx| {
+                                                flags.livekit = *next;
+                                                cx.notify();
+                                            });
+                                        }
+                                    }),
+                            ),
+                    ),
+            )
+            .on_ok({
+                let group = group.clone();
+                let name = name.clone();
+                let about = about.clone();
+                let picture = picture.clone();
+                let parent = parent.clone();
+                let children = children.clone();
+                let flags = flags.clone();
+
+                move |_event, window, cx| {
+                    let mut next = group
+                        .read_with(cx, |group, _cx| group.metadata().cloned())
+                        .ok()
+                        .flatten()
+                        .unwrap_or_default();
+
+                    next.name = value(&name, cx);
+                    next.about = value(&about, cx);
+                    next.picture = value(&picture, cx);
+
+                    match value(&parent, cx).map(GroupId::new) {
+                        Some(Ok(id)) => next.parent = Some(id),
+                        Some(Err(error)) => {
+                            window.push_notification(Notification::error(error.to_string()), cx);
+                            return false;
+                        }
+                        None => next.parent = None,
+                    }
+
+                    next.children = children.read(cx).clone();
+
+                    // The relay must reject these anyway; catch them early.
+                    if let Some(id) = &next.parent {
+                        let key = group
+                            .read_with(cx, |group, _cx| group.key().id().as_str().to_owned())
+                            .ok();
+
+                        if key.as_deref() == Some(id.as_str()) {
+                            window.push_notification(
+                                Notification::error("A group can't be its own parent"),
+                                cx,
+                            );
+                            return false;
+                        }
+
+                        if next.children.iter().any(|child| child == id) {
+                            window.push_notification(
+                                Notification::error("The parent is one of this group's children"),
+                                cx,
+                            );
+                            return false;
+                        }
+                    }
+
+                    let current = flags.read(cx);
+                    next.private = current.private;
+                    next.restricted = current.restricted;
+                    next.hidden = current.hidden;
+                    next.closed = current.closed;
+                    next.livekit = current.livekit;
+
+                    match group.update(cx, |group, cx| group.edit_metadata(&next, cx)) {
+                        Ok(task) => crate::util::report(window, cx, task),
+                        Err(error) => log::warn!("nip29: editing the group failed: {error}"),
+                    }
+
+                    true
+                }
+            })
+    });
+}
+
+/// NIP-29: relays announce LiveKit support with a 204 at this well-known path.
+async fn probe_livekit(http: Arc<dyn HttpClient>, relay: RelayUrl) -> bool {
+    let base = relay
+        .as_str()
+        .replacen("wss://", "https://", 1)
+        .replacen("ws://", "http://", 1);
+    let url = format!("{}/.well-known/nip29/livekit", base.trim_end_matches('/'));
+
+    match http.get(&url, AsyncBody::default(), true).await {
+        Ok(response) => response.status() == 204,
+        Err(_) => false,
+    }
+}
+
+fn children_section(children: &Entity<Vec<GroupId>>, cx: &App) -> AnyElement {
+    let list = children.read(cx);
+
+    let mut section = v_flex()
+        .gap_1()
+        .text_style(TextStyle::Callout)
+        .text_color(cx.theme().text_muted)
+        .child("Children");
+
+    if list.is_empty() {
+        return section
+            .child(
+                div()
+                    .text_color(cx.theme().text_faint)
+                    .child("No subgroups"),
+            )
+            .into_any_element();
+    }
+
+    for (ix, child) in list.iter().enumerate() {
+        let order = h_flex()
+            .flex_shrink_0()
+            .gap_1()
+            .when(ix > 0, |this| {
+                this.child(move_button(children.clone(), ix, ix - 1, "up"))
+            })
+            .when(ix + 1 < list.len(), |this| {
+                this.child(move_button(children.clone(), ix, ix + 1, "down"))
+            });
+
+        section = section.child(
+            h_flex()
+                .justify_between()
+                .gap_2()
+                .child(
+                    div()
+                        .min_w_0()
+                        .truncate()
+                        .text_color(cx.theme().text)
+                        .child(SharedString::from(child.as_str().to_owned())),
+                )
+                .child(order),
+        );
+    }
+
+    section.into_any_element()
+}
+
+fn move_button(
+    children: Entity<Vec<GroupId>>,
+    ix: usize,
+    target: usize,
+    direction: &'static str,
+) -> Button {
+    Button::new(SharedString::from(format!("child-{direction}-{ix}")))
+        .label(if direction == "up" { "Up" } else { "Down" })
+        .ghost()
+        .small()
+        .on_click(move |_event, _window, cx| {
+            children.update(cx, |children, cx| {
+                if target < children.len() {
+                    children.swap(ix, target);
+                    cx.notify();
+                }
+            });
+        })
+}
+
+fn toggle(
+    flags: &Entity<Flags>,
+    select: fn(&mut Flags) -> &mut bool,
+) -> impl Fn(&bool, &mut Window, &mut App) + 'static {
+    let flags = flags.clone();
+
+    move |next, _window, cx| {
+        flags.update(cx, |flags, cx| {
+            *select(flags) = *next;
+            cx.notify();
+        });
+    }
+}
+
+fn value(input: &Entity<InputState>, cx: &App) -> Option<String> {
+    let value = input.read(cx).value().trim().to_owned();
+
+    (!value.is_empty()).then_some(value)
+}

crates/nip29_ui/src/util.rs

@@ -0,0 +1,86 @@
+use anyhow::Result;
+use gpui::{App, Div, Entity, ParentElement, SharedString, Styled, Task, Window};
+use nip29::{Group, Pin, Row};
+use nostr_sdk::prelude::Url;
+use theme::{ActiveTheme, TextStyle, Typeset as _};
+use ui::input::{Input, InputState};
+use ui::notification::Notification;
+use ui::{WindowExtension, v_flex};
+
+pub(crate) fn display_name(group: &Group) -> SharedString {
+    group
+        .metadata()
+        .and_then(|metadata| metadata.name())
+        .map_or_else(
+            || SharedString::from(group.key().id().as_str()),
+            SharedString::from,
+        )
+}
+
+pub(crate) fn attachment_name(url: &Url) -> SharedString {
+    url.path_segments()
+        .and_then(|mut segments| segments.next_back())
+        .filter(|name| !name.is_empty())
+        .map_or_else(
+            || SharedString::from(url.as_str()),
+            |name| SharedString::from(name.to_owned()),
+        )
+}
+
+pub(crate) fn opens_run(rows: &[Row], index: usize) -> bool {
+    let (Some(current), Some(previous)) = (
+        rows.get(index),
+        index.checked_sub(1).and_then(|index| rows.get(index)),
+    ) else {
+        return true;
+    };
+
+    match (current, previous) {
+        (Row::Message(current), Row::Message(previous)) => ui::message::opens_run(
+            Some((previous.author, previous.created_at.as_secs())),
+            (current.author, current.created_at.as_secs()),
+        ),
+        _ => true,
+    }
+}
+
+pub(crate) fn field(label: &'static str, input: &Entity<InputState>, cx: &App) -> Div {
+    v_flex()
+        .gap_1()
+        .text_style(TextStyle::Callout)
+        .text_color(cx.theme().text_muted)
+        .child(label)
+        .child(Input::new(input))
+}
+
+pub(crate) fn pin_label(group: &Group, pin: &Pin) -> SharedString {
+    match pin {
+        Pin::Address(coordinate) => SharedString::from(format!("{coordinate}")),
+        Pin::Event(id) => {
+            let snippet = group
+                .message(*id)
+                .and_then(|message| message.content.lines().next())
+                .map(str::trim)
+                .filter(|line| !line.is_empty());
+
+            match snippet {
+                Some(snippet) => SharedString::from(snippet.chars().take(48).collect::<String>()),
+                None => SharedString::from(id.to_hex().chars().take(8).collect::<String>()),
+            }
+        }
+    }
+}
+
+/// Await a group write and surface any relay error as a notification.
+pub(crate) fn report(window: &mut Window, cx: &mut App, task: Task<Result<()>>) {
+    window
+        .spawn(cx, async move |cx| -> Result<()> {
+            if let Err(error) = task.await {
+                cx.update(|window, cx| {
+                    window.push_notification(Notification::error(error.to_string()), cx);
+                })?;
+            }
+            Ok(())
+        })
+        .detach();
+}

crates/nip4e/Cargo.toml

@@ -1,11 +1,10 @@
 [package]
-name = "device"
+name = "nip4e"
 version.workspace = true
 edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-common = { path = "../common" }
 state = { path = "../state" }
 person = { path = "../person" }
 ui = { path = "../ui" }
@@ -14,7 +13,6 @@ settings = { path = "../settings" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 anyhow.workspace = true
 smallvec.workspace = true
 log.workspace = true

crates/nip4e/src/lib.rs

@@ -8,15 +8,14 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::{
     App, AppContext, Context, Entity, EventEmitter, Global, IntoElement, ParentElement,
-    SharedString, Styled, Subscription, Task, Window, div, relative,
+    SharedString, Styled, Subscription, Task, Window, div, px, relative,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
-use person::PersonRegistry;
+use person::Directory;
 use settings::AppSettings;
 use smallvec::{SmallVec, smallvec};
 use state::{Announcement, CLIENT_NAME, NostrRegistry, UniversalSigner};
-use theme::ActiveTheme;
+use theme::{ActiveTheme, TextStyle, Typeset as _, control_radius};
 use ui::avatar::Avatar;
 use ui::button::Button;
 use ui::notification::{Notification, NotificationKind};
@@ -24,8 +23,8 @@ use ui::{Disableable, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 const IDENTIFIER: &str = "coop:device";
 
-pub fn init(window: &mut Window, cx: &mut App) {
-    DeviceRegistry::set_global(cx.new(|cx| DeviceRegistry::new(window, cx)), cx);
+pub fn init(cx: &mut App) {
+    DeviceRegistry::set_global(cx.new(DeviceRegistry::new), cx);
 }
 
 struct GlobalDeviceRegistry(Entity<DeviceRegistry>);
@@ -40,13 +39,13 @@ pub enum DeviceEvent {
     /// User have not setup encryption key
     NotSet,
     /// The device is requesting an encryption key
-    Requesting,
+    Requesting(SharedString),
     /// An error occurred
     Error(SharedString),
 }
 
 impl DeviceEvent {
-    pub fn error<T>(error: T) -> Self
+    pub(crate) fn error<T>(error: T) -> Self
     where
         T: Into<SharedString>,
     {
@@ -59,19 +58,16 @@ impl DeviceEvent {
 /// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
 #[derive(Debug)]
 pub struct DeviceRegistry {
-    /// Whether there is a pending request for encryption key approval
-    pub pending_request: bool,
-
-    /// Whether an announcement has been made for this device
-    pub announcement_existed: Arc<AtomicBool>,
-
-    /// Signer
     signer: Entity<Option<UniversalSigner>>,
-
-    /// Async tasks
+    /// Whether there is a pending request for encryption key approval
+    pub(crate) pending_request: bool,
+    /// Whether an announcement has been made for this device
+    pub(crate) announcement_existed: Arc<AtomicBool>,
+    /// Person directory for requesters shown in notifications
+    directory: Entity<Directory>,
+    /// Relay notification listener
+    notification_listener: Option<Task<Result<(), Error>>>,
     tasks: Vec<Task<Result<(), Error>>>,
-
-    /// Event subscription
     _subscriptions: SmallVec<[Subscription; 2]>,
 }
 
@@ -89,7 +85,8 @@ impl DeviceRegistry {
     }
 
     /// Create a new device registry instance
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(cx: &mut Context<Self>) -> Self {
+        let entity = cx.entity().downgrade();
         let nostr = NostrRegistry::global(cx);
         let settings = AppSettings::global(cx);
 
@@ -109,25 +106,34 @@ impl DeviceRegistry {
             // Observe the user signer
             cx.subscribe(&nostr, move |this, _nostr, event, cx| {
                 if event.signer_changed() && settings.read(cx).is_nip4e_enabled(cx) {
+                    // The old account's state must not leak into the new one
+                    this.announcement_existed.store(false, Ordering::Relaxed);
+                    this.handle_notifications(cx);
                     this.get_announcement(cx);
                 }
             }),
         );
 
-        cx.defer_in(window, |this, window, cx| {
-            this.handle_notifications(window, cx);
+        cx.defer(move |cx| {
+            entity
+                .update(cx, |this, cx| this.handle_notifications(cx))
+                .ok();
         });
 
         Self {
             signer,
             pending_request: false,
             announcement_existed: Arc::new(AtomicBool::new(false)),
+            directory: Directory::new(cx),
+            notification_listener: None,
             tasks: vec![],
             _subscriptions: subscriptions,
         }
     }
 
-    fn handle_notifications(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    fn handle_notifications(&mut self, cx: &mut Context<Self>) {
+        self.notification_listener = None;
+
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
@@ -135,7 +141,7 @@ impl DeviceRegistry {
         let announcement_existed = self.announcement_existed.clone();
         let (tx, rx) = flume::bounded::<Event>(100);
 
-        self.tasks.push(cx.background_spawn(async move {
+        self.notification_listener = Some(cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
             let current_user = signer.get_public_key_async().await.ok();
@@ -168,18 +174,18 @@ impl DeviceRegistry {
             Ok(())
         }));
 
-        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+        self.tasks.push(cx.spawn(async move |this, cx| {
             while let Ok(event) = rx.recv_async().await {
                 match event.kind {
                     Kind::Custom(10044) => {
-                        this.update_in(cx, |this, _window, cx| {
+                        this.update(cx, |this, cx| {
                             this.set_encryption(&event, cx);
                         })?;
                     }
                     // New request event from other device
                     Kind::Custom(4454) => {
-                        this.update_in(cx, |this, window, cx| {
-                            this.ask_for_approval(event, window, cx);
+                        this.update(cx, |this, cx| {
+                            this.ask_for_approval(event, cx);
                         })?;
                     }
                     // New response event from the master device
@@ -242,39 +248,41 @@ impl DeviceRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        self.tasks.push(cx.background_spawn(async move {
-            let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
-            let current_user = signer.get_public_key_async().await?;
-
-            // Construct the filter for the device announcement event
-            let filter = Filter::new()
-                .kind(Kind::Custom(10044))
-                .author(current_user)
-                .limit(1);
-
-            client
-                .subscribe(filter)
-                .close_on(opts)
-                .with_id(SubscriptionId::new("nip4e"))
-                .await?;
-
-            Ok(())
-        }));
-
         let announcement_existed = self.announcement_existed.clone();
 
         self.tasks.push(cx.spawn(async move |this, cx| {
-            // Wait for 5 seconds
-            cx.background_executor().timer(Duration::from_secs(5)).await;
+            let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+                let opts =
+                    SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
+                let current_user = signer.get_public_key_async().await?;
 
-            // Then check if the msg relays have been found
-            if announcement_existed.load(Ordering::Acquire) {
+                // Construct the filter for the device announcement event
+                let filter = Filter::new()
+                    .kind(Kind::Custom(10044))
+                    .author(current_user)
+                    .limit(1);
+
+                client
+                    .subscribe(filter)
+                    .close_on(opts)
+                    .with_id(SubscriptionId::new("nip4e"))
+                    .await?;
+
+                Ok(())
+            });
+
+            if let Err(e) = task.await {
+                this.update(cx, |_this, cx| {
+                    cx.emit(DeviceEvent::error(e.to_string()));
+                })?;
                 return Ok(());
             }
 
-            this.update(cx, |_this, cx| {
-                cx.emit(DeviceEvent::NotSet);
-            })?;
+            if !announcement_existed.load(Ordering::Acquire) {
+                this.update(cx, |_this, cx| {
+                    cx.emit(DeviceEvent::NotSet);
+                })?;
+            }
 
             Ok(())
         }));
@@ -314,13 +322,13 @@ impl DeviceRegistry {
         cx.background_spawn(async move {
             // Construct an announcement event
             let event = EventBuilder::new(Kind::Custom(10044), "")
-                .tags(vec![
-                    Tag::custom("n", vec![n]),
-                    Tag::custom("client", vec![CLIENT_NAME]),
-                ])
+                .tag(Tag::custom("n", vec![n]))
                 .finalize_async(&signer)
                 .await?;
 
+            // Persist the key locally before announcing it
+            set_keys(&client, &signer, &secret).await?;
+
             // Publish announcement
             client
                 .send_event(&event)
@@ -328,20 +336,21 @@ impl DeviceRegistry {
                 .ack_policy(AckPolicy::none())
                 .await?;
 
-            // Save device keys to the database
-            set_keys(&client, &signer, &secret).await?;
-
             Ok(keys)
         })
     }
 
     /// Set encryption key from the announcement event
     fn set_encryption(&mut self, event: &Event, cx: &mut Context<Self>) {
+        let Some(announcement) = Announcement::from_event(event) else {
+            log::warn!("Ignoring malformed encryption announcement");
+            return;
+        };
+
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        let announcement = Announcement::from(event);
         let device_pubkey = announcement.public_key();
 
         // Get encryption key from the database and compare with the announcement
@@ -381,11 +390,8 @@ impl DeviceRegistry {
             let public_key = signer.get_public_key_async().await?;
             let id = SubscriptionId::new("dekey-requests");
 
-            // Construct a filter for encryption key requests
-            let filter = Filter::new()
-                .kind(Kind::Custom(4454))
-                .author(public_key)
-                .since(Timestamp::now());
+            // Construct a filter for encryption key requests.
+            let filter = Filter::new().kind(Kind::Custom(4454)).author(public_key);
 
             // Subscribe to the device key requests on user's write relays
             client.subscribe(vec![filter]).with_id(id).await?;
@@ -395,7 +401,7 @@ impl DeviceRegistry {
     }
 
     /// Request encryption keys from other device
-    pub fn request(&mut self, cx: &mut Context<Self>) {
+    pub(crate) fn request(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
@@ -414,26 +420,27 @@ impl DeviceRegistry {
                 .pubkey(app_pubkey)
                 .limit(1);
 
-            match client.database().query(filter).await?.into_iter().next() {
-                // Found an approval event
-                Some(event) => Ok(Some(event)),
-                // No approval event found, construct a request event
-                None => {
-                    // Construct an event for device key request
-                    let event = EventBuilder::new(Kind::Custom(4454), "")
-                        .tags(vec![
-                            Tag::custom("P", vec![app_pubkey]),
-                            Tag::custom("client", vec![CLIENT_NAME]),
-                        ])
-                        .finalize_async(&signer)
-                        .await?;
-
-                    // Send the event to write relays
-                    client.send_event(&event).to_nip65().await?;
-
-                    Ok(None)
+            if let Some(event) = client.database().query(filter).await?.into_iter().next() {
+                // Only reuse the stored approval if its key is still valid,
+                // otherwise it's stale and a fresh request is needed
+                if decrypt_approval(&client, &app_keys, public_key, &event)
+                    .await
+                    .is_ok()
+                {
+                    return Ok(Some(event));
                 }
             }
+
+            // No usable approval event found, construct a request event
+            let event = EventBuilder::new(Kind::Custom(4454), "")
+                .tags(vec![Tag::custom("P", vec![app_pubkey])])
+                .finalize_async(&signer)
+                .await?;
+
+            // Send the event to write relays
+            client.send_event(&event).to_nip65().await?;
+
+            Ok(None)
         });
 
         self.tasks.push(cx.spawn(async move |this, cx| {
@@ -463,20 +470,45 @@ impl DeviceRegistry {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
+        let app_keys_task = get_or_init_app_keys(cx);
 
-        cx.emit(DeviceEvent::Requesting);
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            let app_keys = match app_keys_task.await {
+                Ok(app_keys) => app_keys,
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(DeviceEvent::error(e.to_string()));
+                    })?;
+                    return Ok(());
+                }
+            };
 
-        self.tasks.push(cx.background_spawn(async move {
-            let public_key = signer.get_public_key_async().await?;
+            this.update(cx, |_this, cx| {
+                cx.emit(DeviceEvent::Requesting(authorization_code(
+                    &app_keys.public_key(),
+                )));
+            })?;
 
-            // Construct a filter for device key requests
-            let filter = Filter::new()
-                .kind(Kind::Custom(4455))
-                .author(public_key)
-                .since(Timestamp::now());
+            let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+                let public_key = signer.get_public_key_async().await?;
 
-            // Subscribe to the device key requests on user's write relays
-            client.subscribe(filter).await?;
+                // Only approvals addressed to this device's app key matter
+                let filter = Filter::new()
+                    .kind(Kind::Custom(4455))
+                    .author(public_key)
+                    .pubkey(app_keys.public_key());
+
+                // Subscribe to the device key approvals on user's write relays
+                client.subscribe(filter).await?;
+
+                Ok(())
+            });
+
+            if let Err(e) = task.await {
+                this.update(cx, |_this, cx| {
+                    cx.emit(DeviceEvent::error(e.to_string()));
+                })?;
+            }
 
             Ok(())
         }));
@@ -485,22 +517,16 @@ impl DeviceRegistry {
     /// Parse the approval event to get encryption key then set it
     fn extract_encryption(&mut self, event: Event, cx: &mut Context<Self>) {
         let app_keys_task = get_or_init_app_keys(cx);
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+
+        let approval_id = event.id;
 
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
             let app_keys = app_keys_task.await?;
-            let master = event
-                .tags
-                .iter()
-                .find(|tag| tag.kind() == "P")
-                .and_then(|tag| tag.content())
-                .and_then(|content| PublicKey::parse(content).ok())
-                .context("Invalid event's tags")?;
-
-            let payload = event.content.as_str();
-            let decrypted = app_keys.nip44_decrypt_async(&master, payload).await?;
-
-            let secret = SecretKey::from_hex(&decrypted)?;
-            let keys = Keys::new(secret);
+            let identity = signer.get_public_key_async().await?;
+            let keys = decrypt_approval(&client, &app_keys, identity, &event).await?;
 
             Ok(keys)
         });
@@ -510,6 +536,8 @@ impl DeviceRegistry {
                 Ok(keys) => {
                     this.update(cx, |this, cx| {
                         this.set_signer(keys, cx);
+                        // Clean up our request and the approval event from relays
+                        this.cleanup_sync_events(approval_id, cx);
                     })?;
                 }
                 Err(e) => {
@@ -522,6 +550,47 @@ impl DeviceRegistry {
         }));
     }
 
+    /// Delete our key request and the consumed approval event from relays
+    fn cleanup_sync_events(&mut self, approval_id: EventId, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+
+        self.tasks.push(cx.background_spawn(async move {
+            let result: Result<(), Error> = async {
+                let public_key = signer.get_public_key_async().await?;
+
+                // Collect our key request events
+                let filter = Filter::new().kind(Kind::Custom(4454)).author(public_key);
+
+                let mut ids: Vec<EventId> = client
+                    .database()
+                    .query(filter)
+                    .await?
+                    .into_iter()
+                    .map(|event| event.id)
+                    .collect();
+                ids.push(approval_id);
+
+                let deletion = EventBuilder::new(Kind::EventDeletion, "")
+                    .tags(Tags::from_list(ids.into_iter().map(Tag::event).collect()))
+                    .finalize_async(&signer)
+                    .await?;
+
+                client.send_event(&deletion).to_nip65().await?;
+
+                Ok(())
+            }
+            .await;
+
+            if let Err(e) = result {
+                log::error!("Failed to delete sync events: {e}");
+            }
+
+            Ok(())
+        }));
+    }
+
     /// Approve requests for device keys from other devices
     fn approve(&mut self, event: &Event, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
@@ -567,9 +636,14 @@ impl DeviceRegistry {
             Ok(())
         });
 
-        self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             match task.await {
                 Ok(_) => {
+                    this.update(cx, |this, cx| {
+                        // Allow future requests to surface again
+                        this.set_pending_request(false, cx);
+                    })?;
+
                     cx.update(|window, cx| {
                         window.clear_notification_by_id::<DeviceNotification>(id, cx);
                     })
@@ -591,57 +665,89 @@ impl DeviceRegistry {
     }
 
     /// Handle encryption request
-    fn ask_for_approval(&mut self, event: Event, window: &mut Window, cx: &mut Context<Self>) {
+    fn ask_for_approval(&mut self, event: Event, cx: &mut Context<Self>) {
         // Ignore if there is already a pending request
         if self.pending_request {
             return;
         }
         self.set_pending_request(true, cx);
 
-        // Show notification
-        let notification = self.notification(event, cx);
-        window.push_notification(notification, cx);
+        let notification = match self.notification(event, cx) {
+            Ok(notification) => notification,
+            Err(e) => {
+                log::warn!("Ignoring invalid encryption key request: {e}");
+                self.set_pending_request(false, cx);
+                return;
+            }
+        };
+
+        if let Some(window) = cx.windows().first().copied() {
+            if let Err(error) = window.update(cx, |_view, window, cx| {
+                window.push_notification(notification, cx);
+            }) {
+                log::warn!("Failed to show encryption key request: {error}");
+            }
+        } else {
+            log::warn!("Failed to show encryption key request: no open window");
+        }
     }
 
     /// Build a notification for the encryption request.
-    fn notification(&self, event: Event, cx: &Context<Self>) -> Notification {
+    fn notification(
+        &mut self,
+        event: Event,
+        cx: &mut Context<Self>,
+    ) -> Result<Notification, Error> {
         const MSG: &str = "You've requested an encryption key from another device. \
-                           Approve to allow Coop to share with it.";
+                           Approve to allow Coop to share with it. Before approving, \
+                           compare the code with the one shown on the requesting \
+                           device.";
 
-        let request = Announcement::from(&event);
-        let persons = PersonRegistry::global(cx);
-        let profile = persons.read(cx).get(&request.public_key(), cx);
+        let requester = event
+            .tags
+            .iter()
+            .find(|tag| tag.kind() == "P")
+            .and_then(|tag| tag.content())
+            .and_then(|content| PublicKey::parse(content).ok())
+            .context("Request has no valid requester key")?;
+
+        let code = authorization_code(&requester);
+        let directory = self.directory.clone();
+        directory.update(cx, |directory, cx| directory.track([requester], cx));
+        let code_label = code.clone();
 
         let entity = cx.entity().downgrade();
         let loading = Rc::new(Cell::new(false));
         let key = SharedString::from(event.id.to_hex());
 
-        Notification::new()
+        Ok(Notification::new()
             .type_id::<DeviceNotification>(key)
             .autohide(false)
             .with_kind(NotificationKind::Info)
             .title("Encryption Key Request")
             .content(move |_this, _window, cx| {
+                let profile = directory.read(cx).person(&requester, cx);
+
                 v_flex()
-                    .gap_2()
-                    .text_sm()
+                    .gap(px(theme::SPACE))
+                    .text_style(TextStyle::Callout)
                     .child(
                         div()
-                            .text_sm()
+                            .text_style(TextStyle::Callout)
                             .line_height(relative(1.25))
                             .child(SharedString::from(MSG)),
                     )
                     .child(
                         v_flex()
-                            .gap_2()
+                            .gap(px(theme::SPACE))
                             .child(
                                 v_flex()
                                     .gap_1()
-                                    .text_sm()
+                                    .text_style(TextStyle::Callout)
                                     .child(
                                         div()
                                             .font_semibold()
-                                            .text_xs()
+                                            .text_style(TextStyle::Caption)
                                             .text_color(cx.theme().text_muted)
                                             .child(SharedString::from("From:")),
                                     )
@@ -650,12 +756,16 @@ impl DeviceRegistry {
                                             .h_8()
                                             .w_full()
                                             .px_2()
-                                            .rounded(cx.theme().radius)
-                                            .bg(cx.theme().elevated_surface_background)
+                                            .rounded(px(control_radius()))
+                                            .bg(cx.theme().surface_card)
                                             .child(
                                                 h_flex()
-                                                    .gap_2()
-                                                    .child(Avatar::new(profile.avatar()).xsmall())
+                                                    .gap(px(theme::SPACE))
+                                                    .child(
+                                                        Avatar::new(profile.avatar())
+                                                            .seed(profile.avatar_seed())
+                                                            .xsmall(),
+                                                    )
                                                     .child(profile.name()),
                                             ),
                                     ),
@@ -663,22 +773,22 @@ impl DeviceRegistry {
                             .child(
                                 v_flex()
                                     .gap_1()
-                                    .text_sm()
+                                    .text_style(TextStyle::Callout)
                                     .child(
                                         div()
                                             .font_semibold()
-                                            .text_xs()
+                                            .text_style(TextStyle::Caption)
                                             .text_color(cx.theme().text_muted)
-                                            .child(SharedString::from("Client:")),
+                                            .child(SharedString::from("Code:")),
                                     )
                                     .child(
                                         div()
                                             .h_8()
                                             .w_full()
                                             .px_2()
-                                            .rounded(cx.theme().radius)
-                                            .bg(cx.theme().elevated_surface_background)
-                                            .child(request.client_name()),
+                                            .rounded(px(control_radius()))
+                                            .bg(cx.theme().surface_card)
+                                            .child(code_label.clone()),
                                     ),
                             ),
                     )
@@ -704,12 +814,19 @@ impl DeviceRegistry {
                             .ok();
                         }
                     })
-            })
+            }))
     }
 }
 
 struct DeviceNotification;
 
+/// The first eight hexadecimal characters of the client public key.
+fn authorization_code(public_key: &PublicKey) -> SharedString {
+    let hex = public_key.to_hex();
+    let code = hex[..8].to_uppercase();
+    SharedString::from(format!("{} {}", &code[..4], &code[4..]))
+}
+
 /// Get or create new app keys (async, returns a task)
 fn get_or_init_app_keys(cx: &App) -> Task<Result<Keys, Error>> {
     let read = cx.read_credentials(CLIENT_NAME);
@@ -740,8 +857,56 @@ fn get_or_init_app_keys(cx: &App) -> Task<Result<Keys, Error>> {
     })
 }
 
+/// Decrypt and validate an approval event against the current announcement.
+async fn decrypt_approval(
+    client: &Client,
+    app_keys: &Keys,
+    identity: PublicKey,
+    event: &Event,
+) -> Result<Keys, Error> {
+    let master = event
+        .tags
+        .iter()
+        .find(|tag| tag.kind() == "P")
+        .and_then(|tag| tag.content())
+        .and_then(|content| PublicKey::parse(content).ok())
+        .context("Invalid event's tags")?;
+
+    let decrypted = app_keys
+        .nip44_decrypt_async(&master, event.content.as_str())
+        .await?;
+
+    let secret = SecretKey::from_hex(&decrypted)?;
+    let keys = Keys::new(secret);
+
+    // Reject approvals carrying a key that no longer matches the published announcement.
+    let filter = Filter::new()
+        .kind(Kind::Custom(10044))
+        .author(identity)
+        .limit(1);
+
+    if let Some(announcement) = client.database().query(filter).await?.into_iter().next() {
+        let announced = announcement
+            .tags
+            .iter()
+            .find(|tag| tag.kind() == "n")
+            .and_then(|tag| tag.content())
+            .and_then(|content| PublicKey::parse(content).ok())
+            .context("Announcement has no valid encryption key")?;
+
+        if keys.public_key() != announced {
+            return Err(anyhow!("Approval key doesn't match the announcement"));
+        }
+    }
+
+    Ok(keys)
+}
+
 /// Encrypt and store device keys in the local database.
-async fn set_keys(client: &Client, signer: &UniversalSigner, secret: &str) -> Result<(), Error> {
+async fn set_keys<S>(client: &Client, signer: &S, secret: &str) -> Result<(), Error>
+where
+    S: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + ?Sized,
+{
     let public_key = signer.get_public_key_async().await?;
     let content = signer.nip44_encrypt_async(&public_key, secret).await?;
 
@@ -758,7 +923,10 @@ async fn set_keys(client: &Client, signer: &UniversalSigner, secret: &str) -> Re
 }
 
 /// Get device keys from the local database.
-async fn get_keys(client: &Client, signer: &UniversalSigner) -> Result<Keys, Error> {
+async fn get_keys<S>(client: &Client, signer: &S) -> Result<Keys, Error>
+where
+    S: AsyncGetPublicKey + AsyncNip44 + ?Sized,
+{
     let public_key = signer.get_public_key_async().await?;
 
     let filter = Filter::new()

crates/person/src/directory.rs

@@ -0,0 +1,234 @@
+use std::cmp::Reverse;
+use std::collections::{HashMap, HashSet};
+use std::sync::RwLock;
+
+use anyhow::Error;
+use common::emojis_from_tags;
+use gpui::{App, AppContext, Context, Entity, Subscription, Task};
+use nostr_sdk::prelude::*;
+use smallvec::{SmallVec, smallvec};
+use state::NostrRegistry;
+
+use crate::{Person, PersonEvent, PersonRegistry};
+
+/// Directory of persons tracked by a view
+#[derive(Debug)]
+pub struct Directory {
+    persons: HashMap<PublicKey, Person>,
+    /// Keys awaiting their first update, guarded for render-time access
+    pending: RwLock<HashSet<PublicKey>>,
+    tasks: SmallVec<[Task<()>; 2]>,
+    _subscriptions: SmallVec<[Subscription; 1]>,
+}
+
+impl Directory {
+    /// Create a directory following the registry's events
+    pub fn new(cx: &mut App) -> Entity<Self> {
+        let registry = PersonRegistry::global(cx);
+
+        cx.new(|cx| {
+            let subscription = cx.subscribe(&registry, |this: &mut Self, _registry, event, cx| {
+                this.handle_event(event.clone(), cx);
+            });
+
+            Self {
+                persons: HashMap::new(),
+                pending: RwLock::new(HashSet::new()),
+                tasks: SmallVec::new(),
+                _subscriptions: smallvec![subscription],
+            }
+        })
+    }
+
+    /// Load known profiles from the database, request the rest
+    pub fn track(&mut self, keys: impl IntoIterator<Item = PublicKey>, cx: &mut Context<Self>) {
+        /// Profiles and emoji lists loaded from the database
+        type Loaded = (Vec<Person>, Vec<(PublicKey, Vec<(String, Url)>)>);
+
+        let missing: Vec<PublicKey> = keys
+            .into_iter()
+            .filter(|key| {
+                !self.persons.contains_key(key)
+                    && !self.with_pending(|pending| pending.contains(key))
+            })
+            .collect();
+
+        if missing.is_empty() {
+            return;
+        }
+
+        // Accept events that arrive while the database query is running
+        self.with_pending(|pending| {
+            pending.extend(missing.iter().copied());
+        });
+
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let authors = missing.clone();
+
+        let task: Task<Result<Loaded, Error>> = cx.background_spawn(async move {
+            let mut metadata_events: Vec<Event> = client
+                .database()
+                .query(Filter::new().kind(Kind::Metadata).authors(authors.clone()))
+                .await?
+                .into_iter()
+                .collect();
+
+            // Keep only the newest event per author
+            metadata_events.sort_by_key(|event| Reverse(event.created_at));
+            let mut seen = HashSet::new();
+
+            let persons = metadata_events
+                .into_iter()
+                .filter(|event| seen.insert(event.pubkey))
+                .map(|event| {
+                    let metadata = Metadata::from_json(event.content).unwrap_or_default();
+                    Person::new(event.pubkey, metadata)
+                })
+                .collect();
+
+            let mut emoji_events: Vec<Event> = client
+                .database()
+                .query(Filter::new().kind(Kind::Emojis).authors(authors))
+                .await?
+                .into_iter()
+                .collect();
+
+            // Keep only the newest event per author
+            emoji_events.sort_by_key(|event| Reverse(event.created_at));
+            let mut seen = HashSet::new();
+
+            let emojis = emoji_events
+                .into_iter()
+                .filter(|event| seen.insert(event.pubkey))
+                .map(|event| (event.pubkey, emojis_from_tags(&event.tags)))
+                .collect();
+
+            Ok((persons, emojis))
+        });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            let loaded = task.await;
+
+            this.update(cx, |this, cx| {
+                let remaining = match loaded {
+                    Ok((persons, emojis)) => {
+                        let found: HashSet<PublicKey> =
+                            persons.iter().map(Person::public_key).collect();
+                        this.bulk_insert(persons, cx);
+
+                        // Emojis apply on top of loaded or already received data
+                        let mut updated = false;
+
+                        for (public_key, emojis) in emojis {
+                            if emojis.is_empty() {
+                                continue;
+                            }
+
+                            let person = this
+                                .persons
+                                .entry(public_key)
+                                .or_insert_with(|| Person::new(public_key, Metadata::default()));
+                            person.set_emojis(emojis);
+                            updated = true;
+                        }
+
+                        if updated {
+                            cx.notify();
+                        }
+
+                        missing
+                            .into_iter()
+                            .filter(|key| !found.contains(key))
+                            .collect()
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to load persons from the database: {e}");
+                        missing
+                    }
+                };
+
+                if !remaining.is_empty() {
+                    let registry = PersonRegistry::global(cx);
+                    registry.read(cx).fetch(remaining);
+                }
+            })
+            .ok();
+        }));
+    }
+
+    /// The person for a key, or a placeholder that queues a request
+    pub fn person(&self, public_key: &PublicKey, cx: &App) -> Person {
+        if let Some(person) = self.persons.get(public_key) {
+            return person.clone();
+        }
+
+        if self.with_pending(|pending| pending.insert(*public_key)) {
+            let registry = PersonRegistry::global(cx);
+            registry.read(cx).fetch([*public_key]);
+        }
+
+        Person::new(*public_key, Metadata::default())
+    }
+
+    /// Merge event data into the tracked person
+    fn handle_event(&mut self, event: PersonEvent, cx: &mut Context<Self>) {
+        let public_key = match &event {
+            PersonEvent::Metadata(person) => person.public_key(),
+            PersonEvent::Emojis { public_key, .. }
+            | PersonEvent::Announcement { public_key, .. }
+            | PersonEvent::MessagingRelays { public_key, .. } => *public_key,
+        };
+
+        if !self.persons.contains_key(&public_key)
+            && !self.with_pending(|pending| pending.remove(&public_key))
+        {
+            return;
+        }
+
+        let person = self
+            .persons
+            .entry(public_key)
+            .or_insert_with(|| Person::new(public_key, Metadata::default()));
+
+        match event {
+            PersonEvent::Metadata(updated) => person.set_metadata(updated.metadata()),
+            PersonEvent::Emojis { emojis, .. } => person.set_emojis(emojis),
+            PersonEvent::Announcement { announcement, .. } => {
+                person.set_announcement(announcement);
+            }
+            PersonEvent::MessagingRelays { relays, .. } => person.set_messaging_relays(relays),
+        }
+
+        cx.notify();
+    }
+
+    /// Insert loaded persons, keeping data already received from relays
+    fn bulk_insert(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
+        let mut inserted = false;
+
+        for person in persons {
+            let public_key = person.public_key();
+
+            if self.persons.contains_key(&public_key) {
+                continue;
+            }
+
+            self.persons.insert(public_key, person);
+            inserted = true;
+        }
+
+        if inserted {
+            cx.notify();
+        }
+    }
+
+    /// Run `then` with the pending set, tolerating poisoning: it is only a dedupe cache
+    fn with_pending<R>(&self, then: impl FnOnce(&mut HashSet<PublicKey>) -> R) -> R {
+        let mut pending = match self.pending.write() {
+            Ok(pending) => pending,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        then(&mut pending)
+    }
+}

crates/person/src/lib.rs

@@ -2,46 +2,67 @@ use std::collections::{HashMap, HashSet};
 use std::sync::RwLock;
 
 use anyhow::{Error, anyhow};
-use common::EventExt;
-use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
+use common::emojis_from_tags;
+use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Subscription, Task};
 use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
 use state::{Announcement, BOOTSTRAP_RELAYS, NostrRegistry, TIMEOUT};
 
+mod directory;
 mod person;
 
+pub use directory::*;
 pub use person::*;
 
-pub fn init(window: &mut Window, cx: &mut App) {
-    PersonRegistry::set_global(cx.new(|cx| PersonRegistry::new(window, cx)), cx);
+pub fn init(cx: &mut App) {
+    PersonRegistry::set_global(cx.new(PersonRegistry::new), cx);
 }
 
 struct GlobalPersonRegistry(Entity<PersonRegistry>);
 
 impl Global for GlobalPersonRegistry {}
 
+/// A change to a person's data
+#[derive(Debug, Clone)]
+pub enum PersonEvent {
+    /// Profile metadata
+    Metadata(Box<Person>),
+    /// Custom emoji list (NIP-30)
+    Emojis {
+        public_key: PublicKey,
+        emojis: Vec<(String, Url)>,
+    },
+    /// Profile encryption keys announcement (NIP-4e)
+    Announcement {
+        public_key: PublicKey,
+        announcement: Announcement,
+    },
+    /// Messaging relay list (NIP-65)
+    MessagingRelays {
+        public_key: PublicKey,
+        relays: Vec<RelayUrl>,
+    },
+}
+
+impl EventEmitter<PersonEvent> for PersonRegistry {}
+
 #[derive(Debug, Clone)]
 enum Dispatch {
     Person(Person),
     Announcement(Event),
     Relays(Event),
+    Emojis(Event),
 }
 
 /// Person Registry
 #[derive(Debug)]
 pub struct PersonRegistry {
-    /// Collection of all persons (user profiles)
-    persons: HashMap<PublicKey, Entity<Person>>,
-
-    /// Set of public keys that have been seen
-    seen: RwLock<HashSet<PublicKey>>,
-
-    /// Sender for requesting metadata
+    /// Public keys with a metadata request in flight
+    in_flight: RwLock<HashSet<PublicKey>>,
     sender: flume::Sender<PublicKey>,
-
-    /// Tasks for asynchronous operations
     tasks: SmallVec<[Task<()>; 4]>,
+    _subscriptions: SmallVec<[Subscription; 1]>,
 }
 
 impl PersonRegistry {
@@ -56,7 +77,7 @@ impl PersonRegistry {
     }
 
     /// Create a new person registry instance
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
@@ -89,22 +110,26 @@ impl PersonRegistry {
                         Dispatch::Relays(event) => {
                             this.set_messaging_relays(&event, cx);
                         }
+                        Dispatch::Emojis(event) => {
+                            this.set_emojis(&event, cx);
+                        }
                     };
                 })
                 .ok();
             }
         }));
 
-        // Load all user profiles from the database
-        cx.defer_in(window, |this, _window, cx| {
-            this.load(cx);
+        let subscription = cx.subscribe(&nostr, |this, _nostr, event, cx| {
+            if event.signer_changed() {
+                this.get_emojis(cx);
+            }
         });
 
         Self {
-            persons: HashMap::new(),
-            seen: RwLock::new(HashSet::new()),
+            in_flight: RwLock::new(HashSet::new()),
             sender: metadata_tx,
             tasks,
+            _subscriptions: smallvec![subscription],
         }
     }
 
@@ -129,25 +154,21 @@ impl PersonRegistry {
                     Kind::Metadata => {
                         let metadata = Metadata::from_json(&event.content).unwrap_or_default();
                         let person = Person::new(event.pubkey, metadata);
+
                         if tx.send_async(Dispatch::Person(person)).await.is_err() {
-                            log::warn!("PersonRegistry channel closed, dropping metadata event");
-                        }
-                    }
-                    Kind::ContactList => {
-                        let public_keys = event.extract_public_keys();
-                        if let Err(e) = get_metadata(client, public_keys).await {
-                            log::warn!("Failed to get metadata for contact list: {e}");
+                            log::warn!("Channel closed, dropping metadata event");
                         }
                     }
                     Kind::InboxRelays => {
-                        tx.send_async(Dispatch::Relays(event.into_owned()))
-                            .await
-                            .ok();
+                        _ = tx.send_async(Dispatch::Relays(event.into_owned())).await;
+                    }
+                    Kind::Emojis => {
+                        _ = tx.send_async(Dispatch::Emojis(event.into_owned())).await;
                     }
                     Kind::Custom(10044) => {
-                        tx.send_async(Dispatch::Announcement(event.into_owned()))
-                            .await
-                            .ok();
+                        _ = tx
+                            .send_async(Dispatch::Announcement(event.into_owned()))
+                            .await;
                     }
                     _ => {}
                 }
@@ -184,116 +205,101 @@ impl PersonRegistry {
         }
     }
 
-    /// Load all user profiles from the database
-    fn load(&mut self, cx: &mut Context<Self>) {
+    /// Subscribe to the signed-in user's emoji list
+    fn get_emojis(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
+        let Some(public_key) = nostr.read(cx).current_user() else {
+            return;
+        };
 
-        let task: Task<Result<Vec<Person>, Error>> = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).limit(200);
-            let events = client.database().query(filter).await?;
-            let persons = events
-                .into_iter()
-                .map(|event| {
-                    let metadata = Metadata::from_json(event.content).unwrap_or_default();
-                    Person::new(event.pubkey, metadata)
-                })
-                .collect();
+        self.tasks.push(cx.background_spawn(async move {
+            let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
+            let filter = Filter::new().kind(Kind::Emojis).author(public_key).limit(1);
 
-            Ok(persons)
-        });
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            if let Ok(persons) = task.await {
-                this.update(cx, |this, cx| {
-                    this.bulk_insert(persons, cx);
-                })
-                .ok();
+            if let Err(e) = client.subscribe(vec![filter]).close_on(opts).await {
+                log::warn!("Failed to subscribe to emoji list: {e}");
             }
         }));
     }
 
     /// Set profile encryption keys announcement
-    fn set_announcement(&mut self, event: &Event, cx: &mut App) {
-        let announcement = Announcement::from(event);
+    fn set_announcement(&mut self, event: &Event, cx: &mut Context<Self>) {
+        let Some(announcement) = Announcement::from_event(event) else {
+            log::warn!("Ignoring announcement with missing or invalid key tag");
+            return;
+        };
 
-        if let Some(person) = self.persons.get(&event.pubkey) {
-            person.update(cx, |person, cx| {
-                person.set_announcement(announcement);
-                cx.notify();
-            });
-        } else {
-            let person =
-                Person::new(event.pubkey, Metadata::default()).with_announcement(announcement);
-            self.insert(person, cx);
-        }
+        cx.emit(PersonEvent::Announcement {
+            public_key: event.pubkey,
+            announcement,
+        });
     }
 
     /// Set messaging relays for a person
-    fn set_messaging_relays(&mut self, event: &Event, cx: &mut App) {
-        let urls: Vec<RelayUrl> = nip17::extract_relay_list(event).collect();
-
-        if let Some(person) = self.persons.get(&event.pubkey) {
-            person.update(cx, |person, cx| {
-                person.set_messaging_relays(urls);
-                cx.notify();
-            });
-        } else {
-            let person = Person::new(event.pubkey, Metadata::default()).with_messaging_relays(urls);
-            self.insert(person, cx);
-        }
+    fn set_messaging_relays(&mut self, event: &Event, cx: &mut Context<Self>) {
+        cx.emit(PersonEvent::MessagingRelays {
+            public_key: event.pubkey,
+            relays: nip17::extract_relay_list(event).collect(),
+        });
     }
 
-    /// Insert batch of persons
-    fn bulk_insert(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
-        for person in persons.into_iter() {
-            let public_key = person.public_key();
-            self.persons
-                .entry(public_key)
-                .or_insert_with(|| cx.new(|_| person));
-        }
-        cx.notify();
+    /// Set custom emoji for a person from their emoji list event
+    fn set_emojis(&mut self, event: &Event, cx: &mut Context<Self>) {
+        self.set_emojis_for(event.pubkey, emojis_from_tags(&event.tags), cx);
     }
 
-    /// Insert or update a person
-    pub fn insert(&mut self, person: Person, cx: &mut App) {
+    /// Set custom emoji for a person
+    fn set_emojis_for(
+        &mut self,
+        public_key: PublicKey,
+        emojis: Vec<(String, Url)>,
+        cx: &mut Context<Self>,
+    ) {
+        cx.emit(PersonEvent::Emojis { public_key, emojis });
+    }
+
+    /// Publish a person's profile metadata to every directory
+    pub fn insert(&mut self, person: Person, cx: &mut Context<Self>) {
         let public_key = person.public_key();
+        self.release_in_flight(&public_key);
 
-        match self.persons.get(&public_key) {
-            Some(this) => {
-                this.update(cx, |this, cx| {
-                    this.set_metadata(person.metadata());
-                    cx.notify();
-                });
+        cx.emit(PersonEvent::Metadata(Box::new(person)));
+    }
+
+    /// Queue a batched metadata request for keys without one in flight
+    pub(crate) fn fetch<I>(&self, keys: I)
+    where
+        I: IntoIterator<Item = PublicKey>,
+    {
+        let mut queue = Vec::new();
+        {
+            let mut in_flight = match self.in_flight.write() {
+                Ok(in_flight) => in_flight,
+                Err(poisoned) => poisoned.into_inner(),
+            };
+
+            for key in keys {
+                if in_flight.insert(key) {
+                    queue.push(key);
+                }
             }
-            None => {
-                self.persons.insert(public_key, cx.new(|_| person));
+        }
+
+        for public_key in queue {
+            if let Err(error) = self.sender.send(public_key) {
+                log::warn!("Failed to queue metadata request: {error}");
             }
         }
     }
 
-    /// Get single person by public key
-    pub fn get(&self, public_key: &PublicKey, cx: &App) -> Person {
-        if let Some(person) = self.persons.get(public_key) {
-            return person.read(cx).clone();
-        }
-
-        let public_key = *public_key;
-
-        if self.seen.write().unwrap().insert(public_key) {
-            let sender = self.sender.clone();
-
-            // Spawn background task to request metadata
-            cx.background_spawn(async move {
-                if let Err(e) = sender.send_async(public_key).await {
-                    log::warn!("Failed to send public key for metadata request: {e}");
-                }
-            })
-            .detach();
-        }
-
-        // Return a temporary profile with default metadata
-        Person::new(public_key, Metadata::default())
+    /// Allow future fetches for a key once its metadata has arrived
+    fn release_in_flight(&self, public_key: &PublicKey) {
+        let mut in_flight = match self.in_flight.write() {
+            Ok(in_flight) => in_flight,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        in_flight.remove(public_key);
     }
 }
 

crates/person/src/person.rs

@@ -10,13 +10,12 @@ use state::Announcement;
 pub struct Person {
     /// Public Key
     public_key: PublicKey,
-
     /// Metadata (profile)
     metadata: Metadata,
-
+    /// Custom emoji (NIP-30) from the person's emoji list
+    emojis: Vec<(String, Url)>,
     /// Dekey (NIP-4e) announcement
     announcement: Option<Announcement>,
-
     /// Messaging relays
     messaging_relays: Vec<RelayUrl>,
 }
@@ -47,37 +46,17 @@ impl Hash for Person {
     }
 }
 
-impl From<PublicKey> for Person {
-    fn from(public_key: PublicKey) -> Self {
-        Self::new(public_key, Metadata::default())
-    }
-}
-
 impl Person {
     pub fn new(public_key: PublicKey, metadata: Metadata) -> Self {
         Self {
             public_key,
             metadata,
+            emojis: vec![],
             announcement: None,
             messaging_relays: vec![],
         }
     }
 
-    /// Build profile encryption keys announcement
-    pub fn with_announcement(mut self, announcement: Announcement) -> Self {
-        self.announcement = Some(announcement);
-        self
-    }
-
-    /// Build profile messaging relays
-    pub fn with_messaging_relays<I>(mut self, relays: I) -> Self
-    where
-        I: IntoIterator<Item = RelayUrl>,
-    {
-        self.messaging_relays = relays.into_iter().collect();
-        self
-    }
-
     /// Get profile public key
     pub fn public_key(&self) -> PublicKey {
         self.public_key
@@ -88,6 +67,30 @@ impl Person {
         self.metadata.clone()
     }
 
+    /// Custom emoji (NIP-30) as (shortcode, image url) pairs
+    pub fn emojis(&self) -> &[(String, Url)] {
+        &self.emojis
+    }
+
+    /// Set custom emoji from the person's emoji list
+    pub(crate) fn set_emojis(&mut self, emojis: Vec<(String, Url)>) {
+        self.emojis = emojis;
+    }
+
+    /// An `emoji` tag for every custom emoji referenced as `:shortcode:` in `content`
+    pub fn emoji_tags(&self, content: &str) -> Vec<Tag> {
+        let mut tags = Vec::new();
+
+        for (shortcode, url) in &self.emojis {
+            let pattern = format!(":{shortcode}:");
+            if content.contains(&pattern) {
+                tags.push(Tag::custom("emoji", [shortcode.clone(), url.to_string()]));
+            }
+        }
+
+        tags
+    }
+
     /// Get profile encryption keys announcement
     pub fn announcement(&self) -> Option<Announcement> {
         self.announcement.clone()
@@ -103,14 +106,18 @@ impl Person {
         self.messaging_relays.first().cloned()
     }
 
-    /// Get profile avatar
-    pub fn avatar(&self) -> SharedString {
+    /// Get profile picture, if the profile has one
+    pub fn avatar(&self) -> Option<SharedString> {
         self.metadata()
             .picture
             .as_ref()
             .filter(|picture| !picture.is_empty())
-            .map(|picture| picture.into())
-            .unwrap_or_else(|| "brand/avatar.png".into())
+            .map(SharedString::from)
+    }
+
+    /// A stable seed for this profile's generated avatar
+    pub fn avatar_seed(&self) -> String {
+        self.public_key().to_hex()
     }
 
     /// Get profile name
@@ -131,17 +138,17 @@ impl Person {
     }
 
     /// Set profile metadata
-    pub fn set_metadata(&mut self, metadata: Metadata) {
+    pub(crate) fn set_metadata(&mut self, metadata: Metadata) {
         self.metadata = metadata;
     }
 
     /// Set profile encryption keys announcement
-    pub fn set_announcement(&mut self, announcement: Announcement) {
+    pub(crate) fn set_announcement(&mut self, announcement: Announcement) {
         self.announcement = Some(announcement);
     }
 
     /// Set profile messaging relays
-    pub fn set_messaging_relays<I>(&mut self, relays: I)
+    pub(crate) fn set_messaging_relays<I>(&mut self, relays: I)
     where
         I: IntoIterator<Item = RelayUrl>,
     {

crates/settings/src/lib.rs

@@ -1,17 +1,22 @@
-use std::rc::Rc;
+use std::path::PathBuf;
 
 use anyhow::{Error, anyhow};
 use common::config_dir;
-use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task, Window};
+use gpui::{App, AppContext, Context, Entity, Global, ImageSource, Subscription, Task};
 use nostr_sdk::prelude::*;
 use serde::{Deserialize, Serialize};
 use smallvec::{SmallVec, smallvec};
-use theme::{Theme, ThemeFamily, ThemeMode};
+use theme::{AppExt as _, AppearanceMode};
 
-pub fn init(window: &mut Window, cx: &mut App) {
-    AppSettings::set_global(cx.new(|cx| AppSettings::new(window, cx)), cx)
+pub fn init(cx: &mut App) {
+    AppSettings::set_global(cx.new(AppSettings::new), cx)
 }
 
+const DEFAULT_FILE_SERVER: &str = "https://nostr.download/";
+const LEGACY_FILE_SERVER: &str = "blossom.band";
+/// Built-in image shown behind chat and group panels
+pub const DEFAULT_BACKGROUND: &str = "brand/default-bg.jpg";
+
 macro_rules! setting_accessors {
     ($(pub $field:ident: $type:ty),* $(,)?) => {
         impl AppSettings {
@@ -35,14 +40,33 @@ macro_rules! setting_accessors {
     };
 }
 
+macro_rules! setting_getters {
+    ($(pub $field:ident: $type:ty),* $(,)?) => {
+        impl AppSettings {
+            $(
+                paste::paste! {
+                    pub fn [<get_ $field>](cx: &App) -> $type {
+                        Self::global(cx).read(cx).inner.read(cx).$field.clone()
+                    }
+                }
+            )*
+        }
+    };
+}
+
 setting_accessors! {
-    pub theme: Option<String>,
-    pub theme_mode: ThemeMode,
+    pub appearance_mode: AppearanceMode,
     pub hide_avatar: bool,
     pub screening: bool,
     pub nip4e: bool,
-    pub trusted_relays: Vec<String>,
     pub file_server: Url,
+    pub panel_background: bool,
+    pub panel_background_path: Option<PathBuf>,
+}
+
+setting_getters! {
+    pub pinned_rooms: Vec<u64>,
+    pub pinned_groups: Vec<String>,
 }
 
 /// Signer kind
@@ -55,14 +79,6 @@ pub enum SignerKind {
 }
 
 impl SignerKind {
-    pub fn auto(&self) -> bool {
-        matches!(self, SignerKind::Auto)
-    }
-
-    pub fn user(&self) -> bool {
-        matches!(self, SignerKind::User)
-    }
-
     pub fn encryption(&self) -> bool {
         matches!(self, SignerKind::Encryption)
     }
@@ -104,14 +120,10 @@ impl RoomConfig {
     }
 }
 
-/// Settings
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Settings {
-    /// Theme
-    pub theme: Option<String>,
-
-    /// Theme mode
-    pub theme_mode: ThemeMode,
+    #[serde(default, alias = "theme_mode")]
+    pub appearance_mode: AppearanceMode,
 
     /// Hide user avatars
     pub hide_avatar: bool,
@@ -122,33 +134,46 @@ pub struct Settings {
     /// Enable decoupling encryption key
     pub nip4e: bool,
 
+    /// Show an image behind chat and group panels
+    #[serde(default)]
+    pub panel_background: bool,
+
+    /// Custom image for the panel background; the built-in one when unset
+    #[serde(default)]
+    pub panel_background_path: Option<PathBuf>,
+
     /// Trusted relays; Coop will automatically authenticate with these relays
     pub trusted_relays: Vec<String>,
 
     /// Server for blossom media attachments
     pub file_server: Url,
+
+    /// Pinned chat rooms, by conversation ID
+    #[serde(default)]
+    pub pinned_rooms: Vec<u64>,
+
+    /// Pinned groups, by cache tag
+    #[serde(default)]
+    pub pinned_groups: Vec<String>,
 }
 
 impl Default for Settings {
     fn default() -> Self {
         Self {
-            theme: None,
-            theme_mode: ThemeMode::default(),
+            appearance_mode: AppearanceMode::default(),
             hide_avatar: false,
             screening: true,
             nip4e: false,
+            panel_background: true,
+            panel_background_path: None,
             trusted_relays: vec![],
-            file_server: Url::parse("https://blossom.band/").unwrap(),
+            file_server: Url::parse(DEFAULT_FILE_SERVER).unwrap(),
+            pinned_rooms: vec![],
+            pinned_groups: vec![],
         }
     }
 }
 
-impl AsRef<Settings> for Settings {
-    fn as_ref(&self) -> &Settings {
-        self
-    }
-}
-
 struct GlobalAppSettings(Entity<AppSettings>);
 
 impl Global for GlobalAppSettings {}
@@ -157,7 +182,6 @@ impl Global for GlobalAppSettings {}
 pub struct AppSettings {
     /// Settings
     inner: Entity<Settings>,
-
     /// Event subscriptions
     _subscriptions: SmallVec<[Subscription; 2]>,
 }
@@ -173,7 +197,8 @@ impl AppSettings {
         cx.set_global(GlobalAppSettings(state));
     }
 
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(cx: &mut Context<Self>) -> Self {
+        let entity = cx.entity().downgrade();
         let inner = cx.new(|_| Settings::default());
         let mut subscriptions = smallvec![];
 
@@ -185,8 +210,8 @@ impl AppSettings {
         );
 
         // Run at the end of current cycle
-        cx.defer_in(window, |this, window, cx| {
-            this.load(window, cx);
+        cx.defer(move |cx| {
+            entity.update(cx, |this, cx| this.load(cx)).ok();
         });
 
         Self {
@@ -204,7 +229,7 @@ impl AppSettings {
     }
 
     /// Load settings
-    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    fn load(&mut self, cx: &mut Context<Self>) {
         let task: Task<Result<Settings, Error>> = cx.background_spawn(async move {
             #[cfg(not(target_arch = "wasm32"))]
             {
@@ -216,13 +241,19 @@ impl AppSettings {
             Err(anyhow!("Not found"))
         });
 
-        cx.spawn_in(window, async move |this, cx| {
-            let settings = task.await.unwrap_or(Settings::default());
+        cx.spawn(async move |this, cx| {
+            let mut settings = task.await.unwrap_or(Settings::default());
+
+            // Move settings still pointed at the old default file server over to the new one
+            if settings.file_server.host_str() == Some(LEGACY_FILE_SERVER) {
+                settings.file_server = Url::parse(DEFAULT_FILE_SERVER).unwrap();
+            }
 
             // Update settings
-            this.update_in(cx, |this, window, cx| {
+            this.update(cx, |this, cx| {
                 this.set_settings(settings, cx);
-                this.apply_theme(window, cx);
+                this.apply_theme(cx);
+                cx.refresh_windows();
             })
             .ok();
         })
@@ -242,44 +273,10 @@ impl AppSettings {
         }
     }
 
-    /// Set theme
-    pub fn set_theme<T>(&mut self, theme: T, window: &mut Window, cx: &mut Context<Self>)
-    where
-        T: Into<String>,
-    {
-        // Update settings
-        self.inner.update(cx, |this, cx| {
-            this.theme = Some(theme.into());
-            cx.notify();
-        });
-
-        // Apply the new theme
-        self.apply_theme(window, cx);
-    }
-
-    /// Reset theme
-    pub fn reset_theme(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.inner.update(cx, |this, cx| {
-            this.theme = None;
-            cx.notify();
-        });
-        self.apply_theme(window, cx);
-    }
-
-    /// Apply theme
-    pub fn apply_theme(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(name) = self.inner.read(cx).theme.as_ref() {
-            let mode = self.inner.read(cx).theme_mode;
-
-            if let Ok(new_theme) = ThemeFamily::from_assets(name) {
-                Theme::apply_theme(Rc::new(new_theme), Some(window), cx);
-                Theme::change(mode, Some(window), cx);
-            } else {
-                log::info!("Failed to load theme: {name}");
-            }
-        } else {
-            Theme::apply_theme(Rc::new(ThemeFamily::default()), Some(window), cx);
-        }
+    /// Apply the persisted appearance mode to the app
+    pub fn apply_theme(&mut self, cx: &mut Context<Self>) {
+        let mode = self.inner.read(cx).appearance_mode;
+        cx.set_appearance_mode(mode);
     }
 
     /// Check if decoupling encryption key is enabled
@@ -287,27 +284,79 @@ impl AppSettings {
         self.inner.read(cx).nip4e
     }
 
-    /// Check if the given relay is already authenticated
-    pub fn trusted_relay(&self, url: &RelayUrl, cx: &App) -> bool {
-        self.inner
-            .read(cx)
-            .trusted_relays
-            .iter()
-            .any(|relay| relay == url.as_str_without_trailing_slash())
+    /// The image to show behind chat and group panels, when enabled
+    pub fn panel_background_source(cx: &App) -> Option<ImageSource> {
+        if !Self::get_panel_background(cx) {
+            return None;
+        }
+        Some(match Self::get_panel_background_path(cx) {
+            Some(path) => path.into(),
+            None => DEFAULT_BACKGROUND.into(),
+        })
     }
 
-    /// Add a relay to the trusted list
-    pub fn add_trusted_relay(&mut self, url: &RelayUrl, cx: &mut Context<Self>) {
+    /// Check if the chat room is pinned
+    pub fn pinned_room(&self, id: u64, cx: &App) -> bool {
+        self.inner.read(cx).pinned_rooms.contains(&id)
+    }
+
+    /// Pin or unpin the chat room
+    pub fn toggle_pinned_room(&mut self, id: u64, cx: &mut Context<Self>) {
         self.inner.update(cx, |this, cx| {
-            if !this
-                .trusted_relays
-                .iter()
-                .any(|relay| relay == url.as_str_without_trailing_slash())
-            {
-                this.trusted_relays
-                    .push(url.as_str_without_trailing_slash().to_string());
-                cx.notify();
+            if let Some(index) = this.pinned_rooms.iter().position(|pinned| *pinned == id) {
+                this.pinned_rooms.remove(index);
+            } else {
+                this.pinned_rooms.push(id);
             }
+            cx.notify();
+        });
+    }
+
+    /// Check if the group is pinned by its cache tag
+    pub fn pinned_group(&self, tag: &str, cx: &App) -> bool {
+        self.inner
+            .read(cx)
+            .pinned_groups
+            .iter()
+            .any(|pinned| pinned == tag)
+    }
+
+    /// Pin or unpin the group by its cache tag
+    pub fn toggle_pinned_group(&mut self, tag: &str, cx: &mut Context<Self>) {
+        self.inner.update(cx, |this, cx| {
+            if let Some(index) = this.pinned_groups.iter().position(|pinned| pinned == tag) {
+                this.pinned_groups.remove(index);
+            } else {
+                this.pinned_groups.push(tag.to_owned());
+            }
+            cx.notify();
         });
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn json_with(partial: &str) -> Result<Settings, serde_json::Error> {
+        // Every field the persisted format has always required; `partial`
+        // contributes the fields under test.
+        serde_json::from_str(&format!(
+            r#"{{ {} "hide_avatar": false, "screening": true, "nip4e": false,
+                 "trusted_relays": [], "file_server": "https://nostr.download/" }}"#,
+            partial
+        ))
+    }
+
+    #[test]
+    fn old_theme_mode_key_keeps_its_pinned_choice() {
+        let settings = json_with(r#""theme_mode": "Dark", "#).unwrap();
+        assert_eq!(settings.appearance_mode, AppearanceMode::Dark);
+    }
+
+    #[test]
+    fn missing_appearance_mode_falls_back_to_dark() {
+        let settings = json_with("").unwrap();
+        assert_eq!(settings.appearance_mode, AppearanceMode::Dark);
+    }
+}

crates/state/Cargo.toml

@@ -17,13 +17,16 @@ gpui.workspace = true
 instant.workspace = true
 flume.workspace = true
 futures.workspace = true
-log.workspace = true
 anyhow.workspace = true
 webbrowser.workspace = true
 serde_json.workspace = true
 
 mime_guess = "2.0.4"
 
+aes-gcm.workspace = true
+sha2.workspace = true
+data-encoding.workspace = true
+
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 nostr-memory.workspace = true
 

crates/state/src/blossom.rs

@@ -4,30 +4,52 @@ use anyhow::{Error, anyhow};
 use gpui::AsyncApp;
 #[cfg(not(target_arch = "wasm32"))]
 use gpui_tokio::Tokio;
+#[cfg(not(target_arch = "wasm32"))]
 use mime_guess::from_path;
 use nostr_blossom::prelude::*;
 use nostr_sdk::prelude::*;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Error> {
-    let content_type = from_path(&path).first_or_octet_stream().to_string();
-    let data = smol::fs::read(path).await?;
-    let keys = Keys::generate();
+use crate::file::sha256_hex;
 
-    // Construct the blossom client
-    let client = BlossomClient::new(server);
+/// Upload a blob to a blossom server and return its URL
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) async fn upload_blob(
+    server: &Url,
+    data: Vec<u8>,
+    content_type: &str,
+    sha256: &str,
+    cx: &AsyncApp,
+) -> Result<Url, Error> {
+    let client = BlossomClient::new(server.clone());
+    let keys = Keys::generate();
+    let content_type = content_type.to_string();
+    let base = server.clone();
+    let hash = sha256.to_string();
 
     Tokio::spawn(cx, async move {
-        let blob = client
+        match client
             .upload_blob(data, Some(content_type), None, Some(&keys))
-            .await?;
-
-        Ok(blob.url)
+            .await
+        {
+            Ok(blob) => Ok(blob.url),
+            Err(e) if e.to_string().contains("201 Created") => Ok::<Url, Error>(base.join(&hash)?),
+            Err(e) => Err(anyhow!(e.to_string())),
+        }
     })
     .await
     .map_err(|e| anyhow!("Upload error: {e}"))?
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Error> {
+    let content_type = from_path(&path).first_or_octet_stream().to_string();
+    let data = smol::fs::read(&path).await?;
+    let sha256 = sha256_hex(&data);
+
+    upload_blob(&server, data, &content_type, &sha256, cx).await
+}
+
 #[cfg(target_arch = "wasm32")]
 pub async fn upload(_server: Url, _path: PathBuf, _cx: &AsyncApp) -> Result<Url, Error> {
     Err(anyhow!("File upload not supported on web"))

crates/state/src/constants.rs

@@ -1,21 +1,17 @@
 /// Client name (Application name)
 pub const CLIENT_NAME: &str = "Coop";
 
-/// COOP's public key
-pub const COOP_PUBKEY: &str = "npub1j3rz3ndl902lya6ywxvy5c983lxs8mpukqnx4pa4lt5wrykwl5ys7wpw3x";
-
 /// App ID
 pub const APP_ID: &str = "su.reya.coop";
 
 /// Keyring name
-pub const MASTER_KEYRING: &str = "Coop Master Key";
-pub const USER_KEYRING: &str = "Coop User Credential";
+pub const USER_KEYRING: &str = "Coop Safe Storage";
 
 /// Default timeout for subscription
 pub const TIMEOUT: u64 = 2;
 
-/// Default image cache size
-pub const IMAGE_CACHE_SIZE: usize = 20;
+/// Default timeout for Nostr Connect
+pub const NOSTR_CONNECT_TIMEOUT: u64 = 60;
 
 /// Default delay for searching
 pub const FIND_DELAY: u64 = 600;
@@ -29,25 +25,16 @@ pub const DEVICE_GIFTWRAP: &str = "device-gift-wraps";
 /// Default subscription id for user gift wrap events
 pub const USER_GIFTWRAP: &str = "user-gift-wraps";
 
-/// Default timeout for Nostr Connect
-pub const NOSTR_CONNECT_TIMEOUT: u64 = 60;
-
-/// Default Nostr Connect relay
-pub const NOSTR_CONNECT_RELAY: &str = "wss://relay.nip46.com";
-
-/// Default vertex relays
-pub const WOT_RELAYS: [&str; 1] = ["wss://relay.vertexlab.io"];
+/// Default search relays
+pub(crate) const INDEXER_RELAYS: [&str; 2] =
+    ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
 
 /// Default search relays
-pub const INDEXER_RELAYS: [&str; 2] = ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
-
-/// Default search relays
-pub const SEARCH_RELAYS: [&str; 2] = ["wss://antiprimal.net", "wss://search.nos.today"];
+pub(crate) const SEARCH_RELAYS: [&str; 2] = ["wss://antiprimal.net", "wss://search.nos.today"];
 
 /// Default bootstrap relays
-pub const BOOTSTRAP_RELAYS: [&str; 4] = [
+pub const BOOTSTRAP_RELAYS: [&str; 3] = [
     "wss://relay.ditto.pub",
     "wss://relay.primal.net",
-    "wss://relay.nostr.net",
     "wss://profiles.nostr1.com",
 ];

crates/state/src/file.rs

@@ -0,0 +1,337 @@
+use std::path::PathBuf;
+
+use aes_gcm::aead::consts::{U12, U16, U32};
+use aes_gcm::aead::{Aead, AeadCore, KeyInit, OsRng};
+use aes_gcm::aes::Aes256;
+use aes_gcm::{Aes256Gcm, AesGcm, Nonce};
+use anyhow::{Error, anyhow, bail};
+use data_encoding::HEXLOWER;
+use futures::AsyncReadExt;
+use gpui::http_client::AsyncBody;
+use gpui::{AsyncApp, SharedString};
+#[cfg(not(target_arch = "wasm32"))]
+use mime_guess::from_path;
+use nostr::nips::nip94::Sha256Hash;
+use nostr_sdk::prelude::*;
+use sha2::{Digest, Sha256};
+
+pub(crate) const ALGORITHM: &str = "aes-gcm";
+
+pub(crate) const MAX_FILE_SIZE: usize = 25 * 1024 * 1024;
+
+const TAG_SHA256: &str = "x";
+const TAG_ORIGINAL_SHA256: &str = "ox";
+const TAG_FILE_TYPE: &str = "file-type";
+const TAG_ALGORITHM: &str = "encryption-algorithm";
+const TAG_KEY: &str = "decryption-key";
+const TAG_NONCE: &str = "decryption-nonce";
+const TAG_SIZE: &str = "size";
+const TAG_DIM: &str = "dim";
+const TAG_ALT: &str = "alt";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct EncryptedFile {
+    pub data: Vec<u8>,
+    pub key: String,
+    pub nonce: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileAttachment {
+    pub url: Url,
+    pub mime: String,
+    pub key: String,
+    pub nonce: String,
+    pub sha256: Option<String>,
+    pub original_sha256: Option<String>,
+    pub size: Option<u64>,
+    pub dim: Option<(u32, u32)>,
+    pub name: Option<String>,
+}
+
+impl FileAttachment {
+    pub fn tags(&self) -> Vec<Tag> {
+        let mut tags = vec![
+            Tag::custom(TAG_FILE_TYPE, [self.mime.clone()]),
+            Tag::custom(TAG_ALGORITHM, [ALGORITHM]),
+            Tag::custom(TAG_KEY, [self.key.clone()]),
+            Tag::custom(TAG_NONCE, [self.nonce.clone()]),
+        ];
+
+        if let Some(sha256) = &self.sha256 {
+            tags.push(Tag::custom(TAG_SHA256, [sha256.clone()]));
+        }
+
+        if let Some(original_sha256) = &self.original_sha256 {
+            tags.push(Tag::custom(TAG_ORIGINAL_SHA256, [original_sha256.clone()]));
+        }
+
+        if let Some(size) = self.size {
+            tags.push(Tag::custom(TAG_SIZE, [size.to_string()]));
+        }
+
+        if let Some((width, height)) = self.dim {
+            tags.push(Tag::custom(TAG_DIM, [format!("{width}x{height}")]));
+        }
+
+        if let Some(name) = &self.name {
+            tags.push(Tag::custom(TAG_ALT, [name.clone()]));
+        }
+
+        tags
+    }
+
+    pub fn from_tags(content: &str, tags: &Tags) -> Option<Self> {
+        if tag_value(tags, TAG_ALGORITHM)? != ALGORITHM {
+            return None;
+        }
+
+        Some(Self {
+            url: Url::parse(content).ok()?,
+            mime: tag_value(tags, TAG_FILE_TYPE)?.to_string(),
+            key: tag_value(tags, TAG_KEY)?.to_string(),
+            nonce: tag_value(tags, TAG_NONCE)?.to_string(),
+            sha256: tag_value(tags, TAG_SHA256).map(str::to_string),
+            original_sha256: tag_value(tags, TAG_ORIGINAL_SHA256).map(str::to_string),
+            size: tag_value(tags, TAG_SIZE).and_then(|size| size.parse().ok()),
+            dim: tag_value(tags, TAG_DIM).and_then(parse_dim),
+            name: tag_value(tags, TAG_ALT).map(str::to_string),
+        })
+    }
+
+    pub fn is_image(&self) -> bool {
+        self.mime.starts_with("image/")
+    }
+
+    pub fn display_name(&self) -> SharedString {
+        if let Some(name) = &self.name {
+            return name.clone().into();
+        }
+
+        match self.size {
+            Some(size) => format!("{} ({size} bytes)", self.mime).into(),
+            None => self.mime.clone().into(),
+        }
+    }
+}
+
+pub(crate) fn encrypt(data: &[u8]) -> Result<EncryptedFile, Error> {
+    let key = Aes256Gcm::generate_key(OsRng);
+    let nonce = AesGcm::<Aes256, U16>::generate_nonce(OsRng);
+    let cipher = AesGcm::<Aes256, U16>::new(&key);
+
+    let data = cipher
+        .encrypt(&nonce, data)
+        .map_err(|_| anyhow!("Failed to encrypt file"))?;
+
+    Ok(EncryptedFile {
+        data,
+        key: HEXLOWER.encode(key.as_slice()),
+        nonce: HEXLOWER.encode(nonce.as_slice()),
+    })
+}
+
+pub(crate) fn decrypt(data: &[u8], key: &str, nonce: &str) -> Result<Vec<u8>, Error> {
+    let key = decode(key, "decryption key")?;
+    let nonce = decode(nonce, "decryption nonce")?;
+
+    if key.len() != 32 {
+        bail!(
+            "Invalid decryption key length: expected 32 bytes, got {}",
+            key.len()
+        );
+    }
+
+    match nonce.len() {
+        12 => Aes256Gcm::new_from_slice(&key)
+            .map_err(|_| anyhow!("Invalid decryption key"))?
+            .decrypt(Nonce::<U12>::from_slice(&nonce), data)
+            .map_err(|_| anyhow!("Failed to decrypt file")),
+        16 => AesGcm::<Aes256, U16>::new_from_slice(&key)
+            .map_err(|_| anyhow!("Invalid decryption key"))?
+            .decrypt(Nonce::<U16>::from_slice(&nonce), data)
+            .map_err(|_| anyhow!("Failed to decrypt file")),
+        32 => AesGcm::<Aes256, U32>::new_from_slice(&key)
+            .map_err(|_| anyhow!("Invalid decryption key"))?
+            .decrypt(Nonce::<U32>::from_slice(&nonce), data)
+            .map_err(|_| anyhow!("Failed to decrypt file")),
+        len => bail!("Unsupported decryption nonce length: {len} bytes"),
+    }
+}
+
+pub(crate) fn sha256_hex(data: &[u8]) -> String {
+    let hash: [u8; 32] = Sha256::digest(data).into();
+
+    Sha256Hash::from_byte_array(hash).to_hex()
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn upload_encrypted(
+    server: Url,
+    path: PathBuf,
+    cx: &AsyncApp,
+) -> Result<FileAttachment, Error> {
+    let mime = from_path(&path).first_or_octet_stream().to_string();
+    let name = path
+        .file_name()
+        .map(|name| name.to_string_lossy().into_owned());
+    let data = smol::fs::read(&path).await?;
+
+    let encrypted = encrypt(&data)?;
+    let sha256 = sha256_hex(&encrypted.data);
+    let original_sha256 = sha256_hex(&data);
+    let size = encrypted.data.len() as u64;
+    let base_url = server.to_string();
+
+    let url = crate::blossom::upload_blob(
+        &server,
+        encrypted.data,
+        "application/octet-stream",
+        &sha256,
+        cx,
+    )
+    .await
+    .map_err(|e| {
+        let message = e.to_string();
+
+        if !message.contains("415") {
+            return anyhow!(message);
+        }
+
+        anyhow!(
+            "{base_url} rejected the encrypted file. Encrypted attachments are uploaded as
+             opaque data, which this file server does not accept. Choose a different file
+             server in the settings."
+        )
+    })?;
+
+    Ok(FileAttachment {
+        url,
+        mime,
+        key: encrypted.key,
+        nonce: encrypted.nonce,
+        sha256: Some(sha256),
+        original_sha256: Some(original_sha256),
+        size: Some(size),
+        dim: None,
+        name,
+    })
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn upload_encrypted(
+    _server: Url,
+    _path: PathBuf,
+    _cx: &AsyncApp,
+) -> Result<FileAttachment, Error> {
+    Err(anyhow!("File upload not supported on web"))
+}
+
+pub(crate) async fn download_and_decrypt(
+    url: &Url,
+    key: &str,
+    nonce: &str,
+    expected_sha256: Option<&str>,
+    cx: &AsyncApp,
+) -> Result<Vec<u8>, Error> {
+    let client = cx.update(|app| app.http_client());
+    let response = client.get(url.as_str(), AsyncBody::default(), true).await?;
+
+    if !response.status().is_success() {
+        bail!("Failed to download file: HTTP {}", response.status());
+    }
+
+    let mut data = Vec::new();
+    response
+        .into_body()
+        .take(MAX_FILE_SIZE as u64 + 1)
+        .read_to_end(&mut data)
+        .await?;
+
+    if data.len() > MAX_FILE_SIZE {
+        bail!("File is too large (max {MAX_FILE_SIZE} bytes)");
+    }
+
+    if let Some(expected) = expected_sha256
+        && !sha256_hex(&data).eq_ignore_ascii_case(expected)
+    {
+        bail!("File hash mismatch");
+    }
+
+    decrypt(&data, key, nonce)
+}
+
+/// Download and decrypt a file attachment into a temporary file.
+///
+/// The same attachment always maps to the same path, so callers can render the
+/// result directly (e.g. with `img`) without downloading it more than once.
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn download_and_decrypt_to_file(
+    file: &FileAttachment,
+    cx: &AsyncApp,
+) -> Result<PathBuf, Error> {
+    let name = file
+        .sha256
+        .clone()
+        .unwrap_or_else(|| sha256_hex(file.url.as_str().as_bytes()));
+
+    let extension = mime_guess::get_mime_extensions_str(&file.mime)
+        .and_then(|extensions| extensions.first())
+        .copied()
+        .unwrap_or("bin");
+
+    let path = std::env::temp_dir()
+        .join("coop-files")
+        .join(format!("{name}.{extension}"));
+
+    if smol::fs::metadata(&path).await.is_ok() {
+        return Ok(path);
+    }
+
+    let data = download_and_decrypt(
+        &file.url,
+        &file.key,
+        &file.nonce,
+        file.sha256.as_deref(),
+        cx,
+    )
+    .await?;
+
+    let Some(parent) = path.parent() else {
+        bail!("Invalid file path");
+    };
+    smol::fs::create_dir_all(parent).await?;
+
+    // Write under a temporary name first, so an interrupted download is never reused
+    let partial = path.with_extension("download");
+    smol::fs::write(&partial, data).await?;
+    smol::fs::rename(&partial, &path).await?;
+
+    Ok(path)
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn download_and_decrypt_to_file(
+    _file: &FileAttachment,
+    _cx: &AsyncApp,
+) -> Result<PathBuf, Error> {
+    Err(anyhow!("File download not supported on web"))
+}
+
+fn tag_value<'a>(tags: &'a Tags, name: &str) -> Option<&'a str> {
+    tags.iter()
+        .find(|tag| tag.kind() == name)
+        .and_then(|tag| tag.content())
+}
+
+fn parse_dim(value: &str) -> Option<(u32, u32)> {
+    let (width, height) = value.split_once('x')?;
+
+    Some((width.parse().ok()?, height.parse().ok()?))
+}
+
+fn decode(value: &str, label: &str) -> Result<Vec<u8>, Error> {
+    HEXLOWER
+        .decode(value.to_ascii_lowercase().as_bytes())
+        .map_err(|_| anyhow!("Invalid {label} encoding"))
+}

crates/state/src/lib.rs

@@ -4,7 +4,7 @@ use anyhow::{Error, anyhow};
 #[cfg(not(target_arch = "wasm32"))]
 use browser_signer_proxy::prelude::*;
 use common::config_dir;
-use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task, Window};
+use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task, TaskExt};
 use gpui_tokio::Tokio;
 use instant::Duration;
 use nostr_connect::prelude::*;
@@ -17,20 +17,19 @@ use nostr_sdk::prelude::*;
 
 mod blossom;
 mod constants;
+mod file;
 mod nip05;
 mod nip4e;
 mod signer;
 
 pub use blossom::*;
 pub use constants::*;
+pub use file::*;
 pub use nip4e::*;
 pub use nip05::*;
 pub use signer::{CoopAuthUrlHandler, UniversalSigner};
 
-pub fn init(window: &mut Window, cx: &mut App, cli_key: Option<SecretKey>) {
-    // rustls uses the `aws_lc_rs` provider by default
-    // This only errors if the default provider has already
-    // been installed. We can ignore this `Result`.
+pub fn init(cx: &mut App, cli_key: Option<SecretKey>) {
     #[cfg(not(target_arch = "wasm32"))]
     rustls::crypto::aws_lc_rs::default_provider()
         .install_default()
@@ -40,7 +39,7 @@ pub fn init(window: &mut Window, cx: &mut App, cli_key: Option<SecretKey>) {
     #[cfg(not(target_arch = "wasm32"))]
     gpui_tokio::init(cx);
 
-    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx, cli_key)), cx);
+    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(cx, cli_key)), cx);
 }
 
 struct GlobalNostrRegistry(Entity<NostrRegistry>);
@@ -50,12 +49,12 @@ impl Global for GlobalNostrRegistry {}
 /// Signer event.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum StateEvent {
-    /// The state is busy
-    Busy,
     /// User has no signer
     NoSigner,
     /// The signer has changed
     SignerChanged,
+    /// A stored credential needs a passphrase to unlock
+    PassphraseRequired,
     /// An error occurred
     Error(String),
 }
@@ -65,7 +64,7 @@ impl StateEvent {
         matches!(self, StateEvent::SignerChanged)
     }
 
-    pub fn error<T>(error: T) -> Self
+    pub(crate) fn error<T>(error: T) -> Self
     where
         T: Into<String>,
     {
@@ -78,13 +77,12 @@ impl StateEvent {
 pub struct NostrRegistry {
     /// Nostr client
     client: Client,
-
     /// Universal signer
     signer: UniversalSigner,
-
     /// Current user's public key
     current_user: Option<PublicKey>,
-
+    /// Whether the stored credential needs a passphrase to unlock
+    passphrase_required: bool,
     /// Tasks for asynchronous operations
     tasks: Vec<Task<Result<(), Error>>>,
 }
@@ -103,7 +101,8 @@ impl NostrRegistry {
     }
 
     /// Create a new nostr instance
-    fn new(window: &mut Window, cx: &mut Context<Self>, cli_key: Option<SecretKey>) -> Self {
+    fn new(cx: &mut Context<Self>, cli_key: Option<SecretKey>) -> Self {
+        let entity = cx.entity().downgrade();
         let signer = UniversalSigner::new(Keys::generate());
         let authenticator = SignerAuthenticator::new(signer.clone());
 
@@ -125,30 +124,35 @@ impl NostrRegistry {
             .gossip(NostrGossipMemory::unbounded())
             .gossip_config(GossipConfig::default().no_background_refresh())
             .connect_timeout(Duration::from_secs(10))
+            .verify_subscriptions(true)
+            .ban_relay_on_mismatch(true)
             .sleep_when_idle(SleepWhenIdle::Enabled {
                 timeout: Duration::from_secs(600),
             })
             .build();
 
-        // Connect to bootstrap relays after the window is ready
-        cx.defer_in(window, |this, _window, cx| {
-            this.connect_bootstrap_relays(cx);
+        // Connect to bootstrap relays once the registry has been returned to the app
+        cx.defer(move |cx| {
+            let _ = entity.update(cx, |this, cx| {
+                this.connect_bootstrap_relays(cx);
 
-            if cfg!(target_arch = "wasm32") {
-                cx.emit(StateEvent::NoSigner);
-            } else if let Some(secret) = cli_key {
-                // Use CLI-provided key -- same path as get_user_credential
-                let keys = Keys::new(secret);
-                this.set_signer(keys, cx);
-            } else {
-                this.get_user_credential(cx);
-            }
+                if cfg!(target_arch = "wasm32") {
+                    cx.emit(StateEvent::NoSigner);
+                } else if let Some(secret) = cli_key {
+                    // Use CLI-provided key -- same path as restore_session
+                    let keys = Keys::new(secret);
+                    this.set_signer(keys, cx);
+                } else {
+                    this.restore_session(cx);
+                }
+            });
         });
 
         Self {
             client,
             signer,
             current_user: None,
+            passphrase_required: false,
             tasks: vec![],
         }
     }
@@ -169,7 +173,7 @@ impl NostrRegistry {
     }
 
     /// Update the signer
-    pub fn set_signer<T>(&mut self, new_signer: T, cx: &mut Context<Self>)
+    fn set_signer<T>(&mut self, new_signer: T, cx: &mut Context<Self>)
     where
         T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
         <T as AsyncGetPublicKey>::Error: std::error::Error + Send + Sync + 'static,
@@ -182,6 +186,8 @@ impl NostrRegistry {
                     this.update(cx, |this, cx| {
                         this.signer.swap_inner(new_signer);
                         this.current_user = Some(public_key);
+                        this.passphrase_required = false;
+
                         cx.emit(StateEvent::SignerChanged);
                         cx.notify();
                     })?;
@@ -232,89 +238,249 @@ impl NostrRegistry {
         }));
     }
 
-    /// Check the user's credential and set the signer if valid
-    fn get_user_credential(&mut self, cx: &mut Context<Self>) {
+    /// Restore the signer from the stored credential
+    fn restore_session(&mut self, cx: &mut Context<Self>) {
         let user_keyring = cx.read_credentials(USER_KEYRING);
-        let master_keyring = self.get_master_key(cx);
 
         self.tasks.push(cx.spawn(async move |this, cx| {
-            match user_keyring.await {
-                Ok(Some((_username, secret))) => {
-                    let content = String::from_utf8(secret)?;
+            let result = async {
+                match user_keyring.await {
+                    Ok(Some((_username, secret))) => {
+                        let content = String::from_utf8(secret)?;
 
-                    if content.starts_with("nsec1") {
-                        let secret_key = SecretKey::parse(&content)?;
-                        let keys = Keys::new(secret_key);
+                        if content.starts_with("nsec1") {
+                            let keys = Keys::new(SecretKey::parse(&content)?);
+                            this.update(cx, |this, cx| {
+                                this.set_signer(keys, cx);
+                            })?;
+                        } else if content.starts_with("bunker://") {
+                            // The master key used for Nostr Connect is embedded in
+                            // the stored URI so reconnects reuse the same local key
+                            let (base, keys) = extract_master_key(&content);
+                            let uri = NostrConnectUri::parse(base)?;
 
-                        this.update(cx, |this, cx| {
-                            this.set_signer(keys, cx);
-                            cx.notify();
-                        })?;
-                    } else if content.starts_with("bunker://") {
-                        let keys = master_keyring.await;
-                        let timeout = Duration::from_secs(30);
-                        let uri = NostrConnectUri::parse(content)?;
+                            // Construct the nostr connect signer
+                            let mut signer = NostrConnect::new(
+                                uri,
+                                keys,
+                                Duration::from_secs(NOSTR_CONNECT_TIMEOUT),
+                                None,
+                            )?;
 
-                        // Construct the nostr connect signer
-                        let mut signer = NostrConnect::new(uri, keys, timeout, None)?;
+                            // Handle auth url with the default browser
+                            signer.auth_url_handler(CoopAuthUrlHandler);
 
-                        // Handle auth url with the default browser
-                        signer.auth_url_handler(CoopAuthUrlHandler);
-
-                        this.update(cx, |this, cx| {
-                            this.set_signer(signer, cx);
-                            cx.notify();
-                        })?;
-                    } else if content == "proxy" {
-                        #[cfg(not(target_arch = "wasm32"))]
-                        this.update(cx, |this, cx| {
-                            this.connect_proxy(cx);
+                            this.update(cx, |this, cx| {
+                                this.set_signer(signer, cx);
+                            })?;
+                        } else if content.starts_with("ncryptsec1") {
+                            this.update(cx, |this, cx| {
+                                this.passphrase_required = true;
+                                cx.emit(StateEvent::PassphraseRequired);
+                            })?;
+                        } else if content == "proxy" {
+                            #[cfg(not(target_arch = "wasm32"))]
+                            this.update(cx, |this, cx| {
+                                this.connect_proxy(cx);
+                            })?;
+                        } else {
+                            this.update(cx, |_, cx| {
+                                cx.emit(StateEvent::NoSigner);
+                            })?;
+                        }
+                    }
+                    _ => {
+                        this.update(cx, |_, cx| {
+                            cx.emit(StateEvent::NoSigner);
                         })?;
                     }
                 }
-                _ => {
-                    this.update(cx, |_, cx| {
-                        cx.emit(StateEvent::NoSigner);
-                    })?;
-                }
+
+                Ok::<(), Error>(())
+            }
+            .await;
+
+            if let Err(e) = result {
+                this.update(cx, |_, cx| {
+                    cx.emit(StateEvent::error(e.to_string()));
+                    cx.emit(StateEvent::NoSigner);
+                })?;
             }
 
             Ok(())
         }));
     }
 
-    /// Get the master key that used for Nostr Connect
-    pub fn get_master_key(&self, cx: &App) -> Task<Keys> {
-        if cfg!(target_arch = "wasm32") {
-            return cx.background_spawn(async move { Keys::generate() });
-        }
+    /// Unlock the stored encrypted key with its passphrase
+    pub fn restore_with_passphrase(
+        &mut self,
+        password: &str,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<PublicKey, Error>> {
+        let password = password.to_owned();
+        let user_keyring = cx.read_credentials(USER_KEYRING);
 
-        let task = cx.read_credentials(MASTER_KEYRING);
+        cx.spawn(async move |this, cx| {
+            let content = user_keyring
+                .await?
+                .map(|(_username, secret)| String::from_utf8(secret))
+                .transpose()?
+                .ok_or_else(|| anyhow!("no stored credential; nothing to unlock"))?;
 
-        cx.spawn(async move |cx| {
-            let (keys, new_key) = match task.await {
-                Ok(Some((_user, secret))) => match SecretKey::from_slice(&secret) {
-                    Ok(secret_key) => (Keys::new(secret_key), false),
-                    _ => (Keys::generate(), true),
-                },
-                _ => (Keys::generate(), true),
-            };
-
-            if new_key {
-                let keys_clone = keys.clone();
-                let username = keys_clone.public_key().to_hex();
-                let password = keys_clone.secret_key().to_secret_bytes();
-
-                cx.update(|cx| {
-                    let task = cx.write_credentials(MASTER_KEYRING, &username, &password);
-                    cx.background_spawn(async move { task.await.ok() }).detach();
-                });
+            if !content.starts_with("ncryptsec1") {
+                return Err(anyhow!("stored credential is not passphrase-encrypted"));
             }
 
-            keys
+            let decrypt_task = cx.background_spawn(async move {
+                let encrypted = EncryptedSecretKey::from_bech32(&content)?;
+                let secret = encrypted.decrypt(&password)?;
+                Ok::<_, Error>(Keys::new(secret))
+            });
+
+            let keys = decrypt_task.await?;
+            let public_key = keys.public_key();
+
+            this.update(cx, |this, cx| {
+                this.set_signer(keys, cx);
+            })?;
+
+            Ok(public_key)
         })
     }
 
+    /// Import an `nsec1...` secret key, storing it NIP-49 encrypted with `password`
+    pub fn import_nsec(
+        &mut self,
+        nsec: &str,
+        password: &str,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<PublicKey, Error>> {
+        let keys = match SecretKey::parse(nsec.trim()) {
+            Ok(secret) => Keys::new(secret),
+            Err(e) => return Task::ready(Err(anyhow!(e))),
+        };
+
+        if password.is_empty() {
+            return Task::ready(Err(anyhow!("Passphrase must not be empty")));
+        }
+
+        let password = password.to_owned();
+
+        cx.spawn(async move |this, cx| {
+            let job = cx.background_spawn(async move {
+                let encrypted =
+                    EncryptedSecretKey::new(keys.secret_key(), &password, 16, KeySecurity::Medium)?;
+                let ncryptsec = encrypted.to_bech32()?;
+                Ok::<_, Error>((keys, ncryptsec))
+            });
+
+            let (keys, ncryptsec) = job.await?;
+            let public_key = keys.public_key();
+
+            let write = cx.update(|cx| {
+                cx.write_credentials(USER_KEYRING, &public_key.to_hex(), ncryptsec.as_bytes())
+            });
+            write.await?;
+
+            this.update(cx, |this, cx| {
+                this.set_signer(keys, cx);
+            })?;
+
+            Ok(public_key)
+        })
+    }
+
+    /// Import an NIP-49 encrypted secret key (`ncryptsec1...`), decrypting it with `password`
+    pub fn import_ncryptsec(
+        &mut self,
+        ncryptsec: &str,
+        password: &str,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<PublicKey, Error>> {
+        let ncryptsec = ncryptsec.trim().to_owned();
+
+        if password.is_empty() {
+            return Task::ready(Err(anyhow!("Passphrase must not be empty")));
+        }
+
+        let password = password.to_owned();
+
+        cx.spawn(async move |this, cx| {
+            let stored = ncryptsec.clone();
+            let decrypt_task = cx.background_spawn(async move {
+                let encrypted = EncryptedSecretKey::from_bech32(&ncryptsec)?;
+                let secret = encrypted.decrypt(&password)?;
+                Ok::<_, Error>(Keys::new(secret))
+            });
+
+            let keys = decrypt_task.await?;
+            let public_key = keys.public_key();
+
+            let write = cx.update(|cx| {
+                cx.write_credentials(USER_KEYRING, &public_key.to_hex(), stored.as_bytes())
+            });
+            write.await?;
+
+            this.update(cx, |this, cx| {
+                this.set_signer(keys, cx);
+            })?;
+
+            Ok(public_key)
+        })
+    }
+
+    /// Import a `bunker://...` URI (NIP-46), connecting to the remote signer
+    pub fn import_bunker(
+        &mut self,
+        uri: &str,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<PublicKey, Error>> {
+        let uri_string = uri.trim().to_owned();
+
+        let connect_uri = match NostrConnectUri::parse(&uri_string) {
+            Ok(uri) => uri,
+            Err(e) => return Task::ready(Err(anyhow!(e))),
+        };
+
+        let keys = Keys::generate();
+        let credential = with_master_key(&uri_string, &keys);
+        let write = cx.write_credentials(USER_KEYRING, "bunker", credential.as_bytes());
+
+        cx.spawn(async move |this, cx| {
+            // Construct the nostr connect signer
+            let mut signer = NostrConnect::new(
+                connect_uri,
+                keys,
+                Duration::from_secs(NOSTR_CONNECT_TIMEOUT),
+                None,
+            )?;
+
+            // Handle auth url with the default browser
+            signer.auth_url_handler(CoopAuthUrlHandler);
+
+            // Verify the bunker responds before persisting the credential
+            let public_key = signer.get_public_key_async().await?;
+            write.await?;
+
+            this.update(cx, |this, cx| {
+                this.set_signer(signer, cx);
+            })?;
+
+            Ok(public_key)
+        })
+    }
+
+    /// Sign out and remove the stored credential
+    pub fn sign_out(&mut self, cx: &mut Context<Self>) {
+        self.current_user = None;
+        self.passphrase_required = false;
+
+        cx.delete_credentials(USER_KEYRING).detach_and_log_err(cx);
+        cx.emit(StateEvent::SignerChanged);
+        cx.emit(StateEvent::NoSigner);
+        cx.notify();
+    }
+
     /// Start the browser proxy
     #[cfg(not(target_arch = "wasm32"))]
     pub fn connect_proxy(&mut self, cx: &mut Context<Self>) {
@@ -494,68 +660,24 @@ impl NostrRegistry {
             Ok(results)
         })
     }
+}
 
-    /// Perform a WoT (via Vertex) search for a given query.
-    pub fn wot_search(&self, query: &str, cx: &App) -> Task<Result<Vec<PublicKey>, Error>> {
-        let client = self.client();
-        let query = query.to_string();
-        let signer = self.signer.clone();
-
-        cx.background_spawn(async move {
-            // Construct a vertex request event
-            let event = EventBuilder::new(Kind::Custom(5315), "")
-                .tags(vec![
-                    Tag::custom("param", vec!["search", &query]),
-                    Tag::custom("param", vec!["limit", "10"]),
-                ])
-                .finalize_async(&signer)
-                .await?;
-
-            // Send the event to vertex relays
-            let output = client.send_event(&event).to(WOT_RELAYS).await?;
-
-            // Construct a filter to get the response or error from vertex
-            let filter = Filter::new()
-                .kinds(vec![Kind::Custom(6315), Kind::Custom(7000)])
-                .event(output.id().to_owned());
-
-            // Construct target for subscription
-            let target: HashMap<&str, Vec<Filter>> = WOT_RELAYS
-                .into_iter()
-                .map(|relay| (relay, vec![filter.clone()]))
-                .collect();
-
-            // Stream events from the wot relays
-            let mut stream = client
-                .stream_events(target)
-                .timeout(Duration::from_secs(TIMEOUT))
-                .await?;
-
-            while let Some((_url, res)) = stream.next().await {
-                if let Ok(event) = res {
-                    match event.kind {
-                        Kind::Custom(6315) => {
-                            let content: serde_json::Value = serde_json::from_str(&event.content)?;
-                            let pubkeys: Vec<PublicKey> = content
-                                .as_array()
-                                .into_iter()
-                                .flatten()
-                                .filter_map(|item| item.as_object())
-                                .filter_map(|obj| obj.get("pubkey").and_then(|v| v.as_str()))
-                                .filter_map(|pubkey_str| PublicKey::parse(pubkey_str).ok())
-                                .collect();
-
-                            return Ok(pubkeys);
-                        }
-                        Kind::Custom(7000) => {
-                            return Err(anyhow!("Search error"));
-                        }
-                        _ => {}
-                    }
-                }
-            }
-
-            Err(anyhow!("No results for query: {query}"))
-        })
+// Extract the base URI and the master key from a bunker credential with `master=<nsec>`
+fn extract_master_key(credential: &str) -> (&str, Keys) {
+    match credential.split_once("master=") {
+        Some((base, nsec)) => {
+            let keys = SecretKey::parse(nsec)
+                .map(Keys::new)
+                .unwrap_or_else(|_| Keys::generate());
+            (base.trim_end_matches(['?', '&']), keys)
+        }
+        None => (credential, Keys::generate()),
     }
 }
+
+// Embed the master key in a bunker URI so reconnects reuse the same local key
+fn with_master_key(uri: &str, keys: &Keys) -> String {
+    let separator = if uri.contains('?') { '&' } else { '?' };
+    let nsec = keys.secret_key().to_bech32().expect("infallible");
+    format!("{uri}{separator}master={nsec}")
+}

crates/state/src/nip4e.rs

@@ -1,4 +1,3 @@
-use gpui::SharedString;
 use nostr_sdk::prelude::*;
 
 /// Announcement
@@ -6,50 +5,22 @@ use nostr_sdk::prelude::*;
 pub struct Announcement {
     /// The public key of the device that created this announcement.
     public_key: PublicKey,
-
-    /// The name of the device that created this announcement.
-    client_name: Option<String>,
 }
 
-impl From<&Event> for Announcement {
-    fn from(val: &Event) -> Self {
-        let public_key = val
+impl Announcement {
+    pub fn from_event(event: &Event) -> Option<Self> {
+        let public_key = event
             .tags
             .iter()
             .find(|tag| tag.kind() == "n")
             .and_then(|tag| tag.content())
-            .and_then(|c| PublicKey::parse(c).ok())
-            .unwrap_or(val.pubkey);
+            .and_then(|c| PublicKey::parse(c).ok())?;
 
-        let client_name = val
-            .tags
-            .iter()
-            .find(|tag| tag.kind() == "client")
-            .and_then(|tag| tag.content())
-            .map(|c| c.to_string());
-
-        Self::new(public_key, client_name)
-    }
-}
-
-impl Announcement {
-    pub fn new(public_key: PublicKey, client_name: Option<String>) -> Self {
-        Self {
-            public_key,
-            client_name,
-        }
+        Some(Self { public_key })
     }
 
     /// Returns the public key of the device that created this announcement.
     pub fn public_key(&self) -> PublicKey {
         self.public_key
     }
-
-    /// Returns the client name of the device that created this announcement.
-    pub fn client_name(&self) -> SharedString {
-        self.client_name
-            .as_ref()
-            .map(SharedString::from)
-            .unwrap_or(SharedString::from("Unknown"))
-    }
 }

crates/state/src/signer.rs

@@ -5,32 +5,9 @@ use std::pin::Pin;
 use std::sync::{Arc, RwLock};
 
 use nostr_connect::client::AuthUrlHandler;
+use nostr_sdk::error::Error as SignerError;
 use nostr_sdk::prelude::*;
 
-#[derive(Debug)]
-pub struct UniversalSignerError(Box<dyn Error + Send + Sync + 'static>);
-
-impl fmt::Display for UniversalSignerError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl Error for UniversalSignerError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(&*self.0)
-    }
-}
-
-impl UniversalSignerError {
-    pub fn new<E>(err: E) -> Self
-    where
-        E: Error + Send + Sync + 'static,
-    {
-        UniversalSignerError(Box::new(err))
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct UniversalSigner {
     inner: Arc<RwLock<Arc<dyn InnerSigner>>>,
@@ -59,26 +36,46 @@ impl UniversalSigner {
     {
         *self.inner.write().expect("RwLock poisoned") = Arc::new(InnerSignerImpl(new_signer));
     }
+
+    /// Encrypt a payload to the given key with NIP-44.
+    pub async fn nip44_encrypt(
+        &self,
+        public_key: &PublicKey,
+        content: &str,
+    ) -> Result<String, SignerError> {
+        let inner = self.inner.read().expect("RwLock poisoned").clone();
+        inner.nip44_encrypt_async(public_key, content).await
+    }
+
+    /// Decrypt a NIP-44 payload from the given key.
+    pub async fn nip44_decrypt(
+        &self,
+        public_key: &PublicKey,
+        payload: &str,
+    ) -> Result<String, SignerError> {
+        let inner = self.inner.read().expect("RwLock poisoned").clone();
+        inner.nip44_decrypt_async(public_key, payload).await
+    }
 }
 
 trait InnerSigner: fmt::Debug + Send + Sync + 'static {
     fn get_public_key_async(
         &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>>;
+    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, SignerError>> + Send + '_>>;
     fn sign_event_async(
         &self,
         unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>>;
+    ) -> Pin<Box<dyn Future<Output = Result<Event, SignerError>> + Send + '_>>;
     fn nip44_encrypt_async<'a>(
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>>;
     fn nip44_decrypt_async<'a>(
         &'a self,
         public_key: &'a PublicKey,
         payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>>;
 }
 
 #[derive(Debug)]
@@ -93,22 +90,22 @@ where
 {
     fn get_public_key_async(
         &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>> {
+    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, SignerError>> + Send + '_>> {
         Box::pin(async move {
             AsyncGetPublicKey::get_public_key_async(&self.0)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
     fn sign_event_async(
         &self,
         unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Event, SignerError>> + Send + '_>> {
         Box::pin(async move {
             AsyncSignEvent::sign_event_async(&self.0, unsigned)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
@@ -116,11 +113,11 @@ where
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>> {
         Box::pin(async move {
             AsyncNip44::nip44_encrypt_async(&self.0, public_key, content)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
@@ -128,25 +125,17 @@ where
         &'a self,
         public_key: &'a PublicKey,
         payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>> {
         Box::pin(async move {
             AsyncNip44::nip44_decrypt_async(&self.0, public_key, payload)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 }
 
-impl UniversalSigner {
-    #[allow(dead_code)]
-    fn with_inner<R>(&self, f: impl FnOnce(&dyn InnerSigner) -> R) -> R {
-        let guard = self.inner.read().expect("RwLock poisoned");
-        f(&**guard)
-    }
-}
-
 impl AsyncGetPublicKey for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn get_public_key_async(
         &self,
@@ -157,7 +146,7 @@ impl AsyncGetPublicKey for UniversalSigner {
 }
 
 impl AsyncSignEvent for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn sign_event_async(
         &self,
@@ -169,7 +158,7 @@ impl AsyncSignEvent for UniversalSigner {
 }
 
 impl AsyncNip44 for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn nip44_encrypt_async<'a>(
         &'a self,
@@ -199,7 +188,7 @@ impl AuthUrlHandler for CoopAuthUrlHandler {
         auth_url: Url,
     ) -> Pin<Box<dyn Future<Output = Result<(), nostr_connect::error::Error>> + Send + '_>> {
         Box::pin(async move {
-            webbrowser::open(auth_url.as_str()).unwrap();
+            webbrowser::open(auth_url.as_str()).map_err(nostr_connect::error::Error::other)?;
             Ok(())
         })
     }

crates/theme/Cargo.toml

@@ -6,12 +6,12 @@ publish.workspace = true
 
 [dependencies]
 gpui.workspace = true
+gpui-base.workspace = true
 anyhow.workspace = true
 log.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 schemars.workspace = true
-smallvec.workspace = true
 
 [dev-dependencies]
 tempfile = "3.10"

crates/theme/LICENSE

@@ -1 +0,0 @@
-../../LICENSE

crates/theme/README.md

@@ -1 +0,0 @@
-CREDITS: [zed/theme](https://github.com/zed-industries/zed/tree/main/crates/theme)

crates/theme/src/appearance.rs

@@ -0,0 +1,151 @@
+//! Light/dark switching, adapted from bezel
+//! (`crates/theme/src/appearance.rs`, MIT License, Copyright (c) 2026 bezel
+//! contributors): what the user asked for, what the OS reports, and the
+//! plumbing that turns a change in either into a repaint.
+
+use gpui::{App, Global, Subscription, Window};
+use serde::{Deserialize, Serialize};
+
+use crate::{Theme, ThemeMode};
+
+/// The user's appearance preference. Serde-serializable so callers can persist
+/// it wherever their settings live; this crate never touches disk.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum AppearanceMode {
+    /// Follow the OS — matches every other native app on the machine,
+    /// including when the OS is set to switch at sunset.
+    System,
+    Light,
+    /// Paint dark regardless of the OS.
+    #[default]
+    Dark,
+}
+
+impl AppearanceMode {
+    pub const ALL: [Self; 3] = [Self::System, Self::Light, Self::Dark];
+
+    /// Menu/label text.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::System => "System",
+            Self::Light => "Light",
+            Self::Dark => "Dark",
+        }
+    }
+}
+
+/// Global state behind the current theme: what the user chose, and what the OS
+/// last said. Kept separate from [`Theme`] itself so that flipping the OS
+/// appearance while the user has pinned Light still records the new system
+/// value (and takes effect the moment they switch back to `System`).
+pub struct AppearanceState {
+    pub mode: AppearanceMode,
+    pub system: ThemeMode,
+}
+
+impl Global for AppearanceState {}
+
+/// Combine the user's choice with the OS state.
+pub fn resolve(mode: AppearanceMode, system: ThemeMode) -> ThemeMode {
+    match mode {
+        AppearanceMode::System => system,
+        AppearanceMode::Light => ThemeMode::Light,
+        AppearanceMode::Dark => ThemeMode::Dark,
+    }
+}
+
+/// Install the appearance globals and the matching theme. Call once at boot,
+/// before any window opens, so the first frame is already the right palette
+/// (installing later produces a visible dark-to-light flash).
+pub fn init(mode: AppearanceMode, cx: &mut App) {
+    let system = ThemeMode::from_window(cx.window_appearance());
+    cx.set_global(AppearanceState { mode, system });
+    Theme::change(resolve(mode, system), None, cx);
+}
+
+/// The mode currently in effect (defaults to `Dark` before [`init`]).
+pub fn mode(cx: &App) -> AppearanceMode {
+    cx.try_global::<AppearanceState>()
+        .map(|state| state.mode)
+        .unwrap_or_default()
+}
+
+/// Change the user's preference and repaint if that changed the palette.
+/// Persisting the choice is the caller's job.
+pub fn set_mode(mode: AppearanceMode, cx: &mut App) {
+    if !cx.has_global::<AppearanceState>() {
+        return;
+    }
+    let state = cx.global_mut::<AppearanceState>();
+    if state.mode == mode {
+        return;
+    }
+    state.mode = mode;
+    // Coming back to `System`, re-read the OS: a pinned mode holds an
+    // appearance override, so `system` may be stale from before the pin.
+    if mode == AppearanceMode::System {
+        let system = ThemeMode::from_window(cx.window_appearance());
+        cx.global_mut::<AppearanceState>().system = system;
+    }
+    apply(cx);
+}
+
+/// Subscribe a window to OS appearance changes. The returned [`Subscription`]
+/// must outlive the window — callers typically `.detach()` it.
+///
+/// The notification is *per window*, but the appearance it reports is a system
+/// setting, so any one window is enough to learn about the change; re-applying
+/// is idempotent when several fire.
+pub fn observe_window(window: &mut Window, cx: &mut App) -> Subscription {
+    // Reconcile against the *window's* appearance before subscribing: `init`
+    // runs before any window exists and can only ask the app, which on some
+    // platforms is not reliably populated that early in launch.
+    record_system(window.appearance().into(), cx);
+    window.observe_window_appearance(move |window, cx| {
+        record_system(window.appearance().into(), cx);
+    })
+}
+
+/// Record the OS appearance and re-apply if it moved. `window`, when given,
+/// is the more authoritative source for what the OS currently reports.
+pub fn record_system_appearance(window: Option<&Window>, cx: &mut App) {
+    let appearance = match window {
+        Some(window) => window.appearance(),
+        None => cx.window_appearance(),
+    };
+    record_system(ThemeMode::from_window(appearance), cx);
+}
+
+/// Record the OS appearance and re-apply if it moved. Only recorded while the
+/// user's mode is `System` — a pinned mode ignores the OS anyway, and
+/// recording an override read back would overwrite what the OS said with what
+/// we asked for.
+fn record_system(system: ThemeMode, cx: &mut App) {
+    if !cx.has_global::<AppearanceState>() {
+        return;
+    }
+    let state = cx.global_mut::<AppearanceState>();
+    if state.mode != AppearanceMode::System || state.system == system {
+        return;
+    }
+    state.system = system;
+    apply(cx);
+}
+
+/// Re-resolve the palette and, if it moved, swap the theme and force a full
+/// repaint. A no-op when the resolved appearance is unchanged — the OS fires
+/// the appearance notification for other changes too, and repainting every
+/// window for those would be a visible hitch for nothing.
+pub fn apply(cx: &mut App) {
+    let Some(state) = cx.try_global::<AppearanceState>() else {
+        return;
+    };
+    let wanted = resolve(state.mode, state.system);
+    let changed = !cx
+        .try_global::<Theme>()
+        .is_some_and(|theme| theme.mode == wanted);
+    if changed {
+        Theme::change(wanted, None, cx);
+        cx.refresh_windows();
+    }
+}

crates/theme/src/brand.rs

@@ -0,0 +1,298 @@
+//! Brand, ported from bezel (`crates/theme/src/brand.rs`, MIT License,
+//! Copyright (c) 2026 bezel contributors): one hue for the greys, one for the
+//! accent, one radius, and the text ink.
+//!
+//! A brand moves hue alone: every lightness in `palette.rs` stays as the
+//! palette set it.
+
+use gpui::{App, Global, Hsla};
+
+use crate::{ThemeColors, ThemeMode, color, layout};
+
+/// A hue and how much of it, in oklch terms. `chroma: 0.0` is the shipped
+/// neutral, so [`Brand::default`] reproduces the built-in palette exactly.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Tint {
+    /// oklch hue, in degrees.
+    pub hue: f32,
+    /// oklch chroma. Neutral ramps live near 0.01–0.05; an accent carries more.
+    pub chroma: f32,
+}
+
+impl Tint {
+    pub const NONE: Self = Self {
+        hue: 0.0,
+        chroma: 0.0,
+    };
+
+    pub const fn new(hue: f32, chroma: f32) -> Self {
+        Self { hue, chroma }
+    }
+}
+
+/// The greys a UI is built on, as oklch hue and chroma.
+///
+/// Tailwind's five neutral families at their 500 step (tailwindcss.com/docs/colors)
+/// — the same list shadcn offers as its base colour, and the reason these are
+/// quoted rather than invented: a neutral that carries hue is a judgement
+/// someone else has already made five times.
+pub const BASE_COLORS: [(&str, Tint); 5] = [
+    ("Neutral", Tint::NONE),
+    ("Stone", Tint::new(58.071, 0.013)),
+    ("Zinc", Tint::new(285.938, 0.016)),
+    ("Gray", Tint::new(264.364, 0.027)),
+    ("Slate", Tint::new(257.417, 0.046)),
+];
+
+/// The alpha of each text role over the appearance's ink — white in dark,
+/// black in light.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct TextInk {
+    /// [`ThemeColors::text`].
+    pub text: f32,
+    /// [`ThemeColors::text_muted`].
+    pub muted: f32,
+    /// [`ThemeColors::text_faint`].
+    pub faint: f32,
+}
+
+impl TextInk {
+    /// The role at `alpha` over `appearance`'s ink.
+    pub fn color(appearance: ThemeMode, alpha: f32) -> Hsla {
+        match appearance {
+            ThemeMode::Dark => gpui::hsla(0.0, 0.0, 1.0, alpha),
+            ThemeMode::Light => gpui::hsla(0.0, 0.0, 0.0, alpha),
+        }
+    }
+
+    /// Writes [`ThemeColors::text`], [`ThemeColors::text_muted`] and
+    /// [`ThemeColors::text_faint`] for the appearance.
+    pub fn paint(&self, appearance: ThemeMode, colors: &mut ThemeColors) {
+        colors.text = Self::color(appearance, self.text);
+        colors.text_muted = Self::color(appearance, self.muted);
+        colors.text_faint = Self::color(appearance, self.faint);
+    }
+}
+
+/// Text ink for both appearances.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Ink {
+    pub dark: TextInk,
+    pub light: TextInk,
+}
+
+impl Ink {
+    /// Text and muted at 4.5:1 or more and faint at 3:1 or more, on
+    /// [`ThemeColors::bg`] and [`ThemeColors::surface`] in both appearances.
+    pub const ACCESSIBLE: Self = Self {
+        dark: TextInk {
+            text: 0.85,
+            muted: 0.52,
+            faint: 0.40,
+        },
+        light: TextInk {
+            text: 0.85,
+            muted: 0.56,
+            faint: 0.43,
+        },
+    };
+    /// AppKit's label, secondary and tertiary label colours. Muted is under
+    /// 4.5:1 on white, and faint is under 3:1 in both appearances.
+    pub const APPKIT: Self = Self {
+        dark: TextInk {
+            text: 0.85,
+            muted: 0.55,
+            faint: 0.25,
+        },
+        light: TextInk {
+            text: 0.85,
+            muted: 0.50,
+            faint: 0.26,
+        },
+    };
+
+    pub fn for_appearance(&self, appearance: ThemeMode) -> TextInk {
+        match appearance {
+            ThemeMode::Dark => self.dark,
+            ThemeMode::Light => self.light,
+        }
+    }
+}
+
+/// What an app changes about the shipped palette without redesigning it.
+///
+/// Installed as a gpui [`Global`] via [`crate::AppExt::set_brand`]; every
+/// palette install applies it, so it survives a light/dark switch and composes
+/// with [`crate::AppExt::set_palette`] rather than competing with it.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Brand {
+    /// The hue every grey in the palette carries.
+    pub tint: Tint,
+    /// The emphasis hue. Left neutral, the accent follows [`Self::tint`] like
+    /// any other grey — which is what the shipped palette already is.
+    pub accent: Tint,
+    /// The base corner radius; every other corner is a ratio of it. See
+    /// [`crate::BASE_RADIUS`].
+    pub radius: f32,
+    /// The text roles' alphas. [`Ink::APPKIT`] is what the palettes ship.
+    pub ink: Ink,
+}
+
+impl Global for Brand {}
+
+impl Default for Brand {
+    fn default() -> Self {
+        Self {
+            tint: Tint::NONE,
+            accent: Tint::NONE,
+            radius: layout::BASE_RADIUS,
+            ink: Ink::APPKIT,
+        }
+    }
+}
+
+impl Brand {
+    /// Whether applying this brand would change nothing — the shipped palette
+    /// already carries these values, so a JSON theme's own text colors must be
+    /// left alone.
+    pub fn is_default(&self) -> bool {
+        *self == Self::default()
+    }
+
+    /// The shipped palette for an appearance, rotated onto this brand.
+    pub fn branded(&self, appearance: ThemeMode) -> ThemeColors {
+        let mut colors = ThemeColors::for_appearance(appearance);
+        // apply() re-asserts this brand's ink, so the default brand — whose
+        // ink is the shipped one — must skip it to stay a strict no-op.
+        if !self.is_default() {
+            self.apply(appearance, &mut colors);
+        }
+        colors
+    }
+
+    /// Rotate a palette onto this brand's hues.
+    pub fn apply(&self, appearance: ThemeMode, colors: &mut ThemeColors) {
+        self.ink
+            .for_appearance(appearance)
+            .paint(appearance, colors);
+        // Every colour token, with the rule doing the choosing: a token that is
+        // already grey takes the tint, and one that already carries a hue —
+        // danger, warning, success — is semantic and keeps it. Translucent ink
+        // is skipped because it paints over whatever is beneath it, which is
+        // tinted already.
+        let tokens: [&mut Hsla; 41] = [
+            &mut colors.bg,
+            &mut colors.surface,
+            &mut colors.surface_raised,
+            &mut colors.surface_card,
+            &mut colors.surface_dialog,
+            &mut colors.surface_overlay,
+            &mut colors.element_hover,
+            &mut colors.element_active,
+            &mut colors.border_faint,
+            &mut colors.border,
+            &mut colors.border_strong,
+            &mut colors.text,
+            &mut colors.text_muted,
+            &mut colors.text_faint,
+            &mut colors.text_dim,
+            &mut colors.solid,
+            &mut colors.on_solid,
+            &mut colors.accent,
+            &mut colors.accent_strong,
+            &mut colors.on_accent,
+            &mut colors.danger,
+            &mut colors.danger_muted,
+            &mut colors.warning,
+            &mut colors.warning_muted,
+            &mut colors.success,
+            &mut colors.busy,
+            &mut colors.success_muted,
+            &mut colors.surface_raised_hover,
+            &mut colors.band,
+            &mut colors.input_bg,
+            &mut colors.selection,
+            &mut colors.cursor,
+            &mut colors.caret,
+            &mut colors.ring,
+            &mut colors.drop_target,
+            &mut colors.danger_strong,
+            &mut colors.code_text,
+            &mut colors.code_wash,
+            &mut colors.diff_add,
+            &mut colors.diff_del,
+            &mut colors.diff_hunk_bg,
+        ];
+        let syntax: [&mut Hsla; 24] = [
+            &mut colors.syntax.comment,
+            &mut colors.syntax.keyword,
+            &mut colors.syntax.string,
+            &mut colors.syntax.string_special,
+            &mut colors.syntax.escape,
+            &mut colors.syntax.number,
+            &mut colors.syntax.boolean,
+            &mut colors.syntax.type_name,
+            &mut colors.syntax.type_builtin,
+            &mut colors.syntax.constructor,
+            &mut colors.syntax.function,
+            &mut colors.syntax.function_builtin,
+            &mut colors.syntax.macro_name,
+            &mut colors.syntax.property,
+            &mut colors.syntax.constant,
+            &mut colors.syntax.variable,
+            &mut colors.syntax.variable_special,
+            &mut colors.syntax.parameter,
+            &mut colors.syntax.operator,
+            &mut colors.syntax.punctuation,
+            &mut colors.syntax.tag,
+            &mut colors.syntax.attribute,
+            &mut colors.syntax.label,
+            &mut colors.syntax.invalid,
+        ];
+        for slot in tokens.into_iter().chain(syntax) {
+            if slot.a == 1.0 && slot.s <= f32::EPSILON {
+                *slot = color::tint(*slot, self.tint.hue, self.tint.chroma);
+            }
+        }
+
+        if self.accent.chroma > 0.0 {
+            let (accent_l, plate_l) = if appearance.is_light() {
+                (ACCENT_L.1, PLATE_L.1)
+            } else {
+                (ACCENT_L.0, PLATE_L.0)
+            };
+            colors.accent = color::oklch(accent_l, self.accent.chroma, self.accent.hue);
+            colors.accent_strong = color::oklch(plate_l, self.accent.chroma, self.accent.hue);
+            // Whichever label the plate can actually hold. The shipped accent is
+            // the maximum-contrast neutral, where the answer is always the
+            // inverse; a chromatic plate at a yellow hue is bright enough that
+            // the inverse would be the unreadable one.
+            colors.on_accent = label_on(colors.accent_strong, colors);
+        }
+    }
+}
+
+/// The accent's lightness in each appearance — indigo-400's and indigo-600's,
+/// the two steps `palette.rs` picked so an accent clears WCAG AA on its own
+/// background rather than glowing on one and vanishing on the other.
+const ACCENT_L: (f32, f32) = (0.673, 0.511);
+
+/// The lightness of a *plate* carrying [`ThemeColors::on_accent`], taken from
+/// `danger_strong` — the palette's existing chromatic plate, already tuned to
+/// hold a label in both appearances.
+const PLATE_L: (f32, f32) = (0.58, 0.51);
+
+/// Whichever of the palette's two extremes the plate can actually hold.
+fn label_on(plate: Hsla, colors: &ThemeColors) -> Hsla {
+    let (a, b) = (colors.solid, colors.on_solid);
+    if color::contrast_ratio(plate, a) >= color::contrast_ratio(plate, b) {
+        a
+    } else {
+        b
+    }
+}
+
+/// Read the installed brand (the default before one is set).
+pub fn installed(cx: &App) -> Brand {
+    cx.try_global::<Brand>().copied().unwrap_or_default()
+}

crates/theme/src/color.rs

@@ -0,0 +1,215 @@
+//! Color math ported from bezel (`crates/theme/src/color.rs`, MIT License,
+//! Copyright (c) 2026 bezel contributors): the oklch → sRGB → HSL converters
+//! behind the token constructors, WCAG contrast for the palette tests, and
+//! small paint helpers.
+
+use gpui::{Hsla, hsla};
+
+/// A neutral (chroma 0) oklch tone as Hsla. Chroma 0 means r == g == b exactly,
+/// so this goes straight to an achromatic Hsla (skipping the hue math avoids
+/// float-noise saturation).
+pub fn neutral(lightness: f32) -> Hsla {
+    let [v, _, _] = oklch_to_srgb(lightness, 0.0, 0.0);
+    hsla(0.0, 0.0, v, 1.0)
+}
+
+/// An exact achromatic tone from an 8-bit channel value (`grey(13)` ≡ `#0d0d0d`)
+/// — for surfaces matched against reference samples.
+pub fn grey(value: u8) -> Hsla {
+    hsla(0.0, 0.0, value as f32 / 255.0, 1.0)
+}
+
+/// Convert an oklch color (CSS notation: L 0..1, C, H in degrees) to gpui Hsla.
+pub fn oklch(l: f32, c: f32, h_deg: f32) -> Hsla {
+    let [r, g, b] = oklch_to_srgb(l, c, h_deg);
+    let (h, s, l) = rgb_to_hsl(r, g, b);
+    hsla(h, s, l, 1.0)
+}
+
+/// oklch → sRGB (each 0..1, clamped/gamut-clipped per channel).
+/// Reference: Björn Ottosson's OKLab definition (the same matrices CSS Color 4 uses).
+pub fn oklch_to_srgb(l: f32, c: f32, h_deg: f32) -> [f32; 3] {
+    let [r, g, b] = oklch_to_linear(l, c, h_deg);
+    [gamma_encode(r), gamma_encode(g), gamma_encode(b)]
+}
+
+/// oklch → *linear* sRGB, unclamped: a component outside 0..1 is a color the
+/// display cannot make, which is what [`fit_chroma`] tests for.
+fn oklch_to_linear(l: f32, c: f32, h_deg: f32) -> [f32; 3] {
+    let h = h_deg.to_radians();
+    let a = c * h.cos();
+    let b = c * h.sin();
+
+    // OKLab → LMS (cube roots undone)
+    let l_ = l + 0.396_337_78 * a + 0.215_803_76 * b;
+    let m_ = l - 0.105_561_346 * a - 0.063_854_17 * b;
+    let s_ = l - 0.089_484_18 * a - 1.291_485_5 * b;
+    let (l3, m3, s3) = (l_ * l_ * l_, m_ * m_ * m_, s_ * s_ * s_);
+
+    // LMS → linear sRGB
+    let r = 4.076_741_7 * l3 - 3.307_711_6 * m3 + 0.230_969_93 * s3;
+    let g = -1.268_438 * l3 + 2.609_757_4 * m3 - 0.341_319_4 * s3;
+    let b = -0.004_196_086_3 * l3 - 0.703_418_6 * m3 + 1.707_614_7 * s3;
+
+    [r, g, b]
+}
+
+fn gamma_encode(x: f32) -> f32 {
+    let x = x.clamp(0.0, 1.0);
+    if x <= 0.003_130_8 {
+        12.92 * x
+    } else {
+        1.055 * x.powf(1.0 / 2.4) - 0.055
+    }
+}
+
+fn gamma_decode(x: f32) -> f32 {
+    let x = x.clamp(0.0, 1.0);
+    if x <= 0.040_449_936 {
+        x / 12.92
+    } else {
+        ((x + 0.055) / 1.055).powf(2.4)
+    }
+}
+
+/// The oklch lightness of an achromatic tone: [`neutral`] inverted.
+///
+/// Only greys round-trip through this. A grey's three channels are equal, and
+/// the three LMS matrix rows each sum to 1, so the whole OKLab transform
+/// collapses to one cube root — no inverse matrix needed.
+pub fn lightness(color: Hsla) -> f32 {
+    gamma_decode(color.l).cbrt()
+}
+
+/// The most chroma sRGB can hold at this lightness and hue, up to `chroma`.
+///
+/// Near black and near white the gamut is a needle: asking for a mid-ramp
+/// chroma there produces an out-of-range component, and clamping it per channel
+/// shifts the hue instead of dropping the saturation.
+fn fit_chroma(l: f32, chroma: f32, hue: f32) -> f32 {
+    let fits = |c: f32| {
+        oklch_to_linear(l, c, hue)
+            .iter()
+            .all(|x| (-1e-4..=1.0 + 1e-4).contains(x))
+    };
+    if fits(chroma) {
+        return chroma;
+    }
+    let (mut lo, mut hi) = (0.0, chroma);
+    for _ in 0..24 {
+        let mid = 0.5 * (lo + hi);
+        if fits(mid) { lo = mid } else { hi = mid }
+    }
+    lo
+}
+
+/// Re-emit an achromatic tone at `hue`, carrying as much `chroma` as its
+/// lightness can hold. Alpha rides through untouched.
+pub fn tint(color: Hsla, hue: f32, chroma: f32) -> Hsla {
+    if chroma <= 0.0 {
+        return color;
+    }
+    let l = lightness(color);
+    let mut out = oklch(l, fit_chroma(l, chroma, hue), hue);
+    out.a = color.a;
+    out
+}
+
+/// sRGB (0..1 components) → HSL, all components 0..1 (gpui's Hsla convention).
+pub fn rgb_to_hsl(r: f32, g: f32, b: f32) -> (f32, f32, f32) {
+    let max = r.max(g).max(b);
+    let min = r.min(g).min(b);
+    let l = (max + min) / 2.0;
+    let delta = max - min;
+    if delta < f32::EPSILON {
+        return (0.0, 0.0, l);
+    }
+    let s = if l > 0.5 {
+        delta / (2.0 - max - min)
+    } else {
+        delta / (max + min)
+    };
+    let h = if (max - r).abs() < f32::EPSILON {
+        ((g - b) / delta).rem_euclid(6.0)
+    } else if (max - g).abs() < f32::EPSILON {
+        (b - r) / delta + 2.0
+    } else {
+        (r - g) / delta + 4.0
+    } / 6.0;
+    (h, s, l)
+}
+
+/// HSL (gpui convention, all 0..1) → sRGB components 0..1.
+pub fn hsl_to_rgb(h: f32, s: f32, l: f32) -> [f32; 3] {
+    if s <= f32::EPSILON {
+        return [l, l, l];
+    }
+    let q = if l < 0.5 {
+        l * (1.0 + s)
+    } else {
+        l + s - l * s
+    };
+    let p = 2.0 * l - q;
+    let hue = |mut t: f32| {
+        t = t.rem_euclid(1.0);
+        if t < 1.0 / 6.0 {
+            p + (q - p) * 6.0 * t
+        } else if t < 0.5 {
+            q
+        } else if t < 2.0 / 3.0 {
+            p + (q - p) * (2.0 / 3.0 - t) * 6.0
+        } else {
+            p
+        }
+    };
+    [hue(h + 1.0 / 3.0), hue(h), hue(h - 1.0 / 3.0)]
+}
+
+/// WCAG 2.1 relative luminance of an opaque color.
+pub fn relative_luminance(color: Hsla) -> f32 {
+    let lin = |c: f32| {
+        if c <= 0.040_45 {
+            c / 12.92
+        } else {
+            ((c + 0.055) / 1.055).powf(2.4)
+        }
+    };
+    let [r, g, b] = hsl_to_rgb(color.h, color.s, color.l);
+    0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b)
+}
+
+/// WCAG 2.1 contrast ratio between two opaque colors (1.0 … 21.0).
+///
+/// Used by the palette tests to prove each light token reproduces the contrast
+/// its dark counterpart had, rather than merely looking plausible.
+pub fn contrast_ratio(a: Hsla, b: Hsla) -> f32 {
+    let (la, lb) = (relative_luminance(a), relative_luminance(b));
+    let (hi, lo) = if la >= lb { (la, lb) } else { (lb, la) };
+    (hi + 0.05) / (lo + 0.05)
+}
+
+/// Composite `fg` (which may be translucent) over an opaque `bg`, returning the
+/// opaque result — the color the eye actually receives.
+pub fn flatten(fg: Hsla, bg: Hsla) -> Hsla {
+    let a = fg.a.clamp(0.0, 1.0);
+    let [fr, fg_, fb] = hsl_to_rgb(fg.h, fg.s, fg.l);
+    let [br, bg_, bb] = hsl_to_rgb(bg.h, bg.s, bg.l);
+    let (h, s, l) = rgb_to_hsl(
+        fr * a + br * (1.0 - a),
+        fg_ * a + bg_ * (1.0 - a),
+        fb * a + bb * (1.0 - a),
+    );
+    hsla(h, s, l, 1.0)
+}
+
+/// Linear per-component mix of two colors.
+pub fn mix(a: Hsla, b: Hsla, t: f32) -> Hsla {
+    let t = t.clamp(0.0, 1.0);
+    let lerp = |x: f32, y: f32| x + (y - x) * t;
+    hsla(
+        lerp(a.h, b.h),
+        lerp(a.s, b.s),
+        lerp(a.l, b.l),
+        lerp(a.a, b.a),
+    )
+}

crates/theme/src/geometry.rs

@@ -1,57 +1,9 @@
-use std::fmt::{self, Debug, Display, Formatter};
+use std::fmt::Debug;
 
-use gpui::{AbsoluteLength, Axis, Length, Pixels};
+use gpui::Axis;
 use serde::{Deserialize, Serialize};
 
-/// A enum for defining the placement of the element.
-///
-/// See also: [`Side`] if you need to define the left, right side.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Placement {
-    #[serde(rename = "top")]
-    Top,
-    #[serde(rename = "bottom")]
-    Bottom,
-    #[serde(rename = "left")]
-    Left,
-    #[serde(rename = "right")]
-    Right,
-}
-
-impl Display for Placement {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Placement::Top => write!(f, "Top"),
-            Placement::Bottom => write!(f, "Bottom"),
-            Placement::Left => write!(f, "Left"),
-            Placement::Right => write!(f, "Right"),
-        }
-    }
-}
-
-impl Placement {
-    #[inline]
-    pub fn is_horizontal(&self) -> bool {
-        matches!(self, Placement::Left | Placement::Right)
-    }
-
-    #[inline]
-    pub fn is_vertical(&self) -> bool {
-        matches!(self, Placement::Top | Placement::Bottom)
-    }
-
-    #[inline]
-    pub fn axis(&self) -> Axis {
-        match self {
-            Placement::Top | Placement::Bottom => Axis::Vertical,
-            Placement::Left | Placement::Right => Axis::Horizontal,
-        }
-    }
-}
-
 /// A enum for defining the side of the element.
-///
-/// See also: [`Placement`] if you need to define the 4 edges.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Side {
     #[serde(rename = "left")]
@@ -94,39 +46,6 @@ impl AxisExt for Axis {
     }
 }
 
-/// A trait for converting [`Pixels`] to `f32` and `f64`.
-pub trait PixelsExt {
-    fn as_f32(&self) -> f32;
-    #[allow(clippy::wrong_self_convention)]
-    fn as_f64(self) -> f64;
-}
-impl PixelsExt for Pixels {
-    fn as_f32(&self) -> f32 {
-        f32::from(self)
-    }
-
-    fn as_f64(self) -> f64 {
-        f64::from(self)
-    }
-}
-
-/// A trait to extend the [`Length`] enum with utility methods.
-pub trait LengthExt {
-    /// Converts the [`Length`] to [`Pixels`] based on a given `base_size` and `rem_size`.
-    ///
-    /// If the [`Length`] is [`Length::Auto`], it returns `None`.
-    fn to_pixels(&self, base_size: AbsoluteLength, rem_size: Pixels) -> Option<Pixels>;
-}
-
-impl LengthExt for Length {
-    fn to_pixels(&self, base_size: AbsoluteLength, rem_size: Pixels) -> Option<Pixels> {
-        match self {
-            Length::Auto => None,
-            Length::Definite(len) => Some(len.to_pixels(base_size, rem_size)),
-        }
-    }
-}
-
 /// A struct for defining the edges of an element.
 ///
 /// A extend version of [`gpui::Edges`] to serialize/deserialize.
@@ -142,18 +61,3 @@ pub struct Edges<T: Clone + Debug + Default + PartialEq> {
     /// The size of the left edge.
     pub left: T,
 }
-
-impl<T> Edges<T>
-where
-    T: Clone + Debug + Default + PartialEq,
-{
-    /// Creates a new `Edges` instance with all edges set to the same value.
-    pub fn all(value: T) -> Self {
-        Self {
-            top: value.clone(),
-            right: value.clone(),
-            bottom: value.clone(),
-            left: value,
-        }
-    }
-}

crates/theme/src/layout.rs

@@ -0,0 +1,87 @@
+//! Layout constants, ported from bezel
+//! (`crates/theme/src/theme/layout.rs`, MIT License, Copyright (c) 2026 bezel
+//! contributors). Numbers drive layout, colors are paint: these live as plain
+//! numbers and never depend on which color is painted.
+
+use std::sync::atomic::{AtomicU32, Ordering};
+
+/// The branded base radius behind every radius accessor, as raw `f32` bits.
+static BASE: AtomicU32 = AtomicU32::new(BASE_RADIUS.to_bits());
+
+/// Point the radius accessors at a base. Called when a palette is installed.
+pub(crate) fn set_base_radius(radius: f32) {
+    BASE.store(radius.to_bits(), Ordering::Relaxed);
+}
+
+/// The gap between siblings. Measured on macOS 26: `NSStackView().spacing`,
+/// visual format's `-`, and `constraint(equalToSystemSpacingAfter:multiplier: 1)`
+/// all report 8.
+pub const SPACE: f32 = 8.0;
+
+/// The margin from content to its container's edge. Same measurement,
+/// visual format's `|-`.
+pub const CONTENT_MARGIN: f32 = 20.0;
+
+/// From a column's edge to the glyph of the control at the end of a row,
+/// measured to the glyph rather than the button. Mirrored at the trailing end.
+pub const EDGE: f32 = 12.0;
+
+/// Button, text field and select-trigger height. Measured:
+/// `NSButton`, `NSTextField` and `NSPopUpButton` all report 24 at
+/// `.regular` — the body line box with 4 above and below.
+pub const BUTTON_HEIGHT: f32 = 24.0;
+
+/// The same controls at `.small`.
+pub const CONTROL_HEIGHT_SMALL: f32 = 20.0;
+
+/// Every radius below is a ratio of this, so a brand radius moves the whole
+/// set together and keeps the concentric relationships intact.
+pub const BASE_RADIUS: f32 = 8.0;
+
+/// Message bubble corner radius (2x).
+pub fn bubble_radius() -> f32 {
+    radius(2.0)
+}
+
+/// Floating-surface corner radius — popovers, menus, dialogs (1.5x).
+pub fn surface_radius() -> f32 {
+    radius(1.5)
+}
+
+/// Panel / card corner radius (1.25x).
+pub fn panel_radius() -> f32 {
+    radius(1.25)
+}
+
+/// Button, text field and select-trigger radius (1x).
+pub fn button_radius() -> f32 {
+    radius(1.0)
+}
+
+/// Small control radius (chips, tags, steppers) — a size down from
+/// [`button_radius`], for things that sit inside a control rather than being one
+/// (0.75x).
+pub fn control_radius() -> f32 {
+    radius(0.75)
+}
+
+/// A corner as a multiple of the branded base radius.
+///
+/// Read from a process-wide mirror rather than the theme global for the reason
+/// [`crate::paint::current_appearance`] is: the element builders that round a
+/// corner are free functions with no `cx` in scope, and a radius is one number
+/// for the whole app.
+fn radius(ratio: f32) -> f32 {
+    f32::from_bits(BASE.load(Ordering::Relaxed)) * ratio
+}
+
+/// The concentric child of a surface: a row inset by `inset` inside a
+/// container of radius `outer` keeps its corners parallel to the container's,
+/// rather than looking pasted onto it.
+///
+/// This is SwiftUI's `ContainerRelativeShape` rule done as arithmetic. gpui
+/// has no container shape to inherit at paint time, so the relationship is
+/// stated where the child is *defined* instead of resolved at runtime.
+pub const fn inset_radius(outer: f32, inset: f32) -> f32 {
+    if outer > inset { outer - inset } else { 0.0 }
+}

crates/theme/src/lib.rs

@@ -1,25 +1,51 @@
 use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
 
 use gpui::{App, Global, Pixels, SharedString, Window, px};
 
+mod brand;
+mod color;
 mod colors;
 mod geometry;
+mod layout;
 mod notification;
+mod paint;
+mod palette;
 mod platform_kind;
-mod registry;
-mod scale;
 mod scrollbar_mode;
+mod syntax;
 mod theme;
+mod typography;
 
+pub mod appearance;
+
+pub use appearance::AppearanceMode;
+pub use brand::{BASE_COLORS, Brand, Ink, TextInk, Tint};
+pub use color::{
+    contrast_ratio, flatten, grey, hsl_to_rgb, lightness, mix, neutral, oklch, oklch_to_srgb,
+    relative_luminance, rgb_to_hsl, tint,
+};
 pub use colors::*;
 pub use geometry::*;
+pub use layout::{
+    BASE_RADIUS, BUTTON_HEIGHT, CONTENT_MARGIN, CONTROL_HEIGHT_SMALL, EDGE, SPACE, bubble_radius,
+    button_radius, control_radius, inset_radius, panel_radius, surface_radius,
+};
 pub use notification::*;
+pub use paint::{
+    INK_FILL_SCALE, INK_HAIRLINE_SCALE, SCRIM_ALPHA_DARK, band, current_appearance, hairline, ink,
+    plate_active, plate_hover, scrim, set_current_appearance, surface_shadows, wash,
+};
 pub use platform_kind::PlatformKind;
-pub use registry::*;
-pub use scale::*;
 pub use scrollbar_mode::*;
+pub use syntax::{HighlightKind, SyntaxPalette};
 pub use theme::*;
+pub use typography::{
+    DEFAULT_BASE_TEXT_SIZE, Metrics, TextStyle, Typeset, base_text_size, set_base_text_size,
+};
+
+/// Which appearance the app is painting. Bezel names this enum `Appearance`;
+/// coop's `ThemeMode` predates the port and carries the same two variants.
+pub type Appearance = ThemeMode;
 
 /// Defines window border radius for platforms that use client side decorations.
 pub const CLIENT_SIDE_DECORATION_ROUNDING: Pixels = px(10.0);
@@ -31,21 +57,110 @@ pub const CLIENT_SIDE_DECORATION_SHADOW: Pixels = px(10.0);
 pub const CLIENT_SIDE_DECORATION_BORDER: Pixels = px(1.0);
 
 /// Defines window titlebar height
-pub const TITLEBAR_HEIGHT: Pixels = px(36.0);
+pub(crate) const TITLEBAR_HEIGHT: Pixels = px(36.0);
 
 /// Defines workspace tabbar height
-pub const TABBAR_HEIGHT: Pixels = px(44.0);
+pub const TABBAR_HEIGHT: Pixels = px(36.0);
 
 /// Defines default sidebar width
 pub const SIDEBAR_WIDTH: Pixels = px(240.);
 
 pub fn init(cx: &mut App) {
-    registry::init(cx);
-
-    Theme::sync_system_appearance(None, cx);
+    appearance::init(AppearanceMode::default(), cx);
     Theme::sync_scrollbar_appearance(cx);
 }
 
+/// An alternative palette source.
+pub type PaletteBuilder = fn(ThemeMode) -> ThemeColors;
+
+struct GlobalPaletteBuilder(Option<PaletteBuilder>);
+
+impl Global for GlobalPaletteBuilder {}
+
+/// Install a brand or an alternative palette on the app.
+pub trait AppExt {
+    fn set_brand(&mut self, brand: Brand);
+    fn set_palette(&mut self, build: PaletteBuilder);
+    fn set_appearance_mode(&mut self, mode: AppearanceMode);
+    fn set_base_text_size(&mut self, points: f32);
+}
+
+impl AppExt for App {
+    fn set_brand(&mut self, brand: Brand) {
+        self.set_global(brand);
+        reinstall(self);
+    }
+
+    fn set_palette(&mut self, build: PaletteBuilder) {
+        self.set_global(GlobalPaletteBuilder(Some(build)));
+        reinstall(self);
+    }
+
+    fn set_appearance_mode(&mut self, mode: AppearanceMode) {
+        appearance::set_mode(mode, self);
+    }
+
+    fn set_base_text_size(&mut self, points: f32) {
+        typography::set_base_text_size(points);
+        self.refresh_windows();
+    }
+}
+
+/// Re-install the palette for the current appearance.
+fn reinstall(cx: &mut App) {
+    let mode = cx
+        .try_global::<Theme>()
+        .map(|theme| theme.mode)
+        .unwrap_or_default();
+    Theme::change(mode, None, cx);
+    cx.refresh_windows();
+}
+
+/// Mirror the active coop theme into the `gpui-base` global theme.
+pub fn sync_base(cx: &mut App) {
+    let Some(theme) = cx.try_global::<Theme>() else {
+        return;
+    };
+
+    let appearance = if theme.mode.is_dark() {
+        gpui_base::ThemeAppearance::Dark
+    } else {
+        gpui_base::ThemeAppearance::Light
+    };
+    let scrollbar_mode = match theme.scrollbar_mode {
+        ScrollbarMode::Scrolling => gpui_base::ScrollbarMode::Scrolling,
+        ScrollbarMode::Hover => gpui_base::ScrollbarMode::Hover,
+        ScrollbarMode::Always => gpui_base::ScrollbarMode::Always,
+    };
+    let colors = theme.colors;
+    let font_sans = theme.font_sans.clone();
+
+    let base = gpui_base::Theme::global_mut(cx);
+    base.appearance = appearance;
+    base.scrollbar = base.scrollbar.clone().with_mode(scrollbar_mode);
+    base.tokens.typography.sans = font_sans;
+
+    let tokens = &mut base.tokens.colors;
+    tokens.background = colors.bg;
+    tokens.foreground = colors.text;
+    tokens.surface = colors.surface;
+    tokens.surface_foreground = colors.text;
+    tokens.primary = colors.solid;
+    tokens.primary_foreground = colors.on_solid;
+    tokens.secondary = colors.surface_raised;
+    tokens.secondary_foreground = colors.text;
+    tokens.muted = colors.surface_card;
+    tokens.muted_foreground = colors.text_muted;
+    tokens.accent = colors.element_hover;
+    tokens.accent_foreground = colors.text;
+    tokens.destructive = colors.danger_strong;
+    tokens.destructive_foreground = gpui::white();
+    tokens.border = colors.border;
+    tokens.input = colors.border;
+    tokens.ring = colors.ring;
+    tokens.selection = colors.selection;
+}
+
 pub trait ActiveTheme {
     fn theme(&self) -> &Theme;
 }
@@ -59,38 +174,13 @@ impl ActiveTheme for App {
 
 #[derive(Debug, Clone)]
 pub struct Theme {
-    /// Theme colors
     pub colors: ThemeColors,
-
-    /// Theme family
-    pub theme: Rc<ThemeFamily>,
-
-    /// The appearance of the theme (light or dark).
     pub mode: ThemeMode,
-
-    /// The font family for the application.
-    pub font_family: SharedString,
-
-    /// The root font size for the application, default is 15px.
-    pub font_size: Pixels,
-
-    /// Radius for the general elements.
-    pub radius: Pixels,
-
-    /// Radius for the large elements, e.g.: modal, notification.
-    pub radius_lg: Pixels,
-
-    /// Enable shadow for the general elements. default is true
+    pub font_sans: SharedString,
+    pub font_mono: SharedString,
     pub shadow: bool,
-
-    /// Show the scrollbar mode, default: scrolling
     pub scrollbar_mode: ScrollbarMode,
-
-    /// Notification settings
     pub notification: NotificationSettings,
-
-    /// Platform kind
-    pub platform: PlatformKind,
 }
 
 impl Deref for Theme {
@@ -116,7 +206,7 @@ impl Theme {
     }
 
     /// Returns the global theme mutable reference
-    pub fn global_mut(cx: &mut App) -> &mut Theme {
+    pub(crate) fn global_mut(cx: &mut App) -> &mut Theme {
         cx.global_mut::<Theme>()
     }
 
@@ -127,12 +217,7 @@ impl Theme {
 
     /// Sync the theme with the system appearance
     pub fn sync_system_appearance(window: Option<&mut Window>, cx: &mut App) {
-        let appearance = window
-            .as_ref()
-            .map(|window| window.appearance())
-            .unwrap_or_else(|| cx.window_appearance());
-
-        Self::change(appearance, window, cx);
+        appearance::record_system_appearance(window.as_deref(), cx);
     }
 
     /// Sync the Scrollbar showing behavior with the system
@@ -144,77 +229,84 @@ impl Theme {
         };
     }
 
-    /// Apply a new theme to the application.
-    pub fn apply_theme(new_theme: Rc<ThemeFamily>, window: Option<&mut Window>, cx: &mut App) {
-        let theme = cx.global_mut::<Theme>();
-        let mode = theme.mode;
-        // Update the theme
-        theme.theme = new_theme;
-        // Emit a theme change event
-        Self::change(mode, window, cx);
-    }
-
     /// Change the app's appearance
     pub fn change<M>(mode: M, window: Option<&mut Window>, cx: &mut App)
     where
         M: Into<ThemeMode>,
     {
         if !cx.has_global::<Theme>() {
-            let default_theme = ThemeFamily::default();
-            let theme = Theme::from(default_theme);
-
-            cx.set_global(theme);
+            cx.set_global(Theme::default());
         }
 
         let mode = mode.into();
-        let theme = cx.global_mut::<Theme>();
+        let builder = cx
+            .try_global::<GlobalPaletteBuilder>()
+            .and_then(|builder| builder.0);
+        let mut colors = match builder {
+            Some(build) => build(mode),
+            None => ThemeColors::for_appearance(mode),
+        };
+
+        // A default brand changes nothing; anything else rotates the tokens.
+        let installed_brand = brand::installed(cx);
+        if !installed_brand.is_default() {
+            installed_brand.apply(mode, &mut colors);
+        }
+
+        let theme = Theme::global_mut(cx);
 
         // Set the theme mode
         theme.mode = mode;
 
         // Set the theme colors
-        if mode.is_dark() {
-            theme.colors = *theme.theme.dark();
-        } else {
-            theme.colors = *theme.theme.light();
-        }
+        theme.colors = colors;
 
         // Refresh the window if available
         if let Some(window) = window {
             window.refresh();
         }
+
+        // Keep the context-free paint helpers and the radius accessors in step
+        paint::set_current_appearance(mode);
+        layout::set_base_radius(installed_brand.radius);
+
+        // Keep the base-layer projection in step with the coop palette
+        sync_base(cx);
     }
 }
 
-impl From<ThemeFamily> for Theme {
-    fn from(family: ThemeFamily) -> Self {
+impl Default for Theme {
+    fn default() -> Self {
         let platform = PlatformKind::platform();
         let mode = ThemeMode::default();
 
-        // Define the font family based on the platform.
-        let font_family = match platform {
+        // The system UI font, by platform.
+        let font_sans = match platform {
             PlatformKind::Linux => "Inter",
             _ => ".SystemUIFont",
         };
 
-        // Define the theme colors based on the appearance
-        let colors = match mode {
-            ThemeMode::Light => family.light(),
-            ThemeMode::Dark => family.dark(),
-        };
-
-        Theme {
-            font_size: px(15.),
-            font_family: font_family.into(),
-            radius: px(6.),
-            radius_lg: px(10.),
+        Self {
+            font_sans: font_sans.into(),
+            font_mono: system_mono().into(),
             shadow: true,
             scrollbar_mode: ScrollbarMode::default(),
             notification: NotificationSettings::default(),
             mode,
-            colors: *colors,
-            theme: Rc::new(family),
-            platform,
+            colors: ThemeColors::for_appearance(mode),
         }
     }
 }
+
+/// The mono face has no alias of its own, so each backend is named here.
+fn system_mono() -> &'static str {
+    if cfg!(target_family = "wasm") {
+        ".ZedMono"
+    } else if cfg!(target_os = "macos") {
+        ".AppleSystemUIFontMonospaced"
+    } else if cfg!(target_os = "windows") {
+        "Cascadia Mono"
+    } else {
+        "DejaVu Sans Mono"
+    }
+}

crates/theme/src/paint.rs

@@ -0,0 +1,191 @@
+//! Context-free paint helpers, ported from bezel
+//! (`crates/theme/src/paint.rs`, MIT License, Copyright (c) 2026 bezel
+//! contributors): the process-wide appearance mirror and the free functions
+//! ([`ink`], [`hairline`], [`wash`], …) that element builders call without a
+//! `cx` in scope.
+
+use std::sync::atomic::{AtomicU8, Ordering};
+
+use gpui::{BoxShadow, Hsla, hsla, point, px};
+
+use crate::ThemeMode;
+
+/// Process-wide mirror of the installed theme's appearance.
+///
+/// The paint helpers are free functions called from deep inside element
+/// builders that have no `cx` in scope, so they read the appearance from here
+/// instead of the gpui global. Appearance is genuinely process-wide — one
+/// setting for every window — so a single mirror is sound; [`Theme::change`]
+/// is the only writer outside tests.
+static CURRENT_APPEARANCE: AtomicU8 = AtomicU8::new(0);
+
+/// The appearance the context-free paint helpers are painting for.
+pub fn current_appearance() -> ThemeMode {
+    match CURRENT_APPEARANCE.load(Ordering::Relaxed) {
+        1 => ThemeMode::Light,
+        _ => ThemeMode::Dark,
+    }
+}
+
+/// Point the context-free paint helpers at an appearance. Called by
+/// [`Theme::change`]; exposed for tests that build a palette without an `App`.
+pub fn set_current_appearance(appearance: ThemeMode) {
+    let encoded = match appearance {
+        ThemeMode::Dark => 0,
+        ThemeMode::Light => 1,
+    };
+    CURRENT_APPEARANCE.store(encoded, Ordering::Relaxed);
+}
+
+/// Light-mode alpha multiplier for **fills** (hover/active washes, chip and pill
+/// backgrounds).
+///
+/// The established light-UI scales (Primer, Radix) land subtle ≈ 3–4%, hover ≈ 8%,
+/// selected ≈ 14% black — which is where the dark palette's white alphas already
+/// sit. So the honest multiplier is 1: the same number in both appearances, with
+/// only the *tone* flipping. Any per-state correction belongs in that state's
+/// token, not in a blanket multiplier.
+pub const INK_FILL_SCALE: f32 = 1.0;
+
+/// Light-mode alpha multiplier for **hairlines** (borders, dividers, rings).
+/// Opposite of fills: a 1px edge has to hold its own against a bright surround,
+/// and the dark palette's white hairlines are deliberately faint. Scaling up
+/// keeps separators legible instead of dissolving into the panel.
+pub const INK_HAIRLINE_SCALE: f32 = 1.35;
+
+/// Lightness of [`hairline`] ink, dark then light.
+const HAIRLINE_TONE: (f32, f32) = (0.75, 0.25);
+
+/// Translucent **fill** ink for interactive states and chip plates: soft-white on
+/// dark, soft-black on light at [`INK_FILL_SCALE`] of the alpha.
+///
+/// Alphas are quoted in *dark-mode terms* at every call site — the dark theme is
+/// the tuned one — and the light value is derived. Callers keep one number and
+/// both appearances stay in the relationship the dark tuning established.
+pub fn ink(alpha: f32) -> Hsla {
+    ink_for(current_appearance(), alpha)
+}
+
+pub(crate) fn ink_for(appearance: ThemeMode, alpha: f32) -> Hsla {
+    match appearance {
+        ThemeMode::Dark => hsla(0.0, 0.0, 1.0, alpha),
+        ThemeMode::Light => hsla(0.0, 0.0, 0.0, alpha * INK_FILL_SCALE),
+    }
+}
+
+/// Translucent **hairline** ink for borders, dividers and rings: a light grey on
+/// dark, a dark grey on light at [`INK_HAIRLINE_SCALE`] of the alpha. Never
+/// pure white or black.
+///
+/// Separate from [`ink`] because edges and fills scale in opposite directions
+/// when the field brightens — a 1px line needs *more* ink on white, a plate needs
+/// less.
+pub fn hairline(alpha: f32) -> Hsla {
+    hairline_for(current_appearance(), alpha)
+}
+
+pub(crate) fn hairline_for(appearance: ThemeMode, alpha: f32) -> Hsla {
+    match appearance {
+        ThemeMode::Dark => hsla(0.0, 0.0, HAIRLINE_TONE.0, alpha),
+        ThemeMode::Light => hsla(
+            0.0,
+            0.0,
+            HAIRLINE_TONE.1,
+            (alpha * INK_HAIRLINE_SCALE).min(0.5),
+        ),
+    }
+}
+
+/// Interactive-state wash: a softened [`ink`] that stops short of pure black or
+/// white so hover plates read as tinted glass rather than paint.
+pub fn wash(alpha: f32) -> Hsla {
+    wash_for(current_appearance(), alpha)
+}
+
+pub(crate) fn wash_for(appearance: ThemeMode, alpha: f32) -> Hsla {
+    match appearance {
+        ThemeMode::Dark => hsla(0.0, 0.0, 0.92, alpha),
+        ThemeMode::Light => hsla(0.0, 0.0, 0.10, alpha * INK_FILL_SCALE),
+    }
+}
+
+/// Alpha of the standard modal backdrop in dark mode. Call sites that need a
+/// heavier or lighter scrim pass their own dark-mode alpha to [`scrim`].
+pub const SCRIM_ALPHA_DARK: f32 = 0.60;
+
+/// Modal backdrop at `alpha_dark` (quoted, as everywhere, in dark-mode terms).
+///
+/// Black in both appearances — a scrim's job is to darken what is behind it, and
+/// a "light scrim" of white would wash the modal out rather than seat it. What
+/// changes is strength: on a bright field a dark-mode-weight scrim reads as a
+/// blackout, so light mode scales to roughly half.
+pub fn scrim(alpha_dark: f32) -> Hsla {
+    scrim_for(current_appearance(), alpha_dark)
+}
+
+pub(crate) fn scrim_for(appearance: ThemeMode, alpha_dark: f32) -> Hsla {
+    match appearance {
+        ThemeMode::Dark => hsla(0.0, 0.0, 0.0, alpha_dark),
+        ThemeMode::Light => hsla(0.0, 0.0, 0.0, 0.32 * (alpha_dark / SCRIM_ALPHA_DARK)),
+    }
+}
+
+/// Recessed band behind a picker header or footer strip.
+///
+/// A free function as well as a token so the chrome that paints it can be built
+/// from context-free helpers; both resolve to the same value.
+pub fn band() -> Hsla {
+    band_for(current_appearance())
+}
+
+pub(crate) fn band_for(appearance: ThemeMode) -> Hsla {
+    match appearance {
+        ThemeMode::Dark => hsla(0.0, 0.0, 0.0, 0.16),
+        // A recessed strip on white needs far less ink than on near-black; the
+        // dark 16% would read as a bruise.
+        ThemeMode::Light => hsla(0.0, 0.0, 0.0, 0.045),
+    }
+}
+
+/// The elevation shadow a floating surface casts. Painted cut to outside the
+/// shape, because the same drop shadow under a translucent fill reads as a grey
+/// plate.
+pub fn surface_shadows() -> Vec<BoxShadow> {
+    vec![
+        BoxShadow {
+            color: hsla(0.0, 0.0, 0.0, 0.1),
+            offset: point(px(0.0), px(10.0)),
+            blur_radius: px(15.0),
+            spread_radius: px(-3.0),
+            inset: false,
+        },
+        BoxShadow {
+            color: hsla(0.0, 0.0, 0.0, 0.1),
+            offset: point(px(0.0), px(4.0)),
+            blur_radius: px(6.0),
+            spread_radius: px(-4.0),
+            inset: false,
+        },
+    ]
+}
+
+/// Hover over an opaque plate: brighten the plate in dark mode, darken it in
+/// light — never swap an opaque plate for a translucent wash.
+pub(crate) fn plate_hover_for(appearance: ThemeMode, plate: gpui::Hsla) -> gpui::Hsla {
+    crate::color::flatten(ink_for(appearance, 0.10), plate)
+}
+
+/// Pressed over an opaque plate, one rung above [`plate_hover_for`].
+pub(crate) fn plate_active_for(appearance: ThemeMode, plate: gpui::Hsla) -> gpui::Hsla {
+    crate::color::flatten(ink_for(appearance, 0.16), plate)
+}
+
+/// Hover over an opaque plate, for call sites outside this crate.
+pub fn plate_hover(plate: gpui::Hsla) -> gpui::Hsla {
+    plate_hover_for(current_appearance(), plate)
+}
+
+/// Pressed over an opaque plate, for call sites outside this crate.
+pub fn plate_active(plate: gpui::Hsla) -> gpui::Hsla {
+    plate_active_for(current_appearance(), plate)
+}

crates/theme/src/palette.rs

@@ -0,0 +1,137 @@
+use gpui::{hsla, rgb};
+
+use crate::paint::{band_for, hairline_for};
+use crate::syntax::SyntaxPalette;
+use crate::{Ink, TextInk, ThemeColors, ThemeMode, color};
+
+pub(crate) fn dark() -> ThemeColors {
+    let warning = color::oklch(0.828, 0.189, 84.429);
+    ThemeColors {
+        bg: color::grey(6),
+        surface: color::grey(13),
+        surface_raised: color::neutral(0.235),
+        surface_card: color::grey(0x0e),
+        surface_dialog: color::grey(0x10),
+        surface_overlay: color::grey(0x16),
+        element_hover: hsla(0.0, 0.0, 1.0, 0.08),
+        element_active: hsla(0.0, 0.0, 1.0, 0.12),
+
+        border_faint: hairline_for(ThemeMode::Dark, 0.06),
+        border: hairline_for(ThemeMode::Dark, 0.08),
+        border_strong: hairline_for(ThemeMode::Dark, 0.14),
+
+        text: TextInk::color(ThemeMode::Dark, Ink::APPKIT.dark.text),
+        text_muted: TextInk::color(ThemeMode::Dark, Ink::APPKIT.dark.muted),
+        text_faint: TextInk::color(ThemeMode::Dark, Ink::APPKIT.dark.faint),
+        text_dim: color::grey(0x98),
+
+        // The restored Radix yellow brand: #ffe629 plate, #14120b label.
+        solid: color::oklch(0.918, 0.184, 100.9),
+        on_solid: color::grey(0x0e),
+
+        // The restored Radix yellow brand: #f5e147 ink, #ffe629 plate.
+        accent: color::oklch(0.900, 0.166, 101.7),
+        accent_strong: color::oklch(0.918, 0.184, 100.9),
+        on_accent: color::grey(0x0e),
+
+        danger: color::oklch(0.704, 0.191, 22.216),
+        danger_muted: color::oklch(0.808, 0.114, 19.571),
+        danger_strong: color::oklch(0.58, 0.16, 25.0),
+        success: color::oklch(0.765, 0.177, 163.223),
+        success_muted: color::oklch(0.845, 0.143, 164.978),
+        busy: color::oklch(0.718, 0.202, 349.761),
+
+        surface_raised_hover: color::neutral(0.29),
+        band: band_for(ThemeMode::Dark),
+        input_bg: hsla(0.0, 0.0, 1.0, 0.03),
+        selection: rgb(0x3f638b).into(),
+        cursor: color::neutral(0.94),
+        caret: color::neutral(0.673),
+        ring: hairline_for(ThemeMode::Dark, 0.35),
+        drop_line: hairline_for(ThemeMode::Dark, 0.35),
+        drop_target: hsla(0.0, 0.0, 1.0, 0.10),
+
+        code_text: color::neutral(0.94),
+        code_wash: hsla(0.0, 0.0, 1.0, 0.08),
+        syntax: SyntaxPalette::dark(
+            color::neutral(0.922),
+            color::neutral(0.60),
+            color::oklch(0.704, 0.191, 22.216),
+        ),
+        diff_add: color::oklch(0.765, 0.177, 163.223),
+        diff_del: color::oklch(0.704, 0.191, 22.216),
+        diff_hunk_bg: hsla(0.6, 0.35, 0.6, 0.05),
+
+        warning,
+        warning_muted: warning.alpha(0.16),
+    }
+}
+
+pub(crate) fn light() -> ThemeColors {
+    let warning = color::oklch(0.555, 0.163, 48.998);
+    ThemeColors {
+        bg: color::grey(0xff),
+        surface: color::neutral(0.968),
+        surface_raised: color::neutral(0.940),
+        surface_card: color::grey(0xff),
+        surface_dialog: color::grey(0xff),
+        surface_overlay: color::grey(0xff),
+        element_hover: hsla(0.0, 0.0, 0.0, 0.04),
+        element_active: hsla(0.0, 0.0, 0.0, 0.06),
+
+        border_faint: hairline_for(ThemeMode::Light, 0.06),
+        border: hairline_for(ThemeMode::Light, 0.08),
+        border_strong: hairline_for(ThemeMode::Light, 0.14),
+
+        text: TextInk::color(ThemeMode::Light, Ink::APPKIT.light.text),
+        text_muted: color::neutral(0.45),
+        text_faint: TextInk::color(ThemeMode::Light, Ink::APPKIT.light.faint),
+        text_dim: color::neutral(0.50),
+
+        // The restored Radix yellow brand: #ffe629 plate, #473b1f label.
+        solid: color::oklch(0.918, 0.184, 100.9),
+        on_solid: color::oklch(0.358, 0.046, 86.9),
+
+        // The restored Radix yellow brand: #9e6c00 ink, #ffe629 plate.
+        accent: color::oklch(0.569, 0.119, 76.8),
+        accent_strong: color::oklch(0.918, 0.184, 100.9),
+        on_accent: color::neutral(0.205),
+
+        danger: color::oklch(0.577, 0.245, 27.325),
+        danger_muted: color::oklch(0.505, 0.213, 27.518),
+        danger_strong: color::oklch(0.51, 0.20, 25.0),
+        warning,
+        warning_muted: warning.alpha(0.10),
+        success: color::oklch(0.596, 0.145, 163.225),
+        success_muted: color::oklch(0.508, 0.118, 165.612),
+        busy: color::oklch(0.592, 0.249, 0.584),
+
+        surface_raised_hover: color::neutral(0.900),
+        band: band_for(ThemeMode::Light),
+        input_bg: color::neutral(0.950),
+        selection: rgb(0xb3d7ff).into(),
+        cursor: color::neutral(0.205),
+        caret: color::neutral(0.511),
+        ring: hairline_for(ThemeMode::Light, 0.35),
+        drop_line: hairline_for(ThemeMode::Light, 0.35),
+        drop_target: hsla(0.0, 0.0, 0.0, 0.06),
+
+        code_text: color::neutral(0.18),
+        code_wash: hsla(0.0, 0.0, 0.0, 0.06),
+        syntax: SyntaxPalette::light(
+            color::neutral(0.25),
+            color::neutral(0.48),
+            color::oklch(0.505, 0.213, 27.518),
+        ),
+        diff_add: color::oklch(0.596, 0.145, 163.225),
+        diff_del: color::oklch(0.577, 0.245, 27.325),
+        diff_hunk_bg: hsla(0.6, 0.35, 0.35, 0.07),
+    }
+}
+
+pub(crate) fn for_appearance(appearance: ThemeMode) -> ThemeColors {
+    match appearance {
+        ThemeMode::Dark => dark(),
+        ThemeMode::Light => light(),
+    }
+}

crates/theme/src/platform_kind.rs

@@ -18,16 +18,4 @@ impl PlatformKind {
             Self::Web
         }
     }
-
-    pub fn is_linux(&self) -> bool {
-        matches!(self, Self::Linux)
-    }
-
-    pub fn is_windows(&self) -> bool {
-        matches!(self, Self::Windows)
-    }
-
-    pub fn is_mac(&self) -> bool {
-        matches!(self, Self::Mac)
-    }
 }

crates/theme/src/registry.rs

@@ -1,70 +0,0 @@
-use std::collections::HashMap;
-use std::rc::Rc;
-use std::sync::Arc;
-
-use anyhow::{Context as AnyhowContext, Error};
-use gpui::{App, AppContext, AssetSource, Context, Entity, Global, SharedString};
-
-use crate::ThemeFamily;
-
-pub fn init(cx: &mut App) {
-    ThemeRegistry::set_global(cx.new(ThemeRegistry::new), cx);
-}
-
-struct GlobalThemeRegistry(Entity<ThemeRegistry>);
-
-impl Global for GlobalThemeRegistry {}
-
-pub struct ThemeRegistry {
-    /// Map of theme names to theme families
-    themes: HashMap<SharedString, Rc<ThemeFamily>>,
-}
-
-impl ThemeRegistry {
-    /// Retrieve the global theme registry state
-    pub fn global(cx: &App) -> Entity<Self> {
-        cx.global::<GlobalThemeRegistry>().0.clone()
-    }
-
-    /// Set the global theme registry instance
-    pub(crate) fn set_global(state: Entity<Self>, cx: &mut App) {
-        cx.set_global(GlobalThemeRegistry(state));
-    }
-
-    /// Create a new theme registry instance
-    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
-        let mut themes = HashMap::new();
-        let asset = cx.asset_source();
-
-        if let Ok(paths) = asset.list("themes") {
-            for path in paths.into_iter() {
-                match Self::load(&path, asset) {
-                    Ok(theme) => {
-                        themes.insert(path, Rc::new(theme));
-                    }
-                    Err(e) => {
-                        log::error!("Failed to load theme: {path}. Error: {e}");
-                    }
-                }
-            }
-        }
-
-        Self { themes }
-    }
-
-    /// Load a theme from the asset source.
-    fn load(path: &str, asset: &Arc<dyn AssetSource>) -> Result<ThemeFamily, Error> {
-        // Load the theme file from the assets
-        let content = asset.load(path)?.context("Theme not found")?;
-
-        // Parse the JSON content into a Theme Family struct
-        let theme: ThemeFamily = serde_json::from_slice(&content)?;
-
-        Ok(theme)
-    }
-
-    /// Returns a reference to the map of themes.
-    pub fn themes(&self) -> &HashMap<SharedString, Rc<ThemeFamily>> {
-        &self.themes
-    }
-}