@salifbiaye/create-boutique 0.5.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,8 +5,10 @@ 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 { currencies, effective, readProject, validateProject, writeJsonSchema, writeProject, ProjectError, SLUG } from "./project.js";
+import { boutiqueUrl, currencies, effective, normalizeUrl, readProject, validateProject, writeJsonSchema, writeProject, ProjectError, SLUG, storePorts } from "./project.js";
 import { listThemes } from "./themes.js";
 import { writeGuides } from "./guide.js";
 const STATE = (dir) => path.join(dir, ".create-boutique-state.json");
@@ -59,15 +61,16 @@ export async function apply(dir, opts = { up: true }) {
     const p = readProject(target); // lève une ProjectError détaillée si invalide
     checkCsvCurrencies(target, p); // avant toute écriture
     const others = reservedByOthers(target);
-    const clash = [p.apiPort, p.storagePort, ...p.boutiques.map((b) => b.port)].filter((port) => others.has(port));
+    const clash = [p.apiPort, p.storagePort, ...storePorts(p)].filter((port) => others.has(port));
     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);
     writeReadme(target, p);
-    reservePorts(target, [p.apiPort, p.storagePort, ...p.boutiques.map((b) => b.port)]);
+    reservePorts(target, [p.apiPort, p.storagePort, ...storePorts(p)]);
     const previous = fs.existsSync(STATE(target)) ? JSON.parse(fs.readFileSync(STATE(target), "utf8")).hash : null;
     const changed = previous !== hash(p);
     console.log(pc.green("✔ project.json valide, docker-compose.yml et .env régénérés"));
@@ -84,18 +87,77 @@ export async function apply(dir, opts = { up: true }) {
     fs.writeFileSync(STATE(target), JSON.stringify({ hash: hash(p), appliedAt: new Date().toISOString() }, null, 2) + "\n");
     priceWarnings(target);
 }
