Merge pull request #49 from zzstoatzz/feature/webhook-settings

feat(webhooks): add webhook settings UI + API and signed delivery on status changes

Cargo.lock

···
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
 name = "hickory-proto"
 version = "0.24.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "dotenv",
  "env_logger",
  "futures-util",
+ "hex",
  "hickory-resolver",
+ "hmac",
  "log",
  "once_cell",
  "rand 0.8.5",
···
  "rocketman",
  "serde",
  "serde_json",
+ "sha2",
  "thiserror",
  "tokio",
+ "url",
 ]
 
 [[package]]

Cargo.toml

···
 rand = "0.8"
 reqwest = { version = "0.12", features = ["json"] }
 once_cell = "1.19"
+hmac = "0.12"
+sha2 = "0.10"
+hex = "0.4"
+url = "2.5"
 
 [build-dependencies]
 askama = "0.13"

src/api/mod.rs

···
 pub mod auth;
 pub mod preferences;
-pub mod status;
+pub mod status_read;
+pub mod status_util;
+pub mod status_write;
+pub mod webhooks;
 
+pub use crate::api::status_util::HandleResolver;
 pub use auth::OAuthClientType;
-pub use status::HandleResolver;
 
 use actix_web::web;
 
···
         .service(auth::login)
         .service(auth::logout)
         .service(auth::login_post)
-        // Status page routes
-        .service(status::home)
-        .service(status::user_status_page)
-        .service(status::feed)
-        // Status JSON API routes
-        .service(status::owner_status_json)
-        .service(status::user_status_json)
-        .service(status::status_json)
-        .service(status::api_feed)
-        // Emoji API routes
-        .service(status::get_frequent_emojis)
-        .service(status::get_custom_emojis)
-        .service(status::upload_emoji)
-        .service(status::get_following)
-        // Status management routes
-        .service(status::status)
-        .service(status::clear_status)
-        .service(status::delete_status)
-        .service(status::hide_status)
+        // Status page routes (read)
+        .service(status_read::home)
+        .service(status_read::user_status_page)
+        .service(status_read::feed)
+        // Status JSON API routes (read)
+        .service(status_read::owner_status_json)
+        .service(status_read::user_status_json)
+        .service(status_read::status_json)
+        .service(status_read::api_feed)
+        // Emoji + following routes
+        .service(status_read::get_frequent_emojis)
+        .service(status_read::get_custom_emojis)
+        .service(status_write::upload_emoji)
+        .service(status_read::get_following)
+        // Status management routes (write)
+        .service(status_write::status)
+        .service(status_write::clear_status)
+        .service(status_write::delete_status)
+        .service(status_write::hide_status)
         // Preferences routes
         .service(preferences::get_preferences)
-        .service(preferences::save_preferences);
+        .service(preferences::save_preferences)
+        // Webhook routes
+        .service(webhooks::list_webhooks)
+        .service(webhooks::create_webhook)
+        .service(webhooks::update_webhook)
+        .service(webhooks::rotate_secret)
+        .service(webhooks::delete_webhook);
 }

src/api/status.rs

