@salifbiaye/create-boutique 0.1.1

package/cli/dist/generate.js

@@ -0,0 +1,322 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { currencies, effective } from "./project.js";
+const secret = () => crypto.randomBytes(32).toString("base64url");
+// ─────────────────────────── docker-compose.yml ───────────────────────────
+export function composeYaml(p) {
+    const services = p.boutiques
+        .map((b) => `  storefront-${b.slug}:
+    <<: *storefront
+    ports: ["${b.port}:8000"]
+    environment: { <<: *storefront-env, BOUTIQUE: ${b.slug} }
+`)
+        .join("\n");
+    return `# GÉNÉRÉ par create-boutique à partir de config/project.json — ne pas modifier à la main.
+# Pour changer quelque chose : éditer config/project.json puis \`create-boutique apply .\`
+name: ${p.project}
+
+x-storefront: &storefront
+  build: ./storefront
+  image: ${p.project}-storefront
+  restart: unless-stopped
+  depends_on:
+    backend: { condition: service_healthy }
+  environment: &storefront-env
+    MEDUSA_BACKEND_URL: http://backend:9000
+    S3_FILE_URL: \${S3_FILE_URL}
+    STRIPE_PUBLISHABLE_KEY: \${STRIPE_PUBLISHABLE_KEY:-}
+  volumes:
+    - ./config:/app/config:ro      # project.json + campagnes (lecture seule)
+    - keys:/app/keys:ro            # publishable keys écrites par le backend
+
+services:
+  # ───────── Boutiques : 1 instance par boutique, même image ─────────
+${services}
+  # ───────── Backend Medusa + admin : 1 seul, partagé par les boutiques ─────────
+  backend:
+    build: ./backend
+    image: ${p.project}-backend
+    restart: unless-stopped
+    env_file: .env
+    environment:
+      # Postgres interne au réseau Docker, sans SSL (Medusa active le SSL par défaut hors localhost)
+      DATABASE_URL: postgres://medusa:\${POSTGRES_PASSWORD}@postgres:5432/medusa?sslmode=disable
+      REDIS_URL: redis://redis:6379
+      S3_ENDPOINT: http://storage:9000
+    ports: ["${p.apiPort}:9000"]           # API + admin (/app)
+    volumes:
+      - ./config:/app/config:ro    # boutiques, devises, pays → régions, sales channels, clés
+      - ./seed:/app/seed:ro        # products.csv + images à importer
+      - keys:/app/keys             # y écrit la publishable key de chaque boutique
+    depends_on:
+      postgres: { condition: service_healthy }
+      redis: { condition: service_healthy }
+      storage: { condition: service_healthy }
+
+  # ───────── Services internes ─────────
+  postgres:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: medusa
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD}
+      POSTGRES_DB: medusa
+    volumes: [pg_data:/var/lib/postgresql/data]
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U medusa"]
+      interval: 5s
+      retries: 20
+
+  redis:
+    image: redis:7-alpine
+    restart: unless-stopped
+    volumes: [redis_data:/data]
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      retries: 20
+
+  storage:                         # RustFS : stockage S3 des images
+    image: rustfs/rustfs:latest
+    restart: unless-stopped
+    environment:
+      RUSTFS_ACCESS_KEY: \${S3_ACCESS_KEY_ID}
+      RUSTFS_SECRET_KEY: \${S3_SECRET_ACCESS_KEY}
+    # Seule exception au « pas de port public » : les navigateurs chargent les images ici.
+    # Le backend rend le bucket lisible (lecture seule) ; l'écriture exige les identifiants.
+    ports: ["${p.storagePort}:9000"]
+    volumes: [storage_data:/data]
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:9000/health >/dev/null || exit 1"]
+      interval: 5s
+      retries: 20
+
+volumes:
+  pg_data:
+  redis_data:
+  storage_data:
+  keys:
+`;
+}
+/** 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 admin = `http://localhost:${p.apiPort}`;
+    return {
+        PROJECT: p.project,
+        STORE_CORS: origins.join(","),
+        ADMIN_CORS: admin,
+        AUTH_CORS: admin,
+        S3_FILE_URL: `http://localhost:${p.storagePort}/medusa`,
+    };
+}
+export function writeEnv(dir, p, s) {
+    const storageKey = `${p.project}-storage`;
+    const lines = [
+        "# GÉNÉRÉ par create-boutique — secrets du projet. Ne jamais committer ni publier ce fichier.",
+        "",
+        "# Base de données",
+        `POSTGRES_PASSWORD=${secret()}`,
+        "",
+        "# Medusa",
+        `JWT_SECRET=${secret()}`,
+        `COOKIE_SECRET=${secret()}`,
+        `ADMIN_EMAIL=${s.adminEmail}`,
+        `ADMIN_PASSWORD=${secret()}`,
+        "",
+        "# Images (RustFS, compatible S3)",
+        "S3_BUCKET=medusa",
+        "S3_REGION=us-east-1",
+        `S3_ACCESS_KEY_ID=${storageKey}`,
+        `S3_SECRET_ACCESS_KEY=${secret()}`,
+        "",
+        "# Stripe (vide = paiement manuel seulement). Après modification : docker compose restart backend",
+        `STRIPE_API_KEY=${s.stripeSk ?? ""}`,
+        `STRIPE_WEBHOOK_SECRET=${s.stripeWhsec ?? ""}`,
+        `STRIPE_PUBLISHABLE_KEY=${s.stripePk ?? ""}`,
+        "",
+        "# E-mails (Resend ; vide = aucun e-mail envoyé)",
+        `RESEND_API_KEY=${s.resendKey ?? ""}`,
+        `EMAIL_FROM=${s.emailFrom ?? ""}`,
+        "",
+        "# Dérivé de config/project.json (réécrit par `create-boutique apply`)",
+        ...Object.entries(derivedEnv(p)).map(([k, v]) => `${k}=${v}`),
+        "",
+    ];
+    fs.writeFileSync(path.join(dir, ".env"), lines.join("\n"), { mode: 0o600 });
+}
+/** Met à jour les variables dérivées de project.json sans toucher aux secrets. */
+export function refreshEnv(dir, p) {
+    const file = path.join(dir, ".env");
+    let text = fs.readFileSync(file, "utf8");
+    for (const [k, v] of Object.entries(derivedEnv(p))) {
+        const re = new RegExp(`^${k}=.*$`, "m");
+        text = re.test(text) ? text.replace(re, `${k}=${v}`) : `${text.trimEnd()}\n${k}=${v}\n`;
+    }
+    fs.writeFileSync(file, text);
+}
+export function readEnv(dir) {
+    const file = path.join(dir, ".env");
+    if (!fs.existsSync(file))
+        return {};
+    return Object.fromEntries(fs
+        .readFileSync(file, "utf8")
+        .split(/\r?\n/)
+        .filter((l) => /^[A-Z0-9_]+=/.test(l))
+        .map((l) => [l.slice(0, l.indexOf("=")), l.slice(l.indexOf("=") + 1)]));
+}
+// ─────────────────────────── Campagnes ───────────────────────────
+const THEME_ORDER = ["halloween", "thanksgiving", "black-friday", "cyber-monday", "noel", "nouvel-an"];
+const DISCOUNT = {
+    halloween: "40%",
+    thanksgiving: "30%",
+    "black-friday": "50%",
+    "cyber-monday": "50%",
+    noel: "30%",
+    "nouvel-an": "35%",
+};
+const FREE_SHIPPING = { usd: 50, eur: 50, gbp: 50, cad: 75, xof: 25000, xaf: 25000 };
+/** 4e jeudi de novembre (Thanksgiving US). */
+function thanksgiving(year) {
+    const d = new Date(Date.UTC(year, 10, 1));
+    const firstThursday = 1 + ((4 - d.getUTCDay() + 7) % 7);
+    return new Date(Date.UTC(year, 10, firstThursday + 21));
+}
+const day = (d, add = 0, end = false) => {
+    const x = new Date(d.getTime() + add * 86400000);
+    x.setUTCHours(end ? 23 : 0, end ? 59 : 0, end ? 59 : 0, 0);
+    return x;
+};
+/** Dates de la prochaine occurrence de la campagne (si la saison est passée, l'année suivante). */
+export function campaignDates(theme, now = new Date()) {
+    const build = (y) => {
+        const tg = thanksgiving(y);
+        switch (theme) {
+            case "halloween":
+                return [new Date(Date.UTC(y, 9, 20)), day(new Date(Date.UTC(y, 9, 31)), 0, true)];
+            case "thanksgiving":
+                return [day(tg, -6), day(tg, 0, true)];
+            case "black-friday":
+                return [day(tg, 1), day(tg, 3, true)];
+            case "cyber-monday":
+                return [day(tg, 4), day(tg, 4, true)];
+            case "noel":
+                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)];
+            default:
+                return null;
+        }
+    };
+    let range = build(now.getUTCFullYear());
+    if (range && range[1] < now)
+        range = build(now.getUTCFullYear() + 1);
+    if (!range)
+        range = [day(now), day(now, 30, true)];
+    return { startsAt: range[0].toISOString(), endsAt: range[1].toISOString() };
+}
+/** Fichier de campagne initial (dates + variables) ; les textes viennent du thème. Jamais écrasé. */
+export function writeCampaignFiles(dir, p, language) {
+    const campaignsDir = path.join(dir, "config", "campaigns");
+    fs.mkdirSync(campaignsDir, { recursive: true });
+    const locale = `${language}-${p.defaults.country.toUpperCase()}`;
+    // Campagne suivante : prochaine boutique dans l'ordre des saisons.
+    const ordered = [...p.boutiques].sort((a, b) => THEME_ORDER.indexOf(a.theme) - THEME_ORDER.indexOf(b.theme));
+    for (const b of p.boutiques) {
+        const file = path.join(campaignsDir, `${b.slug}.json`);
+        if (fs.existsSync(file))
+            continue;
+        const e = effective(p, b);
+        const i = ordered.findIndex((x) => x.slug === b.slug);
+        const next = ordered[i + 1]?.slug;
+        const threshold = FREE_SHIPPING[e.currency] ?? 50;
+        const freeShipping = new Intl.NumberFormat(locale, { style: "currency", currency: e.currency, maximumFractionDigits: 0 }).format(threshold);
+        const campaign = {
+            ...campaignDates(b.theme),
+            ...(next ? { nextCampaign: next } : {}),
+            vars: { discount: DISCOUNT[b.theme] ?? "20%", freeShipping },
+        };
+        fs.writeFileSync(file, JSON.stringify(campaign, null, 2) + "\n");
+    }
+}
+// ─────────────────────────── README ───────────────────────────
+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} |`;
+    })
+        .join("\n");
+    const text = `# ${p.defaults.storeName} — projet \`${p.project}\`
+
+Généré par **create-boutique**. Un backend Medusa (admin) partagé par ${p.boutiques.length} boutique(s).
+
+## Lancer
+
+\`\`\`bash
+docker compose up -d
+\`\`\`
+
+Le premier démarrage prend quelques minutes (construction des images, base de données, import du catalogue).
+Suivre l'avancement : \`docker compose logs -f backend\`.
+
+| Boutique | Thème | Devise | Adresse locale |
+| --- | --- | --- | --- |
+${rows}
+
+- **Admin** : http://localhost:${p.apiPort}/app — e-mail \`ADMIN_EMAIL\` du fichier \`.env\`, mot de passe \`ADMIN_PASSWORD\` (transmis à part, à changer à la première connexion).
+- **Images** : http://localhost:${p.storagePort}/medusa/…
+- Mémoire : environ 80 Mo par boutique, plus le backend (~500 Mo) et les services.
+
+## Modifier le site
+
+| Je veux changer… | Où | Ensuite |
+| --- | --- | --- |
+| Produits, prix, stock, promos, commandes | Admin → Produits / Commandes | rien |
+| Textes, dates, visuel, logo, image promo, compte à rebours | Admin → **Campagnes** | visible en ~1 min |
+| Image d'une catégorie | Admin → Produits → Catégories → (catégorie) | visible en ~1 min |
+| Nom, devise, pays, pays livrés, thème, ajout de boutique | \`config/project.json\` | \`create-boutique apply .\` |
+| Clés Stripe, Resend, adresse d'envoi | \`.env\` | \`docker compose restart backend\` puis \`docker compose up -d\` |
+| Mise en page, styles | ne pas modifier ici : template, puis \`create-boutique update .\` | — |
+
+Commandes utiles :
+
+\`\`\`bash
+create-boutique add . --boutique ${p.project}-soldes:black-friday   # ajouter une boutique
+create-boutique set . --boutique ${p.boutiques[0].slug} --name "Nouveau nom"
+create-boutique apply .     # après une modification de config/project.json
+create-boutique update .    # mettre à jour le code (config, .env et données conservés)
+create-boutique backup .    # sauvegarde base + images dans backups/<date>/
+\`\`\`
+
+## Paiement Stripe
+
+1. Renseigner \`STRIPE_API_KEY\` (sk_…) et \`STRIPE_PUBLISHABLE_KEY\` (pk_…) dans \`.env\`.
+2. Une fois le backend en ligne en HTTPS (le webhook ne peut pas viser \`localhost\`) :
+   \`create-boutique stripe-webhook . --url https://<adresse du backend>\`
+   crée l'endpoint \`/hooks/payment/stripe_stripe\` dans Stripe, écrit \`STRIPE_WEBHOOK_SECRET\` dans \`.env\` et relance le backend.
+3. À la main si besoin : Stripe → Développeurs → Webhooks, endpoint \`<adresse du backend>/hooks/payment/stripe_stripe\`, événements
+   \`payment_intent.succeeded\`, \`payment_intent.payment_failed\`, \`payment_intent.amount_capturable_updated\`, \`payment_intent.partially_funded\`,
+   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.
+
+## 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.
+- [ ] Une commande test passée dans chaque boutique (\`create-boutique check .\`).
+- [ ] Sauvegarde programmée (\`create-boutique backup .\`).
+
+## À ne pas faire
+
+- Ne pas modifier \`docker-compose.yml\` à la main (régénéré par \`apply\`).
+- Ne pas renommer le \`slug\` d'une boutique (il relie la boutique à ses ventes, sa clé et sa campagne).
+- Ne jamais publier le fichier \`.env\`.
+`;
+    fs.writeFileSync(path.join(dir, "README.md"), text);
+}
+export const projectCurrencies = currencies;