+// ─────────────────────────── urls ───────────────────────────
+/** Préfixe des images en base : <domaine>/medusa (le bucket). Accepte le domaine seul ou déjà suffixé. */
+const filesPrefix = (v) => {
+    const t = v.trim().replace(/\/+$/, "");
+    return /\/medusa$/.test(t) ? t : `${t}/medusa`;
+};
+/**
+ * Change les domaines publics (admin/API, images, site en mode single), régénère .env / compose / Caddyfile.exemple,
+ * puis réécrit l'adresse des images déjà en base : ancienne adresse (S3_FILE_URL avant le changement,
+ * ou --from) → nouvelle. Relançable sans risque (ne touche que ce qui commence par l'ancienne adresse).
+ */
+export async function urls(dir, o, opts) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const before = readEnv(target).S3_FILE_URL;
+    if (o.api || o.files) {
+        const api = o.api ? normalizeUrl(o.api, "--api-url") : p.urls?.api;
+        const files = o.files ? normalizeUrl(o.files, "--files-url") : p.urls?.files;
+        if (!api || !files)
+            throw new ProjectError("première configuration : --api-url et --files-url ensemble (domaine de l'admin et domaine des images)");
+        p.urls = { api, files };
+    }
+    if (o.site) {
+        if (p.mode !== "single")
+            throw new ProjectError("--site-url concerne le mode single ; en mode multi, mettez url sur chaque boutique dans config/project.json");
+        p.site = { ...p.site, url: normalizeUrl(o.site, "--site-url") };
+    }
+    if (!o.api && !o.files && !o.site && !o.from)
+        throw new ProjectError("rien à changer : --api-url, --files-url, --site-url ou --from");
+    writeProject(target, validateProject(p));
+    await apply(target, opts);
+    const after = readEnv(target).S3_FILE_URL;
+    console.log(`Images : ${after}`);
+    // Images déjà importées : réécriture de l'ancienne adresse
+    const from = o.from ? filesPrefix(normalizeFrom(o.from)) : before;
+    if (!from || from === after)
+        return;
+    if (!opts.up) {
+        console.log(pc.yellow(`!   --no-up : images non réécrites. Après le démarrage : create-boutique urls . --from ${from}`));
+        return;
+    }
+    const backend = `http://localhost:${p.apiPort}`;
+    for (let i = 0; i < 60 && !(await fetch(`${backend}/health`).then((r) => r.ok).catch(() => false)); i++)
+        await new Promise((r) => setTimeout(r, 5000));
+    const r = composeOutput(target, ["exec", "-T", "-e", `FILES_FROM=${from}`, "-e", `FILES_TO=${after}`, "backend", "npx", "medusa", "exec", "./src/scripts/rewrite-file-urls.js"]);
+    const m = r.stdout.match(/<<<URLS(.*)URLS>>>/);
+    if (r.code !== 0 || !m)
+        throw new Error(`réécriture des images échouée :\n${r.stderr.slice(-800)}`);
+    const n = JSON.parse(m[1]);
+    console.log(pc.green(`✔ images réécrites : ${from} → ${after} (${n.products} produit(s), ${n.campaigns} campagne(s))`));
+}
+/** --from accepte aussi « localhost:9100 » : on complète le schéma. */
+const normalizeFrom = (v) => (/^https?:\/\//.test(v.trim()) ? v.trim() : `http://${v.trim()}`);
 // ─────────────────────────── add / remove / set ───────────────────────────
 export async function add(dir, specs, opts) {
     if (!specs.length)
         throw new ProjectError("--boutique <slug>:<thème> obligatoire");
     const target = path.resolve(dir);
     const p = readProject(target);
-    const taken = new Set([...reservedByOthers(target), p.apiPort, p.storagePort, ...p.boutiques.map((b) => b.port)]);
-    let from = Math.max(...p.boutiques.map((b) => b.port)) + 1;
+    const taken = new Set([...reservedByOthers(target), p.apiPort, p.storagePort, ...storePorts(p)]);
+    let from = Math.max(8000, ...storePorts(p)) + 1;
     for (const spec of specs) {
         const [slug, theme] = spec.split(":");
         if (!slug || !theme || !SLUG.test(slug))
             throw new ProjectError(`format attendu : --boutique <slug>:<thème> (reçu « ${spec} »)`);
+        if (p.mode === "single") {
+            // Mode single : pas de port, la boutique s'active dans admin → Campagnes
+            p.boutiques.push({ slug, theme });
+            console.log(`+ ${slug} (${theme}) : à mettre en ligne dans admin → Campagnes`);
+            continue;
+        }
         const port = await nextFreePort(from, taken);
         taken.add(port);
         from = port + 1;
@@ -119,6 +181,35 @@ export async function remove(dir, slugs, opts) {
     console.log(`- ${slugs.join(", ")} retirée(s). Ses commandes et son sales channel restent dans l'admin.`);
     await apply(target, opts);
 }
+/**
+ * multi → single : un seul site, sur le port de la première boutique ; les boutiques perdent leur port et leur domaine.
+ * single → multi : chaque boutique reçoit un port libre à partir de celui du site.
+ */
+async function switchMode(target, p, mode) {
+    if (mode === "single") {
+        const first = p.boutiques.find((b) => b.port);
+        p.site = { port: first?.port ?? 8001, ...(first?.url ? { url: first.url } : {}) };
+        for (const b of p.boutiques) {
+            delete b.port;
+            delete b.url;
+        }
+        console.log(`mode single : un seul site sur le port ${p.site.port}${p.site.url ? ` (${p.site.url})` : ""}, boutique en ligne choisie dans admin → Campagnes`);
+    }
+    else {
+        const taken = new Set([...reservedByOthers(target), p.apiPort, p.storagePort]);
+        let from = p.site?.port ?? 8001;
+        for (const b of p.boutiques) {
+            const port = await nextFreePort(from, taken);
+            taken.add(port);
+            from = port + 1;
+            b.port = port;
+            console.log(`${b.slug} → http://localhost:${port}`);
+        }
+        delete p.site;
+        console.log("mode multi : toutes les boutiques sont en ligne, chacune sur son port");
+    }
+    p.mode = mode;
+}
 export async function set(dir, o, opts) {
     const target = path.resolve(dir);
     const p = readProject(target);
@@ -140,6 +231,8 @@ export async function set(dir, o, opts) {
     else {
         if (o.theme)
             throw new ProjectError("--theme s'applique à une boutique : ajoutez --boutique <slug>");
+        if (o.mode && o.mode !== p.mode)
+            await switchMode(target, p, o.mode);
         if (o.name)
             p.defaults.storeName = o.name;
         if (o.currency)
@@ -158,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)
@@ -188,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) {
@@ -248,9 +463,10 @@ export async function check(dir) {
         const e = effective(p, b);
         const steps = [];
         try {
-            const url = b.url ?? `http://localhost:${b.port}`;
+            const url = boutiqueUrl(p, b);
             const html = await fetch(url).then((r) => (r.ok ? r.text() : Promise.reject(new Error(`boutique HTTP ${r.status}`))));
-            if (!html.includes(`data-theme="${b.theme}"`))
+            // Mode single : le site n'affiche que la boutique active
+            if (p.mode !== "single" && !html.includes(`data-theme="${b.theme}"`))
                 throw new Error(`thème ${b.theme} absent de la page`);
             steps.push("page");
             const key = composeOutput(target, ["exec", "-T", "backend", "cat", `/app/keys/${b.slug}`]).stdout.trim();
@@ -301,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`);