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/db/init_db.py

@@ -1,8 +1,8 @@
-"""Initialisation du schema SQLite.
+"""Mise a niveau du schema SQLite au demarrage.
 
-La V1 n'utilise pas Alembic : le schema tient dans une seule table et
-`create_all` suffit. Toute evolution future du schema devra soit passer par
-Alembic, soit par une migration explicite ajoutee ici (voir README).
+Depuis la Phase 2.1, le schema est gere par Alembic : `init_db` se contente de
+declencher les migrations. Il n'existe volontairement aucun mecanisme de
+migration maison en parallele.
 """
 
 from __future__ import annotations
@@ -11,16 +11,12 @@ import logging
 
 from sqlalchemy import Engine
 
-from app.db.base import Base
+from app.db.migrations import run_migrations
 from app.db.session import engine as default_engine
 from app.models import share as _share_model  # noqa: F401  (enregistre la table)
 
 logger = logging.getLogger(__name__)
 
-SCHEMA_VERSION = 1
-
 
 def init_db(engine: Engine | None = None) -> None:
-    target = engine or default_engine
-    Base.metadata.create_all(bind=target)
-    logger.info("Schema SQLite initialise (version %s)", SCHEMA_VERSION)
+    run_migrations(engine or default_engine)

backend/app/db/migrations.py

@@ -0,0 +1,67 @@
+"""Application des migrations Alembic au demarrage.
+
+Deux situations coexistent et doivent toutes deux fonctionner sans
+intervention :
+
+* **installation neuve** : la base est vide, toutes les revisions s'appliquent ;
+* **base existante** creee avant Alembic par `create_all` : la table est deja
+  la, mais `alembic_version` n'existe pas. On estampille alors la revision
+  initiale (aucune modification de donnees) avant de derouler la suite.
+
+Aucune operation destructive n'est effectuee : la seule migration de cette
+phase ajoute une colonne nullable.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from alembic import command
+from alembic.config import Config
+from sqlalchemy import inspect
+
+from app.config import get_settings
+from app.db.session import engine as default_engine
+
+logger = logging.getLogger(__name__)
+
+BACKEND_ROOT = Path(__file__).resolve().parents[2]
+ALEMBIC_INI = BACKEND_ROOT / "alembic.ini"
+INITIAL_REVISION = "0001_initial_schema"
+MAIN_TABLE = "shared_maps"
+
+
+def build_config(database_url: str | None = None, *, configure_logger: bool = False) -> Config:
+    config = Config(str(ALEMBIC_INI))
+    config.set_main_option("script_location", str(BACKEND_ROOT / "migrations"))
+    config.set_main_option("sqlalchemy.url", database_url or get_settings().database_url)
+    # Les migrations tournent dans le processus applicatif : elles ne doivent pas
+    # reconfigurer les logs deja en place.
+    config.attributes["configure_logger"] = configure_logger
+    return config
+
+
+def run_migrations(engine=None, database_url: str | None = None) -> None:  # type: ignore[no-untyped-def]
+    target = engine or default_engine
+    config = build_config(database_url)
+
+    with target.connect() as connection:
+        tables = set(inspect(connection).get_table_names())
+
+    legacy = MAIN_TABLE in tables and "alembic_version" not in tables
+    if legacy:
+        # Base d'avant Alembic : on declare l'etat initial deja atteint plutot
+        # que de rejouer une creation de table qui echouerait.
+        logger.info("Base existante detectee : estampillage de %s", INITIAL_REVISION)
+        command.stamp(config, INITIAL_REVISION)
+
+    command.upgrade(config, "head")
+    logger.info("Migrations appliquees (head)")
+
+
+if __name__ == "__main__":  # pragma: no cover - appele par l'entrypoint Docker
+    import sys
+
+    logging.basicConfig(level="INFO", format="%(levelname)-8s | %(message)s", stream=sys.stdout)
+    run_migrations()

backend/app/db/session.py

@@ -44,6 +44,10 @@ def create_db_engine(database_url: str | None = None) -> Engine:
             # WAL : meilleure resistance aux arrets brutaux du conteneur.
             cursor.execute("PRAGMA journal_mode=WAL")
             cursor.execute("PRAGMA foreign_keys=ON")
+            # Attend au lieu d'echouer immediatement si une ecriture concurrente
+            # tient le verrou : une sauvegarde en cours ne doit pas produire
+            # d'erreur "database is locked" cote utilisateur.
+            cursor.execute("PRAGMA busy_timeout=5000")
             cursor.close()
 
     return engine