···
-use crate::config::Config;
-use crate::emoji::is_builtin_slug;
-use crate::resolver::HickoryDnsTxtResolver;
-use crate::{
-    api::auth::OAuthClientType,
-    config,
-    db::{self, StatusFromDb},
-    dev_utils,
-    error_handler::AppError,
-    lexicons::record::KnownRecord,
-    rate_limiter::RateLimiter,
-    templates::{ErrorTemplate, FeedTemplate, Profile, StatusTemplate},
-};
-use actix_multipart::Multipart;
-use actix_session::Session;
-use actix_web::{
-    HttpRequest, HttpResponse, Responder, Result, get, post,
-    web::{self, Redirect},
-};
-use askama::Template;
-use async_sqlite::{Pool, rusqlite};
-use atrium_api::{
-    agent::Agent,
-    types::string::{Datetime, Did},
-};
-use atrium_common::resolver::Resolver;
-use atrium_identity::{
-    did::CommonDidResolver,
-    handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig},
-};
-use atrium_oauth::DefaultHttpClient;
-use futures_util::TryStreamExt as _;
-use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, sync::Arc};
-
-/// HandleResolver to make it easier to access the OAuthClient in web requests
-pub type HandleResolver = Arc<CommonDidResolver<DefaultHttpClient>>;
-
-/// Admin DID for moderation
-const ADMIN_DID: &str = "did:plc:xbtmt2zjwlrfegqvch7fboei"; // zzstoatzz.io
-
-/// Check if a DID is the admin
-fn is_admin(did: &str) -> bool {
-    did == ADMIN_DID
-}
-
-/// The post body for changing your status
-#[derive(Serialize, Deserialize, Clone)]
-pub struct StatusForm {
-    pub status: String,
-    pub text: Option<String>,
-    pub expires_in: Option<String>, // e.g., "1h", "30m", "1d", etc.
-}
-
-/// The post body for deleting a specific status
-#[derive(Serialize, Deserialize)]
-pub struct DeleteRequest {
-    pub uri: String,
-}
-
-/// Hide/unhide a status (admin only)
-#[derive(Deserialize)]
-pub struct HideStatusRequest {
-    pub uri: String,
-    pub hidden: bool,
-}
-
-/// Parse duration string like "1h", "30m", "1d" into chrono::Duration
-fn parse_duration(duration_str: &str) -> Option<chrono::Duration> {
-    if duration_str.is_empty() {
-        return None;
-    }
-
-    let (num_str, unit) = duration_str.split_at(duration_str.len() - 1);
-    let num: i64 = num_str.parse().ok()?;
-
-    match unit {
-        "m" => Some(chrono::Duration::minutes(num)),
-        "h" => Some(chrono::Duration::hours(num)),
-        "d" => Some(chrono::Duration::days(num)),
-        "w" => Some(chrono::Duration::weeks(num)),
-        _ => None,
-    }
-}
-
-/// Homepage - shows logged-in user's status, or owner's status if not logged in
-#[get("/")]
-pub async fn home(
-    session: Session,
-    _oauth_client: web::Data<OAuthClientType>,
-    db_pool: web::Data<Arc<Pool>>,
-    handle_resolver: web::Data<HandleResolver>,
-) -> Result<impl Responder> {
-    // Default owner of the domain
-    const OWNER_HANDLE: &str = "zzstoatzz.io";
-
-    // Check if user is logged in
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            // User is logged in - show their status page
-            log::debug!("Home: User is logged in with DID: {}", did_string);
-            let did = Did::new(did_string.clone()).expect("failed to parse did");
-
-            // Get their handle
-            let handle = match handle_resolver.resolve(&did).await {
-                Ok(did_doc) => did_doc
-                    .also_known_as
-                    .and_then(|aka| aka.first().map(|h| h.replace("at://", "")))
-                    .unwrap_or_else(|| did_string.clone()),
-                Err(_) => did_string.clone(),
-            };
-
-            // Get user's status
-            let current_status = StatusFromDb::my_status(&db_pool, &did)
-                .await
-                .unwrap_or(None)
-                .and_then(|s| {
-                    // Check if status is expired
-                    if let Some(expires_at) = s.expires_at {
-                        if chrono::Utc::now() > expires_at {
-                            return None; // Status expired
-                        }
-                    }
-                    Some(s)
-                });
-
-            let history = StatusFromDb::load_user_statuses(&db_pool, &did, 10)
-                .await
-                .unwrap_or_else(|err| {
-                    log::error!("Error loading status history: {err}");
-                    vec![]
-                });
-
-            let is_admin_flag = is_admin(did.as_str());
-            let html = StatusTemplate {
-                title: "your status",
-                handle,
-                current_status,
-                history,
-                is_owner: true, // They're viewing their own status
-                is_admin: is_admin_flag,
-            }
-            .render()
-            .expect("template should be valid");
-
-            Ok(web::Html::new(html))
-        }
-        None => {
-            // Not logged in - show owner's status
-            // Resolve owner handle to DID
-            let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
-                dns_txt_resolver: HickoryDnsTxtResolver::default(),
-                http_client: Arc::new(DefaultHttpClient::default()),
-            });
-
-            let owner_handle =
-                atrium_api::types::string::Handle::new(OWNER_HANDLE.to_string()).ok();
-            let owner_did = if let Some(handle) = owner_handle {
-                atproto_handle_resolver.resolve(&handle).await.ok()
-            } else {
-                None
-            };
-
-            let current_status = if let Some(ref did) = owner_did {
-                StatusFromDb::my_status(&db_pool, did)
-                    .await
-                    .unwrap_or(None)
-                    .and_then(|s| {
-                        // Check if status is expired
-                        if let Some(expires_at) = s.expires_at {
-                            if chrono::Utc::now() > expires_at {
-                                return None; // Status expired
-                            }
-                        }
-                        Some(s)
-                    })
-            } else {
-                None
-            };
-
-            let history = if let Some(ref did) = owner_did {
-                StatusFromDb::load_user_statuses(&db_pool, did, 10)
-                    .await
-                    .unwrap_or_else(|err| {
-                        log::error!("Error loading status history: {err}");
-                        vec![]
-                    })
-            } else {
-                vec![]
-            };
-
-            let html = StatusTemplate {
-                title: "nate's status",
-                handle: OWNER_HANDLE.to_string(),
-                current_status,
-                history,
-                is_owner: false, // Visitor viewing owner's status
-                is_admin: false,
-            }
-            .render()
-            .expect("template should be valid");
-
-            Ok(web::Html::new(html))
-        }
-    }
-}
-
-/// View a specific user's status page by handle
-#[get("/@{handle}")]
-pub async fn user_status_page(
-    handle: web::Path<String>,
-    session: Session,
-    db_pool: web::Data<Arc<Pool>>,
-    _handle_resolver: web::Data<HandleResolver>,
-) -> Result<impl Responder> {
-    let handle = handle.into_inner();
-
-    // Resolve handle to DID using ATProto handle resolution
-    // First we need to create a handle resolver
-    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
-        dns_txt_resolver: HickoryDnsTxtResolver::default(),
-        http_client: Arc::new(DefaultHttpClient::default()),
-    });
-
-    let handle_obj = atrium_api::types::string::Handle::new(handle.clone()).ok();
-    let did = match handle_obj {
-        Some(h) => match atproto_handle_resolver.resolve(&h).await {
-            Ok(did) => did,
-            Err(_) => {
-                // Could not resolve handle
-                let html = ErrorTemplate {
-                    title: "User not found",
-                    error: &format!("Could not find user @{}. This handle may not exist or may not be using the ATProto network.", handle),
-                }
-                .render()
-                .expect("template should be valid");
-                return Ok(web::Html::new(html));
-            }
-        },
-        None => {
-            // Invalid handle format
-            let html = ErrorTemplate {
-                title: "Invalid handle",
-                error: &format!(
-                    "'{}' is not a valid handle format. Handles should be like 'alice.bsky.social'",
-                    handle
-                ),
-            }
-            .render()
-            .expect("template should be valid");
-            return Ok(web::Html::new(html));
-        }
-    };
-
-    // Check if logged in user is viewing their own page
-    let is_owner = match session.get::<String>("did").unwrap_or(None) {
-        Some(session_did) => session_did == did.to_string(),
-        None => false,
-    };
-
-    // Get user's status
-    let current_status = StatusFromDb::my_status(&db_pool, &did)
-        .await
-        .unwrap_or(None)
-        .and_then(|s| {
-            // Check if status is expired
-            if let Some(expires_at) = s.expires_at {
-                if chrono::Utc::now() > expires_at {
-                    return None; // Status expired
-                }
-            }
-            Some(s)
-        });
-
-    let history = StatusFromDb::load_user_statuses(&db_pool, &did, 10)
-        .await
-        .unwrap_or_else(|err| {
-            log::error!("Error loading status history: {err}");
-            vec![]
-        });
-
-    let is_admin_flag = match session.get::<String>("did").unwrap_or(None) {
-        Some(d) => is_admin(&d),
-        None => false,
-    };
-    let html = StatusTemplate {
-        title: &format!("@{} status", handle),
-        handle: handle.clone(),
-        current_status,
-        history,
-        is_owner,
-        is_admin: is_admin_flag,
-    }
-    .render()
-    .expect("template should be valid");
-
-    Ok(web::Html::new(html))
-}
-
-/// JSON API for the owner's status (top-level endpoint)
-#[get("/json")]
-pub async fn owner_status_json(
-    db_pool: web::Data<Arc<Pool>>,
-    _handle_resolver: web::Data<HandleResolver>,
-) -> Result<impl Responder> {
-    // Default owner of the domain
-    const OWNER_HANDLE: &str = "zzstoatzz.io";
-
-    // Resolve handle to DID using ATProto handle resolution
-    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
-        dns_txt_resolver: HickoryDnsTxtResolver::default(),
-        http_client: Arc::new(DefaultHttpClient::default()),
-    });
-
-    let did = match atproto_handle_resolver
-        .resolve(&OWNER_HANDLE.parse().expect("failed to parse handle"))
-        .await
-    {
-        Ok(d) => Some(d.to_string()),
-        Err(e) => {
-            log::error!("Failed to resolve handle {}: {}", OWNER_HANDLE, e);
-            None
-        }
-    };
-
-    let current_status = if let Some(did) = did {
-        let did = Did::new(did).expect("failed to parse did");
-        StatusFromDb::my_status(&db_pool, &did)
-            .await
-            .unwrap_or(None)
-            .and_then(|s| {
-                // Check if status is expired
-                if let Some(expires_at) = s.expires_at {
-                    if chrono::Utc::now() > expires_at {
-                        return None; // Status expired
-                    }
-                }
-                Some(s)
-            })
-    } else {
-        None
-    };
-
-    let response = if let Some(status_data) = current_status {
-        serde_json::json!({
-            "handle": OWNER_HANDLE,
-            "status": "known",
-            "emoji": status_data.status,
-            "text": status_data.text,
-            "since": status_data.started_at.to_rfc3339(),
-            "expires": status_data.expires_at.map(|e| e.to_rfc3339()),
-        })
-    } else {
-        serde_json::json!({
-            "handle": OWNER_HANDLE,
-            "status": "unknown",
-            "message": "No current status is known"
-        })
-    };
-
-    Ok(web::Json(response))
-}
-
-/// JSON API for a specific user's status
-#[get("/@{handle}/json")]
-pub async fn user_status_json(
-    handle: web::Path<String>,
-    db_pool: web::Data<Arc<Pool>>,
-    _handle_resolver: web::Data<HandleResolver>,
-) -> Result<impl Responder> {
-    let handle = handle.into_inner();
-
-    // Resolve handle to DID using ATProto handle resolution
-    // First we need to create a handle resolver
-    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
-        dns_txt_resolver: HickoryDnsTxtResolver::default(),
-        http_client: Arc::new(DefaultHttpClient::default()),
-    });
-
-    let handle_obj = atrium_api::types::string::Handle::new(handle.clone()).ok();
-    let did = match handle_obj {
-        Some(h) => match atproto_handle_resolver.resolve(&h).await {
-            Ok(did) => did,
-            Err(_) => {
-                return Ok(web::Json(serde_json::json!({
-                    "status": "unknown",
-                    "message": format!("Could not resolve handle @{}", handle)
-                })));
-            }
-        },
-        None => {
-            return Ok(web::Json(serde_json::json!({
-                "status": "unknown",
-                "message": format!("Invalid handle format: @{}", handle)
-            })));
-        }
-    };
-
-    let current_status = StatusFromDb::my_status(&db_pool, &did)
-        .await
-        .unwrap_or(None)
-        .and_then(|s| {
-            // Check if status is expired
-            if let Some(expires_at) = s.expires_at {
-                if chrono::Utc::now() > expires_at {
-                    return None; // Status expired
-                }
-            }
-            Some(s)
-        });
-
-    let response = if let Some(status_data) = current_status {
-        serde_json::json!({
-            "status": "known",
-            "emoji": status_data.status,
-            "text": status_data.text,
-            "since": status_data.started_at.to_rfc3339(),
-            "expires": status_data.expires_at.map(|e| e.to_rfc3339()),
-        })
-    } else {
-        serde_json::json!({
-            "status": "unknown",
-            "message": format!("No current status is known for @{}", handle)
-        })
-    };
-
-    Ok(web::Json(response))
-}
-
-/// JSON API endpoint for status - returns current status or "unknown"
-#[get("/api/status")]
-pub async fn status_json(db_pool: web::Data<Arc<Pool>>) -> Result<impl Responder> {
-    const OWNER_DID: &str = "did:plc:xbtmt2zjwlrfegqvch7fboei"; // zzstoatzz.io
-
-    let owner_did = Did::new(OWNER_DID.to_string()).ok();
-    let current_status = if let Some(ref did) = owner_did {
-        StatusFromDb::my_status(&db_pool, did)
-            .await
-            .unwrap_or(None)
-            .and_then(|s| {
-                // Check if status is expired
-                if let Some(expires_at) = s.expires_at {
-                    if chrono::Utc::now() > expires_at {
-                        return None; // Status expired
-                    }
-                }
-                Some(s)
-            })
-    } else {
-        None
-    };
-
-    let response = if let Some(status_data) = current_status {
-        serde_json::json!({
-            "status": "known",
-            "emoji": status_data.status,
-            "text": status_data.text,
-            "since": status_data.started_at.to_rfc3339(),
-            "expires": status_data.expires_at.map(|e| e.to_rfc3339()),
-        })
-    } else {
-        serde_json::json!({
-            "status": "unknown",
-            "message": "No current status is known"
-        })
-    };
-
-    Ok(web::Json(response))
-}
-
-/// Feed page - shows all users' statuses
-#[get("/feed")]
-pub async fn feed(
-    request: HttpRequest,
-    session: Session,
-    oauth_client: web::Data<OAuthClientType>,
-    db_pool: web::Data<Arc<Pool>>,
-    handle_resolver: web::Data<HandleResolver>,
-    config: web::Data<config::Config>,
-) -> Result<impl Responder> {
-    // This is essentially the old home function
-    const TITLE: &str = "status feed";
-
-    // Check if dev mode is active
-    let query = request.query_string();
-    let use_dev_mode = config.dev_mode && dev_utils::is_dev_mode_requested(query);
-
-    let mut statuses = if use_dev_mode {
-        // Mix dummy data with real data for testing
-        let mut real_statuses = StatusFromDb::load_latest_statuses(&db_pool)
-            .await
-            .unwrap_or_else(|err| {
-                log::error!("Error loading statuses: {err}");
-                vec![]
-            });
-        let dummy_statuses = dev_utils::generate_dummy_statuses(15);
-        real_statuses.extend(dummy_statuses);
-        // Resort by started_at
-        real_statuses.sort_by(|a, b| b.started_at.cmp(&a.started_at));
-        real_statuses
-    } else {
-        StatusFromDb::load_latest_statuses(&db_pool)
-            .await
-            .unwrap_or_else(|err| {
-                log::error!("Error loading statuses: {err}");
-                vec![]
-            })
-    };
-
-    let mut quick_resolve_map: HashMap<Did, String> = HashMap::new();
-    for db_status in &mut statuses {
-        let authors_did = Did::new(db_status.author_did.clone()).expect("failed to parse did");
-        match quick_resolve_map.get(&authors_did) {
-            None => {}
-            Some(found_handle) => {
-                db_status.handle = Some(found_handle.clone());
-                continue;
-            }
-        }
-        db_status.handle = match handle_resolver.resolve(&authors_did).await {
-            Ok(did_doc) => match did_doc.also_known_as {
-                None => None,
-                Some(also_known_as) => match also_known_as.is_empty() {
-                    true => None,
-                    false => {
-                        let full_handle = also_known_as.first().unwrap();
-                        let handle = full_handle.replace("at://", "");
-                        quick_resolve_map.insert(authors_did, handle.clone());
-                        Some(handle)
-                    }
-                },
-            },
-            Err(err) => {
-                log::error!("Error resolving did: {err}");
-                None
-            }
-        };
-    }
-
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            log::debug!("Feed: User has session with DID: {}", did_string);
-            let did = Did::new(did_string.clone()).expect("failed to parse did");
-            let _my_status = StatusFromDb::my_status(&db_pool, &did)
-                .await
-                .unwrap_or_else(|err| {
-                    log::error!("Error loading my status: {err}");
-                    None
-                });
-
-            log::debug!(
-                "Feed: Attempting to restore OAuth session for DID: {}",
-                did_string
-            );
-            match oauth_client.restore(&did).await {
-                Ok(session) => {
-                    log::debug!("Feed: Successfully restored OAuth session");
-                    let agent = Agent::new(session);
-                    let profile = agent
-                        .api
-                        .app
-                        .bsky
-                        .actor
-                        .get_profile(
-                            atrium_api::app::bsky::actor::get_profile::ParametersData {
-                                actor: atrium_api::types::string::AtIdentifier::Did(did.clone()),
-                            }
-                            .into(),
-                        )
-                        .await;
-
-                    let is_admin = is_admin(did.as_str());
-                    let html = FeedTemplate {
-                        title: TITLE,
-                        profile: match profile {
-                            Ok(profile) => {
-                                let profile_data = Profile {
-                                    did: profile.did.to_string(),
-                                    display_name: profile.display_name.clone(),
-                                    handle: Some(profile.handle.to_string()),
-                                };
-                                Some(profile_data)
-                            }
-                            Err(err) => {
-                                log::error!("Error accessing profile: {err}");
-                                None
-                            }
-                        },
-                        statuses,
-                        is_admin,
-                        dev_mode: use_dev_mode,
-                    }
-                    .render()
-                    .expect("template should be valid");
-
-                    Ok(web::Html::new(html))
-                }
-                Err(err) => {
-                    // Don't purge the session - OAuth tokens might be expired but user is still logged in
-                    log::warn!("Could not restore OAuth session for feed: {:?}", err);
-
-                    // Show feed without profile info instead of error page
-                    let html = FeedTemplate {
-                        title: TITLE,
-                        profile: None,
-                        statuses,
-                        is_admin: is_admin(did.as_str()),
-                        dev_mode: use_dev_mode,
-                    }
-                    .render()
-                    .expect("template should be valid");
-
-                    Ok(web::Html::new(html))
-                }
-            }
-        }
-        None => {
-            let html = FeedTemplate {
-                title: TITLE,
-                profile: None,
-                statuses,
-                is_admin: false,
-                dev_mode: use_dev_mode,
-            }
-            .render()
-            .expect("template should be valid");
-
-            Ok(web::Html::new(html))
-        }
-    }
-}
-
-/// Get paginated statuses for infinite scrolling
-#[get("/api/feed")]
-pub async fn api_feed(
-    query: web::Query<HashMap<String, String>>,
-    db_pool: web::Data<Arc<Pool>>,
-    handle_resolver: web::Data<HandleResolver>,
-    config: web::Data<config::Config>,
-) -> Result<impl Responder> {
-    let offset = query
-        .get("offset")
-        .and_then(|s| s.parse::<i32>().ok())
-        .unwrap_or(0);
-    let limit = query
-        .get("limit")
-        .and_then(|s| s.parse::<i32>().ok())
-        .unwrap_or(20)
-        .min(50); // Cap at 50 items per request
-
-    // Check if dev mode is requested
-    let use_dev_mode = config.dev_mode && query.get("dev").is_some_and(|v| v == "true" || v == "1");
-
-    let mut statuses = if use_dev_mode && offset == 0 {
-        // For first page in dev mode, mix dummy data with real data
-        let mut real_statuses = StatusFromDb::load_statuses_paginated(&db_pool, 0, limit / 2)
-            .await
-            .unwrap_or_else(|err| {
-                log::error!("Error loading paginated statuses: {err}");
-                vec![]
-            });
-        let dummy_statuses = dev_utils::generate_dummy_statuses((limit / 2) as usize);
-        real_statuses.extend(dummy_statuses);
-        real_statuses.sort_by(|a, b| b.started_at.cmp(&a.started_at));
-        real_statuses
-    } else {
-        StatusFromDb::load_statuses_paginated(&db_pool, offset, limit)
-            .await
-            .unwrap_or_else(|err| {
-                log::error!("Error loading statuses: {err}");
-                vec![]
-            })
-    };
-
-    // Resolve handles for each status
-    let mut quick_resolve_map: HashMap<Did, String> = HashMap::new();
-    for db_status in &mut statuses {
-        let authors_did = Did::new(db_status.author_did.clone()).expect("failed to parse did");
-        match quick_resolve_map.get(&authors_did) {
-            None => {}
-            Some(found_handle) => {
-                db_status.handle = Some(found_handle.clone());
-                continue;
-            }
-        }
-        db_status.handle = match handle_resolver.resolve(&authors_did).await {
-            Ok(did_doc) => match did_doc.also_known_as {
-                None => None,
-                Some(also_known_as) => match also_known_as.is_empty() {
-                    true => None,
-                    false => {
-                        let full_handle = also_known_as.first().unwrap();
-                        let handle = full_handle.replace("at://", "");
-                        quick_resolve_map.insert(authors_did, handle.clone());
-                        Some(handle)
-                    }
-                },
-            },
-            Err(_) => None,
-        };
-    }
-
-    Ok(HttpResponse::Ok().json(statuses))
-}
-
-/// Get the most frequently used emojis from all statuses
-#[get("/api/frequent-emojis")]
-pub async fn get_frequent_emojis(db_pool: web::Data<Arc<Pool>>) -> Result<impl Responder> {
-    // Get top 20 most frequently used emojis
-    let emojis = db::get_frequent_emojis(&db_pool, 20)
-        .await
-        .unwrap_or_else(|err| {
-            log::error!("Failed to get frequent emojis: {}", err);
-            Vec::new()
-        });
-
-    // If we have less than 12 emojis, add some defaults to fill it out
-    let mut result = emojis;
-    if result.is_empty() {
-        log::info!("No emoji usage data found, using defaults");
-        let defaults = vec![
-            "😊", "👍", "❤️", "😂", "🎉", "🔥", "✨", "💯", "🚀", "💪", "🙏", "👏",
-        ];
-        result = defaults.into_iter().map(String::from).collect();
-    } else if result.len() < 12 {
-        log::info!("Found {} emojis, padding with defaults", result.len());
-        let defaults = vec![
-            "😊", "👍", "❤️", "😂", "🎉", "🔥", "✨", "💯", "🚀", "💪", "🙏", "👏",
-        ];
-        for emoji in defaults {
-            if !result.contains(&emoji.to_string()) && result.len() < 20 {
-                result.push(emoji.to_string());
-            }
-        }
-    } else {
-        log::info!("Found {} frequently used emojis", result.len());
-    }
-
-    Ok(web::Json(result))
-}
-
-/// Get all custom emojis available on the site
-#[get("/api/custom-emojis")]
-pub async fn get_custom_emojis(app_config: web::Data<Config>) -> Result<impl Responder> {
-    use std::fs;
-
-    #[derive(Serialize)]
-    struct SimpleEmoji {
-        name: String,
-        filename: String,
-    }
-
-    let emojis_dir = app_config.emoji_dir.clone();
-    let mut emojis = Vec::new();
-
-    if let Ok(entries) = fs::read_dir(&emojis_dir) {
-        for entry in entries.flatten() {
-            if let Some(filename) = entry.file_name().to_str() {
-                // Only include image files
-                if filename.ends_with(".png")
-                    || filename.ends_with(".gif")
-                    || filename.ends_with(".jpg")
-                    || filename.ends_with(".webp")
-                {
-                    // Remove file extension to get name
-                    let name = filename
-                        .rsplit_once('.')
-                        .map(|(name, _)| name)
-                        .unwrap_or(filename)
-                        .to_string();
-                    emojis.push(SimpleEmoji {
-                        name: name.clone(),
-                        filename: filename.to_string(),
-                    });
-                }
-            }
-        }
-    }
-
-    // Sort by name
-    emojis.sort_by(|a, b| a.name.cmp(&b.name));
-
-    Ok(HttpResponse::Ok().json(emojis))
-}
-
-/// Admin-only upload of a custom emoji (PNG or GIF)
-#[post("/admin/upload-emoji")]
-pub async fn upload_emoji(
-    session: Session,
-    app_config: web::Data<Config>,
-    mut payload: Multipart,
-) -> Result<impl Responder> {
-    // Require admin
-    let did = match session.get::<String>("did").unwrap_or(None) {
-        Some(d) => d,
-        None => {
-            return Ok(HttpResponse::Unauthorized().json(serde_json::json!({
-                "error": "Not authenticated"
-            })));
-        }
-    };
-    if !is_admin(&did) {
-        return Ok(HttpResponse::Forbidden().json(serde_json::json!({
-            "error": "Admin access required"
-        })));
-    }
-
-    // Parse multipart for optional name and the file
-    let mut desired_name: Option<String> = None;
-    let mut file_bytes: Option<Vec<u8>> = None;
-    let mut file_ext: Option<&'static str> = None; // "png" | "gif"
-
-    const MAX_SIZE: usize = 5 * 1024 * 1024; // 5MB cap
-
-    loop {
-        let mut field = match payload.try_next().await {
-            Ok(Some(f)) => f,
-            Ok(None) => break,
-            Err(e) => {
-                log::warn!("multipart error: {}", e);
-                return Ok(HttpResponse::BadRequest()
-                    .json(serde_json::json!({"error":"Invalid multipart data"})));
-            }
-        };
-        let name = field.name().to_string();
-
-        if name == "name" {
-            // Collect small text field
-            let mut buf = Vec::new();
-            loop {
-                match field.try_next().await {
-                    Ok(Some(chunk)) => {
-                        buf.extend_from_slice(&chunk);
-                        if buf.len() > 1024 {
-                            break;
-                        }
-                    }
-                    Ok(None) => break,
-                    Err(e) => {
-                        log::warn!("multipart read error: {}", e);
-                        return Ok(HttpResponse::BadRequest()
-                            .json(serde_json::json!({"error":"Invalid multipart data"})));
-                    }
-                }
-            }
-            if let Ok(s) = String::from_utf8(buf) {
-                desired_name = Some(s.trim().to_string());
-            }
-            continue;
-        }
-
-        if name == "file" {
-            let ct = field.content_type().cloned();
-            let mut ext_guess: Option<&'static str> = match ct.as_ref().map(|m| m.essence_str()) {
-                Some("image/png") => Some("png"),
-                Some("image/gif") => Some("gif"),
-                _ => None,
-            };
-
-            // Read file bytes with size cap
-            let mut data = Vec::new();
-            loop {
-                match field.try_next().await {
-                    Ok(Some(chunk)) => {
-                        data.extend_from_slice(&chunk);
-                        if data.len() > MAX_SIZE {
-                            return Ok(HttpResponse::BadRequest().json(serde_json::json!({
-                                "error": "File too large (max 5MB)"
-                            })));
-                        }
-                    }
-                    Ok(None) => break,
-                    Err(e) => {
-                        log::warn!("file read error: {}", e);
-                        return Ok(HttpResponse::BadRequest()
-                            .json(serde_json::json!({"error":"Invalid file upload"})));
-                    }
-                }
-            }
-
-            // If content-type was ambiguous, try to infer from magic bytes
-            if ext_guess.is_none() && data.len() >= 4 {
-                if data.starts_with(&[0x89, b'P', b'N', b'G']) {
-                    ext_guess = Some("png");
-                } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
-                    ext_guess = Some("gif");
-                }
-            }
-
-            if ext_guess.is_none() {
-                return Ok(HttpResponse::BadRequest().json(serde_json::json!({
-                    "error": "Unsupported file type (only PNG or GIF)"
-                })));
-            }
-
-            file_ext = ext_guess;
-            file_bytes = Some(data);
-        }
-    }
-
-    let data = match file_bytes {
-        Some(d) => d,
-        None => {
-            return Ok(HttpResponse::BadRequest().json(serde_json::json!({
-                "error": "Missing file field"
-            })));
-        }
-    };
-    let ext = file_ext.unwrap_or("png");
-
-    // Sanitize/derive filename base
-    let base = desired_name
-        .as_ref()
-        .cloned()
-        .unwrap_or_else(|| format!("emoji_{}", chrono::Utc::now().timestamp()));
-    let mut safe: String = base
-        .chars()
-        .filter(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '-')
-        .collect();
-    if safe.is_empty() {
-        safe = "emoji".to_string();
-    }
-    let mut filename = format!("{}.{}", safe.to_lowercase(), ext);
-
-    // Ensure directory exists and avoid overwrite
-    let dir = std::path::Path::new(&app_config.emoji_dir);
-    if let Err(e) = std::fs::create_dir_all(dir) {
-        log::error!("Failed to create emoji dir {}: {}", app_config.emoji_dir, e);
-        return Ok(HttpResponse::InternalServerError().json(serde_json::json!({
-            "error": "Filesystem error"
-        })));
-    }
-
-    // If user provided a name explicitly and it conflicts with a builtin emoji slug, reject
-    if desired_name.is_some() && is_builtin_slug(&safe.to_lowercase()).await {
-        return Ok(HttpResponse::Conflict().json(serde_json::json!({
-            "error": "Name is reserved by a standard emoji.",
-            "code": "name_exists",
-            "name": safe.to_lowercase(),
-        })));
-    }
-
-    // If user provided a name explicitly and that base already exists with any supported
-    // extension, reject with a clear error so the UI can prompt to choose a different name.
-    if desired_name.is_some() {
-        let png_path = dir.join(format!("{}.png", safe.to_lowercase()));
-        let gif_path = dir.join(format!("{}.gif", safe.to_lowercase()));
-        if png_path.exists() || gif_path.exists() {
-            return Ok(HttpResponse::Conflict().json(serde_json::json!({
-                "error": "Name already exists. Choose a different name.",
-                "code": "name_exists",
-                "name": safe.to_lowercase(),
-            })));
-        }
-    }
-
-    let mut path = dir.join(&filename);
-    if path.exists() {
-        // Only auto-deconflict when name wasn't provided explicitly
-        if desired_name.is_none() {
-            for i in 1..1000 {
-                filename = format!("{}-{}.{}", safe.to_lowercase(), i, ext);
-                path = dir.join(&filename);
-                if !path.exists() {
-                    break;
-                }
-            }
-        } else {
-            return Ok(HttpResponse::Conflict().json(serde_json::json!({
-                "error": "Name already exists. Choose a different name.",
-                "code": "name_exists",
-                "name": safe.to_lowercase(),
-            })));
-        }
-    }
-
-    if let Err(e) = std::fs::write(&path, &data) {
-        log::error!("Failed to save emoji to {:?}: {}", path, e);
-        return Ok(HttpResponse::InternalServerError().json(serde_json::json!({
-            "error": "Write failed"
-        })));
-    }
-
-    let url = format!("/emojis/{}", filename);
-    Ok(HttpResponse::Ok().json(serde_json::json!({
-        "success": true,
-        "filename": filename,
-        "url": url
-    })))
-}
-
-/// Get the DIDs of accounts the logged-in user follows
-#[get("/api/following")]
-pub async fn get_following(
-    session: Session,
-    _oauth_client: web::Data<OAuthClientType>,
-) -> Result<impl Responder> {
-    // Check if user is logged in
-    let did = match session.get::<Did>("did").ok().flatten() {
-        Some(did) => did,
-        None => {
-            return Ok(HttpResponse::Unauthorized().json(serde_json::json!({
-                "error": "Not logged in"
-            })));
-        }
-    };
-
-    // WORKAROUND: Call public API directly for getFollows since OAuth scope isn't working
-    // Both getProfile and getFollows are public endpoints that don't require auth
-    // but when called through OAuth, getFollows requires a scope that doesn't exist yet
-
-    let mut all_follows = Vec::new();
-    let mut cursor: Option<String> = None;
-
-    // Use reqwest to call the public API directly
-    let client = reqwest::Client::new();
-
-    loop {
-        let mut url = format!(
-            "https://public.api.bsky.app/xrpc/app.bsky.graph.getFollows?actor={}",
-            did.as_str()
-        );
-
-        if let Some(c) = &cursor {
-            url.push_str(&format!("&cursor={}", c));
-        }
-
-        match client.get(&url).send().await {
-            Ok(response) => {
-                match response.json::<serde_json::Value>().await {
-                    Ok(json) => {
-                        // Extract follows
-                        if let Some(follows) = json["follows"].as_array() {
-                            for follow in follows {
-                                if let Some(did_str) = follow["did"].as_str() {
-                                    all_follows.push(did_str.to_string());
-                                }
-                            }
-                        }
-
-                        // Check for cursor
-                        cursor = json["cursor"].as_str().map(|s| s.to_string());
-                        if cursor.is_none() {
-                            break;
-                        }
-                    }
-                    Err(err) => {
-                        log::error!("Failed to parse follows response: {}", err);
-                        return Ok(HttpResponse::InternalServerError().json(serde_json::json!({
-                            "error": "Failed to parse follows"
-                        })));
-                    }
-                }
-            }
-            Err(err) => {
-                log::error!("Failed to fetch follows from public API: {}", err);
-                return Ok(HttpResponse::InternalServerError().json(serde_json::json!({
-                    "error": "Failed to fetch follows"
-                })));
-            }
-        }
-    }
-
-    Ok(HttpResponse::Ok().json(serde_json::json!({
-        "follows": all_follows
-    })))
-}
-
-/// Clear the user's status by deleting the ATProto record
-#[post("/status/clear")]
-pub async fn clear_status(
-    request: HttpRequest,
-    session: Session,
-    oauth_client: web::Data<OAuthClientType>,
-    db_pool: web::Data<Arc<Pool>>,
-) -> HttpResponse {
-    // Check if the user is logged in
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            let did = Did::new(did_string.clone()).expect("failed to parse did");
-
-            // Get the user's current status to find the record key
-            match StatusFromDb::my_status(&db_pool, &did).await {
-                Ok(Some(current_status)) => {
-                    // Extract the record key from the URI
-                    // URI format: at://did:plc:xxx/io.zzstoatzz.status.record/rkey
-                    let parts: Vec<&str> = current_status.uri.split('/').collect();
-                    if let Some(rkey) = parts.last() {
-                        // Get OAuth session
-                        match oauth_client.restore(&did).await {
-                            Ok(session) => {
-                                let agent = Agent::new(session);
-
-                                // Delete the record from ATProto using com.atproto.repo.deleteRecord
-                                let delete_request =
-                                    atrium_api::com::atproto::repo::delete_record::InputData {
-                                        collection: atrium_api::types::string::Nsid::new(
-                                            "io.zzstoatzz.status.record".to_string(),
-                                        )
-                                        .expect("valid nsid"),
-                                        repo: did.clone().into(),
-                                        rkey: atrium_api::types::string::RecordKey::new(
-                                            rkey.to_string(),
-                                        )
-                                        .expect("valid rkey"),
-                                        swap_commit: None,
-                                        swap_record: None,
-                                    };
-                                match agent
-                                    .api
-                                    .com
-                                    .atproto
-                                    .repo
-                                    .delete_record(delete_request.into())
-                                    .await
-                                {
-                                    Ok(_) => {
-                                        // Also remove from local database
-                                        let _ = StatusFromDb::delete_by_uri(
-                                            &db_pool,
-                                            current_status.uri,
-                                        )
-                                        .await;
-
-                                        Redirect::to("/")
-                                            .see_other()
-                                            .respond_to(&request)
-                                            .map_into_boxed_body()
-                                    }
-                                    Err(e) => {
-                                        log::error!("Failed to delete status from ATProto: {e}");
-                                        HttpResponse::InternalServerError()
-                                            .body("Failed to clear status")
-                                    }
-                                }
-                            }
-                            Err(e) => {
-                                log::error!("Failed to restore OAuth session: {e}");
-                                HttpResponse::InternalServerError().body("Session error")
-                            }
-                        }
-                    } else {
-                        HttpResponse::BadRequest().body("Invalid status URI")
-                    }
-                }
-                Ok(None) => {
-                    // No status to clear
-                    Redirect::to("/")
-                        .see_other()
-                        .respond_to(&request)
-                        .map_into_boxed_body()
-                }
-                Err(e) => {
-                    log::error!("Database error: {e}");
-                    HttpResponse::InternalServerError().body("Database error")
-                }
-            }
-        }
-        None => {
-            // Not logged in
-            Redirect::to("/login")
-                .see_other()
-                .respond_to(&request)
-                .map_into_boxed_body()
-        }
-    }
-}
-
-/// Delete a specific status by URI (JSON endpoint)
-#[post("/status/delete")]
-pub async fn delete_status(
-    session: Session,
-    oauth_client: web::Data<OAuthClientType>,
-    db_pool: web::Data<Arc<Pool>>,
-    req: web::Json<DeleteRequest>,
-) -> HttpResponse {
-    // Check if the user is logged in
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            let did = Did::new(did_string.clone()).expect("failed to parse did");
-
-            // Parse the URI to verify it belongs to this user
-            // URI format: at://did:plc:xxx/io.zzstoatzz.status.record/rkey
-            let uri_parts: Vec<&str> = req.uri.split('/').collect();
-            if uri_parts.len() < 5 {
-                return HttpResponse::BadRequest().json(serde_json::json!({
-                    "error": "Invalid status URI format"
-                }));
-            }
-
-            // Extract DID from URI (at://did:plc:xxx/...)
-            let uri_did_part = uri_parts[2];
-            if uri_did_part != did_string {
-                return HttpResponse::Forbidden().json(serde_json::json!({
-                    "error": "You can only delete your own statuses"
-                }));
-            }
-
-            // Extract record key
-            if let Some(rkey) = uri_parts.last() {
-                // Get OAuth session
-                match oauth_client.restore(&did).await {
-                    Ok(session) => {
-                        let agent = Agent::new(session);
-
-                        // Delete the record from ATProto
-                        let delete_request =
-                            atrium_api::com::atproto::repo::delete_record::InputData {
-                                collection: atrium_api::types::string::Nsid::new(
-                                    "io.zzstoatzz.status.record".to_string(),
-                                )
-                                .expect("valid nsid"),
-                                repo: did.clone().into(),
-                                rkey: atrium_api::types::string::RecordKey::new(rkey.to_string())
-                                    .expect("valid rkey"),
-                                swap_commit: None,
-                                swap_record: None,
-                            };
-
-                        match agent
-                            .api
-                            .com
-                            .atproto
-                            .repo
-                            .delete_record(delete_request.into())
-                            .await
-                        {
-                            Ok(_) => {
-                                // Also remove from local database
-                                let _ =
-                                    StatusFromDb::delete_by_uri(&db_pool, req.uri.clone()).await;
-
-                                HttpResponse::Ok().json(serde_json::json!({
-                                    "success": true
-                                }))
-                            }
-                            Err(e) => {
-                                log::error!("Failed to delete status from ATProto: {e}");
-                                HttpResponse::InternalServerError().json(serde_json::json!({
-                                    "error": "Failed to delete status"
-                                }))
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        log::error!("Failed to restore OAuth session: {e}");
-                        HttpResponse::InternalServerError().json(serde_json::json!({
-                            "error": "Session error"
-                        }))
-                    }
-                }
-            } else {
-                HttpResponse::BadRequest().json(serde_json::json!({
-                    "error": "Invalid status URI"
-                }))
-            }
-        }
-        None => {
-            // Not logged in
-            HttpResponse::Unauthorized().json(serde_json::json!({
-                "error": "Not authenticated"
-            }))
-        }
-    }
-}
-
-/// Hide/unhide a status (admin only)
-#[post("/admin/hide-status")]
-pub async fn hide_status(
-    session: Session,
-    db_pool: web::Data<Arc<Pool>>,
-    req: web::Json<HideStatusRequest>,
-) -> HttpResponse {
-    // Check if the user is logged in and is admin
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            if !is_admin(&did_string) {
-                return HttpResponse::Forbidden().json(serde_json::json!({
-                    "error": "Admin access required"
-                }));
-            }
-
-            // Update the hidden status in the database
-            let uri = req.uri.clone();
-            let hidden = req.hidden;
-
-            let result = db_pool
-                .conn(move |conn| {
-                    conn.execute(
-                        "UPDATE status SET hidden = ?1 WHERE uri = ?2",
-                        rusqlite::params![hidden, uri],
-                    )
-                })
-                .await;
-
-            match result {
-                Ok(rows_affected) if rows_affected > 0 => {
-                    HttpResponse::Ok().json(serde_json::json!({
-                        "success": true,
-                        "message": if hidden { "Status hidden" } else { "Status unhidden" }
-                    }))
-                }
-                Ok(_) => HttpResponse::NotFound().json(serde_json::json!({
-                    "error": "Status not found"
-                })),
-                Err(err) => {
-                    log::error!("Error updating hidden status: {}", err);
-                    HttpResponse::InternalServerError().json(serde_json::json!({
-                        "error": "Database error"
-                    }))
-                }
-            }
-        }
-        None => HttpResponse::Unauthorized().json(serde_json::json!({
-            "error": "Not authenticated"
-        })),
-    }
-}
-
-/// Creates a new status
-#[post("/status")]
-pub async fn status(
-    request: HttpRequest,
-    session: Session,
-    oauth_client: web::Data<OAuthClientType>,
-    db_pool: web::Data<Arc<Pool>>,
-    form: web::Form<StatusForm>,
-    rate_limiter: web::Data<RateLimiter>,
-) -> Result<HttpResponse, AppError> {
-    // Apply rate limiting
-    let client_key = RateLimiter::get_client_key(&request);
-    if !rate_limiter.check_rate_limit(&client_key) {
-        return Err(AppError::RateLimitExceeded);
-    }
-    // Check if the user is logged in
-    match session.get::<String>("did").unwrap_or(None) {
-        Some(did_string) => {
-            let did = Did::new(did_string.clone()).expect("failed to parse did");
-            // gets the user's session from the session store to resume
-            match oauth_client.restore(&did).await {
-                Ok(session) => {
-                    let agent = Agent::new(session);
-
-                    // Calculate expiration time if provided
-                    let expires = form
-                        .expires_in
-                        .as_ref()
-                        .and_then(|exp| parse_duration(exp))
-                        .and_then(|duration| {
-                            let expiry_time = chrono::Utc::now() + duration;
-                            // Convert to ATProto Datetime format (RFC3339)
-                            Some(Datetime::new(expiry_time.to_rfc3339().parse().ok()?))
-                        });
-
-                    //Creates a strongly typed ATProto record
-                    let status: KnownRecord =
-                        crate::lexicons::io::zzstoatzz::status::record::RecordData {
-                            created_at: Datetime::now(),
-                            emoji: form.status.clone(),
-                            text: form.text.clone(),
-                            expires,
-                        }
-                        .into();
-
-                    // TODO no data validation yet from esquema
-                    // Maybe you'd like to add it? https://github.com/fatfingers23/esquema/issues/3
-
-                    let create_result = agent
-                        .api
-                        .com
-                        .atproto
-                        .repo
-                        .create_record(
-                            atrium_api::com::atproto::repo::create_record::InputData {
-                                collection: "io.zzstoatzz.status.record".parse().unwrap(),
-                                repo: did.into(),
-                                rkey: None,
-                                record: status.into(),
-                                swap_commit: None,
-                                validate: None,
-                            }
-                            .into(),
-                        )
-                        .await;
-
-                    match create_result {
-                        Ok(record) => {
-                            let mut status = StatusFromDb::new(
-                                record.uri.clone(),
-                                did_string,
-                                form.status.clone(),
-                            );
-
-                            // Set the text field if provided
-                            status.text = form.text.clone();
-
-                            // Set the expiration time if provided
-                            if let Some(exp_str) = &form.expires_in {
-                                if let Some(duration) = parse_duration(exp_str) {
-                                    status.expires_at = Some(chrono::Utc::now() + duration);
-                                }
-                            }
-
-                            let _ = status.save(db_pool).await;
-                            Ok(Redirect::to("/")
-                                .see_other()
-                                .respond_to(&request)
-                                .map_into_boxed_body())
-                        }
-                        Err(err) => {
-                            log::error!("Error creating status: {err}");
-                            let error_html = ErrorTemplate {
-                                title: "Error",
-                                error: "Was an error creating the status, please check the logs.",
-                            }
-                            .render()
-                            .expect("template should be valid");
-                            Ok(HttpResponse::Ok().body(error_html))
-                        }
-                    }
-                }
-                Err(err) => {
-                    // Destroys the system or you're in a loop
-                    session.purge();
-                    log::error!(
-                        "Error restoring session, we are removing the session from the cookie: {err}"
-                    );
-                    Err(AppError::AuthenticationError("Session error".to_string()))
-                }
-            }
-        }
-        None => Err(AppError::AuthenticationError(
-            "You must be logged in to create a status.".to_string(),
-        )),
-    }
-}

