discovery-media-player 0.1.99 → 0.1.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.99",
+  "version": "0.1.101",
   "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/gabarit-live.js

@@ -261,12 +261,27 @@ var Live=(function(){
   // hôte sans PLAYER_PRESENCE_SECRET n'en renvoie pas, et tout continue comme avant (legacy).
   // ⚠️ AUCUN BACKTICK DANS CE COMMENTAIRE : ce fichier ÉMET du JS via des template literals — un
   // backtick ici ferme la chaîne et casse tout le module (vu à l'instant, 33 essais rouges d'un coup).
+  // ⚠️ LE JETON SE PERSISTE, ET C'EST CE QUI REND LE DURCISSEMENT POSSIBLE (0018). Gardé en mémoire
+  // seule, il était perdu à CHAQUE rechargement de page : le client repartait alors en BOOTSTRAP avec
+  // sa clé habituelle (elle, persistée), ce qui rendait « bootstrap sur clé existante » banal — donc
+  // impossible à refuser sans casser tout rechargement. Rangé à côté de la clé de participant, il a la
+  // même durée de vie qu'elle : un rechargement repart avec son jeton, et un bootstrap sur une ligne
+  // déjà réclamée redevient franchement anormal. Stockage bridé : on retombe sur la mémoire seule, et
+  // le bootstrap reste possible tant que STRICT est absent.
+  var CLE_PT='3dd-present-pt';
+  function ptLu(){ if(_ptJeton)return _ptJeton; try{var s=_store();var v=s&&s.getItem(CLE_PT+':'+SLUG);if(v)_ptJeton=v;}catch(e){} return _ptJeton; }
+  function ptRange(v){ _ptJeton=v||''; try{var s=_store();if(s&&v)s.setItem(CLE_PT+':'+SLUG,v);}catch(e){} }
+  // Refus d'usurpation : cette clé appartient à quelqu'un qui détient son jeton. On ne perd PAS la
+  // présence en silence — on fait TOURNER notre clé pour repartir sur une ligne neuve au battement
+  // suivant. Une mesure qui s'arrête sans le dire est le pire des deux côtés de cette porte.
+  function rotationCle(){ try{var s=_store();if(s){s.removeItem('3dd-present-attkey');s.removeItem(CLE_PT+':'+SLUG);}}catch(e){} _ptJeton=''; }
   function sendAttend(){ if(!SLUG||!ME)return; try{ var h={'Content-Type':'application/json'};var jw=accessToken();if(jw)h.Authorization='Bearer '+jw;
     var corps={action:'present-attend',slug:SLUG,control:CONTROL,key:attKey(),name:ME.name||'',email:ME.email||'',avatar:ME.avatar||''};
-    if(_ptJeton)corps.pt=_ptJeton;else corps.wantToken='1';
+    var pt=ptLu();
+    if(pt)corps.pt=pt;else corps.wantToken='1';
     fetch('/api/doc',{method:'POST',headers:h,body:JSON.stringify(corps)})
       .then(function(r){return r.json();})
-      .then(function(d){if(d&&d.pt)_ptJeton=d.pt;})
+      .then(function(d){ if(d&&d.pt)ptRange(d.pt); else if(d&&d.usurpe)rotationCle(); })
       .catch(function(){}); }catch(e){} }
   var EMOJIS=['👍','❤️','😂','😮','👏','🎉'];
   var RSVG='<svg viewBox="0 0 24 24" fill=none stroke=currentColor stroke-width=2 stroke-linecap=round><circle cx=12 cy=12 r=9 /><path d="M8.5 14.5s1.4 1.7 3.5 1.7 3.5-1.7 3.5-1.7"/><line x1=9 y1=9.2 x2=9.01 y2=9.2 /><line x1=15 y1=9.2 x2=15.01 y2=9.2 /></svg>';

package/server/presentations.js

@@ -768,7 +768,48 @@ let _avertRpcPresence = false;
 // 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, ipHash = null, anonCap = null, hasToken = null } = {}) {
+/**
+ * Appelle la RPC de présence en RÉESSAYANT le contrat plus ancien si la signature n'existe pas.
+ *
+ * ⚠️ POURQUOI UN RÉESSAI PLUTÔT QU'UNE SONDE. Une sonde de colonne est un indice INDIRECT de ce qu'on
+ * veut savoir (la signature de la fonction) ; ici on interroge exactement ce dont on dépend. C'est
+ * indispensable pour 0018, qui n'ajoute AUCUNE colonne — il n'y aurait rien à sonder.
+ *
+ * ⚠️ ET LE VERDICT SE MÉMORISE. Sans mémo, chaque battement d'un hôte non migré paierait un
+ * aller-retour perdu ; le chemin de la présence est chaud (un battement toutes les 25 s par
+ * participant). On retient donc l'ensemble d'arguments qui a marché, pour le processus.
+ */
+let _bumpSansDurcissement = false;   // 0018 absente : ne plus demander p_only_if_unclaimed
+async function appelerBump(corps, durcissementVoulu) {
+  const appel = (b) => PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: b });
+  if (durcissementVoulu && _bumpSansDurcissement) {
+    const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
+    return appel(sansDurcissement);
+  }
+  try {
+    return await appel(corps);
+  } catch (erreur) {
+    if (!durcissementVoulu) throw erreur;   // rien à retirer : l'échec est réel
+    // La signature à 12 arguments n'existe pas (0018 non appliquée) : on retire l'argument et on
+    // réessaie. Le durcissement n'est alors PAS appliqué — et ça se dit, une fois, plus bas.
+    _bumpSansDurcissement = true;
+    // ⚠️ CE QUI DISPARAÎT SE DIT. Le durcissement demandé n'est pas appliqué : sous
+    // PLAYER_PRESENCE_STRICT, la porte se fermerait sur les battements legacy tout en laissant un
+    // bootstrap auto-déclaré s'emparer d'une présence réclamée — c'est-à-dire une fermeture qui
+    // rassure sans protéger. On nomme donc le fichier ET la conséquence.
+    try {
+      PLAYER.errors.capture(new Error(
+        "bootstrap de présence NON durci : appliquez supabase/migrations/0018-bootstrap-non-usurpable.sql. "
+        + "Sans elle, un bootstrap auto-déclaré peut écraser une présence déjà réclamée par un porteur "
+        + "de jeton — n'armez pas PLAYER_PRESENCE_STRICT avant de l'avoir appliquée.",
+      ), { route: "present-attend" });
+    } catch { /* jamais bloquant */ }
+    const { p_only_if_unclaimed: _retire, ...sansDurcissement } = corps;
+    return appel(sansDurcissement);
+  }
+}
+
+async function recordAttendance(slug, participant, { presentation = null, ipHash = null, anonCap = null, hasToken = null, onlyIfUnclaimed = false } = {}) {
   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
@@ -809,12 +850,23 @@ async function recordAttendance(slug, participant, { presentation = null, ipHash
   };
   // true → last_token_at, false → last_no_token_at, null → ni l'un ni l'autre. 0017 seulement.
   if (transitionDispo) corpsRpc.p_has_token = hasToken == null ? null : !!hasToken;
+  // ⚠️ LE DURCISSEMENT DU BOOTSTRAP (0018) N'A PAS DE COLONNE À SONDER — il est fonction-seule. On ne
+  // peut donc pas le déduire d'un indice : on le DEMANDE et on RÉESSAIE le contrat plus ancien si la
+  // signature n'existe pas. C'est la forme que le second hôte préférait (« elle ne peut pas se
+  // tromper, parce qu'elle interroge exactement ce dont elle dépend ») — l'indice indirect de 0017,
+  // lui, resterait vrai si colonne et fonction se désynchronisaient. Le contrat retenu est mémorisé
+  // pour le processus : un hôte non migré ne paie pas deux allers-retours par battement, un seul.
+  const durcissementVoulu = !!onlyIfUnclaimed;
+  if (durcissementVoulu) corpsRpc.p_only_if_unclaimed = true;
   try {
-    const r = await PLAYER.db.request("rpc/player_attendance_bump", { method: "POST", body: corpsRpc });
+    const r = await appelerBump(corpsRpc, durcissementVoulu);
     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 };
+      // Bootstrap sur une ligne DÉJÀ RÉCLAMÉE par un porteur de jeton : rien n'a été écrit. 409 = « ce
+      // n'est pas à toi » — le client fera tourner sa clé plutôt que de perdre sa présence en silence.
+      if (ligne.usurpe) return { ok: false, status: 409, usurpe: true };
       return { ok: true };
     }
     // Forme inattendue : on n'invente pas de verdict, on laisse la boucle de repli faire l'écriture.

package/server/routes-direct.js

@@ -141,15 +141,26 @@ 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, ipHash, anonCap, hasToken });
+            // ⚠️ UN BOOTSTRAP NE PEUT PAS S'EMPARER D'UNE PRÉSENCE DÉJÀ RÉCLAMÉE (0018). `wantToken`
+            // est AUTO-DÉCLARÉ : sans ce verrou, un attaquant le déclarait, posait la clé d'un
+            // participant enregistré, et écrasait sa ligne — l'usurpation même que l'étape 2 ferme
+            // pour les battements ordinaires. Le second hôte l'a EXÉCUTÉE sur sa prod. Le contrôle ne
+            // vaut que pour un bootstrap : un porteur de jeton est déjà prouvé, un membre aussi.
+          }, { presentation: pres, ipHash, anonCap, hasToken, onlyIfUnclaimed: bootstrap });
           // On ÉMET (ou ré-émet) un jeton pour l'anonyme dont l'écriture a réussi : le client le garde
           // et le renvoie aux battements suivants. `exp` court (6 h), ré-émis à chaque battement — pas
           // de table anti-rejeu (le scellé d'archive et l'exp bornent déjà le rejeu, cf. 0007). Un
           // membre n'en a pas besoin (son JWT le prouve). Sans PLAYER_PRESENCE_SECRET, `signPresenceToken`
           // rend "" → aucun champ `pt`, le client reste en mode legacy. Rien ne casse.
