/target

*.sqlite

*.db

.env

.DS_Store

[workspace]

members = [

    "apps/sipp",

    "apps/feeds",

    "apps/parcels",

    "apps/jotts",

    "apps/og",

    "apps/shrink",

    "crates/auth",

]

resolver = "3"

[profile.dist]

inherits = "release"

lto = "thin"

[workspace.dependencies]

# Core web stack

axum = "0.8.8"

tokio = { version = "1", features = ["full"] }

serde = { version = "1", features = ["derive"] }

serde_json = "1"

dotenvy = "0.15"

# HTTP / middleware

tower-http = "0.6.8"

# Assets

rust-embed = "8"

# Database

rusqlite = { version = "0.38", features = ["bundled"] }

nanoid = "0.4.0"

# Auth

subtle = "2"

rand = "0.8"

# Observability

tracing = "0.1"

tracing-subscriber = "0.3"

# Workspace crates

andromeda-auth = { path = "crates/auth" }

[package]

name = "feeds"

version = "0.1.0"

edition = "2024"

[dependencies]

axum = { workspace = true }

tokio = { workspace = true }

serde = { workspace = true }

serde_json = { workspace = true }

dotenvy = { workspace = true }

rust-embed = { workspace = true }

subtle = { workspace = true }

rand = { workspace = true }

andromeda-auth = { workspace = true }

askama = "0.13"

reqwest = { version = "0.12", features = ["json"] }

feed-rs = "2"

chrono = "0.4"

quick-xml = "0.37"

mime_guess = "2"

urlencoding = "2"

# Build from repo root: docker build -t feeds -f apps/feeds/Dockerfile .

FROM rust:1-slim-bookworm AS builder

WORKDIR /app

# Copy workspace manifests

COPY Cargo.toml Cargo.lock ./

COPY crates/auth/Cargo.toml crates/auth/

COPY apps/sipp/Cargo.toml apps/sipp/

COPY apps/feeds/Cargo.toml apps/feeds/

COPY apps/parcels/Cargo.toml apps/parcels/

COPY apps/jotts/Cargo.toml apps/jotts/

COPY apps/og/Cargo.toml apps/og/

COPY apps/shrink/Cargo.toml apps/shrink/

# Create stubs for dependency caching

RUN mkdir -p crates/auth/src && echo '' > crates/auth/src/lib.rs \

    && for app in sipp feeds parcels jotts og shrink; do \

         mkdir -p apps/$app/src && echo 'fn main() {}' > apps/$app/src/main.rs; \

       done

RUN cargo build --release -p feeds

# Copy real source

COPY crates/auth/src crates/auth/src

COPY apps/feeds/src apps/feeds/src

COPY apps/feeds/assets apps/feeds/assets

COPY apps/feeds/askama.toml apps/feeds/askama.toml

