discovery-media-player 0.1.74 → 0.1.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "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/appelant.js

@@ -0,0 +1,59 @@
+// EXTRAIT DE handler.js (refactor lot 3 — routes, 19/08/2026) — blocs déplacés À L'IDENTIQUE.
+// Reste à PLAT dans server/ (les gardes de forge ciblent server/*.js).
+
+let PLAYER = null;
+const init = (ctx) => { PLAYER = ctx; };
+
+// ⚠️ `X-Forwarded-For` EST UN EN-TÊTE, DONC UNE AFFIRMATION DU CLIENT.
+//
+// Onze endroits en prenaient la première valeur pour identifier l'appelant, et toutes les limites
+// de débit s'appuyaient dessus. Un client qui atteint directement le serveur — c'est le cas du
+// serveur autonome, et de toute instance dont le proxy ne réécrit pas cet en-tête — pouvait donc
+// en changer à chaque requête et n'être jamais limité. La limite existait, elle ne limitait rien.
+//
+// Le caractère « par processus » des compteurs était documenté ; la confiance dans un en-tête non
+// authentifié ne l'était pas. C'est la différence entre une limite approximative et une limite
+// décorative.
+//
+// La décision revient à l'hôte, parce que lui seul sait s'il y a un proxy devant lui :
+// `identity.clientIp(req)` s'il la fournit, sinon l'adresse de la socket — jamais l'en-tête. Un
+// hôte derrière un proxy déclare sa politique dans son câblage ; un hôte sans proxy n'a rien à
+// faire, et il est protégé par défaut.
+function adresseAppelant(req) {
+  try {
+    if (PLAYER.identity && typeof PLAYER.identity.clientIp === "function") {
+      const v = PLAYER.identity.clientIp(req);
+      if (v) return String(v).slice(0, 60);
+    }
+  } catch { /* une IP indisponible ne doit pas empêcher de lire un document */ }
+  return String((req.socket && req.socket.remoteAddress) || "").slice(0, 60);
+}
+
+/** La clé d'un membre : son adresse, normalisée — la recherche de ligne est exacte. */
+function lcMembre(email) {
+  return String(email || "").trim().toLowerCase();
+}
+
+function cleAnonyme(brut) {
+  const v = String(brut == null ? "" : brut).trim().slice(0, 120);
+  return /^anon-[A-Za-z0-9_-]{4,}$/.test(v) ? v : "anon-inconnu";
+}
+
+async function profilDuJeton(req) {
+  try {
+    const u = await PLAYER.identity.verifyToken((req.headers && req.headers.authorization) || "");
+    if (!u || !u.email) return null;
+    if (typeof PLAYER.identity.profileOf === "function") {
+      const p = PLAYER.identity.profileOf(u) || {};
+      return { email: String(p.email || u.email), name: String(p.name || ""), avatar: String(p.avatar || "") };
+    }
+    const meta = (u && u.user_metadata) || {};
+    return {
+      email: String(u.email),
+      name: String(u.name || meta.name || meta.full_name || ""),
+      avatar: String(u.avatar || meta.avatarUrl || meta.avatar_url || ""),
+    };
+  } catch { return null; }
+}
+
+module.exports = { init, adresseAppelant, lcMembre, cleAnonyme, profilDuJeton };

package/server/gabarit-legal.js

@@ -0,0 +1,45 @@
+// EXTRAIT DE handler.js (refactor lot 2, 19/08/2026) — texte déplacé À L'IDENTIQUE. Reste à
+// PLAT dans server/ (les gardes de forge ciblent server/*.js).
+const { esc } = require("./texte");
+
+let PLAYER = null;
+const init = (ctx) => { PLAYER = ctx; };
+
+// ⚠️ UNE MENTION DONT L'OBJET EST D'ÊTRE EXACTE NE DOIT PAS INVENTER UN EXPÉDITEUR.
+//
+// Le texte par défaut disait « transmise à son expéditeur ». Vrai pour un lien nominatif, faux
+// pour un lien que PERSONNE n'a envoyé — la plaquette publique d'un programme, ouverte depuis une
+// carte par un visiteur qui n'a reçu aucun message. Le défaut est antérieur au mode serveur à
+// serveur ; c'est lui qui l'a rendu visible, puisqu'il crée précisément des liens sans
+// destinataire NI créateur.
+//
+// La distinction ne demande aucune donnée nouvelle : c'est déjà la clé d'idempotence de ces
+// liens-là. Signalé par le second hôte en regardant son propre écran — ce qu'aucun test ne fait.
+function legalFooter({ tracked, sansExpediteur }) {
+  const L = PLAYER.legal;
+  const liens = [
+    L.legalUrl ? `<a href="${esc(L.legalUrl)}" target=_blank rel=noreferrer>Mentions légales</a>` : "",
+    L.privacyUrl ? `<a href="${esc(L.privacyUrl)}" target=_blank rel=noreferrer>Confidentialité</a>` : "",
+    // Obligation AGPL : l'accès au source se propose à qui UTILISE le logiciel, pas seulement à qui le distribue.
+    L.sourceUrl ? `<a href="${esc(L.sourceUrl)}" target=_blank rel=noreferrer>Code source</a>` : "",
+  ].filter(Boolean).join("<span class=lgl-sep>·</span>");
+  // Un contexte qui ne fournit pas le second texte retombe sur le premier : rien ne casse chez un
+  // hôte qui n'a pas encore de liens sans expéditeur.
+  const texte = sansExpediteur ? (L.trackingNoticeAnonymous || L.trackingNotice) : L.trackingNotice;
+  const mesure = tracked ? `<span class=lgl-note>${esc(texte)}</span>` : "";
+  if (!liens && !mesure) return "";
+  return `<div class=lgl>${mesure}${liens ? `<span class=lgl-links>${liens}</span>` : ""}</div>`;
+}
+
+const LEGAL_CSS = `
+  .lgl{position:fixed;left:0;right:0;bottom:0;z-index:5;display:flex;flex-wrap:wrap;gap:4px 10px;
+    align-items:center;justify-content:center;padding:5px 12px;font-size:10.5px;line-height:1.35;
+    color:rgba(255,255,255,.94);background:rgba(0,0,0,.66);backdrop-filter:blur(3px);pointer-events:none}
+  .lgl a{color:inherit;text-decoration:underline;text-underline-offset:2px;pointer-events:auto}
+  .lgl a:hover{color:#fff}
+  .lgl-sep{margin:0 6px;opacity:.8}
+  .lgl-note{opacity:1}
+  @media (max-width:640px){ .lgl{font-size:10px;padding:4px 10px} }
+`;
+
+module.exports = { init, legalFooter, LEGAL_CSS };