src/api/status_read.rs

···
+use crate::config::Config;
+use crate::db;
+use crate::resolver::HickoryDnsTxtResolver;
+use crate::{
+    api::auth::OAuthClientType,
+    db::StatusFromDb,
+    templates::{ErrorTemplate, FeedTemplate, StatusTemplate},
+};
+use actix_session::Session;
+use actix_web::{Responder, Result, get, web};
+use askama::Template;
+use async_sqlite::Pool;
+use atrium_api::types::string::Did;
+use atrium_common::resolver::Resolver;
+use atrium_identity::handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig};
+use atrium_oauth::DefaultHttpClient;
+use serde_json::json;
+use std::sync::Arc;
+
+use crate::api::status_util::{HandleResolver, is_admin};
+
+/// Homepage - shows logged-in user's status, or owner's status if not logged in
+#[get("/")]
+pub async fn home(
+    session: Session,
+    _oauth_client: web::Data<OAuthClientType>,
+    db_pool: web::Data<Arc<Pool>>,
+    handle_resolver: web::Data<HandleResolver>,
+) -> Result<impl Responder> {
+    // Default owner of the domain
+    const OWNER_HANDLE: &str = "zzstoatzz.io";
+
+    match session.get::<String>("did").unwrap_or(None) {
+        Some(did_string) => {
+            let did = Did::new(did_string.clone()).expect("failed to parse did");
+            let handle = match handle_resolver.resolve(&did).await {
+                Ok(did_doc) => did_doc
+                    .also_known_as
+                    .and_then(|aka| aka.first().map(|h| h.replace("at://", "")))
+                    .unwrap_or_else(|| did_string.clone()),
+                Err(_) => did_string.clone(),
+            };
+            let current_status = StatusFromDb::my_status(&db_pool, &did)
+                .await
+                .unwrap_or(None)
+                .and_then(|s| {
+                    if let Some(expires_at) = s.expires_at {
+                        if chrono::Utc::now() > expires_at {
+                            return None;
+                        }
+                    }
+                    Some(s)
+                });
+            let history = StatusFromDb::load_user_statuses(&db_pool, &did, 10)
+                .await
+                .unwrap_or_else(|err| {
+                    log::error!("Error loading status history: {err}");
+                    vec![]
+                });
+            let is_admin_flag = is_admin(did.as_str());
+            let html = StatusTemplate {
+                title: "your status",
+                handle,
+                current_status,
+                history,
+                is_owner: true,
+                is_admin: is_admin_flag,
+            }
+            .render()
+            .expect("template should be valid");
+            Ok(web::Html::new(html))
+        }
+        None => {
+            let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+                dns_txt_resolver: HickoryDnsTxtResolver::default(),
+                http_client: Arc::new(DefaultHttpClient::default()),
+            });
+            let owner_handle =
+                atrium_api::types::string::Handle::new(OWNER_HANDLE.to_string()).ok();
+            let owner_did = if let Some(handle) = owner_handle {
+                atproto_handle_resolver.resolve(&handle).await.ok()
+            } else {
+                None
+            };
+            let current_status = if let Some(ref did) = owner_did {
+                StatusFromDb::my_status(&db_pool, did)
+                    .await
+                    .unwrap_or(None)
+                    .and_then(|s| {
+                        if let Some(expires_at) = s.expires_at {
+                            if chrono::Utc::now() > expires_at {
+                                return None;
+                            }
+                        }
+                        Some(s)
+                    })
+            } else {
+                None
+            };
+            let history = if let Some(ref did) = owner_did {
+                StatusFromDb::load_user_statuses(&db_pool, did, 10)
+                    .await
+                    .unwrap_or_else(|err| {
+                        log::error!("Error loading status history: {err}");
+                        vec![]
+                    })
+            } else {
+                vec![]
+            };
+            let html = StatusTemplate {
+                title: "nate's status",
+                handle: OWNER_HANDLE.to_string(),
+                current_status,
+                history,
+                is_owner: false,
+                is_admin: false,
+            }
+            .render()
+            .expect("template should be valid");
+            Ok(web::Html::new(html))
+        }
+    }
+}
+
+/// View a specific user's status page by handle
+#[get("/@{handle}")]
+pub async fn user_status_page(
+    handle: web::Path<String>,
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    _handle_resolver: web::Data<HandleResolver>,
+) -> Result<impl Responder> {
+    let handle = handle.into_inner();
+    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+        dns_txt_resolver: HickoryDnsTxtResolver::default(),
+        http_client: Arc::new(DefaultHttpClient::default()),
+    });
+    let handle_obj = atrium_api::types::string::Handle::new(handle.clone()).ok();
+    let did = match handle_obj {
+        Some(h) => match atproto_handle_resolver.resolve(&h).await {
+            Ok(did) => did,
+            Err(_) => {
+                let html = ErrorTemplate {
+                    title: "User not found",
+                    error: &format!("Could not find user @{}.", handle),
+                }
+                .render()
+                .expect("template should be valid");
+                return Ok(web::Html::new(html));
+            }
+        },
+        None => {
+            let html = ErrorTemplate {
+                title: "Invalid handle",
+                error: &format!("'{}' is not a valid handle format.", handle),
+            }
+            .render()
+            .expect("template should be valid");
+            return Ok(web::Html::new(html));
+        }
+    };
+    let is_owner = match session.get::<String>("did").unwrap_or(None) {
+        Some(session_did) => session_did == did.to_string(),
+        None => false,
+    };
+    let current_status = StatusFromDb::my_status(&db_pool, &did)
+        .await
+        .unwrap_or(None)
+        .and_then(|s| {
+            if let Some(expires_at) = s.expires_at {
+                if chrono::Utc::now() > expires_at {
+                    return None;
+                }
+            }
+            Some(s)
+        });
+    let history = StatusFromDb::load_user_statuses(&db_pool, &did, 10)
+        .await
+        .unwrap_or_else(|err| {
+            log::error!("Error loading status history: {err}");
+            vec![]
+        });
+    let html = StatusTemplate {
+        title: &format!("@{} status", handle),
+        handle,
+        current_status,
+        history,
+        is_owner,
+        is_admin: false,
+    }
+    .render()
+    .expect("template should be valid");
+    Ok(web::Html::new(html))
+}
+
+#[get("/json")]
+pub async fn owner_status_json(
+    _session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    _handle_resolver: web::Data<HandleResolver>,
+) -> Result<impl Responder> {
+    // Resolve owner handle to DID (zzstoatzz.io)
+    let owner_handle = atrium_api::types::string::Handle::new("zzstoatzz.io".to_string()).ok();
+    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+        dns_txt_resolver: HickoryDnsTxtResolver::default(),
+        http_client: Arc::new(DefaultHttpClient::default()),
+    });
+    let did = if let Some(handle) = owner_handle {
+        atproto_handle_resolver.resolve(&handle).await.ok()
+    } else {
+        None
+    };
+    let current_status = if let Some(did) = did {
+        StatusFromDb::my_status(&db_pool, &did)
+            .await
+            .unwrap_or(None)
+            .and_then(|s| {
+                if let Some(expires_at) = s.expires_at {
+                    if chrono::Utc::now() > expires_at {
+                        return None;
+                    }
+                }
+                Some(s)
+            })
+    } else {
+        None
+    };
+    let response = if let Some(status_data) = current_status {
+        json!({ "status": "known", "emoji": status_data.status, "text": status_data.text, "since": status_data.started_at.to_rfc3339(), "expires": status_data.expires_at.map(|e| e.to_rfc3339()) })
+    } else {
+        json!({ "status": "unknown", "message": "No current status is known" })
+    };
+    Ok(web::Json(response))
+}
+
+#[get("/@{handle}/json")]
+pub async fn user_status_json(
+    handle: web::Path<String>,
+    _session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+) -> Result<impl Responder> {
+    let handle = handle.into_inner();
+    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+        dns_txt_resolver: HickoryDnsTxtResolver::default(),
+        http_client: Arc::new(DefaultHttpClient::default()),
+    });
+    let handle_obj = atrium_api::types::string::Handle::new(handle.clone()).ok();
+    let did = if let Some(h) = handle_obj {
+        atproto_handle_resolver.resolve(&h).await.ok()
+    } else {
+        None
+    };
+    if let Some(did) = did {
+        let current_status = StatusFromDb::my_status(&db_pool, &did)
+            .await
+            .unwrap_or(None)
+            .and_then(|s| {
+                if let Some(expires_at) = s.expires_at {
+                    if chrono::Utc::now() > expires_at {
+                        return None;
+                    }
+                }
+                Some(s)
+            });
+        let response = if let Some(status_data) = current_status {
+            json!({ "status": "known", "emoji": status_data.status, "text": status_data.text, "since": status_data.started_at.to_rfc3339(), "expires": status_data.expires_at.map(|e| e.to_rfc3339()) })
+        } else {
+            json!({ "status": "unknown", "message": format!("No current status is known for @{}", handle) })
+        };
+        Ok(web::Json(response))
+    } else {
+        Ok(web::Json(
+            json!({ "status": "unknown", "message": format!("Unknown user @{}", handle) }),
+        ))
+    }
+}
+
+#[get("/api/status")]
+pub async fn status_json(db_pool: web::Data<Arc<Pool>>) -> Result<impl Responder> {
+    // Owner: zzstoatzz.io
+    let atproto_handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+        dns_txt_resolver: HickoryDnsTxtResolver::default(),
+        http_client: Arc::new(DefaultHttpClient::default()),
+    });
+    let owner_handle = atrium_api::types::string::Handle::new("zzstoatzz.io".to_string()).ok();
+    let did = if let Some(h) = owner_handle {
+        atproto_handle_resolver.resolve(&h).await.ok()
+    } else {
+        None
+    };
+    let current_status = if let Some(ref did) = did {
+        StatusFromDb::my_status(&db_pool, did)
+            .await
+            .unwrap_or(None)
+            .and_then(|s| {
+                if let Some(expires_at) = s.expires_at {
+                    if chrono::Utc::now() > expires_at {
+                        return None;
+                    }
+                }
+                Some(s)
+            })
+    } else {
+        None
+    };
+    let response = if let Some(status_data) = current_status {
+        json!({ "status": "known", "emoji": status_data.status, "text": status_data.text, "since": status_data.started_at.to_rfc3339(), "expires": status_data.expires_at.map(|e| e.to_rfc3339()) })
+    } else {
+        json!({ "status": "unknown", "message": "No current status is known" })
+    };
+    Ok(web::Json(response))
+}
+
+#[get("/feed")]
+pub async fn feed(
+    session: Session,
+    _db_pool: web::Data<Arc<Pool>>,
+    handle_resolver: web::Data<HandleResolver>,
+    app_config: web::Data<Config>,
+) -> Result<impl Responder> {
+    let did_opt = session.get::<String>("did").unwrap_or(None);
+    let is_admin_flag = did_opt.as_deref().map(is_admin).unwrap_or(false);
+
+    let mut profile: Option<crate::templates::Profile> = None;
+    if let Some(did_str) = did_opt.clone() {
+        let mut handle_opt: Option<String> = None;
+        if let Ok(doc) = handle_resolver
+            .resolve(&atrium_api::types::string::Did::new(did_str.clone()).expect("did"))
+            .await
+        {
+            if let Some(h) = doc.also_known_as.and_then(|aka| aka.first().cloned()) {
+                handle_opt = Some(h.replace("at://", ""));
+            }
+        }
+        profile = Some(crate::templates::Profile {
+            did: did_str,
+            display_name: None,
+            handle: handle_opt,
+        });
+    }
+
+    let html = FeedTemplate {
+        title: "feed",
+        profile,
+        statuses: vec![],
+        is_admin: is_admin_flag,
+        dev_mode: app_config.dev_mode,
+    }
+    .render()
+    .expect("template should be valid");
+    Ok(web::Html::new(html))
+}
+
+#[get("/api/feed")]
+pub async fn api_feed(
+    db_pool: web::Data<Arc<Pool>>,
+    handle_resolver: web::Data<HandleResolver>,
+    query: web::Query<std::collections::HashMap<String, String>>,
+) -> Result<impl Responder> {
+    // Paginated feed
+    let offset = query
+        .get("offset")
+        .and_then(|s| s.parse::<i32>().ok())
+        .unwrap_or(0);
+    let limit = query
+        .get("limit")
+        .and_then(|s| s.parse::<i32>().ok())
+        .unwrap_or(20)
+        .clamp(5, 50);
+
+    let statuses = StatusFromDb::load_statuses_paginated(&db_pool, offset, limit)
+        .await
+        .unwrap_or_default();
+    let mut enriched = Vec::with_capacity(statuses.len());
+    for mut s in statuses {
+        // Resolve handle lazily
+        let did = Did::new(s.author_did.clone()).expect("did");
+        if let Ok(doc) = handle_resolver.resolve(&did).await {
+            if let Some(h) = doc.also_known_as.and_then(|aka| aka.first().cloned()) {
+                s.handle = Some(h.replace("at://", ""));
+            }
+        }
+        enriched.push(s);
+    }
+    let has_more = (enriched.len() as i32) == limit;
+    Ok(web::Json(
+        json!({ "statuses": enriched, "has_more": has_more, "next_offset": offset + (enriched.len() as i32) }),
+    ))
+}
+
+#[get("/api/frequent-emojis")]
+pub async fn get_frequent_emojis(db_pool: web::Data<Arc<Pool>>) -> Result<impl Responder> {
+    let emojis = db::get_frequent_emojis(&db_pool, 20)
+        .await
+        .unwrap_or_default();
+    // Legacy response shape: raw array, not wrapped
+    Ok(web::Json(emojis))
+}
+
+#[get("/api/custom-emojis")]
+pub async fn get_custom_emojis(app_config: web::Data<Config>) -> Result<impl Responder> {
+    // Response shape expected by UI:
+    // [ { "name": "sparkle", "filename": "sparkle.png" }, ... ]
+    let dir = app_config.emoji_dir.clone();
+    let fs_dir = std::path::Path::new(&dir);
+    let fallback = std::path::Path::new("static/emojis");
+
+    let mut map: std::collections::BTreeMap<String, String> = std::collections::BTreeMap::new();
+    let read_dirs = [fs_dir, fallback];
+    for d in read_dirs.iter() {
+        if let Ok(entries) = std::fs::read_dir(d) {
+            for entry in entries.flatten() {
+                let p = entry.path();
+                if let (Some(stem), Some(ext)) = (p.file_stem(), p.extension()) {
+                    let name = stem.to_string_lossy().to_string();
+                    let ext = ext.to_string_lossy().to_ascii_lowercase();
+                    if ext == "png" || ext == "gif" {
+                        // prefer png over gif if duplicates
+                        let filename = format!("{}.{ext}", name);
+                        map.entry(name)
+                            .and_modify(|v| {
+                                if v.ends_with(".gif") && ext == "png" {
+                                    *v = filename.clone();
+                                }
+                            })
+                            .or_insert(filename);
+                    }
+                }
+            }
+        }
+    }
+
+    let custom: Vec<serde_json::Value> = map
+        .into_iter()
+        .map(|(name, filename)| json!({ "name": name, "filename": filename }))
+        .collect();
+    Ok(web::Json(custom))
+}
+
+#[get("/api/following")]
+pub async fn get_following(
+    _session: Session,
+    _oauth_client: web::Data<OAuthClientType>,
+    _db_pool: web::Data<Arc<Pool>>,
+) -> Result<impl Responder> {
+    // Placeholder: follow list disabled here to keep module slim
+    Ok(web::Json(json!({ "follows": [] })))
+}

