Update main.py

main.py

@@ -1,859 +1,45 @@
-"""
-main.py — FastAPI application entry point.
-
-Responsibilities:
-  - Server lifecycle (model loading, semaphore, graceful shutdown)
-  - Route definitions (upload, search, categories, CRUD, reset)
-  - Async orchestration (Cloudinary + AI concurrently, batch Pinecone upserts)
-  - Logging to console and Supabase (fire-and-forget)
-
-All constants live in src/config.py.
-All helper logic lives in src/db.py and src/utils.py.
-All AI inference lives in src/models.py.
-"""
-
-# ── Standard library (no duplicates) ────────────────────────────────
 import asyncio
-import io
-import json
 import os
-import shutil
-import time
-import traceback
-import uuid
-from collections import OrderedDict
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
-from typing import List
 
-# ── Third-party ──────────────────────────────────────────────────────
-from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from pinecone import ServerlessSpec
-
-# ── Internal ─────────────────────────────────────────────────────────
-from src.config import (
-    DEFAULT_PINECONE_KEY, DEFAULT_CLOUDINARY_URL,
-    SUPABASE_URL, SUPABASE_SERVICE_KEY,
-    MAX_CONCURRENT_INFERENCES, MAX_FILES_PER_UPLOAD,
-    IDX_FACES, IDX_OBJECTS, IDX_FACES_DIM, IDX_OBJECTS_DIM,
-)
-from src.db import (
-    pinecone_pool,
-    cld_upload, cld_ping, cld_root_folders,
-    cld_list_folder_images, cld_delete_resource,
-    cld_delete_folder_resources, cld_remove_folder, cld_delete_all_paginated,
-    ensure_indexes, delete_and_recreate_indexes,
-    search_faces, search_objects, merge_face_results, merge_object_results,
-)
-from src.utils import (
-    get_ip, get_cloudinary_creds, is_default_key,
-    sanitize_filename, standardize_category_name,
-    face_ui_score, cld_thumb_url, url_to_public_id,
-    to_list,
-)
-
-# ── AI model (loaded once at startup) ───────────────────────────────
-_ai   = None
-_sem: asyncio.Semaphore  # limits concurrent AI inference calls
-
-
-# ════════════════════════════════════════════════════════════════════
-#  LOGGING — console + optional Supabase (fire-and-forget)
-# ════════════════════════════════════════════════════════════════════
-
-try:
-    from loguru import logger as _loguru
-    _loguru.remove()
-    _loguru.add(
-        lambda msg: print(msg, end=""),
-        format="<green>{time:HH:mm:ss}</green> | <level>{level:<8}</level> | {message}",
-        level="DEBUG", colorize=True,
-    )
-    _log_fn = _loguru.log
-except ImportError:
-    import logging as _logging
-    _logging.basicConfig(level=_logging.INFO)
-    _stdlib = _logging.getLogger("vsl")
-    def _log_fn(level, msg):
-        _stdlib.log(getattr(_logging, level, 20), msg)
-
-
-async def _supabase_log(level: str, event: str, data: dict):
-    """Fire-and-forget insert into Supabase app_logs table. Never raises."""
-    if not (SUPABASE_URL and SUPABASE_SERVICE_KEY):
-        return
-    try:
-        import aiohttp
-        row = {
-            "level":       level.upper(),
-            "event":       event,
-            "user_id":     str(data.get("user_id", "anonymous")),
-            "ip":          str(data.get("ip", "")),
-            "mode":        str(data.get("mode", "")),
-            "page":        str(data.get("page", "")),
-            "duration_ms": int(data["duration_ms"]) if "duration_ms" in data else None,
-            "error":       str(data["error"])       if "error"       in data else None,
-            "data":        data,
-        }
-        headers = {
-            "Content-Type":  "application/json",
-            "apikey":        SUPABASE_SERVICE_KEY,
-            "Authorization": f"Bearer {SUPABASE_SERVICE_KEY}",
-            "Prefer":        "return=minimal",
-        }
-        async with aiohttp.ClientSession() as s:
-            async with s.post(
-                f"{SUPABASE_URL}/rest/v1/app_logs",
-                json=row, headers=headers,
-                timeout=aiohttp.ClientTimeout(total=5),
-            ) as r:
-                if r.status not in (200, 201):
-                    body = await r.text()
-                    _log_fn("WARNING", f"Supabase log failed {r.status}: {body[:200]}")
-    except Exception as exc:
-        _log_fn("DEBUG", f"Supabase log push skipped: {exc}")
-
-
-def log(level: str, event: str, **data):
-    """Log to console and Supabase (background task, never blocks the request)."""
-    _log_fn(level.upper(), f"[{event}] {json.dumps(data, default=str)}")
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            asyncio.create_task(_supabase_log(level, event, data))
-    except Exception:
-        pass
 
