Skip to main content
Glama

sbuilder-mcp

An MCP stdio server that lets an AI agent operate a Store Builder site end to end — design its pages, fill them with real data, look at the result, and publish it — with no human clicking anything.

Tiếng Việt

Install

One command writes this server into every agent client on your machine:

npx -y sbuilder-mcp install --token wbk_… --api https://your-host --site site_…

It knows Claude Code, Claude Desktop, Cursor, Windsurf, VS Code and Codex, and installs into the ones it finds. Name them with --client cursor,codex, or rehearse with --dry-run. An option it does not know is refused, not ignored — a flag that silently does nothing is worse than one that does not exist.

--site is optional and worth passing: a key belongs to exactly one site, so it is written as SB_SITE and every tool then defaults to it. Without it the model has to carry the id through the session, which it can only get by listing pages and reading one back.

--site-name "Your Store" rides alongside it as SB_SITE_NAME. It is a label, never an address — nothing resolves by it — but it lets the agent say the store's name back to you instead of a 32-character id you did not choose. The Apps → AI agent screen appends it whenever the store has a name.

It merges: the servers already in those files stay, whatever it replaces is copied to <file>.sbuilder-backup, and a config it cannot parse is refused rather than overwritten — a file with a trailing comma is far likelier than one worth discarding, and it is what you need to fix it.

The store's Apps → AI agent screen hands you this command with the key already in it.

{
  "mcpServers": {
    "sbuilder": {
      "command": "npx",
      "args": ["-y", "sbuilder-mcp"],
      "env": { "SB_API": "https://api.your-host", "SB_TOKEN": "wbk_…", "SB_SITE": "site_…" }
    }
  }
}

Related MCP server: AI 客服商城 MCP Server

Getting the key

Open your store, go to Apps → AI agent, and press Create key. That screen hands you the config block for your client with the key already in it — this whole section is what it saves you reading.

One key is all you need. It reaches both the partner surface (/api/v1) and the private site API, including the page document and the live-edit socket, and it is bounded three ways on every request: its own scopes, the live role of the member who created it, and the single store it belongs to.

SB_EMAIL + SB_PASSWORD remain optional, and buy exactly one thing: account-level calls — listing your sites, managing members and roles — which a key deliberately cannot make, because those mean "this person's account".

SB_API defaults to http://localhost:8080. Secrets are read from the environment only.

