feat: add inbox panel (#18)

Reviewed-on: #18

crates/workspace/src/views/inbox.rs

@@ -0,0 +1,739 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Error;
+use dock::{BasePanel, DockArea, Panel, PanelEvent};
+use gpui::prelude::*;
+use gpui::{
+    AnyElement, App, Context, Div, EventEmitter, FocusHandle, Focusable, ListAlignment, ListState,
+    Pixels, Render, SharedString, Stateful, Subscription, Task, WeakEntity, Window, div, list, px,
+};
+use gpui_component::button::{Button, ButtonVariants};
+use gpui_component::{ActiveTheme, Icon, IconName, IconNamed, Sizable, StyledExt, h_flex, v_flex};
+use nostr::prelude::{Event, EventId, Kind, PublicKey, Timestamp};
+use signed_core::{COVER_NOTE_KIND, InboxItem, InboxReadState, RepoAddr, filters};
+use signed_state::{
+    Backend, BackendEvent, ProfileStore, RefreshGate, RefreshRequest, RepoListStore, query_inbox,
+};
+use signed_ui::{CountBadge, UserAvatar};
+use utils::relative_time;
+
+use super::{RepoItem, open_repo_item};
+
+/// Delay between a refresh request and the actual re-query.
+const REFRESH_DEBOUNCE: Duration = Duration::from_millis(300);
+
+/// Extra list rows measured above and below the visible area.
+const LIST_OVERDRAW: Pixels = px(400.);
+
+/// Maximum number of sub-activity lines shown under a thread row.
+const MAX_SUB_ACTIVITIES: usize = 5;
+
+/// A repository's slice of the inbox: the threads that belong to it.
+struct InboxSection {
+    /// Repository the section groups, `None` for items without one.
+    address: Option<RepoAddr>,
+    /// Number of threads with an unread event.
+    unread: usize,
+    /// Indices into the threads, newest activity first.
+    entries: Vec<usize>,
+    /// Timestamp of the newest entry, used to order the sections.
+    latest: Timestamp,
+}
+
+#[derive(Clone, Copy)]
+enum InboxRow {
+    Repo(usize),
+    Entry(usize, usize),
+    Empty,
+}
+
+pub struct InboxView {
+    focus_handle: FocusHandle,
+    dock_area: WeakEntity<DockArea>,
+    /// One row per thread, merging notifications and own activity, newest first.
+    threads: Arc<Vec<InboxItem>>,
+    /// The threads grouped by repository, newest first.
+    sections: Arc<Vec<InboxSection>>,
+    /// The flattened repository headers and rows of the list.
+    rows: Arc<Vec<InboxRow>>,
+    /// Number of non-archived threads with an unread event.
+    unread_count: usize,
+    /// Copy of the global read state the current lists were derived with.
+    state: InboxReadState,
+    /// Set once the global state has been read for the current user.
+    state_loaded: bool,
+    refresh: RefreshGate,
+    list: ListState,
+    tasks: Vec<Task<Result<(), Error>>>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl InboxView {
+    pub fn new(dock_area: WeakEntity<DockArea>, cx: &mut Context<Self>) -> Self {
+        let backend = Backend::global(cx);
+        let inbox = backend.read(cx).inbox();
+        let repos = RepoListStore::global(cx);
+        let weak = cx.entity().downgrade();
+
+        let list = ListState::new(0, ListAlignment::Top, LIST_OVERDRAW);
+        let mut subscriptions = vec![];
+
+        subscriptions.push(cx.observe(&inbox, |this, _inbox, cx| {
+            this.sync_state(cx);
+        }));
+
+        subscriptions.push(cx.subscribe(&backend, |this, _backend, event, cx| {
+            this.handle_backend_event(event, cx);
+        }));
+
+        // Rebuild when the user's own repositories load or change,
+        // so a repository without any activity still gets an empty section.
+        subscriptions.push(cx.observe(&repos, |this, _repos, cx| {
+            this.rebuild(cx);
+            cx.notify();
+        }));
+
+        // Derive the sections once the panel exists.
+        cx.defer(move |cx| {
+            if let Err(error) = weak.update(cx, |this, cx| this.sync_state(cx)) {
+                log::warn!("inbox dropped before bootstrap could run: {error}");
+            }
+        });
+
+        Self {
+            focus_handle: cx.focus_handle(),
+            dock_area,
+            threads: Arc::new(Vec::new()),
+            sections: Arc::new(Vec::new()),
+            rows: Arc::new(Vec::new()),
+            unread_count: 0,
+            state: InboxReadState::default(),
+            state_loaded: false,
+            refresh: RefreshGate::default(),
+            list,
+            tasks: vec![],
+            _subscriptions: subscriptions,
+        }
+    }
+
+    /// Mark every known notification read.
+    pub fn mark_all_read(&mut self, cx: &mut Context<Self>) {
+        let Some(me) = Backend::global(cx).read(cx).current_user() else {
+            return;
+        };
+
+        let all: Vec<Event> = self
+            .threads
+            .iter()
+            .flat_map(|item| item.events.iter().cloned())
+            .collect();
+
+        let backend = Backend::global(cx);
+        let inbox = backend.read(cx).inbox();
+
+        inbox.update(cx, |inbox, cx| inbox.mark_all_read(&all, me, cx));
+    }
+
+    /// Re-derive from the global state when it is loaded or changes.
+    pub fn sync_state(&mut self, cx: &mut Context<Self>) {
+        let backend = Backend::global(cx);
+        let inbox = backend.read(cx).inbox();
+
+        let (loaded, state) = {
+            let inbox = inbox.read(cx);
+            (inbox.is_loaded(), inbox.state().clone())
+        };
+
+        if !loaded {
+            let was_present =
+                self.state_loaded || !self.threads.is_empty() || !self.sections.is_empty();
+            self.clear();
+            if was_present {
+                cx.notify();
+            }
+            return;
+        }
+
+        if !self.state_loaded {
+            self.state_loaded = true;
+            self.state = state;
+            self.refresh_initial(cx);
+            return;
+        }
+
+        if self.state != state {
+            self.state = state;
+            self.regroup(cx);
+            cx.notify();
+        }
+    }
+
+    /// Handle a backend event that can change the derived sections.
+    fn handle_backend_event(&mut self, event: &BackendEvent, cx: &mut Context<Self>) {
+        match event {
+            BackendEvent::NostrUpdate(updates) => {
+                let relevant = updates.iter().any(|update| {
+                    let is_notification = filters::NOTIFICATION_KINDS.contains(&update.kind);
+                    let is_comment = update.kind == Kind::Comment;
+                    let is_event_deletion = update.kind == Kind::EventDeletion;
+                    let is_request_to_vanish = update.kind == Kind::RequestToVanish;
+
+                    is_notification || is_comment || is_event_deletion || is_request_to_vanish
+                });
+
+                if relevant {
+                    self.refresh(cx);
+                }
+            }
+            BackendEvent::Synced | BackendEvent::Published(_) => self.refresh(cx),
+            _ => {}
+        }
+    }
+
+    /// One-shot initial load, no debounce.
+    fn refresh_initial(&mut self, cx: &mut Context<Self>) {
+        debug_assert!(!self.refresh.debouncing());
+        if self.refresh.running() {
+            self.refresh.request();
+            return;
+        }
+        self.run_refresh(cx);
+    }
+
+    /// Re-query the local database.
+    fn refresh(&mut self, cx: &mut Context<Self>) {
+        if !self.state_loaded {
+            return;
+        }
+
+        if self.refresh.request() != RefreshRequest::Schedule {
+            return;
+        }
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(REFRESH_DEBOUNCE).await;
+            this.update(cx, |this, cx| this.run_refresh(cx))
+        }));
+    }
+
+    /// One query and apply cycle, the debounced entry point.
+    fn run_refresh(&mut self, cx: &mut Context<Self>) {
+        self.refresh.begin();
+
+        let backend = Backend::global(cx);
+        let Some(me) = backend.read(cx).current_user() else {
+            self.refresh.abort();
+            return;
+        };
+
+        let client = backend.read(cx).client();
+        let state = self.state.clone();
+
+        let work = cx.background_spawn(async move { query_inbox(&client, me, &state).await });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            let (threads, unread_count) = match work.await {
+                Ok(results) => results,
+                Err(error) => {
+                    log::warn!("inbox refresh failed: {error}");
+                    return this.update(cx, |this, _cx| this.refresh.abort());
+                }
+            };
+
+            let again = this.update(cx, |this, cx| {
+                if backend.read(cx).current_user() != Some(me) {
+                    this.refresh.abort();
+                    return false;
+                }
+
+                this.threads = Arc::new(threads);
+                this.unread_count = unread_count;
+                this.rebuild(cx);
+                cx.notify();
+
+                this.refresh.finish()
+            })?;
+
+            if again {
+                this.update(cx, |this, cx| this.refresh(cx))?;
+            }
+
+            Ok(())
+        }));
+    }
+
+    /// Recompute the unread and archived flags from the current state.
+    fn regroup(&mut self, cx: &mut Context<Self>) {
+        let mut items = (*self.threads).clone();
+
+        for item in items.iter_mut() {
+            item.apply_state(&self.state);
+        }
+
+        self.unread_count = items.iter().filter(|item| item.is_unread()).count();
+        self.threads = Arc::new(items);
+        self.rebuild(cx);
+    }
+
+    /// Regroup the current threads by repository and flatten them into rows.
+    fn rebuild(&mut self, cx: &mut Context<Self>) {
+        let backend = Backend::global(cx);
+        let repo_list = RepoListStore::global(cx);
+        let mut sections = self.group_sections();
+
+        if let Some(me) = backend.read(cx).current_user() {
+            for announcement in repo_list.read(cx).announcements_of(&me) {
+                let address = announcement.addr();
+                let known = sections
+                    .iter()
+                    .any(|section| section.address.as_ref() == Some(&address));
+
+                if !known {
+                    sections.push(InboxSection {
+                        address: Some(address),
+                        unread: 0,
+                        entries: Vec::new(),
+                        latest: Timestamp::default(),
+                    });
+                }
+            }
+        }
+
+        sections.sort_by_key(|section| std::cmp::Reverse(section.latest));
+
+        let rows = self.flatten_rows(&sections);
+        self.sections = Arc::new(sections);
+        self.rows = Arc::new(rows);
+    }
+
+    /// Group the threads into one section per repository.
+    fn group_sections(&self) -> Vec<InboxSection> {
+        let mut by_repo: HashMap<Option<RepoAddr>, InboxSection> = HashMap::new();
+
+        for (ix, item) in self.threads.iter().enumerate() {
+            if item.archived {
+                continue;
+            }
+
+            let address = item.address.clone();
+            let section = by_repo
+                .entry(address.clone())
+                .or_insert_with(move || InboxSection {
+                    address,
+                    unread: 0,
+                    entries: Vec::new(),
+                    latest: Timestamp::default(),
+                });
+
+            if item.is_unread() {
+                section.unread += 1;
+            }
+
+            section.latest = section.latest.max(item.latest_activity());
+            section.entries.push(ix);
+        }
+
+        let mut sections: Vec<InboxSection> = by_repo.into_values().collect();
+
+        for section in &mut sections {
+            section.entries.sort_by(|a, b| {
+                self.threads[*b]
+                    .latest_activity()
+                    .cmp(&self.threads[*a].latest_activity())
+            });
+        }
+
+        sections.sort_by_key(|section| std::cmp::Reverse(section.latest));
+        sections
+    }
+
+    /// Flatten the sections into the list of repository headers and their rows.
+    fn flatten_rows(&self, sections: &[InboxSection]) -> Vec<InboxRow> {
+        let mut rows = Vec::new();
+
+        for (section_ix, section) in sections.iter().enumerate() {
+            rows.push(InboxRow::Repo(section_ix));
+
+            if section.entries.is_empty() {
+                rows.push(InboxRow::Empty);
+                continue;
+            }
+
+            rows.extend(
+                (0..section.entries.len()).map(|entry_ix| InboxRow::Entry(section_ix, entry_ix)),
+            );
+        }
+
+        rows
+    }
+
+    /// Forget everything derived for the current user.
+    fn clear(&mut self) {
+        self.threads = Arc::new(Vec::new());
+        self.sections = Arc::new(Vec::new());
+        self.rows = Arc::new(Vec::new());
+        self.unread_count = 0;
+        self.state = InboxReadState::default();
+        self.state_loaded = false;
+        // Drop any in-flight or pending run belonging to the previous user.
+        self.refresh = RefreshGate::default();
+    }
+
+    fn open(
+        &self,
+        root: EventId,
+        kind: Option<Kind>,
+        address: Option<RepoAddr>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(address) = address else {
+            return;
+        };
+
+        let Some(announcement) = RepoListStore::global(cx)
+            .read(cx)
+            .announcements
+            .iter()
+            .find(|announcement| announcement.addr() == address)
+            .cloned()
+        else {
+            return;
+        };
+
+        let item = match kind {
+            Some(Kind::GitIssue) => RepoItem::Issue(root),
+            Some(Kind::GitPullRequest) => RepoItem::PullRequest(root),
+            Some(Kind::GitPatch) => RepoItem::Patch,
+            _ => return,
+        };
+
+        open_repo_item(&self.dock_area, &announcement, item, window, cx);
+    }
+
+    fn render_entry(&self, ix: usize, cx: &Context<Self>) -> AnyElement {
+        let Some(row) = self.rows.get(ix) else {
+            return div().into_any_element();
+        };
+
+        match *row {
+            InboxRow::Empty => empty_section_row(cx),
+            InboxRow::Repo(section_ix) => {
+                let Some(section) = self.sections.get(section_ix) else {
+                    return div().into_any_element();
+                };
+                repo_header(section, cx)
+            }
+            InboxRow::Entry(section_ix, entry_ix) => {
+                let Some(section) = self.sections.get(section_ix) else {
+                    return div().into_any_element();
+                };
+
+                let Some(&thread_ix) = section.entries.get(entry_ix) else {
+                    return div().into_any_element();
+                };
+
+                let Some(item) = self.threads.get(thread_ix) else {
+                    return div().into_any_element();
+                };
+
+                let root = item.root;
+                let kind = item.root_kind;
+                let address = section.address.clone();
+                let first = entry_ix == 0;
+                let last = entry_ix + 1 == section.entries.len();
+
+                thread("inbox-row", ix, item, first, last, cx)
+                    .on_click(cx.listener(move |this, _ev, window, cx| {
+                        this.open(root, kind, address.clone(), window, cx)
+                    }))
+                    .into_any_element()
+            }
+        }
+    }
+}
+
+/// Display name of the repository at `addr`, from the announcement store.
+fn repo_name(addr: Option<&RepoAddr>, cx: &App) -> Option<SharedString> {
+    let repo_list = RepoListStore::global(cx);
+    let addr = addr?;
+    repo_list
+        .read(cx)
+        .announcements
+        .iter()
+        .find(|announcement| announcement.addr() == *addr)
+        .map(|announcement| announcement.name().map(SharedString::from))
+}
+
+/// Header of a repository section.
+fn repo_header(section: &InboxSection, cx: &App) -> AnyElement {
+    let name =
+        repo_name(section.address.as_ref(), cx).unwrap_or_else(|| SharedString::from("Untitled"));
+
+    h_flex()
+        .h_12()
+        .w_full()
+        .gap_1()
+        .items_center()
+        .child(
+            div()
+                .min_w_0()
+                .text_sm()
+                .whitespace_nowrap()
+                .text_ellipsis()
+                .child(name),
+        )
+        .when(section.unread > 0, |this| {
+            this.child(CountBadge::new(section.unread))
+        })
+        .into_any_element()
+}
+
+/// Placeholder under a repository header that has nothing to show.
+fn empty_section_row(cx: &App) -> AnyElement {
+    h_flex()
+        .h_12()
+        .w_full()
+        .px_3()
+        .text_xs()
+        .text_color(cx.theme().secondary_foreground)
+        .bg(cx.theme().secondary.alpha(0.6))
+        .rounded(cx.theme().radius)
+        .child(SharedString::from("No activity yet."))
+        .into_any_element()
+}
+
+fn thread(
+    prefix: &'static str,
+    ix: usize,
+    item: &InboxItem,
+    first: bool,
+    last: bool,
+    cx: &App,
+) -> Stateful<Div> {
+    let title = SharedString::from(item.title());
+    let unread = item.is_unread();
+
+    let backend = Backend::global(cx);
+    let me = backend.read(cx).current_user();
+
+    let mut timeline = v_flex().gap_2().w_full();
+
+    for event in item.timeline(MAX_SUB_ACTIVITIES) {
+        timeline = timeline.child(sub_activity(&event, me, cx));
+    }
+
+    v_flex()
+        .id((prefix, ix))
+        .w_full()
+        .px_3()
+        .py_2()
+        .gap_2()
+        .bg(cx.theme().secondary.alpha(0.6))
+        .when(first, |this| this.rounded_t(cx.theme().radius))
+        .when(last, |this| this.rounded_b(cx.theme().radius))
+        .when(!last, |this| {
+            this.border_b_1().border_color(cx.theme().background)
+        })
+        .hover(|this| this.bg(cx.theme().secondary_hover.alpha(0.8)))
+        .child(
+            h_flex()
+                .gap_2()
+                .text_sm()
+                .child(
+                    h_flex()
+                        .size_6()
+                        .flex_shrink_0()
+                        .items_center()
+                        .justify_center()
+                        .child(Icon::new(IconName::Bell)),
+                )
+                .child(
+                    div()
+                        .min_w_0()
+                        .whitespace_nowrap()
+                        .text_ellipsis()
+                        .child(title),
+                )
+                .child(div().flex_1())
+                .when(unread, |this| {
+                    this.child(
+                        div()
+                            .flex_shrink_0()
+                            .size_2()
+                            .rounded_full()
+                            .bg(cx.theme().primary),
+                    )
+                }),
+        )
+        .child(timeline)
+}
+
+fn sub_activity(event: &Event, me: Option<PublicKey>, cx: &App) -> AnyElement {
+    let profile_store = ProfileStore::global(cx).read(cx);
+    let profile = profile_store.get(&event.pubkey);
+
+    let name = if Some(event.pubkey) == me {
+        SharedString::from("You")
+    } else {
+        profile.name()
+    };
+
+    h_flex()
+        .w_full()
+        .gap_2()
+        .items_center()
+        .child(div().w_6().flex_shrink_0())
+        .child(
+            h_flex()
+                .flex_1()
+                .min_w_0()
+                .gap_1()
+                .items_center()
+                .text_xs()
+                .child(
+                    UserAvatar::new(name.clone())
+                        .picture(profile.picture())
+                        .xsmall(),
+                )
+                .child(name)
+                .child(SharedString::from(activity_phrase(event.kind)))
+                .child(div().flex_1())
+                .child(
+                    div()
+                        .text_color(cx.theme().muted_foreground)
+                        .child(SharedString::from(relative_time(event.created_at))),
+                ),
+        )
+        .into_any_element()
+}
+
+/// Phrase describing an activity event, read as `[name] [phrase]`.
+fn activity_phrase(kind: Kind) -> &'static str {
+    if kind == COVER_NOTE_KIND {
+        return "added a note";
+    }
+
+    match kind {
+        Kind::GitIssue => "opened an issue",
+        Kind::GitPullRequest => "opened a PR",
+        Kind::GitPullRequestUpdate => "updated a PR",
+        Kind::GitPatch => "created a patch",
+        Kind::Comment => "commented",
+        Kind::GitStatusOpen => "opened a status",
+        Kind::GitStatusApplied => "applied a status",
+        Kind::GitStatusClosed => "closed a status",
+        Kind::GitStatusDraft => "drafted a status",
+        _ => "did something",
+    }
+}
+
+/// Centered muted icon and message filling its container.
+fn empty_state(icon: impl IconNamed, message: &str, cx: &App) -> AnyElement {
+    v_flex()
+        .w_full()
+        .flex_1()
+        .min_h_0()
+        .items_center()
+        .justify_center()
+        .gap_2()
+        .py_8()
+        .child(
+            Icon::new(icon)
+                .large()
+                .text_color(cx.theme().muted_foreground),
+        )
+        .child(
+            div()
+                .text_sm()
+                .text_color(cx.theme().muted_foreground)
+                .child(SharedString::from(message)),
+        )
+        .into_any_element()
+}
+
+impl BasePanel for InboxView {
+    fn panel_name(&self) -> &'static str {
+        "inbox"
+    }
+}
+
+impl Panel for InboxView {
+    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div().text_sm().child(SharedString::from("Inbox"))
+    }
+}
+
+impl EventEmitter<PanelEvent> for InboxView {}
+
+impl Focusable for InboxView {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for InboxView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let rows = self.rows.clone();
+
+        if self.list.item_count() != rows.len() {
+            self.list.reset(rows.len());
+        }
+
+        v_flex()
+            .image_cache(gpui::retain_all("inbox"))
+            .size_full()
+            .gap_2()
+            .child(
+                h_flex()
+                    .px_4()
+                    .h_12()
+                    .w_full()
+                    .gap_1()
+                    .items_center()
+                    .child(
+                        div()
+                            .text_sm()
+                            .font_semibold()
+                            .child(SharedString::from("Inbox")),
+                    )
+                    .child(div().flex_1())
+                    .child(
+                        Button::new("mark-all")
+                            .icon(IconName::CircleCheck)
+                            .secondary()
+                            .tooltip("Mark all as read")
+                            .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                this.mark_all_read(cx);
+                            })),
+                    ),
+            )
+            .child(
+                div()
+                    .relative()
+                    .flex_1()
+                    .min_h_0()
+                    .px_4()
+                    .when_else(
+                        rows.is_empty(),
+                        |this| {
+                            this.child(empty_state(IconName::Inbox, "You're all caught up.", cx))
+                        },
+                        |this| {
+                            this.child(
+                                list(
+                                    self.list.clone(),
+                                    cx.processor(|this, ix, _window, cx| this.render_entry(ix, cx)),
+                                )
+                                .size_full()
+                                .min_h_0()
+                                .into_any_element(),
+                            )
+                        },
+                    )
+                    .child(div().h_6().w_full().flex_shrink_0()),
+            )
+    }
+}

