fix: resolve merge conflict and combine following filter with dev mode

- Merge dev mode features into following-filter branch
- Resolve conflicts in feed.html template
- Combine feed-header-with-indicator for both features
- Keep all functionality from both branches intact

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

.env.template

···
 PUBLIC_URL=""          # Set when deployed publicly, e.g. "https://mysite.com". Informs OAuth client id.
 # DB_PATH="./statusphere.sqlite3"     # The SQLite database path. Leave commented out to use a temporary in-memory database.
 
+# Dev Mode Configuration
+DEV_MODE="false"       # Enable dev mode for testing with dummy data. Access via ?dev=true query parameter when enabled.
+
 

Cargo.lock

···
  "env_logger",
  "hickory-resolver",
  "log",
+ "rand 0.8.5",
  "rocketman",
  "serde",
  "serde_json",

Cargo.toml

···
 thiserror = "1.0.69"
 async-sqlite = "0.5.0"
 async-trait = "0.1.88"
+rand = "0.8"
 
 [build-dependencies]
 askama = "0.13"

fly.review.toml

···
   SERVER_HOST = "0.0.0.0"
   DATABASE_URL = "sqlite:///data/status.db"
   ENABLE_FIREHOSE = "true"
+  DEV_MODE = "true"
   # OAUTH_REDIRECT_BASE will be set dynamically by the workflow
 
 [http_service]

src/config.rs

···
 
     /// Log level
     pub log_level: String,
+
+    /// Dev mode for testing with dummy data
+    pub dev_mode: bool,
 }
 
 impl Config {
···
                 .parse()
                 .unwrap_or(false),
             log_level: env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string()),
+            dev_mode: env::var("DEV_MODE")
+                .unwrap_or_else(|_| "false".to_string())
+                .parse()
+                .unwrap_or(false),
         })
     }
 }

src/dev_utils.rs

···
+use crate::db::StatusFromDb;
+use chrono::{Duration, Utc};
+use rand::prelude::*;
+
+/// Generate dummy status data for development testing
+pub fn generate_dummy_statuses(count: usize) -> Vec<StatusFromDb> {
+    let mut rng = thread_rng();
+    let mut statuses = Vec::new();
+
+    // Sample data pools
+    let emojis = vec![
+        "🚀", "💭", "☕", "🎨", "📚", "🎵", "🏃", "😴", "🍕", "💻", "🌟", "🔥", "✨", "🌙", "☀️",
+        "🌈", "⚡", "🎯", "🎮", "📝",
+    ];
+
+    let texts = [
+        Some("working on something cool"),
+        Some("deep in flow state"),
+        Some("taking a break"),
+        Some("debugging..."),
+        Some("shipping it"),
+        None,
+        Some("coffee time"),
+        Some("in a meeting"),
+        Some("focused"),
+        None,
+        Some("learning rust"),
+        Some("reading docs"),
+    ];
+
+    let handles = [
+        "alice.test",
+        "bob.test",
+        "charlie.test",
+        "dana.test",
+        "eve.test",
+        "frank.test",
+        "grace.test",
+        "henry.test",
+        "iris.test",
+        "jack.test",
+        "karen.test",
+        "leo.test",
+    ];
+
+    let now = Utc::now();
+
+    for i in 0..count {
+        // Generate random timestamps going back up to 48 hours
+        let hours_ago = rng.gen_range(0..48);
+        let minutes_ago = rng.gen_range(0..60);
+        let started_at = now - Duration::hours(hours_ago) - Duration::minutes(minutes_ago);
+
+        // Random chance of having an expiration
+        let expires_at = if rng.gen_bool(0.3) {
+            // 30% chance of having expiration
+            let expire_hours = rng.gen_range(1..24);
+            Some(started_at + Duration::hours(expire_hours))
+        } else {
+            None
+        };
+
+        let mut status = StatusFromDb::new(
+            format!("at://did:plc:dummy{}/xyz.statusphere.status/dummy{}", i, i),
+            format!("did:plc:dummy{}", i % handles.len()),
+            emojis.choose(&mut rng).unwrap().to_string(),
+        );
+
+        status.text = texts.choose(&mut rng).unwrap().map(|s| s.to_string());
+        status.started_at = started_at;
+        status.expires_at = expires_at;
+        status.indexed_at = started_at;
+        status.handle = Some(handles[i % handles.len()].to_string());
+
+        statuses.push(status);
+    }
+
+    // Sort by started_at desc (newest first)
+    statuses.sort_by(|a, b| b.started_at.cmp(&a.started_at));
+
+    statuses
+}
+
+/// Check if dev mode is requested via query parameter
+pub fn is_dev_mode_requested(query: &str) -> bool {
+    query.contains("dev=true") || query.contains("dev=1")
+}

src/main.rs

···
 
 mod config;
 mod db;
+mod dev_utils;
 mod error_handler;
 mod ingester;
 #[allow(dead_code)]
···
     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")
···
         .unwrap_or(20)
         .min(50); // Cap at 50 items per request
 
-    let mut statuses = StatusFromDb::load_statuses_paginated(&db_pool, offset, limit)
-        .await
-        .unwrap_or_else(|err| {
-            log::error!("Error loading statuses: {err}");
-            vec![]
-        });
+    // 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();
···
 /// Feed page - shows all users' statuses
 #[get("/feed")]
 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";
-    let mut statuses = StatusFromDb::load_latest_statuses(&db_pool)
-        .await
-        .unwrap_or_else(|err| {
-            log::error!("Error loading statuses: {err}");
-            vec![]
-        });
+
+    // 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 {
···
                         },
                         statuses,
                         is_admin,
+                        dev_mode: use_dev_mode,
                     }
                     .render()
                     .expect("template should be valid");
···
                 profile: None,
                 statuses,
                 is_admin: false,
+                dev_mode: use_dev_mode,
             }
             .render()
             .expect("template should be valid");

src/templates.rs

···
     pub profile: Option<Profile>,
     pub statuses: Vec<StatusFromDb>,
     pub is_admin: bool,
+    pub dev_mode: bool,
 }

templates/feed.html

···
 
         <!-- Feed -->
         <div class="feed-container">
-            <div class="feed-header">
+            <div class="feed-header-with-indicator">
                 <h2>recent updates</h2>
+                {% if dev_mode %}
+                <div class="dev-indicator" title="dev mode: showing dummy data mixed with real posts">dev</div>
+                {% endif %}
             </div>
             
             {% if !statuses.is_empty() %}
···
             
             <!-- End of feed indicator -->
             <div id="end-of-feed" style="display: none; text-align: center; padding: 2rem;">
-                <span style="color: var(--text-tertiary);">You've reached the beginning of time ✨</span>
+                <span style="color: var(--text-tertiary);">you've reached the beginning of time ✨</span>
             </div>
         </div>
 
···
     transform: translateX(20px);
 }
 
-.feed-header {
+.feed-header-with-indicator {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
     margin-bottom: 1.5rem;
 }
 
-.feed-header h2 {
+.feed-container h2 {
     font-size: 1rem;
     font-weight: 500;
     color: var(--text-secondary);
     text-transform: uppercase;
     letter-spacing: 0.05em;
     margin: 0;
+}
+
+.dev-indicator {
+    font-size: 0.75rem;
+    color: var(--text-tertiary);
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    padding: 0.25rem 0.5rem;
+    opacity: 0.7;
 }
 
 /* Status List */