create-snapify-app 0.0.0-stage → 1.1.0

package/template/server/superadmin/routes.ts

@@ -0,0 +1,1095 @@
+/**
+ * Snapify — API superadmin /hamdisup90
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { and, count, desc, eq, gte, sql } from 'drizzle-orm';
+import { asyncRouter, HttpError } from '../http';
+import { db } from '../db/client';
+import {
+  mpOrderItems,
+  mpOrders,
+  mpPayouts,
+  mpProducts,
+  mpPublishers,
+  mpVersions,
+  platformSessions,
+  platformUsers,
+} from '../db/schema';
+import { getMpSettings, setMpSettings, formatDt } from '../platform/settings';
+import { listLicenseOrders, setLicenseOrderStatus, updateLicenseOrder, deleteLicenseOrder } from '../platform/licenseOrders';
+import { syncOfficialMarketplace } from '../marketplace/syncOfficial';
+import { approveProduct, PACKAGES_DIR } from '../marketplace/signing';
+import { flouciMockAllowed } from '../platform/flouci';
+import { clientIp } from '../security/ip';
+import { visitStats, trackVisit } from './analytics';
+import {
+  baseForMarket,
+  buildMarketSeoPack,
+  getLandingSeo,
+  getSeoBacklinks,
+  marketFromHost,
+  seedSeoBacklinks,
+  setLandingSeo,
+  setSeoBacklinks,
+  type LandingMarket,
+} from './landingSeo';
+import { BACKLINK_CATALOG, catalogStats } from './backlinksCatalog';
+import {
+  createSuperadminSession,
+  destroySuperadminSession,
+  isSuperadminAuthed,
+  loginSuperadmin,
+  requireSuperadmin,
+  superadminCreds,
+} from './auth';
+import {
+  createInvoiceFromLicense,
+  createInvoiceFromOrder,
+  recordPaymentEvent,
+  refundMarketplaceOrder,
+  relaunchLicense,
+  sendInvoice,
+  sendNewsletterCampaign,
+} from './ops';
+import { loadSnapshot, updateSnapshot } from '../cms/store';
+import { encryptSecret } from '../security/secrets';
+import { smtpSource, testSmtp } from '../mail';
+import {
+  saInvoices,
+  saNewsletterCampaigns,
+  saNewsletterSubscribers,
+  saPaymentEvents,
+  saTickets,
+} from '../db/schema';
+import crypto from 'crypto';
+
+export function createSuperadminRouter() {
+  const r = asyncRouter();
+
+  r.get('/me', (req, res) => {
+    res.json({ ok: isSuperadminAuthed(req), username: superadminCreds().username });
+  });
+
+  r.post('/login', (req, res) => {
+    const username = String(req.body?.username || '');
+    const password = String(req.body?.password || '');
+    if (!loginSuperadmin(username, password)) throw new HttpError(401, 'Identifiants incorrects');
+    createSuperadminSession(res);
+    res.json({ ok: true, username: superadminCreds().username });
+  });
+
+  r.post('/logout', (req, res) => {
+    destroySuperadminSession(req, res);
+    res.json({ ok: true });
+  });
+
+  /** Tracking public landing (pas d’auth) */
+  r.post('/track', async (req, res) => {
+    const path = String(req.body?.path || '/').slice(0, 200);
+    await trackVisit({
+      path,
+      ip: clientIp(req),
+      ua: String(req.headers['user-agent'] || ''),
+      ref: String(req.body?.ref || req.headers.referer || ''),
+    });
+    res.json({ ok: true });
+  });
+
+  /** SEO public pour la landing (adapté .tn / .fr) */
+  r.get('/seo-public', async (req, res) => {
+    const host = String(req.headers['x-forwarded-host'] || req.headers.host || 'snapify.tn')
+      .split(',')[0]
+      .trim()
+      .toLowerCase();
+    const market = marketFromHost(host);
+    const path = String(req.query.path || '/');
+    const seo = await getLandingSeo();
+    const pack = buildMarketSeoPack(seo, market, path);
+    res.json({
+      ...seo,
+      market: pack.market,
+      title: pack.title,
+      description: pack.description,
+      keywords: pack.keywords,
+      canonical: pack.canonical,
+      ogImage: pack.ogImage,
+      robots: pack.robots,
+      cities: pack.cities,
+      hreflang: pack.hreflang,
+      jsonLd: pack.jsonLd,
+    });
+  });
+
+  r.use(requireSuperadmin);
+
+  r.get('/overview', async (_req, res) => {
+    const visits = await visitStats();
+    const settings = await getMpSettings();
+    const licenses = await listLicenseOrders();
+    const [
+      [prodCount],
+      [pubCount],
+      [orderCount],
+      [pendingCount],
+      [userCount],
+      [activePubCount],
+      [payoutPending],
+      [payoutPendingSum],
+    ] = await Promise.all([
+      db.select({ n: count() }).from(mpProducts),
+      db.select({ n: count() }).from(mpPublishers),
+      db.select({ n: count() }).from(mpOrders).where(eq(mpOrders.status, 'paid')),
+      db.select({ n: count() }).from(mpProducts).where(eq(mpProducts.status, 'pending')),
+      db.select({ n: count() }).from(platformUsers),
+      db.select({ n: count() }).from(mpPublishers).where(eq(mpPublishers.status, 'active')),
+      db.select({ n: count() }).from(mpPayouts).where(eq(mpPayouts.status, 'requested')),
+      db
+        .select({ n: sql<string>`coalesce(sum(${mpPayouts.amountMillimes}), 0)` })
+        .from(mpPayouts)
+        .where(eq(mpPayouts.status, 'requested')),
+    ]);
+    const paidLicenses = licenses.filter((l) => l.status === 'paid');
+    const pendingLicenses = licenses.filter((l) => l.status === 'pending');
+    const since30 = new Date(Date.now() - 30 * 24 * 3600 * 1000);
+    const paidMp = await db
+      .select()
+      .from(mpOrders)
+      .where(and(eq(mpOrders.status, 'paid'), gte(mpOrders.paidAt, since30)));
+    const mpGross = paidMp.reduce((a, o) => a + o.totalMillimes, 0);
+    const mpCommission = paidMp.reduce((a, o) => a + o.commissionMillimes, 0);
+    res.json({
+      visits,
+      marketplace: {
+        products: prodCount?.n || 0,
+        publishers: pubCount?.n || 0,
+        activePublishers: activePubCount?.n || 0,
+        paidOrders: orderCount?.n || 0,
+        pendingReview: pendingCount?.n || 0,
+        commissionBps: settings.commissionBps,
+        developerFeeMillimes: settings.developerFeeMillimes,
+        developerFeeLabel: formatDt(settings.developerFeeMillimes),
+        commissionLabel: `${(settings.commissionBps / 100).toFixed(0)} %`,
+        revenue30dMillimes: mpGross,
+        commission30dMillimes: mpCommission,
+      },
+      licenses: {
+        total: licenses.length,
+        paid: paidLicenses.length,
+        pending: pendingLicenses.length,
+        revenueMillimes: paidLicenses.reduce((a, b) => a + b.amountMillimes, 0),
+      },
+      users: { total: userCount?.n || 0 },
+      payouts: {
+        pending: payoutPending?.n || 0,
+        pendingMillimes: Number(payoutPendingSum?.n || 0),
+      },
+    });
+  });
+
+  r.get('/settings', async (_req, res) => {
+    const s = await getMpSettings();
+    res.json({
+      commissionBps: s.commissionBps,
+      developerFeeMillimes: s.developerFeeMillimes,
+      bankFallback: s.bankFallback,
+      flouciPublicKey: s.flouciPublicKey || '',
+      hasFlouciPrivateKey: Boolean(s.flouciPrivateKeyEnc || process.env.FLOUCI_PRIVATE_KEY),
+    });
+  });
+
+  r.put('/settings', async (req, res) => {
+    const next = await setMpSettings({
+      commissionBps: req.body?.commissionBps !== undefined ? Math.max(0, Math.min(9000, Number(req.body.commissionBps) || 0)) : undefined,
+      developerFeeMillimes:
+        req.body?.developerFeeMillimes !== undefined ? Math.max(0, Number(req.body.developerFeeMillimes) || 0) : undefined,
+      bankFallback: req.body?.bankFallback,
+      flouciPublicKey: req.body?.flouciPublicKey,
+      flouciPrivateKey: req.body?.flouciPrivateKey,
+    });
+    res.json({
+      commissionBps: next.commissionBps,
+      developerFeeMillimes: next.developerFeeMillimes,
+      bankFallback: next.bankFallback,
+      flouciPublicKey: next.flouciPublicKey || '',
+    });
+  });
+
+  r.get('/licenses', async (_req, res) => {
+    res.json({ items: await listLicenseOrders() });
+  });
+
+  r.patch('/licenses/:id', async (req, res) => {
+    const body = req.body || {};
+    // Édition complète (champs client) ou simple changement de statut
+    if (
+      body.name !== undefined ||
+      body.email !== undefined ||
+      body.domain !== undefined ||
+      body.hostingNotes !== undefined ||
+      body.amountMillimes !== undefined ||
+      body.details !== undefined
+    ) {
+      const order = await updateLicenseOrder(req.params.id, body);
+      if (!order) throw new HttpError(404, 'Demande introuvable');
+      return res.json({ order });
+    }
+    const status = body.status;
+    if (status !== 'pending' && status !== 'paid' && status !== 'failed') {
+      throw new HttpError(422, 'status = pending | paid | failed');
+    }
+    const order = await setLicenseOrderStatus(req.params.id, status);
+    if (!order) throw new HttpError(404, 'Demande introuvable');
+    res.json({ order });
+  });
+
+  r.delete('/licenses/:id', async (req, res) => {
+    const order = await deleteLicenseOrder(req.params.id);
+    if (!order) throw new HttpError(404, 'Demande introuvable');
+    res.json({ ok: true, id: order.id });
+  });
+
+  r.post('/licenses/:id/relaunch', async (req, res) => {
+    res.json(await relaunchLicense(req.params.id));
+  });
+
+  r.post('/licenses/:id/invoice', async (req, res) => {
+    const invoice = await createInvoiceFromLicense(req.params.id);
+    res.json({ invoice });
+  });
+
+  r.get('/clients', async (req, res) => {
+    const { listClientProfiles, ensureClientFromLicenseOrder } = await import('../platform/clients');
+    // Backfill : fiches manquantes depuis les demandes licence existantes
+    const orders = await listLicenseOrders();
+    const existing = await listClientProfiles({});
+    if (existing.length < orders.length) {
+      for (const o of orders) {
+        await ensureClientFromLicenseOrder(o).catch(() => undefined);
+      }
+    }
+    const status = String(req.query.status || 'all');
+    const q = String(req.query.q || '').trim();
+    const items = await listClientProfiles({ status, q });
+    res.json({ items });
+  });
+
+  r.get('/clients/:id', async (req, res) => {
+    const { listClientProfiles } = await import('../platform/clients');
+    const items = await listClientProfiles({});
+    const client = items.find((c) => c.id === req.params.id);
+    if (!client) throw new HttpError(404, 'Client introuvable');
+    const orders = (await listLicenseOrders()).filter(
+      (o) => o.email.toLowerCase() === client.email || client.licenseOrderIds.includes(o.id)
+    );
+    const tickets = await db
+      .select()
+      .from(saTickets)
+      .where(eq(saTickets.email, client.email))
+      .orderBy(desc(saTickets.updatedAt))
+      .limit(50);
+    const invoices = await db
+      .select()
+      .from(saInvoices)
+      .where(eq(saInvoices.customerEmail, client.email))
+      .orderBy(desc(saInvoices.createdAt))
+      .limit(50);
+    res.json({ client, orders, tickets, invoices });
+  });
+
+  r.patch('/clients/:id', async (req, res) => {
+    const { updateClientProfile } = await import('../platform/clients');
+    const b = req.body || {};
+    const patch: Record<string, string> = {};
+    for (const k of ['name', 'phone', 'company', 'domain', 'status', 'notes', 'market', 'country'] as const) {
+      if (typeof b[k] === 'string') patch[k] = String(b[k]).slice(0, k === 'notes' ? 4000 : 200);
+    }
+    const client = await updateClientProfile(req.params.id, patch);
+    if (!client) throw new HttpError(404, 'Client introuvable');
+    res.json({ client });
+  });
+
+  r.get('/products', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const rows =
+      status === 'all' || status === 'unsigned'
+        ? await db.select().from(mpProducts).orderBy(desc(mpProducts.updatedAt)).limit(200)
+        : await db
+            .select()
+            .from(mpProducts)
+            .where(eq(mpProducts.status, status as 'pending'))
+            .orderBy(desc(mpProducts.updatedAt))
+            .limit(200);
+    const versions = await db.select().from(mpVersions).orderBy(desc(mpVersions.createdAt));
+    const latest = new Map<string, (typeof versions)[0]>();
+    const unsigned = new Map<string, string[]>();
+    for (const v of versions) {
+      if (!latest.has(v.productId)) latest.set(v.productId, v);
+      if (!v.signed) unsigned.set(v.productId, [...(unsigned.get(v.productId) ?? []), v.version]);
+    }
+    const listed = status === 'unsigned' ? rows.filter((p) => unsigned.has(p.id) && p.status !== 'rejected') : rows;
+    res.json({
+      items: listed.map((p) => ({
+        ...p,
+        priceLabel: formatDt(p.priceMillimes),
+        unsignedVersions: unsigned.get(p.id) ?? [],
+        latestVersion: latest.get(p.id)
+          ? {
+              version: latest.get(p.id)!.version,
+              signed: latest.get(p.id)!.signed,
+              sha256: latest.get(p.id)!.sha256,
+              size: latest.get(p.id)!.size,
+            }
+          : null,
+      })),
+    });
+  });
+
+  r.post('/products/:id/review', async (req, res) => {
+    const action = req.body?.action;
+    const [p] = await db.select().from(mpProducts).where(eq(mpProducts.id, req.params.id)).limit(1);
+    if (!p) throw new HttpError(404, 'Introuvable');
+    if (action === 'approve') return res.json(await approveProduct(p.id));
+    if (action === 'reject') {
+      const [updated] = await db
+        .update(mpProducts)
+        .set({
+          status: 'rejected',
+          rejectionReason: String(req.body?.reason || 'Non conforme').slice(0, 500),
+          updatedAt: new Date(),
+        })
+        .where(eq(mpProducts.id, p.id))
+        .returning();
+      return res.json({ product: updated });
+    }
+    if (action === 'unpublish') {
+      const [updated] = await db
+        .update(mpProducts)
+        .set({ status: 'draft', updatedAt: new Date() })
+        .where(eq(mpProducts.id, p.id))
+        .returning();
+      return res.json({ product: updated });
+    }
+    throw new HttpError(422, 'action = approve | reject | unpublish');
+  });
+
+  r.delete('/products/:id', async (req, res) => {
+    const [p] = await db.select().from(mpProducts).where(eq(mpProducts.id, req.params.id)).limit(1);
+    if (!p) throw new HttpError(404, 'Introuvable');
+    const [sold] = await db.select({ n: count() }).from(mpOrderItems).where(eq(mpOrderItems.productId, p.id));
+    if ((sold?.n || 0) > 0) throw new HttpError(409, 'Impossible de supprimer : des ventes existent. Dépubliez plutôt.');
+    const versions = await db.select().from(mpVersions).where(eq(mpVersions.productId, p.id));
+    for (const v of versions) {
+      const abs = path.resolve(PACKAGES_DIR, path.basename(v.packagePath));
+      if (abs.startsWith(PACKAGES_DIR + path.sep)) await fs.unlink(abs).catch(() => undefined);
+    }
+    await db.delete(mpVersions).where(eq(mpVersions.productId, p.id));
+    await db.delete(mpProducts).where(eq(mpProducts.id, p.id));
+    res.json({ ok: true, id: p.id, name: p.name });
+  });
+
+  r.post('/sync-official', async (_req, res) => {
+    res.json(await syncOfficialMarketplace());
+  });
+
+  r.get('/users', async (req, res) => {
+    const q = String(req.query.q || '').trim();
+    const role = String(req.query.role || 'all');
+    const base = db.select().from(platformUsers).orderBy(desc(platformUsers.createdAt)).limit(300);
+    let rows = await base;
+    if (role !== 'all') rows = rows.filter((u) => u.role === role);
+    if (q) {
+      const nq = q.toLowerCase();
+      rows = rows.filter((u) => u.email.toLowerCase().includes(nq) || u.displayName.toLowerCase().includes(nq));
+    }
+    const pubs = await db.select().from(mpPublishers);
+    const pubByUser = new Map(pubs.map((p) => [p.userId, p]));
+    res.json({
+      items: rows.map((u) => ({
+        id: u.id,
+        email: u.email,
+        displayName: u.displayName,
+        role: u.role,
+        createdAt: u.createdAt,
+        emailVerifiedAt: u.emailVerifiedAt,
+        publisher: pubByUser.get(u.id)
+          ? { id: pubByUser.get(u.id)!.id, status: pubByUser.get(u.id)!.status, displayName: pubByUser.get(u.id)!.displayName }
+          : null,
+      })),
+    });
+  });
+
+  r.patch('/users/:id', async (req, res) => {
+    const role = req.body?.role;
+    const allowed = ['member', 'publisher', 'mod', 'admin'] as const;
+    if (!allowed.includes(role)) throw new HttpError(422, 'role invalide');
+    const [updated] = await db
+      .update(platformUsers)
+      .set({ role, updatedAt: new Date() })
+      .where(eq(platformUsers.id, req.params.id))
+      .returning();
+    if (!updated) throw new HttpError(404, 'Utilisateur introuvable');
+    if (req.body?.revokeSessions) {
+      await db
+        .update(platformSessions)
+        .set({ revokedAt: new Date() })
+        .where(and(eq(platformSessions.userId, updated.id), sql`${platformSessions.revokedAt} is null`));
+    }
+    res.json({
+      user: {
+        id: updated.id,
+        email: updated.email,
+        displayName: updated.displayName,
+        role: updated.role,
+        createdAt: updated.createdAt,
+      },
+    });
+  });
+
+  r.get('/publishers', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const pubs =
+      status === 'all'
+        ? await db.select().from(mpPublishers).orderBy(desc(mpPublishers.createdAt)).limit(300)
+        : await db
+            .select()
+            .from(mpPublishers)
+            .where(eq(mpPublishers.status, status as 'active'))
+            .orderBy(desc(mpPublishers.createdAt))
+            .limit(300);
+    const users = await db.select().from(platformUsers);
+    const byId = new Map(users.map((u) => [u.id, u]));
+    const products = await db.select({ publisherId: mpProducts.publisherId, n: count() }).from(mpProducts).groupBy(mpProducts.publisherId);
+    const prodByPub = new Map(products.map((p) => [p.publisherId, p.n]));
+    res.json({
+      items: pubs.map((p) => ({
+        ...p,
+        email: byId.get(p.userId)?.email || null,
+        userRole: byId.get(p.userId)?.role || null,
+        productCount: prodByPub.get(p.id) || 0,
+      })),
+    });
+  });
+
+  r.patch('/publishers/:id', async (req, res) => {
+    const status = req.body?.status;
+    if (status !== 'active' && status !== 'suspended' && status !== 'pending_payment') {
+      throw new HttpError(422, 'status = active | suspended | pending_payment');
+    }
+    const [updated] = await db
+      .update(mpPublishers)
+      .set({
+        status,
+        ...(status === 'active' && req.body?.markPaid ? { paidAt: new Date() } : {}),
+        ...(typeof req.body?.displayName === 'string' ? { displayName: String(req.body.displayName).slice(0, 120) } : {}),
+      })
+      .where(eq(mpPublishers.id, req.params.id))
+      .returning();
+    if (!updated) throw new HttpError(404, 'Éditeur introuvable');
+    // Suspendre : dépublier ses produits en ligne
+    if (status === 'suspended') {
+      await db
+        .update(mpProducts)
+        .set({ status: 'draft', updatedAt: new Date() })
+        .where(and(eq(mpProducts.publisherId, updated.id), eq(mpProducts.status, 'published')));
+    }
+    res.json({ publisher: updated });
+  });
+
+  r.get('/orders', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const orders =
+      status === 'all'
+        ? await db.select().from(mpOrders).orderBy(desc(mpOrders.createdAt)).limit(150)
+        : await db
+            .select()
+            .from(mpOrders)
+            .where(eq(mpOrders.status, status as 'paid'))
+            .orderBy(desc(mpOrders.createdAt))
+            .limit(150);
+    const users = await db.select().from(platformUsers);
+    const byUser = new Map(users.map((u) => [u.id, u]));
+    const items = await db.select().from(mpOrderItems);
+    const products = await db.select().from(mpProducts);
+    const byProduct = new Map(products.map((p) => [p.id, p]));
+    const itemsByOrder = new Map<string, typeof items>();
+    for (const it of items) {
+      const list = itemsByOrder.get(it.orderId) || [];
+      list.push(it);
+      itemsByOrder.set(it.orderId, list);
+    }
+    res.json({
+      items: orders.map((o) => ({
+        ...o,
+        totalLabel: formatDt(o.totalMillimes),
+        commissionLabel: formatDt(o.commissionMillimes),
+        buyerEmail: byUser.get(o.buyerId)?.email || null,
+        buyerName: byUser.get(o.buyerId)?.displayName || null,
+        lines: (itemsByOrder.get(o.id) || []).map((it) => ({
+          productId: it.productId,
+          productName: byProduct.get(it.productId)?.name || it.productId,
+          unitPriceMillimes: it.unitPriceMillimes,
+          unitPriceLabel: formatDt(it.unitPriceMillimes),
+          licenseKey: it.licenseKey,
+        })),
+      })),
+    });
+  });
+
+  r.get('/payouts', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const rows =
+      status === 'all'
+        ? await db.select().from(mpPayouts).orderBy(desc(mpPayouts.createdAt)).limit(200)
+        : await db
+            .select()
+            .from(mpPayouts)
+            .where(eq(mpPayouts.status, status as 'requested'))
+            .orderBy(desc(mpPayouts.createdAt))
+            .limit(200);
+    const pubs = await db.select().from(mpPublishers);
+    const users = await db.select().from(platformUsers);
+    const byPub = new Map(pubs.map((p) => [p.id, p]));
+    const byUser = new Map(users.map((u) => [u.id, u]));
+    res.json({
+      items: rows.map((p) => {
+        const pub = byPub.get(p.publisherId);
+        return {
+          ...p,
+          amountLabel: formatDt(p.amountMillimes),
+          publisherName: pub?.displayName || p.publisherId,
+          publisherIban: pub?.payoutIban || null,
+          publisherEmail: pub ? byUser.get(pub.userId)?.email || null : null,
+        };
+      }),
+    });
+  });
+
+  r.post('/payouts/:id', async (req, res) => {
+    const status = req.body?.status === 'paid' ? 'paid' : req.body?.status === 'rejected' ? 'rejected' : null;
+    if (!status) throw new HttpError(422, 'status invalide');
+    const [row] = await db
+      .update(mpPayouts)
+      .set({ status, paidAt: status === 'paid' ? new Date() : null, note: req.body?.note ? String(req.body.note).slice(0, 500) : undefined })
+      .where(eq(mpPayouts.id, req.params.id))
+      .returning();
+    if (!row) throw new HttpError(404, 'Payout introuvable');
+    res.json({ payout: row });
+  });
+
+  r.get('/system', async (_req, res) => {
+    const settings = await getMpSettings();
+    let dbOk = false;
+    try {
+      await db.select({ n: count() }).from(platformUsers).limit(1);
+      dbOk = true;
+    } catch {
+      dbOk = false;
+    }
+    res.json({
+      nodeEnv: process.env.NODE_ENV || 'development',
+      version: process.env.npm_package_version || '1.0.0',
+      database: dbOk ? 'ok' : 'error',
+      flouci: {
+        mockAllowed: flouciMockAllowed(),
+        hasPublicKey: Boolean(settings.flouciPublicKey || process.env.FLOUCI_PUBLIC_KEY),
+        hasPrivateKey: Boolean(settings.flouciPrivateKeyEnc || process.env.FLOUCI_PRIVATE_KEY),
+        hasWebhookSecret: Boolean(process.env.FLOUCI_WEBHOOK_SECRET),
+      },
+      signing: {
+        keyConfigured: Boolean(process.env.SNAPIFY_SIGNING_KEY),
+        kid: process.env.SNAPIFY_SIGNING_KID || 'novalabs-2026',
+      },
+      superadmin: {
+        username: superadminCreds().username,
+        passwordConfigured: Boolean(process.env.SUPERADMIN_PASSWORD),
+      },
+      hosts: {
+        community: process.env.COMMUNITY_HOST || '',
+        marketplace: process.env.MARKETPLACE_HOST || '',
+        developers: process.env.DEVELOPERS_HOST || '',
+      },
+    });
+  });
+
+  r.get('/seo', async (_req, res) => {
+    res.json(await getLandingSeo());
+  });
+
+  r.put('/seo', async (req, res) => {
+    res.json(await setLandingSeo(req.body || {}));
+  });
+
+  r.get('/seo/backlinks', async (_req, res) => {
+    const state = await getSeoBacklinks();
+    res.json({
+      catalog: BACKLINK_CATALOG,
+      stats: catalogStats(),
+      tracks: state.tracks,
+    });
+  });
+
+  r.put('/seo/backlinks', async (req, res) => {
+    const body = req.body || {};
+    res.json(await setSeoBacklinks({ tracks: body.tracks }));
+  });
+
+  r.post('/seo/backlinks/seed', async (_req, res) => {
+    res.json(await seedSeoBacklinks());
+  });
+
+  r.get('/seo/daily', async (_req, res) => {
+    const { getDailyImproveReport } = await import('../platform/dailyImprove');
+    res.json({ report: await getDailyImproveReport() });
+  });
+
+  r.post('/seo/daily/run', async (_req, res) => {
+    const { runDailyImprove } = await import('../platform/dailyImprove');
+    const report = await runDailyImprove({ triggeredBy: 'superadmin' });
+    res.json({ report });
+  });
+
+  r.post('/seo/indexnow', async (req, res) => {
+    const seo = await getLandingSeo();
+    const key = (seo.indexNowKey || '').trim();
+    if (!key) throw new HttpError(400, 'Définissez une clé IndexNow dans SEO → Technique.');
+    const urls = Array.isArray(req.body?.urls) ? req.body.urls.map(String).slice(0, 40) : [];
+    if (!urls.length) throw new HttpError(400, 'urls[] requis');
+    const host = String(urls[0]).includes('snapify.fr') ? 'snapify.fr' : 'snapify.tn';
+    const payload = {
+      host,
+      key,
+      keyLocation: `https://${host}/${key}.txt`,
+      urlList: urls,
+    };
+    const r2 = await fetch('https://api.indexnow.org/indexnow', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(20_000),
+    });
+    res.json({ ok: r2.ok, status: r2.status, payload });
+  });
+
+  r.get('/revenue', async (_req, res) => {
+    const since = new Date(Date.now() - 30 * 24 * 3600 * 1000);
+    const paid = await db
+      .select()
+      .from(mpOrders)
+      .where(and(eq(mpOrders.status, 'paid'), gte(mpOrders.paidAt, since)));
+    const items = await db.select().from(mpOrderItems);
+    const byOrder = new Map<string, number>();
+    for (const i of items) byOrder.set(i.orderId, (byOrder.get(i.orderId) || 0) + 1);
+    const gross = paid.reduce((a, o) => a + o.totalMillimes, 0);
+    const commission = paid.reduce((a, o) => a + o.commissionMillimes, 0);
+    res.json({
+      periodDays: 30,
+      orders: paid.length,
+      grossMillimes: gross,
+      commissionMillimes: commission,
+      grossLabel: formatDt(gross),
+      commissionLabel: formatDt(commission),
+    });
+  });
+
+  /* ---- Ops SaaS : commandes, factures, newsletter, tickets, paiements, SMTP ---- */
+
+  r.post('/orders/:id/refund', async (req, res) => {
+    res.json(await refundMarketplaceOrder(req.params.id, req.body?.note ? String(req.body.note) : undefined));
+  });
+
+  r.post('/orders/:id/invoice', async (req, res) => {
+    res.json({ invoice: await createInvoiceFromOrder(req.params.id) });
+  });
+
+  r.get('/invoices', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const rows =
+      status === 'all'
+        ? await db.select().from(saInvoices).orderBy(desc(saInvoices.createdAt)).limit(200)
+        : await db
+            .select()
+            .from(saInvoices)
+            .where(eq(saInvoices.status, status as 'draft'))
+            .orderBy(desc(saInvoices.createdAt))
+            .limit(200);
+    res.json({
+      items: rows.map((i) => ({
+        ...i,
+        amountLabel: formatDt(i.amountMillimes),
+        taxLabel: formatDt(i.taxMillimes),
+      })),
+    });
+  });
+
+  r.patch('/invoices/:id', async (req, res) => {
+    const status = req.body?.status;
+    const allowed = ['draft', 'sent', 'paid', 'void'] as const;
+    if (status && !allowed.includes(status)) throw new HttpError(422, 'status invalide');
+    const patch: Partial<typeof saInvoices.$inferInsert> = {};
+    if (status) {
+      patch.status = status;
+      if (status === 'paid') patch.paidAt = new Date();
+    }
+    if (typeof req.body?.notes === 'string') patch.notes = String(req.body.notes).slice(0, 2000);
+    if (typeof req.body?.customerEmail === 'string') patch.customerEmail = String(req.body.customerEmail).slice(0, 160);
+    if (typeof req.body?.customerName === 'string') patch.customerName = String(req.body.customerName).slice(0, 120);
+    const [updated] = await db.update(saInvoices).set(patch).where(eq(saInvoices.id, req.params.id)).returning();
+    if (!updated) throw new HttpError(404, 'Facture introuvable');
+    res.json({ invoice: updated });
+  });
+
+  r.post('/invoices/:id/send', async (req, res) => {
+    res.json(await sendInvoice(req.params.id));
+  });
+
+  r.delete('/invoices/:id', async (req, res) => {
+    const [row] = await db.delete(saInvoices).where(eq(saInvoices.id, req.params.id)).returning();
+    if (!row) throw new HttpError(404, 'Facture introuvable');
+    res.json({ ok: true, id: row.id });
+  });
+
+  r.get('/payments', async (_req, res) => {
+    const rows = await db.select().from(saPaymentEvents).orderBy(desc(saPaymentEvents.createdAt)).limit(300);
+    res.json({
+      items: rows.map((p) => ({
+        ...p,
+        amountLabel: formatDt(p.amountMillimes),
+      })),
+    });
+  });
+
+  r.post('/payments', async (req, res) => {
+    const kind = req.body?.kind;
+    if (!['charge', 'refund', 'fee', 'payout'].includes(kind)) throw new HttpError(422, 'kind invalide');
+    const amountMillimes = Math.max(0, Math.round(Number(req.body?.amountMillimes) || 0));
+    const status = String(req.body?.status || 'recorded').slice(0, 60);
+    const row = await recordPaymentEvent({
+      provider: req.body?.provider ? String(req.body.provider).slice(0, 40) : 'flouci',
+      kind,
+      amountMillimes,
+      status,
+      trackingId: req.body?.trackingId ? String(req.body.trackingId).slice(0, 120) : undefined,
+      paymentId: req.body?.paymentId ? String(req.body.paymentId).slice(0, 120) : undefined,
+      refType: req.body?.refType ? String(req.body.refType).slice(0, 40) : undefined,
+      refId: req.body?.refId ? String(req.body.refId).slice(0, 80) : undefined,
+      meta: typeof req.body?.meta === 'object' && req.body.meta ? req.body.meta : { note: req.body?.note || '' },
+    });
+    res.json({ event: row });
+  });
+
+  r.get('/newsletter/subscribers', async (_req, res) => {
+    const rows = await db.select().from(saNewsletterSubscribers).orderBy(desc(saNewsletterSubscribers.createdAt)).limit(500);
+    res.json({ items: rows });
+  });
+
+  r.post('/newsletter/subscribers', async (req, res) => {
+    const email = String(req.body?.email || '')
+      .trim()
+      .toLowerCase()
+      .slice(0, 160);
+    if (!email || !email.includes('@')) throw new HttpError(422, 'E-mail invalide');
+    const [row] = await db
+      .insert(saNewsletterSubscribers)
+      .values({
+        id: crypto.randomUUID(),
+        email,
+        name: String(req.body?.name || '').slice(0, 120),
+        source: String(req.body?.source || 'manual').slice(0, 40),
+        status: 'active',
+      })
+      .onConflictDoUpdate({
+        target: saNewsletterSubscribers.email,
+        set: { status: 'active', name: String(req.body?.name || '').slice(0, 120) },
+      })
+      .returning();
+    res.json({ subscriber: row });
+  });
+
+  r.patch('/newsletter/subscribers/:id', async (req, res) => {
+    const status = req.body?.status === 'unsubscribed' ? 'unsubscribed' : req.body?.status === 'active' ? 'active' : null;
+    if (!status) throw new HttpError(422, 'status = active | unsubscribed');
+    const [row] = await db
+      .update(saNewsletterSubscribers)
+      .set({ status })
+      .where(eq(saNewsletterSubscribers.id, req.params.id))
+      .returning();
+    if (!row) throw new HttpError(404, 'Abonné introuvable');
+    res.json({ subscriber: row });
+  });
+
+  r.delete('/newsletter/subscribers/:id', async (req, res) => {
+    const [row] = await db.delete(saNewsletterSubscribers).where(eq(saNewsletterSubscribers.id, req.params.id)).returning();
+    if (!row) throw new HttpError(404, 'Abonné introuvable');
+    res.json({ ok: true });
+  });
+
+  r.get('/newsletter/campaigns', async (_req, res) => {
+    const rows = await db.select().from(saNewsletterCampaigns).orderBy(desc(saNewsletterCampaigns.createdAt)).limit(100);
+    res.json({ items: rows });
+  });
+
+  r.post('/newsletter/send', async (req, res) => {
+    const subject = String(req.body?.subject || '').trim().slice(0, 200);
+    const html = String(req.body?.html || '').trim();
+    if (!subject || !html) throw new HttpError(422, 'subject et html requis');
+    res.json(await sendNewsletterCampaign(subject, html));
+  });
+
+  r.get('/tickets', async (req, res) => {
+    const status = String(req.query.status || 'all');
+    const kind = String(req.query.kind || 'all');
+    let rows = await db.select().from(saTickets).orderBy(desc(saTickets.updatedAt)).limit(300);
+    if (status !== 'all') rows = rows.filter((t) => t.status === status);
+    if (kind !== 'all') rows = rows.filter((t) => t.kind === kind);
+    res.json({ items: rows });
+  });
+
+  r.post('/tickets', async (req, res) => {
+    const subject = String(req.body?.subject || '').trim().slice(0, 200);
+    if (!subject) throw new HttpError(422, 'Sujet requis');
+    const kind = ['support', 'payment', 'dev', 'license', 'payout', 'bug'].includes(req.body?.kind) ? req.body.kind : 'support';
+    const priority = ['low', 'normal', 'high', 'urgent'].includes(req.body?.priority) ? req.body.priority : 'normal';
+    const [row] = await db
+      .insert(saTickets)
+      .values({
+        id: crypto.randomUUID(),
+        kind,
+        priority,
+        subject,
+        body: String(req.body?.body || '').slice(0, 8000),
+        email: req.body?.email ? String(req.body.email).slice(0, 160) : null,
+        name: req.body?.name ? String(req.body.name).slice(0, 120) : null,
+        userId: req.body?.userId ? String(req.body.userId).slice(0, 80) : null,
+        refType: req.body?.refType ? String(req.body.refType).slice(0, 40) : null,
+        refId: req.body?.refId ? String(req.body.refId).slice(0, 80) : null,
+      })
+      .returning();
+    res.json({ ticket: row });
+  });
+
+  r.patch('/tickets/:id', async (req, res) => {
+    const patch: Partial<typeof saTickets.$inferInsert> = { updatedAt: new Date() };
+    if (['open', 'in_progress', 'waiting', 'resolved', 'closed'].includes(req.body?.status)) {
+      patch.status = req.body.status;
+      if (req.body.status === 'resolved' || req.body.status === 'closed') patch.resolvedAt = new Date();
+    }
+    if (['support', 'payment', 'dev', 'license', 'payout', 'bug'].includes(req.body?.kind)) patch.kind = req.body.kind;
+    if (['low', 'normal', 'high', 'urgent'].includes(req.body?.priority)) patch.priority = req.body.priority;
+    if (typeof req.body?.subject === 'string') patch.subject = String(req.body.subject).slice(0, 200);
+    if (typeof req.body?.body === 'string') patch.body = String(req.body.body).slice(0, 8000);
+    const [row] = await db.update(saTickets).set(patch).where(eq(saTickets.id, req.params.id)).returning();
+    if (!row) throw new HttpError(404, 'Ticket introuvable');
+    res.json({ ticket: row });
+  });
+
+  r.delete('/tickets/:id', async (req, res) => {
+    const [row] = await db.delete(saTickets).where(eq(saTickets.id, req.params.id)).returning();
+    if (!row) throw new HttpError(404, 'Ticket introuvable');
+    res.json({ ok: true });
+  });
+
+  r.get('/mail-settings', async (_req, res) => {
+    const s = await loadSnapshot();
+    const { passwordEnc, ...smtp } = s.system.smtp;
+    res.json({
+      smtp: { ...smtp, hasPassword: Boolean(passwordEnc || process.env.SMTP_PASS || process.env.SMTP_PASSWORD) },
+      source: smtpSource(s),
+      envFallback: Boolean(process.env.SMTP_HOST || process.env.SMTP_URL),
+    });
+  });
+
+  r.put('/mail-settings', async (req, res) => {
+    const smtpIn = (req.body?.smtp || {}) as Record<string, unknown>;
+    const next = await updateSnapshot((s) => {
+      const cur = s.system.smtp;
+      s.system.smtp = {
+        enabled: smtpIn.enabled !== undefined ? Boolean(smtpIn.enabled) : cur.enabled,
+        host: smtpIn.host !== undefined ? String(smtpIn.host).slice(0, 200) : cur.host,
+        port: smtpIn.port !== undefined ? Math.max(1, Math.min(65535, Number(smtpIn.port) || 587)) : cur.port,
+        security: ['starttls', 'ssl', 'none'].includes(String(smtpIn.security)) ? (smtpIn.security as 'starttls') : cur.security,
+        username: smtpIn.username !== undefined ? String(smtpIn.username).slice(0, 200) : cur.username,
+        passwordEnc: smtpIn.clearPassword
+          ? undefined
+          : smtpIn.password
+            ? encryptSecret(String(smtpIn.password))
+            : cur.passwordEnc,
+        fromName: smtpIn.fromName !== undefined ? String(smtpIn.fromName).slice(0, 120) : cur.fromName,
+        fromEmail: smtpIn.fromEmail !== undefined ? String(smtpIn.fromEmail).slice(0, 200).toLowerCase() : cur.fromEmail,
+        replyTo: smtpIn.replyTo !== undefined ? String(smtpIn.replyTo).slice(0, 200).toLowerCase() : cur.replyTo,
+        timeoutSec: smtpIn.timeoutSec !== undefined ? Math.max(3, Math.min(120, Number(smtpIn.timeoutSec) || 15)) : cur.timeoutSec,
+        allowSelfSigned: smtpIn.allowSelfSigned !== undefined ? Boolean(smtpIn.allowSelfSigned) : cur.allowSelfSigned,
+      };
+    });
+    const { passwordEnc, ...smtp } = next.system.smtp;
+    res.json({ smtp: { ...smtp, hasPassword: Boolean(passwordEnc) }, source: smtpSource(next) });
+  });
+
+  r.post('/mail-settings/test', async (req, res) => {
+    const to = String(req.body?.to || '').trim().toLowerCase();
+    if (!to || !to.includes('@')) throw new HttpError(422, 'Destinataire invalide');
+    const s = await loadSnapshot();
+    const result = await testSmtp(s.system.smtp, to, req.body?.password ? String(req.body.password) : undefined);
+    res.json(result);
+  });
+
+  r.delete('/users/:id', async (req, res) => {
+    const [u] = await db.select().from(platformUsers).where(eq(platformUsers.id, req.params.id)).limit(1);
+    if (!u) throw new HttpError(404, 'Utilisateur introuvable');
+    const [pub] = await db.select().from(mpPublishers).where(eq(mpPublishers.userId, u.id)).limit(1);
+    if (pub) throw new HttpError(409, 'Compte éditeur lié — suspendez l’éditeur d’abord.');
+    await db.update(platformSessions).set({ revokedAt: new Date() }).where(eq(platformSessions.userId, u.id));
+    await db.delete(platformUsers).where(eq(platformUsers.id, u.id));
+    res.json({ ok: true, id: u.id });
+  });
+
+  return r;
+}
+
+/** Sitemap marketing dual (.tn + .fr) avec hreflang + URLs custom superadmin. */
+export async function landingSitemapXml(market: LandingMarket = 'tn'): Promise<string> {
+  const seo = await getLandingSeo();
+  const today = new Date().toISOString().slice(0, 10);
+  const paths: { path: string; priority: string }[] = [
+    { path: '/', priority: '1.0' },
+    { path: '/commander', priority: '0.9' },
+    { path: '/demo/', priority: '0.8' },
+    { path: '/seo-tunisie', priority: '0.9' },
+    { path: '/seo-france', priority: '0.85' },
+    { path: '/alternative-wordpress', priority: '0.8' },
+    { path: '/presse', priority: '0.65' },
+    { path: '/creation-site-web-france', priority: '1.0' },
+    { path: '/creation-site-web-tunisie', priority: '1.0' },
+  ];
+  if (market === 'tn') {
+    paths.push(
+      { path: '/creation-site-web-tunis', priority: '0.95' },
+      { path: '/creation-site-web-sfax', priority: '0.9' },
+      { path: '/creation-site-web-sousse', priority: '0.9' },
+      { path: '/boutique-en-ligne-tunisie', priority: '0.95' },
+      { path: '/site-vitrine-tunisie', priority: '0.9' },
+      { path: '/agence-web-tunisie', priority: '0.95' }
+    );
+  }
+  if (market === 'fr') {
+    paths.push(
+      { path: '/alternative-wix', priority: '0.98' },
+      { path: '/alternative-shopify', priority: '0.95' },
+      { path: '/alternative-squarespace', priority: '0.9' },
+      { path: '/boutique-en-ligne-france', priority: '0.95' },
+      { path: '/site-vitrine-france', priority: '0.9' },
+      { path: '/creation-site-web-paris', priority: '0.95' },
+      { path: '/creation-site-web-lyon', priority: '0.9' },
+      { path: '/creation-site-web-marseille', priority: '0.9' },
+      { path: '/createur-site-web', priority: '0.95' }
+    );
+  }
+  for (const extra of seo.sitemapExtraUrls || []) {
+    if (!extra.loc) continue;
+    if (extra.market && extra.market !== 'both' && extra.market !== market) continue;
+    const path = extra.loc.startsWith('http') ? extra.loc : extra.loc.startsWith('/') ? extra.loc : `/${extra.loc}`;
+    if (path.startsWith('http')) continue; // handled below
+    if (!paths.some((p) => p.path === path)) paths.push({ path, priority: extra.priority || '0.5' });
+  }
+
+  const entry = (m: LandingMarket, path: string, priority: string) => {
+    const base = baseForMarket(m);
+    const loc = `${base}${path === '/' ? '/' : path}`;
+    const tn = `https://snapify.tn${path === '/' ? '/' : path}`;
+    const fr = `https://snapify.fr${path === '/' ? '/' : path}`;
+    const hreflang =
+      seo.enableHreflang === false
+        ? ''
+        : `
+    <xhtml:link rel="alternate" hreflang="fr-TN" href="${tn}" />
+    <xhtml:link rel="alternate" hreflang="fr-FR" href="${fr}" />
+    <xhtml:link rel="alternate" hreflang="x-default" href="${fr}" />`;
+    return `  <url>
+    <loc>${loc}</loc>
+    <lastmod>${today}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>${priority}</priority>${hreflang}
+  </url>`;
+  };
+
+  const body = paths.map((p) => entry(market, p.path, p.priority)).join('\n');
+  const absoluteExtras = (seo.sitemapExtraUrls || [])
+    .filter((u) => u.loc?.startsWith('http') && (u.market === 'both' || !u.market || u.market === market))
+    .map(
+      (u) =>
+        `  <url><loc>${u.loc}</loc><lastmod>${today}</lastmod><changefreq>weekly</changefreq><priority>${u.priority || '0.5'}</priority></url>`
+    )
+    .join('\n');
+  const ecosys =
+    market === 'fr'
+      ? `  <url><loc>https://marketplace.snapify.fr/</loc><lastmod>${today}</lastmod><changefreq>weekly</changefreq><priority>0.75</priority></url>
+  <url><loc>https://community.snapify.fr/</loc><lastmod>${today}</lastmod><changefreq>weekly</changefreq><priority>0.7</priority></url>`
+      : `  <url><loc>https://marketplace.snapify.tn/</loc><lastmod>${today}</lastmod><changefreq>weekly</changefreq><priority>0.75</priority></url>
+  <url><loc>https://community.snapify.tn/</loc><lastmod>${today}</lastmod><changefreq>weekly</changefreq><priority>0.7</priority></url>`;
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml">
+${body}
+${absoluteExtras}
+${ecosys}
+</urlset>`;
+}
+
+/** Index de sitemaps — point d’entrée unique pour GSC / robots.txt. */
+export async function landingSitemapIndexXml(market: LandingMarket = 'tn'): Promise<string> {
+  const today = new Date().toISOString().slice(0, 10);
+  const base = baseForMarket(market);
+  const marketBase = market === 'fr' ? 'https://marketplace.snapify.fr' : 'https://marketplace.snapify.tn';
+  const communityBase = market === 'fr' ? 'https://community.snapify.fr' : 'https://community.snapify.tn';
+  const entries = [
+    `${base}/sitemap.xml`,
+    `${marketBase}/sitemap.xml`,
+    `${communityBase}/sitemap.xml`,
+  ];
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${entries
+  .map(
+    (loc) => `  <sitemap>
+    <loc>${loc}</loc>
+    <lastmod>${today}</lastmod>
+  </sitemap>`
+  )
+  .join('\n')}
+</sitemapindex>`;
+}
+
+export async function landingRobotsTxt(market: LandingMarket = 'tn'): Promise<string> {
+  const seo = await getLandingSeo();
+  if (seo.robotsTxtOverride?.trim()) return seo.robotsTxtOverride.trim() + '\n';
+  const base = baseForMarket(market);
+  const disallowExtra = (seo.noindexPaths || [])
+    .map((p) => `Disallow: ${p.startsWith('/') ? p : `/${p}`}`)
+    .join('\n');
+  return [
+    'User-agent: *',
+    'Allow: /',
+    'Allow: /seo-tunisie',
+    'Allow: /seo-france',
+    'Allow: /alternative-wordpress',
+    'Allow: /alternative-wix',
+    'Allow: /alternative-shopify',
+    'Allow: /createur-site-web',
+    'Allow: /presse',
+    'Allow: /llms.txt',
+    'Disallow: /administrator',
+    'Disallow: /hamdisup90',
+    'Disallow: /api/',
+    'Disallow: /demo/administrator',
+    disallowExtra,
+    '',
+    seo.robotsTxtExtra?.trim() || '',
+    '',
+    `Sitemap: ${base}/sitemap_index.xml`,
+    '',
+  ]
+    .filter((line, i, arr) => !(line === '' && arr[i - 1] === ''))
+    .join('\n');
+}