sbuilder-mcp 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -6,6 +6,17 @@ 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.22.0] - 2026-09-10
+
+### Added
+- sb_import_site now builds one shared global `header` section from the pages it created and gives every page a reference to it, so editing the menu once changes it on every page instead of leaving each page to carry its own copy.
+- sb_import_site takes a `nav` argument (default true) to skip the shared header, and reports what happened under `shared_header` in its result.
+
+## [0.21.1] - 2026-09-10
+
+### Fixed
+- sb_import_site now keeps the fragment (e.g. `#community`) when it rewrites a same-page section link to point at the imported page, instead of dropping it and sending every such link to the top of the page.
+
 ## [0.21.0] - 2026-09-10
 
 ### Added

package/CHANGELOG.vi.md

@@ -6,6 +6,17 @@ 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.22.0] - 2026-09-10
+
+### Added
+- sb_import_site giờ dựng một global section `header` dùng chung từ các trang nó đã tạo và cho mỗi trang một tham chiếu tới đó, nên sửa menu một lần là đổi trên mọi trang thay vì mỗi trang tự mang một bản riêng.
+- sb_import_site nhận tham số `nav` (mặc định true) để bỏ qua header dùng chung, và báo kết quả qua `shared_header` trong output.
+
+## [0.21.1] - 2026-09-10
+
+### Fixed
+- sb_import_site giờ giữ lại fragment (ví dụ `#community`) khi viết lại một link trỏ tới section trong cùng trang đã import, thay vì bỏ mất nó và khiến mọi link kiểu này đều trỏ về đầu trang.
+
 ## [0.21.0] - 2026-09-10
 
 ### Added

package/dist/domains/site/importmap.js

@@ -441,7 +441,14 @@ export function relink(captured, local, origin) {
             const norm = normalizeUrl(href);
             const to = norm ? local.get(norm) : undefined;
             if (to) {
-                href = to;
+                // THE FRAGMENT SURVIVES. `normalizeUrl` drops it because it is not part
+                // of a page's IDENTITY — that is what folds `/a` and `/a#top` into one
+                // page — but it is very much part of the link, and a source page's
+                // "jump to the forums" section link would otherwise land at the top of
+                // the page and look broken. Measured on a real import: six of them on
+                // one page.
+                const hash = href.indexOf('#');
+                href = hash >= 0 ? `${to}${href.slice(hash)}` : to;
                 rewritten += 1;
             }
             else if (norm && norm.indexOf(origin) === 0) {
@@ -453,3 +460,58 @@ export function relink(captured, local, origin) {
     };
     return { sections: captured.map(one), rewritten, unimported };
 }
+/**
+ * A menu label from a page's own `<title>`.
+ *
+ * A title is written for a browser tab and a search result — "Example Servers —
+ * Model Context Protocol" — and a menu row of those wraps to three lines. The
+ * part before the first separator is what the page calls itself; the cap is
+ * what keeps one long name from owning the row.
+ */
+export function menuLabel(name) {
+    const head = name.split(/\s+[|—–·:]\s+/)[0].trim() || name.trim();
+    return head.length > 28 ? `${head.slice(0, 27).trimEnd()}…` : head;
+}
+/**
+ * THE SHARED HEADER, built from the pages that were actually created.
+ *
+ * NOT from the source's own nav, deliberately. Its links point at the site it
+ * was copied from, half of them at pages the cap left out, and its structure is
+ * somebody else's — three reasons the capture skips page chrome in the first
+ * place. What the merchant needs is a way to reach THESE pages, and that list is
+ * already known exactly.
+ *
+ * Built through `toSpecs` rather than hand-assembled so it wears the same tokens
+ * every imported section does — a header that answers the accent differently is
+ * rule 0 broken on the one band that appears on every page. Only the padding is
+ * overridden: a section's 64px is right for a band of content and absurd for a
+ * menu.
+ */
+export function navSpec(links, t) {
+    if (links.length === 0)
+        return null;
+    const [section] = toSpecs([
+        {
+            kind: 'section',
+            children: [
+                {
+                    kind: 'group',
+                    direction: 'row',
+                    wrap: true,
+                    children: links.map((l) => ({
+                        kind: 'button',
+                        variant: 'link',
+                        text: l.text,
+                        href: l.href,
+                    })),
+                },
+            ],
+        },
+    ], t);
+    if (!section)
+        return null;
+    return {
+        ...section,
+        style: { ...section.style, padding: '16px 24px' },
+    };
+}

package/dist/tools/importpage.js

@@ -4,7 +4,8 @@ import { capture, captureMany, crawlLinks } from '../vision/capture.js';
 import { uploadMedia } from '../transport/media.js';
 import { addSubtree } from '../domains/site/builder.js';
 import { middleEnd } from '../domains/site/traps.js';
-import { toSpecs, tokensFromPage, imageSources, rehostImages, relink, } from '../domains/site/importmap.js';
+import { toSpecs, tokensFromPage, imageSources, menuLabel, navSpec, rehostImages, relink, } from '../domains/site/importmap.js';
+import { subtreeIds } from '../core/tree.js';
 import { canonFor, choosePages, normalizeUrl, robotsRules, robotsSitemaps, sitemapUrls, } from '../domains/site/discover.js';
 import { loadSource } from '../transport/pages.js';
 import { PageDoc } from '../domains/site/document.js';
@@ -156,6 +157,26 @@ async function discoverSite(ctx, entry, opts) {
     }
     return { source: 'links', urls, titles: crawled.titles, visited: crawled.visited, robots, aliases };
 }
