Merge pull request 'add-feeding-overview' (#12) from add-feeding-overview into main

Reviewed-on: #12

README.md

@@ -1,3 +1,264 @@
-# baby-monitor
+# 👶 Baby Monitor
 
-Baby monitor app that helps track feeding, sleeping and diaper changes for a child.
+A self-hosted FastAPI web application for tracking baby activities including feeding, sleeping, and diaper changes. Built with modern Python tools and designed for easy deployment with Docker.
+
+[![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=flat&logo=docker&logoColor=white)](https://www.docker.com/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=flat&logo=fastapi)](https://fastapi.tiangolo.com)
+[![Python](https://img.shields.io/badge/python-3.12+-blue.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
+
+## ✨ Features
+
+- 🔐 **Secure Authentication** - Token-based authentication with environment-configured credentials
+- 💾 **Flexible Storage** - SQLite by default with PostgreSQL support
+- 🚀 **Scalable Sessions** - In-memory tokens with optional Redis for distributed deployments
+- 📦 **Self-Contained** - Docker image includes all optional dependencies
+- 🔌 **Repository Pattern** - Clean architecture with swappable backends
+- 🏥 **Health Checks** - Built-in health and readiness endpoints
+- 🌐 **SPA Frontend** - Modern single-page application interface
+- 🐳 **Docker Ready** - Production-ready Dockerfile with multi-architecture support
+
+## 🚀 Quick Start
+
+### Using Docker (Recommended)
+
+```bash
+# Pull and run the latest image
+docker run -d \
+  --name baby-monitor \
+  -p 8000:8000 \
+  -e ADMIN_PASSWORD=your-secure-password \
+  -v baby_monitor_data:/data \
+  gitea.gt-proj.com/brian/baby-monitor:latest
+
+# Access the application
+open http://localhost:8000
+```
+
+### Using Docker Compose
+
+```yaml
+services:
+  baby-monitor:
+    image: gitea.gt-proj.com/brian/baby-monitor:latest
+    container_name: baby-monitor
+    ports:
+      - "8000:8000"
+    environment:
+      - ENVIRONMENT=production
+      - ADMIN_PASSWORD=${ADMIN_PASSWORD}
+      # Optional: Use Redis for distributed token storage
+      # - REDIS_URI=redis://redis:6379
+    volumes:
+      - ./data:/data
+    restart: unless-stopped
+
+  # Optional: Redis for token storage
+  # redis:
+  #   image: redis:7-alpine
+  #   restart: unless-stopped
+```
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://gitea.gt-proj.com/brian/baby-monitor.git
+cd baby-monitor
+
+# Install dependencies with uv
+uv sync --all-extras
+
+# Set environment variables
+export ENVIRONMENT=development
+export ADMIN_PASSWORD=password
+export DATA_DIR=./data
+
+# Run the application
+uv run uvicorn src.baby_monitor.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+| Variable         | Default      | Description                                 |
+| ---------------- | ------------ | ------------------------------------------- |
+| `ENVIRONMENT`    | `production` | Set to `development` to enable API docs     |
+| `ADMIN_PASSWORD` | _(required)_ | Admin user password                         |
+| `ADMIN_USERNAME` | `admin`      | Admin username                              |
+| `DATA_DIR`       | `/data`      | Directory for SQLite database               |
+| `REDIS_URI`      | _(optional)_ | Redis connection URI for distributed tokens |
+
+### Storage Options
+
+**SQLite (Default)**
+
+- Automatic setup, no configuration needed
+- Data stored in `/data/baby_monitor.db`
+- Perfect for single-server deployments
+
+**Redis (Optional)**
+
+```bash
+# Enable Redis token storage
+export REDIS_URI=redis://localhost:6379
+```
+
+**PostgreSQL (Future)**
+
+- Repository interface ready
+- Swap implementation in `dependencies.py`
+
+## 📁 Project Structure
+
+```
+baby-monitor/
+├── src/baby_monitor/
+│   ├── main.py                     # FastAPI application
+│   ├── models/                     # Pydantic models
+│   ├── routers/                    # API endpoints
+│   │   ├── auth.py                # Authentication routes
+│   │   └── health.py              # Health check routes
+│   ├── repositories/               # Data access layer
+│   │   ├── interfaces.py          # Abstract interfaces
+│   │   ├── user/                  # User repositories
+│   │   ├── token/                 # Token storage
+│   │   └── credentials/           # Credentials management
+│   └── static/                    # Frontend files
+├── tests/                         # Test suite
+│   ├── integration/               # Integration tests
+│   └── unit/                      # Unit tests
+├── Dockerfile                     # Production container
+├── docker-compose.yml             # Local development
+└── pyproject.toml                 # Project dependencies
+```
+
+## 🏗️ Architecture
+
+### Repository Pattern
+
+The application uses the **Repository Pattern** for data access, allowing easy swapping of backends:
+
+```python
+# Switch from SQLite to PostgreSQL
+from baby_monitor.repositories.user.postgresql_user import PostgreSQLUserRepository
+return PostgreSQLUserRepository(db)
+
+# Switch from in-memory to Redis tokens
+# Just set REDIS_URI environment variable
+```
+
+### Technology Stack
+
+- **Backend**: FastAPI + SQLAlchemy 2.0
+- **Database**: SQLite (default) / PostgreSQL (ready)
+- **Cache**: In-memory (default) / Redis (optional)
+- **Package Manager**: uv
+- **Container**: Docker with multi-stage builds
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+uv run pytest
+
+# Run with coverage
+uv run pytest --cov-report=term-missing --cov=src/baby_monitor
+
+# Run specific test types
+uv run pytest tests/unit/
+uv run pytest tests/integration/
+```
+
+## 🔒 Security
+
+- ✅ Token-based authentication
+- ✅ Environment-based secrets (no hardcoded credentials)
+- ✅ API docs disabled in production
+- ✅ CORS configuration ready
+- ⚠️ **TODO**: Add password hashing (currently plain text comparison)
+- ⚠️ **TODO**: Implement rate limiting
+
+## 🚀 Deployment
+
+### Unraid
+
+1. Add the repository to Community Applications
+2. Configure environment variables
+3. Map `/data` volume for persistence
+4. Set admin password
+
+### Docker Swarm / Kubernetes
+
+The application is stateless when using Redis for tokens, making it suitable for:
+
+- Multi-replica deployments
+- Load balancing
+- Rolling updates
+
+### CI/CD
+
+Gitea Actions workflow included:
+
+- Builds multi-architecture images (amd64, arm64)
+- Automatic semantic versioning
+- Pushes to container registry
+- Health checks and metadata
+
+## 📊 API Documentation
+
+When running in development mode (`ENVIRONMENT=development`):
+
+- **OpenAPI Docs**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+- **OpenAPI JSON**: http://localhost:8000/openapi.json
+
+### Key Endpoints
+
+| Endpoint      | Method | Description            |
+| ------------- | ------ | ---------------------- |
+| `/`           | GET    | Serve home page        |
+| `/api/`       | GET    | Authenticated API root |
+| `/api/login`  | POST   | User authentication    |
+| `/api/logout` | POST   | Invalidate token       |
+| `/health`     | GET    | Health check           |
+| `/ready`      | GET    | Readiness probe        |
+| `/info`       | GET    | Feature detection      |
+
+## 🤝 Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+### Development Guidelines
+
+- Write tests for new features
+- Follow PEP 8 style guide
+- Add type hints to all functions
+- Keep line length ≤ 79 characters
+- Run `mypy` and `ruff` before committing
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- Built with [FastAPI](https://fastapi.tiangolo.com/)
+- Package management by [uv](https://github.com/astral-sh/uv)
+- Containerization with [Docker](https://www.docker.com/)
+
+## 📧 Contact
+
+Brian Bjarke Jensen - [@brian](https://gitea.gt-proj.com/brian)
+
+Project Link: [https://gitea.gt-proj.com/brian/baby-monitor](https://gitea.gt-proj.com/brian/baby-monitor)
+
+---
+
+Made with ❤️ for new parents everywhere

docker-compose.prod.yml

@@ -0,0 +1,60 @@
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    volumes:
+      # Persist database to local directory
+      - ./data:/data
+    environment:
+      # Set environment to production
+      - ENVIRONMENT=production
+      # Set admin credentials
+      - ADMIN_USERNAME=admin
+      - ADMIN_PASSWORD=password
+      # Use Redis for token storage
+      - REDIS_URI=redis://redis:6379/0
+      # Use PostgreSQL for database
+      - DATABASE_URL=postgresql://baby_monitor:securepassword@postgres:5432/b
+    command: ["--host", "0.0.0.0", "--port", "8000"]
+    restart: unless-stopped
+    depends_on:
+      redis:
+        condition: service_healthy
+      postgres:
+        condition: service_healthy
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 1s
+  postgres:
+    image: postgres:14-alpine
+    environment:
+      - POSTGRES_USER=baby_monitor
+      - POSTGRES_PASSWORD=securepassword
+      - POSTGRES_DB=baby_monitor_db
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U baby_monitor -d baby_monitor_db"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
+volumes:
+  redis-data:
+  pgdata:

docker-compose.yml

@@ -11,23 +11,10 @@ services:
       # Persist database to local directory
       - ./data:/data
     environment:
+      # Set environment to development for hot-reloading and debug features
       - ENVIRONMENT=development
       # Optional: Override admin credentials for development
-      # - ADMIN_USERNAME=admin
-      # - ADMIN_PASSWORD=devpassword
-      # Optional: Use Redis for token storage (uncomment redis service below)
-      # - REDIS_URI=redis://redis:6379/0
+      - ADMIN_USERNAME=admin
+      - ADMIN_PASSWORD=password
     command: ["--host", "0.0.0.0", "--port", "8000", "--reload"]
     restart: unless-stopped
-
-  # Uncomment to enable Redis token storage
-  # redis:
-  #   image: redis:7-alpine
-  #   ports:
-  #     - "6379:6379"
-  #   volumes:
-  #     - redis-data:/data
-  #   restart: unless-stopped
-# Uncomment if using Redis
-# volumes:
-#   redis-data:

pyproject.toml

@@ -5,6 +5,7 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "bcrypt>=4.0.0",
     "fastapi>=0.121.0",
     "sqlalchemy>=2.0.0",
     "uvicorn>=0.38.0",
@@ -30,6 +31,7 @@ dev = [
     "httpx>=0.28.1",
     "mypy>=1.18.2",
     "pre-commit>=4.3.0",
+    "prettier>=0.0.7",
     "pytest>=8.4.2",
     "pytest-cov>=7.0.0",
     "pyupgrade>=3.21.0",

src/baby_monitor/main.py

@@ -11,6 +11,9 @@ from fastapi.staticfiles import StaticFiles
 
 from baby_monitor.routers.auth import router as auth_router
 from baby_monitor.routers.auth import verify_token
+from baby_monitor.routers.admin import router as admin_router
+from baby_monitor.routers.child import router as child_router
+from baby_monitor.routers.feeding import router as feeding_router
 from baby_monitor.routers.health import router as health_router
 from baby_monitor.repositories.dependencies.get_database import init_db
 
@@ -45,15 +48,55 @@ app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
 
 # Include routers
 app.include_router(auth_router)
+app.include_router(admin_router)
+app.include_router(child_router)
+app.include_router(feeding_router)
 app.include_router(health_router)
 
 
+# Serve HTML pages at root level
 @app.get("/", include_in_schema=False)
 def serve_home() -> FileResponse:
     """Serve the home page (handles auth check client-side)."""
     return FileResponse(static_path / "index.html")
 
 
+@app.get("/login.html", include_in_schema=False)
+def serve_login() -> FileResponse:
+    """Serve the login page."""
+    return FileResponse(static_path / "login.html")
+
+
+@app.get("/register.html", include_in_schema=False)
+def serve_register() -> FileResponse:
+    """Serve the registration page."""
+    return FileResponse(static_path / "register.html")
+
+
+@app.get("/admin.html", include_in_schema=False)
+def serve_admin() -> FileResponse:
+    """Serve the admin page."""
+    return FileResponse(static_path / "admin.html")
+
+
+@app.get("/add-child.html", include_in_schema=False)
+def serve_add_child() -> FileResponse:
+    """Serve the add child page."""
+    return FileResponse(static_path / "add-child.html")
+
+
+@app.get("/log-feeding.html", include_in_schema=False)
+def serve_log_feeding() -> FileResponse:
+    """Serve the log feeding page."""
+    return FileResponse(static_path / "log-feeding.html")
+
+
+@app.get("/feedings.html", include_in_schema=False)
+def serve_feedings() -> FileResponse:
+    """Serve the feedings overview page."""
+    return FileResponse(static_path / "feedings.html")
+
+
 @app.get("/api/")
 def read_root(token: Annotated[str, Depends(verify_token)]) -> dict:
     """API root endpoint (requires authentication)."""

src/baby_monitor/models/auth.py

@@ -16,4 +16,23 @@ class LoginResponse(BaseModel):
     message: str
     username: str
     access_token: str
+    is_admin: bool
+    token_type: str = "bearer"
+
+
+class RegisterRequest(BaseModel):
+    """Request model for user registration."""
+
+    username: str
+    password: str
+    invitation_token: str
+
+
+class RegisterResponse(BaseModel):
+    """Response model for successful registration."""
+
+    message: str
+    username: str
+    access_token: str
+    is_admin: bool
     token_type: str = "bearer"

src/baby_monitor/models/child.py

@@ -0,0 +1,23 @@
+"""Child-related request and response models."""
+
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class CreateChildRequest(BaseModel):
+    """Request model for creating a child."""
+
+    name: str = Field(..., min_length=1, max_length=100)
+    birth_time: datetime
+    birth_weight: float = Field(..., gt=0, description="Birth weight in grams")
+
+
+class ChildResponse(BaseModel):
+    """Response model for child data."""
+
+    id: int
+    name: str
+    birth_time: datetime
+    birth_weight: float
+    user_id: int
+    created_at: datetime

src/baby_monitor/models/db/child.py

@@ -0,0 +1,28 @@
+"""Child database model."""
+
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, Integer, String, DateTime, Float, ForeignKey
+from datetime import datetime
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
+    Base = DeclarativeBase
+else:
+    from baby_monitor.repositories.dependencies.get_database import Base
+
+
+class Child(Base):
+    """Child database model."""
+
+    __tablename__ = "children"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=False)
+    birth_time = Column(DateTime, nullable=False)
+    birth_weight = Column(Float, nullable=False)  # in grams
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<Child(id={self.id}, name='{self.name}', user_id={self.user_id})>"

src/baby_monitor/models/db/feeding.py

@@ -0,0 +1,28 @@
+"""Feeding database model."""
+
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, Integer, DateTime, ForeignKey, String
+from datetime import datetime, UTC
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
+    Base = DeclarativeBase
+else:
+    from baby_monitor.repositories.dependencies.get_database import Base
+
+
+class Feeding(Base):
+    """Feeding log database model."""
+
+    __tablename__ = "feedings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
+    start_time = Column(DateTime, nullable=False)
+    end_time = Column(DateTime, nullable=True)
+    feeding_type = Column(String, nullable=False)  # stores FeedingType enum
+    created_at = Column(DateTime, default=datetime.now(UTC), nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<Feeding(id={self.id}, child_id={self.child_id})>"

src/baby_monitor/models/db/user.py

@@ -1,9 +1,15 @@
 """Database models."""
 
-from sqlalchemy import Column, Integer, String, DateTime
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, Integer, String, DateTime, Boolean
 from datetime import datetime
 
-from baby_monitor.repositories.dependencies.get_database import Base
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
+    Base = DeclarativeBase
+else:
+    from baby_monitor.repositories.dependencies.get_database import Base
 
 
 class User(Base):
@@ -14,6 +20,7 @@ class User(Base):
     id = Column(Integer, primary_key=True, index=True)
     username = Column(String, unique=True, index=True, nullable=False)
     hashed_password = Column(String, nullable=False)
+    is_admin = Column(Boolean, default=False, nullable=False)
     created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
 
     def __repr__(self) -> str:

src/baby_monitor/models/enums.py

@@ -0,0 +1,11 @@
+"""Feeding type enumeration."""
+
+from enum import StrEnum
+
+
+class FeedingType(StrEnum):
+    """Enumeration of feeding types."""
+
+    LEFT_BREAST = "left_breast"
+    RIGHT_BREAST = "right_breast"
+    BOTTLE = "bottle"

src/baby_monitor/models/feeding.py

@@ -0,0 +1,35 @@
+"""Feeding-related request and response models."""
+
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from baby_monitor.models.enums import FeedingType
+
+
+class CreateFeedingRequest(BaseModel):
+    """Request model for creating a feeding log."""
+
+    child_id: int = Field(..., gt=0)
+    start_time: datetime
+    end_time: datetime | None = None
+    feeding_type: FeedingType
+
+
+class UpdateFeedingRequest(BaseModel):
+    """Request model for updating a feeding log."""
+
+    start_time: datetime | None = None
+    end_time: datetime | None = None
+    feeding_type: FeedingType | None = None
+
+
+class FeedingResponse(BaseModel):
+    """Response model for feeding log data."""
+
+    id: int
+    child_id: int
+    start_time: datetime
+    end_time: datetime | None
+    feeding_type: str
+    created_at: datetime
+    child_name: str | None = None  # Optional, populated when needed

src/baby_monitor/models/invitation.py

@@ -0,0 +1,37 @@
+"""Invitation token model for user registration.
+
+Note: DateTime(timezone=True) is used for PostgreSQL compatibility.
+SQLite will store as naive UTC, which is handled in the repository layer.
+"""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+from sqlalchemy import Boolean, DateTime, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
+    Base = DeclarativeBase
+else:
+    from baby_monitor.repositories.dependencies.get_database import Base
+
+
+class Invitation(Base):
+    """Invitation token for new user registration."""
+
+    __tablename__ = "invitations"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    token: Mapped[str] = mapped_column(String, unique=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False
+    )
+    expires_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False
+    )
+    created_by_user_id: Mapped[int] = mapped_column(Integer, nullable=False)
+    is_consumed: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    consumed_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )

src/baby_monitor/repositories/child/sqlite_child.py

@@ -0,0 +1,111 @@
+"""SQLite implementation of child repository."""
+
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.interfaces.child_repository_interface import (
+    ChildRepositoryInterface,
+)
+from baby_monitor.models.db.child import Child
+
+
+class SQLiteChildRepository(ChildRepositoryInterface):
+    """SQLite implementation for child data access."""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create(
+        self, name: str, birth_time: datetime, birth_weight: float, user_id: int
+    ) -> dict:
+        """Create a new child record."""
+        child = Child(
+            name=name,
+            birth_time=birth_time,
+            birth_weight=birth_weight,
+            user_id=user_id,
+        )
+        self.db.add(child)
+        self.db.commit()
+        self.db.refresh(child)
+
+        return {
+            "id": child.id,
+            "name": child.name,
+            "birth_time": child.birth_time,
+            "birth_weight": child.birth_weight,
+            "user_id": child.user_id,
+            "created_at": child.created_at,
+        }
+
+    def get_by_id(self, child_id: int) -> dict | None:
+        """Get a child by ID."""
+        child = self.db.query(Child).filter(Child.id == child_id).first()
+        if not child:
+            return None
+
+        return {
+            "id": child.id,
+            "name": child.name,
+            "birth_time": child.birth_time,
+            "birth_weight": child.birth_weight,
+            "user_id": child.user_id,
+            "created_at": child.created_at,
+        }
+
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all children for a specific user."""
+        children = self.db.query(Child).filter(Child.user_id == user_id).all()
+
+        return [
+            {
+                "id": child.id,
+                "name": child.name,
+                "birth_time": child.birth_time,
+                "birth_weight": child.birth_weight,
+                "user_id": child.user_id,
+                "created_at": child.created_at,
+            }
+            for child in children
+        ]
+
+    def update(
+        self,
+        child_id: int,
+        name: str | None = None,
+        birth_time: datetime | None = None,
+        birth_weight: float | None = None,
+    ) -> dict | None:
+        """Update a child record."""
+        child = self.db.query(Child).filter(Child.id == child_id).first()
+        if not child:
+            return None
+
+        if name is not None:
+            child.name = name  # type: ignore[assignment]
+        if birth_time is not None:
+            child.birth_time = birth_time  # type: ignore[assignment]
+        if birth_weight is not None:
+            child.birth_weight = birth_weight  # type: ignore[assignment]
+
+        self.db.commit()
+        self.db.refresh(child)
+
+        return {
+            "id": child.id,
+            "name": child.name,
+            "birth_time": child.birth_time,
+            "birth_weight": child.birth_weight,
+            "user_id": child.user_id,
+            "created_at": child.created_at,
+        }
+
+    def delete(self, child_id: int) -> bool:
+        """Delete a child record."""
+        child = self.db.query(Child).filter(Child.id == child_id).first()
+        if not child:
+            return False
+
+        self.db.delete(child)
+        self.db.commit()
+        return True

src/baby_monitor/repositories/dependencies/get_child_repository.py

@@ -0,0 +1,15 @@
+"""Dependency for getting child repository instance."""
+
+from typing import Annotated
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.dependencies.get_database import get_database
+from baby_monitor.repositories.child.sqlite_child import SQLiteChildRepository
+
+
+def get_child_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> SQLiteChildRepository:
+    """Get child repository instance."""
+    return SQLiteChildRepository(db)

src/baby_monitor/repositories/dependencies/get_database.py

@@ -3,9 +3,13 @@
 import os
 from pathlib import Path
 from collections.abc import Generator
+from typing import TYPE_CHECKING
 from sqlalchemy import create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker, Session
 
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
 # Database directory
 DATA_DIR = Path(os.getenv("DATA_DIR", "/data"))
 
@@ -23,15 +27,67 @@ engine = create_engine(
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 # Base class for declarative models
-Base = declarative_base()
+Base: "type[DeclarativeBase]" = declarative_base()
+
+
+def _ensure_admin_user() -> None:
+    """Create or update admin user from environment variables."""
+    from baby_monitor.models.db.user import User
+    from baby_monitor.utils.password import hash_password
+
+    admin_username = os.getenv("ADMIN_USERNAME")
+    admin_password = os.getenv("ADMIN_PASSWORD")
+
+    if not admin_username:
+        raise RuntimeError(
+            "ADMIN_USERNAME environment variable is required but not set"
+        )
+    if not admin_password:
+        raise RuntimeError(
+            "ADMIN_PASSWORD environment variable is required but not set"
+        )
+
+    db = SessionLocal()
+    try:
+        # Check if admin user exists
+        admin_user = db.query(User).filter(User.username == admin_username).first()
+
+        hashed_pw = hash_password(admin_password)
+
+        if admin_user:
+            # Update existing admin user's password and ensure admin flag
+            admin_user.hashed_password = hashed_pw  # type: ignore[assignment]
+            admin_user.is_admin = True  # type: ignore[assignment]
+            db.commit()
+        else:
+            # Create new admin user
+            new_admin = User(
+                username=admin_username,
+                hashed_password=hashed_pw,
+                is_admin=True,
+            )
+            db.add(new_admin)
+            db.commit()
+    finally:
+        db.close()
 
 
 def init_db() -> None:
     """Initialize the database by creating all tables."""
+    # Import models to register them with Base.metadata
+    # This must be done before create_all() is called
+    from baby_monitor.models.db.user import User  # noqa: F401
+    from baby_monitor.models.db.child import Child  # noqa: F401
+    from baby_monitor.models.db.feeding import Feeding  # noqa: F401
+    from baby_monitor.models.invitation import Invitation  # noqa: F401
+
     # Ensure data directory exists
     DATA_DIR.mkdir(parents=True, exist_ok=True)
     Base.metadata.create_all(bind=engine)
 
+    # Create admin user if it doesn't exist
+    _ensure_admin_user()
+
 
 def get_database() -> Generator[Session, None, None]:
     """

src/baby_monitor/repositories/dependencies/get_feeding_repository.py

@@ -0,0 +1,17 @@
+"""Dependency for getting feeding repository instance."""
+
+from typing import Annotated
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.dependencies.get_database import get_database
+from baby_monitor.repositories.feeding.sqlite_feeding import (
+    SQLiteFeedingRepository,
+)
+
+
+def get_feeding_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> SQLiteFeedingRepository:
+    """Get feeding repository instance."""
+    return SQLiteFeedingRepository(db)

src/baby_monitor/repositories/dependencies/get_invitation_repository.py

@@ -0,0 +1,25 @@
+"""Dependency injection for invitation repository."""
+
+from typing import Annotated
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.dependencies.get_database import get_database
+from baby_monitor.repositories.invitation.sqlite_invitation import (
+    SQLiteInvitationRepository,
+)
+
+
+def get_invitation_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> SQLiteInvitationRepository:
+    """
+    Provide an invitation repository instance.
+
+    Args:
+        db: Database session from dependency injection
+
+    Returns:
+        SQLiteInvitationRepository instance
+    """
+    return SQLiteInvitationRepository(db)

src/baby_monitor/repositories/feeding/sqlite_feeding.py

@@ -0,0 +1,109 @@
+"""SQLite implementation of feeding repository."""
+
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.interfaces.feeding_repository_interface import (
+    FeedingRepositoryInterface,
+)
+from baby_monitor.models.db.feeding import Feeding
+from baby_monitor.models.db.child import Child
+
+
+class SQLiteFeedingRepository(FeedingRepositoryInterface):
+    """SQLite implementation for feeding log data access."""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create(
+        self,
+        child_id: int,
+        start_time: datetime,
+        feeding_type: str,
+        end_time: datetime | None = None,
+    ) -> dict:
+        """Create a new feeding log entry."""
+        feeding = Feeding(
+            child_id=child_id,
+            start_time=start_time,
+            end_time=end_time,
+            feeding_type=feeding_type,
+        )
+        self.db.add(feeding)
+        self.db.commit()
+        self.db.refresh(feeding)
+
+        return self._to_dict(feeding)
+
+    def get_by_id(self, feeding_id: int) -> dict | None:
+        """Get a feeding log by ID."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return None
+        return self._to_dict(feeding)
+
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all feeding logs for a specific child."""
+        feedings = (
+            self.db.query(Feeding)
+            .filter(Feeding.child_id == child_id)
+            .order_by(Feeding.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(feeding) for feeding in feedings]
+
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all feeding logs for a specific user's children."""
+        feedings = (
+            self.db.query(Feeding)
+            .join(Child)
+            .filter(Child.user_id == user_id)
+            .order_by(Feeding.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(feeding) for feeding in feedings]
+
+    def update(
+        self,
+        feeding_id: int,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        feeding_type: str | None = None,
+    ) -> dict | None:
+        """Update a feeding log entry."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return None
+
+        if start_time is not None:
+            feeding.start_time = start_time  # type: ignore[assignment]
+        if end_time is not None:
+            feeding.end_time = end_time  # type: ignore[assignment]
+        if feeding_type is not None:
+            feeding.feeding_type = feeding_type  # type: ignore[assignment]
+
+        self.db.commit()
+        self.db.refresh(feeding)
+        return self._to_dict(feeding)
+
+    def delete(self, feeding_id: int) -> bool:
+        """Delete a feeding log entry."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return False
+
+        self.db.delete(feeding)
+        self.db.commit()
+        return True
+
+    def _to_dict(self, feeding: Feeding) -> dict:
+        """Convert Feeding model to dictionary."""
+        return {
+            "id": feeding.id,
+            "child_id": feeding.child_id,
+            "start_time": feeding.start_time,
+            "end_time": feeding.end_time,
+            "feeding_type": feeding.feeding_type,
+            "created_at": feeding.created_at,
+        }

src/baby_monitor/repositories/interfaces/__init__.py

@@ -3,6 +3,9 @@
 from .credentials_repository_interface import (
     CredentialsRepositoryInterface,
 )
+from .invitation_repository_interface import (
+    InvitationRepositoryInterface,
+)
 from .token_repository_interface import (
     TokenRepositoryInterface,
 )
@@ -14,4 +17,5 @@ __all__ = [
     "UserRepositoryInterface",
     "TokenRepositoryInterface",
     "CredentialsRepositoryInterface",
+    "InvitationRepositoryInterface",
 ]

src/baby_monitor/repositories/interfaces/child_repository_interface.py

@@ -0,0 +1,36 @@
+"""Interface for child repository operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class ChildRepositoryInterface(ABC):
+    """Interface for child data access operations."""
+
+    @abstractmethod
+    def create(
+        self, name: str, birth_time: datetime, birth_weight: float, user_id: int
+    ) -> dict:
+        """Create a new child record."""
+
+    @abstractmethod
+    def get_by_id(self, child_id: int) -> dict | None:
+        """Get a child by ID."""
+
+    @abstractmethod
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all children for a specific user."""
+
+    @abstractmethod
+    def update(
+        self,
+        child_id: int,
+        name: str | None = None,
+        birth_time: datetime | None = None,
+        birth_weight: float | None = None,
+    ) -> dict | None:
+        """Update a child record."""
+
+    @abstractmethod
+    def delete(self, child_id: int) -> bool:
+        """Delete a child record."""

src/baby_monitor/repositories/interfaces/feeding_repository_interface.py

@@ -0,0 +1,44 @@
+"""Interface for feeding repository operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class FeedingRepositoryInterface(ABC):
+    """Interface for feeding log data access operations."""
+
+    @abstractmethod
+    def create(
+        self,
+        child_id: int,
+        start_time: datetime,
+        feeding_type: str,
+        end_time: datetime | None = None,
+    ) -> dict:
+        """Create a new feeding log entry."""
+
+    @abstractmethod
+    def get_by_id(self, feeding_id: int) -> dict | None:
+        """Get a feeding log by ID."""
+
+    @abstractmethod
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all feeding logs for a specific child."""
+
+    @abstractmethod
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all feeding logs for a specific user's children."""
+
+    @abstractmethod
+    def update(
+        self,
+        feeding_id: int,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        feeding_type: str | None = None,
+    ) -> dict | None:
+        """Update a feeding log entry."""
+
+    @abstractmethod
+    def delete(self, feeding_id: int) -> bool:
+        """Delete a feeding log entry."""

src/baby_monitor/repositories/interfaces/invitation_repository_interface.py

@@ -0,0 +1,49 @@
+"""Interface for invitation repository operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class InvitationRepositoryInterface(ABC):
+    """Interface for managing invitation tokens."""
+
+    @abstractmethod
+    def create_invitation(
+        self, token: str, created_by_user_id: int, expires_at: datetime
+    ) -> None:
+        """
+        Create a new invitation token.
+
+        Args:
+            token: The invitation token string
+            created_by_user_id: ID of the user creating the invitation
+            expires_at: Expiration datetime for the invitation
+        """
+
+    @abstractmethod
+    def verify_invitation(self, token: str) -> bool:
+        """
+        Verify if an invitation token is valid and not consumed.
+
+        Args:
+            token: The invitation token to verify
+
+        Returns:
+            True if valid and not consumed, False otherwise
+        """
+
+    @abstractmethod
+    def consume_invitation(self, token: str) -> bool:
+        """
+        Mark an invitation token as consumed.
+
+        Args:
+            token: The invitation token to consume
+
+        Returns:
+            True if successfully consumed, False if invalid or already used
+        """
+
+    @abstractmethod
+    def cleanup_expired(self) -> None:
+        """Remove expired invitation tokens from storage."""

src/baby_monitor/repositories/invitation/__init__.py

@@ -0,0 +1,7 @@
+"""Invitation repository implementations."""
+
+from baby_monitor.repositories.invitation.sqlite_invitation import (
+    SQLiteInvitationRepository,
+)
+
+__all__ = ["SQLiteInvitationRepository"]

src/baby_monitor/repositories/invitation/sqlite_invitation.py

@@ -0,0 +1,112 @@
+"""SQLite implementation of invitation repository.
+
+Note: SQLite does not support timezone-aware datetimes natively.
+All datetimes are stored as naive UTC and converted at the application layer.
+"""
+
+from datetime import datetime, UTC
+from sqlalchemy.orm import Session
+
+from baby_monitor.models.invitation import Invitation
+from baby_monitor.repositories.interfaces.invitation_repository_interface import (
+    InvitationRepositoryInterface,
+)
+
+
+class SQLiteInvitationRepository(InvitationRepositoryInterface):
+    """SQLite implementation for managing invitation tokens."""
+
+    def __init__(self, db: Session) -> None:
+        """Initialize the repository with a database session."""
+        self.db = db
+
+    def create_invitation(
+        self, token: str, created_by_user_id: int, expires_at: datetime
+    ) -> None:
+        """
+        Create a new invitation token.
+
+        Args:
+            token: The invitation token string
+            created_by_user_id: ID of the user creating the invitation
+            expires_at: Expiration datetime for the invitation
+        """
+        # Convert timezone-aware datetimes to naive UTC for SQLite
+        created_at_utc = datetime.now(UTC).replace(tzinfo=None)
+        expires_at_utc = (
+            expires_at.replace(tzinfo=None) if expires_at.tzinfo else expires_at
+        )
+
+        invitation = Invitation(
+            token=token,
+            created_at=created_at_utc,
+            expires_at=expires_at_utc,
+            created_by_user_id=created_by_user_id,
+            is_consumed=False,
+            consumed_at=None,
+        )
+        self.db.add(invitation)
+        self.db.commit()
+
+    def verify_invitation(self, token: str) -> bool:
+        """
+        Verify if an invitation token is valid and not consumed.
+
+        Args:
+            token: The invitation token to verify
+
+        Returns:
+            True if valid and not consumed, False otherwise
+        """
+        invitation = self.db.query(Invitation).filter(Invitation.token == token).first()
+
+        if not invitation:
+            return False
+
+        # Compare as naive UTC datetimes (SQLite stores without timezone)
+        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        if invitation.expires_at < now_utc:
+            return False
+
+        # Check if already consumed
+        if invitation.is_consumed:
+            return False
+
+        return True
+
+    def consume_invitation(self, token: str) -> bool:
+        """
+        Mark an invitation token as consumed.
+
+        Args:
+            token: The invitation token to consume
+
+        Returns:
+            True if successfully consumed, False if invalid or already used
+        """
+        invitation = self.db.query(Invitation).filter(Invitation.token == token).first()
+
+        if not invitation:
+            return False
+
+        # Compare as naive UTC datetimes (SQLite stores without timezone)
+        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        if invitation.expires_at < now_utc:
+            return False
+
+        # Check if already consumed
+        if invitation.is_consumed:
+            return False
+
+        # Mark as consumed
+        invitation.is_consumed = True
+        invitation.consumed_at = now_utc
+        self.db.commit()
+
+        return True
+
+    def cleanup_expired(self) -> None:
+        """Remove expired invitation tokens from storage."""
+        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        self.db.query(Invitation).filter(Invitation.expires_at < now_utc).delete()
+        self.db.commit()

src/baby_monitor/repositories/token/memory_token.py

@@ -42,7 +42,7 @@ class InMemoryTokenRepository(TokenRepositoryInterface):
 
     def cleanup_expired(self) -> None:
         """Remove expired tokens."""
-        now = datetime.utcnow()
+        now = datetime.now(UTC)
         expired_tokens = [
             token for token, (_, expiry) in self._tokens.items() if now > expiry
         ]

src/baby_monitor/repositories/user/sqlite_user.py

@@ -20,13 +20,18 @@ class SQLiteUserRepository(UserRepositoryInterface):
                 "id": user.id,
                 "username": user.username,
                 "hashed_password": user.hashed_password,
+                "is_admin": user.is_admin,
                 "created_at": user.created_at,
             }
         return None
 
     def create(self, username: str, hashed_password: str) -> dict:
         """Create a new user."""
-        user = User(username=username, hashed_password=hashed_password)
+        user = User(
+            username=username,
+            hashed_password=hashed_password,
+            is_admin=False,
+        )
         self.db.add(user)
         self.db.commit()
         self.db.refresh(user)
@@ -34,6 +39,7 @@ class SQLiteUserRepository(UserRepositoryInterface):
             "id": user.id,
             "username": user.username,
             "hashed_password": user.hashed_password,
+            "is_admin": user.is_admin,
             "created_at": user.created_at,
         }
 
@@ -45,6 +51,7 @@ class SQLiteUserRepository(UserRepositoryInterface):
                 "id": user.id,
                 "username": user.username,
                 "hashed_password": user.hashed_password,
+                "is_admin": user.is_admin,
                 "created_at": user.created_at,
             }
         return None

src/baby_monitor/routers/admin.py

@@ -0,0 +1,66 @@
+"""Admin router for administrative functions."""
+
+import secrets
+from datetime import datetime, timedelta, UTC
+from typing import Annotated
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from baby_monitor.routers.auth import verify_admin
+from baby_monitor.repositories.dependencies.get_invitation_repository import (
+    get_invitation_repository,
+)
+from baby_monitor.repositories.interfaces import (
+    InvitationRepositoryInterface,
+)
+
+router = APIRouter(prefix="/api/admin", tags=["admin"])
+
+
+class InvitationResponse(BaseModel):
+    """Response model for invitation link generation."""
+
+    token: str
+    expires_at: str
+    message: str
+
+
+@router.post("/generate-invitation", response_model=InvitationResponse)
+async def generate_invitation_link(
+    user_id: Annotated[int, Depends(verify_admin)],
+    invitation_repository: Annotated[
+        InvitationRepositoryInterface,
+        Depends(get_invitation_repository),
+    ],
+) -> InvitationResponse:
+    """Generate a new invitation link for user registration.
+
+    The invitation token is valid for 24 hours and can be used once.
+    Requires admin role.
+
+    Args:
+        user_id: Admin user ID (from verify_admin)
+        invitation_repository: Invitation storage backend
+
+    Returns:
+        InvitationResponse with token and expiration details
+    """
+
+    # Generate secure random token
+    invitation_token = secrets.token_urlsafe(32)
+
+    # Calculate expiration (24 hours from now)
+    expires_at = datetime.now(UTC) + timedelta(hours=24)
+
+    # Store invitation token in database
+    invitation_repository.create_invitation(
+        token=invitation_token,
+        created_by_user_id=user_id,
+        expires_at=expires_at,
+    )
+
+    return InvitationResponse(
+        token=invitation_token,
+        expires_at=expires_at.isoformat(),
+        message="Invitation link generated successfully. Valid for 24 hours.",
+    )

src/baby_monitor/routers/auth.py

@@ -4,15 +4,25 @@ import secrets
 from fastapi import APIRouter, HTTPException, Depends, Header
 from typing import Annotated
 
-from baby_monitor.models.auth import LoginRequest, LoginResponse
+from baby_monitor.models.auth import (
+    LoginRequest,
+    LoginResponse,
+    RegisterRequest,
+    RegisterResponse,
+)
 from baby_monitor.repositories import (
     get_token_repository,
-    get_credentials_repository,
+    get_user_repository,
+)
+from baby_monitor.repositories.dependencies.get_invitation_repository import (
+    get_invitation_repository,
 )
 from baby_monitor.repositories.interfaces import (
     TokenRepositoryInterface,
-    CredentialsRepositoryInterface,
+    UserRepositoryInterface,
+    InvitationRepositoryInterface,
 )
+from baby_monitor.utils.password import hash_password, verify_password
 
 router = APIRouter(prefix="/api", tags=["authentication"])
 
@@ -39,11 +49,27 @@ def verify_token(
     return user_id
 
 
+def verify_admin(
+    user_id: Annotated[int, Depends(verify_token)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
+) -> int:
+    """Verify the user is an admin and return user_id."""
+    user = user_repo.get_by_id(user_id)
+
+    if not user:
+        raise HTTPException(status_code=401, detail="User not found")
+
+    if not user.get("is_admin", False):
+        raise HTTPException(status_code=403, detail="Admin access required")
+
+    return user_id
+
+
 @router.post("/login", response_model=LoginResponse)
 def login(
     credentials: LoginRequest,
-    token_repo: TokenRepositoryInterface = Depends(get_token_repository),
-    creds_repo: CredentialsRepositoryInterface = Depends(get_credentials_repository),
+    token_repo: Annotated[TokenRepositoryInterface, Depends(get_token_repository)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
 ) -> LoginResponse:
     """
     API endpoint for user authentication.
@@ -51,21 +77,26 @@ def login(
     Returns user info and access token on successful login.
     Raises 401 on invalid credentials.
     """
-    # Verify credentials using repository
-    if creds_repo.verify_admin_credentials(credentials.username, credentials.password):
-        # Generate a secure random token
-        access_token = secrets.token_urlsafe(32)
-        # Store token with user_id (hardcoded 1 for now)
-        token_repo.store(access_token, user_id=1, ttl=3600)
-
-        return LoginResponse(
-            message="Login successful",
-            username=credentials.username,
-            access_token=access_token,
-        )
-    else:
+    # Check if user exists in database
+    user = user_repo.get_by_username(credentials.username)
+    if not user:
         raise HTTPException(status_code=401, detail="Invalid username or password")
 
+    # Verify password using bcrypt
+    if not verify_password(credentials.password, user["hashed_password"]):
+        raise HTTPException(status_code=401, detail="Invalid username or password")
+
+    # Generate a secure random token
+    access_token = secrets.token_urlsafe(32)
+    token_repo.store(access_token, user_id=user["id"], ttl=3600)
+
+    return LoginResponse(
+        message="Login successful",
+        username=credentials.username,
+        access_token=access_token,
+        is_admin=user.get("is_admin", False),
+    )
+
 
 @router.post("/logout")
 def logout(
@@ -76,3 +107,87 @@ def logout(
     # Note: We'd need to pass the token itself, not user_id
     # This is simplified - in production, extract token from verify_token
     return {"message": "Logged out successfully"}
+
+
+@router.get("/verify-invitation")
+def verify_invitation(
+    token: str,
+    invitation_repo: Annotated[
+        InvitationRepositoryInterface, Depends(get_invitation_repository)
+    ],
+) -> dict[str, bool]:
+    """Verify if an invitation token is valid."""
+    is_valid = invitation_repo.verify_invitation(token)
+    if not is_valid:
+        raise HTTPException(status_code=400, detail="Invalid or expired invitation")
+    return {"valid": True}
+
+
+@router.post("/register", response_model=RegisterResponse)
+def register(
+    request: RegisterRequest,
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
+    invitation_repo: Annotated[
+        InvitationRepositoryInterface, Depends(get_invitation_repository)
+    ],
+    token_repo: Annotated[TokenRepositoryInterface, Depends(get_token_repository)],
+) -> RegisterResponse:
+    """
+    Register a new user with an invitation token.
+
+    Verifies the invitation, creates the user, consumes the invitation,
+    and returns an authentication token.
+    """
+    # Verify invitation token
+    if not invitation_repo.verify_invitation(request.invitation_token):
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid or expired invitation token",
+        )
+
+    # Check if username already exists
+    existing_user = user_repo.get_by_username(request.username)
+    if existing_user:
+        raise HTTPException(
+            status_code=400,
+            detail="Username already exists",
+        )
+
+    # Create the new user with hashed password
+    hashed_pw = hash_password(request.password)
+    user = user_repo.create(
+        username=request.username,
+        hashed_password=hashed_pw,
+    )
+
+    # Consume the invitation token
+    invitation_repo.consume_invitation(request.invitation_token)
+
+    # Generate authentication token
+    access_token = secrets.token_urlsafe(32)
+    token_repo.store(access_token, user_id=user["id"], ttl=3600)
+
+    return RegisterResponse(
+        message="Registration successful",
+        username=user["username"],
+        access_token=access_token,
+        is_admin=user.get("is_admin", False),
+    )
+
+
+@router.get("/me")
+def get_current_user(
+    user_id: Annotated[int, Depends(verify_token)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
+) -> dict:
+    """Get current user info including admin status."""
+    user = user_repo.get_by_id(user_id)
+
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    return {
+        "id": user["id"],
+        "username": user["username"],
+        "is_admin": user.get("is_admin", False),
+    }

src/baby_monitor/routers/child.py

@@ -0,0 +1,90 @@
+"""Child management router."""
+
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends
+
+from baby_monitor.models.child import CreateChildRequest, ChildResponse
+from baby_monitor.routers.auth import verify_token
+from baby_monitor.repositories.child.sqlite_child import SQLiteChildRepository
+from baby_monitor.repositories.dependencies.get_child_repository import (
+    get_child_repository,
+)
+
+router = APIRouter(prefix="/api/children", tags=["children"])
+
+
+@router.post("", response_model=ChildResponse, status_code=201)
+def create_child(
+    request: CreateChildRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> ChildResponse:
+    """Create a new child for the authenticated user."""
+    child = child_repo.create(
+        name=request.name,
+        birth_time=request.birth_time,
+        birth_weight=request.birth_weight,
+        user_id=user_id,
+    )
+
+    return ChildResponse(**child)
+
+
+@router.get("", response_model=list[ChildResponse])
+def get_user_children(
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> list[ChildResponse]:
+    """Get all children for the authenticated user."""
+    children = child_repo.get_by_user_id(user_id)
+    return [ChildResponse(**child) for child in children]
+
+
+@router.get("/{child_id}", response_model=ChildResponse)
+def get_child(
+    child_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> ChildResponse:
+    """Get a specific child by ID."""
+    child = child_repo.get_by_id(child_id)
+
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    # Verify the child belongs to the authenticated user
+    if child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    return ChildResponse(**child)
+
+
+@router.put("/{child_id}", response_model=ChildResponse)
+def update_child(
+    child_id: int,
+    request: CreateChildRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> ChildResponse:
+    """Update a child's information."""
+    # First check if child exists and belongs to user
+    child = child_repo.get_by_id(child_id)
+
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    if child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Update the child
+    updated_child = child_repo.update(
+        child_id=child_id,
+        name=request.name,
+        birth_time=request.birth_time,
+        birth_weight=request.birth_weight,
+    )
+
+    if not updated_child:
+        raise HTTPException(status_code=500, detail="Update failed")
+
+    return ChildResponse(**updated_child)

src/baby_monitor/routers/feeding.py

@@ -0,0 +1,158 @@
+"""Feeding log management router."""
+
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends
+
+from baby_monitor.models.feeding import (
+    CreateFeedingRequest,
+    UpdateFeedingRequest,
+    FeedingResponse,
+)
+from baby_monitor.routers.auth import verify_token
+from baby_monitor.repositories.feeding.sqlite_feeding import (
+    SQLiteFeedingRepository,
+)
+from baby_monitor.repositories.dependencies.get_feeding_repository import (
+    get_feeding_repository,
+)
+from baby_monitor.repositories.child.sqlite_child import SQLiteChildRepository
+from baby_monitor.repositories.dependencies.get_child_repository import (
+    get_child_repository,
+)
+
+router = APIRouter(prefix="/api/feedings", tags=["feedings"])
+
+
+@router.post("", response_model=FeedingResponse, status_code=201)
+def create_feeding(
+    request: CreateFeedingRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Create a new feeding log entry."""
+    # Verify the child belongs to the authenticated user
+    child = child_repo.get_by_id(request.child_id)
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    if child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied to this child")
+
+    feeding = feeding_repo.create(
+        child_id=request.child_id,
+        start_time=request.start_time,
+        end_time=request.end_time,
+        feeding_type=request.feeding_type.value,
+    )
+
+    return FeedingResponse(**feeding)
+
+
+@router.get("/active", response_model=FeedingResponse | None)
+def get_active_feeding(
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse | None:
+    """Get the current active feeding (where end_time is null) for the user."""
+    feedings = feeding_repo.get_by_user_id(user_id)
+
+    # Find the first feeding with no end_time
+    for feeding in feedings:
+        if feeding["end_time"] is None:
+            # Get child info to include in response
+            child = child_repo.get_by_id(feeding["child_id"])
+            response_data = feeding.copy()
+            if child:
+                response_data["child_name"] = child["name"]
+            return FeedingResponse(**response_data)
+
+    return None
+
+
+@router.get("", response_model=list[FeedingResponse])
+def get_user_feedings(
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+) -> list[FeedingResponse]:
+    """Get all feeding logs for the authenticated user's children."""
+    feedings = feeding_repo.get_by_user_id(user_id)
+    return [FeedingResponse(**feeding) for feeding in feedings]
+
+
+@router.get("/{feeding_id}", response_model=FeedingResponse)
+def get_feeding(
+    feeding_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Get a specific feeding log by ID."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify the feeding belongs to user's child
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    return FeedingResponse(**feeding)
+
+
+@router.put("/{feeding_id}", response_model=FeedingResponse)
+def update_feeding(
+    feeding_id: int,
+    request: UpdateFeedingRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Update a feeding log entry."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify ownership
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Update the feeding
+    updated_feeding = feeding_repo.update(
+        feeding_id=feeding_id,
+        start_time=request.start_time,
+        end_time=request.end_time,
+        feeding_type=request.feeding_type.value if request.feeding_type else None,
+    )
+
+    if not updated_feeding:
+        raise HTTPException(status_code=500, detail="Update failed")
+
+    return FeedingResponse(**updated_feeding)
+
+
+@router.delete("/{feeding_id}", status_code=204)
+def delete_feeding(
+    feeding_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> None:
+    """Delete a feeding log entry."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify ownership
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    success = feeding_repo.delete(feeding_id)
+    if not success:
+        raise HTTPException(status_code=500, detail="Delete failed")

src/baby_monitor/static/add-child.html

@@ -0,0 +1,322 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Add Child - Baby Monitor</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 20px;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+        max-width: 500px;
+        width: 100%;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+      }
+
+      .form-group {
+        margin-bottom: 20px;
+      }
+
+      label {
+        display: block;
+        margin-bottom: 8px;
+        color: #333;
+        font-weight: 600;
+        font-size: 14px;
+      }
+
+      input {
+        width: 100%;
+        padding: 12px;
+        border: 1px solid #ddd;
+        border-radius: 6px;
+        font-size: 14px;
+        transition: border-color 0.2s;
+      }
+
+      input:focus {
+        outline: none;
+        border-color: #667eea;
+      }
+
+      .button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+        width: 100%;
+        margin-top: 10px;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:active {
+        transform: translateY(0);
+      }
+
+      .button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .button.secondary {
+        background: #6c757d;
+        margin-top: 10px;
+      }
+
+      .button.secondary:hover {
+        box-shadow: 0 4px 12px rgba(108, 117, 125, 0.4);
+      }
+
+      .message {
+        padding: 12px;
+        border-radius: 6px;
+        margin-bottom: 20px;
+        display: none;
+      }
+
+      .message.show {
+        display: block;
+      }
+
+      .message.error {
+        background: #ffebee;
+        border-left: 4px solid #f44336;
+        color: #c62828;
+      }
+
+      .message.success {
+        background: #e8f5e9;
+        border-left: 4px solid #4caf50;
+        color: #2e7d32;
+      }
+
+      .help-text {
+        font-size: 12px;
+        color: #666;
+        margin-top: 4px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>👶 Add Child</h1>
+      <p class="subtitle">Enter your child's information</p>
+
+      <div id="message" class="message"></div>
+
+      <form id="addChildForm">
+        <div class="form-group">
+          <label for="name">Child's Name *</label>
+          <input
+            type="text"
+            id="name"
+            name="name"
+            required
+            placeholder="Enter child's name"
+            maxlength="100"
+          />
+        </div>
+
+        <div class="form-group">
+          <label for="birthTime">Date and Time of Birth *</label>
+          <input
+            type="datetime-local"
+            id="birthTime"
+            name="birthTime"
+            required
+          />
+          <p class="help-text">
+            Select the date and time when your child was born
+          </p>
+        </div>
+
+        <div class="form-group">
+          <label for="birthWeight">Birth Weight (grams) *</label>
+          <input
+            type="number"
+            id="birthWeight"
+            name="birthWeight"
+            required
+            min="1"
+            step="1"
+            placeholder="e.g., 3500"
+          />
+          <p class="help-text">Enter weight in grams (1 kg = 1000 grams)</p>
+        </div>
+
+        <button type="submit" class="button" id="submitBtn">Add Child</button>
+        <button type="button" class="button secondary" onclick="goBack()">
+          Cancel
+        </button>
+      </form>
+    </div>
+
+    <script>
+      // Check if user is authenticated
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      // Get child ID from URL if editing
+      const urlParams = new URLSearchParams(window.location.search);
+      const childId = urlParams.get("id");
+      const isEditMode = !!childId;
+
+      const form = document.getElementById("addChildForm");
+      const messageDiv = document.getElementById("message");
+      const submitBtn = document.getElementById("submitBtn");
+
+      // Update page title and button text if editing
+      if (isEditMode) {
+        document.querySelector("h1").textContent = "✏️ Edit Child";
+        document.querySelector(".subtitle").textContent =
+          "Update your child's information";
+        submitBtn.textContent = "Update Child";
+
+        // Load existing child data
+        loadChildData(childId);
+      }
+
+      async function loadChildData(id) {
+        try {
+          const response = await fetch(`/api/children/${id}`, {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            const child = await response.json();
+
+            // Populate form fields
+            document.getElementById("name").value = child.name;
+
+            // Format datetime for datetime-local input
+            const birthDate = new Date(child.birth_time);
+            const formattedDate = birthDate.toISOString().slice(0, 16);
+            document.getElementById("birthTime").value = formattedDate;
+
+            document.getElementById("birthWeight").value = child.birth_weight;
+          } else {
+            showMessage("Failed to load child data", "error");
+          }
+        } catch (error) {
+          showMessage("Error loading child data", "error");
+        }
+      }
+
+      form.addEventListener("submit", async (e) => {
+        e.preventDefault();
+
+        const name = document.getElementById("name").value;
+        const birthTime = document.getElementById("birthTime").value;
+        const birthWeight = parseFloat(
+          document.getElementById("birthWeight").value,
+        );
+
+        // Disable button during request
+        submitBtn.disabled = true;
+        const originalText = submitBtn.textContent;
+        submitBtn.textContent = isEditMode ? "Updating..." : "Adding...";
+        messageDiv.classList.remove("show");
+
+        try {
+          const url = isEditMode ? `/api/children/${childId}` : "/api/children";
+          const method = isEditMode ? "PUT" : "POST";
+
+          const response = await fetch(url, {
+            method: method,
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              name: name,
+              birth_time: birthTime,
+              birth_weight: birthWeight,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok) {
+            showMessage(
+              isEditMode
+                ? "Child updated successfully!"
+                : "Child added successfully!",
+              "success",
+            );
+            // Redirect to home page after 1 second
+            setTimeout(() => {
+              window.location.href = "/";
+            }, 1000);
+          } else {
+            showMessage(
+              data.detail ||
+                `Failed to ${isEditMode ? "update" : "add"} child. Please try again.`,
+              "error",
+            );
+          }
+        } catch (error) {
+          showMessage("Network error. Please try again.", "error");
+        } finally {
+          submitBtn.disabled = false;
+          submitBtn.textContent = originalText;
+        }
+      });
+
+      function showMessage(text, type) {
+        messageDiv.textContent = text;
+        messageDiv.className = `message ${type} show`;
+      }
+
+      function goBack() {
+        window.location.href = "/";
+      }
+    </script>
+  </body>
+</html>

src/baby_monitor/static/admin.html

@@ -0,0 +1,319 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Baby Monitor - Admin</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 20px;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+        max-width: 600px;
+        width: 100%;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+      }
+
+      .section {
+        margin-bottom: 30px;
+      }
+
+      .section h2 {
+        color: #444;
+        font-size: 18px;
+        margin-bottom: 15px;
+        display: flex;
+        align-items: center;
+      }
+
+      .section h2::before {
+        content: "🔗";
+        margin-right: 8px;
+      }
+
+      .button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+        width: 100%;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:active {
+        transform: translateY(0);
+      }
+
+      .button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .link-container {
+        display: none;
+        margin-top: 20px;
+        padding: 15px;
+        background: #f8f9fa;
+        border-radius: 8px;
+        border: 2px solid #667eea;
+      }
+
+      .link-container.show {
+        display: block;
+      }
+
+      .link-label {
+        font-size: 12px;
+        color: #666;
+        margin-bottom: 8px;
+        font-weight: 600;
+        text-transform: uppercase;
+      }
+
+      .link-display {
+        display: flex;
+        gap: 10px;
+        align-items: center;
+      }
+
+      .link-text {
+        flex: 1;
+        padding: 10px;
+        background: white;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-family: "Courier New", monospace;
+        font-size: 13px;
+        word-break: break-all;
+        color: #333;
+      }
+
+      .copy-button {
+        padding: 10px 16px;
+        background: #28a745;
+        color: white;
+        border: none;
+        border-radius: 4px;
+        cursor: pointer;
+        font-weight: 600;
+        transition: background 0.2s;
+        white-space: nowrap;
+      }
+
+      .copy-button:hover {
+        background: #218838;
+      }
+
+      .copy-button.copied {
+        background: #155724;
+      }
+
+      .info-box {
+        background: #e7f3ff;
+        border-left: 4px solid #2196f3;
+        padding: 12px;
+        border-radius: 4px;
+        margin-top: 15px;
+        font-size: 14px;
+        color: #555;
+      }
+
+      .error {
+        background: #ffebee;
+        border-left: 4px solid #f44336;
+        color: #c62828;
+        padding: 12px;
+        border-radius: 4px;
+        margin-top: 15px;
+        display: none;
+      }
+
+      .error.show {
+        display: block;
+      }
+
+      .logout-button {
+        background: #dc3545;
+        padding: 8px 16px;
+        font-size: 14px;
+        margin-top: 20px;
+      }
+
+      .logout-button:hover {
+        background: #c82333;
+        box-shadow: 0 4px 12px rgba(220, 53, 69, 0.4);
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>👨‍💼 Admin Dashboard</h1>
+      <p class="subtitle">Manage user invitations and settings</p>
+
+      <div class="section">
+        <h2>Generate Invitation Link</h2>
+        <p style="color: #666; margin-bottom: 15px; font-size: 14px">
+          Create a secure one-time link to invite a new user to register.
+        </p>
+        <button class="button" id="generateBtn" onclick="generateLink()">
+          Generate New Invitation Link
+        </button>
+
+        <div id="linkContainer" class="link-container">
+          <div class="link-label">Invitation Link</div>
+          <div class="link-display">
+            <div class="link-text" id="linkText"></div>
+            <button class="copy-button" id="copyBtn" onclick="copyLink()">
+              Copy
+            </button>
+          </div>
+          <div class="info-box">
+            ℹ️ This link expires in 24 hours and can only be used once. Share it
+            securely with the intended user.
+          </div>
+        </div>
+
+        <div id="error" class="error"></div>
+      </div>
+
+      <button class="button logout-button" onclick="logout()">Logout</button>
+    </div>
+
+    <script>
+      // Check if user is authenticated and is admin
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      // Verify user is admin
+      fetch("/api/me", {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      })
+        .then((response) => response.json())
+        .then((user) => {
+          if (!user.is_admin) {
+            alert("Access denied. Admin privileges required.");
+            window.location.href = "/";
+          }
+        })
+        .catch((error) => {
+          console.error("Error verifying admin status:", error);
+          window.location.href = "/login.html";
+        });
+
+      async function generateLink() {
+        const btn = document.getElementById("generateBtn");
+        const linkContainer = document.getElementById("linkContainer");
+        const linkText = document.getElementById("linkText");
+        const errorDiv = document.getElementById("error");
+
+        // Disable button and show loading state
+        btn.disabled = true;
+        btn.textContent = "Generating...";
+        errorDiv.classList.remove("show");
+
+        try {
+          const response = await fetch("/api/admin/generate-invitation", {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${token}`,
+              "Content-Type": "application/json",
+            },
+          });
+
+          if (!response.ok) {
+            throw new Error(`Failed to generate link: ${response.statusText}`);
+          }
+
+          const data = await response.json();
+
+          // Build the full URL
+          const baseUrl = window.location.origin;
+          const inviteUrl = `${baseUrl}/register.html?token=${data.token}`;
+
+          // Display the link
+          linkText.textContent = inviteUrl;
+          linkContainer.classList.add("show");
+        } catch (error) {
+          errorDiv.textContent = `Error: ${error.message}`;
+          errorDiv.classList.add("show");
+        } finally {
+          btn.disabled = false;
+          btn.textContent = "Generate New Invitation Link";
+        }
+      }
+
+      function copyLink() {
+        const linkText = document.getElementById("linkText").textContent;
+        const copyBtn = document.getElementById("copyBtn");
+
+        navigator.clipboard
+          .writeText(linkText)
+          .then(() => {
+            // Show success state
+            copyBtn.textContent = "✓ Copied!";
+            copyBtn.classList.add("copied");
+
+            // Reset after 2 seconds
+            setTimeout(() => {
+              copyBtn.textContent = "Copy";
+              copyBtn.classList.remove("copied");
+            }, 2000);
+          })
+          .catch((err) => {
+            alert("Failed to copy link: " + err);
+          });
+      }
+
+      function logout() {
+        localStorage.removeItem("access_token");
+        window.location.href = "/login.html";
+      }
+    </script>
+  </body>
+</html>

