Implement multi-stage Docker build for Next.js frontend and Python backend; add frontend proxy in FastAPI to handle requests, and remove old cleanup task functionality.

Dockerfile

@@ -1,12 +1,36 @@
-# Use Python 3.11 slim image
+# Multi-stage build: Frontend + Backend
+# Stage 1: Build Next.js frontend
+FROM node:20-alpine AS frontend-builder
+
+WORKDIR /app/frontend
+
+# Copy frontend package files
+COPY frontend/package*.json ./
+
+# Install frontend dependencies
+RUN npm ci
+
+# Copy frontend source code
+COPY frontend/ .
+
+# Build Next.js app with standalone output
+# When NEXT_PUBLIC_API_URL is empty, frontend will use relative URLs (same domain)
+ENV NEXT_PUBLIC_API_URL=""
+ENV NODE_ENV=production
+RUN npm run build
+
+# Stage 2: Python backend with frontend
 FROM python:3.11-slim
 
 # Set working directory
 WORKDIR /app
 
-# Install system dependencies
+# Install system dependencies including Node.js for running Next.js
 RUN apt-get update && apt-get install -y \
     gcc \
+    curl \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching
@@ -15,18 +39,42 @@ COPY requirements.txt .
 # Install Python dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application code
-COPY . .
+# Copy backend application code
+COPY main.py .
+COPY config.py .
+COPY services/ ./services/
+COPY data/ ./data/
+
+# Copy frontend build from previous stage
+COPY --from=frontend-builder /app/frontend ./frontend
+
+# Install frontend production dependencies (needed for standalone)
+WORKDIR /app/frontend
+RUN npm ci --only=production
+
+# Go back to app root
+WORKDIR /app
 
 # Create output directory for generated images
 RUN mkdir -p assets/generated
 
-# Expose port (Hugging Face Spaces uses port 7860 by default, but we'll use 8000)
-EXPOSE 8000
+# Expose ports (Next.js on 3000, FastAPI on 8000)
+# Note: Hugging Face Spaces will route to port 8000, so we'll proxy Next.js through FastAPI
+EXPOSE 8000 3000
 
 # Set environment variables
 ENV PYTHONUNBUFFERED=1
 ENV PORT=8000
+ENV NODE_ENV=production
+
+# Create startup script to run both services
+RUN echo '#!/bin/bash\n\
+set -e\n\
+# Start Next.js server in background\n\
+cd /app/frontend && PORT=3000 node server.js &\n\
+# Start FastAPI server (foreground)\n\
+cd /app && uvicorn main:app --host 0.0.0.0 --port 8000\n\
+' > /app/start.sh && chmod +x /app/start.sh
 
-# Run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+# Run both services
+CMD ["/app/start.sh"]

main.py

@@ -8,12 +8,13 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException, Request, Response, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, StreamingResponse
 from pydantic import BaseModel, Field
 from typing import Optional, List, Literal, Any, Dict
 import os
-import asyncio
 from starlette.middleware.gzip import GZipMiddleware
+import httpx
+from starlette.requests import Request as StarletteRequest
 
 from services.generator import ad_generator
 from services.matrix import matrix_service
@@ -22,49 +23,18 @@ from services.correction import correction_service
 from services.image import image_service
 from services.auth import auth_service
 from services.auth_dependency import get_current_user
-from services.image_cleanup import cleanup_service
 from config import settings
 
 
