npm - sbuilder-mcp - Versions diffs - 0.7.2 → 0.8.0 - Mend

sbuilder-mcp 0.7.2 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/CHANGELOG.md +13 -0
package/CHANGELOG.vi.md +13 -0
package/dist/domains/site/builder.js +1 -0
package/dist/domains/site/importmap.js +54 -0
package/dist/domains/site/node.js +22 -1
package/dist/tools/importpage.js +18 -2
package/dist/vision/capture.js +151 -50
package/dist/vision/shoot.js +19 -8
package/package.json +1 -1

package/CHANGELOG.md CHANGED Viewed

@@ -6,6 +6,19 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.8.0] - 2026-09-08
+### Added
+- sb_add's `spec` argument now takes `responsive` on any node, seeding per-breakpoint style and config overrides at creation time instead of requiring a follow-up sb_set for every responsive value; it merges over the element's own seeded responsive defaults per namespace, so seeding a mobile style does not drop the element's own mobile config.
+- sb_import takes max_nodes (default 300), a single bound on the whole import; it replaces the old per-section cap, which silently became the real limit on a page whose body has one top-level child, and the amount skipped is now reported on a real run too, not only a dry one.
+- sb_import now preserves the source's layout: a container that actually lays its children out with flex or grid becomes a real row that stacks at mobile instead of every section flattening into one vertical column.
+### Fixed
+- sb_import now captures text from any element that holds it, not only `<p>` and `<blockquote>`, since most of the web does not use paragraph tags; a table-layout page or a utility-CSS page previously imported with none of its text at all.
+- sb_import's empty-result fallback now retries against the page's `<main>` whenever the sections it found produced no content, instead of only when it found no candidate sections in the first place.
+- sb_import now keeps an unpainted content link instead of dropping it, capturing it as a flat link-styled button rather than only capturing links that already look like a call to action; a painted button still requires a filled background or a border with actual width, so a Tailwind page's zero-width reset borders are no longer mistaken for one.
+- sb_import no longer imports the source page's own page-level header and footer, since the target page already carries its own as shared globals; a `<header>` nested inside a section (a hero) is still kept.
 ## [0.7.2] - 2026-09-08
 ### Fixed

package/CHANGELOG.vi.md CHANGED Viewed

@@ -6,6 +6,19 @@ Mọi thay đổi đáng chú ý của dự án được ghi lại trong file n
 Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 và dự án tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.8.0] - 2026-09-08
+### Added
+- Tham số `spec` của sb_add giờ nhận `responsive` trên bất kỳ node nào, cho phép gieo các override style và config theo từng breakpoint ngay lúc tạo node, thay vì phải gọi thêm sb_set cho mỗi giá trị responsive; nó merge đè lên các giá trị responsive mặc định mà chính element đã gieo sẵn theo từng namespace, nên việc gieo một style cho mobile sẽ không làm mất config mobile riêng của element.
+- sb_import nhận max_nodes (mặc định 300), một giới hạn duy nhất cho toàn bộ lần import; nó thay thế giới hạn theo từng section cũ, vốn âm thầm trở thành giới hạn thực tế trên một trang mà `<body>` chỉ có một phần tử con cấp cao nhất, và số lượng bị bỏ qua giờ được báo cáo cả ở lần chạy thật, không chỉ ở dry run.
+- sb_import giờ giữ lại cách bố trí của trang nguồn: một container thực sự sắp xếp các phần tử con bằng flex hoặc grid sẽ trở thành một row thật, tự động xếp chồng ở mobile, thay vì mọi section đều bị làm phẳng thành một cột dọc.
+### Fixed
+- sb_import giờ lấy text từ bất kỳ phần tử nào chứa nó, không chỉ `<p>` và `<blockquote>`, vì phần lớn nội dung trên web không dùng thẻ paragraph; một trang dùng layout bảng hoặc trang dùng utility-CSS trước đây bị import mà không lấy được chữ nào.
+- Cơ chế fallback khi không có kết quả của sb_import giờ thử lại với `<main>` của trang bất cứ khi nào các section tìm được không tạo ra nội dung nào, thay vì chỉ thử lại khi không tìm được section ứng viên nào ngay từ đầu.
+- sb_import giờ giữ lại một liên kết nội dung không được "tô" thay vì bỏ nó đi, lấy nó thành một button kiểu link phẳng thay vì chỉ lấy những liên kết đã trông giống một call-to-action; một button được "tô" vẫn cần có màu nền hoặc viền có độ dày thật, nên các viền reset độ dày bằng 0 của một trang dùng Tailwind không còn bị nhầm là một call-to-action nữa.
+- sb_import không còn import header và footer cấp trang của trang nguồn, vì trang đích đã có sẵn header/footer riêng dưới dạng global dùng chung; một `<header>` nằm lồng bên trong một section (dạng hero) vẫn được giữ lại.
 ## [0.7.2] - 2026-09-08
 ### Fixed

