sbuilder-mcp 0.2.0 → 0.2.2

package/dist/tools/page.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
+import { composeWarnings } from '../domains/site/findings.js';
 import { text } from '../mcp/response.js';
 import { loadSource, saveSource } from '../transport/pages.js';
 import { PageDoc } from '../domains/site/document.js';
 import { addSubtree, setMany, moveNode, removeNode, duplicateNode, } from '../domains/site/builder.js';
-import { request } from '../transport/http.js';
+import { request, redact } from '../transport/http.js';
 import { siteToken } from './credentialpick.js';
 import { validateForSave } from '../domains/site/validate.js';
 import { reviewDesign, REVIEW_NOTICE } from '../domains/site/review.js';
@@ -42,6 +43,7 @@ export class PageSession {
     pageId = '';
     live = null;
     stale = null;
+    warnings = [];
     boxes = [];
     constructor(ctx) {
         this.ctx = ctx;
@@ -90,8 +92,15 @@ export class PageSession {
         this.doc = PageDoc.from(src.document);
         this.siteId = siteId;
         this.pageId = pageId;
+        // The platform's own account of what it could not compose. Typed on the
+        // response since the transport was written and read by nothing until now.
+        this.warnings = composeWarnings(src.warnings);
         return this.doc.outline();
     }
+    /** What the server said it could not compose when this page was opened. */
+    composeWarnings() {
+        return this.warnings;
+    }
     current() {
         if (!this.doc)
             throw new Error('sbuilder: no page is open — call sb_page_open first');
@@ -151,9 +160,11 @@ export function registerPageTools(server, ctx) {
                 'the renderer finds no root and publishes an EMPTY BODY. The next save from here writes ' +
                 'the canonical key and fixes it; publish afterwards.'
             : undefined;
+        const warnings = session.composeWarnings();
         return text({
             outline,
             ...(blank_page_repair ? { blank_page_repair } : {}),
+            ...(warnings.length ? { compose_warnings: warnings } : {}),
             ...reviewField(ctx, doc),
         });
     });
@@ -423,9 +434,12 @@ export function registerPageTools(server, ctx) {
             ...(is_homepage !== undefined ? { isHomepage: is_homepage } : {}),
             ...(settings ? { settings } : {}),
         };
+        // `settings` is the one free-form object a caller hands this server, so the
+        // preview and the echo both go through redact — everything else on this
+        // path is built from narrow arguments.
         if (dry_run !== false)
-            return text({ dry_run: true, would_post: path, body });
-        return text(await request({
+            return text({ dry_run: true, would_post: path, body: redact(body) });
+        const res = redact(await request({
             base: ctx.base,
             method: 'POST',
             path,
@@ -433,6 +447,24 @@ export function registerPageTools(server, ctx) {
             body,
             fetchImpl: ctx.fetchImpl,
         }));
+        // A COLLIDING SLUG IS RENAMED, NOT REFUSED. `uniqueSlug` suffixes -1, -2 …
+        // and its own comment says it "never errors"
+        // (server/internal/page/service.go:877). ErrSlugConflict exists and maps to
+        // 409; this path never reaches it. So the create answers 200 carrying a
+        // DIFFERENT slug than the one asked for, and every link the caller then
+        // authors to the slug it requested is dead.
+        const got = res.page?.slug;
+        const renamed = slug && typeof got === 'string' && got !== slug;
+        return text({
+            ...res,
+            ...(renamed
+                ? {
+                    slug_renamed: `The slug "${slug}" was already taken, so the platform stored ` +
+                        `"${got}" instead and reported success. Link to "${got}", or free the name and ` +
+                        'create it again.',
+                }
+                : {}),
+        });
     });
     server.registerTool('sb_publish', {
         description: 'Compile the draft into the live page. PUBLISH CASCADES: a page sharing a global ' +
@@ -451,7 +483,7 @@ export function registerPageTools(server, ctx) {
         const body = { pageIds: [page_id] };
         if (dry_run !== false)
             return text({ dry_run: true, would_post: path, body });
-        return text(await request({
+        const res = (await request({
             base: ctx.base,
             method: 'POST',
             path,
@@ -459,6 +491,31 @@ export function registerPageTools(server, ctx) {
             body,
             fetchImpl: ctx.fetchImpl,
         }));
+        // A PUBLISHED ROW CARRIES THE WHOLE RENDERED PAGE — document, html and css
+        // — and publish CASCADES, so returning the response as it arrives pours
+        // every republished page's markup into the reader. Kept: what identifies
+        // the row and what a caller would act on.
+        const published = (res.published ?? []).map((p) => ({
+            pageId: p.pageId,
+            ...(p.slug !== undefined ? { slug: p.slug } : {}),
+            ...(p.isHomepage ? { isHomepage: true } : {}),
+        }));
+        // PUBLISH SKIPS A PAGE WITH NO SAVED DRAFT and still answers 200 with
+        // whatever did publish (`server/internal/page/service.go:650`, a bare
+        // `continue`). sb_page_create followed by sb_publish does exactly that:
+        // the call succeeds, the page never flips to published, and the URL 404s.
+        const landed = published.some((p) => p.pageId === page_id);
+        return text({
+            published,
+            ...(published.length !== (res.total ?? published.length) ? { total: res.total } : {}),
+            ...(landed
+                ? {}
+                : {
+                    not_published: `Page ${page_id} has no saved draft, so the platform published ` +
+                        'nothing for it and reported success anyway. Open it with sb_page_open, save an ' +
+                        'edit, then publish again.',
+                }),
+        });
     });
     return session;
 }

package/dist/transport/http.js

@@ -34,8 +34,10 @@ const SECRET_KEYS = /^(authorization|token|access_?token|refresh_?token|password
 /**
  * Replace credential-shaped values with a marker, recursively.
  *
- * Every dry-run preview goes through this, so it is the only thing standing
- * between a `dry_run` result and a bearer token sitting in a transcript. It keys
+ * Every preview that can carry a FREE-FORM object goes through this — `sb_api_call`'s
+ * body and `sb_page_create`'s `settings`, the two places a caller supplies a shape
+ * this server does not type. The rest of the dry-run previews echo patch counts or
+ * bodies built from narrow arguments, which cannot hold a credential. It keys
  * off the FIELD NAME rather than the value's shape on purpose: a token format
  * can change tomorrow, while the field name is what this repo controls.
  */

package/dist/transport/media.js

@@ -66,18 +66,27 @@ export async function uploadMedia(ctx, siteId, source) {
         throw new ApiError(res.status, 'non_json_response', raw.slice(0, 400));
     }
     if (!res.ok) {
-        // THE UPLOAD SURFACE TAKES A SESSION ONLY.
+        // AN API KEY CAN UPLOAD — THE PLATFORM WIDENED THIS.
         //
-        // `/api/media/{siteId}` is mounted behind `RequireAuth` — not the
-        // `RequireAuthOrDefer` that lets a `wbk_` key open `/api/sites`
-        // (server/internal/server/router.go). So a key-only install, which is the
-        // one the store's Agent app hands out and the one the README recommends,
-        // gets a bare "unauthorized" from the ONE tool that cannot be replaced by
-        // sb_api_call, because the body is multipart. Found on a live run.
+        // `/api/media` is now mounted behind `RequireAuthOrDefer`
+        // (server/internal/server/router.go:2821), the same gate `/api/sites` uses,
+        // and `upload_agentkey_test.go` pins the three answers that make it safe:
+        // the key's own site only, the same permission the session path checks, and
+        // no key at all still meaning 401. The platform's own comment gives the
+        // reason it changed — the media LIBRARY already took a key while the UPLOAD
+        // refused one, so a merchant could hand an agent a key that manages every
+        // image the store has and cannot add one.
+        //
+        // This message used to say "an API key cannot upload" and send the caller to
+        // set SB_EMAIL. That is now the wrong instruction: with a key present, a 401
+        // here means the KEY is wrong for this call, not that the wrong KIND of
+        // credential was used, and the old text sent people to fix something that
+        // was never broken.
         if ((res.status === 401 || res.status === 403) && ctx.apiKey && !ctx.session.loggedIn()) {
-            throw new ApiError(res.status, 'media_needs_session', 'sbuilder: the media upload endpoint takes a session token only — an API key cannot ' +
-                'upload. Set SB_EMAIL and SB_PASSWORD and call sb_connect, then retry. Every other ' +
-                'tool works with the key alone.');
+            throw new ApiError(res.status, 'media_key_refused', 'sbuilder: the platform refused this API key for the upload. It accepts a key, so the ' +
+                'cause is the key itself: it needs the media permission, and it must belong to THIS ' +
+                'site — a key minted for another site is refused before the upload is read. Check the ' +
+                "key's scopes and its site, or set SB_EMAIL / SB_PASSWORD to upload as a person.");
         }
         const env = (parsed ?? {});
         const fieldText = env.fields

package/package.json

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