@mostajs/smoke 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog — @mostajs/smoke
+## [0.1.0] — 2026-06-22
+### Ajouté
+- Sonde HTTP via node:http (statut réel, sans suivre les redirections) ; `smoke`/`checksFrom`/`waitForHealth` ; expect number|'2xx'/'3xx'|[codes] ; CLI `--wait`. 5 tests. Extrait du smoke-curl de `deploy.sh`.

package/README.md

@@ -0,0 +1,22 @@
+# @mostajs/smoke
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+Sonde HTTP **zéro-dépendance** des routes d'une app (publiques→200, protégées→303/401), **sans suivre les redirections** (node:http — `fetch` en `redirect:'manual'` renverrait un statut 0 « opaqueredirect » et masquerait le 303). Pré-déploiement & test. Membre de `mosta-deploy-stack`.
+
+```js
+// smoke.config.mjs
+export default { health: '/api/health', public: ['/', '/login'], gated: ['/dashboard', '/m/companies'] };
+```
+
+```bash
+mosta-smoke --config smoke.config.mjs --base http://127.0.0.1:7931 --wait
+```
+`--wait` attend que `health` réponde 2xx avant de sonder ; sortie ≠ 0 si une route n'est pas conforme.
+
+## API
+- `smoke({ base, checks?, public?, gated?, publicExpect?, gatedExpect? })` → `{ ok, pass, fail, results }`
+- `checksFrom({ public, gated })` · `waitForHealth(base, path, { timeoutMs })`
+- `expect` accepte un nombre (`200`), une famille (`'2xx'`/`'3xx'`) ou un tableau (`[303,401]`).
+
+Tests : `npm test`. Licence : AGPL-3.0-or-later.

package/bin/cli.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @mostajs/smoke — CLI : sonde les routes d'une app. Author: Dr Hamid MADANI <drmdh@msn.com>
+// Usage : mosta-smoke [--config smoke.config.mjs] [--base URL] [--wait]
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+import { smoke, waitForHealth } from '../src/index.js';
+
+const args = process.argv.slice(2);
+const val = (k, d) => { const i = args.indexOf(k); return i >= 0 ? args[i + 1] : d; };
+const cfgPath = resolve(process.cwd(), val('--config', 'smoke.config.mjs'));
+const mod = await import(pathToFileURL(cfgPath).href).catch((e) => { console.error(`✗ config introuvable : ${cfgPath}\n  ${e.message}`); process.exit(2); });
+const config = { ...(mod.default || mod.config || mod) };
+if (val('--base')) config.base = val('--base');
+
+if (args.includes('--wait')) {
+  const ready = await waitForHealth(config.base, config.health || '/api/health');
+  if (!ready) { console.error(`✗ serveur non prêt (${config.base}${config.health || '/api/health'})`); process.exit(1); }
+}
+const r = await smoke(config);
+for (const x of r.results) if (!x.ok) console.error(`  ✗ ${x.path} → ${x.error || x.code} (attendu ${JSON.stringify(x.expect)})`);
+if (r.ok) console.log(`✓ smoke OK — ${r.pass}/${r.results.length} routes conformes`);
+else console.error(`✗ smoke KO — ${r.fail} route(s) non conforme(s)`);
+process.exit(r.ok ? 0 : 1);

package/llms.txt

@@ -0,0 +1,6 @@
+# @mostajs/smoke
+Sonde HTTP zéro-dép des routes (publiques→200, protégées→303/401), SANS suivre les redirections (node:http, pas fetch). Membre de mosta-deploy-stack.
+## API
+smoke({base, checks?:[{path,expect}], public?, gated?, publicExpect?=200, gatedExpect?=[303,401]}) → {ok,pass,fail,results}
+checksFrom({public,gated}) · waitForHealth(base,path,{timeoutMs}) · expect = number | '2xx'/'3xx' | [codes]
+CLI: mosta-smoke --config smoke.config.mjs --base URL [--wait]

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@mostajs/smoke",
+  "version": "0.1.0",
+  "description": "Sonde HTTP zéro-dépendance des routes d'une app (pré-déploiement / test) : publiques → 200, protégées → 303/401, sans suivre les redirections. Piloté par un manifeste. Membre de mosta-deploy-stack.",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "mosta-smoke": "bin/cli.mjs"
+  },
+  "files": [
+    "src",
+    "bin",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "keywords": [
+    "mostajs",
+    "smoke",
+    "http",
+    "healthcheck",
+    "deploy",
+    "test",
+    "routes"
+  ],
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.3.0"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  }
+}