src/api/status_util.rs

···
+use atrium_identity::did::CommonDidResolver;
+use atrium_oauth::DefaultHttpClient;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// HandleResolver to make it easier to access the OAuthClient in web requests
+pub type HandleResolver = Arc<CommonDidResolver<DefaultHttpClient>>;
+
+/// Admin DID for moderation
+pub const ADMIN_DID: &str = "did:plc:xbtmt2zjwlrfegqvch7fboei"; // zzstoatzz.io
+
+/// Check if a DID is the admin
+pub fn is_admin(did: &str) -> bool {
+    did == ADMIN_DID
+}
+
+/// The post body for changing your status
+#[derive(Serialize, Deserialize, Clone)]
+pub struct StatusForm {
+    pub status: String,
+    pub text: Option<String>,
+    pub expires_in: Option<String>, // e.g., "1h", "30m", "1d", etc.
+}
+
+/// The post body for deleting a specific status
+#[derive(Serialize, Deserialize)]
+pub struct DeleteRequest {
+    pub uri: String,
+}
+
+/// Hide/unhide a status (admin only)
+#[derive(Deserialize)]
+pub struct HideStatusRequest {
+    pub uri: String,
+    pub hidden: bool,
+}
+
+/// Parse duration string like "1h", "30m", "1d" into chrono::Duration
+pub fn parse_duration(duration_str: &str) -> Option<chrono::Duration> {
+    if duration_str.is_empty() {
+        return None;
+    }
+
+    let (num_str, unit) = duration_str.split_at(duration_str.len() - 1);
+    let num: i64 = num_str.parse().ok()?;
+
+    match unit {
+        "m" => Some(chrono::Duration::minutes(num)),
+        "h" => Some(chrono::Duration::hours(num)),
+        "d" => Some(chrono::Duration::days(num)),
+        "w" => Some(chrono::Duration::weeks(num)),
+        _ => None,
+    }
+}

