@bettercms-ai/mcp 0.9.0

package/dist/index.js

@@ -0,0 +1,1266 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_API_URL = "https://api.bettercms.ai";
+function loadConfig(env = process.env) {
+  const apiUrl = (env.BETTERCMS_API_URL?.trim() || DEFAULT_API_URL).replace(/\/+$/, "");
+  return {
+    apiUrl,
+    deviceBaseUrl: `${apiUrl}/api/v1/auth/device`,
+    managementBaseUrl: `${apiUrl}/api/v1`,
+    credentialsPath: env.BETTERCMS_MCP_CREDENTIALS?.trim() || join(homedir(), ".bettercms", "mcp-credentials.json"),
+    clientName: env.BETTERCMS_MCP_CLIENT_NAME?.trim() || "BetterCMS MCP"
+  };
+}
+
+// src/token-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+var FileTokenStore = class {
+  constructor(path, key) {
+    this.path = path;
+    this.key = key;
+    this.pendingKey = `${key}::pending`;
+  }
+  path;
+  key;
+  /** Pending authorizations live under a sibling key so they never shadow creds. */
+  pendingKey;
+  async readAll() {
+    try {
+      const raw = await readFile(this.path, "utf-8");
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  async writeAll(all) {
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify(all, null, 2), { mode: 384 });
+  }
+  async read() {
+    const all = await this.readAll();
+    return all[this.key] ?? null;
+  }
+  async write(creds) {
+    const all = await this.readAll();
+    all[this.key] = creds;
+    await this.writeAll(all);
+  }
+  async clear() {
+    const all = await this.readAll();
+    delete all[this.key];
+    await this.writeAll(all);
+  }
+  async readPending() {
+    const all = await this.readAll();
+    return all[this.pendingKey] ?? null;
+  }
+  async writePending(pending) {
+    const all = await this.readAll();
+    all[this.pendingKey] = pending;
+    await this.writeAll(all);
+  }
+  async clearPending() {
+    const all = await this.readAll();
+    delete all[this.pendingKey];
+    await this.writeAll(all);
+  }
+};
+
+// src/device-auth.ts
+var EXPIRY_SKEW_MS = 6e4;
+var GRACE_POLL_MS = 25e3;
+var DeviceAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeviceAuthError";
+  }
+};
+var DeviceAuthPendingError = class extends Error {
+  verificationUri;
+  verificationUriComplete;
+  userCode;
+  expiresAt;
+  constructor(pending) {
+    super("Authorization pending \u2014 approve in the browser, then retry.");
+    this.name = "DeviceAuthPendingError";
+    this.verificationUri = pending.verificationUri;
+    this.verificationUriComplete = pending.verificationUriComplete;
+    this.userCode = pending.userCode;
+    this.expiresAt = pending.expiresAt;
+  }
+};
+var DeviceAuthClient = class {
+  constructor(config, store, deps = {}) {
+    this.config = config;
+    this.store = store;
+    this.fetchImpl = deps.fetch ?? globalThis.fetch;
+    this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.log = deps.log ?? ((m) => process.stderr.write(`${m}
+`));
+    this.now = deps.now ?? (() => Date.now());
+  }
+  config;
+  store;
+  fetchImpl;
+  sleep;
+  log;
+  now;
+  inFlight = null;
+  refreshInFlight = null;
+  /** Return a valid access token, doing the least work necessary. Single-flighted. */
+  async getAccessToken() {
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = this.resolveToken().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async resolveToken() {
+    const creds = await this.store.read();
+    if (creds && creds.accessTokenExpiresAt - this.now() > EXPIRY_SKEW_MS) {
+      return creds.accessToken;
+    }
+    if (creds?.refreshToken) {
+      const refreshed = await this.refresh();
+      if (refreshed) return refreshed;
+    }
+    return this.runDeviceFlow();
+  }
+  /**
+   * Resume a still-live authorization if one is persisted, otherwise start a
+   * fresh one; then grace-poll. Throws {@link DeviceAuthPendingError} (carrying
+   * the activation link) if the user hasn't approved within the grace window.
+   */
+  async runDeviceFlow() {
+    let pending = await this.store.readPending();
+    if (pending && pending.expiresAt - this.now() <= EXPIRY_SKEW_MS) {
+      await this.store.clearPending();
+      pending = null;
+    }
+    if (!pending) {
+      pending = await this.startDeviceFlow();
+    }
+    const graceDeadline = Math.min(this.now() + GRACE_POLL_MS, pending.expiresAt);
+    const token = await this.pollForApproval(pending, graceDeadline);
+    if (token) return token;
+    throw new DeviceAuthPendingError(pending);
+  }
+  /** Request a fresh device code, persist it as pending, and log a breadcrumb. */
+  async startDeviceFlow() {
+    const start = await this.fetchImpl(`${this.config.deviceBaseUrl}/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_name: this.config.clientName })
+    });
+    if (!start.ok) {
+      throw new DeviceAuthError(
+        `Failed to start device authorization (HTTP ${start.status}).`
+      );
+    }
+    const code = await start.json();
+    const pending = {
+      deviceCode: code.device_code,
+      userCode: code.user_code,
+      verificationUri: code.verification_uri,
+      verificationUriComplete: code.verification_uri_complete ?? `${code.verification_uri}?code=${encodeURIComponent(code.user_code)}`,
+      intervalSeconds: code.interval,
+      expiresAt: this.now() + code.expires_in * 1e3
+    };
+    await this.store.writePending(pending);
+    this.log("");
+    this.log("\u250C\u2500 BetterCMS authorization required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    this.log(`\u2502 Visit: ${pending.verificationUri}`);
+    this.log(`\u2502 Enter code: ${pending.userCode}`);
+    this.log(`\u2502 Or open: ${pending.verificationUriComplete}`);
+    this.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    return pending;
+  }
+  /**
+   * Poll the token endpoint until `deadline`. Returns the access token on
+   * approval, or null if the deadline passes while still pending. Throws
+   * {@link DeviceAuthError} on a terminal outcome (denied / expired).
+   */
+  async pollForApproval(pending, deadline) {
+    let intervalMs = pending.intervalSeconds * 1e3;
+    while (this.now() < deadline) {
+      await this.sleep(intervalMs);
+      if (this.now() >= deadline) break;
+      const res = await this.fetchImpl(`${this.config.deviceBaseUrl}/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          device_code: pending.deviceCode,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      });
+      if (res.ok) {
+        const body = await res.json();
+        await this.store.clearPending();
+        this.log("[bettercms-mcp] authorized \u2713");
+        return this.persist(body);
+      }
+      const err = await res.json().catch(() => ({}));
+      switch (err.error) {
+        case "authorization_pending":
+          continue;
+        case "slow_down":
+          intervalMs += 5e3;
+          continue;
+        case "access_denied":
+          await this.store.clearPending();
+          throw new DeviceAuthError("Authorization was denied.");
+        case "expired_token":
+          await this.store.clearPending();
+          throw new DeviceAuthError("The device code expired before approval. Try again.");
+        default:
+          throw new DeviceAuthError(
+            `Device authorization failed: ${err.error ?? `HTTP ${res.status}`}.`
+          );
+      }
+    }
+    return null;
+  }
+  /**
+   * Exchange the stored refresh token for a new access token. Single-flighted:
+   * the device `/refresh` endpoint is single-use (it rotates the refresh token
+   * and revokes the prior access key), so a burst of concurrent 401s must NOT
+   * each fire their own refresh — the first would rotate, and the rest would
+   * send the now-stale token, get `invalid_grant`, and wipe the freshly-minted
+   * credentials. Collapsing them into one in-flight rotation keeps the session
+   * alive without a needless re-auth.
+   */
+  async refresh() {
+    if (this.refreshInFlight) return this.refreshInFlight;
+    this.refreshInFlight = this.doRefresh().finally(() => {
+      this.refreshInFlight = null;
+    });
+    return this.refreshInFlight;
+  }
+  /**
+   * Forget the cached credentials and start a fresh device flow. Called when the
+   * bound project was deleted server-side (a key bound to a dead project can never
+   * succeed again) — clearing lets the user re-authorize against a LIVE project.
+   * Returns a new token if approval is fast, else throws {@link DeviceAuthPendingError}
+   * carrying the activation link (the next tool call resumes into the new project).
+   */
+  async resetAndReauthorize() {
+    await this.store.clear();
+    await this.store.clearPending();
+    return this.getAccessToken();
+  }
+  async doRefresh() {
+    const creds = await this.store.read();
+    if (!creds?.refreshToken) return null;
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.config.deviceBaseUrl}/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: creds.refreshToken })
+      });
+    } catch {
+      return null;
+    }
+    if (res.ok) {
+      const body = await res.json();
+      return this.persist(body);
+    }
+    const err = await res.json().catch(() => ({}));
+    if (err.error === "invalid_grant" || res.status === 401 || res.status === 403) {
+      await this.store.clear();
+    }
+    return null;
+  }
+  async persist(body) {
+    const creds = {
+      accessToken: body.access_token,
+      refreshToken: body.refresh_token,
+      accessTokenExpiresAt: this.now() + body.expires_in * 1e3,
+      workspaceId: body.workspace_id,
+      projectId: body.project_id
+    };
+    await this.store.write(creds);
+    return creds.accessToken;
+  }
+};
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BetterCMS } from "@bettercms-ai/sdk";
+
+// src/tools.ts
+import { z } from "zod";
+import { BetterCMSError } from "@bettercms-ai/sdk";
+var fieldType = z.enum([
+  "text",
+  "richtext",
+  "image",
+  "boolean",
+  "number",
+  "select",
+  "reference",
+  "multi-reference",
+  "array",
+  "date",
+  "datetime",
+  "group",
+  // Non-Repeatable Zone: one nested object of fields
+  "repeater"
+  // Repeatable Zone: an array of nested field-objects
+]);
+var slug = z.string().regex(/^[a-z0-9-]+$/, "lowercase letters, numbers, and hyphens only");
+var fieldKey = z.string().regex(/^[a-zA-Z0-9_]+$/, "letters, numbers, and underscores only");
+var fieldShape = {
+  key: fieldKey.describe("machine field key, e.g. 'title' or 'blog_hero'"),
+  label: z.string().min(1).describe("human label shown in the editor"),
+  type: fieldType,
+  required: z.boolean().optional(),
+  options: z.array(z.string()).optional().describe("choices when type is 'select'"),
+  config: z.record(z.string(), z.unknown()).optional().describe(
+    "per-type config: reference {contentModelId}, multi-reference {contentModelId,min,max}, array {itemType: 'text'|'number'|'date'}, date {includeTime}"
+  ),
+  fields: z.array(z.lazy(() => fieldObject)).optional().describe(
+    "NESTED child fields \u2014 REQUIRED for type 'group' (one nested object, a Non-Repeatable Zone like blog_hero \u2192 heading, description, hero_image) and type 'repeater' (a repeatable array of such objects, a Repeatable Zone / section-list like testimonials \u2192 quote, author). A section with repeating items is a 'repeater'; a fixed grouped block is a 'group'. Recurse to any depth \u2014 do NOT flatten zones into separate top-level fields."
+  )
+};
+var fieldObject = z.object(fieldShape);
+function toFields(fs) {
+  return (fs ?? []).map(toField);
+}
+function toField(f) {
+  const base = {
+    key: f.key,
+    label: f.label,
+    ...f.required !== void 0 ? { required: f.required } : {}
+  };
+  if (f.type === "group") {
+    return { ...base, type: "array", config: { zones: { nonRepeatable: toFields(f.fields) } } };
+  }
+  if (f.type === "repeater") {
+    return { ...base, type: "array", config: { zones: { repeatable: { fields: toFields(f.fields) } } } };
+  }
+  if (f.type === "array" && f.config && typeof f.config === "object" && "zones" in f.config) {
+    const zones = f.config.zones ?? {};
+    return {
+      ...base,
+      type: "array",
+      config: {
+        zones: {
+          ...zones.nonRepeatable ? { nonRepeatable: toFields(zones.nonRepeatable) } : {},
+          ...zones.repeatable ? {
+            repeatable: {
+              fields: toFields(zones.repeatable.fields),
+              ...zones.repeatable.minItems !== void 0 ? { minItems: zones.repeatable.minItems } : {},
+              ...zones.repeatable.maxItems !== void 0 ? { maxItems: zones.repeatable.maxItems } : {}
+            }
+          } : {}
+        }
+      }
+    };
+  }
+  return {
+    ...base,
+    type: f.type,
+    ...f.options ? { options: f.options } : {},
+    ...f.config ? { config: f.config } : {}
+  };
+}
+function ok(summary, data) {
+  return {
+    content: [
+      { type: "text", text: summary },
+      { type: "text", text: JSON.stringify(data, null, 2) }
+    ]
+  };
+}
+function fail(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function authPrompt(err) {
+  const text = [
+    "\u{1F510} BetterCMS authorization required \u2014 you're not signed in yet.",
+    "",
+    `1. Open this link and approve:  ${err.verificationUriComplete}`,
+    `   (or visit ${err.verificationUri} and enter code ${err.userCode})`,
+    "2. Once approved, run this tool again \u2014 it resumes automatically and completes your request."
+  ].join("\n");
+  return { content: [{ type: "text", text }], isError: true };
+}
+function buildToolDefs(deps) {
+  async function withClient(fn) {
+    const token = await deps.auth.getAccessToken();
+    try {
+      return await fn(deps.createClient(token));
+    } catch (err) {
+      if (err instanceof BetterCMSError && err.status === 401) {
+        const next = await deps.auth.refresh() ?? await deps.auth.getAccessToken();
+        return await fn(deps.createClient(next));
+      }
+      if (err instanceof BetterCMSError && err.status === 409 && err.bodyCode === "PROJECT_DELETED") {
+        const next = await deps.auth.resetAndReauthorize();
+        return await fn(deps.createClient(next));
+      }
+      throw err;
+    }
+  }
+  function guard(fn) {
+    return async (args) => {
+      try {
+        return await fn(args);
+      } catch (err) {
+        if (err instanceof DeviceAuthPendingError) {
+          return authPrompt(err);
+        }
+        if (err instanceof BetterCMSError) {
+          return fail(`BetterCMS error (${err.status} ${err.code}): ${err.message}`);
+        }
+        return fail(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+  }
+  const createPageInput = z.object({
+    title: z.string().min(1).describe("display title of the page, e.g. 'Home'"),
+    slug: slug.describe("URL-safe path segment, unique per project, e.g. 'home'"),
+    pageType: z.enum(["singleton", "dynamic"]).default("singleton").describe(
+      "'singleton' = exactly one entry (Home, About, Contact); 'dynamic' = many entries sharing this schema (Blog posts, Products). Defaults to singleton."
+    ),
+    fields: z.array(fieldObject).optional().describe("the page's typed schema fields"),
+    metaTitle: z.string().optional().describe("SEO meta title"),
+    metaDescription: z.string().optional().describe("SEO meta description")
+  });
+  const addFieldInput = z.object({
+    modelId: z.string().min(1).describe("id of the content model to extend"),
+    ...fieldShape
+  });
+  const addPageFieldInput = z.object({
+    pageId: z.string().min(1).describe("id of the page to extend (from list_pages / create_page)"),
+    ...fieldShape
+  });
+  const uploadAssetInput = z.object({
+    localPath: z.string().min(1).optional().describe("absolute path to a local file (e.g. a repo image); provide this OR url"),
+    url: z.string().url().optional().describe("remote image URL to ingest; provide this OR localPath"),
+    filename: z.string().optional().describe("override the stored filename"),
+    altText: z.string().optional().describe("accessibility alt text"),
+    caption: z.string().optional(),
+    folderId: z.string().optional().describe("target Media Library folder (defaults to project root)")
+  });
+  const createEntryInput = z.object({
+    contentModelId: z.string().min(1).describe("id of the model this entry belongs to"),
+    slug: slug.optional(),
+    status: z.enum(["draft", "published"]).optional().describe("defaults to draft"),
+    data: z.record(z.string(), z.unknown()).optional().describe("field values keyed by field key")
+  });
+  const getPageInput = z.object({
+    pageId: z.string().min(1).describe("page id (from list_pages / create_page)")
+  });
+  const setPageContentInput = z.object({
+    pageId: z.string().min(1).describe("id of the page to write values to"),
+    data: z.record(z.string(), z.unknown()).describe(
+      "field values keyed by field key. A nested 'array' (zone) value is an OBJECT { nonRepeatable: { childKey: value, \u2026 }, repeatable: [ { childKey: value }, \u2026 ] } \u2014 nonRepeatable holds the fixed-block values, repeatable is the list of item objects (omit a zone you didn't define). A primitive 'array' (itemType) is a plain list. An 'image' value is an asset URL or asset id (from upload_asset) \u2014 the server resolves it to { id, url, name, altText }. Read get_page first to see each field's zones."
+    ),
+    status: z.enum(["draft", "published"]).optional().describe("omit to leave status unchanged")
+  });
+  const getEntryInput = z.object({
+    entryId: z.string().min(1).describe("content entry id")
+  });
+  const listEntriesInput = z.object({
+    modelId: z.string().optional().describe("filter by content model id"),
+    pageId: z.string().optional().describe("filter by page id (a singleton page has one entry)"),
+    status: z.enum(["draft", "published"]).optional()
+  });
+  const updateEntryInput = z.object({
+    entryId: z.string().min(1).describe("content entry id"),
+    data: z.record(z.string(), z.unknown()).optional().describe("field values keyed by field key"),
+    status: z.enum(["draft", "published"]).optional(),
+    slug: slug.optional()
+  });
+  const deletePageInput = z.object({
+    pageId: z.string().min(1).describe("id of the page to delete (from list_pages)")
+  });
+  const deleteEntryInput = z.object({
+    entryId: z.string().min(1).describe("id of the content entry to delete (from list_entries)")
+  });
+  const deleteModelInput = z.object({
+    modelId: z.string().min(1).describe("id of the content model to delete (from list_content_models)")
+  });
+  const getFormInput = z.object({
+    formId: z.string().min(1).describe("form id (from list_forms)")
+  });
+  const formFieldObject = z.object({
+    key: z.string().min(1).describe("machine key for the submitted value, e.g. 'email'"),
+    label: z.string().min(1).describe("field label shown to the visitor"),
+    type: z.enum([
+      "text",
+      "email",
+      "textarea",
+      "select",
+      "checkbox",
+      "number",
+      "phone",
+      "date",
+      "url",
+      "consent",
+      "hidden"
+    ]),
+    placeholder: z.string().optional(),
+    required: z.boolean().optional(),
+    options: z.array(z.string()).optional().describe("choices when type is 'select'"),
+    defaultValue: z.string().optional(),
+    showIf: z.object({ field: z.string(), equals: z.string() }).optional().describe("show this field only when another field equals a value")
+  });
+  const formSettingsShape = {
+    description: z.string().optional(),
+    submitLabel: z.string().optional().describe("submit button label (default 'Submit')"),
+    successMessage: z.string().optional(),
+    redirectUrl: z.string().url().optional().describe("URL to redirect to on success")
+  };
+  const createFormInput = z.object({
+    name: z.string().min(1).describe("human form name (used by getForm('Name'))"),
+    fields: z.array(formFieldObject).default([]).describe("the form's fields"),
+    ...formSettingsShape
+  });
+  const updateFormInput = z.object({
+    formId: z.string().min(1).describe("form id (from list_forms)"),
+    name: z.string().optional(),
+    fields: z.array(formFieldObject).optional().describe("REPLACES the field array \u2014 include all fields to keep"),
+    ...formSettingsShape
+  });
+  const blockObject = z.object({
+    type: z.enum(["heading", "text", "image", "button", "spacer", "video", "columns"]).describe("block type; 'columns' nests child blocks in props.columns"),
+    id: z.string().min(1).describe("stable unique block id"),
+    props: z.record(z.string(), z.unknown()).describe(
+      "per-type props: heading {text, level}; text {text}; image {src, alt}; button {text, href}; spacer {height}; video {url}; columns {columns: block[][], gap}"
+    )
+  });
+  const componentPropObject = z.object({
+    key: z.string().min(1),
+    label: z.string().min(1),
+    target: z.object({ blockId: z.string().min(1), path: z.string().min(1) }),
+    type: z.enum(["text", "richtext", "image", "url", "boolean"]),
+    defaultValue: z.unknown().optional()
+  });
+  const componentCategory = z.enum([
+    "navbar",
+    "footer",
+    "button",
+    "section",
+    "slider",
+    "tabs",
+    "form",
+    "custom"
+  ]);
+  const createComponentInput = z.object({
+    name: z.string().min(1),
+    slug: slug.describe("url-safe unique slug (lowercase letters/numbers/hyphens)"),
+    category: componentCategory.optional().describe("defaults to 'custom'"),
+    description: z.string().optional(),
+    blockJson: z.array(blockObject).default([]).describe("the component's block tree"),
+    props: z.array(componentPropObject).default([]).describe("overridable fields")
+  });
+  const updateComponentInput = z.object({
+    componentId: z.string().min(1).describe("component id (from list_components)"),
+    name: z.string().optional(),
+    category: componentCategory.optional(),
+    description: z.string().optional(),
+    blockJson: z.array(blockObject).optional().describe("REPLACES the block tree"),
+    props: z.array(componentPropObject).optional()
+  });
+  const getComponentInput = z.object({
+    componentId: z.string().min(1).describe("component id (from list_components)")
+  });
+  const defs = [
+    {
+      name: "list_pages",
+      config: {
+        title: "List pages in the current project",
+        description: "List the pages in the project this MCP key is bound to, each with its full field SCHEMA, pageType (singleton|dynamic), and status. Use it to verify WHERE content lands and to read field keys/types before set_page_content / add_page_field.",
+        inputSchema: {}
+      },
+      handler: guard(
+        async () => withClient(async (client) => {
+          const pages = await client.listPages();
+          return ok(
+            `${pages.length} page(s) in the bound project.`,
+            pages.map((p) => ({
+              id: p.id,
+              title: p.title,
+              slug: p.slug,
+              pageType: p.pageType,
+              status: p.status,
+              fields: p.fields
+            }))
+          );
+        })
+      )
+    },
+    {
+      name: "get_page",
+      config: {
+        title: "Get a page (with its field schema)",
+        description: "Get one page by id INCLUDING its full field schema (keys, types, nested group/repeater children) and pageType. Read this before set_page_content so you write correctly-keyed values, or before add_page_field so you know the existing keys.",
+        inputSchema: getPageInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const page = await client.getPage(args.pageId);
+          return ok(
+            `Page '${page.title}' (${page.pageType ?? "page"}, ${page.fields.length} field(s)).`,
+            page
+          );
+        })
+      )
+    },
+    {
+      name: "create_page",
+      config: {
+        title: "Create a page",
+        description: "Create a page with its own typed schema. Supports pageType 'singleton' (exactly one entry \u2014 Home, About, Contact) and 'dynamic' (many entries sharing the schema \u2014 Blog posts, Products). Project-scoped from the key. Additive \u2014 does not delete or overwrite existing pages. FIRST read the page's real markup and DECOMPOSE it into a destructured tree: each visual section becomes a nested field \u2014 a fixed grouped block \u2192 type 'group', a repeating list of items (cards, testimonials, features, FAQs) \u2192 type 'repeater' \u2014 each carrying its own child `fields`. Do NOT flatten sections into many flat top-level fields. Build the full nested tree, then call this once.",
+        inputSchema: createPageInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const page = await client.createPage({
+            title: args.title,
+            slug: args.slug,
+            pageType: args.pageType ?? "singleton",
+            ...args.fields ? { fields: args.fields.map(toField) } : {},
+            ...args.metaTitle !== void 0 ? { metaTitle: args.metaTitle } : {},
+            ...args.metaDescription !== void 0 ? { metaDescription: args.metaDescription } : {}
+          });
+          return ok(
+            `Created ${page.pageType ?? "page"} page '${page.title}' (id ${page.id}, slug ${page.slug}) with ${page.fields.length} field(s).`,
+            page
+          );
+        })
+      )
+    },
+    {
+      name: "add_field",
+      config: {
+        title: "Add a field to a content model",
+        description: "Append a field to an existing content model. Reads the model's current fields and adds yours (read-modify-write) \u2014 never removes existing fields. For a section/zone, add ONE 'group' (fixed block) or 'repeater' (repeating list) field carrying its child `fields` \u2014 don't add the zone's inner fields as separate top-level fields.",
+        inputSchema: addFieldInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const model = await client.getModel(args.modelId);
+          if (model.fields.some((f) => f.key === args.key)) {
+            return fail(`Field '${args.key}' already exists on model '${model.name}'.`);
+          }
+          const updated = await client.updateModel(args.modelId, {
+            fields: [...model.fields, toField(args)]
+          });
+          return ok(
+            `Added field '${args.key}' to '${updated.name}'. Model now has ${updated.fields.length} field(s).`,
+            updated
+          );
+        })
+      )
+    },
+    {
+      name: "add_page_field",
+      config: {
+        title: "Add a field to a page",
+        description: "Append a field to an existing page's schema (Home, About, a blog template, etc.). Additive \u2014 the API rejects a key that already exists and never overwrites or retypes existing fields. Use this when the target is a page (singleton or dynamic); use add_field when the target is a content model. For a section/zone, add ONE 'group' (fixed block) or 'repeater' (repeating list) field carrying its child `fields` \u2014 don't add the zone's inner fields as separate top-level fields.",
+        inputSchema: addPageFieldInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const page = await client.addPageFields(args.pageId, { addFields: [toField(args)] });
+          return ok(
+            `Added field '${args.key}' to page '${page.title}'. Page now has ${page.fields.length} field(s).`,
+            page
+          );
+        })
+      )
+    },
+    {
+      name: "create_entry",
+      config: {
+        title: "Create a content entry",
+        description: "Create a content entry under a model. If data/status are provided they are applied in a follow-up update (entries are created as empty drafts).",
+        inputSchema: createEntryInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const created = await client.createEntry({
+            contentModelId: args.contentModelId,
+            ...args.slug !== void 0 ? { slug: args.slug } : {}
+          });
+          const needsUpdate = args.data !== void 0 || args.status !== void 0;
+          const entry = needsUpdate ? await client.updateEntry(created.id, {
+            ...args.data !== void 0 ? { data: args.data } : {},
+            ...args.status !== void 0 ? { status: args.status } : {}
+          }) : created;
+          return ok(
+            `Created entry '${entry.slug}' (id ${entry.id}, status ${entry.status}).`,
+            entry
+          );
+        })
+      )
+    },
+    {
+      name: "set_page_content",
+      config: {
+        title: "Set a page's field values (content)",
+        description: "Set a page's field VALUES \u2014 the actual content. For a SINGLETON page (Home, About, Site Settings) this creates or updates its one entry, so call it again to edit. `data` is keyed by field key: a nested 'array' (zone) value is an OBJECT { nonRepeatable: { childKey: value }, repeatable: [ { childKey: value } ] }; a primitive 'array' is a plain list; an 'image' value is an asset URL. Read the schema first with get_page. This is how you populate Home/About/Settings \u2014 create_entry is for dynamic collections only.",
+        inputSchema: setPageContentInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const entry = await client.setPageContent(args.pageId, {
+            data: args.data,
+            ...args.status !== void 0 ? { status: args.status } : {}
+          });
+          return ok(
+            `Set content on page ${args.pageId} (entry ${entry.id}, status ${entry.status}).`,
+            entry
+          );
+        })
+      )
+    },
+    {
+      name: "list_entries",
+      config: {
+        title: "List content entries (incl. drafts)",
+        description: "List content entries \u2014 including drafts \u2014 filtered by model and/or page. Use it to SEE existing content before editing. For a singleton page, pass its pageId to get its single entry.",
+        inputSchema: listEntriesInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const entries = await client.listEntries({
+            ...args.modelId ? { modelId: args.modelId } : {},
+            ...args.pageId ? { pageId: args.pageId } : {},
+            ...args.status ? { status: args.status } : {}
+          });
+          return ok(`${entries.length} entr(y/ies).`, entries);
+        })
+      )
+    },
+    {
+      name: "get_entry",
+      config: {
+        title: "Get a content entry (with its values)",
+        description: "Get one content entry by id INCLUDING its `data` (field values), even when draft.",
+        inputSchema: getEntryInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const entry = await client.getEntry(args.entryId);
+          return ok(`Entry '${entry.slug}' (id ${entry.id}, status ${entry.status}).`, entry);
+        })
+      )
+    },
+    {
+      name: "update_entry",
+      config: {
+        title: "Update a content entry's values",
+        description: "Update a content entry's `data` (field values) and/or status by id. `data` is keyed by field key; a nested 'array' (zone) value is an object { nonRepeatable: {\u2026}, repeatable: [{\u2026}] }, a primitive 'array' is a plain list. Use this to edit an existing entry; for a singleton page prefer set_page_content.",
+        inputSchema: updateEntryInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const entry = await client.updateEntry(args.entryId, {
+            ...args.data !== void 0 ? { data: args.data } : {},
+            ...args.status !== void 0 ? { status: args.status } : {},
+            ...args.slug !== void 0 ? { slug: args.slug } : {}
+          });
+          return ok(`Updated entry '${entry.slug}' (id ${entry.id}, status ${entry.status}).`, entry);
+        })
+      )
+    },
+    {
+      name: "upload_asset",
+      config: {
+        title: "Upload an asset to the Media Library",
+        description: "Upload an image/asset from a local file path or a remote URL into the project's Media Library. Returns the asset's stable CDN URL \u2014 put that URL into a content entry's image field. Use this BEFORE creating entries that reference images.",
+        inputSchema: uploadAssetInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const asset = await client.uploadAsset(args);
+          return ok(
+            `Uploaded '${asset.filename}' (id ${asset.id}). Put this URL (or the id ${asset.id}) into an image field to attach it: ${asset.url}`,
+            asset
+          );
+        })
+      )
+    },
+    {
+      name: "delete_page",
+      config: {
+        title: "Delete a page",
+        description: "DELETE a page and its content. Destructive but REVERSIBLE \u2014 it soft-deletes (can be restored from the dashboard) and is audit-logged. Use it to remove a page you created by mistake. Confirm with the user before deleting content they may want.",
+        inputSchema: deletePageInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const res = await client.deletePage(args.pageId);
+          return ok(`Deleted page ${res.id} (soft-delete \u2014 restorable from the dashboard).`, res);
+        })
+      )
+    },
+    {
+      name: "delete_entry",
+      config: {
+        title: "Delete a content entry",
+        description: "DELETE a single content entry. Destructive but REVERSIBLE (soft-delete, restorable from the dashboard) and audit-logged. Use it to remove content created by mistake.",
+        inputSchema: deleteEntryInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const res = await client.deleteEntry(args.entryId);
+          return ok(`Deleted entry ${res.id} (soft-delete \u2014 restorable from the dashboard).`, res);
+        })
+      )
+    },
+    {
+      name: "delete_content_model",
+      config: {
+        title: "Delete a content model",
+        description: "DELETE a content model and its entries. Destructive but REVERSIBLE (soft-delete, restorable from the dashboard) and audit-logged. Confirm with the user first \u2014 this removes all content under the model.",
+        inputSchema: deleteModelInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const res = await client.deleteModel(args.modelId);
+          return ok(`Deleted content model ${res.id} and its entries (soft-delete \u2014 restorable from the dashboard).`, res);
+        })
+      )
+    },
+    // ── Forms (read-only — discover dashboard forms to embed into the site) ──
+    {
+      name: "list_forms",
+      config: {
+        title: "List forms in the current project",
+        description: "List the forms built in the dashboard for the bound project \u2014 each with its id, name, and field schema. Use it to find a form to add to the user's site: read it, then write `<BcmsForm form={getForm('Name')} />` (from @bettercms-ai/next) into the page/component where the user wants it.",
+        inputSchema: {}
+      },
+      handler: guard(
+        async () => withClient(async (client) => {
+          const forms = await client.listForms();
+          return ok(
+            `${forms.length} form(s) in the bound project.`,
+            forms.map((f) => ({ id: f.id, name: f.name, fields: f.fields }))
+          );
+        })
+      )
+    },
+    {
+      name: "get_form",
+      config: {
+        title: "Get a form (with its field schema)",
+        description: "Get one form by id INCLUDING its fields (keys, types, required, options, showIf) and settings (submitLabel, successMessage, redirectUrl, turnstileEnabled, honeypotField). Read this before wiring `<BcmsForm>` so you render the right fields.",
+        inputSchema: getFormInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const form = await client.getForm(args.formId);
+          return ok(`Form '${form.name}' (${form.fields.length} field(s)).`, form);
+        })
+      )
+    },
+    {
+      name: "create_form",
+      config: {
+        title: "Create a form",
+        description: "Create a form (fields + settings) in the bound project. CONFIRM the fields with the user first. Returns the new form's id \u2014 then embed it with `<BcmsForm form={getForm('Name')} />` from @bettercms-ai/next. Field types: text,email,textarea,select(needs options),checkbox,number,phone,date,url,consent,hidden.",
+        inputSchema: createFormInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const form = await client.createForm(args);
+          return ok(`Created form '${form.name}' (id ${form.id}). Embed with <BcmsForm form={getForm('${form.name}')} />.`, form);
+        })
+      )
+    },
+    {
+      name: "update_form",
+      config: {
+        title: "Update a form",
+        description: "Update a form by id \u2014 name, fields, or settings. Read get_form first. Passing `fields` REPLACES the array (include all fields to keep).",
+        inputSchema: updateFormInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const { formId, ...input } = args;
+          const form = await client.updateForm(formId, input);
+          return ok(`Updated form '${form.name}' (id ${form.id}).`, form);
+        })
+      )
+    },
+    // ── Components (discover + author reusable symbols) ──
+    {
+      name: "list_components",
+      config: {
+        title: "List reusable components",
+        description: "List the reusable components in the bound project \u2014 each with id, name, slug, category, blockJson, and props. Use it to find a component to render with `<BcmsBlocks>` from @bettercms-ai/next.",
+        inputSchema: {}
+      },
+      handler: guard(
+        async () => withClient(async (client) => {
+          const list = await client.listComponents();
+          return ok(
+            `${list.length} component(s) in the bound project.`,
+            list.map((cmp) => ({ id: cmp.id, name: cmp.name, slug: cmp.slug, category: cmp.category }))
+          );
+        })
+      )
+    },
+    {
+      name: "get_component",
+      config: {
+        title: "Get a component (with its blockJson)",
+        description: "Get one component by id INCLUDING its blockJson tree and props. Read this before update_component so you keep the existing blocks.",
+        inputSchema: getComponentInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const cmp = await client.getComponent(args.componentId);
+          return ok(`Component '${cmp.name}' (${cmp.blockJson.length} block(s)).`, cmp);
+        })
+      )
+    },
+    {
+      name: "create_component",
+      config: {
+        title: "Create a reusable component",
+        description: "Create a reusable component from a blockJson tree. CONFIRM the structure with the user first. blockJson is an array of blocks (heading/text/image/button/spacer/video/columns); a 'columns' block nests child blocks in props.columns. `props` declares overridable fields. Returns the new id \u2014 render with `<BcmsBlocks>`.",
+        inputSchema: createComponentInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const cmp = await client.createComponent(args);
+          return ok(`Created component '${cmp.name}' (id ${cmp.id}, slug ${cmp.slug}).`, cmp);
+        })
+      )
+    },
+    {
+      name: "update_component",
+      config: {
+        title: "Update a reusable component",
+        description: "Update a component by id \u2014 blockJson, props, name, or category. Read get_component first. Passing `blockJson`/`props` REPLACES them. Updating re-bakes every page that embeds this component.",
+        inputSchema: updateComponentInput.shape
+      },
+      handler: guard(
+        async (args) => withClient(async (client) => {
+          const { componentId, ...input } = args;
+          const cmp = await client.updateComponent(componentId, input);
+          return ok(`Updated component '${cmp.name}' (id ${cmp.id}).`, cmp);
+        })
+      )
+    }
+  ];
+  return defs;
+}
+function registerTools(server, deps) {
+  for (const def of buildToolDefs(deps)) {
+    server.registerTool(def.name, def.config, def.handler);
+  }
+}
+
+// src/prompts.ts
+import { z as z2 } from "zod";
+var SCHEMA_PROPOSAL_FLOW = `### Whole-project schema design (declarative, confirm-first) \u2192 \`create_page\` / \`add_field\`
+Design the WHOLE project's content schema from its code, and **confirm the
+shape with the user BEFORE creating anything**. Never silently guess.
+1. **Read the project's code** \u2014 the connected git repo OR, for an uploaded project,
+   its source in your current working directory (same thing: pages/routes and their
+   components). For each page, identify the editable regions and how they're structured.
+2. **Destructure every page into a tree**, do NOT flatten. Map each region to:
+   - a plain field (text/richtext/image/number/boolean/select/date/datetime/reference),
+   - a **group** (Non-Repeatable Zone \u2014 a fixed grouped block, e.g. a hero with
+     heading + subheading + image), or
+   - a **repeater** (Repeatable Zone / section-list \u2014 a repeating list of items
+     such as feature cards, testimonials, FAQs, pricing tiers), each carrying its
+     own child \`fields\`. Use \`array\` only for primitive lists (tags, bullet strings).
+   Decide pageType per page: singleton (Home/About/Contact) vs dynamic (Blog/Products).
+3. **Present the proposal for confirmation (REQUIRED gate).** Show the full tree \u2014
+   page \u2192 zones \u2192 nested fields, with each zone labelled group vs repeater \u2014 and ask
+   the user (AskUserQuestion) to confirm or adjust: which zones repeat, what fields
+   each holds, singleton vs dynamic, any missing/extra pages. Iterate until they
+   approve. Do NOT call create_page / add_field before this approval.
+4. **Build it** \u2014 once approved, call \`create_page\` once per page with the full
+   nested \`fields\` tree; use \`add_field\`/\`add_page_field\` only to extend later.
+   Keep field keys stable and human-readable. Schema only \u2014 no content yet.
+Field object: { key, label, type, required?, options?, config?, fields? }.`;
+var PAGE_FLOW = `### Page authoring \u2192 \`create_page\` tool
+Author a page (the page-first schema). Ask, in order, via AskUserQuestion:
+1. **Page type** \u2014 singleton (exactly one entry: Home, About, Contact) vs dynamic
+   (many entries sharing the schema: Blog posts, Products).
+2. **Identity** \u2014 title; derive a slug (lowercase, a\u2013z 0\u20139 -) and confirm; optional
+   metaTitle/metaDescription.
+3. **Fields (loop until done)** \u2014 for each: key (^[a-zA-Z0-9_]+$), label, type,
+   required?. Types (13): text, richtext, image, boolean, number, select (needs
+   \`options: string[]\`), reference / multi-reference (\`config.contentModelId\`,
+   multi adds min/max), array (primitives \u2014 \`config.itemType\`: text|number|date),
+   date (\`config.includeTime\`?), datetime, **group** (Non-Repeatable Zone: ONE
+   nested object \u2014 recurse to collect its \`fields\`, e.g. blog_hero \u2192 heading,
+   description, hero_image), **repeater** (Repeatable Zone: an ARRAY of such objects
+   \u2014 recurse to collect item \`fields\`, e.g. testimonials \u2192 quote, author). Nesting
+   may go several levels deep.
+4. **Review** the assembled tree, then call \`create_page\` with
+   { title, slug, pageType, fields, metaTitle?, metaDescription? }. Field object:
+   { key, label, type, required?, options?, config?, fields? }.`;
+var FIELD_FLOW = `### Add a field \u2192 \`add_field\` (models) / \`add_page_field\` (pages)
+Append a field to an existing schema. First decide the target: a **content model**
+or a **page** (Home, About, a blog template). Ask: which target (id \u2014 use
+\`list_pages\` to find a page id), then the field (key, label, type \u2014 any of the 13
+above, including nested group/repeater), required?. Confirm, then call:
+- a model \u2192 \`add_field\` { modelId, key, label, type, ... }
+- a page  \u2192 \`add_page_field\` { pageId, key, label, type, ... }
+Both are additive: they reject a key that already exists and never retype/overwrite
+an existing field (edit those in the dashboard).`;
+var ENTRY_FLOW = `### Create an entry \u2192 \`create_entry\` tool
+Create a content entry under a model. Ask: which model (id), the field values (data),
+status (draft/published). Then call \`create_entry\` { contentModelId, data?, status?, slug? }.`;
+var FORM_FLOW = `### Form authoring \u2192 \`create_form\` / \`update_form\` tools
+Author a form (then the user embeds it with \`<BcmsForm form={getForm('Name')} />\` from
+@bettercms-ai/next). Confirm the fields with the user BEFORE creating. Never guess fields.
+1. **Discover** \u2014 \`list_forms\` to see existing forms; \`get_form\` to read one before editing.
+2. **Collect fields (loop)** \u2014 for each: key (machine key for the value), label, type. Types:
+   text, email, textarea, select (needs \`options: string[]\`), checkbox, number, phone, date,
+   url, consent, hidden. Optional per field: required?, placeholder?, defaultValue?, and
+   \`showIf: { field, equals }\` for conditional display.
+3. **Settings** \u2014 name (used by getForm('Name')), submitLabel?, successMessage?, redirectUrl?.
+4. **Confirm**, then \`create_form\` { name, fields, ... } (returns the new id), or
+   \`update_form\` { formId, ... } to edit (passing \`fields\` REPLACES the array \u2014 include all).
+5. Offer to wire \`<BcmsForm>\` into the page/component where the user wants it.`;
+var COMPONENT_FLOW = `### Component authoring \u2192 \`create_component\` / \`update_component\` tools
+Author a reusable component (Webflow-style symbol) the user renders with \`<BcmsBlocks>\`.
+blockJson is the visual definition; authoring it blind is error-prone, so go slow and
+confirm. Never guess the layout.
+1. **Discover** \u2014 \`list_components\` / \`get_component\` (read before update; keep existing blocks).
+2. **Design the blockJson tree** \u2014 an array of blocks, each { type, id, props }. Types:
+   heading {text, level 1-6}, text {text}, image {src, alt}, button {text, href}, spacer
+   {height}, video {url}, and **columns** {columns: array of arrays of blocks, gap} which
+   NESTS child blocks. Give every block a stable unique id.
+3. **Props (optional)** \u2014 declare overridable fields: { key, label, target: { blockId, path },
+   type: text|richtext|image|url|boolean, defaultValue? } so instances can be customized.
+4. **Confirm the structure** (AskUserQuestion: show the block tree), then \`create_component\`
+   { name, slug, category?, blockJson, props? } (returns the id), or \`update_component\`
+   { componentId, ... } \u2014 note updating re-bakes every page that embeds it.`;
+function registerPrompts(server) {
+  server.registerPrompt(
+    "studio",
+    {
+      title: "BetterCMS Studio (guided)",
+      description: "One command to author in BetterCMS. Detects what you want \u2014 create a page, add a field, create an entry \u2014 and runs the matching guided flow, then calls the right tool.",
+      argsSchema: {
+        request: z2.string().optional().describe("what you want to do, e.g. 'a blog page with a hero zone'")
+      }
+    },
+    ({ request }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `You are the BetterCMS authoring assistant (via the bettercms MCP).
+${request ? `The user's request: "${request}".
+` : ""}
+First, **preflight**: confirm the bettercms tools are loaded (\`create_page\`, \`add_field\`,
+\`create_entry\`). If \`create_page\` is missing and only \`create_model\` shows, the host has a
+stale cached MCP \u2014 tell the user to run \`rm -rf ~/.npm/_npx\` and restart, then stop.
+
+Then **route** to the matching sub-flow below based on the request and conversation
+context. DEFAULT: when setting up a project or designing its schema from the repo (or
+when intent is unclear), run the **whole-repo schema design** flow \u2014 it proposes the
+structure and confirms with the user before creating anything. Use the single-page or
+single-field flows only for targeted follow-ups. If still unsure, ask the user
+(AskUserQuestion: "Design the schema from my project" / "Create one page" / "Add a field" /
+"Create an entry" / "Build a form" / "Build a component"). Run flows by asking ONE step at
+a time, pre-filling sensible defaults from the request but never inventing fields the user
+didn't imply. Whatever the page/zone/form/component is scoped to follows the MCP key's project.
+
+${SCHEMA_PROPOSAL_FLOW}
+
+${PAGE_FLOW}
+
+${FIELD_FLOW}
+
+${ENTRY_FLOW}
+
+${FORM_FLOW}
+
+${COMPONENT_FLOW}
+
+This assistant is extensible: when new BetterCMS tools are added, a new sub-flow appears
+here \u2014 route to it the same way.`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "propose_schema",
+    {
+      title: "Design schema from repo (confirm-first)",
+      description: "Read the repository, propose a destructured content schema (pages \u2192 group/repeater zones \u2192 nested fields), confirm it with you, then create it via create_page. Use this to set up a project's schema.",
+      argsSchema: {
+        request: z2.string().optional().describe("optional focus, e.g. 'just the marketing pages' or 'the whole site'")
+      }
+    },
+    ({ request }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Design the BetterCMS content schema for this repository.${request ? ` Focus: "${request}".` : ""}
+
+Preflight: if \`create_page\` isn't available (only create_model/add_field/create_entry),
+the host has a stale cached MCP \u2014 tell the user to \`rm -rf ~/.npm/_npx\` and restart, then stop.
+
+${SCHEMA_PROPOSAL_FLOW}
+
+After creating, report each page's id, slug, type, and field count, and the project it
+landed in. On 409 slug_taken, offer an alternative slug; on 401/403, the MCP key needs
+(re)authorizing.`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "new_page",
+    {
+      title: "New page (guided)",
+      description: "Guided creation of a BetterCMS page (singleton or dynamic) with fields, including nested group (Non-Repeatable Zone) and repeater (Repeatable Zone) fields. Calls create_page.",
+      argsSchema: {
+        request: z2.string().optional().describe("what the page is, e.g. 'a blog page with a hero'")
+      }
+    },
+    ({ request }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Create a BetterCMS page via the \`create_page\` tool.${request ? ` The user wants: "${request}".` : ""}
+
+Preflight: if \`create_page\` isn't available (only create_model/add_field/create_entry),
+the host has a stale cached MCP \u2014 tell the user to \`rm -rf ~/.npm/_npx\` and restart, then stop.
+
+${PAGE_FLOW}
+
+After creating, report the page id, slug, type, field count, and the project it landed in.
+On 409 slug_taken, offer an alternative slug; on 401/403, the MCP key needs (re)authorizing.`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "new_form",
+    {
+      title: "New form (guided)",
+      description: "Guided creation of a BetterCMS form (fields + settings) you can embed with <BcmsForm>. Calls create_form.",
+      argsSchema: {
+        request: z2.string().optional().describe("what the form is, e.g. 'a contact form with name, email, message'")
+      }
+    },
+    ({ request }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Author a BetterCMS form via the \`create_form\` tool.${request ? ` The user wants: "${request}".` : ""}
+
+${FORM_FLOW}
+
+After creating, report the form id and name, and how to embed it (\`<BcmsForm form={getForm('Name')} />\`).
+On 401/403, the MCP key needs (re)authorizing.`
+          }
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "new_component",
+    {
+      title: "New component (guided)",
+      description: "Guided creation of a reusable BetterCMS component (a blockJson tree + overridable props) you render with <BcmsBlocks>. Calls create_component.",
+      argsSchema: {
+        request: z2.string().optional().describe("what the component is, e.g. 'a hero with heading, text and a button'")
+      }
+    },
+    ({ request }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Author a reusable BetterCMS component via the \`create_component\` tool.${request ? ` The user wants: "${request}".` : ""}
+
+${COMPONENT_FLOW}
+
+After creating, report the component id, name, and slug, and how to render it (\`<BcmsBlocks>\`).
+On 409 slug_taken, offer an alternative slug; on 401/403, the MCP key needs (re)authorizing.`
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/server.ts
+var SERVER_NAME = "bettercms";
+var SERVER_VERSION = "0.1.0";
+function buildServer(deps) {
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {}, prompts: {} } }
+  );
+  registerTools(server, {
+    auth: deps.auth,
+    createClient: (apiKey) => BetterCMS.management({ apiKey, baseUrl: deps.managementBaseUrl })
+  });
+  registerPrompts(server);
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const store = new FileTokenStore(config.credentialsPath, config.apiUrl);
+  const auth = new DeviceAuthClient(config, store);
+  const server = buildServer({ auth, managementBaseUrl: config.managementBaseUrl });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(`[bettercms-mcp] ready on stdio (api: ${config.apiUrl})
+`);
+}
+function isMainModule() {
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  main().catch((err) => {
+    process.stderr.write(`[bettercms-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  DeviceAuthClient,
+  buildServer,
+  loadConfig
+};
+//# sourceMappingURL=index.js.map