webcake-storefront-mcp 1.8.0 → 1.10.0

package/dist/builder/guide.js

@@ -53,6 +53,28 @@ already in this shape — see the \`responsive\` field on get_page_element/updat
 - Colours: prefer the site THEME variables \`var(--color_00)\`, \`var(--color_01)\`, …
   (the published site themes them); plain hex or rgba() also work.
 
+## Make it look DESIGNED (not plain) — do this, every page
+A bare stack of default elements looks unfinished. Apply real styling:
+- SECTIONS: new_section already gives ~56px top/bottom padding + a centred content column.
+  Add variety: give some sections a background (\`section_opts:{ style:{ background:"var(--color_01)" } }\`
+  or a light tint) and alternate so the page has rhythm. Increase padding (72–96px) for hero/CTA.
+- SPACING: children are stacked with a rowGap; bump it (\`section_opts:{ rowGap: 24 }\`) for airy
+  layouts. Don't cram.
+- TYPOGRAPHY hierarchy: h1 40–56px / fontWeight 700, h2 28–34px / 600, body 16–18px with
+  lineHeight "1.6", muted color for sub-text. Center hero text (textAlign:"center").
+- BUTTONS HAVE NO DEFAULT COLOUR — you MUST style them or they look like plain text:
+  \`{ type:"button", opts:{ text:"Mua ngay", style:{ background:"var(--color_02)", color:"#fff",
+  borderRadius:"8px", fontWeight:"600", height:48 } } }\`.
+- HERO: prefer a section with a background image + an overlay heading/sub/button on top
+  (set section_opts.style.background or a full-width image, then text centered), rather than a
+  small image stacked above text.
+- PRODUCT GRID: style the cards — \`grid-product opts.config\`: { columns:3-4, image_ratio:"1/1",
+  img_object_fit:"cover", gap_column:20, gap_row:28, cardBorderRadius:12, cardBoxShadow:"0 6px 24px rgba(0,0,0,.08)",
+  productNameColor:"var(--color_00)", productPriceColor:"var(--color_02)" }.
+- BRAND COLOURS: reuse var(--color_00) (text), and an accent (var(--color_02)/var(--color_03))
+  for buttons, prices, highlights — consistent accent = looks intentional.
+- IMAGES: must be WebCake-CDN urls (search_images cdn_url / upload_images), else they won't show.
+
 ## Responsive breakpoints
 The four breakpoints (largest → smallest), keyed bp1..bp4, are:
 - \`bp1\` ≥1320px (desktop, the base) · \`bp2\` 993–1319 (laptop) · \`bp3\` 641–992 (tablet) · \`bp4\` 320–640 (mobile).
@@ -64,7 +86,9 @@ key — only bp1..bp4.)
 
 ## Content & data
 - Text: \`specials.text\` (HTML allowed), \`specials.tag\` ("h1".."p").
-- Image: \`runtime.config.src\` (URL). Use search_images / upload before referencing.
+- Image: \`runtime.config.src\` (URL). The URL MUST be a WebCake CDN url — the storefront
+  whitelists image domains, so external URLs (Pexels, random sites) won't render. Get CDN
+  urls from search_images (uploads by default → use its cdn_url) or upload_images.
 - Form: wrap inputs in a \`form\`; set \`form.specials.type\`
   (form_order | form_login | form_signup | form_discount | order_tracking). Each input
   needs \`specials.field_name\`.

package/dist/builder/page.js

@@ -63,6 +63,7 @@ export function stackChildren(container, children, opts = {}) {
         grid: `${gridCols}x${children.length || 1}`,
         columns: opts.columns || [{ unit: "fr", value: 1 }],
         rows: rows.length ? rows : [{ unit: "min/max", min: { unit: "px", absValue: 50 }, max: { unit: "max-c" } }],
+        rowGap: opts.rowGap ?? 16, // breathing room between stacked children
         heightUnit: "auto",
     };
     children.forEach((child, i) => {
@@ -96,7 +97,16 @@ export function buildSection(childSpecs = [], sectionOpts = {}) {
         columns: genGridByBp(BREAKPOINTS.bp1[0]).columns,
         contentColStart: SECTION_CONTENT_COL_START,
         contentColEnd: SECTION_CONTENT_COL_END,
+        rowGap: sectionOpts.rowGap,
     });
+    // Give sections vertical breathing room by default (a plain edge-to-edge stack looks
+    // unfinished). Caller can override via sectionOpts.style.
+    section.runtime = section.runtime || {};
+    section.runtime.style = {
+        paddingTop: 56,
+        paddingBottom: 56,
+        ...(sectionOpts.style || {}),
+    };
     return section;
 }
 function buildFromSpec(spec) {

package/dist/changelog.json

@@ -1,4 +1,18 @@
 [
+  {
+    "v": "1.10.0",
+    "d": "24/06/2026",
+    "type": "Added",
+    "en": "New scaffold_store_pages tool creates the standard storefront pages (Category, Product, Cart, Checkout, Thank-you) so navigation links resolve…",
+    "vi": "Tool mới scaffold_store_pages tạo các trang storefront tiêu chuẩn (Category, Product, Cart, Checkout, Thank-you) để các liên kết điều hướng không bị…"
+  },
+  {
+    "v": "1.9.0",
+    "d": "24/06/2026",
+    "type": "Added",
+    "en": "search_images now accepts an upload parameter (default true) that re-hosts each Pexels result on the WebCake CDN and adds a cdn_url field to every…",
+    "vi": "search_images nay nhận thêm tham số upload (mặc định true) để tự động tải từng kết quả Pexels lên WebCake CDN và bổ sung trường cdn_url vào mỗi ảnh,…"
+  },
   {
     "v": "1.8.0",
     "d": "23/06/2026",
@@ -26,19 +40,5 @@
     "type": "Fixed",
     "en": "build_page now passes the finalized page source to create_page in the initial create call (required by the backend), then sets slug and is_homepage…",
     "vi": "build_page nay truyền source trang đã hoàn thiện vào lời gọi create_page ban đầu (bắt buộc bởi backend), sau đó đặt slug và is_homepage qua một lời…"
-  },
-  {
-    "v": "1.5.0",
-    "d": "23/06/2026",
-    "type": "Added",
-    "en": "New create_product tool creates a storefront product (simple name + price, or advanced with named attributes and per-SKU variations); accepts hosted…",
-    "vi": "Tool mới create_product tạo sản phẩm cho storefront (đơn giản với tên + giá, hoặc nâng cao với attributes và variations theo từng SKU); nhận URL ảnh…"
-  },
-  {
-    "v": "1.4.0",
-    "d": "23/06/2026",
-    "type": "Changed",
-    "en": "The install command's interactive wizard now presents numbered choices with ANSI colour output and a completion summary.",
-    "vi": "Trình hướng dẫn tương tác của lệnh install nay hiển thị các lựa chọn được đánh số kèm màu ANSI và thông báo tóm tắt sau khi hoàn tất."
   }
 ]

package/dist/db.js

@@ -43,3 +43,18 @@ export function delConfig(key) {
 export function getAllConfig() {
     return { ...config };
 }
+// ── Image upload cache (source URL/path → WebCake CDN URL, per site) ──────────
+// Re-hosting the same stock photo / external image twice wastes an upload, so we
+// remember the CDN URL the first time. Keyed by site because CDN URLs are per-site.
+const IMAGE_CACHE_FILE = join(CONFIG_DIR, "image-cache.json");
+const imageCache = readJson(IMAGE_CACHE_FILE, {});
+export function getCachedUpload(siteId, source) {
+    const k = `${siteId}::${source}`;
+    return k in imageCache ? imageCache[k] : null;
+}
+export function setCachedUpload(siteId, source, cdnUrl) {
+    if (!siteId || !source || !cdnUrl)
+        return;
+    imageCache[`${siteId}::${source}`] = cdnUrl;
+    writeJson(IMAGE_CACHE_FILE, imageCache);
+}

package/dist/persistence/imageCache.js

@@ -0,0 +1,42 @@
+// Image-upload cache (source URL/path → WebCake CDN URL), keyed per site.
+//
+// WHERE IT LIVES:
+//   - Remote (`serve`) with REDIS_URL set → Redis (shared across all requests/instances,
+//     survives container restarts/redeploys; this is the right place for multi-user mode).
+//   - stdio / npx / no Redis → a local JSON file (~/.webcake-storefront-mcp/image-cache.json)
+//     via db.ts. Single-user, persists on the user's machine.
+// Redis is tried first; on any Redis miss/error we fall back to the file store, so the
+// cache degrades gracefully and never blocks an upload.
+import { getRedis } from "./redis.js";
+import { getCachedUpload as fileGet, setCachedUpload as fileSet } from "../db.js";
+const TTL_MS = 1000 * 60 * 60 * 24 * 30; // 30 days — CDN urls are effectively permanent
+const redisKey = (siteId, source) => `imgc:${siteId}:${source}`;
+export async function getCachedUpload(siteId, source) {
+    const redis = getRedis();
+    if (redis) {
+        try {
+            const v = await redis.get(redisKey(siteId, source));
+            if (v)
+                return v;
+        }
+        catch {
+            /* fall through to the file store */
+        }
+    }
+    return fileGet(siteId, source);
+}
+export async function setCachedUpload(siteId, source, cdnUrl) {
+    if (!siteId || !source || !cdnUrl)
+        return;
+    const redis = getRedis();
+    if (redis) {
+        try {
+            await redis.set(redisKey(siteId, source), cdnUrl, "PX", TTL_MS);
+            return;
+        }
+        catch {
+            /* fall through to the file store */
+        }
+    }
+    fileSet(siteId, source, cdnUrl);
+}

package/dist/tools/builder-extras.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { resolvePreviewUrl } from "../config.js";
+import { getCachedUpload, setCachedUpload } from "../persistence/imageCache.js";
 import { parse as parseHtml } from "node-html-parser";
 import { stat, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -55,14 +56,49 @@ async function toAllowedImage(buf, contentType) {
     const out = await sharp(buf).jpeg({ quality: 85 }).toBuffer();
     return { buf: out, contentType: "image/jpeg" };
 }
+/** Re-host one external image (http(s) URL or data: URI) on the WebCake CDN, with a
+ *  per-site cache so the same source is never uploaded twice. Returns the hosted URL.
+ *  The storefront only renders whitelisted (WebCake CDN) image domains, so every image
+ *  used on a page/product MUST go through this — external URLs (Pexels, etc.) won't show. */
+async function cdnUpload(api, source) {
+    const cached = await getCachedUpload(api.siteId, source);
+    if (cached)
+        return cached;
+    let buf, contentType;
+    if (source.startsWith("data:")) {
+        const m = source.match(/^data:([^;]+);base64,(.*)$/s);
+        if (!m)
+            throw new Error("Malformed data URI.");
+        contentType = m[1];
+        buf = Buffer.from(m[2], "base64");
+    }
+    else {
+        ({ buf, contentType } = await fetchBuffer(source));
+    }
+    const norm = await toAllowedImage(buf, contentType);
+    const dataUri = `data:${norm.contentType};base64,${norm.buf.toString("base64")}`;
+    const res = await api.uploadImageBase64({ base64: dataUri, content_type: norm.contentType });
+    const hosted = (res && res.data) || (res && res.url) || null;
+    if (!hosted)
+        throw new Error("Upload returned no URL.");
+    await setCachedUpload(api.siteId, source, hosted);
+    return hosted;
+}
 export function registerBuilderExtraTools(server, api, handle, opts = {}) {
     // ── Stock images (Pexels) ──────────────────────────────────────────────────
-    server.tool("search_images", `Search stock photos (Pexels) to use on a page. Returns hosted image URLs you can put straight into an image element's runtime.config.src.
+    server.tool("search_images", `Search stock photos (Pexels) for a page/product. IMPORTANT: the storefront only renders
+images served from the WebCake CDN (image domains are whitelisted) — raw Pexels URLs will
+NOT display. By default this re-hosts each result on the WebCake CDN and returns a ready-to-use
+cdn_url (cached, so repeats are free). Use cdn_url for image src / product images.
 Requires the PEXELS_API_KEY environment variable.`, {
         query: z.string().describe("Subject to search, e.g. 'coffee shop interior'"),
         per_page: z.number().min(1).max(30).default(6).describe("How many results (default 6)"),
         orientation: z.enum(["landscape", "portrait", "square"]).optional().describe("Preferred orientation"),
-    }, ({ query, per_page, orientation }) => handle(async () => {
+        upload: z
+            .boolean()
+            .default(true)
+            .describe("Re-host each result on the WebCake CDN and return cdn_url (default true — required for the image to show). Set false to only browse Pexels URLs."),
+    }, ({ query, per_page, orientation, upload }) => handle(async () => {
         const key = process.env.PEXELS_API_KEY;
         if (!key)
             return { error: "PEXELS_API_KEY env var is not set. Add it to use stock image search." };
@@ -75,7 +111,7 @@ Requires the PEXELS_API_KEY environment variable.`, {
         if (!res.ok)
             return { error: `Pexels error ${res.status}` };
         const json = await res.json();
-        const photos = (json.photos || []).map((p) => ({
+        let photos = (json.photos || []).map((p) => ({
             url: p.src && (p.src.large || p.src.original),
             thumbnail: p.src && p.src.medium,
             width: p.width,
@@ -84,10 +120,28 @@ Requires the PEXELS_API_KEY environment variable.`, {
             credit: p.photographer,
             source: p.url,
         }));
-        return { query, total_results: json.total_results, photos };
+        if (upload) {
+            photos = await Promise.all(photos.map(async (ph) => {
+                try {
+                    return { ...ph, cdn_url: await cdnUpload(api, ph.url) };
+                }
+                catch (e) {
+                    return { ...ph, cdn_url: null, upload_error: e?.message ?? String(e) };
+                }
+            }));
+        }
+        return {
+            query,
+            total_results: json.total_results,
+            uploaded_to_cdn: upload,
+            note: upload
+                ? "Use each photo's cdn_url (WebCake-hosted) for image src / product images — NOT url (Pexels, not whitelisted)."
+                : "These are Pexels URLs and will NOT render on the storefront. Run upload_images (or upload:true) to re-host them on the CDN first.",
+            photos,
+        };
     }));
     // ── Upload images to the site CDN ───────────────────────────────────────────