package/cli/dist/guide.js

@@ -0,0 +1,72 @@
+import { spawnSync } from "node:child_process";
+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";
+const escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+/** Chrome / Edge / Chromium installé (CHROME_PATH prioritaire). */
+function findBrowser() {
+    const candidates = [
+        process.env.CHROME_PATH,
+        "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        "/usr/bin/google-chrome",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/microsoft-edge",
+    ];
+    return candidates.find((c) => c && fs.existsSync(c));
+}
+/** Remplit un modèle HTML (valeurs échappées ; les clés *_HTML sont du HTML construit ici) puis l'imprime en PDF. */
+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;");
+    const htmlFile = path.join(dir, `${out}.html`);
+    const pdfFile = path.join(dir, `${out}.pdf`);
+    fs.writeFileSync(htmlFile, html);
+    const browser = findBrowser();
+    if (!browser)
+        return { pdf: false, file: htmlFile };
+    const r = spawnSync(browser, ["--headless", "--disable-gpu", "--no-pdf-header-footer", `--print-to-pdf=${pdfFile}`, pathToFileURL(htmlFile).href], { stdio: "ignore", timeout: 90000 });
+    if (r.status === 0 && fs.existsSync(pdfFile)) {
+        fs.rmSync(htmlFile);
+        return { pdf: true, file: pdfFile };
+    }
+    return { pdf: false, file: htmlFile };
+}
+/**
+ * GUIDE-CLIENT.pdf (1 page, docs/fiche-client[.en].html) et GUIDE-COMPLET.pdf (docs/guide-complet.<lang>.html),
+ * remplis avec l'adresse de l'admin, l'e-mail admin et les boutiques du projet.
+ * Le mot de passe n'est JAMAIS imprimé (champ laissé vide, transmis à part).
+ * Langue = langue du projet (fr, sinon en). Sans Chrome/Edge : fichiers HTML (à imprimer en PDF).
+ */
+export function writeGuides(dir, p, adminEmail, support = "") {
+    const fr = p.defaults.language === "fr";
+    const adminUrl = `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>`;
+    })
+        .join("");
+    const vars = {
+        ADMIN_URL: adminUrl,
+        ADMIN_EMAIL: adminEmail,
+        SUPPORT: support,
+        PROJECT: p.project,
+        STORE_NAME: p.defaults.storeName,
+        CURRENCIES: currencies(p).map((c) => c.toUpperCase()).join(", "),
+        STORES_HTML: stores,
+    };
+    const docs = path.join(PACKAGE_ROOT, "docs");
+    return [
+        render(path.join(docs, fr ? "fiche-client.html" : "fiche-client.en.html"), "GUIDE-CLIENT", dir, vars),
+        render(path.join(docs, fr ? "guide-complet.fr.html" : "guide-complet.en.html"), "GUIDE-COMPLET", dir, vars),
+    ];
+}

