@salifbiaye/create-boutique 0.6.0 → 0.7.0

package/cli/dist/code.js

@@ -0,0 +1,110 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { shouldCopy } from "./paths.js";
+/**
+ * Code généré d'un projet (storefront/, backend/) :
+ * - fichiers conservés par `update` (retouches du projet) ;
+ * - empreinte de chaque fichier à la génération, pour détecter une modification faite à la main
+ *   avant qu'`update` ne remplace le code (rien n'est plus jamais perdu sans prévenir).
+ */
+/** Chemins (relatifs au projet) que `update` ne remplace jamais. */
+export const KEEP = ["storefront/src/styles/custom.css", "storefront/public/custom"];
+const PARTS = ["storefront", "backend"];
+const MANIFEST = (dir) => path.join(dir, ".create-boutique", "code.json");
+const kept = (rel) => KEEP.some((k) => rel === k || rel.startsWith(`${k}/`));
+function walk(dir, root, out) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!shouldCopy(e.name))
+            continue;
+        const abs = path.join(dir, e.name);
+        const rel = path.relative(root, abs).split(path.sep).join("/");
+        if (kept(rel))
+            continue;
+        if (e.isDirectory())
+            walk(abs, root, out);
+        else
+            out.set(rel, crypto.createHash("sha256").update(fs.readFileSync(abs)).digest("hex"));
+    }
+}
+function hashes(target) {
+    const out = new Map();
+    for (const part of PARTS)
+        walk(path.join(target, part), target, out);
+    return out;
+}
+/** Enregistre l'empreinte du code tel que généré (après create et update). */
+export function writeFingerprint(target, version) {
+    fs.mkdirSync(path.dirname(MANIFEST(target)), { recursive: true });
+    fs.writeFileSync(MANIFEST(target), JSON.stringify({ version, files: Object.fromEntries(hashes(target)) }, null, 2) + "\n");
+}
+/** Fichiers modifiés, ajoutés ou supprimés à la main depuis la génération (known=false : projet sans empreinte). */
+export function localChanges(target) {
+    if (!fs.existsSync(MANIFEST(target)))
+        return { known: false, modified: [], added: [], deleted: [] };
+    const before = new Map(Object.entries(JSON.parse(fs.readFileSync(MANIFEST(target), "utf8")).files));
+    const now = hashes(target);
+    const modified = [...now].filter(([f, h]) => before.has(f) && before.get(f) !== h).map(([f]) => f);
+    const added = [...now.keys()].filter((f) => !before.has(f));
+    const deleted = [...before.keys()].filter((f) => !now.has(f));
+    return { known: true, modified, added, deleted };
+}
+/** Copie des fichiers (chemins relatifs au projet) dans un dossier de sauvegarde, arborescence conservée. */
+export function copyFiles(target, files, to) {
+    for (const rel of files) {
+        const src = path.join(target, rel);
+        if (!fs.existsSync(src))
+            continue;
+        const dst = path.join(to, rel);
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        fs.copyFileSync(src, dst);
+    }
+}
+/** Tous les fichiers du code (projet sans empreinte : on sauvegarde tout, par précaution). */
+export const allCodeFiles = (target) => [...hashes(target).keys()];
+/** Met de côté les chemins conservés, pour les remettre après le remplacement du code. */
+export function stashKept(target, tmp) {
+    const saved = [];
+    for (const rel of KEEP) {
+        const src = path.join(target, rel);
+        if (!fs.existsSync(src))
+            continue;
+        fs.cpSync(src, path.join(tmp, rel), { recursive: true });
+        saved.push(rel);
+    }
+    return saved;
+}
+export function restoreKept(target, tmp, saved) {
+    for (const rel of saved) {
+        const dst = path.join(target, rel);
+        fs.rmSync(dst, { recursive: true, force: true });
+        fs.cpSync(path.join(tmp, rel), dst, { recursive: true });
+    }
+    fs.rmSync(tmp, { recursive: true, force: true });
+}
+/**
+ * custom.css : une section prête à remplir par boutique du projet (ajoutée seulement si elle manque :
+ * ce que le développeur a écrit n'est jamais modifié). Appelé à la création et à chaque apply (ex. add).
+ */
+export function syncCustomCss(target, boutiques) {
+    const file = path.join(target, KEEP[0]);
+    if (!fs.existsSync(file))
+        return;
+    let css = fs.readFileSync(file, "utf8");
+    // Projets créés avant le mode d'emploi : une ligne de renvoi en tête (le reste du fichier n'est pas touché)
+    const pointer = "/* Mode d'emploi complet (plan du site, classes, [data-page], exemples) : storefront/PERSONNALISER.md */\n";
+    const withPointer = css.includes("PERSONNALISER.md") ? css : pointer + css;
+    const missing = boutiques.filter((b) => !css.includes(`[data-boutique="${b.slug}"]`));
+    if (!missing.length) {
+        if (withPointer !== css)
+            fs.writeFileSync(file, withPointer);
+        return;
+    }
+    css = withPointer;
+    for (const b of missing) {
+        css += `\n/* ─────────── Boutique ${b.slug} · thème ${b.theme} · ${b.url} ─────────── */\n[data-boutique="${b.slug}"] {\n  /* ex. --primary: #4a2bd6; */\n}\n`;
+    }
+    fs.writeFileSync(file, css);
+}

