.

.github/workflows/release.yml

@@ -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: desktop
+        working-directory: crates/coop
         run: |
           cargo install cargo-packager --locked
           cargo packager --release
@@ -154,13 +154,13 @@ jobs:
 
       - name: Create draft release
         id: create_release
-        uses: akkuman/gitea-release-action@v1
+        uses: softprops/action-gh-release@v2
         with:
-          server_url: "https://git.reya.su/"
-          repository: "reya/coop"
-          token: ${{ secrets.GITEA_TOKEN }}
+          tag_name: ${{ steps.version.outputs.tag }}
+          name: ${{ steps.version.outputs.tag }}
           draft: true
           prerelease: false
+          generate_release_notes: true
           files: |
             artifacts/**/*
 

.gitignore

@@ -19,8 +19,8 @@ dist/
 
 # Useless stuffs
 .DS_Store
+# Added by goreleaser init:
+.intentionally-empty-file.o
 
 .cargo/
 vendor/
-wasm/
-node_modules/

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
 resolver = "2"
-members = ["crates/*", "desktop", "web"]
-default-members = ["desktop"]
+members = ["crates/*"]
+default-members = ["crates/coop"]
 
 [workspace.package]
-version = "1.0.0-beta5"
+version = "1.0.0-beta2"
 edition = "2024"
 publish = false
 
