web build

crates/workspace/src/panels/backup.rs

@@ -0,0 +1,202 @@
+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 nostr_sdk::prelude::*;
+use state::KEYRING;
+use theme::ActiveTheme;
+use ui::button::{Button, ButtonVariants};
+use ui::dock::{Panel, PanelEvent};
+use ui::input::{Input, InputState};
+use ui::{IconName, Sizable, StyledExt, divider, v_flex};
+
+const MSG: &str = "Store your account keys in a safe location. \
+                   You can restore your account or move to another client anytime you want.";
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<BackupPanel> {
+    cx.new(|cx| BackupPanel::new(window, cx))
+}
+
+#[derive(Debug)]
+pub struct BackupPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// Public key input
+    npub_input: Entity<InputState>,
+
+    /// Secret key input
+    nsec_input: Entity<InputState>,
+
+    /// Copied status
+    copied: bool,
+
+    /// Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+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));
+
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.load(window, cx);
+        });
+
+        Self {
+            name: "Backup".into(),
+            focus_handle: cx.focus_handle(),
+            npub_input,
+            nsec_input,
+            copied: false,
+            tasks: vec![],
+        }
+    }
+
+    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let keyring = cx.read_credentials(KEYRING);
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            if let Some((_, secret)) = keyring.await? {
+                let secret = SecretKey::from_slice(&secret)?;
+                let keys = Keys::new(secret);
+
+                this.update_in(cx, |this, window, cx| {
+                    this.npub_input.update(cx, |this, cx| {
+                        this.set_value(keys.public_key().to_bech32().unwrap(), window, cx);
+                    });
+
+                    this.nsec_input.update(cx, |this, cx| {
+                        this.set_value(keys.secret_key().to_bech32().unwrap(), window, cx);
+                    });
+                })?;
+            }
+
+            Ok(())
+        }));
+    }
+
+    fn copy_secret(&mut self, cx: &mut Context<Self>) {
+        let value = self.nsec_input.read(cx).value();
+        let item = ClipboardItem::new_string(value.to_string());
+        cx.write_to_clipboard(item);
+
+        // Set the copied status to true
+        self.set_copied(true, cx);
+    }
+
+    fn set_copied(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.copied = status;
+        cx.notify();
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(Duration::from_secs(2)).await;
+
+            // Clear the error message after a delay
+            this.update(cx, |this, cx| {
+                this.set_copied(false, cx);
+            })?;
+
+            Ok(())
+        }));
+    }
+}
+
+impl Panel for BackupPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        self.name.clone().into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for BackupPanel {}
+
+impl Focusable for BackupPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for BackupPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .p_3()
+            .gap_3()
+            .w_full()
+            .child(
+                div()
+                    .text_xs()
+                    .text_color(cx.theme().text_muted)
+                    .child(SharedString::from(MSG)),
+            )
+            .child(divider(cx))
+            .child(
+                v_flex()
+                    .gap_2()
+                    .flex_1()
+                    .w_full()
+                    .text_sm()
+                    .child(
+                        v_flex()
+                            .gap_1p5()
+                            .w_full()
+                            .child(
+                                div()
+                                    .text_xs()
+                                    .font_semibold()
+                                    .text_color(cx.theme().text_muted)
+                                    .child(SharedString::from("Public Key:")),
+                            )
+                            .child(
+                                Input::new(&self.npub_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_1p5()
+                            .w_full()
+                            .child(
+                                div()
+                                    .text_xs()
+                                    .font_semibold()
+                                    .text_color(cx.theme().text_muted)
+                                    .child(SharedString::from("Secret Key:")),
+                            )
+                            .child(
+                                Input::new(&self.nsec_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
+                    )
+                    .child(
+                        Button::new("copy")
+                            .icon(IconName::Copy)
+                            .label({
+                                if self.copied {
+                                    "Copied"
+                                } else {
+                                    "Copy secret key"
+                                }
+                            })
+                            .primary()
+                            .small()
+                            .font_semibold()
+                            .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                this.copy_secret(cx);
+                            })),
+                    ),
+            )
+    }
+}

crates/workspace/src/panels/contact_list.rs

