ai.dotsy/mcp

Tools

• adapt_site_analyze

  Propose nav wiring + blog collectionization for an imported mirror (draft, opt-in). Read-only; returns per-adapter reports + proposalEtag. Nav decline may include nextStep (e.g. mega-menu → edit fragments/header.html). Wait for mirror-vs-editable answer if requiredDecision pending.

  shallow
• adapt_site_apply

  Apply the adapt proposal (draft): wire nav into the menu store and/or rewrite the blog index to a live <dotsy-collection>. One undo covers the whole apply; a second apply is refused until adapt_site_revert (or force). Queued applies are polled to completion.

  shallow
• adapt_site_revert

  Atomically restore everything the last adapt_site_apply wrote (fragments, the menu doc when the op touched it, index, member configs, routes).

  shallow
• add_custom_domain

  Connect apex and/or www on a paid plan; starts a DNS connect session.

  shallow
• apply_changeset

  Stage writes[] + deletes[] in one call; attach routes via writes[].route. writes[].ifMatch (hash from get_site_manifest; "" = must not exist) guards each key (a delete takes { key, ifMatch } too); atomic:true makes one stale key write nothing (409 changeset_conflict). At most 10 writes; each body ≤60KB and the call ≤80KB. Larger new pages: stage_content_chunk then writes[].bodyStaging, or dotsy push / PUT content-raw.

  shallow
• batch_patch_content

  patch_content on multiple keys; all-or-nothing validation. Preferred edit path for pages over 60KB. replace-string value/replace ≤60KB; whole call ≤80KB.

  shallow
• bulk_put_assets

  Upload 1–200 CMS assets; key = path after /assets/. Each item: exactly one of bodyBase64, bodyText (plain text for .css/.js/.mjs/.json/.svg/.txt/.xml only — not .html pages), or importFromUrl. Optional bodySha256 verifies submitted bytes before write; response sha256 is stored bytes (JS/CSS match; WebP rasters may differ). JPEG/PNG/static GIF are re-encoded to WebP (response key photo.webp; /assets/photo.jpg keeps serving it) — use the response key in CSS/JS; optimize:false stores the bytes as sent at your key; animated GIFs are always kept. Uploaded files are live in the editor and draft preview at once; the published site picks them up at the next publish.

  shallow
• bulk_put_content

  Stage many content keys (pages, layouts, fragments). Content only — not routes or assets. Each body ≤60KB and the whole call ≤80KB; larger pages use stage_content_chunk, dotsy push, or PUT content-raw. May queue above the inline threshold.

  shallow
• claim_site

  Move the guest draft onto your signed-in Dotsy account. Requires OAuth Connect; pass the guestToken from start_site.

  shallow
• create_site

  Create empty site; seeds brief. Globally taken slugs auto-suffix to `{slug}-{adjective}-{noun}` (default); pass onSlugTaken:"fail" to get a 409 instead of a renamed site.

  shallow
• decompose_analyze

  Deprecated — use structure_site_analyze.

  shallow
• delete_asset

  Delete a static asset by key. The editor and draft preview drop it at once; the published site drops it at the next publish.

  shallow
