@salifbiaye/create-boutique 0.4.1 → 0.6.0

package/cli/dist/commands.js

@@ -6,7 +6,7 @@ import { compose, composeOutput, isRunning } from "./docker.js";
 import { readEnv, refreshEnv, writeCampaignFiles, writeCompose, writeReadme } from "./generate.js";
 import { copyTemplate, templateVersion } from "./paths.js";
 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,7 +59,7 @@ 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);
@@ -67,7 +67,7 @@ export async function apply(dir, opts = { up: true }) {
     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 +84,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 +178,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 +228,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)
@@ -248,9 +338,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();

package/cli/dist/create.js

@@ -7,7 +7,7 @@ import { writeCampaignFiles, writeCompose, writeEnv, writeReadme } from "./gener
 import { writeGuides } from "./guide.js";
 import { copyDir, copyTemplate, templateVersion } from "./paths.js";
 import { nextFreePort, reservedByOthers, reservePorts } from "./ports.js";
-import { validateProject, writeJsonSchema, writeProject, ProjectError } from "./project.js";
+import { normalizeUrl, storePorts, validateProject, writeJsonSchema, writeProject, ProjectError } from "./project.js";
 import { listThemes, themeIds } from "./themes.js";
 /** Réponses du CLI : mêmes clés pour les options, le fichier --config et les questions. */
 export const answersSchema = z.object({
@@ -18,6 +18,13 @@ 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(),
@@ -88,6 +95,22 @@ 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é.
@@ -112,7 +135,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, 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 +167,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,8 +214,11 @@ 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)"}`,
@@ -209,7 +255,7 @@ export async function create(dir, input, opts) {
     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.`));

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}`);
@@ -309,7 +317,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}\`

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() {
@@ -52,7 +52,7 @@ export function writeGuides(dir, p, adminEmail, support = "") {
     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 = {

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, 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,6 +14,9 @@ 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)
     --products <csv>  --images <dossier>         catalogue (optionnel)
@@ -22,8 +25,11 @@ const HELP = `create-boutique — Usine à Boutiques
     --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)
