discovery-media-player 0.1.112 → 0.1.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.112",
+  "version": "0.1.113",
   "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

@@ -274,15 +274,29 @@ var Live=(function(){
   // 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.
+  // Jeter le jeton SEULEMENT — la clé reste valide, c'est la nôtre ; seule la preuve est périmée.
+  function ptOublie(){ _ptJeton=''; try{var s=_store();if(s)s.removeItem(CLE_PT+':'+SLUG);}catch(e){} }
   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;
+  // ⚠️ UN SEUL BATTEMENT EN VOL. Le filet périodique, l'arrivée, le changement de page et la fermeture
+  // peuvent tomber ensemble : deux battements concurrents sur la même clé font que la réponse la plus
+  // ANCIENNE peut arriver la dernière et réinstaller un jeton périmé par-dessus le frais.
+  var _attEnVol=false;
+  function sendAttend(){ if(!SLUG||!ME||_attEnVol)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||''};
     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)ptRange(d.pt); else if(d&&d.usurpe)rotationCle(); })
-      .catch(function(){}); }catch(e){} }
+      .then(function(d){ if(d&&d.pt)ptRange(d.pt);
+        // ⚠️ UN JETON REFUSÉ SE JETTE, SINON ON LE RENVOIE POUR TOUJOURS. Expiré, ou signé avec un
+        // secret que l'hôte a changé, il produit un 403 presence-token à CHAQUE battement — et le
+        // client, qui ne réagissait qu'à pt ou usurpe, le gardait en stockage et le représentait
+        // indéfiniment : la présence cessait d'être enregistrée sans que rien ne reparte. On jette le
+        // JETON (pas la clé : elle est encore la nôtre) et le battement suivant redemande une émission.
+        else if(d&&d.error==='presence-token')ptOublie();
+        else if(d&&d.usurpe)rotationCle(); })
+      .catch(function(){})
+      .then(function(){_attEnVol=false;},function(){_attEnVol=false;}); _attEnVol=true; }catch(e){_attEnVol=false;} }
   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>';
   function esc(s){return Player.live.escapeHtml(s);}

package/server/handler.js