src/api/status_write.rs

···
+use crate::config::Config;
+use crate::{
+    api::auth::OAuthClientType, db::StatusFromDb, error_handler::AppError,
+    lexicons::record::KnownRecord, rate_limiter::RateLimiter,
+};
+use actix_multipart::Multipart;
+use actix_session::Session;
+use actix_web::{HttpRequest, HttpResponse, Responder, post, web};
+use async_sqlite::{Pool, rusqlite};
+use atrium_api::{
+    agent::Agent,
+    types::string::{Datetime, Did},
+};
+use futures_util::TryStreamExt as _;
+use std::sync::Arc;
+
+use crate::api::status_util::{HideStatusRequest, StatusForm, parse_duration};
+
+#[post("/admin/upload-emoji")]
+pub async fn upload_emoji(
+    session: Session,
+    mut payload: Multipart,
+    app_config: web::Data<Config>,
+) -> Result<impl Responder, AppError> {
+    if session.get::<String>("did").unwrap_or(None).is_none() {
+        return Ok(HttpResponse::Unauthorized().body("Not authenticated"));
+    }
+    let mut name: Option<String> = None;
+    let mut file_bytes: Option<Vec<u8>> = None;
+    while let Some(item) = payload
+        .try_next()
+        .await
+        .map_err(|e| AppError::ValidationError(e.to_string()))?
+    {
+        let mut field = item;
+        let disp = field.content_disposition().clone();
+        let field_name = disp.get_name().unwrap_or("");
+        if field_name == "name" {
+            let mut buf = Vec::new();
+            while let Some(chunk) = field
+                .try_next()
+                .await
+                .map_err(|e| AppError::ValidationError(e.to_string()))?
+            {
+                buf.extend_from_slice(&chunk);
+            }
+            name = Some(String::from_utf8_lossy(&buf).trim().to_string());
+        } else if field_name == "file" {
+            let mut buf = Vec::new();
+            while let Some(chunk) = field
+                .try_next()
+                .await
+                .map_err(|e| AppError::ValidationError(e.to_string()))?
+            {
+                buf.extend_from_slice(&chunk);
+            }
+            file_bytes = Some(buf);
+        }
+    }
+    let file_bytes = file_bytes.ok_or_else(|| AppError::ValidationError("No file".into()))?;
+    // Basic validation omitted for brevity
+    let emoji_dir = app_config.emoji_dir.clone();
+    let filename = name
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| format!("emoji_{}", chrono::Utc::now().timestamp()));
+    let path_png = format!("{}/{}.png", emoji_dir, filename);
+    std::fs::write(&path_png, &file_bytes).map_err(|e| AppError::ValidationError(e.to_string()))?;
+    Ok(HttpResponse::Ok().json(serde_json::json!({"ok": true, "name": filename})))
+}
+
+/// Clear the user's status by deleting the ATProto record
+#[post("/status/clear")]
+pub async fn clear_status(
+    request: HttpRequest,
+    session: Session,
+    oauth_client: web::Data<OAuthClientType>,
+    db_pool: web::Data<Arc<Pool>>,
+) -> HttpResponse {
+    match session.get::<String>("did").unwrap_or(None) {
+        Some(did_string) => {
+            let did = Did::new(did_string.clone()).expect("failed to parse did");
+            match StatusFromDb::my_status(&db_pool, &did).await {
+                Ok(Some(current_status)) => {
+                    let parts: Vec<&str> = current_status.uri.split('/').collect();
+                    if let Some(rkey) = parts.last() {
+                        match oauth_client.restore(&did).await {
+                            Ok(session) => {
+                                let agent = Agent::new(session);
+                                let delete_request =
+                                    atrium_api::com::atproto::repo::delete_record::InputData {
+                                        collection: atrium_api::types::string::Nsid::new(
+                                            "io.zzstoatzz.status.record".to_string(),
+                                        )
+                                        .expect("valid nsid"),
+                                        repo: did.clone().into(),
+                                        rkey: atrium_api::types::string::RecordKey::new(
+                                            rkey.to_string(),
+                                        )
+                                        .expect("valid rkey"),
+                                        swap_commit: None,
+                                        swap_record: None,
+                                    };
+                                match agent
+                                    .api
+                                    .com
+                                    .atproto
+                                    .repo
+                                    .delete_record(delete_request.into())
+                                    .await
+                                {
+                                    Ok(_) => {
+                                        let _ = StatusFromDb::delete_by_uri(
+                                            &db_pool,
+                                            current_status.uri.clone(),
+                                        )
+                                        .await;
+                                        let pool = db_pool.get_ref().clone();
+                                        let did_for_event = did_string.clone();
+                                        let uri = current_status.uri.clone();
+                                        tokio::spawn(async move {
+                                            crate::webhooks::emit_deleted(
+                                                pool,
+                                                &did_for_event,
+                                                &uri,
+                                            )
+                                            .await;
+                                        });
+                                        web::Redirect::to("/")
+                                            .see_other()
+                                            .respond_to(&request)
+                                            .map_into_boxed_body()
+                                    }
+                                    Err(e) => {
+                                        log::error!("Failed to delete status from ATProto: {e}");
+                                        HttpResponse::InternalServerError()
+                                            .body("Failed to clear status")
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                log::error!("Failed to restore OAuth session: {e}");
+                                HttpResponse::InternalServerError().body("Session error")
+                            }
+                        }
+                    } else {
+                        HttpResponse::BadRequest().body("Invalid status URI")
+                    }
+                }
+                Ok(None) => web::Redirect::to("/")
+                    .see_other()
+                    .respond_to(&request)
+                    .map_into_boxed_body(),
+                Err(e) => {
+                    log::error!("Database error: {e}");
+                    HttpResponse::InternalServerError().body("Database error")
+                }
+            }
+        }
+        None => web::Redirect::to("/login")
+            .see_other()
+            .respond_to(&request)
+            .map_into_boxed_body(),
+    }
+}
+
+/// Delete a specific status by URI (JSON endpoint)
+#[post("/status/delete")]
+pub async fn delete_status(
+    session: Session,
+    oauth_client: web::Data<OAuthClientType>,
+    db_pool: web::Data<Arc<Pool>>,
+    req: web::Json<crate::api::status_util::DeleteRequest>,
+) -> HttpResponse {
+    match session.get::<String>("did").unwrap_or(None) {
+        Some(did_string) => {
+            let did = Did::new(did_string.clone()).expect("failed to parse did");
+            let uri_parts: Vec<&str> = req.uri.split('/').collect();
+            if uri_parts.len() < 5 {
+                return HttpResponse::BadRequest()
+                    .json(serde_json::json!({"error":"Invalid status URI format"}));
+            }
+            let uri_did_part = uri_parts[2];
+            if uri_did_part != did_string {
+                return HttpResponse::Forbidden()
+                    .json(serde_json::json!({"error":"You can only delete your own statuses"}));
+            }
+            if let Some(rkey) = uri_parts.last() {
+                match oauth_client.restore(&did).await {
+                    Ok(session) => {
+                        let agent = Agent::new(session);
+                        let delete_request =
+                            atrium_api::com::atproto::repo::delete_record::InputData {
+                                collection: atrium_api::types::string::Nsid::new(
+                                    "io.zzstoatzz.status.record".to_string(),
+                                )
+                                .expect("valid nsid"),
+                                repo: did.clone().into(),
+                                rkey: atrium_api::types::string::RecordKey::new(rkey.to_string())
+                                    .expect("valid rkey"),
+                                swap_commit: None,
+                                swap_record: None,
+                            };
+                        match agent
+                            .api
+                            .com
+                            .atproto
+                            .repo
+                            .delete_record(delete_request.into())
+                            .await
+                        {
+                            Ok(_) => {
+                                let _ =
+                                    StatusFromDb::delete_by_uri(&db_pool, req.uri.clone()).await;
+                                let pool = db_pool.get_ref().clone();
+                                let did_for_event = did_string.clone();
+                                let uri = req.uri.clone();
+                                tokio::spawn(async move {
+                                    crate::webhooks::emit_deleted(pool, &did_for_event, &uri).await;
+                                });
+                                HttpResponse::Ok().json(serde_json::json!({"success":true}))
+                            }
+                            Err(e) => {
+                                log::error!("Failed to delete status from ATProto: {e}");
+                                HttpResponse::InternalServerError()
+                                    .json(serde_json::json!({"error":"Failed to delete status"}))
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("Failed to restore OAuth session: {e}");
+                        HttpResponse::InternalServerError()
+                            .json(serde_json::json!({"error":"Session error"}))
+                    }
+                }
+            } else {
+                HttpResponse::BadRequest().json(serde_json::json!({"error":"Invalid status URI"}))
+            }
+        }
+        None => HttpResponse::Unauthorized().json(serde_json::json!({"error":"Not authenticated"})),
+    }
+}
+
+/// Hide/unhide a status (admin only)
+#[post("/admin/hide-status")]
+pub async fn hide_status(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    req: web::Json<HideStatusRequest>,
+) -> HttpResponse {
+    match session.get::<String>("did").unwrap_or(None) {
+        Some(did_string) => {
+            if did_string != crate::api::status_util::ADMIN_DID {
+                return HttpResponse::Forbidden()
+                    .json(serde_json::json!({"error":"Admin access required"}));
+            }
+            let uri = req.uri.clone();
+            let hidden = req.hidden;
+            let result = db_pool
+                .conn(move |conn| {
+                    conn.execute(
+                        "UPDATE status SET hidden = ?1 WHERE uri = ?2",
+                        rusqlite::params![hidden, uri],
+                    )
+                })
+                .await;
+            match result {
+                Ok(rows_affected) if rows_affected > 0 => HttpResponse::Ok().json(serde_json::json!({"success":true,"message": if hidden {"Status hidden"} else {"Status unhidden"}})),
+                Ok(_) => HttpResponse::NotFound().json(serde_json::json!({"error":"Status not found"})),
+                Err(err) => { log::error!("Error updating hidden status: {}", err); HttpResponse::InternalServerError().json(serde_json::json!({"error":"Database error"})) }
+            }
+        }
+        None => HttpResponse::Unauthorized().json(serde_json::json!({"error":"Not authenticated"})),
+    }
+}
+
+/// Creates a new status
+#[post("/status")]
+pub async fn status(
+    request: HttpRequest,
+    session: Session,
+    oauth_client: web::Data<OAuthClientType>,
+    db_pool: web::Data<Arc<Pool>>,
+    form: web::Form<StatusForm>,
+    rate_limiter: web::Data<RateLimiter>,
+) -> Result<HttpResponse, AppError> {
+    let client_key = RateLimiter::get_client_key(&request);
+    if !rate_limiter.check_rate_limit(&client_key) {
+        return Err(AppError::RateLimitExceeded);
+    }
+    match session.get::<String>("did").unwrap_or(None) {
+        Some(did_string) => {
+            let did = Did::new(did_string.clone()).expect("failed to parse did");
+            match oauth_client.restore(&did).await {
+                Ok(session) => {
+                    let agent = Agent::new(session);
+                    let expires = form
+                        .expires_in
+                        .as_ref()
+                        .and_then(|exp| parse_duration(exp))
+                        .and_then(|duration| {
+                            let expiry_time = chrono::Utc::now() + duration;
+                            Some(Datetime::new(expiry_time.to_rfc3339().parse().ok()?))
+                        });
+                    let status: KnownRecord =
+                        crate::lexicons::io::zzstoatzz::status::record::RecordData {
+                            created_at: Datetime::now(),
+                            emoji: form.status.clone(),
+                            text: form.text.clone(),
+                            expires,
+                        }
+                        .into();
+                    let create_result = agent
+                        .api
+                        .com
+                        .atproto
+                        .repo
+                        .create_record(
+                            atrium_api::com::atproto::repo::create_record::InputData {
+                                collection: "io.zzstoatzz.status.record".parse().unwrap(),
+                                repo: did.into(),
+                                rkey: None,
+                                record: status.into(),
+                                swap_commit: None,
+                                validate: None,
+                            }
+                            .into(),
+                        )
+                        .await;
+                    match create_result {
+                        Ok(record) => {
+                            let mut status = StatusFromDb::new(
+                                record.uri.clone(),
+                                did_string,
+                                form.status.clone(),
+                            );
+                            status.text = form.text.clone();
+                            if let Some(exp_str) = &form.expires_in {
+                                if let Some(duration) = parse_duration(exp_str) {
+                                    status.expires_at = Some(chrono::Utc::now() + duration);
+                                }
+                            }
+                            let _ = status.save(db_pool.clone()).await;
+                            {
+                                let pool = db_pool.get_ref().clone();
+                                let s = status.clone();
+                                tokio::spawn(async move {
+                                    crate::webhooks::emit_created(pool, &s).await;
+                                });
+                            }
+                            Ok(web::Redirect::to("/")
+                                .see_other()
+                                .respond_to(&request)
+                                .map_into_boxed_body())
+                        }
+                        Err(err) => {
+                            log::error!("Error creating status: {err}");
+                            Ok(HttpResponse::Ok()
+                                .body("Was an error creating the status, please check the logs."))
+                        }
+                    }
+                }
+                Err(err) => {
+                    session.purge();
+                    log::error!("Error restoring session: {err}");
+                    Err(AppError::AuthenticationError("Session error".to_string()))
+                }
+            }
+        }
+        None => Err(AppError::AuthenticationError(
+            "You must be logged in to create a status.".to_string(),
+        )),
+    }
+}

src/api/webhooks.rs

···
+use crate::{config::Config, db, error_handler::AppError};
+use actix_session::Session;
+use actix_web::{HttpResponse, Responder, Result, delete, get, post, put, web};
+use async_sqlite::Pool;
+use atrium_api::types::string::Did;
+use serde::Deserialize;
+use std::sync::Arc;
+use url::Url;
+
+#[derive(Deserialize)]
+pub struct CreateWebhookRequest {
+    pub url: String,
+    pub secret: Option<String>,
+    pub events: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateWebhookRequest {
+    pub url: Option<String>,
+    pub events: Option<String>,
+    pub active: Option<bool>,
+}
+
+#[get("/api/webhooks")]
+pub async fn list_webhooks(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+) -> Result<impl Responder> {
+    let did = session.get::<Did>("did")?;
+    if let Some(did) = did {
+        let hooks = db::get_user_webhooks(&db_pool, did.as_str())
+            .await
+            .map_err(|e| AppError::DatabaseError(e.to_string()))?;
+        let response: Vec<serde_json::Value> = hooks
+            .into_iter()
+            .map(|h| {
+                serde_json::json!({
+                    "id": h.id,
+                    "url": h.url,
+                    "events": h.events,
+                    "active": h.active,
+                    "created_at": h.created_at,
+                    "updated_at": h.updated_at,
+                    "secret_masked": h.masked_secret()
+                })
+            })
+            .collect();
+        Ok(web::Json(serde_json::json!({ "webhooks": response })))
+    } else {
+        Ok(web::Json(
+            serde_json::json!({ "error": "Not authenticated" }),
+        ))
+    }
+}
+
+#[post("/api/webhooks")]
+pub async fn create_webhook(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    app_config: web::Data<Config>,
+    payload: web::Json<CreateWebhookRequest>,
+) -> Result<impl Responder> {
+    let did = session.get::<Did>("did")?;
+    if let Some(did) = did {
+        // Robust URL + SSRF validation
+        if let Err(msg) = validate_url(&payload.url, &app_config) {
+            return Ok(web::Json(serde_json::json!({ "error": msg })));
+        }
+        // Events validation
+        if let Some(events_str) = &payload.events {
+            if let Err(msg) = validate_events(events_str) {
+                return Ok(web::Json(serde_json::json!({ "error": msg })));
+            }
+        }
+        let (id, secret) = db::create_webhook(
+            &db_pool,
+            did.as_str(),
+            &payload.url,
+            payload.secret.as_deref(),
+            payload.events.as_deref(),
+        )
+        .await
+        .map_err(|e| AppError::DatabaseError(e.to_string()))?;
+
+        Ok(web::Json(serde_json::json!({
+            "id": id,
+            "secret": secret, // Only returned once on creation
+        })))
+    } else {
+        Ok(web::Json(
+            serde_json::json!({ "error": "Not authenticated" }),
+        ))
+    }
+}
+
+#[put("/api/webhooks/{id}")]
+pub async fn update_webhook(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    path: web::Path<i64>,
+    payload: web::Json<UpdateWebhookRequest>,
+    app_config: web::Data<Config>,
+) -> impl Responder {
+    match session.get::<Did>("did").unwrap_or(None) {
+        Some(did) => {
+            let id = path.into_inner();
+            if let Some(url) = &payload.url {
+                if let Err(msg) = validate_url(url, &app_config) {
+                    return HttpResponse::BadRequest().json(serde_json::json!({ "error": msg }));
+                }
+            }
+            if let Some(events_str) = &payload.events {
+                if let Err(msg) = validate_events(events_str) {
+                    return HttpResponse::BadRequest().json(serde_json::json!({ "error": msg }));
+                }
+            }
+            let res = db::update_webhook(
+                &db_pool,
+                did.as_str(),
+                id,
+                payload.url.as_deref(),
+                payload.events.as_deref(),
+                payload.active,
+            )
+            .await;
+            match res {
+                Ok(_) => HttpResponse::Ok().json(serde_json::json!({ "success": true })),
+                Err(e) => HttpResponse::InternalServerError()
+                    .json(serde_json::json!({ "error": e.to_string() })),
+            }
+        }
+        None => {
+            HttpResponse::Unauthorized().json(serde_json::json!({ "error": "Not authenticated" }))
+        }
+    }
+}
+
+fn validate_events(s: &str) -> Result<(), &'static str> {
+    if s.trim().is_empty() {
+        return Ok(());
+    }
+    const ALLOWED: &[&str] = &["status.created", "status.deleted"];
+    for ev in s.split(',').map(|e| e.trim()) {
+        if !ALLOWED.contains(&ev) {
+            return Err("Unsupported event type");
+        }
+    }
+    Ok(())
+}
+
+fn validate_url(raw: &str, cfg: &Config) -> Result<(), &'static str> {
+    let url = Url::parse(raw).map_err(|_| "Invalid URL")?;
+    let scheme = url.scheme();
+    let host = url.host_str().ok_or("Missing host")?.to_ascii_lowercase();
+
+    // Treat localhost explicitly
+    let host_is_localname = host == "localhost";
+
+    // If host is an IP literal, apply standard library checks
+    let ip_check_blocks = if let Ok(ip) = host.parse::<std::net::IpAddr>() {
+        match ip {
+            std::net::IpAddr::V4(v4) => {
+                v4.is_private()
+                    || v4.is_loopback()
+                    || v4.is_link_local()
+                    || v4.is_multicast()
+                    || v4.is_unspecified()
+            }
+            std::net::IpAddr::V6(v6) => {
+                v6.is_unique_local() || v6.is_loopback() || v6.is_multicast() || v6.is_unspecified()
+            }
+        }
+    } else {
+        false
+    };
+
+    // Enforce HTTPS in production
+    let is_production = !cfg.oauth_redirect_base.starts_with("http://localhost")
+        && !cfg.oauth_redirect_base.starts_with("http://127.0.0.1");
+    if is_production && scheme != "https" {
+        return Err("HTTPS required in production");
+    }
+
+    // Basic SSRF protection in production
+    if (host_is_localname || ip_check_blocks) && is_production {
+        return Err("Private/local hosts not allowed");
+    }
+
+    Ok(())
+}
+
+#[post("/api/webhooks/{id}/rotate")]
+pub async fn rotate_secret(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    path: web::Path<i64>,
+) -> impl Responder {
+    match session.get::<Did>("did").unwrap_or(None) {
+        Some(did) => {
+            let id = path.into_inner();
+            match db::rotate_webhook_secret(&db_pool, did.as_str(), id).await {
+                Ok(new_secret) => {
+                    HttpResponse::Ok().json(serde_json::json!({ "secret": new_secret }))
+                }
+                Err(e) => HttpResponse::InternalServerError()
+                    .json(serde_json::json!({ "error": e.to_string() })),
+            }
+        }
+        None => {
+            HttpResponse::Unauthorized().json(serde_json::json!({ "error": "Not authenticated" }))
+        }
+    }
+}
+
+#[delete("/api/webhooks/{id}")]
+pub async fn delete_webhook(
+    session: Session,
+    db_pool: web::Data<Arc<Pool>>,
+    path: web::Path<i64>,
+) -> impl Responder {
+    match session.get::<Did>("did").unwrap_or(None) {
+        Some(did) => {
+            let id = path.into_inner();
+            match db::delete_webhook(&db_pool, did.as_str(), id).await {
+                Ok(_) => HttpResponse::Ok().json(serde_json::json!({ "success": true })),
+                Err(e) => HttpResponse::InternalServerError()
+                    .json(serde_json::json!({ "error": e.to_string() })),
+            }
+        }
+        None => {
+            HttpResponse::Unauthorized().json(serde_json::json!({ "error": "Not authenticated" }))
+        }
+    }
+}

src/db/mod.rs

···
 pub mod models;
 pub mod queries;
+pub mod webhooks;
 
 pub use models::{AuthSession, AuthState, StatusFromDb};
 pub use queries::{get_frequent_emojis, get_user_preferences, save_user_preferences};
+pub use webhooks::{
+    Webhook, create_webhook, delete_webhook, get_user_webhooks, rotate_webhook_secret,
+    update_webhook,
+};
 
 use async_sqlite::Pool;
 
···
             accent_color TEXT DEFAULT '#1DA1F2',
             updated_at INTEGER NOT NULL
         )",
+            [],
+        )
+        .unwrap();
+
+        // webhooks
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS webhooks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            did TEXT NOT NULL,
+            url TEXT NOT NULL,
+            secret TEXT NOT NULL,
+            events TEXT DEFAULT '*',
+            active BOOLEAN DEFAULT TRUE,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+        )",
+            [],
+        )
+        .unwrap();
+
+        // index for fast lookups by did
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_webhooks_did ON webhooks(did)",
             [],
         )
         .unwrap();