@@ -35,7 +41,7 @@ const HELP = `create-boutique — Usine à Boutiques
   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(["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,6 +54,11 @@ 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" },
             "stripe-pk": { type: "string" },
             "stripe-sk": { type: "string" },
             "stripe-whsec": { type: "string" },
@@ -88,6 +99,10 @@ 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"],
@@ -104,6 +119,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,6 +135,7 @@ async function main() {
                 currency: lower(values.currency),
                 country: lower(values.country),
                 language: lower(values.language),
+                mode: lower(values.mode),
             }, up);
         case "themes":
             return themes();

package/cli/dist/project.js

@@ -16,8 +16,14 @@ export const projectSchema = z.object({
     templateVersion: z.string().optional(),
     apiPort: z.number().int().min(1).max(65535).default(9000),
     storagePort: z.number().int().min(1).max(65535).default(9100),
-    /** Production : adresses publiques (https) du backend/admin et des images. Présent = Caddy + https dans le compose. */
+    /** Production : adresses publiques (https) du backend/admin et des images. Présent = ports sur 127.0.0.1 (ton reverse proxy les expose), Caddyfile.exemple fourni. */
     urls: z.strictObject({ api: z.url(), files: z.url() }).optional(),
+    /**
+     * multi (défaut) : un site par boutique, toutes en ligne (1 container, 1 port, 1 domaine chacune).
+     * single : un seul site (site.port, site.url) qui affiche la boutique active, choisie dans admin → Campagnes.
+     */
+    mode: z.enum(["multi", "single"]).default("multi"),
+    site: z.strictObject({ port: z.number().int().min(1).max(65535), url: z.url().optional() }).optional(),
     defaults: z.looseObject({
         storeName: z.string().min(1).max(60),
         currency: code3,
@@ -31,7 +37,8 @@ export const projectSchema = z.object({
         .array(z.strictObject({
         slug: z.string().regex(SLUG, "slug : minuscules, chiffres et tirets"),
         theme: z.string(),
-        port: z.number().int().min(1).max(65535),
+        /** Mode multi : port du site de la boutique (inutile en mode single) */
+        port: z.number().int().min(1).max(65535).optional(),
         url: z.url().optional(),
         storeName: z.string().min(1).max(60).optional(),
         currency: code3.optional(),
@@ -59,7 +66,13 @@ export function validateProject(raw) {
     for (const b of p.boutiques)
         if (!themes.includes(b.theme))
             errors.push(`${b.slug} : thème inconnu « ${b.theme} » (disponibles : ${themes.join(", ")})`);
-    const ports = [p.apiPort, p.storagePort, ...p.boutiques.map((b) => b.port)];
+    if (p.mode === "single" && !p.site)
+        errors.push("mode single : bloc site { port } obligatoire");
+    if (p.mode === "multi")
+        for (const b of p.boutiques)
+            if (!b.port)
+                errors.push(`${b.slug} : port obligatoire (mode multi)`);
+    const ports = [p.apiPort, p.storagePort, ...storePorts(p)];
     for (const port of new Set(ports))
         if (ports.filter((x) => x === port).length > 1)
             errors.push(`port utilisé deux fois : ${port}`);
@@ -119,3 +132,29 @@ export function writeJsonSchema(dir) {
     const schema = z.toJSONSchema(projectSchema, { io: "input", unrepresentable: "any" });
     fs.writeFileSync(path.join(dir, "config", "project.schema.json"), JSON.stringify(schema, null, 2) + "\n");
 }
+/**
+ * Adresse publique saisie par l'utilisateur → origine seule (https://images.marque.com).
+ * Accepte « images.marque.com », une barre finale ou « /medusa » (ajouté ensuite par le CLI pour S3_FILE_URL).
+ */
+export function normalizeUrl(v, what) {
+    const raw = /^https?:\/\//.test(v.trim()) ? v.trim() : `https://${v.trim()}`;
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        throw new ProjectError(`${what} : adresse invalide « ${v} » (ex. https://images.marque.com)`);
+    }
+    const path = u.pathname.replace(/\/+$/, "").replace(/\/medusa$/, "");
+    if (path)
+        throw new ProjectError(`${what} : donnez seulement le domaine (ex. https://images.marque.com), sans chemin « ${u.pathname} »`);
+    return u.origin;
+}
+export function fronts(p) {
+    if (p.mode === "single")
+        return p.site ? [{ service: "storefront", boutique: "auto", port: p.site.port, url: p.site.url }] : [];
+    return p.boutiques.filter((b) => b.port).map((b) => ({ service: `storefront-${b.slug}`, boutique: b.slug, port: b.port, url: b.url }));
+}
+export const storePorts = (p) => fronts(p).map((f) => f.port);
+/** Adresse publique d'une boutique (en mode single : celle du site unique). */
+export const boutiqueUrl = (p, b) => p.mode === "single" ? (p.site?.url ?? `http://localhost:${p.site?.port}`) : (b.url ?? `http://localhost:${b.port}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salifbiaye/create-boutique",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Usine à Boutiques : génère un projet complet (backend Medusa + une boutique Next.js par campagne) prêt pour docker compose",
   "type": "module",
   "repository": {

package/templates/backend/src/admin/i18n/json/en.json

@@ -16,7 +16,7 @@
     "saved": "Campaign saved",
     "reset": "Reset to theme texts",
     "resetDone": "Theme texts restored",
-    "emptyHint": "Leave empty to use the theme text.",
+    "emptyHint": "Fields show the current texts (the theme ones by default): change what you want. {discount}, {endDate} and {freeShipping} are replaced automatically by the discount, end date and free-shipping threshold.",
     "sections": {
       "dates": "Dates",
       "hero": "Hero",
@@ -66,6 +66,16 @@
       "save": "Save image",
       "saved": "Image saved"
     },
-    "shareHint": "What shows when the store link is shared (WhatsApp, Facebook, LinkedIn…). Empty = store name, subtitle and main visual."
+    "shareHint": "What shows when the store link is shared (WhatsApp, Facebook, LinkedIn…). Empty = store name, subtitle and main visual.",
+    "online": {
+      "column": "Site",
+      "live": "Live",
+      "action": "Put live",
+      "hint": "Single site: the “Live” store is the one customers see. Orders and in-progress carts of the other stores are not lost.",
+      "confirmTitle": "Change the live store?",
+      "confirmText": "The site will switch from {{from}} to {{to}}. Customers paying right now can finish their order.",
+      "confirm": "Put live",
+      "done": "Store is live: the site has switched."
+    }
   }
 }