drupal-mcp-connector 3.1.0 → 3.2.1

package/src/tools/nested.js

@@ -0,0 +1,69 @@
+/**
+ * Tool: governed nested-paragraph draft (#421).
+ *
+ * Direct component attributes stay on drupal_update_node `components`.
+ * A nested child is a new unpublished paragraph, pinned only by the host
+ * draft. This tool never calls updateEntity on a paragraph.
+ */
+
+import { getSiteConfig } from "../lib/config.js";
+import { resolveBackend } from "../lib/backends/index.js";
+import { resolveSecurityConfig, assertWriteAllowed, assertPublishAllowed } from "../lib/security.js";
+import { draftNestedComponents } from "../lib/nested-draft.js";
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function draftNestedComponentsTool({
+  site: siteName, bundle, id, field, parentId, childField, children,
+  liveRevisionId, resumeParentId, dryRun = false,
+}) {
+  const site = getSiteConfig(siteName);
+  const sec = resolveSecurityConfig(site);
+  assertWriteAllowed(sec, "update", "node", bundle);
+  assertPublishAllowed(sec, { moderation_state: "draft" });
+  const backend = await resolveBackend(site);
+  return draftNestedComponents(backend, {
+    entityType: "node", bundle, id, field, parentId, childField, children,
+    liveRevisionId, resumeParentId,
+  }, {
+    dryRun,
+    site,
+    assertParagraphCreate(paragraphBundle) {
+      assertWriteAllowed(sec, "create", "paragraph", paragraphBundle);
+    },
+  });
+}
+
+export const definitions = [
+  {
+    name: "drupal_draft_nested_components",
+    description:
+      "Replace nested paragraphs on a node by creating new unpublished paragraphs and pinning a new direct parent from the node's unpublished draft. children is the full new list: { op: 'keep', id } copies an existing child pin, { op: 'replace', id, type, attributes, translations? } or { op: 'insert', type, attributes, translations? } creates a new child. Omitting a child leaves it off the draft only; it is not deleted. The published host and every paragraph it already pins stay unchanged. Never edits a live child and never sends nested UUIDs as mcp_components (use drupal_update_node components for a direct paragraph's attributes). Reusable library items and from_library children are refused; update the library item with drupal_entity_update. The first host draft requires MCP Sentinel 2.29.0 (open_draft). An existing working copy continues through /mcp-draft. When the host inventory advertises nested_replacement, one /mcp-draft carries meta.mcp_nested_replacement (parent is the parentId input), the connector creates no paragraphs, and it does not also send the host paragraph field. dryRun then uses that non-saving preflight (serverPreflight sentinel_draft). Hosts that do not advertise nested_replacement keep this sequence, including resumeParentId, and dryRun leaves serverPreflight none. New paragraphs are created in the host's default language. The new parent keeps the published parent's other references and replaces only the child field. Non-default translations on the component must be supplied on each replace or insert; they are created on the new paragraphs, and the component's own translations are copied onto the new parent. dryRun checks paragraph-create permission, creates nothing, and does not evaluate the host payload. If paragraph creates succeed and the host pin fails, the error lists the prepared UUIDs. When a parent was prepared, retry with resumeParentId and the same children list; that retry checks the prepared paragraph's fields, other references, and child revision pins before any host write. A failure before a parent exists says to delete the prepared paragraphs and does not offer a host retry. A lost response is uncertain until a re-read proves the prepared revision is pinned; the same UUID at another revision is not success. A second call after success is refused while the forward draft no longer pins the published component. Governed by the site security policy. Nothing is published.",
+    inputSchema: {
+      type: "object",
+      required: ["bundle", "id", "field", "parentId", "childField", "children"],
+      properties: {
+        site: { type: "string", description: "Named site (omit for default)" },
+        bundle: { type: "string", description: "Node bundle machine name, e.g. 'page'" },
+        id: { type: "string", description: "Node UUID" },
+        field: { type: "string", description: "Host entity-reference-revisions field that pins the direct parent, e.g. 'field_components'" },
+        parentId: { type: "string", description: "UUID of the direct paragraph the published host pins. Not a nested child." },
+        childField: { type: "string", description: "Entity-reference-revisions field on that direct paragraph, e.g. 'field_items'" },
+        children: {
+          type: "array",
+          description: "Full new child list, in order. keep: { op, id }. replace: { op, id, type, attributes, translations? }. insert: { op, type, attributes, translations? }. translations is [{ langcode, attributes }] for each non-default language the component already has. Relationships inside a child are refused.",
+          items: { type: "object" },
+        },
+        liveRevisionId: { type: "string", description: "Optional published revision id. Refused before any create when it is not the current live revision." },
+        resumeParentId: { type: "string", description: "Prepared parent UUID from a previous attempt whose host pin did not finish. Retries only the host pin. Must not be a paragraph the published host already pins." },
+        dryRun: { type: "boolean", default: false, description: "When nested_replacement is advertised, run that non-saving /mcp-draft preflight and create nothing (checks.serverPreflight is sentinel_draft). Otherwise read the host and component, then return without creating paragraphs or evaluating the host draft payload (checks.serverPreflight is none)." },
+      },
+    },
+  },
+];
+
+export const handlers = {
+  drupal_draft_nested_components: draftNestedComponentsTool,
+};

