sbuilder-mcp
An MCP stdio server that lets an AI agent design, populate, inspect, and publish a Store Builder site end to end — no human clicking.
Authenticate & scope —
sb_connectlogs in and lists operable sites;sb_site_listlists them; a single API key reaches both the partner and private site APIs, bounded by scopes, the member's live role, and one store.Reach the whole platform API —
sb_api_findsearches 969 operations by intent and returns a call sheet (params, credential, body fields, handler caveats);sb_api_callexecutes any operation or arbitrary method+path, dry-run by default, with field picking, result pagination, deep-merge PUTs,If-Match, and multipart uploads.Edit page structure — open a page or form (
sb_page_open), read a compressed outline (sb_outline) or one node (sb_node_read), discover element types (sb_catalog_search), read an element's inspector (sb_traits_for), then add nested subtrees (sb_add), write style/config/specials per breakpoint (sb_set), move (sb_move), remove (sb_remove), or duplicate nodes and whole subtrees across pages/sites (sb_duplicate).Use ready-made sections — list saved and built-in layouts (
sb_templates) and drop one onto a page (sb_template_use).Manage pages — list (
sb_page_list), create with seeds for store types (sb_page_create), update name/slug/home/order/SEO/members-only (sb_page_update), inspect versions/autosaves (sb_page_version), fix non-ROOTpage roots (sb_page_repair), and see which of draft/published/session copies is which (sb_page_state).Ship it —
sb_publishcompiles the draft, reports the live revision, cascades to shared globals/overlays, lists unpublished pages, and verifies the origin is serving it.Check your work —
sb_reviewlists visitor-visible defects plus store gaps before a paid order;sb_lookrenders screenshots at three widths with measured boxes and layout defects.Add media —
sb_media_listreuses existing assets;sb_media_uploaduploads a local file, fetches a URL, or searches real photographs and picks one or many.Wire up behaviour —
sb_eventgives a node a click action;sb_bindbinds nodes to 96 store data sources or makes a real add-to-cart/buy-now button.Build the store flows —
sb_storeruns ordered flows: checkout (form + fields + published page), checkout sync, any of 17 form templates, shared header/footer chrome, menus, overlays, cart drawer, built-in apps, global attach/detach/promote, and section-to-template saving.Extend the site —
sb_codemanages injected custom code (html/css/js/scss/ts/json/text),sb_functiondeploys and tests backend TS/JS functions with secrets and logs,sb_collectioncreates data tables, typed fields, and records with CSV import/export.Style & localize —
sb_themereads/patches palette, type scale, presets, and locale;sb_translateenables languages and manages page strings, including machine-fill and review.Import from the web —
sb_importrebuilds one URL's structure and content into the open page using this site's tokens;sb_import_sitecrawls a sitemap or links into draft pages and can patch the site theme.Work live & safely —
sb_live_joinjoins the editor's live-edit room as a visible peer that always yields;sb_undoreverts/redoes this session's page edits and API PUTs, while platform version history outlives the process; tested guards handle band order, site overlays, shared globals, responsive writes, and app blocks that would otherwise fail silently.
Allows searching real photographs through Pexels and uploading selected images into the site's media library via sb_media_upload.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@sbuilder-mcp Design a landing page for the spring sale, fill it with products, and publish it."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
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 |
| Log in, list the sites this account can operate, report which credentials are present |
| List the sites this account can operate |
| 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 |
| 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; |
| Open a page for editing and return its outline — or, with |
| The open page as a compressed tree — never a raw document dump; shared header/footer and overlays one line each unless |
| One node in full, with a warning if it is a shared global |
| Find an element by what it should do, using the platform's own AI hints |
| An element's inspector — tabs, groups, controls and what each declared one writes — plus its AI hints, defaults and containment rules |
| Add an element — or a whole nested subtree — in one call; a filter arrives with its option rows read from the catalogue |
| Write style/config/specials. Per breakpoint by default |
| Move a node to another parent |
| Remove a node and its subtree |
| 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) |
| 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 |
| Add a section template to a page |
| Every page on the site |
| Create a page — a store type arrives with the editor's own starting document; |
| 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 |
| A page's platform recovery points — list named versions and autosave history, snapshot the draft, restore one |
| The site's custom code files (tracking pixels, analytics, chat widgets, site CSS; html/css/js/scss/ts injected, json/text served at |
| The site's backend functions — server-side TypeScript/JavaScript served at |
| 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 |
| Compile the draft into the live page (cascades to shared globals), report which revision went live, and with |
| 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 |
| Rename a page root that is not |
| Every defect a visitor would see, each with its fix, plus the five gaps between this store and a paid order |
| The site's media library |
| 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; |
| Join the editor's live-edit room as a visible peer — edits then appear live |
| Save, render, and return screenshots plus measured node boxes and layout defects measured on the render |
| Give a node a click action — open the cart, go to a page, open a pop-up |
| Bind a node's content to real store data, or make a button add to the cart |
| 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 |
| 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 |
| 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 |
| 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 |
| Run a store flow that must happen in a fixed order — |
| Undo / redo this session's writes — page and form edits and |
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 codegenSo 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 GOODContributor 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_setwrites 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 toolssb_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_callADestructive
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_findARead-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_catalog_searchARead-only
Find an element type by what it does — or OMIT query to browse every type, the only way to meet one you would not have searched for. detail:true adds the AI hints, as does sb_traits_for. query "icon:" lists icon names.
Inputs: limit, query, detail.
sb_codeADestructive
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_collectionBDestructive
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_connectARead-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_functionADestructive
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_joinAIdempotent
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_lookAIdempotent
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_listARead-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_readARead-only
One node in full — style, config, specials, per-breakpoint overrides, bindings.
Inputs: id (required).
sb_outlineARead-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_listARead-only
Every page on the site, with its slug and whether it is live.
Inputs: site_id.
sb_page_openARead-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_repairAIdempotent
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_stateARead-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_versionADestructive
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_publishADestructiveIdempotent
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_removeADestructive
Remove a node and its whole subtree.
Inputs: id (required), force, dry_run.
sb_reviewARead-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_listBRead-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_templatesCRead-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_forARead-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_undoADestructive
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
Scored across 39 tools
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.
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.
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.
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
Related MCP Connectors
Launch and manage online stores with AI agents: products, inventory, pricing, orders and promotions.
Let your AI agent build, preview and update web apps, download source and publish when you allow it.
Build, edit, and publish real websites and online stores by chatting with your AI assistant.
AI-powered web automation. Navigate websites using AI agents for one page or a thousand
Related MCP Servers
- AlicenseBqualityBmaintenanceEnables AI assistants to build, validate, and publish storefront pages to WebCake/StoreCake sites based on natural language descriptions.133474 npm5MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to provide e-commerce customer service with product search, RAG-based FAQ answers, human handoff, and automated security auditing with a review workflow.-

PromptSwingofficial
AlicenseNot gradedqualityBmaintenanceEnables 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 npmApache 2.0
Zarla MCP serverofficial
AlicenseNot gradedqualityCmaintenanceEnables AI assistants to build, edit, preview, and publish websites through natural language, including managing pages, designs, products, and site publishing.MIT