v0.1.0

.env.example

@@ -0,0 +1,17 @@
+# The base URL of the application, e.g., http://localhost:3000 or https://letterfeed.example.com
+LETTERFEED_APP_BASE_URL=http://localhost:3000
+
+# The database URL. Change this if you change the volume mount point
+LETTERFEED_DATABASE_URL=sqlite:////data/letterfeed.db 
+
+# IMAP server settings. Must have IMAP over SSL on port 993
+LETTERFEED_IMAP_SERVER=
+LETTERFEED_IMAP_USERNAME=
+LETTERFEED_IMAP_PASSWORD=
+
+# Email processing settings
+LETTERFEED_SEARCH_FOLDER=INBOX # The folder in which to search for new emails
+LETTERFEED_MOVE_TO_FOLDER= # Optional: Folder to move processed emails
+LETTERFEED_MARK_AS_READ=true # Mark processed emails as read
+LETTERFEED_EMAIL_CHECK_INTERVAL=15 # Interval between checks for new emails
+LETTERFEED_AUTO_ADD_NEW_SENDERS=false # Automatically set up new emails for unknown senders

.github/workflows/ci.yml

@@ -0,0 +1,87 @@
+name: CI
+
+on:
+  release:
+    types: [ published ]
+  push:
+    branches:
+      - master
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  backend:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./backend
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+    - name: Install uv
+      run: curl -LsSf https://astral.sh/uv/install.sh | sh
+    - name: Install dependencies
+      run: |
+        source ~/.cargo/env
+        uv sync --group test
+    - name: Lint with ruff
+      run: |
+        uv run ruff check .
+    - name: Test with pytest
+      run: |
+        uv run pytest
+
+  frontend:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./frontend
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: 20
+        cache: 'npm'
+        cache-dependency-path: frontend/package-lock.json
+    - name: Install dependencies
+      run: npm install
+    - name: Lint with ESLint
+      run: npm run lint
+    - name: Test with Jest
+      run: npm run test
+
+  docker_publish_backend:
+    runs-on: ubuntu-latest
+    needs: backend
+    if: github.event_name == 'release' || github.ref == 'refs/heads/master'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build and publish a Docker image for backend
+        uses: macbre/push-to-ghcr@master
+        with:
+          image_name: letterfeed-backend
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          dockerfile: backend/Dockerfile
+          context: backend/
+
+  docker_publish_frontend:
+    runs-on: ubuntu-latest
+    needs: frontend
+    if: github.event_name == 'release' || github.ref == 'refs/heads/master'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build and publish a Docker image for frontend
+        uses: macbre/push-to-ghcr@master
+        with:
+          image_name: letterfeed-frontend
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          dockerfile: frontend/Dockerfile
+          context: frontend/

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -0,0 +1,137 @@
+# LetterFeed
+
+LetterFeed is a self-hosted application that converts email newsletters into RSS feeds. Kind of like [kill the newsletter](https://github.com/leafac/kill-the-newsletter/), but with a given inbox.
+
+<div align="center">
+  <img src="./screenshot.png">
+</div>
+
+## Getting Started
+
+### Prerequisites
+
+1. An existing mailbox with IMAP over SSL on port 993.
+2. Make sure you have Docker and Docker Compose installed on your system.
+
+### Installation
+
+1.  **Clone the repository:**
+
+    ```bash
+    git clone https://github.com/LeonMusCoden/letterfeed.git
+    cd letterfeed
+    ```
+
+2.  **Configure environment variables:**
+
+    ```bash
+    cp .env.example .env
+    ```
+
+    Edit the `.env` file with your specific settings. 
+
+3.  **Build and run the Docker containers:**
+
+    ```bash
+    docker compose up --build
+    ```
+
+### Behind a Reverse Proxy
+
+Here are some example configurations for running LetterFeed behind a reverse proxy.
+
+#### Nginx
+
+```nginx
+server {
+    listen 80;
+    listen 443 ssl;
+    server_name letterfeed.leonmuscat.de;
+
+    # SSL configuration (assuming certs are managed elsewhere, e.g., Certbot)
+    ssl_certificate /etc/letsencrypt/live/letterfeed.leonmuscat.de/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/letterfeed.leonmuscat.de/privkey.pem;
+    include /etc/letsencrypt/options-ssl-nginx.conf;
+    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
+
+    # Public Feeds (No Authentication)
+    location /api/feeds/ {
+        proxy_pass http://frontend:3000; # Assuming 'frontend' is the service name or IP
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # Secure Frontend (With Basic Auth)
+    location / {
+        auth_basic "Restricted Area";
+        auth_basic_user_file /etc/nginx/conf.d/htpasswd; # Path to your htpasswd file
+
+        proxy_pass http://frontend:3000; # Assuming 'frontend' is the service name or IP
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+#### Traefik
+
+Create a docker-compose.override.yml with 2 routers for feeds and everything else.
+
+```yaml
+services:
+  frontend:
+    ports: !override []
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.services.frontend.loadbalancer.server.port=3000"
+      - "traefik.docker.network=traefik_web"
+
+      # --- Router for Public Feeds (No Authentication) ---
+      - "traefik.http.routers.frontend-public.rule=Host(`letterfeed.leonmuscat.de`) && PathPrefix(`/api/feeds/`)"
+      - "traefik.http.routers.frontend-public.priority=10"
+      - "traefik.http.routers.frontend-public.entrypoints=websecure"
+      - "traefik.http.routers.frontend-public.tls.certresolver=myresolver"
+
+      # --- Router for Secure Frontend (With Basic Auth) ---
+      - "traefik.http.routers.frontend-secure.rule=Host(`letterfeed.leonmuscat.de`)"
+      - "traefik.http.routers.frontend-secure.priority=5"
+      - "traefik.http.routers.frontend-secure.entrypoints=websecure"
+      - "traefik.http.routers.frontend-secure.tls.certresolver=myresolver"
+      - "traefik.http.routers.frontend-secure.middlewares=frontend-auth@docker"
+      - "traefik.http.middlewares.frontend-auth.basicauth.users=test:$$apr1$$ruV6b18i$$9J0V2yJ94jL0g08xJ2Q0Q/"
+
+    networks:
+      - letterfeed_network
+      - traefik_web
+
+networks:
+  traefik_web:
+    external: true
+```
+
+## Development
+
+### Frontend (Next.js)
+
+To run the frontend in development mode:
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+### Backend (FastAPI)
+
+To run the backend in development mode:
+
+```bash
+cd backend
+uv sync --group test
+uvicorn app.main:app --reload
+```
+

backend/.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+*.db

backend/.python-version

@@ -0,0 +1 @@
+3.12

backend/Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.13-alpine AS base
+
+FROM base AS builder
+
+COPY --from=ghcr.io/astral-sh/uv:0.7.20 /uv /bin/uv
+ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy
+
+WORKDIR /app
+COPY pyproject.toml uv.lock ./
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen
+
+COPY app .
+
+FROM base
+COPY --from=builder /app /app
+
+EXPOSE 8000
+
+ENV PATH="/app/.venv/bin:$PATH"
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

backend/app/__init__.py

@@ -0,0 +1 @@
+"""The main application package."""

backend/app/core/__init__.py

@@ -0,0 +1 @@
+"""Core application modules."""

backend/app/core/config.py

@@ -0,0 +1,32 @@
+from pydantic import AliasChoices, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+"""Configuration settings for the Letterfeed application."""
+
+
+class Settings(BaseSettings):
+    """Application settings, loaded from environment variables or .env file."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env", extra="ignore", env_prefix="LETTERFEED_", frozen=True
+    )
+
+    database_url: str = Field(
+        "sqlite:////data/letterfeed.db",
+        validation_alias=AliasChoices("DATABASE_URL", "LETTERFEED_DATABASE_URL"),
+    )
+    app_base_url: str = Field(
+        "http://localhost:8000",
+        validation_alias=AliasChoices("APP_BASE_URL", "LETTERFEED_APP_BASE_URL"),
+    )
+    imap_server: str = ""
+    imap_username: str = ""
+    imap_password: str = ""
+    search_folder: str = "INBOX"
+    move_to_folder: str | None = None
+    mark_as_read: bool = False
+    email_check_interval: int = 15
+    auto_add_new_senders: bool = False
+
+
+settings = Settings()

backend/app/core/database.py

@@ -0,0 +1,25 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+"""Database connection and session management."""
+
+logger = get_logger(__name__)
+
+engine = create_engine(settings.database_url, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    """Dependency that provides a database session."""
+    logger.debug("Creating new database session")
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        logger.debug("Closing database session")
+        db.close()

backend/app/core/imap.py

@@ -0,0 +1,42 @@
+import imaplib
+
+from app.core.logging import get_logger
+
+"""IMAP utility functions for connecting to mail servers and fetching folders."""
+
+logger = get_logger(__name__)
+
+
+def _test_imap_connection(server, username, password):
+    """Test the IMAP connection with the given credentials."""
+    logger.info(f"Testing IMAP connection to {server} for user {username}")
+    try:
+        mail = imaplib.IMAP4_SSL(server)
+        mail.login(username, password)
+        mail.logout()
+        logger.info("IMAP connection successful")
+        return True, "Connection successful"
+    except Exception as e:
+        logger.error(f"IMAP connection failed: {e}")
+        return False, str(e)
+
+
+def get_folders(server, username, password):
+    """Fetch a list of IMAP folders from the mail server."""
+    logger.info(f"Fetching IMAP folders from {server} for user {username}")
+    try:
+        mail = imaplib.IMAP4_SSL(server)
+        mail.login(username, password)
+        status, folders = mail.list()
+        mail.logout()
+        if status == "OK":
+            folder_list = [
+                folder.decode().split(' "/" ')[1].strip('"') for folder in folders
+            ]
+            logger.info(f"Found {len(folder_list)} folders")
+            return folder_list
+        logger.warning(f"Failed to list IMAP folders, status: {status}")
+        return []
+    except Exception as e:
+        logger.error(f"Error fetching IMAP folders: {e}")
+        return []

backend/app/core/logging.py

@@ -0,0 +1,51 @@
+import logging
+from logging.config import dictConfig
+
+"""Logging configuration for the application."""
+
+
+def setup_logging():
+    """Set up the logging configuration for the application."""
+    log_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "default": {
+                "()": "logging.Formatter",
+                "fmt": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            },
+        },
+        "handlers": {
+            "default": {
+                "formatter": "default",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+            },
+        },
+        "loggers": {
+            "app": {
+                "handlers": ["default"],
+                "level": "INFO",
+                "propagate": True,
+            },
+            "uvicorn": {
+                "handlers": ["default"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "uvicorn.error": {
+                "level": "INFO",
+            },
+            "uvicorn.access": {
+                "handlers": ["default"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    }
+    dictConfig(log_config)
+
+
+def get_logger(name: str):
+    """Return a logger instance with the given name."""
+    return logging.getLogger(name)

backend/app/core/scheduler.py

@@ -0,0 +1,54 @@
+from apscheduler.schedulers.background import BackgroundScheduler
+
+from app.core.database import SessionLocal
+from app.core.logging import get_logger
+from app.crud.settings import get_settings
+from app.services.email_processor import process_emails
+
+"""Scheduler for background tasks like email processing."""
+
+logger = get_logger(__name__)
+
+
+def job():
+    """Process emails as a scheduled job."""
+    logger.info("Scheduler job starting: process_emails")
+    db = SessionLocal()
+    try:
+        process_emails(db)
+        logger.info("Scheduler job finished: process_emails")
+    except Exception as e:
+        logger.error(f"Error in scheduled job process_emails: {e}", exc_info=True)
+    finally:
+        db.close()
+
+
+scheduler = BackgroundScheduler()
+
+
+def start_scheduler_with_interval():
+    """Start the scheduler with an interval based on application settings."""
+    logger.info("Attempting to start scheduler...")
+    db = SessionLocal()
+    try:
+        settings = get_settings(db)
+        interval = settings.email_check_interval if settings else 15
+        logger.info(f"Setting scheduler interval to {interval} minutes")
+        scheduler.add_job(
+            job,
+            "interval",
+            minutes=interval,
+            id="email_check_job",
+            replace_existing=True,
+        )
+        if not scheduler.running:
+            # Run the job immediately once
+            job()
+            scheduler.start()
+            logger.info("Scheduler started.")
+        else:
+            logger.info("Scheduler is already running.")
+    except Exception as e:
+        logger.error(f"Failed to start scheduler: {e}", exc_info=True)
+    finally:
+        db.close()

backend/app/crud/__init__.py

@@ -0,0 +1 @@
+"""CRUD operations for database models."""

backend/app/crud/entries.py

@@ -0,0 +1,36 @@
+from sqlalchemy.orm import Session
+
+from app.core.logging import get_logger
+from app.models.entries import Entry
+from app.schemas.entries import EntryCreate
+
+logger = get_logger(__name__)
+
+
+def get_entries_by_newsletter(
+    db: Session, newsletter_id: int, skip: int = 0, limit: int = 100
+):
+    """Retrieve entries for a specific newsletter."""
+    logger.debug(
+        f"Querying entries for newsletter_id={newsletter_id}, skip={skip}, limit={limit}"
+    )
+    return (
+        db.query(Entry)
+        .filter(Entry.newsletter_id == newsletter_id)
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
+
+
+def create_entry(db: Session, entry: EntryCreate, newsletter_id: int):
+    """Create a new entry for a newsletter."""
+    logger.info(
+        f"Creating new entry for newsletter_id={newsletter_id} with subject '{entry.subject}'"
+    )
+    db_entry = Entry(**entry.model_dump(), newsletter_id=newsletter_id)
+    db.add(db_entry)
+    db.commit()
+    db.refresh(db_entry)
+    logger.info(f"Successfully created entry with id={db_entry.id}")
+    return db_entry

backend/app/crud/newsletters.py

@@ -0,0 +1,106 @@
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from app.core.logging import get_logger
+from app.models.entries import Entry
+from app.models.newsletters import Newsletter, Sender
+from app.schemas.newsletters import NewsletterCreate, NewsletterUpdate
+
+logger = get_logger(__name__)
+
+
+def get_newsletter(db: Session, newsletter_id: int):
+    """Retrieve a single newsletter by its ID."""
+    logger.debug(f"Querying for newsletter with id={newsletter_id}")
+    result = (
+        db.query(Newsletter, func.count(Entry.id))
+        .outerjoin(Entry, Newsletter.id == Entry.newsletter_id)
+        .filter(Newsletter.id == newsletter_id)
+        .group_by(Newsletter.id)
+        .first()
+    )
+    if result:
+        newsletter, count = result
+        newsletter.entries_count = count
+        return newsletter
+    return None
+
+
+def get_newsletters(db: Session, skip: int = 0, limit: int = 100):
+    """Retrieve a list of newsletters."""
+    logger.debug(f"Querying for newsletters with skip={skip}, limit={limit}")
+    results = (
+        db.query(Newsletter, func.count(Entry.id))
+        .outerjoin(Entry, Newsletter.id == Entry.newsletter_id)
+        .group_by(Newsletter.id)
+        .order_by(Newsletter.id)
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
+
+    newsletters_with_count = []
+    for newsletter, count in results:
+        newsletter.entries_count = count
+        newsletters_with_count.append(newsletter)
+
+    return newsletters_with_count
+
+
+def create_newsletter(db: Session, newsletter: NewsletterCreate):
+    """Create a new newsletter."""
+    logger.info(f"Creating new newsletter with name '{newsletter.name}'")
+    db_newsletter = Newsletter(name=newsletter.name)
+    db.add(db_newsletter)
+    db.commit()
+    db.refresh(db_newsletter)
+
+    for email in newsletter.sender_emails:
+        db_sender = Sender(email=email, newsletter_id=db_newsletter.id)
+        db.add(db_sender)
+
+    db.commit()
+    db.refresh(db_newsletter)
+
+    logger.info(f"Successfully created newsletter with id={db_newsletter.id}")
+    db_newsletter.entries_count = 0
+    return db_newsletter
+
+
+def update_newsletter(
+    db: Session, newsletter_id: int, newsletter_update: NewsletterUpdate
+):
+    """Update an existing newsletter."""
+    logger.info(f"Updating newsletter with id={newsletter_id}")
+    db_newsletter = db.query(Newsletter).filter(Newsletter.id == newsletter_id).first()
+    if not db_newsletter:
+        return None
+
+    db_newsletter.name = newsletter_update.name
+
+    # Simple approach: delete existing senders and add new ones
+    for sender in db_newsletter.senders:
+        db.delete(sender)
+    db.commit()
+
+    for email in newsletter_update.sender_emails:
+        db_sender = Sender(email=email, newsletter_id=db_newsletter.id)
+        db.add(db_sender)
+
+    db.commit()
+
+    logger.info(f"Successfully updated newsletter with id={db_newsletter.id}")
+    return get_newsletter(db, newsletter_id)
+
+
+def delete_newsletter(db: Session, newsletter_id: int):
+    """Delete a newsletter by its ID."""
+    logger.info(f"Deleting newsletter with id={newsletter_id}")
+    db_newsletter = get_newsletter(db, newsletter_id)
+    if not db_newsletter:
+        return None
+
+    db.delete(db_newsletter)
+    db.commit()
+    logger.info(f"Successfully deleted newsletter with id={newsletter_id}")
+    return db_newsletter

backend/app/crud/settings.py

@@ -0,0 +1,98 @@
+from sqlalchemy.orm import Session
+
+from app.core.config import settings as env_settings
+from app.core.logging import get_logger
+from app.models.settings import Settings as SettingsModel
+from app.schemas.settings import Settings as SettingsSchema
+from app.schemas.settings import SettingsCreate
+
+logger = get_logger(__name__)
+
+
+def get_settings(db: Session, with_password: bool = False) -> SettingsSchema:
+    """Retrieve application settings, prioritizing environment variables over database."""
+    logger.debug("Querying for settings")
+    db_settings = db.query(SettingsModel).first()
+
+    if not db_settings:
+        logger.info(
+            "No settings found in the database, creating new default settings from environment variables."
+        )
+
+        # Get env settings, but only for fields that exist in the DB model
+        model_fields = {c.name for c in SettingsModel.__table__.columns}
+        env_data_for_db = {
+            k: v for k, v in env_settings.model_dump().items() if k in model_fields
+        }
+
+        db_settings = SettingsModel(**env_data_for_db)
+        db.add(db_settings)
+        db.commit()
+        db.refresh(db_settings)
+        logger.info("Default settings created from environment variables.")
+
+    # Build dictionary from DB model attributes, handling possible None values
+    db_data = {
+        "id": db_settings.id,
+        "imap_server": db_settings.imap_server or "",
+        "imap_username": db_settings.imap_username or "",
+        "search_folder": db_settings.search_folder,
+        "move_to_folder": db_settings.move_to_folder,
+        "mark_as_read": db_settings.mark_as_read,
+        "email_check_interval": db_settings.email_check_interval,
+        "auto_add_new_senders": db_settings.auto_add_new_senders,
+    }
+
+    # Get all environment settings that were explicitly set.
+    env_data = env_settings.model_dump(exclude_unset=True)
+
+    # Merge them. env_data takes precedence.
+    merged_data = {**db_data, **env_data}
+
+    # The fields that came from env are the "locked" ones.
+    locked_fields = list(env_data.keys())
+    logger.debug(f"Locked fields from environment variables: {locked_fields}")
+
+    # Handle password separately for security
+    if with_password:
+        logger.debug("Including IMAP password in settings data")
+        if "imap_password" in locked_fields:
+            merged_data["imap_password"] = env_settings.imap_password
+        else:
+            merged_data["imap_password"] = db_settings.imap_password
+    elif "imap_password" in merged_data:
+        # Ensure password is not in the data if not requested
+        del merged_data["imap_password"]
+
+    # Create the final schema object
+    settings_schema = SettingsSchema.model_validate(merged_data)
+    settings_schema.locked_fields = locked_fields
+
+    return settings_schema
+
+
+def create_or_update_settings(db: Session, settings: SettingsCreate):
+    """Create or update application settings."""
+    logger.info("Creating or updating settings")
+    db_settings = db.query(SettingsModel).first()
+    if not db_settings:
+        logger.info("No existing settings found, creating new ones.")
+        db_settings = SettingsModel()
+        db.add(db_settings)
+
+    update_data = settings.model_dump()
+
+    # Do not update fields that are set by environment variables
+    locked_fields = list(env_settings.model_dump(exclude_unset=True).keys())
+    logger.debug(f"Fields locked by environment variables: {locked_fields}")
+
+    for key, value in update_data.items():
+        if key not in locked_fields:
+            setattr(db_settings, key, value)
+
+    db.commit()
+    db.refresh(db_settings)
+    logger.info("Successfully updated settings.")
+
+    # Return the updated settings including locked fields for a complete view
+    return get_settings(db)

backend/app/main.py

@@ -0,0 +1,48 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.database import Base, engine
+from app.core.logging import get_logger, setup_logging
+from app.core.scheduler import scheduler, start_scheduler_with_interval
+from app.routers import feeds, health, imap, newsletters
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Handle application startup and shutdown events."""
+    setup_logging()
+    logger = get_logger(__name__)
+    from app.core.config import settings
+
+    logger.info(f"DATABASE_URL used: {settings.database_url}")
+    logger.info("Starting up Letterfeed backend...")
+    Base.metadata.create_all(bind=engine)
+    start_scheduler_with_interval()
+    yield
+    if scheduler.running:
+        logger.info("Shutting down scheduler...")
+        scheduler.shutdown()
+    logger.info("...Letterfeed backend shut down.")
+
+
+app = FastAPI(lifespan=lifespan)
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://localhost:3000",
+        "http://127.0.0.1:5173",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router)
+app.include_router(imap.router)
+app.include_router(newsletters.router)
+app.include_router(feeds.router)

backend/app/models/__init__.py

@@ -0,0 +1 @@
+"""SQLAlchemy models for the database."""

backend/app/models/entries.py

@@ -0,0 +1,21 @@
+import datetime
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from app.core.database import Base
+
+
+class Entry(Base):
+    """Represents an entry (e.g., an email) associated with a newsletter."""
+    __tablename__ = "entries"
+
+    id = Column(Integer, primary_key=True, index=True)
+    newsletter_id = Column(Integer, ForeignKey("newsletters.id"))
+    subject = Column(String)
+    body = Column(Text)
+    received_at = Column(
+        DateTime(timezone=True), default=datetime.datetime.now(datetime.UTC)
+    )
+
+    newsletter = relationship("Newsletter", back_populates="entries")

backend/app/models/newsletters.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+from app.core.database import Base
+
+
+class Newsletter(Base):
+    """Represents a newsletter, which can have multiple senders and entries."""
+    __tablename__ = "newsletters"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String)
+    is_active = Column(Boolean, default=True)
+
+    senders = relationship(
+        "Sender", back_populates="newsletter", cascade="all, delete-orphan"
+    )
+    entries = relationship(
+        "Entry", back_populates="newsletter", cascade="all, delete-orphan"
+    )
+
+
+class Sender(Base):
+    """Represents an email sender associated with a newsletter."""
+    __tablename__ = "senders"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    newsletter_id = Column(Integer, ForeignKey("newsletters.id"), nullable=False)
+
+    newsletter = relationship("Newsletter", back_populates="senders")

backend/app/models/settings.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Boolean, Column, Integer, String
+
+from app.core.database import Base
+
+
+class Settings(Base):
+    """Represents application settings, including IMAP configuration."""
+    __tablename__ = "settings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    imap_server = Column(String, index=True, nullable=True, default="")
+    imap_username = Column(String, nullable=True, default="")
+    imap_password = Column(String, nullable=True)
+    search_folder = Column(String, default="INBOX")
+    move_to_folder = Column(String, nullable=True)
+    mark_as_read = Column(Boolean, default=False)
+    email_check_interval = Column(Integer, default=15)  # Interval in minutes
+    auto_add_new_senders = Column(Boolean, default=False)

backend/app/routers/__init__.py

@@ -0,0 +1 @@
+"""API routers for the application."""

backend/app/routers/feeds.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import Response
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.core.logging import get_logger
+from app.services.feed_generator import generate_feed
+
+logger = get_logger(__name__)
+router = APIRouter()
+
+
+@router.get("/feeds/{newsletter_id}")
+def get_newsletter_feed(newsletter_id: int, db: Session = Depends(get_db)):
+    """Generate an Atom feed for a specific newsletter."""
+    logger.info(f"Generating feed for newsletter_id={newsletter_id}")
+    feed = generate_feed(db, newsletter_id)
+    if not feed:
+        logger.warning(
+            f"Newsletter with id={newsletter_id} not found, cannot generate feed."
+        )
+        raise HTTPException(status_code=404, detail="Newsletter not found")
+
+    logger.info(f"Successfully generated feed for newsletter_id={newsletter_id}")
+    return Response(content=feed, media_type="application/atom+xml")

backend/app/routers/health.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter()
+
+
+@router.get("/health")
+def health_check():
+    """Perform a health check of the API."""
+    logger.info("Health check endpoint called")
+    return {"status": "ok"}

backend/app/routers/imap.py

@@ -0,0 +1,73 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.core.imap import _test_imap_connection, get_folders
+from app.core.logging import get_logger
+from app.crud.settings import create_or_update_settings, get_settings
+from app.schemas.settings import Settings, SettingsCreate
+
+logger = get_logger(__name__)
+router = APIRouter()
+
+
+@router.get("/imap/settings", response_model=Settings)
+def read_settings(db: Session = Depends(get_db)):
+    """Retrieve IMAP settings."""
+    logger.info("Request to read IMAP settings")
+    settings = get_settings(db)
+    if not settings:
+        logger.warning("IMAP settings not found")
+        raise HTTPException(status_code=404, detail="IMAP settings not found")
+    return settings
+
+
+@router.post("/imap/settings", response_model=Settings)
+def update_settings(settings: SettingsCreate, db: Session = Depends(get_db)):
+    """Update IMAP settings."""
+    logger.info("Request to update IMAP settings")
+    return create_or_update_settings(db=db, settings=settings)
+
+
+@router.post("/imap/test")
+def test_connection(db: Session = Depends(get_db)):
+    """Test the IMAP connection with current settings."""
+    logger.info("Request to test IMAP connection")
+    settings = get_settings(db, with_password=True)
+    if not settings:
+        logger.error("IMAP settings not found, cannot test connection")
+        raise HTTPException(status_code=404, detail="IMAP settings not found")
+
+    is_successful, message = _test_imap_connection(
+        server=settings.imap_server,
+        username=settings.imap_username,
+        password=settings.imap_password,
+    )
+
+    if not is_successful:
+        logger.warning(f"IMAP connection test failed: {message}")
+        raise HTTPException(status_code=400, detail=message)
+
+    logger.info("IMAP connection test successful")
+    return {"message": message}
+
+
+@router.get("/imap/folders", response_model=List[str])
+def read_folders(db: Session = Depends(get_db)):
+    """Retrieve a list of IMAP folders from the configured server."""
+    logger.info("Request to fetch IMAP folders")
+    settings = get_settings(db, with_password=True)
+    if not settings:
+        logger.error("IMAP settings not found, cannot fetch folders")
+        raise HTTPException(status_code=404, detail="IMAP settings not found")
+
+    folders = get_folders(
+        server=settings.imap_server,
+        username=settings.imap_username,
+        password=settings.imap_password,
+    )
+
+    logger.info(f"Found {len(folders)} IMAP folders")
+    return folders

backend/app/routers/newsletters.py

@@ -0,0 +1,72 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.core.logging import get_logger
+from app.crud.newsletters import (
+    create_newsletter,
+    delete_newsletter,
+    get_newsletter,
+    get_newsletters,
+    update_newsletter,
+)
+from app.schemas.newsletters import Newsletter, NewsletterCreate, NewsletterUpdate
+
+logger = get_logger(__name__)
+router = APIRouter()
+
+
+@router.post("/newsletters", response_model=Newsletter)
+def create_new_newsletter(newsletter: NewsletterCreate, db: Session = Depends(get_db)):
+    """Create a new newsletter."""
+    logger.info(
+        f"Request to create new newsletter for senders {newsletter.sender_emails}"
+    )
+    return create_newsletter(db=db, newsletter=newsletter)
+
+
+@router.get("/newsletters", response_model=List[Newsletter])
+def read_newsletters(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    """Retrieve a list of newsletters."""
+    logger.info(f"Request to read newsletters with skip={skip}, limit={limit}")
+    newsletters = get_newsletters(db, skip=skip, limit=limit)
+    return newsletters
+
+
+@router.get("/newsletters/{newsletter_id}", response_model=Newsletter)
+def read_newsletter(newsletter_id: int, db: Session = Depends(get_db)):
+    """Retrieve a single newsletter by its ID."""
+    logger.info(f"Request to read newsletter with id={newsletter_id}")
+    db_newsletter = get_newsletter(db, newsletter_id=newsletter_id)
+    if db_newsletter is None:
+        logger.warning(f"Newsletter with id={newsletter_id} not found")
+        raise HTTPException(status_code=404, detail="Newsletter not found")
+    return db_newsletter
+
+
+@router.put("/newsletters/{newsletter_id}", response_model=Newsletter)
+def update_existing_newsletter(
+    newsletter_id: int, newsletter: NewsletterUpdate, db: Session = Depends(get_db)
+):
+    """Update an existing newsletter."""
+    logger.info(f"Request to update newsletter with id={newsletter_id}")
+    db_newsletter = update_newsletter(
+        db, newsletter_id=newsletter_id, newsletter_update=newsletter
+    )
+    if db_newsletter is None:
+        logger.warning(f"Newsletter with id={newsletter_id} not found, cannot update")
+        raise HTTPException(status_code=404, detail="Newsletter not found")
+    return db_newsletter
+
+
+@router.delete("/newsletters/{newsletter_id}", response_model=Newsletter)
+def delete_existing_newsletter(newsletter_id: int, db: Session = Depends(get_db)):
+    """Delete a newsletter by its ID."""
+    logger.info(f"Request to delete newsletter with id={newsletter_id}")
+    db_newsletter = delete_newsletter(db, newsletter_id=newsletter_id)
+    if db_newsletter is None:
+        logger.warning(f"Newsletter with id={newsletter_id} not found, cannot delete")
+        raise HTTPException(status_code=404, detail="Newsletter not found")
+    return db_newsletter

backend/app/schemas/__init__.py

@@ -0,0 +1 @@
+"""Pydantic schemas for data validation and serialization."""

backend/app/schemas/entries.py

@@ -0,0 +1,23 @@
+import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class EntryBase(BaseModel):
+    """Base schema for an entry."""
+    subject: str
+    body: str
+
+
+class EntryCreate(EntryBase):
+    """Schema for creating a new entry."""
+    pass
+
+
+class Entry(EntryBase):
+    """Schema for retrieving an entry with its ID and newsletter ID."""
+    id: int
+    newsletter_id: int
+    received_at: datetime.datetime
+
+    model_config = ConfigDict(from_attributes=True)

backend/app/schemas/newsletters.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from pydantic import BaseModel, ConfigDict
+
+
+class SenderBase(BaseModel):
+    """Base schema for a sender."""
+    email: str
+
+
+class SenderCreate(SenderBase):
+    """Schema for creating a new sender."""
+    pass
+
+
+class Sender(SenderBase):
+    """Schema for retrieving a sender with its ID and newsletter ID."""
+    id: int
+    newsletter_id: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NewsletterBase(BaseModel):
+    """Base schema for a newsletter."""
+    name: str
+
+
+class NewsletterCreate(NewsletterBase):
+    """Schema for creating a new newsletter."""
+    sender_emails: List[str]
+
+
+class NewsletterUpdate(NewsletterBase):
+    """Schema for updating an existing newsletter."""
+    sender_emails: List[str]
+
+
+class Newsletter(NewsletterBase):
+    """Schema for retrieving a newsletter with its ID, active status, senders, and entries count."""
+    id: int
+    is_active: bool
+    senders: List[Sender] = []
+    entries_count: int
+
+    model_config = ConfigDict(from_attributes=True)

backend/app/schemas/settings.py

@@ -0,0 +1,28 @@
+from typing import List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class SettingsBase(BaseModel):
+    """Base schema for application settings."""
+    imap_server: str
+    imap_username: str
+    search_folder: str = "INBOX"
+    move_to_folder: str | None = None
+    mark_as_read: bool = False
+    email_check_interval: int = 15
+    auto_add_new_senders: bool = False
+
+
+class SettingsCreate(SettingsBase):
+    """Schema for creating or updating settings, including the IMAP password."""
+    imap_password: str
+
+
+class Settings(SettingsBase):
+    """Schema for retrieving settings, with password excluded by default."""
+    id: int
+    imap_password: str | None = Field(None, exclude=True)
+    locked_fields: List[str] = []
+
+    model_config = ConfigDict(from_attributes=True)

backend/app/services/__init__.py

@@ -0,0 +1 @@
+"""Application services for business logic."""

backend/app/services/email_processor.py

@@ -0,0 +1,128 @@
+import email
+import imaplib
+
+from sqlalchemy.orm import Session
+
+from app.core.logging import get_logger
+from app.crud.entries import create_entry
+from app.crud.newsletters import create_newsletter, get_newsletters
+from app.crud.settings import get_settings
+from app.schemas.entries import EntryCreate
+from app.schemas.newsletters import NewsletterCreate
+
+logger = get_logger(__name__)
+
+
+def process_emails(db: Session):
+    """Process unread emails, add them as entries, and manage newsletters."""
+    logger.info("Starting email processing...")
+    settings = get_settings(db, with_password=True)
+    if (
+        not settings
+        or not settings.imap_server
+        or not settings.imap_username
+        or not settings.imap_password
+    ):
+        logger.warning("IMAP settings are not configured. Skipping email processing.")
+        return
+
+    newsletters = get_newsletters(db)
+    sender_map = {}
+    for nl in newsletters:
+        for sender in nl.senders:
+            sender_map[sender.email] = nl
+    logger.info(f"Processing emails for {len(newsletters)} newsletters.")
+
+    try:
+        logger.info(f"Connecting to IMAP server: {settings.imap_server}")
+        mail = imaplib.IMAP4_SSL(settings.imap_server)
+        mail.login(settings.imap_username, settings.imap_password)
+        mail.select(settings.search_folder)
+        logger.info(f"Selected mailbox: {settings.search_folder}")
+
+        status, messages = mail.search(None, "(UNSEEN)")
+        if status != "OK":
+            logger.error(f"Failed to search for unseen emails, status: {status}")
+            return
+
+        email_ids = messages[0].split()
+        logger.info(f"Found {len(email_ids)} unseen emails.")
+
+        for num in email_ids:
+            status, data = mail.fetch(num, "(RFC822)")
+            if status != "OK":
+                logger.warning(f"Failed to fetch email with id={num}")
+                continue
+
+            msg = email.message_from_bytes(data[0][1])
+            sender = email.utils.parseaddr(msg["From"])[1]
+            logger.debug(
+                f"Processing email from {sender} with subject '{msg['Subject']}'"
+            )
+
+            newsletter = sender_map.get(sender)
+            if not newsletter and settings.auto_add_new_senders:
+                logger.info(f"Auto-adding new newsletter for sender: {sender}")
+                newsletter_name = email.utils.parseaddr(msg["From"])[0] or sender
+                new_newsletter_schema = NewsletterCreate(
+                    name=newsletter_name, sender_emails=[sender]
+                )
+                newsletter = create_newsletter(db, new_newsletter_schema)
+                sender_map[sender] = newsletter
+
+            if newsletter:
+                subject = msg["Subject"]
+
+                body = ""
+                html = ""
+
+                for part in msg.walk():
+                    ctype = part.get_content_type()
+                    cdispo = str(part.get("Content-Disposition"))
+
+                    if "attachment" in cdispo:
+                        continue
+
+                    if ctype == "text/plain":
+                        try:
+                            payload = part.get_payload(decode=True)
+                            charset = part.get_content_charset() or "utf-8"
+                            body = payload.decode(charset, "ignore")
+                        except Exception:
+                            pass
+                    elif ctype == "text/html":
+                        try:
+                            payload = part.get_payload(decode=True)
+                            charset = part.get_content_charset() or "utf-8"
+                            html = payload.decode(charset, "ignore")
+                        except Exception:
+                            pass
+
+                final_body = html or body
+
+                entry = EntryCreate(subject=subject, body=final_body)
+                create_entry(db, entry, newsletter.id)
+                logger.info(
+                    f"Created new entry for newsletter '{newsletter.name}' from sender {sender}"
+                )
+
+                if settings.mark_as_read:
+                    logger.debug(f"Marking email with id={num} as read")
+                    mail.store(num, "+FLAGS", "\\Seen")
+
+                if settings.move_to_folder:
+                    logger.debug(
+                        f"Moving email with id={num} to {settings.move_to_folder}"
+                    )
+                    mail.copy(num, settings.move_to_folder)
+                    mail.store(num, "+FLAGS", "\\Deleted")
+
+        if settings.move_to_folder:
+            logger.info("Expunging deleted emails")
+            mail.expunge()
+
+        mail.logout()
+        logger.info("Email processing finished successfully.")
+
+    except Exception as e:
+        logger.error(f"Error processing emails: {e}", exc_info=True)

backend/app/services/feed_generator.py

@@ -0,0 +1,38 @@
+from dateutil import tz
+from feedgen.feed import FeedGenerator
+from sqlalchemy.orm import Session
+
+from app.core.config import settings
+from app.crud.entries import get_entries_by_newsletter
+from app.crud.newsletters import get_newsletter
+
+
+def generate_feed(db: Session, newsletter_id: int):
+    """Generate an Atom feed for a given newsletter."""
+    newsletter = get_newsletter(db, newsletter_id)
+    if not newsletter:
+        return None
+
+    entries = get_entries_by_newsletter(db, newsletter_id)
+
+    feed_url = f"{settings.app_base_url}/feeds/{newsletter_id}"
+
+    fg = FeedGenerator()
+    fg.id(f"urn:letterfeed:newsletter:{newsletter.id}")
+    fg.title(newsletter.name)
+    fg.link(href=feed_url, rel="self")
+    sender_emails = ", ".join([s.email for s in newsletter.senders])
+    fg.description(f"A feed of newsletters from {sender_emails}")
+
+    for entry in entries:
+        fe = fg.add_entry()
+        fe.id(f"urn:letterfeed:entry:{entry.id}")
+        fe.title(entry.subject)
+        fe.content(entry.body, type="html")
+        if entry.received_at.tzinfo is None:
+            timezone_aware_received_at = entry.received_at.replace(tzinfo=tz.tzutc())
+            fe.published(timezone_aware_received_at)
+        else:
+            fe.published(entry.received_at)
+
+    return fg.atom_str(pretty=True)

backend/app/tests/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for the application."""

backend/app/tests/conftest.py

@@ -0,0 +1,65 @@
+import os
+
+os.environ["LETTERFEED_DATABASE_URL"] = "sqlite:///./test.db"
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import sessionmaker
+
+from app.core.database import Base, engine, get_db
+from app.main import app
+
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+@pytest.fixture(scope="function", autouse=True)
+def setup_and_teardown_db():
+    """Set up and tear down the database for each test.
+
+    This fixture is automatically used for all tests. It creates all tables
+    before a test and drops them afterwards. This ensures a clean database for
+    every test.
+    """
+    Base.metadata.create_all(bind=engine)
+    yield
+    Base.metadata.drop_all(bind=engine)
+
+
+@pytest.fixture(name="db_session")
+def db_session_fixture():
+    """Yield a database session for a test."""
+    db = TestingSessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+@pytest.fixture(name="client")
+def client_fixture(db_session):
+    """Yield a TestClient for a test."""
+
+    def override_get_db():
+        yield db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+    with TestClient(app) as client:
+        yield client
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture(scope="session", autouse=True)
+def cleanup_test_db(request):
+    """Clean up the test database after the test session.
+
+    This fixture is automatically used once per test session. It registers a
+    finalizer to remove the test database file after all tests have run.
+    """
+
+    def remove_test_db():
+        # The path is relative to the backend directory where pytest is run
+        db_file = "test.db"
+        if os.path.exists(db_file):
+            os.remove(db_file)
+
+    request.addfinalizer(remove_test_db)

backend/app/tests/test_core.py

@@ -0,0 +1,201 @@
+from unittest.mock import ANY, MagicMock, patch
+
+from sqlalchemy.orm import Session
+
+from app.core.imap import _test_imap_connection, get_folders
+from app.crud.newsletters import create_newsletter
+from app.crud.settings import create_or_update_settings
+from app.schemas.newsletters import NewsletterCreate
+from app.schemas.settings import SettingsCreate
+from app.services.email_processor import process_emails
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_test_imap_connection_success(mock_imap):
+    """Test IMAP connection success."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+    success, message = _test_imap_connection("imap.test.com", "user", "pass")
+    assert success
+    assert message == "Connection successful"
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_test_imap_connection_failure(mock_imap):
+    """Test IMAP connection failure."""
+    mock_imap.return_value.login.side_effect = Exception("Auth failed")
+    success, message = _test_imap_connection("imap.test.com", "user", "pass")
+    assert not success
+    assert message == "Auth failed"
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_get_folders(mock_imap):
+    """Test fetching IMAP folders."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+    mock_imap.return_value.list.return_value = (
+        "OK",
+        [b'(NOCONNECT NOSELECT) "/" "INBOX"', b'(NOCONNECT NOSELECT) "/" "Processed"'],
+    )
+    folders = get_folders("imap.test.com", "user", "pass")
+    assert folders == ["INBOX", "Processed"]
+
+
+@patch("app.services.email_processor.imaplib.IMAP4_SSL")
+def test_process_emails(mock_imap, db_session: Session):
+    """Test processing emails."""
+    # Setup settings
+    settings_data = SettingsCreate(
+        imap_server="imap.test.com",
+        imap_username="test@test.com",
+        imap_password="password",
+        search_folder="INBOX",
+        move_to_folder="Processed",
+        mark_as_read=True,
+    )
+    create_or_update_settings(db_session, settings_data)
+
+    # Setup newsletter
+    newsletter_data = NewsletterCreate(
+        name="Test Newsletter", sender_emails=["newsletter@example.com"]
+    )
+    create_newsletter(db_session, newsletter_data)
+
+    # Mock IMAP connection and email fetching
+    mock_mail = MagicMock()
+    mock_imap.return_value = mock_mail
+    mock_mail.login.return_value = (None, None)
+    mock_mail.select.return_value = (None, None)
+    mock_mail.search.return_value = ("OK", [b"1"])
+
+    # Mock email content
+    mock_msg_bytes = b"From: newsletter@example.com\nSubject: Test Subject\n\nTest Body"
+    mock_mail.fetch.return_value = ("OK", [(None, mock_msg_bytes)])
+
+    process_emails(db_session)
+
+    # Assertions
+    mock_mail.login.assert_called_once_with("test@test.com", "password")
+    mock_mail.select.assert_called_once_with("INBOX")
+    mock_mail.search.assert_called_once_with(None, "(UNSEEN)")
+    mock_mail.fetch.assert_called_once_with(b"1", "(RFC822)")
+    mock_mail.store.assert_any_call(b"1", "+FLAGS", "\\Seen")
+    mock_mail.copy.assert_called_once_with(b"1", "Processed")
+    mock_mail.store.assert_any_call(b"1", "+FLAGS", "\\Deleted")
+    mock_mail.expunge.assert_called_once()
+    mock_mail.logout.assert_called_once()
+
+    # Verify entry in DB
+    from app.crud.entries import get_entries_by_newsletter
+    from app.crud.newsletters import get_newsletters
+
+    newsletters = get_newsletters(db_session)
+    assert len(newsletters) == 1
+    entries = get_entries_by_newsletter(db_session, newsletters[0].id)
+    assert len(entries) == 1
+    assert entries[0].subject == "Test Subject"
+    assert entries[0].body == "Test Body"
+
+
+@patch("app.core.scheduler.job")
+@patch("app.core.scheduler.SessionLocal")
+@patch("app.core.scheduler.scheduler")
+def test_start_scheduler_with_interval(
+    mock_scheduler, mock_session_local, mock_job, db_session: Session
+):
+    """Test starting the scheduler with an interval."""
+    mock_session_local.return_value = db_session
+    mock_scheduler.running = False
+    settings_data = SettingsCreate(
+        imap_server="imap.test.com",
+        imap_username="test@test.com",
+        imap_password="password",
+        email_check_interval=30,
+    )
+    create_or_update_settings(db_session, settings_data)
+
+    from app.core.scheduler import start_scheduler_with_interval
+
+    start_scheduler_with_interval()
+
+    mock_scheduler.add_job.assert_called_with(
+        ANY, "interval", minutes=30, id="email_check_job", replace_existing=True
+    )
+    mock_scheduler.start.assert_called_once()
+    mock_job.assert_called_once()
+
+
+@patch("app.core.scheduler.SessionLocal")
+@patch("app.core.scheduler.process_emails")
+def test_scheduler_job(mock_process_emails, mock_session_local, db_session: Session):
+    """Test the scheduler job."""
+    mock_session_local.return_value = db_session
+    from app.core.scheduler import job
+
+    job()
+    mock_process_emails.assert_called_once_with(db_session)
+
+
+@patch("app.services.email_processor.imaplib.IMAP4_SSL")
+def test_process_emails_auto_add_sender(mock_imap, db_session: Session):
+    """Test processing emails with auto add sender enabled."""
+    settings_data = SettingsCreate(
+        imap_server="imap.test.com",
+        imap_username="test@test.com",
+        imap_password="password",
+        auto_add_new_senders=True,
+    )
+    create_or_update_settings(db_session, settings_data)
+
+    mock_mail = MagicMock()
+    mock_imap.return_value = mock_mail
+    mock_mail.search.return_value = ("OK", [b"1"])
+    mock_msg_bytes = b"From: New Sender <new@example.com>\nSubject: New Email\n\nHello"
+    mock_mail.fetch.return_value = ("OK", [(None, mock_msg_bytes)])
+
+    process_emails(db_session)
+
+    from app.crud.newsletters import get_newsletters
+
+    newsletters = get_newsletters(db_session)
+    assert len(newsletters) == 1
+    assert len(newsletters[0].senders) == 1
+    assert newsletters[0].senders[0].email == "new@example.com"
+    assert newsletters[0].name == "New Sender"
+
+
+@patch("app.services.email_processor.imaplib.IMAP4_SSL")
+def test_process_emails_no_settings(mock_imap, db_session: Session):
+    """Test processing emails with no settings in the database."""
+    # No settings in the DB
+    process_emails(db_session)
+    mock_imap.assert_not_called()
+
+
+@patch("app.services.email_processor.imaplib.IMAP4_SSL")
+def test_process_emails_no_move_or_read(mock_imap, db_session: Session):
+    """Test processing emails with no move or read."""
+    settings_data = SettingsCreate(
+        imap_server="imap.test.com",
+        imap_username="test@test.com",
+        imap_password="password",
+        mark_as_read=False,
+        move_to_folder=None,
+    )
+    create_or_update_settings(db_session, settings_data)
+    create_newsletter(
+        db_session,
+        NewsletterCreate(name="Test", sender_emails=["newsletter@example.com"]),
+    )
+
+    mock_mail = MagicMock()
+    mock_imap.return_value = mock_mail
+    mock_mail.search.return_value = ("OK", [b"1"])
+    mock_msg_bytes = b"From: newsletter@example.com\nSubject: Test Subject\n\nTest Body"
+    mock_mail.fetch.return_value = ("OK", [(None, mock_msg_bytes)])
+
+    process_emails(db_session)
+
+    mock_mail.store.assert_not_called()
+    mock_mail.copy.assert_not_called()

backend/app/tests/test_crud.py

@@ -0,0 +1,172 @@
+import uuid
+from unittest.mock import patch
+
+from sqlalchemy.orm import Session
+
+from app.crud.entries import create_entry, get_entries_by_newsletter
+from app.crud.newsletters import create_newsletter, get_newsletter, get_newsletters
+from app.crud.settings import create_or_update_settings, get_settings
+from app.schemas.entries import EntryCreate
+from app.schemas.newsletters import NewsletterCreate
+from app.schemas.settings import SettingsCreate
+
+
+def test_create_or_update_settings(db_session: Session):
+    """Test creating or updating settings."""
+    settings_data = SettingsCreate(
+        imap_server="imap.test.com",
+        imap_username="test@test.com",
+        imap_password="password",
+        search_folder="INBOX",
+        move_to_folder="Archive",
+        mark_as_read=True,
+    )
+    settings = create_or_update_settings(db_session, settings_data)
+    assert settings.imap_server == "imap.test.com"
+    assert settings.mark_as_read
+
+    updated_settings_data = SettingsCreate(
+        imap_server="imap.updated.com",
+        imap_username="updated@test.com",
+        imap_password="new_password",
+        search_folder="Inbox",
+        move_to_folder=None,
+        mark_as_read=False,
+    )
+    updated_settings = create_or_update_settings(db_session, updated_settings_data)
+    assert updated_settings.imap_server == "imap.updated.com"
+    assert not updated_settings.mark_as_read
+    assert updated_settings.move_to_folder is None
+
+
+def test_get_settings(db_session: Session):
+    """Test getting settings."""
+    settings_data = SettingsCreate(
+        imap_server="imap.get.com",
+        imap_username="get@test.com",
+        imap_password="get_password",
+        search_folder="INBOX",
+        move_to_folder=None,
+        mark_as_read=False,
+    )
+    create_or_update_settings(db_session, settings_data)
+    settings = get_settings(db_session)
+    assert settings.imap_server == "imap.get.com"
+
+
+def test_get_settings_with_env_override(db_session: Session):
+    """Test getting settings with environment variable override."""
+    # 1. Create initial settings in the database
+    db_settings_data = SettingsCreate(
+        imap_server="db.imap.com",
+        imap_username="db_user",
+        imap_password="db_pass",
+        email_check_interval=15,
+    )
+    create_or_update_settings(db_session, db_settings_data)
+
+    # 2. Patch the env_settings to simulate environment variables
+    with patch("app.crud.settings.env_settings") as mock_env_settings:
+        mock_env_settings.model_dump.return_value = {
+            "imap_server": "env.imap.com",
+            "imap_username": "env_user",
+            "imap_password": "env_pass",
+            "email_check_interval": 30,
+        }
+        mock_env_settings.imap_password = "env_pass"
+
+        # 3. Call get_settings and assert the override
+        settings = get_settings(db_session, with_password=True)
+        assert settings.imap_server == "env.imap.com"
+        assert settings.imap_username == "env_user"
+        assert settings.imap_password == "env_pass"
+        assert settings.email_check_interval == 30
+        assert "imap_server" in settings.locked_fields
+        assert "imap_username" in settings.locked_fields
+
+        # 4. Call create_or_update_settings and assert that locked fields are not updated
+        update_data = SettingsCreate(
+            imap_server="new.imap.com",
+            imap_username="new_user",
+            imap_password="new_pass",
+            email_check_interval=45,
+        )
+        updated_settings = create_or_update_settings(db_session, update_data)
+        assert updated_settings.imap_server == "env.imap.com"  # Should not change
+        assert updated_settings.imap_username == "env_user"  # Should not change
+        assert updated_settings.email_check_interval == 30  # Should not change
+
+
+def test_create_newsletter(db_session: Session):
+    """Test creating a newsletter."""
+    unique_email = f"sender_{uuid.uuid4()}@test.com"
+    newsletter_data = NewsletterCreate(
+        name="Test Newsletter 1", sender_emails=[unique_email]
+    )
+    newsletter = create_newsletter(db_session, newsletter_data)
+    assert newsletter.name == "Test Newsletter 1"
+    assert newsletter.is_active
+    assert len(newsletter.senders) == 1
+    assert newsletter.senders[0].email == unique_email
+
+
+def test_get_newsletter(db_session: Session):
+    """Test getting a single newsletter."""
+    unique_email = f"sender_{uuid.uuid4()}@test.com"
+    newsletter_data = NewsletterCreate(
+        name="Test Newsletter 2", sender_emails=[unique_email]
+    )
+    created_newsletter = create_newsletter(db_session, newsletter_data)
+    newsletter = get_newsletter(db_session, created_newsletter.id)
+    assert newsletter.name == "Test Newsletter 2"
+    assert len(newsletter.senders) == 1
+    assert newsletter.senders[0].email == unique_email
+
+
+def test_get_newsletters(db_session: Session):
+    """Test getting multiple newsletters."""
+    create_newsletter(
+        db_session,
+        NewsletterCreate(
+            name="Test Newsletter 3", sender_emails=[f"sender_{uuid.uuid4()}@test.com"]
+        ),
+    )
+    create_newsletter(
+        db_session,
+        NewsletterCreate(
+            name="Test Newsletter 4", sender_emails=[f"sender_{uuid.uuid4()}@test.com"]
+        ),
+    )
+    newsletters = get_newsletters(db_session)
+    assert len(newsletters) >= 2
+
+
+def test_create_entry(db_session: Session):
+    """Test creating a newsletter entry."""
+    unique_email = f"sender_{uuid.uuid4()}@test.com"
+    newsletter_data = NewsletterCreate(
+        name="Test Newsletter 5", sender_emails=[unique_email]
+    )
+    newsletter = create_newsletter(db_session, newsletter_data)
+    entry_data = EntryCreate(subject="Test Subject", body="Test Body")
+    entry = create_entry(db_session, entry_data, newsletter.id)
+    assert entry.subject == "Test Subject"
+    assert entry.newsletter_id == newsletter.id
+
+
+def test_get_entries_by_newsletter(db_session: Session):
+    """Test getting entries for a newsletter."""
+    unique_email = f"sender_{uuid.uuid4()}@test.com"
+    newsletter_data = NewsletterCreate(
+        name="Test Newsletter 6", sender_emails=[unique_email]
+    )
+    newsletter = create_newsletter(db_session, newsletter_data)
+    create_entry(
+        db_session, EntryCreate(subject="Entry 1", body="Body 1"), newsletter.id
+    )
+    create_entry(
+        db_session, EntryCreate(subject="Entry 2", body="Body 2"), newsletter.id
+    )
+    entries = get_entries_by_newsletter(db_session, newsletter.id)
+    assert len(entries) == 2
+    assert entries[0].subject == "Entry 1"

backend/app/tests/test_routers.py

@@ -0,0 +1,147 @@
+import uuid
+from unittest.mock import patch
+
+from fastapi.testclient import TestClient
+
+
+def test_health_check(client: TestClient):
+    """Test the health check endpoint."""
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_update_imap_settings(mock_imap, client: TestClient):
+    """Test updating IMAP settings."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+
+    settings_data = {
+        "imap_server": "imap.example.com",
+        "imap_username": "test@example.com",
+        "imap_password": "password",
+        "search_folder": "INBOX",
+        "move_to_folder": "Processed",
+        "mark_as_read": True,
+    }
+    response = client.post("/imap/settings", json=settings_data)
+    assert response.status_code == 200
+    assert response.json()["imap_server"] == "imap.example.com"
+    assert response.json()["imap_username"] == "test@example.com"
+    assert response.json()["search_folder"] == "INBOX"
+    assert response.json()["move_to_folder"] == "Processed"
+    assert response.json()["mark_as_read"]
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_get_imap_settings(mock_imap, client: TestClient):
+    """Test getting IMAP settings."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+
+    settings_data = {
+        "imap_server": "imap.example.com",
+        "imap_username": "test@example.com",
+        "imap_password": "password",
+        "search_folder": "INBOX",
+        "move_to_folder": "Processed",
+        "mark_as_read": True,
+    }
+    client.post("/imap/settings", json=settings_data)
+
+    response = client.get("/imap/settings")
+    assert response.status_code == 200
+    assert response.json()["imap_server"] == "imap.example.com"
+    assert response.json()["imap_username"] == "test@example.com"
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_test_imap_connection(mock_imap, client: TestClient):
+    """Test the IMAP connection."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+
+    settings_data = {
+        "imap_server": "imap.example.com",
+        "imap_username": "test@example.com",
+        "imap_password": "password",
+        "search_folder": "INBOX",
+        "move_to_folder": "Processed",
+        "mark_as_read": True,
+    }
+    client.post("/imap/settings", json=settings_data)
+
+    response = client.post("/imap/test")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Connection successful"}
+
+
+@patch("app.core.imap.imaplib.IMAP4_SSL")
+def test_get_imap_folders(mock_imap, client: TestClient):
+    """Test getting IMAP folders."""
+    mock_imap.return_value.login.return_value = (None, None)
+    mock_imap.return_value.logout.return_value = (None, None)
+    mock_imap.return_value.list.return_value = (
+        "OK",
+        [b'(NOCONNECT NOSELECT) "/" "INBOX"', b'(NOCONNECT NOSELECT) "/" "Processed"'],
+    )
+
+    settings_data = {
+        "imap_server": "imap.example.com",
+        "imap_username": "test@example.com",
+        "imap_password": "password",
+        "search_folder": "INBOX",
+        "move_to_folder": "Processed",
+        "mark_as_read": True,
+    }
+    client.post("/imap/settings", json=settings_data)
+
+    response = client.get("/imap/folders")
+    assert response.status_code == 200
+    assert response.json() == ["INBOX", "Processed"]
+
+
+def test_create_newsletter(client: TestClient):
+    """Test creating a newsletter."""
+    unique_email = f"newsletter_{uuid.uuid4()}@example.com"
+    newsletter_data = {"name": "Example Newsletter", "sender_emails": [unique_email]}
+    response = client.post("/newsletters", json=newsletter_data)
+    assert response.status_code == 200
+    assert response.json()["name"] == "Example Newsletter"
+    assert response.json()["is_active"]
+    assert len(response.json()["senders"]) == 1
+    assert response.json()["senders"][0]["email"] == unique_email
+
+
+def test_get_newsletters(client: TestClient):
+    """Test getting all newsletters."""
+    unique_email = f"newsletter_{uuid.uuid4()}@example.com"
+    newsletter_data = {"name": "Another Newsletter", "sender_emails": [unique_email]}
+    client.post("/newsletters", json=newsletter_data)
+
+    response = client.get("/newsletters")
+    assert response.status_code == 200
+    assert len(response.json()) >= 1
+    assert any(
+        unique_email in [s["email"] for s in nl["senders"]] for nl in response.json()
+    )
+
+
+def test_get_single_newsletter(client: TestClient):
+    """Test getting a single newsletter."""
+    unique_email = f"newsletter_{uuid.uuid4()}@example.com"
+    newsletter_data = {"name": "Third Newsletter", "sender_emails": [unique_email]}
+    create_response = client.post("/newsletters/", json=newsletter_data)
+    newsletter_id = create_response.json()["id"]
+
+    response = client.get(f"/newsletters/{newsletter_id}")
+    assert response.status_code == 200
+    assert response.json()["senders"][0]["email"] == unique_email
+
+
+def test_get_nonexistent_newsletter(client: TestClient):
+    """Test getting a nonexistent newsletter."""
+    response = client.get("/newsletters/999")
+    assert response.status_code == 404
+    assert response.json() == {"detail": "Newsletter not found"}

backend/app/tests/test_services.py

@@ -0,0 +1,48 @@
+from sqlalchemy.orm import Session
+
+from app.crud.entries import create_entry
+from app.crud.newsletters import create_newsletter
+from app.schemas.entries import EntryCreate
+from app.schemas.newsletters import NewsletterCreate
+from app.services.feed_generator import generate_feed
+
+
+def test_generate_feed(db_session: Session):
+    """Test the feed generation for a newsletter with entries."""
+    # Create a newsletter
+    newsletter_data = NewsletterCreate(
+        name="Feed Test Newsletter", sender_emails=["feed@example.com"]
+    )
+    newsletter = create_newsletter(db_session, newsletter_data)
+
+    # Create entries for the newsletter
+    entry1_data = EntryCreate(
+        subject="First Entry", body="<p>This is the first entry.</p>"
+    )
+    create_entry(db_session, entry1_data, newsletter.id)
+
+    entry2_data = EntryCreate(
+        subject="Second Entry", body="<p>This is the second entry.</p>"
+    )
+    create_entry(db_session, entry2_data, newsletter.id)
+
+    # Generate the feed
+    feed_xml = generate_feed(db_session, newsletter.id)
+    assert feed_xml is not None
+
+    # Parse the feed XML to verify content (simplified check)
+    # In a real scenario, you'd use an XML parser to validate structure and content more thoroughly
+    assert f"<title>{newsletter.name}</title>" in feed_xml.decode()
+    assert f"<id>urn:letterfeed:newsletter:{newsletter.id}</id>" in feed_xml.decode()
+    assert "<title>First Entry</title>" in feed_xml.decode()
+    assert "<title>Second Entry</title>" in feed_xml.decode()
+    assert (
+        '<content type="html">&lt;p&gt;This is the first entry.&lt;/p&gt;</content>'
+        in feed_xml.decode()
+    )
+
+
+def test_generate_feed_nonexistent_newsletter(db_session: Session):
+    """Test feed generation for a non-existent newsletter."""
+    feed_xml = generate_feed(db_session, 999)  # Non-existent newsletter ID
+    assert feed_xml is None

backend/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "letterfeed-backend"
+version = "0.1.0"
+description = "Backend for LetterFeed"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "apscheduler>=3.11.0",
+    "fastapi>=0.116.0",
+    "feedgen>=1.0.0",
+    "pydantic-settings>=2.10.1",
+    "python-dotenv>=1.1.1",
+    "sqlalchemy>=2.0.41",
+    "uvicorn>=0.35.0",
+]
+
+[tool.ruff]
+lint.select = [
+    "E",    # pycodestyle
+    "F",    # pyflakes
+    "I",    # isort
+    "D",    # pydocstyle
+    "D401", # First line should be in imperative mood
+    "T201",
+    "UP",
+]
+lint.ignore = [
+    "UP006",
+    "UP007",
+    # We actually do want to import from typing_extensions
+    "UP035",
+    # Relax the convention by _not_ requiring documentation for every function parameter.
+    "D417",
+    "D100",
+    "E501",
+]
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D", "UP"]
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_executable=".venv/bin/python"
+
+[tool.pyright]
+venvPath='.'
+venv=".venv"
+include="app"
+
+[dependency-groups]
+test = [
+    "httpx>=0.28.1",
+    "pytest>=8.4.1",
+    "ruff>=0.12.3",
+]

backend/uv.lock

@@ -0,0 +1,533 @@
+version = 1
+revision = 2
+requires-python = ">=3.12"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
+]
+
+[[package]]
+name = "apscheduler"
+version = "3.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tzlocal" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4e/00/6d6814ddc19be2df62c8c898c4df6b5b1914f3bd024b780028caa392d186/apscheduler-3.11.0.tar.gz", hash = "sha256:4c622d250b0955a65d5d0eb91c33e6d43fd879834bf541e0a18661ae60460133", size = 107347, upload-time = "2024-11-24T19:39:26.463Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/ae/9a053dd9229c0fde6b1f1f33f609ccff1ee79ddda364c756a924c6d8563b/APScheduler-3.11.0-py3-none-any.whl", hash = "sha256:fc134ca32e50f5eadcc4938e3a4545ab19131435e851abb40b34d63d5141c6da", size = 64004, upload-time = "2024-11-24T19:39:24.442Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.7.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981, upload-time = "2025-07-14T03:29:28.449Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722, upload-time = "2025-07-14T03:29:26.863Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.116.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/20/38/e1da78736143fd885c36213a3ccc493c384ae8fea6a0f0bc272ef42ebea8/fastapi-0.116.0.tar.gz", hash = "sha256:80dc0794627af0390353a6d1171618276616310d37d24faba6648398e57d687a", size = 296518, upload-time = "2025-07-07T15:09:27.82Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/68/d80347fe2360445b5f58cf290e588a4729746e7501080947e6cdae114b1f/fastapi-0.116.0-py3-none-any.whl", hash = "sha256:fdcc9ed272eaef038952923bef2b735c02372402d1203ee1210af4eea7a78d2b", size = 95625, upload-time = "2025-07-07T15:09:26.348Z" },
+]
+
+[[package]]
+name = "feedgen"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6b/59/be0a6f852b5dfbf19e6c8e962c8f41407697f9f52a7902250ed98683ae89/feedgen-1.0.0.tar.gz", hash = "sha256:d9bd51c3b5e956a2a52998c3708c4d2c729f2fcc311188e1e5d3b9726393546a", size = 258496, upload-time = "2023-12-25T18:04:08.421Z" }
+
+[[package]]
+name = "greenlet"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/92/bb85bd6e80148a4d2e0c59f7c0c2891029f8fd510183afc7d8d2feeed9b6/greenlet-3.2.3.tar.gz", hash = "sha256:8b0dd8ae4c0d6f5e54ee55ba935eeb3d735a9b58a8a1e5b5cbab64e01a39f365", size = 185752, upload-time = "2025-06-05T16:16:09.955Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/94/ad0d435f7c48debe960c53b8f60fb41c2026b1d0fa4a99a1cb17c3461e09/greenlet-3.2.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:25ad29caed5783d4bd7a85c9251c651696164622494c00802a139c00d639242d", size = 271992, upload-time = "2025-06-05T16:11:23.467Z" },
+    { url = "https://files.pythonhosted.org/packages/93/5d/7c27cf4d003d6e77749d299c7c8f5fd50b4f251647b5c2e97e1f20da0ab5/greenlet-3.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88cd97bf37fe24a6710ec6a3a7799f3f81d9cd33317dcf565ff9950c83f55e0b", size = 638820, upload-time = "2025-06-05T16:38:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/7e/807e1e9be07a125bb4c169144937910bf59b9d2f6d931578e57f0bce0ae2/greenlet-3.2.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:baeedccca94880d2f5666b4fa16fc20ef50ba1ee353ee2d7092b383a243b0b0d", size = 653046, upload-time = "2025-06-05T16:41:36.343Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ab/158c1a4ea1068bdbc78dba5a3de57e4c7aeb4e7fa034320ea94c688bfb61/greenlet-3.2.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:be52af4b6292baecfa0f397f3edb3c6092ce071b499dd6fe292c9ac9f2c8f264", size = 647701, upload-time = "2025-06-05T16:48:19.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0d/93729068259b550d6a0288da4ff72b86ed05626eaf1eb7c0d3466a2571de/greenlet-3.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0cc73378150b8b78b0c9fe2ce56e166695e67478550769536a6742dca3651688", size = 649747, upload-time = "2025-06-05T16:13:04.628Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f6/c82ac1851c60851302d8581680573245c8fc300253fc1ff741ae74a6c24d/greenlet-3.2.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:706d016a03e78df129f68c4c9b4c4f963f7d73534e48a24f5f5a7101ed13dbbb", size = 605461, upload-time = "2025-06-05T16:12:50.792Z" },
+    { url = "https://files.pythonhosted.org/packages/98/82/d022cf25ca39cf1200650fc58c52af32c90f80479c25d1cbf57980ec3065/greenlet-3.2.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:419e60f80709510c343c57b4bb5a339d8767bf9aef9b8ce43f4f143240f88b7c", size = 1121190, upload-time = "2025-06-05T16:36:48.59Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e1/25297f70717abe8104c20ecf7af0a5b82d2f5a980eb1ac79f65654799f9f/greenlet-3.2.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:93d48533fade144203816783373f27a97e4193177ebaaf0fc396db19e5d61163", size = 1149055, upload-time = "2025-06-05T16:12:40.457Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/8f/8f9e56c5e82eb2c26e8cde787962e66494312dc8cb261c460e1f3a9c88bc/greenlet-3.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:7454d37c740bb27bdeddfc3f358f26956a07d5220818ceb467a483197d84f849", size = 297817, upload-time = "2025-06-05T16:29:49.244Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/cf/f5c0b23309070ae93de75c90d29300751a5aacefc0a3ed1b1d8edb28f08b/greenlet-3.2.3-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:500b8689aa9dd1ab26872a34084503aeddefcb438e2e7317b89b11eaea1901ad", size = 270732, upload-time = "2025-06-05T16:10:08.26Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ae/91a957ba60482d3fecf9be49bc3948f341d706b52ddb9d83a70d42abd498/greenlet-3.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a07d3472c2a93117af3b0136f246b2833fdc0b542d4a9799ae5f41c28323faef", size = 639033, upload-time = "2025-06-05T16:38:53.983Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/df/20ffa66dd5a7a7beffa6451bdb7400d66251374ab40b99981478c69a67a8/greenlet-3.2.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:8704b3768d2f51150626962f4b9a9e4a17d2e37c8a8d9867bbd9fa4eb938d3b3", size = 652999, upload-time = "2025-06-05T16:41:37.89Z" },
+    { url = "https://files.pythonhosted.org/packages/51/b4/ebb2c8cb41e521f1d72bf0465f2f9a2fd803f674a88db228887e6847077e/greenlet-3.2.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5035d77a27b7c62db6cf41cf786cfe2242644a7a337a0e155c80960598baab95", size = 647368, upload-time = "2025-06-05T16:48:21.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/6a/1e1b5aa10dced4ae876a322155705257748108b7fd2e4fae3f2a091fe81a/greenlet-3.2.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2d8aa5423cd4a396792f6d4580f88bdc6efcb9205891c9d40d20f6e670992efb", size = 650037, upload-time = "2025-06-05T16:13:06.402Z" },
+    { url = "https://files.pythonhosted.org/packages/26/f2/ad51331a157c7015c675702e2d5230c243695c788f8f75feba1af32b3617/greenlet-3.2.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c724620a101f8170065d7dded3f962a2aea7a7dae133a009cada42847e04a7b", size = 608402, upload-time = "2025-06-05T16:12:51.91Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bc/862bd2083e6b3aff23300900a956f4ea9a4059de337f5c8734346b9b34fc/greenlet-3.2.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:873abe55f134c48e1f2a6f53f7d1419192a3d1a4e873bace00499a4e45ea6af0", size = 1119577, upload-time = "2025-06-05T16:36:49.787Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/1fc0cc068cfde885170e01de40a619b00eaa8f2916bf3541744730ffb4c3/greenlet-3.2.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:024571bbce5f2c1cfff08bf3fbaa43bbc7444f580ae13b0099e95d0e6e67ed36", size = 1147121, upload-time = "2025-06-05T16:12:42.527Z" },
+    { url = "https://files.pythonhosted.org/packages/27/1a/199f9587e8cb08a0658f9c30f3799244307614148ffe8b1e3aa22f324dea/greenlet-3.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:5195fb1e75e592dd04ce79881c8a22becdfa3e6f500e7feb059b1e6fdd54d3e3", size = 297603, upload-time = "2025-06-05T16:20:12.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/ca/accd7aa5280eb92b70ed9e8f7fd79dc50a2c21d8c73b9a0856f5b564e222/greenlet-3.2.3-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:3d04332dddb10b4a211b68111dabaee2e1a073663d117dc10247b5b1642bac86", size = 271479, upload-time = "2025-06-05T16:10:47.525Z" },
+    { url = "https://files.pythonhosted.org/packages/55/71/01ed9895d9eb49223280ecc98a557585edfa56b3d0e965b9fa9f7f06b6d9/greenlet-3.2.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8186162dffde068a465deab08fc72c767196895c39db26ab1c17c0b77a6d8b97", size = 683952, upload-time = "2025-06-05T16:38:55.125Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/61/638c4bdf460c3c678a0a1ef4c200f347dff80719597e53b5edb2fb27ab54/greenlet-3.2.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f4bfbaa6096b1b7a200024784217defedf46a07c2eee1a498e94a1b5f8ec5728", size = 696917, upload-time = "2025-06-05T16:41:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/22/cc/0bd1a7eb759d1f3e3cc2d1bc0f0b487ad3cc9f34d74da4b80f226fde4ec3/greenlet-3.2.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:ed6cfa9200484d234d8394c70f5492f144b20d4533f69262d530a1a082f6ee9a", size = 692443, upload-time = "2025-06-05T16:48:23.113Z" },
+    { url = "https://files.pythonhosted.org/packages/67/10/b2a4b63d3f08362662e89c103f7fe28894a51ae0bc890fabf37d1d780e52/greenlet-3.2.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:02b0df6f63cd15012bed5401b47829cfd2e97052dc89da3cfaf2c779124eb892", size = 692995, upload-time = "2025-06-05T16:13:07.972Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/c6/ad82f148a4e3ce9564056453a71529732baf5448ad53fc323e37efe34f66/greenlet-3.2.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86c2d68e87107c1792e2e8d5399acec2487a4e993ab76c792408e59394d52141", size = 655320, upload-time = "2025-06-05T16:12:53.453Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/4f/aab73ecaa6b3086a4c89863d94cf26fa84cbff63f52ce9bc4342b3087a06/greenlet-3.2.3-cp314-cp314-win_amd64.whl", hash = "sha256:8c47aae8fbbfcf82cc13327ae802ba13c9c36753b67e760023fd116bc124a62a", size = 301236, upload-time = "2025-06-05T16:15:20.111Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
+]
+
+[[package]]
+name = "letterfeed-backend"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "apscheduler" },
+    { name = "fastapi" },
+    { name = "feedgen" },
+    { name = "pydantic-settings" },
+    { name = "python-dotenv" },
+    { name = "sqlalchemy" },
+    { name = "uvicorn" },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "apscheduler", specifier = ">=3.11.0" },
+    { name = "fastapi", specifier = ">=0.116.0" },
+    { name = "feedgen", specifier = ">=1.0.0" },
+    { name = "pydantic-settings", specifier = ">=2.10.1" },
+    { name = "python-dotenv", specifier = ">=1.1.1" },
+    { name = "sqlalchemy", specifier = ">=2.0.41" },
+    { name = "uvicorn", specifier = ">=0.35.0" },
+]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pytest", specifier = ">=8.4.1" },
+    { name = "ruff", specifier = ">=0.12.3" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/ed/60eb6fa2923602fba988d9ca7c5cdbd7cf25faa795162ed538b527a35411/lxml-6.0.0.tar.gz", hash = "sha256:032e65120339d44cdc3efc326c9f660f5f7205f3a535c1fdbf898b29ea01fb72", size = 4096938, upload-time = "2025-06-26T16:28:19.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/c3/d01d735c298d7e0ddcedf6f028bf556577e5ab4f4da45175ecd909c79378/lxml-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78718d8454a6e928470d511bf8ac93f469283a45c354995f7d19e77292f26108", size = 8429515, upload-time = "2025-06-26T16:26:06.776Z" },
+    { url = "https://files.pythonhosted.org/packages/06/37/0e3eae3043d366b73da55a86274a590bae76dc45aa004b7042e6f97803b1/lxml-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:84ef591495ffd3f9dcabffd6391db7bb70d7230b5c35ef5148354a134f56f2be", size = 4601387, upload-time = "2025-06-26T16:26:09.511Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/28/e1a9a881e6d6e29dda13d633885d13acb0058f65e95da67841c8dd02b4a8/lxml-6.0.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2930aa001a3776c3e2601cb8e0a15d21b8270528d89cc308be4843ade546b9ab", size = 5228928, upload-time = "2025-06-26T16:26:12.337Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/55/2cb24ea48aa30c99f805921c1c7860c1f45c0e811e44ee4e6a155668de06/lxml-6.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:219e0431ea8006e15005767f0351e3f7f9143e793e58519dc97fe9e07fae5563", size = 4952289, upload-time = "2025-06-28T18:47:25.602Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c0/b25d9528df296b9a3306ba21ff982fc5b698c45ab78b94d18c2d6ae71fd9/lxml-6.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd5913b4972681ffc9718bc2d4c53cde39ef81415e1671ff93e9aa30b46595e7", size = 5111310, upload-time = "2025-06-28T18:47:28.136Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/af/681a8b3e4f668bea6e6514cbcb297beb6de2b641e70f09d3d78655f4f44c/lxml-6.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:390240baeb9f415a82eefc2e13285016f9c8b5ad71ec80574ae8fa9605093cd7", size = 5025457, upload-time = "2025-06-26T16:26:15.068Z" },
+    { url = "https://files.pythonhosted.org/packages/99/b6/3a7971aa05b7be7dfebc7ab57262ec527775c2c3c5b2f43675cac0458cad/lxml-6.0.0-cp312-cp312-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d6e200909a119626744dd81bae409fc44134389e03fbf1d68ed2a55a2fb10991", size = 5657016, upload-time = "2025-07-03T19:19:06.008Z" },
+    { url = "https://files.pythonhosted.org/packages/69/f8/693b1a10a891197143c0673fcce5b75fc69132afa81a36e4568c12c8faba/lxml-6.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca50bd612438258a91b5b3788c6621c1f05c8c478e7951899f492be42defc0da", size = 5257565, upload-time = "2025-06-26T16:26:17.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/96/e08ff98f2c6426c98c8964513c5dab8d6eb81dadcd0af6f0c538ada78d33/lxml-6.0.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:c24b8efd9c0f62bad0439283c2c795ef916c5a6b75f03c17799775c7ae3c0c9e", size = 4713390, upload-time = "2025-06-26T16:26:20.292Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/83/6184aba6cc94d7413959f6f8f54807dc318fdcd4985c347fe3ea6937f772/lxml-6.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afd27d8629ae94c5d863e32ab0e1d5590371d296b87dae0a751fb22bf3685741", size = 5066103, upload-time = "2025-06-26T16:26:22.765Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/01/8bf1f4035852d0ff2e36a4d9aacdbcc57e93a6cd35a54e05fa984cdf73ab/lxml-6.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:54c4855eabd9fc29707d30141be99e5cd1102e7d2258d2892314cf4c110726c3", size = 4791428, upload-time = "2025-06-26T16:26:26.461Z" },
+    { url = "https://files.pythonhosted.org/packages/29/31/c0267d03b16954a85ed6b065116b621d37f559553d9339c7dcc4943a76f1/lxml-6.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c907516d49f77f6cd8ead1322198bdfd902003c3c330c77a1c5f3cc32a0e4d16", size = 5678523, upload-time = "2025-07-03T19:19:09.837Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f7/5495829a864bc5f8b0798d2b52a807c89966523140f3d6fa3a58ab6720ea/lxml-6.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36531f81c8214e293097cd2b7873f178997dae33d3667caaae8bdfb9666b76c0", size = 5281290, upload-time = "2025-06-26T16:26:29.406Z" },
+    { url = "https://files.pythonhosted.org/packages/79/56/6b8edb79d9ed294ccc4e881f4db1023af56ba451909b9ce79f2a2cd7c532/lxml-6.0.0-cp312-cp312-win32.whl", hash = "sha256:690b20e3388a7ec98e899fd54c924e50ba6693874aa65ef9cb53de7f7de9d64a", size = 3613495, upload-time = "2025-06-26T16:26:31.588Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1e/cc32034b40ad6af80b6fd9b66301fc0f180f300002e5c3eb5a6110a93317/lxml-6.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:310b719b695b3dd442cdfbbe64936b2f2e231bb91d998e99e6f0daf991a3eba3", size = 4014711, upload-time = "2025-06-26T16:26:33.723Z" },
+    { url = "https://files.pythonhosted.org/packages/55/10/dc8e5290ae4c94bdc1a4c55865be7e1f31dfd857a88b21cbba68b5fea61b/lxml-6.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:8cb26f51c82d77483cdcd2b4a53cda55bbee29b3c2f3ddeb47182a2a9064e4eb", size = 3674431, upload-time = "2025-06-26T16:26:35.959Z" },
+    { url = "https://files.pythonhosted.org/packages/79/21/6e7c060822a3c954ff085e5e1b94b4a25757c06529eac91e550f3f5cd8b8/lxml-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6da7cd4f405fd7db56e51e96bff0865b9853ae70df0e6720624049da76bde2da", size = 8414372, upload-time = "2025-06-26T16:26:39.079Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/f6/051b1607a459db670fc3a244fa4f06f101a8adf86cda263d1a56b3a4f9d5/lxml-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b34339898bb556a2351a1830f88f751679f343eabf9cf05841c95b165152c9e7", size = 4593940, upload-time = "2025-06-26T16:26:41.891Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/74/dd595d92a40bda3c687d70d4487b2c7eff93fd63b568acd64fedd2ba00fe/lxml-6.0.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:51a5e4c61a4541bd1cd3ba74766d0c9b6c12d6a1a4964ef60026832aac8e79b3", size = 5214329, upload-time = "2025-06-26T16:26:44.669Z" },
+    { url = "https://files.pythonhosted.org/packages/52/46/3572761efc1bd45fcafb44a63b3b0feeb5b3f0066886821e94b0254f9253/lxml-6.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d18a25b19ca7307045581b18b3ec9ead2b1db5ccd8719c291f0cd0a5cec6cb81", size = 4947559, upload-time = "2025-06-28T18:47:31.091Z" },
+    { url = "https://files.pythonhosted.org/packages/94/8a/5e40de920e67c4f2eef9151097deb9b52d86c95762d8ee238134aff2125d/lxml-6.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d4f0c66df4386b75d2ab1e20a489f30dc7fd9a06a896d64980541506086be1f1", size = 5102143, upload-time = "2025-06-28T18:47:33.612Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/4b/20555bdd75d57945bdabfbc45fdb1a36a1a0ff9eae4653e951b2b79c9209/lxml-6.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f4b481b6cc3a897adb4279216695150bbe7a44c03daba3c894f49d2037e0a24", size = 5021931, upload-time = "2025-06-26T16:26:47.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/cf03b412f3763d4ca23b25e70c96a74cfece64cec3addf1c4ec639586b13/lxml-6.0.0-cp313-cp313-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a78d6c9168f5bcb20971bf3329c2b83078611fbe1f807baadc64afc70523b3a", size = 5645469, upload-time = "2025-07-03T19:19:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/dd/39c8507c16db6031f8c1ddf70ed95dbb0a6d466a40002a3522c128aba472/lxml-6.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae06fbab4f1bb7db4f7c8ca9897dc8db4447d1a2b9bee78474ad403437bcc29", size = 5247467, upload-time = "2025-06-26T16:26:49.998Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/56/732d49def0631ad633844cfb2664563c830173a98d5efd9b172e89a4800d/lxml-6.0.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:1fa377b827ca2023244a06554c6e7dc6828a10aaf74ca41965c5d8a4925aebb4", size = 4720601, upload-time = "2025-06-26T16:26:52.564Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/7f/6b956fab95fa73462bca25d1ea7fc8274ddf68fb8e60b78d56c03b65278e/lxml-6.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1676b56d48048a62ef77a250428d1f31f610763636e0784ba67a9740823988ca", size = 5060227, upload-time = "2025-06-26T16:26:55.054Z" },
+    { url = "https://files.pythonhosted.org/packages/97/06/e851ac2924447e8b15a294855caf3d543424364a143c001014d22c8ca94c/lxml-6.0.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:0e32698462aacc5c1cf6bdfebc9c781821b7e74c79f13e5ffc8bfe27c42b1abf", size = 4790637, upload-time = "2025-06-26T16:26:57.384Z" },
+    { url = "https://files.pythonhosted.org/packages/06/d4/fd216f3cd6625022c25b336c7570d11f4a43adbaf0a56106d3d496f727a7/lxml-6.0.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4d6036c3a296707357efb375cfc24bb64cd955b9ec731abf11ebb1e40063949f", size = 5662049, upload-time = "2025-07-03T19:19:16.409Z" },
+    { url = "https://files.pythonhosted.org/packages/52/03/0e764ce00b95e008d76b99d432f1807f3574fb2945b496a17807a1645dbd/lxml-6.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7488a43033c958637b1a08cddc9188eb06d3ad36582cebc7d4815980b47e27ef", size = 5272430, upload-time = "2025-06-26T16:27:00.031Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/01/d48cc141bc47bc1644d20fe97bbd5e8afb30415ec94f146f2f76d0d9d098/lxml-6.0.0-cp313-cp313-win32.whl", hash = "sha256:5fcd7d3b1d8ecb91445bd71b9c88bdbeae528fefee4f379895becfc72298d181", size = 3612896, upload-time = "2025-06-26T16:27:04.251Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/87/6456b9541d186ee7d4cb53bf1b9a0d7f3b1068532676940fdd594ac90865/lxml-6.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:2f34687222b78fff795feeb799a7d44eca2477c3d9d3a46ce17d51a4f383e32e", size = 4013132, upload-time = "2025-06-26T16:27:06.415Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/42/85b3aa8f06ca0d24962f8100f001828e1f1f1a38c954c16e71154ed7d53a/lxml-6.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:21db1ec5525780fd07251636eb5f7acb84003e9382c72c18c542a87c416ade03", size = 3672642, upload-time = "2025-06-26T16:27:09.888Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.11.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload-time = "2025-06-14T08:33:17.137Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload-time = "2025-06-14T08:33:14.905Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.33.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },
+    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" },
+    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" },
+    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714, upload-time = "2025-06-18T05:48:06.109Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474, upload-time = "2025-06-18T05:48:03.955Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.12.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/2a/43955b530c49684d3c38fcda18c43caf91e99204c2a065552528e0552d4f/ruff-0.12.3.tar.gz", hash = "sha256:f1b5a4b6668fd7b7ea3697d8d98857390b40c1320a63a178eee6be0899ea2d77", size = 4459341, upload-time = "2025-07-11T13:21:16.086Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/fd/b44c5115539de0d598d75232a1cc7201430b6891808df111b8b0506aae43/ruff-0.12.3-py3-none-linux_armv6l.whl", hash = "sha256:47552138f7206454eaf0c4fe827e546e9ddac62c2a3d2585ca54d29a890137a2", size = 10430499, upload-time = "2025-07-11T13:20:26.321Z" },
+    { url = "https://files.pythonhosted.org/packages/43/c5/9eba4f337970d7f639a37077be067e4ec80a2ad359e4cc6c5b56805cbc66/ruff-0.12.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0a9153b000c6fe169bb307f5bd1b691221c4286c133407b8827c406a55282041", size = 11213413, upload-time = "2025-07-11T13:20:30.017Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/2c/fac3016236cf1fe0bdc8e5de4f24c76ce53c6dd9b5f350d902549b7719b2/ruff-0.12.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fa6b24600cf3b750e48ddb6057e901dd5b9aa426e316addb2a1af185a7509882", size = 10586941, upload-time = "2025-07-11T13:20:33.046Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/0f/41fec224e9dfa49a139f0b402ad6f5d53696ba1800e0f77b279d55210ca9/ruff-0.12.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2506961bf6ead54887ba3562604d69cb430f59b42133d36976421bc8bd45901", size = 10783001, upload-time = "2025-07-11T13:20:35.534Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/ca/dd64a9ce56d9ed6cad109606ac014860b1c217c883e93bf61536400ba107/ruff-0.12.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c4faaff1f90cea9d3033cbbcdf1acf5d7fb11d8180758feb31337391691f3df0", size = 10269641, upload-time = "2025-07-11T13:20:38.459Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5c/2be545034c6bd5ce5bb740ced3e7014d7916f4c445974be11d2a406d5088/ruff-0.12.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40dced4a79d7c264389de1c59467d5d5cefd79e7e06d1dfa2c75497b5269a5a6", size = 11875059, upload-time = "2025-07-11T13:20:41.517Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/d4/a74ef1e801ceb5855e9527dae105eaff136afcb9cc4d2056d44feb0e4792/ruff-0.12.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:0262d50ba2767ed0fe212aa7e62112a1dcbfd46b858c5bf7bbd11f326998bafc", size = 12658890, upload-time = "2025-07-11T13:20:44.442Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c8/1057916416de02e6d7c9bcd550868a49b72df94e3cca0aeb77457dcd9644/ruff-0.12.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12371aec33e1a3758597c5c631bae9a5286f3c963bdfb4d17acdd2d395406687", size = 12232008, upload-time = "2025-07-11T13:20:47.374Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/59/4f7c130cc25220392051fadfe15f63ed70001487eca21d1796db46cbcc04/ruff-0.12.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:560f13b6baa49785665276c963edc363f8ad4b4fc910a883e2625bdb14a83a9e", size = 11499096, upload-time = "2025-07-11T13:20:50.348Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/01/a0ad24a5d2ed6be03a312e30d32d4e3904bfdbc1cdbe63c47be9d0e82c79/ruff-0.12.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:023040a3499f6f974ae9091bcdd0385dd9e9eb4942f231c23c57708147b06311", size = 11688307, upload-time = "2025-07-11T13:20:52.945Z" },
+    { url = "https://files.pythonhosted.org/packages/93/72/08f9e826085b1f57c9a0226e48acb27643ff19b61516a34c6cab9d6ff3fa/ruff-0.12.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:883d844967bffff5ab28bba1a4d246c1a1b2933f48cb9840f3fdc5111c603b07", size = 10661020, upload-time = "2025-07-11T13:20:55.799Z" },
+    { url = "https://files.pythonhosted.org/packages/80/a0/68da1250d12893466c78e54b4a0ff381370a33d848804bb51279367fc688/ruff-0.12.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2120d3aa855ff385e0e562fdee14d564c9675edbe41625c87eeab744a7830d12", size = 10246300, upload-time = "2025-07-11T13:20:58.222Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/22/5f0093d556403e04b6fd0984fc0fb32fbb6f6ce116828fd54306a946f444/ruff-0.12.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6b16647cbb470eaf4750d27dddc6ebf7758b918887b56d39e9c22cce2049082b", size = 11263119, upload-time = "2025-07-11T13:21:01.503Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c9/f4c0b69bdaffb9968ba40dd5fa7df354ae0c73d01f988601d8fac0c639b1/ruff-0.12.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e1417051edb436230023575b149e8ff843a324557fe0a265863b7602df86722f", size = 11746990, upload-time = "2025-07-11T13:21:04.524Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/84/7cc7bd73924ee6be4724be0db5414a4a2ed82d06b30827342315a1be9e9c/ruff-0.12.3-py3-none-win32.whl", hash = "sha256:dfd45e6e926deb6409d0616078a666ebce93e55e07f0fb0228d4b2608b2c248d", size = 10589263, upload-time = "2025-07-11T13:21:07.148Z" },
+    { url = "https://files.pythonhosted.org/packages/07/87/c070f5f027bd81f3efee7d14cb4d84067ecf67a3a8efb43aadfc72aa79a6/ruff-0.12.3-py3-none-win_amd64.whl", hash = "sha256:a946cf1e7ba3209bdef039eb97647f1c77f6f540e5845ec9c114d3af8df873e7", size = 11695072, upload-time = "2025-07-11T13:21:11.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/30/f3eaf6563c637b6e66238ed6535f6775480db973c836336e4122161986fc/ruff-0.12.3-py3-none-win_arm64.whl", hash = "sha256:5f9c7c9c8f84c2d7f27e93674d27136fbf489720251544c4da7fb3d742e011b1", size = 10805855, upload-time = "2025-07-11T13:21:13.547Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sqlalchemy"
+version = "2.0.41"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "(python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/66/45b165c595ec89aa7dcc2c1cd222ab269bc753f1fc7a1e68f8481bd957bf/sqlalchemy-2.0.41.tar.gz", hash = "sha256:edba70118c4be3c2b1f90754d308d0b79c6fe2c0fdc52d8ddf603916f83f4db9", size = 9689424, upload-time = "2025-05-14T17:10:32.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/2a/f1f4e068b371154740dd10fb81afb5240d5af4aa0087b88d8b308b5429c2/sqlalchemy-2.0.41-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:81f413674d85cfd0dfcd6512e10e0f33c19c21860342a4890c3a2b59479929f9", size = 2119645, upload-time = "2025-05-14T17:55:24.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/e8/c664a7e73d36fbfc4730f8cf2bf930444ea87270f2825efbe17bf808b998/sqlalchemy-2.0.41-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:598d9ebc1e796431bbd068e41e4de4dc34312b7aa3292571bb3674a0cb415dd1", size = 2107399, upload-time = "2025-05-14T17:55:28.097Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/78/8a9cf6c5e7135540cb682128d091d6afa1b9e48bd049b0d691bf54114f70/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a104c5694dfd2d864a6f91b0956eb5d5883234119cb40010115fd45a16da5e70", size = 3293269, upload-time = "2025-05-14T17:50:38.227Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/35/f74add3978c20de6323fb11cb5162702670cc7a9420033befb43d8d5b7a4/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6145afea51ff0af7f2564a05fa95eb46f542919e6523729663a5d285ecb3cf5e", size = 3303364, upload-time = "2025-05-14T17:51:49.829Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/d4/c990f37f52c3f7748ebe98883e2a0f7d038108c2c5a82468d1ff3eec50b7/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b46fa6eae1cd1c20e6e6f44e19984d438b6b2d8616d21d783d150df714f44078", size = 3229072, upload-time = "2025-05-14T17:50:39.774Z" },
+    { url = "https://files.pythonhosted.org/packages/15/69/cab11fecc7eb64bc561011be2bd03d065b762d87add52a4ca0aca2e12904/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41836fe661cc98abfae476e14ba1906220f92c4e528771a8a3ae6a151242d2ae", size = 3268074, upload-time = "2025-05-14T17:51:51.736Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/0c19ec16858585d37767b167fc9602593f98998a68a798450558239fb04a/sqlalchemy-2.0.41-cp312-cp312-win32.whl", hash = "sha256:a8808d5cf866c781150d36a3c8eb3adccfa41a8105d031bf27e92c251e3969d6", size = 2084514, upload-time = "2025-05-14T17:55:49.915Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/23/4c2833d78ff3010a4e17f984c734f52b531a8c9060a50429c9d4b0211be6/sqlalchemy-2.0.41-cp312-cp312-win_amd64.whl", hash = "sha256:5b14e97886199c1f52c14629c11d90c11fbb09e9334fa7bb5f6d068d9ced0ce0", size = 2111557, upload-time = "2025-05-14T17:55:51.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ad/2e1c6d4f235a97eeef52d0200d8ddda16f6c4dd70ae5ad88c46963440480/sqlalchemy-2.0.41-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4eeb195cdedaf17aab6b247894ff2734dcead6c08f748e617bfe05bd5a218443", size = 2115491, upload-time = "2025-05-14T17:55:31.177Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8d/be490e5db8400dacc89056f78a52d44b04fbf75e8439569d5b879623a53b/sqlalchemy-2.0.41-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d4ae769b9c1c7757e4ccce94b0641bc203bbdf43ba7a2413ab2523d8d047d8dc", size = 2102827, upload-time = "2025-05-14T17:55:34.921Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/72/c97ad430f0b0e78efaf2791342e13ffeafcbb3c06242f01a3bb8fe44f65d/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a62448526dd9ed3e3beedc93df9bb6b55a436ed1474db31a2af13b313a70a7e1", size = 3225224, upload-time = "2025-05-14T17:50:41.418Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/51/5ba9ea3246ea068630acf35a6ba0d181e99f1af1afd17e159eac7e8bc2b8/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc56c9788617b8964ad02e8fcfeed4001c1f8ba91a9e1f31483c0dffb207002a", size = 3230045, upload-time = "2025-05-14T17:51:54.722Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2f/8c14443b2acea700c62f9b4a8bad9e49fc1b65cfb260edead71fd38e9f19/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c153265408d18de4cc5ded1941dcd8315894572cddd3c58df5d5b5705b3fa28d", size = 3159357, upload-time = "2025-05-14T17:50:43.483Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b2/43eacbf6ccc5276d76cea18cb7c3d73e294d6fb21f9ff8b4eef9b42bbfd5/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f67766965996e63bb46cfbf2ce5355fc32d9dd3b8ad7e536a920ff9ee422e23", size = 3197511, upload-time = "2025-05-14T17:51:57.308Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/2e/677c17c5d6a004c3c45334ab1dbe7b7deb834430b282b8a0f75ae220c8eb/sqlalchemy-2.0.41-cp313-cp313-win32.whl", hash = "sha256:bfc9064f6658a3d1cadeaa0ba07570b83ce6801a1314985bf98ec9b95d74e15f", size = 2082420, upload-time = "2025-05-14T17:55:52.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/61/e8c1b9b6307c57157d328dd8b8348ddc4c47ffdf1279365a13b2b98b8049/sqlalchemy-2.0.41-cp313-cp313-win_amd64.whl", hash = "sha256:82ca366a844eb551daff9d2e6e7a9e5e76d2612c8564f58db6c19a726869c1df", size = 2108329, upload-time = "2025-05-14T17:55:54.495Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/fc/9ba22f01b5cdacc8f5ed0d22304718d2c758fce3fd49a5372b886a86f37c/sqlalchemy-2.0.41-py3-none-any.whl", hash = "sha256:57df5dc6fdb5ed1a88a1ed2195fd31927e705cad62dedd86b46972752a80f576", size = 1911224, upload-time = "2025-05-14T17:39:42.154Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.46.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/20/08dfcd9c983f6a6f4a1000d934b9e6d626cff8d2eeb77a89a68eef20a2b7/starlette-0.46.2.tar.gz", hash = "sha256:7f7361f34eed179294600af672f565727419830b54b7b084efe44bb82d2fccd5", size = 2580846, upload-time = "2025-04-13T13:56:17.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/0c/9d30a4ebeb6db2b25a841afbb80f6ef9a854fc3b41be131d249a977b4959/starlette-0.46.2-py3-none-any.whl", hash = "sha256:595633ce89f8ffa71a015caed34a5b2dc1c0cdb3f0f1fbd1e69339cf2abeec35", size = 72037, upload-time = "2025-04-13T13:56:16.21Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.14.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload-time = "2025-07-04T13:28:34.16Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload-time = "2025-07-04T13:28:32.743Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
+]
+
+[[package]]
+name = "tzlocal"
+version = "5.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tzdata", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload-time = "2025-03-05T21:17:41.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.35.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473, upload-time = "2025-06-28T16:15:46.058Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406, upload-time = "2025-06-28T16:15:44.816Z" },
+]

docker-compose.dev.yml

@@ -0,0 +1,31 @@
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    env_file:
+      - .env
+    volumes:
+      - letterfeed_data:/data
+    networks:
+      - letterfeed_network
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    depends_on:
+      - backend
+    networks:
+      - letterfeed_network
+
+volumes:
+  letterfeed_data:
+
+networks:
+  letterfeed_network:
+    driver: bridge 

docker-compose.yml

@@ -0,0 +1,27 @@
+services:
+  backend:
+    image: ghcr.io/LeonMusCoden/letterfeed-backend:latest
+    restart: unless-stopped
+    env_file:
+      - .env
+    volumes:
+      - letterfeed_data:/data
+    networks:
+      - letterfeed_network
+
+  frontend:
+    image: ghcr.io/LeonMusCoden/letterfeed-frontend:latest
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    depends_on:
+      - backend
+    networks:
+      - letterfeed_network
+
+volumes:
+  letterfeed_data:
+
+networks:
+  letterfeed_network:
+    driver: bridge

frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

frontend/Dockerfile

@@ -0,0 +1,37 @@
+# Dockerfile for Next.js frontend
+
+# 1. Build Stage
+FROM node:24-alpine AS builder
+WORKDIR /app
+
+# Copy package.json and package-lock.json
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install
+
+# Copy the rest of the application
+COPY . .
+
+# Set the API URL for the build
+ARG NEXT_PUBLIC_API_URL=/api
+ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
+
+# Build the Next.js application
+RUN npm run build
+
+# 2. Production Stage
+FROM node:24-alpine
+WORKDIR /app
+
+# Copy the built application from the builder stage
+COPY --from=builder /app/.next ./.next
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/package.json ./package.json
+COPY --from=builder /app/node_modules ./node_modules
+
+# Expose the port the app runs on
+EXPOSE 3000
+
+# Start the application
+CMD ["npm", "start"]

frontend/components/letterfeed/AddNewsletterDialog.tsx

@@ -0,0 +1,115 @@
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { Plus } from "lucide-react"
+import { createNewsletter } from "@/lib/api"
+
+interface AddNewsletterDialogProps {
+  isOpen: boolean
+  onOpenChange: (isOpen: boolean) => void
+  onSuccess: () => void
+}
+
+export function AddNewsletterDialog({ isOpen, onOpenChange, onSuccess }: AddNewsletterDialogProps) {
+  const [newNewsletter, setNewNewsletter] = useState({
+    name: "",
+    emails: [""],
+  })
+
+  const handleAddEmail = () => {
+    setNewNewsletter((prev) => ({
+      ...prev,
+      emails: [...prev.emails, ""],
+    }))
+  }
+
+  const handleRemoveEmail = (index: number) => {
+    setNewNewsletter((prev) => ({
+      ...prev,
+      emails: prev.emails.filter((_, i) => i !== index),
+    }))
+  }
+
+  const handleEmailChange = (index: number, value: string) => {
+    setNewNewsletter((prev) => ({
+      ...prev,
+      emails: prev.emails.map((email, i) => (i === index ? value : email)),
+    }))
+  }
+
+  const handleSubmit = async () => {
+    if (newNewsletter.name && newNewsletter.emails.some((email) => email.trim())) {
+      try {
+        await createNewsletter({
+          name: newNewsletter.name,
+          sender_emails: newNewsletter.emails.filter((email) => email.trim()),
+        })
+        setNewNewsletter({ name: "", emails: [""] })
+        onOpenChange(false)
+        onSuccess()
+      } catch (error) {
+        console.error("Failed to create newsletter:", error)
+      }
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-[425px]">
+        <DialogHeader>
+          <DialogTitle>Register New Newsletter</DialogTitle>
+          <DialogDescription>Add a new newsletter.</DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-4 py-4">
+          <div className="space-y-2">
+            <Label htmlFor="name">Newsletter Name</Label>
+            <Input
+              id="name"
+              value={newNewsletter.name}
+              onChange={(e) => setNewNewsletter((prev) => ({ ...prev, name: e.target.value }))}
+              placeholder="Enter newsletter name"
+            />
+          </div>
+
+          <div className="space-y-2">
+            <Label>Email Addresses</Label>
+            {newNewsletter.emails.map((email, index) => (
+              <div key={index} className="flex gap-2">
+                <Input
+                  value={email}
+                  onChange={(e) => handleEmailChange(index, e.target.value)}
+                  placeholder="Enter email address"
+                  type="email"
+                />
+                {newNewsletter.emails.length > 1 && (
+                  <Button variant="outline" size="sm" onClick={() => handleRemoveEmail(index)}>
+                    Remove
+                  </Button>
+                )}
+              </div>
+            ))}
+            <Button variant="outline" size="sm" onClick={handleAddEmail} className="w-full bg-transparent">
+              <Plus className="w-4 h-4 mr-2" />
+              Add Another Email
+            </Button>
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit}>Register Newsletter</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

frontend/components/letterfeed/EditNewsletterDialog.tsx

@@ -0,0 +1,139 @@
+import { useState, useEffect } from "react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { Plus } from "lucide-react"
+import { Newsletter, updateNewsletter, deleteNewsletter } from "@/lib/api"
+
+interface EditNewsletterDialogProps {
+  newsletter: Newsletter | null
+  isOpen: boolean
+  onOpenChange: (isOpen: boolean) => void
+  onSuccess: () => void
+}
+
+export function EditNewsletterDialog({ newsletter, isOpen, onOpenChange, onSuccess }: EditNewsletterDialogProps) {
+  const [editedDetails, setEditedDetails] = useState<{ name: string; emails: string[] }>({
+    name: "",
+    emails: [],
+  })
+
+  useEffect(() => {
+    if (newsletter) {
+      setEditedDetails({
+        name: newsletter.name,
+        emails: newsletter.senders.map((s) => s.email),
+      })
+    }
+  }, [newsletter])
+
+  if (!newsletter) return null
+
+  const handleUpdateEmailChange = (index: number, value: string) => {
+    setEditedDetails((prev) => ({
+      ...prev,
+      emails: prev.emails.map((email, i) => (i === index ? value : email)),
+    }))
+  }
+
+  const handleAddEmailToEdit = () => {
+    setEditedDetails((prev) => ({
+      ...prev,
+      emails: [...prev.emails, ""],
+    }))
+  }
+
+  const handleRemoveEmailFromEdit = (index: number) => {
+    setEditedDetails((prev) => ({
+      ...prev,
+      emails: prev.emails.filter((_, i) => i !== index),
+    }))
+  }
+
+  const handleUpdate = async () => {
+    try {
+      await updateNewsletter(newsletter.id, {
+        name: editedDetails.name,
+        sender_emails: editedDetails.emails.filter((email) => email.trim()),
+      })
+      onOpenChange(false)
+      onSuccess()
+    } catch (error) {
+      console.error("Failed to update newsletter:", error)
+    }
+  }
+
+  const handleDelete = async () => {
+    if (window.confirm(`Are you sure you want to delete the "${newsletter.name}" newsletter?`)) {
+      try {
+        await deleteNewsletter(newsletter.id)
+        onOpenChange(false)
+        onSuccess()
+      } catch (error) {
+        console.error("Failed to delete newsletter:", error)
+      }
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Edit Newsletter</DialogTitle>
+          <DialogDescription>Update the details for {newsletter.name}.</DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-4 py-4">
+          <div className="space-y-2">
+            <Label htmlFor="edit-name">Newsletter Name</Label>
+            <Input
+              id="edit-name"
+              value={editedDetails.name}
+              onChange={(e) => setEditedDetails((prev) => ({ ...prev, name: e.target.value }))}
+            />
+          </div>
+          <div className="space-y-2">
+            <Label>Email Addresses</Label>
+            {editedDetails.emails.map((email, index) => (
+              <div key={index} className="flex gap-2">
+                <Input
+                  value={email}
+                  onChange={(e) => handleUpdateEmailChange(index, e.target.value)}
+                  placeholder="Enter email address"
+                  type="email"
+                />
+                {editedDetails.emails.length > 1 && (
+                  <Button variant="outline" size="sm" onClick={() => handleRemoveEmailFromEdit(index)}>
+                    Remove
+                  </Button>
+                )}
+              </div>
+            ))}
+            <Button variant="outline" size="sm" onClick={handleAddEmailToEdit} className="w-full bg-transparent">
+              <Plus className="w-4 h-4 mr-2" />
+              Add Another Email
+            </Button>
+          </div>
+        </div>
+        <DialogFooter className="sm:justify-between">
+          <Button variant="destructive" onClick={handleDelete}>
+            Delete Newsletter
+          </Button>
+          <div className="flex gap-2">
+            <Button variant="outline" onClick={() => onOpenChange(false)}>
+              Cancel
+            </Button>
+            <Button onClick={handleUpdate}>Save Changes</Button>
+          </div>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

frontend/components/letterfeed/EmptyState.tsx

@@ -0,0 +1,20 @@
+import { Button } from "@/components/ui/button"
+import { Plus, Rss } from "lucide-react"
+
+interface EmptyStateProps {
+  onAddNewsletter: () => void
+}
+
+export function EmptyState({ onAddNewsletter }: EmptyStateProps) {
+  return (
+    <div className="text-center py-12">
+      <Rss className="w-12 h-12 text-gray-400 mx-auto mb-4" />
+      <h3 className="text-lg font-medium text-gray-900 mb-2">No newsletters registered</h3>
+      <p className="text-gray-600 mb-4">Get started by adding your first newsletter</p>
+      <Button onClick={onAddNewsletter}>
+        <Plus className="w-4 h-4 mr-2" />
+        Add Your First Newsletter
+      </Button>
+    </div>
+  )
+}

frontend/components/letterfeed/Header.tsx

@@ -0,0 +1,34 @@
+import { Button } from "@/components/ui/button"
+import { Plus, Settings } from "lucide-react"
+import Image from "next/image"
+
+interface HeaderProps {
+  onOpenAddNewsletter: () => void
+  onOpenSettings: () => void
+}
+
+export function Header({ onOpenAddNewsletter, onOpenSettings }: HeaderProps) {
+  return (
+    <div className="flex items-center justify-between mb-8">
+      <div className="flex items-center gap-4">
+        <Image src="/logo.png" alt="LetterFeed Logo" width={48} height={48} className="rounded-lg" />
+        <div>
+          <h1 className="text-3xl font-bold text-gray-900">LetterFeed</h1>
+          <p className="text-gray-600 mt-1">Read your newsletters as RSS feeds!</p>
+        </div>
+      </div>
+
+      <div className="flex gap-2">
+        <Button onClick={onOpenAddNewsletter}>
+          <Plus className="w-4 h-4 mr-2" />
+          Add Newsletter
+        </Button>
+
+        <Button variant="outline" onClick={onOpenSettings}>
+          <Settings className="w-4 h-4 mr-2" />
+          Settings
+        </Button>
+      </div>
+    </div>
+  )
+}

frontend/components/letterfeed/LoadingSpinner.tsx

@@ -0,0 +1,9 @@
+import { Loader2 } from "lucide-react"
+
+export function LoadingSpinner() {
+  return (
+    <div className="min-h-screen bg-gray-50 flex items-center justify-center">
+      <Loader2 className="w-12 h-12 text-gray-400 animate-spin" data-testid="loading-spinner" />
+    </div>
+  )
+}

frontend/components/letterfeed/NewsletterCard.tsx

@@ -0,0 +1,61 @@
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
+import { Button } from "@/components/ui/button"
+import { Badge } from "@/components/ui/badge"
+import { Rss, Mail, ExternalLink, Edit } from "lucide-react"
+import { Newsletter, getFeedUrl } from "@/lib/api"
+
+interface NewsletterCardProps {
+  newsletter: Newsletter
+  onEdit: (newsletter: Newsletter) => void
+}
+
+export function NewsletterCard({ newsletter, onEdit }: NewsletterCardProps) {
+  return (
+    <Card className="hover:shadow-md transition-shadow flex flex-col">
+      <CardHeader>
+        <div className="flex justify-between items-start">
+          <div>
+            <CardTitle className="flex items-center gap-2">
+              <Rss className="w-5 h-5 text-orange-500" />
+              {newsletter.name}
+            </CardTitle>
+            <CardDescription>
+                      {newsletter.entries_count} entr{newsletter.entries_count !== 1 ? "ies" : "y"}
+                    </CardDescription>
+          </div>
+          <Button variant="ghost" size="icon" onClick={() => onEdit(newsletter)} aria-label="Edit Newsletter">
+            <Edit className="w-4 h-4" />
+          </Button>
+        </div>
+      </CardHeader>
+      <CardContent className="space-y-4 flex-grow">
+        <div>
+          <h4 className="text-sm font-medium text-gray-700 mb-2 flex items-center gap-1">
+            <Mail className="w-4 h-4" />
+            Email Addresses
+          </h4>
+          <div className="flex flex-wrap gap-1">
+            {newsletter.senders.map((sender) => (
+              <Badge key={sender.id} variant="secondary" className="text-xs">
+                {sender.email}
+              </Badge>
+            ))}
+          </div>
+        </div>
+
+        <div>
+          <h4 className="text-sm font-medium text-gray-700 mb-2">RSS Feed</h4>
+          <a
+            href={getFeedUrl(newsletter.id)}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="inline-flex items-center gap-1 text-sm text-blue-600 hover:text-blue-800 hover:underline"
+          >
+            <ExternalLink className="w-3 h-3" />
+            {getFeedUrl(newsletter.id)}
+          </a>
+        </div>
+      </CardContent>
+    </Card>
+  )
+}

frontend/components/letterfeed/NewsletterList.tsx

@@ -0,0 +1,17 @@
+import { Newsletter } from "@/lib/api"
+import { NewsletterCard } from "./NewsletterCard"
+
+interface NewsletterListProps {
+  newsletters: Newsletter[]
+  onEditNewsletter: (newsletter: Newsletter) => void
+}
+
+export function NewsletterList({ newsletters, onEditNewsletter }: NewsletterListProps) {
+  return (
+    <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+      {newsletters.map((newsletter) => (
+        <NewsletterCard key={newsletter.id} newsletter={newsletter} onEdit={onEditNewsletter} />
+      ))}
+    </div>
+  )
+}

frontend/components/letterfeed/SettingsDialog.tsx

@@ -0,0 +1,227 @@
+import { useState, useEffect } from "react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { Checkbox } from "@/components/ui/checkbox"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Loader2, CheckCircle, XCircle } from "lucide-react"
+import { Settings as AppSettings, SettingsCreate, updateSettings, testImapConnection } from "@/lib/api"
+
+interface SettingsDialogProps {
+  settings: AppSettings
+  folderOptions: string[]
+  isOpen: boolean
+  onOpenChange: (isOpen: boolean) => void
+  onSuccess: () => void
+}
+
+export function SettingsDialog({ settings, folderOptions, isOpen, onOpenChange, onSuccess }: SettingsDialogProps) {
+  const [currentSettings, setCurrentSettings] = useState<SettingsCreate | null>(null)
+  const [testConnectionStatus, setTestConnectionStatus] = useState<"idle" | "loading" | "success" | "error">("idle")
+  const [testConnectionMessage, setTestConnectionMessage] = useState("")
+
+  useEffect(() => {
+    if (settings) {
+      setCurrentSettings({ ...settings, imap_password: "" })
+    }
+  }, [settings])
+
+  if (!currentSettings) return null
+
+  const handleSettingsChange = <K extends keyof SettingsCreate>(key: K, value: SettingsCreate[K]) => {
+    setCurrentSettings((prev) => (prev ? { ...prev, [key]: value } : null))
+  }
+
+  const handleSave = async () => {
+    if (!currentSettings) return
+    try {
+      await updateSettings(currentSettings)
+      onOpenChange(false)
+      onSuccess()
+    } catch (error) {
+      console.error("Failed to save settings:", error)
+    }
+  }
+
+  const handleTestConnection = async () => {
+    if (!currentSettings) return
+    setTestConnectionStatus("loading")
+    try {
+      await updateSettings(currentSettings)
+      const result = await testImapConnection()
+      setTestConnectionStatus("success")
+      setTestConnectionMessage(result.message)
+    } catch (error: unknown) {
+      setTestConnectionStatus("error")
+      if (error instanceof Error) {
+        setTestConnectionMessage(error.message || "Connection failed")
+      } else {
+        setTestConnectionMessage("An unknown error occurred")
+      }
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-2xl max-h-[90vh] overflow-y-auto">
+        <DialogHeader>
+          <DialogTitle>Settings</DialogTitle>
+          <DialogDescription>Fields are locked if they are set by environment variables.</DialogDescription>
+        </DialogHeader>
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-x-8 gap-y-6 py-4">
+          {/* IMAP Configuration */}
+          <div className="space-y-4">
+            <h3 className="text-lg font-medium col-span-1 md:col-span-2">IMAP Configuration</h3>
+            <div className="space-y-2">
+              <Label htmlFor="imap-server">IMAP Server</Label>
+              <Input
+                id="imap-server"
+                value={currentSettings.imap_server}
+                onChange={(e) => handleSettingsChange("imap_server", e.target.value)}
+                placeholder="imap.gmail.com"
+                disabled={settings.locked_fields.includes("imap_server")}
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="imap-username">IMAP Username</Label>
+              <Input
+                id="imap-username"
+                value={currentSettings.imap_username}
+                onChange={(e) => handleSettingsChange("imap_username", e.target.value)}
+                placeholder="your-email@gmail.com"
+                disabled={settings.locked_fields.includes("imap_username")}
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="imap-password">IMAP Password</Label>
+              <Input
+                id="imap-password"
+                type="password"
+                value={currentSettings.imap_password}
+                onChange={(e) => handleSettingsChange("imap_password", e.target.value)}
+                placeholder="Your password or app password"
+                disabled={settings.locked_fields.includes("imap_password")}
+              />
+            </div>
+            <div className="pt-2">
+              <Button
+                onClick={handleTestConnection}
+                disabled={testConnectionStatus === "loading"}
+                variant="outline"
+                size="sm"
+              >
+                {testConnectionStatus === "loading" && <Loader2 className="w-4 h-4 mr-2 animate-spin" />}
+                Test Connection
+              </Button>
+              {testConnectionStatus !== "idle" && (
+                <div
+                  data-testid="connection-status"
+                  className={`mt-2 flex items-center text-sm ${
+                    testConnectionStatus === "success" ? "text-green-600" : "text-red-600"
+                  }`}
+                >
+                  {testConnectionStatus === "success" && <CheckCircle className="w-4 h-4 mr-2" />}
+                  {testConnectionStatus === "error" && <XCircle className="w-4 h-4 mr-2" />}
+                  {testConnectionMessage}
+                </div>
+              )}
+            </div>
+          </div>
+
+          {/* Email Processing */}
+          <div className="space-y-4">
+            <h3 className="text-lg font-medium col-span-1 md:col-span-2">Email Processing</h3>
+            <div className="space-y-2">
+              <Label htmlFor="search-folder">Folder to Search</Label>
+              <Select
+                value={currentSettings.search_folder}
+                onValueChange={(value) => handleSettingsChange("search_folder", value)}
+                disabled={settings.locked_fields.includes("search_folder")}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Select folder" />
+                </SelectTrigger>
+                <SelectContent>
+                  {folderOptions.map((folder) => (
+                    <SelectItem key={folder} value={folder}>
+                      {folder}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="move-folder">Move to Folder</Label>
+              <Select
+                value={currentSettings.move_to_folder || "None"}
+                onValueChange={(value) => handleSettingsChange("move_to_folder", value === "None" ? null : value)}
+                disabled={settings.locked_fields.includes("move_to_folder")}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Select folder or leave empty" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="None">None (Don&apos;t move)</SelectItem>
+                  {folderOptions.map((folder) => (
+                    <SelectItem key={folder} value={folder}>
+                      {folder}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="check-interval">Check Interval (minutes)</Label>
+              <Input
+                id="check-interval"
+                type="number"
+                min="1"
+                max="1440"
+                value={currentSettings.email_check_interval}
+                onChange={(e) => handleSettingsChange("email_check_interval", Number.parseInt(e.target.value) || 15)}
+                placeholder="15"
+                disabled={settings.locked_fields.includes("email_check_interval")}
+              />
+            </div>
+            <div className="flex items-center space-x-2 pt-2">
+              <Checkbox
+                id="mark-read"
+                checked={currentSettings.mark_as_read}
+                onCheckedChange={(checked) => handleSettingsChange("mark_as_read", !!checked)}
+                disabled={settings.locked_fields.includes("mark_as_read")}
+              />
+              <Label htmlFor="mark-read" className="text-sm font-normal">
+                Mark emails as read
+              </Label>
+            </div>
+            <div className="flex items-center space-x-2">
+              <Checkbox
+                id="auto-add"
+                checked={currentSettings.auto_add_new_senders}
+                onCheckedChange={(checked) => handleSettingsChange("auto_add_new_senders", !!checked)}
+                disabled={settings.locked_fields.includes("auto_add_new_senders")}
+              />
+              <Label htmlFor="auto-add" className="text-sm font-normal">
+                Auto-add new senders
+              </Label>
+            </div>
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button onClick={handleSave}>Save Settings</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

frontend/components/letterfeed/__tests__/AddNewsletterDialog.test.tsx

@@ -0,0 +1,74 @@
+import React from "react"
+import { render, screen, fireEvent, waitFor } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { AddNewsletterDialog } from "../AddNewsletterDialog"
+import * as api from "@/lib/api"
+
+// Mock the API module
+jest.mock("@/lib/api", () => ({
+  ...jest.requireActual("@/lib/api"),
+  createNewsletter: jest.fn(),
+}))
+
+const mockedApi = api as jest.Mocked<typeof api>
+
+describe("AddNewsletterDialog", () => {
+  const handleOpenChange = jest.fn()
+  const handleSuccess = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("allows user to fill out the form and submit", async () => {
+    mockedApi.createNewsletter.mockResolvedValueOnce({
+      id: 1,
+      name: "My New Newsletter",
+      is_active: true,
+      senders: [{ id: 1, email: "test@example.com", newsletter_id: 1 }],
+      entries_count: 0,
+    })
+
+    render(<AddNewsletterDialog isOpen={true} onOpenChange={handleOpenChange} onSuccess={handleSuccess} />)
+
+    // Fill out the form
+    fireEvent.change(screen.getByLabelText(/Newsletter Name/i), { target: { value: "My New Newsletter" } })
+    fireEvent.change(screen.getByPlaceholderText(/Enter email address/i), { target: { value: "test@example.com" } })
+
+    // Submit the form
+    fireEvent.click(screen.getByRole("button", { name: /Register Newsletter/i }))
+
+    // Wait for the async operation to complete
+    await waitFor(() => {
+      expect(mockedApi.createNewsletter).toHaveBeenCalledWith({
+        name: "My New Newsletter",
+        sender_emails: ["test@example.com"],
+      })
+      expect(handleSuccess).toHaveBeenCalledTimes(1)
+      expect(handleOpenChange).toHaveBeenCalledWith(false)
+    })
+  })
+
+  it("allows adding and removing email fields", () => {
+    render(<AddNewsletterDialog isOpen={true} onOpenChange={() => {}} onSuccess={() => {}} />)
+
+    // Initial state
+    expect(screen.getAllByPlaceholderText(/Enter email address/i)).toHaveLength(1)
+
+    // Add another email
+    fireEvent.click(screen.getByRole("button", { name: /Add Another Email/i }))
+    expect(screen.getAllByPlaceholderText(/Enter email address/i)).toHaveLength(2)
+
+    // Remove the first email
+    fireEvent.click(screen.getAllByRole("button", { name: /Remove/i })[0])
+    expect(screen.getAllByPlaceholderText(/Enter email address/i)).toHaveLength(1)
+  })
+
+  it("closes the dialog when cancel is clicked", () => {
+    render(<AddNewsletterDialog isOpen={true} onOpenChange={handleOpenChange} onSuccess={handleSuccess} />)
+
+    fireEvent.click(screen.getByRole("button", { name: /Cancel/i }))
+    expect(handleOpenChange).toHaveBeenCalledWith(false)
+    expect(handleSuccess).not.toHaveBeenCalled()
+  })
+})

frontend/components/letterfeed/__tests__/EditNewsletterDialog.test.tsx

@@ -0,0 +1,108 @@
+import React from "react"
+import { render, screen, fireEvent, waitFor } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { EditNewsletterDialog } from "../EditNewsletterDialog"
+import { Newsletter } from "@/lib/api"
+import * as api from "@/lib/api"
+
+// Mock the API module
+jest.mock("@/lib/api", () => ({
+  ...jest.requireActual("@/lib/api"),
+  updateNewsletter: jest.fn(),
+  deleteNewsletter: jest.fn(),
+}))
+
+const mockedApi = api as jest.Mocked<typeof api>
+
+const mockNewsletter: Newsletter = {
+  id: 1,
+  name: "Existing Newsletter",
+  is_active: true,
+  senders: [{ id: 1, email: "current@example.com", newsletter_id: 1 }],
+  entries_count: 5,
+}
+
+describe("EditNewsletterDialog", () => {
+  const handleOpenChange = jest.fn()
+  const handleSuccess = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Mock window.confirm for the delete action
+    window.confirm = jest.fn(() => true)
+  })
+
+  it("renders with initial newsletter data and allows updates", async () => {
+    mockedApi.updateNewsletter.mockResolvedValueOnce({ ...mockNewsletter, name: "Updated Name" })
+
+    render(
+      <EditNewsletterDialog
+        newsletter={mockNewsletter}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    // Check that initial data is present
+    const nameInput = screen.getByLabelText(/Newsletter Name/i)
+    expect(nameInput).toHaveValue("Existing Newsletter")
+    expect(screen.getByDisplayValue("current@example.com")).toBeInTheDocument()
+
+    // Update the name
+    fireEvent.change(nameInput, { target: { value: "Updated Name" } })
+
+    // Submit
+    fireEvent.click(screen.getByRole("button", { name: /Save Changes/i }))
+
+    await waitFor(() => {
+      expect(mockedApi.updateNewsletter).toHaveBeenCalledWith(1, {
+        name: "Updated Name",
+        sender_emails: ["current@example.com"],
+      })
+      expect(handleSuccess).toHaveBeenCalledTimes(1)
+      expect(handleOpenChange).toHaveBeenCalledWith(false)
+    })
+  })
+
+  it("calls deleteNewsletter when delete button is clicked and confirmed", async () => {
+    mockedApi.deleteNewsletter.mockResolvedValueOnce()
+
+    render(
+      <EditNewsletterDialog
+        newsletter={mockNewsletter}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    fireEvent.click(screen.getByRole("button", { name: /Delete Newsletter/i }))
+
+    expect(window.confirm).toHaveBeenCalledWith('Are you sure you want to delete the "Existing Newsletter" newsletter?')
+
+    await waitFor(() => {
+      expect(mockedApi.deleteNewsletter).toHaveBeenCalledWith(1)
+      expect(handleSuccess).toHaveBeenCalledTimes(1)
+      expect(handleOpenChange).toHaveBeenCalledWith(false)
+    })
+  })
+
+  it("does not call deleteNewsletter when delete is not confirmed", () => {
+    window.confirm = jest.fn(() => false) // User clicks "Cancel"
+
+    render(
+      <EditNewsletterDialog
+        newsletter={mockNewsletter}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    fireEvent.click(screen.getByRole("button", { name: /Delete Newsletter/i }))
+
+    expect(mockedApi.deleteNewsletter).not.toHaveBeenCalled()
+    expect(handleSuccess).not.toHaveBeenCalled()
+  })
+})

frontend/components/letterfeed/__tests__/EmptyState.test.tsx

@@ -0,0 +1,24 @@
+import React from "react"
+import { render, screen, fireEvent } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { EmptyState } from "../EmptyState"
+
+describe("EmptyState", () => {
+  it("renders the correct content", () => {
+    render(<EmptyState onAddNewsletter={() => {}} />)
+
+    expect(screen.getByText("No newsletters registered")).toBeInTheDocument()
+    expect(screen.getByText("Get started by adding your first newsletter")).toBeInTheDocument()
+    expect(screen.getByRole("button", { name: /Add Your First Newsletter/i })).toBeInTheDocument()
+  })
+
+  it("calls onAddNewsletter when the button is clicked", () => {
+    const handleAddNewsletter = jest.fn()
+    render(<EmptyState onAddNewsletter={handleAddNewsletter} />)
+
+    const addButton = screen.getByRole("button", { name: /Add Your First Newsletter/i })
+    fireEvent.click(addButton)
+
+    expect(handleAddNewsletter).toHaveBeenCalledTimes(1)
+  })
+})

frontend/components/letterfeed/__tests__/Header.test.tsx

@@ -0,0 +1,30 @@
+import React from "react"
+import { render, screen, fireEvent } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { Header } from "../Header"
+
+describe("Header", () => {
+  it("renders the title and description", () => {
+    render(<Header onOpenAddNewsletter={() => {}} onOpenSettings={() => {}} />)
+    expect(screen.getByText("LetterFeed")).toBeInTheDocument()
+    expect(screen.getByText("Read your newsletters as RSS feeds!")).toBeInTheDocument()
+  })
+
+  it('calls onOpenAddNewsletter when "Add Newsletter" button is clicked', () => {
+    const handleOpenAdd = jest.fn()
+    render(<Header onOpenAddNewsletter={handleOpenAdd} onOpenSettings={() => {}} />)
+
+    const addButton = screen.getByRole("button", { name: /Add Newsletter/i })
+    fireEvent.click(addButton)
+    expect(handleOpenAdd).toHaveBeenCalledTimes(1)
+  })
+
+  it('calls onOpenSettings when "Settings" button is clicked', () => {
+    const handleOpenSettings = jest.fn()
+    render(<Header onOpenAddNewsletter={() => {}} onOpenSettings={handleOpenSettings} />)
+
+    const settingsButton = screen.getByRole("button", { name: /Settings/i })
+    fireEvent.click(settingsButton)
+    expect(handleOpenSettings).toHaveBeenCalledTimes(1)
+  })
+})

frontend/components/letterfeed/__tests__/LoadingSpinner.test.tsx

@@ -0,0 +1,13 @@
+import React from "react"
+import { render, screen } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { LoadingSpinner } from "../LoadingSpinner"
+
+describe("LoadingSpinner", () => {
+  it("renders the spinner with the correct animation class", () => {
+    render(<LoadingSpinner />)
+    const spinner = screen.getByTestId("loading-spinner")
+    expect(spinner).toBeInTheDocument()
+    expect(spinner).toHaveClass("animate-spin")
+  })
+})

frontend/components/letterfeed/__tests__/NewsletterCard.test.tsx

@@ -0,0 +1,63 @@
+import React from "react"
+import { render, screen, fireEvent } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { NewsletterCard } from "../NewsletterCard"
+import { Newsletter } from "@/lib/api"
+
+// Mock the getFeedUrl function
+jest.mock("@/lib/api", () => ({
+  ...jest.requireActual("@/lib/api"), // import and retain all actual implementations
+  getFeedUrl: jest.fn((id) => `http://mock-api/feeds/${id}`),
+}))
+
+const mockNewsletter: Newsletter = {
+  id: 1,
+  name: "Tech Weekly",
+  is_active: true,
+  senders: [
+    { id: 1, email: "contact@techweekly.com", newsletter_id: 1 },
+    { id: 2, email: "updates@techweekly.com", newsletter_id: 1 },
+  ],
+  entries_count: 42,
+}
+
+describe("NewsletterCard", () => {
+  it("renders newsletter details correctly", () => {
+    const handleEdit = jest.fn()
+    render(<NewsletterCard newsletter={mockNewsletter} onEdit={handleEdit} />)
+
+    // Check for the title
+    expect(screen.getByText("Tech Weekly")).toBeInTheDocument()
+
+    // Check for the entries count
+    expect(screen.getByText("42 entries")).toBeInTheDocument()
+
+    // Check for sender emails
+    expect(screen.getByText("contact@techweekly.com")).toBeInTheDocument()
+    expect(screen.getByText("updates@techweekly.com")).toBeInTheDocument()
+
+    // Check for the RSS feed link
+    const feedLink = screen.getByRole("link")
+    expect(feedLink).toHaveAttribute("href", "http://mock-api/feeds/1")
+    expect(feedLink).toHaveTextContent("http://mock-api/feeds/1")
+  })
+
+  it('calls the onEdit function with the correct newsletter when the edit button is clicked', () => {
+    const handleEdit = jest.fn()
+    render(<NewsletterCard newsletter={mockNewsletter} onEdit={handleEdit} />)
+
+    const editButton = screen.getByRole("button", { name: /edit newsletter/i })
+    fireEvent.click(editButton)
+
+    expect(handleEdit).toHaveBeenCalledTimes(1)
+    expect(handleEdit).toHaveBeenCalledWith(mockNewsletter)
+  })
+
+  it('displays "entry" for a single entry', () => {
+    const singleEntryNewsletter = { ...mockNewsletter, entries_count: 1 }
+    const handleEdit = jest.fn()
+    render(<NewsletterCard newsletter={singleEntryNewsletter} onEdit={handleEdit} />)
+
+    expect(screen.getByText("1 entry")).toBeInTheDocument()
+  })
+})