package/cli/dist/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+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 { answersSchema, create } from "./create.js";
+import { ProjectError } from "./project.js";
+const HELP = `create-boutique — Usine à Boutiques
+
+  create-boutique <dossier> [options]              crée un projet (questions si des options manquent)
+    --name "<nom>"            nom affiché
+    --email <email>           e-mail admin (et du marchand)
+    --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)
+    --stripe-pk / --stripe-sk / --stripe-whsec   clés Stripe (optionnelles)
+    --resend-key / --email-from                  e-mails (optionnels)
+    --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 add <dossier> --boutique <slug>:<thème>
+  create-boutique remove <dossier> --boutique <slug>
+  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 check <dossier>                  commande test dans chaque boutique
+  create-boutique backup <dossier>                 base + images dans backups/<date>/
+  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"]);
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            name: { type: "string" },
+            email: { type: "string" },
+            currency: { type: "string" },
+            country: { type: "string" },
+            language: { type: "string" },
+            themes: { type: "string" },
+            boutique: { type: "string", multiple: true },
+            theme: { type: "string" },
+            "stripe-pk": { type: "string" },
+            "stripe-sk": { type: "string" },
+            "stripe-whsec": { type: "string" },
+            "resend-key": { type: "string" },
+            "email-from": { type: "string" },
+            products: { type: "string" },
+            images: { type: "string" },
+            "store-port": { type: "string" },
+            "api-port": { type: "string" },
+            "storage-port": { type: "string" },
+            config: { type: "string" },
+            url: { type: "string" },
+            yes: { type: "boolean", short: "y" },
+            "no-up": { type: "boolean" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    const [first, ...rest] = positionals;
+    if (values.help || !first || first === "help")
+        return console.log(HELP);
+    const up = { up: !values["no-up"] };
+    const dirArg = (i = 0) => {
+        const d = rest[i];
+        if (!d)
+            throw new ProjectError("dossier du projet manquant (ex. create-boutique apply ./boutique-yout)");
+        return d;
+    };
+    const lower = (v) => v?.toLowerCase();
+    if (!COMMANDS.has(first)) {
+        // create-boutique <dossier> [options]
+        const fromFile = values.config ? answersSchema.parse(JSON.parse(fs.readFileSync(values.config, "utf8"))) : {};
+        const port = (v) => (v ? Number(v) : undefined);
+        const fromFlags = answersSchema.parse(Object.fromEntries(Object.entries({
+            name: values.name,
+            email: values.email,
+            currency: lower(values.currency),
+            country: lower(values.country),
+            language: lower(values.language),
+            themes: values.themes === "all" ? "all" : values.themes?.split(",").map((s) => s.trim()).filter(Boolean),
+            boutiques: values.boutique,
+            stripePk: values["stripe-pk"],
+            stripeSk: values["stripe-sk"],
+            stripeWhsec: values["stripe-whsec"],
+            resendKey: values["resend-key"],
+            emailFrom: values["email-from"],
+            products: values.products,
+            images: values.images,
+            storePort: port(values["store-port"]),
+            apiPort: port(values["api-port"]),
+            storagePort: port(values["storage-port"]),
+        }).filter(([, v]) => v !== undefined)));
+        return create(first, { ...fromFile, ...fromFlags }, { yes: !!values.yes });
+    }
+    switch (first) {
+        case "apply":
+            return apply(dirArg(), up);
+        case "add":
+            return add(dirArg(), values.boutique ?? [], up);
+        case "remove":
+            if (!values.boutique?.length)
+                throw new ProjectError("--boutique <slug> obligatoire");
+            return remove(dirArg(), values.boutique, up);
+        case "set":
+            return set(dirArg(), {
+                boutique: values.boutique?.[0],
+                name: values.name,
+                theme: values.theme,
+                currency: lower(values.currency),
+                country: lower(values.country),
+                language: lower(values.language),
+            }, up);
+        case "themes":
+            return themes();
+        case "update":
+            return update(dirArg(), up);
+        case "check":
+            return check(dirArg());
+        case "backup":
+            return backup(dirArg());
+        case "admin":
+            return admin(dirArg());
+        case "guide":
+            return guide(dirArg());
+        case "stripe-webhook":
+            return stripeWebhook(dirArg(), values.url, up);
+        case "campaign": {
+            const [action, dir] = rest;
+            if (!dir)
+                throw new ProjectError("usage : create-boutique campaign export|import <dossier>");
+            if (action === "export")
+                return campaignExport(dir);
+            if (action === "import")
+                return campaignImport(dir, values.boutique ?? [], !!values.yes);
+            throw new ProjectError("usage : create-boutique campaign export|import <dossier>");
+        }
+    }
+}
+main().catch((e) => {
+    if (e instanceof ProjectError)
+        console.error(pc.red("✖ config invalide, rien n'a été modifié :\n") + e.message);
+    else if (e instanceof z.ZodError)
+        console.error(pc.red("✖ options invalides :\n") + z.prettifyError(e));
+    else
+        console.error(pc.red(`✖ ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+});