+/**
+ * A built subtree as the document a GLOBAL SECTION stores.
+ *
+ * A global's document is page-document SHAPED but its `root_node_id` IS the
+ * section — compose carries its nodes over and re-parents that root onto the
+ * page's ROOT (`server/internal/page/compose.go:133`). So the section is built
+ * the ordinary way, under a throwaway ROOT, and then lifted out with its parent
+ * cleared: a master has no parent until a page composes it.
+ */
+export function globalDocumentFrom(spec) {
+    const scratch = PageDoc.from({ schema_version: 2, root_node_id: '', nodes: {} });
+    const { patches, ids } = addSubtree(scratch, scratch.doc.root_node_id, spec);
+    scratch.apply(patches);
+    const rootId = ids[0];
+    const nodes = {};
+    for (const id of subtreeIds(scratch.doc, rootId))
+        nodes[id] = scratch.doc.nodes[id];
+    nodes[rootId].data.parent = null;
+    return { schema_version: 2, root_node_id: rootId, nodes };
+}
 export function registerImportTools(server, ctx, session) {
     server.registerTool('sb_import', {
         description: 'Read a page from any public URL and add its structure and content to the OPEN page as ' +
@@ -313,10 +334,11 @@ export function registerImportTools(server, ctx, session) {
             max_nodes: z.number().int().min(1).max(1000).optional().describe('Per page, default 300'),
             upload_images: z.boolean().optional(),
             homepage: z.boolean().optional().describe("Entry into this site's home page, default true"),
+            nav: z.boolean().optional().describe('Shared header linking the new pages, default true'),
             dry_run: z.boolean().optional(),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
-    }, async ({ url, site_id: given, max_pages, depth, include, exclude, max_images, max_nodes, upload_images, homepage, dry_run, }) => {
+    }, async ({ url, site_id: given, max_pages, depth, include, exclude, max_images, max_nodes, upload_images, homepage, nav, dry_run, }) => {
         const siteId = siteFor(ctx, given);
         const entry = normalizeUrl(url);
         if (!entry) {
@@ -597,6 +619,85 @@ export function registerImportTools(server, ctx, session) {
                 failed.push({ url: p.url, why: e.message.replace(/^sbuilder:\s*/, '').slice(0, 200) });
             }
         }
+        // THE MENU THAT LINKS THEM TOGETHER — the last thing the directive said this
+        // could not do for you.
+        //
+        // Built from the pages that were ACTUALLY created, never from the source's
+        // own nav: that one points at the site this was copied from, half of it at
+        // pages the cap left out, and its structure is somebody else's. What the
+        // merchant needs is a way to reach THESE pages, and that list is known
+        // exactly.
+        //
+        // Skipped when the site already has a header, because a second one is not
+        // an improvement — it is two headers. Also skipped below two pages: a menu
+        // to one page is a link to itself.
+        let chrome;
+        if (nav !== false && built.length >= 2) {
+            try {
+                const existingGlobals = (await request({
+                    base: ctx.base,
+                    method: 'GET',
+                    path: `/api/sites/${encodeURIComponent(siteId)}/global-sections`,
+                    token: siteToken(ctx),
+                    fetchImpl: ctx.fetchImpl,
+                }));
+                const hasHeader = (existingGlobals.globalSections ?? []).some((g) => g.kind === 'header');
+                if (hasHeader) {
+                    chrome = {
+                        skipped: 'this site already has a header global section — a second one is two headers, not a menu',
+                    };
+                }
+                else {
+                    const links = built
+                        .map((b) => {
+                        const planned = plan.pages.find((p) => p.url === b.url);
+                        const to = localPath.get(String(b.url));
+                        return planned && to ? { text: menuLabel(planned.name), href: to } : null;
+                    })
+                        .filter((l) => l !== null);
+                    const spec = navSpec(links, tokens);
+                    if (spec) {
+                        const made = (await request({
+                            base: ctx.base,
+                            method: 'POST',
+                            path: `/api/sites/${encodeURIComponent(siteId)}/global-sections`,
+                            token: siteToken(ctx),
+                            body: { name: 'Header', kind: 'header', document: globalDocumentFrom(spec) },
+                            fetchImpl: ctx.fetchImpl,
+                        }));
+                        const gid = made.globalSection?.id;
+                        if (typeof gid === 'string' && gid) {
+                            // A PAGE REFERENCES a master with a ROOT child carrying
+                            // `globalRef` — the shape the platform's own decompose writes
+                            // (`decompose.go:382`), down to the flex-section type and the
+                            // `globalKind` beside it. FIRST, because compose turns it into a
+                            // real header and a header after middle content is a band-order
+                            // refusal on the next save.
+                            const carried = [];
+                            for (const b of built) {
+                                try {
+                                    await session.open(siteId, String(b.page_id));
+                                    const doc = session.current();
+                                    const { patches } = addSubtree(doc, doc.doc.root_node_id, { type: 'flex-section', specials: { globalRef: gid, globalKind: 'header' } }, 0);
+                                    await session.applyAndSave(patches);
+                                    carried.push(String(b.slug));
+                                }
+                                catch {
+                                    // One page that will not take the header does not undo the
+                                    // header: the master exists and the others carry it.
+                                }
+                            }
+                            chrome = { header: gid, on: carried, links: links.length };
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // The pages are built and correct; a header that could not be made is
+                // a thing to report, never a reason to fail the import.
+                chrome = { failed: e.message.replace(/^sbuilder:\s*/, '').slice(0, 160) };
+            }
+        }
         return text({
             entry,
             discovered_by: found.source,
@@ -607,6 +708,7 @@ export function registerImportTools(server, ctx, session) {
                 rewritten: relinked,
                 ...(unimported ? { still_off_site: unimported } : {}),
             },
+            ...(chrome ? { shared_header: chrome } : {}),
             ...(formsSeen.length
                 ? {
                     forms_found: formsSeen,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sbuilder-mcp",
-  "version": "0.21.0",
+  "version": "0.22.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",