@mostajs/smtp-lite 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog — @mostajs/smtp-lite
+
+## 0.1.0 — 2026-06-21
+- Première version. Transport SMTP zéro-dépendance (`node:net` + `node:tls`) : 587 STARTTLS + AUTH LOGIN.
+- API : `createSmtpTransport`, `sendMail`, `encodeSubject`, `encodeDisplayName`.
+- Encodage RFC 2047 du `Subject` et du nom d'affichage `From` (corrige les rejets `554 Transaction failed / policy restrictions` sur en-têtes non-ASCII).
+- Lecture SMTP robuste (file d'attente des réponses, timeouts, erreurs socket), dot-stuffing RFC 5321.
+- Extrait du client SMTP initialement écrit inline dans l'app Hadhinat, conformément au principe « le SMTP est un métier → son propre module » ; consommé par `@mostajs/mailer` (driver `smtp-lite`).
+- 4 tests `@mostajs/mjs-unit` verts + validation d'envoi réel (IONOS).

package/README.md

@@ -0,0 +1,30 @@
+# @mostajs/smtp-lite
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · Licence : AGPL-3.0-or-later
+
+Transport SMTP minimal **zéro-dépendance** (uniquement `node:net` + `node:tls`) : soumission sur le port 587 avec **STARTTLS** et **AUTH LOGIN**. Variante « lite » (comme `@mostajs/auth-lite`) pour les apps **zéro-build / vendorisées / WebContainer**, sans `nodemailer` ni addon natif.
+
+> Pour un dispatcher complet multi-drivers (Resend, SES, Postmark, Brevo, logs, idempotence), voir **`@mostajs/mailer`** — qui peut justement **consommer ce module** via son driver `smtp-lite`.
+
+## API
+
+```js
+import { createSmtpTransport, sendMail, encodeSubject } from '@mostajs/smtp-lite';
+
+// Transport réutilisable
+const t = createSmtpTransport({ host: 'smtp.ionos.fr', port: 587, user: 'admin@amia.fr', pass: '***' });
+await t.send({ from: 'admin@amia.fr', fromName: 'Hadhinat', to: 'x@y.z', subject: 'Bonjour', html: '<p>…</p>' });
+
+// Ou en une fois
+await sendMail({ host, port, user, pass }, { from, fromName, to, subject, html, text });
+```
+
+- `createSmtpTransport(server) → { server, send(mail) }`
+- `sendMail(server, mail) → { ok: true }` (throw avec le code SMTP en cas de rejet)
+- `encodeSubject(s)` / `encodeDisplayName(name)` : encodage **RFC 2047** des en-têtes non-ASCII (évite les rejets `554` sur sujets/noms accentués).
+
+## Notes
+
+- Les en-têtes `Subject` et le nom d'affichage `From` sont encodés RFC 2047 si non-ASCII (sinon certains serveurs renvoient `554 Transaction failed`).
+- Dot-stuffing RFC 5321 appliqué au corps.
+- Timeouts (connexion + réponse) et propagation d'erreur socket intégrés.

package/llms.txt

@@ -0,0 +1,20 @@
+# @mostajs/smtp-lite
+
+Transport SMTP zéro-dépendance (node:net+tls, 587 STARTTLS, AUTH LOGIN). Variante "lite" sans nodemailer ni natif, pour apps zéro-build/WebContainer. Auteur : Dr Hamid MADANI <drmdh@msn.com>. AGPL-3.0-or-later.
+
+## Exports (./src/index.js)
+- createSmtpTransport({host,port=587,user,pass}) -> { server, send(mail) }
+- sendMail({host,port,user,pass}, {from,fromName?,to,subject,html?,text?}) -> {ok:true} ; throw avec code SMTP si rejet
+- encodeSubject(s) -> "=?UTF-8?B?...?=" (RFC 2047)
+- encodeDisplayName(name) -> nom d'affichage sûr (encoded-word si non-ASCII, sinon quoted-string)
+
+## Points clés
+- Encodage RFC 2047 du Subject ET du nom d'affichage From -> évite "554 Transaction failed / Reject due to policy restrictions" sur en-têtes accentués (tiret cadratin, é, apostrophe...).
+- Dot-stuffing RFC 5321 du corps.
+- Lecture SMTP robuste : réponses mises en file (pas de race read/data), timeouts, erreurs socket propagées.
+
+## Relation avec @mostajs/mailer
+@mostajs/mailer expose createSmtpLiteDriver() + createMailerFromProcessEnv() qui CONSOMMENT ce module comme driver zéro-dépendance (alternative au driver nodemailer createSmtpDriver).
+
+## Quand l'utiliser
+App Node sans build/npm install (vendorisée), ou contexte WebContainer/edge. Sinon préférer @mostajs/mailer (multi-drivers, persistance, idempotence).

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mostajs/smtp-lite",
+  "version": "0.1.0",
+  "description": "Client SMTP minimal ZÉRO-DÉPENDANCE (node:net+tls, soumission 587 STARTTLS, AUTH LOGIN). Variante « lite » sans natif ni npm (comme @mostajs/auth-lite) pour apps zéro-build / WebContainer. Pour les drivers riches (Resend/SES/Brevo…) voir @mostajs/mailer.",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "keywords": [
+    "mostajs",
+    "smtp",
+    "email",
+    "mailer",
+    "starttls",
+    "zero-dependency",
+    "lite"
+  ],
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.3.0"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  }
+}