crates/workspace/src/views/mod.rs

@@ -1,9 +1,11 @@
 mod dialog_state;
+mod inbox;
 mod repo_detail;
 mod repo_list;
 pub(crate) mod sidebar;
 
+pub use inbox::InboxView;
 pub use repo_detail::RepoDetailView;
-pub(crate) use repo_detail::open_repo_panel;
+pub(crate) use repo_detail::{RepoItem, open_repo_item, open_repo_panel};
 pub use repo_list::RepoListView;
 pub use sidebar::SidebarPanel;

crates/workspace/src/views/repo_detail/mod.rs

@@ -1,6 +1,7 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::path::{Component, Path, PathBuf};
 use std::rc::Rc;
+use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::Error;
@@ -13,6 +14,7 @@ use gpui::{
     Focusable, PathPromptOptions, Pixels, Render, SharedString, Size, Subscription, WeakEntity,
     Window, div, px, relative, size, transparent_white,
 };
+use gpui_base::dock::PanelView;
 use gpui_base::{Button as BaseButton, Disableable, Popover};
 use gpui_component::alert::Alert;
 use gpui_component::button::{Button, ButtonVariants};
@@ -24,7 +26,7 @@ use gpui_component::{
     ActiveTheme, Colorize, Icon, IconName, Sizable, StyledExt, ThemeStyled,
     VirtualListScrollHandle, h_flex, v_flex,
 };