+          // ⚠️ SEPT JOURS, ET C'EST LA PERSISTANCE QUI FIXE LE CHIFFRE. Le jeton vit maintenant dans le
+          // stockage du visiteur, à côté de sa clé de participant : sa durée de vie doit couvrir un
+          // RETOUR, sinon l'expiration relance un bootstrap sur une ligne réclamée, qui sera refusé, et
+          // le visiteur repart sur une ligne neuve — une présence coupée en deux dans les statistiques
+          // pour rien. Le rejeu reste borné par le scellé d'archive (0007, il porte aussi sur la table
+          // des présences) : une présentation close refuse toute écriture, jeton valide ou non.
           let pt = "";
           if (!profil && r.ok && typeof PLAYER.identity.signPresenceToken === "function") {
-            pt = PLAYER.identity.signPresenceToken(slug, cleAnon, 6 * 3600);
+            pt = PLAYER.identity.signPresenceToken(slug, cleAnon, 7 * 24 * 3600);
           }
           return jp(r.ok ? 200 : (r.status || 400), pt ? { ...r, pt } : r);
         } catch { return jp(500, { ok: false }); }

package/supabase/init.sql

@@ -398,27 +398,42 @@ create or replace function public.player_attendance_bump(
   p_is_presenter boolean,
   p_max_gap_ms   integer,
   p_anon_cap     integer,
-  p_has_token    boolean default null
+  p_has_token    boolean default null,
+  p_only_if_unclaimed boolean default null
 )