-    server.tool("upload_images", `Convert external image URLs, data: URIs, or LOCAL FILE PATHS into site-hosted CDN URLs by reading/downloading each image and re-uploading it to the WebCake backend. Use this whenever the user supplies their OWN images (their URLs or files from their machine), or a page is built from a reference HTML/URL. The returned hosted URLs go straight into an image element's specials.src / runtime.config.src — same as search_images results. Stock photos from search_images are already hosted and don't need uploading.
+    server.tool("upload_images", `Convert external image URLs, data: URIs, or LOCAL FILE PATHS into site-hosted CDN URLs by reading/downloading each image and re-uploading it to the WebCake backend. Use this whenever the user supplies their OWN images (their URLs or files from their machine), or a page is built from a reference HTML/URL. The returned CDN URLs go straight into an image element's specials.src / runtime.config.src, or a product/category image. This is REQUIRED for any external image (incl. Pexels search results) because the storefront only renders whitelisted WebCake-CDN image domains. Results are cached per site, so re-uploading the same source is free.
 Processes up to 20 entries per call in parallel; non jpeg/png/webp inputs are converted to JPEG. UPLOADS BY DEFAULT (dry_run defaults to FALSE — this touches no account data): returns an "images" map (original source → hosted URL). Pass dry_run:true to only preview the entries that WOULD be processed (local paths report whether the file exists + its size) without any network/filesystem upload. Local file paths are only permitted when the MCP server runs locally (stdio); on the remote HTTP transport they are rejected per-entry.`, {
         urls: z
             .array(z.string())
@@ -124,29 +178,28 @@ Processes up to 20 entries per call in parallel; non jpeg/png/webp inputs are co
         const errors = [];
         await Promise.all(deduped.map(async (entry) => {
             try {
-                let buf, contentType;
-                if (entry.startsWith("data:")) {
-                    const m = entry.match(/^data:([^;]+);base64,(.*)$/s);
-                    if (!m)
-                        throw new Error("Malformed data URI.");
-                    contentType = m[1];
-                    buf = Buffer.from(m[2], "base64");
-                }
-                else if (isLocalPath(entry)) {
+                if (isLocalPath(entry)) {
                     if (!localAllowed)
                         throw new Error("Local file paths are only supported when the server runs locally (stdio). Send a public URL or data: URI instead.");
-                    ({ buf, contentType } = await readLocalImage(entry));
+                    const cached = await getCachedUpload(api.siteId, entry);
+                    if (cached) {
+                        images[entry] = cached;
+                        return;
+                    }
+                    const { buf, contentType } = await readLocalImage(entry);
+                    const norm = await toAllowedImage(buf, contentType);
+                    const dataUri = `data:${norm.contentType};base64,${norm.buf.toString("base64")}`;
+                    const res = await api.uploadImageBase64({ base64: dataUri, content_type: norm.contentType });
+                    const hosted = (res && res.data) || (res && res.url) || null;
+                    if (!hosted)
+                        throw new Error("Upload returned no URL.");
+                    await setCachedUpload(api.siteId, entry, hosted);
+                    images[entry] = hosted;
                 }
                 else {
-                    ({ buf, contentType } = await fetchBuffer(entry));
+                    // http(s) URL or data: URI — cdnUpload handles fetch/convert/upload + cache.
+                    images[entry] = await cdnUpload(api, entry);
                 }
-                const norm = await toAllowedImage(buf, contentType);
-                const dataUri = `data:${norm.contentType};base64,${norm.buf.toString("base64")}`;
-                const res = await api.uploadImageBase64({ base64: dataUri, content_type: norm.contentType });
-                const hosted = (res && res.data) || (res && res.url) || null;
-                if (!hosted)
-                    throw new Error("Upload returned no URL.");
-                images[entry] = hosted;
             }
             catch (e) {
                 errors.push({ url: entry, error: e?.message ?? String(e) });

package/dist/tools/builder.js

@@ -165,4 +165,123 @@ Two-step safety: dry_run=true (default) previews; dry_run=false saves.`, {
             page_source_id: saved && saved.data && saved.data.id,
         };
     }));