-
-# ════════════════════════════════════════════════════════════════════
-#  APPLICATION LIFECYCLE
-# ════════════════════════════════════════════════════════════════════
+from src.core.config import MAX_CONCURRENT_INFERENCES
+from src.core.logging import log, init_logging_session, close_logging_session
+from src.api import danger, explorer, search, system, upload
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """
-    Load all AI models before accepting requests.
-    AIModelManager.__init__ is synchronous and CPU/GPU-heavy, so it runs
-    in a thread-pool executor to avoid blocking the event loop at startup.
-    """
-    global _ai, _sem
-    from src.models import AIModelManager
+    await init_logging_session()
     log("INFO", "server.startup", message="Loading AI models...")
+    
+    from src.services.ai_manager import AIModelManager
+    
     loop = asyncio.get_event_loop()
-    _ai  = await loop.run_in_executor(None, AIModelManager)
-    _sem = asyncio.Semaphore(MAX_CONCURRENT_INFERENCES)
+    app.state.ai = await loop.run_in_executor(None, AIModelManager)
+    app.state.ai_semaphore = asyncio.Semaphore(MAX_CONCURRENT_INFERENCES)
+
     log("INFO", "server.ready", message="All models loaded. API ready.")
     yield
+    
     log("INFO", "server.shutdown", message="API shutting down.")