src/db/models.rs

···
     }
 
     /// Loads the last 10 statuses we have saved
+    #[allow(dead_code)]
     pub async fn load_latest_statuses(
         pool: &Data<Arc<Pool>>,
     ) -> Result<Vec<Self>, async_sqlite::Error> {
···
     }
 
     /// Loads paginated statuses for infinite scrolling
+    #[allow(dead_code)]
     pub async fn load_statuses_paginated(
         pool: &Data<Arc<Pool>>,
         offset: i32,

src/db/webhooks.rs

···
+use async_sqlite::Pool;
+use rand::{Rng, distributions::Alphanumeric};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Webhook {
+    pub id: i64,
+    pub did: String,
+    pub url: String,
+    pub secret: String,
+    pub events: String, // comma-separated or "*"
+    pub active: bool,
+    pub created_at: i64,
+    pub updated_at: i64,
+}
+
+impl Webhook {
+    fn now() -> i64 {
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as i64
+    }
+
+    pub fn masked_secret(&self) -> String {
+        let len = self.secret.len();
+        if len <= 4 {
+            return "****".to_string();
+        }
+        let suffix = &self.secret[len - 4..];
+        format!("****{}", suffix)
+    }
+}
+
+pub fn generate_secret() -> String {
+    rand::thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(40)
+        .map(char::from)
+        .collect()
+}
+
+pub async fn get_user_webhooks(
+    pool: &Pool,
+    did: &str,
+) -> Result<Vec<Webhook>, async_sqlite::Error> {
+    let did = did.to_string();
+    pool.conn(move |conn| {
+        let mut stmt = conn.prepare(
+            "SELECT id, did, url, secret, events, COALESCE(active, 1), created_at, updated_at FROM webhooks WHERE did = ?1 ORDER BY id DESC",
+        )?;
+        let iter = stmt.query_map([&did], |row| {
+            Ok(Webhook {
+                id: row.get(0)?,
+                did: row.get(1)?,
+                url: row.get(2)?,
+                secret: row.get(3)?,
+                events: row.get(4)?,
+                active: row.get::<_, Option<bool>>(5)?.unwrap_or(true),
+                created_at: row.get(6)?,
+                updated_at: row.get(7)?,
+            })
+        })?;
+        let mut v = Vec::new();
+        for item in iter {
+            v.push(item?);
+        }
+        Ok(v)
+    })
+    .await
+}
+
+pub async fn create_webhook(
+    pool: &Pool,
+    did: &str,
+    url: &str,
+    secret_opt: Option<&str>,
+    events: Option<&str>,
+) -> Result<(i64, String), async_sqlite::Error> {
+    let secret = secret_opt.unwrap_or(&generate_secret()).to_string();
+    let now = Webhook::now();
+    let did_owned = did.to_string();
+    let url_owned = url.to_string();
+    let events_owned = events.unwrap_or("*").to_string();
+    let secret_for_insert = secret.clone();
+
+    let id = pool
+        .conn(move |conn| {
+            conn.execute(
+                "INSERT INTO webhooks (did, url, secret, events, active, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, 1, ?5, ?6)",
+                (&did_owned, &url_owned, &secret_for_insert, &events_owned, now, now),
+            )?;
+            Ok(conn.last_insert_rowid())
+        })
+        .await?;
+    Ok((id, secret))
+}
+
+pub async fn update_webhook(
+    pool: &Pool,
+    did: &str,
+    id: i64,
+    url: Option<&str>,
+    events: Option<&str>,
+    active: Option<bool>,
+) -> Result<(), async_sqlite::Error> {
+    let now = Webhook::now();
+    let did_owned = did.to_string();
+    let url_owned = url.map(|s| s.to_string());
+    let events_owned = events.map(|s| s.to_string());
+    pool.conn(move |conn| {
+        // Ensure ownership
+        let mut check = conn.prepare("SELECT COUNT(*) FROM webhooks WHERE id = ?1 AND did = ?2")?;
+        let count: i64 = check.query_row((id, &did_owned), |row| row.get(0))?;
+        if count == 0 {
+            return Ok(0);
+        }
+
+        // Build dynamic update
+        let mut fields = Vec::new();
+        if url_owned.is_some() {
+            fields.push("url = ?");
+        }
+        if events_owned.is_some() {
+            fields.push("events = ?");
+        }
+        if active.is_some() {
+            fields.push("active = ?");
+        }
+        fields.push("updated_at = ?");
+        let sql = format!(
+            "UPDATE webhooks SET {} WHERE id = ? AND did = ?",
+            fields.join(", ")
+        );
+
+        let mut stmt = conn.prepare(&sql)?;
+        let mut params: Vec<Box<dyn async_sqlite::rusqlite::ToSql>> = Vec::new();
+        if let Some(u) = url_owned {
+            params.push(Box::new(u));
+        }
+        if let Some(e) = events_owned {
+            params.push(Box::new(e));
+        }
+        if let Some(a) = active {
+            params.push(Box::new(a));
+        }
+        params.push(Box::new(now));
+        params.push(Box::new(id));
+        params.push(Box::new(did_owned));
+
+        let params_ref: Vec<&dyn async_sqlite::rusqlite::ToSql> =
+            params.iter().map(|b| &**b).collect();
+        let _ = stmt.execute(params_ref.as_slice())?;
+        Ok(1)
+    })
+    .await?;
+    Ok(())
+}
+
+pub async fn rotate_webhook_secret(
+    pool: &Pool,
+    did: &str,
+    id: i64,
+) -> Result<String, async_sqlite::Error> {
+    let new_secret = generate_secret();
+    let now = Webhook::now();
+    let did_owned = did.to_string();
+    let new_for_update = new_secret.clone();
+    pool.conn(move |conn| {
+        let mut stmt = conn.prepare(
+            "UPDATE webhooks SET secret = ?1, updated_at = ?2 WHERE id = ?3 AND did = ?4",
+        )?;
+        let _ = stmt.execute((&new_for_update, now, id, &did_owned))?;
+        Ok(())
+    })
+    .await?;
+    Ok(new_secret)
+}
+
+pub async fn delete_webhook(pool: &Pool, did: &str, id: i64) -> Result<(), async_sqlite::Error> {
+    let did_owned = did.to_string();
+    pool.conn(move |conn| {
+        let mut stmt = conn.prepare("DELETE FROM webhooks WHERE id = ?1 AND did = ?2")?;
+        let _ = stmt.execute((id, &did_owned))?;
+        Ok(())
+    })
+    .await?;
+    Ok(())
+}

src/dev_utils.rs

···
 use rand::prelude::*;
 
 /// Generate dummy status data for development testing
+#[allow(dead_code)]
 pub fn generate_dummy_statuses(count: usize) -> Vec<StatusFromDb> {
     let mut rng = thread_rng();
     let mut statuses = Vec::new();
···
 }
 
 /// Check if dev mode is requested via query parameter
+#[allow(dead_code)]
 pub fn is_dev_mode_requested(query: &str) -> bool {
     query.contains("dev=true") || query.contains("dev=1")
 }

src/emoji.rs

···
     }
 }
 