package/dist/domains/site/builder.js CHANGED Viewed

@@ -90,6 +90,7 @@ export function addSubtree(doc, parentId, spec, index) {
             style: s.style,
             config: s.config,
             specials: s.specials,
+            responsive: s.responsive,
         });
         // Before the owner is handed to a patch: minting rewrites its `config`.
         const sats = mintSatellites(n);

package/dist/domains/site/importmap.js CHANGED Viewed

@@ -125,6 +125,26 @@ function one(c, t) {
             const text = c.text?.trim();
             if (!text)
                 return null;
+            // TWO KINDS OF LINK, and giving them one look was wrong in both
+            // directions. Painting every link produced 38 pink pills out of a
+            // documentation sidebar; dropping the unpainted ones lost a whole page of
+            // story titles. A call to action takes the target's FILL; a link takes its
+            // accent as INK and nothing else, which is the platform's own idiom for a
+            // link (a button carrying href, styled flat).
+            if (c.variant === 'link') {
+                return {
+                    type: 'button',
+                    specials: { text, ...(c.href ? { href: c.href } : {}) },
+                    style: {
+                        width: 'fit-content',
+                        backgroundColor: 'transparent',
+                        border: 'none',
+                        padding: '0',
+                        fontWeight: '500',
+                        ...(t.buttonBg ? { color: t.buttonBg } : {}),
+                    },
+                };
+            }
             return {
                 type: 'button',
                 specials: { text, ...(c.href ? { href: c.href } : {}) },
@@ -157,6 +177,40 @@ function one(c, t) {
                 })),
             };
         }