@@ -0,0 +1,364 @@
+use std::collections::HashSet;
+use std::time::Duration;
+
+use anyhow::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 nostr_sdk::prelude::*;
+use person::PersonRegistry;
+use smallvec::{SmallVec, smallvec};
+use state::NostrRegistry;
+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::{Disableable, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<ContactListPanel> {
+    cx.new(|cx| ContactListPanel::new(window, cx))
+}
+
+#[derive(Debug)]
+pub struct ContactListPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// Npub input
+    input: Entity<InputState>,
+
+    /// Whether the panel is updating
+    updating: bool,
+
+    /// Error message
+    error: Option<SharedString>,
+
+    /// All contacts
+    contacts: HashSet<PublicKey>,
+
+    /// Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 1]>,
+
+    /// Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl ContactListPanel {
+    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let input = cx.new(|cx| InputState::new(window, cx).placeholder("npub1..."));
+        let mut subscriptions = smallvec![];
+
+        subscriptions.push(
+            // Subscribe to user's input events
+            cx.subscribe_in(&input, window, move |this, _input, event, window, cx| {
+                if let InputEvent::PressEnter { .. } = event {
+                    this.add(window, cx);
+                }
+            }),
+        );
+
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.load(window, cx);
+        });
+
+        Self {
+            name: "Contact List".into(),
+            focus_handle: cx.focus_handle(),
+            input,
+            updating: false,
+            contacts: HashSet::new(),
+            error: None,
+            _subscriptions: subscriptions,
+            tasks: vec![],
+        }
+    }
+
+    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(public_key) = nostr.read(cx).signer_pubkey(cx) else {
+            return;
+        };
+
+        let task: Task<Result<HashSet<PublicKey>, Error>> = cx.background_spawn(async move {
+            let contact_list = client.database().contacts_public_keys(public_key).await?;
+            Ok(contact_list)
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            let public_keys = task.await?;
+
+            // Update state
+            this.update(cx, |this, cx| {
+                this.contacts.extend(public_keys);
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn add(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let value = self.input.read(cx).value().to_string();
+
+        if let Ok(public_key) = PublicKey::parse(&value) {
+            if self.contacts.insert(public_key) {
+                self.input.update(cx, |this, cx| {
+                    this.set_value("", window, cx);
+                });
+                cx.notify();
+            }
+        } else {
+            self.set_error("Public Key is invalid", window, cx);
+        }
+    }
+
+    fn remove(&mut self, public_key: &PublicKey, cx: &mut Context<Self>) {
+        self.contacts.remove(public_key);
+        cx.notify();
+    }
+
+    fn set_error<E>(&mut self, error: E, window: &mut Window, cx: &mut Context<Self>)
+    where
+        E: Into<SharedString>,
+    {
+        self.error = Some(error.into());
+        cx.notify();
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            cx.background_executor().timer(Duration::from_secs(2)).await;
+
+            // Clear the error message after a delay
+            this.update(cx, |this, cx| {
+                this.error = None;
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn set_updating(&mut self, updating: bool, cx: &mut Context<Self>) {
+        self.updating = updating;
+        cx.notify();
+    }
+
+    pub fn update(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.contacts.is_empty() {
+            self.set_error("You need to add at least 1 contact", window, cx);
+            return;
+        };
+
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(signer) = nostr.read(cx).signer(cx) else {
+            return;
+        };
+
+        // Get contacts
+        let contacts: Vec<Contact> = self
+            .contacts
+            .iter()
+            .map(|public_key| Contact::new(*public_key))
+            .collect();
+
+        // Set updating state
+        self.set_updating(true, cx);
+
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            // Construct contact list event builder
+            let event = ContactListBuilder::new(contacts)
+                .finalize_async(&signer)
+                .await?;
+
+            // Set contact list
+            client.send_event(&event).to_nip65().await?;
+
+            Ok(())
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(_) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.load(window, cx);
+
+                        window.push_notification("Update successful", cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.set_error(e.to_string(), window, cx);
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+
+    fn render_list_items(&mut self, cx: &mut Context<Self>) -> Vec<impl IntoElement> {
+        let persons = PersonRegistry::global(cx);
+        let mut items = Vec::new();
+
+        for (ix, public_key) in self.contacts.iter().enumerate() {
+            let profile = persons.read(cx).get(public_key, cx);
+
+            items.push(
+                h_flex()
+                    .id(ix)
+                    .group("")
+                    .flex_1()
+                    .w_full()
+                    .h_8()
+                    .px_2()
+                    .justify_between()
+                    .rounded(cx.theme().radius)
+                    .bg(cx.theme().secondary_background)
+                    .text_color(cx.theme().secondary_foreground)
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .text_sm()
+                            .child(Avatar::new(profile.avatar()).small())
+                            .child(profile.name()),
+                    )
+                    .child(
+                        Button::new("remove_{ix}")
+                            .icon(IconName::Close)
+                            .xsmall()
+                            .ghost()
+                            .invisible()
+                            .group_hover("", |this| this.visible())
+                            .on_click({
+                                let public_key = public_key.to_owned();
+                                cx.listener(move |this, _ev, _window, cx| {
+                                    this.remove(&public_key, cx);
+                                })
+                            }),
+                    ),
+            )
+        }
+
+        items
+    }
+
+    fn render_empty(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        h_flex()
+            .h_20()
+            .justify_center()
+            .border_2()
+            .border_dashed()
+            .border_color(cx.theme().border)
+            .rounded(cx.theme().radius_lg)
+            .text_sm()
+            .text_align(TextAlign::Center)
+            .child(SharedString::from("Please add some relays."))
+    }
+}
+
+impl Panel for ContactListPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        self.name.clone().into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for ContactListPanel {}
+
+impl Focusable for ContactListPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+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().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(
+                                    Input::new(&self.input)
+                                        .small()
+                                        .bordered(false)
+                                        .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()),
+                            )
+                        }),
+                )
+                .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/workspace/src/panels/greeter.rs

@@ -0,0 +1,161 @@
+use gpui::{
+    AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
+    IntoElement, ParentElement, Render, SharedString, Styled, Window, div, svg,
+};
+use state::NostrRegistry;
+use theme::ActiveTheme;
+use ui::button::{Button, ButtonVariants};
+use ui::dock::{DockPlacement, Panel, PanelEvent};
+use ui::{Icon, IconName, Sizable, StyledExt, h_flex, v_flex};
+
+use crate::Workspace;
+use crate::panels::profile;
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
+    cx.new(|cx| GreeterPanel::new(window, cx))
+}
+
+pub struct GreeterPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+}
+
+impl GreeterPanel {
+    fn new(_window: &mut Window, cx: &mut App) -> Self {
+        Self {
+            name: "Onboarding".into(),
+            focus_handle: cx.focus_handle(),
+        }
+    }
+
+    fn add_profile_panel(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+
+        if let Some(public_key) = nostr.read(cx).signer_pubkey(cx) {
+            cx.spawn_in(window, async move |_this, cx| {
+                cx.update(|window, cx| {
+                    Workspace::add_panel(
+                        profile::init(public_key, window, cx),
+                        DockPlacement::Right,
+                        window,
+                        cx,
+                    );
+                })
+                .ok();
+            })
+            .detach();
+        }
+    }
+}
+
+impl Panel for GreeterPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, cx: &App) -> AnyElement {
+        div()
+            .child(
+                svg()
+                    .path("brand/coop.svg")
+                    .size_4()
+                    .text_color(cx.theme().text_muted),
+            )
+            .into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for GreeterPanel {}
+
+impl Focusable for GreeterPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for GreeterPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        const TITLE: &str = "Welcome to Coop!";
+        const DESCRIPTION: &str = "Chat Freely, Stay Private on Nostr.";
+
+        h_flex()
+            .size_full()
+            .items_center()
+            .justify_center()
+            .p_2()
+            .child(
+                v_flex()
+                    .h_full()
+                    .w_112()
+                    .gap_6()
+                    .items_center()
+                    .justify_center()
+                    .child(
+                        h_flex()
+                            .mb_4()
+                            .gap_2()
+                            .w_full()
+                            .child(
+                                svg()
+                                    .path("brand/coop.svg")
+                                    .size_12()
+                                    .text_color(cx.theme().icon_muted),
+                            )
+                            .child(
+                                v_flex()
+                                    .child(
+                                        div()
+                                            .font_semibold()
+                                            .text_color(cx.theme().text)
+                                            .child(SharedString::from(TITLE)),
+                                    )
+                                    .child(
+                                        div()
+                                            .text_xs()
+                                            .text_color(cx.theme().text_muted)
+                                            .child(SharedString::from(DESCRIPTION)),
+                                    ),
+                            ),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_2()
+                            .w_full()
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .w_full()
+                                    .text_xs()
+                                    .font_semibold()
+                                    .text_color(cx.theme().text_muted)
+                                    .child(SharedString::from("Get Started"))
+                                    .child(div().flex_1().h_px().bg(cx.theme().border)),
+                            )
+                            .child(
+                                v_flex()
+                                    .gap_2()
+                                    .w_full()
+                                    .child(
+                                        Button::new("profile")
+                                            .icon(Icon::new(IconName::Profile))
+                                            .label("Update profile")
+                                            .ghost()
+                                            .small()
+                                            .justify_start()
+                                            .on_click(cx.listener(move |this, _ev, window, cx| {
+                                                this.add_profile_panel(window, cx)
+                                            })),
+                                    )
+                                    .child(
+                                        Button::new("invite")
+                                            .icon(Icon::new(IconName::Invite))
+                                            .label("Invite friends")
+                                            .ghost()
+                                            .small()
+                                            .justify_start(),
+                                    ),
+                            ),
+                    ),
+            )
+    }
+}