+#[allow(dead_code)]
 static BUILTIN_SLUGS: OnceCell<Arc<HashSet<String>>> = OnceCell::new();
 
+#[allow(dead_code)]
 async fn load_builtin_slugs_inner() -> Arc<HashSet<String>> {
     // Fetch emoji data and collect first short_name as slug
     let url = "https://cdn.jsdelivr.net/npm/emoji-datasource@15.1.0/emoji.json";
···
     Arc::new(set)
 }
 
+#[allow(dead_code)]
 pub async fn is_builtin_slug(name: &str) -> bool {
     let name = name.to_lowercase();
     if let Some(cache) = BUILTIN_SLUGS.get() {

src/main.rs

···
 mod resolver;
 mod storage;
 mod templates;
+mod webhooks;
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
···
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::api::status::get_custom_emojis;
+    use crate::api::status_read::get_custom_emojis;
     use actix_web::{App, test};
 
     #[actix_web::test]

src/webhooks.rs

···
+use async_sqlite::Pool;
+use hmac::{Hmac, Mac};
+use once_cell::sync::Lazy;
+use reqwest::Client;
+use serde::Serialize;
+use sha2::Sha256;
+
+use crate::db::{StatusFromDb, Webhook, get_user_webhooks};
+use futures_util::future;
+
+#[derive(Serialize)]
+pub struct StatusEvent<'a> {
+    pub event: &'a str, // "status.created" | "status.deleted" | "status.cleared"
+    pub did: &'a str,
+    pub handle: Option<&'a str>,
+    pub status: Option<&'a str>,
+    pub text: Option<&'a str>,
+    pub uri: Option<&'a str>,
+    pub since: Option<&'a str>,
+    pub expires: Option<&'a str>,
+}
+
+fn should_send(h: &Webhook, event: &str) -> bool {
+    if !h.active {
+        return false;
+    }
+    let events = h.events.trim();
+    if events == "*" || events.is_empty() {
+        return true;
+    }
+    events
+        .split(',')
+        .map(|e| e.trim())
+        .any(|e| e.eq_ignore_ascii_case(event))
+}
+
+fn hmac_sig_hex(secret: &str, ts: &str, payload: &[u8]) -> String {
+    let mut mac =
+        Hmac::<Sha256>::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
+    mac.update(ts.as_bytes());
+    mac.update(b".");
+    mac.update(payload);
+    hex::encode(mac.finalize().into_bytes())
+}
+
+static HTTP: Lazy<Client> = Lazy::new(Client::new);
+
+pub async fn send_status_event(pool: std::sync::Arc<Pool>, did: &str, event: StatusEvent<'_>) {
+    let hooks = match get_user_webhooks(&pool, did).await {
+        Ok(h) => h,
+        Err(e) => {
+            log::error!("webhooks: failed to load webhooks for {}: {}", did, e);
+            return;
+        }
+    };
+    let payload = match serde_json::to_vec(&event) {
+        Ok(p) => p,
+        Err(e) => {
+            log::error!("webhooks: failed to serialize payload: {}", e);
+            return;
+        }
+    };
+    let ts = chrono::Utc::now().timestamp().to_string();
+
+    let futures = hooks
+        .into_iter()
+        .filter(|h| should_send(h, event.event))
+        .map(|h| {
+            let payload = payload.clone();
+            let ts = ts.clone();
+            let client = HTTP.clone();
+            async move {
+                let sig = hmac_sig_hex(&h.secret, &ts, &payload);
+                let res = client
+                    .post(&h.url)
+                    .header("User-Agent", "status-webhooks/1.0")
+                    .header("Content-Type", "application/json")
+                    .header("X-Status-Webhook-Timestamp", &ts)
+                    .header("X-Status-Webhook-Signature", format!("sha256={}", sig))
+                    .timeout(std::time::Duration::from_secs(5))
+                    .body(payload)
+                    .send()
+                    .await;
+
+                match res {
+                    Ok(resp) => {
+                        if !resp.status().is_success() {
+                            let status = resp.status();
+                            let body = resp.text().await.unwrap_or_default();
+                            log::warn!(
+                                "webhook delivery failed: {} -> {} body={}",
+                                &h.url,
+                                status,
+                                body
+                            );
+                        }
+                    }
+                    Err(e) => log::warn!("webhook delivery error to {}: {}", &h.url, e),
+                }
+            }
+        });
+
+    future::join_all(futures).await;
+}
+
+pub async fn emit_created(pool: std::sync::Arc<Pool>, s: &StatusFromDb) {
+    let did = s.author_did.clone();
+    let emoji = s.status.clone();
+    let text = s.text.clone();
+    let uri = s.uri.clone();
+    let since = s.started_at.to_rfc3339();
+    let expires = s.expires_at.map(|e| e.to_rfc3339());
+    let event = StatusEvent {
+        event: "status.created",
+        did: &did,
+        handle: None,
+        status: Some(&emoji),
+        text: text.as_deref(),
+        uri: Some(&uri),
+        since: Some(&since),
+        expires: expires.as_deref(),
+    };
+    send_status_event(pool, &did, event).await;
+}
+
+pub async fn emit_deleted(pool: std::sync::Arc<Pool>, did: &str, uri: &str) {
+    let did_owned = did.to_string();
+    let uri_owned = uri.to_string();
+    let event = StatusEvent {
+        event: "status.deleted",
+        did: &did_owned,
+        handle: None,
+        status: None,
+        text: None,
+        uri: Some(&uri_owned),
+        since: None,
+        expires: None,
+    };
+    send_status_event(pool, &did_owned, event).await;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_should_send_wildcard() {
+        let h = Webhook {
+            id: 1,
+            did: "d".into(),
+            url: "u".into(),
+            secret: "s".into(),
+            events: "*".into(),
+            active: true,
+            created_at: 0,
+            updated_at: 0,
+        };
+        assert!(should_send(&h, "status.created"));
+    }
+
+    #[test]
+    fn test_should_send_specific() {
+        let h = Webhook {
+            id: 1,
+            did: "d".into(),
+            url: "u".into(),
+            secret: "s".into(),
+            events: "status.deleted".into(),
+            active: true,
+            created_at: 0,
+            updated_at: 0,
+        };
+        assert!(should_send(&h, "status.deleted"));
+        assert!(!should_send(&h, "status.created"));
+    }
+
+    #[test]
+    fn test_hmac_sig_hex() {
+        let sig = hmac_sig_hex("secret", "1234567890", b"{\"a\":1}");
+        // Deterministic expected if inputs fixed
+        assert_eq!(sig.len(), 64);
+    }
+}

static/webhook_guide.css

···
+.wh-tabs { display: flex; gap: 8px; margin: 10px 0; }
+.wh-dynamic .wh-tabs { justify-content: flex-end; }
+.wh-tabs button { border: 1px solid var(--border-color, #2a2a2a); background: var(--bg-secondary, #0f0f0f); color: var(--text, #fff); padding: 6px 10px; border-radius: 8px; cursor: pointer; font-size: 12px; }
+.wh-tabs button.active { background: var(--accent, #1DA1F2); color: #000; border-color: var(--accent, #1DA1F2); }
+.wh-snippet { display: none; }
+.wh-snippet.active { display: block; }
+.wh-static h4 { margin: 0 0 6px 0; }
+.wh-static ul { margin: 0 0 8px 18px; padding: 0; }
+.wh-static pre { background: #0b0b0b; border: 1px solid var(--border-color); border-radius: 8px; padding: 12px; overflow: auto; font-size: 12px; }
+@media (max-width: 900px) {
+  .wh-dynamic .wh-tabs { justify-content: flex-start; }
+}

static/webhook_guide.js

···
+document.addEventListener('DOMContentLoaded', () => {
+  const tabs = document.querySelectorAll('#wh-lang-tabs [data-lang]');
+  const blocks = document.querySelectorAll('.wh-snippet[data-lang]');
+  if (!tabs.length || !blocks.length) return;
+  const activate = (lang) => {
+    tabs.forEach(t => t.classList.toggle('active', t.dataset.lang === lang));
+    blocks.forEach(b => b.classList.toggle('active', b.dataset.lang === lang));
+  };
+  tabs.forEach(btn => btn.addEventListener('click', () => activate(btn.dataset.lang)));
+  // default
+  activate('node');
+});
+

templates/feed.html

···
     
     try {
         const response = await fetch(`/api/feed?offset=${offset}&limit=20`);
-        const newStatuses = await response.json();
+        const data = await response.json();
+        const newStatuses = Array.isArray(data) ? data : (data.statuses || []);
         
         if (newStatuses.length === 0) {
             hasMore = false;
···
         }
         
         offset += newStatuses.length;
+        if (!Array.isArray(data) && typeof data === 'object') {
+            if (typeof data.next_offset === 'number') offset = data.next_offset;
+            if (typeof data.has_more === 'boolean') hasMore = data.has_more;
+        }
         loadingIndicator.style.display = 'none';
     } catch (error) {
         console.error('Error loading more statuses:', error);

templates/status.html

···
                     <button class="color-preset" data-color="#FD79A8" style="background: #FD79A8"></button>
                 </div>
             </div>
+            <div class="settings-row">
+                <label>integrations</label>
+                <button id="open-webhook-config" class="nav-button">configure webhooks</button>
+            </div>
         </div>
         {% endif %}
 
···
             <a href="/logout" class="logout-link">log out</a>
         </div>
         {% endif %}
+
+        <!-- Webhook Full-Page Modal -->
+        <div id="webhook-modal" class="webhook-modal hidden" aria-hidden="true">
+            <div class="webhook-modal-content">
+                <div class="webhook-modal-header">
+                    <h2>webhooks</h2>
+                    <button id="close-webhook-modal" aria-label="Close">✕</button>
+                </div>
+                <div class="webhook-modal-body">
+                    <div class="webhook-intro" style="margin-bottom:10px;">
+                        <p>Send signed events when your status changes. Configure a URL that accepts JSON POSTs. We include an HMAC-SHA256 signature in <code>X-Status-Webhook-Signature</code> and a UNIX timestamp in <code>X-Status-Webhook-Timestamp</code>.</p>
+                    </div>
+                    <form id="create-webhook-form" class="webhook-form" aria-label="create webhook">
+                        <div style="display:flex; flex-direction:column; gap:4px;">
+                            <input type="url" id="wh-url" placeholder="Webhook URL (https://example.com/webhook)" required />
+                            <div class="field-help">HTTPS required in production. Local/private hosts allowed only in local dev.</div>
+                        </div>
+                        <div style="display:flex; flex-direction:column; gap:4px;">
+                            <input type="text" id="wh-secret" placeholder="Secret (optional – autogenerated)" />
+                            <div class="field-help">Used to sign requests with HMAC-SHA256. Reveal only on creation/rotation.</div>
+                        </div>
+                        <div style="display:flex; flex-direction:column; gap:4px;">
+                            <input type="text" id="wh-events" placeholder="Events (optional, default *) e.g. status.created,status.deleted" />
+                            <div class="field-help">Comma-separated. Supported: <code>status.created</code>, <code>status.deleted</code> or <code>*</code>.</div>
+                        </div>
+                        <button type="submit" aria-label="add webhook">add webhook</button>
+                        <div class="field-help">You can add multiple webhooks. Toggle active, rotate secrets, or delete below.</div>
+                    </form>
+                    <div id="webhook-list" class="webhook-list" aria-live="polite"></div>
+
+                    <details class="wh-guide" id="webhook-guide">
+                        <summary>Integration guide</summary>
+                        <div class="content">
+                            <div class="wh-grid">
+                                <div class="wh-static">
+                                    <h4>Request</h4>
+                                    <ul>
+                                        <li>Method: POST</li>
+                                        <li>Content-Type: application/json</li>
+                                        <li>Header <code>X-Status-Webhook-Timestamp</code>: UNIX seconds</li>
+                                        <li>Header <code>X-Status-Webhook-Signature</code>: <code>sha256=&lt;hex&gt;</code></li>
+                                    </ul>
+                                    <h4>Payload</h4>
+<pre><code>{
+  "event": "status.created", // or "status.deleted"
+  "did": "did:plc:...",
+  "handle": null,
+  "status": "🙂",           // created only
+  "text": "in a meeting",   // optional
+  "uri": "at://...",       // record URI
+  "since": "2025-09-10T16:00:00Z", // created only
+  "expires": null            // created only
+}</code></pre>
+                                </div>
+                                <div class="wh-dynamic">
+                                    <div id="wh-lang-tabs" class="wh-tabs" role="tablist" aria-label="language selector">
+                                        <button type="button" data-lang="node" role="tab" aria-selected="true">Node</button>
+                                        <button type="button" data-lang="rust" role="tab">Rust</button>
+                                        <button type="button" data-lang="python" role="tab">Python</button>
+                                        <button type="button" data-lang="go" role="tab">Go</button>
+                                    </div>
+                                    <div class="wh-snippet" data-lang="node">
+                                    <h4>Verify signature</h4>
+                                    <p>Compute HMAC-SHA256 over <code>timestamp + "." + rawBody</code> using your secret. Compare to header (without the <code>sha256=</code> prefix) with constant-time equality, and reject if timestamp is too old (e.g., &gt; 5 minutes).</p>
+<pre><code>// Node (TypeScript)
+import crypto from 'node:crypto';
+
+function verify(req: any, rawBody: Buffer, secret: string): boolean {
+  const ts = req.headers['x-status-webhook-timestamp'];
+  const sig = String(req.headers['x-status-webhook-signature'] || '').replace(/^sha256=/, '');
+  if (!ts || !sig) return false;
+  const now = Math.floor(Date.now()/1000);
+  if (Math.abs(now - Number(ts)) > 300) return false; // 5m
+  const mac = crypto.createHmac('sha256', secret).update(String(ts)).update('.').update(rawBody).digest('hex');
+  return crypto.timingSafeEqual(Buffer.from(mac, 'hex'), Buffer.from(sig, 'hex'));
+}
+</code></pre>
+                                </div>
+                                <div class="wh-snippet" data-lang="rust">
+<pre><code>// Rust (axum-ish)
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+
+fn verify(ts: &str, sig_hdr: &str, body: &[u8], secret: &str) -> bool {
+    let sig = sig_hdr.strip_prefix("sha256=").unwrap_or(sig_hdr);
+    if let Ok(ts_int) = ts.parse::<i64>() {
+        if (chrono::Utc::now().timestamp() - ts_int).abs() > 300 { return false; }
+    } else { return false; }
+    let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).unwrap();
+    mac.update(ts.as_bytes());
+    mac.update(b".");
+    mac.update(body);
+    let calc = hex::encode(mac.finalize().into_bytes());
+    subtle::ConstantTimeEq::ct_eq(calc.as_bytes(), sig.as_bytes()).into()
+}
+</code></pre>
+                                </div>
+                                <div class="wh-snippet" data-lang="python">
+<pre><code># Python (Flask example)
+import hmac, hashlib, time
+from flask import request
+
+def verify(secret: str, raw_body: bytes) -> bool:
+    ts = request.headers.get('X-Status-Webhook-Timestamp')
+    sig_hdr = request.headers.get('X-Status-Webhook-Signature', '')
+    if not ts or not sig_hdr.startswith('sha256='):
+        return False
+    if abs(int(time.time()) - int(ts)) > 300:
+        return False
+    expected = hmac.new(secret.encode(), (ts + '.').encode() + raw_body, hashlib.sha256).hexdigest()
+    actual = sig_hdr[len('sha256='):]
+    return hmac.compare_digest(expected, actual)
+</code></pre>
+                                </div>
+                                <div class="wh-snippet" data-lang="go">
+<pre><code>// Go (net/http)
+package main
+
+import (
+  "crypto/hmac"
+  "crypto/sha256"
+  "encoding/hex"
+  "net/http"
+  "strconv"
+  "time"
+)
+
+func verify(r *http.Request, body []byte, secret string) bool {
+  ts := r.Header.Get("X-Status-Webhook-Timestamp")
+  sig := r.Header.Get("X-Status-Webhook-Signature")
+  if ts == "" || sig == "" { return false }
+  if len(sig) > 7 && sig[:7] == "sha256=" { sig = sig[7:] }
+  tsv, err := strconv.ParseInt(ts, 10, 64)
+  if err != nil || time.Now().Unix()-tsv > 300 || tsv-time.Now().Unix() > 300 { return false }
+  mac := hmac.New(sha256.New, []byte(secret))
+  mac.Write([]byte(ts))
+  mac.Write([]byte("."))
+  mac.Write(body)
+  expected := hex.EncodeToString(mac.Sum(nil))
+  return hmac.Equal([]byte(expected), []byte(sig))
+}
+</code></pre>
+                                </div>
+                                </div>
+                            </div>
+                        </div>
+                    </details>
+                    <link rel="stylesheet" href="/static/webhook_guide.css">
+                    <script src="/static/webhook_guide.js"></script>
+                </div>
+            </div>
+        </div>
 
         <!-- History -->
         {% if !history.is_empty() %}
···
         border-bottom: none;
     }
 }
+/* Webhook Modal */
+.webhook-modal.hidden { display: none; }
+.webhook-modal {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.6);
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+        .webhook-modal-content {
+            width: 96vw;
+            height: 92vh;
+            max-width: 1400px;
+            max-height: 92vh;
+            background: var(--bg, #111);
+            color: var(--text, #fff);
+            border: 1px solid var(--border-color, #2a2a2a);
+            border-radius: 12px;
+            display: flex;
+            flex-direction: column;
+        }
+        .webhook-modal-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 16px 20px;
+            border-bottom: 1px solid var(--border-color, #2a2a2a);
+        }
+        .webhook-modal-header h2 { margin: 0; font-size: 20px; }
+        .webhook-modal-header button {
+            background: transparent;
+            color: inherit;
+            border: 1px solid var(--border-color, #2a2a2a);
+            border-radius: 8px;
+            padding: 6px 10px;
+            cursor: pointer;
+        }
+        .webhook-modal-body {
+            padding: 16px 20px;
+            overflow: auto;
+            height: calc(92vh - 60px);
+        }
+        .webhook-form {
+            display: grid;
+            grid-template-columns: 1.2fr 0.8fr 1fr auto;
+            gap: 8px;
+            margin-bottom: 16px;
+        }
+        .webhook-form input { 
+            background: var(--bg-secondary, #0d0d0d);
+            color: var(--text, #fff);
+            border: 1px solid var(--border-color, #2a2a2a);
+            border-radius: 8px;
+            padding: 10px 12px;
+        }
+        .webhook-form button {
+            background: var(--accent, #1DA1F2);
+            color: #000;
+            border: none;
+            border-radius: 8px;
+            padding: 10px 12px;
+            cursor: pointer;
+        }
+        .field-help { font-size: 12px; opacity: 0.8; margin-top: 2px; grid-column: 1 / -1; }
+        .webhook-list .item {
+            border: 1px solid var(--border-color, #2a2a2a);
+            border-radius: 8px;
+            padding: 12px;
+            margin-bottom: 10px;
+            display: grid;
+            grid-template-columns: 1fr auto;
+            gap: 8px;
+        }
+.webhook-list .meta { font-size: 12px; opacity: 0.8; }
+.webhook-actions { display: flex; gap: 8px; align-items: center; }
+.webhook-actions button {
+    background: transparent;
+    color: inherit;
+    border: 1px solid var(--border-color, #2a2a2a);
+    border-radius: 8px;
+    padding: 6px 10px;
+    cursor: pointer;
+}
+        .webhook-actions .danger { border-color: #803; color: #f77; }
+        .webhook-active { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; }
+        .webhook-active input { transform: translateY(1px); }
+
+        /* Collapsible guide */
+        .wh-guide {
+            margin-top: 20px;
+            border: 1px solid var(--border-color, #2a2a2a);
+            border-radius: 10px;
+            overflow: hidden;
+        }
+        .wh-guide summary {
+            padding: 12px 14px;
+            cursor: pointer;
+            background: var(--bg-secondary, #0f0f0f);
+            font-weight: 600;
+            outline: none;
+        }
+        .wh-guide .content { padding: 14px; }
+        .wh-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
+        .wh-grid pre { background: #0b0b0b; border: 1px solid var(--border-color); border-radius: 8px; padding: 12px; overflow: auto; font-size: 12px; }
+        @media (max-width: 900px) { .wh-grid { grid-template-columns: 1fr; } }
 </style>
 
 <script>
···
 // Initialize on page load
 // Timestamp formatting is handled by /static/timestamps.js
 
-document.addEventListener('DOMContentLoaded', async () => {
+    document.addEventListener('DOMContentLoaded', async () => {
     initTheme();
     // Timestamps are auto-initialized by timestamps.js
     
···
         emojiKeywords = data.emojis;
         window.__emojiSlugs = data.slugs || {};
         window.__reservedEmojiNames = new Set(data.reserved || []);
-        
+
+        // Webhook modal handlers (owner only)
+        const openWebhookBtn = document.getElementById('open-webhook-config');
+        const modal = document.getElementById('webhook-modal');
+        const closeModalBtn = document.getElementById('close-webhook-modal');
+        const listEl = document.getElementById('webhook-list');
+        const formEl = document.getElementById('create-webhook-form');
+
+        if (openWebhookBtn && modal && closeModalBtn && listEl && formEl) {
+            const fetchWebhooks = async () => {
+                const res = await fetch('/api/webhooks');
+                if (!res.ok) return [];
+                const data = await res.json();
+                return data.webhooks || [];
+            };
+
+            const renderWebhooks = (hooks) => {
+                if (!hooks.length) {
+                    listEl.innerHTML = '<p class="meta">no webhooks configured yet</p>';
+                    return;
+                }
+                listEl.innerHTML = '';
+                hooks.forEach(h => {
+                    const item = document.createElement('div');
+                    item.className = 'item';
+                    item.innerHTML = `
+                        <div>
+                            <div><strong>${h.url}</strong></div>
+                            <div class="meta">
+                                events: ${h.events || '*'} • secret: ${h.secret_masked} • ${h.active ? 'active' : 'inactive'}
+                            </div>
+                        </div>
+                        <div class="webhook-actions">
+                            <label class="webhook-active"><input type="checkbox" ${h.active ? 'checked' : ''} data-action="toggle" data-id="${h.id}"> active</label>
+                            <button data-action="rotate" data-id="${h.id}">rotate secret</button>
+                            <button class="danger" data-action="delete" data-id="${h.id}">delete</button>
+                        </div>
+                    `;
+                    listEl.appendChild(item);
+                });
+            };
+
+            const openModal = async () => {
+                modal.classList.remove('hidden');
+                modal.setAttribute('aria-hidden', 'false');
+                const hooks = await fetchWebhooks();
+                renderWebhooks(hooks);
+            };
+
+            const closeModal = () => {
+                modal.classList.add('hidden');
+                modal.setAttribute('aria-hidden', 'true');
+            };
+
+            openWebhookBtn.addEventListener('click', openModal);
+            closeModalBtn.addEventListener('click', closeModal);
+            modal.addEventListener('click', (e) => { if (e.target === modal) closeModal(); });
+
+            formEl.addEventListener('submit', async (e) => {
+                e.preventDefault();
+                const url = document.getElementById('wh-url').value.trim();
+                const secret = document.getElementById('wh-secret').value.trim();
+                const events = document.getElementById('wh-events').value.trim();
+                const res = await fetch('/api/webhooks', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url, secret: secret || null, events: events || null })
+                });
+                if (res.ok) {
+                    const hooks = await fetchWebhooks();
+                    renderWebhooks(hooks);
+                    formEl.reset();
+                    try { const data = await res.json(); if (data.secret) alert('Webhook created. Save this secret now: ' + data.secret); } catch {}
+                } else {
+                    alert('Failed to create webhook');
+                }
+            });
+
+            listEl.addEventListener('click', async (e) => {
+                const btn = e.target.closest('button');
+                if (!btn) return;
+                const id = btn.dataset.id;
+                const action = btn.dataset.action;
+                if (action === 'delete') {
+                    if (!confirm('Delete this webhook?')) return;
+                    const res = await fetch(`/api/webhooks/${id}`, { method: 'DELETE' });
+                    if (res.ok) {
+                        const hooks = await fetchWebhooks();
+                        renderWebhooks(hooks);
+                    }
+                } else if (action === 'rotate') {
+                    const res = await fetch(`/api/webhooks/${id}/rotate`, { method: 'POST' });
+                    if (res.ok) {
+                        const data = await res.json();
+                        alert('New secret: ' + data.secret + '\nSave it now.');
+                        const hooks = await fetchWebhooks();
+                        renderWebhooks(hooks);
+                    }
+                }
+            });
+
+            listEl.addEventListener('change', async (e) => {
+                const input = e.target.closest('input[type="checkbox"][data-action="toggle"]');
+                if (!input) return;
+                const id = input.dataset.id;
+                const active = !!input.checked;
+                await fetch(`/api/webhooks/${id}`, {
+                    method: 'PUT', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ active })
+                });
+            });
+        }
+
         // Load frequent emojis from API
         let frequentEmojis = ['😊', '👍', '❤️', '😂', '🎉', '🔥', '✨', '💯', '🚀', '💪', '🙏', '👏']; // defaults
         try {