webcake-landing-mcp 1.6.0 → 1.6.2

package/dist/changelog.json

@@ -1,4 +1,18 @@
 [
+  {
+    "v": "1.6.2",
+    "d": "27/10/2026",
+    "type": "Fixed",
+    "en": "expand now syncs a field element's properties.field_default with its specials.field_name, turning it on for the editor's system columns…",
+    "vi": "expand nay đồng bộ properties.field_default của field element theo specials.field_name: bật cho các cột hệ thống của editor (phone_number,…"
+  },
+  {
+    "v": "1.6.1",
+    "d": "21/10/2026",
+    "type": "Fixed",
+    "en": "publish_page now looks up the account's verified domains (GET /api/v1/domains/all) and publishes to the domain exactly as the account stores it: an…",
+    "vi": "publish_page nay tra cứu danh sách domain đã xác minh của account (GET /api/v1/domains/all) và publish đúng vào domain theo đúng dạng account đã…"
+  },
   {
     "v": "1.6.0",
     "d": "14/10/2026",
@@ -26,19 +40,5 @@
     "type": "Fixed",
     "en": "The HTTP server now answers a request carrying an unknown mcp-session-id with 404 instead of 400, so clients re-initialize instead of staying stuck…",
     "vi": "HTTP server nay trả về 404 (thay vì 400) khi nhận request với mcp-session-id không xác định, giúp client tự re-initialize thay vì bị kẹt ở trạng…"
-  },
-  {
-    "v": "1.5.8",
-    "d": "13/10/2026",
-    "type": "Fixed",
-    "en": "The OAuth authorize endpoint now accepts http://localhost/127.0.0.1/[::1] redirect URIs on any port as long as the scheme, host, path, and query…",
-    "vi": "Endpoint OAuth authorize nay chấp nhận redirect URI http://localhost/127.0.0.1/[::1] ở bất kỳ port nào miễn là scheme, host, path, và query khớp với…"
-  },
-  {
-    "v": "1.5.7",
-    "d": "13/10/2026",
-    "type": "Changed",
-    "en": "The ingest_url and render_preview tool descriptions now link to the API docs (docs/tools.md for both, plus the Microlink API reference for…",
-    "vi": "Mô tả của tool ingest_url và render_preview nay có thêm link tới tài liệu API (docs/tools.md cho cả hai, cùng với link tham chiếu API của Microlink…"
   }
 ]

package/dist/domains/landing/elements/form.js

@@ -58,7 +58,7 @@ export const FORM = [
         summary: "Single-line input. specials.field_name is the submitted data column (REQUIRED & unique).",
         useWhen: "Name/email/phone fields. Set field_type to text/email/phone/number. Must be a DIRECT child of the form to submit.",
         keySpecials: {
-            field_name: "REQUIRED unique data key. Special names coerce the input type: 'phone_number'/'recheck_phone_number' → tel, 'email' → email. Phone pattern validation only applies when field_name=='phone_number' AND validate=true.",
+            field_name: "REQUIRED unique data key. Use the EXACT system names for standard columns — full_name, first_name, last_name, phone_number, recheck_phone_number, email, address, quantity, coupon, postal_code (never 'phone'/'name'/'sdt'/'ho_ten'): the editor locks those IDs and refuses them when typed, so a field saved as 'phone' can never be renamed to 'phone_number' there. Special names coerce the input type: 'phone_number'/'recheck_phone_number' → tel, 'email' → email. Phone pattern validation only applies when field_name=='phone_number' AND validate=true.",
             field_placeholder: "placeholder text.",
             field_type: "text | email | phone | number | postal_code | date. 'postal_code' enables postcode-detect helper and uses condition/pattern (country_default|limit_5|limit_6|custom). 'date' renders a date input.",
             required: "boolean.",
@@ -99,7 +99,7 @@ export const FORM = [
                 desktop: { styles: { top: 60, left: 20, width: 360, height: 40 } },
                 mobile: { styles: { top: 60, left: 20, width: 360, height: 40 } },
             },
-            specials: { field_name: "phone", field_placeholder: "Số điện thoại", field_type: "phone", required: true },
+            specials: { field_name: "phone_number", field_placeholder: "Số điện thoại", field_type: "phone", required: true },
         },
     },
     {
@@ -389,3 +389,37 @@ export const FORM = [
         },
     },
 ];
