chore: release version 1.0.0-beta5

Reviewed-on: #33

.github/workflows/release.yml

@@ -21,7 +21,7 @@ jobs:
             os: windows-11-arm
             target: aarch64-pc-windows-msvc
           - platform: macos-x64
-            os: macos-13
+            os: macos-15-intel
             target: x86_64-apple-darwin
           - platform: macos-arm64
             os: macos-latest
@@ -45,7 +45,7 @@ jobs:
       # Windows and macOS builds using cargo-packager
       - name: Build with cargo-packager (Windows/macOS)
         if: runner.os != 'Linux'
-        working-directory: crates/coop
+        working-directory: desktop
         run: |
           cargo install cargo-packager --locked
           cargo packager --release
@@ -130,7 +130,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Make get-crate-version executable
         run: chmod +x script/get-crate-version
@@ -154,17 +154,15 @@ jobs:
 
       - name: Create draft release
         id: create_release
-        uses: softprops/action-gh-release@v2
+        uses: akkuman/gitea-release-action@v1
         with:
-          tag_name: ${{ steps.version.outputs.tag }}
-          name: ${{ steps.version.outputs.tag }}
+          server_url: "https://git.reya.su/"
+          repository: "reya/coop"
+          token: ${{ secrets.GITEA_TOKEN }}
           draft: true
           prerelease: false
-          generate_release_notes: true
           files: |
             artifacts/**/*
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Output release info
         run: |

.github/workflows/rust.yml

@@ -13,7 +13,7 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         rustup: [stable]
 
     runs-on: ${{ matrix.os }}

.gitignore

@@ -21,3 +21,6 @@ dist/
 .DS_Store
 # Added by goreleaser init:
 .intentionally-empty-file.o
+
+.cargo/
+vendor/

Cargo.toml

@@ -1,26 +1,30 @@
 [workspace]
 resolver = "2"
-members = ["crates/*"]
-default-members = ["crates/coop"]
+members = ["crates/*", "desktop", "web"]
+default-members = ["desktop"]
 
 [workspace.package]
-version = "0.3.0"
-edition = "2021"
+version = "1.0.0-beta5"
+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" }
 
 # Nostr