frontend/components/letterfeed/__tests__/NewsletterList.test.tsx

@@ -0,0 +1,47 @@
+import React from "react"
+import { render, screen } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { NewsletterList } from "../NewsletterList"
+import { Newsletter } from "@/lib/api"
+
+// Mock the child component to isolate the list component's behavior
+jest.mock("../NewsletterCard", () => ({
+  NewsletterCard: ({ newsletter }: { newsletter: Newsletter }) => (
+    <div data-testid={`newsletter-card-${newsletter.id}`}>{newsletter.name}</div>
+  ),
+}))
+
+const mockNewsletters: Newsletter[] = [
+  {
+    id: 1,
+    name: "Newsletter One",
+    is_active: true,
+    senders: [],
+    entries_count: 10,
+  },
+  {
+    id: 2,
+    name: "Newsletter Two",
+    is_active: true,
+    senders: [],
+    entries_count: 5,
+  },
+]
+
+describe("NewsletterList", () => {
+  it("renders a list of newsletter cards", () => {
+    render(<NewsletterList newsletters={mockNewsletters} onEditNewsletter={() => {}} />)
+
+    // Check that both newsletters are rendered
+    expect(screen.getByText("Newsletter One")).toBeInTheDocument()
+    expect(screen.getByText("Newsletter Two")).toBeInTheDocument()
+    expect(screen.getByTestId("newsletter-card-1")).toBeInTheDocument()
+    expect(screen.getByTestId("newsletter-card-2")).toBeInTheDocument()
+  })
+
+  it("renders nothing when the newsletter list is empty", () => {
+    const { container } = render(<NewsletterList newsletters={[]} onEditNewsletter={() => {}} />)
+    // The main div should be empty
+    expect(container.firstChild).toBeEmptyDOMElement()
+  })
+})