@@ -598,7 +598,18 @@ async function handler(req, res) {
         // ⚠️ La porte du jeton de présence (P1c étape 2) est-elle fermée ? Même raison
         // qu'internalStrict : un cockpit doit voir l'état des DEUX hôtes sans lire un journal — c'est
         // ce booléen, lu avec `presence: { avecJeton, sansJeton }` de la carte, qui dit quand fermer.
-        presenceStrict: !!(PLAYER.config && PLAYER.config.presenceStrict),
+        // ⚠️ EFFECTIF, PAS DÉCLARÉ. Posé sans capacité d'émettre (pas de secret), STRICT est INERTE :
+        // le refuser vraiment expulserait 100 % des participants anonymes, puisque aucun ne peut
+        // obtenir de jeton. Annoncer `true` dans ce cas serait dire qu'une porte est fermée quand elle
+        // est grande ouverte — et c'est ce booléen qu'un cockpit lit pour décider. On rend donc ce qui
+        // s'applique RÉELLEMENT ; `presenceJetons` juste en dessous dit pourquoi, quand les deux
+        // divergent. (Même famille que la carte qui disait « complet » sans couvrir une migration.)
+        presenceStrict: !!(PLAYER.config && PLAYER.config.presenceStrict) && (() => {
+          try {
+            const signer = PLAYER.identity && PLAYER.identity.signPresenceToken;
+            return typeof signer === "function" && !!signer("carte-sonde", "carte-sonde", 60);
+          } catch { return false; }
+        })(),
         // ⚠️ LES JETONS DE PRÉSENCE SONT-ILS RÉELLEMENT ÉMIS ? Sans ce booléen, un exploitant qui vient
         // de poser `PLAYER_PRESENCE_SECRET` n'a AUCUN moyen de vérifier que son réglage a pris : la
         // carte affiche `presence: {0,0}` aussi bien quand le secret est actif que quand la variable est

package/server/routes-direct.js

@@ -111,18 +111,51 @@ async function traiter(req, res, body, _slug) {
           const jetonEntrant = (typeof PLAYER.identity.verifyPresenceToken === "function")
             ? PLAYER.identity.verifyPresenceToken(String(body.pt || "")) : null;
           const jetonValide = !!(jetonEntrant && jetonEntrant.slug === slug && jetonEntrant.key);
-          const bootstrap = !profil && !jetonValide && String(body.wantToken || "") === "1";
           const cleAnon = jetonValide ? String(jetonEntrant.key) : cleAnonyme(body.key);
-          // Le compteur de transition : true = moderne/prouvé (membre, jeton, ou bootstrap moderne) ;
-          // false = legacy (anonyme, ni jeton ni wantToken). Deux champs distincts en base (0017).
-          const hasToken = !!(profil || jetonValide || bootstrap);
+          // ⚠️ ON SIGNE AVANT D'ÉCRIRE, ET C'EST CE QUI FERMAIT UNE BOUCLE. Le jeton était fabriqué
+          // APRÈS l'écriture : on déclarait donc un bootstrap « moderne » sans savoir si un jeton
+          // pourrait seulement sortir. Sans `PLAYER_PRESENCE_SECRET`, la ligne était marquée réclamée
+          // et AUCUN jeton n'était renvoyé — le battement suivant repartait en bootstrap, tombait sur
+          // sa propre ligne réclamée (409), et le client faisait tourner sa clé. Chaque battement
+          // créait alors un participant de plus, jusqu'au plafond de 325. Une protection qui produit
+          // exactement ce qu'elle interdit. (Relevé par un audit externe.)
+          const jetonCandidat = (!profil && typeof PLAYER.identity.signPresenceToken === "function")
+            ? PLAYER.identity.signPresenceToken(slug, cleAnon, 7 * 24 * 3600) : "";
+          const peutEmettre = !!jetonCandidat;
+          // Un bootstrap n'est un bootstrap que si l'hôte peut RÉELLEMENT émettre. Sinon ce battement
+          // ne porte aucune preuve et n'en portera jamais : c'est un battement sans jeton, et le
+          // compteur doit le dire — c'est même ce qui empêche d'armer STRICT sur un hôte sans secret,
+          // puisque `sansJeton` n'y retombera jamais à zéro.
+          const bootstrap = !profil && !jetonValide && String(body.wantToken || "") === "1" && peutEmettre;
+          // ⚠️ TROIS ÉTATS, PAS DEUX. true = PROUVÉ (membre ou jeton valide) → last_token_at, la ligne
+          // devient réclamée. false = sans preuve (legacy, ou moderne sur un hôte sans secret) →
+          // last_no_token_at. null = BOOTSTRAP : ni l'un ni l'autre. Un bootstrap ne prouve rien — il
+          // ne doit donc pas réclamer la ligne (sinon un client qui perd son jeton se refuse lui-même)
+          // ni compter comme legacy (sinon `sansJeton` ne retomberait jamais à zéro, chaque nouveau
+          // visiteur en produisant un). La ligne est créée LIBRE ; elle sera réclamée au battement
+          // suivant, celui qui portera le jeton.
+          const hasToken = (profil || jetonValide) ? true : (bootstrap ? null : false);
           // ⚠️ PORTE STRICTE : une fois la transition finie (sansJeton===0) et PLAYER_PRESENCE_STRICT
           // posé, un battement LEGACY (anonyme, sans jeton ni bootstrap) n'est plus enregistré. Off par
           // défaut → aucun effet pendant la transition. ⚠️ RÉSIDU CONNU (à durcir en suivant) : un
           // bootstrap `wantToken` portant la clé d'un anonyme EXISTANT pourrait l'écraser sous strict —
           // exploitabilité faible (l'attaquant doit connaître un uid anonyme aléatoire, jamais exposé) ;
           // le fermer proprement demande à la RPC de refuser un bootstrap sur une clé déjà existante.
-          if (PLAYER.config && PLAYER.config.presenceStrict && !profil && !jetonValide && !bootstrap) {
+          // ⚠️ STRICT EST INERTE SANS CAPACITÉ D'ÉMETTRE — sinon il refuserait 100 % des participants
+          // anonymes, une panne auto-infligée : sans secret, personne ne PEUT obtenir de jeton. On
+          // dégrade donc, et on le DIT (la carte rend `presenceStrict` effectif, pas déclaré).
+          if (PLAYER.config && PLAYER.config.presenceStrict && !peutEmettre && !profil) {
+            try {
+              if (await PLAYER.limits.allow("presence:strict-inerte", 1, 3600)) {
+                PLAYER.errors.capture(new Error(
+                  "PLAYER_PRESENCE_STRICT est posé mais AUCUN jeton ne peut être émis "
+                  + "(PLAYER_PRESENCE_SECRET absent) : la porte reste OUVERTE. Armé tel quel, elle "
+                  + "refuserait tous les participants anonymes.",
+                ), { route: "present-attend" });
+              }
+            } catch { /* jamais bloquant */ }
+          }
+          if (PLAYER.config && PLAYER.config.presenceStrict && peutEmettre && !profil && !jetonValide && !bootstrap) {
             return jp(403, { ok: false, error: "presence-token" });
           }
           const r = await recordAttendance(slug, {
@@ -158,10 +191,7 @@ async function traiter(req, res, body, _slug) {
           // 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, 7 * 24 * 3600);
-          }
+          const pt = (r.ok && jetonCandidat) ? jetonCandidat : "";
           return jp(r.ok ? 200 : (r.status || 400), pt ? { ...r, pt } : r);
         } catch { return jp(500, { ok: false }); }
       }