RUN touch apps/feeds/src/*.rs crates/auth/src/*.rs && cargo build --release -p feeds

FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

WORKDIR /app

COPY --from=builder /app/target/release/feeds ./feeds

EXPOSE 4555

CMD ["./feeds"]

MIT License

Copyright (c) 2026 Steve Simkins

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

# Feeds

![cover](https://feeds.stevedylan.dev/assets/og.png)

Minimal RSS Feeds

## About

Feeds is a minimal RSS reader that mimics the original experience of RSS. It's just a list of posts. No categories, no marking a post read or unread, and there is no in-app reading. With this approach you have to read the post on the authors personal website and experience it in it's original context. While this may not work well if you have loads of news feeds, I personally love it for [my approach to blogs](https://blogfeeds.net).

This app is also MIT open sourced and designed to be self-hosted; fork the code and change it to your liking!

## Usage

There are several built-in ways to source RSS feeds.

### URL Query Param

Once you have the app running you can add the following to the URL to source an RSS feed:

```

?url=https://bearblog.dev/discover/feed/

```

You can also add multiple URLs by using commas to separate them:

```

?urls=https://bearblog.dev/discover/feed/,https://bearblog.stevedylan.dev/feed/

```

### OPML File

If you save a `feeds.opml` file in the root of the project the app will automatically source it and fetch the posts for the feeds inside.

### FreshRSS API

If neither of the above are provided the app will default to using a FreshRSS API instance. Simply run the following command:

```bash

cp .env.sample .env

```

Then fill in the environment variables:

```

FRESHRSS_URL=

FRESHRSS_USERNAME=

FRESHRSS_PASSWORD=

```

### Admin Panel

Feeds includes a password-protected admin panel at `/admin` for managing your FreshRSS subscriptions. Set the `ADMIN_PASSWORD` environment variable to enable it:

```

ADMIN_PASSWORD=your_secret_password

```

From the admin panel you can view your current subscriptions and add new feeds directly to your FreshRSS instance.

### Feeds API

The `/feeds` endpoint exports your FreshRSS subscriptions in JSON or OPML format:

```

/feeds?format=json

/feeds?format=opml

```

## Quickstart

1. Make sure [Rust](https://www.rust-lang.org/tools/install) is installed

```bash

rustc --version

```

2. Clone and build

```bash

git clone https://github.com/stevedylandev/feeds

cd feeds

cargo build

```

3. Run the dev server

```bash

cargo run

# Server running on http://localhost:4555

```

## Project Structure

The architecture is intentionally simple:

- **`src/main.rs`** - Axum server with routing, templates, and static asset serving

- **`src/feeds.rs`** - Feed fetching, OPML parsing, and FreshRSS API integration

- **`src/auth.rs`** - Session-based authentication with constant-time password verification

- **`src/models.rs`** - Data structures for feeds and FreshRSS responses

- **`src/templates/`** - Askama HTML templates

- **`assets/`** - Static assets embedded at compile time via `rust-embed`

## Environment Variables

| Variable | Description | Required |

|---|---|---|

| `FRESHRSS_URL` | URL of your FreshRSS instance | For FreshRSS mode |

| `FRESHRSS_USERNAME` | FreshRSS username | For FreshRSS mode |

| `FRESHRSS_PASSWORD` | FreshRSS password | For FreshRSS mode |

| `ADMIN_PASSWORD` | Password for the admin panel | For admin access |

| `COOKIE_SECURE` | Set to `true` for HTTPS environments | No |

## Deployment

Since Feeds compiles to a single binary, deployment is straightforward on any platform.

### Self Hosting

If you are running a VPS or your own hardware like a Raspberry Pi, you can use a basic `systemd` service to manage the instance.

1. Clone the repo and build

```bash

git clone https://github.com/stevedylandev/feeds

cd feeds

cargo build --release

```

2. Create a systemd service

The location of where these files are located might depend on your linux distribution, but most commonly they can be found at `/etc/systemd/system`. Create a new file called `feeds.service` and edit it with `nano` or `vim`.

```bash

cd /etc/systemd/system

touch feeds.service

sudo nano feeds.service

```

Paste in the following code:

```bash

[Unit]

# describe the app

Description=Feeds

# start the app after the network is available

After=network.target

[Service]

# usually you'll use 'simple'

# one of https://www.freedesktop.org/software/systemd/man/systemd.service.html#Type=

Type=simple

# which user to use when starting the app

User=YOUR_USER

# path to your application's root directory

WorkingDirectory=/home/YOUR_USER/feeds

# the command to start the app

ExecStart=/home/YOUR_USER/feeds/target/release/feeds

# restart policy

Restart=always

[Install]

# start the app automatically

WantedBy=multi-user.target

```

> [!NOTE]

> Make sure you update `YOUR_USER` with your own user info, and make sure the paths are correct!

3. Start up the service

Run the following commands to enable and start the service

```bash

sudo systemctl enable feeds.service

sudo systemctl start feeds

```

Check and make sure it's working

```bash

sudo systemctl status feeds

```

4. Setup a Tunnel (optional)

From here you have a lot of options of how you may want to access the instance. One easy way to start is to use a Cloudflare tunnel and point it to `http://localhost:4555`.

### Docker

1. Clone the repo

```bash

git clone https://github.com/stevedylandev/feeds

cd feeds

```

2. Build and run the Docker image

```bash

docker build -t feeds .

docker run -p 4555:4555 --env-file .env feeds

```

Or use `docker-compose`

```bash

docker-compose up -d

```

### Railway

1. Fork the repo from GitHub to your own account

2. Login to [Railway](https://railway.com) and create a new project

3. Select Feeds from your repos

4. Railway will auto-detect the Rust project and build it

[general]

dirs = ["src/templates"]

{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

* {

	padding: 0;

	margin: 0;

	box-sizing: border-box;

	font-family: "Commit Mono", monospace, sans-serif;

	scrollbar-width: none;

	-ms-overflow-style: none;

}

html {

	background: #121113;

	color: #ffffff;

}

html::-webkit-scrollbar {

	display: none;

}

body {

	display: flex;

	flex-direction: column;

	justify-content: start;

	align-items: start;

	gap: 1.5rem;

	min-height: 100vh;

	max-width: 700px;

	margin: auto;

}

.header {

	display: flex;

	flex-direction: column;

	gap: 0.5rem;

	text-decoration: none;

	margin-top: 2rem;

}

.links {

	display: flex;

	align-items: center;

	gap: 0.75rem;

	font-size: 12px;

}

.about {

	display: flex;

	flex-direction: column;

	gap: 0.5rem;

	font-size: 14px;

	line-height: 1.25rem;

}

button {

	background: #121113;

	color: #ffffff;

	padding: 6px;

	border: 1px solid white;

	cursor: pointer;

	width: fit-content;

}

a {

	background: #121113;

	color: #ffffff;

}

ul {

	margin-left: 1.5rem;

}

li {

	padding: 0.5rem 0;

}

code {

	background: #333;

	padding: 3px;

}

.feeds-list {

	width: 100%;

	display: flex;

	flex-direction: column;

	gap: 1.5rem;

}

.feed-item {

	display: flex;

	flex-direction: column;

	gap: 0.5rem;

	padding: 1rem 0;

	border-bottom: 1px solid #333;

}

#feed-urls {

	font-size: 12px;

	color: #888;

}

.feed-item:last-child {

	border-bottom: none;

}

.feed-meta {

	display: flex;

	justify-content: space-between;

	align-items: center;

	font-size: 12px;

	color: #888;

}

.feed-source {

	font-weight: 700;

}

.feed-date {

	color: #666;

}

.feed-title {

	font-size: 16px;

	font-weight: 400;

	line-height: 1.4;

}

.feed-title a {

	text-decoration: none;

	color: #ffffff;

	transition: color 0.2s ease;

}

.feed-title a:hover {

	color: #ccc;

}

.feed-author {

	font-size: 12px;

	color: #888;

	font-style: italic;

}

.no-feeds {

	text-align: center;

	color: #888;

	padding: 2rem;

}

#loading {

	text-align: center;

	color: #888;

	padding: 2rem;

}

#error {

	text-align: center;

	padding: 2rem;

}

@media (max-width: 480px) {

	.feed-meta {

		flex-direction: column;

		align-items: flex-start;

		gap: 0.25rem;

	}

	.feed-title {

		font-size: 14px;

	}

}

@media (max-width: 480px) {

	body {

		padding: 1rem;

		gap: 1rem;

	}

}

.admin-form {

	display: flex;

	flex-direction: column;

	gap: 0.75rem;

	width: 100%;

}

.admin-form label {

	font-size: 12px;

	color: #888;

	text-transform: uppercase;

	letter-spacing: 0.05em;

}

.admin-form input {

	background: #1a1a1c;

	color: #ffffff;

	border: 1px solid #333;

	padding: 10px;

	font-family: "Commit Mono", monospace, sans-serif;

	font-size: 14px;

	outline: none;

}

.admin-form input:focus {

	border-color: #666;

}

.error-msg {

	color: #ff6b6b;

	font-size: 14px;

}

.success-msg {

	color: #6bff8a;

	font-size: 14px;

}

.admin-notice {

	font-size: 14px;

	color: #888;

	line-height: 1.4;

}

.admin-subs {

	width: 100%;

	display: flex;

	flex-direction: column;

	gap: 1rem;

}

.admin-subs h3 {

	font-size: 14px;

	color: #888;

	font-weight: 400;

}

@font-face {

	font-family: "Commit Mono";

	src: url("fonts/CommitMono-400-Regular.otf") format("opentype");

	font-weight: 400;

	font-style: normal;

}

@font-face {

	font-family: "Commit Mono";

	src: url("fonts/CommitMono-700-Regular.otf") format("opentype");

	font-weight: 700;

	font-style: normal;

}

services:

  feeds:

    build:

      context: ../..

      dockerfile: apps/feeds/Dockerfile

    ports:

      - "4555:4555"

    volumes:

      - feeds_data:/app/data

    env_file:

      - .env

    restart: unless-stopped

volumes:

  feeds_data:

use axum::{

    extract::{FromRef, FromRequestParts},

    http::request::Parts,

    response::{IntoResponse, Redirect, Response},

};

use std::collections::HashMap;

use std::sync::{Arc, Mutex};

use std::time::{Duration, Instant};

use crate::AppState;

pub use andromeda_auth::{

    build_session_cookie, clear_session_cookie, extract_session_cookie, generate_session_token,

    verify_password,

};

pub type SessionStore = Arc<Mutex<HashMap<String, Instant>>>;

const SESSION_TTL: Duration = Duration::from_secs(7 * 24 * 60 * 60); // 7 days

pub fn new_session_store() -> SessionStore {

    Arc::new(Mutex::new(HashMap::new()))

}

pub fn create_session(store: &SessionStore, token: &str) {

    if let Ok(mut sessions) = store.lock() {

        sessions.insert(token.to_string(), Instant::now());

    }

}

pub fn is_valid_session(store: &SessionStore, token: &str) -> bool {

    if let Ok(mut sessions) = store.lock() {

        if let Some(created) = sessions.get(token) {

            if created.elapsed() < SESSION_TTL {

                return true;

            }

            sessions.remove(token);

        }

    }

    false

}

pub fn delete_session(store: &SessionStore, token: &str) {

    if let Ok(mut sessions) = store.lock() {

        sessions.remove(token);

    }

}

/// Axum extractor — guards routes behind login. Redirects to /admin/login if invalid.

pub struct AuthSession;

impl<S> FromRequestParts<S> for AuthSession

where

    S: Send + Sync,

    Arc<AppState>: FromRef<S>,

{

    type Rejection = Response;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {

        let state = Arc::<AppState>::from_ref(state);

        let token = extract_session_cookie(&parts.headers);

        if let Some(token) = token {

            if is_valid_session(&state.sessions, &token) {

                return Ok(AuthSession);

            }

        }

        Err(Redirect::to("/admin/login").into_response())

    }

}

use crate::models::{FeedItem, FreshRSSResponse, SubscriptionList};

use std::time::Duration;

fn build_client() -> reqwest::Client {

    reqwest::Client::builder()

        .timeout(Duration::from_secs(5))

        .build()

        .expect("Failed to build HTTP client")

}

async fn fetch_feed_from_url(client: &reqwest::Client, url: &str) -> Vec<FeedItem> {

    let response = match client.get(url).send().await {

        Ok(r) => r,

        Err(e) => {

            eprintln!("Failed to fetch feed {url}: {e}");

            return Vec::new();

        }

    };

    let body = match response.bytes().await {

        Ok(b) => b,

        Err(e) => {

            eprintln!("Failed to read feed body {url}: {e}");

            return Vec::new();

        }

    };

    let feed = match feed_rs::parser::parse(&body[..]) {

        Ok(f) => f,

        Err(e) => {

            eprintln!("Failed to parse feed {url}: {e}");

            return Vec::new();

        }

    };

    let feed_title = feed

        .title

        .as_ref()

        .map(|t| t.content.clone())

        .unwrap_or_default();

    feed.entries

        .iter()

        .map(|entry| {

            let published = entry

                .published

                .or(entry.updated)

                .map(|dt| dt.timestamp())

                .unwrap_or(0);

            let link = entry

                .links

                .first()

                .map(|l| l.href.clone())

                .unwrap_or_default();

            let title = entry

                .title

                .as_ref()

                .map(|t| t.content.clone())

                .unwrap_or_default();

            let id = entry.id.clone();

            let entry_author = entry

                .authors

                .first()

                .map(|a| a.name.clone())

                .unwrap_or_default();

            let author = if entry_author.is_empty() {

                feed_title.clone()

            } else {

                format!("{} - {}", feed_title, entry_author)

            };

            FeedItem {

                id,

                title,

                published,

                author,

                link,

                origin: feed_title.clone(),

            }

        })

        .collect()

}

pub async fn parse_urls(urls: &[String]) -> Vec<FeedItem> {

    let client = build_client();

    let mut handles = Vec::new();

    for url in urls {

        let client = client.clone();

        let url = url.clone();

        handles.push(tokio::spawn(async move {

            fetch_feed_from_url(&client, &url).await

        }));

    }

    let mut all_items = Vec::new();

    for handle in handles {

        if let Ok(items) = handle.await {

            all_items.extend(items);

        }

    }

    all_items.sort_by(|a, b| b.published.cmp(&a.published));

    all_items

}

pub fn parse_opml(content: &str) -> Vec<String> {

    let mut urls = Vec::new();

    let mut reader = quick_xml::Reader::from_str(content);

    loop {

        match reader.read_event() {

            Ok(quick_xml::events::Event::Empty(ref e))

            | Ok(quick_xml::events::Event::Start(ref e)) => {

                if e.name().as_ref() == b"outline" {

                    for attr in e.attributes().flatten() {

                        if attr.key.as_ref() == b"xmlUrl" {

                            if let Ok(val) = attr.decode_and_unescape_value(reader.decoder()) {

                                let url = val.to_string();

                                if !url.is_empty() {

                                    urls.push(url);

                                }

                            }

                        }

                    }

                }

            }

            Ok(quick_xml::events::Event::Eof) => break,

            Err(e) => {

                eprintln!("Error parsing OPML: {e}");

                break;

            }

            _ => {}

        }

    }

    urls

}

async fn freshrss_auth(

    client: &reqwest::Client,

    freshrss_url: &str,

    username: &str,

    password: &str,

) -> Result<String, String> {

    let auth_url = format!(

        "{}/api/greader.php/accounts/ClientLogin?Email={}&Passwd={}",

        freshrss_url, username, password

    );

    let response = client

        .get(&auth_url)

        .send()

        .await

        .map_err(|e| format!("Auth request failed: {e}"))?;

    let text = response

        .text()

        .await

        .map_err(|e| format!("Failed to read auth response: {e}"))?;

    for line in text.lines() {

        if let Some(token) = line.strip_prefix("Auth=") {

            return Ok(token.trim().to_string());

        }

    }

    Err("Authentication failed: no Auth token found".to_string())

}

pub async fn fetch_freshrss_items(

    freshrss_url: &str,

    username: &str,

    password: &str,

) -> Result<Vec<FeedItem>, String> {

    let client = build_client();

    let token = freshrss_auth(&client, freshrss_url, username, password).await?;

    let url = format!(

        "{}/api/greader.php/reader/api/0/stream/contents/reading-list?n=60&r=d",

        freshrss_url

    );

    let response = client

        .get(&url)

        .header("Authorization", format!("GoogleLogin auth={token}"))

        .send()

        .await

        .map_err(|e| format!("Failed to fetch reading list: {e}"))?;

    let data: FreshRSSResponse = response

        .json()

        .await

        .map_err(|e| format!("Failed to parse FreshRSS response: {e}"))?;

    let mut items: Vec<FeedItem> = data

        .items

        .iter()

        .map(|item| {

            let link = item

                .canonical

                .as_ref()

                .and_then(|c| c.first())

                .map(|l| l.href.clone())

                .unwrap_or_default();

            FeedItem {

                id: item.id.clone(),

                title: item.title.clone(),

                published: item.published,

                author: item.origin.title.clone(),

                link,

                origin: item.origin.title.clone(),

            }

        })

        .collect();

    items.sort_by(|a, b| b.published.cmp(&a.published));

    Ok(items)

}

pub async fn fetch_freshrss_subscriptions(

    freshrss_url: &str,

    username: &str,

    password: &str,

) -> Result<SubscriptionList, String> {

    let client = build_client();

    let token = freshrss_auth(&client, freshrss_url, username, password).await?;

    let url = format!(

        "{}/api/greader.php/reader/api/0/subscription/list?output=json",

        freshrss_url

    );

    let response = client

        .get(&url)

        .header("Authorization", format!("GoogleLogin auth={token}"))

        .send()

        .await

        .map_err(|e| format!("Failed to fetch subscriptions: {e}"))?;

    if !response.status().is_success() {

        return Err(format!("FreshRSS API error: {}", response.status()));

    }

    let data: SubscriptionList = response

        .json()

        .await

        .map_err(|e| format!("Failed to parse subscription list: {e}"))?;

    Ok(data)

}

pub async fn add_freshrss_subscription(

    freshrss_url: &str,

    username: &str,

    password: &str,

    feed_url: &str,

) -> Result<String, String> {

    let client = build_client();

    let token = freshrss_auth(&client, freshrss_url, username, password).await?;

    let url = format!(

        "{}/api/greader.php/reader/api/0/subscription/quickadd",

        freshrss_url

    );

    let response = client

        .post(&url)

        .header("Authorization", format!("GoogleLogin auth={token}"))

        .form(&[("quickadd", feed_url)])

        .send()

        .await

        .map_err(|e| format!("Failed to add subscription: {e}"))?;

    if !response.status().is_success() {

        let status = response.status();

        let body = response.text().await.unwrap_or_default();

        return Err(format!("FreshRSS API error ({}): {}", status, body));

    }

    // Assign the "Feeds" category via subscription/edit

    let edit_url = format!(

        "{}/api/greader.php/reader/api/0/subscription/edit",

        freshrss_url

    );

    let stream_id = format!("feed/{feed_url}");

    let response = client

        .post(&edit_url)

        .header("Authorization", format!("GoogleLogin auth={token}"))

        .form(&[

            ("ac", "edit"),

            ("s", &stream_id),

            ("a", "user/-/label/Feeds"),

        ])

        .send()

        .await

        .map_err(|e| format!("Feed added but failed to set category: {e}"))?;

    if !response.status().is_success() {

        let status = response.status();

        let body = response.text().await.unwrap_or_default();

        return Err(format!(

            "Feed added but failed to set category ({}): {}",

            status, body

        ));

    }

    Ok(format!("Successfully added feed: {feed_url}"))

}

pub async fn get_feed_items(

    url_query: Option<&str>,

) -> Result<(Vec<FeedItem>, Option<Vec<String>>), String> {

    // Priority 1: URL query parameter

    if let Some(query) = url_query {

        let urls: Vec<String> = query

            .split(',')

            .map(|u| u.trim().to_string())

            .filter(|u| !u.is_empty())

            .collect();

        if !urls.is_empty() {

            let items = parse_urls(&urls).await;

            return Ok((items, Some(urls)));

        }

    }

    // Priority 2: Local OPML file

    if let Ok(content) = tokio::fs::read_to_string("feeds.opml").await {

        let urls = parse_opml(&content);

        if !urls.is_empty() {

            let items = parse_urls(&urls).await;

            return Ok((items, None));

        }

    }

    // Priority 3: FreshRSS fallback

    let freshrss_url = std::env::var("FRESHRSS_URL").map_err(|_| "FRESHRSS_URL not set")?;

    let username =

        std::env::var("FRESHRSS_USERNAME").map_err(|_| "FRESHRSS_USERNAME not set")?;

    let password =

        std::env::var("FRESHRSS_PASSWORD").map_err(|_| "FRESHRSS_PASSWORD not set")?;

    let items = fetch_freshrss_items(&freshrss_url, &username, &password).await?;

    Ok((items, None))

}

mod auth;

mod feeds;

mod models;

use askama::Template;

use axum::{

    extract::{Query, State},

    http::{header, HeaderMap, StatusCode},

    response::{Html, IntoResponse, Json, Redirect, Response},

    routing::{get, post},

    Form, Router,

};

use chrono::DateTime;

use rust_embed::Embed;

use serde::Deserialize;

use std::collections::HashMap;

use std::sync::Arc;

#[derive(Embed)]

#[folder = "assets/"]

struct Assets;

pub struct AppState {

    sessions: auth::SessionStore,

    admin_password: Option<String>,

    cookie_secure: bool,

}

struct TemplateFeedItem {

    title: String,

    link: String,

    author: String,

    formatted_date: String,

}

#[derive(Template)]

#[template(path = "index.html")]

struct IndexTemplate {

    items: Vec<TemplateFeedItem>,

    feed_urls: Option<Vec<String>>,

    error: Option<String>,

}

#[derive(Template)]

#[template(path = "login.html")]

struct LoginTemplate {

    error: Option<String>,

}

#[derive(Template)]

#[template(path = "admin.html")]

struct AdminTemplate {

    freshrss_configured: bool,

    success: Option<String>,

    error: Option<String>,

    subscriptions: Option<Vec<models::Subscription>>,

}

fn format_date(timestamp: i64) -> String {

    DateTime::from_timestamp(timestamp, 0)

        .map(|dt| dt.format("%b %-d, %Y").to_string())

        .unwrap_or_default()

}

fn freshrss_env() -> Option<(String, String, String)> {

    let url = std::env::var("FRESHRSS_URL").ok()?;

    let username = std::env::var("FRESHRSS_USERNAME").ok()?;

    let password = std::env::var("FRESHRSS_PASSWORD").ok()?;

    Some((url, username, password))

}

async fn index_handler(Query(params): Query<HashMap<String, String>>) -> impl IntoResponse {

    let url_query = params

        .get("url")

        .or_else(|| params.get("urls"))

        .map(|s| s.as_str());

    let template = match feeds::get_feed_items(url_query).await {

        Ok((items, feed_urls)) => {

            let template_items: Vec<TemplateFeedItem> = items

                .into_iter()

                .map(|item| TemplateFeedItem {

                    title: item.title,

                    link: item.link,

                    author: item.author,

                    formatted_date: format_date(item.published),

                })

                .collect();

            IndexTemplate {

                items: template_items,

                feed_urls,

                error: None,

            }

        }

        Err(e) => {

            eprintln!("Error fetching feeds: {e}");

            IndexTemplate {

                items: Vec::new(),

                feed_urls: None,

                error: Some("Error loading feeds. Please try again later.".to_string()),

            }

        }

    };

    Html(template.render().unwrap())

}

async fn feeds_handler(

    Query(params): Query<HashMap<String, String>>,

) -> Result<Response, StatusCode> {

    let format = params

        .get("format")

        .map(|s| s.as_str())

        .unwrap_or("json");

    let freshrss_url =

        std::env::var("FRESHRSS_URL").map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let username =

        std::env::var("FRESHRSS_USERNAME").map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let password =

        std::env::var("FRESHRSS_PASSWORD").map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let data = feeds::fetch_freshrss_subscriptions(&freshrss_url, &username, &password)

        .await

        .map_err(|e| {

            eprintln!("Failed to fetch subscriptions: {e}");

            StatusCode::INTERNAL_SERVER_ERROR

        })?;

    match format {

        "json" => Ok(Json(serde_json::json!(data)).into_response()),

        "opml" => {

            let now = chrono::Utc::now().to_rfc2822();

            let subscriptions = data.subscriptions.unwrap_or_default();

            let mut opml = format!(

                r#"<?xml version="1.0" encoding="UTF-8"?>

<opml version="2.0">

  <head>

    <title>Steve's Feeds</title>

    <dateCreated>{now}</dateCreated>

  </head>

  <body>

"#

            );

            for feed in &subscriptions {

                opml.push_str(&format!(

                    "    <outline type=\"rss\" text=\"{}\" title=\"{}\" xmlUrl=\"{}\" htmlUrl=\"{}\" />\n",

                    escape_xml(&feed.title),

                    escape_xml(&feed.title),

                    escape_xml(&feed.url),

                    escape_xml(feed.html_url.as_deref().unwrap_or("")),

                ));

            }

            opml.push_str("  </body>\n</opml>");

            Ok((

                [

                    (header::CONTENT_TYPE, "application/xml"),

                    (

                        header::CONTENT_DISPOSITION,

                        "attachment; filename=\"feeds.opml\"",

                    ),

                ],

                opml,

            )

                .into_response())

        }

        _ => Ok((

            StatusCode::BAD_REQUEST,

            Json(serde_json::json!({

                "error": "Invalid format. Use ?format=json or ?format=opml"

            })),

        )

            .into_response()),

    }

}

fn escape_xml(s: &str) -> String {

    s.replace('&', "&")

        .replace('<', "&lt;")

        .replace('>', ">")

        .replace('"', """)

        .replace('\'', "'")

}

async fn static_handler(axum::extract::Path(path): axum::extract::Path<String>) -> Response {

    match Assets::get(&path) {

        Some(file) => {

            let mime = mime_guess::from_path(&path).first_or_octet_stream();

            (

                [(header::CONTENT_TYPE, mime.as_ref())],

                file.data.to_vec(),

            )

                .into_response()

        }

        None => StatusCode::NOT_FOUND.into_response(),

    }

}

// --- Admin routes ---

#[derive(Deserialize, Default)]

struct FlashQuery {

    error: Option<String>,

    success: Option<String>,

}

#[derive(Deserialize)]

struct LoginForm {

    password: String,

}

#[derive(Deserialize)]

struct AddFeedForm {

    feed_url: String,

}

async fn login_get_handler(Query(q): Query<FlashQuery>) -> impl IntoResponse {

    Html(LoginTemplate { error: q.error }.render().unwrap())

}

async fn login_post_handler(

    State(state): State<Arc<AppState>>,

    Form(form): Form<LoginForm>,

) -> Response {

    let admin_password = match &state.admin_password {

        Some(p) => p,

        None => {

            return Redirect::to("/admin/login?error=No+admin+password+configured").into_response();

        }

    };

    if !auth::verify_password(&form.password, admin_password) {

        return Redirect::to("/admin/login?error=Invalid+password").into_response();

    }

    let token = auth::generate_session_token();

    auth::create_session(&state.sessions, &token);

    let cookie = auth::build_session_cookie(&token, state.cookie_secure);

    let mut resp = Redirect::to("/admin").into_response();

    resp.headers_mut()

        .insert(header::SET_COOKIE, cookie.parse().unwrap());

    resp

}

async fn logout_handler(

    State(state): State<Arc<AppState>>,

    headers: HeaderMap,

) -> Response {

    if let Some(token) = auth::extract_session_cookie(&headers) {

        auth::delete_session(&state.sessions, &token);

    }

    let mut resp = Redirect::to("/admin/login").into_response();

    resp.headers_mut().insert(

        header::SET_COOKIE,

        auth::clear_session_cookie().parse().unwrap(),

    );

    resp

}