src/baby_monitor/static/index.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Baby Monitor - Home</title>
+    <title>Baby Monitor</title>
     <style>
       body {
         font-family: Arial, sans-serif;
@@ -12,6 +12,69 @@
         padding: 0 1rem;
         background-color: #f0f0f0;
       }
+      .burger-menu {
+        position: fixed;
+        top: 1rem;
+        left: 1rem;
+        cursor: pointer;
+        z-index: 1000;
+        background: white;
+        padding: 0.5rem;
+        border-radius: 4px;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+      }
+      .burger-menu div {
+        width: 25px;
+        height: 3px;
+        background-color: #333;
+        margin: 5px 0;
+        transition: 0.3s;
+      }
+      .menu-overlay {
+        position: fixed;
+        top: 0;
+        left: -250px;
+        width: 250px;
+        height: 100vh;
+        background: white;
+        box-shadow: 2px 0 10px rgba(0, 0, 0, 0.1);
+        transition: left 0.3s;
+        z-index: 999;
+        padding: 4rem 1rem 1rem 1rem;
+      }
+      .menu-overlay.open {
+        left: 0;
+      }
+      .menu-backdrop {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100vh;
+        background: rgba(0, 0, 0, 0.5);
+        display: none;
+        z-index: 998;
+      }
+      .menu-backdrop.open {
+        display: block;
+      }
+      .menu-item {
+        padding: 1rem;
+        border-bottom: 1px solid #eee;
+        cursor: pointer;
+        transition: background 0.2s;
+      }
+      .menu-item:hover {
+        background: #f5f5f5;
+      }
+      .menu-item.admin {
+        color: #667eea;
+        font-weight: 600;
+      }
+      .menu-item.logout {
+        color: #dc3545;
+        font-weight: 600;
+      }
       .container {
         background: white;
         padding: 2rem;
@@ -36,33 +99,208 @@
         border-radius: 4px;
         cursor: pointer;
         font-size: 1rem;
+        margin-right: 0.5rem;
       }
       button:hover {
         background-color: #c82333;
       }
