@salifbiaye/create-boutique 0.1.1

package/README.md

@@ -0,0 +1 @@
+# create-boutique

package/cli/dist/commands.js

@@ -0,0 +1,382 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+import { compose, composeOutput, isRunning } from "./docker.js";
+import { composeYaml, readEnv, refreshEnv, writeCampaignFiles, writeReadme } from "./generate.js";
+import { copyDir, TEMPLATES, templateVersion } from "./paths.js";
+import { nextFreePort, reservedByOthers, reservePorts } from "./ports.js";
+import { currencies, effective, readProject, validateProject, writeJsonSchema, writeProject, ProjectError, SLUG } from "./project.js";
+import { listThemes } from "./themes.js";
+import { writeGuides } from "./guide.js";
+const STATE = (dir) => path.join(dir, ".create-boutique-state.json");
+const hash = (p) => crypto.createHash("sha256").update(JSON.stringify(p)).digest("hex");
+// ─────────────────────────── prix par devise ───────────────────────────
+/** seed/products.csv doit avoir une colonne price_<devise> pour chaque devise utilisée (sinon produits invisibles). */
+function checkCsvCurrencies(target, p) {
+    const csv = path.join(target, "seed", "products.csv");
+    if (!fs.existsSync(csv))
+        return;
+    const header = fs
+        .readFileSync(csv, "utf8")
+        .replace(/^/, "")
+        .split(/\r?\n/)[0]
+        .split(",")
+        .map((h) => h.trim());
+    const missing = currencies(p).filter((c) => !header.includes(`price_${c}`));
+    if (missing.length) {
+        throw new ProjectError(`seed/products.csv n'a pas de colonne ${missing.map((c) => `price_${c}`).join(", ")} : ajoutez ces prix dans le CSV (ou dans l'admin si le catalogue est déjà importé)`);
+    }
+}
+/** Projet lancé : produits publiés sans prix dans la devise de chaque boutique (avertissement). */
+function priceWarnings(target) {
+    if (!isRunning(target, "backend"))
+        return;
+    const r = composeOutput(target, ["exec", "-T", "backend", "npx", "medusa", "exec", "./src/scripts/price-report.js"]);
+    const m = r.stdout.match(/<<<PRICES([\s\S]*)PRICES>>>/);
+    if (!m)
+        return;
+    const report = JSON.parse(m[1]);
+    for (const [slug, { currency, missing, published }] of Object.entries(report)) {
+        if (published === 0) {
+            console.log(pc.yellow(`!  ${slug} : aucun produit publié dans cette boutique → Admin → Canaux de vente → ${slug} → Ajouter des produits`));
+            continue;
+        }
+        if (!missing.length)
+            continue;
+        const list = `${missing.slice(0, 5).join(", ")}${missing.length > 5 ? "…" : ""}`;
+        console.log(pc.yellow(`!  ${slug} : ${missing.length} produit(s) sans prix en ${currency.toUpperCase()} (invisibles) : ${list} → Admin → Produits → prix`));
+    }
+}
+// ─────────────────────────── apply ───────────────────────────
+/**
+ * Applique config/project.json : valide (sans rien écrire si erreur), régénère docker-compose.yml,
+ * .env (variables dérivées), README, campagnes des nouvelles boutiques, puis relance le projet.
+ * Le backend redémarre seulement si project.json a changé (il relance alors son seed idempotent).
+ */
+export async function apply(dir, opts = { up: true }) {
+    const target = path.resolve(dir);
+    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));
+    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);
+    writeJsonSchema(target);
+    fs.writeFileSync(path.join(target, "docker-compose.yml"), composeYaml(p));
+    refreshEnv(target, p);
+    writeReadme(target, p);
+    reservePorts(target, [p.apiPort, p.storagePort, ...p.boutiques.map((b) => b.port)]);
+    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"));
+    if (!opts.up)
+        return;
+    if (compose(target, ["up", "-d", "--remove-orphans"]) !== 0)
+        throw new Error("docker compose up a échoué");
+    // État inconnu (jamais appliqué avec démarrage) : on considère que project.json a changé.
+    if (changed && isRunning(target, "backend")) {
+        console.log("project.json a changé : redémarrage du backend (régions, boutiques, clés créées si besoin)…");
+        compose(target, ["restart", "backend"]);
+        compose(target, ["up", "-d"]); // relance les boutiques qui attendaient leur clé
+    }
+    fs.writeFileSync(STATE(target), JSON.stringify({ hash: hash(p), appliedAt: new Date().toISOString() }, null, 2) + "\n");
+    priceWarnings(target);
+}
+// ─────────────────────────── 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;
+    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} »)`);
+        const port = await nextFreePort(from, taken);
+        taken.add(port);
+        from = port + 1;
+        p.boutiques.push({ slug, theme, port });
+        console.log(`+ ${slug} (${theme}) → http://localhost:${port}`);
+    }
+    writeProject(target, validateProject(p));
+    await apply(target, opts);
+}
+export async function remove(dir, slugs, opts) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    for (const slug of slugs) {
+        if (!p.boutiques.some((b) => b.slug === slug))
+            throw new ProjectError(`boutique inconnue : ${slug}`);
+    }
+    p.boutiques = p.boutiques.filter((b) => !slugs.includes(b.slug));
+    if (!p.boutiques.length)
+        throw new ProjectError("impossible de retirer la dernière boutique");
+    writeProject(target, validateProject(p));
+    console.log(`- ${slugs.join(", ")} retirée(s). Ses commandes et son sales channel restent dans l'admin.`);
+    await apply(target, opts);
+}
+export async function set(dir, o, opts) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    if (o.boutique) {
+        const b = p.boutiques.find((x) => x.slug === o.boutique);
+        if (!b)
+            throw new ProjectError(`boutique inconnue : ${o.boutique}`);
+        if (o.language)
+            throw new ProjectError("la langue se règle pour tout le projet : create-boutique set <dossier> --language <code>");
+        if (o.name)
+            b.storeName = o.name;
+        if (o.theme)
+            b.theme = o.theme;
+        if (o.currency)
+            b.currency = o.currency;
+        if (o.country)
+            b.country = o.country;
+    }
+    else {
+        if (o.theme)
+            throw new ProjectError("--theme s'applique à une boutique : ajoutez --boutique <slug>");
+        if (o.name)
+            p.defaults.storeName = o.name;
+        if (o.currency)
+            p.defaults.currency = o.currency;
+        if (o.country)
+            p.defaults.country = o.country;
+        if (o.language)
+            p.defaults.language = o.language;
+    }
+    writeProject(target, validateProject(p));
+    await apply(target, opts);
+}
+// ─────────────────────────── themes ───────────────────────────
+export function themes() {
+    for (const t of listThemes())
+        console.log(`${t.id.padEnd(16)} ${t.name.padEnd(16)} langues : ${t.languages.join(", ")}`);
+}
+// ─────────────────────────── update ───────────────────────────
+/** Remplace storefront/ et backend/ par la version actuelle du template (config, seed, .env et données conservés). */
+export async function update(dir, opts) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const from = p.templateVersion ?? "?";
+    const to = templateVersion();
+    for (const part of ["storefront", "backend"]) {
+        fs.rmSync(path.join(target, part), { recursive: true, force: true });
+        copyDir(path.join(TEMPLATES, part), path.join(target, part));
+    }
+    p.templateVersion = to;
+    writeProject(target, p);
+    console.log(pc.green(`✔ code mis à jour : template ${from} → ${to}`));
+    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) {
+    const target = path.resolve(dir);
+    readProject(target);
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const out = path.join(target, "backups", stamp);
+    fs.mkdirSync(out, { recursive: true });
+    const dump = composeOutput(target, ["exec", "-T", "postgres", "pg_dump", "-U", "medusa", "--clean", "--if-exists", "medusa"]);
+    if (dump.code !== 0)
+        throw new Error(`pg_dump a échoué : ${dump.stderr}`);
+    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");
+}
+// ─────────────────────────── campaign export / import ───────────────────────────
+export function campaignExport(dir) {
+    const target = path.resolve(dir);
+    readProject(target);
+    const r = composeOutput(target, ["exec", "-T", "backend", "npx", "medusa", "exec", "./src/scripts/campaign-export.js"]);
+    const m = r.stdout.match(/<<<CAMPAIGNS([\s\S]*)CAMPAIGNS>>>/);
+    if (r.code !== 0 || !m)
+        throw new Error(`export impossible (le backend tourne-t-il ?)\n${r.stderr}`);
+    const campaigns = JSON.parse(m[1]);
+    const dirOut = path.join(target, "config", "campaigns");
+    fs.mkdirSync(dirOut, { recursive: true });
+    for (const [slug, c] of Object.entries(campaigns)) {
+        fs.writeFileSync(path.join(dirOut, `${slug}.json`), JSON.stringify(c, null, 2) + "\n");
+        console.log(`← ${slug}`);
+    }
+}
+export async function campaignImport(dir, only, yes) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const slugs = only.length ? only : p.boutiques.map((b) => b.slug);
+    const data = {};
+    for (const slug of slugs) {
+        const file = path.join(target, "config", "campaigns", `${slug}.json`);
+        if (!fs.existsSync(file))
+            throw new ProjectError(`fichier manquant : ${file}`);
+        data[slug] = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    if (!yes) {
+        const { confirm, isCancel } = await import("@clack/prompts");
+        const ok = await confirm({ message: `Écraser en base la campagne de ${slugs.join(", ")} (modifications faites dans l'admin perdues) ?`, initialValue: false });
+        if (isCancel(ok) || !ok)
+            return console.log("Rien n'a été importé.");
+    }
+    const r = composeOutput(target, ["exec", "-T", "-e", `CAMPAIGN_IMPORT=${Buffer.from(JSON.stringify(data)).toString("base64")}`, "backend", "npx", "medusa", "exec", "./src/scripts/campaign-import.js"]);
+    if (r.code !== 0 || !/campagne\(s\) importée/.test(r.stdout))
+        throw new Error(`import impossible\n${r.stdout}\n${r.stderr}`);
+    console.log(pc.green(`✔ ${slugs.length} campagne(s) importée(s) (visibles sur les boutiques en ~1 min)`));
+}
+/**
+ * Test de bout en bout, pour chaque boutique : backend en ligne, boutique en ligne avec son thème,
+ * produit avec un prix dans sa devise, commande complète en paiement manuel (panier → adresse →
+ * livraison → paiement → commande). Signale aussi ce qui manque (Stripe, e-mails).
+ */
+export async function check(dir) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const env = readEnv(target);
+    const backend = `http://localhost:${p.apiPort}`;
+    let failed = 0;
+    const health = await fetch(`${backend}/health`).then((r) => r.ok).catch(() => false);
+    console.log(`${health ? pc.green("OK") : pc.red("KO")}  backend ${backend}`);
+    if (!health)
+        throw new Error("le backend ne répond pas : docker compose up -d, puis docker compose logs backend");
+    for (const b of p.boutiques) {
+        const e = effective(p, b);
+        const steps = [];
+        try {
+            const url = b.url ?? `http://localhost:${b.port}`;
+            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}"`))
+                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();
+            if (!key.startsWith("pk_"))
+                throw new Error("publishable key absente (seed du backend ?)");
+            const store = async (pathname, init) => {
+                const r = await fetch(`${backend}${pathname}`, {
+                    method: init?.method ?? "GET",
+                    headers: { "x-publishable-api-key": key, "content-type": "application/json" },
+                    body: init?.body ? JSON.stringify(init.body) : undefined,
+                });
+                const json = await r.json().catch(() => ({}));
+                if (!r.ok)
+                    throw new Error(`${pathname} → ${r.status} ${json.message ?? ""}`);
+                return json;
+            };
+            const { regions } = await store("/store/regions");
+            const region = regions.find((r) => r.currency_code === e.currency && r.countries.some((c) => c.iso_2 === e.country));
+            if (!region)
+                throw new Error(`aucune région ${e.currency.toUpperCase()} contenant ${e.country}`);
+            const { products } = await store(`/store/products?region_id=${region.id}&fields=*variants.calculated_price&limit=50`);
+            const variant = products.flatMap((pr) => pr.variants ?? []).find((v) => v.calculated_price?.calculated_amount != null);
+            if (!variant)
+                throw new Error(`aucun produit avec un prix en ${e.currency.toUpperCase()}`);
+            steps.push("prix");
+            const { cart } = await store("/store/carts", { method: "POST", body: { region_id: region.id } });
+            await store(`/store/carts/${cart.id}/line-items`, { method: "POST", body: { variant_id: variant.id, quantity: 1 } });
+            const address = { first_name: "Check", last_name: "Boutique", address_1: "1 Test Street", city: "Test", postal_code: "10001", country_code: e.country };
+            await store(`/store/carts/${cart.id}`, { method: "POST", body: { email: "check@example.com", shipping_address: address, billing_address: address } });
+            const { shipping_options } = await store(`/store/shipping-options?cart_id=${cart.id}`);
+            if (!shipping_options?.length)
+                throw new Error(`aucune livraison vers ${e.country}`);
+            await store(`/store/carts/${cart.id}/shipping-methods`, { method: "POST", body: { option_id: shipping_options[0].id } });
+            const { payment_collection } = await store("/store/payment-collections", { method: "POST", body: { cart_id: cart.id } });
+            await store(`/store/payment-collections/${payment_collection.id}/payment-sessions`, { method: "POST", body: { provider_id: "pp_system_default" } });
+            const done = await store(`/store/carts/${cart.id}/complete`, { method: "POST" });
+            if (done.type !== "order")
+                throw new Error(`commande non créée : ${done.error?.message ?? "?"}`);
+            steps.push(`commande #${done.order.display_id}`);
+            console.log(`${pc.green("OK")}  ${b.slug.padEnd(24)} ${steps.join(" → ")}`);
+        }
+        catch (err) {
+            failed++;
+            console.log(`${pc.red("KO")}  ${b.slug.padEnd(24)} ${steps.join(" → ")}${steps.length ? " → " : ""}${pc.red(err.message)}`);
+        }
+    }
+    if (!env.STRIPE_API_KEY)
+        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"));
+    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`);
+}
+// ─────────────────────────── admin / guide ───────────────────────────
+/** Accès à l'admin du projet (lus dans .env). Le mot de passe s'affiche seulement sur cette machine. */
+export function admin(dir) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const env = readEnv(target);
+    console.log(`Admin        http://localhost:${p.apiPort}/app`);
+    console.log(`E-mail       ${env.ADMIN_EMAIL ?? "?"}`);
+    console.log(`Mot de passe ${env.ADMIN_PASSWORD ?? "?"}`);
+    console.log(pc.dim("À transmettre au client séparément de la fiche (jamais par le même canal). Il peut le changer ensuite : « Mot de passe oublié ? » sur la page de connexion."));
+}
+/** Régénère la fiche client (1 page) et le guide complet du projet. */
+export function guide(dir) {
+    const target = path.resolve(dir);
+    const p = readProject(target);
+    const env = readEnv(target);
+    for (const r of writeGuides(target, p, env.ADMIN_EMAIL ?? p.defaults.merchantEmail ?? "")) {
+        console.log(`${r.pdf ? pc.green("✔") : pc.yellow("!")} ${path.basename(r.file)}${r.pdf ? "" : " (Chrome/Edge introuvable : à imprimer en PDF)"}`);
+    }
+}
+// ─────────────────────────── stripe-webhook ───────────────────────────
+const STRIPE_EVENTS = [
+    "payment_intent.succeeded",
+    "payment_intent.payment_failed",
+    "payment_intent.amount_capturable_updated",
+    "payment_intent.partially_funded",
+];
+/** Remplace (ou ajoute) une variable du .env sans toucher aux autres. */
+function setEnvValue(target, key, value) {
+    const file = path.join(target, ".env");
+    let text = fs.readFileSync(file, "utf8");
+    const re = new RegExp(`^${key}=.*$`, "m");
+    text = re.test(text) ? text.replace(re, `${key}=${value}`) : `${text.trimEnd()}\n${key}=${value}\n`;
+    fs.writeFileSync(file, text);
+}
+/**
+ * Crée le webhook Stripe du projet (adresse publique du backend) avec la clé STRIPE_API_KEY du .env,
+ * écrit le secret whsec_… dans STRIPE_WEBHOOK_SECRET et relance le backend.
+ * Relançable : un webhook existant sur la même URL est remplacé (Stripe ne redonne jamais un secret).
+ */
+export async function stripeWebhook(dir, backendUrl, opts) {
+    const target = path.resolve(dir);
+    readProject(target);
+    const env = readEnv(target);
+    const key = env.STRIPE_API_KEY;
+    if (!key?.startsWith("sk_"))
+        throw new ProjectError("STRIPE_API_KEY (sk_…) absente du .env : ajoutez les clés Stripe d'abord");
+    if (!backendUrl || !/^https:\/\/[^/]+/.test(backendUrl) || /localhost|127\.0\.0\.1/.test(backendUrl)) {
+        throw new ProjectError("--url <adresse publique HTTPS du backend> obligatoire (ex. https://api.marque.com) : Stripe ne peut pas joindre localhost");
+    }
+    const url = `${backendUrl.replace(/\/$/, "")}/hooks/payment/stripe_stripe`;
+    const stripe = async (p, method = "GET", body) => {
+        const r = await fetch(`https://api.stripe.com/v1${p}`, { method, headers: { authorization: `Bearer ${key}` }, body });
+        const j = await r.json();
+        if (!r.ok)
+            throw new Error(`Stripe : ${j.error?.message ?? r.status}`);
+        return j;
+    };
+    const { data: existing } = await stripe("/webhook_endpoints?limit=100");
+    for (const w of existing.filter((w) => w.url === url)) {
+        await stripe(`/webhook_endpoints/${w.id}`, "DELETE");
+        console.log(`ancien webhook ${w.id} remplacé`);
+    }
+    const body = new URLSearchParams({ url, description: `create-boutique ${path.basename(target)}` });
+    for (const e of STRIPE_EVENTS)
+        body.append("enabled_events[]", e);
+    const created = await stripe("/webhook_endpoints", "POST", body);
+    setEnvValue(target, "STRIPE_WEBHOOK_SECRET", created.secret);
+    console.log(pc.green(`✔ webhook Stripe créé (${key.startsWith("sk_live") ? "production" : "test"}) : ${url}`));
+    console.log(pc.green("✔ STRIPE_WEBHOOK_SECRET écrit dans .env"));
+    if (opts.up && compose(target, ["up", "-d"]) !== 0)
+        throw new Error("docker compose up a échoué");
+}