+    server.tool("scaffold_store_pages", `Create the standard STOREFRONT pages a shop needs so navigation works — clicking a
+product/category/cart from any page lands on a real page instead of a 404.
+Creates only the ones MISSING (matched by slug): Category (collections), Product (products),
+Cart (cart), Checkout (checkout), Thank-you (complete) — all type 'store' (enables use_store),
+plus optional member (login/register/profile) and blog (blog/post) pages.
+Run this right after you create products/categories. dry_run=true (default) previews.`, {
+        include_member: z.boolean().default(false).describe("Also create login/register/profile (type member, use_member)"),
+        include_blog: z.boolean().default(false).describe("Also create blog list + post pages (type blog, use_blog)"),
+        dry_run: z.boolean().default(true).describe("Preview (true) or actually create the missing pages (false)"),
+    }, ({ include_member, include_blog, dry_run }) => handle(async () => {
+        const bind = (name, field) => ({
+            id: "BINDING" + Math.random().toString(36).slice(2, 8),
+            name,
+            target: `${name}::${field}`,
+        });
+        const h1 = (text) => ({ type: "text", opts: { text, specials: { tag: "h1" }, style: { fontSize: "32px", fontWeight: "700" } } });
+        const accentBtn = (text, type = "button") => ({ type, opts: { text, style: { background: "var(--color_02)", color: "#fff", borderRadius: "8px", height: 48, fontWeight: "600" } } });
+        // Each spec: { name, slug, kind, build() -> { sections } }
+        const SPECS = [
+            { name: "Category Page", slug: "collections", kind: "store", flag: "use_store", build: () => ({ sections: [
+                        buildSection([h1("Danh mục sản phẩm"), { type: "grid-product", opts: { config: { columns: 3, image_ratio: "1/1", gap_column: 24, gap_row: 32 } } }]),
+                    ] }) },
+            { name: "Product Page", slug: "products", kind: "store", flag: "use_store", build: () => ({ sections: [
+                        buildSection([
+                            { type: "product-gallery", opts: {} },
+                            { type: "text-dataset", opts: { bindings: [bind("product", "product_name")], style: { fontSize: "28px", fontWeight: "700" } } },
+                            { type: "text-dataset", opts: { bindings: [bind("product", "product_price")], style: { fontSize: "22px", fontWeight: "700", color: "var(--color_02)" } } },
+                            { type: "quantity-input", opts: {} },
+                            accentBtn("Thêm vào giỏ"),
+                        ]),
+                    ] }) },
+            { name: "Cart Page", slug: "cart", kind: "store", flag: "use_store", build: () => ({ sections: [
+                        buildSection([h1("Giỏ hàng"), { type: "cart-items", opts: {} }, accentBtn("Tiến hành thanh toán")]),
+                    ] }) },
+            { name: "Checkout Page", slug: "checkout", kind: "store", flag: "use_store", build: () => ({ sections: [
+                        buildSection([
+                            h1("Thanh toán"),
+                            { type: "form", opts: { specials: { type: "form_order" } }, children: [
+                                    { type: "input", opts: { specials: { field_name: "full_name", label: "Họ tên", placeholder: "Họ tên", required: true, show_label: true } } },
+                                    { type: "phone-number", opts: { specials: { field_name: "phone_number", label: "Số điện thoại", required: true, show_label: true } } },
+                                    { type: "address", opts: { specials: { field_name: "address", label: "Địa chỉ", show_label: true } } },
+                                    accentBtn("Đặt hàng", "submit-button"),
+                                ] },
+                        ]),
+                    ] }) },
+            { name: "Thank You Page", slug: "complete", kind: "store", flag: "use_store", build: () => ({ sections: [
+                        buildSection([h1("Cảm ơn bạn đã đặt hàng!"), { type: "order-items", opts: {} }]),
+                    ] }) },
+        ];
+        if (include_member) {
+            SPECS.push({ name: "Login Page", slug: "login", kind: "member", flag: "use_member", build: () => ({ sections: [
+                        buildSection([h1("Đăng nhập"), { type: "form", opts: { specials: { type: "form_login" } }, children: [
+                                    { type: "identity", opts: { specials: { field_name: "identity", label: "Email / SĐT", required: true, show_label: true } } },
+                                    { type: "password", opts: { specials: { field_name: "password", label: "Mật khẩu", required: true, show_label: true } } },
+                                    accentBtn("Đăng nhập", "submit-button"),
+                                ] }]),
+                    ] }) }, { name: "Register Page", slug: "register", kind: "member", flag: "use_member", build: () => ({ sections: [
+                        buildSection([h1("Đăng ký"), { type: "form", opts: { specials: { type: "form_signup" } }, children: [
+                                    { type: "input", opts: { specials: { field_name: "full_name", label: "Họ tên", required: true, show_label: true } } },
+                                    { type: "email", opts: { specials: { field_name: "email", label: "Email", required: true, show_label: true } } },
+                                    { type: "password", opts: { specials: { field_name: "password", label: "Mật khẩu", required: true, show_label: true } } },
+                                    accentBtn("Tạo tài khoản", "submit-button"),
+                                ] }]),
+                    ] }) }, { name: "Profile Page", slug: "profile", kind: "member", flag: "use_member", build: () => ({ sections: [
+                        buildSection([h1("Tài khoản"), { type: "order-history", opts: {} }, { type: "customer-address", opts: {} }]),
+                    ] }) });
+        }
+        if (include_blog) {
+            SPECS.push({ name: "Blog", slug: "blog", kind: "blog", flag: "use_blog", build: () => ({ sections: [buildSection([h1("Bài viết"), { type: "post-list", opts: {} }])] }) }, { name: "Post", slug: "post", kind: "blog", flag: "use_blog", build: () => ({ sections: [buildSection([{ type: "post-overlay", opts: {} }])] }) });
+        }
+        // What already exists?
+        const pagesRes = await api.listPages();
+        const pages = (pagesRes && pagesRes.data) || pagesRes || [];
+        const existingSlugs = new Set((Array.isArray(pages) ? pages : []).map((p) => (p.slug || "").replace(/^\//, "")));
+        const missing = SPECS.filter((s) => !existingSlugs.has(s.slug));
+        const skipped = SPECS.filter((s) => existingSlugs.has(s.slug)).map((s) => s.slug);
+        if (dry_run) {
+            return {
+                dry_run: true,
+                will_create: missing.map((s) => ({ name: s.name, slug: s.slug, type: s.kind })),
+                already_exist: skipped,
+                hint: "Call again with dry_run=false to create the missing pages so product/category/cart links resolve.",
+            };
+        }
+        const created = [];
+        const errors = [];
+        const flagsEnabled = new Set();
+        for (const spec of missing) {
+            try {
+                if (!flagsEnabled.has(spec.flag)) {
+                    await api.enableSiteFeature(spec.flag).catch(() => { });
+                    flagsEnabled.add(spec.flag);
+                }
+                const source = spec.build();
+                const validation = validatePage(source);
+                if (!validation.valid) {
+                    errors.push({ slug: spec.slug, validation });
+                    continue;
+                }
+                finalizeForRender(source);
+                const res = await api.createPage({ name: spec.name, source, type: PAGE_TYPE_NUM[spec.kind] });
+                const pid = newPageId(res);
+                if (pid)
+                    await api.updatePage(pid, { slug: spec.slug }).catch(() => { });
+                created.push({ name: spec.name, slug: spec.slug, type: spec.kind, page_id: pid });
+            }
+            catch (e) {
+                errors.push({ slug: spec.slug, error: e?.message ?? String(e) });
+            }
+        }
+        return {
+            success: true,
+            created,
+            already_exist: skipped,
+            ...(errors.length ? { errors } : {}),
+            data_sources_enabled: [...flagsEnabled],
+            note: "Publish the site (publish_site) to take the new pages live.",
+        };
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webcake-storefront-mcp",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "MCP server for the WebCake/StoreCake storefront builder — page CRUD, page authoring, products, orders, and more",
   "mcpName": "io.github.vuluu2k/webcake-storefront-mcp",
   "license": "MIT",