package/src/tools/nodes.js

@@ -516,7 +516,7 @@ async function updateNode({ site: siteName, type, id, title, body, summary, form
     const written = await writeComponentDraft(backend, {
       entityType: "node", bundle: type, id, attributes, relationships: resolvedRelationships,
       components: normalizedComponents, langcode,
-    }, { dryRun });
+    }, { dryRun, site });
     const shaped = dryRun ? written : shapeWriteResponse(written, returning);
     return summaryWrite.deprecated && bodyAttr ? attachSummaryDeprecation(shaped) : shaped;
   }
@@ -691,7 +691,7 @@ export const definitions = [
         relationships: { type: "object", description: "Entity-reference fields as JSON:API relationships, keyed by field machine name. Single-value uses { data: { type, id } }; multi-value uses { data: [{ type, id }, …] }. Paragraph / ERR items must carry meta.target_revision_id — the connector injects it when missing, and fails the write if it cannot. Image alt on a translation uses the existing file UUID plus meta.alt; replacing the file is refused." },
         components: {
           type: "array",
-          description: "Field changes for paragraphs this node already references directly (hero, text blocks, CTA banners), saved in the same unpublished draft revision as the node fields. Each entry is { id: paragraph UUID, type: paragraph bundle such as 'p_hero', attributes: { field: value } }. Each changed paragraph gets a new revision that only the draft points at; the live page does not change until the draft is published. Opens the working copy from live when none exists. Default language only. Attribute values only: references (for example a media field) are refused, as are nested paragraphs and paragraphs the node does not reference. Requires MCP Sentinel 2.29.0 or later; older hosts are refused before any write, with no direct paragraph write. A `path` change is refused on this path. The connector's paragraph write policy applies to each component. After the write each component is read back at its working revision and the submitted values compared; a value that did not land is an error. The result carries `_components` (each component's live and working pins and the fields verified), which survives `returning: 'minimal'`.",
+          description: "Field changes for paragraphs this node already references directly (hero, text blocks, CTA banners), saved in the same unpublished draft revision as the node fields. Each entry is { id: paragraph UUID, type: paragraph bundle such as 'p_hero', attributes: { field: value } }. Each changed paragraph gets a new revision that only the draft points at; the live page does not change until the draft is published. Opens the working copy from live when none exists. Default language only. Attribute values only: references (for example a media field) are refused, as are paragraphs the node does not reference. A nested paragraph is refused before any write; use drupal_draft_nested_components. Requires MCP Sentinel 2.29.0 or later; older hosts are refused before any write, with no direct paragraph write. A `path` change is refused on this path. The connector's paragraph write policy applies to each component. After the write each component is read back at its working revision and the submitted values compared; a value that did not land is an error. The result carries `_components` (each component's live and working pins and the fields verified), which survives `returning: 'minimal'`.",
           items: {
             type: "object",
             required: ["id", "type", "attributes"],

package/src/tools/paragraphs.js

@@ -35,6 +35,7 @@
  */
 
 import { getSiteConfig } from "../lib/config.js";
+import { applyAllowedFormatsToAttributes } from "../lib/field-definition.js";
 import { resolveBackend } from "../lib/backends/index.js";
 import {
   resolveSecurityConfig, assertWriteAllowed, assertReadAllowed, redactCanonicalEntity,
@@ -93,7 +94,11 @@ async function createParagraph({ site: siteName, paragraphType, attributes = {}
   const sec = resolveSecurityConfig(site);
   assertWriteAllowed(sec, "create", "paragraph", paragraphType);
   const backend = await resolveBackend(site);
-  const paragraph = await backend.createEntity({ entityType: "paragraph", bundle: paragraphType, attributes });
+  const formatted = await applyAllowedFormatsToAttributes({
+    backend, site, entityType: "paragraph", bundle: paragraphType,
+    attributes: { ...attributes }, defaultBodyFormat: false,
+  });
+  const paragraph = await backend.createEntity({ entityType: "paragraph", bundle: paragraphType, attributes: formatted });
   const bundle = paragraph.bundle || paragraphType;
   const revisionId = await resolveParagraphRevisionId(backend, paragraph, paragraphType);
   if (revisionId === null) throw missingParagraphRevisionError(paragraph.id);
@@ -122,6 +127,10 @@ async function updateParagraph({ site: siteName, paragraphType, id, attributes =
   const sec = resolveSecurityConfig(site);
   assertWriteAllowed(sec, "update", "paragraph", paragraphType);
   const backend = await resolveBackend(site);
+  const formatted = await applyAllowedFormatsToAttributes({
+    backend, site, entityType: "paragraph", bundle: paragraphType,
+    attributes: { ...attributes }, defaultBodyFormat: false,
+  });
   let paragraph;
   if (langcode) {
     const targetLang = assertDraftLangcode(langcode);
@@ -132,11 +141,11 @@ async function updateParagraph({ site: siteName, paragraphType, id, attributes =
       throw new Error("Paragraph translation update requires a paragraph revision ID (the host pin).");
     }
     paragraph = await writeDraft(backend, {
-      entityType: "paragraph", bundle: paragraphType, id, attributes, langcode: targetLang, draftState,
+      entityType: "paragraph", bundle: paragraphType, id, attributes: formatted, langcode: targetLang, draftState,
       draftRevision: { revisionId: pinned },
     });
   } else {
-    paragraph = await backend.updateEntity({ entityType: "paragraph", bundle: paragraphType, id, attributes });
+    paragraph = await backend.updateEntity({ entityType: "paragraph", bundle: paragraphType, id, attributes: formatted });
   }
   const bundle = paragraph.bundle || paragraphType;
   const resolvedRevisionId = await resolveParagraphRevisionId(backend, paragraph, paragraphType);

package/src/tools/translations.js

@@ -28,6 +28,7 @@ import {
 } from "../lib/security.js";
 import { validateUuid, validateMachineName } from "../lib/validate.js";
 import { applySafeDraftDefault } from "../lib/moderation-default.js";
+import { applyAllowedFormatsToAttributes } from "../lib/field-definition.js";
 import { omitLiveComputedMetatag } from "../lib/entity-response.js";
 import { entityRevisionId } from "../lib/write-revision.js";
 import { paragraphRevisionId } from "../lib/err-relationships.js";
@@ -160,7 +161,10 @@ async function createTranslation({
   }
 
   let draftRevision;
-  let drafted = { ...attributes };
+  let drafted = await applyAllowedFormatsToAttributes({
+    backend, site, entityType, bundle: type, attributes: { ...attributes }, existingEntity: existing,
+    defaultBodyFormat: false,
+  });
   delete drafted.langcode;
   if (entityType === "paragraph") {
     const pinned = revisionId ?? paragraphRevisionId(existing);