Phase 2.1 : preparation au deploiement public

Rend une instance exposee sur Internet exploitable sans la transformer en
infrastructure : le produit reste local-first, sans compte et sans telemetrie.

Protection du service : limitation de debit en memoire par client et par
famille d'endpoint (health et ready jamais limites), interrupteur
SHARING_ENABLED, capacite maximale de partages, taille propre aux partages.
X-Forwarded-For n'est cru que si TRUST_PROXY_HEADERS l'autorise, et on lit alors
la derniere valeur, celle ajoutee par le proxy.

Expiration facultative des partages (24 h a 90 jours, ou jamais) : un lien
expire repond 410 et la page publique le dit, sans autre detail. Le proprietaire
peut prolonger ; aucune purge automatique.

Protection des liens non repertories : robots.txt, X-Robots-Tag et meta robots
sur /s/ et /api/, Referrer-Policy no-referrer sur tout le site, redaction des
jetons dans les journaux d'acces, share_token porte a 128 bits (les anciens
restent valides).

Schema gere par Alembic, applique au demarrage. Une base creee avant Alembic est
estampillee puis migree : verifie sur la base reelle de developpement, 4
partages inchanges et expires_at NULL.

Administration par CLI locale au conteneur (stats, liste, suppression, purge,
sauvegarde a chaud via l'API SQLite, restauration prudente) : aucune interface
/admin exposee.

Le jeton de gestion peut enfin etre exporte dans un fichier .openmind-share puis
reimporte depuis un autre navigateur, apres verification aupres du serveur. Il
n'est toujours jamais ajoute a un export .mmap.

Ajoute une page /privacy dont le texte est centralise, et corrige un bug trouve
en observant les logs : Alembic, lance dans le processus applicatif,
reappliquait la configuration de logs d'alembic.ini et desactivait les loggers
existants, ce qui faisait disparaitre les journaux d'acces.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/api/deps.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 
 from typing import Annotated
 
-from fastapi import Depends, Header
+from fastapi import Depends, Header, Request
 from sqlalchemy.orm import Session
 
 from app.config import Settings, get_settings
 from app.db.session import get_db
-from app.services.errors import ShareForbiddenError
+from app.services.client_ip import resolve_client_ip
+from app.services.errors import RateLimitedError, ShareForbiddenError, SharingDisabledError
+from app.services.rate_limit import limiter, parse_rate
 
 MANAGEMENT_TOKEN_HEADER = "X-Management-Token"
 
@@ -27,3 +29,41 @@ def require_management_token(
 
 
 ManagementToken = Annotated[str, Depends(require_management_token)]
+
+
+def require_sharing_enabled(settings: AppSettings) -> None:
+    """Coupe toute l'API de partage quand l'instance est privee.
+
+    Les cartes locales continuent de fonctionner : seul le service serveur est
+    indisponible, et il le dit clairement.
+    """
+    if not settings.sharing_enabled:
+        raise SharingDisabledError()
+
+
+SharingEnabled = Annotated[None, Depends(require_sharing_enabled)]
+
+
+def _rate_limit(bucket: str, spec_name: str):  # type: ignore[no-untyped-def]
+    """Fabrique une dependance de limitation pour une famille d'endpoints.
+
+    La limitation est posee sur les routes concernees, jamais en middleware
+    global : /api/health et /api/ready ne peuvent donc pas etre bloques, ce qui
+    garantit que le healthcheck du conteneur reste fiable sous charge.
+    """
+
+    def dependency(request: Request, settings: AppSettings) -> None:
+        rule = parse_rate(getattr(settings, spec_name))
+        if rule is None:
+            return
+        client = resolve_client_ip(request, trust_proxy_headers=settings.trust_proxy_headers)
+        retry_after = limiter.check(f"{bucket}:{client}", rule)
+        if retry_after is not None:
+            raise RateLimitedError(retry_after)
+
+    return dependency
+
+
+RateLimitCreate = Annotated[None, Depends(_rate_limit("share:create", "share_create_rate_limit"))]
+RateLimitRead = Annotated[None, Depends(_rate_limit("share:read", "share_read_rate_limit"))]
+RateLimitWrite = Annotated[None, Depends(_rate_limit("share:write", "share_write_rate_limit"))]