Merge pull request 'show-most-recent-feeding-session' (#39) from show-most-recent-feeding-session into main

Reviewed-on: #39

.gitea/workflows/refresh_showcase_data.yml

@@ -0,0 +1,43 @@
+name: Refresh Showcase Data
+
+on:
+  schedule:
+    # Run daily at 3 AM UTC
+    - cron: "0 3 * * *"
+  workflow_dispatch: # Allow manual triggering
+
+jobs:
+  refresh-data:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ vars.PYTHON_VERSION }}
+
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+
+      - name: Install dependencies
+        run: |
+          uv sync --no-dev --all-extras
+
+      - name: Run showcase data seeding script
+        env:
+          ADMIN_USERNAME: ${{ secrets.ADMIN_USERNAME }}
+          ADMIN_PASSWORD: ${{ secrets.ADMIN_PASSWORD }}
+          POSTGRES_URI: ${{ secrets.POSTGRES_URI }}
+        run: |
+          uv run python scripts/seed_showcase_data.py
+
+      - name: Notify on success
+        if: success()
+        run: echo "✅ Showcase data refreshed successfully"
+
+      - name: Notify on failure
+        if: failure()
+        run: echo "❌ Failed to refresh showcase data"

Dockerfile

@@ -23,7 +23,9 @@ COPY pyproject.toml README.md ./
 COPY src/ ./src/
 
 # Install Python dependencies including all optional dependencies
-# This makes the image self-contained and ready for any configuration
+# This makes the image self-contained and ready for any configuration:
+# - Redis support (redis extra)
+# - PostgreSQL support (postgres extra)
 RUN uv sync --no-dev --all-extras
 
 # Add virtual environment to PATH

README.md

@@ -81,13 +81,14 @@ uv run uvicorn src.baby_monitor.main:app --reload --host 0.0.0.0 --port 8000
 
 ### Environment Variables
 
-| Variable         | Default      | Description                                 |
+| Variable         | Default      | Description                                    |
-| ---------------- | ------------ | ------------------------------------------- |
+| ---------------- | ------------ | ---------------------------------------------- |
-| `ENVIRONMENT`    | `production` | Set to `development` to enable API docs     |
+| `ENVIRONMENT`    | `production` | Set to `development` to enable API docs        |
-| `ADMIN_PASSWORD` | _(required)_ | Admin user password                         |
+| `ADMIN_PASSWORD` | _(required)_ | Admin user password                            |
-| `ADMIN_USERNAME` | `admin`      | Admin username                              |
+| `ADMIN_USERNAME` | `admin`      | Admin username                                 |
-| `DATA_DIR`       | `/data`      | Directory for SQLite database               |
+| `DATA_DIR`       | `/data`      | Directory for SQLite database (SQLite only)    |
-| `REDIS_URI`      | _(optional)_ | Redis connection URI for distributed tokens |
+| `REDIS_URI`      | _(optional)_ | Redis connection URI for distributed tokens    |
+| `POSTGRES_URI`   | _(optional)_ | PostgreSQL connection URI for database storage |
 
 ### Storage Options
 
@@ -96,18 +97,26 @@ uv run uvicorn src.baby_monitor.main:app --reload --host 0.0.0.0 --port 8000
 - Automatic setup, no configuration needed
 - Data stored in `/data/baby_monitor.db`
 - Perfect for single-server deployments
+- Timezone-aware datetimes stored as naive UTC
 
-**Redis (Optional)**
+**Redis (Optional - Token Storage)**
 
 ```bash
-# Enable Redis token storage
+# Enable Redis token storage for distributed deployments
 export REDIS_URI=redis://localhost:6379
 ```
 
-**PostgreSQL (Future)**
+**PostgreSQL (Optional - Database)**
 
-- Repository interface ready
+```bash
-- Swap implementation in `dependencies.py`
+# Enable PostgreSQL for production database
+export POSTGRES_URI=postgresql://user:password@localhost:5432/baby_monitor
+```
+
+- Supports timezone-aware datetimes natively
+- Recommended for production deployments
+- Better performance for concurrent access
+- Supports database migrations and backups
 
 ## 📁 Project Structure
 

docker-compose.prod.yml

@@ -5,9 +5,6 @@ services:
       dockerfile: Dockerfile
     ports:
       - "8000:8000"
-    volumes:
-      # Persist database to local directory
-      - ./data:/data
     environment:
       # Set environment to production
       - ENVIRONMENT=production
@@ -17,7 +14,7 @@ services:
       # Use Redis for token storage
       - REDIS_URI=redis://redis:6379/0
       # Use PostgreSQL for database
-      - DATABASE_URL=postgresql://baby_monitor:securepassword@postgres:5432/b
+      - POSTGRES_URI=postgresql://baby_monitor:securepassword@postgres:5432/baby_monitor_db
     command: ["--host", "0.0.0.0", "--port", "8000"]
     restart: unless-stopped
     depends_on:
@@ -54,7 +51,7 @@ services:
       interval: 10s
       timeout: 5s
       retries: 5
-      start_period: 10s
+      start_period: 3s
 volumes:
   redis-data:
   pgdata:

pyproject.toml

