discovery-media-player 0.1.87 → 0.1.89

package/docs/RETENTION.md

@@ -92,6 +92,7 @@ Une présentation **inactive** (terminée ou abandonnée) est une archive : **pu
 | `doc_presentation_messages.client_key` | clé d'idempotence d'envoi | idem |
 | `doc_presentation_attendees.name` / `doc_presentation_attendees.email` / `doc_presentation_attendees.avatar` | identité du participant | purgées avec la présentation |
 | `doc_presentation_attendees.attendee_key` | identifiant de présence | idem |
+| `doc_presentation_attendees.creator_ip_hash` | **empreinte tronquée** de l'IP qui a créé la ligne (jamais l'IP en clair) — sert au plafond de création anonyme (migration 0015) | purgée avec la présentation |
 | `doc_presentation_attendees.pages` | pages vues par le participant | idem |
 
 ## Sessions d'agent (`doc_bot_sessions`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.87",
+  "version": "0.1.89",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/presentations.js

@@ -731,13 +731,21 @@ async function toggleReaction(slug, msgId, emoji, reactor, etat) {
 // Heartbeat d'un participant : upsert de sa ligne d'assistance. On accumule le temps de présence (intervalles
 // < 60 s → un aller-retour ne gonfle pas total_ms) et l'ensemble des pages vues (page courante de la présentation).
 const ATTEND_MAX_GAP_MS = 60 * 1000;
+// Plafond de création de participants ANONYMES par (présentation, IP). Défaut = ATTENDEES_PER_EGRESS
+// (250, la cible de mutualisation par sortie internet) × 1,3 = 325 ; l'hôte peut le passer autrement.
+// Ne borne QUE les nouvelles clés anon — jamais l'actualisation d'une clé déjà enregistrée, ni les
+// membres/le présentateur (identité prouvée). Appliqué atomiquement par le RPC `player_attendance_bump`.
+const PLAFOND_CREATION_ANON_DEFAUT = 325;
+// L'avertissement « RPC de présence absente » ne se dit qu'UNE fois par processus : répété à chaque
+// battement, il noierait le journal (un battement toutes les 25 s par participant).
+let _avertRpcPresence = false;
 // ⚠️ SIGNATURE : `(slug, participant, { presentation })`. Le participant reste en 2e position — c'est
 // le contrat d'export PUBLIC (`./presentations`), un hôte tiers appelle `recordAttendance(slug,
 // participant)` à DEUX arguments. L'optimisation « présentation déjà chargée » vit dans un SAC
 // D'OPTIONS, pas dans un slot positionnel : la ranger en 2e position (ce que faisait 0.1.84) déplaçait
 // le vrai paramètre et faisait jeter `Cannot destructure property 'key'` sur un appel à deux arguments
 // (P1a audit CODEX 5.6). `participant || {}` : un appel sans participant tombe en 400, jamais en throw.
-async function recordAttendance(slug, participant, { presentation = null } = {}) {
+async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null } = {}) {
   const { key, name, email, avatar, isMember, isPresenter } = participant || {};
   if (!slug || !key) return { ok: false, status: 400 };
   // La route vient DÉJÀ de charger la présentation (contrôle présentateur) : elle la fournit dans les
@@ -750,6 +758,43 @@ async function recordAttendance(slug, participant, { presentation = null } = {})
   // resté ouvert, longtemps après la fin.
   if (pres.active === false && pres.control_hash == null) return REFUS_ARCHIVE;
   const page = Math.max(1, Math.trunc(Number(pres.current_page) || 1));
+
+  // ⚠️ CHEMIN ATOMIQUE (migration 0015) : upsert ET plafond de création anonyme en UN geste, à l'abri
+  // des créations concurrentes. Absent (404, migration non appliquée) → on retombe sur la boucle
+  // lire-modifier-réécrire ci-dessous — toujours correcte, mais SANS le plafond — et on le dit une
+  // fois. Même patron que player_rate_limit_bump : dégrader, jamais casser, jamais en silence.
+  const capAnon = Number(anonCap) > 0 ? Math.trunc(Number(anonCap)) : PLAFOND_CREATION_ANON_DEFAUT;
+  try {
+    const r = await PLAYER.db.request("rpc/player_attendance_bump", {
+      method: "POST",
+      body: {
+        p_slug: String(slug), p_key: String(key), p_ip_hash: ipHash || null, p_page: page,
+        p_name: (name || "").slice(0, 120), p_avatar: (avatar || "").slice(0, 600),
+        p_is_member: !!isMember, p_is_presenter: !!isPresenter,
+        p_max_gap_ms: ATTEND_MAX_GAP_MS, p_anon_cap: capAnon,
+      },
+    });
+    const ligne = Array.isArray(r) ? r[0] : r;
+    if (ligne && typeof ligne.ok === "boolean") {
+      // Plafond de création atteint : on ne crée pas ce faux participant. 429 = « trop », pas une panne.
+      if (ligne.capped) return { ok: false, status: 429 };
+      return { ok: true };
+    }
+    // Forme inattendue : on n'invente pas de verdict, on laisse la boucle de repli faire l'écriture.
+  } catch (erreur) {
+    if (!_avertRpcPresence) {
+      _avertRpcPresence = true;
+      try {
+        PLAYER.errors.capture(new Error(
+          "présence non atomique : appliquez supabase/migrations/0015-presence-atomique.sql. "
+          + "Sans elle, la présence est écrite par lire-modifier-réécrire (correct) mais le plafond "
+          + "de création de faux participants anonymes n'est pas appliqué. "
+          + "(" + ((erreur && erreur.message) || erreur) + ")",
+        ), { route: "present-attend" });
+      } catch { /* jamais bloquant */ }
+    }
+    // On continue vers la boucle de repli.
+  }
   // ⚠️ LE DERNIER LIRE-MODIFIER-RÉÉCRIRE DU DÉPÔT, fermé comme les autres — mais SANS migration :
   // `last_seen` change à chaque battement accepté, c'est un verrou optimiste gratuit. L'écriture
   // est conditionnée à la valeur LUE ; zéro ligne = quelqu'un d'autre a battu entre-temps (l'autre

package/server/routes-direct.js

@@ -94,6 +94,14 @@ async function traiter(req, res, body, _slug) {
           // On dérive donc la clé de ce qui est prouvé, et jamais de ce qui est affirmé. Un anonyme,
           // lui, ne peut rien prouver : sa clé reste la sienne, mais enfermée dans un espace de noms
           // dont elle ne peut pas sortir — elle ne pourra jamais ressembler à l'e-mail d'un membre.
+          // ⚠️ L'IP NE PART PAS EN CLAIR VERS LA BASE : le plafond de création anonyme compte par
+          // (slug, empreinte d'IP), et une empreinte tronquée suffit à mesurer la pression d'un même
+          // appelant sans conserver de donnée personnelle. Le plafond lui-même est configurable par
+          // l'hôte, défaut ATTENDEES_PER_EGRESS × 1,3 (325) — la même cible que le quota de battement.
+          const ipHash = require("crypto").createHash("sha256").update("att:" + ip).digest("hex").slice(0, 32);
+          const anonCap = (PLAYER.config && Number(PLAYER.config.presenceAnonCap) > 0)
+            ? Math.trunc(Number(PLAYER.config.presenceAnonCap))
+            : Math.ceil(ATTENDEES_PER_EGRESS * 1.3);
           const r = await recordAttendance(String(body.slug || ""), {
             // ⚠️ MINUSCULÉE, ET CE DÉTAIL EST UNE LIGNE DE PRÉSENCE. La clé cliente que 0.1.42 a
             // remplacée l'était (`me.email.toLowerCase()`) ; la clé dérivée ne l'était pas, et la
@@ -110,7 +118,7 @@ async function traiter(req, res, body, _slug) {
             email: profil ? profil.email : body.email,
             avatar: (profil && profil.avatar) || body.avatar,
             isMember: !!profil, isPresenter: estPresentateur,
-          }, { presentation: pres });
+          }, { presentation: pres, ipHash, anonCap });
           return jp(r.ok ? 200 : (r.status || 400), r);
         } catch { return jp(500, { ok: false }); }
       }