-use nostr::prelude::{RelayUrl, ToBech32, Url};
+use nostr::prelude::{EventId, RelayUrl, ToBech32, Url};
 use signed_core::{Announcement, RepoAddr, RepoStatus, filters};
 use signed_git::{CommitList, FileCommit};
 use signed_state::{
@@ -57,7 +59,9 @@ use helpers::{
     ShareTargets, TreeItemSeed, build_tree_items, is_markdown_path, ref_selector_trigger,
     tree_items,
 };
+use issue_detail::IssueDetailView;
 use issues::{IssuesView, open_new_issue_dialog};
+use pull_request_detail::PullRequestDetailView;
 use pull_requests::PullRequestsView;
 use send_patch::open_send_patch_panel;
 
@@ -2649,3 +2653,54 @@ pub(crate) fn open_repo_panel(
 
     detail
 }
+
+/// The nostr store of `announcement`'s repository, without opening a repository panel.
+fn repo_store(announcement: &Announcement, cx: &mut App) -> Entity<RepoStore> {
+    cx.new(|cx| RepoStore::new(announcement.addr(), announcement.relays.clone(), cx))
+}
+
+/// An item of a repository to open from outside its detail panel.
+/// A patch has no detail view in Signed, so it opens nothing.
+pub(crate) enum RepoItem {
+    Issue(EventId),
+    PullRequest(EventId),
+    Patch,
+}
+
+/// Open the detail panel of `item` in `announcement`'s repository, in the dock's center.
+///
+/// The repository store is built here, not taken from a `RepoDetailView`, so the
+/// item panel is the only panel docked.
+///
+/// A patch opens nothing: patches are only consumed inside a pull request's
+/// detail panel, and have no panel of their own.
+pub(crate) fn open_repo_item(
+    dock_area: &WeakEntity<DockArea>,
+    announcement: &Announcement,
+    item: RepoItem,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let panel: Arc<dyn PanelView> =
+        match item {
+            RepoItem::Issue(issue_id) => {
+                let store = repo_store(announcement, cx);
+                panel_handle(cx.new(|cx| IssueDetailView::new(store, issue_id, window, cx)))
+            }
+            RepoItem::PullRequest(pr_id) => {
+                let store = repo_store(announcement, cx);
+                panel_handle(cx.new(|cx| {
+                    PullRequestDetailView::new(dock_area.clone(), store, pr_id, window, cx)
+                }))
+            }
+            RepoItem::Patch => return,
+        };
+
+    let Some(dock_area) = dock_area.upgrade() else {
+        return;
+    };
+
+    dock_area.update(cx, |dock_area, cx| {
+        add_center_panel(dock_area, panel, window, cx);
+    });
+}

crates/workspace/src/views/sidebar/mod.rs

@@ -23,7 +23,7 @@ use signed_state::{
 };
 use signed_ui::{NavItem, PixelAvatar, UserAvatar, title_bar_drag_handlers};
 
-use super::{RepoDetailView, RepoListView, open_repo_panel};
+use super::{InboxView, RepoDetailView, RepoListView, open_repo_panel};
 
 mod create_repo_dialog;
 pub(crate) mod grasp_servers;
@@ -37,6 +37,7 @@ use self::onboarding_dialog::OnboardingState;
 pub struct SidebarPanel {
     focus_handle: FocusHandle,
     dock_area: WeakEntity<DockArea>,
+    inbox: Option<WeakEntity<InboxView>>,
     explore: Option<WeakEntity<RepoListView>>,
     /// Artwork for the sign-in screen.
     banner: SharedString,
@@ -71,6 +72,7 @@ impl SidebarPanel {
 
             if signer_required {
                 this.banner = pick_banner();
+                cx.notify();
             }
 
             if this.refresh(cx) || signer_required {
@@ -99,9 +101,10 @@ impl SidebarPanel {
             }
         }));
 
-        let mut this = Self {
+        Self {
             focus_handle: cx.focus_handle(),
             dock_area,
+            inbox: None,
             explore: None,
             banner: pick_banner(),
             announcements: Arc::new(Vec::new()),
@@ -109,22 +112,9 @@ impl SidebarPanel {
             scanning: false,
             unpushed: HashMap::new(),
             _subscriptions: subscriptions,
-        };
-
-        // Seed the snapshot right away.
-        // The stores may already hold data from before the panel opened.
-        // The first render must not depend on a later store update.
-        this.refresh(cx);
-
-        this
+        }
     }
 
-    /// The sidebar renders only its own derived fields, never the stores
-    /// directly. Because the panel is a cached view, a store update alone does
-    /// not re-render it: the observers notify this panel, which re-runs
-    /// `render` over the fresh snapshot.
-    ///
-    /// Returns `true` when a rendered field changed.
     fn refresh(&mut self, cx: &mut Context<Self>) -> bool {
         let backend = Backend::global(cx);
         let user = backend.read(cx).current_user();
@@ -203,6 +193,20 @@ impl SidebarPanel {
         });
     }
 
+    /// Open the inbox home panel in the dock area's center.
+    pub fn open_inbox(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.inbox.as_ref().and_then(WeakEntity::upgrade).is_some() {
+            return;
+        }
+
+        let panel = cx.new(|cx| InboxView::new(self.dock_area.clone(), cx));
+        self.inbox = Some(panel.downgrade());
+
+        let _ = self.dock_area.update(cx, |dock_area, cx| {
+            add_center_panel(dock_area, panel_handle(panel), window, cx);
+        });
+    }
+
     /// Open the Explore repository list panel in the dock area's center.
     pub fn open_explore(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self
@@ -616,7 +620,7 @@ impl Render for SidebarPanel {
                             .child(
                                 NavItem::new("inbox", "Inbox", Icon::new(IconName::Inbox).small())
                                     .on_click(cx.listener(|this, _ev, window, cx| {
-                                        this.open_explore(window, cx)
+                                        this.open_inbox(window, cx)
                                     })),
                             )
                             .child(