crates/workspace/src/panels/messaging_relays.rs

@@ -0,0 +1,381 @@
+use std::collections::HashSet;
+use std::time::Duration;
+
+use anyhow::{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 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::{Disableable, IconName, Sizable, StyledExt, WindowExtension, divider, h_flex, v_flex};
+
+const MSG: &str = "Messaging Relays are relays that hosted all your messages. \
+                   Other users will find your relays and send messages to it.";
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<MessagingRelayPanel> {
+    cx.new(|cx| MessagingRelayPanel::new(window, cx))
+}
+
+#[derive(Debug)]
+pub struct MessagingRelayPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// Relay URL input
+    input: Entity<InputState>,
+
+    /// Whether the panel is updating
+    updating: bool,
+
+    /// Error message
+    error: Option<SharedString>,
+
+    /// All relays
+    relays: HashSet<RelayUrl>,
+
+    /// Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 1]>,
+
+    /// Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl MessagingRelayPanel {
+    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let input = cx.new(|cx| InputState::new(window, cx).placeholder("wss://example.com"));
+        let mut subscriptions = smallvec![];
+
+        subscriptions.push(
+            // Subscribe to user's input events
+            cx.subscribe_in(&input, window, move |this, _input, event, window, cx| {
+                if let InputEvent::PressEnter { .. } = event {
+                    this.add(window, cx);
+                }
+            }),
+        );
+
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.load(window, cx);
+        });
+
+        Self {
+            name: "Update Messaging Relays".into(),
+            focus_handle: cx.focus_handle(),
+            input,
+            updating: false,
+            relays: HashSet::new(),
+            error: None,
+            _subscriptions: subscriptions,
+            tasks: vec![],
+        }
+    }
+
+    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(public_key) = nostr.read(cx).signer_pubkey(cx) else {
+            return;
+        };
+
+        let task: Task<Result<Vec<RelayUrl>, Error>> = cx.background_spawn(async move {
+            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())
+            } else {
+                Err(anyhow!("Not found."))
+            }
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            let relays = task.await?;
+
+            // Update state
+            this.update(cx, |this, cx| {
+                this.relays.extend(relays);
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn add(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let value = self.input.read(cx).value().to_string();
+
+        if !value.starts_with("ws") {
+            self.set_error("Relay URl is invalid", window, cx);
+            return;
+        }
+
+        if let Ok(url) = RelayUrl::parse(&value) {
+            if self.relays.insert(url) {
+                self.input.update(cx, |this, cx| {
+                    this.set_value("", window, cx);
+                });
+                cx.notify();
+            }
+        } else {
+            self.set_error("Relay URl is invalid", window, cx);
+        }
+    }
+
+    fn remove(&mut self, url: &RelayUrl, cx: &mut Context<Self>) {
+        self.relays.remove(url);
+        cx.notify();
+    }
+
+    fn set_error<E>(&mut self, error: E, window: &mut Window, cx: &mut Context<Self>)
+    where
+        E: Into<SharedString>,
+    {
+        self.error = Some(error.into());
+        cx.notify();
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            cx.background_executor().timer(Duration::from_secs(2)).await;
+
+            // Clear the error message after a delay
+            this.update(cx, |this, cx| {
+                this.error = None;
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn set_updating(&mut self, updating: bool, cx: &mut Context<Self>) {
+        self.updating = updating;
+        cx.notify();
+    }
+
+    pub fn set_relays(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.relays.is_empty() {
+            self.set_error("You need to add at least 1 relay", window, cx);
+            return;
+        };
+
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(signer) = nostr.read(cx).signer(cx) else {
+            return;
+        };
+
+        // Construct event tags
+        let tags: Vec<Tag> = self
+            .relays
+            .iter()
+            .map(|relay| Nip17Tag::Relay(relay.to_owned()).to_tag())
+            .collect();
+
+        // Set updating state
+        self.set_updating(true, cx);
+
+        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?;
+
+            // Set messaging relays
+            client.send_event(&event).to_nip65().await?;
+
+            Ok(())
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(_) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.load(window, cx);
+
+                        window.push_notification("Update successful", cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.set_error(e.to_string(), window, cx);
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+
+    fn render_list_items(&mut self, cx: &mut Context<Self>) -> Vec<impl IntoElement> {
+        let mut items = Vec::new();
+
+        for url in self.relays.iter() {
+            items.push(
+                h_flex()
+                    .id(SharedString::from(url.to_string()))
+                    .group("")
+                    .flex_1()
+                    .w_full()
+                    .h_8()
+                    .px_2()
+                    .justify_between()
+                    .rounded(cx.theme().radius)
+                    .bg(cx.theme().secondary_background)
+                    .text_color(cx.theme().secondary_foreground)
+                    .child(div().text_sm().child(SharedString::from(url.to_string())))
+                    .child(
+                        Button::new("remove_{ix}")
+                            .icon(IconName::Close)
+                            .xsmall()
+                            .ghost()
+                            .invisible()
+                            .group_hover("", |this| this.visible())
+                            .on_click({
+                                let url = url.to_owned();
+                                cx.listener(move |this, _ev, _window, cx| {
+                                    this.remove(&url, cx);
+                                })
+                            }),
+                    ),
+            )
+        }
+
+        items
+    }
+
+    fn render_empty(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        h_flex()
+            .h_20()
+            .justify_center()
+            .border_2()
+            .border_dashed()
+            .border_color(cx.theme().border)
+            .rounded(cx.theme().radius_lg)
+            .text_sm()
+            .text_align(TextAlign::Center)
+            .child(SharedString::from("Please add some relays."))
+    }
+}
+
+impl Panel for MessagingRelayPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        self.name.clone().into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for MessagingRelayPanel {}
+
+impl Focusable for MessagingRelayPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for MessagingRelayPanel {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .p_3()
+            .gap_3()
+            .w_full()
+            .child(
+                div()
+                    .text_xs()
+                    .text_color(cx.theme().text_muted)
+                    .child(SharedString::from(MSG)),
+            )
+            .child(divider(cx))
+            .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("Relays:")),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_1()
+                            .child(
+                                h_flex()
+                                    .gap_1()
+                                    .w_full()
+                                    .child(
+                                        Input::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(true),
+                                    )
+                                    .child(
+                                        Button::new("add")
+                                            .icon(IconName::Plus)
+                                            .tooltip("Add relay")
+                                            .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()),
+                                )
+                            }),
+                    )
+                    .map(|this| {
+                        if self.relays.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.set_relays(window, cx);
+                            })),
+                    ),
+            )
+    }
+}

