Restructure project for HF Spaces deployment

app.py

@@ -0,0 +1,12 @@
+"""Author RAG — Application Entry Point.
+
+Usage:
+    uvicorn app.main:app --reload                          # Development
+    uvicorn app.main:app --host 0.0.0.0 --port 7860       # HF Spaces
+"""
+
+from app.main import app  # noqa: F401
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=7860, reload=True)

app/__init__.py

@@ -0,0 +1 @@
+# Author RAG — Application Package

app/admin/__init__.py

@@ -0,0 +1 @@
+# Admin package

app/admin/router.py

@@ -0,0 +1,223 @@
+"""Author RAG — Per-Author Admin API Router.
+
+All routes require a valid Author JWT (Bearer token).
+Routes live at: /api/admin/{author_slug}/*
+
+Per implementation plan:
+  GET    /api/admin/{slug}/dashboard          — Stats summary
+  GET    /api/admin/{slug}/sessions           — Reader session list
+  GET    /api/admin/{slug}/sessions/{id}      — Session detail + transcript
+  POST   /api/admin/{slug}/sessions/{id}/block
+  POST   /api/admin/{slug}/sessions/{id}/unblock
+  POST   /api/admin/{slug}/sessions/{id}/reply  — Live agent takeover
+  GET    /api/admin/{slug}/books              — Book list
+  POST   /api/admin/{slug}/books/{id}/delete
+  GET    /api/admin/{slug}/analytics          — Charts data
+  GET    /api/admin/{slug}/export/chats       — Export Excel/JSON
+  GET    /api/admin/{slug}/widget-config      — Get widget settings
+  PUT    /api/admin/{slug}/widget-config      — Update widget settings
+  GET    /api/admin/{slug}/smart-links        — Smart links (buy/preview URLs)
+  PUT    /api/admin/{slug}/smart-links/{book_id}
+  POST   /api/admin/{slug}/password           — Change password
+"""
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user, get_redis
+from app.repositories.book_repo import BookRepository
+from app.repositories.audit_repo import AuditRepository
+
+router = APIRouter()
+
+
+@router.get("/{author_slug}/dashboard")
+async def dashboard(
+    author_slug: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Return high-level dashboard stats for the author."""
+    book_repo = BookRepository(db)
+    books = await book_repo.list_for_author(current_user.id)
+
+    from sqlalchemy import func, select
+    from app.models.chat_session import ChatSession
+    from app.models.analytics import AnalyticsEvent
+
+    total_sessions = await db.scalar(
+        select(func.count()).where(ChatSession.author_id == current_user.id)
+    ) or 0
+
+    return {
+        "total_books": len(books),
+        "active_books": sum(1 for b in books if b.status == "active"),
+        "total_sessions": total_sessions,
+    }
+
+
+@router.get("/{author_slug}/sessions")
+async def list_sessions(
+    author_slug: str,
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = 0,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """List reader sessions with pagination."""
+    from sqlalchemy import select, desc
+    from app.models.chat_session import ChatSession
+
+    result = await db.execute(
+        select(ChatSession)
+        .where(ChatSession.author_id == current_user.id)
+        .order_by(desc(ChatSession.created_at))
+        .offset(offset)
+        .limit(limit)
+    )
+    sessions = result.scalars().all()
+    return {
+        "sessions": [
+            {
+                "id": s.id,
+                "visitor_fingerprint": s.visitor_fingerprint,
+                "country": s.country_name,
+                "device_type": s.device_type,
+                "rating": s.rating,
+                "created_at": s.created_at.isoformat() if s.created_at else None,
+                "blocked": s.blocked,
+            }
+            for s in sessions
+        ]
+    }
+
+
+@router.post("/{author_slug}/sessions/{session_id}/block")
+async def block_session(
+    author_slug: str,
+    session_id: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Block a reader session (403 on next message)."""
+    from sqlalchemy import update
+    from app.models.chat_session import ChatSession
+    await db.execute(
+        update(ChatSession)
+        .where(ChatSession.id == session_id, ChatSession.author_id == current_user.id)
+        .values(blocked=True)
+    )
+    await db.commit()
+    return {"message": "Session blocked"}
+
+
+@router.post("/{author_slug}/sessions/{session_id}/unblock")
+async def unblock_session(
+    author_slug: str,
+    session_id: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Unblock a reader session."""
+    from sqlalchemy import update
+    from app.models.chat_session import ChatSession
+    await db.execute(
+        update(ChatSession)
+        .where(ChatSession.id == session_id, ChatSession.author_id == current_user.id)
+        .values(blocked=False)
+    )
+    await db.commit()
+    return {"message": "Session unblocked"}
+
+
+@router.get("/{author_slug}/books")
+async def list_books(
+    author_slug: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """List all books for the author."""
+    book_repo = BookRepository(db)
+    books = await book_repo.list_for_author(current_user.id)
+    return {
+        "books": [
+            {
+                "id": b.id,
+                "title": b.title,
+                "genre": b.genre,
+                "status": b.status,
+                "chunk_count": getattr(b, "chunk_count", 0),
+                "ai_summary": getattr(b, "ai_summary", ""),
+            }
+            for b in books
+        ]
+    }
+
+
+@router.delete("/{author_slug}/books/{book_id}")
+async def delete_book(
+    author_slug: str,
+    book_id: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Delete a book and its ChromaDB collection."""
+    book_repo = BookRepository(db)
+    book = await book_repo.get(book_id)
+    if not book or book.author_id != current_user.id:
+        from fastapi import HTTPException
+        raise HTTPException(404, "Book not found")
+
+    from app.services.embeddings import delete_book_embeddings
+    delete_book_embeddings(current_user.id, book_id)
+
+    await db.delete(book)
+    await db.commit()
+    return {"message": "Book deleted"}
+
+
+@router.get("/{author_slug}/analytics")
+async def get_analytics(
+    author_slug: str,
+    days: int = Query(30, ge=1, le=365),
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Return analytics data for dashboard charts."""
+    from datetime import datetime, timedelta, timezone
+    from sqlalchemy import select, func
+    from app.models.analytics import AnalyticsEvent
+
+    since = datetime.now(timezone.utc) - timedelta(days=days)
+    result = await db.execute(
+        select(
+            func.date(AnalyticsEvent.created_at).label("date"),
+            func.count().label("count"),
+        )
+        .where(
+            AnalyticsEvent.author_id == current_user.id,
+            AnalyticsEvent.created_at >= since,
+        )
+        .group_by(func.date(AnalyticsEvent.created_at))
+        .order_by(func.date(AnalyticsEvent.created_at))
+    )
+    daily = [{"date": str(row.date), "count": row.count} for row in result]
+    return {"daily_sessions": daily, "period_days": days}
+
+
+@router.post("/{author_slug}/password")
+async def change_password(
+    author_slug: str,
+    current_password: str,
+    new_password: str,
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Self-service password change."""
+    from app.core.security import verify_password, hash_password
+    if not verify_password(current_password, current_user.password_hash):
+        from fastapi import HTTPException
+        raise HTTPException(400, "Current password is incorrect")
+    current_user.password_hash = hash_password(new_password)
+    await db.commit()
+    return {"message": "Password updated"}

app/admin/templates/admin.html

@@ -0,0 +1,367 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>AuthorBot — Author Admin Panel</title>
+  <meta name="description" content="Manage your books, readers, analytics, and widget configuration for your AI-powered book sales chatbot.">
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    :root {
+      --bg: #080a12; --surface: #0f1322; --surface2: #161b2e;
+      --border: rgba(255,255,255,0.07); --accent: #6366f1; --accent2: #8b5cf6;
+      --text: #e2e8f0; --muted: #64748b; --green: #4ade80; --red: #f87171;
+    }
+    body { font-family: 'Inter', sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; }
+
+    /* ── Auth Screen ── */
+    .auth-wrap {
+      min-height: 100vh; display: flex; align-items: center; justify-content: center;
+      background: radial-gradient(ellipse at 60% 0%, #1e1060 0%, var(--bg) 70%);
+    }
+    .auth-box {
+      background: var(--surface); border: 1px solid var(--border); border-radius: 20px;
+      padding: 40px; width: 100%; max-width: 420px;
+      box-shadow: 0 32px 64px rgba(0,0,0,0.5);
+    }
+    .logo { font-size: 1.6rem; font-weight: 700; margin-bottom: 4px;
+      background: linear-gradient(135deg, #6366f1, #8b5cf6); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+    .auth-sub { color: var(--muted); font-size: 14px; margin-bottom: 32px; }
+    label { display: block; font-size: 12px; font-weight: 500; color: var(--muted); margin-bottom: 6px; letter-spacing: 0.05em; text-transform: uppercase; }
+    input[type=email], input[type=password], input[type=text] {
+      width: 100%; padding: 12px 14px; border-radius: 10px;
+      border: 1px solid var(--border); background: var(--bg);
+      color: var(--text); font-size: 14px; margin-bottom: 16px;
+      transition: border-color .2s;
+    }
+    input:focus { outline: none; border-color: var(--accent); }
+    .btn {
+      width: 100%; padding: 13px; border-radius: 10px; border: none;
+      background: linear-gradient(135deg, var(--accent), var(--accent2));
+      color: white; font-weight: 600; font-size: 15px; cursor: pointer;
+      transition: opacity .2s, transform .15s;
+    }
+    .btn:hover { opacity: .9; transform: translateY(-1px); }
+    .btn:active { transform: translateY(0); }
+    .msg { margin-top: 12px; font-size: 13px; min-height: 18px; }
+    .msg.ok { color: var(--green); } .msg.err { color: var(--red); }
+
+    /* ── Dashboard ── */
+    #dashboard { display: none; min-height: 100vh; }
+    .sidebar {
+      position: fixed; top: 0; left: 0; bottom: 0; width: 220px;
+      background: var(--surface); border-right: 1px solid var(--border);
+      display: flex; flex-direction: column; padding: 24px 16px;
+    }
+    .sidebar .logo { font-size: 1.2rem; margin-bottom: 32px; }
+    .nav-item {
+      display: flex; align-items: center; gap: 10px; padding: 10px 12px;
+      border-radius: 10px; color: var(--muted); text-decoration: none;
+      font-size: 14px; font-weight: 500; cursor: pointer; border: none; background: none;
+      width: 100%; transition: background .15s, color .15s; margin-bottom: 4px;
+    }
+    .nav-item:hover, .nav-item.active { background: rgba(99,102,241,.15); color: var(--accent); }
+    .main { margin-left: 220px; padding: 32px; }
+    .page { display: none; } .page.active { display: block; }
+    h1 { font-size: 1.5rem; font-weight: 700; margin-bottom: 4px; }
+    .page-sub { color: var(--muted); font-size: 14px; margin-bottom: 28px; }
+    .card {
+      background: var(--surface); border: 1px solid var(--border); border-radius: 16px;
+      padding: 24px; margin-bottom: 20px;
+    }
+    .stat-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 16px; margin-bottom: 24px; }
+    .stat { background: var(--surface2); border: 1px solid var(--border); border-radius: 14px; padding: 20px; }
+    .stat-val { font-size: 2rem; font-weight: 700; color: var(--accent); }
+    .stat-label { font-size: 12px; color: var(--muted); margin-top: 4px; }
+    table { width: 100%; border-collapse: collapse; font-size: 14px; }
+    th { text-align: left; padding: 10px 12px; color: var(--muted); font-weight: 500; font-size: 12px; border-bottom: 1px solid var(--border); }
+    td { padding: 12px; border-bottom: 1px solid rgba(255,255,255,0.04); }
+    tr:last-child td { border-bottom: none; }
+    .badge { display: inline-block; padding: 2px 8px; border-radius: 20px; font-size: 11px; font-weight: 600; }
+    .badge.active { background: rgba(74,222,128,.15); color: var(--green); }
+    .badge.processing { background: rgba(251,191,36,.15); color: #fbbf24; }
+    .badge.failed { background: rgba(248,113,113,.15); color: var(--red); }
+    .action-btn {
+      padding: 5px 12px; border-radius: 6px; border: 1px solid var(--border);
+      background: none; color: var(--text); font-size: 12px; cursor: pointer;
+    }
+    .action-btn:hover { background: rgba(255,255,255,.05); }
+    .action-btn.danger { color: var(--red); border-color: rgba(248,113,113,.3); }
+    pre.json-out {
+      background: var(--bg); border: 1px solid var(--border); border-radius: 10px;
+      padding: 16px; font-size: 12px; overflow: auto; max-height: 400px;
+    }
+    .field-row { margin-bottom: 16px; }
+    .logout-btn {
+      margin-top: auto; color: var(--muted); font-size: 13px; text-align: left;
+      background: none; border: none; cursor: pointer; padding: 8px 12px;
+    }
+    .logout-btn:hover { color: var(--red); }
+  </style>
+</head>
+<body>
+
+<!-- ── Auth Screen ── -->
+<div class="auth-wrap" id="auth-screen">
+  <div class="auth-box">
+    <div class="logo">AuthorBot</div>
+    <p class="auth-sub">Author Admin Panel — sign in to continue</p>
+    <div class="field-row">
+      <label>Email</label>
+      <input type="email" id="email" placeholder="you@example.com" autocomplete="email">
+    </div>
+    <div class="field-row">
+      <label>Password</label>
+      <input type="password" id="password" placeholder="••••••••" autocomplete="current-password">
+    </div>
+    <button class="btn" id="login-btn">Sign In</button>
+    <p class="msg" id="login-msg"></p>
+  </div>
+</div>
+
+<!-- ── Dashboard ── -->
+<div id="dashboard">
+  <nav class="sidebar">
+    <div class="logo">AuthorBot</div>
+    <a class="nav-item active" data-page="overview">📊 Dashboard</a>
+    <a class="nav-item" data-page="books">📚 Books</a>
+    <a class="nav-item" data-page="readers">👥 Readers</a>
+    <a class="nav-item" data-page="analytics">📈 Analytics</a>
+    <a class="nav-item" data-page="widget">🎨 Widget Config</a>
+    <a class="nav-item" data-page="settings">⚙️ Settings</a>
+    <button class="logout-btn" id="logout-btn">Sign Out</button>
+  </nav>
+
+  <main class="main">
+    <!-- Dashboard Overview -->
+    <div class="page active" id="page-overview">
+      <h1>Dashboard</h1>
+      <p class="page-sub">Your AuthorBot at a glance</p>
+      <div class="stat-grid">
+        <div class="stat"><div class="stat-val" id="stat-books">—</div><div class="stat-label">Books Indexed</div></div>
+        <div class="stat"><div class="stat-val" id="stat-sessions">—</div><div class="stat-label">Total Readers</div></div>
+        <div class="stat"><div class="stat-val" id="stat-active">—</div><div class="stat-label">Active Books</div></div>
+      </div>
+      <div class="card">
+        <p style="color:var(--muted);font-size:14px">Use the sidebar to manage books, view reader sessions, and configure your widget.</p>
+      </div>
+    </div>
+
+    <!-- Books -->
+    <div class="page" id="page-books">
+      <h1>Books</h1>
+      <p class="page-sub">Manage your book catalog</p>
+      <div class="card">
+        <table id="books-table">
+          <thead><tr><th>Title</th><th>Status</th><th>Chunks</th><th></th></tr></thead>
+          <tbody id="books-body"><tr><td colspan="4" style="color:var(--muted)">Loading...</td></tr></tbody>
+        </table>
+      </div>
+    </div>
+
+    <!-- Readers -->
+    <div class="page" id="page-readers">
+      <h1>Readers</h1>
+      <p class="page-sub">View and manage reader sessions</p>
+      <div class="card">
+        <table>
+          <thead><tr><th>Session</th><th>Country</th><th>Device</th><th>Rating</th><th>Date</th><th></th></tr></thead>
+          <tbody id="sessions-body"><tr><td colspan="6" style="color:var(--muted)">Loading...</td></tr></tbody>
+        </table>
+      </div>
+    </div>
+
+    <!-- Analytics -->
+    <div class="page" id="page-analytics">
+      <h1>Analytics</h1>
+      <p class="page-sub">Performance overview for the last 30 days</p>
+      <div class="card">
+        <pre class="json-out" id="analytics-output">Click Analytics in the sidebar to load data.</pre>
+      </div>
+    </div>
+
+    <!-- Widget Config -->
+    <div class="page" id="page-widget">
+      <h1>Widget Configuration</h1>
+      <p class="page-sub">Customize your chat widget appearance</p>
+      <div class="card">
+        <p style="color:var(--muted);font-size:14px">Widget config endpoints: <code>GET /api/admin/{slug}/widget-config</code></p>
+        <br>
+        <a href="/widget" target="_blank" class="action-btn">Preview Widget →</a>
+      </div>
+    </div>
+
+    <!-- Settings -->
+    <div class="page" id="page-settings">
+      <h1>Settings</h1>
+      <p class="page-sub">Account and security</p>
+      <div class="card">
+        <h3 style="margin-bottom:16px;font-size:1rem">Change Password</h3>
+        <div class="field-row">
+          <label>Current Password</label>
+          <input type="password" id="cur-pass" style="max-width:320px">
+        </div>
+        <div class="field-row">
+          <label>New Password</label>
+          <input type="password" id="new-pass" style="max-width:320px">
+        </div>
+        <button class="btn" id="change-pass-btn" style="max-width:180px">Update Password</button>
+        <p class="msg" id="pass-msg"></p>
+      </div>
+    </div>
+  </main>
+</div>
+
+<script>
+const API = window.location.origin + '/api';
+let token = localStorage.getItem('access_token');
+let authorSlug = localStorage.getItem('author_slug');
+
+// ── Auth ──────────────────────────────────────────────────────────────────────
+if (token) showDashboard();
+
+document.getElementById('login-btn').onclick = async () => {
+  const msg = document.getElementById('login-msg');
+  msg.textContent = ''; msg.className = 'msg';
+  try {
+    const res = await fetch(API + '/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        email: document.getElementById('email').value,
+        password: document.getElementById('password').value,
+      }),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.detail || 'Login failed');
+    token = data.access_token;
+    localStorage.setItem('access_token', token);
+    localStorage.setItem('author_slug', data.author_slug || 'me');
+    authorSlug = data.author_slug || 'me';
+    showDashboard();
+  } catch (e) {
+    msg.textContent = e.message; msg.className = 'msg err';
+  }
+};
+
+document.getElementById('logout-btn').onclick = () => {
+  localStorage.clear(); location.reload();
+};
+
+function showDashboard() {
+  document.getElementById('auth-screen').style.display = 'none';
+  document.getElementById('dashboard').style.display = 'block';
+  loadDashboard();
+}
+
+// ── Navigation ────────────────────────────────────────────────────────────────
+document.querySelectorAll('.nav-item').forEach(el => {
+  el.onclick = () => {
+    document.querySelectorAll('.nav-item').forEach(n => n.classList.remove('active'));
+    document.querySelectorAll('.page').forEach(p => p.classList.remove('active'));
+    el.classList.add('active');
+    const page = document.getElementById('page-' + el.dataset.page);
+    if (page) page.classList.add('active');
+    if (el.dataset.page === 'books') loadBooks();
+    if (el.dataset.page === 'readers') loadSessions();
+    if (el.dataset.page === 'analytics') loadAnalytics();
+  };
+});
+
+// ── API Calls ─────────────────────────────────────────────────────────────────
+async function apiGet(path) {
+  const res = await fetch(API + path, { headers: { Authorization: 'Bearer ' + token } });
+  return res.json();
+}
+
+async function loadDashboard() {
+  try {
+    const data = await apiGet(`/admin/${authorSlug}/dashboard`);
+    document.getElementById('stat-books').textContent = data.total_books ?? '—';
+    document.getElementById('stat-sessions').textContent = data.total_sessions ?? '—';
+    document.getElementById('stat-active').textContent = data.active_books ?? '—';
+  } catch {}
+}
+
+async function loadBooks() {
+  const tbody = document.getElementById('books-body');
+  tbody.innerHTML = '<tr><td colspan="4" style="color:var(--muted)">Loading...</td></tr>';
+  try {
+    const data = await apiGet(`/admin/${authorSlug}/books`);
+    tbody.innerHTML = (data.books || []).map(b => `
+      <tr>
+        <td style="font-weight:500">${b.title}</td>
+        <td><span class="badge ${b.status}">${b.status}</span></td>
+        <td>${b.chunk_count || 0}</td>
+        <td><button class="action-btn danger" onclick="deleteBook('${b.id}')">Delete</button></td>
+      </tr>
+    `).join('') || '<tr><td colspan="4" style="color:var(--muted)">No books yet. Upload via API.</td></tr>';
+  } catch { tbody.innerHTML = '<tr><td colspan="4" style="color:var(--red)">Failed to load</td></tr>'; }
+}
+
+async function deleteBook(id) {
+  if (!confirm('Delete this book and all its embeddings?')) return;
+  await fetch(API + `/admin/${authorSlug}/books/${id}`, {
+    method: 'DELETE', headers: { Authorization: 'Bearer ' + token }
+  });
+  loadBooks();
+}
+
+async function loadSessions() {
+  const tbody = document.getElementById('sessions-body');
+  tbody.innerHTML = '<tr><td colspan="6" style="color:var(--muted)">Loading...</td></tr>';
+  try {
+    const data = await apiGet(`/admin/${authorSlug}/sessions`);
+    tbody.innerHTML = (data.sessions || []).map(s => `
+      <tr>
+        <td style="font-family:monospace;font-size:11px">${s.id.slice(0,8)}…</td>
+        <td>${s.country || '—'}</td>
+        <td>${s.device_type || '—'}</td>
+        <td>${s.rating ? '⭐'.repeat(s.rating) : '—'}</td>
+        <td style="font-size:12px;color:var(--muted)">${s.created_at ? new Date(s.created_at).toLocaleDateString() : '—'}</td>
+        <td>
+          ${s.blocked
+            ? `<button class="action-btn" onclick="unblockSession('${s.id}')">Unblock</button>`
+            : `<button class="action-btn danger" onclick="blockSession('${s.id}')">Block</button>`
+          }
+        </td>
+      </tr>
+    `).join('') || '<tr><td colspan="6" style="color:var(--muted)">No sessions yet.</td></tr>';
+  } catch { tbody.innerHTML = '<tr><td colspan="6" style="color:var(--red)">Failed to load</td></tr>'; }
+}
+
+async function blockSession(id) {
+  await fetch(API + `/admin/${authorSlug}/sessions/${id}/block`, { method: 'POST', headers: { Authorization: 'Bearer ' + token } });
+  loadSessions();
+}
+async function unblockSession(id) {
+  await fetch(API + `/admin/${authorSlug}/sessions/${id}/unblock`, { method: 'POST', headers: { Authorization: 'Bearer ' + token } });
+  loadSessions();
+}
+
+async function loadAnalytics() {
+  try {
+    const data = await apiGet(`/admin/${authorSlug}/analytics`);
+    document.getElementById('analytics-output').textContent = JSON.stringify(data, null, 2);
+  } catch { document.getElementById('analytics-output').textContent = 'Failed to load analytics'; }
+}
+
+// ── Password change ───────────────────────────────────────────────────────────
+document.getElementById('change-pass-btn').onclick = async () => {
+  const msg = document.getElementById('pass-msg');
+  msg.textContent = ''; msg.className = 'msg';
+  try {
+    const res = await fetch(
+      API + `/admin/${authorSlug}/password?current_password=${encodeURIComponent(document.getElementById('cur-pass').value)}&new_password=${encodeURIComponent(document.getElementById('new-pass').value)}`,
+      { method: 'POST', headers: { Authorization: 'Bearer ' + token } }
+    );
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.detail || 'Failed');
+    msg.textContent = 'Password updated!'; msg.className = 'msg ok';
+  } catch(e) { msg.textContent = e.message; msg.className = 'msg err'; }
+};
+</script>
+</body>
+</html>

app/api/__init__.py

@@ -0,0 +1 @@
+# API package

backend/app/api/v1/chatbot.py → app/api/chat.py

@@ -1,43 +1,61 @@
-"""Author RAG Chatbot SaaS — Chatbot API Router.
-
-Public-facing endpoint used by the embedded widget.
-RULE: Requires X-Subscription-Token header — validated by get_subscription_author.
-RULE: Visitor fingerprint is generated server-side (not trusted from client).
+"""Author RAG — Chat API Router.
+
+Routes (per implementation plan):
+  POST /api/chat/{author_slug}                    — Main chat endpoint (widget)
+  POST /api/chat/{author_slug}/session/init        — Initialize session
+  GET  /api/chat/{author_slug}/session/history/{session_id}
+  POST /api/chat/{author_slug}/session/rate        — Star rating
+  POST /api/chat/{author_slug}/session/reset       — Reset session
+  GET  /api/chat/{author_slug}/events              — SSE for ingestion progress
+
+RULE: Requires X-Subscription-Token header on all routes.
+RULE: Visitor fingerprint is generated server-side.
 """
 
 import uuid
+import hashlib
 
 from fastapi import APIRouter, Depends, Header, Request
+from fastapi.responses import StreamingResponse
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.dependencies import get_db, get_redis, get_subscription_author
-from app.core.rag.pipeline import run_pipeline
-from app.core.session.manager import SessionManager
+from app.services.rag_pipeline import run_pipeline
+from app.services.session_core.manager import SessionManager
 from app.repositories.book_repo import BookRepository
 from app.schemas.chatbot import ChatRequest, ChatResponse, SessionInitResponse
 
 router = APIRouter()
 
 
-@router.post("/session", response_model=SessionInitResponse, status_code=201)
+def _fingerprint(request: Request) -> str:
+    """SHA-256 fingerprint from IP + UA (no PII stored)."""
+    components = [
+        request.client.host if request.client else "unknown",
+        request.headers.get("User-Agent", ""),
+        request.headers.get("Accept-Language", ""),
+    ]
+    return hashlib.sha256("|".join(components).encode()).hexdigest()[:32]
+
+
+@router.post("/{author_slug}/session/init", response_model=SessionInitResponse, status_code=201)
 async def init_session(
+    author_slug: str,
     request: Request,
     author=Depends(get_subscription_author),
     db: AsyncSession = Depends(get_db),
     redis=Depends(get_redis),
 ):
-    """Initialize a new chat session. Returns session ID and active book list."""
+    """Initialize a new chat session for a visitor."""
     session_id = str(uuid.uuid4())
-    visitor_fp = _generate_fingerprint(request)
+    visitor_fp = _fingerprint(request)
 
     book_repo = BookRepository(db)
     active_books = await book_repo.list_active_for_author(author.id)
 
-    # Create session record in DB
-    from app.models.base import generate_uuid
     from app.models.chat_session import ChatSession
-    from app.core.analytics.geo import get_geo_info
-    from app.core.analytics.tracker import parse_device_info
+    from app.services.analytics_core.geo import get_geo_info
+    from app.services.analytics_core.tracker import parse_device_info
 
     geo = await get_geo_info(request)
     device = parse_device_info(request)
@@ -75,25 +93,24 @@ async def init_session(
     )
 
 
-@router.post("/chat", response_model=ChatResponse)
+@router.post("/{author_slug}", response_model=ChatResponse)
 async def chat(
+    author_slug: str,
     payload: ChatRequest,
     author=Depends(get_subscription_author),
     db: AsyncSession = Depends(get_db),
     redis=Depends(get_redis),
 ):
-    """Process one chat message through the full RAG pipeline."""
+    """Process one chat message through the 12-step RAG pipeline."""
     session_mgr = SessionManager(redis)
     session_ctx = await session_mgr.load(payload.session_id, author.id)
 
-    # Update book selection if provided
     if payload.selected_book_id is not None:
         session_ctx.selected_book_id = payload.selected_book_id
         await session_mgr.set_selected_book(
             payload.session_id, author.id, payload.selected_book_id
         )
 
-    # Run 12-step pipeline
     result = await run_pipeline(
         query=payload.message,
         author=author,
@@ -101,15 +118,13 @@ async def chat(
         db=db,
     )
 
-    # Save session
     await session_mgr.save(
         context=session_ctx,
         user_message=payload.message,
         assistant_message=result.response["text"],
     )
 
-    # Persist message to DB + fire analytics
-    from app.core.analytics.tracker import track_turn
+    from app.services.analytics_core.tracker import track_turn
     await track_turn(
         db=db,
         redis=redis,
@@ -130,36 +145,72 @@ async def chat(
     )
 
 
-@router.post("/chat/{session_id}/select-book", status_code=200)
-async def select_book(
+@router.get("/{author_slug}/session/history/{session_id}")
+async def get_history(
+    author_slug: str,
     session_id: str,
-    book_id: str,
     author=Depends(get_subscription_author),
     redis=Depends(get_redis),
 ):
-    """Update the book selection for a session."""
+    """Return full chat history for a session."""
     session_mgr = SessionManager(redis)
-    await session_mgr.set_selected_book(session_id, author.id, book_id)
-    return {"message": "Book selected", "book_id": book_id}
+    ctx = await session_mgr.load(session_id, author.id)
+    return {"session_id": session_id, "history": ctx.history, "turn_count": ctx.turn_count}
 
 
-def _generate_fingerprint(request: Request) -> str:
-    """Generate an anonymous visitor fingerprint from request attributes.
+@router.post("/{author_slug}/session/rate")
+async def rate_session(
+    author_slug: str,
+    session_id: str,
+    rating: int,
+    author=Depends(get_subscription_author),
+    db: AsyncSession = Depends(get_db),
+):
+    """Submit a star rating (1–5) for a chat session."""
+    from app.models.chat_session import ChatSession
+    from sqlalchemy import update
+    await db.execute(
+        update(ChatSession)
+        .where(ChatSession.id == session_id, ChatSession.author_id == author.id)
+        .values(rating=rating)
+    )
+    await db.commit()
+    return {"message": "Rating saved", "rating": rating}
+
 
-    No PII — combines IP hash + User-Agent hash + Accept-Language.
+@router.post("/{author_slug}/session/reset")
+async def reset_session(
+    author_slug: str,
+    session_id: str,
+    author=Depends(get_subscription_author),
+    redis=Depends(get_redis),
+):
+    """Clear the session context from Redis (start fresh)."""
+    session_mgr = SessionManager(redis)
+    await session_mgr.delete(session_id, author.id)
+    return {"message": "Session reset"}
 
-    Args:
-        request: FastAPI request.
 
-    Returns:
-        Short hex fingerprint string.
-    """
-    import hashlib
-    components = [
-        request.client.host if request.client else "unknown",
-        request.headers.get("User-Agent", ""),
-        request.headers.get("Accept-Language", ""),
-        request.headers.get("Accept-Encoding", ""),
-    ]
-    combined = "|".join(components)
-    return hashlib.sha256(combined.encode()).hexdigest()[:32]
+@router.get("/{author_slug}/events")
+async def ingestion_events(
+    author_slug: str,
+    author=Depends(get_subscription_author),
+    redis=Depends(get_redis),
+):
+    """SSE stream for real-time ingestion progress updates."""
+    async def event_stream():
+        pubsub = redis.pubsub()
+        channel = f"ingestion:{author.id}"
+        await pubsub.subscribe(channel)
+        try:
+            async for message in pubsub.listen():
+                if message["type"] == "message":
+                    yield f"data: {message['data']}\n\n"
+        finally:
+            await pubsub.unsubscribe(channel)
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )

app/api/ingest.py

@@ -0,0 +1,164 @@
+"""Author RAG — Ingestion API Router.
+
+Routes (per implementation plan):
+  POST /api/admin/{author_slug}/books/upload          — Upload a book file
+  GET  /api/admin/{author_slug}/books/upload/progress — SSE ingestion progress
+
+RULE: Requires Author JWT (Bearer token).
+RULE: Magic byte validation before any processing.
+"""
+
+import asyncio
+import json
+
+from fastapi import APIRouter, Depends, File, UploadFile, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user, get_redis
+from app.services.file_validator import validate_file
+from app.services.parser import parse_document
+from app.services.chunker import chunk_text
+from app.services.embeddings import embed_and_store
+from app.services.summarizer import generate_summary
+from app.repositories.book_repo import BookRepository
+from app.repositories.document_repo import DocumentRepository
+from app.config import get_settings
+
+router = APIRouter()
+cfg = get_settings()
+
+
+@router.post("/{author_slug}/books/upload", status_code=202)
+async def upload_book(
+    author_slug: str,
+    file: UploadFile = File(...),
+    title: str = "",
+    genre: str = "",
+    price: float = 0.0,
+    buy_url: str = "",
+    current_user=Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis=Depends(get_redis),
+):
+    """Upload a book file (PDF/EPUB/DOCX/TXT) and start async ingestion.
+
+    Responds immediately with book_id. Use /progress SSE to track ingestion.
+    """
+    # Validate file (magic bytes, not just extension)
+    contents = await file.read()
+    ext = validate_file(contents, file.filename or "")
+
+    book_repo = BookRepository(db)
+    doc_repo = DocumentRepository(db)
+
+    book = await book_repo.create(
+        author_id=current_user.id,
+        title=title or (file.filename or "Untitled").rsplit(".", 1)[0],
+        genre=genre,
+        price=price,
+        buy_url=buy_url,
+        status="processing",
+    )
+
+    doc = await doc_repo.create(
+        book_id=book.id,
+        author_id=current_user.id,
+        filename=file.filename or "upload",
+        file_extension=ext,
+        file_size_bytes=len(contents),
+    )
+    await db.commit()
+
+    # Fire async ingestion in background
+    asyncio.create_task(
+        _run_ingestion(
+            contents=contents,
+            ext=ext,
+            book_id=book.id,
+            doc_id=doc.id,
+            author_id=current_user.id,
+            title=book.title,
+            redis=redis,
+            db=db,
+        )
+    )
+
+    return {"book_id": book.id, "doc_id": doc.id, "status": "processing"}
+
+
+@router.get("/{author_slug}/books/upload/progress")
+async def ingestion_progress(
+    author_slug: str,
+    book_id: str,
+    current_user=Depends(get_current_user),
+    redis=Depends(get_redis),
+):
+    """SSE stream for real-time ingestion progress of a specific book."""
+    async def event_stream():
+        channel = f"ingestion:{current_user.id}:{book_id}"
+        pubsub = redis.pubsub()
+        await pubsub.subscribe(channel)
+        try:
+            async for message in pubsub.listen():
+                if message["type"] == "message":
+                    yield f"data: {message['data']}\n\n"
+                    data = json.loads(message["data"])
+                    if data.get("stage") in ("complete", "error"):
+                        break
+        finally:
+            await pubsub.unsubscribe(channel)
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+async def _publish(redis, channel: str, stage: str, progress: int, detail: str = "") -> None:
+    """Publish an SSE progress event to Redis pub/sub."""
+    await redis.publish(channel, json.dumps({"stage": stage, "progress": progress, "detail": detail}))
+
+
+async def _run_ingestion(
+    contents: bytes,
+    ext: str,
+    book_id: str,
+    doc_id: str,
+    author_id: str,
+    title: str,
+    redis,
+    db: AsyncSession,
+) -> None:
+    """Full async ingestion: parse → chunk → embed → summarize."""
+    channel = f"ingestion:{author_id}:{book_id}"
+    book_repo = BookRepository(db)
+
+    try:
+        await _publish(redis, channel, "parsing", 10)
+        text = parse_document(contents, ext)
+
+        await _publish(redis, channel, "chunking", 30)
+        chunks = chunk_text(text)
+
+        await _publish(redis, channel, "embedding", 50)
+        collection_name = await embed_and_store(chunks, author_id, book_id, title)
+
+        await _publish(redis, channel, "summarizing", 80)
+        summary = await generate_summary(text[:3000], title)
+
+        await book_repo.update(book_id, {
+            "status": "active",
+            "chroma_collection": collection_name,
+            "ai_summary": summary,
+            "chunk_count": len(chunks),
+        })
+        await db.commit()
+
+        await _publish(redis, channel, "complete", 100)
+
+    except Exception as e:
+        await book_repo.update(book_id, {"status": "failed"})
+        await db.commit()
+        await _publish(redis, channel, "error", 0, str(e))

app/api/schemas_router.py

@@ -0,0 +1,64 @@
+"""Author RAG — Auth + misc schema routes mounted at /api.
+
+Routes:
+  POST /api/auth/register
+  POST /api/auth/login
+  POST /api/auth/refresh
+  POST /api/auth/logout
+  GET  /api/auth/me
+"""
+
+from fastapi import APIRouter, Depends, Response
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.schemas.auth import LoginRequest, RegisterRequest, TokenResponse, UserResponse, RefreshRequest
+from app.services.auth_service import AuthService
+
+router = APIRouter()
+
+
+@router.post("/auth/register", response_model=TokenResponse, status_code=201, tags=["Auth"])
+async def register(payload: RegisterRequest, db: AsyncSession = Depends(get_db)):
+    """Register a new author account."""
+    return await AuthService(db).register(
+        email=payload.email,
+        password=payload.password,
+        full_name=payload.full_name,
+    )
+
+
+@router.post("/auth/login", response_model=TokenResponse, tags=["Auth"])
+async def login(payload: LoginRequest, response: Response, db: AsyncSession = Depends(get_db)):
+    """Authenticate author and return JWT token pair."""
+    result = await AuthService(db).login(email=payload.email, password=payload.password)
+    response.set_cookie(
+        "refresh_token", result["refresh_token"],
+        httponly=True, secure=True, samesite="lax",
+        max_age=7 * 24 * 60 * 60,
+    )
+    return result
+
+
+@router.post("/auth/refresh", response_model=TokenResponse, tags=["Auth"])
+async def refresh(payload: RefreshRequest, response: Response, db: AsyncSession = Depends(get_db)):
+    """Issue new JWT token pair."""
+    result = await AuthService(db).refresh_tokens(payload.refresh_token)
+    response.set_cookie(
+        "refresh_token", result["refresh_token"],
+        httponly=True, secure=True, samesite="lax",
+        max_age=7 * 24 * 60 * 60,
+    )
+    return result
+
+
+@router.post("/auth/logout", status_code=204, tags=["Auth"])
+async def logout(response: Response, _=Depends(get_current_user)):
+    """Invalidate refresh token cookie."""
+    response.delete_cookie("refresh_token")
+
+
+@router.get("/auth/me", response_model=UserResponse, tags=["Auth"])
+async def get_me(current_user=Depends(get_current_user)):
+    """Return current author profile."""
+    return current_user

app/api/widget.py

@@ -0,0 +1,47 @@
+"""Author RAG — Widget Token API.
+
+Routes (per implementation plan):
+  GET /api/widget/token?slug={author_slug}&domain={domain}
+  GET /api/widget/{author_slug}    — Serves embeddable widget HTML
+
+RULE: Token must be verified on every widget chat request.
+"""
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import FileResponse, JSONResponse
+
+from app.core.security import sign_widget_token, verify_widget_token
+
+router = APIRouter()
+
+WIDGET_HTML = Path(__file__).resolve().parent.parent.parent / "static" / "addon.html"
+
+
+@router.get("/token")
+async def get_widget_token(
+    slug: str = Query(..., description="Author slug"),
+    domain: str = Query(..., description="Author's website domain"),
+):
+    """Generate a signed HMAC widget token for embedding.
+
+    The token encodes the author slug and allowed domain.
+    Embed via: <script src=".../static/widget.js" data-token="TOKEN">
+    """
+    token = sign_widget_token(slug, domain)
+    return {"token": token, "author_slug": slug, "domain": domain}
+
+
+@router.get("/{author_slug}")
+async def get_widget_page(author_slug: str):
+    """Serve the embeddable widget HTML page for an author."""
+    if not WIDGET_HTML.is_file():
+        raise HTTPException(404, "Widget not found")
+    return FileResponse(
+        WIDGET_HTML,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "no-cache, no-store, must-revalidate",
+        },
+    )

app/core/__init__.py

@@ -0,0 +1 @@
+# Core package

app/core/security.py

@@ -0,0 +1,113 @@
+"""Author RAG — Core Security Utilities.
+
+JWT creation/verification, TOTP, HMAC widget tokens, bcrypt password hashing.
+"""
+
+import hashlib
+import hmac
+import base64
+import json
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import bcrypt
+import pyotp
+from jose import JWTError, jwt
+
+from app.config import get_settings
+
+cfg = get_settings()
+
+
+# ─── Password ────────────────────────────────────────────────────────────────
+
+def hash_password(plain: str) -> str:
+    """Hash a plaintext password with bcrypt."""
+    return bcrypt.hashpw(plain.encode(), bcrypt.gensalt()).decode()
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    """Timing-safe bcrypt password verification."""
+    return bcrypt.checkpw(plain.encode(), hashed.encode())
+
+
+# ─── JWT ─────────────────────────────────────────────────────────────────────
+
+def create_jwt(data: dict[str, Any], expires_minutes: int | None = None) -> str:
+    """Create a signed JWT access token."""
+    payload = data.copy()
+    expire = datetime.now(timezone.utc) + timedelta(
+        minutes=expires_minutes or cfg.ACCESS_TOKEN_EXPIRE_MINUTES
+    )
+    payload["exp"] = expire
+    return jwt.encode(payload, cfg.SECRET_KEY, algorithm=cfg.JWT_ALGORITHM)
+
+
+def verify_jwt(token: str) -> dict:
+    """Verify and decode a JWT. Raises JWTError on failure."""
+    return jwt.decode(token, cfg.SECRET_KEY, algorithms=[cfg.JWT_ALGORITHM])
+
+
+# ─── TOTP ─────────────────────────────────────────────────────────────────────
+
+def generate_totp_secret() -> str:
+    """Generate a new base32 TOTP secret."""
+    return pyotp.random_base32()
+
+
+def verify_totp(token: str, secret: str) -> bool:
+    """Verify a 6-digit TOTP code against the secret."""
+    totp = pyotp.TOTP(secret)
+    return totp.verify(token, valid_window=1)
+
+
+def get_totp_provisioning_uri(secret: str, account_name: str) -> str:
+    """Get the otpauth:// URI for QR code generation."""
+    totp = pyotp.TOTP(secret)
+    return totp.provisioning_uri(
+        name=account_name,
+        issuer_name=cfg.SUPERADMIN_2FA_ISSUER,
+    )
+
+
+# ─── HMAC Widget Tokens ───────────────────────────────────────────────────────
+
+def sign_widget_token(author_slug: str, domain: str) -> str:
+    """Generate a signed widget token for embedding on author's site.
+
+    Format: base64url(payload).base64url(hmac)
+    """
+    payload = json.dumps(
+        {"author_slug": author_slug, "domain": domain},
+        separators=(",", ":"),
+    )
+    encoded = base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=")
+    sig = _hmac_sign(encoded)
+    return f"{encoded}.{sig}"
+
+
+def verify_widget_token(token: str) -> dict:
+    """Verify a widget token and return the payload.
+
+    Raises ValueError if invalid.
+    """
+    try:
+        parts = token.split(".")
+        if len(parts) != 2:
+            raise ValueError("Malformed token")
+        encoded_payload, provided_sig = parts
+        expected_sig = _hmac_sign(encoded_payload)
+        if not hmac.compare_digest(expected_sig, provided_sig):
+            raise ValueError("Invalid signature")
+        padded = encoded_payload + "=" * (4 - len(encoded_payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(padded).decode())
+    except ValueError:
+        raise
+    except Exception as e:
+        raise ValueError(f"Token verification failed: {e}") from e
+
+
+def _hmac_sign(payload: str) -> str:
+    secret = (cfg.SUBSCRIPTION_SECRET or cfg.SECRET_KEY).encode()
+    sig = hmac.new(secret, payload.encode(), hashlib.sha256).digest()
+    return base64.urlsafe_b64encode(sig).decode().rstrip("=")

{backend/app → app}/main.py

@@ -1,26 +1,33 @@
 """Author RAG Chatbot SaaS — FastAPI Application Factory.
 
-Routing follows the Hugging Face Space pattern:
-  /ui      — Gradio chat (main entry for visitors)
-  /widget  — Embeddable chat widget (CORS-friendly)
-  /admin   — Admin portal
-  /api/v1  — REST API
-  /health  — Health check
-  /        — Redirect to /ui
+Routing (per implementation plan):
+  /api/chat/{author_slug}          — Widget chat endpoint
+  /api/admin/{author_slug}/*       — Per-author admin endpoints
+  /api/super/*                     — SuperAdmin endpoints (TOTP required)
+  /api/widget/token                — Signed widget token generation
+  /admin                           — Author Admin SPA
+  /superadmin                      — SuperAdmin SPA
+  /widget                          — Embeddable widget test page
+  /health                          — Health check
+  /                                — Redirect to /admin
 """
 
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import AsyncGenerator
 
-import gradio as gr
 import structlog
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 
-from app.api.v1 import auth, books, documents, chatbot, analytics, settings, links, superadmin
+from app.api.chat import router as chat_router
+from app.api.ingest import router as ingest_router
+from app.api.widget import router as widget_router
+from app.api.schemas_router import router as schemas_router
+from app.admin.router import router as admin_router
+from app.superadmin.router import router as superadmin_router
 from app.config import get_settings
 from app.exceptions.base import AppException
 from app.exceptions.auth import AuthError, InvalidTokenError, ExpiredTokenError, AccountLockedError
@@ -30,32 +37,40 @@ from app.exceptions.access import (
 )
 from app.middleware.logging_middleware import LoggingMiddleware
 from app.middleware.rate_limit_middleware import RateLimitMiddleware
-from app.ui_gradio import demo
 
 logger = structlog.get_logger(__name__)
-STATIC_DIR = Path(__file__).resolve().parent.parent / "static"
+
+# Directories
+ROOT_DIR = Path(__file__).resolve().parent.parent
+STATIC_DIR = ROOT_DIR / "static"
+ADMIN_TEMPLATE = ROOT_DIR / "app" / "admin" / "templates" / "admin.html"
+SUPERADMIN_TEMPLATE = ROOT_DIR / "app" / "superadmin" / "templates" / "superadmin.html"
+WIDGET_TEMPLATE = ROOT_DIR / "static" / "addon.html"
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Handle application startup and shutdown lifecycle."""
+    """Application startup / shutdown lifecycle."""
     cfg = get_settings()
-    logger.info("Starting AuthorBot API", env=cfg.APP_ENV)
+    logger.info("Starting AuthorRAG", env=cfg.APP_ENV)
     if Path("/data").exists():
         logger.info("Persistent HF storage detected at /data")
     else:
-        logger.warning("No /data mount — data may not persist across rebuilds")
+        logger.warning("No /data mount — data will not persist across rebuilds")
     yield
-    logger.info("AuthorBot API shutting down")
+    logger.info("AuthorRAG shutting down")
 
 
-def create_fastapi_app() -> FastAPI:
-    """Create and configure the inner FastAPI application."""
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
     cfg = get_settings()
 
     app = FastAPI(
-        title="AuthorBot API",
-        description="RAG Chatbot SaaS for Author Websites",
+        title="Author RAG — AI Book Sales Chatbot SaaS",
+        description=(
+            "Multi-tenant SaaS platform that deploys a persuasive AI chatbot "
+            "on any author's website. Powered by a 12-step RAG pipeline."
+        ),
         version="1.0.0",
         docs_url="/docs",
         redoc_url="/redoc",
@@ -71,7 +86,7 @@ def create_fastapi_app() -> FastAPI:
 
 
 def _register_middleware(app: FastAPI, cfg) -> None:
-    """Register all middleware in correct order (outermost first)."""
+    """Register middleware (outermost first)."""
     app.add_middleware(LoggingMiddleware)
     app.add_middleware(RateLimitMiddleware)
     app.add_middleware(
@@ -84,117 +99,120 @@ def _register_middleware(app: FastAPI, cfg) -> None:
 
 
 def _register_exception_handlers(app: FastAPI) -> None:
-    """Map domain exceptions to clean HTTP responses."""
+    """Map domain exceptions to HTTP responses."""
 
     @app.exception_handler(AuthError)
-    async def auth_error_handler(request: Request, exc: AuthError) -> JSONResponse:
-        return JSONResponse(status_code=401, content={"detail": str(exc)})
+    async def _(r: Request, e: AuthError) -> JSONResponse:
+        return JSONResponse(401, {"detail": str(e)})
 
     @app.exception_handler(InvalidTokenError)
-    async def invalid_token_handler(request: Request, exc: InvalidTokenError) -> JSONResponse:
-        return JSONResponse(status_code=401, content={"detail": "Invalid or malformed token"})
+    async def _(r: Request, e: InvalidTokenError) -> JSONResponse:
+        return JSONResponse(401, {"detail": "Invalid or malformed token"})
 
     @app.exception_handler(ExpiredTokenError)
-    async def expired_token_handler(request: Request, exc: ExpiredTokenError) -> JSONResponse:
-        return JSONResponse(status_code=401, content={"detail": "Token has expired"})
+    async def _(r: Request, e: ExpiredTokenError) -> JSONResponse:
+        return JSONResponse(401, {"detail": "Token has expired"})
 
     @app.exception_handler(AccountLockedError)
-    async def account_locked_handler(request: Request, exc: AccountLockedError) -> JSONResponse:
-        return JSONResponse(status_code=423, content={"detail": str(exc)})
+    async def _(r: Request, e: AccountLockedError) -> JSONResponse:
+        return JSONResponse(423, {"detail": str(e)})
 
     @app.exception_handler(SubscriptionExpiredError)
-    async def subscription_expired_handler(request: Request, exc: SubscriptionExpiredError) -> JSONResponse:
-        return JSONResponse(status_code=403, content={"detail": "This chatbot service is currently unavailable"})
+    async def _(r: Request, e: SubscriptionExpiredError) -> JSONResponse:
+        return JSONResponse(403, {"detail": "This chatbot service is currently unavailable"})
 
     @app.exception_handler(AccessRevokedError)
-    async def access_revoked_handler(request: Request, exc: AccessRevokedError) -> JSONResponse:
-        return JSONResponse(status_code=403, content={"detail": "This chatbot service is currently unavailable"})
+    async def _(r: Request, e: AccessRevokedError) -> JSONResponse:
+        return JSONResponse(403, {"detail": "This chatbot service is currently unavailable"})
 
     @app.exception_handler(InvalidSubscriptionTokenError)
-    async def invalid_subscription_token_handler(request: Request, exc: InvalidSubscriptionTokenError) -> JSONResponse:
-        return JSONResponse(status_code=401, content={"detail": "Invalid or expired subscription token"})
+    async def _(r: Request, e: InvalidSubscriptionTokenError) -> JSONResponse:
+        return JSONResponse(401, {"detail": "Invalid or expired subscription token"})
 
     @app.exception_handler(SubscriptionNotFoundError)
-    async def subscription_not_found_handler(request: Request, exc: SubscriptionNotFoundError) -> JSONResponse:
-        return JSONResponse(status_code=403, content={"detail": "No active subscription. Contact support."})
+    async def _(r: Request, e: SubscriptionNotFoundError) -> JSONResponse:
+        return JSONResponse(403, {"detail": "No active subscription. Contact support."})
 
     @app.exception_handler(BudgetExhaustedError)
-    async def budget_exhausted_handler(request: Request, exc: BudgetExhaustedError) -> JSONResponse:
-        return JSONResponse(
-            status_code=200,
-            content={"message": "I'm taking a short break to recharge! Check back soon."},
-        )
+    async def _(r: Request, e: BudgetExhaustedError) -> JSONResponse:
+        return JSONResponse(200, {"message": "I'm taking a short break to recharge! Check back soon."})
 
     @app.exception_handler(AppException)
-    async def app_exception_handler(request: Request, exc: AppException) -> JSONResponse:
-        logger.error("Unhandled AppException", error=str(exc), path=request.url.path)
-        return JSONResponse(status_code=500, content={"detail": "An internal error occurred"})
+    async def _(r: Request, e: AppException) -> JSONResponse:
+        logger.error("AppException", error=str(e), path=r.url.path)
+        return JSONResponse(500, {"detail": "An internal error occurred"})
 
     @app.exception_handler(Exception)
-    async def unhandled_exception_handler(request: Request, exc: Exception) -> JSONResponse:
-        logger.error("Unhandled exception", error=str(exc), path=request.url.path, exc_info=True)
-        return JSONResponse(status_code=500, content={"detail": "An internal error occurred"})
+    async def _(r: Request, e: Exception) -> JSONResponse:
+        logger.error("Unhandled exception", error=str(e), path=r.url.path, exc_info=True)
+        return JSONResponse(500, {"detail": "An internal error occurred"})
 
 
 def _register_routers(app: FastAPI) -> None:
-    """Register all API routers under /api/v1."""
-    prefix = "/api/v1"
-    app.include_router(auth.router, prefix=f"{prefix}/auth", tags=["Authentication"])
-    app.include_router(books.router, prefix=f"{prefix}/books", tags=["Books"])
-    app.include_router(documents.router, prefix=f"{prefix}/documents", tags=["Documents"])
-    app.include_router(chatbot.router, prefix=f"{prefix}/chatbot", tags=["Chatbot"])
-    app.include_router(analytics.router, prefix=f"{prefix}/analytics", tags=["Analytics"])
-    app.include_router(settings.router, prefix=f"{prefix}/settings", tags=["Settings"])
-    app.include_router(links.router, prefix=f"{prefix}/links", tags=["Links"])
-    app.include_router(superadmin.router, prefix=f"{prefix}/superadmin", tags=["Super Admin"])
+    """Register all API routers with plan-correct prefixes."""
+
+    # Chat widget API: /api/chat/{author_slug}
+    app.include_router(chat_router, prefix="/api/chat", tags=["Chat"])
+
+    # Ingestion API: /api/admin/{author_slug}/books/*
+    app.include_router(ingest_router, prefix="/api/admin", tags=["Ingestion"])
+
+    # Widget token API: /api/widget/*
+    app.include_router(widget_router, prefix="/api/widget", tags=["Widget"])
+
+    # Author admin API: /api/admin/{author_slug}/*
+    app.include_router(admin_router, prefix="/api/admin", tags=["Admin"])
+
+    # SuperAdmin API: /api/super/*
+    app.include_router(superadmin_router, prefix="/api/super", tags=["SuperAdmin"])
+
+    # Misc schema/auth routes: /api/*
+    app.include_router(schemas_router, prefix="/api", tags=["Auth"])
 
 
 def _register_public_routes(app: FastAPI) -> None:
-    """Public-facing pages and static assets (registered before Gradio mount)."""
+    """Static files and HTML page routes."""
 
     if STATIC_DIR.is_dir():
         app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 
     @app.get("/", include_in_schema=False)
     async def root() -> RedirectResponse:
-        """Space home → Gradio chat UI."""
-        return RedirectResponse(url="/ui")
+        return RedirectResponse(url="/admin")
 
-    @app.get("/demo", include_in_schema=False)
-    async def demo_redirect() -> RedirectResponse:
-        """Legacy demo URL → widget."""
-        return RedirectResponse(url="/widget")
+    @app.get("/admin", include_in_schema=False)
+    async def get_admin() -> FileResponse:
+        """Author Admin SPA."""
+        if not ADMIN_TEMPLATE.is_file():
+            raise HTTPException(404, "Admin panel not found")
+        return FileResponse(ADMIN_TEMPLATE)
+
+    @app.get("/superadmin", include_in_schema=False)
+    async def get_superadmin() -> FileResponse:
+        """SuperAdmin SPA (TOTP required — enforced client-side and API-side)."""
+        if not SUPERADMIN_TEMPLATE.is_file():
+            raise HTTPException(404, "SuperAdmin panel not found")
+        return FileResponse(SUPERADMIN_TEMPLATE)
 
     @app.get("/widget", include_in_schema=False)
     async def get_widget() -> FileResponse:
-        """Embeddable chat widget with CORS headers for external sites."""
-        path = STATIC_DIR / "addon.html"
-        if not path.is_file():
-            raise HTTPException(status_code=404, detail="Widget not found")
+        """Embeddable widget test/demo page."""
+        if not WIDGET_TEMPLATE.is_file():
+            raise HTTPException(404, "Widget not found")
         return FileResponse(
-            path,
+            WIDGET_TEMPLATE,
             headers={
                 "Access-Control-Allow-Origin": "*",
                 "Cache-Control": "no-cache, no-store, must-revalidate",
             },
         )
 
-    @app.get("/admin", include_in_schema=False)
-    async def get_admin() -> FileResponse:
-        """Author admin portal."""
-        path = STATIC_DIR / "admin.html"
-        if not path.is_file():
-            raise HTTPException(status_code=404, detail="Admin panel not found")
-        return FileResponse(path)
-
     @app.get("/health", tags=["Health"])
     async def health_check() -> dict:
-        """System health check — verifies DB, Redis, and ChromaDB."""
+        """System health — verifies DB, Redis, ChromaDB."""
         from app.dependencies import check_health
         return await check_health()
 
 
-fastapi_app = create_fastapi_app()
-
-# Mount Gradio at /ui — MUST be last (wraps the FastAPI app for HF Spaces)
-app = gr.mount_gradio_app(fastapi_app, demo, path="/ui")
+# Application instance
+app = create_app()

app/models/__init__.py

@@ -0,0 +1,14 @@
+"""Author RAG — SQLAlchemy model exports."""
+from app.models.base import Base
+from app.models.user import User
+from app.models.book import Book
+from app.models.document import Document
+from app.models.chat_session import ChatSession
+from app.models.link import Link
+from app.models.client_access import ClientAccess
+from app.models.analytics import AnalyticsEvent
+
+__all__ = [
+    "Base", "User", "Book", "Document",
+    "ChatSession", "Link", "ClientAccess", "AnalyticsEvent",
+]