package/src/index.js

@@ -0,0 +1,63 @@
+// @mostajs/smoke — sonde HTTP zéro-dépendance des routes d'une app (pré-déploiement / test). Author: Dr Hamid MADANI <drmdh@msn.com>
+// Vérifie qu'un ensemble de routes répond avec le code attendu : PUBLIQUES → 200, PROTÉGÉES → 303/401 (gating). Sans suivre les redirections.
+// Remplace les boucles `curl` bespoke des deploy.sh. Membre de mosta-deploy-stack.
+// NB : on utilise node:http/https (pas fetch) — fetch en mode redirect:'manual' renvoie un statut 0 « opaqueredirect » et masque le 303.
+import http from 'node:http';
+import https from 'node:https';
+
+/** GET brut qui NE SUIT PAS les redirections → renvoie le vrai statusCode (200/303/401/…). */
+function get(url, timeoutMs = 8000) {
+  return new Promise((resolve) => {
+    let u; try { u = new URL(url); } catch (e) { return resolve({ status: 0, error: e.message }); }
+    const lib = u.protocol === 'https:' ? https : http;
+    const req = lib.request(u, { method: 'GET' }, (res) => { res.resume(); resolve({ status: res.statusCode }); });
+    req.on('error', (e) => resolve({ status: 0, error: e.message }));
+    req.setTimeout(timeoutMs, () => { req.destroy(); resolve({ status: 0, error: 'timeout' }); });
+    req.end();
+  });
+}
+
+/** Le code `c` satisfait-il l'attente `e` (number | '2xx'/'3xx' | tableau de valeurs acceptées) ? */
+function matches(c, e) {
+  if (Array.isArray(e)) return e.some((x) => matches(c, x));
+  if (typeof e === 'string' && /^\dxx$/.test(e)) return Math.floor(c / 100) === Number(e[0]);
+  return c === Number(e);
+}
+
+/** Construit la liste de checks depuis { public, gated } (raccourci courant). */
+export function checksFrom({ public: pub = [], gated = [], publicExpect = 200, gatedExpect = [303, 401] } = {}) {
+  return [
+    ...pub.map((path) => ({ path, expect: publicExpect })),
+    ...gated.map((path) => ({ path, expect: gatedExpect })),
+  ];
+}
+
+/** Attend que `base+health` réponde 2xx (démarrage serveur). Renvoie true/false. */
+export async function waitForHealth(base, health = '/api/health', { timeoutMs = 10000, intervalMs = 250 } = {}) {
+  const until = Date.now() + timeoutMs;
+  while (Date.now() < until) {
+    const r = await get(base + health, intervalMs + 500);
+    if (Math.floor(r.status / 100) === 2) return true;
+    await new Promise((res) => setTimeout(res, intervalMs));
+  }
+  return false;
+}
+
+/**
+ * Sonde les routes. config = { base, checks?:[{path,expect}], public?:[], gated?:[], publicExpect?, gatedExpect? }.
+ * Ne SUIT PAS les redirections (redirect:'manual') pour distinguer 200 vs 303. Renvoie { ok, pass, fail, results }.
+ */
+export async function smoke(config = {}) {
+  const { base } = config;
+  if (!base) throw new Error('@mostajs/smoke: config.base requis');
+  const checks = config.checks || checksFrom(config);
+  const results = [];
+  for (const { path, expect } of checks) {
+    const r = await get(base + path);
+    results.push({ path, code: r.status, expect, ok: r.error ? false : matches(r.status, expect), error: r.error || null });
+  }
+  const pass = results.filter((r) => r.ok).length;
+  return { ok: pass === results.length, pass, fail: results.length - pass, results };
+}
+
+export default { smoke, checksFrom, waitForHealth };