drupal-mcp-connector 3.1.0 → 3.2.1

package/src/lib/component-draft.js

@@ -16,6 +16,7 @@
 import { readNodeDraftInventory, assertDraftLangcode } from "./sentinel-draft.js";
 import { entityRevisionId } from "./write-revision.js";
 import { paragraphPinsFromEntity } from "./err-relationships.js";
+import { applyParagraphTextFormats } from "./field-definition.js";
 import { PREFLIGHT_SENTINEL_DRAFT, dryRunChecks } from "./dry-run-checks.js";
 
 /** Inventory operation: component paragraph changes inside a draft save. */
@@ -159,14 +160,19 @@ function pinMap(entity) {
  * @param {object} [input.relationships]
  * @param {Array} input.components Entries for {@link normalizeComponents}.
  * @param {string} [input.langcode] Must be the default language when given.
- * @param {{dryRun?: boolean}} [options]
+ * @param {{dryRun?: boolean, site?: object}} [options]
  * @returns {Promise<object>} Preview on dryRun; otherwise the written entity
  *   plus `_components` (live and working pins and verified fields per
  *   paragraph).
  */
-export async function writeComponentDraft(backend, input, { dryRun = false } = {}) {
+export async function writeComponentDraft(backend, input, { dryRun = false, site = {} } = {}) {
   const { entityType, bundle, id, attributes = {}, relationships } = input;
   const components = normalizeComponents(input.components);
+  // Refuse a disallowed paragraph format before inventory or the draft preflight.
+  for (const component of components) {
+    const paragraphBundle = component.type.slice("paragraph--".length);
+    await applyParagraphTextFormats(backend, site, paragraphBundle, component.attributes);
+  }
   if (Object.hasOwn(attributes, "path")) {
     throw new Error("Aliases are not revisioned. Change the alias in a separate update; no write was attempted.");
   }
@@ -198,6 +204,22 @@ export async function writeComponentDraft(backend, input, { dryRun = false } = {
     }
   }
 
+  const pinHost = working
+    ? await backend.getEntity({ entityType, bundle, id, resourceVersion: `id:${working}` })
+    : await backend.getEntity({ entityType, bundle, id });
+  if (!pinHost) {
+    throw new Error("The host revision could not be read. No write was attempted, and no direct paragraph write was tried.");
+  }
+  const directIds = new Set(paragraphPinsFromEntity(pinHost).map((pin) => pin.id.toLowerCase()));
+  for (const component of components) {
+    if (!directIds.has(component.id.toLowerCase())) {
+      throw new Error(
+        `${component.id} is not a direct paragraph of this host. Nested paragraphs are not component edits. ` +
+        "Use drupal_draft_nested_components. No write was attempted, and no direct paragraph write was tried."
+      );
+    }
+  }
+
   const data = { type: `${entityType}--${bundle}`, id, attributes };
   if (relationships && Object.keys(relationships).length) data.relationships = relationships;
   const request = { entityType, bundle, id, data, components, live, working, langcode: defaultLang };

package/src/lib/dispatch.js

@@ -15,6 +15,7 @@ import { resolveSecurityConfig, assertNotReadOnly,
 import { toolError, toolResult } from "./errors.js";
 import { BackendCapabilityError, BackendResolutionError } from "./backends/errors.js";
 import { inferOperation } from "./operations.js";
+import { ensureTextFormatContext, toolNeedsTextFormatContext } from "./text-format-context.js";
 import { assertSourceGovernance, GovernanceError } from "./governance.js";
 import {
   assertPrincipalEntitlement, callerTargetHints, DIAGNOSTIC_TOOLS,
@@ -186,6 +187,12 @@ export async function securityMiddleware(toolName, args, handler, context = {})
   });
   return runWithDataFlow(flow, async () => {
     await assertCallAllowed();
+    // Content-tier tokens cannot read field_config. Load Sentinel's schema
+    // before a handler that resolves text formats (#429). Other writes do
+    // not wait. A miss leaves the historical unknown-list path in place.
+    if (toolNeedsTextFormatContext(toolName)) {
+      await ensureTextFormatContext(site);
+    }
     // Charge only after governance and policy gates pass, so an outage or a
     // local deny cannot exhaust the window. Diagnostics do not consume.
     if (!DIAGNOSTIC_TOOLS.has(toolName)) {

package/src/lib/field-definition.js

@@ -11,10 +11,15 @@
  *      `base_field_override` (node body is a base field; its allowed_formats
  *      are not on `field_config`). Internal adapter fetch, not
  *      `drupal_entity_get` (`field_config` is on the agent deny list).
- *   2. Drush `config:get field.field.{entityType}.{bundle}.{field}`, then
+ *      A row whose `field_name` is not the requested field is a miss.
+ *   2. Cached Sentinel `GET /drupal-mcp/context`, for node bundles, when the
+ *      field entry includes `allowed_formats` (#429). A content-tier token
+ *      cannot read `field_config`. Dispatch fills this cache before a tool
+ *      that resolves text formats.
+ *   3. Drush `config:get field.field.{entityType}.{bundle}.{field}`, then
  *      `core.base_field_override.{entityType}.{bundle}.{field}`, when a Drush
  *      bridge is configured.
- *   3. If the definition cannot be resolved: return null. Creates keep the
+ *   4. If the definition cannot be resolved: return null. Creates keep the
  *      historical default chain only while the list is unknown. Updates reuse
  *      the format already stored on that field (#327) so a dry run cannot
  *      preview a fallback the save will reject. Once the list is known, never
@@ -22,6 +27,7 @@
  */
 
 import { drushConfigured } from "./audit-sources.js";
+import { textFormatDefinitionFromContext } from "./text-format-context.js";
 import { validateMachineName } from "./validate.js";
 import { parseDrush, sshDrush } from "../tools/drush.js";
 
@@ -137,15 +143,19 @@ export async function resolveFieldDefinition(backend, site, entityType, bundle,
   if (typeof backend?.getFieldDefinition === "function") {
     try {
       const def = await backend.getFieldDefinition({ entityType, bundle, fieldName });
-      if (def) return parseFieldConfigObject({
-        field_name: def.fieldName,
-        field_type: def.fieldType,
-        settings: { allowed_formats: def.allowedFormats },
-      }, fieldName) ?? def;
+      if (def?.fieldName === fieldName) {
+        return parseFieldConfigObject({
+          field_name: def.fieldName,
+          field_type: def.fieldType,
+          settings: { allowed_formats: def.allowedFormats },
+        }, fieldName) ?? def;
+      }
     } catch {
-      // JSON:API field_config is optional; try Drush next.
+      // JSON:API field_config is optional; try the next source.
     }
   }
+  const fromContext = textFormatDefinitionFromContext(site, entityType, bundle, fieldName);
+  if (fromContext) return fromContext;
   if (drushConfigured(site)) {
     const def = await fieldDefinitionFromDrush(site, entityType, bundle, fieldName);
     if (def) return def;
@@ -242,8 +252,19 @@ function requestedFormatOf(value) {
   return undefined;
 }
 
+/**
+ * @param {*} value
+ * @returns {string|undefined}
+ */
+function storedFormatName(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const format = new Map(Object.entries(value)).get("format");
+  return typeof format === "string" && format && format !== "0" ? format : undefined;
+}
+
 /**
  * Format Drupal already stored for a field, if the canonical entity has one.
+ * A one-element list is the JSON:API shape of a single-value text field.
  * @param {?object} entity
  * @param {string} fieldName
  * @returns {string|undefined}
@@ -252,9 +273,31 @@ function storedTextFormat(entity, fieldName) {
   const fields = entity?.fields;
   if (!fields || typeof fields !== "object" || Array.isArray(fields)) return undefined;
   const value = new Map(Object.entries(fields)).get(fieldName);
-  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const format = new Map(Object.entries(value)).get("format");
-  return typeof format === "string" && format && format !== "0" ? format : undefined;
+  if (Array.isArray(value)) {
+    if (value.length !== 1) return undefined;
+    return storedFormatName(value.at(0));
+  }
+  return storedFormatName(value);
+}
+
+/**
+ * A one-element JSON:API list omits its format when the only item is a
+ * string or a `{ value }` object without `format`. A longer list of bare
+ * strings is a list field, not an omitted text format. A formatted item
+ * inside a longer list still counts.
+ * @param {unknown[]} value
+ * @returns {boolean}
+ */
+function arrayOmitsTextFormat(value) {
+  if (value.length === 1) {
+    const item = value.at(0);
+    if (typeof item === "string") return true;
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    const hasValue = Object.prototype.hasOwnProperty.call(item, "value");
+    const hasFormat = Object.prototype.hasOwnProperty.call(item, "format") && item.format;
+    return hasValue && !hasFormat;
+  }
+  return value.some((item) => isFormattedShape(item) && !requestedFormatOf(item));
 }
 
 /**
@@ -267,8 +310,12 @@ export function attributesOmitTextFormat(attributes) {
   if (!attributes || typeof attributes !== "object") return false;
   for (const [name, value] of Object.entries(attributes)) {
     if (SKIP_FORMAT_FIELDS.has(name) || value === undefined || value === null) continue;
+    if (Array.isArray(value)) {
+      if (arrayOmitsTextFormat(value)) return true;
+      continue;
+    }
     if (typeof value === "string") return true;
-    if (typeof value === "object" && !Array.isArray(value)) {
+    if (typeof value === "object") {
       const hasValue = Object.prototype.hasOwnProperty.call(value, "value");
       const hasFormat = Object.prototype.hasOwnProperty.call(value, "format") && value.format;
       if ((name === "body" || hasValue) && !hasFormat) return true;
@@ -294,6 +341,44 @@ function normalizeFormattedValue(raw, format) {
   return out;
 }
 
+/**
+ * Resolve one formatted value, or return it unchanged when it is not text.
+ * @param {string} fieldName
+ * @param {*} value
+ * @param {?object} def
+ * @param {boolean} treatAsBody
+ * @param {object} site
+ * @param {?object} existingEntity
+ * @returns {*}
+ */
+function resolveFormattedItem(fieldName, value, def, treatAsBody, site, existingEntity) {
+  const formattedType = Boolean(def?.fieldType && FORMATTED_FIELD_TYPES.has(def.fieldType));
+  const restricted = Boolean(def?.allowedFormats?.length);
+  const shaped = isFormattedShape(value);
+  if (typeof value !== "string" && (typeof value !== "object" || value === null || Array.isArray(value))) {
+    return value;
+  }
+  if (def && !formattedType && !restricted && !treatAsBody) return value;
+  if (!def && !shaped && !treatAsBody) return value;
+
+  const allowedFormats = def ? def.allowedFormats : null;
+  const listUnknown = !Array.isArray(allowedFormats) || allowedFormats.length === 0;
+  let requested = requestedFormatOf(value);
+  if ((requested === undefined || requested === null || requested === "") && listUnknown) {
+    const stored = storedTextFormat(existingEntity, fieldName);
+    if (stored) requested = stored;
+  }
+  const format = resolveTextFormat({
+    fieldName,
+    requested,
+    allowedFormats,
+    site,
+    defaultWhenUnknown: treatAsBody,
+  });
+  if (format === undefined && !formattedType && !treatAsBody && !shaped) return value;
+  return normalizeFormattedValue(value, format);
+}
+
 /**
  * Default and validate text formats on a write attribute map (mutates it).
  * Same checks run for dry-run and real writes so a disallowed format never
@@ -303,46 +388,66 @@ function normalizeFormattedValue(raw, format) {
  * caller omitted a format, the format already stored on that field is reused.
  * The same choice is what dryRun previews and what the save sends (#327).
  *
- * @param {{backend: object, site: object, entityType: string, bundle: string, attributes: object, existingEntity?: ?object}} input
+ * `defaultBodyFormat` is true for the node tools, which keep the historical
+ * body fallback when the list is unknown. Other write tools pass false so a
+ * string body is not rewritten to `full_html`.
+ *
+ * A one-element array is checked too (#429). Callers sometimes send the
+ * JSON:API list shape for a single-value text field; skipping the array let
+ * a disallowed format through. An update that omits the format on that
+ * one-element shape reuses the stored format when the allowed list is unknown.
+ *
+ * @param {{backend: object, site: object, entityType: string, bundle: string, attributes: object, existingEntity?: ?object, defaultBodyFormat?: boolean}} input
  * @returns {Promise<object>} The same attributes object, with formats resolved.
  */
 export async function applyAllowedFormatsToAttributes({
   backend, site, entityType, bundle, attributes, existingEntity = null,
+  defaultBodyFormat = true,
 }) {
   const names = Object.keys(attributes).filter((name) => !SKIP_FORMAT_FIELDS.has(name));
   for (const fieldName of names) {
     const value = new Map(Object.entries(attributes)).get(fieldName);
     if (value === undefined || value === null) continue;
-    if (typeof value !== "string" && (typeof value !== "object" || Array.isArray(value))) continue;
-
+    if (!Array.isArray(value) && typeof value !== "string" && typeof value !== "object") continue;
+    const treatAsBody = defaultBodyFormat && fieldName === "body";
     const def = await resolveFieldDefinition(backend, site, entityType, bundle, fieldName);
-    const formattedType = Boolean(def?.fieldType && FORMATTED_FIELD_TYPES.has(def.fieldType));
-    const restricted = Boolean(def?.allowedFormats?.length);
-    const isBody = fieldName === "body";
-    const shaped = isFormattedShape(value);
-
-    if (def && !formattedType && !restricted && !isBody) continue;
-    if (!def && !shaped && !isBody) continue;
-
-    const allowedFormats = def ? def.allowedFormats : null;
-    const listUnknown = !Array.isArray(allowedFormats) || allowedFormats.length === 0;
-    let requested = requestedFormatOf(value);
-    if ((requested === undefined || requested === null || requested === "") && listUnknown) {
-      const stored = storedTextFormat(existingEntity, fieldName);
-      if (stored) requested = stored;
+    if (Array.isArray(value)) {
+      const formattedType = Boolean(def?.fieldType && FORMATTED_FIELD_TYPES.has(def.fieldType));
+      const restricted = Boolean(def?.allowedFormats?.length);
+      const anyShaped = value.some((item) => isFormattedShape(item));
+      if (!formattedType && !restricted && !treatAsBody && !anyShaped) continue;
+      const next = value.map((item) => resolveFormattedItem(
+        fieldName, item, def, treatAsBody, site, existingEntity,
+      ));
+      Object.assign(attributes, Object.fromEntries([[fieldName, next]]));
+      continue;
+    }
+    if (typeof value !== "string" && typeof value !== "object") continue;
+    const next = resolveFormattedItem(fieldName, value, def, treatAsBody, site, existingEntity);
+    if (next !== value) {
+      Object.assign(attributes, Object.fromEntries([[fieldName, next]]));
     }
-    const format = resolveTextFormat({
-      fieldName,
-      requested,
-      allowedFormats,
-      site,
-      defaultWhenUnknown: isBody,
-    });
-
-    if (format === undefined && !formattedType && !isBody && !shaped) continue;
-    Object.assign(attributes, Object.fromEntries([
-      [fieldName, normalizeFormattedValue(value, format)],
-    ]));
   }
   return attributes;
 }
+
+/**
+ * Validate text formats on caller-supplied paragraph attributes.
+ * Paragraph writes do not invent `full_html`. Do not pass attributes copied
+ * from an existing paragraph: those already have the stored format.
+ * @param {object} backend
+ * @param {object} site
+ * @param {string} bundle Paragraph bundle machine name.
+ * @param {object} attributes Mutated in place.
+ * @returns {Promise<object>}
+ */
+export function applyParagraphTextFormats(backend, site, bundle, attributes) {
+  return applyAllowedFormatsToAttributes({
+    backend,
+    site,
+    entityType: "paragraph",
+    bundle,
+    attributes,
+    defaultBodyFormat: false,
+  });
+}