+/**
+ * The editor's SYSTEM form columns — the `default: true` fields of its "add
+ * field" panel (landing_page_backend assets/editor/main/panels/FormPanel.vue).
+ * The editor creates them with `properties.field_default = true`, which LOCKS
+ * the ID box (FieldTrait.vue `disabled`), and it refuses these names when typed
+ * (FieldTrait.vue `defaultFieldName` appends a random suffix). So a field must
+ * be BORN with the canonical name: a field saved as "phone" can never become
+ * "phone_number" in the editor, and only the canonical names get the editor's
+ * extra behaviour (phone validation, address autocomplete, quantity, coupon…).
+ */
+export const SYSTEM_FIELD_NAMES = new Set([
+    "full_name", "first_name", "last_name", "phone_number", "recheck_phone_number",
+    "email", "quantity", "coupon", "address", "postal_code", "country_select",
+    "verify_code", "access_key", "province_id/district_id/commune_id",
+]);
+/** Common hand-made spellings of a system column (slugged: lowercase, no accents, `_`). */
+const SYSTEM_FIELD_ALIASES = {
+    phone: "phone_number", phonenumber: "phone_number", phone_no: "phone_number", tel: "phone_number",
+    telephone: "phone_number", mobile: "phone_number", sdt: "phone_number", so_dt: "phone_number",
+    so_dien_thoai: "phone_number", sodienthoai: "phone_number", dien_thoai: "phone_number", dienthoai: "phone_number",
+    name: "full_name", fullname: "full_name", your_name: "full_name", customer_name: "full_name",
+    ho_ten: "full_name", hoten: "full_name", ho_va_ten: "full_name", ten: "full_name",
+    firstname: "first_name", lastname: "last_name",
+    mail: "email", e_mail: "email", email_address: "email",
+    dia_chi: "address", diachi: "address",
+    so_luong: "quantity", soluong: "quantity", qty: "quantity",
+    ma_giam_gia: "coupon", voucher: "coupon",
+};
+/** The system column a non-canonical field_name was clearly meant to be, else undefined. */
+export function systemFieldAlias(fieldName) {
+    const slug = fieldName.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/đ/gi, "d")
+        .toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    return SYSTEM_FIELD_ALIASES[slug];
+}

package/dist/domains/landing/index.js

@@ -2,6 +2,7 @@ import { CANVAS, EVENT_TRIGGERS, CLICK_ACTIONS, HOVER_ACTIONS, SUCCESS_ACTIONS,
 import { GENERATION_GUIDE } from "./guide.js";
 import { INSTRUCTIONS } from "./instructions.js";
 import { LIBRARY, ELEMENT_TYPES, CONTAINER_TYPES, FIELD_TYPES, createElement } from "./elements/index.js";
+import { SYSTEM_FIELD_NAMES } from "./elements/form.js";
 import { createPageSource } from "./page.js";
 import { canvasToPageSource } from "./canvas-to-source.js";
 import { validatePage, coercePage, pageSchema } from "./validate.js";
@@ -389,6 +390,32 @@ function normalizeSettings(source) {
     ws.desktop ??= CANVAS.desktopWidth;
     ws.mobile ??= CANVAS.mobileWidth;
 }
+// ---------------------------------------------------------------------------
+// form-field lock normalization: the editor locks a field's ID box when
+// `properties.field_default` is true (FieldTrait.vue `disabled`) and only ever
+// sets it on its SYSTEM columns (phone_number, full_name, email…). A model that
+// copies `field_default:true` onto a custom field ("message", "note") leaves
+// the user an ID they can NEVER change; a system column without it is editable
+// in a way the editor itself never allows. So the flag follows the name:
+// on for system names, off for everything else. Deterministic + idempotent,
+// so the expand(compact(x)) == expand(x) invariant holds.
+// ---------------------------------------------------------------------------
+/** Walk a tree node and sync properties.field_default with the field_name in-place (mutates). */
+function normalizeFormFields(node) {
+    if (!node || typeof node !== "object")
+        return;
+    const fn = node.specials?.field_name;
+    if (FIELD_TYPES.has(node.type) && typeof fn === "string" && node.properties && typeof node.properties === "object") {
+        if (SYSTEM_FIELD_NAMES.has(fn))
+            node.properties.field_default = true;
+        else
+            delete node.properties.field_default;
+    }
+    if (Array.isArray(node.children)) {
+        for (const child of node.children)
+            normalizeFormFields(child);
+    }
+}
 /** Apply all post-expand normalizations to every node in a page source. */
 function normalizeSource(source) {
     if (!source || typeof source !== "object")
@@ -405,6 +432,7 @@ function normalizeSource(source) {
                 // url() layer in the same value.
                 normalizeColors(node);
                 normalizeBackgrounds(node);
+                normalizeFormFields(node);
             }
         }
     }

package/dist/domains/landing/instructions.js

