Add desktop search and result anchors

crates/sprout-relay/src/api/events.rs

@@ -0,0 +1,57 @@
+//! Event lookup endpoints.
+//!
+//! Endpoints:
+//!   GET /api/events/:id — fetch a single stored event by ID
+
+use std::sync::Arc;
+
+use axum::{
+    extract::{Path, State},
+    http::{HeaderMap, StatusCode},
+    response::Json,
+};
+
+use crate::state::AppState;
+
+use super::{api_error, check_channel_access, extract_auth_pubkey, internal_error, not_found};
+
+/// Fetch a single stored event by its 64-char hex ID.
+pub async fn get_event(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Path(event_id): Path<String>,
+) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
+    let (_pubkey, pubkey_bytes) = extract_auth_pubkey(&headers, &state).await?;
+
+    let id_bytes = hex::decode(&event_id)
+        .map_err(|_| api_error(StatusCode::BAD_REQUEST, "invalid event ID"))?;
+    if id_bytes.len() != 32 {
+        return Err(api_error(StatusCode::BAD_REQUEST, "invalid event ID"));
+    }
+
+    let stored_event = state
+        .db
+        .get_event_by_id(&id_bytes)
+        .await
+        .map_err(|e| internal_error(&format!("db error: {e}")))?
+        .ok_or_else(|| not_found("event not found"))?;
+
+    if let Some(channel_id) = stored_event.channel_id {
+        check_channel_access(&state, channel_id, &pubkey_bytes).await?;
+    } else {
+        return Err(not_found("event not found"));
+    }
+
+    let tags = serde_json::to_value(&stored_event.event.tags)
+        .map_err(|e| internal_error(&format!("tag serialization error: {e}")))?;
+
+    Ok(Json(serde_json::json!({
+        "id": stored_event.event.id.to_hex(),
+        "pubkey": stored_event.event.pubkey.to_hex(),
+        "created_at": stored_event.event.created_at.as_u64(),
+        "kind": stored_event.event.kind.as_u16(),
+        "tags": tags,
+        "content": stored_event.event.content,
+        "sig": stored_event.event.sig.to_string(),
+    })))
+}

crates/sprout-relay/src/api/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! Endpoints are split into focused submodules:
 //!   - `channels`  — GET/POST /api/channels
+//!   - `events`    — GET /api/events/:id
 //!   - `search`    — GET /api/search
 //!   - `agents`    — GET /api/agents
 //!   - `presence`  — GET /api/presence
@@ -19,6 +20,8 @@ pub mod channels;
 pub mod channels_metadata;
 /// Direct message endpoints.
 pub mod dms;
+/// Event lookup endpoint.
+pub mod events;
 /// Personalized home feed endpoint.
 pub mod feed;
 /// Channel membership endpoints.
@@ -47,6 +50,7 @@ pub use channels_metadata::{
     set_topic_handler, unarchive_channel_handler, update_channel_handler,
 };
 pub use dms::{add_dm_member_handler, list_dms_handler, open_dm_handler};
+pub use events::get_event;
 pub use feed::feed_handler;
 pub use members::{add_members, join_channel, leave_channel, list_members, remove_member};
 pub use messages::{delete_message, get_thread, list_messages, send_message};

crates/sprout-relay/src/router.rs

@@ -29,6 +29,7 @@ pub fn build_router(state: Arc<AppState>) -> Router {
             "/api/channels",
             get(api::channels_handler).post(api::create_channel),
         )
+        .route("/api/events/{id}", get(api::get_event))
         .route("/api/search", get(api::search_handler))
         .route("/api/agents", get(api::agents_handler))
         .route("/api/presence", get(api::presence_handler))

desktop/src-tauri/src/lib.rs

@@ -43,6 +43,13 @@ struct GetFeedQuery<'a> {
     types: Option<&'a str>,
 }
 
+#[derive(Serialize)]
+struct SearchQueryParams<'a> {
+    q: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    limit: Option<u32>,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct FeedItemInfo {
     pub id: String,
@@ -77,6 +84,24 @@ pub struct FeedResponse {
     pub meta: FeedMeta,
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct SearchHitInfo {
+    pub event_id: String,
+    pub content: String,
+    pub kind: u32,
+    pub pubkey: String,
+    pub channel_id: String,
+    pub channel_name: String,
+    pub created_at: u64,
+    pub score: f64,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SearchResponse {
+    pub hits: Vec<SearchHitInfo>,
+    pub found: u64,
+}
+
 fn relay_ws_url() -> String {
     std::env::var("SPROUT_RELAY_URL").unwrap_or_else(|_| "ws://localhost:3000".to_string())
 }
@@ -273,6 +298,56 @@ async fn get_feed(
         .map_err(|e| format!("parse failed: {e}"))
 }
 
+#[tauri::command]
+async fn search_messages(
+    q: String,
+    limit: Option<u32>,
+    state: tauri::State<'_, AppState>,
+) -> Result<SearchResponse, String> {
+    let pubkey_hex = auth_pubkey_header(&state)?;
+    let url = format!("{}{}", relay_api_base_url(), "/api/search");
+    let response = state
+        .http_client
+        .get(url)
+        .header("X-Pubkey", pubkey_hex)
+        .query(&SearchQueryParams {
+            q: q.trim(),
+            limit,
+        })
+        .send()
+        .await
+        .map_err(|e| format!("request failed: {e}"))?;
+
+    if !response.status().is_success() {
+        return Err(relay_error_message(response).await);
+    }
+
+    response
+        .json::<SearchResponse>()
+        .await
+        .map_err(|e| format!("parse failed: {e}"))
+}
+
+#[tauri::command]
+async fn get_event(event_id: String, state: tauri::State<'_, AppState>) -> Result<String, String> {
+    let request = build_authed_request(
+        &state.http_client,
+        &format!("/api/events/{event_id}"),
+        &state,
+    )
+    .await?;
+    let response = request
+        .send()
+        .await
+        .map_err(|e| format!("request failed: {e}"))?;
+
+    if !response.status().is_success() {
+        return Err(relay_error_message(response).await);
+    }
+
+    response.text().await.map_err(|e| format!("parse failed: {e}"))
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     let app_state = AppState {
@@ -299,6 +374,8 @@ pub fn run() {
             get_channels,
             create_channel,
             get_feed,
+            search_messages,
+            get_event,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");