frontend/components/letterfeed/__tests__/SettingsDialog.test.tsx

@@ -0,0 +1,131 @@
+import React from "react"
+import { render, screen, fireEvent, waitFor } from "@testing-library/react"
+import "@testing-library/jest-dom"
+import { SettingsDialog } from "../SettingsDialog"
+import { Settings } from "@/lib/api"
+import * as api from "@/lib/api"
+
+// Mock the API module
+jest.mock("@/lib/api", () => ({
+  ...jest.requireActual("@/lib/api"),
+  updateSettings: jest.fn(),
+  testImapConnection: jest.fn(),
+}))
+
+const mockedApi = api as jest.Mocked<typeof api>
+
+const mockSettings: Settings = {
+  id: 1,
+  imap_server: "imap.example.com",
+  imap_username: "user@example.com",
+  search_folder: "INBOX",
+  move_to_folder: "Archive",
+  mark_as_read: true,
+  email_check_interval: 30,
+  auto_add_new_senders: false,
+  locked_fields: ["imap_server"], // Mock a locked field
+}
+
+const mockFolderOptions = ["INBOX", "Sent", "Archive", "Spam"]
+
+describe("SettingsDialog", () => {
+  const handleOpenChange = jest.fn()
+  const handleSuccess = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("renders settings and respects locked fields", () => {
+    render(
+      <SettingsDialog
+        settings={mockSettings}
+        folderOptions={mockFolderOptions}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    // Check that a locked field is disabled
+    expect(screen.getByLabelText(/IMAP Server/i)).toBeDisabled()
+    // Check that a non-locked field is enabled
+    expect(screen.getByLabelText(/IMAP Username/i)).toBeEnabled()
+
+    // Check that values are set correctly
+    expect(screen.getByLabelText(/IMAP Username/i)).toHaveValue(mockSettings.imap_username)
+    expect(screen.getByLabelText(/Mark emails as read/i)).toBeChecked()
+  })
+
+  it("allows updating and saving settings", async () => {
+    mockedApi.updateSettings.mockResolvedValueOnce(mockSettings)
+
+    render(
+      <SettingsDialog
+        settings={mockSettings}
+        folderOptions={mockFolderOptions}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    // Change a setting
+    fireEvent.change(screen.getByLabelText(/IMAP Username/i), { target: { value: "new.user@example.com" } })
+
+    // Save
+    fireEvent.click(screen.getByRole("button", { name: /Save Settings/i }))
+
+    await waitFor(() => {
+      expect(mockedApi.updateSettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          imap_username: "new.user@example.com",
+        })
+      )
+      expect(handleSuccess).toHaveBeenCalledTimes(1)
+      expect(handleOpenChange).toHaveBeenCalledWith(false)
+    })
+  })
+
+  it("handles successful connection test", async () => {
+    mockedApi.testImapConnection.mockResolvedValueOnce({ message: "Connection successful!" })
+
+    render(
+      <SettingsDialog
+        settings={mockSettings}
+        folderOptions={mockFolderOptions}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    fireEvent.click(screen.getByRole("button", { name: /Test Connection/i }))
+
+    await waitFor(() => {
+      expect(screen.getByText("Connection successful!")).toBeInTheDocument()
+      expect(screen.getByTestId("connection-status")).toHaveClass("text-green-600")
+    })
+  })
+
+  it("handles failed connection test", async () => {
+    mockedApi.testImapConnection.mockRejectedValueOnce(new Error("Authentication failed"))
+
+    render(
+      <SettingsDialog
+        settings={mockSettings}
+        folderOptions={mockFolderOptions}
+        isOpen={true}
+        onOpenChange={handleOpenChange}
+        onSuccess={handleSuccess}
+      />
+    )
+
+    fireEvent.click(screen.getByRole("button", { name: /Test Connection/i }))
+
+    await waitFor(() => {
+      expect(screen.getByText("Authentication failed")).toBeInTheDocument()
+      expect(screen.getByTestId("connection-status")).toHaveClass("text-red-600")
+    })
+  })
+})

frontend/components/ui/badge.tsx

@@ -0,0 +1,46 @@
+import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+  "inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden",
+  {
+    variants: {
+      variant: {
+        default:
+          "border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
+        secondary:
+          "border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
+        destructive:
+          "border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline:
+          "text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+function Badge({
+  className,
+  variant,
+  asChild = false,
+  ...props
+}: React.ComponentProps<"span"> &
+  VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
+  const Comp = asChild ? Slot : "span"
+
+  return (
+    <Comp
+      data-slot="badge"
+      className={cn(badgeVariants({ variant }), className)}
+      {...props}
+    />
+  )
+}
+
+export { Badge, badgeVariants }

frontend/components/ui/button.tsx

@@ -0,0 +1,59 @@
+import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+  {
+    variants: {
+      variant: {
+        default:
+          "bg-primary text-primary-foreground shadow-xs hover:bg-primary/90",
+        destructive:
+          "bg-destructive text-white shadow-xs hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline:
+          "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground shadow-xs hover:bg-secondary/80",
+        ghost:
+          "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+function Button({
+  className,
+  variant,
+  size,
+  asChild = false,
+  ...props
+}: React.ComponentProps<"button"> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean
+  }) {
+  const Comp = asChild ? Slot : "button"
+
+  return (
+    <Comp
+      data-slot="button"
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  )
+}
+
+export { Button, buttonVariants }

frontend/components/ui/card.tsx

@@ -0,0 +1,92 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Card({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card"
+      className={cn(
+        "bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-header"
+      className={cn(
+        "@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-1.5 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-title"
+      className={cn("leading-none font-semibold", className)}
+      {...props}
+    />
+  )
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-description"
+      className={cn("text-muted-foreground text-sm", className)}
+      {...props}
+    />
+  )
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-action"
+      className={cn(
+        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-content"
+      className={cn("px-6", className)}
+      {...props}
+    />
+  )
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-footer"
+      className={cn("flex items-center px-6 [.border-t]:pt-6", className)}
+      {...props}
+    />
+  )
+}
+
+export {
+  Card,
+  CardHeader,
+  CardFooter,
+  CardTitle,
+  CardAction,
+  CardDescription,
+  CardContent,
+}

frontend/components/ui/checkbox.tsx

@@ -0,0 +1,32 @@
+"use client"
+
+import * as React from "react"
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
+import { CheckIcon } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+function Checkbox({
+  className,
+  ...props
+}: React.ComponentProps<typeof CheckboxPrimitive.Root>) {
+  return (
+    <CheckboxPrimitive.Root
+      data-slot="checkbox"
+      className={cn(
+        "peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      )}
+      {...props}
+    >
+      <CheckboxPrimitive.Indicator
+        data-slot="checkbox-indicator"
+        className="flex items-center justify-center text-current transition-none"
+      >
+        <CheckIcon className="size-3.5" />
+      </CheckboxPrimitive.Indicator>
+    </CheckboxPrimitive.Root>
+  )
+}
+
+export { Checkbox }

frontend/components/ui/components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}

frontend/components/ui/dialog.tsx

@@ -0,0 +1,143 @@
+"use client"
+
+import * as React from "react"
+import * as DialogPrimitive from "@radix-ui/react-dialog"
+import { XIcon } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+function Dialog({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Root>) {
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />
+}
+
+function DialogTrigger({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />
+}
+
+function DialogPortal({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
+}
+
+function DialogClose({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Close>) {
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />
+}
+
+function DialogOverlay({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
+  return (
+    <DialogPrimitive.Overlay
+      data-slot="dialog-overlay"
+      className={cn(
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function DialogContent({
+  className,
+  children,
+  showCloseButton = true,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Content> & {
+  showCloseButton?: boolean
+}) {
+  return (
+    <DialogPortal data-slot="dialog-portal">
+      <DialogOverlay />
+      <DialogPrimitive.Content
+        data-slot="dialog-content"
+        className={cn(
+          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
+          className
+        )}
+        {...props}
+      >
+        {children}
+        {showCloseButton && (
+          <DialogPrimitive.Close
+            data-slot="dialog-close"
+            className="ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4"
+          >
+            <XIcon />
+            <span className="sr-only">Close</span>
+          </DialogPrimitive.Close>
+        )}
+      </DialogPrimitive.Content>
+    </DialogPortal>
+  )
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="dialog-header"
+      className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
+      {...props}
+    />
+  )
+}
+
+function DialogFooter({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="dialog-footer"
+      className={cn(
+        "flex flex-col-reverse gap-2 sm:flex-row sm:justify-end",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function DialogTitle({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Title>) {
+  return (
+    <DialogPrimitive.Title
+      data-slot="dialog-title"
+      className={cn("text-lg leading-none font-semibold", className)}
+      {...props}
+    />
+  )
+}
+
+function DialogDescription({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Description>) {
+  return (
+    <DialogPrimitive.Description
+      data-slot="dialog-description"
+      className={cn("text-muted-foreground text-sm", className)}
+      {...props}
+    />
+  )
+}
+
+export {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+}

frontend/components/ui/input.tsx

@@ -0,0 +1,21 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+  return (
+    <input
+      type={type}
+      data-slot="input"
+      className={cn(
+        "file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input flex h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+        "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Input }

frontend/components/ui/label.tsx

@@ -0,0 +1,22 @@
+import * as React from "react"
+import * as LabelPrimitive from "@radix-ui/react-label"
+
+import { cn } from "@/lib/utils"
+
+function Label({
+  className,
+  ...props
+}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      data-slot="label"
+      className={cn(
+        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Label }

frontend/components/ui/select.tsx

@@ -0,0 +1,183 @@
+import * as React from "react"
+import * as SelectPrimitive from "@radix-ui/react-select"
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+function Select({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+  return <SelectPrimitive.Root data-slot="select" {...props} />
+}
+
+function SelectGroup({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Group>) {
+  return <SelectPrimitive.Group data-slot="select-group" {...props} />
+}
+
+function SelectValue({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Value>) {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />
+}
+
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default"
+}) {
+  return (
+    <SelectPrimitive.Trigger
+      data-slot="select-trigger"
+      data-size={size}
+      className={cn(
+        "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 dark:hover:bg-input/50 flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      {children}
+      <SelectPrimitive.Icon asChild>
+        <ChevronDownIcon className="size-4 opacity-50" />
+      </SelectPrimitive.Icon>
+    </SelectPrimitive.Trigger>
+  )
+}
+
+function SelectContent({
+  className,
+  children,
+  position = "popper",
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>) {
+  return (
+    <SelectPrimitive.Portal>
+      <SelectPrimitive.Content
+        data-slot="select-content"
+        className={cn(
+          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+          position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+          className
+        )}
+        position={position}
+        {...props}
+      >
+        <SelectScrollUpButton />
+        <SelectPrimitive.Viewport
+          className={cn(
+            "p-1",
+            position === "popper" &&
+              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1"
+          )}
+        >
+          {children}
+        </SelectPrimitive.Viewport>
+        <SelectScrollDownButton />
+      </SelectPrimitive.Content>
+    </SelectPrimitive.Portal>
+  )
+}
+
+function SelectLabel({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+  return (
+    <SelectPrimitive.Label
+      data-slot="select-label"
+      className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectItem({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Item>) {
+  return (
+    <SelectPrimitive.Item
+      data-slot="select-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        className
+      )}
+      {...props}
+    >
+      <span className="absolute right-2 flex size-3.5 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <CheckIcon className="size-4" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  )
+}
+
+function SelectSeparator({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+  return (
+    <SelectPrimitive.Separator
+      data-slot="select-separator"
+      className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectScrollUpButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+  return (
+    <SelectPrimitive.ScrollUpButton
+      data-slot="select-scroll-up-button"
+      className={cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      )}
+      {...props}
+    >
+      <ChevronUpIcon className="size-4" />
+    </SelectPrimitive.ScrollUpButton>
+  )
+}
+
+function SelectScrollDownButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+  return (
+    <SelectPrimitive.ScrollDownButton
+      data-slot="select-scroll-down-button"
+      className={cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      )}
+      {...props}
+    >
+      <ChevronDownIcon className="size-4" />
+    </SelectPrimitive.ScrollDownButton>
+  )
+}
+
+export {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+}

frontend/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals", "next/typescript"),
+];
+
+export default eslintConfig;

frontend/jest.config.js

@@ -0,0 +1,16 @@
+const nextJest = require('next/jest');
+
+const createJestConfig = nextJest({
+  dir: './',
+});
+
+const customJestConfig = {
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+  testEnvironment: 'jest-environment-jsdom',
+  moduleNameMapper: {
+    '^@/components/(.*)$': '<rootDir>/components/$1',
+    '^@/lib/(.*)$': '<rootDir>/src/lib/$1',
+  },
+};
+
+module.exports = createJestConfig(customJestConfig);

frontend/jest.setup.js

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

frontend/next.config.ts

@@ -0,0 +1,14 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  async rewrites() {
+    return [
+      {
+        source: '/api/:path*',
+        destination: 'http://backend:8000/:path*',
+      },
+    ];
+  },
+};
+
+export default nextConfig;

frontend/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@radix-ui/react-checkbox": "^1.3.2",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.525.0",
+    "next": "15.4.1",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "tailwind-merge": "^3.3.1"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-react": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "babel-jest": "^30.0.4",
+    "eslint": "^9",
+    "eslint-config-next": "15.4.1",
+    "jest": "^30.0.4",
+    "jest-environment-jsdom": "^30.0.4",
+    "jest-fetch-mock": "^3.0.3",
+    "tailwindcss": "^4",
+    "tw-animate-css": "^1.3.5",
+    "typescript": "^5"
+  }
+}

frontend/postcss.config.mjs

@@ -0,0 +1,5 @@
+const config = {
+  plugins: ["@tailwindcss/postcss"],
+};
+
+export default config;

frontend/src/app/globals.css

@@ -0,0 +1,122 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}
+
+:root {
+  --radius: 0.625rem;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --chart-1: oklch(0.646 0.222 41.116);
+  --chart-2: oklch(0.6 0.118 184.704);
+  --chart-3: oklch(0.398 0.07 227.392);
+  --chart-4: oklch(0.828 0.189 84.429);
+  --chart-5: oklch(0.769 0.188 70.08);
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.97 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0 0);
+  --sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --chart-1: oklch(0.488 0.243 264.376);
+  --chart-2: oklch(0.696 0.17 162.48);
+  --chart-3: oklch(0.769 0.188 70.08);
+  --chart-4: oklch(0.627 0.265 303.9);
+  --chart-5: oklch(0.645 0.246 16.439);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}

frontend/src/app/layout.tsx

@@ -0,0 +1,34 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "LetterFeed",
+  description: "Read your newsletters as RSS feeds!",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

frontend/src/app/page.tsx

@@ -0,0 +1,104 @@
+"use client"
+
+import { useState, useEffect, useCallback } from "react"
+import {
+  getNewsletters,
+  getSettings,
+  getImapFolders,
+  Newsletter,
+  Settings as AppSettings,
+} from "@/lib/api"
+import { LoadingSpinner } from "@/components/letterfeed/LoadingSpinner"
+import { Header } from "@/components/letterfeed/Header"
+import { NewsletterList } from "@/components/letterfeed/NewsletterList"
+import { EmptyState } from "@/components/letterfeed/EmptyState"
+import { AddNewsletterDialog } from "@/components/letterfeed/AddNewsletterDialog"
+import { EditNewsletterDialog } from "@/components/letterfeed/EditNewsletterDialog"
+import { SettingsDialog } from "@/components/letterfeed/SettingsDialog"
+
+export default function LetterFeedApp() {
+  const [newsletters, setNewsletters] = useState<Newsletter[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [settings, setSettings] = useState<AppSettings | null>(null)
+  const [folderOptions, setFolderOptions] = useState<string[]>([])
+
+  const [isAddDialogOpen, setIsAddDialogOpen] = useState(false)
+  const [isSettingsOpen, setIsSettingsOpen] = useState(false)
+  const [isEditDialogOpen, setIsEditDialogOpen] = useState(false)
+  const [editingNewsletter, setEditingNewsletter] = useState<Newsletter | null>(null)
+
+  const fetchData = useCallback(async () => {
+    try {
+      const [newslettersData, settingsData, foldersData] = await Promise.all([
+        getNewsletters(),
+        getSettings(),
+        getImapFolders(),
+      ])
+      setNewsletters(newslettersData)
+      setSettings(settingsData)
+      setFolderOptions(foldersData)
+    } catch (error) {
+      console.error("Failed to fetch data:", error)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    fetchData()
+  }, [fetchData])
+
+  const openEditDialog = (newsletter: Newsletter) => {
+    setEditingNewsletter(newsletter)
+    setIsEditDialogOpen(true)
+  }
+
+  if (isLoading) {
+    return <LoadingSpinner />
+  }
+
+  return (
+    <div className="min-h-screen bg-gray-50">
+      <div className="container mx-auto px-4 py-8">
+        <Header
+          onOpenAddNewsletter={() => setIsAddDialogOpen(true)}
+          onOpenSettings={() => setIsSettingsOpen(true)}
+        />
+
+        {newsletters.length > 0 ? (
+          <NewsletterList newsletters={newsletters} onEditNewsletter={openEditDialog} />
+        ) : (
+          <EmptyState onAddNewsletter={() => setIsAddDialogOpen(true)} />
+        )}
+
+        <AddNewsletterDialog
+          isOpen={isAddDialogOpen}
+          onOpenChange={setIsAddDialogOpen}
+          onSuccess={fetchData}
+        />
+
+        {editingNewsletter && (
+          <EditNewsletterDialog
+            newsletter={editingNewsletter}
+            isOpen={isEditDialogOpen}
+            onOpenChange={setIsEditDialogOpen}
+            onSuccess={() => {
+              setEditingNewsletter(null)
+              fetchData()
+            }}
+          />
+        )}
+
+        {settings && (
+          <SettingsDialog
+            settings={settings}
+            folderOptions={folderOptions}
+            isOpen={isSettingsOpen}
+            onOpenChange={setIsSettingsOpen}
+            onSuccess={fetchData}
+          />
+        )}
+      </div>
+    </div>
+  )
+}

frontend/src/lib/__tests__/api.test.ts

@@ -0,0 +1,256 @@
+import {
+  getNewsletters,
+  createNewsletter,
+  updateNewsletter,
+  deleteNewsletter,
+  getSettings,
+  updateSettings,
+  getImapFolders,
+  testImapConnection,
+  getFeedUrl,
+  NewsletterCreate,
+  NewsletterUpdate,
+  SettingsCreate,
+} from "../api"
+
+// Mock the global fetch function
+global.fetch = jest.fn()
+
+const mockFetch = (data: any, ok = true) => { // eslint-disable-line @typescript-eslint/no-explicit-any
+  ;(fetch as jest.Mock).mockResolvedValueOnce({
+    ok,
+    json: () => Promise.resolve(data),
+  })
+}
+
+const mockFetchError = (data: any = {}) => { // eslint-disable-line @typescript-eslint/no-explicit-any
+  ;(fetch as jest.Mock).mockResolvedValueOnce({
+    ok: false,
+    json: () => Promise.resolve(data),
+  })
+}
+
+describe("API Functions", () => {
+  const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL
+
+  beforeEach(() => {
+    // Reset the mock before each test
+    ;(fetch as jest.Mock).mockClear()
+  })
+
+  describe("getNewsletters", () => {
+    it("should fetch newsletters successfully", async () => {
+      const mockNewsletters = [
+        { id: 1, name: "Newsletter 1", is_active: true, senders: [], entries_count: 5 },
+        { id: 2, name: "Newsletter 2", is_active: false, senders: [], entries_count: 10 },
+      ]
+      mockFetch(mockNewsletters)
+
+      const newsletters = await getNewsletters()
+      expect(newsletters).toEqual(mockNewsletters)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/newsletters`)
+    })
+
+    it("should throw an error if fetching newsletters fails", async () => {
+      mockFetchError()
+      await expect(getNewsletters()).rejects.toThrow("Failed to fetch newsletters")
+    })
+  })
+
+  describe("createNewsletter", () => {
+    it("should create a newsletter successfully", async () => {
+      const newNewsletter: NewsletterCreate = { name: "New Newsletter", sender_emails: ["test@example.com"] }
+      const createdNewsletter = {
+        id: 3,
+        ...newNewsletter,
+        is_active: true,
+        senders: [{ id: 1, email: "test@example.com", newsletter_id: 3 }],
+        entries_count: 0,
+      }
+      mockFetch(createdNewsletter)
+
+      const result = await createNewsletter(newNewsletter)
+      expect(result).toEqual(createdNewsletter)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/newsletters`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(newNewsletter),
+      })
+    })
+
+    it("should throw an error if creating newsletter fails", async () => {
+      const newNewsletter: NewsletterCreate = { name: "New Newsletter", sender_emails: [] }
+      mockFetchError()
+      await expect(createNewsletter(newNewsletter)).rejects.toThrow("Failed to create newsletter")
+    })
+  })
+
+  describe("updateNewsletter", () => {
+    it("should update a newsletter successfully", async () => {
+      const updatedNewsletter: NewsletterUpdate = { name: "Updated Newsletter", sender_emails: ["updated@example.com"] }
+      const newsletterId = 1
+      const returnedNewsletter = {
+        id: newsletterId,
+        ...updatedNewsletter,
+        is_active: true,
+        senders: [{ id: 1, email: "updated@example.com", newsletter_id: newsletterId }],
+        entries_count: 12,
+      }
+      mockFetch(returnedNewsletter)
+
+      const result = await updateNewsletter(newsletterId, updatedNewsletter)
+      expect(result).toEqual(returnedNewsletter)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/newsletters/${newsletterId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(updatedNewsletter),
+      })
+    })
+
+    it("should throw an error if updating newsletter fails", async () => {
+      const updatedNewsletter: NewsletterUpdate = { name: "Updated Newsletter", sender_emails: [] }
+      const newsletterId = 1
+      mockFetchError()
+      await expect(updateNewsletter(newsletterId, updatedNewsletter)).rejects.toThrow("Failed to update newsletter")
+    })
+  })
+
+  describe("deleteNewsletter", () => {
+    it("should delete a newsletter successfully", async () => {
+      const newsletterId = 1
+      mockFetch({}, true) // Successful deletion might not have a body
+
+      await deleteNewsletter(newsletterId)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/newsletters/${newsletterId}`, {
+        method: "DELETE",
+      })
+    })
+
+    it("should throw an error if deleting newsletter fails", async () => {
+      const newsletterId = 1
+      mockFetchError()
+      await expect(deleteNewsletter(newsletterId)).rejects.toThrow("Failed to delete newsletter")
+    })
+  })
+
+  describe("getSettings", () => {
+    it("should fetch settings successfully", async () => {
+      const mockSettings = {
+        id: 1,
+        imap_server: "imap.example.com",
+        imap_username: "user@example.com",
+        search_folder: "INBOX",
+        move_to_folder: null,
+        mark_as_read: true,
+        email_check_interval: 60,
+        auto_add_new_senders: false,
+        locked_fields: [],
+      }
+      mockFetch(mockSettings)
+
+      const settings = await getSettings()
+      expect(settings).toEqual(mockSettings)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/imap/settings`)
+    })
+
+    it("should throw an error if fetching settings fails", async () => {
+      mockFetchError()
+      await expect(getSettings()).rejects.toThrow("Failed to fetch settings")
+    })
+  })
+
+  describe("updateSettings", () => {
+    it("should update settings successfully", async () => {
+      const newSettings: SettingsCreate = {
+        imap_server: "new.imap.com",
+        imap_username: "newuser@example.com",
+        imap_password: "password",
+        search_folder: "Archive",
+        move_to_folder: "Processed",
+        mark_as_read: false,
+        email_check_interval: 120,
+        auto_add_new_senders: true,
+      }
+      const updatedSettings = { id: 1, ...newSettings, locked_fields: [] }
+      mockFetch(updatedSettings)
+
+      const result = await updateSettings(newSettings)
+      expect(result).toEqual(updatedSettings)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/imap/settings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(newSettings),
+      })
+    })
+
+    it("should throw an error if updating settings fails", async () => {
+      const newSettings: SettingsCreate = {
+        imap_server: "new.imap.com",
+        imap_username: "newuser@example.com",
+        search_folder: "Archive",
+        mark_as_read: false,
+        email_check_interval: 120,
+        auto_add_new_senders: true,
+      }
+      mockFetchError()
+      await expect(updateSettings(newSettings)).rejects.toThrow("Failed to update settings")
+    })
+  })
+
+  describe("getImapFolders", () => {
+    it("should fetch IMAP folders successfully", async () => {
+      const mockFolders = ["INBOX", "Sent", "Archive"]
+      mockFetch(mockFolders)
+
+      const folders = await getImapFolders()
+      expect(folders).toEqual(mockFolders)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/imap/folders`)
+    })
+
+    it("should return an empty array if fetching IMAP folders fails", async () => {
+      mockFetchError()
+      const folders = await getImapFolders()
+      expect(folders).toEqual([])
+    })
+  })
+
+  describe("testImapConnection", () => {
+    it("should test IMAP connection successfully", async () => {
+      const mockResponse = { message: "Connection successful" }
+      mockFetch(mockResponse)
+
+      const result = await testImapConnection()
+      expect(result).toEqual(mockResponse)
+      expect(fetch).toHaveBeenCalledWith(`${API_BASE_URL}/imap/test`, {
+        method: "POST",
+      })
+    })
+
+    it("should throw an error with detail if testing IMAP connection fails", async () => {
+      const errorMessage = "Invalid credentials"
+      mockFetchError({ detail: errorMessage })
+      await expect(testImapConnection()).rejects.toThrow(errorMessage)
+    })
+
+    it("should throw a generic error if testing IMAP connection fails without detail", async () => {
+      mockFetchError()
+      await expect(testImapConnection()).rejects.toThrow("Failed to test IMAP connection")
+    })
+  })
+
+  describe("getFeedUrl", () => {
+    it("should return the correct feed URL", () => {
+      const newsletterId = 123
+      const expectedUrl = `${API_BASE_URL}/feeds/${newsletterId}`
+      const url = getFeedUrl(newsletterId)
+      expect(url).toBe(expectedUrl)
+    })
+
+    it("should handle newsletterId being 0", () => {
+      const newsletterId = 0
+      const expectedUrl = `${API_BASE_URL}/feeds/0`
+      const url = getFeedUrl(newsletterId)
+      expect(url).toBe(expectedUrl)
+    })
+  })
+})

frontend/src/lib/api.ts

@@ -0,0 +1,142 @@
+// frontend/src/lib/api.ts
+
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL;
+
+export interface Sender {
+    id: number;
+    email: string;
+    newsletter_id: number;
+}
+
+export interface Newsletter {
+  id: number
+  name: string
+  is_active: boolean
+  senders: { id: number; email: string }[]
+  entries_count: number
+}
+
+export interface NewsletterCreate {
+    name: string;
+    sender_emails: string[];
+}
+
+export interface NewsletterUpdate {
+    name: string;
+    sender_emails: string[];
+}
+
+export interface Settings {
+    id: number;
+    imap_server: string;
+    imap_username: string;
+    search_folder: string;
+    move_to_folder?: string | null;
+    mark_as_read: boolean;
+    email_check_interval: number;
+    auto_add_new_senders: boolean;
+    locked_fields: string[];
+}
+
+export interface SettingsCreate {
+    imap_server: string;
+    imap_username: string;
+    imap_password?: string;
+    search_folder: string;
+    move_to_folder?: string | null;
+    mark_as_read: boolean;
+    email_check_interval: number;
+    auto_add_new_senders: boolean;
+}
+
+
+export async function getNewsletters(): Promise<Newsletter[]> {
+    const response = await fetch(`${API_BASE_URL}/newsletters`);
+    if (!response.ok) {
+        throw new Error("Failed to fetch newsletters");
+    }
+    return response.json();
+}
+
+export async function createNewsletter(newsletter: NewsletterCreate): Promise<Newsletter> {
+    const response = await fetch(`${API_BASE_URL}/newsletters`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(newsletter),
+    });
+    if (!response.ok) {
+        throw new Error("Failed to create newsletter");
+    }
+    return response.json();
+}
+
+export async function updateNewsletter(id: number, newsletter: NewsletterUpdate): Promise<Newsletter> {
+    const response = await fetch(`${API_BASE_URL}/newsletters/${id}`, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(newsletter),
+    });
+    if (!response.ok) {
+        throw new Error("Failed to update newsletter");
+    }
+    return response.json();
+}
+
+export async function deleteNewsletter(id: number): Promise<void> {
+    const response = await fetch(`${API_BASE_URL}/newsletters/${id}`, {
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        throw new Error("Failed to delete newsletter");
+    }
+}
+
+export async function getSettings(): Promise<Settings> {
+    const response = await fetch(`${API_BASE_URL}/imap/settings`);
+    if (!response.ok) {
+        throw new Error("Failed to fetch settings");
+    }
+    return response.json();
+}
+
+export async function updateSettings(settings: SettingsCreate): Promise<Settings> {
+    const response = await fetch(`${API_BASE_URL}/imap/settings`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(settings),
+    });
+    if (!response.ok) {
+        throw new Error("Failed to update settings");
+    }
+    return response.json();
+}
+
+export async function getImapFolders(): Promise<string[]> {
+    const response = await fetch(`${API_BASE_URL}/imap/folders`);
+    // If it fails, it's probably because settings are not configured. Return empty array.
+    if (!response.ok) {
+        return [];
+    }
+    return response.json();
+}
+
+export async function testImapConnection(): Promise<{ message: string }> {
+    const response = await fetch(`${API_BASE_URL}/imap/test`, {
+        method: 'POST',
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.detail || "Failed to test IMAP connection");
+    }
+    return response.json();
+}
+
+export function getFeedUrl(newsletterId: number): string {
+    return `${API_BASE_URL}/feeds/${newsletterId}`;
+}

frontend/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

frontend/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/components/*": ["./components/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}