@@ -15,40 +15,34 @@ gpui_platform = { git = "https://github.com/zed-industries/zed", features = ["fo
 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_web = { 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-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-memory = { git = "https://github.com/rust-nostr/nostr" }
+nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
 nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
 nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
 nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ] }
+nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip96", "nip59", "nip49", "nip44" ] }
 
 # Others
 anyhow = "1.0.44"
-chrono = { version = "0.4.38", features = ["wasmbind"] }
+chrono = "0.4.38"
 futures = "0.3"
 itertools = "0.13.0"
 log = "0.4"
 oneshot = "0.1.10"
 flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
-rust-embed = { version = "8.5", features = ["include-exclude"] }
+rust-embed = "8.5.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 schemars = "1"
 smallvec = "1.14.0"
 smol = "2"
+tracing = "0.1.40"
 webbrowser = "1.0.4"
-tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
-errno = { version = "0.3.14", default-features = false }
-instant = "0.1"
-
-[patch.crates-io]
-# Use stacker's psm version which may have better WASM support
-psm = { git = "https://github.com/rust-lang/stacker", branch = "master" }
 
 [profile.release]
 strip = true

Cargo.toml-E

@@ -1,62 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["crates/*", "desktop", "web"]
-default-members = ["desktop"]
-
-[workspace.package]
-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-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
-nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
-nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ] }
-
-# Others
-anyhow = "1.0.44"
-chrono = { version = "0.4.38", features = ["wasmbind"] }
-futures = "0.3"
-itertools = "0.13.0"
-log = "0.4"
-oneshot = "0.1.10"
-flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
-rust-embed = { version = "8.5", features = ["include-exclude"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-schemars = "1"
-smallvec = "1.14.0"
-smol = "2"
-webbrowser = "1.0.4"
-tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
-errno = { version = "0.3.14", default-features = false }
-instant = "0.1"
-
-[patch.crates-io]
-# Use stacker's psm version which may have better WASM support
-psm = { git = "https://github.com/rust-lang/stacker", branch = "master" }
-
-[profile.release]
-strip = true
-opt-level = "z"
-lto = true
-codegen-units = 1
-panic = "abort"
-
-[profile.profiling]
-inherits = "release"
-debug = true

README.md

@@ -1,5 +1,125 @@
+![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>
+    <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">
+</p>
+
 Coop is a simple, fast, and reliable nostr client for secure messaging across all platforms.
 
+### Screenshots
+
+<p float="left">
+  <img src="/docs/mac_01.png" width="250" />
+  <img src="/docs/mac_02.png" width="250" />
+  <img src="/docs/mac_03.png" width="250" />
+  <img src="/docs/mac_04.png" width="250" />
+  <img src="/docs/mac_05.png" width="250" />
+  <img src="/docs/mac_06.png" width="250" />
+  <img src="/docs/mac_07.png" width="250" />
+  <img src="/docs/mac_08.png" width="250" />
+  <img src="/docs/mac_09.png" width="250" />
+  <img src="/docs/linux_01.png" width="250" />
+  <img src="/docs/linux_02.png" width="250" />
+  <img src="/docs/linux_03.png" width="250" />
+  <img src="/docs/linux_04.png" width="250" />
+  <img src="/docs/linux_05.png" width="250" />
+</p>
+
+### Installation
+
+To install Coop, follow these steps:
+
+1. **Download the Latest Release**:
+
+   - Visit the [Coop Releases page on GitHub](https://github.com/lumehq/coop/releases).
+   - Download the package that matches your operating system (Windows, macOS, or Linux).
+
+2. **Install**:
+
+   - **Windows**: Run the downloaded `.exe` installer and follow the on-screen instructions.
+   - **macOS**: Open the downloaded `.dmg` file and drag Coop to your Applications folder.
+   - **Linux**: Run the downloaded `.flatpak` or `.snap` installer and follow the on-screen instructions.
+
+3. **Run Coop**:
+   - Launch Coop from your Applications folder (macOS) or by double-clicking the executable (Windows/Linux).
+
+For more detailed instructions, refer to the [Release Notes](#) on GitHub.
+
+### Developing Coop
+
+Coop is built using Rust and GPUI. All Nostr related stuffs handled by [Rust Nostr SDK](https://github.com/rust-nostr/nostr)
+
+#### Prerequisites
+
+- **Rust Toolchain**: Ensure you have Rust installed. If not, you can install it using [rustup](https://rustup.rs/).
+- **Cargo**: Rust's package manager, which comes bundled with the Rust installation.
+- **Git**: To clone the repository and manage version control.
+
+#### Setting Up the Development Environment
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/lumehq/coop.git
+   cd coop
+   ```
+
+2.1 Install Linux dependencies:
+
+   ```bash
+   ./script/linux
+   ```
+
+2.2 Install FreeBSD dependencies:
+
+   ```bash
+   ./script/freebsd
+   ```
+
+3. Install Rust dependencies:
+
+   ```bash
+   cargo build
+   ```
+
+4. Run the app:
+   ```bash
+   cargo run
+   ```
+
+#### Building for Production
+
+To build Coop for production, use the following command:
+
+```bash
+cargo build --release
+```
+
+This will generate an optimized binary in the `target/release` directory.
+
+#### Contributing Code
+
+If you'd like to contribute to Coop, please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Make your changes and ensure all tests pass.
+4. Submit a pull request with a detailed description of your changes.
+
+For more information, see the [Contributing](#contributing) section.
+
+#### Additional Resources
+
+- [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/)
+
 ### License
 
 Copyright (C) 2025 Ren Amamiya & other Coop contributors

crates/auto_update/Cargo.toml

@@ -5,8 +5,17 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-gpui.workspace = true
-instant.workspace = true
-log.workspace = true
+common = { path = "../common" }
 
-gpui-updater = { git = "https://github.com/AprilNEA/gpui-updater", tag = "v0.0.6", features = ["gpui"] }
+gpui.workspace = true
+gpui_tokio.workspace = true
+anyhow.workspace = true
+smol.workspace = true
+log.workspace = true
+smallvec.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+
+semver = "1.0.27"
+tempfile = "3.23.0"
+futures.workspace = true

crates/auto_update/src/lib.rs

@@ -1,9 +1,22 @@
-#![cfg(not(target_arch = "wasm32"))]
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
 
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Subscription, Window};
-use gpui_updater::{EngineConfig, GitHubSource, UpdateStatus, Updater, Version};
-use instant::{Duration, Instant};
+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 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 {
@@ -15,15 +28,12 @@ fn get_github_repo_name() -> String {
 }
 
 fn is_flatpak_installation() -> bool {
+    // Check if app is installed via Flatpak
     std::env::var("FLATPAK_ID").is_ok() || std::env::var(COOP_UPDATE_EXPLANATION).is_ok()
 }
 
-/// Initialize the auto-update system.
-///
-/// Skips initialization when running as a Flatpak (updates are handled by the
-/// Flatpak distribution channel). Otherwise creates the global [`AutoUpdater`]
-/// entity and schedules a check for updates after a 2-minute delay.
 pub fn init(window: &mut Window, cx: &mut App) {
+    // Skip auto-update initialization if installed via Flatpak
     if is_flatpak_installation() {
         log::info!("Skipping auto-update initialization: App is installed via Flatpak");
         return;
@@ -36,145 +46,516 @@ struct GlobalAutoUpdater(Entity<AutoUpdater>);
 
 impl Global for GlobalAutoUpdater {}
 
-/// Observable auto-update status — re-exported from [`gpui_updater::UpdateStatus`].
-pub use gpui_updater::UpdateStatus as AutoUpdateStatus;
+#[cfg(not(target_os = "windows"))]
+struct InstallerDir(tempfile::TempDir);
 
-/// The global auto-updater entity.
-///
-/// Wraps [`gpui_updater::Updater`] with Coop-specific configuration
-/// (GitHub repo, Flatpak detection, delayed auto-check).
-///
-/// Retrieve the global instance via [`AutoUpdater::global`].
+#[cfg(not(target_os = "windows"))]
+impl InstallerDir {
+    async fn new() -> Result<Self, Error> {
+        Ok(Self(
+            tempfile::Builder::new()
+                .prefix("coop-auto-update")
+                .tempdir()?,
+        ))
+    }
+
+    fn path(&self) -> &Path {
+        self.0.path()
+    }
+}
+
+#[cfg(target_os = "windows")]
+struct InstallerDir(PathBuf);
+
+#[cfg(target_os = "windows")]
+impl InstallerDir {
+    async fn new() -> Result<Self, Error> {
+        let installer_dir = std::env::current_exe()?
+            .parent()
+            .context("No parent dir for Coop.exe")?
+            .join("updates");
+
+        if smol::fs::metadata(&installer_dir).await.is_ok() {
+            smol::fs::remove_dir_all(&installer_dir).await?;
+        }
+
+        smol::fs::create_dir(&installer_dir).await?;
+
+        Ok(Self(installer_dir))
+    }
+
+    fn path(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+struct MacOsUnmounter<'a> {
+    mount_path: PathBuf,
+    background_executor: &'a BackgroundExecutor,
+}
+
+impl Drop for MacOsUnmounter<'_> {
+    fn drop(&mut self) {
+        let mount_path = std::mem::take(&mut self.mount_path);
+
+        self.background_executor
+            .spawn(async move {
+                let unmount_output = Command::new("hdiutil")
+                    .args(["detach", "-force"])
+                    .arg(&mount_path)
+                    .output()
+                    .await;
+
+                match unmount_output {
+                    Ok(output) if output.status.success() => {
+                        log::info!("Successfully unmounted the disk image");
+                    }
+                    Ok(output) => {
+                        log::error!(
+                            "Failed to unmount disk image: {:?}",
+                            String::from_utf8_lossy(&output.stderr)
+                        );
+                    }
+                    Err(error) => {
+                        log::error!("Error while trying to unmount disk image: {:?}", error);
+                    }
+                }
+            })
+            .detach();
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AutoUpdateStatus {
+    Idle,
+    Checking,
+    Checked { download_url: String },
+    Installing,
+    Updated,
+    Errored { msg: Box<String> },
+}
+
+impl AsRef<AutoUpdateStatus> for AutoUpdateStatus {
+    fn as_ref(&self) -> &AutoUpdateStatus {
+        self
+    }
+}
+
+impl AutoUpdateStatus {
+    pub fn is_updating(&self) -> bool {
+        matches!(self, Self::Checked { .. } | Self::Installing)
+    }
+
+    pub fn is_updated(&self) -> bool {
+        matches!(self, Self::Updated)
+    }
+
+    pub fn checked(download_url: String) -> Self {
+        Self::Checked { download_url }
+    }
+
+    pub fn error(e: String) -> Self {
+        Self::Errored { msg: Box::new(e) }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GitHubRelease {
+    pub tag_name: String,
+    pub assets: Vec<GitHubAsset>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GitHubAsset {
+    pub name: String,
+    pub browser_download_url: String,
+}
+
+#[derive(Debug)]
 pub struct AutoUpdater {
-    /// The underlying gpui-updater entity that does the heavy lifting.
-    pub updater: Entity<Updater>,
-    /// Currently running app version.
+    /// Current status of the auto updater
+    pub status: AutoUpdateStatus,
+
+    /// Current version of the application
     pub version: Version,
-    /// Keeps the observer subscription alive.
-    _subscription: Subscription,
-    /// When the last error was recorded, so we can reset to idle after 5s.
-    error_time: Option<Instant>,
+
+    /// Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 1]>,
+
+    /// Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
 }
 
 impl AutoUpdater {
-    /// Retrieve the global auto updater instance.
+    /// Retrieve the global auto updater instance
     pub fn global(cx: &App) -> Entity<Self> {
         cx.global::<GlobalAutoUpdater>().0.clone()
     }
 
+    /// Set the global auto updater instance
     fn set_global(state: Entity<Self>, cx: &mut App) {
         cx.set_global(GlobalAutoUpdater(state));
     }
 
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
+        let mut subscriptions = smallvec![];
 
-        let repo_owner = get_github_repo_owner();
-        let repo_name = get_github_repo_name();
+        subscriptions.push(
+            // Observe the status
+            cx.observe_self(|this, cx| {
+                if let AutoUpdateStatus::Checked { download_url } = this.status.clone() {
+                    this.download_and_install(&download_url, cx);
+                }
+            }),
+        );
 
-        let source =
-            GitHubSource::new(&repo_owner, &repo_name).asset_contains(match std::env::consts::OS {
-                "macos" => "macos",
-                "linux" => "linux",
-                _ => "",
-            });
-
-        let updater: Entity<Updater> =
-            cx.new(|cx| Updater::new(source, EngineConfig::new(version.clone()), cx));
-
-        // When an update becomes available, automatically download and install it.
-        let subscription = cx.observe(&updater, |this: &mut AutoUpdater, _updater, cx| {
-            let status = this.updater.read(cx).status().clone();
-
-            if matches!(status, UpdateStatus::Available(_)) {
-                this.updater.update(cx, |updater, cx| {
-                    updater.download_and_install(cx);
-                });
-            }
-
-            if matches!(status, UpdateStatus::Errored(_)) {
-                this.error_time = Some(Instant::now());
-                cx.spawn(async move |this, cx| {
-                    cx.background_executor().timer(Duration::from_secs(5)).await;
-                    this.update(cx, |_this, cx| cx.notify()).ok();
-                })
-                .detach();
-            } else {
-                this.error_time = None;
-            }
-
-            cx.notify();
-        });
-
-        // Schedule an auto-check after a 2-minute delay (deferred to run at the
-        // end of the current frame so the window is fully set up).
-        cx.defer_in(window, |_this, _window, cx| {
-            let duration = Duration::from_secs(120);
-            cx.spawn(async move |this, cx| {
-                cx.background_executor().timer(duration).await;
-                this.update(cx, |this, cx| {
-                    this.updater.update(cx, |updater, cx| {
-                        updater.check(cx);
-                    });
-                })
-                .ok();
-            })
-            .detach();
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, _window, cx| {
+            this.check(cx);
         });
 
         Self {
-            updater,
+            status: AutoUpdateStatus::Idle,
             version,
-            _subscription: subscription,
-            error_time: None,
+            tasks: vec![],
+            _subscriptions: subscriptions,
         }
     }
 
-    pub fn idle(&self, cx: &App) -> bool {
-        let status = self.updater.read(cx).status();
-        if status == &UpdateStatus::Idle {
-            return true;
-        }
-        if matches!(status, UpdateStatus::Errored(_))
-            && self
-                .error_time
-                .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-        {
-            return true;
-        }
-        false
+    fn set_status(&mut self, status: AutoUpdateStatus, cx: &mut Context<Self>) {
+        self.status = status;
+        cx.notify();
     }
 
-    pub fn status(&self, cx: &App) -> SharedString {
-        let status = self.updater.read(cx).status();
+    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);
 
-        match status {
-            UpdateStatus::Idle => "Up to date".into(),
-            UpdateStatus::Checking => "Checking for updates…".into(),
-            UpdateStatus::UpToDate => "Up to date".into(),
-            UpdateStatus::Available(version) => format!("Version {version} available").into(),
-            UpdateStatus::Downloading { downloaded, total } => {
-                let total_mb = total.map(|t| t as f64 / 1_048_576.0);
-                let downloaded_mb = *downloaded as f64 / 1_048_576.0;
-                match total_mb {
-                    Some(t) => format!("Downloading {downloaded_mb:.1} / {t:.1} MB").into(),
-                    None => format!("Downloading {downloaded_mb:.1} MB").into(),
+        // 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);
+                    })?;
                 }
             }
-            UpdateStatus::Installing => "Installing update…".into(),
-            UpdateStatus::Staged(version) => {
-                format!("Version {version} ready — restart to apply").into()
+
+            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 url = format!(
+                "{}/repos/{}/{}/releases/latest",
+                GITHUB_API_URL, repo_owner, repo_name
+            );
+
+            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()));
             }
-            UpdateStatus::Errored(msg) => {
-                if self
-                    .error_time
-                    .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-                {
-                    "Up to date".into()
-                } else {
-                    format!("Update failed: {msg}").into()
+
+            // 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');
+            let new_version = Version::parse(tag_version).context(format!(
+                "Failed to parse version from tag: {}",
+                release.tag_name
+            ))?;
+
+            if new_version > version {
+                // Find the appropriate asset for the current platform
+                let current_os = std::env::consts::OS;
+                let asset_name = match current_os {
+                    "macos" => "Coop.dmg",
+                    "linux" => "coop.tar.gz",
+                    "windows" => "Coop.exe",
+                    _ => return Err(anyhow!("Unsupported OS: {}", current_os)),
+                };
+
+                let download_url = release
+                    .assets
+                    .iter()
+                    .find(|asset| asset.name == asset_name)
+                    .map(|asset| asset.browser_download_url.clone())
+                    .context(format!(
+                        "No {} asset found in release {}",
+                        asset_name, release.tag_name
+                    ))?;
+
+                Ok(download_url)
+            } else {
+                Err(anyhow!(
+                    "No update available. Current: {}, Latest: {}",
+                    version,
+                    new_version
+                ))
+            }
+        })
+    }
+
+    fn download_and_install(&mut self, download_url: &str, cx: &mut Context<Self>) {
+        let http_client = cx.http_client();
+        let download_url = download_url.to_string();
+
+        let task: Task<Result<(InstallerDir, PathBuf), Error>> = cx.background_spawn(async move {
+            let installer_dir = InstallerDir::new().await?;
+            let target_path = Self::target_path(&installer_dir).await?;
+
+            // Download the release
+            download(&download_url, &target_path, http_client).await?;
+
+            Ok((installer_dir, target_path))
+        });
+
+        self.tasks.push(
+            // Install the new release
+            cx.spawn(async move |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.set_status(AutoUpdateStatus::Updated, cx);
+                            })?;
+                        }
+                    }
+                    Err(e) => {
+                        // Update the status to error including the error message
+                        this.update(cx, |this, cx| {
+                            this.set_status(AutoUpdateStatus::error(e.to_string()), cx);
+                        })?;
+                    }
                 }
-            }
+
+                Ok(())
+            }),
+        );
+    }
+
+    async fn target_path(installer_dir: &InstallerDir) -> Result<PathBuf, Error> {
+        let filename = match std::env::consts::OS {
+            "macos" => anyhow::Ok("Coop.dmg"),
+            "linux" => Ok("coop.tar.gz"),
+            "windows" => Ok("Coop.exe"),
+            unsupported_os => anyhow::bail!("not supported: {unsupported_os}"),
+        }?;
+
+        Ok(installer_dir.path().join(filename))
+    }
+
+    async fn install(
+        installer_dir: InstallerDir,
+        target_path: PathBuf,
+        cx: &AsyncApp,
+    ) -> Result<(), Error> {
+        match std::env::consts::OS {
+            "macos" => install_release_macos(&installer_dir, target_path, cx).await,
+            "linux" => install_release_linux(&installer_dir, target_path, cx).await,
+            "windows" => install_release_windows(target_path).await,
+            unsupported_os => anyhow::bail!("Not supported: {unsupported_os}"),
         }
     }
 }
+
+async fn download(
+    url: &str,
+    target_path: &std::path::Path,
+    client: Arc<dyn HttpClient>,
+) -> Result<(), Error> {
+    let body = AsyncBody::default();
+    let mut target_file = File::create(&target_path).await?;
+    let mut response = client.get(url, body, true).await?;
+
+    // Copy the response body to the target file
+    smol::io::copy(response.body_mut(), &mut target_file).await?;
+
+    Ok(())
+}
+
+async fn install_release_macos(
+    temp_dir: &InstallerDir,
+    downloaded_dmg: PathBuf,
+    cx: &AsyncApp,
+) -> Result<(), Error> {
+    let running_app_path = cx.update(|cx| cx.app_path())?;
+    let running_app_filename = running_app_path
+        .file_name()
+        .with_context(|| format!("invalid running app path {running_app_path:?}"))?;
+
+    let mount_path = temp_dir.path().join("Coop");
+    let mut mounted_app_path: OsString = mount_path.join(running_app_filename).into();
+
+    mounted_app_path.push("/");
+
+    let output = Command::new("hdiutil")
+        .args(["attach", "-nobrowse"])
+        .arg(&downloaded_dmg)
+        .arg("-mountroot")
+        .arg(temp_dir.path())
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to mount: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Create an MacOsUnmounter that will be dropped (and thus unmount the disk) when this function exits
+    let _unmounter = MacOsUnmounter {
+        mount_path: mount_path.clone(),
+        background_executor: cx.background_executor(),
+    };
+
+    let output = Command::new("rsync")
+        .args(["-av", "--delete"])
+        .arg(&mounted_app_path)
+        .arg(&running_app_path)
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to copy app: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}
+
+async fn install_release_linux(
+    temp_dir: &InstallerDir,
+    downloaded_tar_gz: PathBuf,
+    cx: &AsyncApp,
+) -> Result<(), Error> {
+    let running_app_path = cx.update(|cx| cx.app_path())?;
+
+    // Extract the tar.gz file
+    let extracted = temp_dir.path().join("coop");
+    smol::fs::create_dir_all(&extracted)
+        .await
+        .context("failed to create directory to extract update")?;
+
+    let output = Command::new("tar")
+        .arg("-xzf")
+        .arg(&downloaded_tar_gz)
+        .arg("-C")
+        .arg(&extracted)
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to extract {:?} to {:?}: {:?}",
+        downloaded_tar_gz,
+        extracted,
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Find the extracted app directory
+    let mut entries = smol::fs::read_dir(&extracted).await?;
+    let mut app_dir = None;
+
+    use smol::stream::StreamExt;
+
+    while let Some(entry) = entries.next().await {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            app_dir = Some(path);
+            break;
+        }
+    }
+
+    let from = app_dir.context("No app directory found in archive")?;
+
+    // Copy to the current installation directory
+    let output = Command::new("rsync")
+        .args(["-av", "--delete"])
+        .arg(&from)
+        .arg(
+            running_app_path
+                .parent()
+                .context("No parent directory for app")?,
+        )
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to copy app from {:?} to {:?}: {:?}",
+        from,
+        running_app_path.parent(),
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}
+
+async fn install_release_windows(downloaded_installer: PathBuf) -> Result<(), Error> {
+    //const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+    let system_root = std::env::var("SYSTEMROOT");
+    let powershell_path = system_root.as_ref().map_or_else(
+        |_| "powershell.exe".to_string(),
+        |p| format!("{p}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"),
+    );
+
+    let mut installer_path = std::ffi::OsString::new();
+    installer_path.push("\"");
+    installer_path.push(&downloaded_installer);
+    installer_path.push("\"");
+
+    let output = Command::new(powershell_path)
+        //.creation_flags(CREATE_NO_WINDOW)
+        .args(["-NoProfile", "-WindowStyle", "Hidden"])
+        .args(["Start-Process"])
+        .arg(installer_path)
+        .arg("-ArgumentList")
+        .args(["/P", "/R"])
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to start installer: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}

crates/browser-signer-proxy/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "browser-signer-proxy"
-version = "0.1.0"
-edition.workspace = true
-description = "Nostr browser signer (NIP-07) proxy using smol async runtime"
-license = "MIT"
-repository = "https://github.com/nostrdevkit/nostr"
-publish = false
-
-[dependencies]
-atomic-destructor = "0.2"
-event-listener = "5"
-nostr.workspace = true
-opaquerr = "0.1"
-serde.workspace = true
-serde_json.workspace = true
-smol.workspace = true
-tracing = { version = "0.1", features = ["std"] }
-uuid = { version = "1.23", features = ["serde", "v4"] }

crates/browser-signer-proxy/README.md

@@ -1,55 +0,0 @@
-# browser-signer-proxy
-
-Proxy to use Nostr Browser signer ([NIP-07](https://github.com/nostr-protocol/nips/blob/master/07.md)) in native applications.
-
-This is a re-implementation of [`nostr-browser-signer-proxy`](https://github.com/nostrdevkit/nostr/tree/master/signer/nostr-browser-signer-proxy)
-using the [`smol`](https://github.com/smol-rs/smol) async runtime instead of tokio.
-
-## Description
-
-This crate provides a local HTTP proxy that communicates with a NIP-07 browser extension
-(e.g., Alby, nos2x) running in a browser tab. Native applications can use this proxy to
-request public keys, sign events, and perform NIP-04/NIP-44 encryption/decryption through
-the browser extension.
-
-The HTTP server is implemented with a minimal, dependency-free approach using `smol::net::TcpListener`
-and manual HTTP/1.1 parsing — avoiding heavy HTTP framework dependencies entirely.
-
-## Usage
-
-```rust
-use browser_signer_proxy::prelude::*;
-
-async fn example() -> Result<(), Error> {
-    // Create the proxy with default options (localhost:7400)
-    let proxy = BrowserSignerProxy::new(BrowserSignerProxyOptions::default());
-
-    // Open the proxy URL in a browser
-    webbrowser::open(&proxy.url())?;
-
-    // Start the proxy server
-    proxy.start().await?;
-
-    // Use it as an async Nostr signer
-    let public_key = proxy.get_public_key_async().await?;
-    println!("Connected with public key: {public_key}");
-
-    Ok(())
-}
-```
-
-## Differences from the tokio-based version
-
-| Feature | tokio (original) | smol (this crate) |
-|---|---|---|
-| Async runtime | `tokio` | `smol` |
-| HTTP server | `hyper` | `smol::net::TcpListener` + manual HTTP/1.1 |
-| Mutex | `tokio::sync::Mutex` | `smol::lock::Mutex` |
-| Shutdown signal | `tokio::sync::Notify` | `event_listener::Event` |
-| Request-response channel | `tokio::sync::oneshot` | `smol::channel::bounded(1)` |
-| Timeout | `tokio::time::timeout` | `smol::future::or` + `smol::Timer` |
-| Task spawning | `tokio::spawn` | `smol::spawn` |
-
-## License
-
-This project is distributed under the MIT software license.

crates/browser-signer-proxy/index.html

@@ -1,185 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Coop — Web Signer Proxy</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@800;900&display=swap" rel="stylesheet">
-    <style>
-        :root {
-            --brand: #F8FF37;
-            --ink: #111111;
-            --ink-soft: #333333;
-            --muted: #666666;
-            --paper: #FFFFFF;
-            --edge: rgba(17, 17, 17, 0.14);
-            --radius-sm: 1rem;
-            --radius-md: 1.5rem;
-            --radius-lg: 2.5rem;
-            --green: #2E8B57;
-            --red: #D32F2F;
-        }
-
-        * {
-            box-sizing: border-box;
-        }
-
-        html, body {
-            margin: 0;
-            min-height: 100%;
-        }
-
-        body {
-            font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            color: var(--ink);
-            background: var(--brand);
-            -webkit-font-smoothing: antialiased;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            min-height: 100vh;
-            padding: 2rem;
-        }
-
-        .card {
-            background: var(--paper);
-            border-radius: var(--radius-md);
-            padding: 2.5rem;
-            max-width: 440px;
-            width: 100%;
-            box-shadow: 0 8px 0 rgba(17, 17, 17, 0.12), 0 2px 20px rgba(17, 17, 17, 0.06);
-        }
-
-        .logo {
-            display: flex;
-            align-items: center;
-            gap: 0.6rem;
-            margin-bottom: 1.75rem;
-        }
-
-        .logo__mark {
-            width: 2.5rem;
-            height: 2.5rem;
-            background: var(--ink);
-            border-radius: var(--radius-sm);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.2rem;
-            color: var(--brand);
-            letter-spacing: -0.02em;
-        }
-
-        .logo__text {
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.3rem;
-            letter-spacing: -0.02em;
-        }
-
-        .heading {
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.6rem;
-            letter-spacing: -0.03em;
-            line-height: 1.15;
-            margin: 0 0 0.6rem;
-        }
-
-        .subtitle {
-            font-size: 0.95rem;
-            color: var(--ink-soft);
-            margin: 0 0 1.75rem;
-            line-height: 1.5;
-        }
-
-        .status {
-            display: flex;
-            align-items: center;
-            gap: 0.75rem;
-            padding: 1rem 1.25rem;
-            border-radius: var(--radius-sm);
-            font-weight: 600;
-            font-size: 0.95rem;
-            transition: background 300ms ease, color 300ms ease;
-        }
-
-        .status--checking {
-            background: rgba(17, 17, 17, 0.05);
-            color: var(--muted);
-        }
-
-        .status--connected {
-            background: rgba(46, 139, 87, 0.1);
-            color: var(--green);
-        }
-
-        .status--error {
-            background: rgba(211, 47, 47, 0.08);
-            color: var(--red);
-        }
-
-        .status__dot {
-            width: 0.7rem;
-            height: 0.7rem;
-            border-radius: 50%;
-            flex-shrink: 0;
-        }
-
-        .status--checking .status__dot {
-            background: var(--muted);
-            animation: pulse 1.2s ease-in-out infinite;
-        }
-
-        .status--connected .status__dot {
-            background: var(--green);
-        }
-
-        .status--error .status__dot {
-            background: var(--red);
-        }
-
-        @keyframes pulse {
-            0%, 100% { opacity: 0.4; transform: scale(0.85); }
-            50%      { opacity: 1;   transform: scale(1); }
-        }
-
-        .hint {
-            margin-top: 1.5rem;
-            padding-top: 1.25rem;
-            border-top: 1px solid var(--edge);
-            font-size: 0.8rem;
-            color: var(--muted);
-            line-height: 1.5;
-        }
-
-        .hint strong {
-            color: var(--ink-soft);
-        }
-    </style>
-</head>
-<body>
-    <div class="card">
-        <h1 class="heading">Web Signer</h1>
-
-        <p class="subtitle">
-            This page connects the app to your Nostr Web Signer extension so you can sign in and use Coop securely.
-        </p>
-
-        <div id="nip07-status" class="status status--checking">
-            <div class="status__dot"></div>
-            <span id="nip07-status-text">Checking extension…</span>
-        </div>
-
-        <div class="hint">
-            <strong>Keep this tab open</strong> while using the app — it automatically handles sign-in requests in the background.
-        </div>
-    </div>
-
-    <script src="proxy.js"></script>
-</body>
-</html>

crates/browser-signer-proxy/proxy.js

@@ -1,156 +0,0 @@
-let isPolling = false;
-
-async function pollForRequests() {
-    if (isPolling) return;
-    isPolling = true;
-
-    try {
-        const response = await fetch('/api/pending');
-        const data = await response.json();
-
-        console.log('Polled for requests, got:', data);
-
-        // Process any new requests
-        if (data.requests && data.requests.length > 0) {
-            console.log(`Processing ${data.requests.length} requests`);
-            for (const request of data.requests) {
-                await handleNip07Request(request);
-            }
-        }
-    } catch (error) {
-        console.error('Polling error:', error);
-        updateStatus('Error: ' + error.message, 'error');
-    }
-
-    isPolling = false;
-}
-
-async function handleNip07Request(request) {
-    console.log('Handling request:', request);
-
-    try {
-        let result;
-
-        if (!window.nostr) {
-            throw new Error('NIP-07 extension not available');
-        }
-
-        switch (request.method) {
-            case 'get_public_key':
-                console.log('Calling nostr.getPublicKey()');
-                result = await window.nostr.getPublicKey();
-                console.log('Got public key:', result);
-                break;
-
-            case 'sign_event':
-                console.log('Calling nostr.signEvent() with:', request.params);
-                result = await window.nostr.signEvent(request.params);
-                console.log('Got signed event:', result);
-                break;
-
-            case 'nip04_encrypt':
-                console.log('Calling nostr.nip04.encrypt()');
-                result = await window.nostr.nip04.encrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip04_decrypt':
-                console.log('Calling nostr.nip04.decrypt()');
-                result = await window.nostr.nip04.decrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip44_encrypt':
-                console.log('Calling nostr.nip44.encrypt()');
-                result = await window.nostr.nip44.encrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip44_decrypt':
-                console.log('Calling nostr.nip44.decrypt()');
-                result = await window.nostr.nip44.decrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-
-            default:
-                throw new Error(`Unknown method: ${request.method}`);
-        }
-
-        // Send response back to server
-        const responsePayload = {
-            id: request.id,
-            result: result,
-            error: null
-        };
-
-        console.log('Sending response:', responsePayload);
-
-        await fetch('/api/response', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(responsePayload)
-        });
-
-        console.log('Response sent successfully');
-        updateStatus('Request processed successfully', 'connected');
-
-    } catch (error) {
-        console.error('Error handling request:', error);
-
-        // Send error response back to server
-        const errorPayload = {
-            id: request.id,
-            result: null,
-            error: error.message
-        };
-
-        console.log('Sending error response:', errorPayload);
-
-        await fetch('/api/response', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(errorPayload)
-        });
-
-        updateStatus('Error: ' + error.message, 'error');
-    }
-}
-
-function updateStatus(message, state) {
-    const container = document.getElementById('nip07-status');
-    const textEl = document.getElementById('nip07-status-text');
-    if (container && textEl) {
-        container.className = 'status status--' + state;
-        textEl.textContent = message;
-    }
-}
-
-// Start polling when page loads
-window.addEventListener('load', () => {
-    console.log('NIP-07 Proxy loaded');
-
-    // Check if NIP-07 extension is available
-    if (window.nostr) {
-        console.log('NIP-07 extension detected');
-        updateStatus('Connected — ready', 'connected');
-    } else {
-        console.log('NIP-07 extension not found');
-        updateStatus('No NIP-07 extension found', 'error');
-    }
-
-    // Start polling every 500 ms
-    setInterval(pollForRequests, 500);
-});

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

@@ -1,51 +0,0 @@
-// Copyright (c) 2022-2023 Yuki Kishimoto
-// Copyright (c) 2023-2025 Rust Nostr Developers
-// Distributed under the MIT software license
-
-//! Error types for the browser signer proxy.
-
-opaquerr::define_kind! {
-    /// Nostr browser signer proxy error kind.
-    pub ErrorKind {
-        /// Nostr protocol error.
-        Protocol => "nostr protocol error",
-        /// I/O error.
-        IO => "I/O error",
-        /// JSON error.
-        Json => "JSON error",
-        /// The operation timed out.
-        Timeout => "timeout",
-        /// The operation cannot be completed in the current state.
-        State => "invalid state",
-        /// Anything not covered by the stable categories above.
-        Other => "other error",
-    }
-}
-
-opaquerr::define_error! {
-    /// Nostr browser signer proxy error.
-    pub Error(ErrorKind)
-
-    from {
-        nostr::error::Error => ErrorKind::Protocol,
-        std::io::Error => ErrorKind::IO,
-        serde_json::Error => ErrorKind::Json,
-    }
-}
-
-impl Error {
-    pub(crate) fn generic<S>(message: S) -> Self
-    where
-        S: Into<String>,
-    {
-        Self::new(ErrorKind::Other, message.into())
-    }
-
-    pub(crate) fn timeout() -> Self {
-        Self::simple(ErrorKind::Timeout)
-    }
-
-    pub(crate) fn shutdown() -> Self {
-        Self::with_static_message(ErrorKind::State, "server is shutdown")
-    }
-}

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

@@ -1,764 +0,0 @@
-use std::collections::HashMap;
-use std::future::Future;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
-use std::pin::Pin;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-use atomic_destructor::{AtomicDestroyer, AtomicDestructor};
-use event_listener::Event as ShutdownEvent;
-use nostr::prelude::*;
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize, Serializer};
-use serde_json::{Value, json};
-use smol::channel;
-use smol::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use smol::lock::Mutex;
-use smol::net::{TcpListener, TcpStream};
-use uuid::Uuid;
-
-mod error;
-pub mod prelude;
-
-pub use self::error::Error;
-
-const DEFAULT_HTML: &str = include_str!("../index.html");
-const JS: &str = include_str!("../proxy.js");
-
-type PendingResponseMap = HashMap<Uuid, channel::Sender<Result<Value, String>>>;
-
-#[derive(Debug, Deserialize)]
-struct Message {
-    id: Uuid,
-    error: Option<String>,
-    result: Option<Value>,
-}
-
-impl Message {
-    fn into_result(self) -> Result<Value, String> {
-        if let Some(error) = self.error {
-            Err(error)
-        } else {
-            Ok(self.result.unwrap_or(Value::Null))
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum RequestMethod {
-    GetPublicKey,
-    SignEvent,
-    Nip04Encrypt,
-    Nip04Decrypt,
-    Nip44Encrypt,
-    Nip44Decrypt,
-}
-
-impl RequestMethod {
-    fn as_str(&self) -> &str {
-        match self {
-            Self::GetPublicKey => "get_public_key",
-            Self::SignEvent => "sign_event",
-            Self::Nip04Encrypt => "nip04_encrypt",
-            Self::Nip04Decrypt => "nip04_decrypt",
-            Self::Nip44Encrypt => "nip44_encrypt",
-            Self::Nip44Decrypt => "nip44_decrypt",
-        }
-    }
-}
-
-impl Serialize for RequestMethod {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self.as_str())
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-struct RequestData {
-    id: Uuid,
-    method: RequestMethod,
-    params: Value,
-}
-
-impl RequestData {
-    #[inline]
-    fn new(method: RequestMethod, params: Value) -> Self {
-        Self {
-            id: Uuid::new_v4(),
-            method,
-            params,
-        }
-    }
-}
-
-#[derive(Serialize)]
-struct Requests<'a> {
-    requests: &'a [RequestData],
-}
-
-impl<'a> Requests<'a> {
-    #[inline]
-    fn new(requests: &'a [RequestData]) -> Self {
-        Self { requests }
-    }
-
-    #[inline]
-    fn len(&self) -> usize {
-        self.requests.len()
-    }
-}
-
-/// Params for NIP-04 and NIP-44 encryption/decryption
-#[derive(Serialize)]
-struct CryptoParams<'a> {
-    public_key: &'a PublicKey,
-    content: &'a str,
-}
-
-impl<'a> CryptoParams<'a> {
-    #[inline]
-    fn new(public_key: &'a PublicKey, content: &'a str) -> Self {
-        Self {
-            public_key,
-            content,
-        }
-    }
-}
-
-#[derive(Debug)]
-struct ProxyState {
-    /// Requests waiting to be picked up by browser
-    pub outgoing_requests: Mutex<Vec<RequestData>>,
-    /// Map of request ID to response sender
-    pub pending_responses: Mutex<PendingResponseMap>,
-    /// Last time the client asked for the pending requests
-    pub last_pending_request: Arc<AtomicU64>,
-}
-
-/// Configuration options for [`BrowserSignerProxy`].
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BrowserSignerProxyOptions {
-    /// Request timeout for the signer extension. Default is 30 seconds.
-    pub timeout: Duration,
-    /// Proxy server IP address and port. Default is `127.0.0.1:7400`.
-    pub addr: SocketAddr,
-    /// Custom HTML page.
-    // NOTE: not `Option` to move it between threads without reference counter
-    pub custom_html: &'static str,
-}
-
-#[derive(Debug, Clone)]
-struct InnerBrowserSignerProxy {
-    /// Configuration options for the proxy
-    options: BrowserSignerProxyOptions,
-    /// Internal state of the proxy including request queues
-    state: Arc<ProxyState>,
-    /// Notification trigger for graceful shutdown
-    shutdown: Arc<ShutdownEvent>,
-    /// Flag to indicate if the server is shutdown
-    is_shutdown: Arc<AtomicBool>,
-    /// Flag indicating if the server is started
-    is_started: Arc<AtomicBool>,
-}
-
-impl AtomicDestroyer for InnerBrowserSignerProxy {
-    fn on_destroy(&self) {
-        self.shutdown();
-    }
-}
-
-impl InnerBrowserSignerProxy {
-    #[inline]
-    fn is_shutdown(&self) -> bool {
-        self.is_shutdown.load(Ordering::SeqCst)
-    }
-
-    fn shutdown(&self) {
-        // Mark the server as shutdown
-        self.is_shutdown.store(true, Ordering::SeqCst);
-
-        // Notify all waiters that the proxy is shutting down
-        self.shutdown.notify(usize::MAX);
-    }
-}
-
-/// Nostr Browser Signer Proxy
-///
-/// Proxy to use Nostr Browser signer (NIP-07) in native applications.
-#[derive(Debug, Clone)]
-pub struct BrowserSignerProxy {
-    inner: AtomicDestructor<InnerBrowserSignerProxy>,
-}
-
-impl Default for BrowserSignerProxyOptions {
-    fn default() -> Self {
-        Self {
-            timeout: Duration::from_secs(30),
-            // 7 for NIP-07 and 400 because the NIP title is 40 bytes :)
-            addr: SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 7400)),
-            custom_html: "",
-        }
-    }
-}
-
-impl BrowserSignerProxyOptions {
-    /// Sets the timeout duration.
-    pub const fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
-        self
-    }
-
-    /// Sets the IP address.
-    pub const fn ip_addr(mut self, new_ip: IpAddr) -> Self {
-        self.addr = SocketAddr::new(new_ip, self.addr.port());
-        self
-    }
-
-    /// Sets the port number.
-    pub const fn port(mut self, new_port: u16) -> Self {
-        self.addr = SocketAddr::new(self.addr.ip(), new_port);
-        self
-    }
-
-    /// Sets a custom html page.
-    ///
-    /// The page must include `/proxy.js` script (`<script src="/proxy.js"></script>`)
-    /// which will handle communication with the server and update the element
-    /// with id `nip07-proxy-status` with the status.
-    pub const fn custom_html_page(mut self, custom_html: &'static str) -> Self {
-        self.custom_html = custom_html;
-        self
-    }
-}
-
-impl BrowserSignerProxy {
-    /// Construct a new browser signer proxy
-    pub fn new(options: BrowserSignerProxyOptions) -> Self {
-        let state = ProxyState {
-            outgoing_requests: Mutex::new(Vec::new()),
-            pending_responses: Mutex::new(HashMap::new()),
-            last_pending_request: Arc::new(AtomicU64::new(0)),
-        };
-
-        Self {
-            inner: AtomicDestructor::new(InnerBrowserSignerProxy {
-                options,
-                state: Arc::new(state),
-                shutdown: Arc::new(ShutdownEvent::new()),
-                is_shutdown: Arc::new(AtomicBool::new(false)),
-                is_started: Arc::new(AtomicBool::new(false)),
-            }),
-        }
-    }
-
-    /// Indicates whether the server is currently running.
-    #[inline]
-    pub fn is_started(&self) -> bool {
-        self.inner.is_started.load(Ordering::SeqCst)
-    }
-
-    /// Checks if there is an open browser tab ready to respond to requests by
-    /// verifying the time since the last pending request.
-    #[inline]
-    pub fn is_session_active(&self) -> bool {
-        current_time() - self.inner.state.last_pending_request.load(Ordering::SeqCst) < 2
-    }
-
-    /// Get the signer proxy webpage URL
-    #[inline]
-    pub fn url(&self) -> String {
-        format!("http://{}", self.inner.options.addr)
-    }
-
-    /// Start the proxy server.
-    ///
-    /// If this is not called explicitly, the server will be automatically
-    /// started on the first interaction with the signer.
-    pub async fn start(&self) -> Result<(), Error> {
-        // Ensure is not shutdown
-        if self.inner.is_shutdown() {
-            return Err(Error::shutdown());
-        }
-
-        // Mark the proxy as started and check if was already started
-        let is_started: bool = self.inner.is_started.swap(true, Ordering::SeqCst);
-
-        // Immediately return if already started
-        if is_started {
-            return Ok(());
-        }
-
-        let listener: TcpListener = match TcpListener::bind(self.inner.options.addr).await {
-            Ok(listener) => listener,
-            Err(e) => {
-                // Undo the started flag if binding fails
-                self.inner.is_started.store(false, Ordering::SeqCst);
-                return Err(Error::from(e));
-            }
-        };
-
-        let addr: SocketAddr = self.inner.options.addr;
-        let state: Arc<ProxyState> = self.inner.state.clone();
-        let custom_html: &'static str = self.inner.options.custom_html;
-        let shutdown: Arc<ShutdownEvent> = self.inner.shutdown.clone();
-
-        smol::spawn(async move {
-            tracing::info!("Starting proxy server on {addr}");
-
-            loop {
-                // Race between accepting a new connection and shutdown signal
-                let shutdown_listener = shutdown.listen();
-
-                enum AcceptEvent {
-                    Connection(Result<(TcpStream, SocketAddr), std::io::Error>),
-                    Shutdown,
-                }
-
-                let event = smol::future::or(
-                    async { AcceptEvent::Connection(listener.accept().await) },
-                    async {
-                        shutdown_listener.await;
-                        AcceptEvent::Shutdown
-                    },
-                )
-                .await;
-
-                match event {
-                    AcceptEvent::Connection(Ok((stream, _))) => {
-                        let state: Arc<ProxyState> = state.clone();
-                        let shutdown: Arc<ShutdownEvent> = shutdown.clone();
-
-                        smol::spawn(async move {
-                            let shutdown_listener = shutdown.listen();
-
-                            smol::future::or(
-                                async {
-                                    handle_connection(stream, state, custom_html).await;
-                                },
-                                async {
-                                    shutdown_listener.await;
-                                    tracing::debug!(
-                                        "Closing connection, proxy server is shutting down."
-                                    );
-                                },
-                            )
-                            .await;
-                        })
-                        .detach();
-                    }
-                    AcceptEvent::Connection(Err(e)) => {
-                        tracing::error!("Failed to accept connection: {e}");
-                    }
-                    AcceptEvent::Shutdown => break,
-                }
-            }
-
-            tracing::info!("Proxy server shut down.");
-        })
-        .detach();
-
-        Ok(())
-    }
-
-    #[inline]
-    async fn store_pending_response(&self, id: Uuid, tx: channel::Sender<Result<Value, String>>) {
-        let mut pending_responses = self.inner.state.pending_responses.lock().await;
-        pending_responses.insert(id, tx);
-    }
-
-    #[inline]
-    async fn store_outgoing_request(&self, request: RequestData) {
-        let mut outgoing_requests = self.inner.state.outgoing_requests.lock().await;
-        outgoing_requests.push(request);
-    }
-
-    async fn request<T>(&self, method: RequestMethod, params: Value) -> Result<T, Error>
-    where
-        T: DeserializeOwned,
-    {
-        // Start the proxy if not already started
-        self.start().await?;
-
-        // Construct the request
-        let request: RequestData = RequestData::new(method, params);
-
-        // Create a bounded channel of size 1 as a oneshot replacement
-        let (tx, rx) = channel::bounded::<Result<Value, String>>(1);
-
-        // Store the response sender
-        self.store_pending_response(request.id, tx).await;
-
-        // Add to outgoing requests queue
-        self.store_outgoing_request(request).await;
-
-        // Wait for response with timeout
-        let response = race_timeout(self.inner.options.timeout, rx.recv()).await;
-
-        match response {
-            Ok(Ok(res)) => Ok(serde_json::from_value(res)?),
-            Ok(Err(error)) => Err(Error::generic(error)),
-            Err(TimeoutError) => Err(Error::timeout()),
-        }
-    }
-
-    #[inline]
-    async fn _get_public_key(&self) -> Result<PublicKey, Error> {
-        self.request(RequestMethod::GetPublicKey, json!({})).await
-    }
-
-    #[inline]
-    async fn _sign_event(&self, event: UnsignedEvent) -> Result<Event, Error> {
-        let event: Event = self
-            .request(RequestMethod::SignEvent, serde_json::to_value(event)?)
-            .await?;
-        event.verify()?;
-        Ok(event)
-    }
-
-    #[inline]
-    async fn _nip04_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Encrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip04_decrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Decrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip44_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip44Encrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip44_decrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip44Decrypt, serde_json::to_value(params)?)
-            .await
-    }
-}
-
-impl AsyncGetPublicKey for BrowserSignerProxy {
-    type Error = Error;
-
-    #[inline]
-    fn get_public_key_async(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, Self::Error>> + Send + '_>> {
-        Box::pin(async move { self._get_public_key().await })
-    }
-}
-
-impl AsyncSignEvent for BrowserSignerProxy {
-    type Error = Error;
-
-    #[inline]
-    fn sign_event_async(
-        &self,
-        unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, Self::Error>> + Send + '_>> {
-        Box::pin(async move { self._sign_event(unsigned).await })
-    }
-}
-
-impl AsyncNip04 for BrowserSignerProxy {
-    type Error = Error;
-
-    fn nip04_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_encrypt(public_key, content).await })
-    }
-
-    fn nip04_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        encrypted_content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_decrypt(public_key, encrypted_content).await })
-    }
-}
-
-impl AsyncNip44 for BrowserSignerProxy {
-    type Error = Error;
-
-    fn nip44_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip44_encrypt(public_key, content).await })
-    }
-
-    fn nip44_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip44_decrypt(public_key, payload).await })
-    }
-}
-
-// ── Minimal HTTP server ──────────────────────────────────────────────────
-
-/// Handle a single HTTP connection.
-async fn handle_connection(stream: TcpStream, state: Arc<ProxyState>, custom_html: &'static str) {
-    let mut reader = BufReader::new(stream);
-
-    // Read the request line
-    let mut request_line = String::new();
-    if reader.read_line(&mut request_line).await.is_err() {
-        return;
-    }
-    let request_line = request_line.trim_end().to_string();
-
-    // Parse method, path, and HTTP version from request line
-    let parts: Vec<&str> = request_line.split_whitespace().collect();
-    if parts.len() < 2 {
-        send_response(&mut reader, 400, "Bad Request", "", "").await;
-        return;
-    }
-    let method = parts[0].to_uppercase();
-    let path = parts[1].to_string();
-
-    // Read headers until empty line
-    let mut headers = Vec::new();
-    let mut content_length: usize = 0;
-    loop {
-        let mut line = String::new();
-        if reader.read_line(&mut line).await.is_err() {
-            return;
-        }
-        let line = line.trim_end().to_string();
-        if line.is_empty() {
-            break;
-        }
-        if let Some(value) = line.strip_prefix("content-length:") {
-            content_length = value.trim().parse().unwrap_or(0);
-        } else if let Some(value) = line.strip_prefix("Content-Length:") {
-            content_length = value.trim().parse().unwrap_or(0);
-        }
-        headers.push(line);
-    }
-
-    match (method.as_str(), path.as_str()) {
-        // Serve the HTML proxy page
-        ("GET", "/") => {
-            let html = if custom_html.is_empty() {
-                DEFAULT_HTML
-            } else {
-                custom_html
-            };
-            send_response(&mut reader, 200, "OK", "text/html", html).await;
-        }
-        // Serve the JS proxy script
-        ("GET", "/proxy.js") => {
-            send_response(&mut reader, 200, "OK", "application/javascript", JS).await;
-        }
-        // Browser polls this endpoint to get pending requests
-        ("GET", "/api/pending") => {
-            state
-                .last_pending_request
-                .store(current_time(), Ordering::SeqCst);
-
-            let mut outgoing = state.outgoing_requests.lock().await;
-
-            let requests = Requests::new(&outgoing);
-            let json = match serde_json::to_string(&requests) {
-                Ok(j) => j,
-                Err(e) => {
-                    tracing::error!("Failed to serialize pending requests: {e}");
-                    send_response(&mut reader, 500, "Internal Server Error", "", "").await;
-                    return;
-                }
-            };
-
-            tracing::debug!("Sending {} pending requests to browser", requests.len());
-
-            // Clear the outgoing requests after sending them
-            outgoing.clear();
-
-            send_response_cors_json(&mut reader, 200, "OK", &json).await;
-        }
-        // Receive response from browser extension
-        ("POST", "/api/response") => {
-            let mut body_bytes = vec![0u8; content_length];
-            if content_length > 0 && reader.read_exact(&mut body_bytes).await.is_err() {
-                send_response(&mut reader, 400, "Bad Request", "", "").await;
-                return;
-            }
-
-            let message: Message = match serde_json::from_slice(&body_bytes) {
-                Ok(json) => json,
-                Err(e) => {
-                    tracing::error!("Failed to parse response body: {e}");
-                    send_response(&mut reader, 400, "Invalid JSON", "", "").await;
-                    return;
-                }
-            };
-
-            tracing::debug!("Received response from browser: {message:?}");
-
-            let id: Uuid = message.id;
-            let mut pending = state.pending_responses.lock().await;
-
-            match pending.remove(&id) {
-                Some(sender) => {
-                    // Use try_send since we already hold the lock
-                    let _ = sender.try_send(message.into_result());
-                    tracing::info!("Forwarded response for request {id}");
-                }
-                None => tracing::warn!("No pending request found for {id}"),
-            }
-
-            send_response_cors(&mut reader, 200, "OK", "text/plain", "OK").await;
-        }
-        // CORS preflight
-        ("OPTIONS", _) => {
-            let response = "HTTP/1.1 200 OK\r\n\
-                Access-Control-Allow-Origin: *\r\n\
-                Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n\
-                Access-Control-Allow-Headers: Content-Type\r\n\
-                Content-Length: 0\r\n\
-                Connection: close\r\n\
-                \r\n";
-            let _ = reader.get_mut().write_all(response.as_bytes()).await;
-            let _ = reader.get_mut().flush().await;
-        }
-        // 404 - not found
-        _ => {
-            send_response(&mut reader, 404, "Not Found", "", "").await;
-        }
-    }
-}
-
-/// Write an HTTP response to the stream.
-async fn send_response(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    content_type: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-
-    if !content_type.is_empty() {
-        response.push_str(&format!("Content-Type: {content_type}\r\n"));
-    }
-
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-/// Write a response with CORS headers and JSON content type.
-async fn send_response_cors_json(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-    response.push_str("Content-Type: application/json\r\n");
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-/// Write a response with CORS headers.
-async fn send_response_cors(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    content_type: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-
-    if !content_type.is_empty() {
-        response.push_str(&format!("Content-Type: {content_type}\r\n"));
-    }
-
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-// ── Timeout helper ───────────────────────────────────────────────────────
-
-/// An error indicating that an operation timed out.
-#[derive(Debug)]
-struct TimeoutError;
-
-/// Races a channel receive against a duration.
-///
-/// Returns the channel value on success, or [`TimeoutError`] if the duration
-/// elapses first or the channel is closed.
-async fn race_timeout<T>(
-    duration: Duration,
-    recv: impl Future<Output = Result<T, channel::RecvError>>,
-) -> Result<T, TimeoutError> {
-    enum Event<T> {
-        Value(T),
-        ChannelClosed,
-        Timeout,
-    }
-
-    let event = smol::future::or(
-        async {
-            match recv.await {
-                Ok(value) => Event::Value(value),
-                Err(_) => Event::ChannelClosed,
-            }
-        },
-        async {
-            smol::Timer::after(duration).await;
-            Event::Timeout
-        },
-    )
-    .await;
-
-    match event {
-        Event::Value(value) => Ok(value),
-        Event::ChannelClosed | Event::Timeout => Err(TimeoutError),
-    }
-}
-
-// ── Utility ──────────────────────────────────────────────────────────────
-
-/// Gets the current time in seconds since the Unix epoch (1970-01-01). If the
-/// time is before the epoch, returns 0.
-#[inline]
-fn current_time() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_secs())
-        .unwrap_or_default()
-}

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

@@ -1,14 +0,0 @@
-// Copyright (c) 2022-2023 Yuki Kishimoto
-// Copyright (c) 2023-2025 Rust Nostr Developers
-// Distributed under the MIT software license
-
-//! Prelude
-
-#![allow(unknown_lints)]
-#![allow(ambiguous_glob_reexports)]
-#![doc(hidden)]
-
-pub use nostr::prelude::*;
-
-pub use crate::error::{Error, ErrorKind};
-pub use crate::*;

crates/chat/Cargo.toml

@@ -13,16 +13,15 @@ settings = { path = "../settings" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 
 anyhow.workspace = true
 itertools.workspace = true
 smallvec.workspace = true
-log.workspace = true
-flume.workspace = true
-
-futures.workspace = true
-fuzzy-matcher = "0.3.7"
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 smol.workspace = true
+log.workspace = true
+futures.workspace = true
+flume.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+
+fuzzy-matcher = "0.3.7"

crates/chat/src/message.rs

@@ -1,110 +1,10 @@
 use std::hash::Hash;
 use std::ops::Range;
 
-use common::{EventExt, NostrParser, extract_and_remove_media_urls};
-use gpui::{SharedString, SharedUri};
+use common::{EventExt, NostrParser};
+use gpui::SharedString;
 use nostr_sdk::prelude::*;
 
-/// Rendered message.
-#[derive(Debug, Clone)]
-pub struct Message {
-    pub id: EventId,
-    /// Author's public key
-    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<Mention>,
-    /// List of event of the message this message is a reply to
-    pub replies_to: Vec<EventId>,
-}
-
-impl From<&Event> for Message {
-    fn from(val: &Event) -> Self {
-        let mentions = extract_mentions(&val.content);
-        let replies_to = extract_reply_ids(&val.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.content);
-
-        Self {
-            id: val.id,
-            author: val.pubkey,
-            content: string,
-            media,
-            created_at: val.created_at,
-            mentions,
-            replies_to,
-        }
-    }
-}
-
-impl From<&UnsignedEvent> for Message {
-    fn from(val: &UnsignedEvent) -> Self {
-        let mentions = extract_mentions(&val.content);
-        let replies_to = extract_reply_ids(&val.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.content);
-
-        Self {
-            // Event ID must be known
-            id: val.id.unwrap(),
-            author: val.pubkey,
-            content: string,
-            media,
-            created_at: val.created_at,
-            mentions,
-            replies_to,
-        }
-    }
-}
-
-impl From<&NewMessage> for Message {
-    fn from(val: &NewMessage) -> Self {
-        let mentions = extract_mentions(&val.rumor.content);
-        let replies_to = extract_reply_ids(&val.rumor.tags);
-        let (media, string) = extract_and_remove_media_urls(&val.rumor.content);
-
-        Self {
-            // Event ID must be known
-            id: val.rumor.id.unwrap(),
-            author: val.rumor.pubkey,
-            content: string,
-            media,
-            created_at: val.rumor.created_at,
-            mentions,
-            replies_to,
-        }
-    }
-}
-
-impl Eq for Message {}
-
-impl PartialEq for Message {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl Ord for Message {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.created_at.cmp(&other.created_at)
-    }
-}
-
-impl PartialOrd for Message {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Hash for Message {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-    }
-}
-
 /// New message.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NewMessage {
@@ -144,6 +44,74 @@ impl FailedMessage {
     }
 }
 
+/// Message.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub enum Message {
+    User(RenderedMessage),
+    Warning(String, Timestamp),
+    System(Timestamp),
+}
+
+impl Message {
+    pub fn user<I>(user: I) -> Self
+    where
+        I: Into<RenderedMessage>,
+    {
+        Self::User(user.into())
+    }
+
+    pub fn warning<I>(content: I) -> Self
+    where
+        I: Into<String>,
+    {
+        Self::Warning(content.into(), Timestamp::now())
+    }
+
+    pub fn system() -> Self {
+        Self::System(Timestamp::default())
+    }
+
+    fn timestamp(&self) -> &Timestamp {
+        match self {
+            Message::User(msg) => &msg.created_at,
+            Message::Warning(_, ts) => ts,
+            Message::System(ts) => ts,
+        }
+    }
+}
+
+impl From<&NewMessage> for Message {
+    fn from(val: &NewMessage) -> Self {
+        Self::User(val.into())
+    }
+}
+
+impl From<&UnsignedEvent> for Message {
+    fn from(val: &UnsignedEvent) -> Self {
+        Self::User(val.into())
+    }
+}
+
+impl Ord for Message {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match (self, other) {
+            // System always comes first
+            (Message::System(_), Message::System(_)) => self.timestamp().cmp(other.timestamp()),
+            (Message::System(_), _) => std::cmp::Ordering::Less,
+            (_, Message::System(_)) => std::cmp::Ordering::Greater,
+
+            // For non-system messages, compare by timestamp
+            _ => self.timestamp().cmp(other.timestamp()),
+        }
+    }
+}
+
+impl PartialOrd for Message {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Mention {
     pub public_key: PublicKey,
@@ -156,6 +124,98 @@ impl Mention {
     }
 }
 
+/// Rendered message.
+#[derive(Debug, Clone)]
+pub struct RenderedMessage {
+    pub id: EventId,
+    /// Author's public key
+    pub author: PublicKey,
+    /// The content/text of the message
+    pub content: String,
+    /// Message created time as unix timestamp
+    pub created_at: Timestamp,
+    /// List of mentioned public keys in the message
+    pub mentions: Vec<Mention>,
+    /// List of event of the message this message is a reply to
+    pub replies_to: Vec<EventId>,
+}
+
+impl From<&Event> for RenderedMessage {
+    fn from(val: &Event) -> Self {
+        let mentions = extract_mentions(&val.content);
+        let replies_to = extract_reply_ids(&val.tags);
+
+        Self {
+            id: val.id,
+            author: val.pubkey,
+            content: val.content.clone(),
+            created_at: val.created_at,
+            mentions,
+            replies_to,
+        }
+    }
+}
+
+impl From<&UnsignedEvent> for RenderedMessage {
+    fn from(val: &UnsignedEvent) -> Self {
+        let mentions = extract_mentions(&val.content);
+        let replies_to = extract_reply_ids(&val.tags);
+
+        Self {
+            // Event ID must be known
+            id: val.id.unwrap(),
+            author: val.pubkey,
+            content: val.content.clone(),
+            created_at: val.created_at,
+            mentions,
+            replies_to,
+        }
+    }
+}
+
+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);
+
+        Self {
+            // Event ID must be known
+            id: val.rumor.id.unwrap(),
+            author: val.rumor.pubkey,
+            content: val.rumor.content.clone(),
+            created_at: val.rumor.created_at,
+            mentions,
+            replies_to,
+        }
+    }
+}
+
+impl Eq for RenderedMessage {}
+
+impl PartialEq for RenderedMessage {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Ord for RenderedMessage {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.created_at.cmp(&other.created_at)
+    }
+}
+
+impl PartialOrd for RenderedMessage {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Hash for RenderedMessage {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
 /// Extracts all mentions (public keys) from a content string.
 fn extract_mentions(content: &str) -> Vec<Mention> {
     let parser = NostrParser::new();
@@ -174,13 +234,13 @@ fn extract_mentions(content: &str) -> Vec<Mention> {
 fn extract_reply_ids(inner: &Tags) -> Vec<EventId> {
     let mut replies_to = vec![];
 
-    for tag in inner.iter().filter(|tag| tag.kind() == "e") {
+    for tag in inner.filter(TagKind::e()) {
         if let Some(id) = tag.content().and_then(|id| EventId::parse(id).ok()) {
             replies_to.push(id);
         }
     }
 
-    for tag in inner.iter().filter(|tag| tag.kind() == "q") {
+    for tag in inner.filter(TagKind::q()) {
         if let Some(id) = tag.content().and_then(|id| EventId::parse(id).ok()) {
             replies_to.push(id);
         }

crates/chat/src/room.rs

@@ -1,16 +1,15 @@
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
-use device::DeviceRegistry;
 use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
-use instant::Duration;
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry};
 use settings::{RoomConfig, SignerKind};
-use state::{NostrRegistry, TIMEOUT, UniversalSigner};
+use state::{NostrRegistry, TIMEOUT};
 
 use crate::NewMessage;
 
@@ -22,7 +21,7 @@ pub struct SendReport {
     pub receiver: PublicKey,
     pub gift_wrap_id: Option<EventId>,
     pub error: Option<SharedString>,
-    pub output: Option<Output<EventId, EventSendStatus>>,
+    pub output: Option<Output<EventId>>,
 }
 
 impl SendReport {
@@ -42,7 +41,7 @@ impl SendReport {
     }
 
     /// Set the output.
-    pub fn output(mut self, output: Output<EventId, EventSendStatus>) -> Self {
+    pub fn output(mut self, output: Output<EventId>) -> Self {
         self.output = Some(output);
         self
     }
@@ -172,8 +171,7 @@ impl From<&UnsignedEvent> for Room {
         let members = val.extract_public_keys();
         let subject = val
             .tags
-            .iter()
-            .find(|tag| tag.kind() == "subject")
+            .find(TagKind::Subject)
             .and_then(|tag| tag.content().map(|s| s.to_owned().into()));
 
         Room {
@@ -207,7 +205,7 @@ impl Room {
         // WARNING: never sign this event
         let mut event = EventBuilder::new(Kind::PrivateDirectMessage, "")
             .tags(tags)
-            .finalize_unsigned(author);
+            .build(author);
 
         // Ensure that the ID is set
         event.ensure_id();
@@ -271,8 +269,8 @@ impl Room {
     }
 
     /// Returns the members of the room
-    pub fn members(&self) -> &[PublicKey] {
-        &self.members
+    pub fn members(&self) -> Vec<PublicKey> {
+        self.members.clone()
     }
 
     /// Checks if the room has more than two members (group)
@@ -356,38 +354,29 @@ impl Room {
     pub fn connect(&self, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let members = self.members().to_vec();
+        let members = self.members();
 
         cx.background_spawn(async move {
             let opts = SubscribeAutoCloseOptions::default()
                 .exit_policy(ReqExitPolicy::ExitOnEOSE)
                 .timeout(Some(Duration::from_secs(TIMEOUT)));
 
-            let tasks: Vec<_> = members
-                .into_iter()
-                .map(|public_key| {
-                    let client = client.clone();
-                    async move {
-                        let inbox = Filter::new()
-                            .author(public_key)
-                            .kind(Kind::InboxRelays)
-                            .limit(1);
+            for public_key in members.into_iter() {
+                let inbox = Filter::new()
+                    .author(public_key)
+                    .kind(Kind::InboxRelays)
+                    .limit(1);
 
-                        let announcement = Filter::new()
-                            .author(public_key)
-                            .kind(Kind::Custom(10044))
-                            .limit(1);
+                let announcement = Filter::new()
+                    .author(public_key)
+                    .kind(Kind::Custom(10044))
+                    .limit(1);
 
-                        client
-                            .subscribe(vec![inbox, announcement])
-                            .close_on(opts)
-                            .await
-                    }
-                })
-                .collect();
-
-            for result in futures::future::join_all(tasks).await {
-                result?;
+                // Subscribe to the target
+                client
+                    .subscribe(vec![inbox, announcement])
+                    .close_on(opts)
+                    .await?;
             }
 
             Ok(())
@@ -398,12 +387,12 @@ impl Room {
     pub fn get_messages(&self, cx: &App) -> Task<Result<Vec<UnsignedEvent>, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let room_id = self.id.to_string();
+        let conversation_id = self.id.to_string();
 
         cx.background_spawn(async move {
             let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
-                .custom_tag(SingleLetterTag::lowercase(Alphabet::R), room_id);
+                .custom_tag(SingleLetterTag::lowercase(Alphabet::C), conversation_id);
 
             let messages = client
                 .database()
@@ -419,23 +408,12 @@ impl Room {
     }
 
     // Construct a rumor event for direct message
-    pub fn rumor<S, I>(
-        &self,
-        content: S,
-        replies: I,
-        reaction: bool,
-        cx: &App,
-    ) -> Option<UnsignedEvent>
+    pub fn rumor<S, I>(&self, content: S, replies: I, cx: &App) -> Option<UnsignedEvent>
     where
         S: Into<String>,
         I: IntoIterator<Item = EventId>,
     {
-        let kind = if reaction {
-            Kind::Reaction
-        } else {
-            Kind::PrivateDirectMessage
-        };
-
+        let kind = Kind::PrivateDirectMessage;
         let content: String = content.into();
         let replies: Vec<EventId> = replies.into_iter().collect();
 
@@ -443,14 +421,24 @@ impl Room {
         let nostr = NostrRegistry::global(cx);
 
         // Get current user's public key
-        let sender = nostr.read(cx).current_user()?;
+        let sender = nostr.read(cx).signer().public_key()?;
+
+        // Get all members, excluding the sender
+        let members: Vec<Person> = self
+            .members
+            .iter()
+            .filter(|public_key| public_key != &&sender)
+            .map(|member| persons.read(cx).get(member, cx))
+            .collect();
 
         // Construct event's tags
         let mut tags = vec![];
 
         // Add subject tag if present
         if let Some(value) = self.subject.as_ref() {
-            tags.push(Tag::custom("subject", vec![value.to_string()]));
+            tags.push(Tag::from_standardized_without_cell(TagStandard::Subject(
+                value.to_string(),
+            )));
         }
 
         // Add all reply tags
@@ -458,23 +446,21 @@ impl Room {
             tags.push(Tag::event(id))
         }
 
-        // Add all receiver tags (no intermediate allocation)
-        for public_key in self.members.iter().filter(|pk| *pk != &sender) {
-            let member = persons.read(cx).get(public_key, cx);
-            tags.push(
-                Nip01Tag::PublicKey {
+        // Add all receiver tags
+        for member in members.into_iter() {
+            tags.push(Tag::from_standardized_without_cell(
+                TagStandard::PublicKey {
                     public_key: member.public_key(),
-                    relay_hint: member.messaging_relay_hint(),
-                }
-                .to_tag(),
-            );
+                    relay_url: member.messaging_relay_hint(),
+                    alias: None,
+                    uppercase: false,
+                },
+            ));
         }
 
         // Construct a direct message rumor event
         // WARNING: never sign and send this event to relays
-        let mut event = EventBuilder::new(kind, content)
-            .tags(tags)
-            .finalize_unsigned(sender);
+        let mut event = EventBuilder::new(kind, content).tags(tags).build(sender);
 
         // Ensure that the ID is set
         event.ensure_id();
@@ -482,45 +468,17 @@ impl Room {
         Some(event)
     }
 
-    /// Select the appropriate signer based on signer kind and available keys.
-    fn select_signer(
-        signer_kind: &SignerKind,
-        has_announcement: bool,
-        encryption_signer: &Option<UniversalSigner>,
-        user_signer: &UniversalSigner,
-    ) -> UniversalSigner {
-        match signer_kind {
-            SignerKind::Auto => {
-                if has_announcement {
-                    encryption_signer
-                        .clone()
-                        .unwrap_or_else(|| user_signer.clone())
-                } else {
-                    user_signer.clone()
-                }
-            }
-            SignerKind::Encryption => encryption_signer
-                .clone()
-                .expect("encryption signer must be set"),
-            SignerKind::User => user_signer.clone(),
-        }
-    }
-
     /// 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 device = DeviceRegistry::global(cx);
-        let encryption_signer = device.read(cx).signer(cx);
-
+        let persons = PersonRegistry::global(cx);
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let user_signer = nostr.read(cx).signer();
-        let current_user = nostr.read(cx).current_user()?;
+        let signer = nostr.read(cx).signer();
 
-        // Get sender's profile
-        let persons = PersonRegistry::global(cx);
-        let sender = persons.read(cx).get(&current_user, cx);
+        // Get current user's 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
@@ -534,6 +492,9 @@ impl Room {
             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();
 
@@ -558,12 +519,23 @@ impl Room {
                 }
 
                 // Determine the signer to use
-                let signer = Self::select_signer(
-                    signer_kind,
-                    announcement.is_some(),
-                    &encryption_signer,
-                    &user_signer,
-                );
+                let signer = match signer_kind {
+                    SignerKind::Auto => {
+                        if announcement.is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
+                        {
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
+                        } else {
+                            user_signer.clone()
+                        }
+                    }
+                    SignerKind::Encryption => {
+                        // Safe to unwrap due to earlier checks
+                        encryption_signer.as_ref().unwrap().clone()
+                    }
+                    SignerKind::User => user_signer.clone(),
+                };
 
                 // Send the gift wrap event and collect the report
                 match send_gift_wrap(&client, &signer, &member, &rumor, signer_kind).await {
@@ -583,12 +555,23 @@ impl Room {
                 let public_key = sender.public_key();
 
                 // Determine the signer to use
-                let signer = Self::select_signer(
-                    signer_kind,
-                    sender.announcement().is_some(),
-                    &encryption_signer,
-                    &user_signer,
-                );
+                let signer = match signer_kind {
+                    SignerKind::Auto => {
+                        if sender.announcement().is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
+                        {
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
+                        } else {
+                            user_signer.clone()
+                        }
+                    }
+                    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),
@@ -605,15 +588,17 @@ impl Room {
 }
 
 // Helper function to send a gift-wrapped event
-async fn send_gift_wrap(
+async fn send_gift_wrap<T>(
     client: &Client,
-    signer: &UniversalSigner,
+    signer: &T,
     receiver: &Person,
     rumor: &UnsignedEvent,
     config: &SignerKind,
-) -> Result<SendReport, Error> {
-    let k_tag = Tag::custom("k", vec!["14"]);
-    let mut extra_tags = vec![k_tag];
+) -> Result<SendReport, Error>
+where
+    T: NostrSigner + 'static,
+{
+    let mut extra_tags = vec![];
 
     // Determine the receiver public key based on the config
     let receiver = match config {
@@ -637,10 +622,7 @@ async fn send_gift_wrap(
     };
 
     // Construct the gift wrap event
-    let event = nip59::GiftWrapBuilder::new(receiver, rumor.clone())
-        .extra_tags(extra_tags)
-        .finalize_async(signer)
-        .await?;
+    let event = EventBuilder::gift_wrap(signer, &receiver, rumor.clone(), extra_tags).await?;
 
     // Send the gift wrap event and collect the report
     let report = client

crates/chat_ui/Cargo.toml

@@ -14,16 +14,19 @@ chat = { path = "../chat" }
 settings = { path = "../settings" }
 
 gpui.workspace = true
+gpui_tokio.workspace = true
+
 nostr-sdk.workspace = true
 anyhow.workspace = true
 itertools.workspace = true
 smallvec.workspace = true
+smol.workspace = true
 flume.workspace = true
-futures.workspace = true
 log.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 
+once_cell = "1.19.0"
+regex = "1"
 linkify = "0.10.0"
 pulldown-cmark = "0.13.1"
-regex = "1"
-

crates/chat_ui/src/text.rs

@@ -69,7 +69,6 @@ impl RenderedText {
 
     pub fn element(&self, id: ElementId, window: &Window, cx: &App) -> AnyElement {
         let code_background = cx.theme().elevated_surface_background;
-        let color = cx.theme().text_accent;
 
         InteractiveText::new(
             id,
@@ -101,7 +100,6 @@ impl RenderedText {
                                 }
                             }
                             Highlight::Mention => HighlightStyle {
-                                color: Some(color),
                                 underline: Some(UnderlineStyle {
                                     thickness: 1.0.into(),
                                     ..Default::default()

crates/common/Cargo.toml

@@ -7,14 +7,16 @@ publish.workspace = true
 [dependencies]
 gpui.workspace = true
 nostr.workspace = true
-instant.workspace = true
 nostr-sdk.workspace = true
 
+anyhow.workspace = true
 itertools.workspace = true
 chrono.workspace = true
+smallvec.workspace = true
+smol.workspace = true
 futures.workspace = true
 log.workspace = true
 
 dirs = "5.0"
 qrcode = "0.14.1"
-regex = "1.10"
+bech32 = "0.11.1"

crates/common/src/caching.rs

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

crates/common/src/debounced_delay.rs

@@ -1,5 +1,5 @@
 use std::marker::PhantomData;
-use instant::Duration;
+use std::time::Duration;
 
 use futures::channel::oneshot;
 use futures::FutureExt;

crates/common/src/event.rs

@@ -18,7 +18,7 @@ impl EventExt for Event {
     }
 
     fn extract_public_keys(&self) -> Vec<PublicKey> {
-        let mut public_keys: Vec<PublicKey> = self.tags.public_keys().collect();
+        let mut public_keys: Vec<PublicKey> = self.tags.public_keys().copied().collect();
         public_keys.push(self.pubkey);
 
         public_keys.into_iter().unique().collect()
@@ -46,7 +46,7 @@ impl EventExt for UnsignedEvent {
     }
 
     fn extract_public_keys(&self) -> Vec<PublicKey> {
-        let mut public_keys: Vec<PublicKey> = self.tags.public_keys().collect();
+        let mut public_keys: Vec<PublicKey> = self.tags.public_keys().copied().collect();
         public_keys.push(self.pubkey);
         public_keys.into_iter().unique().sorted().collect()
     }

crates/common/src/lib.rs

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

crates/common/src/media_extractor.rs

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

@@ -0,0 +1,71 @@
+[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 = "1.0.0-beta2"
+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" }
+title_bar = { path = "../title_bar" }
+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_platform.workspace = true
+gpui_linux.workspace = true
+gpui_windows.workspace = true
+gpui_macos.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
+webbrowser.workspace = true
+
+indexset = "0.12.3"
+tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+# Temporary workaround https://github.com/zed-industries/zed/issues/47168
+core-text = "=21.0.0"

crates/coop/resources/flatpak/manifest-template.json

@@ -50,7 +50,7 @@
         },
         {
           "type": "dir",
-          "path": "./desktop/resources"
+          "path": "./crates/coop/resources"
         }
       ]
     }

crates/coop/src/dialogs/accounts.rs

@@ -0,0 +1,257 @@
+use anyhow::Error;
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    App, AppContext, Context, Entity, InteractiveElement, IntoElement, ParentElement, Render,
+    SharedString, StatefulInteractiveElement, Styled, Subscription, Task, Window, div, px,
+};
+use nostr_sdk::prelude::*;
+use person::PersonRegistry;
+use state::{NostrRegistry, StateEvent};
+use theme::ActiveTheme;
+use ui::avatar::Avatar;
+use ui::button::{Button, ButtonVariants};
+use ui::indicator::Indicator;
+use ui::{Disableable, Icon, IconName, Sizable, WindowExtension, h_flex, v_flex};
+
+use crate::dialogs::connect::ConnectSigner;
+use crate::dialogs::import::ImportKey;
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<AccountSelector> {
+    cx.new(|cx| AccountSelector::new(window, cx))
+}
+
+/// Account selector
+pub struct AccountSelector {
+    /// Public key currently being chosen for login
+    logging_in: Entity<Option<PublicKey>>,
+
+    /// The error message displayed when an error occurs.
+    error: Entity<Option<SharedString>>,
+
+    /// Async tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+
+    /// Subscription to the signer events
+    _subscription: Option<Subscription>,
+}
+
+impl AccountSelector {
+    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let logging_in = cx.new(|_| None);
+        let error = cx.new(|_| None);
+
+        // Subscribe to the signer events
+        let nostr = NostrRegistry::global(cx);
+        let subscription = cx.subscribe_in(&nostr, window, |this, _state, event, window, cx| {
+            match event {
+                StateEvent::SignerSet => {
+                    window.close_all_modals(cx);
+                    window.refresh();
+                }
+                StateEvent::Error(e) => {
+                    this.set_error(e.to_string(), cx);
+                }
+                _ => {}
+            };
+        });
+
+        Self {
+            logging_in,
+            error,
+            tasks: vec![],
+            _subscription: Some(subscription),
+        }
+    }
+
+    fn logging_in(&self, public_key: &PublicKey, cx: &App) -> bool {
+        self.logging_in.read(cx) == &Some(*public_key)
+    }
+
+    fn set_logging_in(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
+        self.logging_in.update(cx, |this, cx| {
+            *this = Some(public_key);
+            cx.notify();
+        });
+    }
+
+    fn set_error<T>(&mut self, error: T, cx: &mut Context<Self>)
+    where
+        T: Into<SharedString>,
+    {
+        self.error.update(cx, |this, cx| {
+            *this = Some(error.into());
+            cx.notify();
+        });
+
+        self.logging_in.update(cx, |this, cx| {
+            *this = None;
+            cx.notify();
+        })
+    }
+
+    fn login(&mut self, public_key: PublicKey, window: &mut Window, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let task = nostr.read(cx).get_secret(public_key, cx);
+
+        // Mark the public key as being logged in
+        self.set_logging_in(public_key, cx);
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(signer) => {
+                    nostr.update(cx, |this, cx| {
+                        this.set_signer(signer, cx);
+                    });
+                }
+                Err(e) => {
+                    this.update(cx, |this, cx| {
+                        this.set_error(e.to_string(), cx);
+                    })?;
+                }
+            };
+            Ok(())
+        }));
+    }
+
+    fn remove(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+
+        nostr.update(cx, |this, cx| {
+            this.remove_secret(&public_key, cx);
+        });
+    }
+
+    fn open_import(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let import = cx.new(|cx| ImportKey::new(window, cx));
+
+        window.open_modal(cx, move |this, _window, _cx| {
+            this.width(px(460.))
+                .title("Import a Secret Key or Bunker Connection")
+                .show_close(true)
+                .pb_2()
+                .child(import.clone())
+        });
+    }
+
+    fn open_connect(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let connect = cx.new(|cx| ConnectSigner::new(window, cx));
+
+        window.open_modal(cx, move |this, _window, _cx| {
+            this.width(px(460.))
+                .title("Scan QR Code to Connect")
+                .show_close(true)
+                .pb_2()
+                .child(connect.clone())
+        });
+    }
+}
+
+impl Render for AccountSelector {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let persons = PersonRegistry::global(cx);
+        let nostr = NostrRegistry::global(cx);
+        let npubs = nostr.read(cx).npubs();
+        let loading = self.logging_in.read(cx).is_some();
+
+        v_flex()
+            .size_full()
+            .gap_2()
+            .when_some(self.error.read(cx).as_ref(), |this, error| {
+                this.child(
+                    div()
+                        .italic()
+                        .text_xs()
+                        .text_center()
+                        .text_color(cx.theme().text_danger)
+                        .child(error.clone()),
+                )
+            })
+            .children({
+                let mut items = vec![];
+
+                for (ix, public_key) in npubs.read(cx).iter().enumerate() {
+                    let profile = persons.read(cx).get(public_key, cx);
+                    let logging_in = self.logging_in(public_key, cx);
+
+                    items.push(
+                        h_flex()
+                            .id(ix)
+                            .group("")
+                            .px_2()
+                            .h_10()
+                            .justify_between()
+                            .w_full()
+                            .rounded(cx.theme().radius)
+                            .bg(cx.theme().ghost_element_background)
+                            .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .child(Avatar::new(profile.avatar()).small())
+                                    .child(div().text_sm().child(profile.name())),
+                            )
+                            .when(logging_in, |this| this.child(Indicator::new().small()))
+                            .when(!logging_in, |this| {
+                                this.child(
+                                    h_flex()
+                                        .gap_1()
+                                        .invisible()
+                                        .group_hover("", |this| this.visible())
+                                        .child(
+                                            Button::new(format!("del-{ix}"))
+                                                .icon(IconName::Close)
+                                                .ghost()
+                                                .small()
+                                                .disabled(logging_in)
+                                                .on_click(cx.listener({
+                                                    let public_key = *public_key;
+                                                    move |this, _ev, _window, cx| {
+                                                        cx.stop_propagation();
+                                                        this.remove(public_key, cx);
+                                                    }
+                                                })),
+                                        ),
+                                )
+                            })
+                            .when(!logging_in, |this| {
+                                let public_key = *public_key;
+                                this.on_click(cx.listener(move |this, _ev, window, cx| {
+                                    this.login(public_key, window, cx);
+                                }))
+                            }),
+                    );
+                }
+
+                items
+            })
+            .child(div().w_full().h_px().bg(cx.theme().border_variant))
+            .child(
+                h_flex()
+                    .gap_1()
+                    .justify_end()
+                    .w_full()
+                    .child(
+                        Button::new("input")
+                            .icon(Icon::new(IconName::Usb))
+                            .label("Import")
+                            .ghost()
+                            .small()
+                            .disabled(loading)
+                            .on_click(cx.listener(move |this, _ev, window, cx| {
+                                this.open_import(window, cx);
+                            })),
+                    )
+                    .child(
+                        Button::new("qr")
+                            .icon(Icon::new(IconName::Scan))
+                            .label("Scan QR to connect")
+                            .ghost()
+                            .small()
+                            .disabled(loading)
+                            .on_click(cx.listener(move |this, _ev, window, cx| {
+                                this.open_connect(window, cx);
+                            })),
+                    ),
+            )
+    }
+}

crates/coop/src/dialogs/connect.rs

@@ -0,0 +1,115 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use common::StringExt;
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    AppContext, Context, Entity, Image, IntoElement, ParentElement, Render, SharedString, Styled,
+    Subscription, Window, div, img, px,
+};
+use nostr_connect::prelude::*;
+use state::{
+    CLIENT_NAME, CoopAuthUrlHandler, NOSTR_CONNECT_RELAY, NOSTR_CONNECT_TIMEOUT, NostrRegistry,
+    StateEvent,
+};
+use theme::ActiveTheme;
+use ui::v_flex;
+
+pub struct ConnectSigner {
+    /// QR Code
+    qr_code: Option<Arc<Image>>,
+
+    /// Error message
+    error: Entity<Option<SharedString>>,
+
+    /// Subscription to the signer event
+    _subscription: Option<Subscription>,
+}
+
+impl ConnectSigner {
+    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let error = cx.new(|_| None);
+
+        let nostr = NostrRegistry::global(cx);
+        let app_keys = nostr.read(cx).keys();
+
+        let timeout = Duration::from_secs(NOSTR_CONNECT_TIMEOUT);
+        let relay = RelayUrl::parse(NOSTR_CONNECT_RELAY).unwrap();
+
+        // Generate the nostr connect uri
+        let uri = NostrConnectUri::client(app_keys.public_key(), vec![relay], CLIENT_NAME);
+
+        // Generate the nostr connect
+        let mut signer = NostrConnect::new(uri.clone(), app_keys.clone(), timeout, None).unwrap();
+
+        // Handle the auth request
+        signer.auth_url_handler(CoopAuthUrlHandler);
+
+        // Generate a QR code for quick connection
+        let qr_code = uri.to_string().to_qr();
+
+        // Set signer in the background
+        nostr.update(cx, |this, cx| {
+            this.add_nip46_signer(&signer, cx);
+        });
+
+        // Subscribe to the signer event
+        let subscription = cx.subscribe_in(&nostr, window, |this, _state, event, _window, cx| {
+            if let StateEvent::Error(e) = event {
+                this.set_error(e, cx);
+            }
+        });
+
+        Self {
+            qr_code,
+            error,
+            _subscription: Some(subscription),
+        }
+    }
+
+    fn set_error<S>(&mut self, message: S, cx: &mut Context<Self>)
+    where
+        S: Into<SharedString>,
+    {
+        self.error.update(cx, |this, cx| {
+            *this = Some(message.into());
+            cx.notify();
+        });
+    }
+}
+
+impl Render for ConnectSigner {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        const MSG: &str = "Scan with any Nostr Connect-compatible app to connect";
+
+        v_flex()
+            .size_full()
+            .items_center()
+            .justify_center()
+            .p_4()
+            .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),
+                )
+            })
+            .when_some(self.error.read(cx).as_ref(), |this, error| {
+                this.child(
+                    div()
+                        .text_xs()
+                        .text_center()
+                        .text_color(cx.theme().text_danger)
+                        .child(error.clone()),
+                )
+            })
+            .child(
+                div()
+                    .text_xs()
+                    .text_color(cx.theme().text_muted)
+                    .child(SharedString::from(MSG)),
+            )
+    }
+}

crates/coop/src/dialogs/import.rs

@@ -1,19 +1,21 @@
+use std::time::Duration;
+
 use anyhow::{Error, anyhow};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString, Styled,
     Subscription, Task, Window, div,
 };
-use instant::Duration;
 use nostr_connect::prelude::*;
-use state::{CoopAuthUrlHandler, NostrRegistry, USER_KEYRING};
+use smallvec::{SmallVec, smallvec};
+use state::{CoopAuthUrlHandler, NostrRegistry, StateEvent};
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
-use ui::input::{Input, InputEvent, InputState};
-use ui::{Disableable, StyledExt, WindowExtension, divider, v_flex};
+use ui::input::{InputEvent, InputState, TextInput};
+use ui::{Disableable, v_flex};
 
 #[derive(Debug)]
-pub struct ImportIdentity {
+pub struct ImportKey {
     /// Secret key input
     key_input: Entity<InputState>,
 
@@ -23,60 +25,75 @@ pub struct ImportIdentity {
     /// Error message
     error: Entity<Option<SharedString>>,
 
+    /// Countdown timer for nostr connect
+    countdown: Entity<Option<u64>>,
+
     /// Whether the user is currently loading
     loading: bool,
 
     /// Async tasks
     tasks: Vec<Task<Result<(), Error>>>,
 
-    /// Input subscription
-    _subscription: Option<Subscription>,
+    /// Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 2]>,
 }
 
-impl ImportIdentity {
+impl ImportKey {
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let key_input = cx.new(|cx| InputState::new(window, cx).placeholder("nsec or bunker://"));
+        let nostr = NostrRegistry::global(cx);
+        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 input_subscription =
+        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);
                 };
-            });
+            }),
+        );
+
+        subscriptions.push(
+            // Subscribe to the nostr signer event
+            cx.subscribe_in(&nostr, window, |this, _state, event, _window, cx| {
+                if let StateEvent::Error(e) = event {
+                    this.set_error(e, cx);
+                }
+            }),
+        );
 
         Self {
             key_input,
             pass_input,
             error,
+            countdown,
             loading: false,
             tasks: vec![],
-            _subscription: Some(input_subscription),
+            _subscriptions: subscriptions,
         }
     }
 
     fn login(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.loading {
+            return;
+        };
+        // Prevent duplicate login requests
+        self.set_loading(true, cx);
+
         let value = self.key_input.read(cx).value();
         let password = self.pass_input.read(cx).value();
 
-        // Set loading state
-        self.set_loading(true, cx);
-
-        if value.starts_with("ncryptsec1") {
-            self.ncryptsec(value, password, window, cx);
+        if value.starts_with("bunker://") {
+            self.bunker(&value, window, cx);
             return;
         }
 
-        if value.starts_with("bunker://") {
-            match NostrConnectUri::parse(value) {
-                Ok(uri) => {
-                    self.bunker(uri, window, cx);
-                }
-                Err(e) => {
-                    self.set_error(e.to_string(), cx);
-                }
-            }
+        if value.starts_with("ncryptsec1") {
+            self.ncryptsec(value, password, window, cx);
             return;
         }
 
@@ -86,13 +103,52 @@ impl ImportIdentity {
 
             // Update the signer
             nostr.update(cx, |this, cx| {
-                this.set_signer(keys, cx);
+                this.add_key_signer(&keys, cx);
             });
         } else {
             self.set_error("Invalid key", cx);
         }
     }
 
+    fn 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 app_keys = nostr.read(cx).keys();
+        let timeout = Duration::from_secs(30);
+
+        // Construct the nostr connect signer
+        let mut signer = NostrConnect::new(uri, app_keys.clone(), timeout, None).unwrap();
+
+        // Handle auth url with the default browser
+        signer.auth_url_handler(CoopAuthUrlHandler);
+
+        // Set signer in the background
+        nostr.update(cx, |this, cx| {
+            this.add_nip46_signer(&signer, cx);
+        });
+
+        // Start countdown
+        self.tasks.push(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);
+                    })?;
+                } else {
+                    this.update(cx, |this, cx| {
+                        this.set_countdown(Some(i), cx);
+                    })?;
+                }
+                cx.background_executor().timer(Duration::from_secs(1)).await;
+            }
+            Ok(())
+        }));
+    }
+
     fn ncryptsec<S>(&mut self, content: S, pwd: S, window: &mut Window, cx: &mut Context<Self>)
     where
         S: Into<String>,
@@ -123,10 +179,9 @@ impl ImportIdentity {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             match task.await {
                 Ok(keys) => {
-                    nostr.update_in(cx, |this, window, cx| {
-                        this.set_signer(keys, cx);
-                        window.close_modal(cx);
-                    })?;
+                    nostr.update(cx, |this, cx| {
+                        this.add_key_signer(&keys, cx);
+                    });
                 }
                 Err(e) => {
                     this.update(cx, |this, cx| {
@@ -134,55 +189,21 @@ impl ImportIdentity {
                     })?;
                 }
             }
-            Ok(())
-        }));
-    }
-
-    fn bunker(&mut self, uri: NostrConnectUri, window: &mut Window, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        let master_keys = nostr.read(cx).get_master_key(cx);
-        let password = uri.to_string();
-        let save = cx.write_credentials(USER_KEYRING, "bunker", password.as_bytes());
-
-        self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
-            let keys = master_keys.await;
-            let timeout = Duration::from_secs(30);
-
-            // Construct the nostr connect signer
-            let mut signer = NostrConnect::new(uri, keys, timeout, None)?;
-
-            // Handle auth url with the default browser
-            signer.auth_url_handler(CoopAuthUrlHandler);
-
-            nostr.update(cx, |this, cx| {
-                this.set_signer(signer, cx);
-                cx.background_spawn(async move { save.await.ok() }).detach();
-                cx.notify();
-            });
 
             Ok(())
         }));
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
-    fn proxy(&mut self, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        nostr.update(cx, |this, cx| {
-            this.connect_proxy(cx);
-        });
-    }
-
-    fn set_loading(&mut self, status: bool, cx: &mut Context<Self>) {
-        self.loading = status;
-        cx.notify();
-    }
-
     fn set_error<S>(&mut self, message: S, cx: &mut Context<Self>)
     where
         S: Into<SharedString>,
     {
+        // Reset the log in state
         self.set_loading(false, cx);
 
+        // Reset the countdown
+        self.set_countdown(None, cx);
+
         // Update error message
         self.error.update(cx, |this, cx| {
             *this = Some(message.into());
@@ -203,80 +224,67 @@ impl ImportIdentity {
             Ok(())
         }));
     }
+
+    fn set_loading(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.loading = 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 Render for ImportIdentity {
+impl Render for ImportKey {
     fn render(&mut self, _window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const BUNKER_WARN: &str = "Nostr Connect will usually take more time to get all your messages. Please keep your session open until you see all your messages.";
-        const KEY_WARN: &str = "Coop won't store your identity key on the local device. You need to re-login again in the next session. You can use Nostr Connect for persistent login.";
-
-        let is_wasm = cfg!(target_arch = "wasm32");
-        let require_password = self.key_input.read(cx).value().starts_with("ncryptsec1");
-        let key_warning = self.key_input.read(cx).value().starts_with("nsec1") || require_password;
-        let bunker_warning = self.key_input.read(cx).value().starts_with("bunker://");
-
         v_flex()
             .size_full()
-            .gap_4()
+            .gap_2()
             .text_sm()
             .child(
                 v_flex()
-                    .gap_2()
-                    .child(
+                    .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("Continue with existing key or bunker connection")
-                            .child(Input::new(&self.key_input)),
+                            .child("Password:")
+                            .child(TextInput::new(&self.pass_input)),
                     )
-                    .when(require_password, |this| {
-                        this.child(
-                            v_flex()
-                                .gap_1()
-                                .text_color(cx.theme().text_muted)
-                                .child("Decrypt Password:")
-                                .child(Input::new(&self.pass_input)),
-                        )
-                    })
-                    .when(bunker_warning, |this| {
-                        this.child(
-                            div()
-                                .text_xs()
-                                .text_color(cx.theme().text_warning)
-                                .child(div().child(BUNKER_WARN)),
-                        )
-                    })
-                    .when(key_warning, |this| {
-                        this.child(
-                            div()
-                                .text_xs()
-                                .text_color(cx.theme().text_warning)
-                                .child(div().child(KEY_WARN)),
-                        )
-                    }),
+                },
             )
             .child(
                 Button::new("login")
                     .label("Continue")
                     .primary()
-                    .font_semibold()
                     .loading(self.loading)
                     .disabled(self.loading)
-                    .on_click(cx.listener(move |this, _ev, window, cx| {
+                    .on_click(cx.listener(move |this, _, window, cx| {
                         this.login(window, cx);
                     })),
             )
-            .child(divider(cx))
-            .when(!is_wasm, |this| {
+            .when_some(self.countdown.read(cx).as_ref(), |this, i| {
                 this.child(
-                    Button::new("proxy")
-                        .label("Connect via Web Extension (Experimental)")
-                        .ghost_alt()
-                        .loading(self.loading)
-                        .disabled(self.loading)
-                        .on_click(cx.listener(move |this, _ev, _window, cx| {
-                            this.proxy(cx);
-                        })),
+                    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| {

crates/coop/src/dialogs/mod.rs

@@ -1,3 +1,5 @@
+pub mod accounts;
+pub mod connect;
 pub mod import;
 pub mod restore;
 pub mod screening;

crates/coop/src/dialogs/restore.rs

@@ -1,4 +1,4 @@
-use instant::Duration;
+use std::time::Duration;
 
 use anyhow::Error;
 use device::DeviceRegistry;
@@ -7,10 +7,10 @@ use gpui::{
     AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString, Styled,
     Subscription, Task, Window, div,
 };
-use nostr_sdk::prelude::*;
+use nostr_connect::prelude::*;
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
-use ui::input::{Input, InputEvent, InputState};
+use ui::input::{InputEvent, InputState, TextInput};
 use ui::{WindowExtension, v_flex};
 
 #[derive(Debug)]
@@ -107,7 +107,7 @@ impl Render for RestoreEncryption {
                     .text_sm()
                     .text_color(cx.theme().text_muted)
                     .child("Secret Key")
-                    .child(Input::new(&self.key_input)),
+                    .child(TextInput::new(&self.key_input)),
             )
             .child(
                 Button::new("restore")

crates/coop/src/dialogs/screening.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
+use std::time::Duration;
 
-use anyhow::Error;
+use anyhow::{Context as AnyhowContext, Error};
 use common::TimestampExt;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     App, AppContext, Context, Div, Entity, InteractiveElement, IntoElement, ParentElement, Render,
     SharedString, Styled, Subscription, Task, Window, div, px, relative, uniform_list,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry, shorten_pubkey};
 use smallvec::{SmallVec, smallvec};
@@ -16,7 +16,7 @@ use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::indicator::Indicator;
-use ui::{Disableable, Icon, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
+use ui::{Icon, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 pub fn init(public_key: PublicKey, window: &mut Window, cx: &mut App) -> Entity<Screening> {
     cx.new(|cx| Screening::new(public_key, window, cx))
@@ -55,7 +55,7 @@ impl Screening {
             window.close_all_modals(cx);
         }));
 
-        cx.defer_in(window, |this, _window, cx| {
+        cx.defer_in(window, move |this, _window, cx| {
             this.check_contact(cx);
             this.check_wot(cx);
             this.check_last_activity(cx);
@@ -78,13 +78,12 @@ impl Screening {
         let client = nostr.read(cx).client();
         let public_key = self.public_key;
 
-        let Some(current_user) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<bool, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let signer_pubkey = signer.get_public_key().await?;
+
             // Check if user is in contact list
-            let contacts = client.database().contacts_public_keys(current_user).await;
+            let contacts = client.database().contacts_public_keys(signer_pubkey).await;
             let followed = contacts.unwrap_or_default().contains(&public_key);
 
             Ok(followed)
@@ -106,17 +105,16 @@ impl Screening {
         let client = nostr.read(cx).client();
         let public_key = self.public_key;
 
-        let Some(current_user) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<Vec<PublicKey>, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let signer_pubkey = signer.get_public_key().await?;
+
             // Check mutual contacts
             let filter = Filter::new().kind(Kind::ContactList).pubkey(public_key);
             let mut mutual_contacts = vec![];
 
             if let Ok(events) = client.database().query(filter).await {
-                for event in events.into_iter().filter(|ev| ev.pubkey != current_user) {
+                for event in events.into_iter().filter(|ev| ev.pubkey != signer_pubkey) {
                     mutual_contacts.push(event.pubkey);
                 }
             }
@@ -224,20 +222,12 @@ impl Screening {
     fn report(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
         let public_key = self.public_key;
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let tag = Nip56Tag::PublicKey {
-                public_key,
-                report: Report::Impersonation,
-            }
-            .to_tag();
-
-            let event = EventBuilder::new(Kind::Reporting, "")
-                .tag(tag)
-                .finalize_async(&signer)
-                .await?;
+            let tag = Tag::public_key_report(public_key, Report::Impersonation);
+            let builder = EventBuilder::report(vec![tag], "");
+            let event = client.sign_event_builder(builder).await?;
 
             // Send the report to the public relays
             client.send_event(&event).to(BOOTSTRAP_RELAYS).await?;
@@ -263,7 +253,7 @@ impl Screening {
             let contacts = contacts.clone();
             let total = contacts.len();
 
-            this.title("Mutual contacts").child(
+            this.title(SharedString::from("Mutual contacts")).child(
                 v_flex().gap_1().pb_2().child(
                     uniform_list("contacts", total, move |range, _window, cx| {
                         let persons = PersonRegistry::global(cx);
@@ -342,7 +332,7 @@ impl Render for Screening {
                             .h_7()
                             .justify_center()
                             .rounded_full()
-                            .bg(cx.theme().elevated_surface_background)
+                            .bg(cx.theme().surface_background)
                             .text_sm()
                             .truncate()
                             .text_ellipsis()
@@ -355,8 +345,7 @@ impl Render for Screening {
                             .gap_1()
                             .child(
                                 Button::new("njump")
-                                    .icon(IconName::Link)
-                                    .label("njump.me")
+                                    .label("View on njump.me")
                                     .secondary()
                                     .small()
                                     .rounded()
@@ -387,18 +376,21 @@ impl Render for Screening {
                             .text_sm()
                             .child(status_badge(Some(self.followed), cx))
                             .child(
-                                v_flex().text_sm().child("Contact").child(
-                                    div()
-                                        .line_clamp(1)
-                                        .text_color(cx.theme().text_muted)
-                                        .child({
-                                            if self.followed {
-                                                SharedString::from(CONTACT)
-                                            } else {
-                                                SharedString::from(NOT_CONTACT)
-                                            }
-                                        }),
-                                ),
+                                v_flex()
+                                    .text_sm()
+                                    .child(SharedString::from("Contact"))
+                                    .child(
+                                        div()
+                                            .line_clamp(1)
+                                            .text_color(cx.theme().text_muted)
+                                            .child({
+                                                if self.followed {
+                                                    SharedString::from(CONTACT)
+                                                } else {
+                                                    SharedString::from(NOT_CONTACT)
+                                                }
+                                            }),
+                                    ),
                             ),
                     )
                     .child(
@@ -413,7 +405,7 @@ impl Render for Screening {
                                     .child(
                                         h_flex()
                                             .gap_0p5()
-                                            .child("Activity on Public Relays")
+                                            .child(SharedString::from("Activity on Public Relays"))
                                             .child(
                                                 Button::new("active")
                                                     .icon(IconName::Info)
@@ -482,8 +474,25 @@ impl Render for Screening {
                             .gap_2()
                             .child(status_badge(Some(mutuals > 0), cx))
                             .child(
-                                h_flex()
+                                v_flex()
                                     .text_sm()
+                                    .child(
+                                        h_flex()
+                                            .gap_0p5()
+                                            .child(SharedString::from("Mutual contacts"))
+                                            .child(
+                                                Button::new("mutuals")
+                                                    .icon(IconName::Info)
+                                                    .xsmall()
+                                                    .ghost()
+                                                    .rounded()
+                                                    .on_click(cx.listener(
+                                                        move |this, _, window, cx| {
+                                                            this.mutual_contacts(window, cx);
+                                                        },
+                                                    )),
+                                            ),
+                                    )
                                     .child(
                                         div()
                                             .line_clamp(1)
@@ -495,17 +504,6 @@ impl Render for Screening {
                                                     SharedString::from(NO_MUTUAL)
                                                 }
                                             }),
-                                    )
-                                    .child(
-                                        Button::new("mutuals")
-                                            .icon(IconName::Info)
-                                            .xsmall()
-                                            .ghost()
-                                            .rounded()
-                                            .disabled(mutuals == 0)
-                                            .on_click(cx.listener(move |this, _, window, cx| {
-                                                this.mutual_contacts(window, cx);
-                                            })),
                                     ),
                             ),
                     ),

crates/coop/src/dialogs/settings.rs

@@ -3,11 +3,11 @@ use gpui::{
     App, AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString, Styled,
     Window, div, px,
 };
-use settings::AppSettings;
+use settings::{AppSettings, AuthMode};
 use theme::{ActiveTheme, Theme, ThemeMode};
 use ui::button::{Button, ButtonVariants};
 use ui::group_box::{GroupBox, GroupBoxVariants};
-use ui::input::{Input, InputState};
+use ui::input::{InputState, TextInput};
 use ui::menu::{DropdownMenu, PopupMenuItem};
 use ui::notification::Notification;
 use ui::switch::Switch;
@@ -56,15 +56,18 @@ impl Preferences {
 
 impl Render for Preferences {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const SCREENING: &str = "Show an screening dialog to verify the unknown sender.";
-        const AVATAR: &str = "Hide all avatar pictures to improve performance.";
-        const MODE: &str = "Use the selected light or dark theme, or to follow the OS.";
-        const NIP4E: &str = "Use a dedicated key to encrypt and decrypt messages.";
+        const SCREENING: &str =
+            "When opening a request, a popup will appear to help you identify the sender.";
+        const AVATAR: &str =
+            "Hide all avatar pictures to improve performance and protect your privacy.";
+        const MODE: &str =
+            "Choose whether to use the selected light or dark theme, or to follow the OS.";
+        const AUTH: &str = "Choose the authentication behavior for relays.";
         const RESET: &str = "Reset the theme to the default one.";
 
         let screening = AppSettings::get_screening(cx);
         let hide_avatar = AppSettings::get_hide_avatar(cx);
-        let nip4e = AppSettings::get_nip4e(cx);
+        let auth_mode = AppSettings::get_auth_mode(cx);
         let theme_mode = AppSettings::get_theme_mode(cx);
 
         v_flex()
@@ -91,6 +94,52 @@ impl Render for Preferences {
                             .on_click(move |_, _window, cx| {
                                 AppSettings::update_hide_avatar(!hide_avatar, cx);
                             }),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_3()
+                            .justify_between()
+                            .child(
+                                v_flex()
+                                    .child(
+                                        div()
+                                            .text_sm()
+                                            .child(SharedString::from("Relay authentication")),
+                                    )
+                                    .child(
+                                        div()
+                                            .text_xs()
+                                            .text_color(cx.theme().text_muted)
+                                            .child(SharedString::from(AUTH)),
+                                    ),
+                            )
+                            .child(
+                                Button::new("auth")
+                                    .label(auth_mode.to_string())
+                                    .ghost_alt()
+                                    .small()
+                                    .dropdown_menu(|this, _window, _cx| {
+                                        this.min_w(px(256.))
+                                            .item(
+                                                PopupMenuItem::new("Auto authentication").on_click(
+                                                    |_ev, _window, cx| {
+                                                        AppSettings::update_auth_mode(
+                                                            AuthMode::Auto,
+                                                            cx,
+                                                        );
+                                                    },
+                                                ),
+                                            )
+                                            .item(PopupMenuItem::new("Ask every time").on_click(
+                                                |_ev, _window, cx| {
+                                                    AppSettings::update_auth_mode(
+                                                        AuthMode::Manual,
+                                                        cx,
+                                                    );
+                                                },
+                                            ))
+                                    }),
+                            ),
                     ),
             )
             .child(
@@ -158,21 +207,6 @@ impl Render for Preferences {
                             ),
                     ),
             )
-            .child(
-                GroupBox::new()
-                    .id("experiments")
-                    .title("Experiments")
-                    .fill()
-                    .child(
-                        Switch::new("nip4e")
-                            .label("Decoupling Encryption Key")
-                            .description(NIP4E)
-                            .checked(nip4e)
-                            .on_click(move |_, _window, cx| {
-                                AppSettings::update_nip4e(!nip4e, cx);
-                            }),
-                    ),
-            )
             .child(
                 GroupBox::new()
                     .id("media")
@@ -184,7 +218,7 @@ impl Render for Preferences {
                             .child(
                                 h_flex()
                                     .gap_1()
-                                    .child(Input::new(&self.file_input).text_xs().small())
+                                    .child(TextInput::new(&self.file_input).text_xs().small())
                                     .child(
                                         Button::new("update-file-server")
                                             .icon(IconName::Check)

crates/coop/src/main.rs

@@ -7,24 +7,20 @@ use gpui::{
     actions, point, px, size,
 };
 use gpui_platform::application;
-use nostr_sdk::prelude::SecretKey;
 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();
 
-    // Parse CLI arguments for --sec <nsec1>
-    let cli_key = parse_cli_key();
-    if let Err(ref e) = cli_key {
-        eprintln!("Failed to parse --sec argument: {e}");
-        std::process::exit(1);
-    }
-    let cli_key = cli_key.unwrap();
-
     // Run application
     application()
         .with_assets(Assets)
@@ -33,9 +29,6 @@ fn main() {
             // Load embedded fonts in assets/fonts
             load_embedded_fonts(cx);
 
-            // Set app identity
-            cx.set_app_identity(APP_ID, CLIENT_NAME);
-
             // Register the `quit` function
             cx.on_action(quit);
 
@@ -55,7 +48,7 @@ fn main() {
             }]);
 
             // Set up the window bounds
-            let bounds = Bounds::centered(None, size(px(960.0), px(720.0)), cx);
+            let bounds = Bounds::centered(None, size(px(920.0), px(700.0)), cx);
 
             // Set up the window options
             let opts = WindowOptions {
@@ -74,39 +67,47 @@ fn main() {
 
             // Open a window with default options
             cx.open_window(opts, |window, cx| {
-                // Initialize components
-                ui::init(cx);
+                // Bring the app to the foreground
+                cx.activate(true);
 
-                // Initialize theme registry
-                theme::init(cx);
+                cx.new(|cx| {
+                    // Initialize the tokio runtime
+                    gpui_tokio::init(cx);
 
-                // Initialize settings
-                settings::init(window, cx);
+                    // Initialize components
+                    ui::init(cx);
 
-                // Initialize the nostr client
-                state::init(window, cx, cli_key);
+                    // Initialize theme registry
+                    theme::init(cx);
 
-                // Initialize person registry
-                person::init(window, cx);
+                    // Initialize settings
+                    settings::init(window, cx);
 
-                // Initialize device signer
-                //
-                // NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
-                device::init(window, cx);
+                    // Initialize the nostr client
+                    state::init(window, cx);
 
-                // Initialize app registry
-                chat::init(window, cx);
+                    // Initialize person registry
+                    person::init(window, cx);
 
-                // Initialize auto update
-                auto_update::init(window, cx);
+                    // Initialize relay auth registry
+                    relay_auth::init(window, cx);
 
-                // Root view
-                cx.new(|cx| Root::new(workspace::init(window, cx).into(), window, 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(window, cx);
+
+                    // Root Entity
+                    Root::new(workspace::init(window, cx).into(), window, cx)
+                })
             })
             .expect("Failed to open window. Please restart the application.");
-
-            // Bring the app to the foreground
-            cx.activate(true);
         });
 }
 
@@ -134,25 +135,6 @@ fn load_embedded_fonts(cx: &App) {
         .unwrap();
 }
 
-fn parse_cli_key() -> Result<Option<SecretKey>, String> {
-    let args: Vec<String> = std::env::args().collect();
-    let mut i = 0;
-    while i < args.len() {
-        if args[i] == "--sec" {
-            if i + 1 < args.len() {
-                let nsec = &args[i + 1];
-                return SecretKey::parse(nsec)
-                    .map(Some)
-                    .map_err(|e| format!("Invalid nsec key '{nsec}': {e}"));
-            } else {
-                return Err("--sec requires a value (nsec1...)".to_string());
-            }
-        }
-        i += 1;
-    }
-    Ok(None)
-}
-
 fn quit(_ev: &Quit, cx: &mut App) {
     log::info!("Gracefully quitting the application . . .");
     cx.quit();

crates/coop/src/panels/backup.rs

@@ -1,15 +1,16 @@
+use std::time::Duration;
+
 use anyhow::Error;
 use gpui::{
     AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
     Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Task, Window, div,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
-use state::USER_KEYRING;
+use state::KEYRING;
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
-use ui::input::{Input, InputState};
+use ui::input::{InputState, TextInput};
 use ui::{IconName, Sizable, StyledExt, divider, v_flex};
 
 const MSG: &str = "Store your account keys in a safe location. \
@@ -39,8 +40,8 @@ pub struct BackupPanel {
 
 impl BackupPanel {
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let npub_input = cx.new(|cx| InputState::new(window, cx));
-        let nsec_input = cx.new(|cx| InputState::new(window, cx).masked(true));
+        let npub_input = cx.new(|cx| InputState::new(window, cx).disabled(true));
+        let nsec_input = cx.new(|cx| InputState::new(window, cx).disabled(true).masked(true));
 
         // Run at the end of current cycle
         cx.defer_in(window, |this, window, cx| {
@@ -58,7 +59,7 @@ impl BackupPanel {
     }
 
     fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let keyring = cx.read_credentials(USER_KEYRING);
+        let keyring = cx.read_credentials(KEYRING);
 
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             if let Some((_, secret)) = keyring.await? {
@@ -154,7 +155,12 @@ impl Render for BackupPanel {
                                     .text_color(cx.theme().text_muted)
                                     .child(SharedString::from("Public Key:")),
                             )
-                            .child(Input::new(&self.npub_input).small().disabled(true)),
+                            .child(
+                                TextInput::new(&self.npub_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
                     )
                     .child(
                         v_flex()
@@ -167,7 +173,12 @@ impl Render for BackupPanel {
                                     .text_color(cx.theme().text_muted)
                                     .child(SharedString::from("Secret Key:")),
                             )
-                            .child(Input::new(&self.nsec_input).small().disabled(true)),
+                            .child(
+                                TextInput::new(&self.nsec_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
                     )
                     .child(
                         Button::new("copy")

crates/coop/src/panels/contact_list.rs

@@ -1,13 +1,13 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
-use anyhow::Error;
+use anyhow::{Context as AnyhowContext, Error};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
@@ -16,8 +16,7 @@ use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
-use ui::input::{Input, InputEvent, InputState};
-use ui::scroll::ScrollableElement;
+use ui::input::{InputEvent, InputState, TextInput};
 use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<ContactListPanel> {
@@ -83,12 +82,11 @@ impl ContactListPanel {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        let Some(public_key) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<HashSet<PublicKey>, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let public_key = signer.get_public_key().await?;
             let contact_list = client.database().contacts_public_keys(public_key).await?;
+
             Ok(contact_list)
         });
 
@@ -158,7 +156,6 @@ impl ContactListPanel {
 
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         // Get contacts
         let contacts: Vec<Contact> = self
@@ -172,9 +169,8 @@ impl ContactListPanel {
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             // Construct contact list event builder
-            let event = ContactListBuilder::new(contacts)
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::contact_list(contacts);
+            let event = client.sign_event_builder(builder).await?;
 
             // Set contact list
             client.send_event(&event).to_nip65().await?;
@@ -221,7 +217,8 @@ impl ContactListPanel {
                     .px_2()
                     .justify_between()
                     .rounded(cx.theme().radius)
-                    .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                    .bg(cx.theme().secondary_background)
+                    .text_color(cx.theme().secondary_foreground)
                     .child(
                         h_flex()
                             .gap_2()
@@ -283,78 +280,79 @@ impl Focusable for ContactListPanel {
 
 impl Render for ContactListPanel {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex()
-            .p_3()
-            .gap_3()
-            .w_full()
-            .overflow_y_scrollbar()
-            .child(
-                v_flex()
-                    .gap_2()
-                    .flex_1()
-                    .w_full()
-                    .text_sm()
-                    .child(
-                        div()
-                            .text_xs()
-                            .font_semibold()
-                            .text_color(cx.theme().text_muted)
-                            .child("New contact:"),
-                    )
-                    .child(
-                        v_flex()
-                            .gap_1()
-                            .child(
-                                h_flex()
-                                    .gap_1()
-                                    .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
-                                    .child(
-                                        Button::new("add")
-                                            .icon(IconName::Plus)
-                                            .tooltip("Add contact")
-                                            .ghost()
-                                            .size(rems(2.))
-                                            .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().text_danger)
-                                        .child(error.clone()),
+        v_flex().p_3().gap_3().w_full().child(
+            v_flex()
+                .gap_2()
+                .flex_1()
+                .w_full()
+                .text_sm()
+                .child(
+                    div()
+                        .text_xs()
+                        .font_semibold()
+                        .text_color(cx.theme().text_muted)
+                        .child(SharedString::from("New contact:")),
+                )
+                .child(
+                    v_flex()
+                        .gap_1()
+                        .child(
+                            h_flex()
+                                .gap_1()
+                                .w_full()
+                                .child(
+                                    TextInput::new(&self.input)
+                                        .small()
+                                        .bordered(false)
+                                        .cleanable(),
                                 )
-                            }),
-                    )
-                    .map(|this| {
-                        if self.contacts.is_empty() {
-                            this.child(self.render_empty(window, cx))
-                        } else {
+                                .child(
+                                    Button::new("add")
+                                        .icon(IconName::Plus)
+                                        .tooltip("Add contact")
+                                        .ghost()
+                                        .size(rems(2.))
+                                        .on_click(cx.listener(move |this, _, window, cx| {
+                                            this.add(window, cx);
+                                        })),
+                                ),
+                        )
+                        .when_some(self.error.as_ref(), |this, error| {
                             this.child(
-                                v_flex()
-                                    .gap_1()
-                                    .flex_1()
-                                    .w_full()
-                                    .children(self.render_list_items(cx)),
+                                div()
+                                    .italic()
+                                    .text_xs()
+                                    .text_color(cx.theme().text_danger)
+                                    .child(error.clone()),
                             )
-                        }
-                    })
-                    .child(
-                        Button::new("submit")
-                            .icon(IconName::CheckCircle)
-                            .label("Update")
-                            .primary()
-                            .font_semibold()
-                            .loading(self.updating)
-                            .disabled(self.updating)
-                            .on_click(cx.listener(move |this, _ev, window, cx| {
-                                this.update(window, cx);
-                            })),
-                    ),
-            )
+                        }),
+                )
+                .map(|this| {
+                    if self.contacts.is_empty() {
+                        this.child(self.render_empty(window, cx))
+                    } else {
+                        this.child(
+                            v_flex()
+                                .gap_1()
+                                .flex_1()
+                                .w_full()
+                                .children(self.render_list_items(cx)),
+                        )
+                    }
+                })
+                .child(
+                    Button::new("submit")
+                        .icon(IconName::CheckCircle)
+                        .label("Update")
+                        .primary()
+                        .small()
+                        .font_semibold()
+                        .loading(self.updating)
+                        .disabled(self.updating)
+                        .on_click(cx.listener(move |this, _ev, window, cx| {
+                            this.update(window, cx);
+                        })),
+                ),
+        )
     }
 }

crates/coop/src/panels/greeter.rs

@@ -1,7 +1,6 @@
-use anyhow::Error;
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
-    IntoElement, ParentElement, Render, SharedString, Styled, Task, Window, div, svg,
+    IntoElement, ParentElement, Render, SharedString, Styled, Window, div, svg,
 };
 use state::NostrRegistry;
 use theme::ActiveTheme;
@@ -10,7 +9,7 @@ use ui::dock::{DockPlacement, Panel, PanelEvent};
 use ui::{Icon, IconName, Sizable, StyledExt, h_flex, v_flex};
 
 use crate::panels::profile;
-use crate::{Command, Workspace};
+use crate::workspace::Workspace;
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
     cx.new(|cx| GreeterPanel::new(window, cx))
@@ -19,7 +18,6 @@ pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
 pub struct GreeterPanel {
     name: SharedString,
     focus_handle: FocusHandle,
-    tasks: Vec<Task<Result<(), Error>>>,
 }
 
 impl GreeterPanel {
@@ -27,15 +25,15 @@ impl GreeterPanel {
         Self {
             name: "Onboarding".into(),
             focus_handle: cx.focus_handle(),
-            tasks: vec![],
         }
     }
 
     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) = nostr.read(cx).current_user() {
-            self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+        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),
@@ -45,9 +43,8 @@ impl GreeterPanel {
                     );
                 })
                 .ok();
-
-                Ok(())
-            }));
+            })
+            .detach();
         }
     }
 }
@@ -146,20 +143,17 @@ impl Render for GreeterPanel {
                                             .ghost()
                                             .small()
                                             .justify_start()
-                                            .on_click(cx.listener(move |this, _, window, cx| {
+                                            .on_click(cx.listener(move |this, _ev, window, cx| {
                                                 this.add_profile_panel(window, cx)
                                             })),
                                     )
                                     .child(
-                                        Button::new("theme")
-                                            .icon(Icon::new(IconName::Moon))
-                                            .label("Change theme")
+                                        Button::new("invite")
+                                            .icon(Icon::new(IconName::Invite))
+                                            .label("Invite friends")
                                             .ghost()
                                             .small()
-                                            .justify_start()
-                                            .on_click(cx.listener(move |_, _, _, cx| {
-                                                cx.dispatch_action(&Command::ToggleTheme);
-                                            })),
+                                            .justify_start(),
                                     ),
                             ),
                     ),

crates/coop/src/panels/messaging_relays.rs

@@ -1,20 +1,20 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
-use anyhow::{Error, anyhow};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
 use state::NostrRegistry;
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
-use ui::input::{Input, InputEvent, InputState};
+use ui::input::{InputEvent, InputState, TextInput};
 use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, divider, h_flex, v_flex};
 
 const MSG: &str = "Messaging Relays are relays that hosted all your messages. \
@@ -83,18 +83,17 @@ impl MessagingRelayPanel {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        let Some(public_key) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<Vec<RelayUrl>, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let public_key = signer.get_public_key().await?;
+
             let filter = Filter::new()
                 .kind(Kind::InboxRelays)
                 .author(public_key)
                 .limit(1);
 
             if let Some(event) = client.database().query(filter).await?.first_owned() {
-                Ok(nip17::extract_relay_list(&event).collect())
+                Ok(nip17::extract_owned_relay_list(event).collect())
             } else {
                 Err(anyhow!("Not found."))
             }
@@ -171,13 +170,12 @@ impl MessagingRelayPanel {
 
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         // Construct event tags
         let tags: Vec<Tag> = self
             .relays
             .iter()
-            .map(|relay| Nip17Tag::Relay(relay.to_owned()).to_tag())
+            .map(|relay| Tag::relay(relay.clone()))
             .collect();
 
         // Set updating state
@@ -185,10 +183,8 @@ impl MessagingRelayPanel {
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             // Construct nip17 event builder
-            let event = EventBuilder::new(Kind::InboxRelays, "")
-                .tags(tags)
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::new(Kind::InboxRelays, "").tags(tags);
+            let event = client.sign_event_builder(builder).await?;
 
             // Set messaging relays
             client.send_event(&event).to_nip65().await?;
@@ -320,7 +316,12 @@ impl Render for MessagingRelayPanel {
                                 h_flex()
                                     .gap_1()
                                     .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
+                                    .child(
+                                        TextInput::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(),
+                                    )
                                     .child(
                                         Button::new("add")
                                             .icon(IconName::Plus)
@@ -360,6 +361,7 @@ impl Render for MessagingRelayPanel {
                             .icon(IconName::CheckCircle)
                             .label("Update")
                             .primary()
+                            .small()
                             .font_semibold()
                             .loading(self.updating)
                             .disabled(self.updating)

crates/coop/src/panels/mod.rs

@@ -4,3 +4,4 @@ pub mod greeter;
 pub mod messaging_relays;
 pub mod profile;
 pub mod relay_list;
+pub mod trash;

crates/coop/src/panels/profile.rs

@@ -1,4 +1,5 @@
 use std::str::FromStr;
+use std::time::Duration;
 
 use anyhow::{Context as AnyhowContext, Error};
 use gpui::{
@@ -6,7 +7,6 @@ use gpui::{
     Focusable, IntoElement, ParentElement, PathPromptOptions, Render, SharedString, Styled, Task,
     Window, div,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry, shorten_pubkey};
 use settings::AppSettings;
@@ -15,7 +15,7 @@ use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
-use ui::input::{Input, InputState};
+use ui::input::{InputState, TextInput};
 use ui::notification::Notification;
 use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
@@ -65,7 +65,7 @@ impl ProfilePanel {
         // Use multi-line input for bio
         let bio_input = cx.new(|cx| {
             InputState::new(window, cx)
-                .multi_line(true)
+                .multi_line()
                 .auto_grow(3, 8)
                 .placeholder("A short introduce about you.")
         });
@@ -132,7 +132,7 @@ impl ProfilePanel {
         cx.notify();
 
         if status {
-            self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            cx.spawn_in(window, async move |this, cx| {
                 cx.background_executor().timer(Duration::from_secs(2)).await;
 
                 // Reset the copied state after a delay
@@ -143,9 +143,8 @@ impl ProfilePanel {
                     .ok();
                 })
                 .ok();
-
-                Ok(())
-            }));
+            })
+            .detach();
         }
     }
 
@@ -208,12 +207,12 @@ impl ProfilePanel {
     fn publish(&self, metadata: &Metadata, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
         let metadata = metadata.clone();
 
         cx.background_spawn(async move {
             // Build and sign the metadata event
-            let event = metadata.finalize_async(&signer).await?;
+            let builder = EventBuilder::metadata(&metadata);
+            let event = client.sign_event_builder(builder).await?;
 
             // Send event to user's relays
             client.send_event(&event).await?;
@@ -353,7 +352,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("What should people call you?")),
                     )
-                    .child(Input::new(&self.name_input).small()),
+                    .child(TextInput::new(&self.name_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -364,7 +363,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("A short introduction about you:")),
                     )
-                    .child(Input::new(&self.bio_input).small()),
+                    .child(TextInput::new(&self.bio_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -375,7 +374,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("Website:")),
                     )
-                    .child(Input::new(&self.website_input).small()),
+                    .child(TextInput::new(&self.website_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -419,6 +418,7 @@ impl Render for ProfilePanel {
                     .icon(IconName::CheckCircle)
                     .label("Update")
                     .primary()
+                    .small()
                     .font_semibold()
                     .loading(self.updating)
                     .disabled(self.updating)

crates/coop/src/panels/relay_list.rs

@@ -1,13 +1,13 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
-use anyhow::{Error, anyhow};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     Action, AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, px, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use serde::Deserialize;
 use smallvec::{SmallVec, smallvec};
@@ -15,7 +15,7 @@ use state::NostrRegistry;
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
-use ui::input::{Input, InputEvent, InputState};
+use ui::input::{InputEvent, InputState, TextInput};
 use ui::menu::DropdownMenu;
 use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, divider, h_flex, v_flex};
 
@@ -100,19 +100,18 @@ impl RelayListPanel {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        let Some(public_key) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<Vec<(RelayUrl, Option<RelayMetadata>)>, Error>> = cx
             .background_spawn(async move {
+                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_relay_list(&event).collect())
+                    Ok(nip65::extract_owned_relay_list(event).collect())
                 } else {
                     Err(anyhow!("Not found."))
                 }
@@ -207,7 +206,6 @@ impl RelayListPanel {
 
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         // Get all relays
         let relays = self.relays.clone();
@@ -216,9 +214,8 @@ impl RelayListPanel {
         self.set_updating(true, cx);
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let event = nip65::RelayList::new(relays)
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::relay_list(relays);
+            let event = client.sign_event_builder(builder).await?;
 
             // Set relay list for current user
             client.send_event(&event).await?;
@@ -371,7 +368,12 @@ impl Render for RelayListPanel {
                                 h_flex()
                                     .gap_1()
                                     .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
+                                    .child(
+                                        TextInput::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(),
+                                    )
                                     .child(
                                         Button::new("metadata")
                                             .map(|this| {
@@ -429,6 +431,7 @@ impl Render for RelayListPanel {
                             .icon(IconName::CheckCircle)
                             .label("Update")
                             .primary()
+                            .small()
                             .font_semibold()
                             .loading(self.updating)
                             .disabled(self.updating)

crates/coop/src/panels/trash.rs

@@ -0,0 +1,152 @@
+use chat::ChatRegistry;
+use gpui::{
+    AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, InteractiveElement, IntoElement, ListAlignment, ListState, ParentElement, Render,
+    SharedString, Styled, Window, div, list, px, relative,
+};
+use theme::ActiveTheme;
+use ui::button::{Button, ButtonVariants};
+use ui::dock::{Panel, PanelEvent};
+use ui::scroll::Scrollbar;
+use ui::{Icon, IconName, Sizable, h_flex, v_flex};
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<TrashPanel> {
+    cx.new(|cx| TrashPanel::new(window, cx))
+}
+
+pub struct TrashPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// List state for messages
+    list_state: ListState,
+}
+
+impl TrashPanel {
+    fn new(_window: &mut Window, cx: &mut App) -> Self {
+        let chat = ChatRegistry::global(cx);
+        let count = chat.read(cx).count_trash_messages(cx);
+        let list_state = ListState::new(count, ListAlignment::Bottom, px(1024.));
+
+        Self {
+            name: "Trash".into(),
+            focus_handle: cx.focus_handle(),
+            list_state,
+        }
+    }
+
+    fn copy(&self, ix: usize, cx: &App) {
+        let chat = ChatRegistry::global(cx);
+        let trashes = chat.read(cx).trashes();
+
+        if let Some(message) = trashes.read(cx).iter().nth(ix) {
+            let item = ClipboardItem::new_string(message.raw_event.to_string());
+            cx.write_to_clipboard(item);
+        }
+    }
+
+    fn render_list_item(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let chat = ChatRegistry::global(cx);
+        let trashes = chat.read(cx).trashes();
+
+        if let Some(message) = trashes.read(cx).iter().nth(ix) {
+            v_flex()
+                .id(ix)
+                .p_2()
+                .w_full()
+                .child(
+                    v_flex()
+                        .p_2()
+                        .w_full()
+                        .gap_1()
+                        .rounded(cx.theme().radius_lg)
+                        .bg(cx.theme().surface_background)
+                        .text_sm()
+                        .child(
+                            div()
+                                .text_color(cx.theme().text_danger)
+                                .child(message.reason.clone()),
+                        )
+                        .child(
+                            h_flex()
+                                .h_10()
+                                .w_full()
+                                .px_2()
+                                .justify_between()
+                                .bg(cx.theme().elevated_surface_background)
+                                .border_1()
+                                .border_color(cx.theme().border)
+                                .rounded(cx.theme().radius)
+                                .child(
+                                    div()
+                                        .truncate()
+                                        .text_ellipsis()
+                                        .text_xs()
+                                        .line_height(relative(1.))
+                                        .child(message.raw_event.clone()),
+                                )
+                                .child(
+                                    Button::new(format!("copy-{ix}"))
+                                        .icon(IconName::Copy)
+                                        .ghost()
+                                        .small()
+                                        .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                            this.copy(ix, cx);
+                                        })),
+                                ),
+                        ),
+                )
+                .into_any_element()
+        } else {
+            div().id(ix).into_any_element()
+        }
+    }
+}
+
+impl Panel for TrashPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        h_flex()
+            .gap_1()
+            .text_sm()
+            .child(Icon::new(IconName::Warning).small())
+            .child("Errors")
+            .into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for TrashPanel {}
+
+impl Focusable for TrashPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for TrashPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex().size_full().relative().child(
+            v_flex()
+                .flex_1()
+                .relative()
+                .child(
+                    list(
+                        self.list_state.clone(),
+                        cx.processor(move |this, ix, window, cx| {
+                            this.render_list_item(ix, window, cx)
+                        }),
+                    )
+                    .size_full(),
+                )
+                .child(Scrollbar::vertical(&self.list_state)),
+        )
+    }
+}

crates/coop/src/sidebar/entry.rs

@@ -164,7 +164,9 @@ impl RenderOnce for RoomEntry {
                                 )
                                 .on_cancel(move |_event, window, cx| {
                                     window.dispatch_action(Box::new(ClosePanel), cx);
-                                    true
+                                    // Prevent closing the modal on click
+                                    // modal will be automatically closed after closing panel
+                                    false
                                 })
                         });
                     }

crates/coop/src/sidebar/mod.rs

@@ -1,26 +1,26 @@
 use std::collections::HashSet;
 use std::ops::Range;
+use std::time::Duration;
 
-use anyhow::Error;
+use anyhow::{Context as AnyhowContext, Error};
 use chat::{ChatEvent, ChatRegistry, Room, RoomKind};
-use common::{DebouncedDelay, TimestampExt, coop_cache};
+use common::{DebouncedDelay, TimestampExt};
 use entry::RoomEntry;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, IntoElement,
-    ParentElement, Render, SharedString, Styled, Subscription, Task, UniformListScrollHandle,
-    Window, div, uniform_list,
+    ParentElement, Render, RetainAllImageCache, SharedString, Styled, Subscription, Task,
+    UniformListScrollHandle, Window, div, uniform_list,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
-use state::{FIND_DELAY, IMAGE_CACHE_SIZE, NostrRegistry};
-use theme::{ActiveTheme, SIDEBAR_WIDTH};
+use state::{FIND_DELAY, NostrRegistry};
+use theme::{ActiveTheme, SIDEBAR_WIDTH, TABBAR_HEIGHT};
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
 use ui::indicator::Indicator;
-use ui::input::{Input, InputEvent, InputState};
+use ui::input::{InputEvent, InputState, TextInput};
 use ui::notification::Notification;
 use ui::scroll::Scrollbar;
 use ui::{Icon, IconName, Selectable, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
@@ -29,11 +29,19 @@ mod entry;
 
 const INPUT_PLACEHOLDER: &str = "Find or start a conversation";
 
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<Sidebar> {
+    cx.new(|cx| Sidebar::new(window, cx))
+}
+
 /// Sidebar.
 pub struct Sidebar {
+    name: SharedString,
     focus_handle: FocusHandle,
     scroll_handle: UniformListScrollHandle,
 
+    /// Image cache
+    image_cache: Entity<RetainAllImageCache>,
+
     /// Find input state
     find_input: Entity<InputState>,
 
@@ -75,7 +83,7 @@ pub struct Sidebar {
 }
 
 impl Sidebar {
-    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let chat = ChatRegistry::global(cx);
         let filter = cx.new(|_| RoomKind::Ongoing);
         let contact_list = cx.new(|_| None);
@@ -130,8 +138,10 @@ impl Sidebar {
         );
 
         Self {
+            name: "Sidebar".into(),
             focus_handle: cx.focus_handle(),
             scroll_handle: UniformListScrollHandle::new(),
+            image_cache: RetainAllImageCache::new(cx),
             find_input,
             find_debouncer: DebouncedDelay::new(),
             find_results,
@@ -153,12 +163,11 @@ impl Sidebar {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        let Some(public_key) = nostr.read(cx).current_user() else {
-            return;
-        };
-
         let task: Task<Result<HashSet<PublicKey>, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let public_key = signer.get_public_key().await?;
             let contacts = client.database().contacts_public_keys(public_key).await?;
+
             Ok(contacts)
         });
 
@@ -247,6 +256,7 @@ impl Sidebar {
     fn set_finding(&mut self, status: bool, _window: &mut Window, cx: &mut Context<Self>) {
         // Disable the input to prevent duplicate requests
         self.find_input.update(cx, |this, cx| {
+            this.set_disabled(status, cx);
             this.set_loading(status, cx);
         });
         // Set the search status
@@ -314,14 +324,14 @@ impl Sidebar {
         let async_chat = chat.downgrade();
 
         let nostr = NostrRegistry::global(cx);
-        let Some(public_key) = nostr.read(cx).current_user() else {
-            return;
-        };
+        let signer = nostr.read(cx).signer();
 
         // Get all selected public keys
         let receivers = self.get_selected(cx);
 
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            let public_key = signer.get_public_key().await?;
+
             // Create a new room and emit it
             async_chat.update_in(cx, |this, _window, cx| {
                 let room = cx.new(|_| {
@@ -329,7 +339,7 @@ impl Sidebar {
                         .organize(&public_key)
                         .kind(RoomKind::Ongoing)
                 });
-                this.emit_room(&room, _window, cx);
+                this.emit_room(&room, cx);
             })?;
 
             // Reset the find panel
@@ -354,14 +364,6 @@ impl Sidebar {
             cx.notify();
         });
         self.new_requests = false;
-
-        // Reset search state when switching to inbox/requests
-        self.reset(window, cx);
-
-        // Clear the find input value
-        self.find_input.update(cx, |this, cx| {
-            this.set_value("", window, cx);
-        });
     }
 
     fn render_list_items(
@@ -381,9 +383,9 @@ impl Sidebar {
                 let room = item.read(cx);
                 let room_clone = item.clone();
                 let public_key = room.display_member(cx).public_key();
-                let handler = cx.listener(move |_this, _ev, window, cx| {
+                let handler = cx.listener(move |_this, _ev, _window, cx| {
                     ChatRegistry::global(cx).update(cx, |s, cx| {
-                        s.emit_room(&room_clone, window, cx);
+                        s.emit_room(&room_clone, cx);
                     });
                 });
 
@@ -464,7 +466,7 @@ impl Sidebar {
                 });
 
                 RoomEntry::new(range.start + ix)
-                    .name(profile.name().trim())
+                    .name(profile.name())
                     .avatar(profile.avatar())
                     .on_click(handler)
                     .selected(selected)
@@ -476,7 +478,7 @@ impl Sidebar {
 
 impl Panel for Sidebar {
     fn panel_id(&self) -> SharedString {
-        "Sidebar".into()
+        self.name.clone()
     }
 }
 
@@ -490,11 +492,8 @@ impl Focusable for Sidebar {
 
 impl Render for Sidebar {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let nostr = NostrRegistry::global(cx);
         let chat = ChatRegistry::global(cx);
-        let logged_in = nostr.read(cx).current_user().is_some();
-        let loading = chat.read(cx).loading() && logged_in;
-
+        let loading = chat.read(cx).loading();
         let total_rooms = chat.read(cx).count(self.filter.read(cx), cx);
 
         // Whether the find panel should be shown
@@ -508,25 +507,31 @@ impl Render for Sidebar {
         };
 
         v_flex()
-            .image_cache(coop_cache("sidebar", IMAGE_CACHE_SIZE))
+            .image_cache(self.image_cache.clone())
             .size_full()
             .gap_2()
             .child(
-                h_flex().px_2().py_1().child(
-                    Input::new(&self.find_input)
-                        .small()
-                        .text_xs()
-                        .disabled(loading)
-                        .when(!self.find_input.read(cx).loading, |this| {
-                            this.suffix(
-                                Button::new("find-icon")
-                                    .icon(IconName::Search)
-                                    .tooltip("Press Enter to search")
-                                    .transparent()
-                                    .small(),
-                            )
-                        }),
-                ),
+                h_flex()
+                    .h(TABBAR_HEIGHT)
+                    .border_b_1()
+                    .border_color(cx.theme().border)
+                    .bg(cx.theme().tab_background)
+                    .child(
+                        TextInput::new(&self.find_input)
+                            .appearance(false)
+                            .bordered(false)
+                            .small()
+                            .text_xs()
+                            .when(!self.find_input.read(cx).loading, |this| {
+                                this.suffix(
+                                    Button::new("find-icon")
+                                        .icon(IconName::Search)
+                                        .tooltip("Press Enter to search")
+                                        .transparent()
+                                        .small(),
+                                )
+                            }),
+                    ),
             )
             .child(
                 h_flex()
@@ -538,6 +543,7 @@ impl Render for Sidebar {
                             Button::new("search-results")
                                 .icon(IconName::Search)
                                 .tooltip("All search results")
+                                .small()
                                 .ghost_alt()
                                 .font_semibold()
                                 .flex_1()
@@ -553,8 +559,9 @@ impl Render for Sidebar {
                                     this.icon(IconName::Inbox)
                                 }
                             })
-                            .when(!show_find_panel, |this| this.label("Inbox").small())
+                            .when(!show_find_panel, |this| this.label("Inbox"))
                             .tooltip("All ongoing conversations")
+                            .small()
                             .ghost_alt()
                             .font_semibold()
                             .flex_1()
@@ -574,8 +581,9 @@ impl Render for Sidebar {
                                     this.icon(IconName::Fistbump)
                                 }
                             })
-                            .when(!show_find_panel, |this| this.label("Requests").small())
+                            .when(!show_find_panel, |this| this.label("Requests"))
                             .tooltip("Incoming new conversations")
+                            .small()
                             .ghost_alt()
                             .font_semibold()
                             .flex_1()
@@ -604,13 +612,17 @@ impl Render for Sidebar {
                             .items_center()
                             .justify_center()
                             .text_center()
-                            .child(div().text_sm().font_semibold().child("No conversations"))
                             .child(
                                 div()
-                                    .text_xs()
-                                    .text_color(cx.theme().text_muted)
-                                    .child("Start a conversation with someone to get started."),
-                            ),
+                                    .text_sm()
+                                    .font_semibold()
+                                    .child(SharedString::from("No conversations")),
+                            )
+                            .child(div().text_xs().text_color(cx.theme().text_muted).child(
+                                SharedString::from(
+                                    "Start a conversation with someone to get started.",
+                                ),
+                            )),
                     ),
                 )
             })
@@ -635,7 +647,7 @@ impl Render for Sidebar {
                                                 .font_semibold()
                                                 .text_color(cx.theme().text_muted)
                                                 .child(Icon::new(IconName::ChevronDown))
-                                                .child("Results"),
+                                                .child(SharedString::from("Results")),
                                         )
                                         .child(
                                             uniform_list(
@@ -662,7 +674,7 @@ impl Render for Sidebar {
                                                 .font_semibold()
                                                 .text_color(cx.theme().text_muted)
                                                 .child(Icon::new(IconName::ChevronDown).small())
-                                                .child("Contacts"),
+                                                .child(SharedString::from("Suggestions")),
                                         )
                                         .child(
                                             uniform_list(
@@ -699,17 +711,17 @@ impl Render for Sidebar {
                 this.child(
                     div()
                         .absolute()
-                        .bottom_2()
+                        .bottom_0()
                         .left_0()
                         .h_9()
                         .w_full()
-                        .px_4()
+                        .px_2()
                         .child(
                             Button::new("create")
                                 .label(button_label)
                                 .primary()
-                                .rounded()
-                                .shadow_md()
+                                .small()
+                                .shadow_lg()
                                 .on_click(cx.listener(move |this, _ev, window, cx| {
                                     this.create_room(window, cx);
                                 })),
@@ -732,13 +744,15 @@ impl Render for Sidebar {
                                 .h_9()
                                 .justify_center()
                                 .bg(cx.theme().background.opacity(0.85))
-                                .when(cx.theme().shadow, |this| this.shadow_md())
+                                .border_color(cx.theme().border_disabled)
+                                .border_1()
+                                .when(cx.theme().shadow, |this| this.shadow_xs())
                                 .rounded_full()
                                 .text_xs()
                                 .font_semibold()
                                 .text_color(cx.theme().text_muted)
                                 .child(Indicator::new().small().color(cx.theme().icon_accent))
-                                .child("Getting messages..."),
+                                .child(SharedString::from("Getting messages...")),
                         ),
                 )
             })

crates/coop/src/workspace.rs

@@ -1,56 +1,60 @@
 use std::sync::Arc;
 
 use ::settings::AppSettings;
-use anyhow::Error;
-use auto_update::AutoUpdater;
 use chat::{ChatEvent, ChatRegistry};
-use common::{CoopImageCache, download_dir};
+use common::download_dir;
 use device::{DeviceEvent, DeviceRegistry};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     Action, App, AppContext, Axis, Context, Entity, InteractiveElement, IntoElement, ParentElement,
-    Render, SharedString, Styled, Subscription, Task, Window, div, image_cache, px,
+    Render, SharedString, StatefulInteractiveElement, Styled, Subscription, Window, div, px,
+    relative,
 };
 use nostr_sdk::prelude::*;
 use person::{PersonRegistry, shorten_pubkey};
 use serde::Deserialize;
 use smallvec::{SmallVec, smallvec};
-use state::{IMAGE_CACHE_SIZE, NostrRegistry, StateEvent};
+use state::{NostrRegistry, StateEvent};
 use theme::{ActiveTheme, SIDEBAR_WIDTH, Theme, ThemeRegistry};
+use title_bar::TitleBar;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{ClosePanel, DockArea, DockItem, DockPlacement, PanelView};
 use ui::menu::{DropdownMenu, PopupMenuItem};
 use ui::notification::{Notification, NotificationKind};
-use ui::{Icon, IconName, Root, Sizable, TitleBar, WindowExtension, h_flex, v_flex};
+use ui::{Icon, IconName, Root, Sizable, WindowExtension, h_flex, v_flex};
 
-use crate::dialogs::import::ImportIdentity;
 use crate::dialogs::restore::RestoreEncryption;
-use crate::dialogs::settings;
-use crate::panels::{backup, contact_list, greeter, messaging_relays, profile, relay_list};
-use crate::sidebar::Sidebar;
+use crate::dialogs::{accounts, settings};
+use crate::panels::{backup, contact_list, greeter, messaging_relays, profile, relay_list, trash};
+use crate::sidebar;
 
-mod dialogs;
-mod panels;
-mod sidebar;
+const PREPARE_MSG: &str = "Coop is preparing a new identity for you. This may take a moment...";
+const ENC_MSG: &str = "Encryption Key is a special key that used to encrypt and decrypt your messages. \
+                       Your identity is completely decoupled from all encryption processes to protect your privacy.";
+const ENC_WARN: &str = "By resetting your encryption key, you will lose access to \
+                        all your encrypted messages before. This action cannot be undone.";
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<Workspace> {
     cx.new(|cx| Workspace::new(window, cx))
 }
 
 struct DeviceNotifcation;
-struct MsgRelayNotification;
+struct SignerNotifcation;
+struct RelayNotifcation;
 
 #[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 #[action(namespace = workspace, no_json)]
 enum Command {
     ToggleTheme,
-    Update,
+    ToggleAccount,
+
     RefreshMessagingRelays,
     BackupEncryption,
     ImportEncryption,
     RefreshEncryption,
     ResetEncryption,
+
     ShowRelayList,
     ShowMessaging,
     ShowProfile,
@@ -60,18 +64,14 @@ enum Command {
 }
 
 pub struct Workspace {
-    sidebar: Entity<Sidebar>,
+    /// App's Title Bar
+    titlebar: Entity<TitleBar>,
+
     /// App's Dock Area
     dock: Entity<DockArea>,
 
-    /// App's Image Cache
-    image_cache: Entity<CoopImageCache>,
-
-    /// Async tasks
-    tasks: Vec<Task<Result<(), Error>>>,
-
     /// Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 6]>,
+    _subscriptions: SmallVec<[Subscription; 5]>,
 }
 
 impl Workspace {
@@ -80,9 +80,8 @@ impl Workspace {
         let device = DeviceRegistry::global(cx);
         let nostr = NostrRegistry::global(cx);
 
-        let sidebar = cx.new(|cx| Sidebar::new(window, cx));
+        let titlebar = cx.new(|_| TitleBar::new());
         let dock = cx.new(|cx| DockArea::new(window, cx));
-        let image_cache = CoopImageCache::new(IMAGE_CACHE_SIZE, cx);
 
         let mut subscriptions = smallvec![];
 
@@ -94,14 +93,42 @@ impl Workspace {
         );
 
         subscriptions.push(
-            // Subscribe to the nostr events
+            // Subscribe to the signer events
             cx.subscribe_in(&nostr, window, move |this, _state, event, window, cx| {
                 match event {
-                    StateEvent::SignerChanged => {
-                        window.close_all_modals(cx);
+                    StateEvent::Creating => {
+                        let note = Notification::new()
+                            .id::<SignerNotifcation>()
+                            .title("Preparing a new identity")
+                            .message(PREPARE_MSG)
+                            .autohide(false)
+                            .with_kind(NotificationKind::Info);
+
+                        window.push_notification(note, cx);
                     }
-                    StateEvent::NoSigner => {
-                        this.import_identity(window, cx);
+                    StateEvent::Connecting => {
+                        let note = Notification::new()
+                            .id::<RelayNotifcation>()
+                            .message("Connecting to the bootstrap relays...")
+                            .with_kind(NotificationKind::Info);
+
+                        window.push_notification(note, cx);
+                    }
+                    StateEvent::Connected => {
+                        let note = Notification::new()
+                            .id::<RelayNotifcation>()
+                            .message("Connected to the bootstrap relays")
+                            .with_kind(NotificationKind::Success);
+
+                        window.push_notification(note, cx);
+                    }
+                    StateEvent::SignerSet => {
+                        this.set_center_layout(window, cx);
+                        // Clear the signer notification
+                        window.clear_notification::<SignerNotifcation>(cx);
+                    }
+                    StateEvent::Show => {
+                        this.account_selector(window, cx);
                     }
                     _ => {}
                 };
@@ -114,7 +141,7 @@ impl Workspace {
                 match event {
                     DeviceEvent::Requesting => {
                         const MSG: &str =
-                            "Please open other client and approve the request for encryption key.";
+                            "Coop has sent a request for an encryption key. Please open the other client then approve the request.";
 
                         let note = Notification::new()
                             .id::<DeviceNotifcation>()
@@ -125,25 +152,12 @@ impl Workspace {
 
                         window.push_notification(note, cx);
                     }
-                    DeviceEvent::NotSet => {
-                        const MSG: &str =
-                            "User're not setup encryption key yet. Do you want to create one?";
-
+                    DeviceEvent::Creating => {
                         let note = Notification::new()
                             .id::<DeviceNotifcation>()
-                            .message(MSG)
-                            .with_kind(NotificationKind::Info)
-                            .action(|_this, _window, _cx| {
-                                Button::new("retry").label("Retry").on_click(
-                                    move |_this, window, cx| {
-                                        let device = DeviceRegistry::global(cx);
-                                        device.update(cx, |this, cx| {
-                                            this.set_announcement(Keys::generate(), cx);
-                                        });
-                                        window.clear_notification::<DeviceNotifcation>(cx);
-                                    },
-                                )
-                            });
+                            .autohide(false)
+                            .message("Creating encryption key")
+                            .with_kind(NotificationKind::Info);
 
                         window.push_notification(note, cx);
                     }
@@ -166,27 +180,6 @@ impl Workspace {
             // Observe all events emitted by the chat registry
             cx.subscribe_in(&chat, window, move |this, chat, ev, window, cx| {
                 match ev {
-                    ChatEvent::InboxRelayNotFound => {
-                        const MSG: &str = "Messaging Relays not found. Cannot receive messages.";
-
-                        window.push_notification(
-                            Notification::warning(MSG)
-                                .id::<MsgRelayNotification>()
-                                .autohide(false)
-                                .action(|_this, _window, _cx| {
-                                    Button::new("retry").label("Retry").on_click(
-                                        move |_this, window, cx| {
-                                            let chat = ChatRegistry::global(cx);
-                                            chat.update(cx, |this, cx| {
-                                                this.get_metadata(cx);
-                                            });
-                                            window.clear_notification::<MsgRelayNotification>(cx);
-                                        },
-                                    )
-                                }),
-                            cx,
-                        );
-                    }
                     ChatEvent::OpenRoom(id) => {
                         if let Some(room) = chat.read(cx).room(id, cx) {
                             this.dock.update(cx, |this, cx| {
@@ -219,22 +212,25 @@ impl Workspace {
             }),
         );
 
-        cx.defer_in(window, |this, window, cx| {
-            let dock = this.dock.downgrade();
-            let greeter = Arc::new(greeter::init(window, cx));
-            let tabs = DockItem::tabs(vec![greeter], None, &dock, window, cx);
-            let center = DockItem::split(Axis::Vertical, vec![tabs], &dock, window, cx);
+        subscriptions.push(
+            // Observe the chat registry
+            cx.observe(&chat, move |this, chat, cx| {
+                let ids = this.panel_ids(cx);
 
-            this.dock.update(cx, |this, cx| {
-                this.set_center(center, window, cx);
-            });
+                chat.update(cx, |this, cx| {
+                    this.refresh_rooms(&ids, cx);
+                });
+            }),
+        );
+
+        // Set the layout at the end of cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.set_layout(window, cx);
         });
 
         Self {
-            sidebar,
+            titlebar,
             dock,
-            image_cache,
-            tasks: vec![],
             _subscriptions: subscriptions,
         }
     }
@@ -255,6 +251,40 @@ impl Workspace {
         }
     }
 
+    /// Get all panel ids
+    fn panel_ids(&self, cx: &App) -> Vec<u64> {
+        self.dock
+            .read(cx)
+            .items
+            .panel_ids(cx)
+            .into_iter()
+            .filter_map(|panel| panel.parse::<u64>().ok())
+            .collect()
+    }
+
+    /// Set the dock layout
+    fn set_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let left = DockItem::panel(Arc::new(sidebar::init(window, cx)));
+
+        // Update the dock layout with sidebar on the left
+        self.dock.update(cx, |this, cx| {
+            this.set_left_dock(left, Some(SIDEBAR_WIDTH), true, window, cx);
+        });
+    }
+
+    /// Set the center dock layout
+    fn set_center_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let dock = self.dock.downgrade();
+        let greeter = Arc::new(greeter::init(window, cx));
+        let tabs = DockItem::tabs(vec![greeter], None, &dock, window, cx);
+        let center = DockItem::split(Axis::Vertical, vec![tabs], &dock, window, cx);
+
+        // Update the layout with center dock
+        self.dock.update(cx, |this, cx| {
+            this.set_center(center, window, cx);
+        });
+    }
+
     /// Handle command events
     fn on_command(&mut self, command: &Command, window: &mut Window, cx: &mut Context<Self>) {
         match command {
@@ -271,12 +301,13 @@ impl Workspace {
             }
             Command::ShowProfile => {
                 let nostr = NostrRegistry::global(cx);
+                let signer = nostr.read(cx).signer();
 
-                if let Some(public_key) = nostr.read(cx).current_user() {
+                if let Some(public_key) = signer.public_key() {
                     self.dock.update(cx, |this, cx| {
                         this.add_panel(
                             Arc::new(profile::init(public_key, window, cx)),
-                            DockPlacement::Left,
+                            DockPlacement::Right,
                             window,
                             cx,
                         );
@@ -287,7 +318,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(contact_list::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -297,7 +328,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(backup::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -307,7 +338,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(messaging_relays::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -317,7 +348,7 @@ impl Workspace {
                 let chat = ChatRegistry::global(cx);
                 // Trigger a refresh of the chat registry
                 chat.update(cx, |this, cx| {
-                    this.reload(cx);
+                    this.refresh(window, cx);
                 });
             }
             Command::ShowRelayList => {
@@ -342,11 +373,14 @@ impl Workspace {
             Command::ToggleTheme => {
                 self.theme_selector(window, cx);
             }
+            Command::ToggleAccount => {
+                self.account_selector(window, cx);
+            }
             Command::BackupEncryption => {
                 let device = DeviceRegistry::global(cx).downgrade();
                 let save_dialog = cx.prompt_for_new_path(download_dir(), Some("encryption.txt"));
 
-                self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+                cx.spawn_in(window, async move |_this, cx| {
                     // Get the output path from the save dialog
                     let output_path = match save_dialog.await {
                         Ok(Ok(Some(path))) => path,
@@ -373,30 +407,17 @@ impl Workspace {
                         cx.open_with_system(output_path.as_path());
                     })?;
 
-                    Ok(())
-                }));
+                    Ok::<_, anyhow::Error>(())
+                })
+                .detach();
             }
             Command::ImportEncryption => {
                 self.import_encryption(window, cx);
             }
-            Command::Update => {
-                let auto_updater = AutoUpdater::global(cx);
-                auto_updater.update(cx, |this, cx| {
-                    this.updater.update(cx, |updater, cx| {
-                        updater.check(cx);
-                    });
-                });
-            }
         }
     }
 
     fn confirm_reset_encryption(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        const ENC_MSG: &str = "Encryption Key is a special key that used to encrypt and decrypt your messages. \
-                               Your identity is completely decoupled from all encryption processes to protect your privacy.";
-
-        const ENC_WARN: &str = "By resetting your encryption key, you will lose access to \
-                                all your encrypted messages before. This action cannot be undone.";
-
         let device = DeviceRegistry::global(cx);
         let ent = device.downgrade();
 
@@ -431,23 +452,24 @@ impl Workspace {
 
     fn import_encryption(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let restore = cx.new(|cx| RestoreEncryption::new(window, cx));
+
         window.open_modal(cx, move |this, _window, _cx| {
-            this.width(px(420.))
+            this.width(px(520.))
                 .title("Restore Encryption")
                 .child(restore.clone())
         });
     }
 
-    fn import_identity(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let import = cx.new(|cx| ImportIdentity::new(window, cx));
+    fn account_selector(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let accounts = accounts::init(window, cx);
 
         window.open_modal(cx, move |this, _window, _cx| {
-            this.width(px(450.))
+            this.width(px(520.))
+                .title("Continue with")
                 .show_close(false)
-                .overlay_closable(false)
                 .keyboard(false)
-                .title("Onboarding")
-                .child(import.clone())
+                .overlay_closable(false)
+                .child(accounts.clone())
         });
     }
 
@@ -533,7 +555,8 @@ impl Workspace {
 
     fn titlebar_left(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
         let nostr = NostrRegistry::global(cx);
-        let current_user = nostr.read(cx).current_user();
+        let signer = nostr.read(cx).signer();
+        let current_user = signer.public_key();
 
         h_flex()
             .flex_shrink_0()
@@ -543,7 +566,7 @@ impl Workspace {
                     div()
                         .text_xs()
                         .text_color(cx.theme().text_muted)
-                        .child(SharedString::from("Import your identity to continue")),
+                        .child(SharedString::from("Choose an account to continue...")),
                 )
             })
             .when_some(current_user.as_ref(), |this, public_key| {
@@ -595,9 +618,9 @@ impl Workspace {
                                 )
                                 .separator()
                                 .menu_with_icon(
-                                    "Check for Updates",
-                                    IconName::Device,
-                                    Box::new(Command::Update),
+                                    "Accounts",
+                                    IconName::Group,
+                                    Box::new(Command::ToggleAccount),
                                 )
                                 .menu_with_icon(
                                     "Settings",
@@ -610,96 +633,136 @@ impl Workspace {
     }
 
     fn titlebar_right(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let updater = AutoUpdater::global(cx);
         let chat = ChatRegistry::global(cx);
-        let nip4e_enabled = AppSettings::get_nip4e(cx);
-        let nostr = NostrRegistry::global(cx);
+        let initializing = chat.read(cx).initializing;
+        let trash_messages = chat.read(cx).count_trash_messages(cx);
 
-        let Some(public_key) = nostr.read(cx).current_user() else {
+        let device = DeviceRegistry::global(cx);
+        let device_initializing = device.read(cx).initializing;
+
+        let nostr = NostrRegistry::global(cx);
+        let signer = nostr.read(cx).signer();
+
+        let Some(public_key) = signer.public_key() else {
             return div();
         };
 
         let persons = PersonRegistry::global(cx);
         let profile = persons.read(cx).get(&public_key, cx);
         let announcement = profile.announcement();
-        let updater_idle = updater.read(cx).idle(cx);
 
         h_flex()
             .when(!cx.theme().platform.is_mac(), |this| this.pr_2())
             .gap_2()
-            .when(!updater_idle, |this| {
-                let status = updater.read(cx).status(cx);
-                this.child(div().text_xs().italic().child(status))
-            })
-            .when(nip4e_enabled, |this| {
+            .when(trash_messages > 0, |this| {
                 this.child(
-                    Button::new("key")
-                        .icon(IconName::UserKey)
-                        .tooltip("Decoupled encryption key")
-                        .small()
-                        .ghost()
-                        .dropdown_menu(move |this, _window, _cx| {
-                            this.min_w(px(260.))
-                                .label("Encryption Key")
-                                .when_some(announcement.as_ref(), |this, announcement| {
-                                    let name = announcement.client_name();
-                                    let pkey = shorten_pubkey(announcement.public_key(), 8);
-
-                                    this.item(PopupMenuItem::element(move |_window, cx| {
-                                        h_flex()
-                                            .gap_1()
-                                            .text_sm()
-                                            .child(
-                                                Icon::new(IconName::Device)
-                                                    .small()
-                                                    .text_color(cx.theme().icon_muted),
-                                            )
-                                            .child(name.clone())
-                                    }))
-                                    .item(
-                                        PopupMenuItem::element(move |_window, cx| {
-                                            h_flex()
-                                                .gap_1()
-                                                .text_sm()
-                                                .child(
-                                                    Icon::new(IconName::UserKey)
-                                                        .small()
-                                                        .text_color(cx.theme().icon_muted),
-                                                )
-                                                .child(SharedString::from(pkey.clone()))
-                                        }),
-                                    )
-                                })
-                                .separator()
-                                .menu_with_icon(
-                                    "Backup",
-                                    IconName::Shield,
-                                    Box::new(Command::BackupEncryption),
-                                )
-                                .menu_with_icon(
-                                    "Restore from secret key",
-                                    IconName::Usb,
-                                    Box::new(Command::ImportEncryption),
-                                )
-                                .separator()
-                                .menu_with_icon(
-                                    "Reload",
-                                    IconName::Refresh,
-                                    Box::new(Command::RefreshEncryption),
-                                )
-                                .menu_with_icon(
-                                    "Reset",
-                                    IconName::Warning,
-                                    Box::new(Command::ResetEncryption),
-                                )
+                    h_flex()
+                        .id("trash-messages")
+                        .h_6()
+                        .px_1()
+                        .gap_1()
+                        .rounded(cx.theme().radius)
+                        .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                        .child(
+                            Icon::new(IconName::Warning)
+                                .small()
+                                .text_color(cx.theme().text_danger),
+                        )
+                        .child(
+                            div()
+                                .text_xs()
+                                .line_height(relative(1.))
+                                .child(format!("{trash_messages}")),
+                        )
+                        .on_click(move |_ev, window, cx| {
+                            cx.stop_propagation();
+                            // Add the trash panel to the center workspace
+                            Self::add_panel(
+                                trash::init(window, cx),
+                                DockPlacement::Center,
+                                window,
+                                cx,
+                            );
                         }),
                 )
             })
+            .child(
+                Button::new("key")
+                    .icon(IconName::UserKey)
+                    .tooltip("Decoupled encryption key")
+                    .small()
+                    .ghost()
+                    .loading(device_initializing)
+                    .when(device_initializing, |this| {
+                        this.label("Dekey")
+                            .xsmall()
+                            .tooltip("Loading decoupled encryption key...")
+                    })
+                    .dropdown_menu(move |this, _window, _cx| {
+                        this.min_w(px(260.))
+                            .label("Encryption Key")
+                            .when_some(announcement.as_ref(), |this, announcement| {
+                                let name = announcement.client_name();
+                                let pkey = shorten_pubkey(announcement.public_key(), 8);
+
+                                this.item(PopupMenuItem::element(move |_window, cx| {
+                                    h_flex()
+                                        .gap_1()
+                                        .text_sm()
+                                        .child(
+                                            Icon::new(IconName::Device)
+                                                .small()
+                                                .text_color(cx.theme().icon_muted),
+                                        )
+                                        .child(name.clone())
+                                }))
+                                .item(PopupMenuItem::element(move |_window, cx| {
+                                    h_flex()
+                                        .gap_1()
+                                        .text_sm()
+                                        .child(
+                                            Icon::new(IconName::UserKey)
+                                                .small()
+                                                .text_color(cx.theme().icon_muted),
+                                        )
+                                        .child(SharedString::from(pkey.clone()))
+                                }))
+                            })
+                            .separator()
+                            .menu_with_icon(
+                                "Backup",
+                                IconName::Shield,
+                                Box::new(Command::BackupEncryption),
+                            )
+                            .menu_with_icon(
+                                "Restore from secret key",
+                                IconName::Usb,
+                                Box::new(Command::ImportEncryption),
+                            )
+                            .separator()
+                            .menu_with_icon(
+                                "Reload",
+                                IconName::Refresh,
+                                Box::new(Command::RefreshEncryption),
+                            )
+                            .menu_with_icon(
+                                "Reset",
+                                IconName::Warning,
+                                Box::new(Command::ResetEncryption),
+                            )
+                    }),
+            )
             .child(
                 Button::new("inbox")
                     .icon(IconName::Inbox)
                     .small()
                     .ghost()
+                    .loading(initializing)
+                    .when(initializing, |this| {
+                        this.label("Inbox")
+                            .xsmall()
+                            .tooltip("Getting inbox messages...")
+                    })
                     .dropdown_menu(move |this, _window, cx| {
                         let urls: Vec<(SharedString, SharedString)> = profile
                             .messaging_relays()
@@ -723,7 +786,17 @@ impl Workspace {
                                     .w_full()
                                     .text_sm()
                                     .justify_between()
-                                    .child(url.clone())
+                                    .child(
+                                        h_flex()
+                                            .gap_2()
+                                            .child(
+                                                div()
+                                                    .size_1p5()
+                                                    .rounded_full()
+                                                    .bg(cx.theme().icon_accent),
+                                            )
+                                            .child(url.clone()),
+                                    )
                                     .child(
                                         div()
                                             .text_xs()
@@ -735,6 +808,11 @@ impl Workspace {
 
                         // Footer
                         menu.separator()
+                            .menu_with_icon(
+                                "Reload",
+                                IconName::Refresh,
+                                Box::new(Command::RefreshMessagingRelays),
+                            )
                             .menu_with_icon(
                                 "Manage gossip relays",
                                 IconName::Relay,
@@ -742,15 +820,9 @@ impl Workspace {
                             )
                             .menu_with_icon(
                                 "Manage messaging relays",
-                                IconName::Relay,
+                                IconName::Settings,
                                 Box::new(Command::ShowMessaging),
                             )
-                            .separator()
-                            .menu_with_icon(
-                                "Reload",
-                                IconName::Refresh,
-                                Box::new(Command::RefreshMessagingRelays),
-                            )
                     }),
             )
     }
@@ -761,38 +833,28 @@ impl Render for Workspace {
         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(cx).into_any_element();
+        let right = self.titlebar_right(cx).into_any_element();
+
+        // Update title bar children
+        self.titlebar.update(cx, |this, _cx| {
+            this.set_children(vec![left, right]);
+        });
+
         div()
-            .id("workspace")
+            .id(SharedString::from("workspace"))
             .on_action(cx.listener(Self::on_command))
             .relative()
             .size_full()
             .child(
-                image_cache(self.image_cache.clone())
+                v_flex()
                     .relative()
                     .size_full()
-                    .child(
-                        v_flex()
-                            .size_full()
-                            // Title Bar
-                            .child(
-                                TitleBar::new()
-                                    .child(self.titlebar_left(cx))
-                                    .child(self.titlebar_right(cx)),
-                            )
-                            // Main
-                            .child(
-                                h_flex()
-                                    .size_full()
-                                    .child(
-                                        div()
-                                            .flex_shrink_0()
-                                            .h_full()
-                                            .w(SIDEBAR_WIDTH)
-                                            .child(self.sidebar.clone()),
-                                    )
-                                    .child(self.dock.clone()),
-                            ),
-                    ),
+                    // Title Bar
+                    .child(self.titlebar.clone())
+                    // Dock
+                    .child(self.dock.clone()),
             )
             // Notifications
             .children(notification_layer)

crates/coop_web/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "coop_web"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+assets = { path = "../assets" }
+ui = { path = "../ui" }
+theme = { path = "../theme" }
+common = { path = "../common" }
+state = { path = "../state" }
+device = { path = "../device" }
+chat = { path = "../chat" }
+chat_ui = { path = "../chat_ui" }
+settings = { path = "../settings" }
+person = { path = "../person" }
+relay_auth = { path = "../relay_auth" }
+
+gpui.workspace = true
+gpui_web.workspace = true
+gpui_platform.workspace = true
+gpui_tokio.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
+webbrowser.workspace = true
+
+tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
+console_error_panic_hook = "0.1"
+tracing-wasm = "0.2"
+console_log = "1.0"
+wasm-bindgen = "0.2"

crates/coop_web/src/lib.rs

@@ -0,0 +1,26 @@
+use gpui::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn run() -> Result<(), JsValue> {
+    console_error_panic_hook::set_once();
+
+    // Initialize logging to browser console
+    console_log::init_with_level(log::Level::Info).expect("Failed to initialize logger");
+
+    // Also initialize tracing for WASM
+    tracing_wasm::set_as_global_default();
+
+    #[cfg(target_family = "wasm")]
+    gpui_platform::web_init();
+
+    #[cfg(not(target_family = "wasm"))]
+    let app = gpui_platform::application();
+
+    #[cfg(target_family = "wasm")]
+    let app = gpui_platform::single_threaded_web();
+
+    app.run(|_cx| {});
+
+    Ok(())
+}

crates/coop_web/src/www/index.html

@@ -72,6 +72,6 @@
                 <p>Loading Coop...</p>
             </div>
         </div>
-        <script type="module" src="main.js"></script>
+        <script type="module" src="/src/main.js"></script>
     </body>
 </html>

crates/device/Cargo.toml

@@ -10,15 +10,15 @@ state = { path = "../state" }
 person = { path = "../person" }
 ui = { path = "../ui" }
 theme = { path = "../theme" }
-settings = { path = "../settings" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
+
 anyhow.workspace = true
+itertools.workspace = true
 smallvec.workspace = true
+smol.workspace = true
 log.workspace = true
 flume.workspace = true
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-smol.workspace = true
+serde.workspace = true
+serde_json.workspace = true

crates/device/src/lib.rs

@@ -2,9 +2,7 @@ use std::cell::Cell;
 use std::collections::HashSet;
 use std::path::PathBuf;
 use std::rc::Rc;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use instant::Duration;
+use std::time::Duration;
 
 use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::{
@@ -13,9 +11,7 @@ use gpui::{
 };
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
-use settings::AppSettings;
-use smallvec::{SmallVec, smallvec};
-use state::{Announcement, CLIENT_NAME, NostrRegistry, UniversalSigner};
+use state::{Announcement, NostrRegistry, StateEvent, TIMEOUT, app_name};
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::Button;
@@ -23,6 +19,8 @@ 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);
@@ -37,10 +35,10 @@ impl Global for GlobalDeviceRegistry {}
 pub enum DeviceEvent {
     /// A new encryption signer has been set
     Set,
-    /// User have not setup encryption key
-    NotSet,
     /// The device is requesting an encryption key
     Requesting,
+    /// The device is creating a new encryption key
+    Creating,
     /// An error occurred
     Error(SharedString),
 }
@@ -59,20 +57,17 @@ impl DeviceEvent {
 /// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
 #[derive(Debug)]
 pub struct DeviceRegistry {
+    /// Whether the registry is currently initializing
+    pub initializing: bool,
+
     /// Whether there is a pending request for encryption key approval
     pub pending_request: bool,
 
-    /// Whether an announcement has been made for this device
-    pub announcement_existed: Arc<AtomicBool>,
-
-    /// Signer
-    signer: Entity<Option<UniversalSigner>>,
-
     /// Async tasks
     tasks: Vec<Task<Result<(), Error>>>,
 
     /// Event subscription
-    _subscriptions: SmallVec<[Subscription; 2]>,
+    _subscription: Option<Subscription>,
 }
 
 impl EventEmitter<DeviceEvent> for DeviceRegistry {}
@@ -91,54 +86,35 @@ impl DeviceRegistry {
     /// Create a new device registry instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
-        let settings = AppSettings::global(cx);
 
-        let signer = cx.new(|_| None);
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Subscribe to nostr state events
-            cx.observe(&settings, move |this, settings, cx| {
-                if settings.read(cx).is_nip4e_enabled(cx) {
-                    this.get_announcement(cx);
-                };
-            }),
-        );
-
-        subscriptions.push(
-            // Observe the user signer
-            cx.subscribe(&nostr, move |this, _nostr, event, cx| {
-                if event.signer_changed() && settings.read(cx).is_nip4e_enabled(cx) {
-                    this.get_announcement(cx);
-                }
-            }),
-        );
+        // 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);
+            };
+        });
 
         cx.defer_in(window, |this, window, cx| {
             this.handle_notifications(window, cx);
         });
 
         Self {
-            signer,
+            initializing: true,
             pending_request: false,
-            announcement_existed: Arc::new(AtomicBool::new(false)),
             tasks: vec![],
-            _subscriptions: subscriptions,
+            _subscription: Some(subscription),
         }
     }
 
     fn handle_notifications(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
-
-        let announcement_existed = self.announcement_existed.clone();
         let (tx, rx) = flume::bounded::<Event>(100);
 
         self.tasks.push(cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
-            let current_user = signer.get_public_key_async().await.ok();
 
             while let Some(notification) = notifications.next().await {
                 if let ClientNotification::Message { message, .. } = notification
@@ -150,15 +126,15 @@ impl DeviceRegistry {
                     }
 
                     match event.kind {
-                        Kind::Custom(10044) if current_user == Some(event.pubkey) => {
-                            announcement_existed.store(true, Ordering::Relaxed);
-                            tx.send_async(event.into_owned()).await?;
+                        Kind::Custom(4454) => {
+                            if verify_author(&client, event.as_ref()).await {
+                                tx.send_async(event.into_owned()).await?;
+                            }
                         }
-                        Kind::Custom(4454) if current_user == Some(event.pubkey) => {
-                            tx.send_async(event.into_owned()).await?;
-                        }
-                        Kind::Custom(4455) if current_user == Some(event.pubkey) => {
-                            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?;
+                            }
                         }
                         _ => {}
                     }
@@ -171,11 +147,6 @@ impl DeviceRegistry {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             while let Ok(event) = rx.recv_async().await {
                 match event.kind {
-                    Kind::Custom(10044) => {
-                        this.update_in(cx, |this, _window, cx| {
-                            this.set_encryption(&event, cx);
-                        })?;
-                    }
                     // New request event from other device
                     Kind::Custom(4454) => {
                         this.update_in(cx, |this, window, cx| {
@@ -195,41 +166,48 @@ impl DeviceRegistry {
         }));
     }
 
+    /// Set whether the registry is currently initializing
+    fn set_initializing(&mut self, initializing: bool, cx: &mut Context<Self>) {
+        self.initializing = initializing;
+        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();
     }
 
-    /// Get the signer
-    pub fn signer(&self, cx: &App) -> Option<UniversalSigner> {
-        self.signer.read(cx).clone()
-    }
-
     /// Set the decoupled encryption key for the current user
-    fn set_signer(&mut self, new_signer: Keys, cx: &mut Context<Self>) {
-        self.signer.update(cx, |this, cx| {
-            *this = Some(UniversalSigner::new(new_signer));
-            cx.notify();
-        });
-        cx.emit(DeviceEvent::Set);
+    fn set_signer<S>(&mut self, new: S, cx: &mut Context<Self>)
+    where
+        S: NostrSigner + 'static,
+    {
+        let nostr = NostrRegistry::global(cx);
+        let signer = nostr.read(cx).signer();
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            signer.set_encryption_signer(new).await;
+
+            // Update state
+            this.update(cx, |this, cx| {
+                this.set_initializing(false, cx);
+                cx.emit(DeviceEvent::Set);
+            })?;
+
+            Ok(())
+        }));
     }
 
     /// 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();
 
         cx.background_spawn(async move {
-            let keys = get_keys(&client, &signer).await?;
+            let keys = get_keys(&client).await?;
             let content = keys.secret_key().to_bech32()?;
 
-            if cfg!(target_arch = "wasm32") {
-                return Err(anyhow!("Not supported"));
-            }
-
-            #[cfg(not(target_arch = "wasm32"))]
             smol::fs::write(path, &content).await?;
 
             Ok(())
@@ -240,41 +218,47 @@ impl DeviceRegistry {
     pub fn get_announcement(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
-        self.tasks.push(cx.background_spawn(async move {
-            let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
-            let current_user = signer.get_public_key_async().await?;
+        let task: Task<Result<Event, Error>> = cx.background_spawn(async move {
+            let signer = client.signer().context("Signer not found")?;
+            let public_key = signer.get_public_key().await?;
 
             // Construct the filter for the device announcement event
             let filter = Filter::new()
                 .kind(Kind::Custom(10044))
-                .author(current_user)
+                .author(public_key)
                 .limit(1);
 
-            client
-                .subscribe(filter)
-                .close_on(opts)
-                .with_id(SubscriptionId::new("nip4e"))
+            // Stream events from user's write relays
+            let mut stream = client
+                .stream_events(filter)
+                .timeout(Duration::from_secs(TIMEOUT))
                 .await?;
 
-            Ok(())
-        }));
-
-        let announcement_existed = self.announcement_existed.clone();
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            // Wait for 5 seconds
-            cx.background_executor().timer(Duration::from_secs(5)).await;
-
-            // Then check if the msg relays have been found
-            if announcement_existed.load(Ordering::Acquire) {
-                return Ok(());
+            while let Some((_url, res)) = stream.next().await {
+                if let Ok(event) = res {
+                    return Ok(event);
+                }
             }
 
-            this.update(cx, |_this, cx| {
-                cx.emit(DeviceEvent::NotSet);
-            })?;
+            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.set_encryption(&event, cx);
+                    })?;
+                }
+                Err(_) => {
+                    // User has no announcement, create a new one
+                    this.update(cx, |this, cx| {
+                        this.set_announcement(Keys::generate(), cx);
+                    })?;
+                }
+            }
 
             Ok(())
         }));
@@ -284,6 +268,9 @@ impl DeviceRegistry {
     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) => {
@@ -306,20 +293,19 @@ impl DeviceRegistry {
     fn create_encryption(&self, keys: Keys, cx: &App) -> Task<Result<Keys, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         let secret = keys.secret_key().to_secret_hex();
         let n = keys.public_key();
 
         cx.background_spawn(async move {
             // Construct an announcement event
-            let event = EventBuilder::new(Kind::Custom(10044), "")
-                .tags(vec![
-                    Tag::custom("n", vec![n]),
-                    Tag::custom("client", vec![CLIENT_NAME]),
-                ])
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::new(Kind::Custom(10044), "").tags(vec![
+                Tag::custom(TagKind::custom("n"), vec![n]),
+                Tag::client(app_name()),
+            ]);
+
+            // Sign the event with user's signer
+            let event = client.sign_event_builder(builder).await?;
 
             // Publish announcement
             client
@@ -329,7 +315,7 @@ impl DeviceRegistry {
                 .await?;
 
             // Save device keys to the database
-            set_keys(&client, &signer, &secret).await?;
+            set_keys(&client, &secret).await?;
 
             Ok(keys)
         })
@@ -339,14 +325,13 @@ impl DeviceRegistry {
     fn set_encryption(&mut self, event: &Event, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         let announcement = Announcement::from(event);
         let device_pubkey = announcement.public_key();
 
         // Get encryption key from the database and compare with the announcement
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
-            let keys = get_keys(&client, &signer).await?;
+            let keys = get_keys(&client).await?;
 
             // Compare the public key from the announcement with the one from the database
             if keys.public_key() != device_pubkey {
@@ -378,7 +363,7 @@ impl DeviceRegistry {
         let signer = nostr.read(cx).signer();
 
         self.tasks.push(cx.background_spawn(async move {
-            let public_key = signer.get_public_key_async().await?;
+            let public_key = signer.get_public_key().await?;
             let id = SubscriptionId::new("dekey-requests");
 
             // Construct a filter for encryption key requests
@@ -400,12 +385,11 @@ impl DeviceRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        let app_keys_task = get_or_init_app_keys(cx);
+        let app_keys = nostr.read(cx).keys();
+        let app_pubkey = app_keys.public_key();
 
         let task: Task<Result<Option<Event>, Error>> = cx.background_spawn(async move {
-            let app_keys = app_keys_task.await?;
-            let app_pubkey = app_keys.public_key();
-            let public_key = signer.get_public_key_async().await?;
+            let public_key = signer.get_public_key().await?;
 
             // Construct a filter to get the latest approval event
             let filter = Filter::new()
@@ -420,13 +404,13 @@ impl DeviceRegistry {
                 // No approval event found, construct a request event
                 None => {
                     // Construct an event for device key request
-                    let event = EventBuilder::new(Kind::Custom(4454), "")
-                        .tags(vec![
-                            Tag::custom("P", vec![app_pubkey]),
-                            Tag::custom("client", vec![CLIENT_NAME]),
-                        ])
-                        .finalize_async(&signer)
-                        .await?;
+                    let builder = EventBuilder::new(Kind::Custom(4454), "").tags(vec![
+                        Tag::custom(TagKind::custom("P"), vec![app_pubkey]),
+                        Tag::client(app_name()),
+                    ]);
+
+                    // Sign the event with user's signer
+                    let event = client.sign_event_builder(builder).await?;
 
                     // Send the event to write relays
                     client.send_event(&event).to_nip65().await?;
@@ -445,7 +429,10 @@ impl DeviceRegistry {
                 }
                 Ok(None) => {
                     this.update(cx, |this, cx| {
+                        this.set_initializing(false, cx);
                         this.wait_for_approval(cx);
+
+                        cx.emit(DeviceEvent::Requesting);
                     })?;
                 }
                 Err(e) => {
@@ -464,10 +451,8 @@ impl DeviceRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        cx.emit(DeviceEvent::Requesting);
-
         self.tasks.push(cx.background_spawn(async move {
-            let public_key = signer.get_public_key_async().await?;
+            let public_key = signer.get_public_key().await?;
 
             // Construct a filter for device key requests
             let filter = Filter::new()
@@ -484,20 +469,19 @@ impl DeviceRegistry {
 
     /// Parse the approval event to get encryption key then set it
     fn extract_encryption(&mut self, event: Event, cx: &mut Context<Self>) {
-        let app_keys_task = get_or_init_app_keys(cx);
+        let nostr = NostrRegistry::global(cx);
+        let app_keys = nostr.read(cx).keys();
 
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
-            let app_keys = app_keys_task.await?;
             let master = event
                 .tags
-                .iter()
-                .find(|tag| tag.kind() == "P")
+                .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_async(&master, payload).await?;
+            let decrypted = app_keys.nip44_decrypt(&master, payload).await?;
 
             let secret = SecretKey::from_hex(&decrypted)?;
             let keys = Keys::new(secret);
@@ -526,7 +510,6 @@ impl DeviceRegistry {
     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 signer = nostr.read(cx).signer();
 
         // Get user's write relays
         let event = event.clone();
@@ -534,32 +517,31 @@ impl DeviceRegistry {
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             // Get device keys
-            let keys = get_keys(&client, &signer).await?;
+            let keys = get_keys(&client).await?;
             let secret = keys.secret_key().to_secret_hex();
 
             // Extract the target public key from the event tags
             let target = event
                 .tags
-                .iter()
-                .find(|tag| tag.kind() == "P")
+                .find(TagKind::custom("P"))
                 .and_then(|tag| tag.content())
                 .and_then(|content| PublicKey::parse(content).ok())
                 .context("Target is not a valid public key")?;
 
             // Encrypt the device keys with the user's signer
-            let payload = keys.nip44_encrypt_async(&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 event = EventBuilder::new(Kind::Custom(4455), payload)
-                .tags(vec![
-                    Tag::custom("P", vec![keys.public_key().to_hex()]),
-                    Tag::public_key(target),
-                ])
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::new(Kind::Custom(4455), payload).tags(vec![
+                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
             client.send_event(&event).to_nip65().await?;
@@ -567,7 +549,7 @@ impl DeviceRegistry {
             Ok(())
         });
 
-        self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+        cx.spawn_in(window, async move |_this, cx| {
             match task.await {
                 Ok(_) => {
                     cx.update(|window, cx| {
@@ -585,9 +567,8 @@ impl DeviceRegistry {
                     .ok();
                 }
             };
-
-            Ok(())
-        }));
+        })
+        .detach();
     }
 
     /// Handle encryption request
@@ -605,9 +586,6 @@ impl DeviceRegistry {
 
     /// Build a notification for the encryption request.
     fn notification(&self, event: Event, cx: &Context<Self>) -> Notification {
-        const MSG: &str = "You've requested an encryption key from another device. \
-                           Approve to allow Coop to share with it.";
-
         let request = Announcement::from(&event);
         let persons = PersonRegistry::global(cx);
         let profile = persons.read(cx).get(&request.public_key(), cx);
@@ -710,45 +688,29 @@ impl DeviceRegistry {
 
 struct DeviceNotification;
 
-/// Get or create new app keys (async, returns a task)
-fn get_or_init_app_keys(cx: &App) -> Task<Result<Keys, Error>> {
-    let read = cx.read_credentials(CLIENT_NAME);
-
-    cx.spawn(async move |cx| {
-        if let Ok(Some((_, secret))) = read.await
-            && let Ok(keys) = SecretKey::from_slice(&secret).map(Keys::new)
-        {
-            return Ok(keys);
-        }
-
-        // No stored keys found or invalid — generate new ones
-        let keys = Keys::generate();
-        let user = keys.public_key().to_hex();
-        let secret = keys.secret_key().to_secret_bytes();
-
-        cx.update(|cx| {
-            let write = cx.write_credentials(CLIENT_NAME, &user, &secret);
-            cx.background_spawn(async move {
-                if let Err(e) = write.await {
-                    log::error!("Keyring not available or panic: {e}")
-                }
-            })
-            .detach();
-        });
-
-        Ok(keys)
-    })
+/// Verify the author of an event
+async fn verify_author(client: &Client, event: &Event) -> bool {
+    if let Some(signer) = client.signer()
+        && let Ok(public_key) = signer.get_public_key().await
+    {
+        return public_key == event.pubkey;
+    }
+    false
 }
 
 /// Encrypt and store device keys in the local database.
-async fn set_keys(client: &Client, signer: &UniversalSigner, secret: &str) -> Result<(), Error> {
-    let public_key = signer.get_public_key_async().await?;
-    let content = signer.nip44_encrypt_async(&public_key, secret).await?;
+async fn set_keys(client: &Client, secret: &str) -> Result<(), Error> {
+    let signer = client.signer().context("Signer not found")?;
+    let public_key = signer.get_public_key().await?;
+
+    // Encrypt the value
+    let content = signer.nip44_encrypt(&public_key, secret).await?;
 
     // Construct the application data event
     let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
         .tag(Tag::identifier(IDENTIFIER))
-        .finalize_async(signer)
+        .build(public_key)
+        .sign(&Keys::generate())
         .await?;
 
     // Save the event to the database
@@ -758,8 +720,9 @@ async fn set_keys(client: &Client, signer: &UniversalSigner, secret: &str) -> Re
 }
 
 /// Get device keys from the local database.
-async fn get_keys(client: &Client, signer: &UniversalSigner) -> Result<Keys, Error> {
-    let public_key = signer.get_public_key_async().await?;
+async fn get_keys(client: &Client) -> Result<Keys, Error> {
+    let signer = client.signer().context("Signer not found")?;
+    let public_key = signer.get_public_key().await?;
 
     let filter = Filter::new()
         .kind(Kind::ApplicationSpecificData)
@@ -767,10 +730,7 @@ async fn get_keys(client: &Client, signer: &UniversalSigner) -> Result<Keys, Err
         .author(public_key);
 
     if let Some(event) = client.database().query(filter).await?.first() {
-        let content = signer
-            .nip44_decrypt_async(&public_key, &event.content)
-            .await?;
-
+        let content = signer.nip44_decrypt(&public_key, &event.content).await?;
         let secret = SecretKey::parse(&content)?;
         let keys = Keys::new(secret);
 

crates/person/Cargo.toml

@@ -10,8 +10,9 @@ state = { path = "../state" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 anyhow.workspace = true
 smallvec.workspace = true
+smol.workspace = true
 flume.workspace = true
 log.workspace = true
+urlencoding = "2.1.3"

crates/person/src/lib.rs

@@ -1,10 +1,11 @@
+use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
-use std::sync::RwLock;
+use std::rc::Rc;
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
 use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
 use state::{Announcement, BOOTSTRAP_RELAYS, NostrRegistry, TIMEOUT};
@@ -23,9 +24,9 @@ impl Global for GlobalPersonRegistry {}
 
 #[derive(Debug, Clone)]
 enum Dispatch {
-    Person(Person),
-    Announcement(Event),
-    Relays(Event),
+    Person(Box<Person>),
+    Announcement(Box<Event>),
+    Relays(Box<Event>),
 }
 
 /// Person Registry
@@ -35,7 +36,7 @@ pub struct PersonRegistry {
     persons: HashMap<PublicKey, Entity<Person>>,
 
     /// Set of public keys that have been seen
-    seen: RwLock<HashSet<PublicKey>>,
+    seens: Rc<RefCell<HashSet<PublicKey>>>,
 
     /// Sender for requesting metadata
     sender: flume::Sender<PublicKey>,
@@ -62,38 +63,53 @@ impl PersonRegistry {
 
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Dispatch>(100);
-        let (metadata_tx, metadata_rx) = flume::unbounded::<PublicKey>();
+        let (mta_tx, mta_rx) = flume::unbounded::<PublicKey>();
 
         let mut tasks = smallvec![];
 
-        let client2 = client.clone();
-        tasks.push(cx.background_spawn(async move {
-            Self::handle_notifications(&client2, &tx).await;
-        }));
+        tasks.push(
+            // Handle nostr notifications
+            cx.background_spawn({
+                let client = client.clone();
 
-        let client3 = client.clone();
-        tasks.push(cx.background_spawn(async move {
-            Self::handle_requests(&client3, &metadata_rx).await;
-        }));
+                async move {
+                    Self::handle_notifications(&client, &tx).await;
+                }
+            }),
+        );
 
-        tasks.push(cx.spawn(async move |this, cx| {
-            while let Ok(event) = rx.recv_async().await {
-                this.update(cx, |this, cx| {
-                    match event {
-                        Dispatch::Person(person) => {
-                            this.insert(person, cx);
-                        }
-                        Dispatch::Announcement(event) => {
-                            this.set_announcement(&event, cx);
-                        }
-                        Dispatch::Relays(event) => {
-                            this.set_messaging_relays(&event, cx);
-                        }
-                    };
-                })
-                .ok();
-            }
-        }));
+        tasks.push(
+            // Handle metadata requests
+            cx.background_spawn({
+                let client = client.clone();
+
+                async move {
+                    Self::handle_requests(&client, &mta_rx).await;
+                }
+            }),
+        );
+
+        tasks.push(
+            // Update GPUI state
+            cx.spawn(async move |this, cx| {
+                while let Ok(event) = rx.recv_async().await {
+                    this.update(cx, |this, cx| {
+                        match event {
+                            Dispatch::Person(person) => {
+                                this.insert(*person, cx);
+                            }
+                            Dispatch::Announcement(event) => {
+                                this.set_announcement(&event, cx);
+                            }
+                            Dispatch::Relays(event) => {
+                                this.set_messaging_relays(&event, cx);
+                            }
+                        };
+                    })
+                    .ok();
+                }
+            }),
+        );
 
         // Load all user profiles from the database
         cx.defer_in(window, |this, _window, cx| {
@@ -102,8 +118,8 @@ impl PersonRegistry {
 
         Self {
             persons: HashMap::new(),
-            seen: RwLock::new(HashSet::new()),
-            sender: metadata_tx,
+            seens: Rc::new(RefCell::new(HashSet::new())),
+            sender: mta_tx,
             tasks,
         }
     }
@@ -129,25 +145,24 @@ impl PersonRegistry {
                     Kind::Metadata => {
                         let metadata = Metadata::from_json(&event.content).unwrap_or_default();
                         let person = Person::new(event.pubkey, metadata);
-                        if tx.send_async(Dispatch::Person(person)).await.is_err() {
-                            log::warn!("PersonRegistry channel closed, dropping metadata event");
-                        }
+                        let val = Box::new(person);
+                        // Send
+                        tx.send_async(Dispatch::Person(val)).await.ok();
                     }
                     Kind::ContactList => {
                         let public_keys = event.extract_public_keys();
-                        if let Err(e) = get_metadata(client, public_keys).await {
-                            log::warn!("Failed to get metadata for contact list: {e}");
-                        }
+                        // Get metadata for all public keys
+                        get_metadata(client, public_keys).await.ok();
                     }
                     Kind::InboxRelays => {
-                        tx.send_async(Dispatch::Relays(event.into_owned()))
-                            .await
-                            .ok();
+                        let val = Box::new(event.into_owned());
+                        // Send
+                        tx.send_async(Dispatch::Relays(val)).await.ok();
                     }
                     Kind::Custom(10044) => {
-                        tx.send_async(Dispatch::Announcement(event.into_owned()))
-                            .await
-                            .ok();
+                        let val = Box::new(event.into_owned());
+                        // Send
+                        tx.send_async(Dispatch::Announcement(val)).await.ok();
                     }
                     _ => {}
                 }
@@ -167,17 +182,13 @@ impl PersonRegistry {
                 Ok(Some(public_key)) => {
                     batch.insert(public_key);
                     // Process the batch if it's full
-                    if batch.len() >= 20
-                        && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
-                    {
-                        log::warn!("Failed to get metadata batch: {e}");
+                    if batch.len() >= 20 {
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
                     }
                 }
                 _ => {
-                    if !batch.is_empty()
-                        && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
-                    {
-                        log::warn!("Failed to get metadata batch: {e}");
+                    if !batch.is_empty() {
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
                     }
                 }
             }
@@ -206,7 +217,7 @@ impl PersonRegistry {
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Ok(persons) = task.await {
                 this.update(cx, |this, cx| {
-                    this.bulk_insert(persons, cx);
+                    this.bulk_inserts(persons, cx);
                 })
                 .ok();
             }
@@ -231,7 +242,7 @@ impl PersonRegistry {
 
     /// Set messaging relays for a person
     fn set_messaging_relays(&mut self, event: &Event, cx: &mut App) {
-        let urls: Vec<RelayUrl> = nip17::extract_relay_list(event).collect();
+        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| {
@@ -245,7 +256,7 @@ impl PersonRegistry {
     }
 
     /// Insert batch of persons
-    fn bulk_insert(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
+    fn bulk_inserts(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
         for person in persons.into_iter() {
             let public_key = person.public_key();
             self.persons
@@ -279,14 +290,15 @@ impl PersonRegistry {
         }
 
         let public_key = *public_key;
+        let mut seen = self.seens.borrow_mut();
 
-        if self.seen.write().unwrap().insert(public_key) {
+        if seen.insert(public_key) {
             let sender = self.sender.clone();
 
             // Spawn background task to request metadata
             cx.background_spawn(async move {
                 if let Err(e) = sender.send_async(public_key).await {
-                    log::warn!("Failed to send public key for metadata request: {e}");
+                    log::warn!("Failed to send public key for metadata request: {}", e);
                 }
             })
             .detach();

crates/person/src/person.rs

@@ -5,6 +5,8 @@ use gpui::SharedString;
 use nostr_sdk::prelude::*;
 use state::Announcement;
 
+const IMAGE_RESIZER: &str = "https://wsrv.nl";
+
 /// Person
 #[derive(Debug, Clone)]
 pub struct Person {
@@ -109,7 +111,13 @@ impl Person {
             .picture
             .as_ref()
             .filter(|picture| !picture.is_empty())
-            .map(|picture| picture.into())
+            .map(|picture| {
+                let encoded_picture = urlencoding::encode(picture);
+                let url = format!(
+                    "{IMAGE_RESIZER}/?url={encoded_picture}&w=100&h=100&fit=cover&mask=circle&n=-1"
+                );
+                url.into()
+            })
             .unwrap_or_else(|| "brand/avatar.png".into())
     }
 
@@ -118,13 +126,13 @@ impl Person {
         if let Some(display_name) = self.metadata().display_name.as_ref()
             && !display_name.is_empty()
         {
-            return SharedString::from(display_name.trim());
+            return SharedString::from(display_name);
         }
 
         if let Some(name) = self.metadata().name.as_ref()
             && !name.is_empty()
         {
-            return SharedString::from(name.trim());
+            return SharedString::from(name);
         }
 
         SharedString::from(shorten_pubkey(self.public_key(), 4))

crates/relay_auth/Cargo.toml

@@ -1,28 +1,21 @@
 [package]
-name = "workspace"
+name = "relay_auth"
 version.workspace = true
 edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-ui = { path = "../ui" }
-theme = { path = "../theme" }
-common = { path = "../common" }
 state = { path = "../state" }
-device = { path = "../device" }
-chat = { path = "../chat" }
-chat_ui = { path = "../chat_ui" }
 settings = { path = "../settings" }
-person = { path = "../person" }
-auto_update = { path = "../auto_update" }
+common = { path = "../common" }
+theme = { path = "../theme" }
+ui = { path = "../ui" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
-nostr-connect.workspace = true
-browser-signer-proxy = { path = "../browser-signer-proxy" }
 
 anyhow.workspace = true
-serde.workspace = true
-log.workspace = true
 smallvec.workspace = true
+smol.workspace = true
+flume.workspace = true
+log.workspace = true

crates/relay_auth/src/lib.rs

@@ -0,0 +1,377 @@
+use std::borrow::Cow;
+use std::cell::Cell;
+use std::collections::HashSet;
+use std::hash::Hash;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use anyhow::{Context as AnyhowContext, Error, anyhow};
+use gpui::{
+    App, AppContext, Context, Entity, Global, IntoElement, ParentElement, SharedString, Styled,
+    Task, Window, div, relative,
+};
+use nostr_sdk::prelude::*;
+use settings::{AppSettings, AuthMode};
+use smallvec::{SmallVec, smallvec};
+use state::NostrRegistry;
+use theme::ActiveTheme;
+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.";
+
+pub fn init(window: &mut Window, cx: &mut App) {
+    RelayAuth::set_global(cx.new(|cx| RelayAuth::new(window, cx)), cx);
+}
+
+/// Authentication request
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+struct AuthRequest {
+    url: RelayUrl,
+    challenge: String,
+}
+
+impl AuthRequest {
+    pub fn new<S>(challenge: S, url: RelayUrl) -> Self
+    where
+        S: Into<String>,
+    {
+        Self {
+            challenge: challenge.into(),
+            url,
+        }
+    }
+
+    pub fn url(&self) -> &RelayUrl {
+        &self.url
+    }
+
+    pub fn challenge(&self) -> &str {
+        &self.challenge
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum Signal {
+    Auth(Arc<AuthRequest>),
+    Pending((EventId, RelayUrl)),
+}
+
+struct GlobalRelayAuth(Entity<RelayAuth>);
+
+impl Global for GlobalRelayAuth {}
+
+// Relay authentication
+#[derive(Debug)]
+pub struct RelayAuth {
+    /// Pending events waiting for resend after authentication
+    pending_events: HashSet<(EventId, RelayUrl)>,
+
+    /// Tasks for asynchronous operations
+    _tasks: SmallVec<[Task<()>; 2]>,
+}
+
+impl RelayAuth {
+    /// Retrieve the global relay auth state
+    pub fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalRelayAuth>().0.clone()
+    }
+
+    /// Set the global relay auth instance
+    fn set_global(state: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalRelayAuth(state));
+    }
+
+    /// Create a new relay auth instance
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> 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);
+
+        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 {
+                        RelayMessage::Auth { challenge } => {
+                            if challenges.insert(challenge.clone()) {
+                                let request = Arc::new(AuthRequest::new(challenge, relay_url));
+                                let signal = Signal::Auth(request);
+
+                                tx.send_async(signal).await.ok();
+                            }
+                        }
+                        RelayMessage::Ok {
+                            event_id, message, ..
+                        } => {
+                            let msg = MachineReadablePrefix::parse(&message);
+
+                            // Handle authentication messages
+                            if let Some(MachineReadablePrefix::AuthRequired) = msg {
+                                let signal = Signal::Pending((event_id, relay_url));
+                                tx.send_async(signal).await.ok();
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }));
+
+        tasks.push(cx.spawn_in(window, async move |this, cx| {
+            while let Ok(signal) = rx.recv_async().await {
+                match signal {
+                    Signal::Auth(req) => {
+                        this.update_in(cx, |this, window, cx| {
+                            this.handle_auth(&req, window, cx);
+                        })
+                        .ok();
+                    }
+                    Signal::Pending((event_id, relay_url)) => {
+                        this.update_in(cx, |this, _window, cx| {
+                            this.insert_pending_event(event_id, relay_url, cx);
+                        })
+                        .ok();
+                    }
+                }
+            }
+        }));
+
+        Self {
+            pending_events: HashSet::default(),
+            _tasks: tasks,
+        }
+    }
+
+    /// Insert a pending event waiting for resend after authentication
+    fn insert_pending_event(&mut self, id: EventId, relay: RelayUrl, cx: &mut Context<Self>) {
+        self.pending_events.insert((id, relay));
+        cx.notify();
+    }
+
+    /// Get all pending events for a specific relay,
+    fn get_pending_events(&self, relay: &RelayUrl, _cx: &App) -> Vec<EventId> {
+        self.pending_events
+            .iter()
+            .filter(|(_, pending_relay)| pending_relay == relay)
+            .map(|(id, _relay)| id)
+            .cloned()
+            .collect()
+    }
+
+    /// Clear all pending events for a specific relay,
+    fn clear_pending_events(&mut self, relay: &RelayUrl, cx: &mut Context<Self>) {
+        self.pending_events
+            .retain(|(_, pending_relay)| pending_relay != relay);
+        cx.notify();
+    }
+
+    /// Handle authentication request
+    fn handle_auth(&mut self, req: &Arc<AuthRequest>, window: &mut Window, cx: &mut Context<Self>) {
+        let settings = AppSettings::global(cx);
+        let trusted_relay = settings.read(cx).trusted_relay(req.url(), cx);
+        let mode = AppSettings::get_auth_mode(cx);
+
+        if trusted_relay && mode == AuthMode::Auto {
+            // Automatically authenticate if the relay is authenticated before
+            self.response(req, window, cx);
+        } else {
+            // Otherwise open the auth request popup
+            self.ask_for_approval(req, window, cx);
+        }
+    }
+
+    /// Send auth response and wait for confirmation
+    fn auth(&self, req: &Arc<AuthRequest>, cx: &App) -> Task<Result<(), Error>> {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let req = req.clone();
+
+        // Get all pending events for the relay
+        let pending_events = self.get_pending_events(req.url(), cx);
+
+        cx.background_spawn(async move {
+            // Construct event
+            let builder = EventBuilder::auth(req.challenge(), req.url().clone());
+            let event = client.sign_event_builder(builder).await?;
+
+            // Get the event ID
+            let id = event.id;
+
+            // Get the relay
+            let relay = client.relay(req.url()).await?.context("Relay not found")?;
+
+            // Subscribe to notifications
+            let mut notifications = relay.notifications();
+
+            // Send the AUTH message
+            relay
+                .send_msg(ClientMessage::Auth(Cow::Borrowed(&event)))
+                .await?;
+
+            log::info!("Sending AUTH event");
+
+            while let Some(notification) = notifications.next().await {
+                match notification {
+                    RelayNotification::Message { message } => {
+                        if let RelayMessage::Ok { event_id, .. } = *message {
+                            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?;
+                                }
+                            }
+
+                            // 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,
+                    _ => {}
+                }
+            }
+
+            Err(anyhow!("Authentication failed"))
+        })
+    }
+
+    /// Respond to an authentication request.
+    fn response(&self, req: &Arc<AuthRequest>, window: &Window, cx: &Context<Self>) {
+        let settings = AppSettings::global(cx);
+        let req = req.clone();
+        let challenge = SharedString::from(req.challenge().to_string());
+
+        // Create a task for authentication
+        let task = self.auth(&req, cx);
+
+        cx.spawn_in(window, async move |this, cx| {
+            let result = task.await;
+            let url = req.url();
+
+            this.update_in(cx, |this, window, 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(
+                            Notification::success(format!(
+                                "Relay {} has been authenticated",
+                                url.domain().unwrap_or_default()
+                            )),
+                            cx,
+                        );
+                    }
+                    Err(e) => {
+                        window.push_notification(
+                            Notification::error(e.to_string()).autohide(false),
+                            cx,
+                        );
+                    }
+                }
+            })
+            .ok();
+        })
+        .detach();
+    }
+
+    /// Push a popup to approve the authentication request.
+    fn ask_for_approval(&self, req: &Arc<AuthRequest>, window: &Window, cx: &Context<Self>) {
+        let notification = self.notification(req, cx);
+
+        cx.spawn_in(window, async move |_this, cx| {
+            cx.update(|window, cx| {
+                window.push_notification(notification, cx);
+            })
+            .ok();
+        })
+        .detach();
+    }
+
+    /// 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()
+            .type_id::<AuthNotification>(challenge)
+            .autohide(false)
+            .with_kind(NotificationKind::Info)
+            .title("Authentication Required")
+            .content(move |_this, _window, cx| {
+                v_flex()
+                    .gap_2()
+                    .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().elevated_surface_background)
+                            .text_color(cx.theme().text)
+                            .child(url.clone()),
+                    )
+                    .into_any_element()
+            })
+            .action(move |_this, _window, _cx| {
+                let view = entity.clone();
+                let req = req.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.response(&req, window, cx);
+                            })
+                            .ok();
+                        }
+                    })
+            })
+    }
+}
+
+struct AuthNotification;

crates/settings/Cargo.toml

@@ -10,6 +10,7 @@ common = { path = "../common" }
 
 nostr-sdk.workspace = true
 gpui.workspace = true
+smol.workspace = true
 anyhow.workspace = true
 log.workspace = true
 smallvec.workspace = true
@@ -17,6 +18,3 @@ serde.workspace = true
 serde_json.workspace = true
 
 paste = "1.0.15"
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-smol.workspace = true

crates/settings/src/lib.rs

@@ -1,3 +1,5 @@
+use std::collections::{HashMap, HashSet};
+use std::fmt::Display;
 use std::rc::Rc;
 
 use anyhow::{Error, anyhow};
@@ -18,15 +20,13 @@ macro_rules! setting_accessors {
             $(
                 paste::paste! {
                     pub fn [<get_ $field>](cx: &App) -> $type {
-                        Self::global(cx).read(cx).inner.read(cx).$field.clone()
+                        Self::global(cx).read(cx).values.$field.clone()
                     }
 
                     pub fn [<update_ $field>](value: $type, cx: &mut App) {
                         Self::global(cx).update(cx, |this, cx| {
-                            this.inner.update(cx, |inner, cx| {
-                                inner.$field = value;
-                                cx.notify();
-                            });
+                            this.values.$field = value;
+                            cx.notify();
                         });
                     }
                 }
@@ -40,18 +40,36 @@ setting_accessors! {
     pub theme_mode: ThemeMode,
     pub hide_avatar: bool,
     pub screening: bool,
-    pub nip4e: bool,
-    pub trusted_relays: Vec<String>,
+    pub auth_mode: AuthMode,
+    pub trusted_relays: HashSet<RelayUrl>,
+    pub room_configs: HashMap<u64, RoomConfig>,
     pub file_server: Url,
 }
 
+/// Authentication mode
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AuthMode {
+    #[default]
+    Auto,
+    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,
-    Encryption,
     #[default]
+    Auto,
     User,
+    Encryption,
 }
 
 impl SignerKind {
@@ -79,7 +97,7 @@ impl RoomConfig {
     pub fn new() -> Self {
         Self {
             backup: true,
-            signer_kind: SignerKind::default(),
+            signer_kind: SignerKind::Auto,
         }
     }
 
@@ -119,11 +137,14 @@ pub struct Settings {
     /// Enable screening for unknown chat requests
     pub screening: bool,
 
-    /// Enable decoupling encryption key
-    pub nip4e: bool,
+    /// Authentication mode
+    pub auth_mode: AuthMode,
 
     /// Trusted relays; Coop will automatically authenticate with these relays
-    pub trusted_relays: Vec<String>,
+    pub trusted_relays: HashSet<RelayUrl>,
+
+    /// Configuration for each chat room
+    pub room_configs: HashMap<u64, RoomConfig>,
 
     /// Server for blossom media attachments
     pub file_server: Url,
@@ -136,8 +157,9 @@ impl Default for Settings {
             theme_mode: ThemeMode::default(),
             hide_avatar: false,
             screening: true,
-            nip4e: false,
-            trusted_relays: vec![],
+            auth_mode: AuthMode::default(),
+            trusted_relays: HashSet::default(),
+            room_configs: HashMap::default(),
             file_server: Url::parse("https://blossom.band/").unwrap(),
         }
     }
@@ -156,7 +178,7 @@ impl Global for GlobalAppSettings {}
 /// Application settings
 pub struct AppSettings {
     /// Settings
-    inner: Entity<Settings>,
+    values: Settings,
 
     /// Event subscriptions
     _subscriptions: SmallVec<[Subscription; 2]>,
@@ -174,12 +196,11 @@ impl AppSettings {
     }
 
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let inner = cx.new(|_| Settings::default());
         let mut subscriptions = smallvec![];
 
         subscriptions.push(
             // Observe and automatically save settings on changes
-            cx.observe(&inner, |this, _inner, cx| {
+            cx.observe_self(|this, cx| {
                 this.save(cx);
             }),
         );
@@ -190,30 +211,27 @@ impl AppSettings {
         });
 
         Self {
-            inner,
+            values: Settings::default(),
             _subscriptions: subscriptions,
         }
     }
 
     /// Update settings
     fn set_settings(&mut self, settings: Settings, cx: &mut Context<Self>) {
-        self.inner.update(cx, |this, cx| {
-            *this = settings;
-            cx.notify();
-        });
+        self.values = settings;
+        cx.notify();
     }
 
     /// Load settings
     fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let task: Task<Result<Settings, Error>> = cx.background_spawn(async move {
-            #[cfg(not(target_arch = "wasm32"))]
-            {
-                let path = config_dir().join(".settings");
-                if let Ok(content) = smol::fs::read_to_string(&path).await {
-                    return Ok(serde_json::from_str(&content)?);
-                }
+            let path = config_dir().join(".settings");
+
+            if let Ok(content) = smol::fs::read_to_string(&path).await {
+                Ok(serde_json::from_str(&content)?)
+            } else {
+                Err(anyhow!("Not found"))
             }
-            Err(anyhow!("Not found"))
         });
 
         cx.spawn_in(window, async move |this, cx| {
@@ -231,15 +249,19 @@ impl AppSettings {
 
     /// Save settings
     pub fn save(&mut self, cx: &mut Context<Self>) {
-        let settings = self.inner.read(cx);
-        if let Ok(content) = serde_json::to_string(&settings) {
-            #[cfg(not(target_arch = "wasm32"))]
-            cx.background_spawn(async move {
-                let path = config_dir().join(".settings");
-                smol::fs::write(&path, content).await.ok();
-            })
-            .detach();
-        }
+        let settings = self.values.clone();
+
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            let path = config_dir().join(".settings");
+            let content = serde_json::to_string(&settings)?;
+
+            // Write settings to file
+            smol::fs::write(&path, content).await?;
+
+            Ok(())
+        });
+
+        task.detach();
     }
 
     /// Set theme
@@ -248,10 +270,8 @@ impl AppSettings {
         T: Into<String>,
     {
         // Update settings
-        self.inner.update(cx, |this, cx| {
-            this.theme = Some(theme.into());
-            cx.notify();
-        });
+        self.values.theme = Some(theme.into());
+        cx.notify();
 
         // Apply the new theme
         self.apply_theme(window, cx);
@@ -259,17 +279,16 @@ impl AppSettings {
 
     /// Reset theme
     pub fn reset_theme(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.inner.update(cx, |this, cx| {
-            this.theme = None;
-            cx.notify();
-        });
+        self.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.inner.read(cx).theme.as_ref() {
-            let mode = self.inner.read(cx).theme_mode;
+        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);
@@ -282,32 +301,26 @@ impl AppSettings {
         }
     }
 
-    /// Check if decoupling encryption key is enabled
-    pub fn is_nip4e_enabled(&self, cx: &App) -> bool {
-        self.inner.read(cx).nip4e
-    }
-
     /// Check if the given relay is already authenticated
-    pub fn trusted_relay(&self, url: &RelayUrl, cx: &App) -> bool {
-        self.inner
-            .read(cx)
-            .trusted_relays
-            .iter()
-            .any(|relay| relay == url.as_str_without_trailing_slash())
+    pub fn trusted_relay(&self, url: &RelayUrl, _cx: &App) -> bool {
+        self.values.trusted_relays.iter().any(|relay| {
+            relay.as_str_without_trailing_slash() == url.as_str_without_trailing_slash()
+        })
     }
 
     /// Add a relay to the trusted list
     pub fn add_trusted_relay(&mut self, url: &RelayUrl, cx: &mut Context<Self>) {
-        self.inner.update(cx, |this, cx| {
-            if !this
-                .trusted_relays
-                .iter()
-                .any(|relay| relay == url.as_str_without_trailing_slash())
-            {
-                this.trusted_relays
-                    .push(url.as_str_without_trailing_slash().to_string());
-                cx.notify();
-            }
-        });
+        self.values.trusted_relays.insert(url.clone());
+        cx.notify();
+    }
+
+    /// Add a room configuration
+    pub fn add_room_config(&mut self, id: u64, config: RoomConfig, cx: &mut Context<Self>) {
+        self.values
+            .room_configs
+            .entry(id)
+            .and_modify(|this| *this = config)
+            .or_default();
+        cx.notify();
     }
 }

crates/state/Cargo.toml

@@ -9,27 +9,22 @@ common = { path = "../common" }
 
 nostr.workspace = true
 nostr-sdk.workspace = true
+nostr-lmdb.workspace = true
 nostr-gossip-memory.workspace = true
-nostr-blossom.workspace = true
 nostr-connect.workspace = true
+nostr-blossom.workspace = true
 
 gpui.workspace = true
-instant.workspace = true
+gpui_tokio.workspace = true
+smol.workspace = true
 flume.workspace = true
-futures.workspace = true
 log.workspace = true
 anyhow.workspace = true
 webbrowser.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 
-mime_guess = "2.0.4"
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-nostr-memory.workspace = true
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-browser-signer-proxy = { path = "../browser-signer-proxy" }
-nostr-lmdb.workspace = true
-smol.workspace = true
-gpui_tokio.workspace = true
 rustls = "0.23"
+petname = "2.0.2"
+whoami = "1.6.1"
+mime_guess = "2.0.4"

crates/state/src/blossom.rs

@@ -1,14 +1,12 @@
 use std::path::PathBuf;
 
-use anyhow::{Error, anyhow};
+use anyhow::{anyhow, Error};
 use gpui::AsyncApp;
-#[cfg(not(target_arch = "wasm32"))]
 use gpui_tokio::Tokio;
 use mime_guess::from_path;
 use nostr_blossom::prelude::*;
 use nostr_sdk::prelude::*;
 
-#[cfg(not(target_arch = "wasm32"))]
 pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Error> {
     let content_type = from_path(&path).first_or_octet_stream().to_string();
     let data = smol::fs::read(path).await?;
@@ -27,8 +25,3 @@ pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Er
     .await
     .map_err(|e| anyhow!("Upload error: {e}"))?
 }
-
-#[cfg(target_arch = "wasm32")]
-pub async fn upload(_server: Url, _path: PathBuf, _cx: &AsyncApp) -> Result<Url, Error> {
-    Err(anyhow!("File upload not supported on web"))
-}

crates/state/src/constants.rs

@@ -1,3 +1,5 @@
+use std::sync::OnceLock;
+
 /// Client name (Application name)
 pub const CLIENT_NAME: &str = "Coop";
 
@@ -8,15 +10,11 @@ pub const COOP_PUBKEY: &str = "npub1j3rz3ndl902lya6ywxvy5c983lxs8mpukqnx4pa4lt5w
 pub const APP_ID: &str = "su.reya.coop";
 
 /// Keyring name
-pub const MASTER_KEYRING: &str = "Coop Master Key";
-pub const USER_KEYRING: &str = "Coop User Credential";
+pub const 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;
 
@@ -39,15 +37,26 @@ pub const NOSTR_CONNECT_RELAY: &str = "wss://relay.nip46.com";
 pub const WOT_RELAYS: [&str; 1] = ["wss://relay.vertexlab.io"];
 
 /// Default search relays
-pub const INDEXER_RELAYS: [&str; 2] = ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
+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; 4] = [
-    "wss://relay.ditto.pub",
+pub const BOOTSTRAP_RELAYS: [&str; 3] = [
+    "wss://relay.damus.io",
     "wss://relay.primal.net",
-    "wss://relay.nostr.net",
-    "wss://profiles.nostr1.com",
+    "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

@@ -16,15 +16,14 @@ impl From<&Event> for Announcement {
         let public_key = val
             .tags
             .iter()
-            .find(|tag| tag.kind() == "n")
+            .find(|tag| tag.kind().as_str() == "n")
             .and_then(|tag| tag.content())
             .and_then(|c| PublicKey::parse(c).ok())
             .unwrap_or(val.pubkey);
 
         let client_name = val
             .tags
-            .iter()
-            .find(|tag| tag.kind() == "client")
+            .find(TagKind::Client)
             .and_then(|tag| tag.content())
             .map(|c| c.to_string());
 

crates/state/src/lib.rs

@@ -1,46 +1,40 @@
 use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
 
-use anyhow::{Error, anyhow};
-#[cfg(not(target_arch = "wasm32"))]
-use browser_signer_proxy::prelude::*;
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use common::config_dir;
-use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task, Window};
-use gpui_tokio::Tokio;
-use instant::Duration;
+use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Task, Window};
 use nostr_connect::prelude::*;
 use nostr_gossip_memory::prelude::*;
-#[cfg(not(target_arch = "wasm32"))]
 use nostr_lmdb::prelude::*;
-#[cfg(target_arch = "wasm32")]
-use nostr_memory::prelude::*;
 use nostr_sdk::prelude::*;
 
 mod blossom;
 mod constants;
+mod device;
 mod nip05;
-mod nip4e;
 mod signer;
 
 pub use blossom::*;
 pub use constants::*;
-pub use nip4e::*;
+pub use device::*;
 pub use nip05::*;
-pub use signer::{CoopAuthUrlHandler, UniversalSigner};
+pub use signer::*;
 
-pub fn init(window: &mut Window, cx: &mut App, cli_key: Option<SecretKey>) {
+pub fn init(window: &mut Window, cx: &mut App) {
     // rustls uses the `aws_lc_rs` provider by default
     // This only errors if the default provider has already
     // been installed. We can ignore this `Result`.
-    #[cfg(not(target_arch = "wasm32"))]
     rustls::crypto::aws_lc_rs::default_provider()
         .install_default()
         .ok();
 
     // Initialize the tokio runtime
-    #[cfg(not(target_arch = "wasm32"))]
     gpui_tokio::init(cx);
 
-    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx, cli_key)), cx);
+    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx)), cx);
 }
 
 struct GlobalNostrRegistry(Entity<NostrRegistry>);
@@ -50,24 +44,24 @@ impl Global for GlobalNostrRegistry {}
 /// Signer event.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum StateEvent {
-    /// The state is busy
-    Busy,
-    /// User has no signer
-    NoSigner,
-    /// The signer has changed
-    SignerChanged,
+    /// Connecting to the bootstrapping relay
+    Connecting,
+    /// Connected to the bootstrapping relay
+    Connected,
+    /// Creating the signer
+    Creating,
+    /// Show the identity dialog
+    Show,
+    /// A new signer has been set
+    SignerSet,
     /// An error occurred
-    Error(String),
+    Error(SharedString),
 }
 
 impl StateEvent {
-    pub fn signer_changed(&self) -> bool {
-        matches!(self, StateEvent::SignerChanged)
-    }
-
     pub fn error<T>(error: T) -> Self
     where
-        T: Into<String>,
+        T: Into<SharedString>,
     {
         Self::Error(error.into())
     }
@@ -79,11 +73,19 @@ pub struct NostrRegistry {
     /// Nostr client
     client: Client,
 
-    /// Universal signer
-    signer: UniversalSigner,
+    /// Nostr signer
+    signer: Arc<CoopSigner>,
 
-    /// Current user's public key
-    current_user: Option<PublicKey>,
+    /// All local stored identities
+    npubs: Entity<Vec<PublicKey>>,
+
+    /// Keys directory
+    key_dir: PathBuf,
+
+    /// Master app keys used for various operations.
+    ///
+    /// Example: Nostr Connect and NIP-4e operations
+    app_keys: Keys,
 
     /// Tasks for asynchronous operations
     tasks: Vec<Task<Result<(), Error>>>,
@@ -103,52 +105,59 @@ impl NostrRegistry {
     }
 
     /// Create a new nostr instance
-    fn new(window: &mut Window, cx: &mut Context<Self>, cli_key: Option<SecretKey>) -> Self {
-        let signer = UniversalSigner::new(Keys::generate());
-        let authenticator = SignerAuthenticator::new(signer.clone());
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let key_dir = config_dir().join("keys");
+        let app_keys = get_or_init_app_keys(cx).unwrap_or(Keys::generate());
+
+        // Construct the nostr signer
+        let signer = Arc::new(CoopSigner::new(app_keys.clone()));
+
+        // Get all local stored npubs
+        let npubs = cx.new(|_| match Self::discover(&key_dir) {
+            Ok(npubs) => npubs,
+            Err(e) => {
+                log::error!("Failed to discover npubs: {e}");
+                vec![]
+            }
+        });
 
         // Construct the nostr lmdb instance
-        #[cfg(not(target_arch = "wasm32"))]
-        let database = cx.foreground_executor().block_on(async move {
+        let lmdb = cx.foreground_executor().block_on(async move {
             NostrLmdb::open(config_dir().join("nostr"))
                 .await
                 .expect("Failed to initialize database")
         });
 
-        #[cfg(target_arch = "wasm32")]
-        let database = MemoryDatabase::unbounded();
-
         // Construct the nostr client
         let client = ClientBuilder::default()
-            .database(database)
-            .authenticator(authenticator)
+            .signer(signer.clone())
+            .database(lmdb)
             .gossip(NostrGossipMemory::unbounded())
-            .gossip_config(GossipConfig::default().no_background_refresh())
+            .automatic_authentication(false)
             .connect_timeout(Duration::from_secs(10))
             .sleep_when_idle(SleepWhenIdle::Enabled {
                 timeout: Duration::from_secs(600),
             })
             .build();
 
-        // Connect to bootstrap relays after the window is ready
+        // Run at the end of current cycle
         cx.defer_in(window, |this, _window, cx| {
-            this.connect_bootstrap_relays(cx);
-
-            if cfg!(target_arch = "wasm32") {
-                cx.emit(StateEvent::NoSigner);
-            } else if let Some(secret) = cli_key {
-                // Use CLI-provided key -- same path as get_user_credential
-                let keys = Keys::new(secret);
-                this.set_signer(keys, cx);
+            this.connect(cx);
+            // Create an identity if none exists
+            if this.npubs.read(cx).is_empty() {
+                this.create_identity(cx);
             } else {
-                this.get_user_credential(cx);
+                // Show the identity dialog
+                cx.emit(StateEvent::Show);
             }
         });
 
         Self {
             client,
             signer,
-            current_user: None,
+            npubs,
+            key_dir,
+            app_keys,
             tasks: vec![],
         }
     }
@@ -158,51 +167,61 @@ impl NostrRegistry {
         self.client.clone()
     }
 
-    /// Get the current signer
-    pub fn signer(&self) -> UniversalSigner {
+    /// Get the nostr signer
+    pub fn signer(&self) -> Arc<CoopSigner> {
         self.signer.clone()
     }
 
-    /// Get the current user's public key
-    pub fn current_user(&self) -> Option<PublicKey> {
-        self.current_user
+    /// Get the npubs entity
+    pub fn npubs(&self) -> Entity<Vec<PublicKey>> {
+        self.npubs.clone()
     }
 
-    /// Update the signer
-    pub fn set_signer<T>(&mut self, new_signer: T, cx: &mut Context<Self>)
-    where
-        T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
-        <T as AsyncGetPublicKey>::Error: std::error::Error + Send + Sync + 'static,
-        <T as AsyncSignEvent>::Error: std::error::Error + Send + Sync + 'static,
-        <T as AsyncNip44>::Error: std::error::Error + Send + Sync + 'static,
-    {
-        let task = cx.spawn(async move |this, cx| {
-            match new_signer.get_public_key_async().await {
-                Ok(public_key) => {
-                    this.update(cx, |this, cx| {
-                        this.signer.swap_inner(new_signer);
-                        this.current_user = Some(public_key);
-                        cx.emit(StateEvent::SignerChanged);
-                        cx.notify();
-                    })?;
-                }
-                Err(e) => {
-                    this.update(cx, |_this, cx| {
-                        cx.emit(StateEvent::error(e.to_string()));
-                    })?;
-                }
-            };
+    /// Get the app keys
+    pub fn keys(&self) -> Keys {
+        self.app_keys.clone()
+    }
 
-            Ok(())
-        });
-        self.tasks.push(task);
+    /// Discover all npubs in the keys directory
+    fn discover(dir: &PathBuf) -> Result<Vec<PublicKey>, Error> {
+        // Ensure keys directory exists
+        std::fs::create_dir_all(dir)?;
+
+        let files = std::fs::read_dir(dir)?;
+        let mut entries = Vec::new();
+        let mut npubs: Vec<PublicKey> = Vec::new();
+
+        for file in files.flatten() {
+            let metadata = file.metadata()?;
+            let modified_time = metadata.modified()?;
+            let name = file.file_name().into_string().unwrap().replace(".npub", "");
+            entries.push((modified_time, name));
+        }
+
+        // Sort by modification time (most recent first)
+        entries.sort_by(|a, b| b.0.cmp(&a.0));
+
+        for (_, name) in entries {
+            let public_key = PublicKey::parse(&name)?;
+            npubs.push(public_key);
+        }
+
+        Ok(npubs)
     }
 
     /// Connect to the bootstrapping relays
-    fn connect_bootstrap_relays(&mut self, cx: &mut Context<Self>) {
+    fn connect(&mut self, cx: &mut Context<Self>) {
         let client = self.client();
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            // Add search relay to the relay pool
+            for url in SEARCH_RELAYS.into_iter() {
+                client
+                    .add_relay(url)
+                    .capabilities(RelayCapabilities::READ)
+                    .await?;
+            }
+
             // Add indexer relay to the relay pool
             for url in INDEXER_RELAYS.into_iter() {
                 client
@@ -217,181 +236,345 @@ impl NostrRegistry {
             }
 
             // Connect to all added relays
-            client.connect().await;
+            client
+                .connect()
+                .and_wait(Duration::from_secs(TIMEOUT))
+                .await;
 
             Ok(())
         });
 
+        // Emit connecting event
+        cx.emit(StateEvent::Connecting);
+
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Err(e) = task.await {
                 this.update(cx, |_this, cx| {
                     cx.emit(StateEvent::error(e.to_string()));
                 })?;
-            }
-            Ok(())
-        }));
-    }
-
-    /// Check the user's credential and set the signer if valid
-    fn get_user_credential(&mut self, cx: &mut Context<Self>) {
-        let user_keyring = cx.read_credentials(USER_KEYRING);
-        let master_keyring = self.get_master_key(cx);
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            match user_keyring.await {
-                Ok(Some((_username, secret))) => {
-                    let content = String::from_utf8(secret)?;
-
-                    if content.starts_with("nsec1") {
-                        let secret_key = SecretKey::parse(&content)?;
-                        let keys = Keys::new(secret_key);
-
-                        this.update(cx, |this, cx| {
-                            this.set_signer(keys, cx);
-                            cx.notify();
-                        })?;
-                    } else if content.starts_with("bunker://") {
-                        let keys = master_keyring.await;
-                        let timeout = Duration::from_secs(30);
-                        let uri = NostrConnectUri::parse(content)?;
-
-                        // Construct the nostr connect signer
-                        let mut signer = NostrConnect::new(uri, keys, timeout, None)?;
-
-                        // Handle auth url with the default browser
-                        signer.auth_url_handler(CoopAuthUrlHandler);
-
-                        this.update(cx, |this, cx| {
-                            this.set_signer(signer, cx);
-                            cx.notify();
-                        })?;
-                    } else if content == "proxy" {
-                        #[cfg(not(target_arch = "wasm32"))]
-                        this.update(cx, |this, cx| {
-                            this.connect_proxy(cx);
-                        })?;
-                    }
-                }
-                _ => {
-                    this.update(cx, |_, cx| {
-                        cx.emit(StateEvent::NoSigner);
-                    })?;
-                }
+            } else {
+                this.update(cx, |_this, cx| {
+                    cx.emit(StateEvent::Connected);
+                })?;
             }
 
             Ok(())
         }));
     }
 
-    /// Get the master key that used for Nostr Connect
-    pub fn get_master_key(&self, cx: &App) -> Task<Keys> {
-        if cfg!(target_arch = "wasm32") {
-            return cx.background_spawn(async move { Keys::generate() });
+    /// Get the secret for a given npub.
+    pub fn get_secret(
+        &self,
+        public_key: PublicKey,
+        cx: &App,
+    ) -> Task<Result<Arc<dyn NostrSigner>, Error>> {
+        let npub = public_key.to_bech32().unwrap();
+        let key_path = self.key_dir.join(format!("{}.npub", npub));
+        let app_keys = self.app_keys.clone();
+
+        if let Ok(payload) = std::fs::read_to_string(key_path) {
+            if !payload.is_empty() {
+                cx.background_spawn(async move {
+                    let decrypted = app_keys.nip44_decrypt(&public_key, &payload).await?;
+                    let secret = SecretKey::parse(&decrypted)?;
+                    let keys = Keys::new(secret);
+
+                    Ok(keys.into_nostr_signer())
+                })
+            } else {
+                self.get_secret_keyring(&npub, cx)
+            }
+        } else {
+            self.get_secret_keyring(&npub, cx)
         }
+    }
 
-        let task = cx.read_credentials(MASTER_KEYRING);
+    /// Get the secret for a given npub in the OS credentials store.
+    #[deprecated = "Use get_secret instead"]
+    fn get_secret_keyring(
+        &self,
+        user: &str,
+        cx: &App,
+    ) -> Task<Result<Arc<dyn NostrSigner>, Error>> {
+        let read = cx.read_credentials(user);
+        let app_keys = self.app_keys.clone();
 
-        cx.spawn(async move |cx| {
-            let (keys, new_key) = match task.await {
-                Ok(Some((_user, secret))) => match SecretKey::from_slice(&secret) {
-                    Ok(secret_key) => (Keys::new(secret_key), false),
-                    _ => (Keys::generate(), true),
-                },
-                _ => (Keys::generate(), true),
-            };
+        cx.background_spawn(async move {
+            let (_, secret) = read
+                .await
+                .map_err(|_| anyhow!("Failed to get signer. Please re-import the secret key"))?
+                .ok_or_else(|| anyhow!("Failed to get signer. Please re-import the secret key"))?;
 
-            if new_key {
-                let keys_clone = keys.clone();
-                let username = keys_clone.public_key().to_hex();
-                let password = keys_clone.secret_key().to_secret_bytes();
-
-                cx.update(|cx| {
-                    let task = cx.write_credentials(MASTER_KEYRING, &username, &password);
-                    cx.background_spawn(async move { task.await.ok() }).detach();
-                });
+            // Try to parse as a direct secret key first
+            if let Ok(secret_key) = SecretKey::from_slice(&secret) {
+                return Ok(Keys::new(secret_key).into_nostr_signer());
             }
 
-            keys
+            // Convert the secret into string
+            let sec = String::from_utf8(secret)
+                .map_err(|_| anyhow!("Failed to parse secret as UTF-8"))?;
+
+            // Try to parse as a NIP-46 URI
+            let uri =
+                NostrConnectUri::parse(&sec).map_err(|_| anyhow!("Failed to parse NIP-46 URI"))?;
+
+            let timeout = Duration::from_secs(NOSTR_CONNECT_TIMEOUT);
+            let mut nip46 = NostrConnect::new(uri, app_keys, timeout, None)?;
+
+            // Set the auth URL handler
+            nip46.auth_url_handler(CoopAuthUrlHandler);
+
+            Ok(nip46.into_nostr_signer())
         })
     }
 
-    /// Start the browser proxy
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn connect_proxy(&mut self, cx: &mut Context<Self>) {
-        let proxy = BrowserSignerProxy::new(BrowserSignerProxyOptions::default());
-        let (tx, rx) = flume::bounded::<String>(1);
+    /// Add a new npub to the keys directory
+    fn write_secret(
+        &self,
+        public_key: PublicKey,
+        secret: String,
+        cx: &App,
+    ) -> Task<Result<(), Error>> {
+        let npub = public_key.to_bech32().unwrap();
+        let key_path = self.key_dir.join(format!("{}.npub", npub));
+        let app_keys = self.app_keys.clone();
 
-        self.tasks.push(Tokio::spawn_result(cx, {
-            let proxy = proxy.clone();
-            async move {
-                // Start the proxy and get the web url
-                proxy.start().await?;
-                // Notify GPUI
-                let url = proxy.url();
-                tx.send(url).ok();
-                Ok(())
-            }
-        }));
+        cx.background_spawn(async move {
+            // If the secret starts with "bunker://" (nostr connect), use it directly; otherwise, encrypt it
+            let content = if secret.starts_with("bunker://") {
+                secret
+            } else {
+                app_keys.nip44_encrypt(&public_key, &secret).await?
+            };
 
-        self.tasks.push(Tokio::spawn_result(cx, {
-            let proxy = proxy.clone();
-            async move {
-                loop {
-                    if proxy.is_session_active() {
-                        break;
-                    }
-                    smol::Timer::after(Duration::from_secs(1)).await;
-                }
-                Ok(())
-            }
-        }));
+            // Write the encrypted secret to the keys directory
+            smol::fs::write(key_path, &content).await?;
 
-        self.tasks.push(cx.spawn({
-            let proxy = proxy.clone();
-            async move |this, cx| {
-                while let Ok(url) = rx.recv_async().await {
+            Ok(())
+        })
+    }
+
+    /// Remove a secret
+    pub fn remove_secret(&mut self, public_key: &PublicKey, cx: &mut Context<Self>) {
+        let public_key = public_key.to_owned();
+        let npub = public_key.to_bech32().unwrap();
+
+        let keys_dir = config_dir().join("keys");
+        let key_path = keys_dir.join(format!("{}.npub", npub));
+
+        // Remove the secret file from the keys directory
+        std::fs::remove_file(key_path).ok();
+
+        self.npubs.update(cx, |this, cx| {
+            this.retain(|k| k != &public_key);
+            cx.notify();
+        });
+    }
+
+    /// Create a new identity
+    pub fn create_identity(&mut self, cx: &mut Context<Self>) {
+        let client = self.client();
+        let keys = Keys::generate();
+        let async_keys = keys.clone();
+
+        // Emit creating event
+        cx.emit(StateEvent::Creating);
+
+        // Create the write secret task
+        let write_secret =
+            self.write_secret(keys.public_key(), keys.secret_key().to_secret_hex(), cx);
+
+        // Run async tasks in background
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            let signer = async_keys.into_nostr_signer();
+
+            // Construct relay list event
+            let relay_list = default_relay_list();
+            let event = EventBuilder::relay_list(relay_list).sign(&signer).await?;
+
+            // Publish relay list
+            client
+                .send_event(&event)
+                .to(BOOTSTRAP_RELAYS)
+                .ack_policy(AckPolicy::none())
+                .await?;
+
+            // Construct the default metadata
+            let name = petname::petname(2, "-").unwrap_or("Cooper".to_string());
+            let avatar = Url::parse(&format!("https://avatar.vercel.sh/{name}")).unwrap();
+            let metadata = Metadata::new().display_name(&name).picture(avatar);
+            let event = EventBuilder::metadata(&metadata).sign(&signer).await?;
+
+            // Publish metadata event
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ack_policy(AckPolicy::none())
+                .await?;
+
+            // Construct the default contact list
+            let contacts = vec![Contact::new(PublicKey::parse(COOP_PUBKEY).unwrap())];
+            let event = EventBuilder::contact_list(contacts).sign(&signer).await?;
+
+            // Publish contact list event
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ack_policy(AckPolicy::none())
+                .await?;
+
+            // Construct the default messaging relay list
+            let relays = default_messaging_relays();
+            let event = EventBuilder::nip17_relay_list(relays).sign(&signer).await?;
+
+            // Publish messaging relay list event
+            client.send_event(&event).to_nip65().await?;
+
+            // Write user's credentials to the system keyring
+            write_secret.await?;
+
+            Ok(())
+        });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(_) => {
                     this.update(cx, |this, cx| {
-                        let save = cx.write_credentials(USER_KEYRING, "proxy", b"proxy");
-                        cx.background_spawn(async move { save.await.ok() }).detach();
-                        cx.open_url(&url);
-                        this.set_signer(proxy.clone(), cx);
+                        this.set_signer(keys, cx);
                     })?;
                 }
-                Ok(())
-            }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(StateEvent::error(e.to_string()));
+                    })?;
+                }
+            };
+
+            Ok(())
         }));
+    }
 
-        // Monitor the session, if the browser disconnects, notify user to reconnect
-        self.tasks.push(cx.spawn({
-            let proxy = proxy.clone();
-            let executor = cx.background_executor().clone();
-            async move |this, cx| {
-                // Wait for the signer to be confirmed (timeout is 30s)
-                executor.timer(Duration::from_secs(30)).await;
+    /// Set the signer for the nostr client and verify the public key
+    pub fn set_signer<T>(&mut self, new: T, cx: &mut Context<Self>)
+    where
+        T: NostrSigner + 'static,
+    {
+        let client = self.client();
+        let signer = self.signer();
 
-                loop {
-                    executor.timer(Duration::from_secs(5)).await;
-                    if !proxy.is_session_active() {
-                        _ = this.update(cx, |this, cx| {
-                            // Only notify if this proxy is still the active signer
-                            if this.current_user.is_some() {
-                                this.signer.swap_inner(Keys::generate());
-                                this.current_user = None;
-                                cx.emit(StateEvent::NoSigner);
+        // Create a task to update the signer and verify the public key
+        let task: Task<Result<PublicKey, Error>> = cx.background_spawn(async move {
+            // Update signer and unsubscribe
+            signer.switch(new).await;
+            client.unsubscribe_all().await?;
+
+            // Verify and get public key
+            let signer = client.signer().context("Signer not found")?;
+            let public_key = signer.get_public_key().await?;
+
+            log::info!("Signer's public key: {}", public_key);
+            Ok(public_key)
+        });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok(public_key) => {
+                    this.update(cx, |this, cx| {
+                        // Add public key to npubs if not already present
+                        this.npubs.update(cx, |this, cx| {
+                            if !this.contains(&public_key) {
+                                this.push(public_key);
                                 cx.notify();
                             }
                         });
-                        break;
+
+                        // Emit signer changed event
+                        cx.emit(StateEvent::SignerSet);
+                    })?;
+                }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(StateEvent::error(e.to_string()));
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+
+    /// Add a key signer to keyring
+    pub fn add_key_signer(&mut self, keys: &Keys, cx: &mut Context<Self>) {
+        let keys = keys.clone();
+        let write_secret =
+            self.write_secret(keys.public_key(), keys.secret_key().to_secret_hex(), cx);
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match write_secret.await {
+                Ok(_) => {
+                    this.update(cx, |this, cx| {
+                        this.set_signer(keys, cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(StateEvent::error(e.to_string()));
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+
+    /// Add a nostr connect signer to keyring
+    pub fn add_nip46_signer(&mut self, nip46: &NostrConnect, cx: &mut Context<Self>) {
+        let nip46 = nip46.clone();
+        let async_nip46 = nip46.clone();
+
+        // Connect and verify the remote signer
+        let task: Task<Result<(PublicKey, NostrConnectUri), Error>> =
+            cx.background_spawn(async move {
+                let uri = async_nip46.bunker_uri().await?;
+                let public_key = async_nip46.get_public_key().await?;
+
+                Ok((public_key, uri))
+            });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            match task.await {
+                Ok((public_key, uri)) => {
+                    // Create the write secret task
+                    let write_secret = this.read_with(cx, |this, cx| {
+                        this.write_secret(public_key, uri.to_string(), cx)
+                    })?;
+
+                    match write_secret.await {
+                        Ok(_) => {
+                            this.update(cx, |this, cx| {
+                                this.set_signer(nip46, cx);
+                            })?;
+                        }
+                        Err(e) => {
+                            this.update(cx, |_this, cx| {
+                                cx.emit(StateEvent::error(e.to_string()));
+                            })?;
+                        }
                     }
                 }
+                Err(e) => {
+                    this.update(cx, |_this, cx| {
+                        cx.emit(StateEvent::error(e.to_string()));
+                    })?;
+                }
+            };
 
-                Ok(())
-            }
+            Ok(())
         }));
     }
 
     /// Get the public key of a NIP-05 address
-    pub fn query_address(&self, addr: Nip05Address, cx: &App) -> Task<Result<PublicKey, Error>> {
+    pub fn get_address(&self, addr: Nip05Address, cx: &App) -> Task<Result<PublicKey, Error>> {
         let client = self.client();
         let http_client = cx.http_client();
 
@@ -428,7 +611,7 @@ impl NostrRegistry {
 
         // Get the address task if the query is a valid NIP-05 address
         let address_task = if let Ok(addr) = Nip05Address::parse(&query) {
-            Some(self.query_address(addr, cx))
+            Some(self.get_address(addr, cx))
         } else {
             None
         };
@@ -444,18 +627,6 @@ impl NostrRegistry {
                 return Ok(results);
             }
 
-            // Add search relay to the relay pool
-            for url in SEARCH_RELAYS.into_iter() {
-                if client.relay(url).await.is_ok() {
-                    client
-                        .add_relay(url)
-                        .capabilities(RelayCapabilities::READ)
-                        .await?;
-                } else {
-                    return Err(anyhow!("Failed to add search relay: {}", url));
-                }
-            }
-
             // Return early if the query is a valid public key
             if let Ok(public_key) = PublicKey::parse(&query) {
                 results.push(public_key);
@@ -499,17 +670,14 @@ impl NostrRegistry {
     pub fn wot_search(&self, query: &str, cx: &App) -> Task<Result<Vec<PublicKey>, Error>> {
         let client = self.client();
         let query = query.to_string();
-        let signer = self.signer.clone();
 
         cx.background_spawn(async move {
             // Construct a vertex request event
-            let event = EventBuilder::new(Kind::Custom(5315), "")
-                .tags(vec![
-                    Tag::custom("param", vec!["search", &query]),
-                    Tag::custom("param", vec!["limit", "10"]),
-                ])
-                .finalize_async(&signer)
-                .await?;
+            let builder = EventBuilder::new(Kind::Custom(5315), "").tags(vec![
+                Tag::custom(TagKind::custom("param"), vec!["search", &query]),
+                Tag::custom(TagKind::custom("param"), vec!["limit", "10"]),
+            ]);
+            let event = client.sign_event_builder(builder).await?;
 
             // Send the event to vertex relays
             let output = client.send_event(&event).to(WOT_RELAYS).await?;
@@ -559,3 +727,78 @@ impl NostrRegistry {
         })
     }
 }
+
+/// Get or create new app keys
+fn get_or_init_app_keys(cx: &App) -> Result<Keys, Error> {
+    let read = cx.read_credentials(CLIENT_NAME);
+    let stored_keys: Option<Keys> = cx.foreground_executor().block_on(async move {
+        if let Ok(Some((_, secret))) = read.await {
+            SecretKey::from_slice(&secret).map(Keys::new).ok()
+        } else {
+            None
+        }
+    });
+
+    if let Some(keys) = stored_keys {
+        Ok(keys)
+    } else {
+        let keys = Keys::generate();
+        let user = keys.public_key().to_hex();
+        let secret = keys.secret_key().to_secret_bytes();
+        let write = cx.write_credentials(CLIENT_NAME, &user, &secret);
+
+        cx.foreground_executor().block_on(async move {
+            if let Err(e) = write.await {
+                log::error!("Keyring not available or panic: {e}")
+            }
+        });
+
+        Ok(keys)
+    }
+}
+
+fn default_relay_list() -> Vec<(RelayUrl, Option<RelayMetadata>)> {
+    vec![
+        (
+            RelayUrl::parse("wss://relay.nostr.net").unwrap(),
+            Some(RelayMetadata::Write),
+        ),
+        (
+            RelayUrl::parse("wss://relay.primal.net").unwrap(),
+            Some(RelayMetadata::Write),
+        ),
+        (
+            RelayUrl::parse("wss://relay.damus.io").unwrap(),
+            Some(RelayMetadata::Read),
+        ),
+        (
+            RelayUrl::parse("wss://nos.lol").unwrap(),
+            Some(RelayMetadata::Read),
+        ),
+        (
+            RelayUrl::parse("wss://nostr.superfriends.online").unwrap(),
+            None,
+        ),
+    ]
+}
+
+fn default_messaging_relays() -> Vec<RelayUrl> {
+    vec![
+        RelayUrl::parse("wss://nos.lol").unwrap(),
+        RelayUrl::parse("wss://nip17.com").unwrap(),
+        RelayUrl::parse("wss://auth.nostr1.com").unwrap(),
+    ]
+}
+
+#[derive(Debug, Clone)]
+pub struct CoopAuthUrlHandler;
+
+impl AuthUrlHandler for CoopAuthUrlHandler {
+    #[allow(mismatched_lifetime_syntaxes)]
+    fn on_auth_url(&self, auth_url: Url) -> BoxedFuture<Result<()>> {
+        Box::pin(async move {
+            webbrowser::open(auth_url.as_str())?;
+            Ok(())
+        })
+    }
+}

crates/state/src/nip05.rs

@@ -1,10 +1,9 @@
 use std::sync::Arc;
 
 use anyhow::Error;
-use futures::io::AsyncReadExt;
 use gpui::http_client::{AsyncBody, HttpClient};
 use nostr_sdk::prelude::*;
-use serde_json::Value;
+use smol::io::AsyncReadExt;
 
 #[allow(async_fn_in_trait)]
 pub trait NostrAddress {

crates/state/src/signer.rs

@@ -1,206 +1,134 @@
-use std::error::Error;
-use std::fmt;
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::{Arc, RwLock};
+use std::borrow::Cow;
+use std::result::Result;
+use std::sync::Arc;
 
-use nostr_connect::client::AuthUrlHandler;
 use nostr_sdk::prelude::*;
+use smol::lock::RwLock;
 
 #[derive(Debug)]
-pub struct UniversalSignerError(Box<dyn Error + Send + Sync + 'static>);
+pub struct CoopSigner {
+    /// User's signer
+    signer: RwLock<Arc<dyn NostrSigner>>,
 
-impl fmt::Display for UniversalSignerError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
+    /// User's signer public key
+    signer_pkey: RwLock<Option<PublicKey>>,
+
+    /// Specific signer for encryption purposes
+    encryption_signer: RwLock<Option<Arc<dyn NostrSigner>>>,
 }
 
-impl Error for UniversalSignerError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(&*self.0)
-    }
-}
-
-impl UniversalSignerError {
-    pub fn new<E>(err: E) -> Self
-    where
-        E: Error + Send + Sync + 'static,
-    {
-        UniversalSignerError(Box::new(err))
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct UniversalSigner {
-    inner: Arc<RwLock<Arc<dyn InnerSigner>>>,
-}
-
-impl UniversalSigner {
+impl CoopSigner {
     pub fn new<T>(signer: T) -> Self
     where
-        T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
-        <T as AsyncGetPublicKey>::Error: Error + Send + Sync + 'static,
-        <T as AsyncSignEvent>::Error: Error + Send + Sync + 'static,
-        <T as AsyncNip44>::Error: Error + Send + Sync + 'static,
+        T: IntoNostrSigner,
     {
         Self {
-            inner: Arc::new(RwLock::new(Arc::new(InnerSignerImpl(signer)))),
+            signer: RwLock::new(signer.into_nostr_signer()),
+            signer_pkey: RwLock::new(None),
+            encryption_signer: RwLock::new(None),
         }
     }
 
-    /// Swap the inner signer in-place. All clones see the new signer.
-    pub fn swap_inner<T>(&self, new_signer: T)
+    /// Get the current signer.
+    pub async fn get(&self) -> Arc<dyn NostrSigner> {
+        self.signer.read().await.clone()
+    }
+
+    /// Get the encryption signer.
+    pub async fn get_encryption_signer(&self) -> Option<Arc<dyn NostrSigner>> {
+        self.encryption_signer.read().await.clone()
+    }
+
+    /// 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()
+    }
+
+    /// Switch the current signer to a new signer.
+    pub async fn switch<T>(&self, new: T)
     where
-        T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
-        <T as AsyncGetPublicKey>::Error: Error + Send + Sync + 'static,
-        <T as AsyncSignEvent>::Error: Error + Send + Sync + 'static,
-        <T as AsyncNip44>::Error: Error + Send + Sync + 'static,
+        T: IntoNostrSigner,
     {
-        *self.inner.write().expect("RwLock poisoned") = Arc::new(InnerSignerImpl(new_signer));
+        let new_signer = new.into_nostr_signer();
+        let public_key = new_signer.get_public_key().await.ok();
+        let mut signer = self.signer.write().await;
+        let mut signer_pkey = self.signer_pkey.write().await;
+        let mut encryption_signer = self.encryption_signer.write().await;
+
+        // Switch to the new signer
+        *signer = new_signer;
+
+        // Update the public key
+        *signer_pkey = public_key;
+
+        // Reset the encryption signer
+        *encryption_signer = None;
+    }
+
+    /// Set the encryption signer.
+    pub async fn set_encryption_signer<T>(&self, new: T)
+    where
+        T: IntoNostrSigner,
+    {
+        let mut encryption_signer = self.encryption_signer.write().await;
+        *encryption_signer = Some(new.into_nostr_signer());
     }
 }
 
-trait InnerSigner: fmt::Debug + Send + Sync + 'static {
-    fn get_public_key_async(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>>;
-    fn sign_event_async(
-        &self,
+impl NostrSigner for CoopSigner {
+    #[allow(mismatched_lifetime_syntaxes)]
+    fn backend(&self) -> SignerBackend {
+        SignerBackend::Custom(Cow::Borrowed("custom"))
+    }
+
+    fn get_public_key<'a>(&'a self) -> BoxedFuture<'a, Result<PublicKey, SignerError>> {
+        Box::pin(async move { self.get().await.get_public_key().await })
+    }
+
+    fn sign_event<'a>(
+        &'a self,
         unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>>;
-    fn nip44_encrypt_async<'a>(
+    ) -> BoxedFuture<'a, Result<Event, SignerError>> {
+        Box::pin(async move { self.get().await.sign_event(unsigned).await })
+    }
+
+    fn nip04_encrypt<'a>(
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
-    fn nip44_decrypt_async<'a>(
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip04_encrypt(public_key, content).await })
+    }
+
+    fn nip04_decrypt<'a>(
         &'a self,
         public_key: &'a PublicKey,
-        payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
-}
-
-#[derive(Debug)]
-struct InnerSignerImpl<T>(T);
-
-impl<T> InnerSigner for InnerSignerImpl<T>
-where
-    T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + Send + Sync + 'static,
-    <T as AsyncGetPublicKey>::Error: Error + Send + Sync + 'static,
-    <T as AsyncSignEvent>::Error: Error + Send + Sync + 'static,
-    <T as AsyncNip44>::Error: Error + Send + Sync + 'static,
-{
-    fn get_public_key_async(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>> {
+        encrypted_content: &'a str,
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
         Box::pin(async move {
-            AsyncGetPublicKey::get_public_key_async(&self.0)
+            self.get()
+                .await
+                .nip04_decrypt(public_key, encrypted_content)
                 .await
-                .map_err(UniversalSignerError::new)
         })
     }
 
-    fn sign_event_async(
-        &self,
-        unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>> {
-        Box::pin(async move {
-            AsyncSignEvent::sign_event_async(&self.0, unsigned)
-                .await
-                .map_err(UniversalSignerError::new)
-        })
-    }
-
-    fn nip44_encrypt_async<'a>(
+    fn nip44_encrypt<'a>(
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
-        Box::pin(async move {
-            AsyncNip44::nip44_encrypt_async(&self.0, public_key, content)
-                .await
-                .map_err(UniversalSignerError::new)
-        })
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip44_encrypt(public_key, content).await })
     }
 
-    fn nip44_decrypt_async<'a>(
+    fn nip44_decrypt<'a>(
         &'a self,
         public_key: &'a PublicKey,
         payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
-        Box::pin(async move {
-            AsyncNip44::nip44_decrypt_async(&self.0, public_key, payload)
-                .await
-                .map_err(UniversalSignerError::new)
-        })
-    }
-}
-
-impl UniversalSigner {
-    #[allow(dead_code)]
-    fn with_inner<R>(&self, f: impl FnOnce(&dyn InnerSigner) -> R) -> R {
-        let guard = self.inner.read().expect("RwLock poisoned");
-        f(&**guard)
-    }
-}
-
-impl AsyncGetPublicKey for UniversalSigner {
-    type Error = UniversalSignerError;
-
-    fn get_public_key_async(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, Self::Error>> + Send + '_>> {
-        let inner = self.inner.read().expect("RwLock poisoned").clone();
-        Box::pin(async move { inner.get_public_key_async().await })
-    }
-}
-
-impl AsyncSignEvent for UniversalSigner {
-    type Error = UniversalSignerError;
-
-    fn sign_event_async(
-        &self,
-        unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, Self::Error>> + Send + '_>> {
-        let inner = self.inner.read().expect("RwLock poisoned").clone();
-        Box::pin(async move { inner.sign_event_async(unsigned).await })
-    }
-}
-
-impl AsyncNip44 for UniversalSigner {
-    type Error = UniversalSignerError;
-
-    fn nip44_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        let inner = self.inner.read().expect("RwLock poisoned").clone();
-        Box::pin(async move { inner.nip44_encrypt_async(public_key, content).await })
-    }
-
-    fn nip44_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        let inner = self.inner.read().expect("RwLock poisoned").clone();
-        Box::pin(async move { inner.nip44_decrypt_async(public_key, payload).await })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CoopAuthUrlHandler;
-
-impl AuthUrlHandler for CoopAuthUrlHandler {
-    fn on_auth_url(
-        &self,
-        auth_url: Url,
-    ) -> Pin<Box<dyn Future<Output = Result<(), nostr_connect::error::Error>> + Send + '_>> {
-        Box::pin(async move {
-            webbrowser::open(auth_url.as_str()).unwrap();
-            Ok(())
-        })
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip44_decrypt(public_key, payload).await })
     }
 }

crates/theme/src/colors.rs

@@ -112,7 +112,7 @@ impl ThemeColors {
             elevated_surface_background: neutral().light().step_3(),
             panel_background: neutral().light().step_1(),
             overlay: neutral().light_alpha().step_3(),
-            title_bar: neutral().light().step_2(),
+            title_bar: neutral().light().step_3(),
             title_bar_inactive: neutral().light().step_1(),
             window_border: hsl(240.0, 5.9, 78.0),
 
@@ -198,7 +198,7 @@ impl ThemeColors {
             elevated_surface_background: neutral().dark().step_3(),
             panel_background: neutral().dark().step_1(),
             overlay: neutral().dark_alpha().step_3(),
-            title_bar: neutral().dark().step_2(),
+            title_bar: neutral().dark().step_3(),
             title_bar_inactive: neutral().dark().step_1(),
             window_border: hsl(240.0, 3.7, 28.0),
 

crates/theme/src/geometry.rs

@@ -1,6 +1,6 @@
 use std::fmt::{self, Debug, Display, Formatter};
 
-use gpui::{AbsoluteLength, Axis, Length, Pixels};
+use gpui::{AbsoluteLength, Axis, Corner, Length, Pixels};
 use serde::{Deserialize, Serialize};
 
 /// A enum for defining the placement of the element.
@@ -49,6 +49,141 @@ impl Placement {
     }
 }
 
+/// 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 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.

crates/theme/src/lib.rs

@@ -34,7 +34,7 @@ pub const CLIENT_SIDE_DECORATION_BORDER: Pixels = px(1.0);
 pub const TITLEBAR_HEIGHT: Pixels = px(36.0);
 
 /// Defines workspace tabbar height
-pub const TABBAR_HEIGHT: Pixels = px(44.0);
+pub const TABBAR_HEIGHT: Pixels = px(28.0);
 
 /// Defines default sidebar width
 pub const SIDEBAR_WIDTH: Pixels = px(240.);
@@ -192,6 +192,7 @@ impl From<ThemeFamily> for Theme {
         let mode = ThemeMode::default();
 
         // Define the font family based on the platform.
+        // TODO: Use native fonts on Linux too.
         let font_family = match platform {
             PlatformKind::Linux => "Inter",
             _ => ".SystemUIFont",

crates/theme/src/notification.rs

@@ -1,9 +1,10 @@
-use gpui::{Anchor, Pixels, px};
+use gpui::{Pixels, px};
+use serde::{Deserialize, Serialize};
 
-use crate::{Edges, TITLEBAR_HEIGHT};
+use crate::{Anchor, Edges, TITLEBAR_HEIGHT};
 
 /// The settings for notifications.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct NotificationSettings {
     /// The placement of the notification, default: [`Anchor::TopRight`]
     pub placement: Anchor,

crates/theme/src/platform_kind.rs

@@ -3,7 +3,6 @@ pub enum PlatformKind {
     Mac,
     Linux,
     Windows,
-    Web,
 }
 
 impl PlatformKind {
@@ -12,21 +11,22 @@ impl PlatformKind {
             Self::Linux
         } else if cfg!(target_os = "windows") {
             Self::Windows
-        } else if cfg!(target_os = "macos") {
-            Self::Mac
         } else {
-            Self::Web
+            Self::Mac
         }
     }
 
+    #[allow(dead_code)]
     pub fn is_linux(&self) -> bool {
         matches!(self, Self::Linux)
     }
 
+    #[allow(dead_code)]
     pub fn is_windows(&self) -> bool {
         matches!(self, Self::Windows)
     }
 
+    #[allow(dead_code)]
     pub fn is_mac(&self) -> bool {
         matches!(self, Self::Mac)
     }

crates/title_bar/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "title_bar"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+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
+
+[target.'cfg(target_os = "windows")'.dependencies]
+windows = { version = "0.61", features = ["Wdk_System_SystemServices"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+linicon = "2.3.0"

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/title_bar/src/platforms/linux.rs

@@ -0,0 +1,227 @@
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    svg, Action, App, InteractiveElement, IntoElement, MouseButton, ParentElement, RenderOnce,
+    SharedString, StatefulInteractiveElement, Styled, Window,
+};
+use linicon::{lookup_icon, IconType};
+use theme::ActiveTheme;
+use ui::{h_flex, Icon, IconName, Sizable};
+
+#[derive(IntoElement)]
+pub struct LinuxWindowControls {
+    close_window_action: Option<Box<dyn Action>>,
+}
+
+impl LinuxWindowControls {
+    pub fn new(close_window_action: Option<Box<dyn Action>>) -> Self {
+        Self {
+            close_window_action,
+        }
+    }
+}
+
+impl RenderOnce for LinuxWindowControls {
+    fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement {
+        let supported_controls = window.window_controls();
+
+        h_flex()
+            .id("linux-window-controls")
+            .gap_2()
+            .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
+            .when(supported_controls.minimize, |this| {
+                this.child(WindowControl::new(
+                    LinuxControl::Minimize,
+                    IconName::WindowMinimize,
+                ))
+            })
+            .when(supported_controls.maximize, |this| {
+                this.child({
+                    if window.is_maximized() {
+                        WindowControl::new(LinuxControl::Restore, IconName::WindowRestore)
+                    } else {
+                        WindowControl::new(LinuxControl::Maximize, IconName::WindowMaximize)
+                    }
+                })
+            })
+            .child(
+                WindowControl::new(LinuxControl::Close, IconName::WindowClose)
+                    .when_some(self.close_window_action, |this, close_action| {
+                        this.close_action(close_action)
+                    }),
+            )
+    }
+}
+
+#[derive(IntoElement)]
+pub struct WindowControl {
+    kind: LinuxControl,
+    fallback: IconName,
+    close_action: Option<Box<dyn Action>>,
+}
+
+impl WindowControl {
+    pub fn new(kind: LinuxControl, fallback: IconName) -> Self {
+        Self {
+            kind,
+            fallback,
+            close_action: None,
+        }
+    }
+
+    pub fn close_action(mut self, action: Box<dyn Action>) -> Self {
+        self.close_action = Some(action);
+        self
+    }
+
+    pub fn is_gnome(&self) -> bool {
+        matches!(detect_desktop_environment(), DesktopEnvironment::Gnome)
+    }
+}
+
+impl RenderOnce for WindowControl {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let is_gnome = self.is_gnome();
+
+        h_flex()
+            .id(self.kind.as_icon_name())
+            .group("")
+            .justify_center()
+            .items_center()
+            .rounded_full()
+            .size_6()
+            .when(is_gnome, |this| {
+                this.bg(cx.theme().ghost_element_background_alt)
+                    .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                    .active(|this| this.bg(cx.theme().ghost_element_active))
+            })
+            .map(|this| {
+                if let Some(Some(path)) = linux_controls().get(&self.kind).cloned() {
+                    this.child(
+                        svg()
+                            .external_path(SharedString::from(path))
+                            .size_4()
+                            .text_color(cx.theme().text),
+                    )
+                } else {
+                    this.child(Icon::new(self.fallback).small().text_color(cx.theme().text))
+                }
+            })
+            .on_mouse_move(|_, _window, cx| cx.stop_propagation())
+            .on_click(move |_, window, cx| {
+                cx.stop_propagation();
+                match self.kind {
+                    LinuxControl::Minimize => window.minimize_window(),
+                    LinuxControl::Restore => window.zoom_window(),
+                    LinuxControl::Maximize => window.zoom_window(),
+                    LinuxControl::Close => cx.quit(),
+                }
+            })
+    }
+}
+
+static DE: OnceLock<DesktopEnvironment> = OnceLock::new();
+static LINUX_CONTROLS: OnceLock<HashMap<LinuxControl, Option<String>>> = OnceLock::new();
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DesktopEnvironment {
+    Gnome,
+    Kde,
+    Unknown,
+}
+
+/// Detect the current desktop environment
+pub fn detect_desktop_environment() -> &'static DesktopEnvironment {
+    DE.get_or_init(|| {
+        // Try to use environment variables first
+        if let Ok(output) = std::env::var("XDG_CURRENT_DESKTOP") {
+            let desktop = output.to_lowercase();
+            if desktop.contains("gnome") {
+                return DesktopEnvironment::Gnome;
+            } else if desktop.contains("kde") {
+                return DesktopEnvironment::Kde;
+            }
+        }
+
+        // Fallback detection methods
+        if let Ok(output) = std::env::var("DESKTOP_SESSION") {
+            let session = output.to_lowercase();
+            if session.contains("gnome") {
+                return DesktopEnvironment::Gnome;
+            } else if session.contains("kde") || session.contains("plasma") {
+                return DesktopEnvironment::Kde;
+            }
+        }
+
+        DesktopEnvironment::Unknown
+    })
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+pub enum LinuxControl {
+    Minimize,
+    Restore,
+    Maximize,
+    Close,
+}
+
+impl LinuxControl {
+    pub fn as_icon_name(&self) -> &'static str {
+        match self {
+            LinuxControl::Close => "window-close",
+            LinuxControl::Minimize => "window-minimize",
+            LinuxControl::Maximize => "window-maximize",
+            LinuxControl::Restore => "window-restore",
+        }
+    }
+}
+
+fn linux_controls() -> &'static HashMap<LinuxControl, Option<String>> {
+    LINUX_CONTROLS.get_or_init(|| {
+        let mut icons = HashMap::new();
+        icons.insert(LinuxControl::Close, None);
+        icons.insert(LinuxControl::Minimize, None);
+        icons.insert(LinuxControl::Maximize, None);
+        icons.insert(LinuxControl::Restore, None);
+
+        let icon_names = [
+            (LinuxControl::Close, vec!["window-close", "dialog-close"]),
+            (
+                LinuxControl::Minimize,
+                vec!["window-minimize", "window-lower"],
+            ),
+            (
+                LinuxControl::Maximize,
+                vec!["window-maximize", "window-expand"],
+            ),
+            (
+                LinuxControl::Restore,
+                vec!["window-restore", "window-return"],
+            ),
+        ];
+
+        for (control, icon_names) in icon_names {
+            for icon_name in icon_names {
+                // Try GNOME-style naming first
+                let mut control_icon = lookup_icon(format!("{icon_name}-symbolic"))
+                    .find(|icon| matches!(icon, Ok(icon) if icon.icon_type == IconType::SVG));
+
+                // If not found, try KDE-style naming
+                if control_icon.is_none() {
+                    control_icon = lookup_icon(icon_name)
+                        .find(|icon| matches!(icon, Ok(icon) if icon.icon_type == IconType::SVG));
+                }
+
+                if let Some(Ok(icon)) = control_icon {
+                    icons
+                        .entry(control)
+                        .and_modify(|v| *v = Some(icon.path.to_string_lossy().to_string()));
+                }
+            }
+        }
+
+        icons
+    })
+}

crates/title_bar/src/platforms/mac.rs

@@ -0,0 +1,6 @@
+/// Use pixels here instead of a rem-based size because the macOS traffic
+/// lights are a static size, and don't scale with the rest of the UI.
+///
+/// Magic number: There is one extra pixel of padding on the left side due to
+/// the 1px border around the window on macOS apps.
+pub const TRAFFIC_LIGHT_PADDING: f32 = 80.;

crates/title_bar/src/platforms/mod.rs

@@ -0,0 +1,4 @@
+#[cfg(target_os = "linux")]
+pub mod linux;
+pub mod mac;
+pub mod windows;

crates/title_bar/src/platforms/windows.rs

@@ -0,0 +1,147 @@
+use gpui::prelude::FluentBuilder;
+use gpui::{
+    div, px, App, ElementId, Hsla, InteractiveElement, IntoElement, ParentElement, Pixels,
+    RenderOnce, Rgba, StatefulInteractiveElement, Styled, Window, WindowControlArea,
+};
+use theme::ActiveTheme;
+use ui::h_flex;
+
+#[derive(IntoElement)]
+pub struct WindowsWindowControls {
+    button_height: Pixels,
+}
+
+impl WindowsWindowControls {
+    pub fn new(button_height: Pixels) -> Self {
+        Self { button_height }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn get_font() -> &'static str {
+        "Segoe Fluent Icons"
+    }
+
+    #[cfg(target_os = "windows")]
+    fn get_font() -> &'static str {
+        use windows::Wdk::System::SystemServices::RtlGetVersion;
+
+        let mut version = unsafe { std::mem::zeroed() };
+        let status = unsafe { RtlGetVersion(&mut version) };
+
+        if status.is_ok() && version.dwBuildNumber >= 22000 {
+            "Segoe Fluent Icons"
+        } else {
+            "Segoe MDL2 Assets"
+        }
+    }
+}
+
+impl RenderOnce for WindowsWindowControls {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let close_button_hover_color = Rgba {
+            r: 232.0 / 255.0,
+            g: 17.0 / 255.0,
+            b: 32.0 / 255.0,
+            a: 1.0,
+        };
+
+        let button_hover_color = cx.theme().ghost_element_hover;
+        let button_active_color = cx.theme().ghost_element_active;
+
+        div()
+            .id("windows-window-controls")
+            .font_family(Self::get_font())
+            .flex()
+            .flex_row()
+            .justify_center()
+            .content_stretch()
+            .max_h(self.button_height)
+            .min_h(self.button_height)
+            .child(WindowsCaptionButton::new(
+                "minimize",
+                WindowsCaptionButtonIcon::Minimize,
+                button_hover_color,
+                button_active_color,
+            ))
+            .child(WindowsCaptionButton::new(
+                "maximize-or-restore",
+                if window.is_maximized() {
+                    WindowsCaptionButtonIcon::Restore
+                } else {
+                    WindowsCaptionButtonIcon::Maximize
+                },
+                button_hover_color,
+                button_active_color,
+            ))
+            .child(WindowsCaptionButton::new(
+                "close",
+                WindowsCaptionButtonIcon::Close,
+                close_button_hover_color,
+                button_active_color,
+            ))
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+enum WindowsCaptionButtonIcon {
+    Minimize,
+    Restore,
+    Maximize,
+    Close,
+}
+
+#[derive(IntoElement)]
+struct WindowsCaptionButton {
+    id: ElementId,
+    icon: WindowsCaptionButtonIcon,
+    hover_background_color: Hsla,
+    active_background_color: Hsla,
+}
+
+impl WindowsCaptionButton {
+    pub fn new(
+        id: impl Into<ElementId>,
+        icon: WindowsCaptionButtonIcon,
+        hover_background_color: impl Into<Hsla>,
+        active_background_color: impl Into<Hsla>,
+    ) -> Self {
+        Self {
+            id: id.into(),
+            icon,
+            hover_background_color: hover_background_color.into(),
+            active_background_color: active_background_color.into(),
+        }
+    }
+}
+
+impl RenderOnce for WindowsCaptionButton {
+    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
+        h_flex()
+            .id(self.id)
+            .justify_center()
+            .content_center()
+            .occlude()
+            .w(px(36.))
+            .h_full()
+            .text_size(px(10.0))
+            .hover(|style| style.bg(self.hover_background_color))
+            .active(|style| style.bg(self.active_background_color))
+            .map(|this| match self.icon {
+                WindowsCaptionButtonIcon::Close => {
+                    this.window_control_area(WindowControlArea::Close)
+                }
+                WindowsCaptionButtonIcon::Maximize | WindowsCaptionButtonIcon::Restore => {
+                    this.window_control_area(WindowControlArea::Max)
+                }
+                WindowsCaptionButtonIcon::Minimize => {
+                    this.window_control_area(WindowControlArea::Min)
+                }
+            })
+            .child(match self.icon {
+                WindowsCaptionButtonIcon::Minimize => "\u{e921}",
+                WindowsCaptionButtonIcon::Restore => "\u{e923}",
+                WindowsCaptionButtonIcon::Maximize => "\u{e922}",
+                WindowsCaptionButtonIcon::Close => "\u{e8bb}",
+            })
+    }
+}

crates/ui/Cargo.toml

@@ -9,8 +9,9 @@ common = { path = "../common" }
 theme = { path = "../theme" }
 
 gpui.workspace = true
-instant.workspace = true
+smol.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 smallvec.workspace = true
 anyhow.workspace = true
 itertools.workspace = true
@@ -19,10 +20,7 @@ log.workspace = true
 unicode-segmentation = "1.12.0"
 uuid = "1.10"
 regex = "1"
+image = "0.25.1"
 lsp-types = "0.97.0"
-ropey = { version = "=2.0.0-beta.1", features = ["metric_lines_lf", "metric_utf16"] }
+rope = { git = "https://github.com/zed-industries/zed" }
 sum_tree = { git = "https://github.com/zed-industries/zed" }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-smol.workspace = true
-tree-sitter = "0.26"

crates/ui/LICENSE

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

@@ -0,0 +1,332 @@
+//! 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::{
+    AnyElement, App, Axis, Bounds, Display, Edges, Element, GlobalElementId, Half,
+    InspectorElementId, IntoElement, LayoutId, ParentElement, Pixels, Point, Position, Size, Style,
+    Window, point, px,
+};
+use smallvec::SmallVec;
+use theme::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,8 +1,8 @@
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AbsoluteLength, App, Div, Hsla, ImageSource, Img, InteractiveElement, Interactivity,
-    IntoElement, ObjectFit, ParentElement, RenderOnce, StyleRefinement, Styled, StyledImage,
-    Window, div, img, px,
+    IntoElement, ParentElement, RenderOnce, StyleRefinement, Styled, StyledImage, Window, div, img,
+    px,
 };
 use theme::ActiveTheme;
 
@@ -26,7 +26,9 @@ pub(super) fn avatar_size(size: Size) -> AbsoluteLength {
 /// ```
 /// use ui::{Avatar};
 ///
-/// Avatar::new("path/to/image.png").grayscale(true).border_color(gpui::red());
+/// Avatar::new("path/to/image.png")
+///     .grayscale(true)
+///     .border_color(gpui::red());
 /// ```
 #[derive(IntoElement)]
 pub struct Avatar {
@@ -128,7 +130,7 @@ impl RenderOnce for Avatar {
                 self.image
                     .size(image_size)
                     .rounded_full()
-                    .object_fit(ObjectFit::Cover)
+                    .object_fit(gpui::ObjectFit::Fill)
                     .bg(cx.theme().ghost_element_background)
                     .with_fallback(move || {
                         img("brand/avatar.png")

crates/ui/src/button.rs

@@ -2,15 +2,15 @@ use std::rc::Rc;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    AnyElement, App, ClickEvent, Div, ElementId, Hsla, InteractiveElement, IntoElement,
-    ParentElement, RenderOnce, SharedString, Stateful, StatefulInteractiveElement as _,
-    StyleRefinement, Styled, Window, div, relative,
+    div, relative, AnyElement, App, ClickEvent, Div, ElementId, Hsla, InteractiveElement,
+    IntoElement, ParentElement, RenderOnce, SharedString, Stateful,
+    StatefulInteractiveElement as _, StyleRefinement, Styled, Window,
 };
 use theme::ActiveTheme;
 
 use crate::indicator::Indicator;
 use crate::tooltip::Tooltip;
-use crate::{Disableable, Icon, IconName, Selectable, Sizable, Size, StyledExt, h_flex};
+use crate::{h_flex, Disableable, Icon, IconName, Selectable, Sizable, Size, StyledExt};
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct ButtonCustomVariant {
@@ -617,7 +617,7 @@ impl ButtonVariant {
         };
 
         let fg = match self {
-            ButtonVariant::Primary => cx.theme().text_muted,
+            ButtonVariant::Primary => cx.theme().text_muted, // TODO: use a different color?
             _ => cx.theme().text_muted,
         };
 

crates/ui/src/checkbox.rs

@@ -1,5 +1,5 @@
 use std::rc::Rc;
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{

crates/ui/src/dock/dock.rs

@@ -214,8 +214,6 @@ impl Dock {
     pub fn set_open(&mut self, open: bool, window: &mut Window, cx: &mut Context<Self>) {
         self.open = open;
         let item = self.panel.clone();
-        // Use defer_in (not window.defer) so the callback is cancelled
-        // if this Dock entity is dropped before the deferred frame runs.
         cx.defer_in(window, move |_, window, cx| {
             item.set_collapsed(!open, window, cx);
         });

crates/ui/src/dock/mod.rs

@@ -2,10 +2,11 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    AnyElement, AnyView, App, AppContext, Axis, Bounds, Context, Edges, Entity, EntityId,
-    EventEmitter, Focusable, InteractiveElement as _, IntoElement, ParentElement as _, Pixels,
-    Render, SharedString, Styled, Subscription, WeakEntity, Window, actions, div, px,
+    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, actions, div, px,
 };
+use theme::CLIENT_SIDE_DECORATION_ROUNDING;
 
 use crate::ElementExt;
 
@@ -109,8 +110,15 @@ impl DockItem {
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
+        let mut items = items;
+
         let stack_panel = cx.new(|cx| {
             let mut stack_panel = StackPanel::new(axis, window, cx);
+            for (i, item) in items.iter_mut().enumerate() {
+                let view = item.view();
+                let size = sizes.get(i).copied().flatten();
+                stack_panel.add_panel(view.clone(), size, dock_area.clone(), window, cx)
+            }
 
             for (i, item) in items.iter().enumerate() {
                 let view = item.view();
@@ -737,22 +745,34 @@ 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")
             .relative()
             .size_full()
+            .overflow_hidden()
             .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(
                         div()
                             .flex()
                             .flex_row()
-                            .size_full()
+                            .h_full()
                             // Left dock
                             .when_some(self.left_dock.clone(), |this, dock| {
                                 this.child(div().flex().flex_none().child(dock))
@@ -763,8 +783,14 @@ impl Render for DockArea {
                                     .flex()
                                     .flex_1()
                                     .flex_col()
+                                    .overflow_hidden()
                                     // Top center
-                                    .child(div().flex_1().child(self.render_items(window, cx)))
+                                    .child(
+                                        div()
+                                            .flex_1()
+                                            .overflow_hidden()
+                                            .child(self.render_items(window, cx)),
+                                    )
                                     // Bottom Dock
                                     .when_some(self.bottom_dock.clone(), |this, dock| {
                                         this.child(dock)

crates/ui/src/dock/stack_panel.rs

@@ -1,12 +1,13 @@
 use std::sync::Arc;
 
+use gpui::prelude::FluentBuilder;
 use gpui::{
     App, AppContext, Axis, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
     IntoElement, ParentElement, Pixels, Render, SharedString, Styled, Subscription, WeakEntity,
     Window,
 };
 use smallvec::SmallVec;
-use theme::{AxisExt as _, Placement};
+use theme::{ActiveTheme, AxisExt as _, CLIENT_SIDE_DECORATION_ROUNDING, Placement};
 
 use super::{DockArea, PanelEvent};
 use crate::dock::panel::{Panel, PanelView};
@@ -368,20 +369,26 @@ impl Focusable for StackPanel {
 }
 
 impl EventEmitter<PanelEvent> for StackPanel {}
-
 impl EventEmitter<DismissEvent> for StackPanel {}
 
 impl Render for StackPanel {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        h_flex().size_full().overflow_hidden().child(
-            ResizablePanelGroup::new("stack-panel-group")
-                .with_state(&self.state)
-                .axis(self.axis)
-                .children(self.panels.clone().into_iter().map(|panel| {
-                    resizable_panel()
-                        .child(panel.view())
-                        .visible(panel.visible(cx))
-                })),
-        )
+        h_flex()
+            .size_full()
+            .overflow_hidden()
+            .bg(cx.theme().panel_background)
+            .when(cx.theme().platform.is_linux(), |this| {
+                this.rounded_br(CLIENT_SIDE_DECORATION_ROUNDING)
+            })
+            .child(
+                ResizablePanelGroup::new("stack-panel-group")
+                    .with_state(&self.state)
+                    .axis(self.axis)
+                    .children(self.panels.clone().into_iter().map(|panel| {
+                        resizable_panel()
+                            .child(panel.view())
+                            .visible(panel.visible(cx))
+                    })),
+            )
     }
 }

crates/ui/src/dock/tab_panel.rs

@@ -2,12 +2,12 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    Anchor, App, AppContext, Context, DefiniteLength, DismissEvent, DragMoveEvent, Empty, Entity,
+    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, div, px, rems,
 };
-use theme::{ActiveTheme, AxisExt, Placement, TABBAR_HEIGHT};
+use theme::{ActiveTheme, AxisExt, CLIENT_SIDE_DECORATION_ROUNDING, Placement, TABBAR_HEIGHT};
 
 use crate::button::{Button, ButtonVariants as _};
 use crate::dock::dock::DockPlacement;
@@ -51,7 +51,7 @@ impl Render for DragPanel {
             .overflow_hidden()
             .whitespace_nowrap()
             .rounded(cx.theme().radius)
-            .text_sm()
+            .text_xs()
             .text_color(cx.theme().text)
             .text_ellipsis()
             .when(cx.theme().shadow, |this| this.shadow_xs())
@@ -312,7 +312,6 @@ impl TabPanel {
 
         cx.emit(PanelEvent::ZoomOut);
         cx.emit(PanelEvent::LayoutChanged);
-        cx.notify();
     }
 
     fn detach_panel(
@@ -322,22 +321,10 @@ impl TabPanel {
         cx: &mut Context<Self>,
     ) {
         let panel_view = panel.view();
-        let removed_ix = self.panels.iter().position(|p| p.view() == panel_view);
         self.panels.retain(|p| p.view() != panel_view);
 
         if self.active_ix >= self.panels.len() {
             self.set_active_ix(self.panels.len().saturating_sub(1), window, cx)
-        } else if let Some(removed_ix) = removed_ix {
-            if removed_ix < self.active_ix {
-                self.active_ix = self.active_ix.saturating_sub(1);
-            } else if removed_ix == self.active_ix {
-                // The active panel was removed and another panel shifted into
-                // its position. Activate the new panel at the same index.
-                if let Some(new_active) = self.panels.get(self.active_ix) {
-                    new_active.set_active(true, cx);
-                }
-                self.focus_active_panel(window, cx);
-            }
         }
     }
 
@@ -473,7 +460,7 @@ impl TabPanel {
                                 })
                         }
                     })
-                    .anchor(Anchor::TopRight),
+                    .anchor(Corner::TopRight),
             )
     }
 
@@ -580,7 +567,6 @@ impl TabPanel {
         let left_dock_button = self.render_dock_toggle_button(DockPlacement::Left, window, cx);
         let bottom_dock_button = self.render_dock_toggle_button(DockPlacement::Bottom, window, cx);
         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();
@@ -600,7 +586,6 @@ impl TabPanel {
                 .py_2()
                 .pl_3()
                 .pr_2()
-                .rounded_t(cx.theme().radius_lg)
                 .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())
@@ -626,7 +611,7 @@ impl TabPanel {
                             div()
                                 .w_full()
                                 .text_ellipsis()
-                                .text_sm()
+                                .text_xs()
                                 .child(panel.title(cx)),
                         )
                         .when(state.draggable, |this| {
@@ -656,14 +641,17 @@ impl TabPanel {
         TabBar::new("tab-bar")
             .track_scroll(&self.tab_bar_scroll_handle)
             .h(TABBAR_HEIGHT)
-            .bg(cx.theme().panel_background)
-            .rounded_t(cx.theme().radius_lg)
             .when(has_extend_dock_button, |this| {
                 this.prefix(
                     h_flex()
                         .items_center()
                         .top_0()
                         .right(-px(1.))
+                        .border_r_1()
+                        .border_b_1()
+                        .h_full()
+                        .border_color(cx.theme().border)
+                        .bg(cx.theme().tab_background)
                         .pl_0p5()
                         .pr_1()
                         .children(left_dock_button)
@@ -700,7 +688,6 @@ impl TabPanel {
                                 .on_click(cx.listener({
                                     let panel = panel.clone();
                                     move |view, _ev, window, cx| {
-                                        cx.stop_propagation();
                                         view.remove_panel(&panel, window, cx);
                                     }
                                 })),
@@ -763,7 +750,7 @@ impl TabPanel {
                 div()
                     .id("tab-bar-empty-space")
                     .h_full()
-                    .flex_grow_1()
+                    .flex_grow()
                     .min_w_16()
                     .when(state.droppable, |this| {
                         let view = cx.entity();
@@ -793,8 +780,12 @@ impl TabPanel {
                         .top_0()
                         .right_0()
                         .h_full()
+                        .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)),
                 )
@@ -824,8 +815,10 @@ impl TabPanel {
             .child(
                 div()
                     .size_full()
-                    .rounded_b(cx.theme().radius_lg)
                     .bg(cx.theme().panel_background)
+                    .when(cx.theme().platform.is_linux(), |this| {
+                        this.rounded_b(CLIENT_SIDE_DECORATION_ROUNDING)
+                    })
                     .overflow_hidden()
                     .child(
                         active_panel
@@ -1147,24 +1140,17 @@ impl Render for TabPanel {
             state.closable = false;
         }
 
-        div()
+        v_flex()
             .when(!self.collapsed, |this| {
                 this.on_action(cx.listener(Self::on_action_toggle_zoom))
                     .on_action(cx.listener(Self::on_action_close_panel))
             })
             .id("tab-panel")
+            .tab_group()
             .track_focus(&focus_handle)
             .size_full()
-            .p_1()
             .overflow_hidden()
-            .child(
-                v_flex()
-                    .rounded(cx.theme().radius_lg)
-                    .when(cx.theme().shadow, |this| this.shadow_xs())
-                    .size_full()
-                    .tab_group()
-                    .child(self.render_title_bar(&state, window, cx))
-                    .child(self.render_active_panel(&state, window, cx)),
-            )
+            .child(self.render_title_bar(&state, window, cx))
+            .child(self.render_active_panel(&state, window, cx))
     }
 }

crates/ui/src/history.rs

@@ -1,8 +1,6 @@
 use std::fmt::Debug;
-use instant::{Duration, Instant};
+use std::time::{Duration, Instant};
 
-/// A HistoryItem represents a single change in the history.
-/// It must implement Clone and PartialEq to be used in the History.
 pub trait HistoryItem: Clone + PartialEq {
     fn version(&self) -> usize;
     fn set_version(&mut self, version: usize);
@@ -24,11 +22,10 @@ pub struct History<I: HistoryItem> {
     redos: Vec<I>,
     last_changed_at: Instant,
     version: usize,
-    pub(crate) ignore: bool,
-    max_undos: usize,
+    max_undo: usize,
     group_interval: Option<Duration>,
-    grouping: bool,
     unique: bool,
+    pub ignore: bool,
 }
 
 impl<I> History<I>
@@ -42,16 +39,15 @@ where
             ignore: false,
             last_changed_at: Instant::now(),
             version: 0,
-            max_undos: 1000,
+            max_undo: 1000,
             group_interval: None,
-            grouping: false,
             unique: false,
         }
     }
 
     /// Set the maximum number of undo steps to keep, defaults to 1000.
-    pub fn max_undos(mut self, max_undos: usize) -> Self {
-        self.max_undos = max_undos;
+    pub fn max_undo(mut self, max_undo: usize) -> Self {
+        self.max_undo = max_undo;
         self
     }
 
@@ -68,20 +64,10 @@ where
         self
     }
 
-    /// Start grouping changes, this will prevent the version from being incremented until `end_grouping` is called.
-    pub fn start_grouping(&mut self) {
-        self.grouping = true;
-    }
-
-    /// End grouping changes, this will allow the version to be incremented again.
-    pub fn end_grouping(&mut self) {
-        self.grouping = false;
-    }
-
     /// Increment the version number if the last change was made more than `GROUP_INTERVAL` milliseconds ago.
     fn inc_version(&mut self) -> usize {
         let t = Instant::now();
-        if !self.grouping && Some(self.last_changed_at.elapsed()) > self.group_interval {
+        if Some(self.last_changed_at.elapsed()) > self.group_interval {
             self.version += 1;
         }
 
@@ -94,11 +80,10 @@ where
         self.version
     }
 
-    /// Push a new change to the history.
     pub fn push(&mut self, item: I) {
         let version = self.inc_version();
 
-        if self.undos.len() >= self.max_undos {
+        if self.undos.len() >= self.max_undo {
             self.undos.remove(0);
         }
 
@@ -128,7 +113,6 @@ where
         self.redos.clear();
     }
 
-    /// Undo the last change and return the changes that were undone.
     pub fn undo(&mut self) -> Option<Vec<I>> {
         if let Some(first_change) = self.undos.pop() {
             let mut changes = vec![first_change.clone()];
@@ -151,7 +135,6 @@ where
         }
     }
 
-    /// Redo the last undone change and return the changes that were redone.
     pub fn redo(&mut self) -> Option<Vec<I>> {
         if let Some(first_change) = self.redos.pop() {
             let mut changes = vec![first_change.clone()];