package/cli/dist/create.js

@@ -0,0 +1,194 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { z } from "zod";
+import { composeYaml, writeCampaignFiles, writeEnv, writeReadme } from "./generate.js";
+import { writeGuides } from "./guide.js";
+import { copyDir, TEMPLATES, templateVersion } from "./paths.js";
+import { nextFreePort, reservedByOthers, reservePorts } from "./ports.js";
+import { 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({
+    name: z.string().min(1).max(60).optional(),
+    email: z.email().optional(),
+    currency: z.string().regex(/^[a-z]{3}$/).optional(),
+    country: z.string().regex(/^[a-z]{2}$/).optional(),
+    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(),
+    stripePk: z.string().optional(),
+    stripeSk: z.string().optional(),
+    stripeWhsec: z.string().optional(),
+    resendKey: z.string().optional(),
+    emailFrom: z.email().optional(),
+    products: z.string().optional(),
+    images: z.string().optional(),
+    storePort: z.number().int().optional(),
+    apiPort: z.number().int().optional(),
+    storagePort: z.number().int().optional(),
+});
+const cancelled = (v) => {
+    if (p.isCancel(v)) {
+        p.cancel("Création annulée.");
+        process.exit(1);
+    }
+    return v;
+};
+const slugify = (s) => s
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+/** Complète les réponses manquantes par des questions (sauf --yes : valeurs par défaut). */
+async function ask(a, dirName, yes) {
+    const themes = listThemes();
+    if (yes) {
+        if (!a.email)
+            throw new ProjectError("--email est obligatoire avec --yes");
+        return {
+            ...a,
+            name: a.name ?? dirName,
+            email: a.email,
+            currency: a.currency ?? "usd",
+            country: a.country ?? "us",
+            language: a.language ?? "en",
+            themes: a.themes ?? (a.boutiques?.length ? [] : "all"),
+        };
+    }
+    p.intro(pc.inverse(" create-boutique "));
+    const name = a.name ?? cancelled(await p.text({ message: "Nom de la boutique", initialValue: dirName, validate: (v) => (v?.trim() ? undefined : "obligatoire") }));
+    const email = a.email ?? cancelled(await p.text({ message: "E-mail admin (et du marchand)", validate: (v) => (z.email().safeParse(v).success ? undefined : "e-mail invalide") }));
+    const currency = a.currency ?? cancelled(await p.text({ message: "Devise (code ISO)", initialValue: "usd", validate: (v) => (/^[a-z]{3}$/.test(v ?? "") ? undefined : "ex. usd, eur, xof") }));
+    const country = a.country ?? cancelled(await p.text({ message: "Pays principal (code ISO)", initialValue: "us", validate: (v) => (/^[a-z]{2}$/.test(v ?? "") ? undefined : "ex. us, fr, sn") }));
+    const language = a.language ?? cancelled(await p.text({ message: "Langue du site", initialValue: "en", validate: (v) => (/^[a-z]{2}$/.test(v ?? "") ? undefined : "ex. en, fr") }));
+    let chosen = a.themes;
+    if (!chosen) {
+        chosen = cancelled(await p.multiselect({
+            message: "Thèmes (une boutique par thème ; espace = cocher)",
+            options: themes.map((t) => ({ value: t.id, label: t.id, hint: t.name })),
+            initialValues: themes.map((t) => t.id),
+            required: false,
+        }));
+    }
+    const extra = [...(a.boutiques ?? [])];
+    if (!a.boutiques) {
+        while (cancelled(await p.confirm({ message: "Ajouter une autre boutique ?", initialValue: false }))) {
+            const slug = cancelled(await p.text({ message: "Nom (slug) de la boutique", validate: (v) => (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v ?? "") ? undefined : "minuscules, chiffres et tirets") }));
+            const theme = cancelled(await p.select({ message: "Thème", options: themes.map((t) => ({ value: t.id, label: t.id })) }));
+            extra.push(`${slug}:${theme}`);
+        }
+    }
+    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;
+    const products = a.products ?? (cancelled(await p.text({ message: "Fichier produits (CSV, optionnel)", defaultValue: "" })) || undefined);
+    const images = a.images ?? (cancelled(await p.text({ message: "Dossier images (optionnel)", defaultValue: "" })) || undefined);
+    return { ...a, name, email, currency, country, language, themes: chosen, boutiques: extra, stripePk, stripeSk, products, images };
+}
+export async function create(dir, input, opts) {
+    const target = path.resolve(dir);
+    if (fs.existsSync(target) && fs.readdirSync(target).length) {
+        throw new ProjectError(`le dossier ${target} existe déjà et n'est pas vide`);
+    }
+    const project = slugify(path.basename(target));
+    if (!project)
+        throw new ProjectError("nom de dossier invalide");
+    const a = await ask(input, path.basename(target), opts.yes);
+    // Boutiques : une par thème coché (slug = <projet>-<thème>) + --boutique slug:thème
+    const known = themeIds();
+    const themeList = a.themes === "all" ? known : (a.themes ?? []);
+    for (const t of themeList)
+        if (!known.includes(t))
+            throw new ProjectError(`thème inconnu : ${t} (disponibles : ${known.join(", ")})`);
+    const wanted = [
+        ...themeList.map((t) => ({ slug: `${project}-${t}`, theme: t })),
+        ...(a.boutiques ?? []).map((s) => {
+            const [slug, theme] = s.split(":");
+            return { slug, theme };
+        }),
+    ];
+    if (!wanted.length)
+        throw new ProjectError("au moins une boutique est obligatoire (--themes ou --boutique)");
+    // Ports : libres sur la machine et non réservés par un autre projet généré.
+    const taken = reservedByOthers(target);
+    const apiPort = await nextFreePort(a.apiPort ?? 9000, taken);
+    taken.add(apiPort);
+    const storagePort = await nextFreePort(a.storagePort ?? 9100, taken);
+    taken.add(storagePort);
+    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 });
+    }
+    const proj = validateProject({
+        project,
+        templateVersion: templateVersion(),
+        apiPort,
+        storagePort,
+        defaults: {
+            storeName: a.name,
+            currency: a.currency,
+            country: a.country,
+            language: a.language,
+            shipsTo: "all",
+            merchantEmail: a.email,
+            email: { mode: "platform" },
+        },
+        boutiques,
+    });
+    // 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(14)}→ http://localhost:${b.port}`),
+        `${"Backend / admin".padEnd(width + 14)}→ http://localhost:${proj.apiPort}/app`,
+        `Devise ${a.currency.toUpperCase()} · pays ${a.country.toUpperCase()} · langue ${a.language}`,
+        `Paiement : ${a.stripeSk ? "Stripe + manuel" : "manuel (Stripe : non configuré)"}`,
+        `Catalogue : ${a.products ?? "aucun (à ajouter dans l'admin)"}`,
+    ];
+    if (opts.yes)
+        console.log(`\nRécapitulatif : ${proj.boutiques.length} boutique(s)\n  ${lines.join("\n  ")}\n`);
+    else {
+        p.note(lines.join("\n"), `Récapitulatif : ${proj.boutiques.length} boutique(s)`);
+        if (!cancelled(await p.confirm({ message: "Créer le projet ?", initialValue: true }))) {
+            p.cancel("Rien n'a été créé.");
+            return;
+        }
+    }
+    // Écriture du projet
+    copyDir(path.join(TEMPLATES, "storefront"), path.join(target, "storefront"));
+    copyDir(path.join(TEMPLATES, "backend"), path.join(target, "backend"));
+    writeProject(target, proj);
+    writeJsonSchema(target);
+    writeCampaignFiles(target, proj, a.language);
+    fs.mkdirSync(path.join(target, "seed", "images"), { recursive: true });
+    if (a.products)
+        fs.copyFileSync(path.resolve(a.products), path.join(target, "seed", "products.csv"));
+    if (a.images)
+        copyDir(path.resolve(a.images), path.join(target, "seed", "images"));
+    writeEnv(target, proj, {
+        adminEmail: a.email,
+        stripePk: a.stripePk,
+        stripeSk: a.stripeSk,
+        stripeWhsec: a.stripeWhsec,
+        resendKey: a.resendKey,
+        emailFrom: a.emailFrom,
+    });
+    fs.writeFileSync(path.join(target, "docker-compose.yml"), composeYaml(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)]);
+    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`;
+    if (opts.yes)
+        console.log(`Projet créé : ${target}\nEnsuite :\n  ${next.replace("\n", "\n  ")}\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).`);
+}

package/cli/dist/docker.js

@@ -0,0 +1,19 @@
+import { spawnSync } from "node:child_process";
+/** docker compose dans le dossier du projet (sortie affichée). Renvoie le code de sortie. */
+export function compose(dir, args, opts = {}) {
+    const r = spawnSync("docker", ["compose", ...args], { cwd: dir, stdio: "inherit", shell: false, ...opts });
+    if (r.error)
+        throw new Error(`docker introuvable : installez Docker (${r.error.message})`);
+    return r.status ?? 1;
+}
+/** docker compose avec sortie capturée. */
+export function composeOutput(dir, args, input) {
+    const r = spawnSync("docker", ["compose", ...args], { cwd: dir, encoding: "utf8", input, maxBuffer: 256 * 1024 * 1024 });
+    if (r.error)
+        throw new Error(`docker introuvable : installez Docker (${r.error.message})`);
+    return { code: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+export function isRunning(dir, service) {
+    const { stdout } = composeOutput(dir, ["ps", "--status", "running", "--services"]);
+    return stdout.split(/\r?\n/).includes(service);
+}