Add bookmarks internal page

crates/ely_browser_core/src/navigation.rs

@@ -16,6 +16,7 @@ pub(crate) fn tab_title(url: &UrlText) -> String {
 fn internal_page_title(url: &str) -> Option<&'static str> {
     match url {
         "ely://new-tab" => Some("New Tab"),
+        "ely://bookmarks" => Some("Bookmarks"),
         "ely://downloads" => Some("Downloads"),
         "ely://history" => Some("History"),
         "ely://archive" => Some("Archived Tabs"),
@@ -84,6 +85,10 @@ pub(crate) fn downloads_url() -> Result<UrlText, CoreError> {
     internal_page_url("ely://downloads")
 }
 
+pub(crate) fn bookmarks_url() -> Result<UrlText, CoreError> {
+    internal_page_url("ely://bookmarks")
+}
+
 pub(crate) fn history_url() -> Result<UrlText, CoreError> {
     internal_page_url("ely://history")
 }

crates/ely_browser_core/src/state.rs

@@ -1,12 +1,13 @@
 use std::collections::BTreeMap;
 
 use ely_domain::{
-    ArchivedTab, BrowserTab, DomainError, DownloadEntry, DownloadPolicy, HistoryEntry, Profile,
-    ProfileId, ProfileKind, Space, SpaceId, SyncStatus, TabId, UrlText,
+    ArchivedTab, BookmarkEntry, BrowserTab, DomainError, DownloadEntry, DownloadPolicy,
+    HistoryEntry, Profile, ProfileId, ProfileKind, Space, SpaceId, SyncStatus, TabId, UrlText,
 };
 
 use crate::CoreError;
 
+mod bookmarks;
 mod commands;
 mod downloads;
 mod history;
@@ -42,6 +43,7 @@ pub struct BrowserSnapshot {
     pub favorites: Vec<BrowserTab>,
     pub pinned_tabs: Vec<BrowserTab>,
     pub archived_tabs: Vec<ArchivedTab>,
+    pub bookmarks: Vec<BookmarkEntry>,
     pub download_entries: Vec<DownloadEntry>,
     pub history_entries: Vec<HistoryEntry>,
     pub installed_plugins: Vec<InstalledPlugin>,
@@ -64,6 +66,7 @@ pub struct BrowserCore {
     profiles: Vec<Profile>,
     tabs: Vec<BrowserTab>,
     archived_tabs: Vec<ArchivedTab>,
+    bookmarks: Vec<BookmarkEntry>,
     download_entries: Vec<DownloadEntry>,
     history_entries: Vec<HistoryEntry>,
     installed_plugins: Vec<InstalledPlugin>,
@@ -108,6 +111,7 @@ impl BrowserCore {
             profiles: vec![profile],
             tabs: vec![tab],
             archived_tabs: Vec::new(),
+            bookmarks: Vec::new(),
             download_entries: Vec::new(),
             history_entries: Vec::new(),
             installed_plugins: Vec::new(),
@@ -182,21 +186,14 @@ impl BrowserCore {
     }
 
     pub fn snapshot(&self) -> Result<BrowserSnapshot, CoreError> {
-        let active_space = self
-            .spaces
-            .iter()
-            .find(|space| space.id() == &self.active_space_id)
-            .ok_or(CoreError::MissingActiveTab)?;
-        let active_profile = self
-            .profiles
-            .iter()
-            .find(|profile| profile.id() == &self.active_profile_id)
-            .ok_or(CoreError::MissingActiveTab)?;
+        let active_space = self.active_space()?;
+        let active_profile = self.active_profile()?;
 
         Ok(BrowserSnapshot {
             favorites: self.favorites(),
             pinned_tabs: self.pinned_tabs(),
             archived_tabs: self.archived_tabs.clone(),
+            bookmarks: self.visible_bookmarks(),
             download_entries: self.visible_downloads(),
             history_entries: self.visible_history(),
             installed_plugins: self.installed_plugins.clone(),
@@ -219,7 +216,14 @@ impl BrowserCore {
         self.profiles
             .iter()
             .find(|profile| profile.id() == &self.active_profile_id)
-            .ok_or(CoreError::MissingActiveTab)
+            .ok_or_else(|| CoreError::ProfileNotFound { id: self.active_profile_id.clone() })
+    }
+
+    fn active_space(&self) -> Result<&Space, CoreError> {
+        self.spaces
+            .iter()
+            .find(|space| space.id() == &self.active_space_id)
+            .ok_or_else(|| CoreError::SpaceNotFound { id: self.active_space_id.clone() })
     }
 
     fn favorites(&self) -> Vec<BrowserTab> {

crates/ely_browser_core/src/state/bookmarks.rs

@@ -0,0 +1,64 @@
+use std::time::SystemTime;
+
+use ely_domain::{BookmarkEntry, BookmarkId, UrlText};
+
+use crate::CoreError;
+
+use super::BrowserCore;
+
+impl BrowserCore {
+    pub fn bookmark_active_tab(&mut self) -> Result<BookmarkId, CoreError> {
+        let active_tab = self.active_tab()?.clone();
+        if let Some(bookmark) = self.bookmarks.iter().find(|bookmark| {
+            bookmark.profile_id() == active_tab.profile_id()
+                && bookmark.space_id() == active_tab.space_id()
+                && bookmark.url() == active_tab.url()
+        }) {
+            return Ok(bookmark.id().clone());
+        }
+
+        let collection_name = self.active_space()?.name().to_string();
+        let bookmark = BookmarkEntry::new(
+            active_tab.profile_id().clone(),
+            active_tab.space_id().clone(),
+            collection_name,
+            active_tab.title(),
+            active_tab.url().clone(),
+            SystemTime::now(),
+        )?;
+        let bookmark_id = bookmark.id().clone();
+        self.bookmarks.push(bookmark);
+        Ok(bookmark_id)
+    }
+
+    pub(super) fn find_bookmark_match(&self, query: &str) -> Option<UrlText> {
+        let normalized_query = query.trim().to_lowercase();
+        if normalized_query.is_empty() {
+            return None;
+        }
+
+        self.bookmarks
+            .iter()
+            .rev()
+            .filter(|bookmark| bookmark.profile_id() == &self.active_profile_id)
+            .find(|bookmark| bookmark_matches_query(bookmark, &normalized_query))
+            .map(|bookmark| bookmark.url().clone())
+    }
+
+    pub(super) fn visible_bookmarks(&self) -> Vec<BookmarkEntry> {
+        self.bookmarks
+            .iter()
+            .filter(|bookmark| bookmark.profile_id() == &self.active_profile_id)
+            .cloned()
+            .collect()
+    }
+}
+
+fn bookmark_matches_query(bookmark: &BookmarkEntry, normalized_query: &str) -> bool {
+    bookmark.title().to_lowercase().contains(normalized_query)
+        || bookmark.url().as_str().to_lowercase().contains(normalized_query)
+        || bookmark.display_url().to_lowercase().contains(normalized_query)
+        || bookmark.collection_name().to_lowercase().contains(normalized_query)
+        || bookmark.tags().iter().any(|tag| tag.to_lowercase().contains(normalized_query))
+        || bookmark.note().is_some_and(|note| note.to_lowercase().contains(normalized_query))
+}

crates/ely_browser_core/src/state/commands.rs

@@ -3,8 +3,8 @@ use ely_domain::{CommandIntent, CommandScope, ProfileId, ProfileKind, SpaceId};
 use crate::{
     CoreError,
     navigation::{
-        about_url, downloads_url, history_url, move_tab_space_name, new_profile_name,
-        new_space_name, search_url, settings_page_url, settings_url, space_icon,
+        about_url, bookmarks_url, downloads_url, history_url, move_tab_space_name,
+        new_profile_name, new_space_name, search_url, settings_page_url, settings_url, space_icon,
         switch_profile_name, sync_status_url,
     },
 };
@@ -51,6 +51,12 @@ impl BrowserCore {
                     self.command_query.clear();
                 }
             }
+            CommandIntent::ScopedSearch { scope: CommandScope::Bookmarks, query } => {
+                if let Some(url) = self.find_bookmark_match(query) {
+                    self.open_tab(url);
+                    self.command_query.clear();
+                }
+            }
             CommandIntent::ScopedSearch { scope: CommandScope::Settings, query } => {
                 if let Some(url) = settings_page_url(query)? {
                     self.open_tab(url);
@@ -102,6 +108,10 @@ impl BrowserCore {
                 self.open_tab(downloads_url()?);
                 Ok(true)
             }
+            "bookmarks" | "open-bookmarks" | "open bookmarks" => {
+                self.open_tab(bookmarks_url()?);
+                Ok(true)
+            }
             "history" | "open-history" | "open history" => {
                 self.open_tab(history_url()?);
                 Ok(true)
@@ -126,6 +136,10 @@ impl BrowserCore {
                 self.toggle_active_tab_favorite()?;
                 Ok(true)
             }
+            "bookmark" | "add-bookmark" | "add bookmark" => {
+                self.bookmark_active_tab()?;
+                Ok(true)
+            }
             "pin" | "pin-tab" | "toggle-pin" => {
                 self.toggle_active_tab_pinned()?;
                 Ok(true)

crates/ely_browser_core/src/state/sync.rs

@@ -15,6 +15,11 @@ impl BrowserCore {
                 self.tabs.len(),
                 SyncObjectState::LocalOnly,
             ),
+            SyncObjectStatus::new(
+                SyncObjectKind::Bookmarks,
+                self.bookmarks.len(),
+                SyncObjectState::LocalOnly,
+            ),
             SyncObjectStatus::new(
                 SyncObjectKind::Profiles,
                 self.profiles.len(),

crates/ely_browser_core/tests/bookmarks.rs

@@ -0,0 +1,108 @@
+use std::error::Error;
+
+use ely_browser_core::{BrowserCore, InitialBrowserConfig};
+use ely_domain::{CommandIntent, CommandScope, ProfileKind, UrlText};
+
+#[test]
+fn bookmark_active_tab_records_current_context() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+    let tab_id = core.open_tab(UrlText::parse("https://example.com/research")?);
+    let active_profile_id = core.active_tab()?.profile_id().clone();
+    let active_space_id = core.active_tab()?.space_id().clone();
+
+    let bookmark_id = core.bookmark_active_tab()?;
+    let snapshot = core.snapshot()?;
+    let [bookmark] = snapshot.bookmarks.as_slice() else {
+        return Err(format!("expected 1 bookmark, got {}", snapshot.bookmarks.len()).into());
+    };
+
+    assert_eq!(snapshot.active_tab_id, tab_id);
+    assert_eq!(bookmark.id(), &bookmark_id);
+    assert_eq!(bookmark.profile_id(), &active_profile_id);
+    assert_eq!(bookmark.space_id(), &active_space_id);
+    assert_eq!(bookmark.collection_name(), "Work");
+    assert_eq!(bookmark.title(), "example.com");
+    assert_eq!(bookmark.url().as_str(), "https://example.com/research");
+    assert!(bookmark.tags().is_empty());
+    assert_eq!(bookmark.note(), None);
+    Ok(())
+}
+
+#[test]
+fn bookmark_active_tab_reuses_existing_bookmark() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+    core.open_tab(UrlText::parse("https://example.com/research")?);
+
+    let first_id = core.bookmark_active_tab()?;
+    let second_id = core.bookmark_active_tab()?;
+
+    assert_eq!(first_id, second_id);
+    assert_eq!(core.snapshot()?.bookmarks.len(), 1);
+    Ok(())
+}
+
+#[test]
+fn bookmarks_scoped_search_opens_matching_bookmark() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+    core.open_tab(UrlText::parse("https://example.com/research")?);
+    core.bookmark_active_tab()?;
+
+    core.set_command_query("@bookmarks research");
+    let intent = core.submit_command()?;
+    let snapshot = core.snapshot()?;
+    let active_tab = core.active_tab()?;
+
+    assert_eq!(
+        intent,
+        Some(CommandIntent::ScopedSearch {
+            scope: CommandScope::Bookmarks,
+            query: "research".to_string()
+        })
+    );
+    assert_eq!(active_tab.url().as_str(), "https://example.com/research");
+    assert_eq!(snapshot.command_query, "");
+    Ok(())
+}
+
+#[test]
+fn bookmarks_stay_with_active_profile() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+    let default_profile_id = core.active_tab()?.profile_id().clone();
+    let personal_profile_id = core.create_profile("Personal", 0xf54e00, ProfileKind::Standard)?;
+
+    core.open_tab(UrlText::parse("https://example.com/personal")?);
+    core.bookmark_active_tab()?;
+    core.select_profile(&default_profile_id)?;
+
+    core.set_command_query("@bookmarks personal");
+    let intent = core.submit_command()?;
+    let snapshot = core.snapshot()?;
+
+    assert_eq!(
+        intent,
+        Some(CommandIntent::ScopedSearch {
+            scope: CommandScope::Bookmarks,
+            query: "personal".to_string()
+        })
+    );
+    assert_eq!(core.active_tab()?.profile_id(), &default_profile_id);
+    assert_ne!(core.active_tab()?.profile_id(), &personal_profile_id);
+    assert!(snapshot.bookmarks.is_empty());
+    assert_eq!(snapshot.command_query, "@bookmarks personal");
+    Ok(())
+}
+
+#[test]
+fn open_bookmarks_command_opens_bookmarks_page() -> Result<(), Box<dyn Error>> {
+    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
+
+    core.set_command_query(">open-bookmarks");
+    let intent = core.submit_command()?;
+    let active_tab = core.active_tab()?;
+
+    assert_eq!(intent, Some(CommandIntent::Command("open-bookmarks".to_string())));
+    assert_eq!(active_tab.title(), "Bookmarks");
+    assert_eq!(active_tab.url().as_str(), "ely://bookmarks");
+    assert_eq!(core.snapshot()?.command_query, "");
+    Ok(())
+}

crates/ely_browser_core/tests/sync.rs

@@ -8,6 +8,7 @@ fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Erro
     let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
     core.create_space("Research", "R", 0xf54e00)?;
     core.open_tab(UrlText::parse("https://example.com/research")?);
+    core.bookmark_active_tab()?;
 
     let snapshot = core.snapshot()?;
     let status = &snapshot.sync_status;
@@ -20,6 +21,7 @@ fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Erro
         &[
             SyncObjectStatus::new(SyncObjectKind::Spaces, 2, SyncObjectState::LocalOnly),
             SyncObjectStatus::new(SyncObjectKind::Tabs, 3, SyncObjectState::LocalOnly),
+            SyncObjectStatus::new(SyncObjectKind::Bookmarks, 1, SyncObjectState::LocalOnly),
             SyncObjectStatus::new(SyncObjectKind::Profiles, 1, SyncObjectState::LocalOnly),
             SyncObjectStatus::new(SyncObjectKind::History, 1, SyncObjectState::PrivacyControlled),
             SyncObjectStatus::new(SyncObjectKind::PluginSettings, 0, SyncObjectState::LocalOnly),