-
+    await close_logging_session()
 
 app = FastAPI(lifespan=lifespan)
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True,
-    allow_methods=["*"], allow_headers=["*"],
+    allow_origins=["*"], # Update this to your frontend URL in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
-os.makedirs("temp_uploads", exist_ok=True)
-
-
-# ════════════════════════════════════════════════════════════════════
-#  HEALTH & STATUS
-# ════════════════════════════════════════════════════════════════════
-
-@app.get("/")
-async def root():
-    return {"status": "ok"}
-
-
-@app.get("/api/health")
-async def health():
-    return {"status": "ok", "timestamp": datetime.now(timezone.utc).isoformat()}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  FRONTEND EVENT LOG
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/log")
-async def frontend_log(
-    request:  Request,
-    event:    str = Form(...),
-    user_id:  str = Form(""),
-    page:     str = Form(""),
-    metadata: str = Form("{}"),
-):
-    """Receives client-side events (page visits, tab switches, errors) for analytics."""
-    ip = get_ip(request)
-    try:
-        meta = json.loads(metadata) if metadata else {}
-    except Exception:
-        meta = {}
-    log("INFO", f"frontend.{event}",
-        user_id=user_id or "anonymous",
-        page=page, ip=ip,
-        ua=request.headers.get("User-Agent", "")[:120],
-        **meta)
-    return {"ok": True}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  1. VERIFY KEYS & AUTO-BUILD INDEXES
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/verify-keys")
-async def verify_keys(
-    request:        Request,
-    pinecone_key:   str = Form(""),
-    cloudinary_url: str = Form(""),
-    user_id:        str = Form(""),
-):
-    ip    = get_ip(request)
-    mode  = "guest" if is_default_key(pinecone_key, DEFAULT_PINECONE_KEY) else "personal"
-    start = time.perf_counter()
-    log("INFO", "settings.verify_keys.start", user_id=user_id or "anonymous", mode=mode, ip=ip)
-
-    if cloudinary_url:
-        creds = get_cloudinary_creds(cloudinary_url)
-        if not creds.get("cloud_name"):
-            raise HTTPException(400, "Invalid Cloudinary Environment URL.")
-        try:
-            await asyncio.to_thread(cld_ping, creds)
-        except Exception as e:
-            log("ERROR", "settings.verify_keys.cloudinary_fail",
-                user_id=user_id or "anonymous", ip=ip, error=str(e))
-            raise HTTPException(400, "Invalid Cloudinary Environment URL.")
-
-    indexes_created = []
-    if pinecone_key:
-        try:
-            pc = pinecone_pool.get(pinecone_key)
-            created = await asyncio.to_thread(ensure_indexes, pc)
-            indexes_created = created
-        except Exception as e:
-            err   = str(e)
-            clean = (
-                "Invalid Pinecone API Key."
-                if "401" in err or "unauthorized" in err.lower()
-                else f"Pinecone Error: {err}"
-            )
-            log("ERROR", "settings.verify_keys.pinecone_fail",
-                user_id=user_id or "anonymous", ip=ip, error=clean)
-            raise HTTPException(400, clean)
-
-    log("INFO", "settings.verify_keys.success",
-        user_id=user_id or "anonymous", mode=mode, ip=ip,
-        indexes_created=indexes_created,
-        duration_ms=round((time.perf_counter() - start) * 1000))
-    return {"message": "Keys verified and indexes ready!"}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  2. UPLOAD
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/upload")
-async def upload_images(
-    request:             Request,
-    files:               List[UploadFile] = File(...),
-    folder_name:         str  = Form(...),
-    detect_faces:        bool = Form(True),   # configurable, not hardcoded
-    user_pinecone_key:   str  = Form(""),
-    user_cloudinary_url: str  = Form(""),
-    user_id:             str  = Form(""),
-):
-    ip    = get_ip(request)
-    start = time.perf_counter()
-
-    # ── Enforce file count limit ─────────────────────────────────────
-    # Each file spawns concurrent Cloudinary + AI tasks.
-    # Uncapped batches can exhaust RAM / GPU memory.
-    if len(files) > MAX_FILES_PER_UPLOAD:
-        raise HTTPException(
-            400,
-            f"Too many files. Maximum {MAX_FILES_PER_UPLOAD} per request, got {len(files)}."
-        )
-
-    actual_pc_key  = user_pinecone_key   or DEFAULT_PINECONE_KEY
-    actual_cld_url = user_cloudinary_url or DEFAULT_CLOUDINARY_URL
-    folder = standardize_category_name(folder_name)
-    creds  = get_cloudinary_creds(actual_cld_url)
-    if not creds.get("cloud_name"):
-        raise HTTPException(400, "Invalid Cloudinary URL.")
-
-    pc       = pinecone_pool.get(actual_pc_key)
-    idx_obj  = pc.Index(IDX_OBJECTS)
-    idx_face = pc.Index(IDX_FACES)
-
-    all_face_upserts:   list[dict] = []
-    all_object_upserts: list[dict] = []
-    uploaded_urls:      list[str]  = []
-
-    async def _process_file(file: UploadFile) -> tuple[str, str, list]:
-        """
-        For a single file:
-          1. Read bytes into memory
-          2. Write to temp path (YOLO/InsightFace need a file path)
-          3. Run Cloudinary upload and AI inference CONCURRENTLY
-          4. Clean up temp file in finally block
-
-        Cloudinary gets an in-memory BytesIO — no disk I/O needed.
-        AI gets the temp file path — required by ONNX/YOLO loaders.
-        """
-        file_bytes = await file.read()
-        file_id    = uuid.uuid4().hex
-        tmp_path   = f"temp_uploads/upload_{file_id}_{sanitize_filename(file.filename)}"
-
-        with open(tmp_path, "wb") as f:
-            f.write(file_bytes)
-
-        async def _run_ai():
-            try:
-                async with _sem:
-                    return await _ai.process_image_async(tmp_path, detect_faces=detect_faces)
-            finally:
-                if os.path.exists(tmp_path):
-                    os.remove(tmp_path)
-
-        cld_task = asyncio.to_thread(cld_upload, io.BytesIO(file_bytes), folder, creds)
-        ai_task  = _run_ai()
-        cld_res, vectors = await asyncio.gather(cld_task, ai_task)
-        return file_id, cld_res["secure_url"], vectors
-
-    # Run all files concurrently
-    results = await asyncio.gather(*[_process_file(f) for f in files])
-
-    # ── Build Pinecone upsert payloads ───────────────────────────────
-    # Metadata schema (single `url` key — no duplication):
-    #   url            : Cloudinary secure_url for retrieval
-    #   folder         : category/folder name for filtering
-    #   face_crop      : base64 JPEG thumbnail (faces only, for UI display)
-    #   det_score      : InsightFace detection confidence (faces only)
-    #   face_width_px  : face width in pixels (faces only, for threshold selection)
-    for file_id, image_url, vectors in results:
-        uploaded_urls.append(image_url)
-
-        for i, v in enumerate(vectors):
-            vector_id = f"{file_id}_{i}"
-            lane      = v["type"]
-
-            if lane == "face":
-                metadata = {
-                    "url":           image_url,
-                    "folder":        folder,
-                    "face_crop":     v.get("face_crop",     ""),
-                    "det_score":     float(v.get("det_score",    1.0)),
-                    "face_width_px": int(v.get("face_width_px", 0)),
-                }
-                all_face_upserts.append({
-                    "id":       vector_id,
-                    "values":   to_list(v["vector"]),
-                    "metadata": metadata,
-                })
-            else:
-                metadata = {
-                    "url":    image_url,
-                    "folder": folder,
-                }
-                all_object_upserts.append({
-                    "id":       vector_id,
-                    "values":   to_list(v["vector"]),
-                    "metadata": metadata,
-                })
-
-    # Batch upsert — fewer Pinecone round-trips
-    db_tasks = []
-    if all_face_upserts:
-        db_tasks.append(asyncio.to_thread(idx_face.upsert, vectors=all_face_upserts))
-    if all_object_upserts:
-        db_tasks.append(asyncio.to_thread(idx_obj.upsert,  vectors=all_object_upserts))
-    if db_tasks:
-        try:
-            await asyncio.gather(*db_tasks)
-        except Exception as e:
-            raise HTTPException(500, f"Database insertion failed: {e}")
-
-    duration_ms = round((time.perf_counter() - start) * 1000)
-    log("INFO", "upload.complete",
-        user_id=user_id or "anonymous", ip=ip,
-        files=len(files), folder=folder,
-        face_vectors=len(all_face_upserts),
-        object_vectors=len(all_object_upserts),
-        duration_ms=duration_ms)
-
-    return {
-        "message": "Done!",
-        "urls":    uploaded_urls,
-        "summary": {
-            "files":          len(files),
-            "face_vectors":   len(all_face_upserts),
-            "object_vectors": len(all_object_upserts),
-        },
-    }
-
-
-# ════════════════════════════════════════════════════════════════════
-#  3. SEARCH
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/search")
-async def search_database(
-    request:             Request,
-    file:                UploadFile = File(...),
-    detect_faces:        bool = Form(True),
-    user_pinecone_key:   str  = Form(""),
-    user_cloudinary_url: str  = Form(""),
-    user_id:             str  = Form(""),
-):
-    ip            = get_ip(request)
-    start         = time.perf_counter()
-    actual_pc_key = user_pinecone_key or DEFAULT_PINECONE_KEY
-    mode          = "guest" if is_default_key(actual_pc_key, DEFAULT_PINECONE_KEY) else "personal"
-
-    log("INFO", "search.start",
-        user_id=user_id or "anonymous", ip=ip, mode=mode,
-        filename=file.filename, detect_faces=detect_faces)
-
-    if not actual_pc_key:
-        raise HTTPException(400, "Pinecone key is missing.")
-
-    tmp_path = f"temp_uploads/query_{uuid.uuid4().hex}_{sanitize_filename(file.filename)}"
-    try:
-        with open(tmp_path, "wb") as buf:
-            shutil.copyfileobj(file.file, buf)
 