-returns table (ok boolean, created boolean, capped boolean)
+returns table (ok boolean, created boolean, capped boolean, usurpe boolean)
 language plpgsql
 security definer
 set search_path = public
 as $$
 declare
   v_exists boolean;
+  v_claimed boolean;
   v_count  integer;
   v_page   integer := greatest(1, coalesce(p_page, 1));
 begin
-  select true into v_exists
+  -- On lit l'existence ET l'état « réclamée » en un seul geste : un bootstrap n'a rien à écrire sur
+  -- une ligne dont un porteur de jeton s'est déjà servi.
+  select true, (last_token_at is not null) into v_exists, v_claimed
     from public.doc_presentation_attendees
     where slug = p_slug and attendee_key = p_key;
 
+  if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+    return query select false, false, false, true;   -- usurpation : on n'écrit RIEN
+    return;
+  end if;
+
   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));
-    select true into v_exists
+    -- Re-lire sous le verrou : la ligne a pu naître entre-temps — et si elle est née RÉCLAMÉE, un
+    -- bootstrap concurrent ne doit pas davantage l'écraser ici qu'au premier contrôle.
+    select true, (last_token_at is not null) into v_exists, v_claimed
       from public.doc_presentation_attendees
       where slug = p_slug and attendee_key = p_key;
+    if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+      return query select false, false, false, true;
+      return;
+    end if;
     if not coalesce(v_exists, false) then
       select count(*) into v_count
         from public.doc_presentation_attendees
@@ -426,7 +441,7 @@ begin
           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;
+        return query select false, false, true, false;
         return;
       end if;
     end if;
@@ -456,17 +471,17 @@ begin
         last_token_at    = case when p_has_token is true  then now() else l.last_token_at    end,
         last_no_token_at = case when p_has_token is false then now() else l.last_no_token_at end;
 
-  return query select true, not coalesce(v_exists, false), false;
+  return query select true, not coalesce(v_exists, false), false, false;
 end;
 $$;
-revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean) from public;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean) 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, boolean) from %I', r);
+      execute format('revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean) from %I', r);
     end if;
   end loop;
 end
@@ -474,7 +489,7 @@ $$;
 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, boolean) to service_role;
