discovery-media-player 0.1.12 → 0.1.14

package/context/standalone.js

@@ -204,7 +204,35 @@ function createStandaloneContext(env = process.env) {
 
     // Sans expéditeur configuré, le re-partage et le code du mur d'accès sont indisponibles — et
     // le disent. Ils ne prétendent pas avoir envoyé.
-    mail: { async send() { return null; } },
+    /**
+     * Envoi d'email : capacité de l'HÔTE. Sans route configurée, le player ne prétend pas avoir
+     * envoyé — il rend `null`, et l'interface dit « envoi indisponible ».
+     *
+     * ⚠️ UN SECRET À LUI, ET C'EST UN ARBITRAGE ASSUMÉ. Le troisième, donc l'inflation est réelle.
+     * Mais `PLAYER_HOST_FETCH_SECRET` part vers l'hôte à CHAQUE fichier ouvert : il vit dans ses
+     * journaux d'accès à raison de plusieurs entrées par lecture. Lui ajouter le pouvoir de faire
+     * partir du courrier au nom de l'hôte élargirait énormément ce qu'une fuite de journaux
+     * permettrait — et une réputation d'expéditeur perdue met des semaines à revenir. Répondre à
+     * une question et agir vers le dehors ne sont pas le même pouvoir, même dans la même
+     * direction.
+     *
+     * La charge utile porte les champs STRUCTURÉS en plus du HTML : un hôte qui compose lui-même
+     * (gabarit à sa marque, aucun texte venu de l'appelant) a tout ce qu'il lui faut sans avoir à
+     * découper le nôtre.
+     */
+    mail: {
+      async send(message) {
+        const url = String(env.PLAYER_HOST_MAIL_URL || "").trim();
+        const secret = String(env.PLAYER_HOST_MAIL_SECRET || "");
+        if (!url) return null;
+        if (!secret) {
+          try { journal.capture(new Error("PLAYER_HOST_MAIL_URL est configurée sans PLAYER_HOST_MAIL_SECRET : aucun envoi ne partira"), {}); } catch { /* ignore */ }
+          return null;
+        }
+        const reponse = await appelHote(url, secret, message, journal);
+        return reponse && reponse.sent === true ? { sent: true } : null;
+      },
+    },
 
     identity: {
       /**
@@ -335,6 +363,17 @@ function createStandaloneContext(env = process.env) {
       get sourceUrl() { return String(env.PLAYER_SOURCE_URL || "https://github.com/Juli1artha/discovery-media-player").trim(); },
       get legalUrl() { return String(env.PLAYER_LEGAL_URL || "").trim(); },
       get privacyUrl() { return String(env.PLAYER_PRIVACY_URL || "").trim(); },
+      /**
+       * ⚠️ Mention d'un lien que PERSONNE n'a envoyé — plaquette publique ouverte depuis une carte.
+       * Parler d'« expéditeur » y serait faux, et c'est la seule phrase du produit dont l'objet
+       * est d'être exacte. Le player choisit d'après le lien lui-même : ni destinataire, ni
+       * créateur.
+       */
+      get trackingNoticeAnonymous() {
+        const perso = String(env.PLAYER_TRACKING_NOTICE_ANON || "").trim();
+        return perso || "La consultation de ce document est mesurée (pages vues, temps de lecture).";
+      },
+
       get trackingNotice() {
         const perso = String(env.PLAYER_TRACKING_NOTICE || "").trim();
         return perso || "La consultation de ce document est mesurée (pages vues, temps de lecture) et transmise à son expéditeur.";
@@ -356,6 +395,7 @@ function createStandaloneContext(env = process.env) {
       // Même raison que ci-dessus : « la capacité existe » et « elle est configurée »
       // sont deux questions, et seule la seconde explique un refus.
       hostShare: !!String(env.PLAYER_HOST_SHARE_SECRET || ""),
+      hostMail: !!String(env.PLAYER_HOST_MAIL_URL || "").trim(),
     },
   };
 }

package/package.json

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

@@ -1145,7 +1145,17 @@ async function relayerFichier(res, r, disposition) {
   res.end(buf);
 }
 
-function legalFooter({ tracked }) {
+// ⚠️ 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>` : "",
@@ -1153,7 +1163,10 @@ function legalFooter({ tracked }) {
     // 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>");
-  const mesure = tracked ? `<span class=lgl-note>${esc(L.trackingNotice)}</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>`;
 }
@@ -1363,6 +1376,26 @@ ${gcid ? `<script nonce="${nonce}" src="https://accounts.google.com/gsi/client"
 </body></html>`;
 }
 
+/**
+ * ⚠️ LE VISITEUR EST VENU SOUS UNE MARQUE ; C'EST CELLE-LÀ QU'IL DOIT LIRE.
+ *
+ * Le titre ajoutait le nom de l'INSTANCE — celui de la société qui exploite l'outil. Vrai tant
+ * qu'une instance ne sert qu'un public ; faux dès qu'elle en sert deux, et le visiteur d'une
+ * marque cliente voit alors le nom d'une société qui ne le concerne pas.
+ *
+ * Aucune configuration nouvelle : la marque du lien est DÉJÀ résolue (`brandForShare`, la même
+ * qui habille le loader) et posée sur `share.brand_name` avant qu'on arrive ici. Le titre ne la
+ * consultait simplement pas.
+ *
+ * Le « propulsé par » reste celui de l'instance, lui, et c'est délibéré : dire qui opère l'outil
+ * est une information honnête, pas une trahison de marque.
+ */
+function titreOnglet(share) {
+  const base = share.doc_title || share.file_name || "Document";
+  const marque = String((share && share.brand_name) || "").trim();
+  return marque ? `${base} — ${marque}` : PLAYER.branding.title(base);
+}
+
 function viewerHtml(share, nonce, logoUrl, pitch) {
   const title = esc(share.doc_title || share.file_name || "Document");
   // Aperçu interne : slug vide (= pas de tracking, pas de bouton de re-partage) + stream depuis le bucket public.
@@ -1394,7 +1427,7 @@ function viewerHtml(share, nonce, logoUrl, pitch) {
 <meta name=robots content="noindex,nofollow">
 <link rel=icon href="data:,">
 <link rel=preconnect href="https://cdnjs.cloudflare.com" crossorigin>
-<title>${esc(PLAYER.branding.title(share.doc_title || share.file_name || "Document"))}</title>
+<title>${esc(titreOnglet(share))}</title>
 <style>
   :root{--bg:#33312e;--bar:#26241f}
   *{box-sizing:border-box}
@@ -1582,7 +1615,7 @@ ${LEGAL_CSS}
     ${botOn ? botMarkup(share, pitch) : ""}
   </div>
   ${PLAYER.branding.poweredBy ? `<div class=brand>Propulsé par ${esc(PLAYER.branding.poweredBy)}</div>` : ""}
-  ${legalFooter({ tracked: !preview && !!share.slug })}
+  ${legalFooter({ tracked: !preview && !!share.slug, sansExpediteur: !share.recipient_email && !share.created_by })}
   ${brandLogo || !brandIntroRuntime ? "" : `<script nonce="${nonce}">(${brandIntroRuntime.toString()})();</script>`}
   <script nonce="${nonce}">${PLAYER_BROWSER_JS}</script>
   <script nonce="${nonce}" src="${PDFJS}/pdf.min.js"></script>
@@ -2586,15 +2619,42 @@ async function handler(req, res) {
         try { out = await createReshare(body.slug || slug, { email: mail, name: body.name }); } catch { /* parent introuvable */ }
         if (!out) return j(404, { ok: false });
         let sent = false;
+        let refusEnvoi = null;
         if (body.send) {
           try {
             const parent = await getShareBySlug(body.slug || slug);
+            // ⚠️ ON N'ENVOIE DE COURRIER QUE POUR UN LIEN QUI A UN DESTINATAIRE.
+            //
+            // Le lecteur d'un lien ANONYME est un visiteur quelconque : lui laisser demander un
+            // envoi ferait des serveurs de l'hôte un relais de courrier non sollicité, avec SON
+            // domaine dans l'en-tête. Ce qui coûte cher n'est pas le message parti, c'est la
+            // réputation d'expéditeur : elle met des semaines à revenir, et pendant ce temps
+            // AUCUN de ses emails n'arrive — factures, relances, notifications d'équipe
+            // comprises. Une commodité sur une page publique mettrait en jeu tout son courrier
+            // transactionnel.
+            //
+            // Un lien nominatif, lui, a été créé par quelqu'un qui s'est authentifié et qui
+            // engage sa responsabilité. `recipient_email` est nul sur exactement les liens sans
+            // membre derrière — c'est déjà la clé d'idempotence du chemin serveur à serveur.
+            //
+            // ⚠️ La garde est ICI, sur le chemin qui agit, et pas chez l'hôte à l'arrivée. Un
+            // filtre à l'arrivée dépend d'une liste à jour ; un chemin qui ne sait pas formuler
+            // la demande ne la formulera jamais par accident. Même raison que les trois verrous
+            // de `docshare.create`. Demandé par le second hôte, qui l'a réclamée CHEZ NOUS alors
+            // qu'il aurait pu la poser chez lui.
+            if (!parent || !parent.recipient_email) {
+              refusEnvoi = "no-recipient";
+              throw new Error("envoi réservé aux liens nominatifs");
+            }
             const origin = `https://${req.headers.host}`;
             const r = await sendReshareEmail({ parent, childSlug: out.slug, origin, toEmail: mail, toName: body.name });
             sent = !!(r && r.sent);
           } catch { /* best-effort : le lien existe quand même */ }
         }
-        return j(200, { ok: true, slug: out.slug, sent });
+        // Le refus se DIT : « rien n'est parti » et « l'envoi n'était pas permis » ne se
+        // ressemblent pas, et une interface qui les confond propose un bouton qui ne marchera
+        // jamais.
+        return j(200, { ok: true, slug: out.slug, sent, ...(refusEnvoi ? { sendRefused: refusEnvoi } : {}) });
       }
       const ua0 = req.headers["user-agent"];
       const ip0 = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "";
@@ -2656,7 +2716,7 @@ async function handler(req, res) {
         // muette sur les URL.
         capabilities: [
           "docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth",
-          "host-share",
+          "host-share", "host-mail",
         ],
         // ⚠️ POUR QUELLES ORIGINES cette instance accepte d'être encadrée. Un booléen ne
         // suffisait pas : un hôte a besoin de voir que SON domaine manque, pas seulement que
@@ -2673,6 +2733,7 @@ async function handler(req, res) {
         // possible. Un hôte qui oublie le secret reçoit un 401 qui ressemble à un droit
         // manquant ; ce booléen le lui dit sans qu'il ait à essayer.
         hostShare: !!(PLAYER.config && PLAYER.config.hostShare),
+        hostMail: !!(PLAYER.config && PLAYER.config.hostMail),
         // Greffons de l'hôte : présents ou coupés (PLAYER_PLUGINS_OFF). Booléens uniquement.
         plugins: {
           bot: !!p.bot, visitors: !!p.visitors, brandIntro: !!p.brandIntro,

package/server/shares.js

@@ -43,10 +43,43 @@ async function createReshare(parentSlug, { email, name }) {
   const parent = await getShareBySlug(parentSlug);
   if (!parent) throw Object.assign(new Error("lien introuvable"), { statusCode: 404 });
   const slug = newSlug();
+
+  // ⚠️ ON HÉRITE DE TOUT, ON N'ÉNUMÈRE QUE LES EXCEPTIONS — ET LE SENS DE CETTE INVERSION EST LA
+  // CORRECTION ELLE-MÊME.
+  //
+  // Cette ligne énumérait les colonnes à recopier. Une énumération se périme à chaque colonne
+  // ajoutée, en silence, ET DU MAUVAIS CÔTÉ : la nouveauté est oubliée. Les colonnes de cette
+  // table sont `not null default`, donc l'oubli ne produisait pas un trou — il produisait une
+  // VALEUR PAR DÉFAUT, c'est-à-dire la plus permissive :
+  //
+  //   • `require_auth` (défaut `false`) — un document derrière le mur d'accès, une fois
+  //     re-partagé, s'ouvrait SANS mur. Un destinataire pouvait donc lever la protection en se
+  //     transmettant le document à lui-même. C'est le plus grave, et il n'était pas dans le
+  //     rapport qui a mené ici.
+  //   • `allow_download` (défaut `true`) — le bouton Télécharger revenait sur un document où il
+  //     avait été refusé.
+  //   • `brand_key` — la marque se perdait à l'endroit exact où le document commence à circuler :
+  //     le lecteur d'un document VALONEUF transmettait un lien qui s'ouvre sous une autre marque.
+  //
+  // Aucun de ces trois n'était visible : le lien fonctionne, il est simplement plus permissif que
+  // son parent. Signalé par le second hôte, qui a vu la marque — celle qui SE VOIT — et a supposé
+  // que le reste suivait. Le reste suivait.
+  //
+  // Sens de l'inversion : une colonne ajoutée demain sera héritée sans que personne y pense. Si
+  // c'est une restriction, elle se propage ; si elle ne doit pas l'être, il faudra l'écrire ici,
+  // et ce sera une décision au lieu d'un oubli.
+  //
+  // `created_at` est retiré : la base le pose. `is_test` est hérité — un lien de répétition dont
+  // un enfant compterait dans les vraies statistiques les fausserait.
+  const { created_at: _cree, ...herite } = parent;
   const row = {
-    slug, doc_id: parent.doc_id, doc_title: parent.doc_title, file_url: parent.file_url, file_name: parent.file_name,
-    recipient_email: low(email) || null, recipient_name: (name || "").trim() || null,
-    created_by: parent.recipient_email || parent.created_by || null, parent_slug: parent.slug,
+    ...herite,
+    slug,
+    recipient_email: low(email) || null,
+    recipient_name: (name || "").trim() || null,
+    created_by: parent.recipient_email || parent.created_by || null,
+    parent_slug: parent.slug,
+    revoked: false,
   };
   await PLAYER.db.request("commercial_doc_shares", { method: "POST", headers: { Prefer: "return=minimal" }, body: [row] });
   return { slug, docTitle: parent.doc_title };
@@ -225,7 +258,25 @@ async function sendReshareEmail({ parent, childSlug, origin, toEmail, toName })
     <p style="font-size:13px;color:#777">Vous pouvez répondre directement à cet email pour échanger avec ${e(forwarder)}.</p>
     <p style="font-size:11px;color:#999;margin-top:22px">Propulsé par 3D Discovery — visualisation 3D &amp; visites immersives.</p>
   </div>`;
-  return PLAYER.mail.send({ to: toEmail, subject: `${forwarder} vous recommande : ${title}`, html, replyTo: parent.recipient_email || undefined });
+  // ⚠️ LES CHAMPS STRUCTURÉS ACCOMPAGNENT LE HTML, ILS NE LE REMPLACENT PAS.
+  //
+  // Un hôte qui envoie avec sa propre identité voudra composer avec son gabarit — et surtout
+  // n'y laisser entrer AUCUN texte fourni par l'appelant. Notre HTML, lui, insère `toName` : un
+  // champ libre, échappé mais choisi par qui détient le lien, dans un message signé par l'hôte.
+  // Lui donner les éléments séparés, c'est lui permettre de n'en reprendre aucun.
+  //
+  // Le HTML reste là pour un hôte qui ne veut pas composer : rien ne casse pour l'existant.
+  return PLAYER.mail.send({
+    to: toEmail,
+    subject: `${forwarder} vous recommande : ${title}`,
+    html,
+    replyTo: parent.recipient_email || undefined,
+    kind: "reshare",
+    doc: { title, url },
+    from: { name: parent.recipient_name || null, email: parent.recipient_email || null },
+    // Fourni par l'appelant, donc à traiter comme tel : un hôte prudent l'ignore.
+    untrusted: { toName: (toName || "").trim() || null },
+  });
 }
 
 async function revokeShare(slug) {