discovery-media-player 0.1.13 → 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: {
       /**
@@ -367,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.13",
+  "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

@@ -2619,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 || "";
@@ -2689,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
@@ -2706,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) {