+        case 'group': {
+            const kids = (c.children ?? []).map((k) => one(k, t)).filter((n) => n !== null);
+            if (kids.length === 0)
+                return null;
+            if (kids.length === 1)
+                return kids[0];
+            // A ROW OF TWO OR MORE COLUMNS NEEDS AN EXPLICIT STACK BREAKPOINT, and
+            // nothing catches it for you: the columns SHRINK to fit, so no box
+            // overflows and `measure` stays silent while a photo becomes a sliver and
+            // a label truncates mid-word. Rule 3 of the design skill, and an import is
+            // the one place a row arrives without anybody having thought about 390.
+            //
+            // The wide answer is said out loud at base too, because the cascade
+            // resolves narrower slots LAST but does consult them: a `column` written
+            // only at mobile would otherwise reach desktop whenever base declares
+            // nothing.
+            return {
+                type: 'flex-block',
+                style: {
+                    width: '100%',
+                    display: 'flex',
+                    flexDirection: 'row',
+                    flexWrap: c.wrap ? 'wrap' : 'nowrap',
+                    alignItems: 'flex-start',
+                    gap: '24px',
+                },
+                responsive: { mobile: { style: { flexDirection: 'column', gap: '16px' } } },
+                children: kids.map((k) => ({
+                    type: 'flex-block',
+                    style: { flex: '1 1 280px', minWidth: '0', display: 'flex', flexDirection: 'column', gap: '12px' },
+                    children: [k],
+                })),
+            };
+        }
         case 'section': {
             const kids = (c.children ?? []).map((k) => one(k, t)).filter((n) => n !== null);
             if (kids.length === 0)

package/dist/domains/site/node.js CHANGED Viewed

@@ -1,5 +1,26 @@
 import { ELEMENTS, SATELLITE_RULES } from '../../catalog/elements.generated.js';
 import { genId } from './ids.js';
+/**
+ * The element's own per-breakpoint defaults with the caller's laid over them.
+ *
+ * Per NAMESPACE, not per slot: an element that seeds `mobile.config.iconSize`
+ * and a caller who asks for `mobile.style.flexDirection` must end with both.
+ * Replacing the slot would drop the one nobody mentioned, which is the quiet
+ * kind of loss this repo keeps finding.
+ */
+function mergeResponsive(base, over) {
+    if (!over)
+        return base;
+    const out = { ...base };
+    for (const [bp, slot] of Object.entries(over)) {
+        out[bp] = {
+            ...(out[bp] ?? {}),
+            ...(slot.style ? { style: { ...(out[bp]?.style ?? {}), ...slot.style } } : {}),
+            ...(slot.config ? { config: { ...(out[bp]?.config ?? {}), ...slot.config } } : {}),
+        };
+    }
+    return out;
+}
 /** Structured clone via JSON — the defaults are plain data, and this is what
  *  stops two nodes of the same type sharing one nested object. */
 function copy(v) {
@@ -73,7 +94,7 @@ export function createNode(type, opts = {}) {
         style: { ...copy(d.style ?? {}), ...(opts.style ?? {}) },
         config,
         specials: { ...copy(d.specials ?? {}), ...(opts.specials ?? {}) },
-        responsive: copy(d.responsive ?? {}),
+        responsive: mergeResponsive(copy(d.responsive ?? {}), opts.responsive),
         ...(states ? { states: copy(states) } : {}),
         events: [],
         // SEED THE ELEMENT'S OWN BINDINGS.

package/dist/tools/importpage.js CHANGED Viewed

@@ -41,6 +41,13 @@ export function registerImportTools(server, ctx, session) {
                 .max(100)
                 .optional()
                 .describe('Default 24 — every image is an upload'),
+            max_nodes: z
+                .number()
+                .int()
+                .min(1)
+                .max(1000)
+                .optional()
+                .describe('Default 300 — the bound on the whole import'),
             upload_images: z
                 .boolean()
                 .optional()
@@ -48,13 +55,17 @@ export function registerImportTools(server, ctx, session) {
             dry_run: z.boolean().optional(),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
-    }, async ({ url, site_id: given, max_sections, max_images, upload_images, dry_run }) => {
+    }, async ({ url, site_id: given, max_sections, max_images, max_nodes, upload_images, dry_run }) => {
         const siteId = siteFor(ctx, given);
         // THE TARGET PAGE MUST BE OPEN, and not only because that is where the
         // nodes go: its own heading, button and section are where the tokens come
         // from, so an import with no open page is an import with no design.
         const doc = session.current();
-        const shot = await capture(url, { maxSections: max_sections, maxImages: max_images });
+        const shot = await capture(url, {
+            maxSections: max_sections,
+            maxImages: max_images,
+            maxNodes: max_nodes,
+        });
         const tokens = tokensFromPage(doc.doc);
         const images = imageSources(shot.sections);
         if (dry_run !== false) {
@@ -115,6 +126,11 @@ export function registerImportTools(server, ctx, session) {
         return text({
             read: shot.url,
             added_sections: added,
+            // WHAT WAS LEFT BEHIND, on the real run too. The dry run said it and the
+            // real one did not, which is the wrong way round: a caller who skipped
+            // the preview is exactly the caller who needs to be told that 21 nodes
+            // hit the ceiling, or that the page's own header was dropped on purpose.
+            ...(Object.keys(shot.skipped).length ? { skipped: shot.skipped } : {}),
             images: {
                 copied: rehosted.size,
                 ...(failed.length ? { failed } : {}),

package/dist/vision/capture.js CHANGED Viewed

@@ -13,7 +13,7 @@ function capturePage(limits) {
     // page, as `ReferenceError: HEADINGS is not defined`, by which point the file
     // already carried a comment saying exactly that.
     const HEADINGS = new Set(['H1', 'H2', 'H3', 'H4', 'H5', 'H6']);
-    const taken = { images: 0 };
+    const taken = { images: 0, nodes: 0 };
     const skipped = {};
     const skip = (why) => void (skipped[why] = (skipped[why] ?? 0) + 1);
     const here = location.href;
@@ -67,73 +67,145 @@ function capturePage(limits) {
         'SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE', 'SVG', 'PATH', 'IFRAME', 'CANVAS',
         'NAV', 'FORM', 'INPUT', 'SELECT', 'TEXTAREA', 'BUTTON',
     ]);
-    /** Collect the renderable leaves under one section, in document order. */
+    /**
+     * The renderable content under one section, AS A TREE.
+     *
+     * It used to return a flat list, and flatness was the biggest thing an import
+     * lost. A source's three-column feature row came back as three stacked blocks;
+     * a card — image, heading, copy, button — came back as four siblings with
+     * nothing saying they belonged together. Everything a reader understands from
+     * the ARRANGEMENT was thrown away, and no amount of correct colour brings it
+     * back.
+     *
+     * So a container that actually lays its children out — `display:flex` or
+     * `grid` — and has two or more of them that produced something becomes a
+     * GROUP carrying its direction. Anything else flattens, because a `<div>` that
+     * merely wraps is not a design decision and reproducing it would nest the
+     * result ten deep for nothing.
+     */
     const leaves = (root) => {
-        const out = [];
         const walk = (el) => {
-            if (out.length >= limits.maxPerSection)
-                return;
+            // ONE BOUND, on the whole import. There used to be a second, per section,
+            // and it kept doing the same wrong job under a new number: a page whose
+            // <body> has a single child is ONE section, so the per-section cap became
+            // the page cap and truncated it — news.ycombinator.com captured 84 links
+            // and 45 lines and lost the rest at exactly 120. Two limits for one
+            // quantity means the tighter one is always the real limit, and nobody
+            // remembers which that is.
+            if (taken.nodes >= limits.maxNodes) {
+                skip('over-node-limit');
+                return [];
+            }
             const tag = el.tagName;
             if (IGNORE.has(tag)) {
                 skip(tag.toLowerCase());
-                return;
+                return [];
             }
             if (!visible(el)) {
                 skip('hidden');
-                return;
+                return [];
             }
             if (HEADINGS.has(tag)) {
                 const text = clean(el.textContent);
-                if (text)
-                    out.push({ kind: 'heading', level: Number(tag.slice(1)), text });
-                return;
+                if (!text)
+                    return [];
+                taken.nodes++;
+                return [{ kind: 'heading', level: Number(tag.slice(1)), text }];
             }
             if (tag === 'IMG') {
                 const src = el.getAttribute('src');
                 if (!src || src.startsWith('data:')) {
                     skip('image-without-src');
-                    return;
+                    return [];
                 }
-                // BOUNDED, because every image is an upload. A sponsors wall is a real
-                // page shape — one measured at 36 logos in four sections — and importing
-                // it means 36 sequential HTTP round trips inside a single tool call,
-                // which is slow, half-fails in interesting ways, and is almost never
-                // what the caller wanted from "import this page".
                 if (taken.images >= limits.maxImages) {
                     skip('over-image-limit');
-                    return;
+                    return [];
                 }
                 taken.images++;
-                out.push({ kind: 'image', src: abs(src), alt: clean(el.getAttribute('alt')) });
-                return;
+                taken.nodes++;
+                return [{ kind: 'image', src: abs(src), alt: clean(el.getAttribute('alt')) }];
             }
-            if (tag === 'A' && looksLikeButton(el)) {
+            if (tag === 'A') {
                 const text = clean(el.textContent);
-                const href = el.getAttribute('href');
-                if (text) {
-                    out.push({ kind: 'button', text, ...(href ? { href: abs(href) } : {}) });
+                // A LINK THAT IS NOT A BUTTON IS STILL A LINK. It used to contribute
+                // NOTHING, and on a page whose content IS a list of links that is the
+                // whole page: news.ycombinator.com lost 1,595 characters of story titles
+                // and bylines that way. The platform has no inline-link element — its
+                // own idiom is a `button` carrying `href`, styled flat — so that is what
+                // an unpainted link becomes, and the variant is what keeps it from
+                // arriving as a call to action.
+                if (text && el.children.length === 0) {
+                    const href = el.getAttribute('href');
+                    taken.nodes++;
+                    return [{
+                            kind: 'button',
+                            variant: looksLikeButton(el) ? 'cta' : 'link',
+                            text,
+                            ...(href ? { href: abs(href) } : {}),
+                        }];
+                }
+                if (looksLikeButton(el) && text) {
+                    const href = el.getAttribute('href');
+                    taken.nodes++;
+                    return [{ kind: 'button', variant: 'cta', text, ...(href ? { href: abs(href) } : {}) }];
                 }
-                return;
             }
             if (tag === 'UL' || tag === 'OL') {
                 const items = Array.from(el.querySelectorAll('li'))
                     .map((li) => clean(li.textContent))
                     .filter(Boolean);
-                if (items.length)
-                    out.push({ kind: 'list', items });
-                return;
+                if (!items.length)
+                    return [];
+                taken.nodes++;
+                return [{ kind: 'list', items }];
             }
             if (tag === 'P' || tag === 'BLOCKQUOTE') {
                 const text = clean(el.textContent);
-                if (text)
-                    out.push({ kind: 'text', text });
-                return;
+                if (!text)
+                    return [];
+                taken.nodes++;
+                return [{ kind: 'text', text }];
+            }
+            const kids = [];
+            for (const child of Array.from(el.children)) {
+                for (const c of walk(child))
+                    kids.push(c);
+            }
+            if (kids.length > 0) {
+                const cs = getComputedStyle(el);
+                const lays = cs.display === 'flex' || cs.display === 'grid' ||
+                    cs.display === 'inline-flex' || cs.display === 'inline-grid';
+                // A ROW is worth keeping; a column is what the page already is, so
+                // wrapping one in a group would add a level that renders identically.
+                const row = cs.display.indexOf('grid') >= 0
+                    ? true
+                    : cs.flexDirection === 'row' || cs.flexDirection === 'row-reverse';
+                if (lays && row && kids.length >= 2) {
+                    taken.nodes++;
+                    return [{ kind: 'group', direction: 'row', wrap: cs.flexWrap === 'wrap', children: kids }];
+                }
+                return kids;
             }
-            for (const child of Array.from(el.children))
-                walk(child);
+            // THE TEXT FALLBACK, and it is most of the web. Capturing only <p> meant a
+            // page whose prose sits in a <div>, a <td> or a <span> came back EMPTY:
+            // measured, news.ycombinator.com (a table layout) and tailwindcss.com both
+            // kept 0 of ~4,000 and ~6,000 characters.
+            //
+            // Safe because it only fires when nothing INSIDE offered anything, so a
+            // paragraph is never taken twice — once through its <p> and again through
+            // the <div> around it. Bounded because a fallback that fires high in the
+            // tree would otherwise carry a whole page as one string.
+            const own = clean(el.textContent);
+            if (own && own.length <= limits.maxTextChars) {
+                taken.nodes++;
+                return [{ kind: 'text', text: own }];
+            }
+            if (own)
+                skip('text-too-long');
+            return [];
         };
-        walk(root);
-        return out;
+        return walk(root);
     };
     // SECTION CANDIDATES, widest first: a page that marks its bands up
     // semantically is read that way, and one that does not falls back to the
@@ -154,22 +226,50 @@ function capturePage(limits) {
     // document is one candidate too, and keeping THAT would reduce every page to a
     // single band. The finest ones are the page's actual bands.
     candidates = candidates.filter((el) => !candidates.some((o) => o !== el && el.contains(o)));
-    const sections = [];
-    for (const el of candidates) {
-        if (sections.length >= limits.maxSections) {
-            skip('over-section-limit');
-            break;
-        }
-        if (!visible(el)) {
-            skip('hidden');
-            continue;
-        }
-        const children = leaves(el);
-        if (children.length === 0) {
-            skip('empty-section');
-            continue;
+    // THE SOURCE'S OWN HEADER AND FOOTER ARE NEVER WANTED. The target site has its
+    // own, as shared globals, and importing somebody else's navigation onto a
+    // storefront is a second menu pointing at a different website. Only the
+    // PAGE-LEVEL ones are dropped — a `<header>` inside a section is a hero, and
+    // excluding those would lose the first thing on most landing pages.
+    const chrome = new Set();
+    for (const el of Array.from(document.body.children)) {
+        if (el.tagName === 'HEADER' || el.tagName === 'FOOTER')
+            chrome.add(el);
+    }
+    const build = (from) => {
+        const acc = [];
+        for (const el of from) {
+            if (chrome.has(el)) {
+                skip('page-chrome');
+                continue;
+            }
+            if (acc.length >= limits.maxSections) {
+                skip('over-section-limit');
+                break;
+            }
+            if (!visible(el)) {
+                skip('hidden');
+                continue;
+            }
+            const children = leaves(el);
+            if (children.length === 0) {
+                skip('empty-section');
+                continue;
+            }
+            acc.push({ kind: 'section', children });
         }
-        sections.push({ kind: 'section', children });
+        return acc;
+    };
+    let sections = build(candidates);
+    // THE FALLBACK HAS TO FIRE ON AN EMPTY RESULT, not only on an empty candidate
+    // LIST. A page can offer `<section>` elements that hold nothing this platform
+    // renders — a wrapper around a canvas, a slot filled by script later — and the
+    // old order took "we found candidates" as "we found content", so the whole
+    // page came back empty. Measured: tailwindcss.com kept 0 of 6,004 characters
+    // while reporting one skipped empty section.
+    if (sections.length === 0) {
+        const main = document.querySelectorAll('main')[0] ?? document.body;
+        sections = build(Array.from(main.children));
     }
     return { url: here, title: clean(document.title), sections, skipped };
 }
@@ -183,8 +283,9 @@ function capturePage(limits) {
 export async function capture(url, opts = {}) {
     const limits = {
         maxSections: opts.maxSections ?? 24,
-        maxPerSection: opts.maxPerSection ?? 40,
         maxImages: opts.maxImages ?? 24,
+        maxTextChars: opts.maxTextChars ?? 1200,
+        maxNodes: opts.maxNodes ?? 400,
     };
     let browser;
     try {

package/dist/vision/shoot.js CHANGED Viewed

@@ -90,15 +90,26 @@ export async function closeBrowser() {
         await b.close().catch(() => { });
 }
 /**
- * A kept browser is a child process, and a child process outlives a parent
- * that forgets it. `beforeExit` fires when the event loop drains and CAN await
- * the close (`exit` cannot). A signal kills the loop without draining it, so
- * SIGINT/SIGTERM close Chrome too and then re-raise so the exit code is the
- * one the signal would have produced. Registered once, at module load.
+ * A kept browser is a child process, and a child process outlives a parent that
+ * forgets it. SIGINT/SIGTERM close Chrome and then re-raise, so the exit code is
+ * the one the signal would have produced. That is the path the MCP server
+ * actually takes, because a stdio server is stopped by its client.
+ *
+ * THERE USED TO BE A `beforeExit` HANDLER HERE TOO, and it could never fire.
+ * `beforeExit` runs when the event loop DRAINS, and an open browser connection
+ * is exactly what keeps it from draining — so in the one situation the handler
+ * described (a caller that finished and forgot to close) it was unreachable, and
+ * in the other (nothing open) it had nothing to do. Proved by measurement: a
+ * script that took one screenshot and returned was still alive twenty seconds
+ * later, and two of them were killed by the OS for memory during this repo's own
+ * development. `playwright-core` exposes no `browser.process()` for `launch()`,
+ * so there is nothing to `unref` and no way to make it reachable.
+ *
+ * SO THE CONTRACT IS EXPLICIT: a caller that is not a long-running server must
+ * call `closeBrowser()` when it is done — a `finally` block, not a hope. The
+ * pooling is deliberate (a vision loop shoots constantly and must not pay a
+ * launch each time); the cost of it is this one line at every other call site.
  */
-process.once('beforeExit', () => {
-    void closeBrowser();
-});
 for (const signal of ['SIGINT', 'SIGTERM']) {
     process.once(signal, () => {
         void closeBrowser().finally(() => process.kill(process.pid, signal));

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "sbuilder-mcp",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "MCP server that designs and operates a Store Builder site — pages, data, theme and publish — through the platform's own API and live-edit protocol.",
   "mcpName": "io.github.vuluu2k/sbuilder-mcp",
   "type": "module",