@@ -41,7 +41,7 @@ MODEL (essentials):
 - IMAGES: include them (hero/product, feature icons, about photo). The server AUTO-HOSTS external image URLs on every save: any real http(s) image URL you put in specials.src / a url(...) background / gallery item.link / video poster is downloaded and re-hosted automatically by create_page/update_page/add_section/patch_page (the result's rehost field reports how many) — so you do NOT have to pre-call upload_images for reference or web images. WHERE THEY LAND: with credentials AND the settled org, every image is filed into THAT ORG's MEDIA COLLECTION (bộ sưu tập) — the same library the editor's media picker reads — so the user can re-pick it later; rehost.collection:true (and images[x].collection:true from upload_images) confirms it. This is why the org must be settled before any image work (see ORGANIZATION FIRST). With no credentials the image goes to the public CDN instead — the URL works and the page renders, but it is absent from every collection (collection:false); that is a server-setup issue to report, not something to fix by hand-uploading elsewhere. SOURCE PRIORITY: (1) images the user supplied or that exist in the reference HTML/URL → put the REAL source URL straight into specials.src and let the save host it (use those exact images, never swap them for stock photos; the original URL must reach the save un-altered — NEVER replace a real source image URL with a placeholder). The ONE case you MUST still call upload_images yourself: LOCAL FILE PATHS from the user's computer (pass the path directly in upload_images urls — the save can't read local files; NEVER upload a user's local file to a third-party host like catbox or imgur first), then use the returned URL. (2) only for slots with NO source image → call search_images with a short English subject (e.g. 'fresh coffee cup') and put a returned URL (src.large for a hero/banner, src.medium for a card/thumb) into the image-block specials.src; it works out of the box (a shared proxy supplies images); (3) if search_images returns ok:false / is unreachable / has no fitting photo → find a real image YOURSELF using whatever web search/fetch capability you have (brand site, product page, free-to-use source) and re-host it via upload_images; (4) a PLACEHOLDER sized to the box (https://placehold.co/<width>x<height>) is the LAST resort, only after (2) AND (3) both failed. (gallery.media = array of OBJECTS {type:'image',link:'<url>',linkVideo:'',typeVideo:'youtube',imageCompression:true} — NOT plain strings, the gallery reads item.link; video.specials.img = poster). NEVER leave src empty (renders blank). DON'T AUTHOR BASE64 IMAGES. A 'data:image/...;base64,...' URI never reaches the stored source — the save DECODES it and uploads it to the CDN like any other image (it counts in the rehost report), and validate_page only WARNS, so a base64 URI that came in from a reference/user paste needs no manual fix: just save. What you must not do is EMIT base64 yourself: the whole image travels through this connection inside your payload, and megabytes there can drop it. Put a real http(s) URL in the slot, or call upload_images (it accepts data: URIs) and use the returned statics.pancake.vn URL. Ensure text contrasts with its section background.
 
 - BEYOND ELEMENT CAPABILITY: when a reference effect can't be expressed with an element's built-in specials (hover scale/lift/zoom & transitions, gradients, glassmorphism/backdrop-blur, custom shadows, gradient/clipped text, keyframe animations outside the 9 entrance types) DON'T drop it — use the escape hatches so the page is as complete as possible: element specials.custom_css (extra DECLARATIONS in #w-<id>{…}; declarations-only) + specials.custom_class (both need specials.customAdvance:true) for per-element styling, and page settings.extra_css (a full raw stylesheet in <head> — where :hover/@keyframes/media-queries live, target #w-<element id>) + settings.extra_script (raw JS) + settings.bhet/bbet (raw HTML blocks at end of <head>/<body> — for webfont <link>s, <meta>/verification, analytics/pixels, chat widgets, third-party embeds). get_generation_guide has the recipes. SAFETY (custom is raw + global → sloppy custom BREAKS the whole UI): SCOPE every extra_css rule to "#w-<id>" or a specials.custom_class — NEVER a bare tag / "*" / a Webcake-internal class (.section-container/.rectangle-css/.text-block-css/.group-*…); keep custom_css to VISUAL props only (no position/top/left/width/height/display/float); close every bhet/bbet tag; don't restructure "#w-…" elements in extra_script. validate_page flags unscoped selectors, layout props in custom_css, unbalanced braces/tags, missing customAdvance, and CSS/JS in the wrong field — fix every such warning.
-- PREVIEW vs PUBLISH: for review share the EDITOR url (the builder renders the raw source). The editor_url SIGNS THE BROWSER IN automatically (it routes through the builder's /transport with the account token), so it works even when the user isn't logged in — but for the same reason it must go to the PAGE OWNER ONLY, never into anything public. create_page AUTO-PUBLISHES on success (builds the rendered app + publish_html), so a fresh page's preview_url renders right away — but the preview host (preview.localhost:5800 local / staging.webcake.me staging / www.webcake.me prod) only serves it for ~10 MINUTES after the last publish, then shows "Preview page is expired". The EDIT routes (update_page/add_section/patch_page) store source only — after finishing a round of edits, run publish_page({ page_id, dry_run:false }) to rebuild the rendered app (else the preview shows the STALE pre-edit build). ONLY a custom_domain (publish_page({ page_id, custom_domain, dry_run:false })) gives a permanent public URL; without one the page has just the ephemeral preview link — say so and suggest attaching a domain the user already points at Webcake.
+- PREVIEW vs PUBLISH: for review share the EDITOR url (the builder renders the raw source). The editor_url SIGNS THE BROWSER IN automatically (it routes through the builder's /transport with the account token), so it works even when the user isn't logged in — but for the same reason it must go to the PAGE OWNER ONLY, never into anything public. create_page AUTO-PUBLISHES on success (builds the rendered app + publish_html), so a fresh page's preview_url renders right away — but the preview host (preview.localhost:5800 local / staging.webcake.me staging / www.webcake.me prod) only serves it for ~10 MINUTES after the last publish, then shows "Preview page is expired". The EDIT routes (update_page/add_section/patch_page) store source only — after finishing a round of edits, run publish_page({ page_id, dry_run:false }) to rebuild the rendered app (else the preview shows the STALE pre-edit build). ONLY a custom_domain (publish_page({ page_id, custom_domain, dry_run:false })) gives a permanent public URL; without one the page has just the ephemeral preview link — say so and suggest attaching a domain the user already points at Webcake. The custom_domain must be one the user ALREADY ADDED in their account, written EXACTLY as listed there — www.example.com and example.com are DIFFERENT domains (if unsure which form they added, ask; never add or drop "www" yourself). publish_page corrects a www/non-www mismatch to the stored form (see domain_note) and refuses a domain the account doesn't have (reason domain_not_in_account) — then ask the user which listed domain to use.
 - VISUAL CHECK — a screenshot costs tokens + a round-trip, so by DEFAULT do NOT screenshot. validate_page (errors + warnings) and the save-time auto-fix already catch the mechanical defects (off-canvas, wrapped-text overlap, contrast, missing data) token-free — trust them. Screenshot ONLY when it adds something validation can't: (a) you're CLONING a reference and need to compare pixel fidelity, (b) the USER asks to see/verify the look, or (c) you have a specific AESTHETIC doubt (color/imagery/composition) text-validation can't judge. When you do: SCREENSHOT WITH YOUR OWN CAPABILITY FIRST — a browser/screenshot MCP (e.g. chrome-devtools) or any URL-capture tool (fresh + unlimited); only if you have none, call render_preview(page_id) (PNG; on a quota/429 it returns ok:false → skip that round, never fail the build). Take ONE shot, patch_page only the clear mismatches by id, re-publish (publish_page), and re-shoot ONLY if you changed something material — do NOT reflexively loop 2–3 times. For a clone, compare to the reference (screenshot the reference URL too when you only have HTML) — section order, colors, spacing, image placement, sizing, text. The no-domain preview only renders ~10 min after the last publish, so shoot promptly and re-publish before re-checking.
 
 Start by calling get_generation_guide. Tools: get_generation_guide, list_elements, get_element, new_element, new_page_skeleton, get_page_schema, validate_page, layout, search_images, get_icon_svg, upload_images, render_preview, ingest_html, ingest_url, list_organizations, create_page, list_pages, find_pages, get_page, update_page, add_section, patch_page, publish_page.`;

package/dist/domains/landing/validate.js

@@ -9,6 +9,7 @@
 import { readFileSync } from "node:fs";
 import Ajv2020Module from "ajv/dist/2020.js";
 import { CONTAINER_TYPES, FIELD_TYPES } from "./elements/index.js";
+import { systemFieldAlias } from "./elements/form.js";
 import { ANIMATABLE_TYPES, ANIMATION_NAMES } from "./vocab.js";
 import { estTextHeightPx, measureTextBlock } from "./text-metrics.js";
 import { isColorKey, isUnparseableByEditor } from "./color.js";
@@ -316,6 +317,12 @@ export function validatePage(input) {
             if (!fn || typeof fn !== "string" || fn.trim() === "") {
                 warnings.push(`${path} (${type}): form input should have a unique specials.field_name.`);
             }
+            else {
+                const canonical = systemFieldAlias(fn);
+                if (canonical && canonical !== fn) {
+                    warnings.push(`${path} (${type}): field_name "${fn}" should be the system column "${canonical}" — the Webcake editor reserves system names (typing "${canonical}" there gets a random suffix), so the user can NEVER rename this field to "${canonical}" later, and only "${canonical}" gets the editor's built-in behaviour. Rename it now (also update any {{${fn}}} placeholder). On an EXISTING page this changes the submitted data column — ask the user first.`);
+                }
+            }
             // `field_placeholder` is the ONLY placeholder key the renderer reads. A stray
             // `placeholder` renders blank; a select with no field_placeholder crashes the
             // published renderer (unescapeHTML(undefined)).

package/dist/persistence/domain-match.js

@@ -0,0 +1,36 @@
+/**
+ * Match a publish domain against the domains the account actually added (PURE — no network,
+ * smoke-tested). The editor's publish modal only lets the user PICK from that list, so its
+ * publishes always carry the stored form; publish_page used to take `custom_domain` verbatim,
+ * so an AI that wrote `xsummit.vn` published a page the customer had added as `www.xsummit.vn`
+ * — the page lived on a domain record that doesn't exist, and Dynamic campaigns on it failed.
+ *
+ * www and non-www are DIFFERENT domain records, so neither form is "the right one" in general:
+ * the stored form wins. Exact match → keep; the www-toggled form is stored → use that;
+ * neither → not in the account (the caller refuses rather than publishing to a phantom domain).
+ */
+/** Lowercase host only: strips scheme, path/query, port, trailing dot and whitespace. */
+export function normalizeDomain(d) {
+    return String(d ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/^[a-z]+:\/\//, "")
+        .replace(/[/?#].*$/, "")
+        .replace(/:\d+$/, "")
+        .replace(/\.$/, "");
+}
+export function matchAccountDomain(requested, accountDomains) {
+    const want = normalizeDomain(requested);
+    const stored = new Map();
+    for (const d of accountDomains) {
+        const n = normalizeDomain(d);
+        if (n && !stored.has(n))
+            stored.set(n, n);
+    }
+    if (want && stored.has(want))
+        return { ok: true, domain: want, adjusted: requested.trim() !== want };
+    const toggled = want.startsWith("www.") ? want.slice(4) : `www.${want}`;
+    if (want && stored.has(toggled))
+        return { ok: true, domain: toggled, adjusted: true };
+    return { ok: false, candidates: [...stored.keys()].slice(0, 20) };
+}

package/dist/persistence/webcake-client.js

@@ -74,6 +74,7 @@ const PAGES_ENDPOINT = "/api/v1/ai/pages";
 const SEARCH_PAGES_ENDPOINT = "/api/v1/ai/search_pages";
 const PAGE_SOURCE_ENDPOINT = "/api/v1/ai/page_source";
 const PAGE_VERSION_ENDPOINT = "/api/v1/ai/page_version";
+const DOMAINS_ENDPOINT = "/api/v1/domains/all";
 const UPDATE_ENDPOINT = "/api/v1/ai/update_page_source";
 const APPEND_ENDPOINT = "/api/v1/ai/append_section";
 // The editor's own publish routes (NOT under /api/v1/ai). Both scopes are
@@ -290,10 +291,10 @@ export async function createPage(config, name, source, orgId) {
 // ---------------------------------------------------------------------------
 // Read / list / edit existing pages
 // ---------------------------------------------------------------------------
-async function getJson(url, config) {
+async function getJson(url, config, orgId) {
     let res;
     try {
-        res = await fetch(url, { method: "GET", headers: authHeaders(config), signal: timeoutSignal(HTTP_TIMEOUT_MS) });
+        res = await fetch(url, { method: "GET", headers: authHeaders(config, orgId), signal: timeoutSignal(HTTP_TIMEOUT_MS) });
     }
     catch (e) {
         const e2 = timeoutOrNetworkError(url, e);
@@ -343,6 +344,27 @@ export async function searchPages(config, filters) {
     const pages = r.json?.data?.pages ?? r.json?.pages ?? [];
     return { ok: true, status: r.status, pages };
 }
+/**
+ * The VERIFIED domains the account can publish to, via the dashboard's own domain list
+ * (`GET /api/v1/domains/all` → LandingPageWeb.V1.DomainController.get_all_domains). The list is
+ * per ORGANIZATION (`x-org-id`; a page in an org can only use that org's domains), else the
+ * account's personal domains. `term` is a case-insensitive substring filter server-side — pass the
+ * bare host (no www) so both the www and non-www records come back. publish_page uses this to
+ * publish to the domain EXACTLY as stored (see persistence/domain-match.ts).
+ */
+export async function listVerifiedDomains(config, opts = {}) {
+    const qs = new URLSearchParams({ is_verified: "true", limit: "50" });
+    if (opts.term)
+        qs.set("term", opts.term);
+    const org = opts.orgId == null || `${opts.orgId}` === "" ? undefined : `${opts.orgId}`;
+    const r = await getJson(`${config.base}${DOMAINS_ENDPOINT}?${qs}`, config, org);
+    if (!r.ok)
+        return { ok: false, status: r.status, endpoint_missing: r.status === 404, error: r.error };
+    const rows = r.json?.domains?.data ?? r.json?.data?.data ?? r.json?.data ?? [];
+    if (!Array.isArray(rows))
+        return { ok: false, status: r.status, error: "Unexpected domains response shape" };
+    return { ok: true, status: r.status, domains: rows.map((d) => String(d?.domain ?? "")).filter(Boolean) };
+}
 /** Read a page's decoded source tree (must be owned by the account). */
 /**
  * The page source's VERSION only (`updated_at`), a few hundred bytes instead of the

package/dist/smoke.js

@@ -15,6 +15,7 @@ import { registerFontGroups } from "./persistence/webcake-client.js";
 import { warningsField } from "./mcp/response.js";
 import { readConfig, resolveEnv, ENV_NAMES, configFromHeaders } from "./persistence/config.js";
 import { toEditorUrl, toEditorLoginUrl, toPreviewUrl, buildPublishRequestRedacted } from "./persistence/webcake-client.js";
+import { matchAccountDomain, normalizeDomain } from "./persistence/domain-match.js";
 import { normalizePhoto, resolvePexelsKey, pexelsKeyFromHeaders, resolvePexelsProxyBase, buildSearchQuery, PEXELS_PROXY_DEFAULT, variantPixels, annotateVariantSizes } from "./persistence/pexels-client.js";
 import { putDraft, getDraft, updateDraft, deleteDraft } from "./persistence/draft-cache.js";
 import { buildConnectUrl, parseCallback } from "./auth/login.js";
@@ -186,6 +187,36 @@ console.log("== expand: relocates misplaced responsive.<bp>.animation into confi
     const kept = landingDomain.expand(both).page[0].children[0].responsive.desktop;
     check("explicit config.animation wins over the stray key", kept.config.animation.name === "zoomIn" && kept.animation === undefined, kept.config);
 }
+console.log("== form fields: field_default follows the system field_name; alias names warn ==");
+{
+    // The editor locks a field's ID when properties.field_default is true and
+    // refuses system names when typed — so the lock must match the name, and a
+    // hand-made "phone" must be flagged before it is saved un-renameable.
+    const mk = (fields) => ({
+        page: [{ id: "s1", type: "section", responsive: { desktop: { styles: { height: 400 } }, mobile: { styles: { height: 400 } } },
+                children: [{ id: "f1", type: "form",
+                        responsive: { desktop: { styles: { top: 10, left: 10, width: 400, height: 300 } }, mobile: { styles: { top: 10, left: 10, width: 400, height: 300 } } },
+                        children: fields.map((f, i) => ({ id: `i${i}`, type: f.type ?? "input", properties: f.properties,
+                            responsive: { desktop: { styles: { top: i * 50, left: 0, width: 300, height: 40 } }, mobile: { styles: { top: i * 50, left: 0, width: 300, height: 40 } } },
+                            specials: { field_name: f.name, field_placeholder: "x" } })) }] }],
+        popup: [], settings: {},
+    });
+    const ex = landingDomain.expand(mk([
+        { name: "phone_number" },
+        { name: "message", properties: { field_default: true } },
+        { name: "phone" },
+    ]));
+    const kids = ex.page[0].children[0].children;
+    check("system field gets field_default:true", kids[0].properties.field_default === true, kids[0].properties);
+    check("custom field never locked", kids[1].properties.field_default === undefined, kids[1].properties);
+    check("field_default normalization idempotent", JSON.stringify(landingDomain.expand(ex)) === JSON.stringify(ex));
+    const w = validatePage(ex).warnings;
+    check("alias 'phone' warns → phone_number", w.some((m) => m.includes('"phone"') && m.includes('"phone_number"')), w);
+    check("canonical/custom names don't warn", !w.some((m) => m.includes('"message" should') || m.includes('"phone_number" should')), w);
+    const vi = landingDomain.expand(mk([{ name: "Số điện thoại" }, { name: "Họ tên" }]));
+    const wv = validatePage(vi).warnings;
+    check("Vietnamese aliases warn", wv.some((m) => m.includes('"phone_number"')) && wv.some((m) => m.includes('"full_name"')), wv);
+}
 console.log("== validate: accepts JSON string input ==");
 const r3 = validatePage(JSON.stringify(good));
 check("string input parsed & valid", r3.valid, r3.errors);
@@ -2502,6 +2533,22 @@ console.log("== stale-overwrite guard: a UI edit is never silently reverted ==")
     check("page-version: store is bounded (LRU evicts the oldest)", lastKnownPageVersion("bulk0") === undefined && lastKnownPageVersion("bulk119")?.fp === "fp119");
     resetPageVersions();
 }
+console.log("== publish_page: custom_domain matches the account's stored domain (www vs non-www) ==");
+{
+    // The xsummit case: customer added www.xsummit.vn, the AI passed xsummit.vn verbatim.
+    const m1 = matchAccountDomain("xsummit.vn", ["www.xsummit.vn"]);
+    check("domain: non-www request → the stored www form", m1.ok && m1.domain === "www.xsummit.vn" && m1.adjusted, m1);
+    const m2 = matchAccountDomain("www.shop.vn", ["shop.vn"]);
+    check("domain: www request → the stored non-www form (never force www)", m2.ok && m2.domain === "shop.vn" && m2.adjusted, m2);
+    const m3 = matchAccountDomain("shop.vn", ["shop.vn", "www.shop.vn"]);
+    check("domain: both forms stored → exact match wins", m3.ok && m3.domain === "shop.vn" && !m3.adjusted, m3);
+    const m4 = matchAccountDomain("https://WWW.Shop.vn/sale?x=1", ["www.shop.vn"]);
+    check("domain: scheme/case/path stripped before matching", m4.ok && m4.domain === "www.shop.vn", m4);
+    const m5 = matchAccountDomain("other.vn", ["www.shop.vn"]);
+    check("domain: not in the account → no match, lists candidates", !m5.ok && m5.candidates.includes("www.shop.vn"), m5);
+    check("domain: empty account list → no match", !matchAccountDomain("shop.vn", []).ok);
+    check("domain: normalizeDomain drops port + trailing dot", normalizeDomain(" Shop.VN.:8080/a ") === "shop.vn", normalizeDomain(" Shop.VN.:8080/a "));
+}
 console.log("== server: MCP serverInfo.version follows package.json (no hardcoded constant) ==");
 {
     const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));

package/dist/tools/persistence.js

@@ -13,7 +13,8 @@ import { z } from "zod";
 import { text, warningsField, autoFixedField } from "../mcp/response.js";
 import { objectOrJson, objectsOrJson } from "../mcp/params.js";
 import { readConfig, configFromHeaders } from "../persistence/config.js";
-import { buildRequestRedacted, buildUpdateRequestRedacted, buildAppendRequestRedacted, buildPublishRequestRedacted, buildPageApp, createPage, listOrganizations, listPages, searchPages, getPageSource, getPageVersion, updatePageSource, appendSection, publishPage, toPreviewUrl, } from "../persistence/webcake-client.js";
+import { buildRequestRedacted, buildUpdateRequestRedacted, buildAppendRequestRedacted, buildPublishRequestRedacted, buildPageApp, createPage, listOrganizations, listPages, searchPages, listVerifiedDomains, getPageSource, getPageVersion, updatePageSource, appendSection, publishPage, toPreviewUrl, } from "../persistence/webcake-client.js";
+import { matchAccountDomain, normalizeDomain } from "../persistence/domain-match.js";
 import { putDraft, getDraft, updateDraft, deleteDraft } from "../persistence/draft-cache.js";
 import { sourceFingerprint, decideOverwrite, rememberPageVersion, forgetPageVersion, lastKnownPageVersion, sourceCacheKey, cachePageSource, cachedPageSource, cachedPageSourceVersion, dropCachedPageSource, } from "../persistence/page-version.js";
 /**
@@ -1405,7 +1406,7 @@ export function registerPersistenceTools(server, domain) {
         custom_domain: z
             .string()
             .optional()
-            .describe("Optional custom domain to serve the page at (e.g. 'shop.example.com' — must already point at Webcake). OMIT to reuse the page's CURRENTLY-ATTACHED domain (so republishing keeps it live at the same URL, like the editor's publish modal); if the page has none it publishes domain-less (preview-host URL). Pass an empty string '' to force a domain-less publish even when the page has a domain."),
+            .describe("Optional custom domain to serve the page at (e.g. 'shop.example.com' — must already point at Webcake). Use it EXACTLY as the account lists it: 'www.example.com' and 'example.com' are DIFFERENT domain records — a www/non-www mismatch is corrected to the stored form, and a domain the account never added is refused (nothing published). OMIT to reuse the page's CURRENTLY-ATTACHED domain (so republishing keeps it live at the same URL, like the editor's publish modal); if the page has none it publishes domain-less (preview-host URL). Pass an empty string '' to force a domain-less publish even when the page has a domain."),
         custom_path: z.string().optional().describe("Optional path under the custom domain (e.g. 'sale')."),
         dry_run: z.boolean().optional().describe("Default TRUE — preview the request without sending. Does NOT call the build host. Set false to actually publish (build + publish)."),
     }, { title: "Publish Webcake Page", readOnlyHint: false, destructiveHint: true, openWorldHint: true }, async ({ page_id, custom_domain, custom_path, dry_run }, extra) => {
@@ -1444,6 +1445,41 @@ export function registerPersistenceTools(server, domain) {
         // Normalize an empty-string domain to "no domain" so downstream !! checks agree.
         if (!effectiveDomain)
             effectiveDomain = undefined;
+        // Publish to the domain EXACTLY as the account stores it (the editor's modal can only pick
+        // from that list). A verbatim custom_domain once published `xsummit.vn` for a customer who had
+        // added `www.xsummit.vn`: the page lived on a domain record that doesn't exist and Dynamic
+        // campaigns on it failed. Explicit domain not in the account → refuse. An INHERITED domain that
+        // isn't listed (shared from another member, older record) or a lookup failure → publish as
+        // before, with a note — never block a republish on the lookup itself.
+        let domainNote;
+        if (effectiveDomain) {
+            const bare = normalizeDomain(effectiveDomain).replace(/^www\./, "");
+            const listed = await listVerifiedDomains(config, { term: bare, orgId: res.organization_id });
+            if (listed.ok) {
+                const m = matchAccountDomain(effectiveDomain, listed.domains ?? []);
+                if (m.ok) {
+                    if (m.domain !== effectiveDomain)
+                        domainNote = `'${effectiveDomain}' is stored in the account as '${m.domain}' — publishing to '${m.domain}' (www and non-www are different domains; campaigns and tracking key on the stored one).`;
+                    effectiveDomain = m.domain;
+                }
+                else if (!domainInherited) {
+                    return text({
+                        published: false,
+                        reason: "domain_not_in_account",
+                        page_id,
+                        requested_domain: effectiveDomain,
+                        account_domains_matching: m.candidates,
+                        hint: "The domain must be added and verified in the account (Domains) first, and passed EXACTLY as listed — www.example.com and example.com are different. Pick one of account_domains_matching, ask the user which domain to use, or pass custom_domain:'' to publish without a domain.",
+                    });
+                }
+                else {
+                    domainNote = `The page's attached domain '${effectiveDomain}' is not among the account's verified domains — republished to it unchanged.`;
+                }
+            }
+            else {
+                domainNote = `Could not check '${effectiveDomain}' against the account's domain list (${listed.error ?? `HTTP ${listed.status}`}) — publishing to it as given.`;
+            }
+        }
         const opts = { customDomain: effectiveDomain, customPath: effectivePath };
         const buildBase = config.buildBase;
         // Only the preview window serves a domain-less publish, and only briefly.
@@ -1465,6 +1501,7 @@ export function registerPersistenceTools(server, domain) {
                     ? { would_run: true, build_host: buildBase, note: "Build host will be called on dry_run=false to produce rendered app/app_css, then the page is published live via the editor's publish_html route." }
                     : { would_run: false, note: "No build host configured — publish will fall back to the LEGACY source-only route (nothing goes live). Set WEBCAKE_BUILD_BASE env or x-webcake-build-base header (prod preset: https://build.webcake.io) to publish for real." },
                 ...(previewExpiryNote ? { note: previewExpiryNote } : {}),
+                ...(domainNote ? { domain_note: domainNote } : {}),
                 request: buildPublishRequestRedacted(config, page_id, res.source, opts, !!buildBase),
                 hint: "Re-run with dry_run=false to actually publish.",
             });
@@ -1509,6 +1546,7 @@ export function registerPersistenceTools(server, domain) {
             status: outcome.status,
             error: outcome.error,
             ...(outcome.ok && previewExpiryNote ? { note: previewExpiryNote } : {}),
+            ...(domainNote ? { domain_note: domainNote } : {}),
             ...(buildWarning ? { warning: buildWarning } : {}),
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webcake-landing-mcp",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "MCP server exposing Webcake landing-page element schemas + AI usage hints, and persisting LLM-generated page sources to a Webcake backend.",
   "mcpName": "io.github.vuluu2k/webcake-landing-mcp",
   "type": "module",