+    grant execute on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean) to service_role;
   end if;
 end
 $$;

package/supabase/migrations/0018-bootstrap-non-usurpable.sql

@@ -0,0 +1,133 @@
+-- UN BOOTSTRAP NE PEUT PAS S'EMPARER D'UNE PRÉSENCE DÉJÀ RÉCLAMÉE PAR UN PORTEUR DE JETON.
+--
+-- ⚠️ Le résidu de l'étape 2, et le dernier verrou avant PLAYER_PRESENCE_STRICT. Un client moderne qui
+-- n'a pas encore de jeton s'annonce par `wantToken` : c'est ce marqueur qui le distingue d'un client
+-- legacy, et il est AUTO-DÉCLARÉ. Sous STRICT, un attaquant pouvait donc le déclarer à son tour, poser
+-- la clé d'un participant déjà enregistré, et écraser sa ligne — exactement l'usurpation que l'étape 2
+-- ferme pour les battements ordinaires. Le second hôte l'a EXÉCUTÉE sur sa prod (nom du titulaire
+-- remplacé) : ce n'est pas une hypothèse.
+--
+-- La règle : une ligne qui a DÉJÀ battu avec un jeton valide (`last_token_at` renseigné) est RÉCLAMÉE.
+-- Un bootstrap — par définition sans jeton — n'a rien à y écrire. Il reste libre de créer une ligne
+-- neuve, et d'adopter une ligne legacy jamais réclamée (c'est le chemin de montée normal).
+--
+-- ⚠️ POURQUOI CE N'EST PAS UN REFUS DE RECHARGEMENT. Le client PERSISTE désormais son jeton à côté de
+-- sa clé de participant (même durée de vie, même stockage) : un rechargement de page repart donc avec
+-- son jeton, pas en bootstrap. Un bootstrap sur une ligne réclamée devient alors franchement anormal —
+-- et le client, refusé, fait TOURNER sa clé pour repartir sur une ligne neuve plutôt que de perdre sa
+-- présence en silence.
+--
+-- ⚠️ Sans lui : le player appelle la signature à 11 arguments (0017) ou 10 (0015) et le bootstrap n'est
+--    pas contrôlé — c'est l'état d'aujourd'hui, tenable tant que PLAYER_PRESENCE_STRICT est absent.
+--    N'ARMEZ PAS STRICT sans cette migration : elle est ce qui rend la fermeture utile.
+--    Le player réessaie automatiquement le contrat plus ancien, donc appliquer dans n'importe quel
+--    ordre est inoffensif.
+
+drop function if exists public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean);
+
+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,
+  p_has_token    boolean default null,
+  p_only_if_unclaimed boolean default null
+)
+returns table (ok boolean, created boolean, capped boolean, usurpe boolean)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  v_exists boolean;
+  v_claimed boolean;
+  v_count  integer;
+  v_page   integer := greatest(1, coalesce(p_page, 1));
+begin
+  -- On lit l'existence ET l'état « réclamée » en un seul geste : un bootstrap n'a rien à écrire sur
+  -- une ligne dont un porteur de jeton s'est déjà servi.
+  select true, (last_token_at is not null) into v_exists, v_claimed
+    from public.doc_presentation_attendees
+    where slug = p_slug and attendee_key = p_key;
+
+  if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+    return query select false, false, false, true;   -- usurpation : on n'écrit RIEN
+    return;
+  end if;
+
+  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-temps — et si elle est née RÉCLAMÉE, un
+    -- bootstrap concurrent ne doit pas davantage l'écraser ici qu'au premier contrôle.
+    select true, (last_token_at is not null) into v_exists, v_claimed
+      from public.doc_presentation_attendees
+      where slug = p_slug and attendee_key = p_key;
+    if p_only_if_unclaimed is true and coalesce(v_exists, false) and coalesce(v_claimed, false) then
+      return query select false, false, false, true;
+      return;
+    end if;
+    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, false;
+        return;
+      end if;
+    end if;
+  end if;
+
+  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, last_token_at, last_no_token_at)
+  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,
+     case when p_has_token is true then now() end,
+     case when p_has_token is false then now() end)
+  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,
+        last_token_at    = case when p_has_token is true  then now() else l.last_token_at    end,
+        last_no_token_at = case when p_has_token is false then now() else l.last_no_token_at end;
+
+  return query select true, not coalesce(v_exists, false), false, false;
+end;
+$$;
+revoke all on function public.player_attendance_bump(text, text, text, integer, text, text, boolean, boolean, integer, integer, boolean, boolean) 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, boolean, boolean) 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, boolean, boolean) to service_role;
+  end if;
+end
+$$;