crates/workspace/src/panels/mod.rs

@@ -0,0 +1,7 @@
+pub mod backup;
+pub mod contact_list;
+pub mod greeter;
+pub mod messaging_relays;
+pub mod profile;
+pub mod relay_list;
+pub mod trash;

crates/workspace/src/panels/profile.rs

@@ -0,0 +1,433 @@
+use std::str::FromStr;
+use std::time::Duration;
+
+use anyhow::{Context as AnyhowContext, Error, anyhow};
+use gpui::{
+    AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, IntoElement, ParentElement, PathPromptOptions, Render, SharedString, Styled, Task,
+    Window, div,
+};
+use nostr_sdk::prelude::*;
+use person::{Person, PersonRegistry, shorten_pubkey};
+use settings::AppSettings;
+use state::{NostrRegistry, upload};
+use theme::ActiveTheme;
+use ui::avatar::Avatar;
+use ui::button::{Button, ButtonVariants};
+use ui::dock::{Panel, PanelEvent};
+use ui::input::{Input, InputState};
+use ui::notification::Notification;
+use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
+
+pub fn init(public_key: PublicKey, window: &mut Window, cx: &mut App) -> Entity<ProfilePanel> {
+    cx.new(|cx| ProfilePanel::new(public_key, window, cx))
+}
+
+#[derive(Debug)]
+pub struct ProfilePanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// User's public key
+    public_key: PublicKey,
+
+    /// User's name text input
+    name_input: Entity<InputState>,
+
+    /// User's avatar url text input
+    avatar_input: Entity<InputState>,
+
+    /// User's bio multi line input
+    bio_input: Entity<InputState>,
+
+    /// User's website url text input
+    website_input: Entity<InputState>,
+
+    /// Uploading state
+    uploading: bool,
+
+    /// Copied states
+    copied: bool,
+
+    /// Updating state
+    updating: bool,
+
+    /// Tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl ProfilePanel {
+    fn new(public_key: PublicKey, window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let name_input = cx.new(|cx| InputState::new(window, cx).placeholder("Alice"));
+        let website_input = cx.new(|cx| InputState::new(window, cx).placeholder("alice.me"));
+        let avatar_input = cx.new(|cx| InputState::new(window, cx).placeholder("alice.me/a.jpg"));
+
+        // Use multi-line input for bio
+        let bio_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .multi_line(true)
+                .auto_grow(3, 8)
+                .placeholder("A short introduce about you.")
+        });
+
+        // Get user's profile and update inputs
+        cx.defer_in(window, move |this, window, cx| {
+            this.set_profile(window, cx);
+        });
+
+        Self {
+            name: "Update Profile".into(),
+            focus_handle: cx.focus_handle(),
+            public_key,
+            name_input,
+            avatar_input,
+            bio_input,
+            website_input,
+            uploading: false,
+            copied: false,
+            updating: false,
+            tasks: vec![],
+        }
+    }
+
+    fn set_profile(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let persons = PersonRegistry::global(cx);
+        let profile = persons.read(cx).get(&self.public_key, cx);
+        let metadata = profile.metadata();
+
+        self.avatar_input.update(cx, |this, cx| {
+            if let Some(avatar) = metadata.picture.as_ref() {
+                this.set_value(avatar, window, cx);
+            }
+        });
+
+        self.bio_input.update(cx, |this, cx| {
+            if let Some(bio) = metadata.about.as_ref() {
+                this.set_value(bio, window, cx);
+            }
+        });
+
+        self.name_input.update(cx, |this, cx| {
+            if let Some(display_name) = metadata.display_name.as_ref() {
+                this.set_value(display_name, window, cx);
+            }
+        });
+
+        self.website_input.update(cx, |this, cx| {
+            if let Some(website) = metadata.website.as_ref() {
+                this.set_value(website, window, cx);
+            }
+        });
+    }
+
+    fn copy(&mut self, value: String, window: &mut Window, cx: &mut Context<Self>) {
+        let item = ClipboardItem::new_string(value);
+        cx.write_to_clipboard(item);
+
+        self.set_copied(true, window, cx);
+    }
+
+    fn set_copied(&mut self, status: bool, window: &mut Window, cx: &mut Context<Self>) {
+        self.copied = status;
+        cx.notify();
+
+        if status {
+            cx.spawn_in(window, async move |this, cx| {
+                cx.background_executor().timer(Duration::from_secs(2)).await;
+
+                // Reset the copied state after a delay
+                cx.update(|window, cx| {
+                    this.update(cx, |this, cx| {
+                        this.set_copied(false, window, cx);
+                    })
+                    .ok();
+                })
+                .ok();
+            })
+            .detach();
+        }
+    }
+
+    fn set_uploading(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.uploading = status;
+        cx.notify();
+    }
+
+    fn upload(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        // Get the user's configured blossom server
+        let server = AppSettings::get_file_server(cx);
+
+        // Ask user for file upload
+        let path = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: None,
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            this.update(cx, |this, cx| {
+                this.set_uploading(true, cx);
+            })?;
+
+            let mut paths = path.await??.context("Not found")?;
+            let path = paths.pop().context("No path")?;
+
+            // Upload via blossom client
+            match upload(server, path, cx).await {
+                Ok(url) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.avatar_input.update(cx, |this, cx| {
+                            this.set_value(url.to_string(), window, cx);
+                        });
+                        this.set_uploading(false, cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_uploading(false, cx);
+                        window.push_notification(
+                            Notification::error(e.to_string()).autohide(false),
+                            cx,
+                        );
+                    })?;
+                }
+            }
+
+            Ok(())
+        }));
+    }
+
+    fn set_updating(&mut self, updating: bool, cx: &mut Context<Self>) {
+        self.updating = updating;
+        cx.notify();
+    }
+
+    /// Set the metadata for the current user
+    fn publish(&self, metadata: &Metadata, cx: &App) -> Task<Result<(), Error>> {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let metadata = metadata.clone();
+
+        let Some(signer) = nostr.read(cx).signer(cx) else {
+            return Task::ready(Err(anyhow!("Signer is required")));
+        };
+
+        cx.background_spawn(async move {
+            // Build and sign the metadata event
+            let event = metadata.finalize_async(&signer).await?;
+
+            // Send event to user's relays
+            client.send_event(&event).await?;
+
+            Ok(())
+        })
+    }
+
+    fn update(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let persons = PersonRegistry::global(cx);
+        let public_key = self.public_key;
+        let old_metadata = persons.read(cx).get(&public_key, cx).metadata();
+
+        // Extract all new metadata fields
+        let avatar = self.avatar_input.read(cx).value();
+        let name = self.name_input.read(cx).value();
+        let bio = self.bio_input.read(cx).value();
+        let website = self.website_input.read(cx).value();
+
+        // Construct the new metadata
+        let mut new_metadata = old_metadata
+            .display_name(name.as_ref())
+            .name(name.as_ref())
+            .about(bio.as_ref());
+
+        // Verify the avatar URL before adding it
+        if let Ok(url) = Url::from_str(&avatar) {
+            new_metadata = new_metadata.picture(url);
+        }
+
+        // Verify the website URL before adding it
+        if let Ok(url) = Url::from_str(&website) {
+            new_metadata = new_metadata.website(url);
+        }
+
+        // Set the metadata
+        let task = self.publish(&new_metadata, cx);
+
+        // Set the updating state
+        self.set_updating(true, cx);
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(_) => {
+                    this.update_in(cx, |this, window, cx| {
+                        // Update the registry
+                        persons.update(cx, |this, cx| {
+                            this.insert(Person::new(public_key, new_metadata), cx);
+                        });
+
+                        // Update current panel
+                        this.set_updating(false, cx);
+                        this.set_profile(window, cx);
+
+                        window.push_notification("Profile updated successfully", cx);
+                    })?;
+                }
+                Err(e) => {
+                    cx.update(|window, cx| {
+                        window.push_notification(
+                            Notification::error(e.to_string()).autohide(false),
+                            cx,
+                        );
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+}
+
+impl Panel for ProfilePanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        self.name.clone().into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for ProfilePanel {}
+
+impl Focusable for ProfilePanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for ProfilePanel {
+    fn render(&mut self, _window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar_input = self.avatar_input.read(cx).value();
+
+        // Get the avatar
+        let avatar = if avatar_input.is_empty() {
+            "brand/avatar.png"
+        } else {
+            avatar_input.as_str()
+        };
+
+        // Get the public key as short string
+        let shorten_pkey = SharedString::from(shorten_pubkey(self.public_key, 8));
+
+        v_flex()
+            .p_3()
+            .gap_3()
+            .w_full()
+            .child(
+                v_flex()
+                    .h_40()
+                    .w_full()
+                    .items_center()
+                    .justify_center()
+                    .gap_4()
+                    .child(Avatar::new(avatar).large())
+                    .child(
+                        Button::new("upload")
+                            .icon(IconName::PlusCircle)
+                            .label("Add an avatar")
+                            .xsmall()
+                            .ghost()
+                            .rounded()
+                            .disabled(self.uploading)
+                            .loading(self.uploading)
+                            .on_click(cx.listener(move |this, _, window, cx| {
+                                this.upload(window, cx);
+                            })),
+                    ),
+            )
+            .child(
+                v_flex()
+                    .gap_1p5()
+                    .child(
+                        div()
+                            .text_sm()
+                            .text_color(cx.theme().text_muted)
+                            .child(SharedString::from("What should people call you?")),
+                    )
+                    .child(Input::new(&self.name_input).bordered(false).small()),
+            )
+            .child(
+                v_flex()
+                    .gap_1p5()
+                    .child(
+                        div()
+                            .text_sm()
+                            .text_color(cx.theme().text_muted)
+                            .child(SharedString::from("A short introduction about you:")),
+                    )
+                    .child(Input::new(&self.bio_input).bordered(false).small()),
+            )
+            .child(
+                v_flex()
+                    .gap_1p5()
+                    .child(
+                        div()
+                            .text_sm()
+                            .text_color(cx.theme().text_muted)
+                            .child(SharedString::from("Website:")),
+                    )
+                    .child(Input::new(&self.website_input).bordered(false).small()),
+            )
+            .child(
+                v_flex()
+                    .gap_1p5()
+                    .child(
+                        div()
+                            .text_sm()
+                            .text_color(cx.theme().text_muted)
+                            .child(SharedString::from("Public Key:")),
+                    )
+                    .child(
+                        h_flex()
+                            .h_8()
+                            .w_full()
+                            .justify_center()
+                            .gap_3()
+                            .rounded(cx.theme().radius)
+                            .bg(cx.theme().secondary_background)
+                            .text_sm()
+                            .text_color(cx.theme().secondary_foreground)
+                            .child(shorten_pkey)
+                            .child(
+                                Button::new("copy")
+                                    .icon({
+                                        if self.copied {
+                                            IconName::CheckCircle
+                                        } else {
+                                            IconName::Copy
+                                        }
+                                    })
+                                    .xsmall()
+                                    .secondary()
+                                    .on_click(cx.listener(move |this, _ev, window, cx| {
+                                        this.copy(this.public_key.to_bech32().unwrap(), window, 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/workspace/src/panels/relay_list.rs

@@ -0,0 +1,450 @@
+use std::collections::HashSet;
+use std::time::Duration;
+
+use anyhow::{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 nostr_sdk::prelude::*;
+use serde::Deserialize;
+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::menu::DropdownMenu;
+use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, divider, h_flex, v_flex};
+
+const MSG: &str = "Relay List (or Gossip Relays) are a set of relays \
+                   where you will publish all your events. Others also publish events \
+                   related to you here.";
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<RelayListPanel> {
+    cx.new(|cx| RelayListPanel::new(window, cx))
+}
+
+#[derive(Action, Clone, PartialEq, Eq, Deserialize)]
+#[action(namespace = relay, no_json)]
+enum SetMetadata {
+    Read,
+    Write,
+}
+
+#[derive(Debug)]
+pub struct RelayListPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// Relay URL input
+    input: Entity<InputState>,
+
+    /// Whether the panel is updating
+    updating: bool,
+
+    /// Relay metadata input
+    metadata: Entity<Option<RelayMetadata>>,
+
+    /// Error message
+    error: Option<SharedString>,
+
+    // All relays
+    relays: HashSet<(RelayUrl, Option<RelayMetadata>)>,
+
+    // Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 1]>,
+
+    // Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl RelayListPanel {
+    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let input = cx.new(|cx| InputState::new(window, cx).placeholder("wss://example.com"));
+        let metadata = cx.new(|_| None);
+
+        let mut subscriptions = smallvec![];
+
+        subscriptions.push(
+            // Subscribe to user's input events
+            cx.subscribe_in(&input, window, move |this, _input, event, window, cx| {
+                if let InputEvent::PressEnter { .. } = event {
+                    this.add(window, cx);
+                }
+            }),
+        );
+
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.load(window, cx);
+        });
+
+        Self {
+            name: "Update Relay List".into(),
+            focus_handle: cx.focus_handle(),
+            input,
+            updating: false,
+            metadata,
+            relays: HashSet::new(),
+            error: None,
+            _subscriptions: subscriptions,
+            tasks: vec![],
+        }
+    }
+
+    #[allow(clippy::type_complexity)]
+    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(public_key) = nostr.read(cx).signer_pubkey(cx) else {
+            return;
+        };
+
+        let task: Task<Result<Vec<(RelayUrl, Option<RelayMetadata>)>, Error>> = cx
+            .background_spawn(async move {
+                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())
+                } else {
+                    Err(anyhow!("Not found."))
+                }
+            });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            let relays = task.await?;
+
+            // Update state
+            this.update(cx, |this, cx| {
+                this.relays.extend(relays);
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn add(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let value = self.input.read(cx).value().to_string();
+        let metadata = self.metadata.read(cx);
+
+        if !value.starts_with("ws") {
+            self.set_error("Relay URl is invalid", window, cx);
+            return;
+        }
+
+        if let Ok(url) = RelayUrl::parse(&value) {
+            if self.relays.insert((url, metadata.to_owned())) {
+                self.input.update(cx, |this, cx| {
+                    this.set_value("", window, cx);
+                });
+                cx.notify();
+            }
+        } else {
+            self.set_error("Relay URl is invalid", window, cx);
+        }
+    }
+
+    fn remove(&mut self, url: &RelayUrl, cx: &mut Context<Self>) {
+        self.relays.retain(|(relay, _)| relay != url);
+        cx.notify();
+    }
+
+    fn set_error<E>(&mut self, error: E, window: &mut Window, cx: &mut Context<Self>)
+    where
+        E: Into<SharedString>,
+    {
+        self.error = Some(error.into());
+        cx.notify();
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            cx.background_executor().timer(Duration::from_secs(2)).await;
+
+            // Clear the error message after a delay
+            this.update(cx, |this, cx| {
+                this.error = None;
+                cx.notify();
+            })?;
+
+            Ok(())
+        }));
+    }
+
+    fn set_updating(&mut self, updating: bool, cx: &mut Context<Self>) {
+        self.updating = updating;
+        cx.notify();
+    }
+
+    fn set_metadata(&mut self, ev: &SetMetadata, _window: &mut Window, cx: &mut Context<Self>) {
+        match ev {
+            SetMetadata::Read => {
+                self.metadata.update(cx, |this, cx| {
+                    *this = Some(RelayMetadata::Read);
+                    cx.notify();
+                });
+            }
+            SetMetadata::Write => {
+                self.metadata.update(cx, |this, cx| {
+                    *this = Some(RelayMetadata::Write);
+                    cx.notify();
+                });
+            }
+        }
+    }
+
+    fn set_relays(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.relays.is_empty() {
+            self.set_error("You need to add at least 1 relay", window, cx);
+            return;
+        };
+
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        let Some(signer) = nostr.read(cx).signer(cx) else {
+            return;
+        };
+
+        // Get all relays
+        let relays = self.relays.clone();
+
+        // Set updating state
+        self.set_updating(true, cx);
+
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            let event = EventBuilder::relay_list(relays)
+                .finalize_async(&signer)
+                .await?;
+
+            // Set relay list for current user
+            client.send_event(&event).await?;
+
+            Ok(())
+        });
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(_) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.load(window, cx);
+
+                        window.push_notification("Update successful", cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_updating(false, cx);
+                        this.set_error(e.to_string(), window, cx);
+                    })?;
+                }
+            };
+
+            Ok(())
+        }));
+    }
+
+    fn render_list_items(&mut self, cx: &mut Context<Self>) -> Vec<impl IntoElement> {
+        let mut items = Vec::new();
+
+        for (url, metadata) in self.relays.iter() {
+            items.push(
+                h_flex()
+                    .id(SharedString::from(url.to_string()))
+                    .group("")
+                    .flex_1()
+                    .w_full()
+                    .h_8()
+                    .px_2()
+                    .justify_between()
+                    .rounded(cx.theme().radius)
+                    .bg(cx.theme().secondary_background)
+                    .text_color(cx.theme().secondary_foreground)
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .text_sm()
+                            .child(SharedString::from(url.to_string()))
+                            .child(
+                                div()
+                                    .p_0p5()
+                                    .rounded_xs()
+                                    .font_semibold()
+                                    .text_size(px(8.))
+                                    .text_color(cx.theme().secondary_foreground)
+                                    .map(|this| {
+                                        if let Some(metadata) = metadata {
+                                            this.child(SharedString::from(metadata.to_string()))
+                                        } else {
+                                            this.child("Read and Write")
+                                        }
+                                    }),
+                            ),
+                    )
+                    .child(
+                        Button::new("remove_{ix}")
+                            .icon(IconName::Close)
+                            .xsmall()
+                            .ghost()
+                            .invisible()
+                            .group_hover("", |this| this.visible())
+                            .on_click({
+                                let url = url.to_owned();
+                                cx.listener(move |this, _ev, _window, cx| {
+                                    this.remove(&url, cx);
+                                })
+                            }),
+                    ),
+            )
+        }
+
+        items
+    }
+
+    fn render_empty(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        h_flex()
+            .h_20()
+            .justify_center()
+            .border_2()
+            .border_dashed()
+            .border_color(cx.theme().border)
+            .rounded(cx.theme().radius_lg)
+            .text_sm()
+            .text_align(TextAlign::Center)
+            .child(SharedString::from("Please add some relays."))
+    }
+}
+
+impl Panel for RelayListPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        self.name.clone().into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for RelayListPanel {}
+
+impl Focusable for RelayListPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for RelayListPanel {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .on_action(cx.listener(Self::set_metadata))
+            .p_3()
+            .gap_3()
+            .w_full()
+            .child(
+                div()
+                    .text_xs()
+                    .text_color(cx.theme().text_muted)
+                    .child(SharedString::from(MSG)),
+            )
+            .child(divider(cx))
+            .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("Relays:")),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_1()
+                            .child(
+                                h_flex()
+                                    .gap_1()
+                                    .w_full()
+                                    .child(
+                                        Input::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(true),
+                                    )
+                                    .child(
+                                        Button::new("metadata")
+                                            .map(|this| {
+                                                if let Some(metadata) = self.metadata.read(cx) {
+                                                    this.label(metadata.to_string())
+                                                } else {
+                                                    this.label("R & W")
+                                                }
+                                            })
+                                            .tooltip("Relay metadata")
+                                            .ghost()
+                                            .h(rems(2.))
+                                            .text_xs()
+                                            .dropdown_menu(|this, _window, _cx| {
+                                                this.menu("Read", Box::new(SetMetadata::Read))
+                                                    .menu("Write", Box::new(SetMetadata::Write))
+                                            }),
+                                    )
+                                    .child(
+                                        Button::new("add")
+                                            .icon(IconName::Plus)
+                                            .tooltip("Add relay")
+                                            .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()),
+                                )
+                            }),
+                    )
+                    .map(|this| {
+                        if self.relays.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.set_relays(window, cx);
+                            })),
+                    ),
+            )
+    }
+}

crates/workspace/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)),
+        )
+    }
+}