@@ -71,3 +71,7 @@ markers = [
 [[tool.mypy.overrides]]
 module = "redis.*"
 ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "showcase_data_definitions.*"
+ignore_missing_imports = true

scripts/seed_showcase_data.py

@@ -0,0 +1,185 @@
+"""Seed test data into the database for demo purposes."""
+
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add parent directory to path to import baby_monitor modules
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+# Import after path is set up
+from baby_monitor.repositories.dependencies.get_database import (  # noqa: E402
+    get_database,
+    init_db,
+)
+from baby_monitor.repositories.user.sqlite_user import (  # noqa: E402
+    DatabaseUserRepository,
+)
+from baby_monitor.repositories.child.sqlite_child import (  # noqa: E402
+    DatabaseChildRepository,
+)
+from baby_monitor.repositories.feeding.sqlite_feeding import (  # noqa: E402
+    DatabaseFeedingRepository,
+)
+from baby_monitor.repositories.diaper_change.sqlite_diaper_change import (  # noqa: E402, E501
+    DatabaseDiaperChangeRepository,
+)
+from baby_monitor.repositories.sleep.sqlite_sleep import (  # noqa: E402
+    DatabaseSleepRepository,
+)
+from baby_monitor.routers.auth import hash_password  # noqa: E402
+from showcase_data_definitions import generate_showcase_data  # noqa: E402
+
+
+def seed_database(reference_time: datetime | None = None) -> None:
+    """
+    Seed the database with test data.
+
+    This function is idempotent - it will check if test users exist
+    and either create them or update timestamps of existing data.
+
+    Args:
+        reference_time: The "now" time to use for generating timestamps.
+            Defaults to current time.
+    """
+    # Initialize database
+    init_db()
+    db = next(get_database())
+
+    try:
+        # Initialize repositories
+        user_repo = DatabaseUserRepository(db)
+        child_repo = DatabaseChildRepository(db)
+        feeding_repo = DatabaseFeedingRepository(db)
+        diaper_repo = DatabaseDiaperChangeRepository(db)
+        sleep_repo = DatabaseSleepRepository(db)
+
+        # Generate showcase data
+        test_data = generate_showcase_data(reference_time)
+
+        print("Starting database seeding...")
+        print(f"Reference time: {test_data['reference_time']}")
+
+        # Create or get showcase users
+        user_ids = []
+        for user_data in test_data["users"]:
+            # Check if user exists
+            existing_user = user_repo.get_by_username(user_data["username"])
+
+            if existing_user:
+                print(f"✓ User '{user_data['username']}' already exists")
+                user_ids.append(existing_user["id"])
+            else:
+                # Create new user
+                hashed_pw = hash_password(user_data["password"])
+                user_id = user_repo.create(
+                    username=user_data["username"],
+                    hashed_password=hashed_pw,
+                )
+                user_ids.append(user_id["id"])
+                print(f"✓ Created user '{user_data['username']}'")
+
+        # Create or get shared child
+        child_data = test_data["child"]
+
+        # Check if child exists for first user
+        existing_children = child_repo.get_by_user_id(user_ids[0])
+        child_id: int | None = None
+
+        # Look for existing child with matching name
+        for child in existing_children:
+            if child["name"] == child_data["name"]:
+                child_id = child["id"]
+                print(f"✓ Child '{child_data['name']}' already exists")
+                break
+
+        if child_id is None:
+            # Create new child
+            created_child = child_repo.create(
+                name=child_data["name"],
+                birth_time=child_data["birth_time"],
+                birth_weight=child_data["birth_weight"],
+                user_id=user_ids[0],
+            )
+            child_id = created_child["id"]
+            print(f"✓ Created child '{child_data['name']}'")
+
+        # Ensure child_id is set
+        assert child_id is not None, "Child ID must be set at this point"
+
+        # Share child with second user if not already shared
+        parent_ids = child_repo.get_parent_ids(child_id)
+        if user_ids[1] not in parent_ids:
+            child_repo.add_parent(child_id, user_ids[1])
+            msg = f"✓ Shared child with '{test_data['users'][1]['username']}'"
+            print(msg)
+
+        # Clear existing logs to avoid duplicates
+        print("Clearing existing logs...")
+
+        # Get all logs for this child
+        existing_feedings = feeding_repo.get_by_child_id(child_id)
+        for feeding in existing_feedings:
+            feeding_repo.delete(feeding["id"])
+
+        existing_diapers = diaper_repo.get_by_child_id(child_id)
+        for diaper in existing_diapers:
+            diaper_repo.delete(diaper["id"])
+
+        existing_sleep = sleep_repo.get_by_child_id(child_id)
+        for sleep in existing_sleep:
+            sleep_repo.delete(sleep["id"])
+
+        print("✓ Cleared existing logs")
+
+        # Add feeding logs
+        print(f"Adding {len(test_data['feedings'])} feeding logs...")
+        for feeding in test_data["feedings"]:
+            feeding_repo.create(
+                child_id=child_id,
+                start_time=feeding["start_time"],
+                end_time=feeding["end_time"],
+                feeding_type=feeding["feeding_type"],
+            )
+        print(f"✓ Added {len(test_data['feedings'])} feedings")
+
+        # Add diaper changes
+        print(f"Adding {len(test_data['diapers'])} diaper changes...")
+        for diaper in test_data["diapers"]:
+            diaper_repo.create(
+                child_id=child_id,
+                change_time=diaper["time"],
+                poop_color=diaper.get("poop_color"),
+                poop_amount=diaper.get("poop_amount"),
+                pee_color=diaper.get("pee_color"),
+                pee_amount=diaper.get("pee_amount"),
+            )
+        print(f"✓ Added {len(test_data['diapers'])} diaper changes")
+
+        # Add sleep sessions
+        print(f"Adding {len(test_data['sleep'])} sleep sessions...")
+        for sleep in test_data["sleep"]:
+            sleep_repo.create(
+                child_id=child_id,
+                start_time=sleep["start_time"],
+                end_time=sleep["end_time"],
+            )
+        print(f"✓ Added {len(test_data['sleep'])} sleep sessions")
+
+        db.commit()
+        print("\n✅ Database seeding completed successfully!")
+        print("\nTest user credentials:")
+        print(f"  Username: {test_data['users'][0]['username']}")
+        print(f"  Password: {test_data['users'][0]['password']}")
+        print("  (Both users share the same password)")
+
+    except Exception as e:
+        db.rollback()
+        print(f"\n❌ Error seeding database: {e}")
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    seed_database()

scripts/showcase_data_definitions.py

@@ -0,0 +1,278 @@
+"""Definition of showcase data to be used for presenting the app."""
+
+from datetime import datetime, timedelta
+import random
+
+# User credentials
+SHOWCASE_USERS = [
+    {
+        "username": "user",
+        "password": "demo123",  # Will be hashed when inserted
+    },
+    {
+        "username": "user2",
+        "password": "demo123",  # Will be hashed when inserted
+    },
+]
+
+# Shared child (14 days old)
+CHILD_AGE_DAYS = 14
+
+
+def get_child_data(reference_time: datetime) -> dict:
+    """Get child data with birth time relative to reference time."""
+    birth_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
+    return {
+        "name": "Emma Rose",
+        "birth_time": birth_time,
+        "birth_weight": 3420,  # grams (7.5 lbs)
+    }
+
+
+def get_feeding_schedule(reference_time: datetime) -> list[dict]:
+    """
+    Generate realistic feeding schedule for the last 14 days.
+
+    Newborns feed every 2-3 hours initially, gradually spacing out
+    to 3-4 hours.
+    """
+    feedings: list[dict] = []
+    current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
+    end_time = reference_time
+
+    feeding_types = ["left_breast", "right_breast", "bottle"]
+
+    # Day-by-day feeding patterns
+    day_number = 0
+    while current_time < end_time:
+        age_in_days = day_number
+
+        # Newborns feed more frequently
+        if age_in_days < 3:
+            interval_hours = random.uniform(2, 2.5)
+            duration_minutes = random.randint(15, 25)
+        elif age_in_days < 7:
+            interval_hours = random.uniform(2.5, 3)
+            duration_minutes = random.randint(20, 30)
+        else:
+            interval_hours = random.uniform(3, 3.5)
+            duration_minutes = random.randint(20, 35)
+
+        # Alternate between breasts and occasional bottle
+        if random.random() < 0.2:  # 20% bottle feeding
+            feeding_type = "bottle"
+        else:
+            # Alternate breasts
+            feeding_type = feeding_types[len(feedings) % 2]
+
+        start_time = current_time
+        end_time_feeding = start_time + timedelta(minutes=duration_minutes)
+
+        feedings.append(
+            {
+                "start_time": start_time,
+                "end_time": end_time_feeding,
+                "feeding_type": feeding_type,
+            }
+        )
+
+        current_time += timedelta(hours=interval_hours)
+
+        # Move to next day
+        prev_date = (current_time - timedelta(hours=interval_hours)).date()
+        if current_time.date() != prev_date:
+            day_number += 1
+
+    return feedings
+
+
+def get_diaper_changes(reference_time: datetime) -> list[dict]:
+    """
+    Generate realistic diaper changes for the last 14 days.
+
+    - First 2-3 days: Black/dark (meconium), minimal pee
+    - Days 3-5: Transition to yellow, more frequent
+    - Days 5+: Regular yellow stools, normal pee patterns
+    - 8-10 diaper changes per day initially, settling to 6-8
+    """
+    diapers = []
+    current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
+    end_time = reference_time
+
+    day_number = 0
+
+    while current_time < end_time:
+        age_in_days = day_number
+
+        # Determine number of diaper changes per day based on age
+        if age_in_days < 3:
+            changes_per_day = random.randint(8, 10)
+        elif age_in_days < 7:
+            changes_per_day = random.randint(7, 9)
+        else:
+            changes_per_day = random.randint(6, 8)
+
+        # Distribute changes throughout the day
+        day_start = current_time.replace(hour=0, minute=0, second=0, microsecond=0)
+        day_end = day_start + timedelta(days=1)
+
+        for _ in range(changes_per_day):
+            # Random time during the day
+            random_seconds = random.randint(0, 86400)
+            change_time = day_start + timedelta(seconds=random_seconds)
+
+            if change_time >= end_time:
+                break
+
+            # Determine diaper contents
+            has_poop = random.random() < 0.4  # 40% have poop
+            # 90% have pee, or always if no poop
+            has_pee = random.random() < 0.9 or not has_poop
+
+            diaper = {
+                "time": change_time,
+                "has_poop": has_poop,
+                "has_pee": has_pee,
+            }
+
+            # Poop characteristics based on age
+            if has_poop:
+                if age_in_days < 2:
+                    # Meconium phase
+                    diaper["poop_color"] = "black"
+                    diaper["poop_amount"] = "light"
+                elif age_in_days < 4:
+                    # Transition phase
+                    colors = ["black", "green", "yellow"]
+                    diaper["poop_color"] = random.choice(colors)
+                    amounts = ["light", "medium"]
+                    diaper["poop_amount"] = random.choice(amounts)
+                else:
+                    # Normal phase
+                    colors = ["yellow", "yellow", "yellow", "green"]
+                    diaper["poop_color"] = random.choice(colors)
+                    # Amount increases with age
+                    if age_in_days < 7:
+                        amounts = ["light", "medium"]
+                        diaper["poop_amount"] = random.choice(amounts)
+                    else:
+                        amounts = ["medium", "heavy"]
+                        diaper["poop_amount"] = random.choice(amounts)
+
+            # Pee characteristics based on age
+            if has_pee:
+                if age_in_days < 2:
+                    # Very light pee initially
+                    diaper["pee_amount"] = "light"
+                    diaper["pee_color"] = random.choice(["clear", "yellow"])
+                elif age_in_days < 5:
+                    # Increasing output
+                    diaper["pee_amount"] = random.choice(["light", "medium"])
+                    diaper["pee_color"] = random.choice(["clear", "yellow"])
+                else:
+                    # Normal output
+                    if age_in_days < 10:
+                        amounts = ["medium", "medium", "heavy"]
+                        diaper["pee_amount"] = random.choice(amounts)
+                    else:
+                        amounts = ["medium", "heavy", "heavy"]
+                        diaper["pee_amount"] = random.choice(amounts)
+                    colors = ["clear", "yellow", "yellow"]
+                    diaper["pee_color"] = random.choice(colors)
+
+            diapers.append(diaper)
+
+        day_number += 1
+        current_time = day_end
+
+    # Sort by time (type: ignore for mypy - we know time is datetime)
+    diapers.sort(
+        key=lambda x: x["time"]  # type: ignore[arg-type,return-value]
+    )
+    return diapers
+
+
+def get_sleep_sessions(reference_time: datetime) -> list[dict]:
+    """
+    Generate realistic sleep patterns for the last 14 days.
+
+    Newborns sleep 16-18 hours per day in short bursts (30min - 4 hours).
+    Sleep gradually consolidates over time.
+    """
+    sleep_sessions = []
+    current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
+    end_time = reference_time
+
+    day_number = 0
+
+    while current_time < end_time:
+        age_in_days = day_number
+
+        # Sleep patterns evolve with age
+        if age_in_days < 3:
+            # Very short, frequent naps
+            avg_wake_time = 1.5  # hours
+            sleep_duration_range = (30, 120)  # minutes
+        elif age_in_days < 7:
+            # Slightly longer sleep periods
+            avg_wake_time = 2
+            sleep_duration_range = (45, 180)
+        else:
+            # More consolidated sleep
+            avg_wake_time = 2.5
+            sleep_duration_range = (60, 240)
+
+        # Random wake time with variation
+        wake_minutes = random.randint(int(avg_wake_time * 45), int(avg_wake_time * 75))
+
+        # Sleep start time
+        start_time = current_time + timedelta(minutes=wake_minutes)
+
+        if start_time >= end_time:
+            break
+
+        # Sleep duration
+        duration_minutes = random.randint(*sleep_duration_range)
+
+        # Longer sleep at night
+        if 20 <= start_time.hour or start_time.hour < 6:
+            duration_minutes = int(duration_minutes * 1.3)
+
+        end_time_sleep = start_time + timedelta(minutes=duration_minutes)
+
+        sleep_sessions.append(
+            {
+                "start_time": start_time,
+                "end_time": end_time_sleep,
+            }
+        )
+
+        current_time = end_time_sleep
+        birth_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
+        day_number = (current_time - birth_time).days
+
+    return sleep_sessions
+
+
+def generate_showcase_data(reference_time: datetime | None = None) -> dict:
+    """
+    Generate all test data with timestamps relative to reference time.
+
+    Args:
+        reference_time: The "now" time to use as reference.
+            Defaults to current time.
+
+    Returns:
+        Dictionary containing all test data
+    """
+    if reference_time is None:
+        reference_time = datetime.now()
+
+    return {
+        "users": SHOWCASE_USERS,
+        "child": get_child_data(reference_time),
+        "feedings": get_feeding_schedule(reference_time),
+        "diapers": get_diaper_changes(reference_time),
+        "sleep": get_sleep_sessions(reference_time),
+        "reference_time": reference_time,
+    }

src/baby_monitor/main.py

@@ -14,6 +14,8 @@ 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.diaper_change import router as diaper_change_router
+from baby_monitor.routers.sleep import router as sleep_router
 from baby_monitor.routers.health import router as health_router
 from baby_monitor.repositories.dependencies.get_database import init_db
 
@@ -51,6 +53,8 @@ app.include_router(auth_router)
 app.include_router(admin_router)
 app.include_router(child_router)
 app.include_router(feeding_router)
+app.include_router(diaper_change_router)
+app.include_router(sleep_router)
 app.include_router(health_router)
 
 
@@ -97,6 +101,48 @@ def serve_feedings() -> FileResponse:
     return FileResponse(static_path / "feedings.html")
 
 
+@app.get("/diapers.html", include_in_schema=False)
+def serve_diapers() -> FileResponse:
+    """Serve the diaper changes overview page."""
+    return FileResponse(static_path / "diapers.html")
+
+
+@app.get("/log-diaper.html", include_in_schema=False)
+def serve_log_diaper() -> FileResponse:
+    """Serve the log diaper change page."""
+    return FileResponse(static_path / "log-diaper.html")
+
+
+@app.get("/sleep.html", include_in_schema=False)
+def serve_sleep() -> FileResponse:
+    """Serve the sleep overview page."""
+    return FileResponse(static_path / "sleep.html")
+
+
+@app.get("/log-sleep.html", include_in_schema=False)
+def serve_log_sleep() -> FileResponse:
+    """Serve the log sleep page."""
+    return FileResponse(static_path / "log-sleep.html")
+
+
+@app.get("/settings.html", include_in_schema=False)
+def serve_settings() -> FileResponse:
+    """Serve the settings page."""
+    return FileResponse(static_path / "settings.html")
+
+
+@app.get("/menu.css", include_in_schema=False)
+def serve_menu_css() -> FileResponse:
+    """Serve the shared menu CSS."""
+    return FileResponse(static_path / "menu.css")
+
+
+@app.get("/menu.js", include_in_schema=False)
+def serve_menu_js() -> FileResponse:
+    """Serve the shared menu JavaScript."""
+    return FileResponse(static_path / "menu.js")
+
+
 @app.get("/api/")
 def read_root(token: Annotated[str, Depends(verify_token)]) -> dict:
     """API root endpoint (requires authentication)."""

src/baby_monitor/models/child.py

@@ -19,5 +19,6 @@ class ChildResponse(BaseModel):
     name: str
     birth_time: datetime
     birth_weight: float
-    user_id: int
     created_at: datetime
+    parent_count: int | None = None
+    parent_usernames: list[str] | None = None

src/baby_monitor/models/child_invitation.py

@@ -0,0 +1,41 @@
+"""Child invitation model for sharing child access."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+from sqlalchemy import Boolean, DateTime, Integer, String, ForeignKey
+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 ChildInvitation(Base):
+    """Invitation code for sharing child access with other users."""
+
+    __tablename__ = "child_invitations"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    code: Mapped[str] = mapped_column(String, unique=True, nullable=False)
+    child_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("children.id"), nullable=False
+    )
+    created_by_user_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("users.id"), nullable=False
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False
+    )
+    expires_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False
+    )
+    is_consumed: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    consumed_by_user_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("users.id"), nullable=True
+    )
+    consumed_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )

src/baby_monitor/models/db/child.py

@@ -1,7 +1,7 @@
 """Child database model."""
 
 from typing import TYPE_CHECKING
-from sqlalchemy import Column, Integer, String, DateTime, Float, ForeignKey
+from sqlalchemy import Column, Integer, String, DateTime, Float
 from datetime import datetime
 
 if TYPE_CHECKING:
@@ -19,10 +19,11 @@ class Child(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     name = Column(String, nullable=False)
-    birth_time = Column(DateTime, nullable=False)
+    birth_time = Column(DateTime(timezone=True), nullable=False)
     birth_weight = Column(Float, nullable=False)  # in grams
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    created_at = Column(
-    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+        DateTime(timezone=True), default=datetime.utcnow, nullable=False
+    )
 
     def __repr__(self) -> str:
-        return f"<Child(id={self.id}, name='{self.name}', user_id={self.user_id})>"
+        return f"<Child(id={self.id}, name='{self.name}')>"

src/baby_monitor/models/db/child_parent.py

@@ -0,0 +1,31 @@
+"""Child-Parent junction table for many-to-many relationship."""
+
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, Integer, ForeignKey, DateTime
+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 ChildParent(Base):
+    """Junction table linking children to their parents (users)."""
+
+    __tablename__ = "child_parents"
+
+    id = Column(Integer, primary_key=True, index=True)
+    child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    created_at = Column(
+        DateTime(timezone=True), default=datetime.utcnow, nullable=False
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<ChildParent(id={self.id}, "
+            f"child_id={self.child_id}, user_id={self.user_id})>"
+        )

src/baby_monitor/models/db/diaper_change.py

@@ -0,0 +1,32 @@
+"""Diaper change 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 DiaperChange(Base):
+    """Diaper change log database model."""
+
+    __tablename__ = "diaper_changes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
+    change_time = Column(DateTime(timezone=True), nullable=False)
+    poop_amount = Column(String, nullable=True)  # stores PoopAmount enum
+    poop_color = Column(String, nullable=True)  # stores PoopColor enum
+    pee_amount = Column(String, nullable=True)  # stores PeeAmount enum
+    pee_color = Column(String, nullable=True)  # stores PeeColor enum
+    created_at = Column(
+        DateTime(timezone=True), default=datetime.now(UTC), nullable=False
+    )
+
+    def __repr__(self) -> str:
+        return f"<DiaperChange(id={self.id}, child_id={self.child_id})>"

src/baby_monitor/models/db/feeding.py

@@ -19,10 +19,12 @@ class Feeding(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
-    start_time = Column(DateTime, nullable=False)
+    start_time = Column(DateTime(timezone=True), nullable=False)
-    end_time = Column(DateTime, nullable=True)
+    end_time = Column(DateTime(timezone=True), nullable=True)
     feeding_type = Column(String, nullable=False)  # stores FeedingType enum
-    created_at = Column(DateTime, default=datetime.now(UTC), nullable=False)
+    created_at = Column(
+        DateTime(timezone=True), 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/sleep.py

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

src/baby_monitor/models/db/user.py

@@ -21,7 +21,9 @@ class User(Base):
     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)
+    created_at = Column(
+        DateTime(timezone=True), default=datetime.utcnow, nullable=False
+    )
 
     def __repr__(self) -> str:
         return f"<User(id={self.id}, username='{self.username}')>"

src/baby_monitor/models/diaper_change.py

@@ -0,0 +1,46 @@
+"""Diaper change-related request and response models."""
+
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from baby_monitor.models.enums import (
+    PeeAmount,
+    PeeColor,
+    PoopAmount,
+    PoopColor,
+)
+
+
+class CreateDiaperChangeRequest(BaseModel):
+    """Request model for creating a diaper change log."""
+
+    child_id: int = Field(..., gt=0)
+    change_time: datetime
+    poop_amount: PoopAmount | None = None
+    poop_color: PoopColor | None = None
+    pee_amount: PeeAmount | None = None
+    pee_color: PeeColor | None = None
+
+
+class UpdateDiaperChangeRequest(BaseModel):
+    """Request model for updating a diaper change log."""
+
+    change_time: datetime | None = None
+    poop_amount: PoopAmount | None = None
+    poop_color: PoopColor | None = None
+    pee_amount: PeeAmount | None = None
+    pee_color: PeeColor | None = None
+
+
+class DiaperChangeResponse(BaseModel):
+    """Response model for diaper change log data."""
+
+    id: int
+    child_id: int
+    change_time: datetime
+    poop_amount: str | None
+    poop_color: str | None
+    pee_amount: str | None
+    pee_color: str | None
+    created_at: datetime
+    child_name: str | None = None  # Optional, populated when needed

src/baby_monitor/models/enums.py

@@ -9,3 +9,36 @@ class FeedingType(StrEnum):
     LEFT_BREAST = "left_breast"
     RIGHT_BREAST = "right_breast"
     BOTTLE = "bottle"
+
+
+class PoopAmount(StrEnum):
+    """Enumeration of poop amounts."""
+
+    LIGHT = "light"
+    MEDIUM = "medium"
+    HEAVY = "heavy"
+
+
+class PoopColor(StrEnum):
+    """Enumeration of poop colors."""
+
+    BLACK = "black"
+    YELLOW = "yellow"
+    GREEN = "green"
+    BROWN = "brown"
+
+
+class PeeAmount(StrEnum):
+    """Enumeration of pee amounts."""
+
+    LIGHT = "light"
+    MEDIUM = "medium"
+    HEAVY = "heavy"
+
+
+class PeeColor(StrEnum):
+    """Enumeration of pee colors."""
+
+    CLEAR = "clear"
+    YELLOW = "yellow"
+    RED = "red"

src/baby_monitor/models/sleep.py

@@ -0,0 +1,29 @@
+"""Sleep-related request and response models."""
+
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class CreateSleepRequest(BaseModel):
+    """Request model for creating a sleep log."""
+
+    child_id: int = Field(..., gt=0)
+    start_time: datetime
+    end_time: datetime | None = None
+
+
+class UpdateSleepRequest(BaseModel):
+    """Request model for updating a sleep log."""
+
+    end_time: datetime | None = None
+
+
+class SleepResponse(BaseModel):
+    """Response model for sleep log data."""
+
+    id: int
+    child_id: int
+    start_time: datetime
+    end_time: datetime | None
+    created_at: datetime
+    child_name: str | None = None  # Optional, populated when needed

src/baby_monitor/repositories/__init__.py

@@ -1,13 +1,23 @@
 """Repository implementations package."""
 
 from baby_monitor.repositories.dependencies import (
+    get_child_repository,
     get_credentials_repository,
+    get_diaper_change_repository,
+    get_feeding_repository,
+    get_invitation_repository,
+    get_sleep_repository,
     get_token_repository,
     get_user_repository,
 )
 
 __all__ = [
+    "get_child_repository",
     "get_credentials_repository",
+    "get_diaper_change_repository",
+    "get_feeding_repository",
+    "get_invitation_repository",
+    "get_sleep_repository",
     "get_token_repository",
     "get_user_repository",
 ]

src/baby_monitor/repositories/child/sqlite_child.py

@@ -1,16 +1,23 @@
-"""SQLite implementation of child repository."""
+"""Database-agnostic implementation of child repository.
 
-from datetime import datetime
+Works with both SQLite and PostgreSQL.
+"""
+
+from datetime import datetime, UTC
 from sqlalchemy.orm import Session
 
-from baby_monitor.repositories.interfaces.child_repository_interface import (
+from baby_monitor.repositories.interfaces import (
     ChildRepositoryInterface,
 )
 from baby_monitor.models.db.child import Child
+from baby_monitor.models.db.child_parent import ChildParent
 
 
-class SQLiteChildRepository(ChildRepositoryInterface):
+class DatabaseChildRepository(ChildRepositoryInterface):
-    """SQLite implementation for child data access."""
+    """Database implementation for child data access.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
 
     def __init__(self, db: Session):
         self.db = db
@@ -18,23 +25,29 @@ class SQLiteChildRepository(ChildRepositoryInterface):
     def create(
         self, name: str, birth_time: datetime, birth_weight: float, user_id: int
     ) -> dict:
-        """Create a new child record."""
+        """Create a new child record and link to user."""
         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)
 
+        # Create the child-parent relationship
+        child_parent = ChildParent(
+            child_id=child.id,
+            user_id=user_id,
+        )
+        self.db.add(child_parent)
+        self.db.commit()
+
         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,
         }
 
@@ -49,13 +62,18 @@ class SQLiteChildRepository(ChildRepositoryInterface):
             "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."""
+        """Get all children for a specific user via junction table."""
-        children = self.db.query(Child).filter(Child.user_id == user_id).all()
+        # Join Child and ChildParent tables
+        children = (
+            self.db.query(Child)
+            .join(ChildParent, Child.id == ChildParent.child_id)
+            .filter(ChildParent.user_id == user_id)
+            .all()
+        )
 
         return [
             {
@@ -63,12 +81,59 @@ class SQLiteChildRepository(ChildRepositoryInterface):
                 "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 get_parent_ids(self, child_id: int) -> list[int]:
+        """Get all parent user IDs for a specific child."""
+        parent_ids = (
+            self.db.query(ChildParent.user_id)
+            .filter(ChildParent.child_id == child_id)
+            .all()
+        )
+        return [user_id for (user_id,) in parent_ids]
+
+    def remove_parent(self, child_id: int, user_id: int) -> bool:
+        """Remove a parent-child relationship."""
+        link = (
+            self.db.query(ChildParent)
+            .filter(
+                ChildParent.child_id == child_id,
+                ChildParent.user_id == user_id,
+            )
+            .first()
+        )
+        if link:
+            self.db.delete(link)
+            self.db.commit()
+            return True
+        return False
+
+    def add_parent(self, child_id: int, user_id: int) -> bool:
+        """Add a parent-child relationship."""
+        # Check if relationship already exists
+        existing = (
+            self.db.query(ChildParent)
+            .filter(
+                ChildParent.child_id == child_id,
+                ChildParent.user_id == user_id,
+            )
+            .first()
+        )
+        if existing:
+            return False
+
+        link = ChildParent(
+            child_id=child_id,
+            user_id=user_id,
+            created_at=datetime.now(UTC),
+        )
+        self.db.add(link)
+        self.db.commit()
+        return True
+
     def update(
         self,
         child_id: int,
@@ -96,16 +161,19 @@ class SQLiteChildRepository(ChildRepositoryInterface):
             "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."""
+        """Delete a child record and all parent relationships."""
         child = self.db.query(Child).filter(Child.id == child_id).first()
         if not child:
             return False
 
+        # Delete all parent relationships first
+        self.db.query(ChildParent).filter(ChildParent.child_id == child_id).delete()
+
+        # Delete the child
         self.db.delete(child)
         self.db.commit()
         return True

src/baby_monitor/repositories/child_invitation/__init__.py

@@ -0,0 +1,13 @@
+"""Child invitation repository implementations."""
+
+from baby_monitor.repositories.child_invitation.sqlite_child_invitation import (  # noqa: E501
+    DatabaseChildInvitationRepository,
+)
+
+# Keep old name for backward compatibility
+SQLiteChildInvitationRepository = DatabaseChildInvitationRepository
+
+__all__ = [
+    "DatabaseChildInvitationRepository",
+    "SQLiteChildInvitationRepository",
+]

src/baby_monitor/repositories/child_invitation/sqlite_child_invitation.py

@@ -0,0 +1,118 @@
+"""Database-agnostic implementation of child invitation repository.
+
+Supports both SQLite and PostgreSQL:
+- SQLite: stores datetimes as naive UTC
+- PostgreSQL: stores datetimes as timezone-aware
+"""
+
+from datetime import datetime, UTC
+from sqlalchemy.orm import Session
+from baby_monitor.models.child_invitation import ChildInvitation
+from baby_monitor.repositories.interfaces import (
+    ChildInvitationRepositoryInterface,
+)
+
+
+class DatabaseChildInvitationRepository(ChildInvitationRepositoryInterface):
+    """Database implementation of child invitation repository.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
+
+    def __init__(self, db: Session):
+        """Initialize the repository with a database session."""
+        self.db = db
+
+    def _get_now_utc(self, reference_dt: datetime) -> datetime:
+        """
+        Get current UTC time matching the timezone awareness of reference.
+
+        Args:
+            reference_dt: A datetime from DB to match timezone format
+
+        Returns:
+            Current UTC time (naive for SQLite, aware for PostgreSQL)
+        """
+        now = datetime.now(UTC)
+        if reference_dt.tzinfo is None:
+            # SQLite: return naive UTC
+            return now.replace(tzinfo=None)
+        # PostgreSQL: return timezone-aware
+        return now
+
+    def create_invitation(
+        self,
+        code: str,
+        child_id: int,
+        created_by_user_id: int,
+        expires_at: datetime,
+    ) -> int:
+        """Create a new child invitation."""
+        invitation = ChildInvitation(
+            code=code,
+            child_id=child_id,
+            created_by_user_id=created_by_user_id,
+            created_at=datetime.now(UTC),
+            expires_at=expires_at,
+            is_consumed=False,
+        )
+        self.db.add(invitation)
+        self.db.commit()
+        self.db.refresh(invitation)
+        return invitation.id
+
+    def get_by_code(self, code: str) -> dict | None:
+        """Get invitation by code."""
+        invitation = (
+            self.db.query(ChildInvitation).filter(ChildInvitation.code == code).first()
+        )
+        if not invitation:
+            return None
+
+        return {
+            "id": invitation.id,
+            "code": invitation.code,
+            "child_id": invitation.child_id,
+            "created_by_user_id": invitation.created_by_user_id,
+            "created_at": invitation.created_at,
+            "expires_at": invitation.expires_at,
+            "is_consumed": invitation.is_consumed,
+            "consumed_by_user_id": invitation.consumed_by_user_id,
+            "consumed_at": invitation.consumed_at,
+        }
+
+    def verify_invitation(self, code: str) -> bool:
+        """Verify if an invitation code is valid and not expired."""
+        invitation = (
+            self.db.query(ChildInvitation).filter(ChildInvitation.code == code).first()
+        )
+
+        if not invitation:
+            return False
+
+        if invitation.is_consumed:
+            return False
+
+        # Get current time matching database timezone format
+        now_utc = self._get_now_utc(invitation.expires_at)
+        if invitation.expires_at < now_utc:
+            return False
+
+        return True
+
+    def consume_invitation(
+        self, code: str, consumed_by_user_id: int, consumed_at: datetime
+    ) -> bool:
+        """Mark invitation as consumed."""
+        invitation = (
+            self.db.query(ChildInvitation).filter(ChildInvitation.code == code).first()
+        )
+
+        if not invitation:
+            return False
+
+        invitation.is_consumed = True
+        invitation.consumed_by_user_id = consumed_by_user_id
+        invitation.consumed_at = consumed_at
+        self.db.commit()
+        return True

src/baby_monitor/repositories/dependencies/__init__.py

@@ -1,11 +1,23 @@
 """Dependency injection for repositories."""
 
+from .get_child_invitation_repository import get_child_invitation_repository
+from .get_child_repository import get_child_repository
 from .get_credentials_repository import get_credentials_repository
+from .get_diaper_change_repository import get_diaper_change_repository
+from .get_feeding_repository import get_feeding_repository
+from .get_invitation_repository import get_invitation_repository
+from .get_sleep_repository import get_sleep_repository
 from .get_token_repository import get_token_repository
 from .get_user_repository import get_user_repository
 
 __all__ = [
-    "get_user_repository",
+    "get_child_invitation_repository",
-    "get_token_repository",
+    "get_child_repository",
     "get_credentials_repository",
+    "get_diaper_change_repository",
+    "get_feeding_repository",
+    "get_invitation_repository",
+    "get_sleep_repository",
+    "get_token_repository",
+    "get_user_repository",
 ]

src/baby_monitor/repositories/dependencies/get_child_invitation_repository.py

@@ -0,0 +1,19 @@
+"""Dependency for child invitation repository."""
+
+from typing import Annotated
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from baby_monitor.repositories.child_invitation.sqlite_child_invitation import (  # noqa: E501
+    DatabaseChildInvitationRepository,
+)
+from baby_monitor.repositories.interfaces import (
+    ChildInvitationRepositoryInterface,
+)
+from baby_monitor.repositories.dependencies.get_database import get_database
+
+
+def get_child_invitation_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> ChildInvitationRepositoryInterface:
+    """Get child invitation repository instance (works with any database)."""
+    return DatabaseChildInvitationRepository(db)

src/baby_monitor/repositories/dependencies/get_child_repository.py

@@ -5,11 +5,14 @@ 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
+from baby_monitor.repositories.child.sqlite_child import DatabaseChildRepository
+from baby_monitor.repositories.interfaces.child_repository_interface import (
+    ChildRepositoryInterface,
+)
 
 
 def get_child_repository(
     db: Annotated[Session, Depends(get_database)],
-) -> SQLiteChildRepository:
+) -> ChildRepositoryInterface:
-    """Get child repository instance."""
+    """Get child repository instance (works with any database)."""
-    return SQLiteChildRepository(db)
+    return DatabaseChildRepository(db)

src/baby_monitor/repositories/dependencies/get_database.py

@@ -10,18 +10,30 @@ from sqlalchemy.orm import declarative_base, sessionmaker, Session
 if TYPE_CHECKING:
     from sqlalchemy.orm import DeclarativeBase
 
-# Database directory
+# Database directory (used for SQLite)
 DATA_DIR = Path(os.getenv("DATA_DIR", "/data"))
 
-# SQLite database URL
+# Check for PostgreSQL URI, otherwise use SQLite
-DATABASE_URL = f"sqlite:///{DATA_DIR}/baby_monitor.db"
+POSTGRES_URI = os.getenv("POSTGRES_URI")
 
-# Create engine with check_same_thread=False for SQLite
+if POSTGRES_URI:
-engine = create_engine(
+    # Use PostgreSQL
-    DATABASE_URL,
+    DATABASE_URL = POSTGRES_URI
-    connect_args={"check_same_thread": False},
+    # PostgreSQL doesn't need special connect_args
-    echo=False,  # Set to True for SQL query logging
+    engine = create_engine(
-)
+        DATABASE_URL,
+        echo=False,  # Set to True for SQL query logging
+        pool_pre_ping=True,  # Verify connections before using them
+    )
+else:
+    # Use SQLite (default)
+    DATABASE_URL = f"sqlite:///{DATA_DIR}/baby_monitor.db"
+    # Create engine with check_same_thread=False for SQLite
+    engine = create_engine(
+        DATABASE_URL,
+        connect_args={"check_same_thread": False},
+        echo=False,  # Set to True for SQL query logging
+    )
 
 # Session factory
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@@ -33,7 +45,7 @@ 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
+    from baby_monitor.utils import hash_password
 
     admin_username = os.getenv("ADMIN_USERNAME")
     admin_password = os.getenv("ADMIN_PASSWORD")
@@ -78,11 +90,23 @@ def init_db() -> None:
     # 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.child_parent import (  # noqa: F401
+        ChildParent,
+    )
     from baby_monitor.models.db.feeding import Feeding  # noqa: F401
+    from baby_monitor.models.db.diaper_change import (  # noqa: F401
+        DiaperChange,
+    )
+    from baby_monitor.models.db.sleep import Sleep  # noqa: F401
     from baby_monitor.models.invitation import Invitation  # noqa: F401
+    from baby_monitor.models.child_invitation import (  # noqa: F401
+        ChildInvitation,
+    )
+
+    # Ensure data directory exists (only needed for SQLite)
+    if not POSTGRES_URI:
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
 
-    # 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

src/baby_monitor/repositories/dependencies/get_diaper_change_repository.py

@@ -0,0 +1,20 @@
+"""Dependency for getting diaper change 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.diaper_change.sqlite_diaper_change import (
+    DatabaseDiaperChangeRepository,
+)
+from baby_monitor.repositories.interfaces.diaper_change_repository_interface import (  # noqa: E501
+    DiaperChangeRepositoryInterface,
+)
+
+
+def get_diaper_change_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> DiaperChangeRepositoryInterface:
+    """Get diaper change repository instance (works with any database)."""
+    return DatabaseDiaperChangeRepository(db)

src/baby_monitor/repositories/dependencies/get_feeding_repository.py

@@ -6,12 +6,15 @@ from sqlalchemy.orm import Session
 
 from baby_monitor.repositories.dependencies.get_database import get_database
 from baby_monitor.repositories.feeding.sqlite_feeding import (
-    SQLiteFeedingRepository,
+    DatabaseFeedingRepository,
+)
+from baby_monitor.repositories.interfaces.feeding_repository_interface import (
+    FeedingRepositoryInterface,
 )
 
 
 def get_feeding_repository(
     db: Annotated[Session, Depends(get_database)],
-) -> SQLiteFeedingRepository:
+) -> FeedingRepositoryInterface:
-    """Get feeding repository instance."""
+    """Get feeding repository instance (works with any database)."""
-    return SQLiteFeedingRepository(db)
+    return DatabaseFeedingRepository(db)

src/baby_monitor/repositories/dependencies/get_invitation_repository.py

@@ -6,13 +6,16 @@ from sqlalchemy.orm import Session
 
 from baby_monitor.repositories.dependencies.get_database import get_database
 from baby_monitor.repositories.invitation.sqlite_invitation import (
-    SQLiteInvitationRepository,
+    DatabaseInvitationRepository,
+)
+from baby_monitor.repositories.interfaces.invitation_repository_interface import (
+    InvitationRepositoryInterface,
 )
 
 
 def get_invitation_repository(
     db: Annotated[Session, Depends(get_database)],
-) -> SQLiteInvitationRepository:
+) -> InvitationRepositoryInterface:
     """
     Provide an invitation repository instance.
 
@@ -20,6 +23,6 @@ def get_invitation_repository(
         db: Database session from dependency injection
 
     Returns:
-        SQLiteInvitationRepository instance
+        InvitationRepositoryInterface instance (works with any database)
     """
-    return SQLiteInvitationRepository(db)
+    return DatabaseInvitationRepository(db)

src/baby_monitor/repositories/dependencies/get_sleep_repository.py

@@ -0,0 +1,18 @@
+"""Dependency for getting sleep 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.sleep.sqlite_sleep import DatabaseSleepRepository
+from baby_monitor.repositories.interfaces.sleep_repository_interface import (
+    SleepRepositoryInterface,
+)
+
+
+def get_sleep_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> SleepRepositoryInterface:
+    """Get sleep repository instance (works with any database)."""
+    return DatabaseSleepRepository(db)

src/baby_monitor/repositories/dependencies/get_token_repository.py

@@ -6,7 +6,7 @@ import logging
 from baby_monitor.repositories.interfaces import (
     TokenRepositoryInterface,
 )
-from baby_monitor.repositories.token.memory_token import (
+from baby_monitor.repositories.token import (
     InMemoryTokenRepository,
 )
 
@@ -43,7 +43,7 @@ def _initialize_token_repository() -> TokenRepositoryInterface:
         ) from e
 
     try:
-        from baby_monitor.repositories.token.redis_token import (
+        from baby_monitor.repositories.token import (
             RedisTokenRepository,
         )
 

src/baby_monitor/repositories/dependencies/get_user_repository.py

@@ -11,7 +11,7 @@ from baby_monitor.repositories.interfaces import (
     UserRepositoryInterface,
 )
 from baby_monitor.repositories.user.sqlite_user import (
-    SQLiteUserRepository,
+    DatabaseUserRepository,
 )
 
 # Singleton instance
@@ -22,12 +22,12 @@ def get_user_repository(
     db: Annotated[Session, Depends(get_database)],
 ) -> UserRepositoryInterface:
     """
-    Get user repository instance.
+    Get user repository instance (works with any database).
     """
 
     global _user_repository
 
     if _user_repository is None:
-        _user_repository = SQLiteUserRepository(db)
+        _user_repository = DatabaseUserRepository(db)
 
     return _user_repository

src/baby_monitor/repositories/diaper_change/sqlite_diaper_change.py

@@ -0,0 +1,141 @@
+"""Database-agnostic implementation of diaper change repository.
+
+Works with both SQLite and PostgreSQL.
+"""
+
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.interfaces import (  # noqa: E501
+    DiaperChangeRepositoryInterface,
+)
+from baby_monitor.models.db.diaper_change import DiaperChange
+from baby_monitor.models.db.child import Child
+from baby_monitor.models.db.child_parent import ChildParent
+
+
+class DatabaseDiaperChangeRepository(DiaperChangeRepositoryInterface):
+    """Database implementation for diaper change log data access.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create(
+        self,
+        child_id: int,
+        change_time: datetime,
+        poop_amount: str | None = None,
+        poop_color: str | None = None,
+        pee_amount: str | None = None,
+        pee_color: str | None = None,
+    ) -> dict:
+        """Create a new diaper change log entry."""
+        diaper_change = DiaperChange(
+            child_id=child_id,
+            change_time=change_time,
+            poop_amount=poop_amount,
+            poop_color=poop_color,
+            pee_amount=pee_amount,
+            pee_color=pee_color,
+        )
+        self.db.add(diaper_change)
+        self.db.commit()
+        self.db.refresh(diaper_change)
+
+        return self._to_dict(diaper_change)
+
+    def get_by_id(self, diaper_change_id: int) -> dict | None:
+        """Get a diaper change log by ID."""
+        diaper_change = (
+            self.db.query(DiaperChange)
+            .filter(DiaperChange.id == diaper_change_id)
+            .first()
+        )
+        if not diaper_change:
+            return None
+        return self._to_dict(diaper_change)
+
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all diaper change logs for a specific child."""
+        diaper_changes = (
+            self.db.query(DiaperChange)
+            .filter(DiaperChange.child_id == child_id)
+            .order_by(DiaperChange.change_time.desc())
+            .all()
+        )
+        return [self._to_dict(dc) for dc in diaper_changes]
+
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all diaper change logs for a specific user's children."""
+        diaper_changes = (
+            self.db.query(DiaperChange)
+            .join(Child, DiaperChange.child_id == Child.id)
+            .join(ChildParent, Child.id == ChildParent.child_id)
+            .filter(ChildParent.user_id == user_id)
+            .order_by(DiaperChange.change_time.desc())
+            .all()
+        )
+        return [self._to_dict(dc) for dc in diaper_changes]
+
+    def update(
+        self,
+        diaper_change_id: int,
+        change_time: datetime | None = None,
+        poop_amount: str | None = None,
+        poop_color: str | None = None,
+        pee_amount: str | None = None,
+        pee_color: str | None = None,
+    ) -> dict | None:
+        """Update a diaper change log entry."""
+        diaper_change = (
+            self.db.query(DiaperChange)
+            .filter(DiaperChange.id == diaper_change_id)
+            .first()
+        )
+        if not diaper_change:
+            return None
+
+        if change_time is not None:
+            diaper_change.change_time = change_time  # type: ignore[assignment]
+        if poop_amount is not None:
+            diaper_change.poop_amount = poop_amount  # type: ignore[assignment]
+        if poop_color is not None:
+            diaper_change.poop_color = poop_color  # type: ignore[assignment]
+        if pee_amount is not None:
+            diaper_change.pee_amount = pee_amount  # type: ignore[assignment]
+        if pee_color is not None:
+            diaper_change.pee_color = pee_color  # type: ignore[assignment]
+
+        self.db.commit()
+        self.db.refresh(diaper_change)
+        return self._to_dict(diaper_change)
+
+    def delete(self, diaper_change_id: int) -> bool:
+        """Delete a diaper change log entry."""
+        diaper_change = (
+            self.db.query(DiaperChange)
+            .filter(DiaperChange.id == diaper_change_id)
+            .first()
+        )
+        if not diaper_change:
+            return False
+
+        self.db.delete(diaper_change)
+        self.db.commit()
+        return True
+
+    def _to_dict(self, diaper_change: DiaperChange) -> dict:
+        """Convert DiaperChange model to dictionary."""
+        return {
+            "id": diaper_change.id,
+            "child_id": diaper_change.child_id,
+            "change_time": diaper_change.change_time,
+            "poop_amount": diaper_change.poop_amount,
+            "poop_color": diaper_change.poop_color,
+            "pee_amount": diaper_change.pee_amount,
+            "pee_color": diaper_change.pee_color,
+            "created_at": diaper_change.created_at,
+        }

src/baby_monitor/repositories/feeding/sqlite_feeding.py

@@ -1,17 +1,24 @@
-"""SQLite implementation of feeding repository."""
+"""Database-agnostic implementation of feeding repository.
+
+Works with both SQLite and PostgreSQL.
+"""
 
 from datetime import datetime
 from sqlalchemy.orm import Session
 
-from baby_monitor.repositories.interfaces.feeding_repository_interface import (
+from baby_monitor.repositories.interfaces import (
     FeedingRepositoryInterface,
 )
 from baby_monitor.models.db.feeding import Feeding
 from baby_monitor.models.db.child import Child
+from baby_monitor.models.db.child_parent import ChildParent
 
 
-class SQLiteFeedingRepository(FeedingRepositoryInterface):
+class DatabaseFeedingRepository(FeedingRepositoryInterface):
-    """SQLite implementation for feeding log data access."""
+    """Database implementation for feeding log data access.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
 
     def __init__(self, db: Session):
         self.db = db
@@ -57,8 +64,9 @@ class SQLiteFeedingRepository(FeedingRepositoryInterface):
         """Get all feeding logs for a specific user's children."""
         feedings = (
             self.db.query(Feeding)
-            .join(Child)
+            .join(Child, Feeding.child_id == Child.id)
-            .filter(Child.user_id == user_id)
+            .join(ChildParent, Child.id == ChildParent.child_id)
+            .filter(ChildParent.user_id == user_id)
             .order_by(Feeding.start_time.desc())
             .all()
         )

src/baby_monitor/repositories/interfaces/__init__.py

@@ -1,5 +1,8 @@
 """Repository interfaces package."""
 
+from .child_invitation_interface import (
+    ChildInvitationRepositoryInterface,
+)
 from .credentials_repository_interface import (
     CredentialsRepositoryInterface,
 )
@@ -12,10 +15,27 @@ from .token_repository_interface import (
 from .user_repository_interface import (
     UserRepositoryInterface,
 )
+from .child_repository_interface import (
+    ChildRepositoryInterface,
+)
+from .feeding_repository_interface import (
+    FeedingRepositoryInterface,
+)
+from .diaper_change_repository_interface import (
+    DiaperChangeRepositoryInterface,
+)
+from .sleep_repository_interface import (
+    SleepRepositoryInterface,
+)
 
 __all__ = [
-    "UserRepositoryInterface",
+    "ChildInvitationRepositoryInterface",
-    "TokenRepositoryInterface",
+    "ChildRepositoryInterface",
     "CredentialsRepositoryInterface",
+    "DiaperChangeRepositoryInterface",
+    "FeedingRepositoryInterface",
     "InvitationRepositoryInterface",
+    "SleepRepositoryInterface",
+    "TokenRepositoryInterface",
+    "UserRepositoryInterface",
 ]

src/baby_monitor/repositories/interfaces/child_invitation_interface.py

@@ -0,0 +1,36 @@
+"""Repository interface for child invitation operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class ChildInvitationRepositoryInterface(ABC):
+    """Interface for child invitation repository operations."""
+
+    @abstractmethod
+    def create_invitation(
+        self,
+        code: str,
+        child_id: int,
+        created_by_user_id: int,
+        expires_at: datetime,
+    ) -> int:
+        """Create a new child invitation."""
+        pass
+
+    @abstractmethod
+    def get_by_code(self, code: str) -> dict | None:
+        """Get invitation by code."""
+        pass
+
+    @abstractmethod
+    def verify_invitation(self, code: str) -> bool:
+        """Verify if an invitation code is valid and not expired."""
+        pass
+
+    @abstractmethod
+    def consume_invitation(
+        self, code: str, consumed_by_user_id: int, consumed_at: datetime
+    ) -> bool:
+        """Mark invitation as consumed."""
+        pass

src/baby_monitor/repositories/interfaces/child_repository_interface.py

@@ -34,3 +34,15 @@ class ChildRepositoryInterface(ABC):
     @abstractmethod
     def delete(self, child_id: int) -> bool:
         """Delete a child record."""
+
+    @abstractmethod
+    def get_parent_ids(self, child_id: int) -> list[int]:
+        """Get all parent user IDs for a specific child."""
+
+    @abstractmethod
+    def remove_parent(self, child_id: int, user_id: int) -> bool:
+        """Remove a parent-child relationship."""
+
+    @abstractmethod
+    def add_parent(self, child_id: int, user_id: int) -> bool:
+        """Add a parent-child relationship."""

src/baby_monitor/repositories/interfaces/diaper_change_repository_interface.py

@@ -0,0 +1,48 @@
+"""Interface for diaper change repository operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class DiaperChangeRepositoryInterface(ABC):
+    """Interface for diaper change log data access operations."""
+
+    @abstractmethod
+    def create(
+        self,
+        child_id: int,
+        change_time: datetime,
+        poop_amount: str | None = None,
+        poop_color: str | None = None,
+        pee_amount: str | None = None,
+        pee_color: str | None = None,
+    ) -> dict:
+        """Create a new diaper change log entry."""
+
+    @abstractmethod
+    def get_by_id(self, diaper_change_id: int) -> dict | None:
+        """Get a diaper change log by ID."""
+
+    @abstractmethod
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all diaper change logs for a specific child."""
+
+    @abstractmethod
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all diaper change logs for a specific user's children."""
+
+    @abstractmethod
+    def update(
+        self,
+        diaper_change_id: int,
+        change_time: datetime | None = None,
+        poop_amount: str | None = None,
+        poop_color: str | None = None,
+        pee_amount: str | None = None,
+        pee_color: str | None = None,
+    ) -> dict | None:
+        """Update a diaper change log entry."""
+
+    @abstractmethod
+    def delete(self, diaper_change_id: int) -> bool:
+        """Delete a diaper change log entry."""

src/baby_monitor/repositories/interfaces/sleep_repository_interface.py

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

src/baby_monitor/repositories/interfaces/user_repository_interface.py

@@ -17,3 +17,15 @@ class UserRepositoryInterface(ABC):
     @abstractmethod
     def get_by_id(self, user_id: int) -> dict | None:
         """Get user by ID."""
+
+    @abstractmethod
+    def get_all(self) -> list[dict]:
+        """Get all users."""
+
+    @abstractmethod
+    def delete(self, user_id: int) -> bool:
+        """Delete a user by ID. Returns True if successful."""
+
+    @abstractmethod
+    def update_password(self, user_id: int, hashed_password: str) -> bool:
+        """Update user password. Returns True if successful."""

src/baby_monitor/repositories/invitation/__init__.py

@@ -1,7 +1,10 @@
 """Invitation repository implementations."""
 
 from baby_monitor.repositories.invitation.sqlite_invitation import (
-    SQLiteInvitationRepository,
+    DatabaseInvitationRepository,
 )
 
-__all__ = ["SQLiteInvitationRepository"]
+# Keep old name for backward compatibility
+SQLiteInvitationRepository = DatabaseInvitationRepository
+
+__all__ = ["DatabaseInvitationRepository", "SQLiteInvitationRepository"]

src/baby_monitor/repositories/invitation/sqlite_invitation.py

@@ -1,25 +1,49 @@
-"""SQLite implementation of invitation repository.
+"""Database-agnostic implementation of invitation repository.
 
-Note: SQLite does not support timezone-aware datetimes natively.
+Supports both SQLite and PostgreSQL:
-All datetimes are stored as naive UTC and converted at the application layer.
+- SQLite: stores datetimes as naive UTC
+- PostgreSQL: stores datetimes as timezone-aware
+
+The repository automatically adapts by checking the timezone awareness
+of datetimes returned from the database.
 """
 
 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 (
+from baby_monitor.repositories.interfaces import (
     InvitationRepositoryInterface,
 )
 
 
-class SQLiteInvitationRepository(InvitationRepositoryInterface):
+class DatabaseInvitationRepository(InvitationRepositoryInterface):
-    """SQLite implementation for managing invitation tokens."""
+    """Database implementation for managing invitation tokens.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
 
     def __init__(self, db: Session) -> None:
         """Initialize the repository with a database session."""
         self.db = db
 
+    def _get_now_utc(self, reference_dt: datetime) -> datetime:
+        """
+        Get current UTC time matching the timezone awareness of reference.
+
+        Args:
+            reference_dt: A datetime from DB to match timezone format
+
+        Returns:
+            Current UTC time (naive for SQLite, aware for PostgreSQL)
+        """
+        now = datetime.now(UTC)
+        if reference_dt.tzinfo is None:
+            # SQLite: return naive UTC
+            return now.replace(tzinfo=None)
+        # PostgreSQL: return timezone-aware
+        return now
+
     def create_invitation(
         self, token: str, created_by_user_id: int, expires_at: datetime
     ) -> None:
@@ -63,8 +87,8 @@ class SQLiteInvitationRepository(InvitationRepositoryInterface):
         if not invitation:
             return False
 
-        # Compare as naive UTC datetimes (SQLite stores without timezone)
+        # Get current time matching database timezone format
-        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        now_utc = self._get_now_utc(invitation.expires_at)
         if invitation.expires_at < now_utc:
             return False
 
@@ -89,8 +113,8 @@ class SQLiteInvitationRepository(InvitationRepositoryInterface):
         if not invitation:
             return False
 
-        # Compare as naive UTC datetimes (SQLite stores without timezone)
+        # Get current time matching database timezone format
-        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        now_utc = self._get_now_utc(invitation.expires_at)
         if invitation.expires_at < now_utc:
             return False
 
@@ -107,6 +131,14 @@ class SQLiteInvitationRepository(InvitationRepositoryInterface):
 
     def cleanup_expired(self) -> None:
         """Remove expired invitation tokens from storage."""
-        now_utc = datetime.now(UTC).replace(tzinfo=None)
+        # For cleanup, we need to get a sample to determine format
+        # Get any invitation to check timezone format
+        sample = self.db.query(Invitation).first()
+        if sample:
+            now_utc = self._get_now_utc(sample.expires_at)
+        else:
+            # No invitations, use naive UTC (safe default)
+            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/sleep/sqlite_sleep.py

@@ -0,0 +1,108 @@
+"""Database-agnostic implementation of sleep repository.
+
+Works with both SQLite and PostgreSQL.
+"""
+
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.interfaces import (
+    SleepRepositoryInterface,
+)
+from baby_monitor.models.db.sleep import Sleep
+from baby_monitor.models.db.child import Child
+from baby_monitor.models.db.child_parent import ChildParent
+
+
+class DatabaseSleepRepository(SleepRepositoryInterface):
+    """Database implementation for sleep log data access.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create(
+        self,
+        child_id: int,
+        start_time: datetime,
+        end_time: datetime | None = None,
+    ) -> dict:
+        """Create a new sleep log entry."""
+        sleep = Sleep(
+            child_id=child_id,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        self.db.add(sleep)
+        self.db.commit()
+        self.db.refresh(sleep)
+
+        return self._to_dict(sleep)
+
+    def get_by_id(self, sleep_id: int) -> dict | None:
+        """Get a sleep log by ID."""
+        sleep = self.db.query(Sleep).filter(Sleep.id == sleep_id).first()
+        if not sleep:
+            return None
+        return self._to_dict(sleep)
+
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all sleep logs for a specific child."""
+        sleeps = (
+            self.db.query(Sleep)
+            .filter(Sleep.child_id == child_id)
+            .order_by(Sleep.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(sleep) for sleep in sleeps]
+
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all sleep logs for a specific user's children."""
+        sleeps = (
+            self.db.query(Sleep)
+            .join(Child, Sleep.child_id == Child.id)
+            .join(ChildParent, Child.id == ChildParent.child_id)
+            .filter(ChildParent.user_id == user_id)
+            .order_by(Sleep.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(sleep) for sleep in sleeps]
+
+    def update(
+        self,
+        sleep_id: int,
+        end_time: datetime | None = None,
+    ) -> dict | None:
+        """Update a sleep log entry."""
+        sleep = self.db.query(Sleep).filter(Sleep.id == sleep_id).first()
+        if not sleep:
+            return None
+
+        if end_time is not None:
+            sleep.end_time = end_time  # type: ignore[assignment]
+
+        self.db.commit()
+        self.db.refresh(sleep)
+        return self._to_dict(sleep)
+
+    def delete(self, sleep_id: int) -> bool:
+        """Delete a sleep log entry."""
+        sleep = self.db.query(Sleep).filter(Sleep.id == sleep_id).first()
+        if not sleep:
+            return False
+
+        self.db.delete(sleep)
+        self.db.commit()
+        return True
+
+    def _to_dict(self, sleep: Sleep) -> dict:
+        """Convert Sleep model to dictionary."""
+        return {
+            "id": sleep.id,
+            "child_id": sleep.child_id,
+            "start_time": sleep.start_time,
+            "end_time": sleep.end_time,
+            "created_at": sleep.created_at,
+        }

src/baby_monitor/repositories/token/__init__.py

@@ -0,0 +1,11 @@
+"""Token repository implementations and configurations."""
+
+from .default_ttl import DEFAULT_TTL
+from .memory_token import InMemoryTokenRepository
+from .redis_token import RedisTokenRepository
+
+__all__ = [
+    "DEFAULT_TTL",
+    "InMemoryTokenRepository",
+    "RedisTokenRepository",
+]

src/baby_monitor/repositories/token/default_ttl.py

@@ -0,0 +1,3 @@
+"""Definition of Token default TTL."""
+
+DEFAULT_TTL = 28800  # seconds -> 8 hours

src/baby_monitor/repositories/token/memory_token.py

@@ -3,6 +3,7 @@
 from datetime import datetime, timedelta, UTC
 
 from baby_monitor.repositories.interfaces import TokenRepositoryInterface
+from baby_monitor.repositories.token import DEFAULT_TTL
 
 
 class InMemoryTokenRepository(TokenRepositoryInterface):
@@ -17,13 +18,16 @@ class InMemoryTokenRepository(TokenRepositoryInterface):
         # token -> (user_id, expiry_time)
         self._tokens: dict[str, tuple[int, datetime]] = {}
 
-    def store(self, token: str, user_id: int, ttl: int = 3600) -> None:
+    def store(self, token: str, user_id: int, ttl: int = DEFAULT_TTL) -> None:
         """Store a token with TTL (time to live in seconds)."""
         expiry = datetime.now(UTC) + timedelta(seconds=ttl)
         self._tokens[token] = (user_id, expiry)
 
     def verify(self, token: str) -> int | None:
-        """Verify token and return user_id if valid, None otherwise."""
+        """Verify token and return user_id if valid, None otherwise.
+
+        Implements sliding expiration: extends token lifetime on each verification.
+        """
         if token not in self._tokens:
             return None
 
@@ -34,6 +38,10 @@ class InMemoryTokenRepository(TokenRepositoryInterface):
             del self._tokens[token]
             return None
 
+        # Sliding expiration: extend the token lifetime
+        new_expiry = datetime.now(UTC) + timedelta(seconds=DEFAULT_TTL)
+        self._tokens[token] = (user_id, new_expiry)
+
         return user_id
 
     def invalidate(self, token: str) -> None:

src/baby_monitor/repositories/token/redis_token.py

@@ -3,14 +3,14 @@
 from typing import Any
 
 from baby_monitor.repositories.interfaces import TokenRepositoryInterface
+from baby_monitor.repositories.token import DEFAULT_TTL
 
 
 class RedisTokenRepository(TokenRepositoryInterface):
     """
     Redis-based token storage.
 
-    Requires redis package: pip install redis
+    This implementation uses Redis to store tokens with TTL. Implements sliding expiration.
-    Set REDIS_URI environment variable (e.g., redis://localhost:6379/0)
     """
 
     def __init__(self, redis_client: Any) -> None:
@@ -22,16 +22,21 @@ class RedisTokenRepository(TokenRepositoryInterface):
         """
         self.redis = redis_client
 
-    def store(self, token: str, user_id: int, ttl: int = 3600) -> None:
+    def store(self, token: str, user_id: int, ttl: int = DEFAULT_TTL) -> None:
         """Store a token with TTL (time to live in seconds)."""
         key = f"token:{token}"
         self.redis.setex(key, ttl, str(user_id))
 
     def verify(self, token: str) -> int | None:
-        """Verify token and return user_id if valid, None otherwise."""
+        """Verify token and return user_id if valid, None otherwise.
+
+        Implements sliding expiration: extends token lifetime on verification.
+        """
         key = f"token:{token}"
         user_id_str = self.redis.get(key)
         if user_id_str:
+            # Sliding expiration: extend the token lifetime
+            self.redis.expire(key, DEFAULT_TTL)
             return int(user_id_str)
         return None
 

src/baby_monitor/repositories/user/postgresql_user.py

@@ -1,64 +0,0 @@
-"""PostgreSQL user repository (future implementation)."""
-
-from sqlalchemy.orm import Session
-
-from baby_monitor.repositories.interfaces import UserRepositoryInterface
-from baby_monitor.models.db.user import User
-
-
-class PostgreSQLUserRepository(UserRepositoryInterface):
-    """
-    PostgreSQL-based user repository.
-
-    This implementation uses the same SQLAlchemy models as SQLite,
-    just with a different database engine.
-
-    To use this implementation:
-    1. Add psycopg2-binary dependency
-    2. Update DATABASE_URL in database.py:
-       DATABASE_URL = os.getenv(
-           "DATABASE_URL",
-           "postgresql://user:password@localhost:5432/baby_monitor"
-       )
-    3. Replace SQLiteUserRepository with this in dependencies
-    """
-
-    def __init__(self, db: Session):
-        self.db = db
-
-    def get_by_username(self, username: str) -> dict | None:
-        """Get user by username."""
-        user = self.db.query(User).filter(User.username == username).first()
-        if user:
-            return {
-                "id": user.id,
-                "username": user.username,
-                "hashed_password": user.hashed_password,
-                "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)
-        self.db.add(user)
-        self.db.commit()
-        self.db.refresh(user)
-        return {
-            "id": user.id,
-            "username": user.username,
-            "hashed_password": user.hashed_password,
-            "created_at": user.created_at,
-        }
-
-    def get_by_id(self, user_id: int) -> dict | None:
-        """Get user by ID."""
-        user = self.db.query(User).filter(User.id == user_id).first()
-        if user:
-            return {
-                "id": user.id,
-                "username": user.username,
-                "hashed_password": user.hashed_password,
-                "created_at": user.created_at,
-            }
-        return None

src/baby_monitor/repositories/user/sqlite_user.py

@@ -1,4 +1,7 @@
-"""SQLite implementation of user repository."""
+"""Database-agnostic implementation of user repository.
+
+Works with both SQLite and PostgreSQL.
+"""
 
 from sqlalchemy.orm import Session
 
@@ -6,8 +9,11 @@ from baby_monitor.repositories.interfaces import UserRepositoryInterface
 from baby_monitor.models.db.user import User
 
 
-class SQLiteUserRepository(UserRepositoryInterface):
+class DatabaseUserRepository(UserRepositoryInterface):
-    """SQLite-based user repository."""
+    """Database-based user repository.
+
+    Works with both SQLite and PostgreSQL databases.
+    """
 
     def __init__(self, db: Session):
         self.db = db
@@ -55,3 +61,35 @@ class SQLiteUserRepository(UserRepositoryInterface):
                 "created_at": user.created_at,
             }
         return None
+
+    def get_all(self) -> list[dict]:
+        """Get all users."""
+        users = self.db.query(User).all()
+        return [
+            {
+                "id": user.id,
+                "username": user.username,
+                "hashed_password": user.hashed_password,
+                "is_admin": user.is_admin,
+                "created_at": user.created_at,
+            }
+            for user in users
+        ]
+
+    def delete(self, user_id: int) -> bool:
+        """Delete a user by ID. Returns True if successful."""
+        user = self.db.query(User).filter(User.id == user_id).first()
+        if user:
+            self.db.delete(user)
+            self.db.commit()
+            return True
+        return False
+
+    def update_password(self, user_id: int, hashed_password: str) -> bool:
+        """Update user password. Returns True if successful."""
+        user = self.db.query(User).filter(User.id == user_id).first()
+        if user:
+            user.hashed_password = hashed_password  # type: ignore
+            self.db.commit()
+            return True
+        return False

src/baby_monitor/routers/admin.py

@@ -3,15 +3,25 @@
 import secrets
 from datetime import datetime, timedelta, UTC
 from typing import Annotated
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 
 from baby_monitor.routers.auth import verify_admin
-from baby_monitor.repositories.dependencies.get_invitation_repository import (
+from baby_monitor.repositories.dependencies import (
     get_invitation_repository,
+    get_user_repository,
+    get_child_repository,
+    get_feeding_repository,
+    get_diaper_change_repository,
+    get_sleep_repository,
 )
 from baby_monitor.repositories.interfaces import (
     InvitationRepositoryInterface,
+    UserRepositoryInterface,
+    ChildRepositoryInterface,
+    FeedingRepositoryInterface,
+    DiaperChangeRepositoryInterface,
+    SleepRepositoryInterface,
 )
 
 router = APIRouter(prefix="/api/admin", tags=["admin"])
@@ -64,3 +74,172 @@ async def generate_invitation_link(
         expires_at=expires_at.isoformat(),
         message="Invitation link generated successfully. Valid for 24 hours.",
     )
+
+
+class UserResponse(BaseModel):
+    """Response model for user data."""
+
+    id: int
+    username: str
+    is_admin: bool
+    created_at: datetime
+
+
+class DeleteUserResponse(BaseModel):
+    """Response model for user deletion."""
+
+    message: str
+    deleted_children: list[int]
+    deleted_feedings: int
+    deleted_diapers: int
+    deleted_sleeps: int
+
+
+@router.get("/users", response_model=list[UserResponse])
+async def get_all_users(
+    admin_id: Annotated[int, Depends(verify_admin)],
+    user_repository: Annotated[
+        UserRepositoryInterface,
+        Depends(get_user_repository),
+    ],
+) -> list[UserResponse]:
+    """Get all users in the system.
+
+    Requires admin role.
+
+    Args:
+        admin_id: Admin user ID (from verify_admin)
+        user_repository: User storage backend
+
+    Returns:
+        List of all users with their basic information
+    """
+    users = user_repository.get_all()
+    return [
+        UserResponse(
+            id=user["id"],
+            username=user["username"],
+            is_admin=user["is_admin"],
+            created_at=user["created_at"],
+        )
+        for user in users
+    ]
+
+
+@router.delete("/users/{user_id}", response_model=DeleteUserResponse)
+async def delete_user(
+    user_id: int,
+    admin_id: Annotated[int, Depends(verify_admin)],
+    user_repository: Annotated[
+        UserRepositoryInterface,
+        Depends(get_user_repository),
+    ],
+    child_repository: Annotated[
+        ChildRepositoryInterface,
+        Depends(get_child_repository),
+    ],
+    feeding_repository: Annotated[
+        FeedingRepositoryInterface,
+        Depends(get_feeding_repository),
+    ],
+    diaper_repository: Annotated[
+        DiaperChangeRepositoryInterface,
+        Depends(get_diaper_change_repository),
+    ],
+    sleep_repository: Annotated[
+        SleepRepositoryInterface,
+        Depends(get_sleep_repository),
+    ],
+) -> DeleteUserResponse:
+    """Delete a user and cascade delete orphaned children and their logs.
+
+    When a user is deleted:
+    1. Find all children belonging to this user
+    2. For each child, check if other users also have this child
+    3. Delete only children that have no other parents (orphaned)
+    4. For orphaned children, delete all associated logs (feedings, diapers, sleep)
+    5. Finally delete the user
+
+    Requires admin role.
+
+    Args:
+        user_id: ID of user to delete
+        admin_id: Admin user ID (from verify_admin)
+        user_repository: User storage backend
+        child_repository: Child storage backend
+        feeding_repository: Feeding storage backend
+        diaper_repository: Diaper change storage backend
+        sleep_repository: Sleep storage backend
+
+    Returns:
+        DeleteUserResponse with deletion summary
+
+    Raises:
+        HTTPException: If user not found or trying to delete yourself
+    """
+    # Prevent admin from deleting themselves
+    if user_id == admin_id:
+        raise HTTPException(status_code=400, detail="Cannot delete your own account")
+
+    # Check if user exists
+    user = user_repository.get_by_id(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Get all children belonging to this user
+    children = child_repository.get_by_user_id(user_id)
+
+    deleted_children_ids = []
+    total_feedings_deleted = 0
+    total_diapers_deleted = 0
+    total_sleeps_deleted = 0
+
+    # For each child, check if they have other parents
+    for child in children:
+        child_id = child["id"]
+
+        # Remove this user's relationship with the child
+        child_repository.remove_parent(child_id, user_id)
+
+        # Check if child has any remaining parents
+        remaining_parents = child_repository.get_parent_ids(child_id)
+
+        # Only delete child and logs if they have no other parents
+        if len(remaining_parents) == 0:
+            # Delete all logs for this orphaned child
+            feedings = feeding_repository.get_by_child_id(child_id)
+            for feeding in feedings:
+                feeding_repository.delete(feeding["id"])
+                total_feedings_deleted += 1
+
+            diapers = diaper_repository.get_by_child_id(child_id)
+            for diaper in diapers:
+                diaper_repository.delete(diaper["id"])
+                total_diapers_deleted += 1
+
+            sleeps = sleep_repository.get_by_child_id(child_id)
+            for sleep in sleeps:
+                sleep_repository.delete(sleep["id"])
+                total_sleeps_deleted += 1
+
+            # Delete the orphaned child
+            child_repository.delete(child_id)
+            deleted_children_ids.append(child_id)
+
+    # Finally, delete the user
+    user_repository.delete(user_id)
+
+    message = f"User '{user['username']}' deleted successfully"
+    if deleted_children_ids:
+        message += (
+            f" with {len(deleted_children_ids)} orphaned "
+            f"child{'ren' if len(deleted_children_ids) != 1 else ''}"
+        )
+
+    return DeleteUserResponse(
+        message=message,
+        deleted_children=deleted_children_ids,
+        deleted_feedings=total_feedings_deleted,
+        deleted_diapers=total_diapers_deleted,
+        deleted_sleeps=total_sleeps_deleted,
+    )

src/baby_monitor/routers/auth.py

@@ -1,8 +1,9 @@
 """Authentication router for login and user management."""
 
 import secrets
-from fastapi import APIRouter, HTTPException, Depends, Header
 from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends, Header
+from pydantic import BaseModel
 
 from baby_monitor.models.auth import (
     LoginRequest,
@@ -11,22 +12,35 @@ from baby_monitor.models.auth import (
     RegisterResponse,
 )
 from baby_monitor.repositories import (
+    get_child_repository,
+    get_diaper_change_repository,
+    get_feeding_repository,
+    get_invitation_repository,
+    get_sleep_repository,
     get_token_repository,
     get_user_repository,
 )
-from baby_monitor.repositories.dependencies.get_invitation_repository import (
-    get_invitation_repository,
-)
 from baby_monitor.repositories.interfaces import (
     TokenRepositoryInterface,
     UserRepositoryInterface,
     InvitationRepositoryInterface,
+    ChildRepositoryInterface,
+    FeedingRepositoryInterface,
+    DiaperChangeRepositoryInterface,
+    SleepRepositoryInterface,
 )
-from baby_monitor.utils.password import hash_password, verify_password
+from baby_monitor.utils import hash_password, verify_password
 
 router = APIRouter(prefix="/api", tags=["authentication"])
 
 
+class ChangePasswordRequest(BaseModel):
+    """Request model for password change."""
+
+    current_password: str
+    new_password: str
+
+
 def verify_token(
     authorization: Annotated[str | None, Header()] = None,
     token_repo: TokenRepositoryInterface = Depends(get_token_repository),
@@ -191,3 +205,97 @@ def get_current_user(
         "username": user["username"],
         "is_admin": user.get("is_admin", False),
     }
+
+
+@router.post("/change-password")
+def change_password(
+    request: ChangePasswordRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],  # noqa: E501
+) -> dict:
+    """Change password for the current user."""
+    # Get user with credentials
+    user = user_repo.get_by_id(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Verify current password
+    if not verify_password(request.current_password, user["hashed_password"]):
+        raise HTTPException(status_code=401, detail="Current password is incorrect")
+
+    # Hash new password
+    new_password_hash = hash_password(request.new_password)
+
+    # Update password
+    success = user_repo.update_password(user_id, new_password_hash)
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to update password")
+
+    return {"message": "Password changed successfully"}
+
+
+@router.delete("/account")
+def delete_account(
+    user_id: Annotated[int, Depends(verify_token)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],  # noqa: E501
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],  # noqa: E501
+    feeding_repo: Annotated[
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],  # noqa: E501
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],  # noqa: E501
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],  # noqa: E501
+) -> dict:
+    """Delete current user's account and cascade delete orphaned children."""
+    # Get user's children
+    children = child_repo.get_by_user_id(user_id)
+
+    deleted_children = []
+    deleted_feedings = 0
+    deleted_diapers = 0
+    deleted_sleeps = 0
+
+    # Process each child
+    for child in children:
+        child_id = child["id"]
+
+        # Remove the parent-child relationship
+        child_repo.remove_parent(child_id, user_id)
+
+        # Check if child has any remaining parents
+        remaining_parents = child_repo.get_parent_ids(child_id)
+
+        if len(remaining_parents) == 0:
+            # Child is orphaned, delete all logs first
+            feedings = feeding_repo.get_by_child_id(child_id)
+            for feeding in feedings:
+                feeding_repo.delete(feeding["id"])
+                deleted_feedings += 1
+
+            diapers = diaper_repo.get_by_child_id(child_id)
+            for diaper in diapers:
+                diaper_repo.delete(diaper["id"])
+                deleted_diapers += 1
+
+            sleeps = sleep_repo.get_by_child_id(child_id)
+            for sleep in sleeps:
+                sleep_repo.delete(sleep["id"])
+                deleted_sleeps += 1
+
+            # Now delete the child
+            child_repo.delete(child_id)
+            deleted_children.append(child["name"])
+
+    # Finally, delete the user
+    user_repo.delete(user_id)
+
+    return {
+        "message": "Account deleted successfully",
+        "deleted_children": deleted_children,
+        "deleted_logs": {
+            "feedings": deleted_feedings,
+            "diaper_changes": deleted_diapers,
+            "sleep_sessions": deleted_sleeps,
+        },
+    }

src/baby_monitor/routers/child.py

@@ -1,23 +1,53 @@
 """Child management router."""
 
+import secrets
+from datetime import datetime, timedelta, UTC
 from typing import Annotated
 from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
 
 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.interfaces import (
-from baby_monitor.repositories.dependencies.get_child_repository import (
+    ChildRepositoryInterface,
+    ChildInvitationRepositoryInterface,
+    UserRepositoryInterface,
+)
+from baby_monitor.repositories.dependencies import (
     get_child_repository,
+    get_child_invitation_repository,
+    get_user_repository,
 )
 
 router = APIRouter(prefix="/api/children", tags=["children"])
 
 
+class CreateChildInvitationRequest(BaseModel):
+    """Request model for creating a child invitation."""
+
+    child_id: int
+
+
+class ChildInvitationResponse(BaseModel):
+    """Response model for child invitation."""
+
+    code: str
+    child_id: int
+    expires_at: str
+    message: str
+
+
+class RedeemChildInvitationRequest(BaseModel):
+    """Request model for redeeming a child invitation."""
+
+    code: str
+
+
 @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)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> ChildResponse:
     """Create a new child for the authenticated user."""
     child = child_repo.create(
@@ -33,18 +63,37 @@ def create_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)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_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]
+
+    # Add parent information to each child
+    result = []
+    for child in children:
+        child_data = child.copy()
+        parent_ids = child_repo.get_parent_ids(child["id"])
+        child_data["parent_count"] = len(parent_ids)
+
+        # Get usernames of all parents
+        parent_usernames = []
+        for parent_id in parent_ids:
+            parent = user_repo.get_by_id(parent_id)
+            if parent:
+                parent_usernames.append(parent["username"])
+        child_data["parent_usernames"] = parent_usernames
+
+        result.append(ChildResponse(**child_data))
+
+    return result
 
 
 @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)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> ChildResponse:
     """Get a specific child by ID."""
     child = child_repo.get_by_id(child_id)
@@ -53,7 +102,8 @@ def get_child(
         raise HTTPException(status_code=404, detail="Child not found")
 
     # Verify the child belongs to the authenticated user
-    if child["user_id"] != user_id:
+    parent_ids = child_repo.get_parent_ids(child_id)
+    if user_id not in parent_ids:
         raise HTTPException(status_code=403, detail="Access denied")
 
     return ChildResponse(**child)
@@ -64,7 +114,7 @@ def update_child(
     child_id: int,
     request: CreateChildRequest,
     user_id: Annotated[int, Depends(verify_token)],
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> ChildResponse:
     """Update a child's information."""
     # First check if child exists and belongs to user
@@ -73,7 +123,8 @@ def update_child(
     if not child:
         raise HTTPException(status_code=404, detail="Child not found")
 
-    if child["user_id"] != user_id:
+    parent_ids = child_repo.get_parent_ids(child_id)
+    if user_id not in parent_ids:
         raise HTTPException(status_code=403, detail="Access denied")
 
     # Update the child
@@ -88,3 +139,93 @@ def update_child(
         raise HTTPException(status_code=500, detail="Update failed")
 
     return ChildResponse(**updated_child)
+
+
+@router.post("/invitations", response_model=ChildInvitationResponse)
+def create_child_invitation(
+    request: CreateChildInvitationRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+    invitation_repo: Annotated[
+        ChildInvitationRepositoryInterface,
+        Depends(get_child_invitation_repository),
+    ],
+) -> ChildInvitationResponse:
+    """Create an invitation code to share child access with another user."""
+    # Verify the child exists and user has access
+    child = child_repo.get_by_id(request.child_id)
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    parent_ids = child_repo.get_parent_ids(request.child_id)
+    if user_id not in parent_ids:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Generate a short invitation code (8 characters)
+    code = secrets.token_urlsafe(6)[:8].upper()
+
+    # Calculate expiration (7 days from now)
+    expires_at = datetime.now(UTC) + timedelta(days=7)
+
+    # Create the invitation
+    invitation_repo.create_invitation(
+        code=code,
+        child_id=request.child_id,
+        created_by_user_id=user_id,
+        expires_at=expires_at,
+    )
+
+    return ChildInvitationResponse(
+        code=code,
+        child_id=request.child_id,
+        expires_at=expires_at.isoformat(),
+        message="Invitation code created. Valid for 7 days.",
+    )
+
+
+@router.post("/invitations/redeem")
+def redeem_child_invitation(
+    request: RedeemChildInvitationRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+    invitation_repo: Annotated[
+        ChildInvitationRepositoryInterface,
+        Depends(get_child_invitation_repository),
+    ],
+) -> dict:
+    """Redeem an invitation code to gain access to a child."""
+    # Verify the invitation code
+    if not invitation_repo.verify_invitation(request.code):
+        raise HTTPException(
+            status_code=400, detail="Invalid or expired invitation code"
+        )
+
+    # Get the invitation details
+    invitation = invitation_repo.get_by_code(request.code)
+    if not invitation:
+        raise HTTPException(status_code=400, detail="Invalid invitation code")
+
+    child_id = invitation["child_id"]
+
+    # Check if user already has access to this child
+    parent_ids = child_repo.get_parent_ids(child_id)
+    if user_id in parent_ids:
+        raise HTTPException(
+            status_code=400, detail="You already have access to this child"
+        )
+
+    # Add user as a parent
+    child_repo.add_parent(child_id, user_id)
+
+    # Consume the invitation
+    invitation_repo.consume_invitation(request.code, user_id, datetime.now(UTC))
+
+    # Get child details
+    child = child_repo.get_by_id(child_id)
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    return {
+        "message": f"Successfully added access to {child['name']}",
+        "child": ChildResponse(**child),
+    }

src/baby_monitor/routers/diaper_change.py

@@ -0,0 +1,141 @@
+"""Diaper change log management router."""
+
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends
+
+from baby_monitor.models.diaper_change import (
+    CreateDiaperChangeRequest,
+    UpdateDiaperChangeRequest,
+    DiaperChangeResponse,
+)
+from baby_monitor.routers.auth import verify_token
+from baby_monitor.repositories.interfaces import (
+    DiaperChangeRepositoryInterface,
+    ChildRepositoryInterface,
+)
+from baby_monitor.repositories.dependencies import (
+    get_diaper_change_repository,
+    get_child_repository,
+)
+from baby_monitor.utils.verify_child_access import verify_child_access
+
+router = APIRouter(prefix="/api/diaper-changes", tags=["diaper-changes"])
+
+
+@router.post("", response_model=DiaperChangeResponse, status_code=201)
+def create_diaper_change(
+    request: CreateDiaperChangeRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> DiaperChangeResponse:
+    """Create a new diaper change log entry."""
+    # Verify the child belongs to the authenticated user
+    verify_child_access(child_repo, request.child_id, user_id)
+
+    diaper_change = diaper_repo.create(
+        child_id=request.child_id,
+        change_time=request.change_time,
+        poop_amount=request.poop_amount.value if request.poop_amount else None,
+        poop_color=request.poop_color.value if request.poop_color else None,
+        pee_amount=request.pee_amount.value if request.pee_amount else None,
+        pee_color=request.pee_color.value if request.pee_color else None,
+    )
+
+    return DiaperChangeResponse(**diaper_change)
+
+
+@router.get("", response_model=list[DiaperChangeResponse])
+def get_user_diaper_changes(
+    user_id: Annotated[int, Depends(verify_token)],
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],
+) -> list[DiaperChangeResponse]:
+    """Get all diaper change logs for the authenticated user's children."""
+    diaper_changes = diaper_repo.get_by_user_id(user_id)
+    return [DiaperChangeResponse(**dc) for dc in diaper_changes]
+
+
+@router.get("/{diaper_change_id}", response_model=DiaperChangeResponse)
+def get_diaper_change(
+    diaper_change_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> DiaperChangeResponse:
+    """Get a specific diaper change log by ID."""
+    diaper_change = diaper_repo.get_by_id(diaper_change_id)
+
+    if not diaper_change:
+        raise HTTPException(status_code=404, detail="Diaper change log not found")
+
+    # Verify the diaper change belongs to user's child
+    verify_child_access(child_repo, diaper_change["child_id"], user_id)
+
+    return DiaperChangeResponse(**diaper_change)
+
+
+@router.put("/{diaper_change_id}", response_model=DiaperChangeResponse)
+def update_diaper_change(
+    diaper_change_id: int,
+    request: UpdateDiaperChangeRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> DiaperChangeResponse:
+    """Update an existing diaper change log."""
+    diaper_change = diaper_repo.get_by_id(diaper_change_id)
+
+    if not diaper_change:
+        raise HTTPException(status_code=404, detail="Diaper change log not found")
+
+    # Verify the diaper change belongs to user's child
+    verify_child_access(child_repo, diaper_change["child_id"], user_id)
+
+    updated = diaper_repo.update(
+        diaper_change_id=diaper_change_id,
+        change_time=request.change_time,
+        poop_amount=request.poop_amount.value if request.poop_amount else None,
+        poop_color=request.poop_color.value if request.poop_color else None,
+        pee_amount=request.pee_amount.value if request.pee_amount else None,
+        pee_color=request.pee_color.value if request.pee_color else None,
+    )
+
+    if not updated:
+        raise HTTPException(
+            status_code=500, detail="Failed to update diaper change log"
+        )
+
+    return DiaperChangeResponse(**updated)
+
+
+@router.delete("/{diaper_change_id}", status_code=204)
+def delete_diaper_change(
+    diaper_change_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    diaper_repo: Annotated[
+        DiaperChangeRepositoryInterface, Depends(get_diaper_change_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> None:
+    """Delete a diaper change log."""
+    diaper_change = diaper_repo.get_by_id(diaper_change_id)
+
+    if not diaper_change:
+        raise HTTPException(status_code=404, detail="Diaper change log not found")
+
+    # Verify the diaper change belongs to user's child
+    verify_child_access(child_repo, diaper_change["child_id"], user_id)
+
+    success = diaper_repo.delete(diaper_change_id)
+    if not success:
+        raise HTTPException(
+            status_code=500, detail="Failed to delete diaper change log"
+        )

src/baby_monitor/routers/feeding.py

@@ -9,16 +9,15 @@ from baby_monitor.models.feeding import (
     FeedingResponse,
 )
 from baby_monitor.routers.auth import verify_token
-from baby_monitor.repositories.feeding.sqlite_feeding import (
+from baby_monitor.repositories.interfaces import (
-    SQLiteFeedingRepository,
+    ChildRepositoryInterface,
+    FeedingRepositoryInterface,
 )
-from baby_monitor.repositories.dependencies.get_feeding_repository import (
+from baby_monitor.repositories.dependencies 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,
 )
+from baby_monitor.utils import verify_child_access
 
 router = APIRouter(prefix="/api/feedings", tags=["feedings"])
 
@@ -27,17 +26,14 @@ router = APIRouter(prefix="/api/feedings", tags=["feedings"])
 def create_feeding(
     request: CreateFeedingRequest,
     user_id: Annotated[int, Depends(verify_token)],
-    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    feeding_repo: Annotated[
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, 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)
+    verify_child_access(child_repo, request.child_id, user_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,
@@ -52,8 +48,10 @@ def create_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)],
+    feeding_repo: Annotated[
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, 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)
@@ -74,7 +72,9 @@ def get_active_feeding(
 @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)],
+    feeding_repo: Annotated[
+        FeedingRepositoryInterface, 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)
@@ -85,8 +85,10 @@ def get_user_feedings(
 def get_feeding(
     feeding_id: int,
     user_id: Annotated[int, Depends(verify_token)],
-    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    feeding_repo: Annotated[
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> FeedingResponse:
     """Get a specific feeding log by ID."""
     feeding = feeding_repo.get_by_id(feeding_id)
@@ -95,9 +97,7 @@ def get_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"])
+    verify_child_access(child_repo, feeding["child_id"], user_id)
-    if not child or child["user_id"] != user_id:
-        raise HTTPException(status_code=403, detail="Access denied")
 
     return FeedingResponse(**feeding)
 
@@ -107,8 +107,10 @@ def update_feeding(
     feeding_id: int,
     request: UpdateFeedingRequest,
     user_id: Annotated[int, Depends(verify_token)],
-    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    feeding_repo: Annotated[
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> FeedingResponse:
     """Update a feeding log entry."""
     feeding = feeding_repo.get_by_id(feeding_id)
@@ -117,16 +119,15 @@ def update_feeding(
         raise HTTPException(status_code=404, detail="Feeding log not found")
 
     # Verify ownership
-    child = child_repo.get_by_id(feeding["child_id"])
+    verify_child_access(child_repo, feeding["child_id"], user_id)
-    if not child or child["user_id"] != user_id:
-        raise HTTPException(status_code=403, detail="Access denied")
 
     # Update the feeding
+    feeding_type_value = request.feeding_type.value if request.feeding_type else None
     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,
+        feeding_type=feeding_type_value,
     )
 
     if not updated_feeding:
@@ -139,8 +140,10 @@ def update_feeding(
 def delete_feeding(
     feeding_id: int,
     user_id: Annotated[int, Depends(verify_token)],
-    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    feeding_repo: Annotated[
-    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+        FeedingRepositoryInterface, Depends(get_feeding_repository)
+    ],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
 ) -> None:
     """Delete a feeding log entry."""
     feeding = feeding_repo.get_by_id(feeding_id)
@@ -149,9 +152,7 @@ def delete_feeding(
         raise HTTPException(status_code=404, detail="Feeding log not found")
 
     # Verify ownership
-    child = child_repo.get_by_id(feeding["child_id"])
+    verify_child_access(child_repo, feeding["child_id"], user_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:

src/baby_monitor/routers/sleep.py

@@ -0,0 +1,142 @@
+"""Sleep log management router."""
+
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends
+
+from baby_monitor.models.sleep import (
+    CreateSleepRequest,
+    UpdateSleepRequest,
+    SleepResponse,
+)
+from baby_monitor.routers.auth import verify_token
+from baby_monitor.repositories.interfaces import (
+    SleepRepositoryInterface,
+    ChildRepositoryInterface,
+)
+from baby_monitor.repositories.dependencies import (
+    get_sleep_repository,
+    get_child_repository,
+)
+from baby_monitor.utils import verify_child_access
+
+router = APIRouter(prefix="/api/sleep", tags=["sleep"])
+
+
+@router.post("", response_model=SleepResponse, status_code=201)
+def create_sleep(
+    request: CreateSleepRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> SleepResponse:
+    """Create a new sleep log entry."""
+    # Verify the child belongs to the authenticated user
+    verify_child_access(child_repo, request.child_id, user_id)
+
+    sleep = sleep_repo.create(
+        child_id=request.child_id,
+        start_time=request.start_time,
+        end_time=request.end_time,
+    )
+
+    return SleepResponse(**sleep)
+
+
+@router.get("/active", response_model=SleepResponse | None)
+def get_active_sleep(
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> SleepResponse | None:
+    """Get the current active sleep (where end_time is null) for the user."""
+    sleeps = sleep_repo.get_by_user_id(user_id)
+
+    # Find the first sleep with no end_time
+    for sleep in sleeps:
+        if sleep["end_time"] is None:
+            # Get child info to include in response
+            child = child_repo.get_by_id(sleep["child_id"])
+            response_data = sleep.copy()
+            if child:
+                response_data["child_name"] = child["name"]
+            return SleepResponse(**response_data)
+
+    return None
+
+
+@router.get("", response_model=list[SleepResponse])
+def get_user_sleeps(
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+) -> list[SleepResponse]:
+    """Get all sleep logs for the authenticated user's children."""
+    sleeps = sleep_repo.get_by_user_id(user_id)
+    return [SleepResponse(**sleep) for sleep in sleeps]
+
+
+@router.get("/{sleep_id}", response_model=SleepResponse)
+def get_sleep(
+    sleep_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> SleepResponse:
+    """Get a specific sleep log by ID."""
+    sleep = sleep_repo.get_by_id(sleep_id)
+
+    if not sleep:
+        raise HTTPException(status_code=404, detail="Sleep log not found")
+
+    # Verify the sleep belongs to user's child
+    verify_child_access(child_repo, sleep["child_id"], user_id)
+
+    return SleepResponse(**sleep)
+
+
+@router.put("/{sleep_id}", response_model=SleepResponse)
+def update_sleep(
+    sleep_id: int,
+    request: UpdateSleepRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> SleepResponse:
+    """Update an existing sleep log."""
+    sleep = sleep_repo.get_by_id(sleep_id)
+
+    if not sleep:
+        raise HTTPException(status_code=404, detail="Sleep log not found")
+
+    # Verify the sleep belongs to user's child
+    verify_child_access(child_repo, sleep["child_id"], user_id)
+
+    updated = sleep_repo.update(
+        sleep_id=sleep_id,
+        end_time=request.end_time,
+    )
+
+    if not updated:
+        raise HTTPException(status_code=500, detail="Failed to update sleep log")
+
+    return SleepResponse(**updated)
+
+
+@router.delete("/{sleep_id}", status_code=204)
+def delete_sleep(
+    sleep_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    sleep_repo: Annotated[SleepRepositoryInterface, Depends(get_sleep_repository)],
+    child_repo: Annotated[ChildRepositoryInterface, Depends(get_child_repository)],
+) -> None:
+    """Delete a sleep log."""
+    sleep = sleep_repo.get_by_id(sleep_id)
+
+    if not sleep:
+        raise HTTPException(status_code=404, detail="Sleep log not found")
+
+    # Verify the sleep belongs to user's child
+    verify_child_access(child_repo, sleep["child_id"], user_id)
+
+    success = sleep_repo.delete(sleep_id)
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to delete sleep log")

src/baby_monitor/static/add-child.html

@@ -192,6 +192,23 @@
           Cancel
         </button>
       </form>
+
+      <div
+        id="skipOption"
+        style="text-align: center; margin-top: 20px; display: none"
+      >
+        <p style="color: #666; font-size: 14px; margin-bottom: 10px">
+          Want to accept a child share invitation first?
+        </p>
+        <button
+          type="button"
+          class="button secondary"
+          onclick="skipToHome()"
+          style="margin: 0"
+        >
+          Skip for now
+        </button>
+      </div>
     </div>
 
     <script>
@@ -205,11 +222,17 @@
       const urlParams = new URLSearchParams(window.location.search);
       const childId = urlParams.get("id");
       const isEditMode = !!childId;
+      const fromHome = urlParams.get("from") === "home"; // Check if redirected from home
 
       const form = document.getElementById("addChildForm");
       const messageDiv = document.getElementById("message");
       const submitBtn = document.getElementById("submitBtn");
 
+      // Show skip option if user was redirected from home (has no children)
+      if (fromHome && !isEditMode) {
+        document.getElementById("skipOption").style.display = "block";
+      }
+
       // Update page title and button text if editing
       if (isEditMode) {
         document.querySelector("h1").textContent = "✏️ Edit Child";
@@ -290,9 +313,9 @@
                 : "Child added successfully!",
               "success",
             );
-            // Redirect to home page after 1 second
+            // Redirect to settings page if editing, otherwise home page
             setTimeout(() => {
-              window.location.href = "/";
+              window.location.href = isEditMode ? "/settings.html" : "/";
             }, 1000);
           } else {
             showMessage(
@@ -315,6 +338,11 @@
       }
 
       function goBack() {
+        // Redirect to settings page if editing, otherwise home page
+        window.location.href = isEditMode ? "/settings.html" : "/";
+      }
+
+      function skipToHome() {
         window.location.href = "/";
       }
     </script>

src/baby_monitor/static/admin.html

@@ -185,6 +185,172 @@
         background: #c82333;
         box-shadow: 0 4px 12px rgba(220, 53, 69, 0.4);
       }
+
+      .user-management h2::before {
+        content: "👥";
+      }
+
+      .search-box {
+        width: 100%;
+        padding: 10px;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-size: 14px;
+        margin-bottom: 15px;
+      }
+
+      .user-list {
+        max-height: 400px;
+        overflow-y: auto;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+      }
+
+      .user-item {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 12px;
+        border-bottom: 1px solid #eee;
+        background: white;
+      }
+
+      .user-item:last-child {
+        border-bottom: none;
+      }
+
+      .user-item:hover {
+        background: #f8f9fa;
+      }
+
+      .user-info {
+        flex: 1;
+      }
+
+      .user-name {
+        font-weight: 600;
+        color: #333;
+        margin-bottom: 4px;
+      }
+
+      .user-meta {
+        font-size: 12px;
+        color: #666;
+      }
+
+      .admin-badge {
+        display: inline-block;
+        padding: 2px 8px;
+        background: #667eea;
+        color: white;
+        border-radius: 3px;
+        font-size: 11px;
+        font-weight: 600;
+        margin-left: 8px;
+      }
+
+      .delete-user-btn {
+        padding: 6px 12px;
+        background: #dc3545;
+        color: white;
+        border: none;
+        border-radius: 4px;
+        font-size: 13px;
+        cursor: pointer;
+        transition: background 0.2s;
+      }
+
+      .delete-user-btn:hover {
+        background: #c82333;
+      }
+
+      .delete-user-btn:disabled {
+        background: #ccc;
+        cursor: not-allowed;
+      }
+
+      .modal {
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1000;
+        justify-content: center;
+        align-items: center;
+      }
+
+      .modal.show {
+        display: flex;
+      }
+
+      .modal-content {
+        background: white;
+        padding: 30px;
+        border-radius: 8px;
+        max-width: 500px;
+        width: 90%;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+      }
+
+      .modal h3 {
+        color: #333;
+        margin-bottom: 15px;
+      }
+
+      .modal p {
+        color: #666;
+        margin-bottom: 20px;
+        line-height: 1.5;
+      }
+
+      .modal-buttons {
+        display: flex;
+        gap: 10px;
+        justify-content: flex-end;
+      }
+
+      .modal-button {
+        padding: 10px 20px;
+        border: none;
+        border-radius: 4px;
+        font-size: 14px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: background 0.2s;
+      }
+
+      .modal-button.cancel {
+        background: #6c757d;
+        color: white;
+      }
+
+      .modal-button.cancel:hover {
+        background: #5a6268;
+      }
+
+      .modal-button.confirm {
+        background: #dc3545;
+        color: white;
+      }
+
+      .modal-button.confirm:hover {
+        background: #c82333;
+      }
+
+      .empty-state {
+        text-align: center;
+        padding: 40px 20px;
+        color: #999;
+      }
+
+      .loading {
+        text-align: center;
+        padding: 20px;
+        color: #666;
+      }
     </style>
   </head>
   <body>
@@ -218,9 +384,46 @@
         <div id="error" class="error"></div>
       </div>
 
+      <div class="section user-management">
+        <h2>User Management</h2>
+        <p style="color: #666; margin-bottom: 15px; font-size: 14px">
+          View and manage all users in the system.
+        </p>
+
+        <input
+          type="text"
+          id="userSearch"
+          class="search-box"
+          placeholder="Search users by username..."
+          oninput="filterUsers()"
+        />
+
+        <div id="userListContainer" class="loading">Loading users...</div>
+      </div>
+
       <button class="button logout-button" onclick="logout()">Logout</button>
     </div>
 
+    <!-- Delete Confirmation Modal -->
+    <div class="modal" id="deleteModal">
+      <div class="modal-content">
+        <h3>⚠️ Confirm User Deletion</h3>
+        <p id="deleteMessage"></p>
+        <p style="color: #dc3545; font-weight: 600">
+          This action cannot be undone. All associated children and their logs
+          (feedings, diapers, sleep) will be permanently deleted.
+        </p>
+        <div class="modal-buttons">
+          <button class="modal-button cancel" onclick="closeDeleteModal()">
+            Cancel
+          </button>
+          <button class="modal-button confirm" onclick="confirmDelete()">
+            Delete User
+          </button>
+        </div>
+      </div>
+    </div>
+
     <script>
       // Check if user is authenticated and is admin
       const token = localStorage.getItem("access_token");
@@ -228,7 +431,10 @@
         window.location.href = "/login.html";
       }
 
-      // Verify user is admin
+      let allUsers = [];
+      let userToDelete = null;
+
+      // Verify user is admin and load data
       fetch("/api/me", {
         headers: {
           Authorization: `Bearer ${token}`,
@@ -240,12 +446,154 @@
             alert("Access denied. Admin privileges required.");
             window.location.href = "/";
           }
+          // Load users after verifying admin status
+          loadUsers();
         })
         .catch((error) => {
           console.error("Error verifying admin status:", error);
           window.location.href = "/login.html";
         });
 
+      async function loadUsers() {
+        const container = document.getElementById("userListContainer");
+
+        try {
+          const response = await fetch("/api/admin/users", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (!response.ok) {
+            throw new Error("Failed to load users");
+          }
+
+          allUsers = await response.json();
+          renderUsers(allUsers);
+        } catch (error) {
+          console.error("Error loading users:", error);
+          container.innerHTML = `
+            <div class="empty-state">
+              ❌ Failed to load users: ${error.message}
+            </div>
+          `;
+        }
+      }
+
+      function renderUsers(users) {
+        const container = document.getElementById("userListContainer");
+
+        if (users.length === 0) {
+          container.innerHTML = `
+            <div class="empty-state">
+              No users found.
+            </div>
+          `;
+          return;
+        }
+
+        container.className = "user-list";
+        container.innerHTML = users
+          .map(
+            (user) => `
+          <div class="user-item">
+            <div class="user-info">
+              <div class="user-name">
+                ${user.username}
+                ${user.is_admin ? '<span class="admin-badge">ADMIN</span>' : ""}
+              </div>
+              <div class="user-meta">
+                ID: ${user.id} • Created: ${new Date(user.created_at).toLocaleDateString()}
+              </div>
+            </div>
+            <button
+              class="delete-user-btn"
+              onclick="showDeleteModal(${user.id}, '${user.username}', ${user.is_admin})"
+              ${user.is_admin ? 'disabled title="Cannot delete admin users"' : ""}
+            >
+              Delete
+            </button>
+          </div>
+        `,
+          )
+          .join("");
+      }
+
+      function filterUsers() {
+        const searchTerm = document
+          .getElementById("userSearch")
+          .value.toLowerCase();
+        const filtered = allUsers.filter((user) =>
+          user.username.toLowerCase().includes(searchTerm),
+        );
+        renderUsers(filtered);
+      }
+
+      function showDeleteModal(userId, username, isAdmin) {
+        if (isAdmin) {
+          return; // Don't allow deleting admin users
+        }
+
+        userToDelete = { id: userId, username };
+        const modal = document.getElementById("deleteModal");
+        const message = document.getElementById("deleteMessage");
+
+        message.textContent = `Are you sure you want to delete user "${username}"?`;
+        modal.classList.add("show");
+      }
+
+      function closeDeleteModal() {
+        const modal = document.getElementById("deleteModal");
+        modal.classList.remove("show");
+        userToDelete = null;
+      }
+
+      async function confirmDelete() {
+        if (!userToDelete) return;
+
+        const modal = document.getElementById("deleteModal");
+        const confirmBtn = modal.querySelector(".modal-button.confirm");
+
+        confirmBtn.disabled = true;
+        confirmBtn.textContent = "Deleting...";
+
+        try {
+          const response = await fetch(`/api/admin/users/${userToDelete.id}`, {
+            method: "DELETE",
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.detail || "Failed to delete user");
+          }
+
+          const result = await response.json();
+
+          // Show success message
+          alert(
+            `✓ ${result.message}\n\n` +
+              `Deleted:\n` +
+              `• ${result.deleted_children.length} children\n` +
+              `• ${result.deleted_feedings} feedings\n` +
+              `• ${result.deleted_diapers} diaper changes\n` +
+              `• ${result.deleted_sleeps} sleep sessions`,
+          );
+
+          // Reload user list
+          await loadUsers();
+          closeDeleteModal();
+        } catch (error) {
+          console.error("Error deleting user:", error);
+          alert(`Failed to delete user: ${error.message}`);
+        } finally {
+          confirmBtn.disabled = false;
+          confirmBtn.textContent = "Delete User";
+        }
+      }
+
       async function generateLink() {
         const btn = document.getElementById("generateBtn");
         const linkContainer = document.getElementById("linkContainer");

src/baby_monitor/static/feedings.html

@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Feedings - Baby Monitor</title>
+    <link rel="stylesheet" href="/menu.css" />
     <style>
       * {
         margin: 0;
@@ -15,9 +16,11 @@
         font-family:
           -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
           Cantarell, sans-serif;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        background-color: #f0f0f0;
         min-height: 100vh;
-        padding: 20px;
+        max-width: 800px;
+        margin: 2rem auto;
+        padding: 0 1rem;
       }
 
       .container {
@@ -25,8 +28,6 @@
         border-radius: 12px;
         box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
         padding: 40px;
-        max-width: 1000px;
-        margin: 0 auto;
       }
 
       h1 {
@@ -71,6 +72,10 @@
         box-shadow: 0 4px 12px rgba(108, 117, 125, 0.4);
       }
 
+      .hidden {
+        display: none;
+      }
+
       .loading {
         text-align: center;
         padding: 40px;
@@ -113,6 +118,13 @@
       .chart-wrapper {
         position: relative;
         height: 300px;
+        max-width: 100%;
+        margin: 0 auto;
+      }
+
+      .chart-wrapper canvas {
+        max-width: 100%;
+        max-height: 100%;
       }
 
       .charts-row {
@@ -277,91 +289,9 @@
       .edit-button:hover {
         background: #5568d3;
       }
-
-      .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.logout {
-        color: #dc3545;
-        font-weight: 600;
-      }
     </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="menuHome">🏠 Home</div>
-      <div class="menu-item" id="menuAddChild">👶 Add Child</div>
-      <div class="menu-item logout" id="menuLogout">🚪 Logout</div>
-    </div>
-
     <div class="container">
       <h1>🍼 Feedings</h1>
       <p class="subtitle">Overview of all feeding sessions</p>
@@ -372,6 +302,7 @@
     </div>
 
     <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
+    <script src="/menu.js"></script>
     <script>
       // Check if user is authenticated
       const token = localStorage.getItem("access_token");
@@ -379,42 +310,24 @@
         window.location.href = "/login.html";
       }
 
+      // Initialize burger menu
+      initBurgerMenu({ includeHome: true });
+
       let allFeedings = [];
       let allChildren = [];
-      let currentDaysRange = 7;
+      let currentDaysRange =
-      let selectedChildId = null; // null means "All Children"
+        parseInt(localStorage.getItem("lastFeedingTimeRange")) || 7;
+      let selectedChildId = null; // null means show first/only child
+      let barChartInstance = null;
+      let pieChartInstance = null;
+      let durationChartInstance = null;
 
-      // Burger menu functionality
+      // Restore last selected child from localStorage
-      const burgerMenu = document.getElementById("burgerMenu");
+      const lastChildId = localStorage.getItem("lastFeedingChildFilter");
-      const menuOverlay = document.getElementById("menuOverlay");
+      if (lastChildId && lastChildId !== "all") {
-      const menuBackdrop = document.getElementById("menuBackdrop");
+        selectedChildId = parseInt(lastChildId);
-
-      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("menuHome").addEventListener("click", () => {
-        window.location.href = "/";
-      });
-
-      document.getElementById("menuAddChild").addEventListener("click", () => {
-        window.location.href = "/add-child.html";
-      });
-
-      document.getElementById("menuLogout").addEventListener("click", () => {
-        closeMenu();
-        logout();
-      });
-
       // Load feedings data
       async function loadFeedings() {
         try {
@@ -448,6 +361,11 @@
 
           if (response.ok) {
             allChildren = await response.json();
+
+            // Auto-select first child if no selection exists
+            if (selectedChildId === null && allChildren.length > 0) {
+              selectedChildId = allChildren[0].id;
+            }
           }
         } catch (error) {
           console.error("Error loading children:", error);
@@ -456,11 +374,13 @@
 
       function onDaysRangeChange(event) {
         currentDaysRange = parseInt(event.target.value);
+        localStorage.setItem("lastFeedingTimeRange", currentDaysRange);
         displayFeedings(allFeedings);
       }
 
       function onChildChange(event) {
-        selectedChildId = event.target.value === "all" ? null : parseInt(event.target.value);
+        selectedChildId = parseInt(event.target.value);
+        localStorage.setItem("lastFeedingChildFilter", event.target.value);
         displayFeedings(allFeedings);
       }
 
@@ -482,31 +402,48 @@
           const durationChartData = prepareDurationChartData(feedings);
 
           // Build child dropdown options
-          const childOptions = allChildren.map(child => 
+          const childOptions = allChildren
-            `<option value="${child.id}" ${selectedChildId === child.id ? 'selected' : ''}>${child.name}</option>`
+            .map(
-          ).join('');
+              (child) =>
+                `<option value="${child.id}" ${selectedChildId === child.id ? "selected" : ""}>${child.name}</option>`,
+            )
+            .join("");
 
           content.innerHTML = `
             <div class="controls">
-              <label for="childFilter">Child:</label>
+              ${
-              <select id="childFilter" onchange="onChildChange(event)">
+                allChildren.length === 1
-                <option value="all" ${selectedChildId === null ? 'selected' : ''}>All Children</option>
+                  ? `
-                ${childOptions}
+                <label for="childDisplay">Child:</label>
-              </select>
+                <input
+                  type="text"
+                  id="childDisplay"
+                  value="${allChildren[0].name}"
+                  readonly
+                  style="background-color: #f5f5f5; cursor: default; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 14px;"
+                />
+              `
+                  : `
+                <label for="childFilter">Child:</label>
+                <select id="childFilter" onchange="onChildChange(event)">
+                  ${childOptions}
+                </select>
+              `
+              }
 
               <label for="daysRange">Time Range:</label>
               <select id="daysRange" onchange="onDaysRangeChange(event)">
-                <option value="1" ${currentDaysRange === 1 ? 'selected' : ''}>Last 24 Hours</option>
+                <option value="1" ${currentDaysRange === 1 ? "selected" : ""}>Last 24 Hours</option>
-                <option value="3" ${currentDaysRange === 3 ? 'selected' : ''}>Last 3 Days</option>
+                <option value="3" ${currentDaysRange === 3 ? "selected" : ""}>Last 3 Days</option>
-                <option value="7" ${currentDaysRange === 7 ? 'selected' : ''}>Last 7 Days</option>
+                <option value="7" ${currentDaysRange === 7 ? "selected" : ""}>Last 7 Days</option>
-                <option value="14" ${currentDaysRange === 14 ? 'selected' : ''}>Last 14 Days</option>
+                <option value="14" ${currentDaysRange === 14 ? "selected" : ""}>Last 14 Days</option>
-                <option value="30" ${currentDaysRange === 30 ? 'selected' : ''}>Last 30 Days</option>
+                <option value="30" ${currentDaysRange === 30 ? "selected" : ""}>Last 30 Days</option>
-                <option value="90" ${currentDaysRange === 90 ? 'selected' : ''}>Last 90 Days</option>
+                <option value="90" ${currentDaysRange === 90 ? "selected" : ""}>Last 90 Days</option>
               </select>
             </div>
 
             <div class="chart-container">
-              <h2>Feedings Per Day (Last ${currentDaysRange} Day${currentDaysRange !== 1 ? 's' : ''})</h2>
+              <h2>Total Feeding Time (Last ${currentDaysRange} Day${currentDaysRange !== 1 ? "s" : ""})</h2>
               <div class="chart-wrapper">
                 <canvas id="feedingsChart"></canvas>
               </div>
@@ -533,7 +470,7 @@
           renderBarChart(barChartData);
           renderPieChart(pieChartData);
           renderDurationChart(durationChartData);
-          
+
           // Render feeding list
           renderFeedingList(feedings);
         }
@@ -553,7 +490,9 @@
 
         // Filter by selected child if applicable
         if (selectedChildId !== null) {
-          filteredFeedings = filteredFeedings.filter((f) => f.child_id === selectedChildId);
+          filteredFeedings = filteredFeedings.filter(
+            (f) => f.child_id === selectedChildId,
+          );
         }
 
         // Sort by most recent first
@@ -561,45 +500,49 @@
           return new Date(b.start_time) - new Date(a.start_time);
         });
 
-        const listHtml = filteredFeedings.map((feeding) => {
+        const listHtml = filteredFeedings
-          const startTime = new Date(feeding.start_time);
+          .map((feeding) => {
-          const endTime = feeding.end_time ? new Date(feeding.end_time) : null;
+            const startTime = new Date(feeding.start_time);
-          
+            const endTime = feeding.end_time
-          const dateStr = startTime.toLocaleDateString("en-US", {
+              ? new Date(feeding.end_time)
-            month: "short",
+              : null;
-            day: "numeric",
-            year: "numeric",
-          });
-          
-          const timeStr = startTime.toLocaleTimeString("en-US", {
-            hour: "numeric",
-            minute: "2-digit",
-          });
 
-          const duration = endTime 
+            const dateStr = startTime.toLocaleDateString("en-US", {
-            ? Math.round((endTime - startTime) / 60000) 
+              month: "short",
-            : null;
+              day: "numeric",
+              year: "numeric",
+            });
 
-          const typeClass = feeding.feeding_type.replace("_", "-");
+            const timeStr = startTime.toLocaleTimeString("en-US", {
-          const typeLabel = formatFeedingType(feeding.feeding_type);
+              hour: "numeric",
+              minute: "2-digit",
+            });
 
-          // Get child name
+            const duration = endTime
-          const child = allChildren.find(c => c.id === feeding.child_id);
+              ? Math.round((endTime - startTime) / 60000)
-          const childName = child ? child.name : "Unknown";
+              : null;
 
-          return `
+            const typeClass = feeding.feeding_type.replace("_", "-");
+            const typeLabel = formatFeedingType(feeding.feeding_type);
+
+            // Get child name
+            const child = allChildren.find((c) => c.id === feeding.child_id);
+            const childName = child ? child.name : "Unknown";
+
+            return `
             <div class="feeding-item">
               <div class="feeding-info-left">
-                <div class="feeding-time">${dateStr} at ${timeStr}${selectedChildId === null ? ` - ${childName}` : ''}</div>
+                <div class="feeding-time">${dateStr} at ${timeStr}${selectedChildId === null ? ` - ${childName}` : ""}</div>
                 <div class="feeding-details">
                   <span class="feeding-type-badge ${typeClass}">${typeLabel}</span>
-                  ${duration !== null ? `${duration} minutes` : 'Ongoing'}
+                  ${duration !== null ? `${duration} minutes` : "Ongoing"}
                 </div>
               </div>
               <button class="edit-button" onclick="editFeeding(${feeding.id})">Edit</button>
             </div>
           `;
-        }).join("");
+          })
+          .join("");
 
         const listContainer = `
           <div class="feedings-list">
@@ -614,7 +557,7 @@
         `;
 
         const content = document.getElementById("content");
-        content.insertAdjacentHTML('beforeend', listContainer);
+        content.insertAdjacentHTML("beforeend", listContainer);
       }
 
       function formatFeedingType(type) {
@@ -650,7 +593,9 @@
 
         // Filter by selected child if applicable
         if (selectedChildId !== null) {
-          recentFeedings = recentFeedings.filter((f) => f.child_id === selectedChildId);
+          recentFeedings = recentFeedings.filter(
+            (f) => f.child_id === selectedChildId,
+          );
         }
 
         const typeCounts = {
@@ -698,7 +643,9 @@
 
         // Filter by selected child if applicable
         if (selectedChildId !== null) {
-          completedFeedings = completedFeedings.filter((f) => f.child_id === selectedChildId);
+          completedFeedings = completedFeedings.filter(
+            (f) => f.child_id === selectedChildId,
+          );
         }
 
         // Calculate durations in minutes
@@ -711,14 +658,14 @@
         // Find max duration to determine how many bins we need
         const maxDuration = Math.max(...durations, 0);
         const maxBin = Math.ceil(maxDuration / 5) * 5; // Round up to nearest 5
-        
+
         // Create 5-minute duration buckets dynamically
         const buckets = {};
         for (let i = 0; i < maxBin; i += 5) {
           const label = `${i}-${i + 5}`;
           buckets[label] = 0;
         }
-        
+
         // Add a final bucket for anything over the max
         if (maxBin > 0) {
           buckets[`${maxBin}+`] = 0;
@@ -728,7 +675,7 @@
         durations.forEach((duration) => {
           const binIndex = Math.floor(duration / 5) * 5;
           const label = `${binIndex}-${binIndex + 5}`;
-          
+
           if (buckets[label] !== undefined) {
             buckets[label]++;
           } else {
@@ -745,62 +692,259 @@
       function prepareBarChartData(feedings) {
         const now = new Date();
         const labels = [];
-        const data = [];
+        const durations = []; // Array of arrays, each containing individual feeding durations
+        const feedingCounts = []; // For reference
 
         // Filter by selected child if applicable
         let filteredFeedings = feedings;
         if (selectedChildId !== null) {
-          filteredFeedings = feedings.filter((f) => f.child_id === selectedChildId);
+          filteredFeedings = feedings.filter(
+            (f) => f.child_id === selectedChildId,
+          );
         }
 
-        // Create days based on currentDaysRange (including today)
+        // Only use completed feedings
-        for (let i = currentDaysRange - 1; i >= 0; i--) {
+        const completedFeedings = filteredFeedings.filter((f) => f.end_time);
-          const date = new Date(now);
-          date.setDate(date.getDate() - i);
-          date.setHours(0, 0, 0, 0);
 
-          const dateStr = date.toLocaleDateString("en-US", {
+        // If 24 hours selected, show 3-hour aggregates
-            month: "short",
+        if (currentDaysRange === 1) {
-            day: "numeric",
+          // Create 8 three-hour buckets
-          });
+          for (let i = 7; i >= 0; i--) {
-          labels.push(dateStr);
+            const periodStart = new Date(now);
+            periodStart.setHours(periodStart.getHours() - i * 3, 0, 0, 0);
 
-          // Count feedings for this day
+            const periodEnd = new Date(periodStart);
-          const nextDay = new Date(date);
+            periodEnd.setHours(periodEnd.getHours() + 3);
-          nextDay.setDate(nextDay.getDate() + 1);
 
-          const count = filteredFeedings.filter((f) => {
+            const startLabel = periodStart.toLocaleTimeString("en-US", {
-            const feedingDate = new Date(f.start_time);
+              hour: "numeric",
-            return feedingDate >= date && feedingDate < nextDay;
+              hour12: true,
-          }).length;
+            });
+            const endLabel = periodEnd.toLocaleTimeString("en-US", {
+              hour: "numeric",
+              hour12: true,
+            });
+            labels.push(`${startLabel}-${endLabel}`);
 
-          data.push(count);
+            // Get individual feeding durations for this 3-hour period (in minutes)
+            const periodFeedings = completedFeedings.filter((f) => {
+              const feedingDate = new Date(f.start_time);
+              return feedingDate >= periodStart && feedingDate < periodEnd;
+            });
+
+            const feedingDurations = periodFeedings.map((feeding) => {
+              const start = new Date(feeding.start_time);
+              const end = new Date(feeding.end_time);
+              return (end - start) / 60000; // Convert to minutes
+            });
+
+            durations.push(feedingDurations);
+            feedingCounts.push(periodFeedings.length);
+          }
+        } else if (currentDaysRange === 3) {
+          // Show 8-hour aggregates for 3 days (9 buckets total)
+          for (let i = 8; i >= 0; i--) {
+            const periodStart = new Date(now);
+            periodStart.setHours(periodStart.getHours() - i * 8, 0, 0, 0);
+
+            const periodEnd = new Date(periodStart);
+            periodEnd.setHours(periodEnd.getHours() + 8);
+
+            // Format label based on the 8-hour period
+            const dayStr = periodStart.toLocaleDateString("en-US", {
+              month: "short",
+              day: "numeric",
+            });
+            const startHour = periodStart.getHours();
+            let periodLabel;
+            if (startHour >= 0 && startHour < 8) {
+              periodLabel = `${dayStr} Night`;
+            } else if (startHour >= 8 && startHour < 16) {
+              periodLabel = `${dayStr} Morning`;
+            } else {
+              periodLabel = `${dayStr} Evening`;
+            }
+            labels.push(periodLabel);
+
+            // Get individual feeding durations for this 8-hour period (in minutes)
+            const periodFeedings = completedFeedings.filter((f) => {
+              const feedingDate = new Date(f.start_time);
+              return feedingDate >= periodStart && feedingDate < periodEnd;
+            });
+
+            const feedingDurations = periodFeedings.map((feeding) => {
+              const start = new Date(feeding.start_time);
+              const end = new Date(feeding.end_time);
+              return (end - start) / 60000; // Convert to minutes
+            });
+
+            durations.push(feedingDurations);
+            feedingCounts.push(periodFeedings.length);
+          }
+        } else {
+          // Create days based on currentDaysRange (including today)
+          for (let i = currentDaysRange - 1; i >= 0; i--) {
+            const date = new Date(now);
+            date.setDate(date.getDate() - i);
+            date.setHours(0, 0, 0, 0);
+
+            const dateStr = date.toLocaleDateString("en-US", {
+              month: "short",
+              day: "numeric",
+            });
+            labels.push(dateStr);
+
+            // Get individual feeding durations for this day (in minutes)
+            const nextDay = new Date(date);
+            nextDay.setDate(nextDay.getDate() + 1);
+
+            const dayFeedings = completedFeedings.filter((f) => {
+              const feedingDate = new Date(f.start_time);
+              return feedingDate >= date && feedingDate < nextDay;
+            });
+
+            const feedingDurations = dayFeedings.map((feeding) => {
+              const start = new Date(feeding.start_time);
+              const end = new Date(feeding.end_time);
+              return (end - start) / 60000; // Convert to minutes
+            });
+
+            durations.push(feedingDurations);
+            feedingCounts.push(dayFeedings.length);
+          }
         }
 
-        return { labels, data };
+        return { labels, durations, feedingCounts };
       }
 
       function renderBarChart(chartData) {
         const ctx = document.getElementById("feedingsChart").getContext("2d");
-        
+
-        new Chart(ctx, {
+        // Destroy existing chart if it exists
+        if (barChartInstance) {
+          barChartInstance.destroy();
+        }
+
+        // Find the maximum number of feedings in any period
+        const maxFeedings = Math.max(
+          ...chartData.durations.map((d) => d.length),
+          0,
+        );
+
+        // If no feedings at all, show empty chart
+        if (maxFeedings === 0) {
+          barChartInstance = new Chart(ctx, {
+            type: "bar",
+            data: {
+              labels: chartData.labels,
+              datasets: [
+                {
+                  label: "No Data",
+                  data: new Array(chartData.labels.length).fill(0),
+                  backgroundColor: "rgba(102, 126, 234, 0.3)",
+                },
+              ],
+            },
+            options: {
+              responsive: true,
+              maintainAspectRatio: false,
+              scales: {
+                y: {
+                  beginAtZero: true,
+                  max: 60,
+                  title: {
+                    display: true,
+                    text: "Minutes",
+                  },
+                },
+              },
+              plugins: {
+                legend: {
+                  display: false,
+                },
+              },
+            },
+          });
+          return;
+        }
+
+        // Create color palette for different feedings
+        const colors = [
+          "rgba(102, 126, 234, 0.8)",
+          "rgba(118, 75, 162, 0.8)",
+          "rgba(255, 159, 64, 0.8)",
+          "rgba(76, 175, 80, 0.8)",
+          "rgba(244, 67, 54, 0.8)",
+          "rgba(156, 39, 176, 0.8)",
+          "rgba(102, 126, 234, 0.6)",
+          "rgba(118, 75, 162, 0.6)",
+          "rgba(255, 159, 64, 0.6)",
+          "rgba(76, 175, 80, 0.6)",
+        ];
+
+        // Create datasets - one for each feeding position
+        const datasets = [];
+        for (let feedingIndex = 0; feedingIndex < maxFeedings; feedingIndex++) {
+          const dataForFeeding = chartData.durations.map(
+            (periodDurations) => periodDurations[feedingIndex] || 0,
+          );
+
+          datasets.push({
+            label: `Feeding ${feedingIndex + 1}`,
+            data: dataForFeeding,
+            backgroundColor: colors[feedingIndex % colors.length],
+            borderColor: colors[feedingIndex % colors.length]
+              .replace("0.8", "1")
+              .replace("0.6", "1"),
+            borderWidth: 1,
+          });
+        }
+
+        barChartInstance = new Chart(ctx, {
           type: "bar",
           data: {
             labels: chartData.labels,
-            datasets: [
+            datasets: datasets,
-              {
-                label: "Feedings",
-                data: chartData.data,
-                backgroundColor: "rgba(102, 126, 234, 0.7)",
-                borderColor: "rgba(102, 126, 234, 1)",
-                borderWidth: 2,
-                borderRadius: 6,
-              },
-            ],
           },
           options: {
             responsive: true,
             maintainAspectRatio: false,
+            scales: {
+              x: {
+                stacked: true,
+                ticks: {
+                  font: {
+                    size: 12,
+                  },
+                },
+                grid: {
+                  display: false,
+                },
+              },
+              y: {
+                stacked: true,
+                beginAtZero: true,
+                title: {
+                  display: true,
+                  text: "Minutes",
+                  font: {
+                    size: 13,
+                    weight: "600",
+                  },
+                },
+                ticks: {
+                  font: {
+                    size: 12,
+                  },
+                  callback: function (value) {
+                    return Math.round(value) + "m";
+                  },
+                },
+                grid: {
+                  color: "rgba(0, 0, 0, 0.05)",
+                },
+              },
+            },
             plugins: {
               legend: {
                 display: false,
@@ -816,42 +960,18 @@
                 },
                 callbacks: {
                   label: function (context) {
-                    const count = context.parsed.y;
+                    const minutes = Math.round(context.parsed.y);
-                    return `${count} feeding${count !== 1 ? "s" : ""}`;
+                    return `${context.dataset.label}: ${minutes}m`;
                   },
-                },
+                  footer: function (tooltipItems) {
-              },
+                    const periodIndex = tooltipItems[0].dataIndex;
-            },
+                    const totalMinutes = chartData.durations[
-            scales: {
+                      periodIndex
-              y: {
+                    ].reduce((sum, val) => sum + val, 0);
-                beginAtZero: true,
+                    const feedingCount = chartData.feedingCounts[periodIndex];
-                title: {
+                    return `Total: ${Math.round(totalMinutes)}m (${feedingCount} feeding${feedingCount !== 1 ? "s" : ""})`;
-                  display: true,
-                  text: "Number of Feedings",
-                  font: {
-                    size: 13,
-                    weight: "600",
                   },
                 },
-                ticks: {
-                  stepSize: 1,
-                  font: {
-                    size: 12,
-                  },
-                },
-                grid: {
-                  color: "rgba(0, 0, 0, 0.05)",
-                },
-              },
-              x: {
-                ticks: {
-                  font: {
-                    size: 12,
-                  },
-                },
-                grid: {
-                  display: false,
-                },
               },
             },
           },
@@ -860,7 +980,12 @@
 
       function renderPieChart(chartData) {
         const ctx = document.getElementById("pieChart").getContext("2d");
-        
+
+        // Destroy existing chart instance if it exists
+        if (pieChartInstance) {
+          pieChartInstance.destroy();
+        }
+
         // Color mapping for each type
         const colorMap = {
           "Left Breast": {
@@ -871,7 +996,7 @@
             background: "rgba(118, 75, 162, 0.8)",
             border: "rgba(118, 75, 162, 1)",
           },
-          "Bottle": {
+          Bottle: {
             background: "rgba(255, 159, 64, 0.8)",
             border: "rgba(255, 159, 64, 1)",
           },
@@ -879,13 +1004,13 @@
 
         // Generate colors based on labels present
         const backgroundColors = chartData.labels.map(
-          (label) => colorMap[label]?.background || "rgba(200, 200, 200, 0.8)"
+          (label) => colorMap[label]?.background || "rgba(200, 200, 200, 0.8)",
         );
         const borderColors = chartData.labels.map(
-          (label) => colorMap[label]?.border || "rgba(200, 200, 200, 1)"
+          (label) => colorMap[label]?.border || "rgba(200, 200, 200, 1)",
         );
-        
+
-        new Chart(ctx, {
+        pieChartInstance = new Chart(ctx, {
           type: "pie",
           data: {
             labels: chartData.labels,
@@ -923,8 +1048,12 @@
                 callbacks: {
                   label: function (context) {
                     const count = context.parsed;
-                    const total = context.dataset.data.reduce((a, b) => a + b, 0);
+                    const total = context.dataset.data.reduce(
-                    const percentage = total > 0 ? ((count / total) * 100).toFixed(1) : 0;
+                      (a, b) => a + b,
+                      0,
+                    );
+                    const percentage =
+                      total > 0 ? ((count / total) * 100).toFixed(1) : 0;
                     return `${context.label}: ${count} (${percentage}%)`;
                   },
                 },
@@ -936,8 +1065,13 @@
 
       function renderDurationChart(chartData) {
         const ctx = document.getElementById("durationChart").getContext("2d");
-        
+
-        new Chart(ctx, {
+        // Destroy existing chart instance if it exists
+        if (durationChartInstance) {
+          durationChartInstance.destroy();
+        }
+
+        durationChartInstance = new Chart(ctx, {
           type: "bar",
           data: {
             labels: chartData.labels,

src/baby_monitor/static/index.html

@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Baby Monitor</title>
+    <link rel="stylesheet" href="/menu.css" />
     <style>
       body {
         font-family: Arial, sans-serif;
@@ -12,69 +13,6 @@
         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;
@@ -85,11 +23,10 @@
         color: #333;
         margin-bottom: 1rem;
       }
-      .user-info {
+      .greeting {
-        background: #e3f2fd;
+        color: #666;
-        padding: 1rem;
+        font-size: 1.1rem;
-        border-radius: 4px;
+        margin-bottom: 2rem;
-        margin-bottom: 1rem;
       }
       button {
         padding: 0.75rem 1.5rem;
@@ -203,23 +140,82 @@
       .cancel-button:hover {
         background-color: #5a6268;
       }
+      .sleep-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;
+      }
+      .sleep-button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4);
+        background: linear-gradient(135deg, #764ba2 0%, #667eea 100%);
+      }
+      .sleep-button.active {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+      }
+      .sleep-button.active:hover {
+        background: linear-gradient(135deg, #00f2fe 0%, #4facfe 100%);
+      }
+      .sleep-info {
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+        opacity: 0.9;
+      }
+      .recent-activity {
+        margin-top: 2rem;
+        padding: 1.5rem;
+        background: #f8f9fa;
+        border-radius: 8px;
+      }
+      .recent-activity h3 {
+        margin-top: 0;
+        margin-bottom: 1rem;
+        color: #333;
+        font-size: 1.1rem;
+      }
+      .activity-grid {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+      }
+      .activity-card {
+        background: white;
+        padding: 1rem;
+        border-radius: 6px;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+      }
+      .activity-card .icon {
+        font-size: 1.5rem;
+        margin-bottom: 0.5rem;
+      }
+      .activity-card .type {
+        font-weight: 600;
+        color: #333;
+        margin-bottom: 0.25rem;
+      }
+      .activity-card .time {
+        font-size: 0.85rem;
+        color: #666;
+      }
+      .activity-card .details {
+        font-size: 0.85rem;
+        color: #888;
+        margin-top: 0.5rem;
+      }
+      .activity-card.empty {
+        opacity: 0.5;
+        font-style: italic;
+        color: #999;
+      }
     </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>
@@ -260,41 +256,36 @@
       </div>
     </div>
 
+    <!-- Start Sleep Modal -->
+    <div class="modal" id="startSleepModal">
+      <div class="modal-content">
+        <h2>😴 Start Sleep</h2>
+        <form id="startSleepForm">
+          <div class="form-group">
+            <label for="modalSleepChildId">Child</label>
+            <select id="modalSleepChildId" required>
+              <option value="">Select a child</option>
+            </select>
+          </div>
+          <div class="modal-buttons">
+            <button
+              type="button"
+              class="cancel-button"
+              onclick="closeStartSleepModal()"
+            >
+              Cancel
+            </button>
+            <button type="submit">Start</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
+    <script src="/menu.js"></script>
     <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 = "/login.html";
@@ -317,6 +308,11 @@
             }
           })
           .then((user) => {
+            // Initialize burger menu
+            initBurgerMenu({
+              includeHome: true,
+            });
+
             // Check if user has any children
             return fetch("/api/children", {
               headers: {
@@ -325,9 +321,9 @@
             })
               .then((response) => response.json())
               .then((children) => {
-                // If no children, redirect to add-child page
+                // If no children, show welcome message with option to add
                 if (children.length === 0) {
-                  window.location.href = "/add-child.html";
+                  showNoChildrenMessage();
                   return;
                 }
 
@@ -340,10 +336,38 @@
           });
       }
 
+      function showNoChildrenMessage() {
+        const content = document.getElementById("content");
+        content.className = "";
+        content.innerHTML = `
+          <h1>👶 Welcome to Baby Monitor</h1>
+          <div style="text-align: center; padding: 40px 20px;">
+            <div style="font-size: 64px; margin-bottom: 20px;">🍼</div>
+            <h2 style="color: #333; margin-bottom: 15px;">No Children Added Yet</h2>
+            <p style="color: #666; margin-bottom: 30px; line-height: 1.6;">
+              You can add a child to start tracking or redeem a child share code<br>
+              from another user to access their child's information.
+            </p>
+            <div style="display: flex; gap: 15px; justify-content: center; flex-wrap: wrap;">
+              <a href="/add-child.html" class="button" style="text-decoration: none; display: inline-block;">
+                ➕ Add Your Child
+              </a>
+              <a href="/settings.html" class="button secondary" style="text-decoration: none; display: inline-block;">
+                🔗 Redeem Share Code
+              </a>
+            </div>
+          </div>
+        `;
+      }
+
       let activeFeeding = null;
       let userChildren = [];
       let lastFeeding = null;
       let updateTimerInterval = null;
+      let activeSleep = null;
+      let lastSleep = null;
+      let sleepUpdateTimerInterval = null;
+      let lastDiaperChange = null;
 
       async function loadFeedingStatus(children) {
         userChildren = children;
@@ -360,8 +384,8 @@
             activeFeeding = await activeResponse.json();
           }
 
-          // Fetch all feedings to get the last one
+          // Fetch the 10 most recent feedings to calculate the most recent session
-          const feedingsResponse = await fetch("/api/feedings", {
+          const feedingsResponse = await fetch("/api/feedings?limit=10", {
             headers: {
               Authorization: `Bearer ${token}`,
             },
@@ -370,8 +394,107 @@
           if (feedingsResponse.ok) {
             const feedings = await feedingsResponse.json();
             if (feedings.length > 0) {
-              // Feedings are ordered by start_time desc, so first is most recent
+              // Calculate the most recent feeding session
-              lastFeeding = feedings[0];
+              let sessionStart = feedings[0].start_time;
+              let sessionEnd = feedings[0].end_time || feedings[0].start_time;
+              let sessionChildId = feedings[0].child_id;
+              let sessionEntries = [feedings[0]];
+
+              for (let i = 1; i < feedings.length; i++) {
+                const entry = feedings[i];
+                // Only group entries for the same child (ignore feeding type)
+                if (entry.child_id !== sessionChildId) {
+                  break;
+                }
+                // If the gap between this entry's end_time and current sessionStart is more than 30 min, stop
+                const prevEnd = entry.end_time || entry.start_time;
+                const sessionStartDate = new Date(sessionStart);
+                const prevEndDate = new Date(prevEnd);
+                const diffMins = Math.abs(
+                  (sessionStartDate - prevEndDate) / 60000,
+                );
+                if (diffMins > 30) {
+                  break;
+                }
+                // Extend session to include this entry
+                sessionStart = entry.start_time;
+                sessionEntries.push(entry);
+              }
+
+              // Calculate accumulated feeding time for all events in the session
+              let accumulatedMinutes = 0;
+              sessionEntries.forEach((entry) => {
+                if (entry.end_time && entry.start_time) {
+                  const start = new Date(entry.start_time);
+                  const end = new Date(entry.end_time);
+                  const diffMs = end - start;
+                  if (diffMs > 0) {
+                    accumulatedMinutes += Math.floor(diffMs / 60000);
+                  }
+                }
+              });
+
+              // Build a string showing all feeding types used during the session
+              const feedingTypesSet = new Set();
+              sessionEntries.forEach((entry) => {
+                if (entry.feeding_type) {
+                  feedingTypesSet.add(entry.feeding_type);
+                }
+              });
+              const feedingTypesString = Array.from(feedingTypesSet)
+                .map(formatFeedingType)
+                .join(", ");
+
+              // Compose a session object
+              lastFeeding = {
+                child_id: sessionChildId,
+                feeding_type: feedings[0].feeding_type,
+                start_time: sessionStart,
+                end_time: sessionEnd,
+                entries: sessionEntries,
+                child_name: feedings[0].child_name,
+                accumulated_minutes: accumulatedMinutes,
+                feeding_types_string: feedingTypesString,
+              };
+            }
+          }
+
+          // Fetch active sleep
+          const activeSleepResponse = await fetch("/api/sleep/active", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (activeSleepResponse.ok) {
+            activeSleep = await activeSleepResponse.json();
+          }
+
+          // Fetch all sleep logs to get the last one
+          const sleepResponse = await fetch("/api/sleep", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (sleepResponse.ok) {
+            const sleeps = await sleepResponse.json();
+            if (sleeps.length > 0) {
+              lastSleep = sleeps[0];
+            }
+          }
+
+          // Fetch all diaper changes to get the last one
+          const diaperResponse = await fetch("/api/diaper-changes", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (diaperResponse.ok) {
+            const diapers = await diaperResponse.json();
+            if (diapers.length > 0) {
+              lastDiaperChange = diapers[0];
             }
           }
         } catch (error) {
@@ -380,6 +503,7 @@
 
         renderContent();
         startUpdateTimer();
+        startSleepUpdateTimer();
       }
 
       function startUpdateTimer() {
@@ -401,6 +525,25 @@
         }
       }
 
+      function startSleepUpdateTimer() {
+        // Clear any existing timer
+        if (sleepUpdateTimerInterval) {
+          clearInterval(sleepUpdateTimerInterval);
+        }
+
+        // Update every 30 seconds if there's an active sleep
+        if (activeSleep) {
+          sleepUpdateTimerInterval = setInterval(() => {
+            if (activeSleep) {
+              updateSleepTimeDisplay();
+            } else {
+              clearInterval(sleepUpdateTimerInterval);
+              sleepUpdateTimerInterval = null;
+            }
+          }, 30000); // Update every 30 seconds
+        }
+      }
+
       function updateFeedingTimeDisplay() {
         const timeElement = document.getElementById("feedingTimeInfo");
         if (timeElement && activeFeeding) {
@@ -408,11 +551,18 @@
         }
       }
 
+      function updateSleepTimeDisplay() {
+        const timeElement = document.getElementById("sleepTimeInfo");
+        if (timeElement && activeSleep) {
+          timeElement.textContent = formatTime(activeSleep.start_time);
+        }
+      }
+
       function renderContent() {
         const feedingButtonHtml = activeFeeding
           ? `
             <button class="feeding-button active" onclick="stopFeeding()">
-              🛑 Stop Feeding
+              🛑 Stopped Feeding
               <div class="feeding-info">
                 ${activeFeeding.child_name || "Child"} - ${formatFeedingType(activeFeeding.feeding_type)}<br>
                 Started <span id="feedingTimeInfo">${formatTime(activeFeeding.start_time)}</span>
@@ -420,21 +570,129 @@
             </button>
           `
           : `
-            <button class="feeding-button" onclick="showStartFeedingModal()">
+            <button class="feeding-button" onclick="window.location.href='/log-feeding.html'">
-              ▶️ Start Feeding
+              🍼 Started Feeding
+            </button>
+          `;
+
+        const sleepButtonHtml = activeSleep
+          ? `
+            <button class="sleep-button active" onclick="stopSleep()">
+              🛑 Stopped Sleeping
+              <div class="sleep-info">
+                ${activeSleep.child_name || "Child"}<br>
+                Started <span id="sleepTimeInfo">${formatTime(activeSleep.start_time)}</span>
+              </div>
+            </button>
+          `
+          : `
+            <button class="sleep-button" onclick="showStartSleepModal()">
+              😴 Started Sleeping
             </button>
           `;
 
         document.getElementById("content").innerHTML = `
-          <h1>Welcome to Baby Monitor!</h1>
+          <h1>Hi ${username}</h1>
-          <div class="user-info">
+          <p class="greeting">Let's keep track of your baby's care.</p>
-            <p><strong>Logged in as:</strong> ${username}</p>
+          <button class="feeding-button" onclick="window.location.href='/log-diaper.html'" style="background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); margin-bottom: 20px;">
-          </div>
+            🧷 Changed Diaper
+          </button>
           ${feedingButtonHtml}
-          <p>Your session is active.</p>
+          ${sleepButtonHtml}
+          ${buildRecentActivitySection()}
         `;
       }
 
+      function buildRecentActivitySection() {
+        // Build diaper card
+        const diaperCard = lastDiaperChange
+          ? `
+            <a href="/diapers.html" class="activity-card" style="text-decoration:none; color:inherit;">
+              <div class="icon">🧷</div>
+              <div class="type">Last Diaper</div>
+              <div class="time">${formatTime(lastDiaperChange.change_time)}</div>
+              <div class="details">
+                ${lastDiaperChange.poop_amount ? `💩 ${lastDiaperChange.poop_amount}` : ""}
+                ${lastDiaperChange.poop_amount && lastDiaperChange.pee_amount ? " • " : ""}
+                ${lastDiaperChange.pee_amount ? `💧 ${lastDiaperChange.pee_amount}` : ""}
+              </div>
+            </a>
+          `
+          : `
+            <a href="/diapers.html" class="activity-card empty" style="text-decoration:none; color:inherit;">
+              <div class="icon">🧷</div>
+              <div class="type">No diaper changes yet</div>
+            </a>
+          `;
+
+        // Build feeding card
+        const feedingCard = lastFeeding
+          ? `
+            <a href="/feedings.html" class="activity-card" style="text-decoration:none; color:inherit;">
+              <div class="icon">🍼</div>
+              <div class="type">Last Feeding Session</div>
+              <div class="time">${formatTime(lastFeeding.start_time)}</div>
+              <div class="details">
+                ${lastFeeding.feeding_types_string ? `${lastFeeding.feeding_types_string}` : ""}
+                ${lastFeeding.feeding_types_string && lastFeeding.accumulated_minutes ? " • " : ""}
+                ${lastFeeding.accumulated_minutes} minutes total
+                ${lastFeeding.end_time ? "" : " (ongoing)"}
+              </div>
+            </a>
+          `
+          : `
+            <a href="/feedings.html" class="activity-card empty" style="text-decoration:none; color:inherit;">
+              <div class="icon">🍼</div>
+              <div class="type">No feedings yet</div>
+            </a>
+          `;
+
+        // Build sleep card
+        const sleepCard = lastSleep
+          ? `
+            <a href="/sleep.html" class="activity-card" style="text-decoration:none; color:inherit;">
+              <div class="icon">😴</div>
+              <div class="type">Last Sleep</div>
+              <div class="time">${formatTime(lastSleep.start_time)}</div>
+              <div class="details">
+                Duration: ${lastSleep.end_time ? calculateDuration(lastSleep.start_time, lastSleep.end_time) : "ongoing"}
+              </div>
+            </a>
+          `
+          : `
+            <a href="/sleep.html" class="activity-card empty" style="text-decoration:none; color:inherit;">
+              <div class="icon">😴</div>
+              <div class="type">No sleep sessions yet</div>
+            </a>
+          `;
+
+        return `
+          <div class="recent-activity">
+            <h3>📊 Recent Activity</h3>
+            <div class="activity-grid">
+              ${diaperCard}
+              ${feedingCard}
+              ${sleepCard}
+            </div>
+          </div>
+        `;
+      }
+
+      function calculateDuration(startTime, endTime) {
+        const start = new Date(startTime);
+        const end = new Date(endTime);
+        const diffMs = end - start;
+        const diffMins = Math.floor(diffMs / 60000);
+
+        if (diffMins < 60) {
+          return `${diffMins} min`;
+        }
+
+        const hours = Math.floor(diffMins / 60);
+        const mins = diffMins % 60;
+        return `${hours}h ${mins}m`;
+      }
+
       function formatFeedingType(type) {
         const types = {
           left_breast: "Left Breast",
@@ -464,18 +722,40 @@
         const childSelect = document.getElementById("modalChildId");
         const typeSelect = document.getElementById("modalFeedingType");
 
-        // Clear and populate child select
+        // Clear and populate child select or show single child
-        childSelect.innerHTML = '<option value="">Select a child</option>';
+        if (userChildren.length === 1) {
-        userChildren.forEach((child) => {
+          // Single child: replace dropdown with text display
-          const option = document.createElement("option");
+          const child = userChildren[0];
-          option.value = child.id;
+          const formGroup = childSelect.parentElement;
-          option.textContent = child.name;
+          formGroup.innerHTML = `
-          childSelect.appendChild(option);
+            <label for="modalChildName">Child</label>
-        });
+            <input
+              type="text"
+              id="modalChildName"
+              value="${child.name}"
+              readonly
+              style="background-color: #f5f5f5; cursor: default;"
+            />
+            <input type="hidden" id="modalChildId" value="${child.id}" />
+          `;
+        } else {
+          // Multiple children: show dropdown
+          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
+          // Set defaults based on last feeding
+          if (lastFeeding) {
+            childSelect.value = lastFeeding.child_id;
+          }
+        }
+
+        // Set default feeding type based on last feeding
         if (lastFeeding) {
-          childSelect.value = lastFeeding.child_id;
           typeSelect.value = lastFeeding.feeding_type;
         }
 
@@ -583,6 +863,108 @@
         }
       }
 
+      function showStartSleepModal() {
+        window.location.href = "/log-sleep.html";
+      }
+
+      function closeStartSleepModal() {
+        const modal = document.getElementById("startSleepModal");
+        modal.classList.remove("show");
+        document.getElementById("startSleepForm").reset();
+      }
+
+      document
+        .getElementById("startSleepForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const childId = parseInt(
+            document.getElementById("modalSleepChildId").value,
+          );
+
+          try {
+            const now = new Date();
+            const localDateTime = new Date(
+              now.getTime() - now.getTimezoneOffset() * 60000,
+            )
+              .toISOString()
+              .slice(0, 19);
+
+            const response = await fetch("/api/sleep", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify({
+                child_id: childId,
+                start_time: localDateTime,
+              }),
+            });
+
+            if (response.ok) {
+              const sleep = await response.json();
+              activeSleep = sleep;
+              lastSleep = sleep;
+
+              // Add child name to active sleep
+              const child = userChildren.find((c) => c.id === childId);
+              if (child) {
+                activeSleep.child_name = child.name;
+              }
+
+              closeStartSleepModal();
+              renderContent();
+              startSleepUpdateTimer();
+            } else {
+              const data = await response.json();
+              alert(data.detail || "Failed to start sleep");
+            }
+          } catch (error) {
+            console.error("Error starting sleep:", error);
+            alert("Network error. Please try again.");
+          }
+        });
+
+      async function stopSleep() {
+        if (!activeSleep) return;
+
+        try {
+          const now = new Date();
+          const localDateTime = new Date(
+            now.getTime() - now.getTimezoneOffset() * 60000,
+          )
+            .toISOString()
+            .slice(0, 19);
+
+          const response = await fetch(`/api/sleep/${activeSleep.id}`, {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              end_time: localDateTime,
+            }),
+          });
+
+          if (response.ok) {
+            activeSleep = null;
+            if (sleepUpdateTimerInterval) {
+              clearInterval(sleepUpdateTimerInterval);
+              sleepUpdateTimerInterval = null;
+            }
+            renderContent();
+          } else {
+            const data = await response.json();
+            alert(data.detail || "Failed to stop sleep");
+          }
+        } catch (error) {
+          console.error("Error stopping sleep:", error);
+          alert("Network error. Please try again.");
+        }
+      }
+
       async function logout() {
         const token = localStorage.getItem("access_token");
 

src/baby_monitor/static/log-diaper.html

@@ -0,0 +1,522 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Log Diaper Change - 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;
+      }
+
+      .section-title {
+        color: #666;
+        font-size: 13px;
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+        margin: 25px 0 15px 0;
+        padding-top: 15px;
+        border-top: 1px solid #eee;
+      }
+
+      .section-title:first-of-type {
+        border-top: none;
+        margin-top: 0;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1 id="pageTitle">🧷 Log Diaper Change</h1>
+      <p class="subtitle">Record a diaper change</p>
+
+      <div id="message" class="message"></div>
+
+      <form id="diaperForm">
+        <div class="form-group">
+          <label for="childSelect">Child *</label>
+          <select id="childSelect" required>
+            <option value="">Select a child</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <label for="changeTime">Change Time *</label>
+          <input type="datetime-local" id="changeTime" required />
+        </div>
+
+        <div class="section-title">💩 Poop Information (Optional)</div>
+
+        <div class="form-group">
+          <label for="poopAmount">Poop Amount</label>
+          <select id="poopAmount">
+            <option value="">None</option>
+            <option value="light">Light</option>
+            <option value="medium">Medium</option>
+            <option value="heavy">Heavy</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <label for="poopColor">Poop Color</label>
+          <select id="poopColor">
+            <option value="">None</option>
+            <option value="black">Black</option>
+            <option value="yellow">Yellow</option>
+            <option value="green">Green</option>
+            <option value="brown">Brown</option>
+          </select>
+        </div>
+
+        <div class="section-title">💧 Pee Information (Optional)</div>
+
+        <div class="form-group">
+          <label for="peeAmount">Pee Amount</label>
+          <select id="peeAmount">
+            <option value="">None</option>
+            <option value="light">Light</option>
+            <option value="medium">Medium</option>
+            <option value="heavy">Heavy</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <label for="peeColor">Pee Color</label>
+          <select id="peeColor">
+            <option value="">None</option>
+            <option value="clear">Clear</option>
+            <option value="yellow">Yellow</option>
+            <option value="red">Red</option>
+          </select>
+        </div>
+
+        <button type="submit" class="button" id="submitBtn">
+          Log Diaper Change
+        </button>
+        <button
+          type="button"
+          class="button secondary"
+          onclick="window.location.href=getReturnUrl()"
+        >
+          Cancel
+        </button>
+      </form>
+    </div>
+
+    <script>
+      // Check if user is authenticated
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      // Determine return URL based on referrer
+      function getReturnUrl() {
+        const referrer = document.referrer;
+        if (referrer.includes("/diapers.html")) {
+          return "/diapers.html";
+        }
+        // Default to home page
+        return "/";
+      }
+
+      // Check if we're in edit mode
+      const urlParams = new URLSearchParams(window.location.search);
+      const diaperChangeId = urlParams.get("id");
+      const isEditMode = !!diaperChangeId;
+
+      // Update UI for edit mode
+      if (isEditMode) {
+        document.getElementById("pageTitle").textContent =
+          "🧷 Edit Diaper Change";
+        document.getElementById("submitBtn").textContent =
+          "Update Diaper Change";
+      }
+
+      let children = [];
+
+      // Load children when page loads
+      async function loadChildren() {
+        try {
+          const response = await fetch("/api/children", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            children = await response.json();
+            const select = document.getElementById("childSelect");
+
+            // Populate select dropdown or show single child
+            if (children.length === 1) {
+              // Single child: replace dropdown with text display
+              const child = children[0];
+              const formGroup = select.parentElement;
+              formGroup.innerHTML = `
+                <label for="childName">Child *</label>
+                <input
+                  type="text"
+                  id="childName"
+                  value="${child.name}"
+                  readonly
+                  style="background-color: #f5f5f5; cursor: default;"
+                />
+                <input type="hidden" id="childSelect" name="childSelect" value="${child.id}" />
+              `;
+            } else {
+              // Multiple children: show dropdown (clear the placeholder first)
+              select.innerHTML = "";
+              children.forEach((child) => {
+                const option = document.createElement("option");
+                option.value = child.id;
+                option.textContent = child.name;
+                select.appendChild(option);
+              });
+            }
+
+            // If editing, load the diaper change data
+            if (isEditMode) {
+              await loadDiaperChangeData();
+            } else {
+              // Set default time to now for new entries
+              const now = new Date();
+              now.setMinutes(now.getMinutes() - now.getTimezoneOffset());
+              document.getElementById("changeTime").value = now
+                .toISOString()
+                .slice(0, 16);
+
+              // Load last used child from localStorage (only for multiple children)
+              if (children.length > 1) {
+                const lastDiaperChange = JSON.parse(
+                  localStorage.getItem("lastDiaperChange") || "{}",
+                );
+
+                if (lastDiaperChange.child_id) {
+                  document.getElementById("childSelect").value =
+                    lastDiaperChange.child_id;
+                }
+              }
+
+              // Prepopulate poop and pee fields from most recent entry
+              try {
+                const response = await fetch("/api/diaper-changes", {
+                  headers: { Authorization: `Bearer ${token}` },
+                });
+                if (response.ok) {
+                  const changes = await response.json();
+                  if (changes.length > 0) {
+                    const last = changes[0];
+                    document.getElementById("poopAmount").value =
+                      last.poop_amount || "";
+                    document.getElementById("poopColor").value =
+                      last.poop_color || "";
+                    document.getElementById("peeAmount").value =
+                      last.pee_amount || "";
+                    document.getElementById("peeColor").value =
+                      last.pee_color || "";
+                  }
+                }
+              } catch (error) {
+                // Ignore error, just use default
+              }
+            }
+          } else {
+            showMessage("Failed to load children", "error");
+          }
+        } catch (error) {
+          console.error("Error:", error);
+          showMessage("Network error. Please try again.", "error");
+        }
+      }
+
+      // Load diaper change data for editing
+      async function loadDiaperChangeData() {
+        try {
+          const response = await fetch(
+            `/api/diaper-changes/${diaperChangeId}`,
+            {
+              headers: {
+                Authorization: `Bearer ${token}`,
+              },
+            },
+          );
+
+          if (response.ok) {
+            const diaperChange = await response.json();
+
+            // Populate form fields
+            document.getElementById("childSelect").value =
+              diaperChange.child_id;
+
+            // Convert UTC time to local datetime-local format
+            const changeTime = new Date(diaperChange.change_time);
+            changeTime.setMinutes(
+              changeTime.getMinutes() - changeTime.getTimezoneOffset(),
+            );
+            document.getElementById("changeTime").value = changeTime
+              .toISOString()
+              .slice(0, 16);
+
+            document.getElementById("poopAmount").value =
+              diaperChange.poop_amount || "";
+            document.getElementById("poopColor").value =
+              diaperChange.poop_color || "";
+            document.getElementById("peeAmount").value =
+              diaperChange.pee_amount || "";
+            document.getElementById("peeColor").value =
+              diaperChange.pee_color || "";
+          } else {
+            showMessage("Failed to load diaper change data", "error");
+          }
+        } catch (error) {
+          console.error("Error:", error);
+          showMessage("Network error. Please try again.", "error");
+        }
+      }
+
+      // Handle form submission
+      document
+        .getElementById("diaperForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const childId = parseInt(
+            document.getElementById("childSelect").value,
+          );
+          const changeTime = new Date(
+            document.getElementById("changeTime").value,
+          ).toISOString();
+          const poopAmount =
+            document.getElementById("poopAmount").value || null;
+          const poopColor = document.getElementById("poopColor").value || null;
+          const peeAmount = document.getElementById("peeAmount").value || null;
+          const peeColor = document.getElementById("peeColor").value || null;
+
+          const submitBtn = document.getElementById("submitBtn");
+          submitBtn.disabled = true;
+          submitBtn.textContent = isEditMode ? "Updating..." : "Logging...";
+
+          try {
+            const url = isEditMode
+              ? `/api/diaper-changes/${diaperChangeId}`
+              : "/api/diaper-changes";
+            const method = isEditMode ? "PUT" : "POST";
+
+            const body = isEditMode
+              ? {
+                  change_time: changeTime,
+                  poop_amount: poopAmount,
+                  poop_color: poopColor,
+                  pee_amount: peeAmount,
+                  pee_color: peeColor,
+                }
+              : {
+                  child_id: childId,
+                  change_time: changeTime,
+                  poop_amount: poopAmount,
+                  poop_color: poopColor,
+                  pee_amount: peeAmount,
+                  pee_color: peeColor,
+                };
+
+            const response = await fetch(url, {
+              method: method,
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify(body),
+            });
+
+            if (response.ok) {
+              // Save last used child for next time (only for new entries, not edits)
+              if (!isEditMode) {
+                localStorage.setItem(
+                  "lastDiaperChange",
+                  JSON.stringify({
+                    child_id: childId,
+                  }),
+                );
+              }
+
+              showMessage(
+                isEditMode
+                  ? "Diaper change updated successfully!"
+                  : "Diaper change logged successfully!",
+                "success",
+              );
+              setTimeout(() => {
+                window.location.href = getReturnUrl();
+              }, 1000);
+            } else {
+              const errorData = await response.json();
+              showMessage(
+                errorData.detail || "Failed to log diaper change",
+                "error",
+              );
+              submitBtn.disabled = false;
+              submitBtn.textContent = isEditMode
+                ? "Update Diaper Change"
+                : "Log Diaper Change";
+            }
+          } catch (error) {
+            console.error("Error:", error);
+            showMessage("Network error. Please try again.", "error");
+            submitBtn.disabled = false;
+            submitBtn.textContent = isEditMode
+              ? "Update Diaper Change"
+              : "Log Diaper Change";
+          }
+        });
+
+      function showMessage(text, type) {
+        const messageDiv = document.getElementById("message");
+        messageDiv.textContent = text;
+        messageDiv.className = `message ${type} show`;
+      }
+
+      // Initialize
+      loadChildren();
+    </script>
+  </body>
+</html>

src/baby_monitor/static/log-feeding.html

@@ -206,6 +206,16 @@
         window.location.href = "/login.html";
       }
 
+      // Determine return URL based on referrer
+      function getReturnUrl() {
+        const referrer = document.referrer;
+        if (referrer.includes("/feedings.html")) {
+          return "/feedings.html";
+        }
+        // Default to home page
+        return "/";
+      }
+
       const form = document.getElementById("logFeedingForm");
       const messageDiv = document.getElementById("message");
       const submitBtn = document.getElementById("submitBtn");
@@ -231,7 +241,8 @@
       // Update title and button text if editing
       if (isEditMode) {
         document.querySelector("h1").textContent = "🍼 Edit Feeding";
-        document.querySelector(".subtitle").textContent = "Update feeding session details";
+        document.querySelector(".subtitle").textContent =
+          "Update feeding session details";
         submitBtn.textContent = "Update Feeding";
       }
 
@@ -258,13 +269,32 @@
               return;
             }
 
-            // Populate select dropdown
+            // Populate select dropdown or show single child
-            children.forEach((child) => {
+            if (children.length === 1) {
-              const option = document.createElement("option");
+              // Single child: replace dropdown with text display
-              option.value = child.id;
+              const child = children[0];
-              option.textContent = child.name;
+              const formGroup = childSelect.parentElement;
-              childSelect.appendChild(option);
+              formGroup.innerHTML = `
-            });
+                <label for="childName">Child</label>
+                <input
+                  type="text"
+                  id="childName"
+                  value="${child.name}"
+                  readonly
+                  style="background-color: #f5f5f5; cursor: default;"
+                />
+                <input type="hidden" id="childId" name="childId" value="${child.id}" />
+              `;
+            } else {
+              // Multiple children: show dropdown (clear placeholder first)
+              childSelect.innerHTML = "";
+              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";
@@ -273,6 +303,22 @@
             // If editing, load the feeding data
             if (isEditMode) {
               loadFeedingData();
+            } else {
+              // Set default feeding type to most recent log entry
+              try {
+                const response = await fetch("/api/feedings", {
+                  headers: { Authorization: `Bearer ${token}` },
+                });
+                if (response.ok) {
+                  const feedings = await response.json();
+                  if (feedings.length > 0) {
+                    document.getElementById("feedingType").value =
+                      feedings[0].feeding_type;
+                  }
+                }
+              } catch (error) {
+                // Ignore error, just use default
+              }
             }
           } else {
             showMessage("Failed to load children", "error");
@@ -292,25 +338,29 @@
 
           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
+              startTime.getTime() - startTime.getTimezoneOffset() * 60000,
-            ).toISOString().slice(0, 16);
+            )
+              .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
+                endTime.getTime() - endTime.getTimezoneOffset() * 60000,
-              ).toISOString().slice(0, 16);
+              )
+                .toISOString()
+                .slice(0, 16);
               document.getElementById("endTime").value = endLocalDateTime;
             }
-            
+
             document.getElementById("feedingType").value = feeding.feeding_type;
           } else {
             showMessage("Failed to load feeding data", "error");
@@ -336,9 +386,11 @@
         messageDiv.classList.remove("show");
 
         try {
-          const url = isEditMode ? `/api/feedings/${feedingId}` : "/api/feedings";
+          const url = isEditMode
+            ? `/api/feedings/${feedingId}`
+            : "/api/feedings";
           const method = isEditMode ? "PUT" : "POST";
-          
+
           const response = await fetch(url, {
             method: method,
             headers: {
@@ -357,16 +409,19 @@
 
           if (response.ok) {
             showMessage(
-              isEditMode ? "Feeding updated successfully!" : "Feeding logged successfully!", 
+              isEditMode
-              "success"
+                ? "Feeding updated successfully!"
+                : "Feeding logged successfully!",
+              "success",
             );
-            // Redirect to feedings page after 1 second
+            // Redirect to appropriate page after 1 second
             setTimeout(() => {
-              window.location.href = "/feedings.html";
+              window.location.href = getReturnUrl();
             }, 1000);
           } else {
             showMessage(
-              data.detail || `Failed to ${isEditMode ? 'update' : 'log'} feeding. Please try again.`,
+              data.detail ||
+                `Failed to ${isEditMode ? "update" : "log"} feeding. Please try again.`,
               "error",
             );
           }
@@ -384,7 +439,7 @@
       }
 
       function goBack() {
-        window.location.href = "/";
+        window.location.href = getReturnUrl();
       }
     </script>
   </body>

src/baby_monitor/static/log-sleep.html

@@ -0,0 +1,414 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Log Sleep - 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, #4facfe 0%, #00f2fe 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: #4facfe;
+      }
+
+      .button {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 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(79, 172, 254, 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 Sleep</h1>
+      <p class="subtitle">Record a sleep session</p>
+
+      <div id="message" class="message"></div>
+
+      <div id="loadingChildren" class="loading">Loading children...</div>
+
+      <form id="logSleepForm" 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 sleep is ongoing</p>
+        </div>
+
+        <button type="submit" class="button" id="submitBtn">Log Sleep</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";
+      }
+
+      // Determine return URL based on referrer
+      function getReturnUrl() {
+        const referrer = document.referrer;
+        if (referrer.includes("/sleep.html")) {
+          return "/sleep.html";
+        }
+        // Default to home page
+        return "/";
+      }
+
+      const form = document.getElementById("logSleepForm");
+      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 sleep session
+      const urlParams = new URLSearchParams(window.location.search);
+      const sleepId = urlParams.get("id");
+      const isEditMode = !!sleepId;
+
+      // Set default start time to now (only for new sleep sessions)
+      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 Sleep";
+        document.querySelector(".subtitle").textContent =
+          "Update sleep session details";
+        submitBtn.textContent = "Update Sleep";
+      }
+
+      // 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 or show single child
+            if (children.length === 1) {
+              // Single child: replace dropdown with text display
+              const child = children[0];
+              const formGroup = childSelect.parentElement;
+              formGroup.innerHTML = `
+                <label for="childName">Child</label>
+                <input
+                  type="text"
+                  id="childName"
+                  value="${child.name}"
+                  readonly
+                  style="background-color: #f5f5f5; cursor: default;"
+                />
+                <input type="hidden" id="childId" name="childId" value="${child.id}" />
+              `;
+            } else {
+              // Multiple children: show dropdown (clear placeholder first)
+              childSelect.innerHTML = "";
+              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 sleep data
+            if (isEditMode) {
+              loadSleepData();
+            }
+          } else {
+            showMessage("Failed to load children", "error");
+          }
+        } catch (error) {
+          showMessage("Network error loading children", "error");
+        }
+      }
+
+      async function loadSleepData() {
+        try {
+          const response = await fetch(`/api/sleep/${sleepId}`, {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            const sleep = await response.json();
+
+            // Populate form with existing data
+            document.getElementById("childId").value = sleep.child_id;
+
+            // Format datetime for datetime-local input
+            const startTime = new Date(sleep.start_time);
+            const startLocalDateTime = new Date(
+              startTime.getTime() - startTime.getTimezoneOffset() * 60000,
+            )
+              .toISOString()
+              .slice(0, 16);
+            document.getElementById("startTime").value = startLocalDateTime;
+
+            if (sleep.end_time) {
+              const endTime = new Date(sleep.end_time);
+              const endLocalDateTime = new Date(
+                endTime.getTime() - endTime.getTimezoneOffset() * 60000,
+              )
+                .toISOString()
+                .slice(0, 16);
+              document.getElementById("endTime").value = endLocalDateTime;
+            }
+          } else {
+            showMessage("Failed to load sleep data", "error");
+          }
+        } catch (error) {
+          showMessage("Network error loading sleep", "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;
+
+        // Disable button during request
+        submitBtn.disabled = true;
+        submitBtn.textContent = isEditMode ? "Updating..." : "Logging...";
+        messageDiv.classList.remove("show");
+
+        try {
+          const url = isEditMode ? `/api/sleep/${sleepId}` : "/api/sleep";
+          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,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok) {
+            showMessage(
+              isEditMode
+                ? "Sleep updated successfully!"
+                : "Sleep logged successfully!",
+              "success",
+            );
+            // Redirect to appropriate page after 1 second
+            setTimeout(() => {
+              window.location.href = getReturnUrl();
+            }, 1000);
+          } else {
+            showMessage(
+              data.detail ||
+                `Failed to ${isEditMode ? "update" : "log"} sleep. Please try again.`,
+              "error",
+            );
+          }
+        } catch (error) {
+          showMessage("Network error. Please try again.", "error");
+        } finally {
+          submitBtn.disabled = false;
+          submitBtn.textContent = isEditMode ? "Update Sleep" : "Log Sleep";
+        }
+      });
+
+      function showMessage(text, type) {
+        messageDiv.textContent = text;
+        messageDiv.className = `message ${type} show`;
+      }
+
+      function goBack() {
+        window.location.href = getReturnUrl();
+      }
+    </script>
+  </body>
+</html>

src/baby_monitor/static/menu.css

@@ -0,0 +1,73 @@
+/* Burger Menu Styles */
+.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-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-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-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;
+}

src/baby_monitor/static/menu.js

@@ -0,0 +1,110 @@
+/**
+ * Initializes the burger menu navigation
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.includeHome - Whether to include Home menu item
+ * @param {boolean} options.includeFeedings - Whether to include Feedings menu item
+ * @param {boolean} options.includeDiapers - Whether to include Diapers menu item
+ * @param {boolean} options.includeSleep - Whether to include Sleep menu item
+ * @param {boolean} options.includeSettings - Whether to include Settings menu item
+ */
+function initBurgerMenu(options = {}) {
+  const {
+    includeHome = true,
+    includeFeedings = true,
+    includeDiapers = true,
+    includeSleep = true,
+    includeSettings = true,
+  } = options;
+
+  // Create burger menu HTML
+  const burgerMenuHTML = `
+    <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">
+      ${includeHome ? '<div class="menu-item" id="menuHome">🏠 Home</div>' : ""}
+      ${includeDiapers ? '<div class="menu-item" id="menuDiapers">🧷 Diapers</div>' : ""}
+      ${includeFeedings ? '<div class="menu-item" id="menuFeedings">🍼 Feedings</div>' : ""}
+      ${includeSleep ? '<div class="menu-item" id="menuSleep">😴 Sleep</div>' : ""}
+      ${includeSettings ? '<div class="menu-item" id="menuSettings">⚙️ Settings</div>' : ""}
+      <div class="menu-item logout" id="menuLogout">🚪 Logout</div>
+    </div>
+  `;
+
+  // Insert menu at the beginning of body
+  document.body.insertAdjacentHTML("afterbegin", burgerMenuHTML);
+
+  // Get elements
+  const burgerMenu = document.getElementById("burgerMenu");
+  const menuOverlay = document.getElementById("menuOverlay");
+  const menuBackdrop = document.getElementById("menuBackdrop");
+
+  // Toggle menu function
+  function toggleMenu() {
+    menuOverlay.classList.toggle("open");
+    menuBackdrop.classList.toggle("open");
+  }
+
+  // Close menu function
+  function closeMenu() {
+    menuOverlay.classList.remove("open");
+    menuBackdrop.classList.remove("open");
+  }
+
+  // Event listeners for menu toggle
+  burgerMenu.addEventListener("click", toggleMenu);
+  menuBackdrop.addEventListener("click", closeMenu);
+
+  // Navigation event listeners
+  if (includeHome) {
+    document.getElementById("menuHome")?.addEventListener("click", () => {
+      window.location.href = "/";
+    });
+  }
+
+  if (includeFeedings) {
+    document.getElementById("menuFeedings")?.addEventListener("click", () => {
+      window.location.href = "/feedings.html";
+    });
+  }
+
+  if (includeDiapers) {
+    document.getElementById("menuDiapers")?.addEventListener("click", () => {
+      window.location.href = "/diapers.html";
+    });
+  }
+
+  if (includeSleep) {
+    document.getElementById("menuSleep")?.addEventListener("click", () => {
+      window.location.href = "/sleep.html";
+    });
+  }
+
+  if (includeSettings) {
+    document.getElementById("menuSettings")?.addEventListener("click", () => {
+      window.location.href = "/settings.html";
+    });
+  }
+
+  document.getElementById("menuLogout").addEventListener("click", () => {
+    closeMenu();
+    // Call the page's logout function if it exists, otherwise use default
+    if (typeof logout === "function") {
+      logout();
+    } else {
+      defaultLogout();
+    }
+  });
+
+  // Default logout function
+  function defaultLogout() {
+    localStorage.removeItem("access_token");
+    localStorage.removeItem("username");
+    window.location.href = "/login.html";
+  }
+}

src/baby_monitor/static/settings.html

@@ -0,0 +1,859 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Settings - Baby Monitor</title>
+    <link rel="stylesheet" href="/menu.css" />
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background-color: #f0f0f0;
+        min-height: 100vh;
+        max-width: 800px;
+        margin: 2rem auto;
+        padding: 0 1rem;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+      }
+
+      .section {
+        margin-bottom: 40px;
+        padding: 20px;
+        background: #f8f9fa;
+        border-radius: 8px;
+      }
+
+      .section h2 {
+        color: #333;
+        font-size: 20px;
+        margin-bottom: 20px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+
+      .form-group {
+        margin-bottom: 20px;
+      }
+
+      .form-group label {
+        display: block;
+        margin-bottom: 8px;
+        color: #333;
+        font-weight: 600;
+        font-size: 14px;
+      }
+
+      .form-group input {
+        width: 100%;
+        padding: 12px;
+        border: 2px solid #e0e0e0;
+        border-radius: 6px;
+        font-size: 14px;
+        transition: border-color 0.2s;
+      }
+
+      .form-group input:focus {
+        outline: none;
+        border-color: #667eea;
+      }
+
+      .form-group input:disabled {
+        background-color: #f5f5f5;
+        cursor: not-allowed;
+      }
+
+      .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;
+        text-decoration: none;
+        display: inline-block;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:disabled {
+        opacity: 0.5;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .button.secondary {
+        background: #6c757d;
+      }
+
+      .button.secondary:hover {
+        box-shadow: 0 4px 12px rgba(108, 117, 125, 0.4);
+      }
+
+      .button.success {
+        background: linear-gradient(135deg, #56ab2f 0%, #a8e063 100%);
+      }
+
+      .button.success:hover {
+        box-shadow: 0 4px 12px rgba(86, 171, 47, 0.4);
+      }
+
+      .children-list {
+        display: grid;
+        gap: 15px;
+        margin-top: 20px;
+      }
+
+      .child-card {
+        background: white;
+        padding: 20px;
+        border-radius: 8px;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+      }
+
+      .child-card h3 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 18px;
+      }
+
+      .child-info {
+        color: #666;
+        font-size: 14px;
+        margin-bottom: 15px;
+      }
+
+      .child-info p {
+        margin-bottom: 5px;
+      }
+
+      .child-actions {
+        display: flex;
+        gap: 10px;
+      }
+
+      .loading {
+        text-align: center;
+        padding: 40px;
+        color: #666;
+      }
+
+      .alert {
+        padding: 12px 20px;
+        border-radius: 6px;
+        margin-bottom: 20px;
+        font-size: 14px;
+      }
+
+      .alert-success {
+        background-color: #d4edda;
+        color: #155724;
+        border: 1px solid #c3e6cb;
+      }
+
+      .alert-error {
+        background-color: #f8d7da;
+        color: #721c24;
+        border: 1px solid #f5c6cb;
+      }
+
+      .hidden {
+        display: none;
+      }
+
+      .quick-action {
+        display: block;
+        width: 100%;
+        padding: 15px;
+        margin-bottom: 15px;
+        background: white;
+        border: 2px solid #667eea;
+        color: #667eea;
+        border-radius: 8px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s;
+        text-align: left;
+      }
+
+      .quick-action:hover {
+        background: #667eea;
+        color: white;
+        transform: translateX(5px);
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>⚙️ Settings</h1>
+      <p class="subtitle">Manage your account and children</p>
+
+      <div id="alert" class="hidden"></div>
+
+      <div class="section">
+        <h2>👤 Account Information</h2>
+        <div class="form-group">
+          <label for="username">Username</label>
+          <input type="text" id="username" disabled />
+        </div>
+      </div>
+
+      <div class="section">
+        <h2>🔑 Change Password</h2>
+        <form id="userForm">
+          <div class="form-group">
+            <label for="currentPassword">Current Password</label>
+            <input type="password" id="currentPassword" />
+          </div>
+          <div class="form-group">
+            <label for="newPassword">New Password</label>
+            <input type="password" id="newPassword" />
+          </div>
+          <div class="form-group">
+            <label for="confirmPassword">Confirm New Password</label>
+            <input type="password" id="confirmPassword" />
+          </div>
+          <button type="submit" class="button" id="saveUserBtn">
+            💾 Save Changes
+          </button>
+        </form>
+
+        <div
+          style="
+            margin-top: 40px;
+            padding-top: 30px;
+            border-top: 2px solid #dc3545;
+          "
+        >
+          <h3 style="color: #dc3545; margin-bottom: 15px">⚠️ Danger Zone</h3>
+          <p style="color: #666; margin-bottom: 15px; font-size: 14px">
+            Deleting your account is permanent and cannot be undone. This will:
+          </p>
+          <ul
+            style="
+              color: #666;
+              margin-bottom: 20px;
+              margin-left: 20px;
+              font-size: 14px;
+            "
+          >
+            <li>Delete your account permanently</li>
+            <li>Delete all children that have no other parents</li>
+            <li>
+              Delete all logs (feedings, diaper changes, sleep) for orphaned
+              children
+            </li>
+            <li>
+              Remove you as a parent from shared children (they will remain for
+              other parents)
+            </li>
+          </ul>
+          <button
+            class="button"
+            style="
+              background: linear-gradient(135deg, #dc3545 0%, #c82333 100%);
+            "
+            onclick="confirmDeleteAccount()"
+          >
+            🗑️ Delete Account
+          </button>
+        </div>
+      </div>
+
+      <div class="section">
+        <h2>👶 Your Children</h2>
+
+        <button
+          class="quick-action"
+          onclick="window.location.href='/add-child.html'"
+        >
+          ➕ Add New Child
+        </button>
+
+        <button
+          class="quick-action"
+          onclick="showRedeemCodeModal()"
+          style="border-color: #56ab2f; color: #56ab2f"
+        >
+          🔗 Redeem Share Code
+        </button>
+
+        <div id="childrenContent" class="loading">
+          <p>Loading children...</p>
+        </div>
+      </div>
+    </div>
+
+    <!-- Redeem Code Modal -->
+    <div
+      class="modal"
+      id="redeemCodeModal"
+      style="
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1000;
+        justify-content: center;
+        align-items: center;
+      "
+    >
+      <div
+        style="
+          background: white;
+          padding: 30px;
+          border-radius: 12px;
+          max-width: 400px;
+          width: 90%;
+        "
+      >
+        <h2 style="margin-top: 0">🔗 Redeem Share Code</h2>
+        <p style="color: #666; margin-bottom: 20px">
+          Enter the share code to get access to a child.
+        </p>
+        <form id="redeemCodeForm">
+          <div class="form-group">
+            <label for="shareCode">Share Code</label>
+            <input
+              type="text"
+              id="shareCode"
+              placeholder="Enter code"
+              required
+              style="
+                width: 100%;
+                padding: 12px;
+                border: 2px solid #e0e0e0;
+                border-radius: 6px;
+                font-size: 14px;
+              "
+            />
+          </div>
+          <div style="display: flex; gap: 10px; margin-top: 20px">
+            <button
+              type="button"
+              class="button secondary"
+              onclick="closeRedeemCodeModal()"
+              style="flex: 1"
+            >
+              Cancel
+            </button>
+            <button type="submit" class="button success" style="flex: 1">
+              Redeem
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+
+    <!-- Share Code Modal -->
+    <div
+      class="modal"
+      id="shareCodeModal"
+      style="
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1000;
+        justify-content: center;
+        align-items: center;
+      "
+    >
+      <div
+        style="
+          background: white;
+          padding: 30px;
+          border-radius: 12px;
+          max-width: 400px;
+          width: 90%;
+        "
+      >
+        <h2 style="margin-top: 0">🔗 Share Code</h2>
+        <p style="color: #666; margin-bottom: 20px" id="shareCodeChildName"></p>
+        <div
+          style="
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+          "
+        >
+          <div
+            style="
+              display: flex;
+              align-items: center;
+              justify-content: space-between;
+            "
+          >
+            <span
+              style="
+                font-size: 24px;
+                font-weight: bold;
+                color: #333;
+                letter-spacing: 2px;
+              "
+              id="shareCodeValue"
+            ></span>
+            <button
+              onclick="copyShareCode()"
+              style="
+                background: #667eea;
+                color: white;
+                border: none;
+                padding: 10px 15px;
+                border-radius: 6px;
+                cursor: pointer;
+                font-size: 14px;
+              "
+            >
+              📋 Copy
+            </button>
+          </div>
+        </div>
+        <p style="color: #666; font-size: 14px; margin-bottom: 20px">
+          Share this code with another user. They can use it in Settings >
+          Redeem Share Code to get access to this child.
+          <br /><br />
+          This code expires in 7 days.
+        </p>
+        <button
+          type="button"
+          class="button"
+          onclick="closeShareCodeModal()"
+          style="width: 100%"
+        >
+          Close
+        </button>
+      </div>
+    </div>
+
+    <script src="/menu.js"></script>
+    <script>
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      // Initialize burger menu
+      initBurgerMenu({ includeHome: true });
+
+      let currentUser = null;
+      let children = [];
+
+      // Load user data and children
+      async function loadData() {
+        try {
+          // Fetch user info
+          const userResponse = await fetch("/api/me", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (userResponse.ok) {
+            currentUser = await userResponse.json();
+            document.getElementById("username").value = currentUser.username;
+          } else {
+            window.location.href = "/login.html";
+            return;
+          }
+
+          // Fetch children
+          const childrenResponse = await fetch("/api/children", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (childrenResponse.ok) {
+            children = await childrenResponse.json();
+            displayChildren();
+          } else {
+            showAlert("Failed to load children", "error");
+          }
+        } catch (error) {
+          console.error("Error loading data:", error);
+          showAlert("Network error. Please try again.", "error");
+        }
+      }
+
+      function displayChildren() {
+        const container = document.getElementById("childrenContent");
+
+        if (children.length === 0) {
+          container.innerHTML = `
+            <p style="color: #666; text-align: center; padding: 20px;">
+              No children added yet. Click "Add New Child" to get started.
+            </p>
+          `;
+          return;
+        }
+
+        container.innerHTML = `
+          <div class="children-list">
+            ${children
+              .map((child) => {
+                // Get list of other users (excluding current user)
+                const otherUsers =
+                  child.parent_usernames && child.parent_usernames.length > 1
+                    ? child.parent_usernames.filter(
+                        (username) => username !== currentUser.username,
+                      )
+                    : [];
+
+                return `
+              <div class="child-card">
+                <h3 style="margin: 0;">👶 ${child.name}</h3>
+                <div class="child-info">
+                  <p><strong>Birth Date:</strong> ${formatDate(child.birth_time)}</p>
+                  <p><strong>Birth Weight:</strong> ${child.birth_weight}g</p>
+                  <p><strong>Added:</strong> ${formatDate(child.created_at)}</p>
+                  ${otherUsers.length > 0 ? `<p><strong>Shared with:</strong> ${otherUsers.join(", ")}</p>` : ""}
+                </div>
+                <div class="child-actions">
+                  <button class="button secondary" onclick="editChild(${child.id})">
+                    ✏️ Edit
+                  </button>
+                  <button class="button success" onclick="shareChild(${child.id})">
+                    🔗 Share
+                  </button>
+                </div>
+              </div>
+            `;
+              })
+              .join("")}
+          </div>
+        `;
+      }
+
+      function formatDate(dateString) {
+        const date = new Date(dateString);
+        return date.toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "long",
+          day: "numeric",
+        });
+      }
+
+      function editChild(childId) {
+        const child = children.find((c) => c.id === childId);
+        if (!child) return;
+
+        // Redirect to add-child page with child data in query params
+        const params = new URLSearchParams({
+          id: child.id,
+          name: child.name,
+          birth_time: child.birth_time,
+          birth_weight: child.birth_weight,
+        });
+        window.location.href = `/add-child.html?${params.toString()}`;
+      }
+
+      async function shareChild(childId) {
+        const child = children.find((c) => c.id === childId);
+        if (!child) return;
+
+        try {
+          const response = await fetch("/api/children/invitations", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              child_id: childId,
+            }),
+          });
+
+          if (!response.ok) {
+            throw new Error("Failed to create invitation");
+          }
+
+          const invitation = await response.json();
+
+          // Show the share code modal
+          document.getElementById("shareCodeChildName").textContent =
+            `Share code for ${child.name}`;
+          document.getElementById("shareCodeValue").textContent =
+            invitation.code;
+          window.currentShareCode = invitation.code; // Store for copy function
+          document.getElementById("shareCodeModal").style.display = "flex";
+        } catch (error) {
+          console.error("Error creating share code:", error);
+          showAlert("Failed to create share code. Please try again.", "error");
+        }
+      }
+
+      function closeShareCodeModal() {
+        document.getElementById("shareCodeModal").style.display = "none";
+        window.currentShareCode = null;
+      }
+
+      function copyShareCode() {
+        const code = window.currentShareCode;
+        if (!code) return;
+
+        if (navigator.clipboard) {
+          navigator.clipboard
+            .writeText(code)
+            .then(() => {
+              showAlert("Share code copied to clipboard!", "success");
+            })
+            .catch((err) => {
+              console.error("Failed to copy to clipboard:", err);
+              showAlert(
+                "Failed to copy. Please copy the code manually.",
+                "error",
+              );
+            });
+        } else {
+          // Fallback for older browsers
+          const textArea = document.createElement("textarea");
+          textArea.value = code;
+          textArea.style.position = "fixed";
+          textArea.style.left = "-999999px";
+          document.body.appendChild(textArea);
+          textArea.select();
+          try {
+            document.execCommand("copy");
+            showAlert("Share code copied to clipboard!", "success");
+          } catch (err) {
+            showAlert(
+              "Failed to copy. Please copy the code manually.",
+              "error",
+            );
+          }
+          document.body.removeChild(textArea);
+        }
+      }
+
+      function showRedeemCodeModal() {
+        document.getElementById("redeemCodeModal").style.display = "flex";
+      }
+
+      function closeRedeemCodeModal() {
+        document.getElementById("redeemCodeModal").style.display = "none";
+        document.getElementById("redeemCodeForm").reset();
+      }
+
+      document
+        .getElementById("redeemCodeForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const code = document.getElementById("shareCode").value.trim();
+
+          try {
+            const response = await fetch("/api/children/invitations/redeem", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify({ code }),
+            });
+
+            if (!response.ok) {
+              const error = await response.json();
+              // Show the specific error message from the backend in a popup
+              alert(error.detail || "Failed to redeem code");
+              return;
+            }
+
+            const result = await response.json();
+            alert(result.message);
+            closeRedeemCodeModal();
+
+            // Reload children list
+            await loadData();
+          } catch (error) {
+            console.error("Error redeeming code:", error);
+            // Display the actual error message in a popup
+            alert(error.message);
+          }
+        });
+
+      async function confirmDeleteAccount() {
+        const confirmed = confirm(
+          "⚠️ WARNING: This action cannot be undone!\n\n" +
+            "Are you absolutely sure you want to delete your account?\n\n" +
+            "This will:\n" +
+            "• Delete your account permanently\n" +
+            "• Delete all children that have no other parents\n" +
+            "• Delete ALL logs for orphaned children\n" +
+            "• Remove you as a parent from shared children\n\n" +
+            'Type "DELETE" in the next prompt to confirm.',
+        );
+
+        if (!confirmed) {
+          return;
+        }
+
+        const confirmText = prompt("Type DELETE to confirm account deletion:");
+        if (confirmText !== "DELETE") {
+          showAlert(
+            "Account deletion cancelled. You must type DELETE exactly.",
+            "info",
+          );
+          return;
+        }
+
+        try {
+          const response = await fetch("/api/account", {
+            method: "DELETE",
+            headers: {
+              Authorization: `Bearer ${localStorage.getItem("token")}`,
+            },
+          });
+
+          if (!response.ok) {
+            throw new Error("Failed to delete account");
+          }
+
+          const result = await response.json();
+
+          // Show deletion summary
+          let message = "✅ Account deleted successfully!\n\n";
+          if (result.deleted_children && result.deleted_children.length > 0) {
+            message += `Deleted children: ${result.deleted_children.join(", ")}\n`;
+          }
+          if (result.deleted_logs) {
+            message += `\nDeleted logs:\n`;
+            message += `• Feedings: ${result.deleted_logs.feedings}\n`;
+            message += `• Diaper Changes: ${result.deleted_logs.diaper_changes}\n`;
+            message += `• Sleep Sessions: ${result.deleted_logs.sleep_sessions}`;
+          }
+
+          alert(message);
+
+          // Logout and redirect
+          localStorage.removeItem("token");
+          window.location.href = "/login.html";
+        } catch (error) {
+          console.error("Error deleting account:", error);
+          showAlert("Failed to delete account. Please try again.", "error");
+        }
+      }
+
+      function showAlert(message, type) {
+        const alert = document.getElementById("alert");
+        alert.className = `alert alert-${type}`;
+        alert.textContent = message;
+        alert.classList.remove("hidden");
+
+        setTimeout(() => {
+          alert.classList.add("hidden");
+        }, 5000);
+      }
+
+      // Handle user form submission
+      document
+        .getElementById("userForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const currentPassword =
+            document.getElementById("currentPassword").value;
+          const newPassword = document.getElementById("newPassword").value;
+          const confirmPassword =
+            document.getElementById("confirmPassword").value;
+
+          // Validate passwords
+          if (newPassword && newPassword !== confirmPassword) {
+            alert("New passwords do not match");
+            return;
+          }
+
+          if (newPassword && !currentPassword) {
+            alert("Current password is required to change password");
+            return;
+          }
+
+          // If no password change requested, just show success
+          if (!newPassword) {
+            alert("No changes to save");
+            return;
+          }
+
+          const saveBtn = document.getElementById("saveUserBtn");
+          saveBtn.disabled = true;
+          saveBtn.textContent = "Saving...";
+
+          try {
+            const response = await fetch("/api/change-password", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify({
+                current_password: currentPassword,
+                new_password: newPassword,
+              }),
+            });
+
+            if (!response.ok) {
+              const error = await response.json();
+              throw new Error(error.detail || "Failed to change password");
+            }
+
+            const result = await response.json();
+            alert(result.message);
+
+            // Clear form
+            document.getElementById("userForm").reset();
+          } catch (error) {
+            console.error("Error updating password:", error);
+            alert(error.message || "Failed to update password");
+          } finally {
+            saveBtn.disabled = false;
+            saveBtn.textContent = "💾 Save Changes";
+          }
+        });
+
+      // Load data on page load
+      loadData();
+    </script>
+  </body>
+</html>

src/baby_monitor/utils/__init__.py

@@ -0,0 +1,11 @@
+"""Utility functions for the baby monitor application."""
+
+from .hash_password import hash_password
+from .verify_child_access import verify_child_access
+from .verify_password import verify_password
+
+__all__ = [
+    "verify_child_access",
+    "hash_password",
+    "verify_password",
+]

src/baby_monitor/utils/hash_password.py

@@ -0,0 +1,17 @@
+"""Definition of hash_password function."""
+
+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")

src/baby_monitor/utils/verify_child_access.py

@@ -0,0 +1,28 @@
+"""Definition of verify_child_access function."""
+
+from fastapi import HTTPException
+from baby_monitor.repositories.interfaces import (
+    ChildRepositoryInterface,
+)
+
+
+def verify_child_access(
+    child_repo: ChildRepositoryInterface, child_id: int, user_id: int
+) -> None:
+    """Verify that user has access to the child.
+
+    Args:
+        child_repo: Child repository instance
+        child_id: ID of the child to verify access for
+        user_id: ID of the user requesting access
+
+    Raises:
+        HTTPException: 404 if child not found, 403 if user is not a parent
+    """
+    child = child_repo.get_by_id(child_id)
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    parent_ids = child_repo.get_parent_ids(child_id)
+    if user_id not in parent_ids:
+        raise HTTPException(status_code=403, detail="Access denied to this child")

src/baby_monitor/utils/verify_password.py

@@ -1,22 +1,8 @@
-"""Password hashing utilities using bcrypt."""
+"""Definition of verify_password function."""
 
 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.