Fix nutrition upload crash, persist runtime writes, serve API on its own domain

/api/upload/nutrition called json.dumps() in a module that never imported
json, so every request to it raised NameError, was swallowed by the broad
except, and came back as "500 Database import failed". Import json.

Persist the three directories the app writes to at runtime. Products added
through the UI are appended to data/seed_catalogs/*.json and retrained models
are written to app/intelligence/artifacts/*.joblib; both live inside the image,
so a redeploy silently discarded them. The paths now come from settings
(DATA_DIR / SEED_CATALOG_DIR / MODEL_ARTIFACTS_DIR) so a volume can be mounted
on them, and catalog_engine.save_catalog resolves against DATA_DIR instead of
a working-directory-relative "data/", which landed somewhere different
depending on where the process was started from.

Mounting those volumes would otherwise have made things worse: Docker seeds a
named volume from the image on first use, but a bind mount starts empty and
just hides what the image shipped. A bind mount on /app/data would have left
the API with no seed catalogs, so the next product added would write a JSON
file containing only that product. The image now keeps pristine copies at
/app/.bundled, and restore_bundled_assets() tops up whatever a freshly mounted
directory is missing at startup without overwriting anything already there.

Configure CORS for the split-domain deployment: the React app is served from
catalogue.nearle.ai.in and calls the API on mcp.catalogue.nearle.ai.in, so the
frontend origin has to be in API_CORS_ORIGINS. A wrong list fails only in the
browser while the server logs a healthy 200, so the effective origins are now
logged at startup with a warning when they are localhost-only.

Fix FRONTEND_DIST, which looked for a sibling "frontend/" directory that is
actually named "catalogue_frontend/", so the single-port unified-serving branch
could never activate even with a build sitting next to it.

Rebuild the Dockerfile on the frontend's multi-stage pattern: dependencies
resolve into a venv in a build stage, the runtime stage copies only that.
Adds PYTHONUNBUFFERED so startup errors reach Dokploy's log pane, a liveness
HEALTHCHECK (/api/health answers 200 even when Postgres is down, so a database
blip cannot restart-loop the container), and an overridable PORT. The CMD execs
uvicorn so SIGTERM reaches it rather than the sh wrapper.

Add "from __future__ import annotations" to ollama_service and image_search,
which used PEP 604 unions in runtime-evaluated signatures and so could not be
imported below Python 3.10.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/main.py

@@ -9,6 +9,7 @@ Run with:
 from __future__ import annotations
 
 import logging
+import os
 import threading
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -18,6 +19,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 
+from app.infrastructure.persistence import restore_bundled_assets
 from app.infrastructure.settings import API_CORS_ORIGINS
 from app.api.routers import health, brands, search, chat, catalog, system
 from app.api.routers import stores, discounts, analytics as store_analytics, trending, recommendations, store_admin
@@ -43,6 +45,15 @@ async def lifespan(_app: FastAPI):
     healthcheck pass while that settles.
     """
 
+    # Runs before the thread below, and synchronously: the seed catalogs and
+    # model artifacts have to be in place before the first request can read
+    # them, and it is a handful of file copies on first boot, nothing on every
+    # boot after that.
+    try:
+        restore_bundled_assets()
+    except Exception as e:
+        logger.warning("Could not restore bundled assets: %s", e)
+
     def _async_init():
         try:
             ensure_store_intelligence_schema()
@@ -93,6 +104,24 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# A wrong origin list fails only in the browser, as an opaque "blocked by CORS"
+# with a perfectly healthy 200 in the server log - so state the effective list
+# at startup, where it can actually be compared against the frontend's URL.
+logger.info(
+    "CORS allowed origins: %s",
+    ", ".join(API_CORS_ORIGINS) if API_CORS_ORIGINS else "(none - same-origin only)",
+)
+if API_CORS_ORIGINS and all(
+    o.startswith(("http://localhost", "http://127.0.0.1")) for o in API_CORS_ORIGINS
+):
+    logger.warning(
+        "API_CORS_ORIGINS lists only localhost origins (%s). If this API is "
+        "published on a domain and the frontend is served from a different one, "
+        "every browser request will be blocked. Set API_CORS_ORIGINS to the "
+        "frontend's exact origin, e.g. https://catalogue.nearle.ai.in",
+        ", ".join(API_CORS_ORIGINS),
+    )
+
 app.include_router(health.router, prefix="/api")
 app.include_router(auth.router, prefix="/api")
 app.include_router(user_products.router, prefix="/api")
@@ -112,9 +141,34 @@ app.include_router(nutrition.router, prefix="/api")
 app.include_router(nutrition_admin.router, prefix="/api")
 app.include_router(upload.router, prefix="/api")
 
-# Serve built frontend static files if dist exists (single-port unified deployment)
-FRONTEND_DIST = Path(__file__).resolve().parents[2] / "frontend" / "dist"
+# Serve built frontend static files if dist exists (single-port unified
+# deployment). Off in the normal setup: the React app is served by its own
+# nginx on catalogue.nearle.ai.in and this API answers on
+# mcp.catalogue.nearle.ai.in, so no dist/ is present here and the JSON root
+# handler at the bottom of this file is what responds to /.
+#
+# The candidates cover both repo layouts - the sibling checkout is named
+# `catalogue_frontend`, and only `frontend` was checked before, so this branch
+# could never activate even when a build was sitting right next to it.
+# FRONTEND_DIST_DIR overrides both when the build lands somewhere else.
+_dist_override = os.getenv("FRONTEND_DIST_DIR", "").strip()
+_repo_root = Path(__file__).resolve().parents[2]
+_dist_candidates = (
+    [Path(_dist_override)]
+    if _dist_override
+    else [
+        _repo_root / "catalogue_frontend" / "dist",
+        _repo_root / "frontend" / "dist",
+        Path(__file__).resolve().parents[1] / "frontend" / "dist",
+    ]
+)
+FRONTEND_DIST = next(
+    (p for p in _dist_candidates if (p / "assets").exists()),
+    _dist_candidates[0],
+)
+
 if FRONTEND_DIST.exists() and (FRONTEND_DIST / "assets").exists():
+    logger.info("Serving built frontend from %s", FRONTEND_DIST)
     app.mount("/assets", StaticFiles(directory=str(FRONTEND_DIST / "assets")), name="assets")
 
     @app.get("/{full_path:path}")