package/server/schema.js

@@ -57,6 +57,18 @@ const ATTENDUES = {
     migration: "supabase/migrations/0006-reactions-ordonnees.sql",
     fonction: "empêcher deux réactions simultanées de s'écraser",
   },
+  // ⚠️ ENTRÉE DE REPORT, PAS DE GATE D'ÉCRITURE. Les six ci-dessus sont sondées par les chemins
+  // d'écriture (`attendue()`) pour décider s'ils écrivent la colonne. Celle-ci ne l'est que par la
+  // carte (`sonderTout`, `?schema=1`) : la présence dégrade sur l'ABSENCE DE LA RPC
+  // `player_attendance_bump` (repli sur la boucle, cf. presentations.js), pas sur cette colonne. Mais
+  // colonne et fonction voyagent ENSEMBLE dans la 0015 : la colonne est donc le témoin PROBEABLE que
+  // la 0015 est appliquée — une RPC, elle, ne se sonde pas proprement en REST sans l'appeler. Sans
+  // cette entrée, la carte annonçait « complet » à un hôte sans la 0015, présence dégradée (relevé ADV).
+  presenceAtomique: {
+    table: "doc_presentation_attendees", colonne: "creator_ip_hash",
+    migration: "supabase/migrations/0015-presence-atomique.sql",
+    fonction: "écrire la présence atomiquement et plafonner la création de faux participants anonymes",
+  },
 };
 
 /**

package/supabase/init.sql

@@ -230,9 +230,21 @@ create table if not exists public.doc_presentation_attendees (
   last_seen    timestamptz not null default now(),
   total_ms     bigint not null default 0,
   pages        jsonb not null default '[]'::jsonb,
+  -- Empreinte (jamais l'IP en clair) de l'appelant qui a CRÉÉ la ligne — plafond de création anonyme
+  -- par (slug, empreinte). Cf. migration 0015. Nullable : les lignes d'avant ne la portent pas.
+  creator_ip_hash text,
   primary key (slug, attendee_key)
 );
 create index if not exists doc_presentation_attendees_slug_idx on public.doc_presentation_attendees (slug);
+-- ⚠️ RÈGLE (sixième audit) : un index sur une colonne apparue APRÈS un init publié est précédé de son
+-- ALTER, ICI MÊME — sur une base d'hier, `create table if not exists` saute le corps de table et
+-- `creator_ip_hash` n'existerait qu'au rattrapage de fin de fichier, trop tard pour cet index.
+alter table public.doc_presentation_attendees
+  add column if not exists creator_ip_hash text;
+-- Compter les créations anonymes par (slug, empreinte) sans scanner toute la table. Cf. migration 0015.
+create index if not exists idx_attendees_slug_creator
+  on public.doc_presentation_attendees (slug, creator_ip_hash)
+  where is_member = false and is_presenter = false;
 
 -- ── Assistant IA (greffon `bot`) ───────────────────────────────────────────────────────────────
 -- Facultatif : le player fonctionne sans (PLAYER_PLUGINS_OFF=bot). La table peut rester vide.
@@ -332,6 +344,103 @@ begin
 end
 $$;
 
+-- Présence en un seul geste + plafond de création anonyme atomique. Cf. migration 0015 (mêmes règles).
+create or replace function public.player_attendance_bump(
+  p_slug         text,
+  p_key          text,
+  p_ip_hash      text,
+  p_page         integer,
+  p_name         text,
+  p_avatar       text,
+  p_is_member    boolean,
+  p_is_presenter boolean,
+  p_max_gap_ms   integer,
+  p_anon_cap     integer
+)
+returns table (ok boolean, created boolean, capped boolean)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_exists boolean;
+  v_count  integer;
+  v_page   integer := greatest(1, coalesce(p_page, 1));
+begin
+  -- Chemin rapide : la ligne existe déjà → c'est une ACTUALISATION, jamais soumise au plafond.
+  select true into v_exists
+    from public.doc_presentation_attendees
+    where slug = p_slug and attendee_key = p_key;
+
+  -- Création d'une ligne ANONYME : on sérialise par (slug, ip) et on compte sous le verrou, pour que
+  -- deux créations concurrentes ne franchissent pas le plafond ensemble. Membres et présentateur en
+  -- sont exemptés (leur identité est prouvée, ils ne gonflent pas de faux participants).
+  if not coalesce(v_exists, false) and not p_is_member and not p_is_presenter then
+    perform pg_advisory_xact_lock(hashtextextended(p_slug || '|' || coalesce(p_ip_hash, ''), 0));
+    -- Re-lire sous le verrou : la ligne a pu naître entre la première lecture et ici (même clé,
+    -- deux onglets). Si elle existe désormais, ce n'est plus une création → pas de plafond.
+    select true into v_exists
+      from public.doc_presentation_attendees
+      where slug = p_slug and attendee_key = p_key;
+    if not coalesce(v_exists, false) then
+      select count(*) into v_count
+        from public.doc_presentation_attendees
+        where slug = p_slug
+          and creator_ip_hash is not distinct from p_ip_hash
+          and is_member = false and is_presenter = false;
+      if v_count >= p_anon_cap then
+        return query select false, false, true;   -- plafond atteint : on ne crée pas
+        return;
+      end if;
+    end if;
+  end if;
+
+  -- L'écriture, en UN geste, pour la création comme pour l'actualisation. `last_seen` strictement
+  -- croissant ; le temps ajouté est le trou depuis le dernier battement, ignoré au-delà de MAX_GAP
+  -- (un onglet resté ouvert ne gonfle pas la présence) ; la page vue rejoint l'ensemble sans doublon.
+  insert into public.doc_presentation_attendees as l
+    (slug, attendee_key, name, email, avatar, is_member, is_presenter,
+     first_seen, last_seen, total_ms, pages, creator_ip_hash)
+  values
+    (p_slug, p_key, nullif(p_name, ''), null, nullif(p_avatar, ''), p_is_member, p_is_presenter,
+     now(), now(), 0, jsonb_build_array(v_page), p_ip_hash)
+  on conflict (slug, attendee_key) do update
+    set last_seen    = greatest(now(), l.last_seen + interval '1 millisecond'),
+        total_ms     = l.total_ms + (
+                         case
+                           when (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000) <= p_max_gap_ms
+                           then (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000)::bigint
+                           else 0
+                         end),
+        pages        = case when l.pages @> to_jsonb(v_page) then l.pages else l.pages || to_jsonb(v_page) end,
+        name         = coalesce(nullif(p_name, ''), l.name),
+        avatar       = coalesce(nullif(p_avatar, ''), l.avatar),
+        is_member    = p_is_member,
+        is_presenter = p_is_presenter;
+
+  return query select true, not coalesce(v_exists, false), false;
+end;
+$$;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from public;
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname = r) then
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from %I', r);
+    end if;
+  end loop;
+end
+$$;
+do $$
+begin
+  if exists (select 1 from pg_roles where rolname = 'service_role') then
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) to service_role;
+  end if;
+end
+$$;
+
 -- ── Accès ──────────────────────────────────────────────────────────────────────────────────────
 -- RLS activé SANS politique permissive : seul `service_role` (donc la route du player) passe.
 -- ⚠️ N'ajoutez pas de politique de lecture publique « pour que le direct fonctionne ». C'est

package/supabase/migrations/0015-presence-atomique.sql

@@ -0,0 +1,141 @@
+-- LA PRÉSENCE EN UN SEUL GESTE, ET UN PLAFOND DE CRÉATION QUI TIENT SOUS LA CONCURRENCE.
+--
+-- Deux choses, une fonction (P1c audit CODEX 5.6).
+--
+-- 1. UPSERT ATOMIQUE. `recordAttendance` faisait lire-modifier-réécrire avec un verrou optimiste sur
+--    `last_seen` et quatre tours de reprise. Correct, mais jusqu'à quatre allers-retours par
+--    battement. Un `insert … on conflict do update` fait le même travail en UN geste : cumul du temps
+--    plafonné au trou (ATTEND_MAX_GAP), union de la page vue, `last_seen` strictement croissant (la
+--    même défense que la boucle JS, portée en SQL), rafraîchissement des drapeaux à chaque battement.
+--
+-- 2. PLAFOND DE CRÉATION ANONYME, ATOMIQUE. La clé `anon-*` est choisie par le navigateur : un même
+--    visiteur peut fabriquer des milliers de clés distinctes et gonfler la liste des participants.
+--    On borne le nombre de NOUVELLES lignes anonymes par (présentation, IP fiable) — jamais les
+--    battements d'une clé DÉJÀ enregistrée, qui doivent toujours pouvoir s'actualiser. Les membres
+--    authentifiés et le présentateur ne consomment pas ce quota. Le contrôle et l'insertion sont
+--    sérialisés par un verrou d'avis par (slug, ip) : deux créations concurrentes ne peuvent pas
+--    franchir le plafond ensemble.
+--
+-- ⚠️ POURQUOI UNE FONCTION SQL, alors que le reste du player tient en PostgREST simple : ni l'upsert
+--    conditionnel (`count = count + 1` nomme la colonne des deux côtés) ni le « compter-puis-insérer
+--    atomique » ne sont exprimables en REST. C'est le même motif que `player_rate_limit_bump` (0004),
+--    et la garde de portabilité reste vraie : un `rpc/` n'ajoute ni jointure ni arbre booléen au REST.
+--
+-- ⚠️ Sans lui : le player retombe sur la boucle lire-modifier-réécrire (toujours correcte, sans le
+--    plafond de création) et le dit une fois en nommant ce fichier. Rien ne casse, rien ne se ferme.
+--    Applicable pendant que la version précédente tourne : tant que le code ne l'appelle pas, elle ne
+--    fait rien ; dès qu'il l'appelle, elle compte juste.
+--
+-- ⚠️ L'IP N'EST JAMAIS STOCKÉE EN CLAIR. La colonne porte un HASH tronqué (le player le calcule), qui
+--    suffit à compter la pression d'un même appelant sans conserver de donnée personnelle.
+
+alter table public.doc_presentation_attendees
+  add column if not exists creator_ip_hash text;
+
+-- Compter les créations anonymes par (slug, ip) reste rapide même sur une grande table.
+create index if not exists idx_attendees_slug_creator
+  on public.doc_presentation_attendees (slug, creator_ip_hash)
+  where is_member = false and is_presenter = false;
+
+create or replace function public.player_attendance_bump(
+  p_slug         text,
+  p_key          text,
+  p_ip_hash      text,
+  p_page         integer,
+  p_name         text,
+  p_avatar       text,
+  p_is_member    boolean,
+  p_is_presenter boolean,
+  p_max_gap_ms   integer,
+  p_anon_cap     integer
+)
+returns table (ok boolean, created boolean, capped boolean)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_exists boolean;
+  v_count  integer;
+  v_page   integer := greatest(1, coalesce(p_page, 1));
+begin
+  -- Chemin rapide : la ligne existe déjà → c'est une ACTUALISATION, jamais soumise au plafond.
+  select true into v_exists
+    from public.doc_presentation_attendees
+    where slug = p_slug and attendee_key = p_key;
+
+  -- Création d'une ligne ANONYME : on sérialise par (slug, ip) et on compte sous le verrou, pour que
+  -- deux créations concurrentes ne franchissent pas le plafond ensemble. Membres et présentateur en
+  -- sont exemptés (leur identité est prouvée, ils ne gonflent pas de faux participants).
+  if not coalesce(v_exists, false) and not p_is_member and not p_is_presenter then
+    perform pg_advisory_xact_lock(hashtextextended(p_slug || '|' || coalesce(p_ip_hash, ''), 0));
+    -- Re-lire sous le verrou : la ligne a pu naître entre la première lecture et ici (même clé,
+    -- deux onglets). Si elle existe désormais, ce n'est plus une création → pas de plafond.
+    select true into v_exists
+      from public.doc_presentation_attendees
+      where slug = p_slug and attendee_key = p_key;
+    if not coalesce(v_exists, false) then
+      select count(*) into v_count
+        from public.doc_presentation_attendees
+        where slug = p_slug
+          and creator_ip_hash is not distinct from p_ip_hash
+          and is_member = false and is_presenter = false;
+      if v_count >= p_anon_cap then
+        return query select false, false, true;   -- plafond atteint : on ne crée pas
+        return;
+      end if;
+    end if;
+  end if;
+
+  -- L'écriture, en UN geste, pour la création comme pour l'actualisation. `last_seen` strictement
+  -- croissant ; le temps ajouté est le trou depuis le dernier battement, ignoré au-delà de MAX_GAP
+  -- (un onglet resté ouvert ne gonfle pas la présence) ; la page vue rejoint l'ensemble sans doublon.
+  insert into public.doc_presentation_attendees as l
+    (slug, attendee_key, name, email, avatar, is_member, is_presenter,
+     first_seen, last_seen, total_ms, pages, creator_ip_hash)
+  values
+    (p_slug, p_key, nullif(p_name, ''), null, nullif(p_avatar, ''), p_is_member, p_is_presenter,
+     now(), now(), 0, jsonb_build_array(v_page), p_ip_hash)
+  on conflict (slug, attendee_key) do update
+    set last_seen    = greatest(now(), l.last_seen + interval '1 millisecond'),
+        total_ms     = l.total_ms + (
+                         case
+                           when (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000) <= p_max_gap_ms
+                           then (extract(epoch from (greatest(now(), l.last_seen + interval '1 millisecond') - l.last_seen)) * 1000)::bigint
+                           else 0
+                         end),
+        pages        = case when l.pages @> to_jsonb(v_page) then l.pages else l.pages || to_jsonb(v_page) end,
+        name         = coalesce(nullif(p_name, ''), l.name),
+        avatar       = coalesce(nullif(p_avatar, ''), l.avatar),
+        is_member    = p_is_member,
+        is_presenter = p_is_presenter;
+
+  return query select true, not coalesce(v_exists, false), false;
+end;
+$$;
+
+-- Même posture d'accès que player_rate_limit_bump : le player parle avec la clé de service ; personne
+-- d'autre n'a à appeler ceci. `anon`/`authenticated` sont des rôles Supabase, pas Postgres — on ne les
+-- révoque que s'ils existent, pour que le fichier passe aussi sur un Postgres nu (public auto-hébergé).
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from public;
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname = r) then
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) from %I', r);
+    end if;
+  end loop;
+end
+$$;
+
+-- Sur un Postgres nu, `revoke … from public` emporterait aussi le compte de service : on accorde donc
+-- explicitement, et seulement si le rôle existe (sinon l'exploitant accorde à son propre rôle).
+do $$
+begin
+  if exists (select 1 from pg_roles where rolname = 'service_role') then
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer) to service_role;
+  end if;
+end
+$$;