• delete_content

  Delete content key (tombstone if published). A fragments/* section that pages still place is refused with section_in_use (lists the pages) — detach it or remove it first.

  shallow
• delete_draft_test

  Remove a draft A/B test (releases variant bodies; does not publish).

  shallow
• delete_menu_item

  Remove one item from a menu (page stays live).

  shallow
• delete_route

  Remove a route by path.

  shallow
• delete_site

  Permanently delete site; confirmSlug must equal slug.

  shallow
• detach_section

  Give one page its own copy of a shared section; every other page keeps the shared one. A draft — publish_site to go live. A section the layout places is hidden on that page instead (share_section name + hide).

  shallow
• discard_drafts

  Discard unpublished drafts: all (omit key/keys/routes), one content key (key), or a selection (keys, routes). Destructive — check get_draft_status first.

  shallow
• edit_page

  Open the interactive page canvas to change content: the user clicks an element, then you call patch_content. Use when the intent is editing — not for verify-only checks (use preview_page).

  shallow
• estimate_test

  Estimate days to reach promote readiness for a page (traffic baseline). Read-only.

  shallow
• find_replace

  Case-insensitive find→replace across pages in one staged commit. Batch all replacements into ONE call — never parallelize find_replace on the same key (concurrent edits surface as per-key conflict). find/replace ≤60KB.

  shallow
• get_account_context

  Account, user, memberships[]. Pass workspace on writes when memberships.length > 1.

  shallow
• get_activity

  List site activity or fetch one change diff (pass id). Filters: who, state, actor (me), since, limit≤20. Notes from context are visible to everyone on the site — no secrets.

  shallow
• get_adapt_status

  Read adapt state: proposal summary + proposalEtag (+ applied/consumed flag), undo-record presence, active or queued job progress. Use to resume in a fresh session.

  shallow
• get_analytics

  Read-only traffic overview (default) or full breakdowns via include[]; optional bot id for crawler page drill-down.

  shallow
• get_asset

  Read one asset (metadata + base64 + stored sha256). sha256 is the stored blob; may differ from upload bodySha256 when IMAGES re-encodes rasters. Uploaded files are live in the editor and draft preview at once; the published site picks them up at the next publish.

  shallow
• get_content

  Read one content key; optional selector (region) or published=true (live body). Bodies over 40KB without a selector return a truncated summary — use selector, batch_patch_content, or dotsy pull.

  shallow
• get_custom_domain_connect

  Current connect session and nextAction (browser URL or manual DNS guide).

  shallow
• get_draft_status

  Pending draft changes: content keys and routes with status. May include requiredDecision (publish_confirm) before publish_site.

  shallow
• get_form_submission

  Read one form submission with the full field payload (explicit PII access — use only when needed).

  shallow
• get_menu

  Read a menu's draft items and etag; menu rules → get_skill('nav').

  shallow
• get_menu_doc

  Read the whole menu doc (all menus + shell/template), etag for put_menu_doc, and issues (by item id) — page_not_routable, page_missing, page_dead_link, page_is_redirect — computed from the draft routes, so a link that won't show or leads nowhere shows up before publish.

  shallow
• get_route

  Get one route by path (home is '/').

  shallow
• get_site

  Site detail, stats, publicUrl, brief head (default-on), and readiness flags. pages[] is a ~25-entry head by default (stats.pages has the true count) — pass pages: true for the full array (capped at 1000), or enumerate everything with list_content/get_site_manifest. Large sites (200+ pages): list_pages is paginated — use cursor or get_site_manifest for the full route set.

  shallow
• get_site_build_progress

  Read-only build progress for humans (build-theater view) during structure/adapt or after import. Agent reads structuredContent.forHumans — optional; do not call in a loop during import_site_from_url (that tool blocks until done). Prefer get_site for agent logic.

  shallow
• get_site_manifest

  Content keys + hashes only (optional routes=true) — static files live in list_assets, not manifest. Diff keys+hashes before apply_changeset; stage only changed bodies.

  shallow
• get_site_outline

  Site shape: every layout and shared section (`sections`: fragments/* by name, with page count, whether the file exists and staged-change flag), whether a layout is missing, redirects count, menus grouped by where they show, and collections with their page placements. Use for 'is my layout missing', 'which shared sections exist and where', 'where does this menu show' — without listing every page. Read-only; indexing mirrors list_pages (a freshly imported/graduated site may still be indexing).

  shallow
• get_skill

  Skill body + optional questions[]. Accepts an id OR a synonym (e.g. 'list', 'menu') — resolves aliases and suggests near-misses. Start with intake when ambiguous.

  shallow
• get_structure_result

  Last structure apply job result (structuredKeys, conflicts, partial).

  shallow
• get_structure_status

  Flat vs structured page counts; informs user — do not auto-run analyze/apply while requiredDecision pending.

  shallow
• graduate_site

  Enable site search & collections (kv → do-sqlite), one-way. Unlocks search_content, collection indexes, visitor /__paige/search, and moves any R2 form-submission ledger into SiteDb. 409 blocked covers three unrelated gates: an unsupported source backend (no override, ever); strictDrafts — default true, this client sends true unless you pass strictDrafts:false — blocking on unpublished drafts or unrecovered KV content rows; or a KV snapshot that looks incomplete (e.g. a page deleted in the last couple of minutes). force:true overrides ONLY that last, incomplete-snapshot gate — never the backend or strictDrafts gates. The blocked response's `reason` names which gate fired, and `audit` (+ `audit.warnings`) is aggregate COUNTS only (published/route/pending-draft counts) — never row keys — so judge the size of the gap, not a row list, before forcing. The flip is one-way: anything outside the frozen snapshot is unreachable once it lands.

  shallow
• import_site_from_url

  Import URL to draft. On complete, response may include requiredDecision — preview then ask mirror vs editable before structure_*.

  shallow
• inspect_collection

  Collection state — count, server.mode, sample entries, tag (membershipKind, match=) when discovered; plus name, noun, URL pattern, layout, where it's listed, and post fields used. Pass status/q/cursor/limit (any one, even empty) for a full items[] page instead: status draft = never published; a published post with unpublished edits is status published with hasChanges:true (never draft) and shows its staged title/date/tags/author; scheduled = future visibleAt. Never-published drafts come from staged content (no extra reads, no publish needed to see them); published/scheduled come from the index. limit defaults to 50, clamped 1-200. Omit all four for just the base inspect (no items[]).

  shallow
• list_assets

  CMS uploads under assets/ only — not mirrored clone CDN (get_site mirroredAssets or import warmJob). Not content — use list_content. Uploaded files are live in the editor and draft preview at once; the published site picks them up at the next publish.

  shallow
• list_collections

  Collections on the site — name, noun, item count (or 'not published yet'), URL pattern, and whether any member is staged. Includes a collection only a draft page lists. Returns a bare array (not wrapped in an object) — pass each row's key verbatim to inspect_collection/update_collection.

  shallow
• list_content

  List content keys (HTML/md); not assets — use list_assets. Defaults to 50 keys per page — raise limit (max 1000) or pass cursor (from nextCursor) to page through the rest. Per-row `size`/`missing` are measured automatically only on pages of ≤100 rows; past that they're ABSENT (not measured, never `null`) unless you pass withSize:true, which forces measurement at a cost of one storage read per returned row. Only `size: null` + `missing: true` means the page's stored bytes are gone.

  shallow
• list_custom_domains

  List all custom hostnames and connection status for the site.

  shallow
• list_form_submissions

  List form submissions (metadata + bounded field preview — not full PII). Works on kv and do-sqlite backends.

  shallow
• list_goals

  List site conversion goals (pageview paths and form submits). Required before start_test.

  shallow
• list_my_sites

  List your Dotsy sites. Renders a site-picker for humans; agent reads structuredContent. Use to choose a site — not for editing content (use edit_page) or verify-only checks (use preview_page). Defaults to your active workspace; pass workspace (org id or slug from get_account_context memberships) to list another workspace's sites without switching the dashboard session.

  shallow
• list_pages

  List pages on a site — route settings (path/title/navLabel/purpose) by default, one row per route. Renders a page-picker for humans (redirect and worker routes left out there — nothing to open in edit_page); agent reads structuredContent. Use after picking a site — not for editing (use edit_page) or verify-only checks (use preview_page). Pass view:'pages' to group by layout instead — adds layout/noLayout/q filters, what each page places, and indexing progress; use that for 'what pages use this layout' or 'is this page indexed yet', not for route settings. Paginated — pass cursor (from nextCursor) for more; partial:true means this page is a window, not the full route set.

  shallow
• list_skills

  Paige build skills (id + whenToUse). Pull get_skill on demand — do not duplicate in tool text.

  shallow
• new_post_template

  Read-only scaffold for a new post — suggested key/path, membership meta, blank or duplicate body. Then put_post (+ optional put_route).

  shallow
• patch_content

  Edit one content key via ops[] (selector ops or replace-string; wrap/unwrap/move restructure siblings). Stages draft; op shapes in schema.

  shallow
• patch_route

  Partial route update (only sent fields change; an OMITTED field is left alone). On a field that accepts null (contentKey, redirectTo, redirectStatus, preserveQuery), sending null CLEARS it back to its default — different from omitting it. To set redirectTo/redirectStatus, include purpose: "redirect" in the SAME call — the check looks only at what's sent, not the route's stored purpose, so a PATCH that sets redirectTo without repeating purpose: "redirect" (even on a route that's already a redirect) 400s invalid_body.

  shallow
• preflight_site

  Plan check before publish or large build (counts, route soft limit, seo suggestions). When ok is false, blocking lists the failed suggestion codes. Read-only.

  shallow
• preview_page

  Verify-only composed HTML check; home preview may include requiredDecision — ask mirror vs editable before structure_*.

  shallow
• promote_experiment

  Promote a winning A/B variant to live — explicit user instruction only; see get_skill('verify') § A/B.

  shallow
• publish_site

  Publish draft to live. feedback and handoff required (use dummy feedback + one-line handoff if clean).

  shallow
• put_content

  Stage one content key. Body ≤60KB. Larger pages: stage_content_chunk + apply_changeset bodyStaging, dotsy push, or PUT content-raw. Edits to an existing large page: batch_patch_content.

  shallow
• put_goals

  Create or replace all site conversion goals (≤50). Required before start_test when no goal exists.

  shallow
• put_menu_doc

  Replace the whole menu doc (ifMatch from get_menu_doc required). Each item may omit menu — the enclosing menu key in doc is used.

  shallow
• put_menu_item

  Partial upsert one menu item: provided fields overwrite; omitted html/childTemplate/childShell/attrs/data are preserved. To remove those keys, use put_menu_doc. A brand-new id dedupes by (menu, ref) — reuses an existing item linking the same target instead of creating a duplicate. An id that already names an item always updates that exact item, even if another item links the same page.

  shallow
• put_post

  Stage a blog post via structured meta+body (?format=post). Key e.g. blog/my-post.html. Declared membership: meta.collections; schedule: meta.visibleAt; SEO title override: meta.seoTitle (card always shows meta.title); custom fields: meta.custom.

  shallow
• put_route

  Create/replace route; contentKey derived from path if omitted. On a field that accepts null (contentKey, redirectTo, redirectStatus, preserveQuery), sending null clears it back to its default.

  shallow
• reapply_custom_domain_oauth

  Re-apply DNS with stored Cloudflare OAuth grant (no browser).

  shallow
• refresh_custom_domain

  Poll one hostname until DNS/cert propagates.

  shallow
• reindex_collection

  Build/finish collection indexes after publish returns collectionDataPending or collectionSqlPending.

  shallow
• remove_custom_domain

  Remove one custom hostname from the site.

  shallow
• rename_content

  Re-key a page by slug (draft or published static). Server-side hash copy — no body round-trip. Default deletes static routes (obscure-URL); movePath:true repoints the route, rewrites menu refs and other redirects aimed at the old path, and — only for an already-PUBLISHED page — leaves a 301 there too (leaveRedirect, default true; no effect on a never-published page, or when movePath is false). Retry-safe: a part-way failure (409 rename_failed) rolls everything back, so resend the same call. On fragments/<name>.html it also rewrites every <dotsy-fragment name> reference and hide marker in the same all-or-nothing commit. Then publish_site.

  shallow
• rename_page

  Change a page's URL: moves its route from `from` to `to`. Menu links and other redirects that pointed at the old path retarget automatically; a 301 is left at the old path by default (leaveRedirect). Retry-safe (resend the same call after any error). Errors: 404 route_not_found (from isn't a route); 400 reserved_route (to is under /__dotsy/) or invalid_body (missing/malformed from or to); 422 rename_same_path (from equals to already), rename_pattern_route (from or to contains a :param segment — pattern routes can't be renamed this way), rename_redirect_route (from is itself a different redirect — edit its redirectTo instead); 409 rename_experiment_running (an A/B test is running on from — end it first) or rename_target_exists (to is already a different route — unless to already serves the exact content from would, which is treated as already done and returns 200). Then publish_site.

  shallow
• rename_site

  Rename the site slug (public hostname {slug}.dotsy.site). Owner-only. After success: use the returned slug in every later tool. Published site: the old slug redirects on the API (301 for reads, 308 for writes) while it stays reserved; the old host 301s and stays reserved until delete or rename-back. Never published: the old slug 404s on the API and the old hostname is released (no 301; create_site can reuse it). Analytics history stays on the old slug. HTML absolute URLs are not rewritten — publish_site refreshes sitemap; find_replace if stored HTML must change.

  shallow
• reorder_menu

  Set final menu order. Pass ifMatch from get_menu; stale → 409 with current items.

  shallow
• revert_change

  Undo one activity event by staging the prior version as draft only — call publish_site to go live. Respects AI access.

  shallow
• search_content

  Find pages containing a phrase (grep without reading bodies). Requires do-sqlite — graduate_site first if search_unavailable.

  shallow
• set_experiment_note

  Record what was learned from an ended A/B test (≤500 chars; null clears).

  shallow
• set_primary_custom_domain

  Set the canonical host (301 target) when multiple hostnames are connected.

  shallow
• share_section

  Make a block that repeats on several pages one shared section, or change where one shows. No arguments: lists blocks repeated on 3+ pages. sourceKey + selector (or selectors: a sibling run, one wrapper): a dry run finds every page with it; dryRun:false shares it. name + scope/hide/show: move an existing section to/from every page, or hide/show it per page. Over the per-call cap (too_many_pages, nothing written): share with keys, then again under the same name from a page that still has a copy; for every page then move with name + scope every_page + keys (max-1 pages a call; put all hide on the first) until all are moved. Always a draft (publish_site to go live; undo: revert_change).

  shallow
• stage_content_chunk

  Append one ≤60KB chunk of a large new page. Omit stagingId on seq 0; pass the returned stagingId on later seq. Set finalize:true on the last chunk, then apply_changeset with writes[].bodyStaging.

  shallow
• start_edit_session

  Open a draft session. Returns preview/edit URLs for the person (see linkGuidance). draftEditorUrl only when the site gives AI agents Full access. path defaults to '/'.

  shallow
• start_site

  Start one draft site with no Dotsy account. Returns slug + guestToken — pass guestToken on every later tool call until claim_site.

  shallow
• start_test

  Start a same-URL A/B test (draft or live source). Rules → get_skill('verify') § A/B.

  shallow
• structure_site_analyze

  Propose shared layout + fragments; persist:false first. Wait for mirror-vs-editable answer if requiredDecision pending.

  shallow
• structure_site_apply

  Rewrite flat pages to layout + fragments (draft). Do not call while requiredDecision pending — user must pick editable first. It extracts header/footer only: afterwards share_section with no arguments lists the other repeated blocks (banner, CTA).

  shallow
• submit_feedback

  Optional mid-session feedback (required feedback rides with publish_site).

  shallow
• update_brief

  Update `_intent/site.md` (site brief) or a page brief when `page` is set. See field descriptions for rules, notes, and head enums.

  shallow
• update_collection

  Rename a collection's display name and/or noun (e.g. the generic 'posts' key shown as 'Recipes' / 'recipe') — cosmetic only, stored separately from the tag that defines membership; doesn't need publish. Provide at least one of name/noun. null (or "") resets that field back to its derived default — different from omitting it, which leaves the current value alone.

  shallow
• update_site

  Update site settings: title, keyConvention, or editingMode ('live' = each editor save publishes immediately; 'staged' = saves stay drafts until publish_site). Slug is the hostname — change it with rename_site, not this tool. Set 'staged' before handing the editor to a person via start_edit_session's draftEditorUrl. signature toggles the "Made with Dotsy" badge ({enabled, mark: logo|dot, reveal: pill|seal}); it is live immediately. trailingSlash (ignore|never|always) sets the page URL form: the other form 301s to it and canonicals/sitemap use it; live immediately. ownSeoFiles: true lets the next publish use the site's own robots.txt that blocks the whole site (Disallow: /) and its own static sitemap.xml (replaces the generated one, collection pages included); a robots.txt without Disallow: / is used anyway.

  shallow
• verify_page

  Pre-publish lint (tags, assets, layout). Pair with preview_page — see get_skill('verify').

  shallow
• wait_for_custom_domain

  Poll one hostname until it is connected or the timeout is reached.

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/39c0e37b-dc74-4175-8096-e1398c25328d/badge.svg)](https://vouch.tools/servers/39c0e37b-dc74-4175-8096-e1398c25328d)