-nostr = { git = "https://github.com/rust-nostr/nostr",  features = [ "nip96", "nip59", "nip49", "nip44" ] }
-nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
-nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
+nostr-lmdb = { git = "https://github.com/rust-nostr/nostr", rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
+nostr-connect = { git = "https://github.com/rust-nostr/nostr", rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
+nostr-blossom = { git = "https://github.com/rust-nostr/nostr", rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
+nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr", rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
+nostr-sdk = { git = "https://github.com/rust-nostr/nostr", rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
+nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip96", "nip59", "nip49", "nip44" ], rev = "46d66396467e07c3dfb71e5102104ecb7e9c6b64" }
 
 # Others
 anyhow = "1.0.44"
@@ -29,7 +33,6 @@ futures = "0.3"
 itertools = "0.13.0"
 log = "0.4"
 oneshot = "0.1.10"
-reqwest = { version = "0.12", features = ["multipart", "stream", "json"] }
 flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
 rust-embed = "8.5.0"
 serde = { version = "1.0", features = ["derive"] }
@@ -39,6 +42,7 @@ smallvec = "1.14.0"
 smol = "2"
 tracing = "0.1.40"
 webbrowser = "1.0.4"
+tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
 
 [profile.release]
 strip = true

README.md

@@ -1,12 +1,12 @@
 ![Coop](/docs/coop.png)
 
 <p>
-    <a href="https://github.com/lumehq/coop/actions/workflows/rust.yml">
-      <img alt="Actions" src="https://github.com/lumehq/coop/actions/workflows/rust.yml/badge.svg">
+    <a href="https://github.com/reyakov/coop/actions/workflows/rust.yml">
+      <img alt="Actions" src="https://github.com/reyakov/coop/actions/workflows/rust.yml/badge.svg">
     </a>
-    <img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/lumehq/coop">
-    <img alt="GitHub issues" src="https://img.shields.io/github/issues-raw/lumehq/coop">
-    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/lumehq/coop">
+    <img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/reyakov/coop">
+    <img alt="GitHub issues" src="https://img.shields.io/github/issues-raw/reyakov/coop">
+    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/reyakov/coop">
 </p>
 
 Coop is a simple, fast, and reliable nostr client for secure messaging across all platforms.
@@ -36,7 +36,7 @@ To install Coop, follow these steps:
 
 1. **Download the Latest Release**:
 
-   - Visit the [Coop Releases page on GitHub](https://github.com/lumehq/coop/releases).
+   - Visit the [Coop Releases page on GitHub](https://github.com/reyakov/coop/releases).
    - Download the package that matches your operating system (Windows, macOS, or Linux).
 
 2. **Install**:
@@ -65,7 +65,7 @@ Coop is built using Rust and GPUI. All Nostr related stuffs handled by [Rust Nos
 1. Clone the repository:
 
    ```bash
-   git clone https://github.com/lumehq/coop.git
+   git clone https://github.com/reyakov/coop.git
    cd coop
    ```
 
@@ -118,7 +118,7 @@ For more information, see the [Contributing](#contributing) section.
 - [Rust Nostr](https://github.com/rust-nostr/nostr/)
 - [GPUI](https://www.gpui.rs/)
 - [GPUI Components](https://github.com/longbridge/gpui-component/)
-- [Coop Issue Tracker](https://github.com/lumehq/coop/issues/)
+- [Coop Issue Tracker](https://github.com/reyakov/coop/issues/)
 
 ### License
 

assets/icons/book.svg

@@ -0,0 +1,3 @@
+<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>

assets/icons/copy.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="M7.10352 4C7.42998 2.84575 8.49122 2 9.75 2H14.25C15.5088 2 16.57 2.84575 16.8965 4H18.25C19.7688 4 21 5.23122 21 6.75V19.25C21 20.7688 19.7688 22 18.25 22H5.75C4.23122 22 3 20.7688 3 19.25V6.75C3 5.23122 4.23122 4 5.75 4H7.10352ZM8.5 4.75V6.25C8.5 6.38807 8.61193 6.5 8.75 6.5H15.25C15.3881 6.5 15.5 6.38807 15.5 6.25V4.75C15.5 4.05964 14.9404 3.5 14.25 3.5H9.75C9.05964 3.5 8.5 4.05964 8.5 4.75Z" fill="currentColor"/>
+<path d="M8.75 8.75V4C8.75 3.30964 9.30964 2.75 10 2.75H20C20.6904 2.75 21.25 3.30964 21.25 4V14C21.25 14.6904 20.6904 15.25 20 15.25H15.25M14 8.75H4C3.30964 8.75 2.75 9.30964 2.75 10V20C2.75 20.6904 3.30964 21.25 4 21.25H14C14.6904 21.25 15.25 20.6904 15.25 20V10C15.25 9.30964 14.6904 8.75 14 8.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>

assets/icons/device.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M14.25 10.75C14.25 9.64543 15.1454 8.75 16.25 8.75H20.25C21.3546 8.75 22.25 9.64543 22.25 10.75V19.25C22.25 20.3546 21.3546 21.25 20.25 21.25H16.25C15.1454 21.25 14.25 20.3546 14.25 19.25V10.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M17.25 18.25H19.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M20.25 8.75V5.75C20.25 4.64543 19.3546 3.75 18.25 3.75H5.75C4.64543 3.75 3.75 4.64543 3.75 5.75V14.75C3.75 15.8546 2.85457 16.75 1.75 16.75V18.25C1.75 19.3546 2.64543 20.25 3.75 20.25H14.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M3.75 16.75H14.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/group.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<circle cx="12" cy="8.75" r="3" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><circle cx="4" cy="9.80005" r="2" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><circle cx="20" cy="9.80005" r="2" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M7.25 16.625V16.5C7.25 13.8766 9.37665 11.75 12 11.75C14.6234 11.75 16.75 13.8766 16.75 16.5V16.625C16.75 17.5225 16.0225 18.25 15.125 18.25H8.875C7.97754 18.25 7.25 17.5225 7.25 16.625Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M4.25 17.2602H2.75C1.64543 17.2602 0.706551 16.3538 0.919944 15.2701C1.25877 13.5493 2.15049 12.3257 4 11.8301" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M19.75 17.2601H21.25C22.3546 17.2601 23.2935 16.3538 23.08 15.27C22.7412 13.5493 21.8495 12.3257 20 11.8301" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/input.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M11.75 6.75H19.25C20.3546 6.75 21.25 7.64543 21.25 8.75V15.25C21.25 16.3546 20.3546 17.25 19.25 17.25H11.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M5.75 6.75H4.75C3.64543 6.75 2.75 7.64543 2.75 8.75V15.25C2.75 16.3546 3.64543 17.25 4.75 17.25H5.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M8.75 3.75V20.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" 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="M19.25 4C20.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.75C2 5.23122 3.23122 4 4.75 4H19.25ZM6.25 7.5C5.83579 7.5 5.5 7.83579 5.5 8.25V15.75C5.5 16.1642 5.83579 16.5 6.25 16.5C6.66421 16.5 7 16.1642 7 15.75V8.25C7 7.83579 6.66421 7.5 6.25 7.5Z" fill="currentColor"/>
+<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"/>
 </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="M6.25 8.25V15.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+<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"/>
 </svg>

assets/icons/panel-right-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="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.75ZM17.75 7.5C18.1642 7.5 18.5 7.83579 18.5 8.25V15.75C18.5 16.1642 18.1642 16.5 17.75 16.5C17.3358 16.5 17 16.1642 17 15.75V8.25C17 7.83579 17.3358 7.5 17.75 7.5Z" fill="currentColor"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M15 5.5V18.5H4.75C4.05964 18.5 3.5 17.9404 3.5 17.25V6.75C3.5 6.05964 4.05964 5.5 4.75 5.5H15ZM22 6.75C22 5.23122 20.7688 4 19.25 4H4.75C3.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.75Z" fill="currentColor"/>
 </svg>

assets/icons/panel-right.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="M17.75 8.25V15.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M15.75 5V19" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/><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"/>
 </svg>

assets/icons/refresh.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M13 21C13.5523 21 14 20.5523 14 20C14 19.4477 13.5523 19 13 19C12.4477 19 12 19.4477 12 20C12 20.5523 12.4477 21 13 21Z" fill="currentColor"/><path d="M21 11C21 10.4477 20.5523 9.99999 20 9.99999C19.4477 9.99999 19 10.4477 19 11C19 11.5523 19.4477 12 20 12C20.5523 12 21 11.5523 21 11Z" fill="currentColor"/><path d="M19.9295 14.2679C20.4078 14.5441 20.5716 15.1557 20.2955 15.634C20.0193 16.1123 19.4078 16.2761 18.9295 16C18.4512 15.7238 18.2873 15.1123 18.5634 14.634C18.8396 14.1557 19.4512 13.9918 19.9295 14.2679Z" fill="currentColor"/><path d="M17.3676 19.2942C17.8459 19.0181 18.0098 18.4065 17.7336 17.9282C17.4575 17.4499 16.8459 17.286 16.3676 17.5621C15.8893 17.8383 15.7254 18.4499 16.0016 18.9282C16.2777 19.4065 16.8893 19.5703 17.3676 19.2942Z" fill="currentColor"/><path d="M18.9269 7.99998C18.4487 8.27612 17.8371 8.11225 17.5609 7.63396C17.2848 7.15566 17.4487 6.54407 17.9269 6.26793C18.4052 5.99179 19.0168 6.15566 19.293 6.63396C19.5691 7.11225 19.4052 7.72384 18.9269 7.99998Z" fill="currentColor"/><path d="M9.25 14.75V20.25H3.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15.2493 4.41452C14.2521 3.98683 13.1537 3.75 12 3.75C7.44365 3.75 3.75 7.44365 3.75 12C3.75 15.498 5.92698 18.4875 9 19.6876" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/reset.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M13 17.25C16.4518 17.25 19.25 14.4518 19.25 11V10.5C19.25 6.77208 16.2279 3.75 12.5 3.75C8.77208 3.75 5.75 6.77208 5.75 10.5V20" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M2 16.5L5.75 20.25L9.5 16.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/scan.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M7.25 4.75H4.75C3.64543 4.75 2.75 5.64543 2.75 6.75V9.25M16.75 4.75H19.25C20.3546 4.75 21.25 5.64543 21.25 6.75V9.25M21.25 14.75V17.25C21.25 18.3546 20.3546 19.25 19.25 19.25H16.75M7.25 19.25H4.75C3.64543 19.25 2.75 18.3546 2.75 17.25V14.75M7.75 9.75V14.25M16.25 9.75V14.25M12 9.75V12.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/settings2.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M13 19.25H5.95C4.82989 19.25 4.26984 19.25 3.84202 19.032C3.46569 18.8403 3.15973 18.5343 2.96799 18.158C2.75 17.7302 2.75 17.1701 2.75 16.05V7.95C2.75 6.82989 2.75 6.26984 2.96799 5.84202C3.15973 5.46569 3.46569 5.15973 3.84202 4.96799C4.26984 4.75 4.8299 4.75 5.95 4.75H18.05C19.1701 4.75 19.7302 4.75 20.158 4.96799C20.5343 5.15973 20.8403 5.46569 21.032 5.84202C21.25 6.26984 21.25 6.8299 21.25 7.95V11" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M3 5.63635L10.9761 10.3898C11.6069 10.7657 12.3931 10.7657 13.0239 10.3898L21 5.63635" stroke="currentColor" stroke-width="1.5"/><path d="M21.8148 15.375L21.1669 15.7491M16.1856 18.625L16.8335 18.2509M21.8147 18.625L21.1669 18.251M16.1855 15.375L16.8335 15.7491M19.0002 20.25L19.0002 19.4375M19.0002 13.75V14.5625M21.1669 17C21.1669 16.6053 21.0613 16.2352 20.8769 15.9165C20.5022 15.269 19.8021 14.8333 19.0002 14.8333C18.1983 14.8333 17.4981 15.269 17.1235 15.9165C16.9391 16.2352 16.8335 16.6053 16.8335 17C16.8335 17.3947 16.9391 17.7648 17.1235 18.0835C17.4982 18.731 18.1983 19.1667 19.0002 19.1667C19.8021 19.1667 20.5022 18.731 20.8769 18.0835C21.0613 17.7648 21.1669 17.3947 21.1669 17Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/user-key.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M12.9996 12.8145C12.675 12.7719 12.3415 12.75 11.9996 12.75C8.55174 12.75 5.94978 14.981 4.9305 18.114C4.56744 19.23 5.50919 20.25 6.68275 20.25H13.9996M15.7496 6.5C15.7496 8.57107 14.0706 10.25 11.9996 10.25C9.92851 10.25 8.24958 8.57107 8.24958 6.5C8.24958 4.42893 9.92851 2.75 11.9996 2.75C14.0706 2.75 15.7496 4.42893 15.7496 6.5ZM15.7496 14C15.7496 12.7574 16.7569 11.75 17.9996 11.75C19.2422 11.75 20.2496 12.7574 20.2496 14C20.2496 14.7801 19.8526 15.4675 19.2496 15.8711V17L18.7496 17.9356L19.2496 18.9678V20L17.9996 21L16.7496 20V15.8711C16.1466 15.4675 15.7496 14.7801 15.7496 14Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/themes/aurora.json

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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

@@ -0,0 +1,144 @@
+{
+  "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/auto_update/Cargo.toml

@@ -9,7 +9,6 @@ common = { path = "../common" }
 
 gpui.workspace = true
 gpui_tokio.workspace = true
-reqwest.workspace = true
 anyhow.workspace = true
 smol.workspace = true
 log.workspace = true

crates/auto_update/src/lib.rs

@@ -3,26 +3,28 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
 
-use anyhow::{anyhow, Context as AnyhowContext, Error};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::http_client::{AsyncBody, HttpClient};
 use gpui::{
     App, AppContext, AsyncApp, BackgroundExecutor, Context, Entity, Global, Subscription, Task,
+    Window,
 };
 use semver::Version;
 use serde::Deserialize;
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
 use smol::fs::File;
+use smol::io::AsyncReadExt;
 use smol::process::Command;
 
 const GITHUB_API_URL: &str = "https://api.github.com";
 const COOP_UPDATE_EXPLANATION: &str = "COOP_UPDATE_EXPLANATION";
 
 fn get_github_repo_owner() -> String {
-    std::env::var("COOP_GITHUB_REPO_OWNER").unwrap_or_else(|_| "your-username".to_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(|_| "your-repo".to_string())
+    std::env::var("COOP_GITHUB_REPO_NAME").unwrap_or_else(|_| "coop".to_string())
 }
 
 fn is_flatpak_installation() -> bool {
@@ -30,14 +32,14 @@ fn is_flatpak_installation() -> bool {
     std::env::var("FLATPAK_ID").is_ok() || std::env::var(COOP_UPDATE_EXPLANATION).is_ok()
 }
 
-pub fn init(cx: &mut App) {
+pub fn init(window: &mut Window, cx: &mut App) {
     // Skip auto-update initialization if installed via Flatpak
     if is_flatpak_installation() {
         log::info!("Skipping auto-update initialization: App is installed via Flatpak");
         return;
     }
 
-    AutoUpdater::set_global(cx.new(AutoUpdater::new), cx);
+    AutoUpdater::set_global(cx.new(|cx| AutoUpdater::new(window, cx)), cx);
 }
 
 struct GlobalAutoUpdater(Entity<AutoUpdater>);
@@ -181,7 +183,7 @@ pub struct AutoUpdater {
     _subscriptions: SmallVec<[Subscription; 1]>,
 
     /// Background tasks
-    _tasks: SmallVec<[Task<()>; 2]>,
+    tasks: Vec<Task<Result<(), Error>>>,
 }
 
 impl AutoUpdater {
@@ -195,44 +197,9 @@ impl AutoUpdater {
         cx.set_global(GlobalAutoUpdater(state));
     }
 
-    fn new(cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
-        let async_version = version.clone();
-
         let mut subscriptions = smallvec![];
-        let mut tasks = smallvec![];
-
-        tasks.push(
-            // Check for updates after 2 minutes
-            cx.spawn(async move |this, cx| {
-                cx.background_executor()
-                    .timer(Duration::from_secs(120))
-                    .await;
-
-                // Update the status to checking
-                this.update(cx, |this, cx| {
-                    this.set_status(AutoUpdateStatus::Checking, cx);
-                })
-                .ok();
-
-                match Self::check_for_updates(async_version, cx).await {
-                    Ok(download_url) => {
-                        // Update the status to checked with download URL
-                        this.update(cx, |this, cx| {
-                            this.set_status(AutoUpdateStatus::checked(download_url), cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        log::warn!("Failed to check for updates: {e}");
-                        this.update(cx, |this, cx| {
-                            this.set_status(AutoUpdateStatus::Idle, cx);
-                        })
-                        .ok();
-                    }
-                }
-            }),
-        );
 
         subscriptions.push(
             // Observe the status
@@ -243,11 +210,16 @@ impl AutoUpdater {
             }),
         );
 
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, _window, cx| {
+            this.check(cx);
+        });
+
         Self {
             status: AutoUpdateStatus::Idle,
             version,
+            tasks: vec![],
             _subscriptions: subscriptions,
-            _tasks: tasks,
         }
     }
 
@@ -256,31 +228,63 @@ impl AutoUpdater {
         cx.notify();
     }
 
-    fn check_for_updates(version: Version, cx: &AsyncApp) -> Task<Result<String, Error>> {
+    fn check(&mut self, cx: &mut Context<Self>) {
+        let version = self.version.clone();
+        let duration = Duration::from_secs(120);
+        let task = self.check_for_updates(version, cx);
+
+        // Check for updates after 2 minutes
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(duration).await;
+
+            // Update the status to checking
+            this.update(cx, |this, cx| {
+                this.set_status(AutoUpdateStatus::Checking, cx);
+            })?;
+
+            match task.await {
+                Ok(download_url) => {
+                    // Update the status to checked with download URL
+                    this.update(cx, |this, cx| {
+                        this.set_status(AutoUpdateStatus::checked(download_url), cx);
+                    })?;
+                }
+                Err(e) => {
+                    log::warn!("Failed to check for updates: {e}");
+                    this.update(cx, |this, cx| {
+                        this.set_status(AutoUpdateStatus::Idle, cx);
+                    })?;
+                }
+            }
+
+            Ok(())
+        }));
+    }
+
+    fn check_for_updates(&self, version: Version, cx: &App) -> Task<Result<String, Error>> {
+        let http_client = cx.http_client();
+        let repo_owner = get_github_repo_owner();
+        let repo_name = get_github_repo_name();
+
         cx.background_spawn(async move {
-            let client = reqwest::Client::new();
-            let repo_owner = get_github_repo_owner();
-            let repo_name = get_github_repo_name();
             let url = format!(
                 "{}/repos/{}/{}/releases/latest",
                 GITHUB_API_URL, repo_owner, repo_name
             );
 
-            let response = client
-                .get(&url)
-                .header("User-Agent", "Coop-Auto-Updater")
-                .send()
-                .await
-                .context("Failed to fetch GitHub releases")?;
+            let async_body = AsyncBody::default();
+            let mut body = Vec::new();
+            let mut response = http_client.get(&url, async_body, false).await?;
+
+            // Read the response body into a vector
+            response.body_mut().read_to_end(&mut body).await?;
 
             if !response.status().is_success() {
                 return Err(anyhow!("GitHub API returned error: {}", response.status()));
             }
 
-            let release: GitHubRelease = response
-                .json()
-                .await
-                .context("Failed to parse GitHub release")?;
+            // Parse the response body as JSON
+            let release: GitHubRelease = serde_json::from_slice(&body)?;
 
             // Parse version from tag (remove 'v' prefix if present)
             let tag_version = release.tag_name.trim_start_matches('v');
@@ -334,29 +338,31 @@ impl AutoUpdater {
             Ok((installer_dir, target_path))
         });
 
-        self._tasks.push(
+        self.tasks.push(
             // Install the new release
             cx.spawn(async move |this, cx| {
-                _ = this.update(cx, |this, cx| {
+                this.update(cx, |this, cx| {
                     this.set_status(AutoUpdateStatus::Installing, cx);
-                });
+                })?;
 
                 match task.await {
                     Ok((installer_dir, target_path)) => {
                         if Self::install(installer_dir, target_path, cx).await.is_ok() {
                             // Update the status to updated
-                            _ = this.update(cx, |this, cx| {
+                            this.update(cx, |this, cx| {
                                 this.set_status(AutoUpdateStatus::Updated, cx);
-                            });
+                            })?;
                         }
                     }
                     Err(e) => {
                         // Update the status to error including the error message
-                        _ = this.update(cx, |this, cx| {
+                        this.update(cx, |this, cx| {
                             this.set_status(AutoUpdateStatus::error(e.to_string()), cx);
-                        });
+                        })?;
                     }
                 }
+
+                Ok(())
             }),
         );
     }

crates/chat/src/lib.rs

@@ -1,20 +1,23 @@
 use std::cmp::Reverse;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap, HashSet};
 use std::hash::{DefaultHasher, Hash, Hasher};
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
-use anyhow::{anyhow, Context as AnyhowContext, Error};
-use common::EventUtils;
-use fuzzy_matcher::skim::SkimMatcherV2;
+use anyhow::{Context as AnyhowContext, Error, anyhow};
+use common::EventExt;
+use device::{DeviceEvent, DeviceRegistry};
 use fuzzy_matcher::FuzzyMatcher;
+use fuzzy_matcher::skim::SkimMatcherV2;
 use gpui::{
-    App, AppContext, Context, Entity, EventEmitter, Global, Subscription, Task, WeakEntity, Window,
+    App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Subscription, Task,
+    WeakEntity, Window,
 };
 use nostr_sdk::prelude::*;
-use smallvec::{smallvec, SmallVec};
-use state::{NostrRegistry, DEVICE_GIFTWRAP, USER_GIFTWRAP};
+use smallvec::{SmallVec, smallvec};
+use smol::lock::RwLock;
+use state::{CoopSigner, DEVICE_GIFTWRAP, NostrRegistry, StateEvent, TIMEOUT, USER_GIFTWRAP};
 
 mod message;
 mod room;
@@ -39,6 +42,8 @@ pub enum ChatEvent {
     CloseRoom(u64),
     /// An event to notify UI about a new chat request
     Ping,
+    /// An error occurred
+    Error(SharedString),
 }
 
 /// Channel signal.
@@ -48,22 +53,62 @@ enum Signal {
     Message(NewMessage),
     /// Eose received from relay pool
     Eose,
+    /// An error occurred
+    Error(FailedMessage),
 }
 
+impl Signal {
+    pub fn message(gift_wrap: EventId, rumor: UnsignedEvent) -> Self {
+        Self::Message(NewMessage::new(gift_wrap, rumor))
+    }
+
+    pub fn eose() -> Self {
+        Self::Eose
+    }
+
+    pub fn error<T>(event: &Event, reason: T) -> Self
+    where
+        T: Into<SharedString>,
+    {
+        Self::Error(FailedMessage::new(event, reason))
+    }
+}
+
+type Dekey = bool;
+type GiftWrapId = EventId;
+
 /// Chat Registry
 #[derive(Debug)]
 pub struct ChatRegistry {
-    /// Collection of all chat rooms
+    /// Whether the chat registry is currently initializing.
+    pub initializing: bool,
+
+    /// Chat rooms
     rooms: Vec<Entity<Room>>,
 
+    /// Events that failed to unwrap for any reason
+    trashes: Entity<BTreeSet<FailedMessage>>,
+
+    /// Tracking events seen on which relays in the current session
+    seens: Arc<RwLock<HashMap<EventId, HashSet<RelayUrl>>>>,
+
+    /// Mapping of unwrapped event ids to their gift wrap event ids
+    event_map: Arc<RwLock<HashMap<EventId, (GiftWrapId, Dekey)>>>,
+
     /// Tracking the status of unwrapping gift wrap events.
     tracking_flag: 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]>,
 
     /// Subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
+    _subscriptions: SmallVec<[Subscription; 2]>,
 }
 
 impl EventEmitter<ChatEvent> for ChatRegistry {}
@@ -82,35 +127,68 @@ impl ChatRegistry {
     /// Create a new chat registry instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
-        let nip65 = nostr.read(cx).nip65_state();
-        let nip17 = nostr.read(cx).nip17_state();
+        let device = DeviceRegistry::global(cx);
 
+        let (tx, rx) = flume::unbounded::<Signal>();
         let mut subscriptions = smallvec![];
 
         subscriptions.push(
-            // Observe the nip65 state and load chat rooms on every state change
-            cx.observe(&nip65, |this, state, cx| {
-                if state.read(cx).idle() {
+            // Subscribe to the signer event
+            cx.subscribe_in(&nostr, window, |this, state, event, window, cx| {
+                if event == &StateEvent::SignerSet {
                     this.reset(cx);
-                }
+                    this.get_contact_list(cx);
+                    this.get_rooms(cx);
+
+                    let signer = state.read(cx).signer();
+                    cx.spawn_in(window, async move |this, cx| {
+                        let user_signer = signer.get().await;
+                        this.update(cx, |this, cx| {
+                            this.get_messages(user_signer, cx);
+                        })
+                        .ok();
+                    })
+                    .detach();
+                };
             }),
         );
 
         subscriptions.push(
-            // Observe the nip17 state and load chat rooms on every state change
-            cx.observe(&nip17, |this, _state, cx| {
-                this.get_rooms(cx);
+            // Subscribe to the device event
+            cx.subscribe_in(&device, window, |_this, _s, event, window, cx| {
+                if event == &DeviceEvent::Set {
+                    let nostr = NostrRegistry::global(cx);
+                    let signer = nostr.read(cx).signer();
+
+                    cx.spawn_in(window, async move |this, cx| {
+                        if let Some(device_signer) = signer.get_encryption_signer().await {
+                            this.update(cx, |this, cx| {
+                                this.get_messages(device_signer, cx);
+                            })
+                            .ok();
+                        }
+                    })
+                    .detach();
+                };
             }),
         );
 
+        // Run at the end of the current cycle
         cx.defer_in(window, |this, _window, cx| {
+            this.get_rooms(cx);
             this.handle_notifications(cx);
             this.tracking(cx);
         });
 
         Self {
+            initializing: true,
             rooms: vec![],
+            trashes: cx.new(|_| BTreeSet::default()),
+            seens: Arc::new(RwLock::new(HashMap::default())),
+            event_map: Arc::new(RwLock::new(HashMap::default())),
             tracking_flag: Arc::new(AtomicBool::new(false)),
+            signal_rx: rx,
+            signal_tx: tx,
             tasks: smallvec![],
             _subscriptions: subscriptions,
         }
@@ -122,60 +200,92 @@ impl ChatRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
         let status = self.tracking_flag.clone();
+        let seens = self.seens.clone();
+        let event_map = self.event_map.clone();
+        let trashes = self.trashes.downgrade();
 
         let initialized_at = Timestamp::now();
         let sub_id1 = SubscriptionId::new(DEVICE_GIFTWRAP);
         let sub_id2 = SubscriptionId::new(USER_GIFTWRAP);
 
         // Channel for communication between nostr and gpui
-        let (tx, rx) = flume::bounded::<Signal>(1024);
+        let tx = self.signal_tx.clone();
+        let rx = self.signal_rx.clone();
 
         self.tasks.push(cx.background_spawn(async move {
-            let device_signer = signer.get_encryption_signer().await;
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
 
             while let Some(notification) = notifications.next().await {
-                let ClientNotification::Message { message, .. } = notification else {
+                let ClientNotification::Message { message, relay_url } = notification else {
                     // Skip non-message notifications
                     continue;
                 };
 
-                match message {
-                    RelayMessage::Event { event, .. } => {
+                match *message {
+                    RelayMessage::Event {
+                        event,
+                        subscription_id,
+                    } => {
+                        // Keep track of which relays have seen this event
+                        {
+                            let mut seens = seens.write().await;
+                            seens.entry(event.id).or_default().insert(relay_url);
+                        }
+
+                        // De-duplicate events by their ID
                         if !processed_events.insert(event.id) {
-                            // Skip if the event has already been processed
                             continue;
                         }
 
+                        // Skip non-gift wrap events
                         if event.kind != Kind::GiftWrap {
-                            // Skip non-gift wrap events
                             continue;
                         }
 
-                        log::info!("Received gift wrap event: {:?}", event);
-
                         // Extract the rumor from the gift wrap event
-                        match Self::extract_rumor(&client, &device_signer, event.as_ref()).await {
-                            Ok(rumor) => match rumor.created_at >= initialized_at {
-                                true => {
-                                    let new_message = NewMessage::new(event.id, rumor);
-                                    let signal = Signal::Message(new_message);
+                        match extract_rumor(&client, &signer, event.as_ref()).await {
+                            Ok(rumor) => {
+                                // Map the rumor id to the gift wrap event id for later lookup
+                                {
+                                    let mut event_map = event_map.write().await;
+                                    let dekey = subscription_id.as_ref() == &sub_id1;
+                                    event_map.insert(rumor.id.unwrap(), (event.id, dekey));
+                                }
 
+                                if rumor.kind != Kind::PrivateDirectMessage
+                                    || rumor.kind != Kind::Custom(15)
+                                {
+                                    log::info!("Rumor is not releated to NIP17");
+                                    continue;
+                                }
+
+                                // Check if the rumor has a recipient
+                                if rumor.tags.is_empty() {
+                                    let signal =
+                                        Signal::error(event.as_ref(), "Recipient is missing");
                                     tx.send_async(signal).await?;
                                 }
-                                false => {
+
+                                // Check if the rumor was created after the chat was initialized (for detecting new messages)
+                                if rumor.created_at >= initialized_at {
+                                    let signal = Signal::message(event.id, rumor);
+                                    tx.send_async(signal).await?;
+                                } else {
+                                    // Mark the chat still processing new messages
                                     status.store(true, Ordering::Release);
                                 }
-                            },
+                            }
                             Err(e) => {
-                                log::warn!("Failed to unwrap the gift wrap event: {e}");
+                                let reason = format!("Failed to extract rumor: {e}");
+                                let signal = Signal::error(event.as_ref(), reason);
+                                tx.send_async(signal).await?;
                             }
                         }
                     }
                     RelayMessage::EndOfStoredEvents(id) => {
                         if id.as_ref() == &sub_id1 || id.as_ref() == &sub_id2 {
-                            tx.send_async(Signal::Eose).await?;
+                            tx.send_async(Signal::eose()).await?;
                         }
                     }
                     _ => {}
@@ -198,6 +308,12 @@ impl ChatRegistry {
                             this.get_rooms(cx);
                         })?;
                     }
+                    Signal::Error(trash) => {
+                        trashes.update(cx, |this, cx| {
+                            this.insert(trash);
+                            cx.notify();
+                        })?;
+                    }
                 };
             }
 
@@ -208,19 +324,180 @@ impl ChatRegistry {
     /// Tracking the status of unwrapping gift wrap events.
     fn tracking(&mut self, cx: &mut Context<Self>) {
         let status = self.tracking_flag.clone();
+        let tx = self.signal_tx.clone();
 
         self.tasks.push(cx.background_spawn(async move {
-            let loop_duration = Duration::from_secs(10);
+            let loop_duration = Duration::from_secs(15);
 
             loop {
                 if status.load(Ordering::Acquire) {
                     _ = status.compare_exchange(true, false, Ordering::Release, Ordering::Relaxed);
+                    _ = tx.send_async(Signal::Eose).await;
+                } else {
+                    _ = tx.send_async(Signal::Eose).await;
                 }
                 smol::Timer::after(loop_duration).await;
             }
         }));
     }
 
+    /// Get contact list from relays
+    fn get_contact_list(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+
+        let Some(public_key) = signer.public_key() else {
+            return;
+        };
+
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            let id = SubscriptionId::new("contact-list");
+            let opts = SubscribeAutoCloseOptions::default()
+                .exit_policy(ReqExitPolicy::ExitOnEOSE)
+                .timeout(Some(Duration::from_secs(TIMEOUT)));
+
+            // Construct filter for inbox relays
+            let filter = Filter::new()
+                .kind(Kind::ContactList)
+                .author(public_key)
+                .limit(1);
+
+            // Subscribe
+            client.subscribe(filter).close_on(opts).with_id(id).await?;
+
+            Ok(())
+        });
+
+        self.tasks.push(task);
+    }
+
+    /// Get all messages for the provided signer
+    fn get_messages<T>(&mut self, signer: T, cx: &mut Context<Self>)
+    where
+        T: NostrSigner + 'static,
+    {
+        let task = self.subscribe_gift_wrap_events(signer, cx);
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(_) => {
+                    this.update(cx, |this, cx| {
+                        this.set_initializing(false, cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(ChatEvent::Error(SharedString::from(e.to_string())));
+                    })?;
+                }
+            }
+            Ok(())
+        }));
+    }
+
+    // Get messaging relay list for current user
+    fn get_messaging_relays(&self, cx: &App) -> Task<Result<Vec<RelayUrl>, Error>> {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+
+        cx.background_spawn(async move {
+            let public_key = signer.get_public_key().await?;
+            let id = SubscriptionId::new("inbox-relay");
+
+            // Construct filter for inbox relays
+            let filter = Filter::new()
+                .kind(Kind::InboxRelays)
+                .author(public_key)
+                .limit(1);
+
+            // Stream events from user's write relays
+            let mut stream = client
+                .stream_events(filter)
+                .with_id(id)
+                .timeout(Duration::from_secs(TIMEOUT))
+                .await?;
+
+            while let Some((_url, res)) = stream.next().await {
+                if let Ok(event) = res {
+                    let urls: Vec<RelayUrl> = nip17::extract_owned_relay_list(event).collect();
+                    return Ok(urls);
+                }
+            }
+
+            Err(anyhow!("Messaging Relays not found"))
+        })
+    }
+
+    /// Continuously get gift wrap events for the signer
+    fn subscribe_gift_wrap_events<T>(&self, signer: T, cx: &App) -> Task<Result<(), Error>>
+    where
+        T: NostrSigner + 'static,
+    {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let urls = self.get_messaging_relays(cx);
+
+        cx.background_spawn(async move {
+            let urls = urls.await?;
+            let public_key = signer.get_public_key().await?;
+            let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
+            let id = SubscriptionId::new(format!("{}-msg", public_key.to_hex()));
+
+            // Ensure relay connections
+            for url in urls.iter() {
+                client.add_relay(url).and_connect().await?;
+            }
+
+            // Construct target for subscription
+            let target: HashMap<RelayUrl, Filter> = urls
+                .into_iter()
+                .map(|relay| (relay, filter.clone()))
+                .collect();
+
+            let output = client.subscribe(target).with_id(id).await?;
+
+            log::info!(
+                "Successfully subscribed to gift-wrap messages on: {:?}",
+                output.success
+            );
+
+            Ok(())
+        })
+    }
+
+    /// Refresh the chat registry, fetching messages and contact list from relays.
+    pub fn refresh(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.reset(cx);
+        self.get_contact_list(cx);
+        self.get_rooms(cx);
+
+        let nostr = NostrRegistry::global(cx);
+        let signer = nostr.read(cx).signer();
+
+        cx.spawn_in(window, async move |this, cx| {
+            let user_signer = signer.get().await;
+            let device_signer = signer.get_encryption_signer().await;
+
+            this.update(cx, |this, cx| {
+                this.get_messages(user_signer, cx);
+
+                if let Some(device_signer) = device_signer {
+                    this.get_messages(device_signer, cx);
+                }
+            })
+            .ok();
+        })
+        .detach();
+    }
+
+    /// Set the initializing status of the chat registry
+    fn set_initializing(&mut self, initializing: bool, cx: &mut Context<Self>) {
+        self.initializing = initializing;
+        cx.notify();
+    }
+
     /// Get the loading status of the chat registry
     pub fn loading(&self) -> bool {
         self.tracking_flag.load(Ordering::Acquire)
@@ -251,6 +528,51 @@ impl ChatRegistry {
             .count()
     }
 
+    /// Count the number of messages seen by a given relay.
+    pub fn count_messages(&self, relay_url: &RelayUrl) -> usize {
+        self.seens
+            .read_blocking()
+            .values()
+            .filter(|seen| seen.contains(relay_url))
+            .count()
+    }
+
+    /// Count the number of trash messages.
+    pub fn count_trash_messages(&self, cx: &App) -> usize {
+        self.trashes.read(cx).len()
+    }
+
+    /// Get the trash messages entity.
+    pub fn trashes(&self) -> Entity<BTreeSet<FailedMessage>> {
+        self.trashes.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
+            .read_blocking()
+            .get(id)
+            .map(|(id, _dekey)| self.seen_on(id))
+    }
+
+    /// Get the relays that have seen a given gift wrap id.
+    pub fn seen_on(&self, id: &EventId) -> HashSet<RelayUrl> {
+        self.seens
+            .read_blocking()
+            .get(id)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// Check if a given rumor was encrypted by the dekey.
+    pub fn encrypted_by_dekey(&self, id: &EventId) -> bool {
+        self.event_map
+            .read_blocking()
+            .get(id)
+            .map(|(_, dekey)| *dekey)
+            .unwrap_or(false)
+    }
+
     /// Add a new room to the start of list.
     pub fn add_room<I>(&mut self, room: I, cx: &mut Context<Self>)
     where
@@ -328,7 +650,12 @@ impl ChatRegistry {
 
     /// Reset the registry.
     pub fn reset(&mut self, cx: &mut Context<Self>) {
+        self.initializing = true;
         self.rooms.clear();
+        self.trashes.update(cx, |this, cx| {
+            this.clear();
+            cx.notify();
+        });
         cx.notify();
     }
 
@@ -364,16 +691,21 @@ impl ChatRegistry {
     pub fn get_rooms(&mut self, cx: &mut Context<Self>) {
         let task = self.get_rooms_from_database(cx);
 
-        cx.spawn(async move |this, cx| {
-            let rooms = task.await.ok()?;
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(rooms) => {
+                    this.update(cx, |this, cx| {
+                        this.extend_rooms(rooms, cx);
+                        this.sort(cx);
+                    })?;
+                }
+                Err(e) => {
+                    log::error!("Failed to load rooms: {}", e);
+                }
+            };
 
-            this.update(cx, move |this, cx| {
-                this.extend_rooms(rooms, cx);
-                this.sort(cx);
-            })
-            .ok()
-        })
-        .detach();
+            Ok(())
+        }));
     }
 
     /// Create a task to load rooms from the database
@@ -386,7 +718,11 @@ impl ChatRegistry {
             let public_key = signer.get_public_key().await?;
 
             // Get contacts
-            let contacts = client.database().contacts_public_keys(public_key).await?;
+            let contacts = client
+                .database()
+                .contacts_public_keys(public_key)
+                .await
+                .unwrap_or_default();
 
             // Construct authored filter
             let authored_filter = Filter::new()
@@ -413,10 +749,10 @@ impl ChatRegistry {
 
             // Process each event and group by room hash
             for raw in events.into_iter() {
-                if let Ok(rumor) = UnsignedEvent::from_json(&raw.content) {
-                    if rumor.tags.public_keys().peekable().peek().is_some() {
-                        grouped.entry(rumor.uniq_id()).or_default().push(rumor);
-                    }
+                if let Ok(rumor) = UnsignedEvent::from_json(&raw.content)
+                    && rumor.tags.public_keys().peekable().peek().is_some()
+                {
+                    grouped.entry(rumor.uniq_id()).or_default().push(rumor);
                 }
             }
 
@@ -456,11 +792,21 @@ impl ChatRegistry {
     /// 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>) {
+        let nostr = NostrRegistry::global(cx);
+        let signer = nostr.read(cx).signer();
+
         match self.rooms.iter().find(|e| e.read(cx).id == message.room) {
             Some(room) => {
                 room.update(cx, |this, cx| {
+                    if this.kind == RoomKind::Request
+                        && let Some(public_key) = signer.public_key()
+                        && message.rumor.pubkey == public_key
+                    {
+                        this.set_ongoing(cx);
+                    }
                     this.push_message(message, cx);
                 });
+                self.sort(cx);
             }
             None => {
                 // Push the new room to the front of the list
@@ -470,158 +816,155 @@ impl ChatRegistry {
     }
 
     /// Trigger a refresh of the opened chat rooms by their IDs
-    pub fn refresh_rooms(&mut self, ids: Option<Vec<u64>>, cx: &mut Context<Self>) {
-        if let Some(ids) = ids {
-            for room in self.rooms.iter() {
-                if ids.contains(&room.read(cx).id) {
-                    room.update(cx, |this, cx| {
-                        this.emit_refresh(cx);
-                    });
-                }
+    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(
-        client: &Client,
-        device_signer: &Option<Arc<dyn NostrSigner>>,
-        gift_wrap: &Event,
-    ) -> Result<UnsignedEvent, Error> {
-        // Try to get cached rumor first
-        if let Ok(event) = Self::get_rumor(client, gift_wrap.id).await {
-            return Ok(event);
+/// Unwraps a gift-wrapped event and processes its contents.
+async fn extract_rumor(
+    client: &Client,
+    signer: &Arc<CoopSigner>,
+    gift_wrap: &Event,
+) -> Result<UnsignedEvent, Error> {
+    // 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(signer, gift_wrap).await?;
+    let mut rumor = unwrapped.rumor;
+
+    // Generate event id for the rumor if it doesn't have one
+    rumor.ensure_id();
+
+    // Cache the rumor
+    if let Err(e) = set_rumor(client, gift_wrap.id, &rumor).await {
+        log::error!("Failed to cache rumor: {e:?}");
+    }
+
+    Ok(rumor)
+}
+
+/// Helper method to try unwrapping with different signers
+async fn try_unwrap(signer: &Arc<CoopSigner>, gift_wrap: &Event) -> Result<UnwrappedGift, Error> {
+    // Try with the device signer first
+    if let Some(signer) = signer.get_encryption_signer().await {
+        log::info!("trying with encryption key");
+        if let Ok(unwrapped) = try_unwrap_with(gift_wrap, &signer).await {
+            return Ok(unwrapped);
         }
-
-        // Try to unwrap with the available signer
-        let unwrapped = Self::try_unwrap(client, device_signer, gift_wrap).await?;
-        let mut rumor_unsigned = unwrapped.rumor;
-
-        // Generate event id for the rumor if it doesn't have one
-        rumor_unsigned.ensure_id();
-
-        // Cache the rumor
-        Self::set_rumor(client, gift_wrap.id, &rumor_unsigned).await?;
-
-        Ok(rumor_unsigned)
     }
 
-    /// Helper method to try unwrapping with different signers
-    async fn try_unwrap(
-        client: &Client,
-        device_signer: &Option<Arc<dyn NostrSigner>>,
-        gift_wrap: &Event,
-    ) -> Result<UnwrappedGift, Error> {
-        // Try with the device signer first
-        if let Some(signer) = device_signer {
-            if let Ok(unwrapped) = Self::try_unwrap_with(gift_wrap, signer).await {
-                return Ok(unwrapped);
-            };
-        };
+    // Fallback to the user's signer
+    let user_signer = signer.get().await;
+    let unwrapped = try_unwrap_with(gift_wrap, &user_signer).await?;
 
-        // Try with the user's signer
-        let user_signer = client.signer().context("Signer not found")?;
-        let unwrapped = UnwrappedGift::from_gift_wrap(user_signer, gift_wrap).await?;
+    Ok(unwrapped)
+}
 
-        Ok(unwrapped)
-    }
+/// Attempts to unwrap a gift wrap event with a given signer.
+async fn try_unwrap_with<T>(gift_wrap: &Event, signer: &T) -> Result<UnwrappedGift, Error>
+where
+    T: NostrSigner + 'static,
+{
+    // Get the sealed event
+    let seal = signer
+        .nip44_decrypt(&gift_wrap.pubkey, &gift_wrap.content)
+        .await?;
 
-    /// Attempts to unwrap a gift wrap event with a given signer.
-    async fn try_unwrap_with(
-        gift_wrap: &Event,
-        signer: &Arc<dyn NostrSigner>,
-    ) -> Result<UnwrappedGift, Error> {
-        // Get the sealed event
-        let seal = signer
-            .nip44_decrypt(&gift_wrap.pubkey, &gift_wrap.content)
-            .await?;
+    // Verify the sealed event
+    let seal: Event = Event::from_json(seal)?;
+    seal.verify_with_ctx(&SECP256K1)?;
 
-        // Verify the sealed event
-        let seal: Event = Event::from_json(seal)?;
-        seal.verify_with_ctx(&SECP256K1)?;
+    // Get the rumor event
+    let rumor = signer.nip44_decrypt(&seal.pubkey, &seal.content).await?;
+    let rumor = UnsignedEvent::from_json(rumor)?;
 
-        // Get the rumor event
-        let rumor = signer.nip44_decrypt(&seal.pubkey, &seal.content).await?;
-        let rumor = UnsignedEvent::from_json(rumor)?;
+    Ok(UnwrappedGift {
+        sender: seal.pubkey,
+        rumor,
+    })
+}
 
-        Ok(UnwrappedGift {
-            sender: seal.pubkey,
-            rumor,
-        })
-    }
+/// Stores an unwrapped event in local database with reference to original
+async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Result<(), Error> {
+    let rumor_id = rumor.id.context("Rumor is missing an event id")?;
+    let author = rumor.pubkey;
+    let conversation = conversation_id(rumor);
 
-    /// Stores an unwrapped event in local database with reference to original
-    async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Result<(), Error> {
-        let rumor_id = rumor.id.context("Rumor is missing an event id")?;
-        let author = rumor.pubkey;
-        let conversation = Self::conversation_id(rumor);
+    let mut tags = rumor.tags.clone().to_vec();
 
-        let mut tags = rumor.tags.clone().to_vec();
+    // Add a unique identifier
+    tags.push(Tag::identifier(id));
 
-        // Add a unique identifier
-        tags.push(Tag::identifier(id));
+    // Add a reference to the rumor's author
+    tags.push(Tag::custom(
+        TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::A)),
+        [author],
+    ));
 
-        // Add a reference to the rumor's author
+    // Add a conversation id
+    tags.push(Tag::custom(
+        TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::C)),
+        [conversation.to_string()],
+    ));
+
+    // Add a reference to the rumor's id
+    tags.push(Tag::event(rumor_id));
+
+    // Add references to the rumor's participants
+    for receiver in rumor.tags.public_keys().copied() {
         tags.push(Tag::custom(
-            TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::A)),
-            [author],
+            TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::P)),
+            [receiver],
         ));
-
-        // Add a conversation id
-        tags.push(Tag::custom(
-            TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::C)),
-            [conversation.to_string()],
-        ));
-
-        // Add a reference to the rumor's id
-        tags.push(Tag::event(rumor_id));
-
-        // Add references to the rumor's participants
-        for receiver in rumor.tags.public_keys().copied() {
-            tags.push(Tag::custom(
-                TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::P)),
-                [receiver],
-            ));
-        }
-
-        // Convert rumor to json
-        let content = rumor.as_json();
-
-        // Construct the event
-        let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
-            .tags(tags)
-            .sign(&Keys::generate())
-            .await?;
-
-        // Save the event to the database
-        client.database().save_event(&event).await?;
-
-        Ok(())
     }
 
-    /// Retrieves a previously unwrapped event from local database
-    async fn get_rumor(client: &Client, gift_wrap: EventId) -> Result<UnsignedEvent, Error> {
-        let filter = Filter::new()
-            .kind(Kind::ApplicationSpecificData)
-            .identifier(gift_wrap)
-            .limit(1);
+    // Convert rumor to json
+    let content = rumor.as_json();
 
-        if let Some(event) = client.database().query(filter).await?.first_owned() {
-            UnsignedEvent::from_json(event.content).map_err(|e| anyhow!(e))
-        } else {
-            Err(anyhow!("Event is not cached yet."))
-        }
-    }
+    // Construct the event
+    let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
+        .tags(tags)
+        .sign(&Keys::generate())
+        .await?;
 
-    /// Get the conversation ID for a given rumor (message).
-    fn conversation_id(rumor: &UnsignedEvent) -> u64 {
-        let mut hasher = DefaultHasher::new();
-        let mut pubkeys: Vec<PublicKey> = rumor.tags.public_keys().copied().collect();
-        pubkeys.push(rumor.pubkey);
-        pubkeys.sort();
-        pubkeys.dedup();
-        pubkeys.hash(&mut hasher);
+    // Save the event to the database
+    client.database().save_event(&event).await?;
 
-        hasher.finish()
+    Ok(())
+}
+
+/// Retrieves a previously unwrapped event from local database
+async fn get_rumor(client: &Client, gift_wrap: EventId) -> Result<UnsignedEvent, Error> {
+    let filter = Filter::new()
+        .kind(Kind::ApplicationSpecificData)
+        .identifier(gift_wrap)
+        .limit(1);
+
+    if let Some(event) = client.database().query(filter).await?.first_owned() {
+        UnsignedEvent::from_json(event.content).map_err(|e| anyhow!(e))
+    } else {
+        Err(anyhow!("Event is not cached yet."))
     }
 }
+
+/// Get the conversation ID for a given rumor (message).
+fn conversation_id(rumor: &UnsignedEvent) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    let mut pubkeys: Vec<PublicKey> = rumor.tags.public_keys().copied().collect();
+    pubkeys.push(rumor.pubkey);
+    pubkeys.sort();
+    pubkeys.dedup();
+    pubkeys.hash(&mut hasher);
+
+    hasher.finish()
+}

crates/chat/src/message.rs

@@ -1,6 +1,8 @@
 use std::hash::Hash;
+use std::ops::Range;
 
-use common::EventUtils;
+use common::{EventExt, NostrParser, extract_and_remove_media_urls};
+use gpui::{SharedString, SharedUri};
 use nostr_sdk::prelude::*;
 
 /// New message.
@@ -23,6 +25,25 @@ impl NewMessage {
     }
 }
 
+/// Trash message.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct FailedMessage {
+    pub raw_event: SharedString,
+    pub reason: SharedString,
+}
+
+impl FailedMessage {
+    pub fn new<T>(event: &Event, reason: T) -> Self
+    where
+        T: Into<SharedString>,
+    {
+        Self {
+            raw_event: SharedString::from(event.as_json()),
+            reason: reason.into(),
+        }
+    }
+}
+
 /// Message.
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum Message {
@@ -91,6 +112,18 @@ impl PartialOrd for Message {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct Mention {
+    pub public_key: PublicKey,
+    pub range: Range<usize>,
+}
+
+impl Mention {
+    pub fn new(public_key: PublicKey, range: Range<usize>) -> Self {
+        Self { public_key, range }
+    }
+}
+
 /// Rendered message.
 #[derive(Debug, Clone)]
 pub struct RenderedMessage {
@@ -99,10 +132,12 @@ pub struct RenderedMessage {
     pub author: PublicKey,
     /// The content/text of the message
     pub content: String,
+    /// List of media URLs in the message
+    pub media: Vec<SharedUri>,
     /// Message created time as unix timestamp
     pub created_at: Timestamp,
     /// List of mentioned public keys in the message
-    pub mentions: Vec<PublicKey>,
+    pub mentions: Vec<Mention>,
     /// List of event of the message this message is a reply to
     pub replies_to: Vec<EventId>,
 }
@@ -111,11 +146,13 @@ impl From<&Event> for RenderedMessage {
     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: val.content.clone(),
+            content: string,
+            media,
             created_at: val.created_at,
             mentions,
             replies_to,
@@ -127,12 +164,14 @@ impl From<&UnsignedEvent> for RenderedMessage {
     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 {
             // Event ID must be known
             id: val.id.unwrap(),
             author: val.pubkey,
-            content: val.content.clone(),
+            content: string,
+            media,
             created_at: val.created_at,
             mentions,
             replies_to,
@@ -144,12 +183,14 @@ impl From<&NewMessage> for RenderedMessage {
     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 {
             // Event ID must be known
             id: val.rumor.id.unwrap(),
             author: val.rumor.pubkey,
-            content: val.rumor.content.clone(),
+            content: string,
+            media,
             created_at: val.rumor.created_at,
             mentions,
             replies_to,
@@ -184,20 +225,17 @@ impl Hash for RenderedMessage {
 }
 
 /// Extracts all mentions (public keys) from a content string.
-fn extract_mentions(content: &str) -> Vec<PublicKey> {
+fn extract_mentions(content: &str) -> Vec<Mention> {
     let parser = NostrParser::new();
     let tokens = parser.parse(content);
 
     tokens
-        .filter_map(|token| match token {
-            Token::Nostr(nip21) => match nip21 {
-                Nip21::Pubkey(pubkey) => Some(pubkey),
-                Nip21::Profile(profile) => Some(profile.public_key),
-                _ => None,
-            },
+        .filter_map(|token| match token.value {
+            Nip21::Pubkey(public_key) => Some(Mention::new(public_key, token.range)),
+            Nip21::Profile(profile) => Some(Mention::new(profile.public_key, token.range)),
             _ => None,
         })
-        .collect::<Vec<_>>()
+        .collect()
 }
 
 /// Extracts all reply (ids) from the event tags.

crates/chat/src/room.rs

@@ -2,8 +2,8 @@ use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 use std::time::Duration;
 
-use anyhow::{Context as AnyhowContext, Error};
-use common::EventUtils;
+use anyhow::{Error, anyhow};
+use common::EventExt;
 use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
@@ -11,7 +11,10 @@ use person::{Person, PersonRegistry};
 use settings::{RoomConfig, SignerKind};
 use state::{NostrRegistry, TIMEOUT};
 
-use crate::{ChatRegistry, NewMessage};
+use crate::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.";
 
 #[derive(Debug, Clone)]
 pub struct SendReport {
@@ -54,16 +57,44 @@ impl SendReport {
 
     /// Returns true if the send is pending.
     pub fn pending(&self) -> bool {
-        self.output.is_none() && self.error.is_none()
+        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.
     pub fn success(&self) -> bool {
-        if let Some(output) = self.output.as_ref() {
-            !output.failed.is_empty()
-        } else {
-            false
-        }
+        self.error.is_none() && self.output.as_ref().is_some_and(|o| !o.success.is_empty())
+    }
+
+    /// Returns true if the send failed.
+    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 }
     }
 }
 
@@ -149,7 +180,7 @@ impl From<&UnsignedEvent> for Room {
             subject,
             members,
             kind: RoomKind::default(),
-            config: RoomConfig::default(),
+            config: RoomConfig::new(),
         }
     }
 }
@@ -201,10 +232,8 @@ impl Room {
 
     /// Sets this room is ongoing conversation
     pub fn set_ongoing(&mut self, cx: &mut Context<Self>) {
-        if self.kind != RoomKind::Ongoing {
-            self.kind = RoomKind::Ongoing;
-            cx.notify();
-        }
+        self.kind = RoomKind::Ongoing;
+        cx.notify();
     }
 
     /// Updates the creation timestamp of the room
@@ -222,6 +251,23 @@ impl Room {
         cx.notify();
     }
 
+    /// Updates the signer kind config for the room
+    pub fn set_signer_kind(&mut self, kind: &SignerKind, cx: &mut Context<Self>) {
+        self.config.set_signer_kind(kind);
+        cx.notify();
+    }
+
+    /// Updates the backup config for the room
+    pub fn set_backup(&mut self, cx: &mut Context<Self>) {
+        self.config.toggle_backup();
+        cx.notify();
+    }
+
+    /// Returns the config of the room
+    pub fn config(&self) -> &RoomConfig {
+        &self.config
+    }
+
     /// Returns the members of the room
     pub fn members(&self) -> Vec<PublicKey> {
         self.members.clone()
@@ -296,10 +342,6 @@ impl Room {
 
         if new_message {
             self.set_created_at(created_at, cx);
-            // Sort chats after emitting a new message
-            ChatRegistry::global(cx).update(cx, |this, cx| {
-                this.sort(cx);
-            });
         }
     }
 
@@ -309,43 +351,31 @@ impl Room {
     }
 
     /// Get gossip relays for each member
-    pub fn early_connect(&self, cx: &App) -> Task<Result<(), Error>> {
+    pub fn connect(&self, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-
         let members = self.members();
-        let subscription_id = SubscriptionId::new(format!("room-{}", self.id));
 
         cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
-            let public_key = signer.get_public_key().await?;
+            let opts = SubscribeAutoCloseOptions::default()
+                .exit_policy(ReqExitPolicy::ExitOnEOSE)
+                .timeout(Some(Duration::from_secs(TIMEOUT)));
 
-            for member in members.into_iter() {
-                if member == public_key {
-                    continue;
-                };
-
-                // Construct a filter for messaging relays
+            for public_key in members.into_iter() {
                 let inbox = Filter::new()
+                    .author(public_key)
                     .kind(Kind::InboxRelays)
-                    .author(member)
                     .limit(1);
 
-                // Construct a filter for announcement
                 let announcement = Filter::new()
+                    .author(public_key)
                     .kind(Kind::Custom(10044))
-                    .author(member)
                     .limit(1);
 
-                // Subscribe to get member's gossip relays
+                // Subscribe to the target
                 client
                     .subscribe(vec![inbox, announcement])
-                    .with_id(subscription_id.clone())
-                    .close_on(
-                        SubscribeAutoCloseOptions::default()
-                            .timeout(Some(Duration::from_secs(TIMEOUT)))
-                            .exit_policy(ReqExitPolicy::ExitOnEOSE),
-                    )
+                    .close_on(opts)
                     .await?;
             }
 
@@ -370,6 +400,10 @@ impl Room {
                 .await?
                 .into_iter()
                 .filter_map(|event| UnsignedEvent::from_json(&event.content).ok())
+                .filter(|event| {
+                    // Only process private direct messages and file messages
+                    event.kind == Kind::PrivateDirectMessage || event.kind == Kind::Custom(15)
+                })
                 .sorted_by_key(|message| message.created_at)
                 .collect();
 
@@ -393,7 +427,7 @@ impl Room {
         // Get current user's public key
         let sender = nostr.read(cx).signer().public_key()?;
 
-        // Get all members
+        // Get all members, excluding the sender
         let members: Vec<Person> = self
             .members
             .iter()
@@ -418,11 +452,6 @@ impl Room {
 
         // Add all receiver tags
         for member in members.into_iter() {
-            // Skip current user
-            if member.public_key() == sender {
-                continue;
-            }
-
             tags.push(Tag::from_standardized_without_cell(
                 TagStandard::PublicKey {
                     public_key: member.public_key(),
@@ -445,116 +474,114 @@ impl Room {
 
     /// Send rumor event to all members's messaging relays
     pub fn send(&self, rumor: UnsignedEvent, cx: &App) -> Option<Task<Vec<SendReport>>> {
+        let config = self.config.clone();
         let persons = PersonRegistry::global(cx);
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        // Get room's config
-        let config = self.config.clone();
-
         // Get current user's public key
-        let sender = nostr.read(cx).signer().public_key()?;
+        let public_key = nostr.read(cx).signer().public_key()?;
+        let sender = persons.read(cx).get(&public_key, cx);
 
         // Get all members (excluding sender)
         let members: Vec<Person> = self
             .members
             .iter()
-            .filter(|public_key| public_key != &&sender)
+            .filter(|public_key| public_key != &&sender.public_key())
             .map(|member| persons.read(cx).get(member, cx))
             .collect();
 
         Some(cx.background_spawn(async move {
             let signer_kind = config.signer_kind();
+            let backup = config.backup();
+
             let user_signer = signer.get().await;
             let encryption_signer = signer.get_encryption_signer().await;
 
+            let mut sents = 0;
             let mut reports = Vec::new();
 
+            // Process each member
             for member in members {
-                let relays = member.messaging_relays();
                 let announcement = member.announcement();
+                let public_key = member.public_key();
 
-                // Skip if member has no messaging relays
-                if relays.is_empty() {
-                    reports.push(SendReport::new(member.public_key()).error("No messaging relays"));
-                    continue;
+                // 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;
+                    }
                 }
 
-                // Ensure relay connections
-                for url in relays.iter() {
-                    client
-                        .add_relay(url)
-                        .and_connect()
-                        .capabilities(RelayCapabilities::GOSSIP)
-                        .await
-                        .ok();
-                }
-
-                // When forced to use encryption signer, skip if receiver has no announcement
-                if signer_kind.encryption() && announcement.is_none() {
-                    reports
-                        .push(SendReport::new(member.public_key()).error("Encryption not found"));
-                    continue;
-                }
-
-                // Determine receiver and signer based on signer kind
-                let (receiver, signer_to_use) = match signer_kind {
+                // Determine the signer to use
+                let signer = match signer_kind {
                     SignerKind::Auto => {
-                        if let Some(announcement) = announcement {
-                            if let Some(enc_signer) = encryption_signer.as_ref() {
-                                (announcement.public_key(), enc_signer.clone())
-                            } else {
-                                (member.public_key(), user_signer.clone())
-                            }
+                        if announcement.is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
+                        {
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
                         } else {
-                            (member.public_key(), user_signer.clone())
+                            user_signer.clone()
                         }
                     }
                     SignerKind::Encryption => {
-                        let Some(encryption_signer) = encryption_signer.as_ref() else {
-                            reports.push(
-                                SendReport::new(member.public_key()).error("Encryption not found"),
-                            );
-                            continue;
-                        };
-                        let Some(announcement) = announcement else {
-                            reports.push(
-                                SendReport::new(member.public_key())
-                                    .error("Announcement not found"),
-                            );
-                            continue;
-                        };
-                        (announcement.public_key(), encryption_signer.clone())
+                        // Safe to unwrap due to earlier checks
+                        encryption_signer.as_ref().unwrap().clone()
                     }
-                    SignerKind::User => (member.public_key(), user_signer.clone()),
+                    SignerKind::User => user_signer.clone(),
                 };
 
-                // Create and send gift-wrapped event
-                match EventBuilder::gift_wrap(&signer_to_use, &receiver, rumor.clone(), []).await {
-                    Ok(event) => {
-                        match client
-                            .send_event(&event)
-                            .to(relays)
-                            .ack_policy(AckPolicy::none())
-                            .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 = match signer_kind {
+                    SignerKind::Auto => {
+                        if sender.announcement().is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
                         {
-                            Ok(output) => {
-                                reports.push(
-                                    SendReport::new(member.public_key())
-                                        .gift_wrap_id(event.id)
-                                        .output(output),
-                                );
-                            }
-                            Err(e) => {
-                                reports.push(
-                                    SendReport::new(member.public_key()).error(e.to_string()),
-                                );
-                            }
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
+                        } else {
+                            user_signer.clone()
                         }
                     }
-                    Err(e) => {
-                        reports.push(SendReport::new(member.public_key()).error(e.to_string()));
+                    SignerKind::Encryption => {
+                        // Safe to unwrap due to earlier checks
+                        encryption_signer.as_ref().unwrap().clone()
+                    }
+                    SignerKind::User => user_signer.clone(),
+                };
+
+                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);
                     }
                 }
             }
@@ -562,222 +589,57 @@ impl Room {
             reports
         }))
     }
-
-    /*
-    * /// Create a new unsigned message event
-    pub fn create_message(
-        &self,
-        content: &str,
-        replies: Vec<EventId>,
-        cx: &App,
-    ) -> Task<Result<UnsignedEvent, Error>> {
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        let subject = self.subject.clone();
-        let content = content.to_string();
-
-        let mut member_and_relay_hints = HashMap::new();
-
-        // Populate the hashmap with member and relay hint tasks
-        for member in self.members.iter() {
-            let hint = nostr.read(cx).relay_hint(member, cx);
-            member_and_relay_hints.insert(member.to_owned(), hint);
-        }
-
-        cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
-            let public_key = signer.get_public_key().await?;
-
-            // List of event tags for each receiver
-            let mut tags = vec![];
-
-            for (member, task) in member_and_relay_hints.into_iter() {
-                // Skip current user
-                if member == public_key {
-                    continue;
-                }
-
-                // Get relay hint if available
-                let relay_url = task.await;
-
-                // Construct a public key tag with relay hint
-                let tag = TagStandard::PublicKey {
-                    public_key: member,
-                    relay_url,
-                    alias: None,
-                    uppercase: false,
-                };
-
-                tags.push(Tag::from_standardized_without_cell(tag));
-            }
-
-            // Add subject tag if present
-            if let Some(value) = subject {
-                tags.push(Tag::from_standardized_without_cell(TagStandard::Subject(
-                    value.to_string(),
-                )));
-            }
-
-            // Add all reply tags
-            for id in replies {
-                tags.push(Tag::event(id))
-            }
-
-            // Construct a direct message event
-            //
-            // WARNING: never sign and send this event to relays
-            let mut event = EventBuilder::new(Kind::PrivateDirectMessage, content)
-                .tags(tags)
-                .build(public_key);
-
-            // Ensure the event ID has been generated
-            event.ensure_id();
-
-            Ok(event)
-        })
-    }
-
-    /// Create a task to send a message to all room members
-    pub fn send_message(
-        &self,
-        rumor: &UnsignedEvent,
-        cx: &App,
-    ) -> Task<Result<Vec<SendReport>, Error>> {
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        let mut members = self.members();
-        let rumor = rumor.to_owned();
-
-        cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
-            let current_user = signer.get_public_key().await?;
-
-            // Remove the current user's public key from the list of receivers
-            // the current user will be handled separately
-            members.retain(|this| this != &current_user);
-
-            // Collect the send reports
-            let mut reports: Vec<SendReport> = vec![];
-
-            for receiver in members.into_iter() {
-                // Construct the gift wrap event
-                let event =
-                    EventBuilder::gift_wrap(signer, &receiver, rumor.clone(), vec![]).await?;
-
-                // Send the gift wrap event to the messaging relays
-                match client.send_event(&event).to_nip17().await {
-                    Ok(output) => {
-                        let id = output.id().to_owned();
-                        let auth = output.failed.iter().any(|(_, s)| s.starts_with("auth-"));
-                        let report = SendReport::new(receiver).status(output);
-                        let tracker = tracker().read().await;
-
-                        if auth {
-                            // Wait for authenticated and resent event successfully
-                            for attempt in 0..=SEND_RETRY {
-                                // Check if event was successfully resent
-                                if tracker.is_sent_by_coop(&id) {
-                                    let output = Output::new(id);
-                                    let report = SendReport::new(receiver).status(output);
-                                    reports.push(report);
-                                    break;
-                                }
-
-                                // Check if retry limit exceeded
-                                if attempt == SEND_RETRY {
-                                    reports.push(report);
-                                    break;
-                                }
-
-                                smol::Timer::after(Duration::from_millis(1200)).await;
-                            }
-                        } else {
-                            reports.push(report);
-                        }
-                    }
-                    Err(e) => {
-                        reports.push(SendReport::new(receiver).error(e.to_string()));
-                    }
-                }
-            }
-
-            // Construct the gift-wrapped event
-            let event =
-                EventBuilder::gift_wrap(signer, &current_user, rumor.clone(), vec![]).await?;
-
-            // Only send a backup message to current user if sent successfully to others
-            if reports.iter().all(|r| r.is_sent_success()) {
-                // Send the event to the messaging relays
-                match client.send_event(&event).to_nip17().await {
-                    Ok(output) => {
-                        reports.push(SendReport::new(current_user).status(output));
-                    }
-                    Err(e) => {
-                        reports.push(SendReport::new(current_user).error(e.to_string()));
-                    }
-                }
-            } else {
-                reports.push(SendReport::new(current_user).on_hold(event));
-            }
-
-            Ok(reports)
-        })
-    }
-
-    /// Create a task to resend a failed message
-    pub fn resend_message(
-        &self,
-        reports: Vec<SendReport>,
-        cx: &App,
-    ) -> Task<Result<Vec<SendReport>, Error>> {
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        cx.background_spawn(async move {
-            let mut resend_reports = vec![];
-
-            for report in reports.into_iter() {
-                let receiver = report.receiver;
-
-                // Process failed events
-                if let Some(output) = report.status {
-                    let id = output.id();
-                    let urls: Vec<&RelayUrl> = output.failed.keys().collect();
-
-                    if let Some(event) = client.database().event_by_id(id).await? {
-                        for url in urls.into_iter() {
-                            let relay = client.relay(url).await?.context("Relay not found")?;
-                            let id = relay.send_event(&event).await?;
-
-                            let resent: Output<EventId> = Output {
-                                val: id,
-                                success: HashSet::from([url.to_owned()]),
-                                failed: HashMap::new(),
-                            };
-
-                            resend_reports.push(SendReport::new(receiver).status(resent));
-                        }
-                    }
-                }
-
-                // Process the on hold event if it exists
-                if let Some(event) = report.on_hold {
-                    // Send the event to the messaging relays
-                    match client.send_event(&event).await {
-                        Ok(output) => {
-                            resend_reports.push(SendReport::new(receiver).status(output));
-                        }
-                        Err(e) => {
-                            resend_reports.push(SendReport::new(receiver).error(e.to_string()));
-                        }
-                    }
-                }
-            }
-
-            Ok(resend_reports)
-        })
-    }
-    */
+}
+
+// Helper function to send a gift-wrapped event
+async fn send_gift_wrap<T>(
+    client: &Client,
+    signer: &T,
+    receiver: &Person,
+    rumor: &UnsignedEvent,
+    config: &SignerKind,
+) -> Result<SendReport, Error>
+where
+    T: NostrSigner + 'static,
+{
+    let k_tag = Tag::custom(TagKind::k(), vec!["14"]);
+    let mut extra_tags = vec![k_tag];
+
+    // Determine the receiver public key based on the config
+    let receiver = match config {
+        SignerKind::Auto => {
+            if let Some(announcement) = receiver.announcement().as_ref() {
+                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() {
+                extra_tags.push(Tag::public_key(receiver.public_key()));
+                announcement.public_key()
+            } else {
+                return Err(anyhow!("User has no encryption announcement"));
+            }
+        }
+        SignerKind::User => receiver.public_key(),
+    };
+
+    // Construct the gift wrap event
+    let event = EventBuilder::gift_wrap(signer, &receiver, rumor.clone(), extra_tags).await?;
+
+    // Send the gift wrap event and collect the report
+    let report = client
+        .send_event(&event)
+        .to_nip17()
+        .ack_policy(AckPolicy::none())
+        .await
+        .map(|output| {
+            SendReport::new(receiver)
+                .gift_wrap_id(event.id)
+                .output(output)
+        })?;
+
+    Ok(report)
 }

crates/chat_ui/Cargo.toml

@@ -7,7 +7,6 @@ publish.workspace = true
 [dependencies]
 state = { path = "../state" }
 ui = { path = "../ui" }
-dock = { path = "../dock" }
 theme = { path = "../theme" }
 common = { path = "../common" }
 person = { path = "../person" }
@@ -29,3 +28,5 @@ serde_json.workspace = true
 
 once_cell = "1.19.0"
 regex = "1"
+linkify = "0.10.0"
+pulldown-cmark = "0.13.1"

crates/chat_ui/src/actions.rs

@@ -1,24 +1,17 @@
 use gpui::Action;
 use nostr_sdk::prelude::*;
 use serde::Deserialize;
+use settings::SignerKind;
 
 #[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 #[action(namespace = chat, no_json)]
 pub enum Command {
     Insert(&'static str),
-    ChangeSubject(&'static str),
+    ChangeSubject(String),
+    ChangeSigner(SignerKind),
+    ToggleBackup,
+    Copy(PublicKey),
+    Relays(PublicKey),
+    Njump(PublicKey),
+    Trace(EventId),
 }
-
-#[derive(Action, Clone, PartialEq, Eq, Deserialize)]
-#[action(namespace = chat, no_json)]
-pub struct SeenOn(pub EventId);
-
-/// Define a open public key action
-#[derive(Action, Clone, PartialEq, Eq, Deserialize, Debug)]
-#[action(namespace = pubkey, no_json)]
-pub struct OpenPublicKey(pub PublicKey);
-
-/// Define a copy inline public key action
-#[derive(Action, Clone, PartialEq, Eq, Deserialize, Debug)]
-#[action(namespace = pubkey, no_json)]
-pub struct CopyPublicKey(pub PublicKey);

crates/chat_ui/src/subject.rs

@@ -1,60 +0,0 @@
-use gpui::{
-    div, App, AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString,
-    Styled, Window,
-};
-use theme::ActiveTheme;
-use ui::input::{InputState, TextInput};
-use ui::{v_flex, Sizable};
-
-pub fn init(subject: Option<String>, window: &mut Window, cx: &mut App) -> Entity<Subject> {
-    cx.new(|cx| Subject::new(subject, window, cx))
-}
-
-pub struct Subject {
-    input: Entity<InputState>,
-}
-
-impl Subject {
-    pub fn new(subject: Option<String>, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let input = cx.new(|cx| InputState::new(window, cx).placeholder("Plan for holiday"));
-
-        if let Some(value) = subject {
-            input.update(cx, |this, cx| {
-                this.set_value(value, window, cx);
-            });
-        };
-
-        Self { input }
-    }
-
-    pub fn new_subject(&self, cx: &App) -> SharedString {
-        self.input.read(cx).value()
-    }
-}
-
-impl Render for Subject {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex()
-            .gap_2()
-            .child(
-                v_flex()
-                    .gap_1()
-                    .child(
-                        div()
-                            .text_sm()
-                            .text_color(cx.theme().text_muted)
-                            .child(SharedString::from("Subject:")),
-                    )
-                    .child(TextInput::new(&self.input).small()),
-            )
-            .child(
-                div()
-                    .text_xs()
-                    .italic()
-                    .text_color(cx.theme().text_placeholder)
-                    .child(SharedString::from(
-                        "Subject will be updated when you send a new message.",
-                    )),
-            )
-    }
-}

crates/chat_ui/src/text.rs

@@ -1,29 +1,29 @@
 use std::ops::Range;
 use std::sync::Arc;
 
+use chat::Mention;
+use common::RangeExt;
 use gpui::{
-    AnyElement, App, ElementId, HighlightStyle, InteractiveText, IntoElement, SharedString,
-    StyledText, UnderlineStyle, Window,
+    AnyElement, App, ElementId, Entity, FontStyle, FontWeight, HighlightStyle, InteractiveText,
+    IntoElement, SharedString, StrikethroughStyle, StyledText, UnderlineStyle, Window,
 };
-use nostr_sdk::prelude::*;
-use once_cell::sync::Lazy;
 use person::PersonRegistry;
-use regex::Regex;
 use theme::ActiveTheme;
 
-use crate::actions::OpenPublicKey;
-
-static URL_REGEX: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(?i)(?:^|\s)(?:https?://)?(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}(?::\d+)?(?:/[^\s]*)?(?:\s|$)").unwrap()
-});
-
-static NOSTR_URI_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"nostr:(npub|note|nprofile|nevent|naddr)[a-zA-Z0-9]+").unwrap());
-
+#[allow(clippy::enum_variant_names)]
+#[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Highlight {
-    Link,
-    Nostr,
+    Code,
+    InlineCode(bool),
+    Highlight(HighlightStyle),
+    Mention,
+}
+
+impl From<HighlightStyle> for Highlight {
+    fn from(style: HighlightStyle) -> Self {
+        Self::Highlight(style)
+    }
 }
 
 #[derive(Default)]
@@ -35,7 +35,12 @@ pub struct RenderedText {
 }
 
 impl RenderedText {
-    pub fn new(content: &str, cx: &App) -> Self {
+    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();
@@ -43,10 +48,12 @@ impl RenderedText {
 
         render_plain_text_mut(
             content,
+            mentions,
             &mut text,
             &mut highlights,
             &mut link_ranges,
             &mut link_urls,
+            persons,
             cx,
         );
 
@@ -61,7 +68,8 @@ impl RenderedText {
     }
 
     pub fn element(&self, id: ElementId, window: &Window, cx: &App) -> AnyElement {
-        let link_color = cx.theme().text_accent;
+        let code_background = cx.theme().elevated_surface_background;
+        let color = cx.theme().text_accent;
 
         InteractiveText::new(
             id,
@@ -71,15 +79,36 @@ impl RenderedText {
                     (
                         range.clone(),
                         match highlight {
-                            Highlight::Link => HighlightStyle {
-                                color: Some(link_color),
-                                underline: Some(UnderlineStyle::default()),
+                            Highlight::Code => HighlightStyle {
+                                background_color: Some(code_background),
                                 ..Default::default()
                             },
-                            Highlight::Nostr => HighlightStyle {
-                                color: Some(link_color),
+                            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,
                         },
                     )
                 }),
@@ -87,22 +116,10 @@ impl RenderedText {
         )
         .on_click(self.link_ranges.clone(), {
             let link_urls = self.link_urls.clone();
-            move |ix, window, cx| {
-                let token = link_urls[ix].as_str();
-
-                if let Some(clean_url) = token.strip_prefix("nostr:") {
-                    if let Ok(public_key) = PublicKey::parse(clean_url) {
-                        window.dispatch_action(Box::new(OpenPublicKey(public_key)), cx);
-                    }
-                } else if is_url(token) {
-                    let url = if token.starts_with("http") {
-                        token.to_string()
-                    } else {
-                        format!("https://{token}")
-                    };
-                    cx.open_url(&url);
-                } else {
-                    log::warn!("Unrecognized token {token}")
+            move |ix, _, cx| {
+                let url = &link_urls[ix];
+                if url.starts_with("http") {
+                    cx.open_url(url);
                 }
             }
         })
@@ -110,214 +127,273 @@ impl RenderedText {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn render_plain_text_mut(
-    content: &str,
+    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>,
     cx: &App,
 ) {
-    // Copy the content directly
-    text.push_str(content);
+    use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
 
-    // Collect all URLs
-    let mut url_matches: Vec<(Range<usize>, String)> = Vec::new();
+    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();
 
-    for link in URL_REGEX.find_iter(content) {
-        let range = link.start()..link.end();
-        let url = link.as_str().to_string();
+    let mut options = Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
 
-        url_matches.push((range, url));
-    }
+    for (event, source_range) in Parser::new_ext(block, options).into_offset_iter() {
+        let prev_len = text.len();
 
-    // Collect all nostr entities with nostr: prefix
-    let mut nostr_matches: Vec<(Range<usize>, String)> = Vec::new();
+        match event {
+            Event::Text(t) => {
+                // Process text with mention replacements
+                let t_str = t.as_ref();
+                let mut last_processed = 0;
 
-    for nostr_match in NOSTR_URI_REGEX.find_iter(content) {
-        let range = nostr_match.start()..nostr_match.end();
-        let nostr_uri = nostr_match.as_str().to_string();
+                while let Some(mention) = mentions.first() {
+                    if !source_range.contains_inclusive(&mention.range) {
+                        break;
+                    }
 
-        // Check if this nostr URI overlaps with any already processed URL
-        if !url_matches
-            .iter()
-            .any(|(url_range, _)| url_range.start < range.end && range.start < url_range.end)
-        {
-            nostr_matches.push((range, nostr_uri));
-        }
-    }
+                    // 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;
 
-    // Combine all matches for processing from end to start
-    let mut all_matches = Vec::new();
-    all_matches.extend(url_matches);
-    all_matches.extend(nostr_matches);
+                    // 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,
+                        );
+                    }
 
-    // Sort by position (end to start) to avoid changing positions when replacing text
-    all_matches.sort_by(|(range_a, _), (range_b, _)| range_b.start.cmp(&range_a.start));
+                    // Process the mention replacement
+                    let profile = persons.read(cx).get(&mention.public_key, cx);
+                    let replacement_text = format!("@{}", profile.name());
 
-    // Process all matches
-    for (range, entity) in all_matches {
-        // Handle URL token
-        if is_url(&entity) {
-            highlights.push((range.clone(), Highlight::Link));
-            link_ranges.push(range);
-            link_urls.push(entity);
-            continue;
-        };
+                    let replacement_start = text.len();
+                    text.push_str(&replacement_text);
+                    let replacement_end = text.len();
 
-        if let Ok(nip21) = Nip21::parse(&entity) {
-            match nip21 {
-                Nip21::Pubkey(public_key) => {
-                    render_pubkey(
-                        public_key,
-                        text,
-                        &range,
-                        highlights,
-                        link_ranges,
-                        link_urls,
-                        cx,
-                    );
+                    highlights.push((replacement_start..replacement_end, Highlight::Mention));
+
+                    last_processed = mention_end_in_text;
+                    mentions = &mentions[1..];
                 }
-                Nip21::Profile(nip19_profile) => {
-                    render_pubkey(
-                        nip19_profile.public_key,
+
+                // 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,
-                        &range,
-                        highlights,
-                        link_ranges,
-                        link_urls,
-                        cx,
-                    );
-                }
-                Nip21::EventId(event_id) => {
-                    render_bech32(
-                        event_id.to_bech32().unwrap(),
-                        text,
-                        &range,
-                        highlights,
-                        link_ranges,
-                        link_urls,
-                    );
-                }
-                Nip21::Event(nip19_event) => {
-                    render_bech32(
-                        nip19_event.to_bech32().unwrap(),
-                        text,
-                        &range,
-                        highlights,
-                        link_ranges,
-                        link_urls,
-                    );
-                }
-                Nip21::Coordinate(nip19_coordinate) => {
-                    render_bech32(
-                        nip19_coordinate.to_bech32().unwrap(),
-                        text,
-                        &range,
                         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'),
+            _ => {}
         }
     }
 }
 
-/// Check if a string is a URL
-fn is_url(s: &str) -> bool {
-    URL_REGEX.is_match(s)
-}
+#[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()
+        });
+    }
 
-/// Format a bech32 entity with ellipsis and last 4 characters
-fn format_shortened_entity(entity: &str) -> String {
-    let prefix_end = entity.find('1').unwrap_or(0);
+    // Add the text
+    text.push_str(segment);
+    let text_end = text.len();
 
-    if prefix_end > 0 && entity.len() > prefix_end + 5 {
-        let prefix = &entity[0..=prefix_end]; // Include the '1'
-        let suffix = &entity[entity.len() - 4..]; // Last 4 chars
+    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()
+        });
 
-        format!("{prefix}...{suffix}")
+        // Add highlight for the entire linked segment
+        if style != HighlightStyle::default() {
+            highlights.push((segment_start..text_end, Highlight::Highlight(style)));
+        }
     } else {
-        entity.to_string()
-    }
-}
+        // Handle link detection within the segment
+        let mut finder = linkify::LinkFinder::new();
+        finder.kinds(&[linkify::LinkKind::Url]);
+        let mut last_link_pos = 0;
 
-fn render_pubkey(
-    public_key: PublicKey,
-    text: &mut String,
-    range: &Range<usize>,
-    highlights: &mut Vec<(Range<usize>, Highlight)>,
-    link_ranges: &mut Vec<Range<usize>>,
-    link_urls: &mut Vec<String>,
-    cx: &App,
-) {
-    let persons = PersonRegistry::global(cx);
-    let profile = persons.read(cx).get(&public_key, cx);
-    let display_name = format!("@{}", profile.name());
+        for link in finder.links(segment) {
+            let start = link.start();
+            let end = link.end();
 
-    text.replace_range(range.clone(), &display_name);
+            // 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;
 
-    let new_length = display_name.len();
-    let length_diff = new_length as isize - (range.end - range.start) as isize;
-    let new_range = range.start..(range.start + new_length);
+                if style != HighlightStyle::default() {
+                    highlights.push((non_link_start..non_link_end, Highlight::Highlight(style)));
+                }
+            }
 
-    highlights.push((new_range.clone(), Highlight::Nostr));
-    link_ranges.push(new_range);
-    link_urls.push(format!("nostr:{}", profile.public_key().to_hex()));
+            // Add the link
+            let range = (segment_start + start)..(segment_start + end);
+            link_ranges.push(range.clone());
+            link_urls.push(link.as_str().to_string());
 
-    if length_diff != 0 {
-        adjust_ranges(highlights, link_ranges, range.end, length_diff);
-    }
-}
+            // Apply link styling (underline + existing style)
+            let mut link_style = style;
+            link_style.underline = Some(UnderlineStyle {
+                thickness: 1.0.into(),
+                ..Default::default()
+            });
 
-fn render_bech32(
-    bech32: String,
-    text: &mut String,
-    range: &Range<usize>,
-    highlights: &mut Vec<(Range<usize>, Highlight)>,
-    link_ranges: &mut Vec<Range<usize>>,
-    link_urls: &mut Vec<String>,
-) {
-    let njump_url = format!("https://njump.me/{bech32}");
-    let shortened_entity = format_shortened_entity(&bech32);
-    let display_text = format!("https://njump.me/{shortened_entity}");
+            highlights.push((range, Highlight::Highlight(link_style)));
 
-    text.replace_range(range.clone(), &display_text);
-
-    let new_length = display_text.len();
-    let length_diff = new_length as isize - (range.end - range.start) as isize;
-    let new_range = range.start..(range.start + new_length);
-
-    highlights.push((new_range.clone(), Highlight::Link));
-    link_ranges.push(new_range);
-    link_urls.push(njump_url);
-
-    if length_diff != 0 {
-        adjust_ranges(highlights, link_ranges, range.end, length_diff);
-    }
-}
-
-// Helper function to adjust ranges when text length changes
-fn adjust_ranges(
-    highlights: &mut [(Range<usize>, Highlight)],
-    link_ranges: &mut [Range<usize>],
-    position: usize,
-    length_diff: isize,
-) {
-    // Adjust highlight ranges
-    for (range, _) in highlights.iter_mut() {
-        if range.start > position {
-            range.start = (range.start as isize + length_diff) as usize;
-            range.end = (range.end as isize + length_diff) as usize;
+            last_link_pos = end;
         }
-    }
 
-    // Adjust link ranges
-    for range in link_ranges.iter_mut() {
-        if range.start > position {
-            range.start = (range.start as isize + length_diff) as usize;
-            range.end = (range.end as isize + length_diff) as usize;
+        // 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)));
+            }
         }
     }
 }
+
+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("  ");
+    }
+}

crates/common/Cargo.toml

@@ -15,8 +15,9 @@ chrono.workspace = true
 smallvec.workspace = true
 smol.workspace = true
 futures.workspace = true
-reqwest.workspace = true
 log.workspace = true
 
 dirs = "5.0"
 qrcode = "0.14.1"
+bech32 = "0.11.1"
+regex = "1.10"

crates/common/src/caching.rs

@@ -0,0 +1,135 @@
+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/display.rs

@@ -1,11 +1,10 @@
 use std::sync::Arc;
 
-use anyhow::{anyhow, Error};
 use chrono::{Local, TimeZone};
 use gpui::{Image, ImageFormat, SharedString};
 use nostr_sdk::prelude::*;
-use qrcode::render::svg;
 use qrcode::QrCode;
+use qrcode::render::svg;
 
 const NOW: &str = "now";
 const SECONDS_IN_MINUTE: i64 = 60;
@@ -13,12 +12,12 @@ const MINUTES_IN_HOUR: i64 = 60;
 const HOURS_IN_DAY: i64 = 24;
 const DAYS_IN_MONTH: i64 = 30;
 
-pub trait RenderedTimestamp {
+pub trait TimestampExt {
     fn to_human_time(&self) -> SharedString;
     fn to_ago(&self) -> SharedString;
 }
 
-impl RenderedTimestamp for Timestamp {
+impl TimestampExt for Timestamp {
     fn to_human_time(&self) -> SharedString {
         let input_time = match Local.timestamp_opt(self.as_secs() as i64, 0) {
             chrono::LocalResult::Single(time) => time,
@@ -61,23 +60,11 @@ impl RenderedTimestamp for Timestamp {
     }
 }
 
-pub trait TextUtils {
-    fn to_public_key(&self) -> Result<PublicKey, Error>;
+pub trait StringExt {
     fn to_qr(&self) -> Option<Arc<Image>>;
 }
 
-impl<T: AsRef<str>> TextUtils for T {
-    fn to_public_key(&self) -> Result<PublicKey, Error> {
-        let s = self.as_ref();
-        if s.starts_with("nprofile1") {
-            Ok(Nip19Profile::from_bech32(s)?.public_key)
-        } else if s.starts_with("npub1") {
-            Ok(PublicKey::parse(s)?)
-        } else {
-            Err(anyhow!("Invalid public key"))
-        }
-    }
-
+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();
@@ -94,13 +81,3 @@ impl<T: AsRef<str>> TextUtils for T {
         )))
     }
 }
-
-pub fn shorten_pubkey(public_key: PublicKey, len: usize) -> String {
-    let Ok(pubkey) = public_key.to_bech32();
-
-    format!(
-        "{}:{}",
-        &pubkey[0..(len + 1)],
-        &pubkey[pubkey.len() - len..]
-    )
-}

crates/common/src/event.rs

@@ -3,12 +3,12 @@ use std::hash::{DefaultHasher, Hash, Hasher};
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
 
-pub trait EventUtils {
+pub trait EventExt {
     fn uniq_id(&self) -> u64;
     fn extract_public_keys(&self) -> Vec<PublicKey>;
 }
 
-impl EventUtils for Event {
+impl EventExt for Event {
     fn uniq_id(&self) -> u64 {
         let mut hasher = DefaultHasher::new();
         let mut pubkeys: Vec<PublicKey> = self.extract_public_keys();
@@ -25,7 +25,7 @@ impl EventUtils for Event {
     }
 }
 
-impl EventUtils for UnsignedEvent {
+impl EventExt for UnsignedEvent {
     fn uniq_id(&self) -> u64 {
         let mut hasher = DefaultHasher::new();
         let mut pubkeys: Vec<PublicKey> = vec![];

crates/common/src/lib.rs

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

crates/common/src/media_extractor.rs

@@ -0,0 +1,117 @@
+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 {
+    image_regex: Regex,
+    video_regex: Regex,
+}
+
+impl MediaExtractor {
+    /// Creates a new MediaExtractor with compiled regex patterns
+    pub 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> {
+        let mut urls = Vec::new();
+
+        // Extract image URLs
+        for capture in self.image_regex.find_iter(text) {
+            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 {
+        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) {
+        let urls = self.extract_media_urls(text);
+        let cleaned_text = self.remove_media_urls(text);
+        (urls, cleaned_text)
+    }
+
+    /// Helper function to clean up text after URL removal
+    fn cleanup_text(&self, text: &str) -> String {
+        let text = text.trim();
+
+        // Remove multiple consecutive spaces
+        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
+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/nip96.rs

@@ -1,83 +0,0 @@
-use anyhow::anyhow;
-use nostr::hashes::sha256::Hash as Sha256Hash;
-use nostr::hashes::Hash;
-use nostr::prelude::*;
-use nostr_sdk::prelude::*;
-use reqwest::{multipart, Client as ReqClient, Response};
-
-pub(crate) fn make_multipart_form(
-    file_data: Vec<u8>,
-    mime_type: Option<&str>,
-) -> Result<multipart::Form, anyhow::Error> {
-    let form_file_part = multipart::Part::bytes(file_data).file_name("filename");
-
-    // Set the part's MIME type, or leave it as is if mime_type is None
-
-    let part = match mime_type {
-        Some(mime) => form_file_part.mime_str(mime)?,
-        None => form_file_part,
-    };
-
-    Ok(multipart::Form::new().part("file", part))
-}
-
-pub(crate) async fn upload<T>(
-    signer: &T,
-    desc: &ServerConfig,
-    file_data: Vec<u8>,
-    mime_type: Option<&str>,
-) -> Result<Url, anyhow::Error>
-where
-    T: NostrSigner,
-{
-    let payload: Sha256Hash = Sha256Hash::hash(&file_data);
-    let data: HttpData = HttpData::new(desc.api_url.clone(), HttpMethod::POST).payload(payload);
-    let nip98_auth: String = data.to_authorization(signer).await?;
-
-    // Make form
-    let form: multipart::Form = make_multipart_form(file_data, mime_type)?;
-
-    // Make req client
-    let req_client = ReqClient::new();
-
-    // Send
-    let response: Response = req_client
-        .post(desc.api_url.clone())
-        .header("Authorization", nip98_auth)
-        .multipart(form)
-        .send()
-        .await?;
-
-    // Parse response
-    let json: Value = response.json().await?;
-    let upload_response = nip96::UploadResponse::from_json(json.to_string())?;
-
-    if upload_response.status == UploadResponseStatus::Error {
-        return Err(anyhow!(upload_response.message));
-    }
-
-    Ok(upload_response.download_url()?.to_owned())
-}
-
-pub async fn nip96_upload(
-    client: &Client,
-    server: &Url,
-    file: Vec<u8>,
-) -> Result<Url, anyhow::Error> {
-    let req_client = ReqClient::new();
-    let config_url = nip96::get_server_config_url(server)?;
-
-    // Get
-    let res = req_client.get(config_url.to_string()).send().await?;
-    let json: Value = res.json().await?;
-
-    let config = nip96::ServerConfig::from_json(json.to_string())?;
-    let signer = client
-        .signer()
-        .cloned()
-        .unwrap_or(Keys::generate().into_nostr_signer());
-
-    let url = upload(&signer, &config, file, None).await?;
-
-    Ok(url)
-}

crates/common/src/parser.rs

@@ -0,0 +1,210 @@
+use std::ops::Range;
+
+use nostr::prelude::*;
+
+const BECH32_SEPARATOR: u8 = b'1';
+const SCHEME_WITH_COLON: &str = "nostr:";
+
+/// Nostr parsed token with its range in the original text
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Token {
+    /// The parsed NIP-21 URI
+    ///
+    /// <https://github.com/nostr-protocol/nips/blob/master/21.md>
+    pub value: Nip21,
+    /// The range of this token in the original text
+    pub range: Range<usize>,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Match {
+    start: usize,
+    end: usize,
+}
+
+/// Nostr parser
+#[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 {
+        Self
+    }
+
+    /// Parse text
+    pub fn parse<'a>(&self, text: &'a str) -> NostrParserIter<'a> {
+        NostrParserIter::new(text)
+    }
+}
+
+struct FindMatches<'a> {
+    bytes: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> FindMatches<'a> {
+    fn new(text: &'a str) -> Self {
+        Self {
+            bytes: text.as_bytes(),
+            pos: 0,
+        }
+    }
+
+    fn try_parse_nostr_uri(&mut self) -> Option<Match> {
+        let start = self.pos;
+        let bytes = self.bytes;
+        let len = bytes.len();
+
+        // Check if we have "nostr:" prefix
+        if len - start < SCHEME_WITH_COLON.len() {
+            return None;
+        }
+
+        // Check for "nostr:" prefix (case-insensitive)
+        let scheme_prefix = &bytes[start..start + SCHEME_WITH_COLON.len()];
+        if !scheme_prefix.eq_ignore_ascii_case(SCHEME_WITH_COLON.as_bytes()) {
+            return None;
+        }
+
+        // Skip the scheme
+        let pos = start + SCHEME_WITH_COLON.len();
+
+        // Parse bech32 entity
+        let mut has_separator = false;
+        let mut end = pos;
+
+        while end < len {
+            let byte = bytes[end];
+
+            // Check for bech32 separator
+            if byte == BECH32_SEPARATOR && !has_separator {
+                has_separator = true;
+                end += 1;
+                continue;
+            }
+
+            // Check if character is valid for bech32
+            if !byte.is_ascii_alphanumeric() {
+                break;
+            }
+
+            end += 1;
+        }
+
+        // Must have at least one character after separator
+        if !has_separator || end <= pos + 1 {
+            return None;
+        }
+
+        // Update position
+        self.pos = end;
+
+        Some(Match { start, end })
+    }
+}
+
+impl Iterator for FindMatches<'_> {
+    type Item = Match;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.pos < self.bytes.len() {
+            // Try to parse nostr URI
+            if let Some(mat) = self.try_parse_nostr_uri() {
+                return Some(mat);
+            }
+
+            // Skip one character if no match found
+            self.pos += 1;
+        }
+
+        None
+    }
+}
+
+enum HandleMatch {
+    Token(Token),
+    Recursion,
+}
+
+pub struct NostrParserIter<'a> {
+    /// The original text
+    text: &'a str,
+    /// Matches found
+    matches: FindMatches<'a>,
+    /// A pending match
+    pending_match: Option<Match>,
+    /// Last match end index
+    last_match_end: usize,
+}
+
+impl<'a> NostrParserIter<'a> {
+    fn new(text: &'a str) -> Self {
+        Self {
+            text,
+            matches: FindMatches::new(text),
+            pending_match: None,
+            last_match_end: 0,
+        }
+    }
+
+    fn handle_match(&mut self, mat: Match) -> HandleMatch {
+        // Update last match end
+        self.last_match_end = mat.end;
+
+        // Extract the matched string
+        let data: &str = &self.text[mat.start..mat.end];
+
+        // Parse NIP-21 URI
+        match Nip21::parse(data) {
+            Ok(uri) => HandleMatch::Token(Token {
+                value: uri,
+                range: mat.start..mat.end,
+            }),
+            // If the nostr URI parsing is invalid, skip it
+            Err(_) => HandleMatch::Recursion,
+        }
+    }
+}
+
+impl<'a> Iterator for NostrParserIter<'a> {
+    type Item = Token;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Handle a pending match
+        if let Some(pending_match) = self.pending_match.take() {
+            return match self.handle_match(pending_match) {
+                HandleMatch::Token(token) => Some(token),
+                HandleMatch::Recursion => self.next(),
+            };
+        }
+
+        match self.matches.next() {
+            Some(mat) => {
+                // Skip any text before this match
+                if mat.start > self.last_match_end {
+                    // Update pending match
+                    // This will be handled at next iteration, in `handle_match` method.
+                    self.pending_match = Some(mat);
+
+                    // Skip the text before the match
+                    self.last_match_end = mat.start;
+                    return self.next();
+                }
+
+                // Handle match
+                match self.handle_match(mat) {
+                    HandleMatch::Token(token) => Some(token),
+                    HandleMatch::Recursion => self.next(),
+                }
+            }
+            None => None,
+        }
+    }
+}

crates/common/src/paths.rs

@@ -7,6 +7,13 @@ pub fn home_dir() -> &'static PathBuf {
     HOME_DIR.get_or_init(|| dirs::home_dir().expect("failed to determine home directory"))
 }
 
+/// Returns the path to the user's download directory.
+pub fn download_dir() -> &'static PathBuf {
+    static DOWNLOAD_DIR: OnceLock<PathBuf> = OnceLock::new();
+    DOWNLOAD_DIR
+        .get_or_init(|| dirs::download_dir().expect("failed to determine download directory"))
+}
+
 /// Returns the path to the configuration directory used by Coop.
 pub fn config_dir() -> &'static PathBuf {
     static CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();
@@ -56,9 +63,3 @@ pub fn support_dir() -> &'static PathBuf {
         config_dir().clone()
     })
 }
-
-/// Returns the path to the `nostr` file.
-pub fn nostr_file() -> &'static PathBuf {
-    static NOSTR_FILE: OnceLock<PathBuf> = OnceLock::new();
-    NOSTR_FILE.get_or_init(|| support_dir().join("nostr-db"))
-}

crates/common/src/range.rs

@@ -0,0 +1,45 @@
+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/coop/Cargo.toml

@@ -1,63 +0,0 @@
-[package]
-name = "coop"
-version.workspace = true
-edition.workspace = true
-publish.workspace = true
-
-[[bin]]
-name = "coop"
-path = "src/main.rs"
-
-[package.metadata.packager]
-name = "Coop"
-product-name = "Coop"
-description = "Chat Freely, Stay Private on Nostr"
-identifier = "su.reya.coop"
-category = "SocialNetworking"
-version = "0.3.0"
-out-dir = "../../dist"
-before-packaging-command = "cargo build --release"
-resources = ["Cargo.toml", "src"]
-icons = [
-    "resources/32x32.png",
-    "resources/128x128.png",
-    "resources/128x128@2x.png",
-    "resources/icon.icns",
-    "resources/icon.ico",
-]
-
-[dependencies]
-assets = { path = "../assets" }
-ui = { path = "../ui" }
-titlebar = { path = "../titlebar" }
-dock = { path = "../dock" }
-theme = { path = "../theme" }
-common = { path = "../common" }
-state = { path = "../state" }
-device = { path = "../device" }
-chat = { path = "../chat" }
-chat_ui = { path = "../chat_ui" }
-settings = { path = "../settings" }
-auto_update = { path = "../auto_update" }
-person = { path = "../person" }
-relay_auth = { path = "../relay_auth" }
-
-gpui.workspace = true
-gpui_tokio.workspace = true
-reqwest_client.workspace = true
-
-nostr-connect.workspace = true
-nostr-sdk.workspace = true
-
-anyhow.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-itertools.workspace = true
-log.workspace = true
-smallvec.workspace = true
-smol.workspace = true
-futures.workspace = true
-oneshot.workspace = true
-
-indexset = "0.12.3"
-tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }

crates/coop/src/dialogs/mod.rs

@@ -1 +0,0 @@
-pub mod screening;

crates/coop/src/dialogs/profile.rs

@@ -1,266 +0,0 @@
-use std::time::Duration;
-
-use anyhow::Error;
-use common::shorten_pubkey;
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, relative, rems, App, AppContext, ClipboardItem, Context, Entity, IntoElement,
-    ParentElement, Render, SharedString, Styled, Task, Window,
-};
-use nostr_sdk::prelude::*;
-use person::PersonRegistry;
-use smallvec::{smallvec, SmallVec};
-use state::{NostrAddress, NostrRegistry};
-use theme::ActiveTheme;
-use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
-use ui::{h_flex, v_flex, Icon, IconName, Sizable, StyledExt};
-
-pub fn init(public_key: PublicKey, window: &mut Window, cx: &mut App) -> Entity<ProfileDialog> {
-    cx.new(|cx| ProfileDialog::new(public_key, window, cx))
-}
-
-#[derive(Debug)]
-pub struct ProfileDialog {
-    public_key: PublicKey,
-
-    /// Follow status
-    followed: bool,
-
-    /// Verification status
-    verified: bool,
-
-    /// Copy status
-    copied: bool,
-
-    /// Async operations
-    _tasks: SmallVec<[Task<()>; 1]>,
-}
-
-impl ProfileDialog {
-    pub fn new(public_key: PublicKey, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let http_client = cx.http_client();
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        let persons = PersonRegistry::global(cx);
-        let profile = persons.read(cx).get(&public_key, cx);
-
-        let mut tasks = smallvec![];
-
-        // Check if the user is following
-        let check_follow: Task<Result<bool, Error>> = cx.background_spawn(async move {
-            let signer = client.signer().await?;
-            let public_key = signer.get_public_key().await?;
-            let contact_list = client.database().contacts_public_keys(public_key).await?;
-
-            Ok(contact_list.contains(&public_key))
-        });
-
-        // Verify the NIP05 address if available
-        let verify_nip05 = profile.metadata().nip05.and_then(|address| {
-            Nip05Address::parse(&address).ok().map(|addr| {
-                cx.background_spawn(async move { addr.verify(&http_client, &public_key).await })
-            })
-        });
-
-        tasks.push(
-            // Load user profile data
-            cx.spawn_in(window, async move |this, cx| {
-                let followed = check_follow.await.unwrap_or(false);
-
-                // Update the followed status
-                this.update(cx, |this, cx| {
-                    this.followed = followed;
-                    cx.notify();
-                })
-                .ok();
-
-                // Update the NIP05 verification status if user has NIP05 address
-                if let Some(task) = verify_nip05 {
-                    if let Ok(verified) = task.await {
-                        this.update(cx, |this, cx| {
-                            this.verified = verified;
-                            cx.notify();
-                        })
-                        .ok();
-                    }
-                }
-            }),
-        );
-
-        Self {
-            public_key,
-            followed: false,
-            verified: false,
-            copied: false,
-            _tasks: tasks,
-        }
-    }
-
-    fn address(&self, cx: &Context<Self>) -> Option<String> {
-        let persons = PersonRegistry::global(cx);
-        let profile = persons.read(cx).get(&self.public_key, cx);
-
-        profile.metadata().nip05
-    }
-
-    fn copy_pubkey(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let persons = PersonRegistry::global(cx);
-        let profile = persons.read(cx).get(&self.public_key, cx);
-
-        let Ok(bech32) = profile.public_key().to_bech32();
-        let item = ClipboardItem::new_string(bech32);
-        cx.write_to_clipboard(item);
-
-        self.set_copied(true, window, cx);
-    }
-
-    fn set_copied(&mut self, status: bool, window: &mut Window, cx: &mut Context<Self>) {
-        self.copied = status;
-        cx.notify();
-
-        if status {
-            self._tasks.push(
-                // Reset the copied state after a delay
-                cx.spawn_in(window, async move |this, cx| {
-                    cx.background_executor().timer(Duration::from_secs(2)).await;
-                    cx.update(|window, cx| {
-                        this.update(cx, |this, cx| {
-                            this.set_copied(false, window, cx);
-                        })
-                        .ok();
-                    })
-                    .ok();
-                }),
-            );
-        }
-    }
-}
-
-impl Render for ProfileDialog {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let persons = PersonRegistry::global(cx);
-        let profile = persons.read(cx).get(&self.public_key, cx);
-        let bech32 = shorten_pubkey(profile.public_key(), 16);
-        let shared_bech32 = SharedString::from(bech32);
-
-        v_flex()
-            .gap_4()
-            .text_sm()
-            .child(
-                v_flex()
-                    .gap_3()
-                    .items_center()
-                    .justify_center()
-                    .text_center()
-                    .child(Avatar::new(profile.avatar()).size(rems(4.)))
-                    .child(
-                        v_flex()
-                            .child(
-                                div()
-                                    .font_semibold()
-                                    .line_height(relative(1.25))
-                                    .child(profile.name()),
-                            )
-                            .when_some(self.address(cx), |this, address| {
-                                this.child(
-                                    h_flex()
-                                        .justify_center()
-                                        .gap_1()
-                                        .text_xs()
-                                        .text_color(cx.theme().text_muted)
-                                        .child(address)
-                                        .when(self.verified, |this| {
-                                            this.child(
-                                                div()
-                                                    .relative()
-                                                    .text_color(cx.theme().text_accent)
-                                                    .child(
-                                                        Icon::new(IconName::CheckCircle)
-                                                            .small()
-                                                            .block(),
-                                                    ),
-                                            )
-                                        }),
-                                )
-                            }),
-                    )
-                    .when(!self.followed, |this| {
-                        this.child(
-                            div()
-                                .flex_none()
-                                .w_32()
-                                .p_1()
-                                .rounded_full()
-                                .bg(cx.theme().elevated_surface_background)
-                                .text_xs()
-                                .font_semibold()
-                                .child(SharedString::from("Unknown contact")),
-                        )
-                    }),
-            )
-            .child(
-                v_flex()
-                    .gap_1()
-                    .text_sm()
-                    .child(
-                        div()
-                            .text_color(cx.theme().text_muted)
-                            .child(SharedString::from("Bio:")),
-                    )
-                    .child(
-                        div()
-                            .p_2()
-                            .min_h_16()
-                            .rounded(cx.theme().radius)
-                            .bg(cx.theme().elevated_surface_background)
-                            .child(
-                                profile
-                                    .metadata()
-                                    .about
-                                    .map(SharedString::from)
-                                    .unwrap_or(SharedString::from("No bio.")),
-                            ),
-                    ),
-            )
-            .child(div().my_1().h_px().w_full().bg(cx.theme().border))
-            .child(
-                v_flex()
-                    .gap_1()
-                    .child(
-                        div()
-                            .text_xs()
-                            .text_color(cx.theme().text_placeholder)
-                            .font_semibold()
-                            .child(SharedString::from("Public Key:")),
-                    )
-                    .child(
-                        h_flex()
-                            .gap_2()
-                            .w_full()
-                            .h_12()
-                            .justify_center()
-                            .bg(cx.theme().surface_background)
-                            .rounded(cx.theme().radius)
-                            .text_sm()
-                            .child(shared_bech32)
-                            .child(
-                                Button::new("copy")
-                                    .icon({
-                                        if self.copied {
-                                            IconName::CheckCircle
-                                        } else {
-                                            IconName::Copy
-                                        }
-                                    })
-                                    .xsmall()
-                                    .ghost()
-                                    .on_click(cx.listener(move |this, _e, window, cx| {
-                                        this.copy_pubkey(window, cx);
-                                    })),
-                            ),
-                    ),
-            )
-    }
-}

crates/coop/src/main.rs

@@ -1,139 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use assets::Assets;
-use gpui::{
-    actions, point, px, size, App, AppContext, Application, Bounds, KeyBinding, Menu, MenuItem,
-    SharedString, Size, TitlebarOptions, WindowBackgroundAppearance, WindowBounds,
-    WindowDecorations, WindowKind, WindowOptions,
-};
-use state::{APP_ID, CLIENT_NAME};
-use ui::Root;
-
-mod dialogs;
-mod panels;
-mod sidebar;
-mod workspace;
-
-actions!(coop, [Quit]);
-
-fn main() {
-    // Initialize logging
-    tracing_subscriber::fmt::init();
-
-    // Initialize the Application
-    let app = Application::new()
-        .with_assets(Assets)
-        .with_http_client(Arc::new(reqwest_client::ReqwestClient::new()));
-
-    // Run application
-    app.run(move |cx| {
-        // Load embedded fonts in assets/fonts
-        load_embedded_fonts(cx);
-
-        // Register the `quit` function
-        cx.on_action(quit);
-
-        // Register the `quit` function with CMD+Q (macOS)
-        #[cfg(target_os = "macos")]
-        cx.bind_keys([KeyBinding::new("cmd-q", Quit, None)]);
-
-        // Register the `quit` function with Super+Q (others)
-        #[cfg(not(target_os = "macos"))]
-        cx.bind_keys([KeyBinding::new("super-q", Quit, None)]);
-
-        // Set menu items
-        cx.set_menus(vec![Menu {
-            name: "Coop".into(),
-            items: vec![MenuItem::action("Quit", Quit)],
-        }]);
-
-        // Set up the window bounds
-        let bounds = Bounds::centered(None, size(px(920.0), px(700.0)), cx);
-
-        // Set up the window options
-        let opts = WindowOptions {
-            window_background: WindowBackgroundAppearance::Opaque,
-            window_decorations: Some(WindowDecorations::Client),
-            window_bounds: Some(WindowBounds::Windowed(bounds)),
-            window_min_size: Some(Size::new(px(640.), px(480.))),
-            kind: WindowKind::Normal,
-            app_id: Some(APP_ID.to_owned()),
-            titlebar: Some(TitlebarOptions {
-                title: Some(SharedString::new_static(CLIENT_NAME)),
-                traffic_light_position: Some(point(px(9.0), px(9.0))),
-                appears_transparent: true,
-            }),
-            ..Default::default()
-        };
-
-        // Open a window with default options
-        cx.open_window(opts, |window, cx| {
-            // Bring the app to the foreground
-            cx.activate(true);
-
-            cx.new(|cx| {
-                // Initialize components
-                ui::init(cx);
-
-                // Initialize theme registry
-                theme::init(cx);
-
-                // Initialize settings
-                settings::init(cx);
-
-                // Initialize the nostr client
-                state::init(window, cx);
-
-                // Initialize relay auth registry
-                relay_auth::init(window, cx);
-
-                // Initialize person registry
-                person::init(cx);
-
-                // Initialize device signer
-                //
-                // NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
-                device::init(window, cx);
-
-                // Initialize app registry
-                chat::init(window, cx);
-
-                // Initialize auto update
-                auto_update::init(cx);
-
-                // Root Entity
-                Root::new(workspace::init(window, cx).into(), window, cx)
-            })
-        })
-        .expect("Failed to open window. Please restart the application.");
-    });
-}
-
-fn load_embedded_fonts(cx: &App) {
-    let asset_source = cx.asset_source();
-    let font_paths = asset_source.list("fonts").unwrap();
-    let embedded_fonts = Mutex::new(vec![]);
-    let executor = cx.background_executor();
-
-    cx.foreground_executor().block_on(executor.scoped(|scope| {
-        for font_path in &font_paths {
-            if !font_path.ends_with(".ttf") {
-                continue;
-            }
-
-            scope.spawn(async {
-                let font_bytes = asset_source.load(font_path.as_str()).unwrap().unwrap();
-                embedded_fonts.lock().unwrap().push(font_bytes);
-            });
-        }
-    }));
-
-    cx.text_system()
-        .add_fonts(embedded_fonts.into_inner().unwrap())
-        .unwrap();
-}
-
-fn quit(_ev: &Quit, cx: &mut App) {
-    log::info!("Gracefully quitting the application . . .");
-    cx.quit();
-}

crates/coop/src/panels/connect.rs

@@ -1,127 +0,0 @@
-use std::sync::Arc;
-
-use common::TextUtils;
-use dock::panel::{Panel, PanelEvent};
-use dock::ClosePanel;
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, img, px, relative, AnyElement, App, AppContext, Context, Entity, EventEmitter,
-    FocusHandle, Focusable, Image, IntoElement, ParentElement, Render, SharedString, Styled, Task,
-    Window,
-};
-use smallvec::{smallvec, SmallVec};
-use state::NostrRegistry;
-use theme::ActiveTheme;
-use ui::notification::Notification;
-use ui::{v_flex, StyledExt, WindowExtension};
-
-pub fn init(window: &mut Window, cx: &mut App) -> Entity<ConnectPanel> {
-    cx.new(|cx| ConnectPanel::new(window, cx))
-}
-
-pub struct ConnectPanel {
-    name: SharedString,
-    focus_handle: FocusHandle,
-
-    /// QR Code
-    qr_code: Option<Arc<Image>>,
-
-    /// Background tasks
-    _tasks: SmallVec<[Task<()>; 1]>,
-}
-
-impl ConnectPanel {
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let nostr = NostrRegistry::global(cx);
-        let weak_state = nostr.downgrade();
-        let (signer, uri) = nostr.read(cx).client_connect(None);
-
-        // Generate a QR code for quick connection
-        let qr_code = uri.to_string().to_qr();
-
-        let mut tasks = smallvec![];
-
-        tasks.push(
-            // Wait for nostr connect
-            cx.spawn_in(window, async move |_this, cx| {
-                let result = signer.bunker_uri().await;
-
-                weak_state
-                    .update_in(cx, |this, window, cx| {
-                        match result {
-                            Ok(uri) => {
-                                this.persist_bunker(uri, cx);
-                                this.set_signer(signer, true, cx);
-                                // Close the current panel after setting the signer
-                                window.dispatch_action(Box::new(ClosePanel), cx);
-                            }
-                            Err(e) => {
-                                window.push_notification(Notification::error(e.to_string()), cx);
-                            }
-                        };
-                    })
-                    .ok();
-            }),
-        );
-
-        Self {
-            name: "Nostr Connect".into(),
-            focus_handle: cx.focus_handle(),
-            qr_code,
-            _tasks: tasks,
-        }
-    }
-}
-
-impl Panel for ConnectPanel {
-    fn panel_id(&self) -> SharedString {
-        self.name.clone()
-    }
-
-    fn title(&self, _cx: &App) -> AnyElement {
-        self.name.clone().into_any_element()
-    }
-}
-
-impl EventEmitter<PanelEvent> for ConnectPanel {}
-
-impl Focusable for ConnectPanel {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Render for ConnectPanel {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex()
-            .size_full()
-            .items_center()
-            .justify_center()
-            .p_2()
-            .gap_10()
-            .child(
-                v_flex()
-                    .justify_center()
-                    .items_center()
-                    .text_center()
-                    .child(
-                        div()
-                            .font_semibold()
-                            .line_height(relative(1.25))
-                            .child(SharedString::from("Continue with Nostr Connect")),
-                    )
-                    .child(div().text_sm().text_color(cx.theme().text_muted).child(
-                        SharedString::from("Use Nostr Connect apps to scan the code"),
-                    )),
-            )
-            .when_some(self.qr_code.as_ref(), |this, qr| {
-                this.child(
-                    img(qr.clone())
-                        .size(px(256.))
-                        .rounded(cx.theme().radius_lg)
-                        .border_1()
-                        .border_color(cx.theme().border),
-                )
-            })
-    }
-}

crates/coop/src/panels/greeter.rs

@@ -1,294 +0,0 @@
-use dock::dock::DockPlacement;
-use dock::panel::{Panel, PanelEvent};
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, relative, svg, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle,
-    Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Window,
-};
-use state::{NostrRegistry, RelayState};
-use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
-use ui::{h_flex, v_flex, Icon, IconName, Sizable, StyledExt};
-
-use crate::panels::{connect, import, messaging_relays, profile, relay_list};
-use crate::workspace::Workspace;
-
-pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
-    cx.new(|cx| GreeterPanel::new(window, cx))
-}
-
-pub struct GreeterPanel {
-    name: SharedString,
-    focus_handle: FocusHandle,
-}
-
-impl GreeterPanel {
-    fn new(_window: &mut Window, cx: &mut App) -> Self {
-        Self {
-            name: "Onboarding".into(),
-            focus_handle: cx.focus_handle(),
-        }
-    }
-
-    fn add_profile_panel(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        let signer = nostr.read(cx).signer();
-
-        if let Some(public_key) = signer.public_key() {
-            cx.spawn_in(window, async move |_this, cx| {
-                cx.update(|window, cx| {
-                    Workspace::add_panel(
-                        profile::init(public_key, window, cx),
-                        DockPlacement::Center,
-                        window,
-                        cx,
-                    );
-                })
-                .ok();
-            })
-            .detach();
-        }
-    }
-}
-
-impl Panel for GreeterPanel {
-    fn panel_id(&self) -> SharedString {
-        self.name.clone()
-    }
-
-    fn title(&self, cx: &App) -> AnyElement {
-        div()
-            .child(
-                svg()
-                    .path("brand/coop.svg")
-                    .size_4()
-                    .text_color(cx.theme().text_muted),
-            )
-            .into_any_element()
-    }
-}
-
-impl EventEmitter<PanelEvent> for GreeterPanel {}
-
-impl Focusable for GreeterPanel {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Render for GreeterPanel {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const TITLE: &str = "Welcome to Coop!";
-        const DESCRIPTION: &str = "Chat Freely, Stay Private on Nostr.";
-
-        let nostr = NostrRegistry::global(cx);
-        let nip65_state = nostr.read(cx).nip65_state();
-        let nip17_state = nostr.read(cx).nip17_state();
-        let signer = nostr.read(cx).signer();
-        let owned = signer.owned();
-
-        let required_actions = nip65_state.read(cx) == &RelayState::NotConfigured
-            || nip17_state.read(cx) == &RelayState::NotConfigured;
-
-        h_flex()
-            .size_full()
-            .items_center()
-            .justify_center()
-            .p_2()
-            .child(
-                v_flex()
-                    .h_full()
-                    .w_112()
-                    .gap_6()
-                    .items_center()
-                    .justify_center()
-                    .child(
-                        h_flex()
-                            .mb_4()
-                            .gap_2()
-                            .w_full()
-                            .child(
-                                svg()
-                                    .path("brand/coop.svg")
-                                    .size_12()
-                                    .text_color(cx.theme().icon_muted),
-                            )
-                            .child(
-                                v_flex()
-                                    .child(
-                                        div()
-                                            .font_semibold()
-                                            .line_height(relative(1.25))
-                                            .child(SharedString::from(TITLE)),
-                                    )
-                                    .child(
-                                        div()
-                                            .text_sm()
-                                            .text_color(cx.theme().text_muted)
-                                            .line_height(relative(1.25))
-                                            .child(SharedString::from(DESCRIPTION)),
-                                    ),
-                            ),
-                    )
-                    .when(required_actions, |this| {
-                        this.child(
-                            v_flex()
-                                .gap_2()
-                                .w_full()
-                                .child(
-                                    h_flex()
-                                        .gap_1()
-                                        .w_full()
-                                        .text_sm()
-                                        .font_semibold()
-                                        .text_color(cx.theme().text_muted)
-                                        .child(SharedString::from("Required Actions"))
-                                        .child(div().flex_1().h_px().bg(cx.theme().border)),
-                                )
-                                .child(
-                                    v_flex()
-                                        .gap_2()
-                                        .w_full()
-                                        .when(nip65_state.read(cx).not_configured(), |this| {
-                                            this.child(
-                                                Button::new("relaylist")
-                                                    .icon(Icon::new(IconName::Relay))
-                                                    .label("Set up relay list")
-                                                    .ghost()
-                                                    .small()
-                                                    .justify_start()
-                                                    .on_click(move |_ev, window, cx| {
-                                                        Workspace::add_panel(
-                                                            relay_list::init(window, cx),
-                                                            DockPlacement::Center,
-                                                            window,
-                                                            cx,
-                                                        );
-                                                    }),
-                                            )
-                                        })
-                                        .when(nip17_state.read(cx).not_configured(), |this| {
-                                            this.child(
-                                                Button::new("import")
-                                                    .icon(Icon::new(IconName::Relay))
-                                                    .label("Set up messaging relays")
-                                                    .ghost()
-                                                    .small()
-                                                    .justify_start()
-                                                    .on_click(move |_ev, window, cx| {
-                                                        Workspace::add_panel(
-                                                            messaging_relays::init(window, cx),
-                                                            DockPlacement::Center,
-                                                            window,
-                                                            cx,
-                                                        );
-                                                    }),
-                                            )
-                                        }),
-                                ),
-                        )
-                    })
-                    .when(!owned, |this| {
-                        this.child(
-                            v_flex()
-                                .gap_2()
-                                .w_full()
-                                .child(
-                                    h_flex()
-                                        .gap_1()
-                                        .w_full()
-                                        .text_sm()
-                                        .font_semibold()
-                                        .text_color(cx.theme().text_muted)
-                                        .child(SharedString::from("Use your own identity"))
-                                        .child(div().flex_1().h_px().bg(cx.theme().border)),
-                                )
-                                .child(
-                                    v_flex()
-                                        .gap_2()
-                                        .w_full()
-                                        .child(
-                                            Button::new("connect")
-                                                .icon(Icon::new(IconName::Door))
-                                                .label("Connect account via Nostr Connect")
-                                                .ghost()
-                                                .small()
-                                                .justify_start()
-                                                .on_click(move |_ev, window, cx| {
-                                                    Workspace::add_panel(
-                                                        connect::init(window, cx),
-                                                        DockPlacement::Center,
-                                                        window,
-                                                        cx,
-                                                    );
-                                                }),
-                                        )
-                                        .child(
-                                            Button::new("import")
-                                                .icon(Icon::new(IconName::Usb))
-                                                .label("Import a secret key or bunker")
-                                                .ghost()
-                                                .small()
-                                                .justify_start()
-                                                .on_click(move |_ev, window, cx| {
-                                                    Workspace::add_panel(
-                                                        import::init(window, cx),
-                                                        DockPlacement::Center,
-                                                        window,
-                                                        cx,
-                                                    );
-                                                }),
-                                        ),
-                                ),
-                        )
-                    })
-                    .child(
-                        v_flex()
-                            .gap_2()
-                            .w_full()
-                            .child(
-                                h_flex()
-                                    .gap_1()
-                                    .w_full()
-                                    .text_sm()
-                                    .font_semibold()
-                                    .text_color(cx.theme().text_muted)
-                                    .child(SharedString::from("Get Started"))
-                                    .child(div().flex_1().h_px().bg(cx.theme().border)),
-                            )
-                            .child(
-                                v_flex()
-                                    .gap_2()
-                                    .w_full()
-                                    .child(
-                                        Button::new("backup")
-                                            .icon(Icon::new(IconName::Shield))
-                                            .label("Backup account")
-                                            .ghost()
-                                            .small()
-                                            .justify_start(),
-                                    )
-                                    .child(
-                                        Button::new("profile")
-                                            .icon(Icon::new(IconName::Profile))
-                                            .label("Update profile")
-                                            .ghost()
-                                            .small()
-                                            .justify_start()
-                                            .on_click(cx.listener(move |this, _ev, window, cx| {
-                                                this.add_profile_panel(window, cx)
-                                            })),
-                                    )
-                                    .child(
-                                        Button::new("invite")
-                                            .icon(Icon::new(IconName::Invite))
-                                            .label("Invite friends")
-                                            .ghost()
-                                            .small()
-                                            .justify_start(),
-                                    ),
-                            ),
-                    ),
-            )
-    }
-}

crates/coop/src/panels/import.rs

@@ -1,371 +0,0 @@
-use std::time::Duration;
-
-use anyhow::anyhow;
-use dock::panel::{Panel, PanelEvent};
-use dock::ClosePanel;
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, relative, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle,
-    Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Subscription, Window,
-};
-use nostr_connect::prelude::*;
-use smallvec::{smallvec, SmallVec};
-use state::{CoopAuthUrlHandler, NostrRegistry};
-use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
-use ui::input::{InputEvent, InputState, TextInput};
-use ui::notification::Notification;
-use ui::{v_flex, Disableable, StyledExt, WindowExtension};
-
-pub fn init(window: &mut Window, cx: &mut App) -> Entity<ImportPanel> {
-    cx.new(|cx| ImportPanel::new(window, cx))
-}
-
-#[derive(Debug)]
-pub struct ImportPanel {
-    name: SharedString,
-    focus_handle: FocusHandle,
-
-    /// Secret key input
-    key_input: Entity<InputState>,
-
-    /// Password input (if required)
-    pass_input: Entity<InputState>,
-
-    /// Error message
-    error: Entity<Option<SharedString>>,
-
-    /// Countdown timer for nostr connect
-    countdown: Entity<Option<u64>>,
-
-    /// Whether the user is currently logging in
-    logging_in: bool,
-
-    /// Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
-}
-
-impl ImportPanel {
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let key_input = cx.new(|cx| InputState::new(window, cx).masked(true));
-        let pass_input = cx.new(|cx| InputState::new(window, cx).masked(true));
-
-        let error = cx.new(|_| None);
-        let countdown = cx.new(|_| None);
-
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Subscribe to key input events and process login when the user presses enter
-            cx.subscribe_in(&key_input, window, |this, _input, event, window, cx| {
-                if let InputEvent::PressEnter { .. } = event {
-                    this.login(window, cx);
-                };
-            }),
-        );
-
-        Self {
-            key_input,
-            pass_input,
-            error,
-            countdown,
-            name: "Import".into(),
-            focus_handle: cx.focus_handle(),
-            logging_in: false,
-            _subscriptions: subscriptions,
-        }
-    }
-
-    fn login(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        if self.logging_in {
-            return;
-        };
-        // Prevent duplicate login requests
-        self.set_logging_in(true, cx);
-
-        let value = self.key_input.read(cx).value();
-        let password = self.pass_input.read(cx).value();
-
-        if value.starts_with("bunker://") {
-            self.login_with_bunker(&value, window, cx);
-            return;
-        }
-
-        if value.starts_with("ncryptsec1") {
-            self.login_with_password(&value, &password, window, cx);
-            return;
-        }
-
-        if let Ok(secret) = SecretKey::parse(&value) {
-            let keys = Keys::new(secret);
-            let nostr = NostrRegistry::global(cx);
-            // Update the signer
-            nostr.update(cx, |this, cx| {
-                this.set_signer(keys, true, cx);
-            });
-            // Close the current panel after setting the signer
-            window.dispatch_action(Box::new(ClosePanel), cx);
-        } else {
-            self.set_error("Invalid", cx);
-        }
-    }
-
-    fn login_with_bunker(&mut self, content: &str, window: &mut Window, cx: &mut Context<Self>) {
-        let Ok(uri) = NostrConnectUri::parse(content) else {
-            self.set_error("Bunker is not valid", cx);
-            return;
-        };
-
-        let nostr = NostrRegistry::global(cx);
-        let weak_state = nostr.downgrade();
-
-        let app_keys = nostr.read(cx).app_keys();
-        let timeout = Duration::from_secs(30);
-        let mut signer = NostrConnect::new(uri, app_keys.clone(), timeout, None).unwrap();
-
-        // Handle auth url with the default browser
-        signer.auth_url_handler(CoopAuthUrlHandler);
-
-        // Start countdown
-        cx.spawn_in(window, async move |this, cx| {
-            for i in (0..=30).rev() {
-                if i == 0 {
-                    this.update(cx, |this, cx| {
-                        this.set_countdown(None, cx);
-                    })
-                    .ok();
-                } else {
-                    this.update(cx, |this, cx| {
-                        this.set_countdown(Some(i), cx);
-                    })
-                    .ok();
-                }
-                cx.background_executor().timer(Duration::from_secs(1)).await;
-            }
-        })
-        .detach();
-
-        // Handle connection
-        cx.spawn_in(window, async move |_this, cx| {
-            let result = signer.bunker_uri().await;
-
-            weak_state
-                .update_in(cx, |this, window, cx| {
-                    match result {
-                        Ok(uri) => {
-                            this.persist_bunker(uri, cx);
-                            this.set_signer(signer, true, cx);
-                            // Close the current panel after setting the signer
-                            window.dispatch_action(Box::new(ClosePanel), cx);
-                        }
-                        Err(e) => {
-                            window.push_notification(Notification::error(e.to_string()), cx);
-                        }
-                    };
-                })
-                .ok();
-        })
-        .detach();
-    }
-
-    pub fn login_with_password(
-        &mut self,
-        content: &str,
-        pwd: &str,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if pwd.is_empty() {
-            self.set_error("Password is required", cx);
-            return;
-        }
-
-        let Ok(enc) = EncryptedSecretKey::from_bech32(content) else {
-            self.set_error("Secret Key is invalid", cx);
-            return;
-        };
-
-        let password = pwd.to_owned();
-
-        // Decrypt in the background to ensure it doesn't block the UI
-        let task = cx.background_spawn(async move {
-            if let Ok(content) = enc.decrypt(&password) {
-                Ok(Keys::new(content))
-            } else {
-                Err(anyhow!("Invalid password"))
-            }
-        });
-
-        cx.spawn_in(window, async move |this, cx| {
-            let result = task.await;
-
-            this.update_in(cx, |this, window, cx| {
-                match result {
-                    Ok(keys) => {
-                        let nostr = NostrRegistry::global(cx);
-                        // Update the signer
-                        nostr.update(cx, |this, cx| {
-                            this.set_signer(keys, true, cx);
-                        });
-                        // Close the current panel after setting the signer
-                        window.dispatch_action(Box::new(ClosePanel), cx);
-                    }
-                    Err(e) => {
-                        this.set_error(e.to_string(), cx);
-                    }
-                };
-            })
-            .ok();
-        })
-        .detach();
-    }
-
-    fn set_error<S>(&mut self, message: S, cx: &mut Context<Self>)
-    where
-        S: Into<SharedString>,
-    {
-        // Reset the log in state
-        self.set_logging_in(false, cx);
-
-        // Reset the countdown
-        self.set_countdown(None, cx);
-
-        // Update error message
-        self.error.update(cx, |this, cx| {
-            *this = Some(message.into());
-            cx.notify();
-        });
-
-        // Clear the error message after 3 secs
-        cx.spawn(async move |this, cx| {
-            cx.background_executor().timer(Duration::from_secs(3)).await;
-
-            this.update(cx, |this, cx| {
-                this.error.update(cx, |this, cx| {
-                    *this = None;
-                    cx.notify();
-                });
-            })
-            .ok();
-        })
-        .detach();
-    }
-
-    fn set_logging_in(&mut self, status: bool, cx: &mut Context<Self>) {
-        self.logging_in = status;
-        cx.notify();
-    }
-
-    fn set_countdown(&mut self, i: Option<u64>, cx: &mut Context<Self>) {
-        self.countdown.update(cx, |this, cx| {
-            *this = i;
-            cx.notify();
-        });
-    }
-}
-
-impl Panel for ImportPanel {
-    fn panel_id(&self) -> SharedString {
-        self.name.clone()
-    }
-
-    fn title(&self, _cx: &App) -> AnyElement {
-        self.name.clone().into_any_element()
-    }
-}
-
-impl EventEmitter<PanelEvent> for ImportPanel {}
-
-impl Focusable for ImportPanel {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Render for ImportPanel {
-    fn render(&mut self, _window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const SECRET_WARN: &str = "* Coop doesn't store your secret key. \
-            It will be cleared when you close the app. \
-            To persist your identity, please connect via Nostr Connect.";
-
-        v_flex()
-            .size_full()
-            .items_center()
-            .justify_center()
-            .p_2()
-            .gap_10()
-            .child(
-                div()
-                    .text_center()
-                    .font_semibold()
-                    .line_height(relative(1.25))
-                    .child(SharedString::from("Import a Secret Key or Bunker")),
-            )
-            .child(
-                v_flex()
-                    .w_112()
-                    .gap_2()
-                    .text_sm()
-                    .child(
-                        v_flex()
-                            .gap_1()
-                            .text_sm()
-                            .text_color(cx.theme().text_muted)
-                            .child("nsec or bunker://")
-                            .child(TextInput::new(&self.key_input)),
-                    )
-                    .when(
-                        self.key_input.read(cx).value().starts_with("ncryptsec1"),
-                        |this| {
-                            this.child(
-                                v_flex()
-                                    .gap_1()
-                                    .text_sm()
-                                    .text_color(cx.theme().text_muted)
-                                    .child("Password:")
-                                    .child(TextInput::new(&self.pass_input)),
-                            )
-                        },
-                    )
-                    .child(
-                        Button::new("login")
-                            .label("Continue")
-                            .primary()
-                            .loading(self.logging_in)
-                            .disabled(self.logging_in)
-                            .on_click(cx.listener(move |this, _, window, cx| {
-                                this.login(window, cx);
-                            })),
-                    )
-                    .when_some(self.countdown.read(cx).as_ref(), |this, i| {
-                        this.child(
-                            div()
-                                .text_xs()
-                                .text_center()
-                                .text_color(cx.theme().text_muted)
-                                .child(SharedString::from(format!(
-                                    "Approve connection request from your signer in {} seconds",
-                                    i
-                                ))),
-                        )
-                    })
-                    .when_some(self.error.read(cx).as_ref(), |this, error| {
-                        this.child(
-                            div()
-                                .text_xs()
-                                .text_center()
-                                .text_color(cx.theme().danger_foreground)
-                                .child(error.clone()),
-                        )
-                    })
-                    .child(
-                        div()
-                            .mt_2()
-                            .italic()
-                            .text_xs()
-                            .text_color(cx.theme().text_muted)
-                            .child(SharedString::from(SECRET_WARN)),
-                    ),
-            )
-    }
-}

crates/coop/src/panels/relay_list.rs

@@ -1,365 +0,0 @@
-use std::collections::HashSet;
-use std::time::Duration;
-
-use anyhow::{anyhow, Context as AnyhowContext, Error};
-use dock::panel::{Panel, PanelEvent};
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, relative, uniform_list, AnyElement, App, AppContext, Context, Entity, EventEmitter,
-    FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement, Render, SharedString,
-    Styled, Subscription, Task, TextAlign, UniformList, Window,
-};
-use nostr_sdk::prelude::*;
-use smallvec::{smallvec, SmallVec};
-use state::{NostrRegistry, BOOTSTRAP_RELAYS};
-use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
-use ui::input::{InputEvent, InputState, TextInput};
-use ui::{divider, h_flex, v_flex, IconName, Sizable, StyledExt};
-
-pub fn init(window: &mut Window, cx: &mut App) -> Entity<RelayListPanel> {
-    cx.new(|cx| RelayListPanel::new(window, cx))
-}
-
-#[derive(Debug)]
-pub struct RelayListPanel {
-    name: SharedString,
-    focus_handle: FocusHandle,
-
-    /// Relay URL input
-    input: Entity<InputState>,
-
-    /// Relay metadata input
-    metadata: Entity<Option<RelayMetadata>>,
-
-    /// Error message
-    error: Option<SharedString>,
-
-    // All relays
-    relays: HashSet<(RelayUrl, Option<RelayMetadata>)>,
-
-    // Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
-
-    // Background tasks
-    _tasks: SmallVec<[Task<()>; 1]>,
-}
-
-impl RelayListPanel {
-    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let input = cx.new(|cx| InputState::new(window, cx).placeholder("wss://example.com"));
-        let metadata = cx.new(|_| None);
-
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        let mut subscriptions = smallvec![];
-        let mut tasks = smallvec![];
-
-        tasks.push(
-            // Load user's relays in the local database
-            cx.spawn_in(window, async move |this, cx| {
-                let result = cx
-                    .background_spawn(async move { Self::load(&client).await })
-                    .await;
-
-                if let Ok(relays) = result {
-                    this.update(cx, |this, cx| {
-                        this.relays.extend(relays);
-                        cx.notify();
-                    })
-                    .ok();
-                }
-            }),
-        );
-
-        subscriptions.push(
-            // Subscribe to user's input events
-            cx.subscribe_in(&input, window, move |this, _input, event, window, cx| {
-                if let InputEvent::PressEnter { .. } = event {
-                    this.add(window, cx);
-                }
-            }),
-        );
-
-        Self {
-            name: "Update Relay List".into(),
-            focus_handle: cx.focus_handle(),
-            input,
-            metadata,
-            relays: HashSet::new(),
-            error: None,
-            _subscriptions: subscriptions,
-            _tasks: tasks,
-        }
-    }
-
-    async fn load(client: &Client) -> Result<Vec<(RelayUrl, Option<RelayMetadata>)>, Error> {
-        let signer = client.signer().context("Signer not found")?;
-        let public_key = signer.get_public_key().await?;
-
-        let filter = Filter::new()
-            .kind(Kind::RelayList)
-            .author(public_key)
-            .limit(1);
-
-        if let Some(event) = client.database().query(filter).await?.first_owned() {
-            Ok(nip65::extract_owned_relay_list(event).collect())
-        } else {
-            Err(anyhow!("Not found."))
-        }
-    }
-
-    fn add(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let value = self.input.read(cx).value().to_string();
-        let metadata = self.metadata.read(cx);
-
-        if !value.starts_with("ws") {
-            self.set_error("Relay URl is invalid", window, cx);
-            return;
-        }
-
-        if let Ok(url) = RelayUrl::parse(&value) {
-            if !self.relays.insert((url, metadata.to_owned())) {
-                self.input.update(cx, |this, cx| {
-                    this.set_value("", window, cx);
-                });
-                cx.notify();
-            }
-        } else {
-            self.set_error("Relay URl is invalid", window, cx);
-        }
-    }
-
-    fn remove(&mut self, url: &RelayUrl, cx: &mut Context<Self>) {
-        self.relays.retain(|(relay, _)| relay != url);
-        cx.notify();
-    }
-
-    fn set_error<E>(&mut self, error: E, window: &mut Window, cx: &mut Context<Self>)
-    where
-        E: Into<SharedString>,
-    {
-        self.error = Some(error.into());
-        cx.notify();
-
-        cx.spawn_in(window, async move |this, cx| {
-            cx.background_executor().timer(Duration::from_secs(2)).await;
-            // Clear the error message after a delay
-            this.update(cx, |this, cx| {
-                this.error = None;
-                cx.notify();
-            })
-            .ok();
-        })
-        .detach();
-    }
-
-    pub fn set_relays(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        if self.relays.is_empty() {
-            self.set_error("You need to add at least 1 relay", window, cx);
-            return;
-        };
-
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-        let relays = self.relays.clone();
-
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let builder = EventBuilder::relay_list(relays);
-            let event = client.sign_event_builder(builder).await?;
-
-            // Set relay list for current user
-            client.send_event(&event).to(BOOTSTRAP_RELAYS).await?;
-
-            Ok(())
-        });
-
-        cx.spawn_in(window, async move |this, cx| {
-            match task.await {
-                Ok(_) => {
-                    // TODO
-                }
-                Err(e) => {
-                    this.update_in(cx, |this, window, cx| {
-                        this.set_error(e.to_string(), window, cx);
-                    })
-                    .ok();
-                }
-            };
-        })
-        .detach();
-    }
-
-    fn render_list(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> UniformList {
-        let relays = self.relays.clone();
-        let total = relays.len();
-
-        uniform_list(
-            "relays",
-            total,
-            cx.processor(move |_v, range, _window, cx| {
-                let mut items = Vec::new();
-
-                for ix in range {
-                    let Some((url, metadata)) = relays.iter().nth(ix) else {
-                        continue;
-                    };
-
-                    items.push(
-                        div()
-                            .id(SharedString::from(url.to_string()))
-                            .group("")
-                            .w_full()
-                            .h_9()
-                            .py_0p5()
-                            .child(
-                                h_flex()
-                                    .px_2()
-                                    .flex()
-                                    .justify_between()
-                                    .rounded(cx.theme().radius)
-                                    .bg(cx.theme().elevated_surface_background)
-                                    .child(
-                                        div().text_sm().child(SharedString::from(url.to_string())),
-                                    )
-                                    .child(
-                                        h_flex()
-                                            .gap_1()
-                                            .text_xs()
-                                            .map(|this| {
-                                                if let Some(metadata) = metadata {
-                                                    this.child(SharedString::from(
-                                                        metadata.to_string(),
-                                                    ))
-                                                } else {
-                                                    this.child(SharedString::from("Read+Write"))
-                                                }
-                                            })
-                                            .child(
-                                                Button::new("remove_{ix}")
-                                                    .icon(IconName::Close)
-                                                    .xsmall()
-                                                    .ghost()
-                                                    .invisible()
-                                                    .group_hover("", |this| this.visible())
-                                                    .on_click({
-                                                        let url = url.to_owned();
-                                                        cx.listener(
-                                                            move |this, _ev, _window, cx| {
-                                                                this.remove(&url, cx);
-                                                            },
-                                                        )
-                                                    }),
-                                            ),
-                                    ),
-                            ),
-                    )
-                }
-
-                items
-            }),
-        )
-        .h_full()
-    }
-
-    fn render_empty(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        h_flex()
-            .mt_2()
-            .h_20()
-            .justify_center()
-            .border_2()
-            .border_dashed()
-            .border_color(cx.theme().border)
-            .rounded(cx.theme().radius_lg)
-            .text_sm()
-            .text_align(TextAlign::Center)
-            .child(SharedString::from("Please add some relays."))
-    }
-}
-
-impl Panel for RelayListPanel {
-    fn panel_id(&self) -> SharedString {
-        self.name.clone()
-    }
-
-    fn title(&self, _cx: &App) -> AnyElement {
-        self.name.clone().into_any_element()
-    }
-}
-
-impl EventEmitter<PanelEvent> for RelayListPanel {}
-
-impl Focusable for RelayListPanel {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Render for RelayListPanel {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex()
-            .size_full()
-            .items_center()
-            .justify_center()
-            .p_2()
-            .gap_10()
-            .child(
-                div()
-                    .text_center()
-                    .font_semibold()
-                    .line_height(relative(1.25))
-                    .child(SharedString::from("Update Relay List")),
-            )
-            .child(
-                v_flex()
-                    .w_112()
-                    .gap_2()
-                    .text_sm()
-                    .child(
-                        v_flex()
-                            .gap_1p5()
-                            .child(
-                                h_flex()
-                                    .gap_1()
-                                    .w_full()
-                                    .child(TextInput::new(&self.input).small())
-                                    .child(
-                                        Button::new("add")
-                                            .icon(IconName::Plus)
-                                            .label("Add")
-                                            .ghost()
-                                            .on_click(cx.listener(move |this, _, window, cx| {
-                                                this.add(window, cx);
-                                            })),
-                                    ),
-                            )
-                            .when_some(self.error.as_ref(), |this, error| {
-                                this.child(
-                                    div()
-                                        .italic()
-                                        .text_xs()
-                                        .text_color(cx.theme().danger_foreground)
-                                        .child(error.clone()),
-                                )
-                            }),
-                    )
-                    .map(|this| {
-                        if !self.relays.is_empty() {
-                            this.child(self.render_list(window, cx))
-                        } else {
-                            this.child(self.render_empty(window, cx))
-                        }
-                    })
-                    .child(divider(cx))
-                    .child(
-                        Button::new("submit")
-                            .label("Update")
-                            .primary()
-                            .on_click(cx.listener(move |this, _ev, window, cx| {
-                                this.set_relays(window, cx);
-                            })),
-                    ),
-            )
-    }
-}

crates/coop/src/workspace.rs

@@ -1,290 +0,0 @@
-use std::sync::Arc;
-
-use chat::{ChatEvent, ChatRegistry};
-use dock::dock::DockPlacement;
-use dock::panel::{PanelStyle, PanelView};
-use dock::{ClosePanel, DockArea, DockItem};
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, rems, App, AppContext, Axis, Context, Entity, InteractiveElement, IntoElement,
-    ParentElement, Render, SharedString, Styled, Subscription, Window,
-};
-use person::PersonRegistry;
-use smallvec::{smallvec, SmallVec};
-use state::{NostrRegistry, RelayState};
-use theme::{ActiveTheme, SIDEBAR_WIDTH, TITLEBAR_HEIGHT};
-use titlebar::TitleBar;
-use ui::avatar::Avatar;
-use ui::button::{Button, ButtonVariants};
-use ui::menu::DropdownMenu;
-use ui::{h_flex, v_flex, Root, Sizable, WindowExtension};
-
-use crate::panels::greeter;
-use crate::sidebar;
-
-pub fn init(window: &mut Window, cx: &mut App) -> Entity<Workspace> {
-    cx.new(|cx| Workspace::new(window, cx))
-}
-
-pub struct Workspace {
-    /// App's Title Bar
-    titlebar: Entity<TitleBar>,
-
-    /// App's Dock Area
-    dock: Entity<DockArea>,
-
-    /// Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 3]>,
-}
-
-impl Workspace {
-    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let chat = ChatRegistry::global(cx);
-        let titlebar = cx.new(|_| TitleBar::new());
-        let dock = cx.new(|cx| DockArea::new(window, cx).style(PanelStyle::TabBar));
-
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Observe all events emitted by the chat registry
-            cx.subscribe_in(&chat, window, move |this, chat, ev, window, cx| {
-                match ev {
-                    ChatEvent::OpenRoom(id) => {
-                        if let Some(room) = chat.read(cx).room(id, cx) {
-                            this.dock.update(cx, |this, cx| {
-                                this.add_panel(
-                                    Arc::new(chat_ui::init(room, window, cx)),
-                                    DockPlacement::Center,
-                                    window,
-                                    cx,
-                                );
-                            });
-                        }
-                    }
-                    ChatEvent::CloseRoom(..) => {
-                        this.dock.update(cx, |this, cx| {
-                            // Force focus to the tab panel
-                            this.focus_tab_panel(window, cx);
-
-                            // Dispatch the close panel action
-                            cx.defer_in(window, |_, window, cx| {
-                                window.dispatch_action(Box::new(ClosePanel), cx);
-                                window.close_all_modals(cx);
-                            });
-                        });
-                    }
-                    _ => {}
-                };
-            }),
-        );
-
-        subscriptions.push(
-            // Observe the chat registry
-            cx.observe(&chat, move |this, chat, cx| {
-                let ids = this.panel_ids(cx);
-
-                chat.update(cx, |this, cx| {
-                    this.refresh_rooms(ids, cx);
-                });
-            }),
-        );
-
-        // Set the default layout for app's dock
-        cx.defer_in(window, |this, window, cx| {
-            this.set_layout(window, cx);
-        });
-
-        Self {
-            titlebar,
-            dock,
-            _subscriptions: subscriptions,
-        }
-    }
-
-    /// Add panel to the dock
-    pub fn add_panel<P>(panel: P, placement: DockPlacement, window: &mut Window, cx: &mut App)
-    where
-        P: PanelView,
-    {
-        if let Some(root) = window.root::<Root>().flatten() {
-            if let Ok(workspace) = root.read(cx).view().clone().downcast::<Self>() {
-                workspace.update(cx, |this, cx| {
-                    this.dock.update(cx, |this, cx| {
-                        this.add_panel(Arc::new(panel), placement, window, cx);
-                    });
-                });
-            }
-        }
-    }
-
-    /// Get all panel ids
-    fn panel_ids(&self, cx: &App) -> Option<Vec<u64>> {
-        let ids: Vec<u64> = self
-            .dock
-            .read(cx)
-            .items
-            .panel_ids(cx)
-            .into_iter()
-            .filter_map(|panel| panel.parse::<u64>().ok())
-            .collect();
-
-        Some(ids)
-    }
-
-    /// Set the dock layout
-    fn set_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let weak_dock = self.dock.downgrade();
-
-        // Sidebar
-        let left = DockItem::panel(Arc::new(sidebar::init(window, cx)));
-
-        // Main workspace
-        let center = DockItem::split_with_sizes(
-            Axis::Vertical,
-            vec![DockItem::tabs(
-                vec![Arc::new(greeter::init(window, cx))],
-                None,
-                &weak_dock,
-                window,
-                cx,
-            )],
-            vec![None],
-            &weak_dock,
-            window,
-            cx,
-        );
-
-        // Update the dock layout
-        self.dock.update(cx, |this, cx| {
-            this.set_left_dock(left, Some(SIDEBAR_WIDTH), true, window, cx);
-            this.set_center(center, window, cx);
-        });
-    }
-
-    fn titlebar_left(&mut self, _window: &mut Window, cx: &Context<Self>) -> impl IntoElement {
-        let nostr = NostrRegistry::global(cx);
-        let nip65 = nostr.read(cx).nip65_state();
-        let nip17 = nostr.read(cx).nip17_state();
-        let signer = nostr.read(cx).signer();
-        let current_user = signer.public_key();
-
-        h_flex()
-            .h(TITLEBAR_HEIGHT)
-            .flex_shrink_0()
-            .justify_between()
-            .gap_2()
-            .when_some(current_user.as_ref(), |this, public_key| {
-                let persons = PersonRegistry::global(cx);
-                let profile = persons.read(cx).get(public_key, cx);
-
-                this.child(
-                    Button::new("current-user")
-                        .child(Avatar::new(profile.avatar()).size(rems(1.25)))
-                        .small()
-                        .caret()
-                        .compact()
-                        .transparent()
-                        .dropdown_menu(move |this, _window, _cx| {
-                            this.label(profile.name())
-                                .separator()
-                                .menu("Profile", Box::new(ClosePanel))
-                                .menu("Backup", Box::new(ClosePanel))
-                                .menu("Themes", Box::new(ClosePanel))
-                                .menu("Settings", Box::new(ClosePanel))
-                        }),
-                )
-            })
-            .when(nostr.read(cx).creating_signer(), |this| {
-                this.child(div().text_xs().text_color(cx.theme().text_muted).child(
-                    SharedString::from("Coop is creating a new identity for you..."),
-                ))
-            })
-            .when(!nostr.read(cx).connected(), |this| {
-                this.child(
-                    div()
-                        .text_xs()
-                        .text_color(cx.theme().text_muted)
-                        .child(SharedString::from("Connecting...")),
-                )
-            })
-            .map(|this| match nip65.read(cx) {
-                RelayState::Checking => this.child(
-                    div()
-                        .text_xs()
-                        .text_color(cx.theme().text_muted)
-                        .child(SharedString::from("Fetching user's relay list...")),
-                ),
-                RelayState::NotConfigured => this.child(
-                    h_flex()
-                        .h_6()
-                        .w_full()
-                        .px_1()
-                        .text_xs()
-                        .text_color(cx.theme().warning_foreground)
-                        .bg(cx.theme().warning_background)
-                        .rounded_sm()
-                        .child(SharedString::from("User hasn't configured a relay list")),
-                ),
-                _ => this,
-            })
-            .map(|this| match nip17.read(cx) {
-                RelayState::Checking => {
-                    this.child(div().text_xs().text_color(cx.theme().text_muted).child(
-                        SharedString::from("Fetching user's messaging relay list..."),
-                    ))
-                }
-                RelayState::NotConfigured => this.child(
-                    h_flex()
-                        .h_6()
-                        .w_full()
-                        .px_1()
-                        .text_xs()
-                        .text_color(cx.theme().warning_foreground)
-                        .bg(cx.theme().warning_background)
-                        .rounded_sm()
-                        .child(SharedString::from(
-                            "User hasn't configured a messaging relay list",
-                        )),
-                ),
-                _ => this,
-            })
-    }
-
-    fn titlebar_right(&mut self, _window: &mut Window, _cx: &Context<Self>) -> impl IntoElement {
-        h_flex().h(TITLEBAR_HEIGHT).flex_shrink_0()
-    }
-}
-
-impl Render for Workspace {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let modal_layer = Root::render_modal_layer(window, cx);
-        let notification_layer = Root::render_notification_layer(window, cx);
-
-        // Titlebar elements
-        let left = self.titlebar_left(window, cx).into_any_element();
-        let right = self.titlebar_right(window, cx).into_any_element();
-
-        // Update title bar children
-        self.titlebar.update(cx, |this, _cx| {
-            this.set_children(vec![left, right]);
-        });
-
-        div()
-            .id(SharedString::from("workspace"))
-            .relative()
-            .size_full()
-            .child(
-                v_flex()
-                    .relative()
-                    .size_full()
-                    // Title Bar
-                    .child(self.titlebar.clone())
-                    // Dock
-                    .child(self.dock.clone()),
-            )
-            // Notifications
-            .children(notification_layer)
-            // Modals
-            .children(modal_layer)
-    }
-}

crates/device/Cargo.toml

@@ -7,6 +7,9 @@ publish.workspace = true
 [dependencies]
 common = { path = "../common" }
 state = { path = "../state" }
+person = { path = "../person" }
+ui = { path = "../ui" }
+theme = { path = "../theme" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true

crates/device/src/lib.rs

@@ -1,17 +1,26 @@
-use std::collections::{HashMap, HashSet};
+use std::cell::Cell;
+use std::collections::HashSet;
+use std::path::PathBuf;
+use std::rc::Rc;
 use std::time::Duration;
 
-use anyhow::{anyhow, Context as AnyhowContext, Error};
-use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task, Window};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
+use gpui::{
+    App, AppContext, Context, Entity, EventEmitter, Global, IntoElement, ParentElement,
+    SharedString, Styled, Subscription, Task, Window, div, relative,
+};
 use nostr_sdk::prelude::*;
-use smallvec::{smallvec, SmallVec};
-use state::{app_name, NostrRegistry, RelayState, DEVICE_GIFTWRAP, TIMEOUT};
-
-mod device;
-
-pub use device::*;
+use person::PersonRegistry;
+use state::{Announcement, CLIENT_NAME, NostrRegistry, StateEvent, TIMEOUT};
+use theme::ActiveTheme;
+use ui::avatar::Avatar;
+use ui::button::Button;
+use ui::notification::{Notification, NotificationKind};
+use ui::{Disableable, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 const IDENTIFIER: &str = "coop:device";
+const MSG: &str = "You've requested an encryption key from another device. \
+                   Approve to allow Coop to share with it.";
 
 pub fn init(window: &mut Window, cx: &mut App) {
     DeviceRegistry::set_global(cx.new(|cx| DeviceRegistry::new(window, cx)), cx);
@@ -21,24 +30,48 @@ struct GlobalDeviceRegistry(Entity<DeviceRegistry>);
 
 impl Global for GlobalDeviceRegistry {}
 
+/// Device event.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum DeviceEvent {
+    /// A new encryption signer has been set
+    Set,
+    /// The device is requesting an encryption key
+    Requesting,
+    /// The device is creating a new encryption key
+    Creating,
+    /// An error occurred
+    Error(SharedString),
+}
+
+impl DeviceEvent {
+    pub fn error<T>(error: T) -> Self
+    where
+        T: Into<SharedString>,
+    {
+        Self::Error(error.into())
+    }
+}
+
 /// Device Registry
 ///
 /// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
 #[derive(Debug)]
 pub struct DeviceRegistry {
-    /// Device state
-    state: DeviceState,
+    /// Whether the registry is currently initializing
+    pub initializing: bool,
 
-    /// Device requests
-    requests: Entity<HashSet<Event>>,
+    /// Whether there is a pending request for encryption key approval
+    pub pending_request: bool,
 
     /// Async tasks
     tasks: Vec<Task<Result<(), Error>>>,
 
-    /// Subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
+    /// Event subscription
+    _subscription: Option<Subscription>,
 }
 
+impl EventEmitter<DeviceEvent> for DeviceRegistry {}
+
 impl DeviceRegistry {
     /// Retrieve the global device registry state
     pub fn global(cx: &App) -> Entity<Self> {
@@ -53,54 +86,39 @@ impl DeviceRegistry {
     /// Create a new device registry instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
-        let nip65_state = nostr.read(cx).nip65_state();
 
-        // Construct an entity for encryption signer requests
-        let requests = cx.new(|_| HashSet::default());
+        // Subscribe to nostr state events
+        let subscription = cx.subscribe_in(&nostr, window, |this, _e, event, _window, cx| {
+            if event == &StateEvent::SignerSet {
+                this.set_initializing(true, cx);
+                this.get_announcement(cx);
+            };
+        });
 
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Observe the NIP-65 state
-            cx.observe(&nip65_state, |this, state, cx| {
-                match state.read(cx) {
-                    RelayState::Idle => {
-                        this.reset(cx);
-                    }
-                    RelayState::Configured(_) => {
-                        this.get_announcement(cx);
-                    }
-                    _ => {}
-                };
-            }),
-        );
-
-        cx.defer_in(window, |this, _window, cx| {
-            this.handle_notifications(cx);
+        cx.defer_in(window, |this, window, cx| {
+            this.handle_notifications(window, cx);
         });
 
         Self {
-            state: DeviceState::default(),
-            requests,
+            initializing: true,
+            pending_request: false,
             tasks: vec![],
-            _subscriptions: subscriptions,
+            _subscription: Some(subscription),
         }
     }
 
-    fn handle_notifications(&mut self, cx: &mut Context<Self>) {
+    fn handle_notifications(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let (tx, rx) = flume::bounded::<Event>(100);
 
-        cx.background_spawn(async move {
+        self.tasks.push(cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
 
             while let Some(notification) = notifications.next().await {
-                if let ClientNotification::Message {
-                    message: RelayMessage::Event { event, .. },
-                    ..
-                } = notification
+                if let ClientNotification::Message { message, .. } = notification
+                    && let RelayMessage::Event { event, .. } = *message
                 {
                     if !processed_events.insert(event.id) {
                         // Skip if the event has already been processed
@@ -110,56 +128,53 @@ impl DeviceRegistry {
                     match event.kind {
                         Kind::Custom(4454) => {
                             if verify_author(&client, event.as_ref()).await {
-                                tx.send_async(event.into_owned()).await.ok();
+                                tx.send_async(event.into_owned()).await?;
                             }
                         }
                         Kind::Custom(4455) => {
                             if verify_author(&client, event.as_ref()).await {
-                                tx.send_async(event.into_owned()).await.ok();
+                                tx.send_async(event.into_owned()).await?;
                             }
                         }
                         _ => {}
                     }
                 }
             }
-        })
-        .detach();
 
-        self.tasks.push(
-            // Update GPUI states
-            cx.spawn(async move |this, cx| {
-                while let Ok(event) = rx.recv_async().await {
-                    match event.kind {
-                        Kind::Custom(4454) => {
-                            this.update(cx, |this, cx| {
-                                this.add_request(event, cx);
-                            })?;
-                        }
-                        Kind::Custom(4455) => {
-                            this.update(cx, |this, cx| {
-                                this.parse_response(event, cx);
-                            })?;
-                        }
-                        _ => {}
+            Ok(())
+        }));
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            while let Ok(event) = rx.recv_async().await {
+                match event.kind {
+                    // New request event from other device
+                    Kind::Custom(4454) => {
+                        this.update_in(cx, |this, window, cx| {
+                            this.ask_for_approval(event, window, cx);
+                        })?;
                     }
+                    // New response event from the master device
+                    Kind::Custom(4455) => {
+                        this.update(cx, |this, cx| {
+                            this.extract_encryption(event, cx);
+                        })?;
+                    }
+                    _ => {}
                 }
-
-                Ok(())
-            }),
-        );
+            }
+            Ok(())
+        }));
     }
 
-    pub fn state(&self) -> &DeviceState {
-        &self.state
+    /// Set whether the registry is currently initializing
+    fn set_initializing(&mut self, initializing: bool, cx: &mut Context<Self>) {
+        self.initializing = initializing;
+        cx.notify();
     }
 
-    /// Reset the device state
-    pub fn reset(&mut self, cx: &mut Context<Self>) {
-        self.state = DeviceState::Initial;
-        self.requests.update(cx, |this, cx| {
-            this.clear();
-            cx.notify();
-        });
+    /// Set whether there is a pending request for encryption key approval
+    fn set_pending_request(&mut self, pending: bool, cx: &mut Context<Self>) {
+        self.pending_request = pending;
         cx.notify();
     }
 
@@ -176,62 +191,31 @@ impl DeviceRegistry {
 
             // Update state
             this.update(cx, |this, cx| {
-                this.set_state(DeviceState::Set, cx);
-                this.get_messages(cx);
+                this.set_initializing(false, cx);
+                cx.emit(DeviceEvent::Set);
             })?;
 
             Ok(())
         }));
     }
 
-    /// Continuously get gift wrap events for the current encryption keys
-    fn get_messages(&mut self, cx: &mut Context<Self>) {
+    /// Backup the encryption's secret key to a file
+    pub fn backup(&self, path: PathBuf, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
-        let messaging_relays = nostr.read(cx).messaging_relays(cx);
 
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let encryption_signer = signer
-                .get_encryption_signer()
-                .await
-                .context("Signer not found")?;
+        cx.background_spawn(async move {
+            let keys = get_keys(&client).await?;
+            let content = keys.secret_key().to_bech32()?;
 
-            let public_key = encryption_signer.get_public_key().await?;
-            let urls = messaging_relays.await;
-
-            let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
-            let id = SubscriptionId::new(DEVICE_GIFTWRAP);
-
-            // Construct target for subscription
-            let target: HashMap<&RelayUrl, Filter> =
-                urls.iter().map(|relay| (relay, filter.clone())).collect();
-
-            client.subscribe(target).with_id(id).await?;
-            log::info!("Subscribed to encryption gift-wrap messages");
+            smol::fs::write(path, &content).await?;
 
             Ok(())
-        });
-
-        task.detach();
-    }
-
-    /// Set the device state
-    fn set_state(&mut self, state: DeviceState, cx: &mut Context<Self>) {
-        self.state = state;
-        cx.notify();
-    }
-
-    /// Add a request for device keys
-    fn add_request(&mut self, request: Event, cx: &mut Context<Self>) {
-        self.requests.update(cx, |this, cx| {
-            this.insert(request);
-            cx.notify();
-        });
+        })
     }
 
     /// Get device announcement for current user
-    fn get_announcement(&mut self, cx: &mut Context<Self>) {
+    pub fn get_announcement(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
@@ -245,36 +229,33 @@ impl DeviceRegistry {
                 .author(public_key)
                 .limit(1);
 
+            // Stream events from user's write relays
             let mut stream = client
                 .stream_events(filter)
                 .timeout(Duration::from_secs(TIMEOUT))
                 .await?;
 
             while let Some((_url, res)) = stream.next().await {
-                match res {
-                    Ok(event) => {
-                        log::info!("Received device announcement event: {event:?}");
-                        return Ok(event);
-                    }
-                    Err(e) => {
-                        log::error!("Failed to receive device announcement event: {e}");
-                    }
+                if let Ok(event) = res {
+                    return Ok(event);
                 }
             }
 
-            Err(anyhow!("Device announcement not found"))
+            Err(anyhow!("Announcement not found"))
         });
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(event) => {
+                    // Set encryption key from the announcement event
                     this.update(cx, |this, cx| {
-                        this.init_device_signer(&event, cx);
+                        this.set_encryption(&event, cx);
                     })?;
                 }
                 Err(_) => {
+                    // User has no announcement, create a new one
                     this.update(cx, |this, cx| {
-                        this.announce_device(cx);
+                        this.set_announcement(Keys::generate(), cx);
                     })?;
                 }
             }
@@ -283,148 +264,134 @@ impl DeviceRegistry {
         }));
     }
 
-    /// Create a new device signer and announce it
-    fn announce_device(&mut self, cx: &mut Context<Self>) {
+    /// Create a new device signer and announce it to user's relay list
+    pub fn set_announcement(&mut self, keys: Keys, cx: &mut Context<Self>) {
+        let task = self.create_encryption(keys, cx);
+
+        // Notify that we're creating a new encryption key
+        cx.emit(DeviceEvent::Creating);
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(keys) => {
+                    this.update(cx, |this, cx| {
+                        this.set_signer(keys, cx);
+                        this.wait_for_request(cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(DeviceEvent::error(e.to_string()));
+                    })?;
+                }
+            }
+            Ok(())
+        }));
+    }
+
+    /// Create new encryption key and announce it to user's relay list
+    fn create_encryption(&self, keys: Keys, cx: &App) -> Task<Result<Keys, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        // Generate a new device keys
-        let keys = Keys::generate();
         let secret = keys.secret_key().to_secret_hex();
         let n = keys.public_key();
 
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+        cx.background_spawn(async move {
             // Construct an announcement event
             let builder = EventBuilder::new(Kind::Custom(10044), "").tags(vec![
                 Tag::custom(TagKind::custom("n"), vec![n]),
-                Tag::client(app_name()),
+                Tag::client(CLIENT_NAME),
             ]);
+
+            // Sign the event with user's signer
             let event = client.sign_event_builder(builder).await?;
 
             // Publish announcement
-            client.send_event(&event).to_nip65().await?;
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ack_policy(AckPolicy::none())
+                .await?;
 
             // Save device keys to the database
             set_keys(&client, &secret).await?;
 
-            Ok(())
-        });
-
-        cx.spawn(async move |this, cx| {
-            if task.await.is_ok() {
-                this.update(cx, |this, cx| {
-                    this.set_signer(keys, cx);
-                    this.listen_device_request(cx);
-                })
-                .ok();
-            }
+            Ok(keys)
         })
-        .detach();
     }
 
-    /// Initialize device signer (decoupled encryption key) for the current user
-    fn init_device_signer(&mut self, event: &Event, cx: &mut Context<Self>) {
+    /// Set encryption key from the announcement event
+    fn set_encryption(&mut self, event: &Event, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
         let announcement = Announcement::from(event);
         let device_pubkey = announcement.public_key();
 
+        // Get encryption key from the database and compare with the announcement
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
-            if let Ok(keys) = get_keys(&client).await {
-                if keys.public_key() != device_pubkey {
-                    return Err(anyhow!("Key mismatch"));
-                };
+            let keys = get_keys(&client).await?;
 
-                Ok(keys)
-            } else {
-                Err(anyhow!("Key not found"))
-            }
+            // Compare the public key from the announcement with the one from the database
+            if keys.public_key() != device_pubkey {
+                return Err(anyhow!("Encryption Key doesn't match the announcement"));
+            };
+
+            Ok(keys)
         });
 
-        cx.spawn(async move |this, cx| {
-            match task.await {
-                Ok(keys) => {
-                    this.update(cx, |this, cx| {
-                        this.set_signer(keys, cx);
-                        this.listen_device_request(cx);
-                    })
-                    .ok();
-                }
-                Err(e) => {
-                    this.update(cx, |this, cx| {
-                        this.request_device_keys(cx);
-                        this.listen_device_approval(cx);
-                    })
-                    .ok();
-
-                    log::warn!("Failed to initialize device signer: {e}");
-                }
-            };
-        })
-        .detach();
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            if let Ok(keys) = task.await {
+                this.update(cx, |this, cx| {
+                    this.set_signer(keys, cx);
+                    this.wait_for_request(cx);
+                })?;
+            } else {
+                this.update(cx, |this, cx| {
+                    this.request(cx);
+                })?;
+            }
+            Ok(())
+        }));
     }
 
-    /// Listen for device key requests on user's write relays
-    fn listen_device_request(&mut self, cx: &mut Context<Self>) {
+    /// Wait for encryption key requests from now on
+    fn wait_for_request(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
 
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
+        self.tasks.push(cx.background_spawn(async move {
             let public_key = signer.get_public_key().await?;
+            let id = SubscriptionId::new("dekey-requests");
 
-            // Construct a filter for device key requests
+            // Construct a filter for encryption key requests
             let filter = Filter::new()
                 .kind(Kind::Custom(4454))
                 .author(public_key)
                 .since(Timestamp::now());
 
             // Subscribe to the device key requests on user's write relays
-            client.subscribe(filter).await?;
+            client.subscribe(vec![filter]).with_id(id).await?;
 
             Ok(())
-        });
-
-        task.detach();
-    }
-
-    /// Listen for device key approvals on user's write relays
-    fn listen_device_approval(&mut self, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        let client = nostr.read(cx).client();
-
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
-            let public_key = signer.get_public_key().await?;
-
-            // Construct a filter for device key requests
-            let filter = Filter::new()
-                .kind(Kind::Custom(4455))
-                .author(public_key)
-                .since(Timestamp::now());
-
-            // Subscribe to the device key requests on user's write relays
-            client.subscribe(filter).await?;
-
-            Ok(())
-        });
-
-        task.detach();
+        }));
     }
 
     /// Request encryption keys from other device
-    fn request_device_keys(&mut self, cx: &mut Context<Self>) {
+    pub 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();
 
-        let app_keys = nostr.read(cx).app_keys().clone();
+        let app_keys = nostr.read(cx).keys();
         let app_pubkey = app_keys.public_key();
 
-        let task: Task<Result<Option<Keys>, Error>> = cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
+        let task: Task<Result<Option<Event>, Error>> = cx.background_spawn(async move {
             let public_key = signer.get_public_key().await?;
 
+            // Construct a filter to get the latest approval event
             let filter = Filter::new()
                 .kind(Kind::Custom(4455))
                 .author(public_key)
@@ -432,28 +399,17 @@ impl DeviceRegistry {
                 .limit(1);
 
             match client.database().query(filter).await?.first_owned() {
-                Some(event) => {
-                    let root_device = event
-                        .tags
-                        .find(TagKind::custom("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(&root_device, payload).await?;
-
-                    let secret = SecretKey::from_hex(&decrypted)?;
-                    let keys = Keys::new(secret);
-
-                    Ok(Some(keys))
-                }
+                // 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 builder = EventBuilder::new(Kind::Custom(4454), "").tags(vec![
-                        Tag::client(app_name()),
                         Tag::custom(TagKind::custom("P"), vec![app_pubkey]),
+                        Tag::client(CLIENT_NAME),
                     ]);
+
+                    // Sign the event with user's signer
                     let event = client.sign_event_builder(builder).await?;
 
                     // Send the event to write relays
@@ -464,35 +420,60 @@ impl DeviceRegistry {
             }
         });
 
-        cx.spawn(async move |this, cx| {
+        self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
-                Ok(Some(keys)) => {
+                Ok(Some(event)) => {
                     this.update(cx, |this, cx| {
-                        this.set_signer(keys, cx);
-                    })
-                    .ok();
+                        this.extract_encryption(event, cx);
+                    })?;
                 }
                 Ok(None) => {
                     this.update(cx, |this, cx| {
-                        this.set_state(DeviceState::Requesting, cx);
-                    })
-                    .ok();
+                        this.set_initializing(false, cx);
+                        this.wait_for_approval(cx);
+
+                        cx.emit(DeviceEvent::Requesting);
+                    })?;
                 }
                 Err(e) => {
-                    log::error!("Failed to request the encryption key: {e}");
+                    this.update(cx, |_this, cx| {
+                        cx.emit(DeviceEvent::error(e.to_string()));
+                    })?;
                 }
             };
-        })
-        .detach();
+            Ok(())
+        }));
     }
 
-    /// Parse the response event for device keys from other devices
-    fn parse_response(&mut self, event: Event, cx: &mut Context<Self>) {
+    /// Wait for encryption key approvals
+    fn wait_for_approval(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
-        let app_keys = nostr.read(cx).app_keys().clone();
+        let client = nostr.read(cx).client();
+        let signer = nostr.read(cx).signer();
+
+        self.tasks.push(cx.background_spawn(async move {
+            let public_key = signer.get_public_key().await?;
+
+            // Construct a filter for device key requests
+            let filter = Filter::new()
+                .kind(Kind::Custom(4455))
+                .author(public_key)
+                .since(Timestamp::now());
+
+            // Subscribe to the device key requests on user's write relays
+            client.subscribe(filter).await?;
+
+            Ok(())
+        }));
+    }
+
+    /// Parse the approval event to get encryption key then set it
+    fn extract_encryption(&mut self, event: Event, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let app_keys = nostr.read(cx).keys();
 
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
-            let root_device = event
+            let master = event
                 .tags
                 .find(TagKind::custom("P"))
                 .and_then(|tag| tag.content())
@@ -500,7 +481,7 @@ impl DeviceRegistry {
                 .context("Invalid event's tags")?;
 
             let payload = event.content.as_str();
-            let decrypted = app_keys.nip44_decrypt(&root_device, payload).await?;
+            let decrypted = app_keys.nip44_decrypt(&master, payload).await?;
 
             let secret = SecretKey::from_hex(&decrypted)?;
             let keys = Keys::new(secret);
@@ -508,31 +489,33 @@ impl DeviceRegistry {
             Ok(keys)
         });
 
-        cx.spawn(async move |this, cx| {
+        self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(keys) => {
                     this.update(cx, |this, cx| {
                         this.set_signer(keys, cx);
-                    })
-                    .ok();
+                    })?;
                 }
                 Err(e) => {
-                    log::error!("Error: {e}")
+                    this.update(cx, |_this, cx| {
+                        cx.emit(DeviceEvent::error(e.to_string()));
+                    })?;
                 }
-            };
-        })
-        .detach();
+            }
+            Ok(())
+        }));
     }
 
     /// Approve requests for device keys from other devices
-    #[allow(dead_code)]
-    fn approve(&mut self, event: Event, cx: &mut Context<Self>) {
+    fn approve(&mut self, event: &Event, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let signer = client.signer().context("Signer not found")?;
+        // Get user's write relays
+        let event = event.clone();
+        let id: SharedString = event.id.to_hex().into();
 
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             // Get device keys
             let keys = get_keys(&client).await?;
             let secret = keys.secret_key().to_secret_hex();
@@ -546,16 +529,18 @@ impl DeviceRegistry {
                 .context("Target is not a valid public key")?;
 
             // Encrypt the device keys with the user's signer
-            let payload = signer.nip44_encrypt(&target, &secret).await?;
+            let payload = keys.nip44_encrypt(&target, &secret).await?;
 
             // Construct the response event
             //
             // P tag: the current device's public key
             // p tag: the requester's public key
             let builder = EventBuilder::new(Kind::Custom(4455), payload).tags(vec![
-                Tag::custom(TagKind::custom("P"), vec![keys.public_key()]),
+                Tag::custom(TagKind::custom("P"), vec![keys.public_key().to_hex()]),
                 Tag::public_key(target),
             ]);
+
+            // Sign the builder
             let event = client.sign_event_builder(builder).await?;
 
             // Send the response event to the user's relay list
@@ -564,16 +549,151 @@ impl DeviceRegistry {
             Ok(())
         });
 
-        task.detach();
+        cx.spawn_in(window, async move |_this, cx| {
+            match task.await {
+                Ok(_) => {
+                    cx.update(|window, cx| {
+                        window.clear_notification_by_id::<DeviceNotification>(id, cx);
+                    })
+                    .ok();
+                }
+                Err(e) => {
+                    cx.update(|window, cx| {
+                        window.push_notification(
+                            Notification::error(e.to_string()).autohide(false),
+                            cx,
+                        );
+                    })
+                    .ok();
+                }
+            };
+        })
+        .detach();
+    }
+
+    /// Handle encryption request
+    fn ask_for_approval(&mut self, event: Event, window: &mut Window, 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);
+    }
+
+    /// Build a notification for the encryption request.
+    fn notification(&self, event: Event, cx: &Context<Self>) -> Notification {
+        let request = Announcement::from(&event);
+        let persons = PersonRegistry::global(cx);
+        let profile = persons.read(cx).get(&request.public_key(), cx);
+
+        let entity = cx.entity().downgrade();
+        let loading = Rc::new(Cell::new(false));
+        let key = SharedString::from(event.id.to_hex());
+
+        Notification::new()
+            .type_id::<DeviceNotification>(key)
+            .autohide(false)
+            .with_kind(NotificationKind::Info)
+            .title("Encryption Key Request")
+            .content(move |_this, _window, cx| {
+                v_flex()
+                    .gap_2()
+                    .text_sm()
+                    .child(
+                        div()
+                            .text_sm()
+                            .line_height(relative(1.25))
+                            .child(SharedString::from(MSG)),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_2()
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .text_sm()
+                                    .child(
+                                        div()
+                                            .font_semibold()
+                                            .text_xs()
+                                            .text_color(cx.theme().text_muted)
+                                            .child(SharedString::from("From:")),
+                                    )
+                                    .child(
+                                        div()
+                                            .h_8()
+                                            .w_full()
+                                            .px_2()
+                                            .rounded(cx.theme().radius)
+                                            .bg(cx.theme().elevated_surface_background)
+                                            .child(
+                                                h_flex()
+                                                    .gap_2()
+                                                    .child(Avatar::new(profile.avatar()).xsmall())
+                                                    .child(profile.name()),
+                                            ),
+                                    ),
+                            )
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .text_sm()
+                                    .child(
+                                        div()
+                                            .font_semibold()
+                                            .text_xs()
+                                            .text_color(cx.theme().text_muted)
+                                            .child(SharedString::from("Client:")),
+                                    )
+                                    .child(
+                                        div()
+                                            .h_8()
+                                            .w_full()
+                                            .px_2()
+                                            .rounded(cx.theme().radius)
+                                            .bg(cx.theme().elevated_surface_background)
+                                            .child(request.client_name()),
+                                    ),
+                            ),
+                    )
+                    .into_any_element()
+            })
+            .action(move |_this, _window, _cx| {
+                let view = entity.clone();
+                let event = event.clone();
+
+                Button::new("approve")
+                    .label("Approve")
+                    .loading(loading.get())
+                    .disabled(loading.get())
+                    .on_click({
+                        let loading = Rc::clone(&loading);
+                        move |_ev, window, cx| {
+                            // Set loading state to true
+                            loading.set(true);
+                            // Process to approve the request
+                            view.update(cx, |this, cx| {
+                                this.approve(&event, window, cx);
+                            })
+                            .ok();
+                        }
+                    })
+            })
     }
 }
 
+struct DeviceNotification;
+
 /// Verify the author of an event
 async fn verify_author(client: &Client, event: &Event) -> bool {
-    if let Some(signer) = client.signer() {
-        if let Ok(public_key) = signer.get_public_key().await {
-            return public_key == event.pubkey;
-        }
+    if let Some(signer) = client.signer()
+        && let Ok(public_key) = signer.get_public_key().await
+    {
+        return public_key == event.pubkey;
     }
     false
 }
@@ -607,8 +727,7 @@ async fn get_keys(client: &Client) -> Result<Keys, Error> {
     let filter = Filter::new()
         .kind(Kind::ApplicationSpecificData)
         .identifier(IDENTIFIER)
-        .author(public_key)
-        .limit(1);
+        .author(public_key);
 
     if let Some(event) = client.database().query(filter).await?.first() {
         let content = signer.nip44_decrypt(&public_key, &event.content).await?;

crates/dock/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "dock"
-version.workspace = true
-edition.workspace = true
-publish.workspace = true
-
-[dependencies]
-common = { path = "../common" }
-theme = { path = "../theme" }
-ui = { path = "../ui" }
-
-gpui.workspace = true
-smallvec.workspace = true
-anyhow.workspace = true
-log.workspace = true
-
-[target.'cfg(target_os = "linux")'.dependencies]
-linicon = "2.3.0"

crates/dock/src/tab/mod.rs

@@ -1,165 +0,0 @@
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, px, AnyElement, App, Div, InteractiveElement, IntoElement, MouseButton, ParentElement,
-    RenderOnce, StatefulInteractiveElement, Styled, Window,
-};
-use theme::{ActiveTheme, TABBAR_HEIGHT};
-use ui::{Selectable, Sizable, Size};
-
-pub mod tab_bar;
-
-#[derive(IntoElement)]
-pub struct Tab {
-    ix: usize,
-    base: Div,
-    label: Option<AnyElement>,
-    prefix: Option<AnyElement>,
-    suffix: Option<AnyElement>,
-    disabled: bool,
-    selected: bool,
-    size: Size,
-}
-
-impl Tab {
-    pub fn new() -> Self {
-        Self {
-            ix: 0,
-            base: div(),
-            label: None,
-            disabled: false,
-            selected: false,
-            prefix: None,
-            suffix: None,
-            size: Size::default(),
-        }
-    }
-
-    /// Set label for the tab.
-    pub fn label(mut self, label: impl Into<AnyElement>) -> Self {
-        self.label = Some(label.into());
-        self
-    }
-
-    /// Set the left side of the tab
-    pub fn prefix(mut self, prefix: impl Into<AnyElement>) -> Self {
-        self.prefix = Some(prefix.into());
-        self
-    }
-
-    /// Set the right side of the tab
-    pub fn suffix(mut self, suffix: impl Into<AnyElement>) -> Self {
-        self.suffix = Some(suffix.into());
-        self
-    }
-
-    /// Set disabled state to the tab
-    pub fn disabled(mut self, disabled: bool) -> Self {
-        self.disabled = disabled;
-        self
-    }
-
-    /// Set index to the tab.
-    pub fn ix(mut self, ix: usize) -> Self {
-        self.ix = ix;
-        self
-    }
-}
-
-impl Default for Tab {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Selectable for Tab {
-    fn selected(mut self, selected: bool) -> Self {
-        self.selected = selected;
-        self
-    }
-
-    fn is_selected(&self) -> bool {
-        self.selected
-    }
-}
-
-impl InteractiveElement for Tab {
-    fn interactivity(&mut self) -> &mut gpui::Interactivity {
-        self.base.interactivity()
-    }
-}
-
-impl StatefulInteractiveElement for Tab {}
-
-impl Styled for Tab {
-    fn style(&mut self) -> &mut gpui::StyleRefinement {
-        self.base.style()
-    }
-}
-
-impl Sizable for Tab {
-    fn with_size(mut self, size: impl Into<Size>) -> Self {
-        self.size = size.into();
-        self
-    }
-}
-
-impl RenderOnce for Tab {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let (text_color, hover_text_color, bg_color, border_color) =
-            match (self.selected, self.disabled) {
-                (true, false) => (
-                    cx.theme().tab_active_foreground,
-                    cx.theme().tab_hover_foreground,
-                    cx.theme().tab_active_background,
-                    cx.theme().border,
-                ),
-                (false, false) => (
-                    cx.theme().tab_inactive_foreground,
-                    cx.theme().tab_hover_foreground,
-                    cx.theme().ghost_element_background,
-                    cx.theme().border_transparent,
-                ),
-                (true, true) => (
-                    cx.theme().tab_inactive_foreground,
-                    cx.theme().tab_hover_foreground,
-                    cx.theme().ghost_element_background,
-                    cx.theme().border_disabled,
-                ),
-                (false, true) => (
-                    cx.theme().tab_inactive_foreground,
-                    cx.theme().tab_hover_foreground,
-                    cx.theme().ghost_element_background,
-                    cx.theme().border_disabled,
-                ),
-            };
-
-        self.base
-            .id(self.ix)
-            .h(TABBAR_HEIGHT)
-            .px_4()
-            .relative()
-            .flex()
-            .items_center()
-            .flex_shrink_0()
-            .cursor_pointer()
-            .overflow_hidden()
-            .text_xs()
-            .text_ellipsis()
-            .text_color(text_color)
-            .bg(bg_color)
-            .border_l(px(1.))
-            .border_r(px(1.))
-            .border_color(border_color)
-            .when(!self.selected && !self.disabled, |this| {
-                this.hover(|this| this.text_color(hover_text_color))
-            })
-            .when_some(self.prefix, |this, prefix| {
-                this.child(prefix).text_color(text_color)
-            })
-            .when_some(self.label, |this, label| this.child(label))
-            .when_some(self.suffix, |this, suffix| this.child(suffix))
-            .on_mouse_down(MouseButton::Left, |_ev, _window, cx| {
-                cx.stop_propagation();
-            })
-    }
-}

crates/dock/src/tab/tab_bar.rs

@@ -1,127 +0,0 @@
-use gpui::prelude::FluentBuilder as _;
-#[cfg(not(target_os = "windows"))]
-use gpui::Pixels;
-use gpui::{
-    div, px, AnyElement, App, Div, InteractiveElement, IntoElement, ParentElement, RenderOnce,
-    ScrollHandle, StatefulInteractiveElement as _, StyleRefinement, Styled, Window,
-};
-use smallvec::SmallVec;
-use theme::ActiveTheme;
-use ui::{h_flex, Sizable, Size, StyledExt};
-
-#[derive(IntoElement)]
-pub struct TabBar {
-    base: Div,
-    style: StyleRefinement,
-    scroll_handle: Option<ScrollHandle>,
-    prefix: Option<AnyElement>,
-    suffix: Option<AnyElement>,
-    last_empty_space: AnyElement,
-    children: SmallVec<[AnyElement; 2]>,
-    size: Size,
-}
-
-impl TabBar {
-    pub fn new() -> Self {
-        Self {
-            base: h_flex().px(px(-1.)),
-            style: StyleRefinement::default(),
-            scroll_handle: None,
-            children: SmallVec::new(),
-            prefix: None,
-            suffix: None,
-            size: Size::default(),
-            last_empty_space: div().w_3().into_any_element(),
-        }
-    }
-
-    /// Track the scroll of the TabBar.
-    pub fn track_scroll(mut self, scroll_handle: &ScrollHandle) -> Self {
-        self.scroll_handle = Some(scroll_handle.clone());
-        self
-    }
-
-    /// Set the prefix element of the TabBar
-    pub fn prefix(mut self, prefix: impl IntoElement) -> Self {
-        self.prefix = Some(prefix.into_any_element());
-        self
-    }
-
-    /// Set the suffix element of the TabBar
-    pub fn suffix(mut self, suffix: impl IntoElement) -> Self {
-        self.suffix = Some(suffix.into_any_element());
-        self
-    }
-
-    /// Set the last empty space element of the TabBar.
-    pub fn last_empty_space(mut self, last_empty_space: impl IntoElement) -> Self {
-        self.last_empty_space = last_empty_space.into_any_element();
-        self
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    pub fn height(window: &mut Window) -> Pixels {
-        (1.75 * window.rem_size()).max(px(36.))
-    }
-}
-
-impl Default for TabBar {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ParentElement for TabBar {
-    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
-        self.children.extend(elements)
-    }
-}
-
-impl Styled for TabBar {
-    fn style(&mut self) -> &mut StyleRefinement {
-        &mut self.style
-    }
-}
-
-impl Sizable for TabBar {
-    fn with_size(mut self, size: impl Into<Size>) -> Self {
-        self.size = size.into();
-        self
-    }
-}
-
-impl RenderOnce for TabBar {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        self.base
-            .group("tab-bar")
-            .relative()
-            .refine_style(&self.style)
-            .bg(cx.theme().surface_background)
-            .child(
-                div()
-                    .id("border-bottom")
-                    .absolute()
-                    .left_0()
-                    .bottom_0()
-                    .size_full()
-                    .border_b_1()
-                    .border_color(cx.theme().border),
-            )
-            .text_color(cx.theme().text)
-            .when_some(self.prefix, |this, prefix| this.child(prefix))
-            .child(
-                h_flex()
-                    .id("tabs")
-                    .flex_grow()
-                    .overflow_x_scroll()
-                    .when_some(self.scroll_handle, |this, scroll_handle| {
-                        this.track_scroll(&scroll_handle)
-                    })
-                    .children(self.children)
-                    .when(self.suffix.is_some(), |this| {
-                        this.child(self.last_empty_space)
-                    }),
-            )
-            .when_some(self.suffix, |this, suffix| this.child(suffix))
-    }
-}

crates/person/Cargo.toml

@@ -7,7 +7,6 @@ publish.workspace = true
 [dependencies]
 common = { path = "../common" }
 state = { path = "../state" }
-device = { path = "../device" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
@@ -16,3 +15,4 @@ smallvec.workspace = true
 smol.workspace = true
 flume.workspace = true
 log.workspace = true
+urlencoding = "2.1.3"

crates/person/src/lib.rs

@@ -3,19 +3,19 @@ use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 use std::time::Duration;
 
-use anyhow::{anyhow, Error};
-use common::EventUtils;
-use device::Announcement;
-use gpui::{App, AppContext, Context, Entity, Global, Task};
+use anyhow::{Error, anyhow};
+use common::EventExt;
+use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
 use nostr_sdk::prelude::*;
-pub use person::*;
-use smallvec::{smallvec, SmallVec};
-use state::{NostrRegistry, BOOTSTRAP_RELAYS, TIMEOUT};
+use smallvec::{SmallVec, smallvec};
+use state::{Announcement, BOOTSTRAP_RELAYS, NostrRegistry, TIMEOUT};
 
 mod person;
 
-pub fn init(cx: &mut App) {
-    PersonRegistry::set_global(cx.new(PersonRegistry::new), cx);
+pub use person::*;
+
+pub fn init(window: &mut Window, cx: &mut App) {
+    PersonRegistry::set_global(cx.new(|cx| PersonRegistry::new(window, cx)), cx);
 }
 
 struct GlobalPersonRegistry(Entity<PersonRegistry>);
@@ -36,13 +36,13 @@ pub struct PersonRegistry {
     persons: HashMap<PublicKey, Entity<Person>>,
 
     /// Set of public keys that have been seen
-    seen: Rc<RefCell<HashSet<PublicKey>>>,
+    seens: Rc<RefCell<HashSet<PublicKey>>>,
 
     /// Sender for requesting metadata
     sender: flume::Sender<PublicKey>,
 
     /// Tasks for asynchronous operations
-    _tasks: SmallVec<[Task<()>; 4]>,
+    tasks: SmallVec<[Task<()>; 4]>,
 }
 
 impl PersonRegistry {
@@ -57,13 +57,13 @@ impl PersonRegistry {
     }
 
     /// Create a new person registry instance
-    fn new(cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Dispatch>(100);
-        let (mta_tx, mta_rx) = flume::bounded::<PublicKey>(100);
+        let (mta_tx, mta_rx) = flume::unbounded::<PublicKey>();
 
         let mut tasks = smallvec![];
 
@@ -111,33 +111,16 @@ impl PersonRegistry {
             }),
         );
 
-        tasks.push(
-            // Load all user profiles from the database
-            cx.spawn(async move |this, cx| {
-                let result = cx
-                    .background_executor()
-                    .await_on_background(async move { Self::load_persons(&client).await })
-                    .await;
-
-                match result {
-                    Ok(persons) => {
-                        this.update(cx, |this, cx| {
-                            this.bulk_inserts(persons, cx);
-                        })
-                        .ok();
-                    }
-                    Err(e) => {
-                        log::error!("Failed to load all persons from the database: {e}");
-                    }
-                };
-            }),
-        );
+        // Load all user profiles from the database
+        cx.defer_in(window, |this, _window, cx| {
+            this.load(cx);
+        });
 
         Self {
             persons: HashMap::new(),
-            seen: Rc::new(RefCell::new(HashSet::new())),
+            seens: Rc::new(RefCell::new(HashSet::new())),
             sender: mta_tx,
-            _tasks: tasks,
+            tasks,
         }
     }
 
@@ -152,7 +135,7 @@ impl PersonRegistry {
                 continue;
             };
 
-            if let RelayMessage::Event { event, .. } = message {
+            if let RelayMessage::Event { event, .. } = *message {
                 // Skip if the event has already been processed
                 if !processed.insert(event.id) {
                     continue;
@@ -163,25 +146,21 @@ impl PersonRegistry {
                         let metadata = Metadata::from_json(&event.content).unwrap_or_default();
                         let person = Person::new(event.pubkey, metadata);
                         let val = Box::new(person);
-
                         // Send
                         tx.send_async(Dispatch::Person(val)).await.ok();
                     }
                     Kind::ContactList => {
                         let public_keys = event.extract_public_keys();
-
                         // Get metadata for all public keys
-                        Self::get_metadata(client, public_keys).await.ok();
+                        get_metadata(client, public_keys).await.ok();
                     }
                     Kind::InboxRelays => {
                         let val = Box::new(event.into_owned());
-
                         // Send
                         tx.send_async(Dispatch::Relays(val)).await.ok();
                     }
                     Kind::Custom(10044) => {
                         let val = Box::new(event.into_owned());
-
                         // Send
                         tx.send_async(Dispatch::Announcement(val)).await.ok();
                     }
@@ -198,104 +177,91 @@ impl PersonRegistry {
         loop {
             match flume::Selector::new()
                 .recv(rx, |result| result.ok())
-                .wait_timeout(Duration::from_secs(2))
+                .wait_timeout(Duration::from_secs(TIMEOUT))
             {
                 Ok(Some(public_key)) => {
                     batch.insert(public_key);
                     // Process the batch if it's full
                     if batch.len() >= 20 {
-                        Self::get_metadata(client, std::mem::take(&mut batch))
-                            .await
-                            .ok();
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
                     }
                 }
                 _ => {
-                    Self::get_metadata(client, std::mem::take(&mut batch))
-                        .await
-                        .ok();
+                    if !batch.is_empty() {
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
+                    }
                 }
             }
         }
     }
 
-    /// Get metadata for all public keys in a event
-    async fn get_metadata<I>(client: &Client, public_keys: I) -> Result<(), Error>
-    where
-        I: IntoIterator<Item = PublicKey>,
-    {
-        let authors: Vec<PublicKey> = public_keys.into_iter().collect();
-        let limit = authors.len();
-
-        if authors.is_empty() {
-            return Err(anyhow!("You need at least one public key"));
-        }
-
-        // Construct the subscription option
-        let opts = SubscribeAutoCloseOptions::default()
-            .exit_policy(ReqExitPolicy::ExitOnEOSE)
-            .timeout(Some(Duration::from_secs(TIMEOUT)));
-
-        // Construct the filter for metadata
-        let filter = Filter::new()
-            .kind(Kind::Metadata)
-            .authors(authors)
-            .limit(limit);
-
-        // Construct target for subscription
-        let target = BOOTSTRAP_RELAYS
-            .into_iter()
-            .map(|relay| (relay, vec![filter.clone()]))
-            .collect::<HashMap<_, _>>();
-
-        client.subscribe(target).close_on(opts).await?;
-
-        Ok(())
-    }
-
     /// Load all user profiles from the database
-    async fn load_persons(client: &Client) -> Result<Vec<Person>, Error> {
-        let filter = Filter::new().kind(Kind::Metadata).limit(200);
-        let events = client.database().query(filter).await?;
+    fn load(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
 
-        let mut persons = vec![];
+        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();
 
-        for event in events.into_iter() {
-            let metadata = Metadata::from_json(event.content).unwrap_or_default();
-            let person = Person::new(event.pubkey, metadata);
-            persons.push(person);
-        }
+            Ok(persons)
+        });
 
-        Ok(persons)
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            if let Ok(persons) = task.await {
+                this.update(cx, |this, cx| {
+                    this.bulk_inserts(persons, cx);
+                })
+                .ok();
+            }
+        }));
     }
 
     /// Set profile encryption keys announcement
     fn set_announcement(&mut self, event: &Event, cx: &mut App) {
-        if let Some(person) = self.persons.get(&event.pubkey) {
-            let announcement = Announcement::from(event);
+        let announcement = Announcement::from(event);
 
+        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);
         }
     }
 
     /// Set messaging relays for a person
     fn set_messaging_relays(&mut self, event: &Event, cx: &mut App) {
-        if let Some(person) = self.persons.get(&event.pubkey) {
-            let urls: Vec<RelayUrl> = nip17::extract_relay_list(event).cloned().collect();
+        let urls: Vec<RelayUrl> = nip17::extract_relay_list(event).cloned().collect();
 
+        if let Some(person) = self.persons.get(&event.pubkey) {
             person.update(cx, |person, cx| {
-                person.set_messaging_relays(event.pubkey, urls);
+                person.set_messaging_relays(urls);
                 cx.notify();
             });
+        } else {
+            let person = Person::new(event.pubkey, Metadata::default()).with_messaging_relays(urls);
+            self.insert(person, cx);
         }
     }
 
     /// Insert batch of persons
     fn bulk_inserts(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
         for person in persons.into_iter() {
-            self.persons.insert(person.public_key(), cx.new(|_| person));
+            let public_key = person.public_key();
+            self.persons
+                .entry(public_key)
+                .or_insert_with(|| cx.new(|_| person));
         }
         cx.notify();
     }
@@ -307,7 +273,7 @@ impl PersonRegistry {
         match self.persons.get(&public_key) {
             Some(this) => {
                 this.update(cx, |this, cx| {
-                    *this = person;
+                    this.set_metadata(person.metadata());
                     cx.notify();
                 });
             }
@@ -324,7 +290,7 @@ impl PersonRegistry {
         }
 
         let public_key = *public_key;
-        let mut seen = self.seen.borrow_mut();
+        let mut seen = self.seens.borrow_mut();
 
         if seen.insert(public_key) {
             let sender = self.sender.clone();
@@ -342,3 +308,37 @@ impl PersonRegistry {
         Person::new(public_key, Metadata::default())
     }
 }
+
+/// Get metadata for all public keys in a event
+async fn get_metadata<I>(client: &Client, public_keys: I) -> Result<(), Error>
+where
+    I: IntoIterator<Item = PublicKey>,
+{
+    let authors: Vec<PublicKey> = public_keys.into_iter().collect();
+    let limit = authors.len();
+
+    if authors.is_empty() {
+        return Err(anyhow!("You need at least one public key"));
+    }
+
+    // Construct the subscription option
+    let opts = SubscribeAutoCloseOptions::default()
+        .exit_policy(ReqExitPolicy::ExitOnEOSE)
+        .timeout(Some(Duration::from_secs(TIMEOUT)));
+
+    // Construct the filter for metadata
+    let filter = Filter::new()
+        .kind(Kind::Metadata)
+        .authors(authors)
+        .limit(limit);
+
+    // Construct target for subscription
+    let target: HashMap<&str, Vec<Filter>> = BOOTSTRAP_RELAYS
+        .into_iter()
+        .map(|relay| (relay, vec![filter.clone()]))
+        .collect();
+
+    client.subscribe(target).close_on(opts).await?;
+
+    Ok(())
+}

crates/person/src/person.rs

@@ -1,9 +1,9 @@
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 
-use device::Announcement;
 use gpui::SharedString;
 use nostr_sdk::prelude::*;
+use state::Announcement;
 
 const IMAGE_RESIZER: &str = "https://wsrv.nl";
 
@@ -65,6 +65,21 @@ impl Person {
         }
     }
 
+    /// 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
@@ -80,12 +95,6 @@ impl Person {
         self.announcement.clone()
     }
 
-    /// Set profile encryption keys announcement
-    pub fn set_announcement(&mut self, announcement: Announcement) {
-        self.announcement = Some(announcement);
-        log::info!("Updated announcement for: {}", self.public_key());
-    }
-
     /// Get profile messaging relays
     pub fn messaging_relays(&self) -> &Vec<RelayUrl> {
         &self.messaging_relays
@@ -96,15 +105,6 @@ impl Person {
         self.messaging_relays.first().cloned()
     }
 
-    /// Set profile messaging relays
-    pub fn set_messaging_relays<I>(&mut self, public_key: PublicKey, relays: I)
-    where
-        I: IntoIterator<Item = RelayUrl>,
-    {
-        self.messaging_relays = relays.into_iter().collect();
-        log::info!("Updated messaging relays for: {}", public_key);
-    }
-
     /// Get profile avatar
     pub fn avatar(&self) -> SharedString {
         self.metadata()
@@ -112,8 +112,9 @@ impl Person {
             .as_ref()
             .filter(|picture| !picture.is_empty())
             .map(|picture| {
+                let encoded_picture = urlencoding::encode(picture);
                 let url = format!(
-                    "{IMAGE_RESIZER}/?url={picture}&w=100&h=100&fit=cover&mask=circle&n=-1"
+                    "{IMAGE_RESIZER}/?url={encoded_picture}&w=100&h=100&fit=cover&mask=circle&n=-1"
                 );
                 url.into()
             })
@@ -122,20 +123,38 @@ impl Person {
 
     /// Get profile name
     pub fn name(&self) -> SharedString {
-        if let Some(display_name) = self.metadata().display_name.as_ref() {
-            if !display_name.is_empty() {
-                return SharedString::from(display_name);
-            }
+        if let Some(display_name) = self.metadata().display_name.as_ref()
+            && !display_name.is_empty()
+        {
+            return SharedString::from(display_name);
         }
 
-        if let Some(name) = self.metadata().name.as_ref() {
-            if !name.is_empty() {
-                return SharedString::from(name);
-            }
+        if let Some(name) = self.metadata().name.as_ref()
+            && !name.is_empty()
+        {
+            return SharedString::from(name);
         }
 
         SharedString::from(shorten_pubkey(self.public_key(), 4))
     }
+
+    /// Set profile metadata
+    pub fn set_metadata(&mut self, metadata: Metadata) {
+        self.metadata = metadata;
+    }
+
+    /// Set profile encryption keys announcement
+    pub 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)
+    where
+        I: IntoIterator<Item = RelayUrl>,
+    {
+        self.messaging_relays = relays.into_iter().collect();
+    }
 }
 
 /// Shorten a [`PublicKey`] to a string with the first and last `len` characters
@@ -145,7 +164,7 @@ pub fn shorten_pubkey(public_key: PublicKey, len: usize) -> String {
     let Ok(pubkey) = public_key.to_bech32();
 
     format!(
-        "{}:{}",
+        "{}...{}",
         &pubkey[0..(len + 1)],
         &pubkey[pubkey.len() - len..]
     )

crates/relay_auth/src/lib.rs

@@ -5,19 +5,19 @@ use std::hash::Hash;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use anyhow::{anyhow, Context as AnyhowContext, Error};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::{
     App, AppContext, Context, Entity, Global, IntoElement, ParentElement, SharedString, Styled,
-    Task, Window,
+    Task, Window, div, relative,
 };
 use nostr_sdk::prelude::*;
 use settings::{AppSettings, AuthMode};
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
 use state::NostrRegistry;
 use theme::ActiveTheme;
-use ui::button::{Button, ButtonVariants};
-use ui::notification::Notification;
-use ui::{v_flex, Disableable, IconName, Sizable, WindowExtension};
+use ui::button::Button;
+use ui::notification::{Notification, NotificationKind};
+use ui::{Disableable, WindowExtension, v_flex};
 
 const AUTH_MESSAGE: &str =
     "Approve the authentication request to allow Coop to continue sending or receiving events.";
@@ -34,7 +34,10 @@ struct AuthRequest {
 }
 
 impl AuthRequest {
-    pub fn new(challenge: impl Into<String>, url: RelayUrl) -> Self {
+    pub fn new<S>(challenge: S, url: RelayUrl) -> Self
+    where
+        S: Into<String>,
+    {
         Self {
             challenge: challenge.into(),
             url,
@@ -67,7 +70,7 @@ pub struct RelayAuth {
     pending_events: HashSet<(EventId, RelayUrl)>,
 
     /// Tasks for asynchronous operations
-    tasks: SmallVec<[Task<()>; 2]>,
+    _tasks: SmallVec<[Task<()>; 2]>,
 }
 
 impl RelayAuth {
@@ -83,32 +86,21 @@ impl RelayAuth {
 
     /// Create a new relay auth instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        cx.defer_in(window, |this, window, cx| {
-            this.handle_notifications(window, cx);
-        });
-
-        Self {
-            pending_events: HashSet::default(),
-            tasks: smallvec![],
-        }
-    }
-
-    /// Handle nostr notifications
-    fn handle_notifications(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
+        let mut tasks = smallvec![];
+
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Signal>(256);
 
-        self.tasks.push(cx.background_spawn(async move {
-            log::info!("Started handling nostr notifications");
+        tasks.push(cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut challenges: HashSet<Cow<'_, str>> = HashSet::default();
 
             while let Some(notification) = notifications.next().await {
                 if let ClientNotification::Message { relay_url, message } = notification {
-                    match message {
+                    match *message {
                         RelayMessage::Auth { challenge } => {
                             if challenges.insert(challenge.clone()) {
                                 let request = Arc::new(AuthRequest::new(challenge, relay_url));
@@ -134,7 +126,7 @@ impl RelayAuth {
             }
         }));
 
-        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+        tasks.push(cx.spawn_in(window, async move |this, cx| {
             while let Ok(signal) = rx.recv_async().await {
                 match signal {
                     Signal::Auth(req) => {
@@ -152,6 +144,11 @@ impl RelayAuth {
                 }
             }
         }));
+
+        Self {
+            pending_events: HashSet::default(),
+            _tasks: tasks,
+        }
     }
 
     /// Insert a pending event waiting for resend after authentication
@@ -162,15 +159,12 @@ impl RelayAuth {
 
     /// Get all pending events for a specific relay,
     fn get_pending_events(&self, relay: &RelayUrl, _cx: &App) -> Vec<EventId> {
-        let pending_events: Vec<EventId> = self
-            .pending_events
+        self.pending_events
             .iter()
             .filter(|(_, pending_relay)| pending_relay == relay)
             .map(|(id, _relay)| id)
             .cloned()
-            .collect();
-
-        pending_events
+            .collect()
     }
 
     /// Clear all pending events for a specific relay,
@@ -227,31 +221,31 @@ impl RelayAuth {
 
             while let Some(notification) = notifications.next().await {
                 match notification {
-                    RelayNotification::Message {
-                        message: RelayMessage::Ok { event_id, .. },
-                    } => {
-                        if id != event_id {
-                            continue;
-                        }
-
-                        // Get all subscriptions
-                        let subscriptions = relay.subscriptions().await;
-
-                        // Re-subscribe to previous subscriptions
-                        for (id, filters) in subscriptions.into_iter() {
-                            if !filters.is_empty() {
-                                relay.send_msg(ClientMessage::req(id, filters)).await?;
+                    RelayNotification::Message { message } => {
+                        if let RelayMessage::Ok { event_id, .. } = *message {
+                            if id != event_id {
+                                continue;
                             }
-                        }
 
-                        // Re-send pending events
-                        for id in pending_events {
-                            if let Some(event) = client.database().event_by_id(&id).await? {
-                                relay.send_event(&event).await?;
+                            // Get all subscriptions
+                            let subscriptions = relay.subscriptions().await;
+
+                            // Re-subscribe to previous subscriptions
+                            for (id, filters) in subscriptions.into_iter() {
+                                if !filters.is_empty() {
+                                    relay.send_msg(ClientMessage::req(id, filters)).await?;
+                                }
                             }
-                        }
 
-                        return Ok(());
+                            // Re-send pending events
+                            for id in pending_events {
+                                if let Some(event) = client.database().event_by_id(&id).await? {
+                                    relay.send_event(&event).await?;
+                                }
+                            }
+
+                            return Ok(());
+                        }
                     }
                     RelayNotification::AuthenticationFailed => break,
                     _ => {}
@@ -266,7 +260,7 @@ impl RelayAuth {
     fn response(&self, req: &Arc<AuthRequest>, window: &Window, cx: &Context<Self>) {
         let settings = AppSettings::global(cx);
         let req = req.clone();
-        let challenge = req.challenge().to_string();
+        let challenge = SharedString::from(req.challenge().to_string());
 
         // Create a task for authentication
         let task = self.auth(&req, cx);
@@ -276,20 +270,31 @@ impl RelayAuth {
             let url = req.url();
 
             this.update_in(cx, |this, window, cx| {
-                window.clear_notification(challenge, cx);
+                window.clear_notification_by_id::<AuthNotification>(challenge, cx);
 
                 match result {
                     Ok(_) => {
                         // Clear pending events for the authenticated relay
                         this.clear_pending_events(url, cx);
+
                         // Save the authenticated relay to automatically authenticate future requests
                         settings.update(cx, |this, cx| {
                             this.add_trusted_relay(url, cx);
                         });
-                        window.push_notification(format!("{} has been authenticated", url), cx);
+
+                        window.push_notification(
+                            Notification::success(format!(
+                                "Relay {} has been authenticated",
+                                url.domain().unwrap_or_default()
+                            )),
+                            cx,
+                        );
                     }
                     Err(e) => {
-                        window.push_notification(Notification::error(e.to_string()), cx);
+                        window.push_notification(
+                            Notification::error(e.to_string()).autohide(false),
+                            cx,
+                        );
                     }
                 }
             })
@@ -314,49 +319,50 @@ impl RelayAuth {
     /// Build a notification for the authentication request.
     fn notification(&self, req: &Arc<AuthRequest>, cx: &Context<Self>) -> Notification {
         let req = req.clone();
+        let challenge = SharedString::from(req.challenge.clone());
         let url = SharedString::from(req.url().to_string());
         let entity = cx.entity().downgrade();
         let loading = Rc::new(Cell::new(false));
 
         Notification::new()
-            .custom_id(SharedString::from(&req.challenge))
+            .type_id::<AuthNotification>(challenge)
             .autohide(false)
-            .icon(IconName::Info)
-            .title(SharedString::from("Authentication Required"))
-            .content(move |_window, cx| {
+            .with_kind(NotificationKind::Info)
+            .title("Authentication Required")
+            .content(move |_this, _window, cx| {
                 v_flex()
                     .gap_2()
-                    .text_sm()
-                    .child(SharedString::from(AUTH_MESSAGE))
+                    .child(
+                        div()
+                            .text_sm()
+                            .line_height(relative(1.25))
+                            .child(SharedString::from(AUTH_MESSAGE)),
+                    )
                     .child(
                         v_flex()
                             .py_1()
                             .px_1p5()
                             .rounded_sm()
                             .text_xs()
-                            .bg(cx.theme().warning_background)
-                            .text_color(cx.theme().warning_foreground)
+                            .bg(cx.theme().elevated_surface_background)
+                            .text_color(cx.theme().text)
                             .child(url.clone()),
                     )
                     .into_any_element()
             })
-            .action(move |_window, _cx| {
+            .action(move |_this, _window, _cx| {
                 let view = entity.clone();
                 let req = req.clone();
 
                 Button::new("approve")
                     .label("Approve")
-                    .small()
-                    .primary()
                     .loading(loading.get())
                     .disabled(loading.get())
                     .on_click({
                         let loading = Rc::clone(&loading);
-
                         move |_ev, window, cx| {
                             // Set loading state to true
                             loading.set(true);
-
                             // Process to approve the request
                             view.update(cx, |this, cx| {
                                 this.response(&req, window, cx);
@@ -367,3 +373,5 @@ impl RelayAuth {
             })
     }
 }
+
+struct AuthNotification;

crates/settings/Cargo.toml

@@ -5,6 +5,7 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
+theme = { path = "../theme" }
 common = { path = "../common" }
 
 nostr-sdk.workspace = true

crates/settings/src/lib.rs

@@ -1,14 +1,17 @@
 use std::collections::{HashMap, HashSet};
+use std::fmt::Display;
+use std::rc::Rc;
 
-use anyhow::{anyhow, Error};
+use anyhow::{Error, anyhow};
 use common::config_dir;
-use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task};
+use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task, Window};
 use nostr_sdk::prelude::*;
 use serde::{Deserialize, Serialize};
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
+use theme::{Theme, ThemeFamily, ThemeMode};
 
-pub fn init(cx: &mut App) {
-    AppSettings::set_global(cx.new(AppSettings::new), cx)
+pub fn init(window: &mut Window, cx: &mut App) {
+    AppSettings::set_global(cx.new(|cx| AppSettings::new(window, cx)), cx)
 }
 
 macro_rules! setting_accessors {
@@ -33,6 +36,8 @@ macro_rules! setting_accessors {
 }
 
 setting_accessors! {
+    pub theme: Option<String>,
+    pub theme_mode: ThemeMode,
     pub hide_avatar: bool,
     pub screening: bool,
     pub auth_mode: AuthMode,
@@ -49,11 +54,20 @@ pub enum AuthMode {
     Manual,
 }
 
+impl Display for AuthMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AuthMode::Auto => write!(f, "Auto"),
+            AuthMode::Manual => write!(f, "Ask every time"),
+        }
+    }
+}
+
 /// Signer kind
 #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum SignerKind {
-    Auto,
     #[default]
+    Auto,
     User,
     Encryption,
 }
@@ -80,18 +94,43 @@ pub struct RoomConfig {
 }
 
 impl RoomConfig {
+    pub fn new() -> Self {
+        Self {
+            backup: true,
+            signer_kind: SignerKind::Auto,
+        }
+    }
+
+    /// Get backup config
     pub fn backup(&self) -> bool {
         self.backup
     }
 
+    /// Set backup config
+    pub fn toggle_backup(&mut self) {
+        self.backup = !self.backup;
+    }
+
+    /// Get signer kind config
     pub fn signer_kind(&self) -> &SignerKind {
         &self.signer_kind
     }
+
+    /// Set signer kind config
+    pub fn set_signer_kind(&mut self, kind: &SignerKind) {
+        self.signer_kind = kind.to_owned();
+    }
 }
 
 /// Settings
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Settings {
+    /// Theme
+    pub theme: Option<String>,
+
+    /// Theme mode
+    pub theme_mode: ThemeMode,
+
     /// Hide user avatars
     pub hide_avatar: bool,
 
@@ -107,19 +146,21 @@ pub struct Settings {
     /// Configuration for each chat room
     pub room_configs: HashMap<u64, RoomConfig>,
 
-    /// File server for NIP-96 media attachments
+    /// Server for blossom media attachments
     pub file_server: Url,
 }
 
 impl Default for Settings {
     fn default() -> Self {
         Self {
+            theme: None,
+            theme_mode: ThemeMode::default(),
             hide_avatar: false,
             screening: true,
             auth_mode: AuthMode::default(),
             trusted_relays: HashSet::default(),
             room_configs: HashMap::default(),
-            file_server: Url::parse("https://nostrmedia.com").unwrap(),
+            file_server: Url::parse("https://blossom.band/").unwrap(),
         }
     }
 }
@@ -154,7 +195,7 @@ impl AppSettings {
         cx.set_global(GlobalAppSettings(state));
     }
 
-    fn new(cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let mut subscriptions = smallvec![];
 
         subscriptions.push(
@@ -164,12 +205,9 @@ impl AppSettings {
             }),
         );
 
-        cx.defer(|cx| {
-            let settings = AppSettings::global(cx);
-
-            settings.update(cx, |this, cx| {
-                this.load(cx);
-            });
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.load(window, cx);
         });
 
         Self {
@@ -185,7 +223,7 @@ impl AppSettings {
     }
 
     /// Load settings
-    fn load(&mut self, cx: &mut Context<Self>) {
+    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let task: Task<Result<Settings, Error>> = cx.background_spawn(async move {
             let path = config_dir().join(".settings");
 
@@ -196,12 +234,13 @@ impl AppSettings {
             }
         });
 
-        cx.spawn(async move |this, cx| {
+        cx.spawn_in(window, async move |this, cx| {
             let settings = task.await.unwrap_or(Settings::default());
 
             // Update settings
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, window, cx| {
                 this.set_settings(settings, cx);
+                this.apply_theme(window, cx);
             })
             .ok();
         })
@@ -225,6 +264,43 @@ impl AppSettings {
         task.detach();
     }
 
+    /// 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.values.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.values.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.values.theme.as_ref() {
+            let mode = self.values.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);
+        }
+    }
+
     /// Check if the given relay is already authenticated
     pub fn trusted_relay(&self, url: &RelayUrl, _cx: &App) -> bool {
         self.values.trusted_relays.iter().any(|relay| {

crates/state/Cargo.toml

@@ -7,15 +7,16 @@ publish.workspace = true
 [dependencies]
 common = { path = "../common" }
 
+nostr.workspace = true
 nostr-sdk.workspace = true
 nostr-lmdb.workspace = true
-nostr-connect.workspace = true
 nostr-gossip-memory.workspace = true
+nostr-connect.workspace = true
+nostr-blossom.workspace = true
 
 gpui.workspace = true
 gpui_tokio.workspace = true
 smol.workspace = true
-reqwest.workspace = true
 flume.workspace = true
 log.workspace = true
 anyhow.workspace = true
@@ -26,3 +27,4 @@ serde_json.workspace = true
 rustls = "0.23"
 petname = "2.0.2"
 whoami = "1.6.1"
+mime_guess = "2.0.4"

crates/state/src/blossom.rs

@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use anyhow::{anyhow, Error};
+use gpui::AsyncApp;
+use gpui_tokio::Tokio;
+use mime_guess::from_path;
+use nostr_blossom::prelude::*;
+use nostr_sdk::prelude::*;
+
+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();
+
+    // Construct the blossom client
+    let client = BlossomClient::new(server);
+
+    Tokio::spawn(cx, async move {
+        let blob = client
+            .upload_blob(data, Some(content_type), None, Some(&keys))
+            .await?;
+
+        Ok(blob.url)
+    })
+    .await
+    .map_err(|e| anyhow!("Upload error: {e}"))?
+}

crates/state/src/constants.rs

@@ -1,10 +1,8 @@
-use std::sync::OnceLock;
-
 /// Client name (Application name)
 pub const CLIENT_NAME: &str = "Coop";
 
 /// COOP's public key
-pub const COOP_PUBKEY: &str = "npub126kl5fruqan90py77gf6pvfvygefl2mu2ukew6xdx5pc5uqscwgsnkgarv";
+pub const COOP_PUBKEY: &str = "npub1j3rz3ndl902lya6ywxvy5c983lxs8mpukqnx4pa4lt5wrykwl5ys7wpw3x";
 
 /// App ID
 pub const APP_ID: &str = "su.reya.coop";
@@ -15,47 +13,39 @@ pub const 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 delay for searching
 pub const FIND_DELAY: u64 = 600;
 
 /// Default limit for searching
 pub const FIND_LIMIT: usize = 20;
 
-/// Default timeout for Nostr Connect
-pub const NOSTR_CONNECT_TIMEOUT: u64 = 200;
-
-/// Default Nostr Connect relay
-pub const NOSTR_CONNECT_RELAY: &str = "wss://relay.nsec.app";
-
 /// Default subscription id for device gift wrap events
 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 const SEARCH_RELAYS: [&str; 1] = ["wss://antiprimal.net"];
-
 pub const INDEXER_RELAYS: [&str; 1] = ["wss://indexer.coracle.social"];
 
+/// Default search relays
+pub const SEARCH_RELAYS: [&str; 2] = ["wss://antiprimal.net", "wss://search.nos.today"];
+
 /// Default bootstrap relays
 pub const BOOTSTRAP_RELAYS: [&str; 3] = [
     "wss://relay.damus.io",
     "wss://relay.primal.net",
     "wss://user.kindpag.es",
 ];
-
-static APP_NAME: OnceLock<String> = OnceLock::new();
-
-/// Get the app name
-pub fn app_name() -> &'static String {
-    APP_NAME.get_or_init(|| {
-        let devicename = whoami::devicename();
-        let platform = whoami::platform();
-
-        format!("{CLIENT_NAME} on {platform} ({devicename})")
-    })
-}

crates/state/src/device.rs

@@ -1,28 +1,6 @@
 use gpui::SharedString;
 use nostr_sdk::prelude::*;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-pub enum DeviceState {
-    #[default]
-    Initial,
-    Requesting,
-    Set,
-}
-
-impl DeviceState {
-    pub fn initial(&self) -> bool {
-        matches!(self, DeviceState::Initial)
-    }
-
-    pub fn requesting(&self) -> bool {
-        matches!(self, DeviceState::Requesting)
-    }
-
-    pub fn set(&self) -> bool {
-        matches!(self, DeviceState::Set)
-    }
-}
-
 /// Announcement
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Announcement {

crates/state/src/signer.rs

@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 use std::result::Result;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 use nostr_sdk::prelude::*;
@@ -16,14 +15,6 @@ pub struct CoopSigner {
 
     /// Specific signer for encryption purposes
     encryption_signer: RwLock<Option<Arc<dyn NostrSigner>>>,
-
-    /// Whether coop is creating a new identity
-    creating: AtomicBool,
-
-    /// By default, Coop generates a new signer for new users.
-    ///
-    /// This flag indicates whether the signer is user-owned or Coop-generated.
-    owned: AtomicBool,
 }
 
 impl CoopSigner {
@@ -35,8 +26,6 @@ impl CoopSigner {
             signer: RwLock::new(signer.into_nostr_signer()),
             signer_pkey: RwLock::new(None),
             encryption_signer: RwLock::new(None),
-            creating: AtomicBool::new(false),
-            owned: AtomicBool::new(false),
         }
     }
 
@@ -51,22 +40,15 @@ impl CoopSigner {
     }
 
     /// Get public key
+    ///
+    /// Ensure to call this method after the signer has been initialized.
+    /// Otherwise, it will panic.
     pub fn public_key(&self) -> Option<PublicKey> {
-        self.signer_pkey.read_blocking().to_owned()
-    }
-
-    /// Get the flag indicating whether the signer is creating a new identity.
-    pub fn creating(&self) -> bool {
-        self.creating.load(Ordering::SeqCst)
-    }
-
-    /// Get the flag indicating whether the signer is user-owned.
-    pub fn owned(&self) -> bool {
-        self.owned.load(Ordering::SeqCst)
+        *self.signer_pkey.read_blocking()
     }
 
     /// Switch the current signer to a new signer.
-    pub async fn switch<T>(&self, new: T, owned: bool)
+    pub async fn switch<T>(&self, new: T)
     where
         T: IntoNostrSigner,
     {
@@ -84,9 +66,6 @@ impl CoopSigner {
 
         // Reset the encryption signer
         *encryption_signer = None;
-
-        // Update the owned flag
-        self.owned.store(owned, Ordering::SeqCst);
     }
 
     /// Set the encryption signer.

crates/theme/src/colors.rs

@@ -1,4 +1,4 @@
-use gpui::{hsla, Hsla, Rgba};
+use gpui::{Hsla, Rgba, hsla};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -8,10 +8,13 @@ use crate::scale::{ColorScale, ColorScaleSet, ColorScales};
 pub struct ThemeColors {
     // Surface colors
     pub background: Hsla,
-    pub overlay: Hsla,
     pub surface_background: Hsla,
     pub elevated_surface_background: Hsla,
     pub panel_background: Hsla,
+    pub overlay: Hsla,
+    pub title_bar: Hsla,
+    pub title_bar_inactive: Hsla,
+    pub window_border: Hsla,
 
     // Border colors
     pub border: Hsla,
@@ -27,6 +30,8 @@ pub struct ThemeColors {
     pub text_muted: Hsla,
     pub text_placeholder: Hsla,
     pub text_accent: Hsla,
+    pub text_danger: Hsla,
+    pub text_warning: Hsla,
 
     // Icon colors
     pub icon: Hsla,
@@ -74,11 +79,11 @@ pub struct ThemeColors {
     pub ghost_element_disabled: Hsla,
 
     // Tab colors
-    pub tab_inactive_background: Hsla,
-    pub tab_inactive_foreground: Hsla,
+    pub tab_background: Hsla,
+    pub tab_foreground: Hsla,
+    pub tab_hover_background: Hsla,
     pub tab_active_background: Hsla,
     pub tab_active_foreground: Hsla,
-    pub tab_hover_foreground: Hsla,
 
     // Scrollbar colors
     pub scrollbar_thumb_background: Hsla,
@@ -91,26 +96,111 @@ pub struct ThemeColors {
     pub drop_target_background: Hsla,
     pub cursor: Hsla,
     pub selection: Hsla,
-
-    // System
-    pub titlebar: Hsla,
-    pub titlebar_inactive: Hsla,
 }
 
 /// The default colors for the theme.
 ///
 /// Themes that do not specify all colors are refined off of these defaults.
 impl ThemeColors {
+    /// Returns the default colors for light themes.
+    ///
+    /// Themes that do not specify all colors are refined off of these defaults.
+    pub fn light() -> Self {
+        Self {
+            background: neutral().light().step_1(),
+            surface_background: neutral().light().step_2(),
+            elevated_surface_background: neutral().light().step_3(),
+            panel_background: neutral().light().step_1(),
+            overlay: neutral().light_alpha().step_3(),
+            title_bar: neutral().light().step_3(),
+            title_bar_inactive: neutral().light().step_1(),
+            window_border: hsl(240.0, 5.9, 78.0),
+
+            border: neutral().light().step_6(),
+            border_variant: neutral().light().step_5(),
+            border_focused: brand().light().step_7(),
+            border_selected: brand().light().step_7(),
+            border_transparent: gpui::transparent_black(),
+            border_disabled: neutral().light().step_3(),
+            ring: brand().light().step_8(),
+
+            text: neutral().light().step_12(),
+            text_muted: neutral().light().step_11(),
+            text_placeholder: neutral().light().step_10(),
+            text_accent: brand().light().step_9(),
+            text_danger: danger().light().step_9(),
+            text_warning: warning().light().step_9(),
+
+            icon: neutral().light().step_11(),
+            icon_muted: neutral().light().step_10(),
+            icon_accent: brand().light().step_11(),
+
+            element_foreground: brand().light().step_12(),
+            element_background: brand().light().step_9(),
+            element_hover: brand().light_alpha().step_10(),
+            element_active: brand().light().step_10(),
+            element_selected: brand().light().step_11(),
+            element_disabled: brand().light_alpha().step_3(),
+
+            secondary_foreground: brand().light().step_11(),
+            secondary_background: brand().light().step_3(),
+            secondary_hover: brand().light_alpha().step_4(),
+            secondary_active: brand().light().step_5(),
+            secondary_selected: brand().light().step_5(),
+            secondary_disabled: brand().light_alpha().step_3(),
+
+            danger_foreground: danger().light().step_12(),
+            danger_background: danger().light().step_3(),
+            danger_hover: danger().light_alpha().step_4(),
+            danger_active: danger().light().step_5(),
+            danger_selected: danger().light().step_5(),
+            danger_disabled: danger().light_alpha().step_3(),
+
+            warning_foreground: warning().light().step_12(),
+            warning_background: warning().light().step_3(),
+            warning_hover: warning().light_alpha().step_4(),
+            warning_active: warning().light().step_5(),
+            warning_selected: warning().light().step_5(),
+            warning_disabled: warning().light_alpha().step_3(),
+
+            ghost_element_background: gpui::transparent_black(),
+            ghost_element_background_alt: neutral().light().step_3(),
+            ghost_element_hover: neutral().light_alpha().step_4(),
+            ghost_element_active: neutral().light().step_5(),
+            ghost_element_selected: neutral().light().step_5(),
+            ghost_element_disabled: neutral().light_alpha().step_2(),
+
+            tab_background: neutral().light().step_3(),
+            tab_foreground: neutral().light().step_11(),
+            tab_hover_background: neutral().light_alpha().step_4(),
+            tab_active_background: neutral().light().step_1(),
+            tab_active_foreground: neutral().light().step_12(),
+
+            scrollbar_thumb_background: neutral().light_alpha().step_3(),
+            scrollbar_thumb_hover_background: neutral().light_alpha().step_4(),
+            scrollbar_thumb_border: gpui::transparent_black(),
+            scrollbar_track_background: gpui::transparent_black(),
+            scrollbar_track_border: gpui::transparent_black(),
+
+            drop_target_background: brand().light_alpha().step_2(),
+            cursor: hsl(200., 100., 50.),
+            selection: hsl(200., 100., 50.).alpha(0.25),
+        }
+    }
+
     /// Returns the default colors for dark themes.
     ///
     /// Themes that do not specify all colors are refined off of these defaults.
-    pub fn colors() -> Self {
+    pub fn dark() -> Self {
         Self {
             background: neutral().dark().step_1(),
             surface_background: neutral().dark().step_2(),
             elevated_surface_background: neutral().dark().step_3(),
-            panel_background: neutral().dark().step_3(),
+            panel_background: neutral().dark().step_1(),
             overlay: neutral().dark_alpha().step_3(),
+            title_bar: neutral().dark().step_3(),
+            title_bar_inactive: neutral().dark().step_1(),
+            window_border: hsl(240.0, 3.7, 28.0),
 
             border: neutral().dark().step_6(),
             border_variant: neutral().dark().step_5(),
@@ -123,7 +213,9 @@ impl ThemeColors {
             text: neutral().dark().step_12(),
             text_muted: neutral().dark().step_11(),
             text_placeholder: neutral().dark().step_10(),
-            text_accent: brand().dark().step_11(),
+            text_accent: brand().dark().step_9(),
+            text_danger: danger().dark().step_9(),
+            text_warning: warning().dark().step_9(),
 
             icon: neutral().dark().step_11(),
             icon_muted: neutral().dark().step_10(),
@@ -164,24 +256,21 @@ impl ThemeColors {
             ghost_element_selected: neutral().dark().step_5(),
             ghost_element_disabled: neutral().dark_alpha().step_2(),
 
-            tab_inactive_background: neutral().dark().step_2(),
-            tab_inactive_foreground: neutral().dark().step_11(),
-            tab_active_background: neutral().dark().step_3(),
+            tab_background: neutral().dark().step_3(),
+            tab_foreground: neutral().dark().step_11(),
+            tab_hover_background: neutral().dark_alpha().step_4(),
+            tab_active_background: neutral().dark().step_1(),
             tab_active_foreground: neutral().dark().step_12(),
-            tab_hover_foreground: brand().dark().step_9(),
 
             scrollbar_thumb_background: neutral().dark_alpha().step_3(),
             scrollbar_thumb_hover_background: neutral().dark_alpha().step_4(),
             scrollbar_thumb_border: gpui::transparent_black(),
             scrollbar_track_background: gpui::transparent_black(),
-            scrollbar_track_border: neutral().dark().step_5(),
+            scrollbar_track_border: gpui::transparent_black(),
 
             drop_target_background: brand().dark_alpha().step_2(),
             cursor: hsl(200., 100., 50.),
             selection: hsl(200., 100., 50.).alpha(0.25),
-
-            titlebar: neutral().dark_alpha().step_1(),
-            titlebar_inactive: neutral().dark_alpha().step_2(),
         }
     }
 }

crates/theme/src/geometry.rs

@@ -0,0 +1,159 @@
+use std::fmt::{self, Debug, Display, Formatter};
+
+use gpui::{AbsoluteLength, Axis, Length, Pixels};
+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")]
+    Left,
+    #[serde(rename = "right")]
+    Right,
+}
+
+impl Side {
+    /// Returns true if the side is left.
+    #[inline]
+    pub fn is_left(&self) -> bool {
+        matches!(self, Self::Left)
+    }
+
+    /// Returns true if the side is right.
+    #[inline]
+    pub fn is_right(&self) -> bool {
+        matches!(self, Self::Right)
+    }
+}
+
+/// A trait to extend the [`Axis`] enum with utility methods.
+pub trait AxisExt {
+    #[allow(clippy::wrong_self_convention)]
+    fn is_horizontal(self) -> bool;
+    #[allow(clippy::wrong_self_convention)]
+    fn is_vertical(self) -> bool;
+}
+
+impl AxisExt for Axis {
+    #[inline]
+    fn is_horizontal(self) -> bool {
+        self == Axis::Horizontal
+    }
+
+    #[inline]
+    fn is_vertical(self) -> bool {
+        self == Axis::Vertical
+    }
+}
+
+/// 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.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, Eq, PartialEq)]
+#[repr(C)]
+pub struct Edges<T: Clone + Debug + Default + PartialEq> {
+    /// The size of the top edge.
+    pub top: T,
+    /// The size of the right edge.
+    pub right: T,
+    /// The size of the bottom edge.
+    pub bottom: T,
+    /// 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/lib.rs

@@ -1,9 +1,11 @@
 use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 
-use gpui::{px, App, Global, Pixels, SharedString, Window};
+use gpui::{App, Global, Pixels, SharedString, Window, px};
 
 mod colors;
+mod geometry;
+mod notification;
 mod platform_kind;
 mod registry;
 mod scale;
@@ -11,6 +13,8 @@ mod scrollbar_mode;
 mod theme;
 
 pub use colors::*;
+pub use geometry::*;
+pub use notification::*;
 pub use platform_kind::PlatformKind;
 pub use registry::*;
 pub use scale::*;
@@ -29,15 +33,12 @@ pub const CLIENT_SIDE_DECORATION_BORDER: Pixels = px(1.0);
 /// Defines window titlebar height
 pub const TITLEBAR_HEIGHT: Pixels = px(36.0);
 
-/// Defines tabbar height
-pub const TABBAR_HEIGHT: Pixels = px(30.);
+/// Defines workspace tabbar height
+pub const TABBAR_HEIGHT: Pixels = px(28.0);
 
 /// Defines default sidebar width
 pub const SIDEBAR_WIDTH: Pixels = px(240.);
 
-/// Defines search input width
-pub const SEARCH_INPUT_WIDTH: Pixels = px(420.);
-
 pub fn init(cx: &mut App) {
     registry::init(cx);
 
@@ -85,7 +86,10 @@ pub struct Theme {
     /// Show the scrollbar mode, default: scrolling
     pub scrollbar_mode: ScrollbarMode,
 
-    /// Platform
+    /// Notification settings
+    pub notification: NotificationSettings,
+
+    /// Platform kind
     pub platform: PlatformKind,
 }
 
@@ -169,7 +173,11 @@ impl Theme {
         theme.mode = mode;
 
         // Set the theme colors
-        theme.colors = *theme.theme.colors();
+        if mode.is_dark() {
+            theme.colors = *theme.theme.dark();
+        } else {
+            theme.colors = *theme.theme.light();
+        }
 
         // Refresh the window if available
         if let Some(window) = window {
@@ -182,8 +190,7 @@ impl From<ThemeFamily> for Theme {
     fn from(family: ThemeFamily) -> Self {
         let platform = PlatformKind::platform();
         let mode = ThemeMode::default();
-        // Define the theme colors based on the appearance
-        let colors = family.colors();
+
         // Define the font family based on the platform.
         // TODO: Use native fonts on Linux too.
         let font_family = match platform {
@@ -191,13 +198,20 @@ impl From<ThemeFamily> for Theme {
             _ => ".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(5.),
+            radius: px(6.),
             radius_lg: px(10.),
             shadow: true,
             scrollbar_mode: ScrollbarMode::default(),
+            notification: NotificationSettings::default(),
             mode,
             colors: *colors,
             theme: Rc::new(family),

crates/theme/src/notification.rs

@@ -0,0 +1,30 @@
+use gpui::{Anchor, Pixels, px};
+
+use crate::{Edges, TITLEBAR_HEIGHT};
+
+/// The settings for notifications.
+#[derive(Debug, Clone)]
+pub struct NotificationSettings {
+    /// The placement of the notification, default: [`Anchor::TopRight`]
+    pub placement: Anchor,
+    /// The margins of the notification with respect to the window edges.
+    pub margins: Edges<Pixels>,
+    /// The maximum number of notifications to show at once, default: 10
+    pub max_items: usize,
+}
+
+impl Default for NotificationSettings {
+    fn default() -> Self {
+        let offset = px(16.);
+        Self {
+            placement: Anchor::TopRight,
+            margins: Edges {
+                top: TITLEBAR_HEIGHT + offset, // avoid overlap with title bar
+                right: offset,
+                bottom: offset,
+                left: offset,
+            },
+            max_items: 10,
+        }
+    }
+}

crates/theme/src/scrollbar_mode.rs

@@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize, JsonSchema)]
 pub enum ScrollbarMode {
     #[default]
-    Hover,
     Scrolling,
+    Hover,
     Always,
 }
 

crates/theme/src/theme.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::ThemeColors;
 
-#[derive(Debug, Clone, Copy, Default, PartialEq, PartialOrd, Eq, Hash)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, PartialOrd, Eq, Hash, Deserialize, Serialize)]
 pub enum ThemeMode {
     #[default]
     Light,
@@ -18,11 +18,11 @@ impl ThemeMode {
         matches!(self, Self::Dark)
     }
 
-    /// Return lower_case theme name: `light`, `dark`.
+    /// Return theme name: `light`, `dark`.
     pub fn name(&self) -> &'static str {
         match self {
-            ThemeMode::Light => "light",
-            ThemeMode::Dark => "dark",
+            ThemeMode::Light => "Light",
+            ThemeMode::Dark => "Dark",
         }
     }
 }
@@ -51,27 +51,37 @@ pub struct ThemeFamily {
     /// The URL of the theme.
     pub url: String,
 
-    /// The colors for the theme.
-    pub colors: ThemeColors,
+    /// The light colors for the theme.
+    pub light: ThemeColors,
+
+    /// The dark colors for the theme.
+    pub dark: ThemeColors,
 }
 
 impl Default for ThemeFamily {
     fn default() -> Self {
         ThemeFamily {
             id: "coop".into(),
-            name: "Coop Dark".into(),
+            name: "Coop Default Theme".into(),
             author: "Coop".into(),
             url: "https://github.com/lumehq/coop".into(),
-            colors: ThemeColors::colors(),
+            light: ThemeColors::light(),
+            dark: ThemeColors::dark(),
         }
     }
 }
 
 impl ThemeFamily {
-    /// Returns the colors for the theme.
+    /// Returns the light colors for the theme.
     #[inline(always)]
-    pub fn colors(&self) -> &ThemeColors {
-        &self.colors
+    pub fn light(&self) -> &ThemeColors {
+        &self.light
+    }
+
+    /// Returns the dark colors for the theme.
+    #[inline(always)]
+    pub fn dark(&self) -> &ThemeColors {
+        &self.dark
     }
 
     /// Load a theme family from a JSON file.
@@ -143,14 +153,14 @@ impl ThemeFamily {
     ///
     /// # fn main() -> anyhow::Result<()> {
     /// // Assuming the file exists at `assets/themes/my-theme.json`
-    /// let theme = ThemeFamily::from_assets("my-theme")?;
+    /// let theme = ThemeFamily::from_assets("themes/my-theme.json")?;
     ///
     /// println!("Loaded theme: {}", theme.name);
     /// # Ok(())
     /// # }
     /// ```
-    pub fn from_assets(name: &str) -> anyhow::Result<Self> {
-        let path = format!("assets/themes/{}.json", name);
+    pub fn from_assets(target: &str) -> anyhow::Result<Self> {
+        let path = format!("assets/{target}");
         Self::from_file(path)
     }
 }

crates/title_bar/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "titlebar"
+name = "title_bar"
 version.workspace = true
 edition.workspace = true
 publish.workspace = true
@@ -9,7 +9,9 @@ common = { path = "../common" }
 theme = { path = "../theme" }
 ui = { path = "../ui" }
 
+nostr-sdk.workspace = true
 gpui.workspace = true
+smol.workspace = true
 smallvec.workspace = true
 anyhow.workspace = true
 log.workspace = true

crates/title_bar/src/lib.rs

@@ -0,0 +1,172 @@
+#[cfg(target_os = "linux")]
+use gpui::MouseButton;
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    AnyElement, Context, Decorations, Hsla, InteractiveElement as _, IntoElement, ParentElement,
+    Pixels, Render, StatefulInteractiveElement as _, Styled, Window, WindowControlArea, px,
+};
+use smallvec::{SmallVec, smallvec};
+use theme::{ActiveTheme, CLIENT_SIDE_DECORATION_ROUNDING, PlatformKind};
+use ui::h_flex;
+
+#[cfg(target_os = "linux")]
+use crate::platforms::linux::LinuxWindowControls;
+use crate::platforms::mac::TRAFFIC_LIGHT_PADDING;
+use crate::platforms::windows::WindowsWindowControls;
+
+mod platforms;
+
+/// Titlebar
+pub struct TitleBar {
+    /// Children elements of the title bar.
+    children: SmallVec<[AnyElement; 2]>,
+
+    /// Whether the title bar is currently being moved.
+    should_move: bool,
+}
+
+impl TitleBar {
+    pub fn new() -> Self {
+        Self {
+            children: smallvec![],
+            should_move: false,
+        }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    pub fn height(&self, window: &mut Window) -> Pixels {
+        (1.75 * window.rem_size()).max(px(34.))
+    }
+
+    #[cfg(target_os = "windows")]
+    pub fn height(&self, _window: &mut Window) -> Pixels {
+        px(32.)
+    }
+
+    pub fn titlebar_color(&self, window: &mut Window, cx: &mut Context<Self>) -> Hsla {
+        if cfg!(any(target_os = "linux", target_os = "freebsd")) {
+            if window.is_window_active() && !self.should_move {
+                cx.theme().title_bar
+            } else {
+                cx.theme().title_bar_inactive
+            }
+        } else {
+            cx.theme().title_bar
+        }
+    }
+
+    pub fn set_children<T>(&mut self, children: T)
+    where
+        T: IntoIterator<Item = AnyElement>,
+    {
+        self.children = children.into_iter().collect();
+    }
+}
+
+impl Default for TitleBar {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Render for TitleBar {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let height = self.height(window);
+        let color = self.titlebar_color(window, cx);
+        let children = std::mem::take(&mut self.children);
+
+        #[cfg(target_os = "linux")]
+        let supported_controls = window.window_controls();
+        let decorations = window.window_decorations();
+
+        h_flex()
+            .window_control_area(WindowControlArea::Drag)
+            .h(height)
+            .w_full()
+            .map(|this| {
+                if window.is_fullscreen() {
+                    this.px_2()
+                } else if cx.theme().platform.is_mac() {
+                    this.pr_2().pl(px(TRAFFIC_LIGHT_PADDING))
+                } else {
+                    this.px_2()
+                }
+            })
+            .map(|this| match decorations {
+                Decorations::Server => this,
+                Decorations::Client { tiling } => this
+                    .when(!(tiling.top || tiling.right), |div| {
+                        div.rounded_tr(CLIENT_SIDE_DECORATION_ROUNDING)
+                    })
+                    .when(!(tiling.top || tiling.left), |div| {
+                        div.rounded_tl(CLIENT_SIDE_DECORATION_ROUNDING)
+                    }),
+            })
+            .bg(color)
+            .border_b_1()
+            .border_color(cx.theme().border)
+            .content_stretch()
+            .child(
+                h_flex()
+                    .id("title-bar")
+                    .justify_between()
+                    .w_full()
+                    .when(cx.theme().platform.is_mac(), |this| {
+                        this.on_click(|event, window, _| {
+                            if event.click_count() == 2 {
+                                window.titlebar_double_click();
+                            }
+                        })
+                    })
+                    .when(cx.theme().platform.is_linux(), |this| {
+                        this.on_click(|event, window, _| {
+                            if event.click_count() == 2 {
+                                window.zoom_window();
+                            }
+                        })
+                    })
+                    .when(!cx.theme().platform.is_mac(), |this| this.pr_2())
+                    .children(children),
+            )
+            .when(!window.is_fullscreen(), |this| match cx.theme().platform {
+                PlatformKind::Linux => {
+                    #[cfg(target_os = "linux")]
+                    if matches!(decorations, Decorations::Client { .. }) {
+                        this.child(LinuxWindowControls::new(None))
+                            .when(supported_controls.window_menu, |this| {
+                                this.on_mouse_down(MouseButton::Right, move |ev, window, _| {
+                                    window.show_window_menu(ev.position)
+                                })
+                            })
+                            .on_mouse_move(cx.listener(move |this, _ev, window, _| {
+                                if this.should_move {
+                                    this.should_move = false;
+                                    window.start_window_move();
+                                }
+                            }))
+                            .on_mouse_down_out(cx.listener(move |this, _ev, _window, _cx| {
+                                this.should_move = false;
+                            }))
+                            .on_mouse_up(
+                                MouseButton::Left,
+                                cx.listener(move |this, _ev, _window, _cx| {
+                                    this.should_move = false;
+                                }),
+                            )
+                            .on_mouse_down(
+                                MouseButton::Left,
+                                cx.listener(move |this, _ev, _window, _cx| {
+                                    this.should_move = true;
+                                }),
+                            )
+                    } else {
+                        this
+                    }
+                    #[cfg(not(target_os = "linux"))]
+                    this
+                }
+                PlatformKind::Windows => this.child(WindowsWindowControls::new(height)),
+                PlatformKind::Mac => this,
+            })
+    }
+}

crates/titlebar/src/lib.rs

@@ -1,188 +0,0 @@
-use gpui::prelude::FluentBuilder;
-#[cfg(target_os = "linux")]
-use gpui::MouseButton;
-#[cfg(not(target_os = "windows"))]
-use gpui::Pixels;
-use gpui::{
-    div, px, AnyElement, Context, Decorations, Hsla, InteractiveElement as _, IntoElement,
-    ParentElement, Render, StatefulInteractiveElement as _, Styled, Window, WindowControlArea,
-};
-use smallvec::{smallvec, SmallVec};
-use theme::{ActiveTheme, PlatformKind, CLIENT_SIDE_DECORATION_ROUNDING};
-use ui::h_flex;
-
-#[cfg(target_os = "linux")]
-use crate::platforms::linux::LinuxWindowControls;
-use crate::platforms::mac::TRAFFIC_LIGHT_PADDING;
-use crate::platforms::windows::WindowsWindowControls;
-
-mod platforms;
-
-/// Titlebar
-pub struct TitleBar {
-    /// Children elements of the title bar.
-    children: SmallVec<[AnyElement; 2]>,
-
-    /// Whether the title bar is currently being moved.
-    should_move: bool,
-}
-
-impl TitleBar {
-    pub fn new() -> Self {
-        Self {
-            children: smallvec![],
-            should_move: false,
-        }
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    pub fn height(&self, window: &mut Window) -> Pixels {
-        (1.75 * window.rem_size()).max(px(34.))
-    }
-
-    #[cfg(target_os = "windows")]
-    pub fn height(&self, _window: &mut Window) -> Pixels {
-        px(32.)
-    }
-
-    pub fn titlebar_color(&self, window: &mut Window, cx: &mut Context<Self>) -> Hsla {
-        if cfg!(any(target_os = "linux", target_os = "freebsd")) {
-            if window.is_window_active() && !self.should_move {
-                cx.theme().titlebar
-            } else {
-                cx.theme().titlebar_inactive
-            }
-        } else {
-            cx.theme().titlebar
-        }
-    }
-
-    pub fn set_children<T>(&mut self, children: T)
-    where
-        T: IntoIterator<Item = AnyElement>,
-    {
-        self.children = children.into_iter().collect();
-    }
-}
-
-impl Default for TitleBar {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Render for TitleBar {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let height = self.height(window);
-        let color = self.titlebar_color(window, cx);
-        let children = std::mem::take(&mut self.children);
-
-        #[cfg(target_os = "linux")]
-        let supported_controls = window.window_controls();
-        let decorations = window.window_decorations();
-
-        h_flex()
-            .window_control_area(WindowControlArea::Drag)
-            .h(height)
-            .w_full()
-            .map(|this| {
-                if window.is_fullscreen() {
-                    this.px_2()
-                } else if cx.theme().platform.is_mac() {
-                    this.pr_2().pl(px(TRAFFIC_LIGHT_PADDING))
-                } else {
-                    this.px_2()
-                }
-            })
-            .map(|this| match decorations {
-                Decorations::Server => this,
-                Decorations::Client { tiling } => this
-                    .when(!(tiling.top || tiling.right), |el| {
-                        el.rounded_tr(CLIENT_SIDE_DECORATION_ROUNDING)
-                    })
-                    .when(!(tiling.top || tiling.left), |el| {
-                        el.rounded_tl(CLIENT_SIDE_DECORATION_ROUNDING)
-                    }),
-            })
-            .bg(color)
-            .border_b_1()
-            .border_color(cx.theme().border)
-            .content_stretch()
-            .child(
-                h_flex()
-                    .id("title-bar")
-                    .justify_between()
-                    .w_full()
-                    .when(cx.theme().platform.is_mac(), |this| {
-                        this.on_click(|event, window, _| {
-                            if event.click_count() == 2 {
-                                window.titlebar_double_click();
-                            }
-                        })
-                    })
-                    .when(cx.theme().platform.is_linux(), |this| {
-                        this.on_click(|event, window, _| {
-                            if event.click_count() == 2 {
-                                window.zoom_window();
-                            }
-                        })
-                    })
-                    .children(children),
-            )
-            .child(
-                h_flex()
-                    .absolute()
-                    .top_0()
-                    .right_0()
-                    .pr_2()
-                    .h(height)
-                    .child(
-                        div().when(!window.is_fullscreen(), |this| match cx.theme().platform {
-                            PlatformKind::Linux => {
-                                #[cfg(target_os = "linux")]
-                                if matches!(decorations, Decorations::Client { .. }) {
-                                    this.child(LinuxWindowControls::new(None))
-                                        .when(supported_controls.window_menu, |this| {
-                                            this.on_mouse_down(
-                                                MouseButton::Right,
-                                                move |ev, window, _| {
-                                                    window.show_window_menu(ev.position)
-                                                },
-                                            )
-                                        })
-                                        .on_mouse_move(cx.listener(move |this, _ev, window, _| {
-                                            if this.should_move {
-                                                this.should_move = false;
-                                                window.start_window_move();
-                                            }
-                                        }))
-                                        .on_mouse_down_out(cx.listener(
-                                            move |this, _ev, _window, _cx| {
-                                                this.should_move = false;
-                                            },
-                                        ))
-                                        .on_mouse_up(
-                                            MouseButton::Left,
-                                            cx.listener(move |this, _ev, _window, _cx| {
-                                                this.should_move = false;
-                                            }),
-                                        )
-                                        .on_mouse_down(
-                                            MouseButton::Left,
-                                            cx.listener(move |this, _ev, _window, _cx| {
-                                                this.should_move = true;
-                                            }),
-                                        )
-                                } else {
-                                    this
-                                }
-                                #[cfg(not(target_os = "linux"))]
-                                this
-                            }
-                            PlatformKind::Windows => this.child(WindowsWindowControls::new(height)),
-                            PlatformKind::Mac => this,
-                        }),
-                    ),
-            )
-    }
-}

crates/ui/Cargo.toml

@@ -22,5 +22,6 @@ uuid = "1.10"
 regex = "1"
 image = "0.25.1"
 lsp-types = "0.97.0"
-rope = { git = "https://github.com/zed-industries/zed" }
+ropey = { version = "=2.0.0-beta.1", features = ["metric_lines_lf", "metric_utf16"] }
 sum_tree = { git = "https://github.com/zed-industries/zed" }
+tree-sitter = "0.26"

crates/ui/LICENSE

@@ -1,191 +0,0 @@
-Copyright 2024 Longbridge <https://longbridge.com>
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

crates/ui/src/anchored.rs

@@ -1,333 +0,0 @@
-//! This is a fork of gpui's anchored element that adds support for offsetting
-//! https://github.com/zed-industries/zed/blob/b06f4088a3565c5e30663106ff79c1ced645d87a/crates/gpui/src/elements/anchored.rs
-use gpui::{
-    point, px, AnyElement, App, Axis, Bounds, Display, Edges, Element, GlobalElementId, Half,
-    InspectorElementId, IntoElement, LayoutId, ParentElement, Pixels, Point, Position, Size, Style,
-    Window,
-};
-use smallvec::SmallVec;
-
-use crate::Anchor;
-
-/// The state that the anchored element element uses to track its children.
-pub struct AnchoredState {
-    child_layout_ids: SmallVec<[LayoutId; 4]>,
-}
-
-/// An anchored element that can be used to display UI that
-/// will avoid overflowing the window bounds.
-pub(crate) struct Anchored {
-    children: SmallVec<[AnyElement; 2]>,
-    anchor_corner: Anchor,
-    fit_mode: AnchoredFitMode,
-    anchor_position: Option<Point<Pixels>>,
-    position_mode: AnchoredPositionMode,
-    offset: Option<Point<Pixels>>,
-}
-
-/// anchored gives you an element that will avoid overflowing the window bounds.
-/// Its children should have no margin to avoid measurement issues.
-pub(crate) fn anchored() -> Anchored {
-    Anchored {
-        children: SmallVec::new(),
-        anchor_corner: Anchor::TopLeft,
-        fit_mode: AnchoredFitMode::SwitchAnchor,
-        anchor_position: None,
-        position_mode: AnchoredPositionMode::Window,
-        offset: None,
-    }
-}
-
-#[allow(dead_code)]
-impl Anchored {
-    /// Sets which corner of the anchored element should be anchored to the current position.
-    pub fn anchor(mut self, anchor: Anchor) -> Self {
-        self.anchor_corner = anchor;
-        self
-    }
-
-    /// Sets the position in window coordinates
-    /// (otherwise the location the anchored element is rendered is used)
-    pub fn position(mut self, anchor: Point<Pixels>) -> Self {
-        self.anchor_position = Some(anchor);
-        self
-    }
-
-    /// Offset the final position by this amount.
-    /// Useful when you want to anchor to an element but offset from it, such as in PopoverMenu.
-    pub fn offset(mut self, offset: Point<Pixels>) -> Self {
-        self.offset = Some(offset);
-        self
-    }
-
-    /// Sets the position mode for this anchored element. Local will have this
-    /// interpret its [`Anchored::position`] as relative to the parent element.
-    /// While Window will have it interpret the position as relative to the window.
-    pub fn position_mode(mut self, mode: AnchoredPositionMode) -> Self {
-        self.position_mode = mode;
-        self
-    }
-
-    /// Snap to window edge instead of switching anchor corner when an overflow would occur.
-    pub fn snap_to_window(mut self) -> Self {
-        self.fit_mode = AnchoredFitMode::SnapToWindow;
-        self
-    }
-
-    /// Snap to window edge and leave some margins.
-    pub fn snap_to_window_with_margin(mut self, edges: impl Into<Edges<Pixels>>) -> Self {
-        self.fit_mode = AnchoredFitMode::SnapToWindowWithMargin(edges.into());
-        self
-    }
-}
-
-impl ParentElement for Anchored {
-    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
-        self.children.extend(elements)
-    }
-}
-
-impl Element for Anchored {
-    type PrepaintState = ();
-    type RequestLayoutState = AnchoredState;
-
-    fn id(&self) -> Option<gpui::ElementId> {
-        None
-    }
-
-    fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
-        None
-    }
-
-    fn request_layout(
-        &mut self,
-        _id: Option<&GlobalElementId>,
-        _inspector_id: Option<&InspectorElementId>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> (gpui::LayoutId, Self::RequestLayoutState) {
-        let child_layout_ids = self
-            .children
-            .iter_mut()
-            .map(|child| child.request_layout(window, cx))
-            .collect::<SmallVec<_>>();
-
-        let anchored_style = Style {
-            position: Position::Absolute,
-            display: Display::Flex,
-            ..Style::default()
-        };
-
-        let layout_id = window.request_layout(anchored_style, child_layout_ids.iter().copied(), cx);
-
-        (layout_id, AnchoredState { child_layout_ids })
-    }
-
-    fn prepaint(
-        &mut self,
-        _id: Option<&GlobalElementId>,
-        _inspector_id: Option<&InspectorElementId>,
-        bounds: Bounds<Pixels>,
-        request_layout: &mut Self::RequestLayoutState,
-        window: &mut Window,
-        cx: &mut App,
-    ) {
-        if request_layout.child_layout_ids.is_empty() {
-            return;
-        }
-
-        let mut child_min = point(Pixels::MAX, Pixels::MAX);
-        let mut child_max = Point::default();
-        for child_layout_id in &request_layout.child_layout_ids {
-            let child_bounds = window.layout_bounds(*child_layout_id);
-            child_min = child_min.min(&child_bounds.origin);
-            child_max = child_max.max(&child_bounds.bottom_right());
-        }
-        let size: Size<Pixels> = (child_max - child_min).into();
-
-        let (origin, mut desired) = self.position_mode.get_position_and_bounds(
-            self.anchor_position,
-            self.anchor_corner,
-            size,
-            bounds,
-            self.offset,
-        );
-
-        let limits = Bounds {
-            origin: Point::default(),
-            size: window.viewport_size(),
-        };
-
-        if self.fit_mode == AnchoredFitMode::SwitchAnchor {
-            let mut anchor_corner = self.anchor_corner;
-
-            if desired.left() < limits.left() || desired.right() > limits.right() {
-                let switched = Bounds::from_corner_and_size(
-                    anchor_corner
-                        .other_side_corner_along(Axis::Horizontal)
-                        .into(),
-                    origin,
-                    size,
-                );
-                if !(switched.left() < limits.left() || switched.right() > limits.right()) {
-                    anchor_corner = anchor_corner.other_side_corner_along(Axis::Horizontal);
-                    desired = switched
-                }
-            }
-
-            if desired.top() < limits.top() || desired.bottom() > limits.bottom() {
-                let switched = Bounds::from_corner_and_size(
-                    anchor_corner.other_side_corner_along(Axis::Vertical).into(),
-                    origin,
-                    size,
-                );
-                if !(switched.top() < limits.top() || switched.bottom() > limits.bottom()) {
-                    desired = switched;
-                }
-            }
-        }
-
-        let client_inset = window.client_inset().unwrap_or(px(0.));
-        let edges = match self.fit_mode {
-            AnchoredFitMode::SnapToWindowWithMargin(edges) => edges,
-            _ => Edges::default(),
-        }
-        .map(|edge| *edge + client_inset);
-
-        // Snap the horizontal edges of the anchored element to the horizontal edges of the window if
-        // its horizontal bounds overflow, aligning to the left if it is wider than the limits.
-        if desired.right() > limits.right() {
-            desired.origin.x -= desired.right() - limits.right() + edges.right;
-        }
-        if desired.left() < limits.left() {
-            desired.origin.x = limits.origin.x + edges.left;
-        }
-
-        // Snap the vertical edges of the anchored element to the vertical edges of the window if
-        // its vertical bounds overflow, aligning to the top if it is taller than the limits.
-        if desired.bottom() > limits.bottom() {
-            desired.origin.y -= desired.bottom() - limits.bottom() + edges.bottom;
-        }
-        if desired.top() < limits.top() {
-            desired.origin.y = limits.origin.y + edges.top;
-        }
-
-        let offset = desired.origin - bounds.origin;
-        let offset = point(offset.x.round(), offset.y.round());
-
-        window.with_element_offset(offset, |window| {
-            for child in &mut self.children {
-                child.prepaint(window, cx);
-            }
-        })
-    }
-
-    fn paint(
-        &mut self,
-        _id: Option<&GlobalElementId>,
-        _inspector_id: Option<&InspectorElementId>,
-        _bounds: Bounds<Pixels>,
-        _request_layout: &mut Self::RequestLayoutState,
-        _prepaint: &mut Self::PrepaintState,
-        window: &mut Window,
-        cx: &mut App,
-    ) {
-        for child in &mut self.children {
-            child.paint(window, cx);
-        }
-    }
-}
-
-impl IntoElement for Anchored {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
-
-/// Which algorithm to use when fitting the anchored element to be inside the window.
-#[allow(dead_code)]
-#[derive(Copy, Clone, PartialEq)]
-pub enum AnchoredFitMode {
-    /// Snap the anchored element to the window edge.
-    SnapToWindow,
-    /// Snap to window edge and leave some margins.
-    SnapToWindowWithMargin(Edges<Pixels>),
-    /// Switch which corner anchor this anchored element is attached to.
-    SwitchAnchor,
-}
-
-/// Which algorithm to use when positioning the anchored element.
-#[allow(dead_code)]
-#[derive(Copy, Clone, PartialEq)]
-pub enum AnchoredPositionMode {
-    /// Position the anchored element relative to the window.
-    Window,
-    /// Position the anchored element relative to its parent.
-    Local,
-}
-
-impl AnchoredPositionMode {
-    fn get_position_and_bounds(
-        &self,
-        anchor_position: Option<Point<Pixels>>,
-        anchor_corner: Anchor,
-        size: Size<Pixels>,
-        bounds: Bounds<Pixels>,
-        offset: Option<Point<Pixels>>,
-    ) -> (Point<Pixels>, Bounds<Pixels>) {
-        let offset = offset.unwrap_or_default();
-
-        match self {
-            AnchoredPositionMode::Window => {
-                let anchor_position = anchor_position.unwrap_or(bounds.origin);
-                let bounds =
-                    Self::from_corner_and_size(anchor_corner, anchor_position + offset, size);
-                (anchor_position, bounds)
-            }
-            AnchoredPositionMode::Local => {
-                let anchor_position = anchor_position.unwrap_or_default();
-                let bounds = Self::from_corner_and_size(
-                    anchor_corner,
-                    bounds.origin + anchor_position + offset,
-                    size,
-                );
-                (anchor_position, bounds)
-            }
-        }
-    }
-
-    // Ref https://github.com/zed-industries/zed/blob/b06f4088a3565c5e30663106ff79c1ced645d87a/crates/gpui/src/geometry.rs#L863
-    fn from_corner_and_size(
-        anchor: Anchor,
-        origin: Point<Pixels>,
-        size: Size<Pixels>,
-    ) -> Bounds<Pixels> {
-        let origin = match anchor {
-            Anchor::TopLeft => origin,
-            Anchor::TopCenter => Point {
-                x: origin.x - size.width.half(),
-                y: origin.y,
-            },
-            Anchor::TopRight => Point {
-                x: origin.x - size.width,
-                y: origin.y,
-            },
-            Anchor::BottomLeft => Point {
-                x: origin.x,
-                y: origin.y - size.height,
-            },
-            Anchor::BottomCenter => Point {
-                x: origin.x - size.width.half(),
-                y: origin.y - size.height,
-            },
-            Anchor::BottomRight => Point {
-                x: origin.x - size.width,
-                y: origin.y - size.height,
-            },
-        };
-
-        Bounds { origin, size }
-    }
-}

crates/ui/src/avatar.rs

@@ -1,10 +1,24 @@
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    div, img, px, rems, AbsoluteLength, App, Hsla, ImageSource, Img, IntoElement, ParentElement,
-    RenderOnce, Styled, StyledImage, Window,
+    AbsoluteLength, App, Div, Hsla, ImageSource, Img, InteractiveElement, Interactivity,
+    IntoElement, ParentElement, RenderOnce, StyleRefinement, Styled, StyledImage, Window, div, img,
+    px,
 };
 use theme::ActiveTheme;
 
+use crate::{Selectable, Sizable, Size};
+
+/// Returns the size of the avatar based on the given [`Size`].
+pub(super) fn avatar_size(size: Size) -> AbsoluteLength {
+    match size {
+        Size::Large => px(64.).into(),
+        Size::Medium => px(32.).into(),
+        Size::Small => px(24.).into(),
+        Size::XSmall => px(20.).into(),
+        Size::Size(size) => size.into(),
+    }
+}
+
 /// An element that renders a user avatar with customizable appearance options.
 ///
 /// # Examples
@@ -18,18 +32,24 @@ use theme::ActiveTheme;
 /// ```
 #[derive(IntoElement)]
 pub struct Avatar {
+    base: Div,
     image: Img,
-    size: Option<AbsoluteLength>,
+    style: StyleRefinement,
+    size: Size,
     border_color: Option<Hsla>,
+    selected: bool,
 }
 
 impl Avatar {
     /// Creates a new avatar element with the specified image source.
     pub fn new(src: impl Into<ImageSource>) -> Self {
         Avatar {
+            base: div(),
             image: img(src),
-            size: None,
+            style: StyleRefinement::default(),
+            size: Size::Medium,
             border_color: None,
+            selected: false,
         }
     }
 
@@ -56,14 +76,38 @@ impl Avatar {
         self.border_color = Some(color.into());
         self
     }
+}
 
-    /// Size overrides the avatar size. By default they are 1rem.
-    pub fn size<L: Into<AbsoluteLength>>(mut self, size: impl Into<Option<L>>) -> Self {
-        self.size = size.into().map(Into::into);
+impl Sizable for Avatar {
+    fn with_size(mut self, size: impl Into<Size>) -> Self {
+        self.size = size.into();
         self
     }
 }
 
+impl Styled for Avatar {
+    fn style(&mut self) -> &mut StyleRefinement {
+        &mut self.style
+    }
+}
+
+impl Selectable for Avatar {
+    fn is_selected(&self) -> bool {
+        self.selected
+    }
+
+    fn selected(mut self, selected: bool) -> Self {
+        self.selected = selected;
+        self
+    }
+}
+
+impl InteractiveElement for Avatar {
+    fn interactivity(&mut self) -> &mut Interactivity {
+        self.base.interactivity()
+    }
+}
+
 impl RenderOnce for Avatar {
     fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
         let border_width = if self.border_color.is_some() {
@@ -71,8 +115,7 @@ impl RenderOnce for Avatar {
         } else {
             px(0.)
         };
-
-        let image_size = self.size.unwrap_or_else(|| rems(1.).into());
+        let image_size = avatar_size(self.size);
         let container_size = image_size.to_pixels(window.rem_size()) + border_width * 2.;
 
         div()

crates/ui/src/button.rs

@@ -131,8 +131,8 @@ pub struct Button {
 
     rounded: bool,
     compact: bool,
-    underline: bool,
     caret: bool,
+    indicator: bool,
 
     on_click: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
     on_hover: Option<Rc<dyn Fn(&bool, &mut Window, &mut App)>>,
@@ -162,7 +162,7 @@ impl Button {
             variant: ButtonVariant::default(),
             disabled: false,
             selected: false,
-            underline: false,
+            indicator: false,
             compact: false,
             caret: false,
             rounded: false,
@@ -219,9 +219,9 @@ impl Button {
         self
     }
 
-    /// Set true to show the underline indicator.
-    pub fn underline(mut self) -> Self {
-        self.underline = true;
+    /// Set true to show the indicator.
+    pub fn indicator(mut self) -> Self {
+        self.indicator = true;
         self
     }
 
@@ -455,6 +455,17 @@ impl RenderOnce for Button {
                     })
             })
             .text_color(normal_style.fg)
+            .when(self.indicator && !self.disabled, |this| {
+                this.child(
+                    div()
+                        .absolute()
+                        .bottom_px()
+                        .right_px()
+                        .size_1()
+                        .rounded_full()
+                        .bg(gpui::green()),
+                )
+            })
             .when(!self.disabled && !self.selected, |this| {
                 this.bg(normal_style.bg)
                     .hover(|this| {
@@ -470,17 +481,6 @@ impl RenderOnce for Button {
                 let selected_style = style.selected(cx);
                 this.bg(selected_style.bg).text_color(selected_style.fg)
             })
-            .when(self.selected && self.underline, |this| {
-                this.child(
-                    div()
-                        .absolute()
-                        .bottom_0()
-                        .left_0()
-                        .h_px()
-                        .w_full()
-                        .bg(cx.theme().element_background),
-                )
-            })
             .when(self.disabled, |this| {
                 let disabled_style = style.disabled(cx);
                 this.cursor_not_allowed()
@@ -513,7 +513,7 @@ impl ButtonVariant {
     fn bg_color(&self, cx: &App) -> Hsla {
         match self {
             ButtonVariant::Primary => cx.theme().element_background,
-            ButtonVariant::Secondary => cx.theme().elevated_surface_background,
+            ButtonVariant::Secondary => cx.theme().secondary_background,
             ButtonVariant::Danger => cx.theme().danger_background,
             ButtonVariant::Warning => cx.theme().warning_background,
             ButtonVariant::Ghost { alt } => {
@@ -531,7 +531,7 @@ impl ButtonVariant {
     fn text_color(&self, cx: &App) -> Hsla {
         match self {
             ButtonVariant::Primary => cx.theme().element_foreground,
-            ButtonVariant::Secondary => cx.theme().text_muted,
+            ButtonVariant::Secondary => cx.theme().secondary_foreground,
             ButtonVariant::Danger => cx.theme().danger_foreground,
             ButtonVariant::Warning => cx.theme().warning_foreground,
             ButtonVariant::Transparent => cx.theme().text_placeholder,

crates/ui/src/checkbox.rs

@@ -1,49 +1,109 @@
+use std::rc::Rc;
+use std::time::Duration;
+
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    div, svg, App, ElementId, InteractiveElement, IntoElement, ParentElement, RenderOnce,
-    SharedString, StatefulInteractiveElement as _, Styled as _, Window,
+    div, px, relative, rems, svg, Animation, AnimationExt, AnyElement, App, Div, ElementId,
+    InteractiveElement, IntoElement, ParentElement, RenderOnce, SharedString,
+    StatefulInteractiveElement, StyleRefinement, Styled, Window,
 };
 use theme::ActiveTheme;
 
-use crate::{h_flex, v_flex, Disableable, IconName, Selectable};
-
-type OnClick = Option<Box<dyn Fn(&bool, &mut Window, &mut App) + 'static>>;
+use crate::icon::IconNamed;
+use crate::{v_flex, Disableable, IconName, Selectable, Sizable, Size, StyledExt as _};
 
 /// A Checkbox element.
+#[allow(clippy::type_complexity)]
 #[derive(IntoElement)]
 pub struct Checkbox {
     id: ElementId,
+    base: Div,
+    style: StyleRefinement,
     label: Option<SharedString>,
+    children: Vec<AnyElement>,
     checked: bool,
     disabled: bool,
-    on_click: OnClick,
+    size: Size,
+    tab_stop: bool,
+    tab_index: isize,
+    on_click: Option<Rc<dyn Fn(&bool, &mut Window, &mut App) + 'static>>,
 }
 
 impl Checkbox {
+    /// Create a new Checkbox with the given id.
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
+            base: div(),
+            style: StyleRefinement::default(),
             label: None,
+            children: Vec::new(),
             checked: false,
             disabled: false,
+            size: Size::default(),
             on_click: None,
+            tab_stop: true,
+            tab_index: 0,
         }
     }
 
+    /// Set the label for the checkbox.
     pub fn label(mut self, label: impl Into<SharedString>) -> Self {
         self.label = Some(label.into());
         self
     }
 
+    /// Set the checked state for the checkbox.
     pub fn checked(mut self, checked: bool) -> Self {
         self.checked = checked;
         self
     }
 
+    /// Set the click handler for the checkbox.
+    ///
+    /// The `&bool` parameter indicates the new checked state after the click.
     pub fn on_click(mut self, handler: impl Fn(&bool, &mut Window, &mut App) + 'static) -> Self {
-        self.on_click = Some(Box::new(handler));
+        self.on_click = Some(Rc::new(handler));
         self
     }
+
+    /// Set the tab stop for the checkbox, default is true.
+    pub fn tab_stop(mut self, tab_stop: bool) -> Self {
+        self.tab_stop = tab_stop;
+        self
+    }
+
+    /// Set the tab index for the checkbox, default is 0.
+    pub fn tab_index(mut self, tab_index: isize) -> Self {
+        self.tab_index = tab_index;
+        self
+    }
+
+    #[allow(clippy::type_complexity)]
+    fn handle_click(
+        on_click: &Option<Rc<dyn Fn(&bool, &mut Window, &mut App) + 'static>>,
+        checked: bool,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        let new_checked = !checked;
+        if let Some(f) = on_click {
+            (f)(&new_checked, window, cx);
+        }
+    }
+}
+
+impl InteractiveElement for Checkbox {
+    fn interactivity(&mut self) -> &mut gpui::Interactivity {
+        self.base.interactivity()
+    }
+}
+impl StatefulInteractiveElement for Checkbox {}
+
+impl Styled for Checkbox {
+    fn style(&mut self) -> &mut gpui::StyleRefinement {
+        &mut self.style
+    }
 }
 
 impl Disableable for Checkbox {
@@ -63,64 +123,190 @@ impl Selectable for Checkbox {
     }
 }
 
-impl RenderOnce for Checkbox {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let icon_color = if self.disabled {
-            cx.theme().icon_muted
-        } else {
-            cx.theme().icon_accent
-        };
-
-        h_flex()
-            .id(self.id)
-            .gap_2()
-            .items_center()
-            .child(
-                v_flex()
-                    .flex_shrink_0()
-                    .relative()
-                    .rounded_sm()
-                    .size_5()
-                    .bg(cx.theme().elevated_surface_background)
-                    .child(
-                        svg()
-                            .absolute()
-                            .top_0p5()
-                            .left_0p5()
-                            .size_4()
-                            .text_color(icon_color)
-                            .map(|this| match self.checked {
-                                true => this.path(IconName::Check.path()),
-                                _ => this,
-                            }),
-                    ),
-            )
-            .map(|this| {
-                if let Some(label) = self.label {
-                    this.text_color(cx.theme().text_muted).child(
-                        div()
-                            .w_full()
-                            .overflow_x_hidden()
-                            .text_ellipsis()
-                            .text_sm()
-                            .child(label),
-                    )
-                } else {
-                    this
-                }
-            })
-            .when(self.disabled, |this| {
-                this.cursor_not_allowed()
-                    .text_color(cx.theme().text_placeholder)
-            })
-            .when_some(
-                self.on_click.filter(|_| !self.disabled),
-                |this, on_click| {
-                    this.on_click(move |_, window, cx| {
-                        let checked = !self.checked;
-                        on_click(&checked, window, cx);
-                    })
-                },
-            )
+impl ParentElement for Checkbox {
+    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
+        self.children.extend(elements);
+    }
+}
+
+impl Sizable for Checkbox {
+    fn with_size(mut self, size: impl Into<Size>) -> Self {
+        self.size = size.into();
+        self
+    }
+}
+
+pub(crate) fn checkbox_check_icon(
+    id: ElementId,
+    size: Size,
+    checked: bool,
+    disabled: bool,
+    window: &mut Window,
+    cx: &mut App,
+) -> impl IntoElement {
+    let toggle_state = window.use_keyed_state(id, cx, |_, _| checked);
+
+    let color = if disabled {
+        cx.theme().text.opacity(0.5)
+    } else {
+        cx.theme().text
+    };
+
+    svg()
+        .absolute()
+        .top_px()
+        .left_px()
+        .map(|this| match size {
+            Size::XSmall => this.size_2(),
+            Size::Small => this.size_2p5(),
+            Size::Medium => this.size_3(),
+            Size::Large => this.size_3p5(),
+            _ => this.size_3(),
+        })
+        .text_color(color)
+        .map(|this| match checked {
+            true => this.path(IconName::Check.path()),
+            _ => this,
+        })
+        .map(|this| {
+            if !disabled && checked != *toggle_state.read(cx) {
+                let duration = Duration::from_secs_f64(0.25);
+                cx.spawn({
+                    let toggle_state = toggle_state.clone();
+                    async move |cx| {
+                        cx.background_executor().timer(duration).await;
+                        toggle_state.update(cx, |this, _| *this = checked);
+                    }
+                })
+                .detach();
+
+                this.with_animation(
+                    ElementId::NamedInteger("toggle".into(), checked as u64),
+                    Animation::new(Duration::from_secs_f64(0.25)),
+                    move |this, delta| {
+                        this.opacity(if checked { 1.0 * delta } else { 1.0 - delta })
+                    },
+                )
+                .into_any_element()
+            } else {
+                this.into_any_element()
+            }
+        })
+}
+
+impl RenderOnce for Checkbox {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let focus_handle = window
+            .use_keyed_state(self.id.clone(), cx, |_, cx| cx.focus_handle())
+            .read(cx)
+            .clone();
+
+        let checked = self.checked;
+        let radius = cx.theme().radius.min(px(4.));
+
+        let border_color = if checked {
+            cx.theme().border_focused
+        } else {
+            cx.theme().border
+        };
+
+        let color = if self.disabled {
+            border_color.opacity(0.5)
+        } else {
+            border_color
+        };
+
+        div().child(
+            self.base
+                .id(self.id.clone())
+                .when(!self.disabled, |this| {
+                    this.track_focus(
+                        &focus_handle
+                            .tab_stop(self.tab_stop)
+                            .tab_index(self.tab_index),
+                    )
+                })
+                .h_flex()
+                .gap_2()
+                .items_start()
+                .line_height(relative(1.))
+                .text_color(cx.theme().text)
+                .map(|this| match self.size {
+                    Size::XSmall => this.text_xs(),
+                    Size::Small => this.text_sm(),
+                    Size::Medium => this.text_base(),
+                    Size::Large => this.text_lg(),
+                    _ => this,
+                })
+                .when(self.disabled, |this| this.text_color(cx.theme().text_muted))
+                .rounded(cx.theme().radius * 0.5)
+                .refine_style(&self.style)
+                .child(
+                    div()
+                        .relative()
+                        .map(|this| match self.size {
+                            Size::XSmall => this.size_3(),
+                            Size::Small => this.size_3p5(),
+                            Size::Medium => this.size_4(),
+                            Size::Large => this.size(rems(1.125)),
+                            _ => this.size_4(),
+                        })
+                        .flex_shrink_0()
+                        .border_1()
+                        .border_color(color)
+                        .rounded(radius)
+                        .when(cx.theme().shadow && !self.disabled, |this| this.shadow_xs())
+                        .map(|this| match checked {
+                            false => this.bg(cx.theme().background),
+                            _ => this.bg(color),
+                        })
+                        .child(checkbox_check_icon(
+                            self.id,
+                            self.size,
+                            checked,
+                            self.disabled,
+                            window,
+                            cx,
+                        )),
+                )
+                .when(self.label.is_some() || !self.children.is_empty(), |this| {
+                    this.child(
+                        v_flex()
+                            .w_full()
+                            .line_height(relative(1.2))
+                            .gap_1()
+                            .map(|this| {
+                                if let Some(label) = self.label {
+                                    this.child(
+                                        div()
+                                            .size_full()
+                                            .text_color(cx.theme().text)
+                                            .when(self.disabled, |this| {
+                                                this.text_color(cx.theme().text_muted)
+                                            })
+                                            .line_height(relative(1.))
+                                            .child(label),
+                                    )
+                                } else {
+                                    this
+                                }
+                            })
+                            .children(self.children),
+                    )
+                })
+                .on_mouse_down(gpui::MouseButton::Left, |_, window, _| {
+                    // Avoid focus on mouse down.
+                    window.prevent_default();
+                })
+                .when(!self.disabled, |this| {
+                    this.on_click({
+                        let on_click = self.on_click.clone();
+                        move |_, window, cx| {
+                            window.prevent_default();
+                            Self::handle_click(&on_click, checked, window, cx);
+                        }
+                    })
+                }),
+        )
     }
 }

crates/ui/src/dock/dock.rs

@@ -3,20 +3,26 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    div, px, App, AppContext, Axis, Context, Element, Entity, IntoElement, MouseMoveEvent,
-    MouseUpEvent, ParentElement as _, Pixels, Point, Render, Style, Styled as _, WeakEntity,
-    Window,
+    App, AppContext, Axis, Context, Element, Empty, Entity, IntoElement, MouseMoveEvent,
+    MouseUpEvent, ParentElement as _, Pixels, Point, Render, Style, StyleRefinement, Styled as _,
+    WeakEntity, Window, div, px,
 };
-use ui::StyledExt;
 
 use super::{DockArea, DockItem};
-use crate::panel::PanelView;
-use crate::resizable::{resize_handle, PANEL_MIN_SIZE};
-use crate::tab_panel::TabPanel;
+use crate::StyledExt;
+use crate::dock::panel::PanelView;
+use crate::dock::tab_panel::TabPanel;
+use crate::resizable::{PANEL_MIN_SIZE, resize_handle};
 
-#[derive(Clone, Render)]
+#[derive(Clone)]
 struct ResizePanel;
 
+impl Render for ResizePanel {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        Empty
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DockPlacement {
     Center,
@@ -265,22 +271,22 @@ impl Dock {
         let mut right_dock_size = px(0.0);
 
         // Get the size of the left dock if it's open and not the current dock
-        if let Some(left_dock) = &dock_area.left_dock {
-            if left_dock.entity_id() != cx.entity().entity_id() {
-                let left_dock_read = left_dock.read(cx);
-                if left_dock_read.is_open() {
-                    left_dock_size = left_dock_read.size;
-                }
+        if let Some(left_dock) = &dock_area.left_dock
+            && left_dock.entity_id() != cx.entity().entity_id()
+        {
+            let left_dock_read = left_dock.read(cx);
+            if left_dock_read.is_open() {
+                left_dock_size = left_dock_read.size;
             }
         }
 
         // Get the size of the right dock if it's open and not the current dock
-        if let Some(right_dock) = &dock_area.right_dock {
-            if right_dock.entity_id() != cx.entity().entity_id() {
-                let right_dock_read = right_dock.read(cx);
-                if right_dock_read.is_open() {
-                    right_dock_size = right_dock_read.size;
-                }
+        if let Some(right_dock) = &dock_area.right_dock
+            && right_dock.entity_id() != cx.entity().entity_id()
+        {
+            let right_dock_read = right_dock.read(cx);
+            if right_dock_read.is_open() {
+                right_dock_size = right_dock_read.size;
             }
         }
 
@@ -321,6 +327,8 @@ impl Render for Dock {
             return div();
         }
 
+        let cache_style = StyleRefinement::default().absolute().size_full();
+
         div()
             .relative()
             .overflow_hidden()
@@ -336,7 +344,7 @@ impl Render for Dock {
             .map(|this| match &self.panel {
                 DockItem::Split { view, .. } => this.child(view.clone()),
                 DockItem::Tabs { view, .. } => this.child(view.clone()),
-                DockItem::Panel { view, .. } => this.child(view.clone().view()),
+                DockItem::Panel { view, .. } => this.child(view.clone().view().cached(cache_style)),
             })
             .child(self.render_resize_handle(window, cx))
             .child(DockElement {

crates/ui/src/dock/mod.rs

@@ -2,23 +2,24 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    actions, div, px, AnyElement, AnyView, App, AppContext, Axis, Bounds, Context, Edges, Entity,
+    AnyElement, AnyView, App, AppContext, Axis, Bounds, Context, Decorations, Edges, Entity,
     EntityId, EventEmitter, Focusable, InteractiveElement as _, IntoElement, ParentElement as _,
-    Pixels, Render, SharedString, Styled, Subscription, WeakEntity, Window,
+    Pixels, Render, SharedString, Styled, Subscription, WeakEntity, Window, actions, div, px,
 };
-use ui::ElementExt;
+use theme::CLIENT_SIDE_DECORATION_ROUNDING;
 
-use crate::dock::{Dock, DockPlacement};
-use crate::panel::{Panel, PanelEvent, PanelStyle, PanelView};
-use crate::stack_panel::StackPanel;
-use crate::tab_panel::TabPanel;
+use crate::ElementExt;
 
-pub mod dock;
-pub mod panel;
-pub mod resizable;
-pub mod stack_panel;
-pub mod tab;
-pub mod tab_panel;
+#[allow(clippy::module_inception)]
+mod dock;
+mod panel;
+mod stack_panel;
+mod tab_panel;
+
+pub use dock::*;
+pub use panel::*;
+pub use stack_panel::*;
+pub use tab_panel::*;
 
 actions!(dock, [ToggleZoom, ClosePanel]);
 
@@ -204,19 +205,16 @@ impl DockItem {
     /// Returns all panel ids
     pub fn panel_ids(&self, cx: &App) -> Vec<SharedString> {
         match self {
-            Self::Tabs { view, .. } => view.read(cx).panel_ids(cx),
-            Self::Split { items, .. } => {
-                let mut total = vec![];
-
-                for item in items.iter() {
-                    if let DockItem::Tabs { view, .. } = item {
-                        total.extend(view.read(cx).panel_ids(cx));
-                    }
-                }
-
-                total
-            }
             Self::Panel { .. } => vec![],
+            Self::Tabs { view, .. } => view.read(cx).panel_ids(cx),
+            Self::Split { items, .. } => items
+                .iter()
+                .filter_map(|item| match item {
+                    DockItem::Tabs { view, .. } => Some(view.read(cx).panel_ids(cx)),
+                    _ => None,
+                })
+                .flatten()
+                .collect(),
         }
     }
 
@@ -592,17 +590,13 @@ impl DockArea {
                 }
             }
             DockPlacement::Right => {
-                if let Some(dock) = self.right_dock.as_ref() {
-                    dock.update(cx, |dock, cx| dock.add_panel(panel, window, cx))
-                } else {
-                    self.set_right_dock(
-                        DockItem::tabs(vec![panel], None, &weak_self, window, cx),
-                        Some(px(320.)),
-                        true,
-                        window,
-                        cx,
-                    );
-                }
+                self.set_right_dock(
+                    DockItem::tabs(vec![panel], None, &weak_self, window, cx),
+                    Some(px(320.)),
+                    true,
+                    window,
+                    cx,
+                );
             }
             DockPlacement::Center => {
                 self.items
@@ -751,6 +745,7 @@ impl EventEmitter<DockEvent> for DockArea {}
 impl Render for DockArea {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let view = cx.entity().clone();
+        let decorations = window.window_decorations();
 
         div()
             .id("dock-area")
@@ -760,7 +755,17 @@ impl Render for DockArea {
             .on_prepaint(move |bounds, _, cx| view.update(cx, |r, _| r.bounds = bounds))
             .map(|this| {
                 if let Some(zoom_view) = self.zoom_view.clone() {
-                    this.child(zoom_view)
+                    this.map(|this| match decorations {
+                        Decorations::Server => this,
+                        Decorations::Client { tiling } => this
+                            .when(!(tiling.top || tiling.right), |div| {
+                                div.rounded_br(CLIENT_SIDE_DECORATION_ROUNDING)
+                            })
+                            .when(!(tiling.top || tiling.left), |div| {
+                                div.rounded_bl(CLIENT_SIDE_DECORATION_ROUNDING)
+                            }),
+                    })
+                    .child(zoom_view)
                 } else {
                     // render dock
                     this.child(

crates/ui/src/dock/panel.rs

@@ -1,9 +1,10 @@
 use gpui::{
-    AnyElement, AnyView, App, Element, Entity, EventEmitter, FocusHandle, Focusable, Hsla, Render,
+    AnyElement, AnyView, App, Element, Entity, EventEmitter, FocusHandle, Focusable, Render,
     SharedString, Window,
 };
-use ui::button::Button;
-use ui::menu::PopupMenu;
+
+use crate::button::Button;
+use crate::menu::PopupMenu;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PanelEvent {
@@ -20,12 +21,6 @@ pub enum PanelStyle {
     TabBar,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct TitleStyle {
-    pub background: Hsla,
-    pub foreground: Hsla,
-}
-
 pub trait Panel: EventEmitter<PanelEvent> + Render + Focusable {
     /// The name of the panel used to serialize, deserialize and identify the panel.
     ///

crates/ui/src/dock/stack_panel.rs

@@ -7,16 +7,16 @@ use gpui::{
     Window,
 };
 use smallvec::SmallVec;
-use theme::{ActiveTheme, CLIENT_SIDE_DECORATION_ROUNDING};
-use ui::{h_flex, AxisExt as _, Placement};
+use theme::{ActiveTheme, AxisExt as _, CLIENT_SIDE_DECORATION_ROUNDING, Placement};
 
 use super::{DockArea, PanelEvent};
-use crate::panel::{Panel, PanelView};
+use crate::dock::panel::{Panel, PanelView};
+use crate::dock::tab_panel::TabPanel;
+use crate::h_flex;
 use crate::resizable::{
-    resizable_panel, ResizablePanelEvent, ResizablePanelGroup, ResizablePanelState, ResizableState,
-    PANEL_MIN_SIZE,
+    PANEL_MIN_SIZE, ResizablePanelEvent, ResizablePanelGroup, ResizablePanelState, ResizableState,
+    resizable_panel,
 };
-use crate::tab_panel::TabPanel;
 
 pub struct StackPanel {
     pub(super) parent: Option<WeakEntity<StackPanel>>,
@@ -70,10 +70,10 @@ impl StackPanel {
             return false;
         }
 
-        if let Some(parent) = &self.parent {
-            if let Some(parent) = parent.upgrade() {
-                return parent.read(cx).is_last_panel(cx);
-            }
+        if let Some(parent) = &self.parent
+            && let Some(parent) = parent.upgrade()
+        {
+            return parent.read(cx).is_last_panel(cx);
         }
 
         true
@@ -297,12 +297,11 @@ impl StackPanel {
 
     /// Find the first top left in the stack.
     pub fn left_top_tab_panel(&self, check_parent: bool, cx: &App) -> Option<Entity<TabPanel>> {
-        if check_parent {
-            if let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade()) {
-                if let Some(panel) = parent.read(cx).left_top_tab_panel(true, cx) {
-                    return Some(panel);
-                }
-            }
+        if check_parent
+            && let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade())
+            && let Some(panel) = parent.read(cx).left_top_tab_panel(true, cx)
+        {
+            return Some(panel);
         }
 
         let first_panel = self.panels.first();
@@ -321,12 +320,11 @@ impl StackPanel {
 
     /// Find the first top right in the stack.
     pub fn right_top_tab_panel(&self, check_parent: bool, cx: &App) -> Option<Entity<TabPanel>> {
-        if check_parent {
-            if let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade()) {
-                if let Some(panel) = parent.read(cx).right_top_tab_panel(true, cx) {
-                    return Some(panel);
-                }
-            }
+        if check_parent
+            && let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade())
+            && let Some(panel) = parent.read(cx).right_top_tab_panel(true, cx)
+        {
+            return Some(panel);
         }
 
         let panel = if self.axis.is_vertical() {
@@ -371,7 +369,6 @@ impl Focusable for StackPanel {
 }
 
 impl EventEmitter<PanelEvent> for StackPanel {}
-
 impl EventEmitter<DismissEvent> for StackPanel {}
 
 impl Render for StackPanel {

crates/ui/src/dock/tab_panel.rs

@@ -2,22 +2,22 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    div, px, rems, App, AppContext, Context, Corner, DefiniteLength, DismissEvent, DragMoveEvent,
-    Empty, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement as _, IntoElement,
-    MouseButton, ParentElement, Pixels, Render, ScrollHandle, SharedString,
-    StatefulInteractiveElement, Styled, WeakEntity, Window,
+    Anchor, App, AppContext, Context, DefiniteLength, DismissEvent, DragMoveEvent, Empty, Entity,
+    EventEmitter, FocusHandle, Focusable, InteractiveElement as _, IntoElement, MouseButton,
+    ParentElement, Pixels, Render, ScrollHandle, SharedString, StatefulInteractiveElement, Styled,
+    WeakEntity, Window, div, px, rems,
 };
-use theme::{ActiveTheme, CLIENT_SIDE_DECORATION_ROUNDING, TABBAR_HEIGHT};
-use ui::button::{Button, ButtonVariants as _};
-use ui::menu::{DropdownMenu, PopupMenu};
-use ui::{h_flex, v_flex, AxisExt, IconName, Placement, Selectable, Sizable, StyledExt};
+use theme::{ActiveTheme, AxisExt, CLIENT_SIDE_DECORATION_ROUNDING, Placement, TABBAR_HEIGHT};
 
-use crate::dock::DockPlacement;
-use crate::panel::{Panel, PanelView};
-use crate::stack_panel::StackPanel;
-use crate::tab::tab_bar::TabBar;
+use crate::button::{Button, ButtonVariants as _};
+use crate::dock::dock::DockPlacement;
+use crate::dock::panel::{Panel, PanelView};
+use crate::dock::stack_panel::StackPanel;
+use crate::dock::{ClosePanel, DockArea, PanelEvent, PanelStyle, ToggleZoom};
+use crate::menu::{DropdownMenu, PopupMenu};
 use crate::tab::Tab;
-use crate::{ClosePanel, DockArea, PanelEvent, PanelStyle, ToggleZoom};
+use crate::tab::tab_bar::TabBar;
+use crate::{IconName, Selectable, Sizable, StyledExt, h_flex, v_flex};
 
 #[derive(Clone)]
 struct TabState {
@@ -42,22 +42,20 @@ impl DragPanel {
 
 impl Render for DragPanel {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        div()
+        h_flex()
             .id("drag-panel")
             .cursor_grab()
-            .py_1()
-            .px_2()
-            .w_24()
-            .flex()
-            .items_center()
+            .p_2()
+            .min_w_24()
             .justify_center()
             .overflow_hidden()
             .whitespace_nowrap()
-            .rounded(cx.theme().radius_lg)
+            .rounded(cx.theme().radius)
             .text_xs()
-            .when(cx.theme().shadow, |this| this.shadow_lg())
+            .text_color(cx.theme().text)
+            .text_ellipsis()
+            .when(cx.theme().shadow, |this| this.shadow_xs())
             .bg(cx.theme().background)
-            .text_color(cx.theme().text_accent)
             .child(self.panel.title(cx))
     }
 }
@@ -234,14 +232,13 @@ impl TabPanel {
             .any(|p| p.panel_id(cx) == panel.panel_id(cx))
         {
             // Set the active panel to the matched panel
-            if active {
-                if let Some(ix) = self
+            if active
+                && let Some(ix) = self
                     .panels
                     .iter()
                     .position(|p| p.panel_id(cx) == panel.panel_id(cx))
-                {
-                    self.set_active_ix(ix, window, cx);
-                }
+            {
+                self.set_active_ix(ix, window, cx);
             }
 
             return;
@@ -374,12 +371,11 @@ impl TabPanel {
 
     /// Return true if self or parent only have last panel.
     fn is_last_panel(&self, cx: &App) -> bool {
-        if let Some(parent) = &self.stack_panel {
-            if let Some(stack_panel) = parent.upgrade() {
-                if !stack_panel.read(cx).is_last_panel(cx) {
-                    return false;
-                }
-            }
+        if let Some(parent) = &self.stack_panel
+            && let Some(stack_panel) = parent.upgrade()
+            && !stack_panel.read(cx).is_last_panel(cx)
+        {
+            return false;
         }
 
         self.panels.len() <= 1
@@ -425,14 +421,13 @@ impl TabPanel {
         let view = cx.entity().clone();
         let build_popup_menu = move |this, cx: &App| view.read(cx).popup_menu(this, cx);
         let toolbar = self.toolbar_buttons(window, cx);
-        let has_toolbar = !toolbar.is_empty();
 
         h_flex()
             .p_0p5()
-            .gap_1()
+            .gap_1p5()
             .occlude()
             .rounded_full()
-            .children(toolbar.into_iter().map(|btn| btn.small().ghost().rounded()))
+            .children(toolbar.into_iter().map(|btn| btn.small().ghost()))
             .when(self.zoomed, |this| {
                 this.child(
                     Button::new("zoom")
@@ -445,15 +440,11 @@ impl TabPanel {
                         })),
                 )
             })
-            .when(has_toolbar, |this| {
-                this.child(div().flex_shrink_0().h_4().w_px().bg(cx.theme().border))
-            })
             .child(
                 Button::new("menu")
                     .icon(IconName::Ellipsis)
                     .small()
                     .ghost()
-                    .rounded()
                     .dropdown_menu({
                         let zoomable = state.zoomable;
                         let closable = state.closable;
@@ -469,7 +460,7 @@ impl TabPanel {
                                 })
                         }
                     })
-                    .anchor(Corner::TopRight),
+                    .anchor(Anchor::TopRight),
             )
     }
 
@@ -479,12 +470,12 @@ impl TabPanel {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Option<Button> {
+        let dock_area = self.dock_area.upgrade()?.read(cx);
+
         if self.zoomed {
             return None;
         }
 
-        let dock_area = self.dock_area.upgrade()?.read(cx);
-
         if !dock_area.toggle_button_visible {
             return None;
         }
@@ -578,6 +569,7 @@ impl TabPanel {
         let right_dock_button = self.render_dock_toggle_button(DockPlacement::Right, window, cx);
         let has_extend_dock_button = left_dock_button.is_some() || bottom_dock_button.is_some();
         let tabs_count = self.panels.len();
+        let is_bottom_dock = bottom_dock_button.is_some();
 
         if tabs_count == 1 && dock_area.read(cx).panel_style == PanelStyle::Default {
             let panel = self.panels.first().unwrap();
@@ -590,10 +582,11 @@ impl TabPanel {
                 .justify_between()
                 .items_center()
                 .line_height(rems(1.0))
-                .h(px(30.))
+                .h(TABBAR_HEIGHT)
                 .py_2()
                 .pl_3()
                 .pr_2()
+                .bg(cx.theme().panel_background)
                 .when(left_dock_button.is_some(), |this| this.pl_2())
                 .when(right_dock_button.is_some(), |this| this.pr_2())
                 .when(has_extend_dock_button, |this| {
@@ -610,6 +603,7 @@ impl TabPanel {
                     div()
                         .id("tab")
                         .flex_1()
+                        .px_2()
                         .min_w_16()
                         .overflow_hidden()
                         .whitespace_nowrap()
@@ -638,12 +632,13 @@ impl TabPanel {
                         .flex_shrink_0()
                         .ml_1()
                         .gap_1()
-                        .child(self.render_toolbar(state, window, cx)),
+                        .child(self.render_toolbar(state, window, cx))
+                        .children(right_dock_button),
                 )
                 .into_any_element();
         }
 
-        TabBar::new()
+        TabBar::new("tab-bar")
             .track_scroll(&self.tab_bar_scroll_handle)
             .h(TABBAR_HEIGHT)
             .when(has_extend_dock_button, |this| {
@@ -656,8 +651,9 @@ impl TabPanel {
                         .border_b_1()
                         .h_full()
                         .border_color(cx.theme().border)
-                        .bg(cx.theme().surface_background)
-                        .px_2()
+                        .bg(cx.theme().tab_background)
+                        .pl_0p5()
+                        .pr_1()
                         .children(left_dock_button)
                         .children(bottom_dock_button),
                 )
@@ -679,16 +675,43 @@ impl TabPanel {
                 Some(
                     Tab::new()
                         .ix(ix)
-                        .label(panel.title(cx))
-                        .py_2()
+                        .tab_bar_prefix(has_extend_dock_button)
+                        .child(panel.title(cx))
                         .selected(active)
                         .disabled(disabled)
+                        .suffix(
+                            Button::new("close-{ix}")
+                                .icon(IconName::Close)
+                                .tooltip("Close panel")
+                                .ghost()
+                                .xsmall()
+                                .on_click(cx.listener({
+                                    let panel = panel.clone();
+                                    move |view, _ev, window, cx| {
+                                        view.remove_panel(&panel, window, cx);
+                                    }
+                                })),
+                        )
+                        .on_click(cx.listener({
+                            let is_collapsed = self.collapsed;
+                            let dock_area = self.dock_area.clone();
+                            move |view, _, window, cx| {
+                                view.set_active_ix(ix, window, cx);
+
+                                // Open dock if clicked on the collapsed bottom dock
+                                if is_bottom_dock && is_collapsed {
+                                    _ = dock_area.update(cx, |dock_area, cx| {
+                                        dock_area.toggle_dock(DockPlacement::Bottom, window, cx);
+                                    });
+                                }
+                            }
+                        }))
                         .when(!disabled, |this| {
                             this.on_mouse_down(
                                 MouseButton::Middle,
                                 cx.listener({
                                     let panel = panel.clone();
-                                    move |view, _, window, cx| {
+                                    move |view, _ev, window, cx| {
                                         view.remove_panel(&panel, window, cx);
                                     }
                                 }),
@@ -727,7 +750,7 @@ impl TabPanel {
                 div()
                     .id("tab-bar-empty-space")
                     .h_full()
-                    .flex_grow()
+                    .flex_grow_1()
                     .min_w_16()
                     .when(state.droppable, |this| {
                         let view = cx.entity();
@@ -754,14 +777,15 @@ impl TabPanel {
                 this.suffix(
                     h_flex()
                         .items_center()
-                        .px_2()
-                        .gap_1()
                         .top_0()
                         .right_0()
                         .h_full()
-                        .border_color(cx.theme().border)
                         .border_l_1()
                         .border_b_1()
+                        .px_0p5()
+                        .gap_1()
+                        .border_color(cx.theme().border)
+                        .bg(cx.theme().tab_background)
                         .child(self.render_toolbar(state, window, cx))
                         .when_some(right_dock_button, |this, btn| this.child(btn)),
                 )
@@ -1077,7 +1101,9 @@ impl TabPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if let Some(panel) = self.active_panel(cx) {
+        if self.panels.len() > 1
+            && let Some(panel) = self.active_panel(cx)
+        {
             self.remove_panel(&panel, window, cx);
         }
     }
@@ -1094,6 +1120,7 @@ impl Focusable for TabPanel {
 }
 
 impl EventEmitter<DismissEvent> for TabPanel {}
+
 impl EventEmitter<PanelEvent> for TabPanel {}
 
 impl Render for TabPanel {

crates/ui/src/geometry.rs

@@ -1,294 +0,0 @@
-use std::fmt::{self, Debug, Display, Formatter};
-
-use gpui::{AbsoluteLength, Axis, Corner, Length, Pixels};
-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,
-        }
-    }
-}
-
-/// The anchor position of an element.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
-pub enum Anchor {
-    #[default]
-    #[serde(rename = "top-left")]
-    TopLeft,
-    #[serde(rename = "top-center")]
-    TopCenter,
-    #[serde(rename = "top-right")]
-    TopRight,
-    #[serde(rename = "bottom-left")]
-    BottomLeft,
-    #[serde(rename = "bottom-center")]
-    BottomCenter,
-    #[serde(rename = "bottom-right")]
-    BottomRight,
-}
-
-impl Display for Anchor {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Anchor::TopLeft => write!(f, "TopLeft"),
-            Anchor::TopCenter => write!(f, "TopCenter"),
-            Anchor::TopRight => write!(f, "TopRight"),
-            Anchor::BottomLeft => write!(f, "BottomLeft"),
-            Anchor::BottomCenter => write!(f, "BottomCenter"),
-            Anchor::BottomRight => write!(f, "BottomRight"),
-        }
-    }
-}
-
-impl Anchor {
-    /// Returns true if the anchor is at the top.
-    #[inline]
-    pub fn is_top(&self) -> bool {
-        matches!(self, Self::TopLeft | Self::TopCenter | Self::TopRight)
-    }
-
-    /// Returns true if the anchor is at the bottom.
-    #[inline]
-    pub fn is_bottom(&self) -> bool {
-        matches!(
-            self,
-            Self::BottomLeft | Self::BottomCenter | Self::BottomRight
-        )
-    }
-
-    /// Returns true if the anchor is at the left.
-    #[inline]
-    pub fn is_left(&self) -> bool {
-        matches!(self, Self::TopLeft | Self::BottomLeft)
-    }
-
-    /// Returns true if the anchor is at the right.
-    #[inline]
-    pub fn is_right(&self) -> bool {
-        matches!(self, Self::TopRight | Self::BottomRight)
-    }
-
-    /// Returns true if the anchor is at the center.
-    #[inline]
-    pub fn is_center(&self) -> bool {
-        matches!(self, Self::TopCenter | Self::BottomCenter)
-    }
-
-    /// Swaps the vertical position of the anchor.
-    pub fn swap_vertical(&self) -> Self {
-        match self {
-            Anchor::TopLeft => Anchor::BottomLeft,
-            Anchor::TopCenter => Anchor::BottomCenter,
-            Anchor::TopRight => Anchor::BottomRight,
-            Anchor::BottomLeft => Anchor::TopLeft,
-            Anchor::BottomCenter => Anchor::TopCenter,
-            Anchor::BottomRight => Anchor::TopRight,
-        }
-    }
-
-    /// Swaps the horizontal position of the anchor.
-    pub fn swap_horizontal(&self) -> Self {
-        match self {
-            Anchor::TopLeft => Anchor::TopRight,
-            Anchor::TopCenter => Anchor::TopCenter,
-            Anchor::TopRight => Anchor::TopLeft,
-            Anchor::BottomLeft => Anchor::BottomRight,
-            Anchor::BottomCenter => Anchor::BottomCenter,
-            Anchor::BottomRight => Anchor::BottomLeft,
-        }
-    }
-
-    pub(crate) fn other_side_corner_along(&self, axis: Axis) -> Anchor {
-        match axis {
-            Axis::Vertical => match self {
-                Self::TopLeft => Self::BottomLeft,
-                Self::TopCenter => Self::BottomCenter,
-                Self::TopRight => Self::BottomRight,
-                Self::BottomLeft => Self::TopLeft,
-                Self::BottomCenter => Self::TopCenter,
-                Self::BottomRight => Self::TopRight,
-            },
-            Axis::Horizontal => match self {
-                Self::TopLeft => Self::TopRight,
-                Self::TopCenter => Self::TopCenter,
-                Self::TopRight => Self::TopLeft,
-                Self::BottomLeft => Self::BottomRight,
-                Self::BottomCenter => Self::BottomCenter,
-                Self::BottomRight => Self::BottomLeft,
-            },
-        }
-    }
-}
-
-impl From<Corner> for Anchor {
-    fn from(corner: Corner) -> Self {
-        match corner {
-            Corner::TopLeft => Anchor::TopLeft,
-            Corner::TopRight => Anchor::TopRight,
-            Corner::BottomLeft => Anchor::BottomLeft,
-            Corner::BottomRight => Anchor::BottomRight,
-        }
-    }
-}
-
-impl From<Anchor> for Corner {
-    fn from(anchor: Anchor) -> Self {
-        match anchor {
-            Anchor::TopLeft => Corner::TopLeft,
-            Anchor::TopRight => Corner::TopRight,
-            Anchor::BottomLeft => Corner::BottomLeft,
-            Anchor::BottomRight => Corner::BottomRight,
-            Anchor::TopCenter => Corner::TopLeft,
-            Anchor::BottomCenter => Corner::BottomLeft,
-        }
-    }
-}
-
-/// 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")]
-    Left,
-    #[serde(rename = "right")]
-    Right,
-}
-
-impl Side {
-    /// Returns true if the side is left.
-    #[inline]
-    pub fn is_left(&self) -> bool {
-        matches!(self, Self::Left)
-    }
-
-    /// Returns true if the side is right.
-    #[inline]
-    pub fn is_right(&self) -> bool {
-        matches!(self, Self::Right)
-    }
-}
-
-/// A trait to extend the [`Axis`] enum with utility methods.
-pub trait AxisExt {
-    #[allow(clippy::wrong_self_convention)]
-    fn is_horizontal(self) -> bool;
-    #[allow(clippy::wrong_self_convention)]
-    fn is_vertical(self) -> bool;
-}
-
-impl AxisExt for Axis {
-    #[inline]
-    fn is_horizontal(self) -> bool {
-        self == Axis::Horizontal
-    }
-
-    #[inline]
-    fn is_vertical(self) -> bool {
-        self == Axis::Vertical
-    }
-}
-
-/// 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.
-#[derive(Debug, Clone, Default, Serialize, Deserialize, Eq, PartialEq)]
-#[repr(C)]
-pub struct Edges<T: Clone + Debug + Default + PartialEq> {
-    /// The size of the top edge.
-    pub top: T,
-    /// The size of the right edge.
-    pub right: T,
-    /// The size of the bottom edge.
-    pub bottom: T,
-    /// 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,
-        }
-    }
-}