sb_media_upload's photo search needs no key here: it calls the platform's own GET /api/sites/{siteId}/images/search, which runs a rotated pool of provider keys behind the credential this server already holds. An operator enables it by setting PEXELS_API_KEYS on the SERVER (comma separated; free keys at https://www.pexels.com/api/). With none configured the search answers "unavailable" and tells the caller to find a photograph by its own means and pass the URL — which the platform then fetches server-side. There is deliberately no fallback provider in this client: one would put the very key the platform exists to hold back into every install.

Tools

Tool

What it does

sb_connect

Log in, list the sites this account can operate, report which credentials are present

sb_site_list

List the sites this account can operate

sb_api_find

Find API operations by intent — one line per match — then read one operation's call sheet by id: real parameter schemas, the credential it needs, and the body's fields read off the handler that decodes them, each carrying the trap its own doc comment records

sb_api_call

Execute an operation, or any route by method+path; dry run by default. Field selection (dotted paths, on lists and single-object write answers) and local result pagination; merge for whole-record PUTs, If-Match, multipart file

sb_page_open

Open a page for editing and return its outline — or, with form_id, a form's field document (fields, defaults, dependent-field rules)

sb_outline

The open page as a compressed tree — never a raw document dump; shared header/footer and overlays one line each unless chrome: true

sb_node_read

One node in full, with a warning if it is a shared global

sb_catalog_search

Find an element by what it should do, using the platform's own AI hints

sb_traits_for

An element's inspector — tabs, groups, controls and what each declared one writes — plus its AI hints, defaults and containment rules

sb_add

Add an element — or a whole nested subtree — in one call; a filter arrives with its option rows read from the catalogue

sb_set

Write style/config/specials. Per breakpoint by default

sb_move

Move a node to another parent

sb_remove

Remove a node and its subtree

sb_duplicate

Copy a node and its subtree under fresh ids, right after the original — or onto another page or site, as the editor's copy/paste does (assets copied, references that cannot travel listed)

sb_templates

The store's saved section templates, plus the BUILT-IN layouts — hero, feature trio, stats, FAQ, CTA band, product shelf, category strip, brand wall, trust band — composed against the page's own tokens

sb_template_use

Add a section template to a page

sb_page_list

Every page on the site

sb_page_create

Create a page — a store type arrives with the editor's own starting document; type is the route for checkout, product, category, post, course

sb_page_update

Edit a page's name, slug, home flag, order, SEO (title, description, Open Graph, robots, meta tags, JSON-LD) and members-only flag — merged into settings, so the keys it does not name survive. On a template page: make it the type's default, or choose which products/categories/posts render through it

sb_page_version

A page's platform recovery points — list named versions and autosave history, snapshot the draft, restore one

sb_code

The site's custom code files (tracking pixels, analytics, chat widgets, site CSS; html/css/js/scss/ts injected, json/text served at /_wb/code/<name>) for every page or one — list, create, merge-update, remove; scss/ts compile on write and report compile_error

sb_function

The site's backend functions — server-side TypeScript/JavaScript served at /_wb/fn/<slug> with the site's sealed secrets, collections and fetch (a _ slug is an importable module) — list, read, create, merge-update, remove, test-run (counts toward the monthly quota), the run log, this month's usage, and write-only secrets; a failed build reports compile_error

sb_collection

The site's data tables (collections) — create, rename, delete tables; add, edit, reorder and delete typed fields (text, number, integer, select, tags, reference, gallery…); list, read, add, merge-edit, delete, move and reorder records; CSV export and import; upsert by external id. An edit keeps the row's published flag and sends its rev

sb_publish

Compile the draft into the live page (cascades to shared globals), report which revision went live, and with verify check the origin is serving it; lists other pages with unpublished drafts and never-published pages (publish_drafts publishes both)

sb_page_state

Which of a page's three copies is which — the DRAFT the editor canvas shows, the PUBLISHED row the storefront serves, and this session's — plus whether the editor will render the canvas BLANK, and where the recovery points are

sb_page_repair

Rename a page root that is not ROOT (left by older seeds) so every editor build draws it — one page or the whole site

sb_review

Every defect a visitor would see, each with its fix, plus the five gaps between this store and a paid order

sb_media_list

The site's media library

sb_media_upload

Add an image and get its URL — a local path, a URL the platform fetches, or a SEARCH for real photographs you read and pick from, one or several at a time; paths uploads many local files in one call

sb_live_join

Join the editor's live-edit room as a visible peer — edits then appear live

sb_look

Save, render, and return screenshots plus measured node boxes and layout defects measured on the render

sb_event

Give a node a click action — open the cart, go to a page, open a pop-up

sb_bind

Bind a node's content to real store data, or make a button add to the cart

sb_import

Read a page from any public URL and add its structure and content to the open page as real elements, styled with THIS page's own tokens — a translation, not a clone

sb_import_site

Read a WHOLE site from one URL — its sitemap, or the links on that page — and give each page found its own draft page here, built from this site's tokens; the entry page's own colours and type scale also patch into this SITE'S theme, so it stops being purely a read

sb_theme

Read or patch the site's palette and type scale — the layer every style preset resolves from, so one token repaints every page; per-breakpoint text-style overrides and element style presets; locale sets the site's language

sb_translate

Translate a site the way the editor's Multilingual panel does — enable languages, list a page's strings as missing / done / outdated, write or machine-fill them, approve machine rows

sb_store

Run a store flow that must happen in a fixed order — checkout (the four writes that make a working one), checkout_sync (the store's current payment and delivery methods into every existing order form, checkout page republished), form (any of the platform's 17 templates with its own field document), chrome (one shared header or footer on a real site menu — site name linked home, desktop menu, mobile drawer, search, cart and account icons), menu (a menu node bound to the site's menu, its links resolved), overlay_attach (a pop-up or quick view on the open page), cart (the site's cart drawer, when it has none; relocalize puts an existing one in the site's language) and app (a built-in app plus the pages it needs), global_attach / global_detach (put an EXISTING shared section on the open page, or take it off), global_promote (make a section on the page a NEW shared section) and template_save (save a section as a reusable template)

sb_undo

Undo / redo this session's writes — page and form edits and sb_api_call PUTs, each named by tool and target, the open page's by default (all: true for every page); a page is refused if someone else saved it since. The platform's versions and history (sb_page_version) outlive this process

Thirty-nine tools, 969 API operations (362 of the 451 writes carrying a body shape read off the handler), 124 elements, 96 binding sources. sb_api_find is an index rather than a tool per endpoint, so the tool list stays short while everything the platform can do stays reachable — and operations added to the platform arrive with the next npm run codegen.

Every result is compact JSON, every directive is said once per process, and every tool carries MCP annotations — a client that honours them stops asking a person to confirm a read.

Full reference: docs/tools.md. What the builder supports natively, and where it stops: docs/capabilities.md.

How it stays in sync

The platform publishes two generated, committed artifacts. A build step reads them out of a checkout and emits the catalog:

WB_REPO=/path/to/web_builder npm run codegen

So this repository vendors no platform code — it depends on two data files with a maintained contract. src/catalog/api.generated.ts is committed, so npm install needs no checkout at all.

Development

npm run build     # tsc -> dist/
npm test          # vitest
npm run smoke     # offline self-test; must print ALL GOOD

Contributor guide: CLAUDE.md. Design rationale: docs/superpowers/specs/.

Release

A push to main that touches src/** releases on its own (.github/workflows/auto-release.yml): the gate runs (build, test, smoke), the version bump is read off the commit subject — feat is minor, BREAKING CHANGE or ! is major, anything else is patch — Claude writes the changelog entry in both languages, server.json is synced, the release is committed as chore(release): vX.Y.Z and tagged, then published to npm, as a GitHub Release, and to the MCP Registry through GitHub OIDC. workflow_dispatch runs the same flow with a bump you choose. A commit whose subject contains chore(release): or release: v is skipped, so a release never triggers another.

The workflow needs two repository secrets in the prod environment: NPM_ACCESS_TOKEN and CLAUDE_CODE_OAUTH_TOKEN. The registry step needs none.

npm run release (scripts/release.mjs) is the offline path — a machine with no CI, or a release cut while a secret is being rotated. It runs the same gate and writes the same ## [x.y.z] - date changelog heading, so the two never disagree.

Designing safely

Five platform rules fail silently if a client does not know them, so they are encoded here as tested code rather than advice:

  • Band order — ROOT's children must read [header][middle][footer], or the platform refuses every save.

  • Site overlays (the cart drawer, pop-ups) are composed onto ROOT on read and stripped on write; they are excluded from every ROOT-level rule and cannot be edited through the page tools.

  • Global sections are shared masters — editing one changes every page carrying it, and publishing cascades. Any result touching one says so.

  • Responsive by default — sb_set writes per breakpoint, because a design should respond. Base is the cascade's fallback layer, not a trap.

  • App blocks — a marketplace app's subtree is composed onto the page on read and reduced back to one reference node on save, so an edit inside it is lost without a word. Every write refuses the interior; the outline flags the block root app: true.

Status

All three phases shipped: authentication and full API reach; the page document, patch protocol, builder and the five traps; the live-edit socket, the yield rule, and the vision loop. Since then: a token diet across every result, and releases that cut themselves.

Requires Node ≥22 (the global WebSocket) and, for sb_look only, system Google Chrome — playwright-core bundles no browser, so installing downloads nothing.

MIT.

Available Tools

39 tools
sb_addB

Add an element — or a whole NESTED subtree — under a parent. One call builds a complete section: pass children rather than calling this once per node.

Inputs: spec (required), parent_id (required), force, index, +1 more.

sb_api_callA
Destructive

Call an operation from sb_api_find (id), or a route the catalog lacks (method+path); dry run by default. pick selects fields, max_items caps lists, item_offset skips items. Lists over 60 KB say so.

Inputs: id, body, file, path, +10 more.

sb_api_findA
Read-only

Find API operations by intent (query), or get a call sheet (id): parameters, credential, body fields and handler caveats. Reaches all 969 operations.

Inputs: id, tag, limit, query.

sb_bindA

Bind a node to real store data so the page shows actual products, not placeholder text. action makes a button a purchase control.

Inputs: id (required), field (required), source (required), force, +2 more.

sb_codeA
Destructive

The site's custom code files — tracking pixels, analytics, chat widgets, site-wide CSS — injected at head, body_start or body_end of every page (no page_id) or one page. Create infers language from the extension, placement from the language. scss/typescript compile on write (compile_error). json/text: placement "none" only; an enabled site-wide "none" file is served at its url. action:"list" | "set" (no id creates; with id merges the named fields over the stored row) | "remove". Not the custom-code element.

Inputs: action (required), id, name, content, +7 more.

sb_collectionB
Destructive

Data tables (collections): tables, typed fields, records, CSV export/import (appends), upsert by external_id. edit merges values (null clears). get/edit/remove/move take id.

Inputs: action (required), id, csv, ids, +21 more.

sb_connectA
Read-only

Log in and list the sites this account can operate. Call this first. Reads SB_EMAIL and SB_PASSWORD from the environment unless you pass them.

Inputs: email, password.

sb_duplicateA

Copy a node and everything under it, under fresh ids, right after the original. The move a designer makes constantly — build one card, duplicate it twice. to_page_id (and to_site_id) pastes the copy onto another page instead, as the editor's copy/paste does: a cross-site copy has its images copied into the target library and references that cannot travel blanked and listed; the open page becomes the target.

Inputs: id (required), force, index, dry_run, +3 more.

sb_eventA

Give a node a click action — open the cart, go to a page, open a pop-up. A purchase is not one: use sb_bind action.

Inputs: id (required), action (required), force, dry_run, +2 more.

sb_functionA
Destructive

Backend functions: server-side TS/JS at /wb/fn/ with the site's secrets, collections and fetch ("" slug = importable module). Not sb_code. action: list | get | set (no id creates; id merges) | remove (id, or secret key) | test (method/path/query/headers/cookies/body) | logs | usage | secret (no key lists; key+value sets). Owner/admin only.

Inputs: action (required), id, key, body, +13 more.

sb_importA

Read a page from any public URL and add its structure and content to the OPEN page as real elements, styled with this page's own tokens. Not a clone: the source's layout and CSS are not copied. Dry run returns what was found.

Inputs: url (required), dry_run, site_id, max_nodes, +4 more.

sb_import_siteB

Read a WHOLE site from one URL — its sitemap, or the links on that page — and give each page found its own DRAFT page here, built from this site's tokens. Not a clone. Dry run returns the page list before anything is created.

Inputs: url (required), nav, depth, theme, +10 more.

sb_live_joinA
Idempotent

Join the site's live-edit room as a visible peer: every write then appears in any open editor as it happens, with the agent shown by the API key's own name rather than a person's. Always yields, so it is safe beside a human. Works with SB_TOKEN or with SB_EMAIL / SB_PASSWORD.

Inputs: site_id.

sb_lookA
Idempotent

Save, render through the platform's own renderer, and return screenshots at desktop, tablet and mobile widths, measured boxes for the bands and their children, and any layout defect measured on the render (overflow, overlap, unreadable text). node_id frames one element. Judge your work from these, not from memory.

Inputs: url, format, widths, node_id, +2 more.

sb_media_listA
Read-only

The site's media library. Reuse an image before adding another; search by name, filter by type, page with limit/offset.

Inputs: limit, offset, search, site_id, +1 more.

sb_media_uploadA

Put an image into the media library and get its URL back, ready for sb_set. Takes a local path, a URL, or a SEARCH — query returns real photographs with their own descriptions, and pick uploads the one you chose, or several at once to stock a site you just built. The only way to add an image.

Inputs: url, name, path, pick, +6 more.

sb_moveA

Move a node to another parent at an index.

Inputs: id (required), index (required), parent_id (required), force, +1 more.

sb_node_readA
Read-only

One node in full — style, config, specials, per-breakpoint overrides, bindings.

Inputs: id (required).

sb_outlineA
Read-only

The open page as a compressed tree — id, type, name, child count, band, and whether a node is a shared global or a site overlay. Never the raw document: a real page is hundreds of KB of JSON.

Inputs: depth, chrome.

sb_page_createC

A store type (product, category, search, blog, post, complete, account) arrives with the document the editor gives a merchant — product carries the whole bound buy box; seed:false for blank. Any other type is empty and sb_page_open seeds its ROOT. TYPE is the route: /checkout and /products/{slug} need a PUBLISHED page of that type or they 404.

Inputs: name (required), seed, slug, type, +7 more.

sb_page_listA
Read-only

Every page on the site, with its slug and whether it is live.

Inputs: site_id.

sb_page_openA
Read-only

Open a page for editing and return its outline. Call before any sb_add / sb_set / sb_move / sb_remove. Find page ids with sb_api_find "list pages". Or form_id: edit that form's field document (fields, specials.formRules on its root).

Inputs: form_id, page_id, site_id.

sb_page_repairA
Idempotent

Rename a page root that is not "ROOT" (sppro_1, rt_ — left by older seeds) to ROOT, for one page or, without page_id, every page on the site. Draft only; a published page is listed for re-publishing. dry_run (default true) lists what would change.

Inputs: dry_run, page_id, site_id.

sb_page_stateA
Read-only

Which of this page's three copies is which: the DRAFT the editor canvas shows, the PUBLISHED row the storefront serves, and what this session holds. Says whether the editor will render the canvas BLANK (its hydrate gate discards a document whose root is missing and shows an empty ROOT, silently — the Go renderer has no such gate, which is how "the live page has data but the canvas is empty" happens), whether the draft has changes the live page does not, and where the recovery points are.

Inputs: page_id, site_id.

sb_page_updateA

Edit a page's name, slug, home flag, order, SEO (merged key by key) or members_only. Reads the page first and merges settings, so keys it does not name survive. On a template page (product, category, post, blog, course, brand): default_template makes it the type's default, render_for/render_default move entities onto it or back to the default.

Inputs: page_id (required), seo, name, slug, +8 more.

sb_page_versionA
Destructive

A page's platform recovery points, everyone's edits included (sb_undo covers this process only). action:"list" — named versions and autosave history; "save" {label} — snapshot the current draft; "restore" {version_id | history_id} — put the draft back. Writes are dry runs by default.

Inputs: action (required), label, dry_run, page_id, +3 more.

sb_publishA
DestructiveIdempotent

Compile the draft into the live page, and report which revision went live (id, publishedAt, fromVersionId). PUBLISH CASCADES to every page sharing a changed global section or overlay; the dry run lists them (would_cascade) and warns FIRST when it would ship shared edits nobody published. verify:true then fetches the live page and says whether the origin is serving that revision yet — the storefront caches for 60s, so a reload showing the old page is that, not a failed publish.

Inputs: page_id (required), verify, dry_run, site_id, +1 more.

sb_removeA
Destructive

Remove a node and its whole subtree.

Inputs: id (required), force, dry_run.

sb_reviewA
Read-only

What a VISITOR would meet on the open page (blank band, placeholder, dead binding) AND what stands between this store and a paid order (checkout page, gateway, delivery, a cart link). Run it before calling a page done; page_id: only that page.

Inputs: page_id.

sb_setA

Write style, config or specials keys on one node, or on many through edits (one save, one live frame). Per BREAKPOINT by default; base:true writes the fallback layer, right for a value that should not vary.

Inputs: id, base, keys, edits, +6 more.

sb_site_listB
Read-only

List the sites this account can operate.

Inputs: no named parameters.

sb_storeA

Run a store flow that must happen in a fixed order. action:"checkout" makes the order form, configures it, saves its fields with this store's real payment and delivery options, then creates and PUBLISHES the checkout page — /checkout 404s without all four. action:"checkout_sync" re-reads the store's payment and delivery methods into every existing order form and republishes the checkout page — run it after adding a shipping method or switching on a gateway, since the form keeps the options it was saved with. action:"form" seeds any of the platform's other form templates (login, contact, booking, stay and more — settings merge into the record) with its own field document, which is the part that cannot be guessed. action:"chrome" gives every page ONE shared header (footer:true — footer) built on a real site menu of page/category/product references: site name, desktop menu, mobile drawer, search, cart and account icons — the gap sb_review reports as siteChrome. action:"menu" binds a menu node on the open page to the site's menu and resolves its links, the way the editor does. action:"overlay_attach" puts a pop-up on the open page (kind:"popup") or points a list-dataset at a quick-view panel (kind:"quickview", list_id), creating either from the platform's own seed when overlay_id is omitted, and re-reads the page afterwards as the editor must. action:"cart" creates the site's cart drawer from the editor's seed when it has none — without it every open_cart control opens nothing. action:"app" installs one of the platform's built-in apps (app_key) and creates the pages it needs that installing it does not — today only "courses" has any, from the platform's own scaffold; every other key installs with nothing further to build. action:"global_attach" puts an EXISTING shared section (global_id) on the open page and action:"global_detach" takes it off, writing the reference the platform reads and placing it in the band ROOT's child order demands — the answer for a page that is missing the site's header, where action:"chrome" would wrongly build a second one. action:"global_promote" turns a section on the open page (node_id) into a NEW shared section (global_kind header|footer|custom, default custom) and leaves the page referencing it; action:"template_save" saves one as a section template (name; template_share sends one to the org's review). site_template offers the whole site as its org's template (org_id attaches first; site_template_remove withdraws). Dry run returns the plan.

Inputs: action (required), kind, name, footer, +19 more.

sb_templatesC
Read-only

The store's saved section templates — designed sections a person starts from rather than assembling one. Use sb_template_use to drop one into the open page.

Inputs: site_id.

sb_template_useA

Add a section template to a page, above the footer — a sb_templates row (another site's is copied in first) or one of the BUILT-IN layouts sb_templates lists, which are composed against this page's own tokens rather than copied.

Inputs: page_id (required), template_id (required), dry_run, site_id.

sb_themeA

The site's palette and type scale — the layer every element's style preset resolves from, so one token repaints every page at once. Call it with nothing to read what the site actually has. colors and text_styles PATCH the saved document: what you do not name is kept, and so does presets (a preset's own literal outranks the text style). A mobile/tablet/laptop object writes that breakpoint. locale sets the site's language (settings.locale, what is served from) — site-wide, every other setting kept.

Inputs: colors, locale, dry_run, presets, +2 more.

sb_traits_forA
Read-only

This element's INSPECTOR, as a person sees it: tabs, groups, and every control name — with what each DECLARED control writes, and the AI hints for using the element. Read this before styling an element; pass control to read one control in full.

Inputs: type (required), control.

sb_translateC

Multilingual, as the editor does it. status | locales (add/remove) | page (rows: missing, done, outdated) | write (node id+field+value; registry fields only) | auto (machine-fill missing) | review (approve).

Inputs: action (required), add, all, from, +8 more.

sb_undoA
Destructive

Put back what a write replaced — a page or form edit made here (sb_add, sb_set, sb_duplicate …), or a PUT through sb_api_call. An undo records what IT replaced, so the newest entry right after one is its redo. A page is refused if anyone else saved it since. IN THIS PROCESS ONLY, capped; the platform's own page history (GET .../pages/{pageId}/history) survives a restart. No argument lists what is undoable.

Inputs: all, index, dry_run.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 39 tools

    Disambiguation4/5

    Most tools have a crisp, distinct job (sb_add/sb_set/sb_move/sb_remove, sb_media_list vs sb_media_upload, sb_api_find vs sb_api_call), and the descriptions actively fence off look-alikes ("Not sb_code", "Not the custom-code element", sb_page_version vs sb_undo vs sb_page_state). The weak spots are sb_store, which is a mega-action tool whose checkout/form/chrome/menu/overlay/global actions overlap with sb_page_create, sb_template_use and sb_page_open(form_id), and the cluster of read-only inspectors (sb_outline, sb_node_read, sb_page_state, sb_review) that need careful reading to keep apart.

    Naming Consistency4/5

    Everything is snake_case under a uniform sb_ prefix, with predictable families (sb_page_*, sb_media_*, sb_api_*, sb_import*). The ordering is inconsistent though: some names are noun_verb (sb_site_list, sb_node_read, sb_page_open, sb_catalog_search) and others verb-only (sb_add, sb_set, sb_publish, sb_undo), and sb_templates vs sb_template_use mixes plural and singular for the same resource.

    Tool Count2/5

    39 tools is far past the comfortable range for a single agent surface; the tool list alone is a large context cost before any work begins. The domain is genuinely broad (page editing, theming, commerce, media, collections, functions, i18n, import), but several could be collapsed — the sb_store action multiplex and the four read-only page inspectors especially — into fewer, better-scoped tools.

    Completeness4/5

    Coverage is unusually thorough: page create/open/update/publish/version/repair, element CRUD, styling, bindings, events, templates, media, theme tokens, i18n, collections, backend functions, custom code, and a generic sb_api_call escape hatch to 969 operations. The main native gaps are page/site deletion, site creation and domain/settings management, which an agent can reach through sb_api_call but not through purpose-built tools.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables an AI assistant to publish a storefront it built to live hosting, read the live site back, add, update or delete a single page, manage the catalogue, orders and reviews, and restore any earlier version in one call. Hosting requires a paid subscription, and a free pre-publish assessment reports which documented signal calls, contrast pairs or hardcoded prices would fail.
      15 npm
      Apache 2.0