drupal-mcp-connector 1.8.1 → 2.1.0

package/src/tools/nodes.js

@@ -9,7 +9,11 @@
 
 import { getSiteConfig } from "../lib/config.js";
 import { resolveBackend } from "../lib/backends/index.js";
-import { resolveSecurityConfig, redactCanonicalEntity, assertWriteAllowed, assertPublishAllowed } from "../lib/security.js";
+import {
+  resolveSecurityConfig, redactCanonicalEntity,
+  assertReadAllowed, assertWriteAllowed, assertDeleteAllowed, assertPublishAllowed,
+} from "../lib/security.js";
+import { applySafeDraftDefault } from "../lib/moderation-default.js";
 import { shapeWriteResponse, RETURNING_SCHEMA } from "../lib/entity-response.js";
 import { buildRedirectAttributes, REDIRECT_ENTITY_TYPE } from "./redirects.js";
 
@@ -156,6 +160,7 @@ function pageOf({ limit = 20, offset = 0 }) {
 async function getNode({ site: siteName, type, id }) {
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
+  assertReadAllowed(sec, "node", type);
   const backend = await resolveBackend(site);
   const entity = await backend.getEntity({ entityType: "node", bundle: type, id });
   return entity ? redactCanonicalEntity(entity, sec, "node") : null;
@@ -172,6 +177,7 @@ async function getNode({ site: siteName, type, id }) {
 async function listNodes({ site: siteName, type, status, filters = [], limit = 20, offset = 0, sort = [{ field: "changed", dir: "desc" }] }) {
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
+  assertReadAllowed(sec, "node", type);
   const backend = await resolveBackend(site);
   const allFilters = [...filters];
   if (status !== undefined) allFilters.push({ field: "status", op: "eq", value: status });
@@ -195,10 +201,12 @@ async function listNodes({ site: siteName, type, status, filters = [], limit = 2
 async function searchContent({ site: siteName, query, type, status, limit = 10 }) {
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
+  const bundle = type || "article";
+  assertReadAllowed(sec, "node", bundle);
   const backend = await resolveBackend(site);
   const filters = [{ field: "title", op: "contains", value: query }];
   if (status !== undefined) filters.push({ field: "status", op: "eq", value: status });
-  const res = await backend.listEntities({ entityType: "node", bundle: type || "article", filters, sort: [{ field: "changed", dir: "desc" }], page: { limit } });
+  const res = await backend.listEntities({ entityType: "node", bundle, filters, sort: [{ field: "changed", dir: "desc" }], page: { limit } });
   return res.entities.map((e) => redactCanonicalEntity(e, sec, "node"));
 }
 
@@ -225,6 +233,8 @@ async function searchContent({ site: siteName, query, type, status, limit = 10 }
  */
 async function createNode({ site: siteName, type, title, body, summary, status, moderationState, fields = {}, relationships = {}, dryRun = false, returning = "full" }) {
   const site = getSiteConfig(siteName);
+  const sec = resolveSecurityConfig(site);
+  assertWriteAllowed(sec, "create", "node", type);
   const attributes = { title, ...fields };
   if (moderationState !== undefined) {
     attributes.moderation_state = moderationState;
@@ -233,7 +243,7 @@ async function createNode({ site: siteName, type, title, body, summary, status,
   }
   const bodyAttr = buildBodyAttribute(body, summary);
   if (bodyAttr) attributes.body = bodyAttr;
-  assertPublishAllowed(resolveSecurityConfig(site), attributes);
+  assertPublishAllowed(sec, attributes);
   if (dryRun) return { dryRun: true, operation: "create", entityType: "node", bundle: type, attributes, relationships };
   const backend = await resolveBackend(site);
   // Alias handling: an explicit `path.alias` is set as a manual alias; otherwise
@@ -256,6 +266,11 @@ async function createNode({ site: siteName, type, title, body, summary, status,
  * bundles (sends `moderation_state`, omits `status`) or `status` for non-moderated
  * types. `moderationState` takes precedence; both are optional on update.
  *
+ * Safe default (#131): when the target is a *published* moderated node and the
+ * caller did not pass `moderationState` / `moderation_state`, the write is
+ * forced to `moderation_state: draft` so it becomes a forward revision rather
+ * than mutating the live default revision. Opt out by passing an explicit state.
+ *
  * Alias hardening: a partial update that doesn't touch `path` can still lose the
  * node's URL alias when a module (e.g. Pathauto, in automatic mode) regenerates
  * it on save. To preserve the existing alias, when the caller supplies no `path`
@@ -269,16 +284,22 @@ async function createNode({ site: siteName, type, title, body, summary, status,
  */
 async function updateNode({ site: siteName, type, id, title, body, summary, status, moderationState, fields = {}, relationships = {}, dryRun = false, returning = "full" }) {
   const site = getSiteConfig(siteName);
-  const attributes = { ...fields };
+  const sec = resolveSecurityConfig(site);
+  assertWriteAllowed(sec, "update", "node", type);
+  const backend = await resolveBackend(site);
+  let attributes = { ...fields };
   if (title !== undefined) attributes.title = title;
   if (moderationState !== undefined) attributes.moderation_state = moderationState;
   else if (status !== undefined) attributes.status = status;
   const bodyAttr = buildBodyAttribute(body, summary);
   if (bodyAttr) attributes.body = bodyAttr;
-  assertPublishAllowed(resolveSecurityConfig(site), attributes);
+  // #131: published moderated nodes without an explicit state → draft forward revision.
+  // Runs before the publish gate and on dryRun so previews match the real write.
+  attributes = await applySafeDraftDefault({
+    backend, entityType: "node", bundle: type, id, attributes,
+  });
+  assertPublishAllowed(sec, attributes);
   if (dryRun) return { dryRun: true, operation: "update", entityType: "node", bundle: type, id, attributes, relationships };
-  const backend = await resolveBackend(site);
-  const sec = resolveSecurityConfig(site);
   // Alias handling (DEV-116): an explicit `path.alias` is set in place by
   // round-tripping the existing alias's pid (no duplicate); a path-less update
   // re-pins the current alias *with its pid* so the save can't revert/duplicate
@@ -304,6 +325,8 @@ async function updateNode({ site: siteName, type, id, title, body, summary, stat
  */
 async function deleteNode({ site: siteName, type, id, dryRun = false }) {
   const site = getSiteConfig(siteName);
+  const sec = resolveSecurityConfig(site);
+  assertDeleteAllowed(sec, "node", type, id);
   if (dryRun) return { dryRun: true, operation: "delete", entityType: "node", bundle: type, id };
   const backend = await resolveBackend(site);
   await backend.deleteEntity({ entityType: "node", bundle: type, id });
@@ -379,7 +402,7 @@ export const definitions = [
   },
   {
     name: "drupal_update_node",
-    description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. Entity-reference fields go in `relationships`, not `fields`.",
+    description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Entity-reference fields go in `relationships`, not `fields`.",
     inputSchema: {
       type: "object", required: ["type", "id"],
       properties: {
@@ -390,7 +413,7 @@ export const definitions = [
         body:    { type: "string" },
         summary: { type: "string" },
         status:  { type: "boolean", description: "Published flag for NON-moderated types: true = publish, false = unpublish. Ignored if moderationState is set." },
-        moderationState: { type: "string", description: "Moderation state transition for content_moderation types, e.g. 'draft', 'published', 'archived'. Takes precedence over status." },
+        moderationState: { type: "string", description: "Moderation state transition for content_moderation types, e.g. 'draft', 'published', 'archived'. Takes precedence over status. Required to keep or re-publish a live node — omitting it on a published moderated node defaults the write to 'draft'." },
         fields:  { type: "object", description: "Scalar/attribute field values keyed by machine name. Entity-reference fields go in `relationships`, not here." },
         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 }, …] }." },
         dryRun:  { type: "boolean", default: false, description: "Validate and return a preview of the update without committing." },

package/src/tools/redirects.js

@@ -19,11 +19,15 @@
  *   - `status_code` defaults to 301 and can be set to 302 (or another redirect
  *     code) explicitly on create, and changed on an existing redirect via update.
  *
- * Redirect entities have no separate enabled/disabled flag — a redirect with a
- * valid source is active. "Enable an existing redirect" therefore means: correct
- * its fields so it matches and fires, which is exactly what drupal_update_redirect
- * does. Both tools are governed: writes assert create/update permission for the
- * `redirect` entity type against the per-site security policy.
+ * Redirect module ≥ dev-1.x makes redirects publishable: an `enabled` base field
+ * (the published key) decides whether the redirect fires. This connector does not
+ * send `enabled` — sites govern that flag server-side (mcp_sentinel's publish
+ * gate exempted it as routing metadata as of its post-1.9 release; on older
+ * sentinel releases a deny-publish profile silently disables agent-created
+ * redirects — verify `enabled` after create on such sites). On pre-publishable
+ * redirect releases the field is absent and every redirect with a valid source
+ * is active. Both tools are governed: writes assert create/update permission for
+ * the `redirect` entity type against the per-site security policy.
  */
 
 import { getSiteConfig } from "../lib/config.js";

package/src/tools/taxonomy.js

@@ -8,7 +8,10 @@
 
 import { getSiteConfig } from "../lib/config.js";
 import { resolveBackend } from "../lib/backends/index.js";
-import { resolveSecurityConfig, redactCanonicalEntity } from "../lib/security.js";
+import {
+  resolveSecurityConfig, redactCanonicalEntity,
+  assertReadAllowed, assertWriteAllowed, assertDeleteAllowed,
+} from "../lib/security.js";
 
 // ---------------------------------------------------------------------------
 // Implementations
@@ -22,6 +25,7 @@ import { resolveSecurityConfig, redactCanonicalEntity } from "../lib/security.js
  */
 async function listVocabularies({ site: siteName }) {
   const site = getSiteConfig(siteName);
+  assertReadAllowed(resolveSecurityConfig(site), "taxonomy_term");
   const backend = await resolveBackend(site);
   return backend.listBundles("taxonomy_term");
 }
@@ -35,6 +39,7 @@ async function listVocabularies({ site: siteName }) {
 async function getTaxonomyTerms({ site: siteName, vocabulary, limit = 50, offset = 0 }) {
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
+  assertReadAllowed(sec, "taxonomy_term", vocabulary);
   const backend = await resolveBackend(site);
   const res = await backend.listEntities({
     entityType: "taxonomy_term", bundle: vocabulary,
@@ -56,6 +61,7 @@ async function getTaxonomyTerms({ site: siteName, vocabulary, limit = 50, offset
 async function getTaxonomyTerm({ site: siteName, vocabulary, id }) {
   const site = getSiteConfig(siteName);
   const sec = resolveSecurityConfig(site);
+  assertReadAllowed(sec, "taxonomy_term", vocabulary);
   const backend = await resolveBackend(site);
   const entity = await backend.getEntity({ entityType: "taxonomy_term", bundle: vocabulary, id });
   return entity ? redactCanonicalEntity(entity, sec, "taxonomy_term") : null;
@@ -70,6 +76,7 @@ async function getTaxonomyTerm({ site: siteName, vocabulary, id }) {
  */
 async function createTaxonomyTerm({ site: siteName, vocabulary, name, description, weight = 0, parentId }) {
   const site = getSiteConfig(siteName);
+  assertWriteAllowed(resolveSecurityConfig(site), "create", "taxonomy_term", vocabulary);
   const backend = await resolveBackend(site);
   const attributes = { name, weight };
   if (description !== undefined) attributes.description = { value: description, format: "plain_text" };
@@ -88,6 +95,7 @@ async function createTaxonomyTerm({ site: siteName, vocabulary, name, descriptio
  */
 async function updateTaxonomyTerm({ site: siteName, vocabulary, id, name, description, weight }) {
   const site = getSiteConfig(siteName);
+  assertWriteAllowed(resolveSecurityConfig(site), "update", "taxonomy_term", vocabulary);
   const backend = await resolveBackend(site);
   const attributes = {};
   if (name !== undefined) attributes.name = name;
@@ -105,6 +113,7 @@ async function updateTaxonomyTerm({ site: siteName, vocabulary, id, name, descri
  */
 async function deleteTaxonomyTerm({ site: siteName, vocabulary, id }) {
   const site = getSiteConfig(siteName);
+  assertDeleteAllowed(resolveSecurityConfig(site), "taxonomy_term", vocabulary, id);
   const backend = await resolveBackend(site);
   await backend.deleteEntity({ entityType: "taxonomy_term", bundle: vocabulary, id });
   return { success: true, deletedId: id };