package/cli/dist/paths.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Racine du package create-boutique (contient templates/). */
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+export const TEMPLATES = path.join(PACKAGE_ROOT, "templates");
+export const THEMES_DIR = path.join(TEMPLATES, "storefront", "themes");
+export function templateVersion() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+    return pkg.version;
+}
+/** Fichiers et dossiers jamais copiés dans un projet (dépendances, builds, secrets). */
+const IGNORED = new Set(["node_modules", ".next", ".medusa", "static", "uploads", ".git", ".turbo", "dist"]);
+export function shouldCopy(name) {
+    return !IGNORED.has(name) && !name.startsWith(".env") && !name.endsWith(".log") && name !== "tsconfig.tsbuildinfo";
+}
+export function copyDir(from, to) {
+    fs.mkdirSync(to, { recursive: true });
+    for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        if (!shouldCopy(entry.name))
+            continue;
+        const src = path.join(from, entry.name);
+        const dst = path.join(to, entry.name);
+        if (entry.isDirectory())
+            copyDir(src, dst);
+        else
+            fs.copyFileSync(src, dst);
+    }
+}

package/cli/dist/ports.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Registre local des ports réservés par les projets générés sur cette machine
+ * (~/.create-boutique/ports.json), pour que deux projets ne prennent pas les mêmes.
+ */
+const REGISTRY = path.join(os.homedir(), ".create-boutique", "ports.json");
+function readRegistry() {
+    try {
+        return JSON.parse(fs.readFileSync(REGISTRY, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function reservePorts(projectDir, ports) {
+    const reg = readRegistry();
+    reg[path.resolve(projectDir)] = ports;
+    fs.mkdirSync(path.dirname(REGISTRY), { recursive: true });
+    fs.writeFileSync(REGISTRY, JSON.stringify(reg, null, 2) + "\n");
+}
+export function releasePorts(projectDir) {
+    const reg = readRegistry();
+    delete reg[path.resolve(projectDir)];
+    fs.mkdirSync(path.dirname(REGISTRY), { recursive: true });
+    fs.writeFileSync(REGISTRY, JSON.stringify(reg, null, 2) + "\n");
+}
+/** Ports réservés par les AUTRES projets (un projet existant n'est pas en conflit avec lui-même). */
+export function reservedByOthers(projectDir) {
+    const self = path.resolve(projectDir);
+    const reg = readRegistry();
+    // On oublie les projets dont le dossier a été supprimé.
+    return new Set(Object.entries(reg).filter(([dir]) => dir !== self && fs.existsSync(dir)).flatMap(([, p]) => p));
+}
+export function isPortFree(port) {
+    return new Promise((resolve) => {
+        const srv = net.createServer();
+        srv.once("error", () => resolve(false));
+        srv.once("listening", () => srv.close(() => resolve(true)));
+        srv.listen(port, "0.0.0.0");
+    });
+}
+/** Premier port libre à partir de `from`, en évitant `taken` (ports déjà choisis ou réservés). */
+export async function nextFreePort(from, taken) {
+    for (let p = from; p < 65535; p++) {
+        if (taken.has(p))
+            continue;
+        if (await isPortFree(p))
+            return p;
+    }
+    throw new Error(`aucun port libre à partir de ${from}`);
+}