package/cli/dist/commands.js

@@ -5,6 +5,8 @@ import pc from "picocolors";
 import { compose, composeOutput, isRunning } from "./docker.js";
 import { readEnv, refreshEnv, writeCampaignFiles, writeCompose, writeReadme } from "./generate.js";
 import { copyTemplate, templateVersion } from "./paths.js";
+import { KEEP, allCodeFiles, copyFiles, syncCustomCss, localChanges, restoreKept, stashKept, writeFingerprint } from "./code.js";
+import * as prompts from "@clack/prompts";
 import { nextFreePort, reservedByOthers, reservePorts } from "./ports.js";
 import { boutiqueUrl, currencies, effective, normalizeUrl, readProject, validateProject, writeJsonSchema, writeProject, ProjectError, SLUG, storePorts } from "./project.js";
 import { listThemes } from "./themes.js";
@@ -63,6 +65,7 @@ export async function apply(dir, opts = { up: true }) {
     if (clash.length)
         throw new ProjectError(`port(s) déjà réservé(s) par un autre projet : ${clash.join(", ")}`);
     writeCampaignFiles(target, p, p.defaults.language);
+    syncCustomCss(target, p.boutiques.map((b) => ({ slug: b.slug, theme: b.theme, url: boutiqueUrl(p, b) })));
     writeJsonSchema(target);
     writeCompose(target, p);
     refreshEnv(target, p);
@@ -248,29 +251,90 @@ export function themes() {
         console.log(`${t.id.padEnd(16)} ${t.name.padEnd(26)} langues : ${t.languages.join(", ")}`);
 }
 // ─────────────────────────── update ───────────────────────────
-/** Remplace storefront/ et backend/ par la version actuelle du template (config, seed, .env et données conservés). */
+/**
+ * Remplace storefront/ et backend/ par la version actuelle du template (config, seed, .env et données conservés).
+ * Conservés aussi : les retouches du projet (KEEP : custom.css, public/custom/).
+ * Code modifié à la main depuis la génération : listé, copié dans backups/<date>-code/, et confirmation demandée.
+ */
 export async function update(dir, opts) {
     const target = path.resolve(dir);
     const p = readProject(target);
     const from = p.templateVersion ?? "?";
     const to = templateVersion();
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const saveDir = path.join(target, "backups", `${stamp}-code`);
+    // Sauvegarde des données avant de changer le code (les migrations d'une nouvelle version touchent la base)
+    if (isRunning(target, "postgres"))
+        backup(target, { label: "avant-update" });
+    else
+        console.log(pc.yellow("!   base arrêtée : pas de sauvegarde automatique avant la mise à jour"));
+    const changes = localChanges(target);
+    if (!changes.known) {
+        // Projet généré avant les empreintes : impossible de savoir ce qui a été modifié, on garde une copie de tout le code
+        copyFiles(target, allCodeFiles(target), saveDir);
+        console.log(pc.yellow(`!   projet sans empreinte du code : copie complète de storefront/ et backend/ dans ${path.relative(target, saveDir)}/ (à comparer si tu avais modifié le code)`));
+    }
+    else {
+        const touched = [...changes.modified, ...changes.added];
+        if (touched.length || changes.deleted.length) {
+            const list = [
+                ...changes.modified.map((f) => `  modifié   ${f}`),
+                ...changes.added.map((f) => `  ajouté    ${f}`),
+                ...changes.deleted.map((f) => `  supprimé  ${f}`),
+            ];
+            console.log(pc.yellow(`\n!   Code modifié à la main depuis la génération (${list.length} fichier(s)) : update va le remplacer.`));
+            console.log(list.slice(0, 40).join("\n") + (list.length > 40 ? `\n  … et ${list.length - 40} autre(s)` : ""));
+            console.log(`    Pour garder une retouche après les mises à jour : la mettre dans ${KEEP.join(" ou ")}.\n`);
+            if (!opts.yes) {
+                if (!process.stdin.isTTY)
+                    throw new ProjectError("code modifié à la main : relancez avec --yes pour mettre à jour quand même (une copie sera faite dans backups/)");
+                const ok = await prompts.confirm({ message: `Mettre à jour quand même ? (copie de ces fichiers dans backups/${stamp}-code/)`, initialValue: false });
+                if (prompts.isCancel(ok) || !ok)
+                    throw new ProjectError("mise à jour annulée : rien n'a été modifié");
+            }
+            copyFiles(target, touched, saveDir);
+            console.log(pc.green(`✔ fichiers modifiés copiés dans ${path.relative(target, saveDir)}/`));
+        }
+    }
+    const tmp = path.join(target, ".create-boutique", "keep-tmp");
+    const saved = stashKept(target, tmp);
     for (const part of ["storefront", "backend"]) {
         fs.rmSync(path.join(target, part), { recursive: true, force: true });
         copyTemplate(part, target);
     }
+    restoreKept(target, tmp, saved);
+    writeFingerprint(target, to);
     p.templateVersion = to;
     writeProject(target, p);
-    console.log(pc.green(`✔ code mis à jour : template ${from} → ${to}`));
+    console.log(pc.green(`✔ code mis à jour : template ${from} → ${to}${saved.length ? ` (conservés : ${saved.join(", ")})` : ""}`));
     await apply(target, { up: false });
     if (opts.up && compose(target, ["up", "-d", "--build", "--remove-orphans"]) !== 0)
         throw new Error("docker compose up --build a échoué");
 }
-// ─────────────────────────── backup ───────────────────────────
-export function backup(dir) {
+// ─────────────────────────── backup / restore ───────────────────────────
+/** Sauvegardes de données (dossiers backups/<date>[-libellé]/ avec database.sql), plus récentes en dernier. */
+function dataBackups(target) {
+    const root = path.join(target, "backups");
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root)
+        .filter((n) => fs.existsSync(path.join(root, n, "database.sql")))
+        .sort();
+}
+/**
+ * Sauvegarde des données : base (database.sql, pg_dump) + images (storage/) dans backups/<date>[-libellé]/.
+ * --keep N : ne garde que les N sauvegardes les plus récentes (les copies de code « -code » ne sont jamais supprimées).
+ * Lancée aussi automatiquement avant `update` et avant `restore`.
+ */
+export function backup(dir, opts = {}) {
     const target = path.resolve(dir);
-    readProject(target);
+    const p = readProject(target);
+    if (!isRunning(target, "postgres"))
+        throw new ProjectError("la base n'est pas démarrée : docker compose up -d, puis relancez la sauvegarde");
     const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    const out = path.join(target, "backups", stamp);
+    const name = opts.label ? `${stamp}-${opts.label}` : stamp;
+    const out = path.join(target, "backups", name);
     fs.mkdirSync(out, { recursive: true });
     const dump = composeOutput(target, ["exec", "-T", "postgres", "pg_dump", "-U", "medusa", "--clean", "--if-exists", "medusa"]);
     if (dump.code !== 0)
@@ -278,8 +342,69 @@ export function backup(dir) {
     fs.writeFileSync(path.join(out, "database.sql"), dump.stdout);
     if (compose(target, ["cp", "storage:/data", path.join(out, "storage")]) !== 0)
         throw new Error("copie des images échouée");
-    console.log(pc.green(`✔ sauvegarde : ${out}`));
-    console.log("Restauration base : docker compose exec -T postgres psql -U medusa medusa < backups/<date>/database.sql");
+    fs.writeFileSync(path.join(out, "info.json"), JSON.stringify({ date: new Date().toISOString(), project: p.project, templateVersion: p.templateVersion, label: opts.label ?? null }, null, 2) + "\n");
+    console.log(pc.green(`✔ sauvegarde : backups/${name}/ (base + images)`));
+    if (opts.keep && opts.keep > 0) {
+        const all = dataBackups(target);
+        for (const old of all.slice(0, Math.max(0, all.length - opts.keep))) {
+            fs.rmSync(path.join(target, "backups", old), { recursive: true, force: true });
+            console.log(`  ancienne sauvegarde supprimée : ${old}`);
+        }
+    }
+    return name;
+}
+/**
+ * Remet la base et les images d'une sauvegarde (la plus récente par défaut, ou --from <nom>).
+ * Fait d'abord une sauvegarde de l'état actuel (« avant-restauration ») : une restauration se défait toujours.
+ */
+export async function restore(dir, opts) {
+    const target = path.resolve(dir);
+    readProject(target);
+    const all = dataBackups(target);
+    if (!all.length)
+        throw new ProjectError("aucune sauvegarde dans backups/ (create-boutique backup .)");
+    const name = opts.from ? all.find((n) => n === opts.from || n.startsWith(opts.from)) : all[all.length - 1];
+    if (!name)
+        throw new ProjectError(`sauvegarde introuvable : ${opts.from}. Disponibles :\n  ${all.join("\n  ")}`);
+    const src = path.join(target, "backups", name);
+    console.log(`Sauvegarde à remettre : backups/${name}/`);
+    console.log(pc.yellow("Tout ce qui a été fait depuis (commandes, produits, campagnes, images) sera remplacé."));
+    if (!opts.yes) {
+        if (!process.stdin.isTTY)
+            throw new ProjectError("restauration : relancez avec --yes pour confirmer");
+        const ok = await prompts.confirm({ message: "Restaurer cette sauvegarde ?", initialValue: false });
+        if (prompts.isCancel(ok) || !ok)
+            throw new ProjectError("restauration annulée : rien n'a été modifié");
+    }
+    // 1. filet de sécurité : l'état actuel
+    backup(target, { label: "avant-restauration" });
+    // 2. plus aucune écriture pendant la restauration
+    compose(target, ["stop", "backend"]);
+    // 3. base
+    const sql = fs.readFileSync(path.join(src, "database.sql"), "utf8");
+    const r = composeOutput(target, ["exec", "-T", "postgres", "psql", "-q", "-v", "ON_ERROR_STOP=1", "-U", "medusa", "medusa"], sql);
+    if (r.code !== 0)
+        throw new Error(`restauration de la base échouée (le backend reste arrêté ; la sauvegarde « avant-restauration » permet de revenir) :\n${r.stderr.slice(-800)}`);
+    console.log(pc.green("✔ base restaurée"));
+    // 4. images : copie, puis propriétaire remis à l'utilisateur du stockage (sinon « File access denied »)
+    if (fs.existsSync(path.join(src, "storage"))) {
+        if (compose(target, ["cp", `backups/${name}/storage/.`, "storage:/data"]) !== 0)
+            throw new Error("restauration des images échouée");
+        const own = composeOutput(target, ["exec", "-T", "-u", "root", "storage", "sh", "-c", "chown -R \"$(stat -c %u:%g /data)\" /data"]);
+        if (own.code !== 0)
+            throw new Error(`droits des images non rétablis : ${own.stderr}`);
+        compose(target, ["restart", "storage"]);
+        console.log(pc.green("✔ images restaurées"));
+    }
+    // 5. relance
+    compose(target, ["up", "-d"]);
+    // Attendre que Docker déclare le backend prêt (migrations + démarrage : jusqu'à quelques minutes)
+    const healthy = () => composeOutput(target, ["ps", "backend", "--format", "{{.Status}}"]).stdout.includes("(healthy)");
+    for (let i = 0; i < 60 && !healthy(); i++)
+        await new Promise((res) => setTimeout(res, 5000));
+    if (!healthy())
+        console.log(pc.yellow("!   le backend n'est pas encore prêt : docker compose logs -f backend"));
+    console.log(pc.green(`✔ restauration terminée (${name}). Pour revenir en arrière : create-boutique restore . --from ${dataBackups(target).filter((n) => n.endsWith("avant-restauration")).pop()}`));
 }
 // ─────────────────────────── campaign export / import ───────────────────────────
 export function campaignExport(dir) {
@@ -392,8 +517,16 @@ export async function check(dir) {
         console.log(pc.yellow("!   Stripe non configuré : paiement manuel uniquement (STRIPE_API_KEY dans .env)"));
     else if (!env.STRIPE_WEBHOOK_SECRET)
         console.log(pc.yellow("!   STRIPE_WEBHOOK_SECRET vide : webhook Stripe à créer (voir README)"));
-    if (!env.RESEND_API_KEY)
-        console.log(pc.yellow("!   RESEND_API_KEY vide : aucun e-mail n'est envoyé aux clients"));
+    if (!env.RESEND_API_KEY && !(env.SMTP_HOST && env.SMTP_USER && env.SMTP_PASS)) {
+        console.log(pc.yellow("!   Ni Resend ni SMTP configuré : aucun e-mail n'est envoyé aux clients (voir README)"));
+    }
+    if (env.NABOOPAY_API_KEY && !env.NABOOPAY_WEBHOOK_SECRET) {
+        console.log(pc.yellow("!   NABOOPAY_WEBHOOK_SECRET vide : les notifications NabooPay sont ignorées (voir README)"));
+    }
+    if (env.PAYTECH_API_KEY && env.PAYTECH_ENV !== "prod")
+        console.log(pc.yellow("!   PayTech en mode test (PAYTECH_ENV=test)"));
+    if (env.PAYDUNYA_MASTER_KEY && env.PAYDUNYA_ENV !== "prod")
+        console.log(pc.yellow("!   PayDunya en mode sandbox (PAYDUNYA_ENV=test)"));
     console.log(pc.dim("    Les commandes de test (check@example.com) peuvent être annulées dans l'admin."));
     if (failed)
         throw new Error(`${failed} boutique(s) en échec`);

package/cli/dist/create.js

@@ -6,9 +6,11 @@ import { z } from "zod";
 import { writeCampaignFiles, writeCompose, writeEnv, writeReadme } from "./generate.js";
 import { writeGuides } from "./guide.js";
 import { copyDir, copyTemplate, templateVersion } from "./paths.js";
+import { syncCustomCss, writeFingerprint } from "./code.js";
 import { nextFreePort, reservedByOthers, reservePorts } from "./ports.js";
-import { normalizeUrl, storePorts, validateProject, writeJsonSchema, writeProject, ProjectError } from "./project.js";
+import { boutiqueUrl, normalizeUrl, storePorts, validateProject, writeJsonSchema, writeProject, ProjectError } from "./project.js";
 import { listThemes, themeIds } from "./themes.js";
+import { askMail, askMobile, mobileSummary } from "./payments.js";
 /** Réponses du CLI : mêmes clés pour les options, le fichier --config et les questions. */
 export const answersSchema = z.object({
     name: z.string().min(1).max(60).optional(),
@@ -30,6 +32,22 @@ export const answersSchema = z.object({
     stripeWhsec: z.string().optional(),
     resendKey: z.string().optional(),
     emailFrom: z.email().optional(),
+    /** E-mails par SMTP (ex. Gmail + mot de passe d'application) si pas de Resend */
+    smtpHost: z.string().optional(),
+    smtpPort: z.number().int().optional(),
+    smtpUser: z.string().optional(),
+    smtpPass: z.string().optional(),
+    /** Paiement mobile (Wave, Orange Money…) : agrégateurs et leurs clés (voir cli/src/payments.ts) */
+    mobile: z.array(z.enum(["paytech", "paydunya", "naboopay"])).optional(),
+    paytechKey: z.string().optional(),
+    paytechSecret: z.string().optional(),
+    paytechEnv: z.enum(["test", "prod"]).optional(),
+    paydunyaMaster: z.string().optional(),
+    paydunyaPrivate: z.string().optional(),
+    paydunyaToken: z.string().optional(),
+    paydunyaEnv: z.enum(["test", "prod"]).optional(),
+    naboopayKey: z.string().optional(),
+    naboopaySecret: z.string().optional(),
     products: z.string().optional(),
     images: z.string().optional(),
     storePort: z.number().int().optional(),
@@ -113,10 +131,14 @@ async function ask(a, dirName, yes) {
         : a.filesUrl;
     const stripePk = a.stripePk ?? (cancelled(await p.text({ message: "Clé Stripe publique (vide = paiement manuel)", placeholder: "pk_test_…", defaultValue: "" })) || undefined);
     const stripeSk = stripePk ? (a.stripeSk ?? (cancelled(await p.password({ message: "Clé Stripe secrète" })) || undefined)) : a.stripeSk;
-    // E-mails clients (confirmation, expédition, mot de passe oublié…) via Resend ; vide = aucun e-mail envoyé.
+    // Paiement mobile (Wave, Orange Money…) : critères de chaque agrégateur expliqués avant le choix
+    const mobile = await askMobile(a, [currency]);
+    // E-mails clients : Resend, SMTP (Gmail…) ou aucun. Déjà donnés en option / --config : pas de question.
+    const mail = a.resendKey || a.smtpHost ? { kind: a.resendKey ? "resend" : "smtp" } : await askMail();
     const resendKey = a.resendKey ??
-        (cancelled(await p.password({ message: "Clé API Resend (vide = aucun e-mail envoyé)", validate: (v) => (!v || v.startsWith("re_") ? undefined : "une clé Resend commence par re_") })) ||
+        (mail.kind !== "resend" ? undefined : cancelled(await p.password({ message: "Clé API Resend (vide = aucun e-mail envoyé)", validate: (v) => (!v || v.startsWith("re_") ? undefined : "une clé Resend commence par re_") })) ||
             undefined);
+    const smtp = "smtp" in mail ? mail.smtp : undefined;
     const emailFrom = resendKey
         ? (a.emailFrom ??
             cancelled(await p.text({
@@ -135,7 +157,7 @@ async function ask(a, dirName, yes) {
     };
     const products = a.products ?? (cancelled(await p.text({ message: "Fichier produits (CSV, optionnel)", defaultValue: "", validate: exists("file") })).trim() || undefined);
     const images = a.images ?? (cancelled(await p.text({ message: "Dossier images (optionnel)", defaultValue: "", validate: exists("dir") })).trim() || undefined);
-    return { ...a, name, email, currency, country, language, mode, apiUrl, filesUrl, themes: chosen, boutiques: extra, stripePk, stripeSk, resendKey, emailFrom, products, images };
+    return { ...a, ...mobile, ...smtp, name, email, currency, country, language, mode, apiUrl, filesUrl, themes: chosen, boutiques: extra, stripePk, stripeSk, resendKey, emailFrom, products, images };
 }
 export async function create(dir, input, opts) {
     const target = path.resolve(dir);
@@ -221,7 +243,8 @@ export async function create(dir, input, opts) {
         `Images : ${proj.urls ? `${proj.urls.files}/medusa` : `http://localhost:${proj.storagePort}/medusa (local : à changer avant la production avec create-boutique urls)`}`,
         `Devise ${a.currency.toUpperCase()} · pays ${a.country.toUpperCase()} · langue ${a.language}`,
         `Paiement : ${a.stripeSk ? "Stripe + manuel" : "manuel (Stripe : non configuré)"}`,
-        `E-mails : ${a.resendKey ? `Resend, depuis ${a.emailFrom ?? "(adresse manquante)"}` : "désactivés (pas de clé Resend)"}`,
+        `E-mails : ${a.resendKey ? `Resend, depuis ${a.emailFrom ?? "(adresse manquante)"}` : a.smtpHost ? `SMTP ${a.smtpHost}${a.smtpUser ? `, depuis ${a.smtpUser}` : ""}${a.smtpPass ? "" : " (mot de passe à mettre dans .env)"}` : "désactivés (Resend ou SMTP à renseigner dans .env)"}`,
+        mobileSummary(a),
         `Catalogue : ${a.products ?? "aucun (à ajouter dans l'admin)"}`,
     ];
     if (opts.yes)
@@ -236,6 +259,8 @@ export async function create(dir, input, opts) {
     // Écriture du projet
     copyTemplate("storefront", target);
     copyTemplate("backend", target);
+    syncCustomCss(target, proj.boutiques.map((b) => ({ slug: b.slug, theme: b.theme, url: boutiqueUrl(proj, b) })));
+    writeFingerprint(target, templateVersion()); // empreinte du code généré : update saura dire ce qui a été modifié à la main
     writeProject(target, proj);
     writeJsonSchema(target);
     fs.mkdirSync(path.join(target, "seed", "images"), { recursive: true });
@@ -251,6 +276,19 @@ export async function create(dir, input, opts) {
         stripeWhsec: a.stripeWhsec,
         resendKey: a.resendKey,
         emailFrom: a.emailFrom,
+        smtpHost: a.smtpHost,
+        smtpPort: a.smtpPort,
+        smtpUser: a.smtpUser,
+        smtpPass: a.smtpPass,
+        paytechKey: a.paytechKey,
+        paytechSecret: a.paytechSecret,
+        paytechEnv: a.paytechEnv,
+        paydunyaMaster: a.paydunyaMaster,
+        paydunyaPrivate: a.paydunyaPrivate,
+        paydunyaToken: a.paydunyaToken,
+        paydunyaEnv: a.paydunyaEnv,
+        naboopayKey: a.naboopayKey,
+        naboopaySecret: a.naboopaySecret,
     });
     writeCompose(target, proj);
     writeReadme(target, proj);
@@ -261,8 +299,17 @@ export async function create(dir, input, opts) {
             console.log(pc.yellow(`Chrome/Edge introuvable : ${path.basename(g.file)} à imprimer en PDF.`));
     }
     const next = `cd ${path.relative(process.cwd(), target) || "."}\ndocker compose up -d`;
+    // Personnaliser : ce qui est conservé par les mises à jour, et ce qui ne l'est pas
+    const custom = [
+        "Personnaliser l'apparence (conservé par create-boutique update) :",
+        '  storefront/src/styles/custom.css : une section par boutique ([data-boutique="<slug>"]) + une commune',
+        "  storefront/PERSONNALISER.md       : mode d'emploi (plan du site page par page, classes, exemples)",
+        "  storefront/public/custom/        : images et polices utilisées par custom.css",
+        "  puis : docker compose up -d --build",
+        "Modifier d'autres fichiers du code reste possible, mais update les remplace (il les liste et les copie dans backups/ avant).",
+    ].join("\n  ");
     if (opts.yes)
-        console.log(`Projet créé : ${target}\nEnsuite :\n  ${next.replace("\n", "\n  ")}\n`);
+        console.log(`Projet créé : ${target}\nEnsuite :\n  ${next.replace("\n", "\n  ")}\n\n  ${custom}\n`);
     else
-        p.outro(`Projet créé. Ensuite :\n\n  ${pc.cyan(next.replace("\n", "\n  "))}\n\n  Mot de passe admin : ADMIN_PASSWORD dans .env (à transmettre à part).`);
+        p.outro(`Projet créé. Ensuite :\n\n  ${pc.cyan(next.replace("\n", "\n  "))}\n\n  Mot de passe admin : ADMIN_PASSWORD dans .env (à transmettre à part).\n\n  ${custom}`);
 }

package/cli/dist/generate.js

@@ -185,9 +185,27 @@ export function writeEnv(dir, p, s) {
         `STRIPE_WEBHOOK_SECRET=${s.stripeWhsec ?? ""}`,
         `STRIPE_PUBLISHABLE_KEY=${s.stripePk ?? ""}`,
         "",
-        "# E-mails (Resend ; vide = aucun e-mail envoyé)",
+        "# E-mails : Resend (prioritaire) OU un serveur SMTP ; les deux vides = aucun e-mail envoyé",
         `RESEND_API_KEY=${s.resendKey ?? ""}`,
         `EMAIL_FROM=${s.emailFrom ?? ""}`,
+        "# SMTP, ex. Gmail : SMTP_HOST=smtp.gmail.com, SMTP_PORT=465, SMTP_USER=adresse gmail, SMTP_PASS=mot de passe d'application",
+        `SMTP_HOST=${s.smtpHost ?? ""}`,
+        `SMTP_PORT=${s.smtpPort ?? 465}`,
+        `SMTP_USER=${s.smtpUser ?? ""}`,
+        `SMTP_PASS=${s.smtpPass ?? ""}`,
+        "",
+        "# Paiement Wave / Orange Money / carte (Afrique de l'Ouest, devise XOF). Vide = désactivé. Après modification :",
+        "# docker compose restart backend. Webhooks : voir README (section Paiement mobile).",
+        `PAYTECH_API_KEY=${s.paytechKey ?? ""}`,
+        `PAYTECH_API_SECRET=${s.paytechSecret ?? ""}`,
+        `PAYTECH_ENV=${s.paytechEnv ?? "test"}`,
+        `PAYDUNYA_MASTER_KEY=${s.paydunyaMaster ?? ""}`,
+        `PAYDUNYA_PRIVATE_KEY=${s.paydunyaPrivate ?? ""}`,
+        `PAYDUNYA_TOKEN=${s.paydunyaToken ?? ""}`,
+        `PAYDUNYA_ENV=${s.paydunyaEnv ?? "test"}`,
+        `NABOOPAY_API_KEY=${s.naboopayKey ?? ""}`,
+        `NABOOPAY_WEBHOOK_SECRET=${s.naboopaySecret ?? ""}`,
+        "NABOOPAY_METHODS=wave,orange_money",
         "",
         "# Dérivé de config/project.json (réécrit par `create-boutique apply`)",
         ...Object.entries(derivedEnv(p)).map(([k, v]) => `${k}=${v}`),
@@ -269,13 +287,28 @@ export function campaignDates(theme, now = new Date()) {
                 return [new Date(Date.UTC(y, 11, 1)), day(new Date(Date.UTC(y, 11, 24)), 0, true)];
             case "nouvel-an":
                 return [new Date(Date.UTC(y, 11, 26)), day(new Date(Date.UTC(y + 1, 0, 2)), 0, true)];
+            // Saison d'été (solstice → fin août) ; Jeux et sport : l'été sportif (mi-juillet → fin août)
+            case "summer":
+                return [new Date(Date.UTC(y, 5, 21)), day(new Date(Date.UTC(y, 7, 31)), 0, true)];
+            case "jeux":
+            case "sport":
+                return [new Date(Date.UTC(y, 6, 15)), day(new Date(Date.UTC(y, 7, 31)), 0, true)];
+            // Ramadan → 2 jours après l'Aïd el-Fitr (Korité). Calendrier lunaire : dates approximatives (± 1 jour selon
+            // l'observation de la lune), à ajuster dans l'admin ; pour la Tabaski, le client change simplement les dates.
+            case "mubarak": {
+                const ramadan = {
+                    2027: [1, 8, 2, 11], 2028: [0, 28, 2, 1], 2029: [0, 16, 1, 17], 2030: [0, 6, 1, 7],
+                };
+                const r = ramadan[y];
+                return r ? [new Date(Date.UTC(y, r[0], r[1])), day(new Date(Date.UTC(y, r[2], r[3])), 0, true)] : null;
+            }
             default:
                 return null;
         }
     };
     let range = build(now.getUTCFullYear());
-    if (range && range[1] < now)
-        range = build(now.getUTCFullYear() + 1);
+    if (!range || range[1] < now)
+        range = build(now.getUTCFullYear() + 1) ?? range;
     if (!range)
         range = [day(now), day(now, 30, true)];
     return { startsAt: range[0].toISOString(), endsAt: range[1].toISOString() };
@@ -373,13 +406,41 @@ create-boutique backup .    # sauvegarde base + images dans backups/<date>/
    puis copier le secret \`whsec_…\` dans \`STRIPE_WEBHOOK_SECRET\` et \`docker compose restart backend\`.
 4. Apple Pay : déclarer les domaines des boutiques dans Stripe → Paramètres → Moyens de paiement.
 
+## Paiement mobile : Wave, Orange Money, carte (PayTech, PayDunya, NabooPay)
+
+Pour les boutiques en **XOF** (FCFA ; PayTech accepte aussi EUR et USD). Le client choisit « Wave, Orange Money… »,
+paie sur la page sécurisée de l'agrégateur, puis revient sur la boutique. Le montant est toujours calculé par le backend.
+
+1. Créer un compte chez l'agrégateur choisi et récupérer ses clés (de test d'abord) :
+   - **PayTech** (paytech.sn) : \`PAYTECH_API_KEY\`, \`PAYTECH_API_SECRET\` ; \`PAYTECH_ENV=test\` (débite 100 à 150 FCFA) puis \`prod\`.
+   - **PayDunya** (paydunya.com) : \`PAYDUNYA_MASTER_KEY\`, \`PAYDUNYA_PRIVATE_KEY\`, \`PAYDUNYA_TOKEN\` ; \`PAYDUNYA_ENV=test\` (sandbox) puis \`prod\`.
+   - **NabooPay** (naboopay.com) : \`NABOOPAY_API_KEY\` ; \`NABOOPAY_METHODS=wave,orange_money\`.
+2. Les écrire dans \`.env\` (jamais ailleurs), puis \`docker compose restart backend\` : le moyen apparaît au paiement.
+3. Notifications (le paiement est confirmé même si le client ferme la page) : le backend doit être en ligne en HTTPS.
+   - PayTech et PayDunya : rien à faire, l'adresse est envoyée à chaque paiement
+     (\`<adresse du backend>/hooks/payment/paytech_paytech\`, \`…/paydunya_paydunya\`).
+   - NabooPay : tableau de bord → Paramètres → Intégration, webhook \`<adresse du backend>/hooks/payment/naboopay_naboopay\`,
+     puis copier son secret dans \`NABOOPAY_WEBHOOK_SECRET\` et \`docker compose restart backend\`.
+4. Remboursement : PayTech et NabooPay depuis l'admin (remboursement total) ; PayDunya dans son tableau de bord, puis
+   « Remboursement » dans l'admin pour l'enregistrer (guide client, section 4.3).
+5. Test PayTech (\`PAYTECH_ENV=test\`) : pas de simulation, chaque paiement débite vraiment 100 à 150 FCFA sur le compte
+   du testeur, reçus sur le solde PayTech de la boutique (moins les frais).
+
+## E-mails sans Resend : SMTP (ex. Gmail)
+
+Si \`RESEND_API_KEY\` est vide, les e-mails partent par le serveur SMTP du \`.env\`. Avec Gmail :
+1. Compte Google → Sécurité → validation en deux étapes activée → **Mots de passe des applications** → en créer un.
+2. \`.env\` : \`SMTP_HOST=smtp.gmail.com\`, \`SMTP_PORT=465\`, \`SMTP_USER=adresse@gmail.com\`, \`SMTP_PASS=<mot de passe d'application>\`,
+   \`EMAIL_FROM\` vide (l'adresse Gmail est utilisée), puis \`docker compose restart backend\`.
+3. Limite Gmail : environ 500 e-mails par jour. Au-delà, ou pour un domaine à la marque : Resend, Brevo, Mailjet (SMTP aussi).
+
 ## Avant de livrer : checklist
 
 - [ ] Chaque boutique s'ouvre à son adresse, avec son thème et sa devise.
 - [ ] Chaque produit a un prix dans la devise de chaque boutique où il est vendu.
 - [ ] Logo, textes et dates de chaque campagne vérifiés (Admin → Campagnes).
 - [ ] Stripe configuré (clés + webhook) ou paiement manuel assumé.
-- [ ] E-mails : \`RESEND_API_KEY\` renseignée, une commande test reçue par le client et le marchand.
+- [ ] E-mails : Resend ou SMTP renseigné, une commande test reçue par le client et le marchand.
 - [ ] Une commande test passée dans chaque boutique (\`create-boutique check .\`).
 - [ ] Sauvegarde programmée (\`create-boutique backup .\`).
 

package/cli/dist/guide.js

@@ -27,6 +27,14 @@ function render(source, out, dir, vars) {
     let html = fs.readFileSync(source, "utf8");
     for (const [k, v] of Object.entries(vars))
         html = html.split(`{{${k}}}`).join(k.endsWith("_HTML") ? v : escapeHtml(v) || " ");
+    // Captures d'écran (docs/guide-images) intégrées au fichier : le PDF n'a besoin de rien à côté
+    html = html.replace(/src="guide-images\/([\w.-]+)"/g, (m, name) => {
+        const file = path.join(path.dirname(source), "guide-images", name);
+        if (!fs.existsSync(file))
+            return m;
+        const type = name.endsWith(".png") ? "image/png" : "image/jpeg";
+        return `src="data:${type};base64,${fs.readFileSync(file).toString("base64")}"`;
+    });
     const htmlFile = path.join(dir, `${out}.html`);
     const pdfFile = path.join(dir, `${out}.pdf`);
     fs.writeFileSync(htmlFile, html);
@@ -48,7 +56,7 @@ function render(source, out, dir, vars) {
  */
 export function writeGuides(dir, p, adminEmail, support = "") {
     const fr = p.defaults.language === "fr";
-    const adminUrl = `http://localhost:${p.apiPort}/app`;
+    const adminUrl = `${p.urls?.api ?? `http://localhost:${p.apiPort}`}/app`;
     const stores = p.boutiques
         .map((b) => {
         const e = effective(p, b);
@@ -58,7 +66,7 @@ export function writeGuides(dir, p, adminEmail, support = "") {
     const vars = {
         ADMIN_URL: adminUrl,
         ADMIN_EMAIL: adminEmail,
-        SUPPORT: support,
+        SUPPORT: support || "l'équipe qui a créé votre boutique",
         PROJECT: p.project,
         STORE_NAME: p.defaults.storeName,
         CURRENCIES: currencies(p).map((c) => c.toUpperCase()).join(", "),