@salifbiaye/create-boutique 0.5.0 → 0.7.0

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 { 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(),
@@ -18,11 +20,34 @@ export const answersSchema = z.object({
     language: z.string().regex(/^[a-z]{2}$/).optional(),
     themes: z.union([z.literal("all"), z.array(z.string())]).optional(),
     boutiques: z.array(z.string().regex(/^[a-z0-9-]+:[a-z0-9-]+$/, "format slug:thème")).optional(),
+    /** multi : un site par boutique ; single : un seul site, la boutique active se choisit dans l'admin */
+    mode: z.enum(["multi", "single"]).optional(),
+    /** Production : domaines publics de l'admin/API et des images (le CLI ajoute /medusa pour les images) */
+    apiUrl: z.string().optional(),
+    filesUrl: z.string().optional(),
+    /** Mode single : domaine du site */
+    siteUrl: z.string().optional(),
     stripePk: z.string().optional(),
     stripeSk: z.string().optional(),
     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(),
@@ -88,12 +113,32 @@ async function ask(a, dirName, yes) {
             extra.push(`${slug}:${theme}`);
         }
     }
+    const mode = a.mode ??
+        cancelled(await p.select({
+            message: "Sites",
+            options: [
+                { value: "multi", label: "Un site par boutique", hint: "toutes en ligne, chacune sur son port / domaine" },
+                { value: "single", label: "Un seul site", hint: "une boutique en ligne à la fois, choisie dans l'admin → Campagnes" },
+            ],
+            initialValue: "multi",
+        }));
+    // Adresses publiques (production) : inscrites dans les images importées, donc à donner avant le premier démarrage
+    const apiUrl = a.apiUrl ??
+        (cancelled(await p.text({ message: "Domaine de l'admin / API en production (vide = test en local)", placeholder: "https://admin.marque.com", defaultValue: "" })).trim() ||
+            undefined);
+    const filesUrl = apiUrl
+        ? (a.filesUrl ?? cancelled(await p.text({ message: "Domaine des images (juste le domaine, /medusa est ajouté)", placeholder: "https://images.marque.com", validate: (v) => (v?.trim() ? undefined : "obligatoire avec le domaine de l'admin") })).trim())
+        : 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({
@@ -112,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, 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);
@@ -144,19 +189,39 @@ export async function create(dir, input, opts) {
     taken.add(apiPort);
     const storagePort = await nextFreePort(a.storagePort ?? 9100, taken);
     taken.add(storagePort);
+    const mode = a.mode ?? "multi";
     let nextStore = a.storePort ?? 8001;
     const boutiques = [];
-    for (const w of wanted) {
-        const port = await nextFreePort(nextStore, taken);
-        taken.add(port);
-        nextStore = port + 1;
-        boutiques.push({ slug: w.slug, theme: w.theme, port });
+    let site;
+    if (mode === "single") {
+        // Un seul site : un port pour tout le projet, les boutiques n'en ont pas
+        site = { port: await nextFreePort(nextStore, taken) };
+        taken.add(site.port);
+        for (const w of wanted)
+            boutiques.push({ slug: w.slug, theme: w.theme });
+    }
+    else {
+        for (const w of wanted) {
+            const port = await nextFreePort(nextStore, taken);
+            taken.add(port);
+            nextStore = port + 1;
+            boutiques.push({ slug: w.slug, theme: w.theme, port });
+        }
     }
+    // Adresses publiques : les deux ensemble (les images importées gardent l'adresse du stockage)
+    if (!!a.apiUrl !== !!a.filesUrl)
+        throw new ProjectError("--api-url et --files-url vont ensemble (domaine de l'admin et domaine des images)");
+    const urls = a.apiUrl && a.filesUrl ? { api: normalizeUrl(a.apiUrl, "--api-url"), files: normalizeUrl(a.filesUrl, "--files-url") } : undefined;
+    if (site && a.siteUrl)
+        Object.assign(site, { url: normalizeUrl(a.siteUrl, "--site-url") });
     const proj = validateProject({
         project,
         templateVersion: templateVersion(),
         apiPort,
         storagePort,
+        mode,
+        ...(site ? { site } : {}),
+        ...(urls ? { urls } : {}),
         defaults: {
             storeName: a.name,
             currency: a.currency,
@@ -171,11 +236,15 @@ export async function create(dir, input, opts) {
     // Récapitulatif
     const width = Math.max(...proj.boutiques.map((b) => b.slug.length)) + 2;
     const lines = [
-        ...proj.boutiques.map((b) => `${b.slug.padEnd(width)}${b.theme.padEnd(16)}→ http://localhost:${b.port}`),
-        `${"Backend / admin".padEnd(width + 16)}→ http://localhost:${proj.apiPort}/app`,
+        ...(proj.mode === "single"
+            ? [`Site unique → http://localhost:${proj.site.port} (boutique en ligne choisie dans admin → Campagnes ; au départ : ${proj.boutiques[0].slug})`, ...proj.boutiques.map((b) => `  ${b.slug.padEnd(width)}${b.theme}`)]
+            : proj.boutiques.map((b) => `${b.slug.padEnd(width)}${b.theme.padEnd(16)}→ http://localhost:${b.port}`)),
+        `${"Backend / admin".padEnd(width + 16)}→ ${proj.urls ? `${proj.urls.api}/app` : `http://localhost:${proj.apiPort}/app`}`,
+        `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)
@@ -190,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 });
@@ -205,18 +276,40 @@ 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);
     fs.writeFileSync(path.join(target, ".gitignore"), ".env\nbackups/\nnode_modules/\n");
-    reservePorts(target, [proj.apiPort, proj.storagePort, ...proj.boutiques.map((b) => b.port)]);
+    reservePorts(target, [proj.apiPort, proj.storagePort, ...storePorts(proj)]);
     for (const g of writeGuides(target, proj, a.email)) {
         if (!g.pdf)
             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

@@ -1,18 +1,19 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { currencies, effective } from "./project.js";
+import { boutiqueUrl, currencies, effective, fronts } from "./project.js";
 const secret = () => crypto.randomBytes(32).toString("base64url");
 // ─────────────────────────── docker-compose.yml ───────────────────────────
-/** Production (urls présent) : ports des containers seulement sur 127.0.0.1, Caddy seul exposé (80/443). */
+/** Production (urls présent) : ports seulement sur 127.0.0.1 ; ton reverse proxy (Caddy, Nginx…) sur la machine les expose en https. */
 const bind = (p, port) => (p.urls ? `127.0.0.1:${port}` : String(port));
 const host = (url) => new URL(url).host;
 export function composeYaml(p) {
-    const services = p.boutiques
-        .map((b) => `  storefront-${b.slug}:
+    // Mode single : un seul service, BOUTIQUE=auto (il affiche la boutique active, choisie dans l'admin)
+    const services = fronts(p)
+        .map((f) => `  ${f.service}:
     <<: *storefront
-    ports: ["${bind(p, b.port)}:8000"]
-    environment: { <<: *storefront-env, BOUTIQUE: ${b.slug} }
+    ports: ["${bind(p, f.port)}:8000"]
+    environment: { <<: *storefront-env, BOUTIQUE: ${f.boutique} }
 `)
         .join("\n");
     return `# GÉNÉRÉ par create-boutique à partir de config/project.json — ne pas modifier à la main.
@@ -51,6 +52,7 @@ ${services}
     volumes:
       - ./config:/app/config:ro    # boutiques, devises, pays → régions, sales channels, clés
       - ./seed:/app/seed:ro        # products.csv + images à importer
+      - ./storefront/themes:/app/themes:ro   # textes par défaut des thèmes (pré-remplis dans admin → Campagnes)
       - keys:/app/keys             # y écrit la publishable key de chaque boutique
     depends_on:
       postgres: { condition: service_healthy }
@@ -94,53 +96,59 @@ ${services}
       test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:9000/health >/dev/null || exit 1"]
       interval: 5s
       retries: 20
-${p.urls ? caddyService : ""}
 volumes:
   pg_data:
   redis_data:
   storage_data:
-  keys:${p.urls ? "\n  caddy_data:\n  caddy_config:" : ""}
+  keys:
 `;
 }
-const caddyService = `
-  # ───────── Production : https automatique (Let's Encrypt), un domaine par boutique ─────────
-  caddy:
-    image: caddy:2-alpine
-    restart: unless-stopped
-    ports: ["80:80", "443:443"]
-    volumes:
-      - ./Caddyfile:/etc/caddy/Caddyfile:ro
-      - caddy_data:/data
-      - caddy_config:/config
-    depends_on:
-      backend: { condition: service_healthy }
-`;
-/** Caddyfile (production) : chaque domaine vers son container ; certificats https obtenus et renouvelés par Caddy. */
+/**
+ * Exemple de Caddyfile (production) : le CLI ne lance aucun reverse proxy, c'est toi qui le gères sur la machine.
+ * Ce fichier n'est utilisé par rien : il montre quel domaine envoyer vers quel port (127.0.0.1).
+ */
 export function caddyfile(p) {
-    const site = (url, upstream) => `${host(url)} {
+    const site = (url, port) => `${host(url)} {
 	encode zstd gzip
-	reverse_proxy ${upstream}
+	reverse_proxy 127.0.0.1:${port}
 }
 `;
     return [
-        "# GÉNÉRÉ par create-boutique à partir de config/project.json — ne pas modifier à la main.",
-        ...p.boutiques.filter((b) => b.url).map((b) => site(b.url, `storefront-${b.slug}:8000`)),
-        site(p.urls.api, "backend:9000"),
-        site(p.urls.files, "storage:9000"),
+        "# EXEMPLE généré par create-boutique (non utilisé) : à recopier dans ton propre Caddyfile, puis recharger Caddy.",
+        "# Régénéré à chaque apply / urls à partir de config/project.json.",
+        ...fronts(p).filter((f) => f.url).map((f) => site(f.url, f.port)),
+        site(p.urls.api, p.apiPort),
+        // Images : lecture seule des fichiers du bucket (GET /medusa/…), tout le reste 404 (ni liste, ni écriture, ni console)
+        `${host(p.urls.files)} {
+	encode zstd gzip
+	@read {
+		method GET HEAD
+		path /medusa/*
+	}
+	handle @read {
+		reverse_proxy 127.0.0.1:${p.storagePort}
+	}
+	respond 404
+}
+`,
     ].join("\n");
 }
-/** Écrit docker-compose.yml (+ Caddyfile en production, supprimé sinon). */
+/** Écrit docker-compose.yml (+ Caddyfile.exemple en production). */
 export function writeCompose(dir, p) {
     fs.writeFileSync(path.join(dir, "docker-compose.yml"), composeYaml(p));
-    const file = path.join(dir, "Caddyfile");
+    // Ancien Caddyfile généré par une version précédente (service caddy retiré) : supprimé ; un Caddyfile à toi n'est jamais touché
+    const old = path.join(dir, "Caddyfile");
+    if (fs.existsSync(old) && fs.readFileSync(old, "utf8").startsWith("# GÉNÉRÉ par create-boutique"))
+        fs.rmSync(old);
+    const example = path.join(dir, "Caddyfile.exemple");
     if (p.urls)
-        fs.writeFileSync(file, caddyfile(p));
-    else if (fs.existsSync(file))
-        fs.rmSync(file);
+        fs.writeFileSync(example, caddyfile(p));
+    else if (fs.existsSync(example))
+        fs.rmSync(example);
 }
 /** Variables qui dépendent de project.json (réécrites à chaque apply). Les secrets ne sont jamais régénérés. */
 function derivedEnv(p) {
-    const origins = p.boutiques.map((b) => b.url ?? `http://localhost:${b.port}`);
+    const origins = fronts(p).map((f) => f.url ?? `http://localhost:${f.port}`);
     const trim = (u) => u.replace(/\/+$/, "");
     const admin = trim(p.urls?.api ?? `http://localhost:${p.apiPort}`);
     const files = trim(p.urls?.files ?? `http://localhost:${p.storagePort}`);
@@ -177,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}`),
@@ -261,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() };
@@ -309,7 +350,7 @@ export function writeReadme(dir, p) {
     const rows = p.boutiques
         .map((b) => {
         const e = effective(p, b);
-        return `| ${b.slug} | ${b.theme} | ${e.currency.toUpperCase()} | http://localhost:${b.port} |`;
+        return `| ${b.slug} | ${b.theme} | ${e.currency.toUpperCase()} | ${boutiqueUrl(p, b)} |`;
     })
         .join("\n");
     const text = `# ${p.defaults.storeName} — projet \`${p.project}\`
@@ -365,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

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { PACKAGE_ROOT } from "./paths.js";
-import { currencies, effective } from "./project.js";
+import { boutiqueUrl, currencies, effective } from "./project.js";
 const escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 /** Chrome / Edge / Chromium installé (CHROME_PATH prioritaire). */
 function findBrowser() {
@@ -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) || "&nbsp;");
+    // 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,17 +56,17 @@ 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);
-        return `<tr><td>${escapeHtml(e.storeName)}</td><td><code>${escapeHtml(b.slug)}</code></td><td>${escapeHtml(b.theme)}</td><td>${e.currency.toUpperCase()}</td><td>${escapeHtml(b.url ?? `http://localhost:${b.port}`)}</td></tr>`;
+        return `<tr><td>${escapeHtml(e.storeName)}</td><td><code>${escapeHtml(b.slug)}</code></td><td>${escapeHtml(b.theme)}</td><td>${e.currency.toUpperCase()}</td><td>${escapeHtml(boutiqueUrl(p, b))}</td></tr>`;
     })
         .join("");
     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(", "),

package/cli/dist/index.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import { parseArgs } from "node:util";
 import pc from "picocolors";
 import { z } from "zod";
-import { add, admin, apply, backup, campaignExport, campaignImport, check, guide, remove, set, stripeWebhook, themes, update } from "./commands.js";
+import { add, admin, apply, urls, backup, restore, campaignExport, campaignImport, check, guide, remove, set, stripeWebhook, themes, update } from "./commands.js";
 import { answersSchema, create } from "./create.js";
 import { ProjectError } from "./project.js";
 const HELP = `create-boutique — Usine à Boutiques
@@ -14,28 +14,38 @@ const HELP = `create-boutique — Usine à Boutiques
     --currency usd            (défaut usd)     --country us (défaut us)     --language en (défaut en)
     --themes a,b,c | all      une boutique par thème, slug = <dossier>-<thème>
     --boutique <slug>:<thème> ajoute une boutique au nom choisi (répétable)
+    --api-url <domaine>  --files-url <domaine>   production : domaines de l'admin et des images (avant le 1er démarrage)
+    --site-url <domaine>      mode single : domaine du site
+    --mode multi|single       multi (défaut) : un site par boutique ; single : un seul site, boutique active choisie dans l'admin
     --stripe-pk / --stripe-sk / --stripe-whsec   clés Stripe (optionnelles)
-    --resend-key / --email-from                  e-mails (optionnels)
+    --resend-key / --email-from                  e-mails par Resend (optionnels)
+    --smtp-host smtp.gmail.com --smtp-user <adresse>   e-mails par SMTP (mot de passe : SMTP_PASS dans .env)
+    --mobile paytech,paydunya,naboopay           paiement Wave / Orange Money (clés dans .env ; détails : create-boutique sans --yes)
     --products <csv>  --images <dossier>         catalogue (optionnel)
     --store-port 8001  --api-port 9000  --storage-port 9100   premiers ports essayés
     --config <fichier.json>   toutes les options dans un fichier (mêmes clés, en camelCase)
     --yes                     aucune question, valeurs par défaut
 
   create-boutique apply <dossier> [--no-up]        applique config/project.json
+  create-boutique urls <dossier> [--api-url …] [--files-url …] [--site-url …] [--from <ancienne adresse des images>]
+                                                   change les domaines publics ; réécrit l'adresse des images déjà en base
   create-boutique add <dossier> --boutique <slug>:<thème>
   create-boutique remove <dossier> --boutique <slug>
+  create-boutique set <dossier> [--mode multi|single]   change de mode (un site par boutique ↔ un seul site)
   create-boutique set <dossier> [--boutique <slug>] [--name …] [--theme …] [--currency …] [--country …] [--language …]
   create-boutique themes                           liste les thèmes
-  create-boutique update <dossier> [--no-up]       met à jour le code (config, .env, données conservés)
+  create-boutique update <dossier> [--no-up] [--yes]   met à jour le code (config, .env, données, custom.css conservés ;
+                                                   code modifié à la main : listé, copié dans backups/, confirmation)
   create-boutique check <dossier>                  commande test dans chaque boutique
-  create-boutique backup <dossier>                 base + images dans backups/<date>/
+  create-boutique backup <dossier> [--keep 7]      base + images dans backups/<date>/ (--keep : garde les N plus récentes)
+  create-boutique restore <dossier> [--from <nom>] [--yes]   remet une sauvegarde (la plus récente par défaut)
   create-boutique admin <dossier>                  adresse, e-mail et mot de passe de l'admin
   create-boutique guide <dossier>                  régénère GUIDE-CLIENT.pdf et GUIDE-COMPLET.pdf
   create-boutique stripe-webhook <dossier> --url https://api.marque.com   crée le webhook Stripe, écrit STRIPE_WEBHOOK_SECRET
   create-boutique campaign export <dossier>        campagnes en base → config/campaigns/*.json
   create-boutique campaign import <dossier> [--boutique <slug>] [--yes]   JSON → base (écrase)
 `;
-const COMMANDS = new Set(["apply", "add", "remove", "set", "themes", "update", "check", "backup", "campaign", "admin", "guide", "stripe-webhook", "help"]);
+const COMMANDS = new Set(["restore", "urls", "apply", "add", "remove", "set", "themes", "update", "check", "backup", "campaign", "admin", "guide", "stripe-webhook", "help"]);
 async function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
@@ -48,11 +58,20 @@ async function main() {
             themes: { type: "string" },
             boutique: { type: "string", multiple: true },
             theme: { type: "string" },
+            mode: { type: "string" },
+            "api-url": { type: "string" },
+            "files-url": { type: "string" },
+            "site-url": { type: "string" },
+            from: { type: "string" },
+            keep: { type: "string" },
             "stripe-pk": { type: "string" },
             "stripe-sk": { type: "string" },
             "stripe-whsec": { type: "string" },
             "resend-key": { type: "string" },
             "email-from": { type: "string" },
+            "smtp-host": { type: "string" },
+            "smtp-user": { type: "string" },
+            mobile: { type: "string" },
             products: { type: "string" },
             images: { type: "string" },
             "store-port": { type: "string" },
@@ -88,11 +107,18 @@ async function main() {
             language: lower(values.language),
             themes: values.themes === "all" ? "all" : values.themes?.split(",").map((s) => s.trim()).filter(Boolean),
             boutiques: values.boutique,
+            mode: lower(values.mode),
+            apiUrl: values["api-url"],
+            filesUrl: values["files-url"],
+            siteUrl: values["site-url"],
             stripePk: values["stripe-pk"],
             stripeSk: values["stripe-sk"],
             stripeWhsec: values["stripe-whsec"],
             resendKey: values["resend-key"],
             emailFrom: values["email-from"],
+            smtpHost: values["smtp-host"],
+            smtpUser: values["smtp-user"],
+            mobile: values.mobile ? values.mobile.split(",").map((m) => m.trim()).filter(Boolean) : undefined,
             products: values.products,
             images: values.images,
             storePort: port(values["store-port"]),
@@ -104,6 +130,8 @@ async function main() {
     switch (first) {
         case "apply":
             return apply(dirArg(), up);
+        case "urls":
+            return urls(dirArg(), { api: values["api-url"], files: values["files-url"], site: values["site-url"], from: values.from }, up);
         case "add":
             return add(dirArg(), values.boutique ?? [], up);
         case "remove":
@@ -118,15 +146,18 @@ async function main() {
                 currency: lower(values.currency),
                 country: lower(values.country),
                 language: lower(values.language),
+                mode: lower(values.mode),
             }, up);
         case "themes":
             return themes();
         case "update":
-            return update(dirArg(), up);
+            return update(dirArg(), { ...up, yes: !!values.yes });
         case "check":
             return check(dirArg());
         case "backup":
-            return backup(dirArg());
+            return void backup(dirArg(), { keep: values.keep ? Number(values.keep) : undefined });
+        case "restore":
+            return restore(dirArg(), { from: values.from, yes: !!values.yes });
         case "admin":
             return admin(dirArg());
         case "guide":