package/src/index.js

@@ -0,0 +1,93 @@
+// @mostajs/smtp-lite — transport SMTP minimal ZÉRO-DÉPENDANCE (node:net + node:tls). Author: Dr Hamid MADANI <drmdh@msn.com>
+// Soumission RFC : connexion 587 → EHLO → STARTTLS → EHLO → AUTH LOGIN → MAIL/RCPT/DATA. Aucune dépendance npm, aucun natif.
+// Variante « lite » (cf. @mostajs/auth-lite) pour apps zéro-build / WebContainer. Drivers riches (Resend/SES/Brevo…) : @mostajs/mailer.
+import net from 'node:net';
+import tls from 'node:tls';
+import crypto from 'node:crypto';
+
+// Connexion robuste : les réponses arrivant AVANT read() sont mises en file (pas de race) ; erreurs socket + timeout propagés.
+function smtpConn(sock, timeoutMs = 20000) {
+  let buf = ''; let waiter = null; const queue = []; let failed = null;
+  const flush = () => {
+    const lines = buf.split(/\r?\n/).filter(Boolean);
+    const last = lines[lines.length - 1] || '';
+    if (/^\d{3} /.test(last)) {   // réponse complète = dernière ligne "NNN " (espace après le code)
+      const out = buf; buf = '';
+      if (waiter) { const w = waiter; waiter = null; clearTimeout(w.t); w.res(out); } else queue.push(out);
+    }
+  };
+  sock.on('data', (d) => { buf += d.toString('utf8'); flush(); });
+  sock.on('error', (e) => { failed = e; if (waiter) { const w = waiter; waiter = null; clearTimeout(w.t); w.rej(e); } });
+  const read = () => new Promise((res, rej) => {
+    if (failed) return rej(failed);
+    if (queue.length) return res(queue.shift());
+    const t = setTimeout(() => { waiter = null; rej(new Error('SMTP timeout (pas de réponse)')); }, timeoutMs);
+    waiter = { res, rej, t };
+  });
+  const send = (line) => new Promise((res, rej) => sock.write(line + '\r\n', (e) => (e ? rej(e) : res())));
+  return { read, send };
+}
+const expect = (resp, codes) => {
+  const code = Number((resp.match(/^(\d{3})/) || [])[1]);
+  if (!codes.includes(code)) throw new Error(`SMTP réponse inattendue (${code}): ${resp.trim().slice(0, 200)}`);
+  return code;
+};
+
+/** Encode une valeur d'en-tête non-ASCII en =?UTF-8?B?…?= (RFC 2047). */
+export function encodeSubject(s) { return '=?UTF-8?B?' + Buffer.from(String(s), 'utf8').toString('base64') + '?='; }
+
+/** Nom d'affichage d'adresse : encoded-word si non-ASCII (RFC 2047), sinon "quoted-string". Évite les rejets 554 (en-tête 8-bit). */
+export function encodeDisplayName(name) {
+  if (!name) return '';
+  return /[^\x20-\x7E]/.test(name) ? encodeSubject(name) : '"' + String(name).replace(/["\\]/g, '') + '"';
+}
+
+/**
+ * Envoie un email via SMTP (STARTTLS 587, AUTH LOGIN). Bas niveau, sans état.
+ * @param {{host,port?,user,pass}} server
+ * @param {{from,fromName?,to,subject,html?,text?}} mail
+ */
+export async function sendMail(server, mail) {
+  const { host, port = 587, user, pass } = server || {};
+  const { from, fromName, to, subject, html, text } = mail || {};
+  if (!host || !user || !pass) throw new Error('SMTP non configuré (host/user/pass requis)');
+  if (!to) throw new Error('sendMail: destinataire (to) requis');
+  const plain = net.connect({ host, port });
+  plain.setTimeout(20000, () => plain.destroy(new Error('SMTP timeout (connexion)')));
+  await new Promise((res, rej) => { plain.once('connect', res); plain.once('error', rej); });
+  let c = smtpConn(plain);
+  expect(await c.read(), [220]);
+  await c.send('EHLO mostajs'); expect(await c.read(), [250]);
+  await c.send('STARTTLS'); expect(await c.read(), [220]);
+  const sock = tls.connect({ socket: plain, servername: host });
+  await new Promise((res, rej) => { sock.once('secureConnect', res); sock.once('error', rej); });
+  c = smtpConn(sock);
+  await c.send('EHLO mostajs'); expect(await c.read(), [250]);
+  await c.send('AUTH LOGIN'); expect(await c.read(), [334]);
+  await c.send(Buffer.from(user, 'utf8').toString('base64')); expect(await c.read(), [334]);
+  await c.send(Buffer.from(pass, 'utf8').toString('base64')); expect(await c.read(), [235]);
+  await c.send(`MAIL FROM:<${from || user}>`); expect(await c.read(), [250]);
+  await c.send(`RCPT TO:<${to}>`); expect(await c.read(), [250, 251]);
+  await c.send('DATA'); expect(await c.read(), [354]);
+  const disp = encodeDisplayName(fromName);
+  const headers = [
+    `From: ${disp ? disp + ' ' : ''}<${from || user}>`,
+    `To: <${to}>`,
+    `Subject: ${encodeSubject(subject || '')}`,
+    `Date: ${new Date().toUTCString()}`,
+    `Message-ID: <${crypto.randomBytes(12).toString('hex')}@mostajs>`,
+    'MIME-Version: 1.0',
+    'Content-Type: text/html; charset=utf-8',
+    'Content-Transfer-Encoding: 8bit',
+  ].join('\r\n');
+  const body = (html || text || '').replace(/\r?\n\./g, '\n..');   // dot-stuffing RFC 5321
+  await c.send(headers + '\r\n\r\n' + body + '\r\n.'); expect(await c.read(), [250]);
+  await c.send('QUIT').catch(() => {});
+  try { sock.end(); } catch { /* ignore */ }
+  return { ok: true };
+}
+
+/** Transport réutilisable lié à un serveur SMTP : `createSmtpTransport(server).send(mail)`. */
+export function createSmtpTransport(server) {
+  return { server, send: (mail) => sendMail(server, mail) };
+}