-        async with _sem:
-            vectors = await _ai.process_image_async(tmp_path, detect_faces=detect_faces)
-
-        inference_ms  = round((time.perf_counter() - start) * 1000)
-        face_vectors   = [v for v in vectors if v["type"] == "face"]
-        object_vectors = [v for v in vectors if v["type"] == "object"]
-        lanes_used     = list({v["type"] for v in vectors})
-
-        log("INFO", "search.inference_done",
-            user_id=user_id or "anonymous", ip=ip, mode=mode,
-            face_vecs=len(face_vectors), obj_vecs=len(object_vectors),
-            inference_ms=inference_ms)
-
-        pc       = pinecone_pool.get(actual_pc_key)
-        idx_obj  = pc.Index(IDX_OBJECTS)
-        idx_face = pc.Index(IDX_FACES)
-
-        if detect_faces and face_vectors:
-            # ── FACE MODE ────────────────────────────────────────────
-            # Query faces index for each detected query face in parallel.
-            # Merge across faces so images matching multiple query faces rank higher.
-            # ALSO run object search on object vectors (not discarded anymore).
-
-            async def _query_face(fv: dict) -> dict:
-                vec       = to_list(fv["vector"])
-                det_score = fv.get("det_score", 1.0)
-                try:
-                    image_map = await asyncio.to_thread(
-                        search_faces, idx_face, vec, det_score)
-                except Exception as e:
-                    if "404" in str(e):
-                        raise HTTPException(404,
-                            "Pinecone index not found. Go to Settings → Verify & Save.")
-                    raise
-                return {
-                    "query_face_idx":  fv.get("face_idx", 0),
-                    "query_face_crop": fv.get("face_crop", ""),
-                    "query_bbox":      fv.get("bbox", []),
-                    "det_score":       det_score,
-                    "face_width_px":   fv.get("face_width_px", 0),
-                    "_image_map":      image_map,
-                    # Per-face results (for UI face tabs)
-                    "matches": sorted(
-                        [
-                            {
-                                "url":       url,
-                                "score":     face_ui_score(d["raw_score"]),
-                                "raw_score": round(d["raw_score"], 4),
-                                "face_crop": d["face_crop"],
-                                "folder":    d["folder"],
-                                "caption":   "👤 Verified Identity",
-                            }
-                            for url, d in image_map.items()
-                        ],
-                        key=lambda x: x["score"], reverse=True,
-                    )[:50],
-                }
-
-            async def _query_obj_single(ov: dict) -> list:
-                vec = to_list(ov["vector"])
-                try:
-                    return await asyncio.to_thread(search_objects, idx_obj, vec)
-                except Exception as e:
-                    if "404" in str(e):
-                        raise HTTPException(404,
-                            "Pinecone index not found. Go to Settings → Verify & Save.")
-                    raise
-
-            # Run all face queries and all object queries concurrently
-            face_tasks = [_query_face(fv) for fv in face_vectors]
-            obj_tasks  = [_query_obj_single(ov) for ov in object_vectors]
-            all_results = await asyncio.gather(*face_tasks, *obj_tasks)
-
-            raw_groups   = list(all_results[:len(face_tasks)])
-            obj_nested   = list(all_results[len(face_tasks):])
-
-            merged_face    = merge_face_results(raw_groups)
-            merged_objects = merge_object_results(obj_nested)
-
-            # Strip internal _image_map from per-face groups
-            face_groups = [
-                {k: v for k, v in g.items() if k != "_image_map"}
-                for g in raw_groups
-                if g.get("matches")
-            ]
-
-            duration_ms = round((time.perf_counter() - start) * 1000)
-            log("INFO", "search.complete",
-                user_id=user_id or "anonymous", ip=ip, mode=mode,
-                lanes=["face", "object"], face_groups=len(face_groups),
-                face_results=len(merged_face), object_results=len(merged_objects),
-                top_face_score=merged_face[0]["score"] if merged_face else 0,
-                duration_ms=duration_ms)
-
-            return {
-                "mode":           "face",
-                "face_groups":    face_groups,       # per-face tabs for UI
-                "results":        merged_face,       # merged cross-face ranked list
-                "object_results": merged_objects,    # semantic/visual matches (new)
-            }
-
-        else:
-            # ── OBJECT MODE ──────────────────────────────────────────
-            # Use object_vectors (not raw `vectors`) to avoid any
-            # potential 1024-D face vector being sent to the 1536-D index.
-            if not object_vectors:
-                return {"mode": "object", "results": [], "face_groups": []}
-
-            async def _query_obj(ov: dict) -> list:
-                vec = to_list(ov["vector"])
-                try:
-                    return await asyncio.to_thread(search_objects, idx_obj, vec)
-                except Exception as e:
-                    if "404" in str(e):
-                        raise HTTPException(404,
-                            "Pinecone index not found. Go to Settings → Verify & Save.")
-                    raise
-
-            nested = await asyncio.gather(*[_query_obj(ov) for ov in object_vectors])
-            final  = merge_object_results(nested)
-
-            duration_ms = round((time.perf_counter() - start) * 1000)
-            log("INFO", "search.complete",
-                user_id=user_id or "anonymous", ip=ip, mode=mode,
-                lanes=lanes_used, results=len(final),
-                top_score=final[0]["score"] if final else 0,
-                duration_ms=duration_ms)
-
-            return {"mode": "object", "results": final, "face_groups": []}
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        log("ERROR", "search.error",
-            user_id=user_id or "anonymous", ip=ip, mode=mode,
-            error=str(e), traceback=traceback.format_exc()[-800:],
-            duration_ms=round((time.perf_counter() - start) * 1000))
-        raise HTTPException(500, str(e))
-    finally:
-        if os.path.exists(tmp_path):
-            os.remove(tmp_path)
-
-
-# ════════════════════════════════════════════════════════════════════
-#  4. CATEGORIES
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/categories")
-async def get_categories(
-    request:             Request,
-    user_cloudinary_url: str = Form(""),
-    user_id:             str = Form(""),
-):
-    ip         = get_ip(request)
-    actual_url = user_cloudinary_url or DEFAULT_CLOUDINARY_URL
-    if not actual_url:
-        return {"categories": []}
-    try:
-        creds = get_cloudinary_creds(actual_url)
-        if not creds.get("cloud_name"):
-            return {"categories": []}
-        result     = await asyncio.to_thread(cld_root_folders, creds)
-        categories = [f["name"] for f in result.get("folders", [])]
-        log("INFO", "categories.fetched",
-            user_id=user_id or "anonymous", ip=ip, count=len(categories))
-        return {"categories": categories}
-    except Exception as e:
-        log("ERROR", "categories.error",
-            user_id=user_id or "anonymous", ip=ip, error=str(e))
-        return {"categories": []}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  5. LIST FOLDER IMAGES
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/cloudinary/folder-images")
-async def list_folder_images(
-    request:             Request,
-    user_cloudinary_url: str = Form(""),
-    folder_name:         str = Form(...),
-    user_id:             str = Form(""),
-    next_cursor:         str = Form(""),
-    page_size:           int = Form(100),
-):
-    ip         = get_ip(request)
-    actual_url = user_cloudinary_url or DEFAULT_CLOUDINARY_URL
-    creds      = get_cloudinary_creds(actual_url)
-    if not creds.get("cloud_name"):
-        raise HTTPException(400, "Invalid Cloudinary URL.")
-
-    result = await asyncio.to_thread(
-        cld_list_folder_images,
-        folder_name, creds, next_cursor or None, page_size,
-    )
-
-    images = [
-        {
-            "url":       r["secure_url"],
-            "thumb_url": cld_thumb_url(r["secure_url"]),
-            "public_id": r["public_id"],
-        }
-        for r in result.get("resources", [])
-    ]
-    next_cur = result.get("next_cursor") or ""
-
-    log("INFO", "explorer.folder_opened",
-        user_id=user_id or "anonymous", ip=ip,
-        folder=folder_name, count=len(images), has_more=bool(next_cur))
-    return {"images": images, "count": len(images), "next_cursor": next_cur}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  6. DELETE SINGLE IMAGE
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/delete-image")
-async def delete_image(
-    request:             Request,
-    user_pinecone_key:   str = Form(""),
-    user_cloudinary_url: str = Form(""),
-    image_url:           str = Form(""),
-    public_id:           str = Form(""),
-    user_id:             str = Form(""),
-):
-    ip             = get_ip(request)
-    actual_pc_key  = user_pinecone_key   or DEFAULT_PINECONE_KEY
-    actual_cld_url = user_cloudinary_url or DEFAULT_CLOUDINARY_URL
-    creds          = get_cloudinary_creds(actual_cld_url)
-    if not creds.get("cloud_name"):
-        raise HTTPException(400, "Invalid Cloudinary URL.")
-
-    pid = public_id or url_to_public_id(image_url)
-    if not pid:
-        raise HTTPException(400, "Could not determine public_id.")
-
-    await asyncio.to_thread(cld_delete_resource, pid, creds)
-
-    if actual_pc_key and image_url:
-        try:
-            pc = pinecone_pool.get(actual_pc_key)
-            for idx_name in [IDX_OBJECTS, IDX_FACES]:
-                await asyncio.to_thread(
-                    pc.Index(idx_name).delete,
-                    filter={"url": {"$eq": image_url}},
-                )
-        except Exception as e:
-            _log_fn("WARNING", f"Pinecone delete warning: {e}")
-
-    log("INFO", "explorer.image_deleted",
-        user_id=user_id or "anonymous", ip=ip,
-        image_url=image_url, public_id=pid)
-    return {"message": "Image deleted successfully."}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  7. DELETE ENTIRE FOLDER
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/delete-folder")
-async def delete_folder(
-    request:             Request,
-    user_pinecone_key:   str = Form(""),
-    user_cloudinary_url: str = Form(""),
-    folder_name:         str = Form(...),
-    user_id:             str = Form(""),
-):
-    ip             = get_ip(request)
-    actual_pc_key  = user_pinecone_key   or DEFAULT_PINECONE_KEY
-    actual_cld_url = user_cloudinary_url or DEFAULT_CLOUDINARY_URL
-    creds          = get_cloudinary_creds(actual_cld_url)
-    if not creds.get("cloud_name"):
-        raise HTTPException(400, "Invalid Cloudinary URL.")
-
-    # Collect all images first (needed for Pinecone URL-filter fallback)
-    all_images, cursor = [], None
-    while True:
-        result = await asyncio.to_thread(
-            cld_list_folder_images, folder_name, creds, cursor)
-        all_images.extend(result.get("resources", []))
-        cursor = result.get("next_cursor")
-        if not cursor:
-            break
-
-    # Delete resources then remove folder record
-    await asyncio.to_thread(cld_delete_folder_resources, folder_name, creds)
-    await asyncio.to_thread(cld_remove_folder, folder_name, creds)
-
-    if actual_pc_key:
-        try:
-            pc = pinecone_pool.get(actual_pc_key)
-            for idx_name in [IDX_OBJECTS, IDX_FACES]:
-                idx = pc.Index(idx_name)
-                try:
-                    await asyncio.to_thread(
-                        idx.delete, filter={"folder": {"$eq": folder_name}})
-                except Exception:
-                    # Fallback: delete by individual URL if filter-delete unsupported
-                    for img in all_images:
-                        url = img.get("secure_url", "")
-                        if url:
-                            try:
-                                await asyncio.to_thread(
-                                    idx.delete, filter={"url": {"$eq": url}})
-                            except Exception:
-                                pass
-        except Exception as e:
-            _log_fn("WARNING", f"Pinecone folder delete warning: {e}")
-
-    log("INFO", "explorer.folder_deleted",
-        user_id=user_id or "anonymous", ip=ip,
-        folder=folder_name, deleted_count=len(all_images))
-    return {
-        "message":       f"Folder '{folder_name}' and all its contents deleted.",
-        "deleted_count": len(all_images),
-    }
-
-
-# ════════════════════════════════════════════════════════════════════
-#  8. RESET DATABASE  ⚠️  DESTRUCTIVE
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/reset-database")
-async def reset_database(
-    request:             Request,
-    user_pinecone_key:   str = Form(""),
-    user_cloudinary_url: str = Form(""),
-    user_id:             str = Form(""),
-):
-    ip    = get_ip(request)
-    start = time.perf_counter()
-    log("WARNING", "danger.reset_database.attempt",
-        user_id=user_id or "anonymous", ip=ip)
-
-    if (is_default_key(user_pinecone_key,   DEFAULT_PINECONE_KEY) or
-            is_default_key(user_cloudinary_url, DEFAULT_CLOUDINARY_URL)):
-        log("WARNING", "danger.reset_database.blocked",
-            user_id=user_id or "anonymous", ip=ip)
-        raise HTTPException(403, "Reset is not allowed on the shared demo database.")
-
-    creds = get_cloudinary_creds(user_cloudinary_url)
-    if not creds.get("cloud_name"):
-        raise HTTPException(400, "Invalid Cloudinary URL.")
-
-    # Wipe Cloudinary
-    try:
-        deleted = await asyncio.to_thread(cld_delete_all_paginated, creds)
-        _log_fn("INFO", f"Cloudinary: deleted {deleted} resources")
-    except Exception as e:
-        _log_fn("WARNING", f"Cloudinary wipe: {e}")
-
-    try:
-        folders_res  = await asyncio.to_thread(cld_root_folders, creds)
-        folder_tasks = [
-            asyncio.to_thread(cld_remove_folder, f["name"], creds)
-            for f in folders_res.get("folders", [])
-        ]
-        if folder_tasks:
-            await asyncio.gather(*folder_tasks, return_exceptions=True)
-    except Exception as e:
-        _log_fn("WARNING", f"Cloudinary folder cleanup: {e}")
-
-    # Wipe and recreate Pinecone indexes
-    try:
-        pc = pinecone_pool.get(user_pinecone_key)
-        await asyncio.to_thread(delete_and_recreate_indexes, pc)
-    except Exception as e:
-        log("ERROR", "danger.reset_database.pinecone_error",
-            user_id=user_id or "anonymous", ip=ip, error=str(e))
-        raise HTTPException(500, f"Pinecone reset error: {e}")
-
-    log("WARNING", "danger.reset_database.complete",
-        user_id=user_id or "anonymous", ip=ip,
-        duration_ms=round((time.perf_counter() - start) * 1000))
-    return {"message": "Database reset complete. All data wiped and indexes recreated."}
-
-
-# ════════════════════════════════════════════════════════════════════
-#  9. DELETE ACCOUNT  ⚠️  DESTRUCTIVE
-# ════════════════════════════════════════════════════════════════════
-
-@app.post("/api/delete-account")
-async def delete_account(
-    request:             Request,
-    user_pinecone_key:   str = Form(""),
-    user_cloudinary_url: str = Form(""),
-    user_id:             str = Form(""),
-):
-    ip    = get_ip(request)
-    start = time.perf_counter()
-    log("WARNING", "danger.delete_account.attempt",
-        user_id=user_id or "anonymous", ip=ip)
-
-    if (is_default_key(user_pinecone_key,   DEFAULT_PINECONE_KEY) or
-            is_default_key(user_cloudinary_url, DEFAULT_CLOUDINARY_URL)):
-        log("WARNING", "danger.delete_account.blocked",
-            user_id=user_id or "anonymous", ip=ip)
-        raise HTTPException(403, "Account deletion is not allowed on the shared demo database.")
-
-    creds = get_cloudinary_creds(user_cloudinary_url)
-
-    try:
-        deleted = await asyncio.to_thread(cld_delete_all_paginated, creds)
-        _log_fn("INFO", f"Account delete: {deleted} Cloudinary resources removed")
-    except Exception as e:
-        _log_fn("WARNING", f"Account delete Cloudinary: {e}")
-
-    try:
-        folders_res  = await asyncio.to_thread(cld_root_folders, creds)
-        folder_tasks = [
-            asyncio.to_thread(cld_remove_folder, f["name"], creds)
-            for f in folders_res.get("folders", [])
-        ]
-        if folder_tasks:
-            await asyncio.gather(*folder_tasks, return_exceptions=True)
-    except Exception as e:
-        _log_fn("WARNING", f"Account delete folders: {e}")
-
-    try:
-        pc       = pinecone_pool.get(user_pinecone_key)
-        existing = {idx.name for idx in await asyncio.to_thread(pc.list_indexes)}
-        tasks    = [
-            asyncio.to_thread(pc.delete_index, name)
-            for name in [IDX_OBJECTS, IDX_FACES]
-            if name in existing
-        ]
-        if tasks:
-            await asyncio.gather(*tasks)
-    except Exception as e:
-        _log_fn("WARNING", f"Account delete Pinecone: {e}")
+os.makedirs("temp_uploads", exist_ok=True)
 
-    log("WARNING", "danger.delete_account.complete",
-        user_id=user_id or "anonymous", ip=ip,
-        duration_ms=round((time.perf_counter() - start) * 1000))
-    return {"message": "Account data deleted. Sign out initiated."}
+app.include_router(system.router)
+app.include_router(upload.router)
+app.include_router(search.router)
+app.include_router(explorer.router)
+app.include_router(danger.router)