+      .admin-button {
+        background-color: #667eea;
+      }
+      .admin-button:hover {
+        background-color: #5568d3;
+      }
+      .hidden {
+        display: none;
+      }
       .loading {
         text-align: center;
         padding: 2rem;
       }
+      .feeding-button {
+        width: 100%;
+        padding: 2rem;
+        font-size: 1.5rem;
+        margin-bottom: 1.5rem;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 8px;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+      }
+      .feeding-button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4);
+        background: linear-gradient(135deg, #764ba2 0%, #667eea 100%);
+      }
+      .feeding-button.active {
+        background: linear-gradient(135deg, #f44336 0%, #e91e63 100%);
+      }
+      .feeding-button.active:hover {
+        background: linear-gradient(135deg, #e91e63 0%, #f44336 100%);
+      }
+      .feeding-info {
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+        opacity: 0.9;
+      }
+      .modal {
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1001;
+        justify-content: center;
+        align-items: center;
+      }
+      .modal.show {
+        display: flex;
+      }
+      .modal-content {
+        background: white;
+        padding: 2rem;
+        border-radius: 8px;
+        max-width: 400px;
+        width: 90%;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+      }
+      .modal h2 {
+        margin-top: 0;
+        margin-bottom: 1.5rem;
+        color: #333;
+      }
+      .form-group {
+        margin-bottom: 1rem;
+      }
+      .form-group label {
+        display: block;
+        margin-bottom: 0.5rem;
+        color: #333;
+        font-weight: 600;
+      }
+      .form-group select {
+        width: 100%;
+        padding: 0.75rem;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-size: 1rem;
+      }
+      .modal-buttons {
+        display: flex;
+        gap: 0.5rem;
+        margin-top: 1.5rem;
+      }
+      .modal-buttons button {
+        flex: 1;
+        margin: 0;
+      }
+      .cancel-button {
+        background-color: #6c757d;
+      }
+      .cancel-button:hover {
+        background-color: #5a6268;
+      }
     </style>
   </head>
   <body>
+    <div class="burger-menu" id="burgerMenu">
+      <div></div>
+      <div></div>
+      <div></div>
+    </div>
+
+    <div class="menu-backdrop" id="menuBackdrop"></div>
+
+    <div class="menu-overlay" id="menuOverlay">
+      <div class="menu-item" id="menuAddChild">👶 Add Child</div>
+      <div class="menu-item" id="menuFeedings">🍼 Feedings</div>
+      <div class="menu-item logout" id="menuLogout">🚪 Logout</div>
+    </div>
+
     <div class="container">
       <div id="content" class="loading">
         <p>Loading...</p>
       </div>
     </div>
 
+    <!-- Start Feeding Modal -->
+    <div class="modal" id="startFeedingModal">
+      <div class="modal-content">
+        <h2>🍼 Start Feeding</h2>
+        <form id="startFeedingForm">
+          <div class="form-group">
+            <label for="modalChildId">Child</label>
+            <select id="modalChildId" required>
+              <option value="">Select a child</option>
+            </select>
+          </div>
+          <div class="form-group">
+            <label for="modalFeedingType">Feeding Type</label>
+            <select id="modalFeedingType" required>
+              <option value="">Select type</option>
+              <option value="left_breast">Left Breast</option>
+              <option value="right_breast">Right Breast</option>
+              <option value="bottle">Bottle</option>
+            </select>
+          </div>
+          <div class="modal-buttons">
+            <button
+              type="button"
+              class="cancel-button"
+              onclick="closeStartFeedingModal()"
+            >
+              Cancel
+            </button>
+            <button type="submit">Start</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
     <script>
       const token = localStorage.getItem("access_token");
       const username = localStorage.getItem("username");
 
+      // Burger menu functionality
+      const burgerMenu = document.getElementById("burgerMenu");
+      const menuOverlay = document.getElementById("menuOverlay");
+      const menuBackdrop = document.getElementById("menuBackdrop");
+
+      function toggleMenu() {
+        menuOverlay.classList.toggle("open");
+        menuBackdrop.classList.toggle("open");
+      }
+
+      function closeMenu() {
+        menuOverlay.classList.remove("open");
+        menuBackdrop.classList.remove("open");
+      }
+
+      burgerMenu.addEventListener("click", toggleMenu);
+      menuBackdrop.addEventListener("click", closeMenu);
+
+      document.getElementById("menuAddChild").addEventListener("click", () => {
+        window.location.href = "/add-child.html";
+      });
+
+      document.getElementById("menuFeedings").addEventListener("click", () => {
+        window.location.href = "/feedings.html";
+      });
+
+      document.getElementById("menuLogout").addEventListener("click", () => {
+        closeMenu();
+        logout();
+      });
+
       // Check if user is logged in
       if (!token) {
-        window.location.href = "/static/login.html";
+        window.location.href = "/login.html";
       } else {
-        // Verify token by making an authenticated request
-        fetch("/api/", {
+        // Fetch current user info including admin status
+        fetch("/api/me", {
           headers: {
             Authorization: `Bearer ${token}`,
           },
@@ -74,31 +312,277 @@
               // Token invalid, redirect to login
               localStorage.removeItem("access_token");
               localStorage.removeItem("username");
-              window.location.href = "/static/login.html";
+              window.location.href = "/login.html";
               throw new Error("Authentication failed");
             }
           })
-          .then((data) => {
-            // Show authenticated content
-            document.getElementById("content").innerHTML = `
-                    <h1>Welcome to Baby Monitor!</h1>
-                    <div class="user-info">
-                        <p><strong>Logged in as:</strong> ${username}</p>
-                    </div>
-                    <p>${data.message}</p>
-                    <button id="logoutBtn">Logout</button>
-                `;
+          .then((user) => {
+            // Check if user has any children
+            return fetch("/api/children", {
+              headers: {
+                Authorization: `Bearer ${token}`,
+              },
+            })
+              .then((response) => response.json())
+              .then((children) => {
+                // If no children, redirect to add-child page
+                if (children.length === 0) {
+                  window.location.href = "/add-child.html";
+                  return;
+                }
 
-            // Add logout handler
-            document
-              .getElementById("logoutBtn")
-              .addEventListener("click", logout);
+                // Load feeding status and show content
+                loadFeedingStatus(children);
+              });
           })
           .catch((error) => {
             console.error("Error:", error);
           });
       }
 
+      let activeFeeding = null;
+      let userChildren = [];
+      let lastFeeding = null;
+      let updateTimerInterval = null;
+
+      async function loadFeedingStatus(children) {
+        userChildren = children;
+
+        try {
+          // Fetch active feeding
+          const activeResponse = await fetch("/api/feedings/active", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (activeResponse.ok) {
+            activeFeeding = await activeResponse.json();
+          }
+
+          // Fetch all feedings to get the last one
+          const feedingsResponse = await fetch("/api/feedings", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (feedingsResponse.ok) {
+            const feedings = await feedingsResponse.json();
+            if (feedings.length > 0) {
+              // Feedings are ordered by start_time desc, so first is most recent
+              lastFeeding = feedings[0];
+            }
+          }
+        } catch (error) {
+          console.error("Error loading feeding status:", error);
+        }
+
+        renderContent();
+        startUpdateTimer();
+      }
+
+      function startUpdateTimer() {
+        // Clear any existing timer
+        if (updateTimerInterval) {
+          clearInterval(updateTimerInterval);
+        }
+
+        // Update every 30 seconds if there's an active feeding
+        if (activeFeeding) {
+          updateTimerInterval = setInterval(() => {
+            if (activeFeeding) {
+              updateFeedingTimeDisplay();
+            } else {
+              clearInterval(updateTimerInterval);
+              updateTimerInterval = null;
+            }
+          }, 30000); // Update every 30 seconds
+        }
+      }
+
+      function updateFeedingTimeDisplay() {
+        const timeElement = document.getElementById("feedingTimeInfo");
+        if (timeElement && activeFeeding) {
+          timeElement.textContent = formatTime(activeFeeding.start_time);
+        }
+      }
+
+      function renderContent() {
+        const feedingButtonHtml = activeFeeding
+          ? `
+            <button class="feeding-button active" onclick="stopFeeding()">
+              🛑 Stop Feeding
+              <div class="feeding-info">
+                ${activeFeeding.child_name || "Child"} - ${formatFeedingType(activeFeeding.feeding_type)}<br>
+                Started <span id="feedingTimeInfo">${formatTime(activeFeeding.start_time)}</span>
+              </div>
+            </button>
+          `
+          : `
+            <button class="feeding-button" onclick="showStartFeedingModal()">
+              ▶️ Start Feeding
+            </button>
+          `;
+
+        document.getElementById("content").innerHTML = `
+          <h1>Welcome to Baby Monitor!</h1>
+          <div class="user-info">
+            <p><strong>Logged in as:</strong> ${username}</p>
+          </div>
+          ${feedingButtonHtml}
+          <p>Your session is active.</p>
+        `;
+      }
+
+      function formatFeedingType(type) {
+        const types = {
+          left_breast: "Left Breast",
+          right_breast: "Right Breast",
+          bottle: "Bottle",
+        };
+        return types[type] || type;
+      }
+
+      function formatTime(dateString) {
+        const date = new Date(dateString);
+        const now = new Date();
+        const diffMs = now - date;
+        const diffMins = Math.floor(diffMs / 60000);
+
+        if (diffMins < 1) return "just now";
+        if (diffMins < 60) return `${diffMins} min ago`;
+
+        const diffHours = Math.floor(diffMins / 60);
+        if (diffHours < 24) return `${diffHours}h ${diffMins % 60}m ago`;
+
+        return date.toLocaleString();
+      }
+
+      function showStartFeedingModal() {
+        const modal = document.getElementById("startFeedingModal");
+        const childSelect = document.getElementById("modalChildId");
+        const typeSelect = document.getElementById("modalFeedingType");
+
+        // Clear and populate child select
+        childSelect.innerHTML = '<option value="">Select a child</option>';
+        userChildren.forEach((child) => {
+          const option = document.createElement("option");
+          option.value = child.id;
+          option.textContent = child.name;
+          childSelect.appendChild(option);
+        });
+
+        // Set defaults based on last feeding
+        if (lastFeeding) {
+          childSelect.value = lastFeeding.child_id;
+          typeSelect.value = lastFeeding.feeding_type;
+        }
+
+        modal.classList.add("show");
+      }
+
+      function closeStartFeedingModal() {
+        const modal = document.getElementById("startFeedingModal");
+        modal.classList.remove("show");
+        document.getElementById("startFeedingForm").reset();
+      }
+
+      document
+        .getElementById("startFeedingForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const childId = parseInt(
+            document.getElementById("modalChildId").value,
+          );
+          const feedingType = document.getElementById("modalFeedingType").value;
+
+          try {
+            const now = new Date();
+            const localDateTime = new Date(
+              now.getTime() - now.getTimezoneOffset() * 60000,
+            )
+              .toISOString()
+              .slice(0, 19);
+
+            const response = await fetch("/api/feedings", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify({
+                child_id: childId,
+                start_time: localDateTime,
+                end_time: null,
+                feeding_type: feedingType,
+              }),
+            });
+
+            if (response.ok) {
+              const feeding = await response.json();
+              activeFeeding = feeding;
+              lastFeeding = feeding; // Update last feeding
+
+              // Add child name to active feeding
+              const child = userChildren.find((c) => c.id === childId);
+              if (child) {
+                activeFeeding.child_name = child.name;
+              }
+
+              closeStartFeedingModal();
+              renderContent();
+              startUpdateTimer(); // Start the timer for live updates
+            } else {
+              const data = await response.json();
+              alert(data.detail || "Failed to start feeding");
+            }
+          } catch (error) {
+            console.error("Error starting feeding:", error);
+            alert("Network error. Please try again.");
+          }
+        });
+
+      async function stopFeeding() {
+        if (!activeFeeding) return;
+
+        try {
+          const now = new Date();
+          const localDateTime = new Date(
+            now.getTime() - now.getTimezoneOffset() * 60000,
+          )
+            .toISOString()
+            .slice(0, 19);
+
+          const response = await fetch(`/api/feedings/${activeFeeding.id}`, {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              end_time: localDateTime,
+            }),
+          });
+
+          if (response.ok) {
+            activeFeeding = null;
+            if (updateTimerInterval) {
+              clearInterval(updateTimerInterval);
+              updateTimerInterval = null;
+            }
+            renderContent();
+          } else {
+            const data = await response.json();
+            alert(data.detail || "Failed to stop feeding");
+          }
+        } catch (error) {
+          console.error("Error stopping feeding:", error);
+          alert("Network error. Please try again.");
+        }
+      }
+
       async function logout() {
         const token = localStorage.getItem("access_token");
 
@@ -115,7 +599,7 @@
           // Clear local storage and redirect
           localStorage.removeItem("access_token");
           localStorage.removeItem("username");
-          window.location.href = "/static/login.html";
+          window.location.href = "/login.html";
         }
       }
     </script>

src/baby_monitor/static/log-feeding.html

@@ -0,0 +1,391 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Log Feeding - Baby Monitor</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 20px;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+        max-width: 500px;
+        width: 100%;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+      }
+
+      .form-group {
+        margin-bottom: 20px;
+      }
+
+      label {
+        display: block;
+        margin-bottom: 8px;
+        color: #333;
+        font-weight: 600;
+        font-size: 14px;
+      }
+
+      input,
+      select {
+        width: 100%;
+        padding: 12px;
+        border: 1px solid #ddd;
+        border-radius: 6px;
+        font-size: 14px;
+        transition: border-color 0.2s;
+      }
+
+      input:focus,
+      select:focus {
+        outline: none;
+        border-color: #667eea;
+      }
+
+      .button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+        width: 100%;
+        margin-top: 10px;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:active {
+        transform: translateY(0);
+      }
+
+      .button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .button.secondary {
+        background: #6c757d;
+        margin-top: 10px;
+      }
+
+      .button.secondary:hover {
+        box-shadow: 0 4px 12px rgba(108, 117, 125, 0.4);
+      }
+
+      .message {
+        padding: 12px;
+        border-radius: 6px;
+        margin-bottom: 20px;
+        display: none;
+      }
+
+      .message.show {
+        display: block;
+      }
+
+      .message.error {
+        background: #ffebee;
+        border-left: 4px solid #f44336;
+        color: #c62828;
+      }
+
+      .message.success {
+        background: #e8f5e9;
+        border-left: 4px solid #4caf50;
+        color: #2e7d32;
+      }
+
+      .help-text {
+        font-size: 12px;
+        color: #666;
+        margin-top: 4px;
+      }
+
+      .loading {
+        text-align: center;
+        padding: 20px;
+        color: #666;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>🍼 Log Feeding</h1>
+      <p class="subtitle">Record a feeding session</p>
+
+      <div id="message" class="message"></div>
+
+      <div id="loadingChildren" class="loading">Loading children...</div>
+
+      <form id="logFeedingForm" style="display: none">
+        <div class="form-group">
+          <label for="childId">Child *</label>
+          <select id="childId" name="childId" required>
+            <option value="">Select a child</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <label for="startTime">Start Time *</label>
+          <input
+            type="datetime-local"
+            id="startTime"
+            name="startTime"
+            required
+          />
+          <p class="help-text">Defaults to current time</p>
+        </div>
+
+        <div class="form-group">
+          <label for="endTime">End Time</label>
+          <input type="datetime-local" id="endTime" name="endTime" />
+          <p class="help-text">Leave empty if feeding is ongoing</p>
+        </div>
+
+        <div class="form-group">
+          <label for="feedingType">Feeding Type *</label>
+          <select id="feedingType" name="feedingType" required>
+            <option value="">Select type</option>
+            <option value="left_breast">Left Breast</option>
+            <option value="right_breast">Right Breast</option>
+            <option value="bottle">Bottle</option>
+          </select>
+        </div>
+
+        <button type="submit" class="button" id="submitBtn">Log Feeding</button>
+        <button type="button" class="button secondary" onclick="goBack()">
+          Cancel
+        </button>
+      </form>
+    </div>
+
+    <script>
+      // Check if user is authenticated
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      const form = document.getElementById("logFeedingForm");
+      const messageDiv = document.getElementById("message");
+      const submitBtn = document.getElementById("submitBtn");
+      const loadingDiv = document.getElementById("loadingChildren");
+      const childSelect = document.getElementById("childId");
+
+      // Check if we're editing an existing feeding
+      const urlParams = new URLSearchParams(window.location.search);
+      const feedingId = urlParams.get("id");
+      const isEditMode = !!feedingId;
+
+      // Set default start time to now (only for new feedings)
+      if (!isEditMode) {
+        const now = new Date();
+        const localDateTime = new Date(
+          now.getTime() - now.getTimezoneOffset() * 60000,
+        )
+          .toISOString()
+          .slice(0, 16);
+        document.getElementById("startTime").value = localDateTime;
+      }
+
+      // Update title and button text if editing
+      if (isEditMode) {
+        document.querySelector("h1").textContent = "🍼 Edit Feeding";
+        document.querySelector(".subtitle").textContent = "Update feeding session details";
+        submitBtn.textContent = "Update Feeding";
+      }
+
+      // Load user's children
+      async function loadChildren() {
+        try {
+          const response = await fetch("/api/children", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            const children = await response.json();
+
+            if (children.length === 0) {
+              showMessage(
+                "No children found. Please add a child first.",
+                "error",
+              );
+              setTimeout(() => {
+                window.location.href = "/add-child.html";
+              }, 2000);
+              return;
+            }
+
+            // Populate select dropdown
+            children.forEach((child) => {
+              const option = document.createElement("option");
+              option.value = child.id;
+              option.textContent = child.name;
+              childSelect.appendChild(option);
+            });
+
+            // Show form, hide loading
+            loadingDiv.style.display = "none";
+            form.style.display = "block";
+
+            // If editing, load the feeding data
+            if (isEditMode) {
+              loadFeedingData();
+            }
+          } else {
+            showMessage("Failed to load children", "error");
+          }
+        } catch (error) {
+          showMessage("Network error loading children", "error");
+        }
+      }
+
+      async function loadFeedingData() {
+        try {
+          const response = await fetch(`/api/feedings/${feedingId}`, {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            const feeding = await response.json();
+            
+            // Populate form with existing data
+            document.getElementById("childId").value = feeding.child_id;
+            
+            // Format datetime for datetime-local input
+            const startTime = new Date(feeding.start_time);
+            const startLocalDateTime = new Date(
+              startTime.getTime() - startTime.getTimezoneOffset() * 60000
+            ).toISOString().slice(0, 16);
+            document.getElementById("startTime").value = startLocalDateTime;
+            
+            if (feeding.end_time) {
+              const endTime = new Date(feeding.end_time);
+              const endLocalDateTime = new Date(
+                endTime.getTime() - endTime.getTimezoneOffset() * 60000
+              ).toISOString().slice(0, 16);
+              document.getElementById("endTime").value = endLocalDateTime;
+            }
+            
+            document.getElementById("feedingType").value = feeding.feeding_type;
+          } else {
+            showMessage("Failed to load feeding data", "error");
+          }
+        } catch (error) {
+          showMessage("Network error loading feeding", "error");
+        }
+      }
+
+      loadChildren();
+
+      form.addEventListener("submit", async (e) => {
+        e.preventDefault();
+
+        const childId = parseInt(document.getElementById("childId").value);
+        const startTime = document.getElementById("startTime").value;
+        const endTimeValue = document.getElementById("endTime").value;
+        const feedingType = document.getElementById("feedingType").value;
+
+        // Disable button during request
+        submitBtn.disabled = true;
+        submitBtn.textContent = isEditMode ? "Updating..." : "Logging...";
+        messageDiv.classList.remove("show");
+
+        try {
+          const url = isEditMode ? `/api/feedings/${feedingId}` : "/api/feedings";
+          const method = isEditMode ? "PUT" : "POST";
+          
+          const response = await fetch(url, {
+            method: method,
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              child_id: childId,
+              start_time: startTime,
+              end_time: endTimeValue || null,
+              feeding_type: feedingType,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok) {
+            showMessage(
+              isEditMode ? "Feeding updated successfully!" : "Feeding logged successfully!", 
+              "success"
+            );
+            // Redirect to feedings page after 1 second
+            setTimeout(() => {
+              window.location.href = "/feedings.html";
+            }, 1000);
+          } else {
+            showMessage(
+              data.detail || `Failed to ${isEditMode ? 'update' : 'log'} feeding. Please try again.`,
+              "error",
+            );
+          }
+        } catch (error) {
+          showMessage("Network error. Please try again.", "error");
+        } finally {
+          submitBtn.disabled = false;
+          submitBtn.textContent = isEditMode ? "Update Feeding" : "Log Feeding";
+        }
+      });
+
+      function showMessage(text, type) {
+        messageDiv.textContent = text;
+        messageDiv.className = `message ${type} show`;
+      }
+
+      function goBack() {
+        window.location.href = "/";
+      }
+    </script>
+  </body>
+</html>

src/baby_monitor/static/login.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Baby Monitor - Login</title>
+    <title>Baby Monitor</title>
     <style>
       body {
         font-family: Arial, sans-serif;
@@ -112,9 +112,14 @@
             // Store token in localStorage
             localStorage.setItem("access_token", data.access_token);
             localStorage.setItem("username", data.username);
-            // Redirect to home page
+
+            // Redirect based on is_admin from login response
             setTimeout(() => {
-              window.location.href = "/";
+              if (data.is_admin === true) {
+                window.location.href = "/admin.html";
+              } else {
+                window.location.href = "/";
+              }
             }, 1000);
           } else {
             showMessage(data.detail || "Login failed", "error");

src/baby_monitor/static/register.html

@@ -0,0 +1,383 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Baby Monitor - Register</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 20px;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+        max-width: 450px;
+        width: 100%;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+        text-align: center;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+        text-align: center;
+      }
+
+      .form-group {
+        margin-bottom: 20px;
+      }
+
+      label {
+        display: block;
+        margin-bottom: 8px;
+        color: #444;
+        font-weight: 600;
+        font-size: 14px;
+      }
+
+      input {
+        width: 100%;
+        padding: 12px;
+        border: 2px solid #e0e0e0;
+        border-radius: 6px;
+        font-size: 16px;
+        transition: border-color 0.3s;
+      }
+
+      input:focus {
+        outline: none;
+        border-color: #667eea;
+      }
+
+      .button {
+        width: 100%;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        padding: 14px;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+        margin-top: 10px;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:active {
+        transform: translateY(0);
+      }
+
+      .button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .error {
+        background: #ffebee;
+        border-left: 4px solid #f44336;
+        color: #c62828;
+        padding: 12px;
+        border-radius: 4px;
+        margin-bottom: 20px;
+        display: none;
+        font-size: 14px;
+      }
+
+      .error.show {
+        display: block;
+      }
+
+      .success {
+        background: #e8f5e9;
+        border-left: 4px solid #4caf50;
+        color: #2e7d32;
+        padding: 12px;
+        border-radius: 4px;
+        margin-bottom: 20px;
+        display: none;
+        font-size: 14px;
+      }
+
+      .success.show {
+        display: block;
+      }
+
+      .loading-container {
+        text-align: center;
+        padding: 40px;
+      }
+
+      .spinner {
+        border: 3px solid #f3f3f3;
+        border-top: 3px solid #667eea;
+        border-radius: 50%;
+        width: 40px;
+        height: 40px;
+        animation: spin 1s linear infinite;
+        margin: 0 auto 20px;
+      }
+
+      @keyframes spin {
+        0% {
+          transform: rotate(0deg);
+        }
+        100% {
+          transform: rotate(360deg);
+        }
+      }
+
+      .info-box {
+        background: #e7f3ff;
+        border-left: 4px solid #2196f3;
+        padding: 12px;
+        border-radius: 4px;
+        margin-bottom: 20px;
+        font-size: 14px;
+        color: #555;
+      }
+
+      .hidden {
+        display: none;
+      }
+
+      .password-requirements {
+        font-size: 12px;
+        color: #666;
+        margin-top: 5px;
+      }
+
+      .password-requirements ul {
+        margin: 5px 0 0 20px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div id="loadingContainer" class="loading-container">
+        <div class="spinner"></div>
+        <p style="color: #666">Validating invitation...</p>
+      </div>
+
+      <div id="registerContainer" class="hidden">
+        <h1>🎉 Create Your Account</h1>
+        <p class="subtitle">Complete the registration to get started</p>
+
+        <div id="error" class="error"></div>
+        <div id="success" class="success"></div>
+
+        <form id="registerForm" onsubmit="handleRegister(event)">
+          <div class="form-group">
+            <label for="username">Username</label>
+            <input
+              type="text"
+              id="username"
+              name="username"
+              required
+              minlength="3"
+              autocomplete="username"
+              placeholder="Choose a username"
+            />
+          </div>
+
+          <div class="form-group">
+            <label for="password">Password</label>
+            <input
+              type="password"
+              id="password"
+              name="password"
+              required
+              minlength="8"
+              autocomplete="new-password"
+              placeholder="Choose a strong password"
+            />
+            <div class="password-requirements">
+              <ul>
+                <li>At least 8 characters long</li>
+                <li>Mix of letters, numbers recommended</li>
+              </ul>
+            </div>
+          </div>
+
+          <div class="form-group">
+            <label for="confirmPassword">Confirm Password</label>
+            <input
+              type="password"
+              id="confirmPassword"
+              name="confirmPassword"
+              required
+              minlength="8"
+              autocomplete="new-password"
+              placeholder="Re-enter your password"
+            />
+          </div>
+
+          <button type="submit" class="button" id="submitBtn">
+            Create Account
+          </button>
+        </form>
+      </div>
+
+      <div id="invalidTokenContainer" class="hidden">
+        <h1>⚠️ Invalid Invitation</h1>
+        <p class="subtitle">This invitation link is invalid or has expired</p>
+        <div class="info-box">
+          This could mean:
+          <ul style="margin: 10px 0 0 20px; color: #555">
+            <li>The invitation has already been used</li>
+            <li>The invitation has expired (24 hours)</li>
+            <li>The invitation link is incorrect</li>
+          </ul>
+        </div>
+        <p style="text-align: center; color: #666; margin-top: 20px">
+          Please contact an administrator for a new invitation link.
+        </p>
+      </div>
+    </div>
+
+    <script>
+      let invitationToken = null;
+
+      // Extract token from URL query parameters
+      const urlParams = new URLSearchParams(window.location.search);
+      invitationToken = urlParams.get("token");
+
+      // Validate token on page load
+      window.addEventListener("DOMContentLoaded", async () => {
+        if (!invitationToken) {
+          showInvalidToken();
+          return;
+        }
+
+        try {
+          // Verify the invitation token
+          const response = await fetch(
+            `/api/verify-invitation?token=${encodeURIComponent(invitationToken)}`,
+          );
+
+          if (response.ok) {
+            showRegisterForm();
+          } else {
+            showInvalidToken();
+          }
+        } catch (error) {
+          console.error("Error validating invitation:", error);
+          showInvalidToken();
+        }
+      });
+
+      function showRegisterForm() {
+        document.getElementById("loadingContainer").classList.add("hidden");
+        document.getElementById("registerContainer").classList.remove("hidden");
+      }
+
+      function showInvalidToken() {
+        document.getElementById("loadingContainer").classList.add("hidden");
+        document
+          .getElementById("invalidTokenContainer")
+          .classList.remove("hidden");
+      }
+
+      async function handleRegister(event) {
+        event.preventDefault();
+
+        const username = document.getElementById("username").value;
+        const password = document.getElementById("password").value;
+        const confirmPassword =
+          document.getElementById("confirmPassword").value;
+        const errorDiv = document.getElementById("error");
+        const successDiv = document.getElementById("success");
+        const submitBtn = document.getElementById("submitBtn");
+
+        // Clear previous messages
+        errorDiv.classList.remove("show");
+        successDiv.classList.remove("show");
+
+        // Validate passwords match
+        if (password !== confirmPassword) {
+          errorDiv.textContent = "Passwords do not match!";
+          errorDiv.classList.add("show");
+          return;
+        }
+
+        // Disable submit button
+        submitBtn.disabled = true;
+        submitBtn.textContent = "Creating Account...";
+
+        try {
+          const response = await fetch("/api/register", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              username: username,
+              password: password,
+              invitation_token: invitationToken,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok) {
+            // Store the access token and username
+            localStorage.setItem("access_token", data.access_token);
+            localStorage.setItem("username", data.username);
+
+            // Show success message
+            successDiv.textContent =
+              "Account created successfully! Redirecting...";
+            successDiv.classList.add("show");
+
+            // Redirect to home page after a brief delay
+            setTimeout(() => {
+              window.location.href = "/";
+            }, 1500);
+          } else {
+            errorDiv.textContent =
+              data.detail || "Registration failed. Please try again.";
+            errorDiv.classList.add("show");
+            submitBtn.disabled = false;
+            submitBtn.textContent = "Create Account";
+          }
+        } catch (error) {
+          console.error("Registration error:", error);
+          errorDiv.textContent = "An error occurred. Please try again.";
+          errorDiv.classList.add("show");
+          submitBtn.disabled = false;
+          submitBtn.textContent = "Create Account";
+        }
+      }
+    </script>
+  </body>
+</html>

src/baby_monitor/utils/password.py

@@ -0,0 +1,33 @@
+"""Password hashing utilities using bcrypt."""
+
+import bcrypt
+
+
+def hash_password(password: str) -> str:
+    """Hash a password using bcrypt.
+
+    Args:
+        password: Plain text password to hash
+
+    Returns:
+        Hashed password as a string
+    """
+    salt = bcrypt.gensalt()
+    hashed: bytes = bcrypt.hashpw(password.encode("utf-8"), salt)
+    return hashed.decode("utf-8")
+
+
+def verify_password(password: str, hashed_password: str) -> bool:
+    """Verify a password against a hashed password.
+
+    Args:
+        password: Plain text password to verify
+        hashed_password: Previously hashed password
+
+    Returns:
+        True if password matches, False otherwise
+    """
+    result: bool = bcrypt.checkpw(
+        password.encode("utf-8"), hashed_password.encode("utf-8")
+    )
+    return result

tests/conftest.py

@@ -12,3 +12,9 @@ def pytest_configure(config: pytest.Config) -> None:
         tmpdir = tempfile.mkdtemp(prefix="baby_monitor_test_")
         os.environ["DATA_DIR"] = tmpdir
         os.environ["ENVIRONMENT"] = "development"
+
+    # Set admin credentials for tests
+    if "ADMIN_USERNAME" not in os.environ:
+        os.environ["ADMIN_USERNAME"] = "admin"
+    if "ADMIN_PASSWORD" not in os.environ:
+        os.environ["ADMIN_PASSWORD"] = "password"

uv.lock

@@ -39,6 +39,7 @@ name = "baby-monitor"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "bcrypt" },
     { name = "fastapi" },
     { name = "sqlalchemy" },
     { name = "uvicorn" },
@@ -57,6 +58,7 @@ dev = [
     { name = "httpx" },
     { name = "mypy" },
     { name = "pre-commit" },
+    { name = "prettier" },
     { name = "pytest" },
     { name = "pytest-cov" },
     { name = "pyupgrade" },
@@ -66,6 +68,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "bcrypt", specifier = ">=4.0.0" },
     { name = "fastapi", specifier = ">=0.121.0" },
     { name = "psycopg2-binary", marker = "extra == 'postgres'", specifier = ">=2.9.0" },
     { name = "redis", marker = "extra == 'redis'", specifier = ">=5.0.0" },
@@ -79,6 +82,7 @@ dev = [
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "mypy", specifier = ">=1.18.2" },
     { name = "pre-commit", specifier = ">=4.3.0" },
+    { name = "prettier", specifier = ">=0.0.7" },
     { name = "pytest", specifier = ">=8.4.2" },
     { name = "pytest-cov", specifier = ">=7.0.0" },
     { name = "pyupgrade", specifier = ">=3.21.0" },
@@ -86,6 +90,72 @@ dev = [
     { name = "types-psycopg2", specifier = ">=2.9.21.20251012" },
 ]
 
+[[package]]
+name = "bcrypt"
+version = "5.0.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-macosx_10_12_universal2.whl", hash = "sha256:4870a52610537037adb382444fefd3706d96d663ac44cbb2f37e3919dca3d7ef" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48f753100931605686f74e27a7b49238122aa761a9aefe9373265b8b7aa43ea4" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f70aadb7a809305226daedf75d90379c397b094755a710d7014b8b117df1ebbf" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:744d3c6b164caa658adcb72cb8cc9ad9b4b75c7db507ab4bc2480474a51989da" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a28bc05039bdf3289d757f49d616ab3efe8cf40d8e8001ccdd621cd4f98f4fc9" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7f277a4b3390ab4bebe597800a90da0edae882c6196d3038a73adf446c4f969f" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:79cfa161eda8d2ddf29acad370356b47f02387153b11d46042e93a0a95127493" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a5393eae5722bcef046a990b84dff02b954904c36a194f6cfc817d7dca6c6f0b" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4c94dec1b5ab5d522750cb059bb9409ea8872d4494fd152b53cca99f1ddd8c" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0cae4cb350934dfd74c020525eeae0a5f79257e8a201c0c176f4b84fdbf2a4b4" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win32.whl", hash = "sha256:b17366316c654e1ad0306a6858e189fc835eca39f7eb2cafd6aaca8ce0c40a2e" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:92864f54fb48b4c718fc92a32825d0e42265a627f956bc0361fe869f1adc3e7d" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dd19cf5184a90c873009244586396a6a884d591a5323f0e8a5922560718d4993" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2" },
+    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.10.5"
@@ -437,6 +507,15 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/pre-commit/pre_commit-4.3.0-py2.py3-none-any.whl", hash = "sha256:2b0747ad7e6e967169136edffee14c16e148a778a54e4f967921aa1ebf2308d8" },
 ]
 
+[[package]]
+name = "prettier"
+version = "0.0.7"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/prettier/prettier-0.0.7.tar.gz", hash = "sha256:6c34b8cd09fd9c8956c05d6395ea3f575e0122dce494ba57685c07065abed427" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/prettier/prettier-0.0.7-py3-none-any.whl", hash = "sha256:20e76791de41cafe481328dd49552303f29ca192151cee1b120c26f66cae9bfc" },
+]
+
 [[package]]
 name = "psycopg2-binary"
 version = "2.9.11"