-async def cleanup_task():
-    """Background task to periodically clean up old images."""
-    while True:
-        try:
-            # Run cleanup every hour
-            await asyncio.sleep(3600)  # 1 hour
-            
-            # Only run cleanup in production if local storage is enabled
-            if settings.environment.lower() == "production" and settings.save_images_locally:
-                print("Running scheduled image cleanup...")
-                stats = cleanup_service.cleanup_old_images(dry_run=False)
-                print(f"Cleanup completed: {stats['deleted']} images deleted, {stats['total_size_mb']} MB freed")
-        except Exception as e:
-            print(f"Error in cleanup task: {e}")
-
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Startup and shutdown events."""
     # Startup: Connect to database
     print("Starting Ad Generator Lite...")
     await db_service.connect()
-    
-    # Start background cleanup task if in production with local storage enabled
-    cleanup_task_handle = None
-    if settings.environment.lower() == "production" and settings.save_images_locally:
-        print(f"Starting image cleanup task (retention: {settings.local_image_retention_hours} hours)")
-        cleanup_task_handle = asyncio.create_task(cleanup_task())
-    
     yield
-    
-    # Shutdown: Cancel cleanup task and disconnect from database
+    # Shutdown: Disconnect from database
     print("Shutting down...")
-    if cleanup_task_handle:
-        cleanup_task_handle.cancel()
-        try:
-            await cleanup_task_handle
-        except asyncio.CancelledError:
-            pass
     await db_service.disconnect()
 
 
@@ -1148,41 +1118,57 @@ async def delete_stored_ad(ad_id: str, username: str = Depends(get_current_user)
     return {"success": True, "deleted_id": ad_id}
 
 
-@app.get("/admin/storage/stats")
-async def get_storage_stats(username: str = Depends(get_current_user)):
-    """
-    Get storage statistics for locally saved images.
-    
-    Requires authentication.
+# Frontend proxy - forward non-API requests to Next.js
+# This must be LAST so it doesn't intercept API routes
+@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
+async def frontend_proxy(path: str, request: StarletteRequest):
     """
-    stats = cleanup_service.get_storage_stats()
-    return {
-        "stats": stats,
-        "retention_hours": settings.local_image_retention_hours,
-        "environment": settings.environment,
-        "save_images_locally": settings.save_images_locally,
-    }
-
-
-@app.post("/admin/storage/cleanup")
-async def trigger_cleanup(
-    dry_run: bool = False,
-    username: str = Depends(get_current_user)
-):
+    Proxy frontend requests to Next.js server.
+    Only proxies if the path doesn't start with API prefixes.
     """
-    Manually trigger image cleanup.
+    # API routes that should be handled by FastAPI
+    api_prefixes = [
+        "/api", "/auth", "/generate", "/matrix", "/extensive", 
+        "/db", "/strategies", "/health", "/images", "/image"
+    ]
     
-    Args:
-        dry_run: If True, only report what would be deleted without actually deleting
-        
-    Requires authentication.
-    """
-    result = cleanup_service.cleanup_old_images(dry_run=dry_run)
-    return {
-        "success": True,
-        "dry_run": dry_run,
-        "result": result,
-    }
+    # Check if this is an API route
+    if any(path.startswith(prefix) for prefix in api_prefixes):
+        # Let FastAPI handle it (will 404 if route doesn't exist)
+        raise HTTPException(status_code=404, detail="API endpoint not found")
+    
+    # Proxy to Next.js server running on port 3000
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            # Forward the request to Next.js
+            nextjs_url = f"http://localhost:3000/{path}"
+            
+            # Forward query parameters
+            if request.url.query:
+                nextjs_url += f"?{request.url.query}"
+            
+            # Forward request
+            response = await client.request(
+                method=request.method,
+                url=nextjs_url,
+                headers={k: v for k, v in request.headers.items() if k.lower() not in ["host", "content-length"]},
+                content=await request.body() if request.method in ["POST", "PUT", "PATCH"] else None,
+                follow_redirects=True,
+            )
+            
+            # Return response
+            return StreamingResponse(
+                response.iter_bytes(),
+                status_code=response.status_code,
+                headers=dict(response.headers),
+                media_type=response.headers.get("content-type"),
+            )
+    except httpx.RequestError:
+        # If Next.js is not running, return a helpful error
+        raise HTTPException(
+            status_code=503,
+            detail="Frontend server is not available. Please ensure Next.js is running on port 3000."
+        )
 
 
 # Run with: uvicorn main:app --reload