@contentful/mcp-tools 0.12.14 → 0.12.15

package/README.md

@@ -134,6 +134,10 @@ Each tool includes semantic annotations to help MCP clients understand tool beha
 |                           | `validate_release`                 | Validate a release, optionally against publish/unpublish                                  |
 |                           | `get_release_action`               | Check the status of a queued release action                                               |
 |                           | `list_release_actions`             | List release actions (max 10 per request)                                                 |
+|                           | `schedule_publish_release`         | Schedule a release to publish at a future datetime (or reschedule)                        |
+|                           | `schedule_unpublish_release`       | Schedule a release to unpublish at a future datetime (or reschedule)                      |
+|                           | `cancel_scheduled_release`         | Cancel a scheduled release action (two-phase confirm)                                     |
+|                           | `list_scheduled_actions`           | List scheduled actions (max 10 per request)                                               |
 | **AI Actions**            | `create_ai_action`                 | Create custom AI-powered workflows                                                        |
 |                           | `invoke_ai_action`                 | Invoke AI action with variables (bulk support)                                            |
 |                           | `get_ai_action_invocation`         | Get AI action invocation details                                                          |

package/dist/index.d.ts

@@ -8639,6 +8639,113 @@ declare class ContentfulMcpTools {
                 action?: "publish" | "unpublish" | "validate" | undefined;
             }, extra?: _modelcontextprotocol_sdk_shared_protocol_js.RequestHandlerExtra<_modelcontextprotocol_sdk_types_js.ServerRequest, _modelcontextprotocol_sdk_types_js.ServerNotification>) => Promise<ToolResponse>;
         };
+        schedulePublishRelease: {
+            title: string;
+            description: string;
+            inputParams: {
+                spaceId: zod.ZodString;
+                environmentId: zod.ZodString;
+            } & {
+                releaseId: zod.ZodString;
+                datetime: zod.ZodString;
+                timezone: zod.ZodOptional<zod.ZodEffects<zod.ZodString, string, string>>;
+                scheduledActionId: zod.ZodOptional<zod.ZodString>;
+            };
+            annotations: {
+                readOnlyHint: boolean;
+                destructiveHint: boolean;
+                idempotentHint: boolean;
+                openWorldHint: boolean;
+            };
+            tool: (params: {
+                spaceId: string;
+                environmentId: string;
+                releaseId: string;
+                datetime: string;
+                timezone?: string | undefined;
+                scheduledActionId?: string | undefined;
+            }, extra?: _modelcontextprotocol_sdk_shared_protocol_js.RequestHandlerExtra<_modelcontextprotocol_sdk_types_js.ServerRequest, _modelcontextprotocol_sdk_types_js.ServerNotification>) => Promise<ToolResponse>;
+        };
+        scheduleUnpublishRelease: {
+            title: string;
+            description: string;
+            inputParams: {
+                spaceId: zod.ZodString;
+                environmentId: zod.ZodString;
+            } & {
+                releaseId: zod.ZodString;
+                datetime: zod.ZodString;
+                timezone: zod.ZodOptional<zod.ZodEffects<zod.ZodString, string, string>>;
+                scheduledActionId: zod.ZodOptional<zod.ZodString>;
+            };
+            annotations: {
+                readOnlyHint: boolean;
+                destructiveHint: boolean;
+                idempotentHint: boolean;
+                openWorldHint: boolean;
+            };
+            tool: (params: {
+                spaceId: string;
+                environmentId: string;
+                releaseId: string;
+                datetime: string;
+                timezone?: string | undefined;
+                scheduledActionId?: string | undefined;
+            }, extra?: _modelcontextprotocol_sdk_shared_protocol_js.RequestHandlerExtra<_modelcontextprotocol_sdk_types_js.ServerRequest, _modelcontextprotocol_sdk_types_js.ServerNotification>) => Promise<ToolResponse>;
+        };
+        cancelScheduledRelease: {
+            title: string;
+            description: string;
+            inputParams: {
+                spaceId: zod.ZodString;
+                environmentId: zod.ZodString;
+            } & {
+                releaseId: zod.ZodString;
+                scheduledActionId: zod.ZodString;
+                confirm: zod.ZodOptional<zod.ZodBoolean>;
+                confirmToken: zod.ZodOptional<zod.ZodString>;
+            };
+            annotations: {
+                readOnlyHint: boolean;
+                destructiveHint: boolean;
+                idempotentHint: boolean;
+                openWorldHint: boolean;
+            };
+            tool: (params: {
+                spaceId: string;
+                environmentId: string;
+                releaseId: string;
+                scheduledActionId: string;
+                confirmToken?: string | undefined;
+                confirm?: boolean | undefined;
+            }, extra?: _modelcontextprotocol_sdk_shared_protocol_js.RequestHandlerExtra<_modelcontextprotocol_sdk_types_js.ServerRequest, _modelcontextprotocol_sdk_types_js.ServerNotification>) => Promise<ToolResponse>;
+        };
+        listScheduledActions: {
+            title: string;
+            description: string;
+            inputParams: {
+                spaceId: zod.ZodString;
+                environmentId: zod.ZodString;
+            } & {
+                releaseId: zod.ZodOptional<zod.ZodString>;
+                statusIn: zod.ZodOptional<zod.ZodString>;
+                statusNin: zod.ZodOptional<zod.ZodString>;
+                limit: zod.ZodOptional<zod.ZodNumber>;
+            };
+            annotations: {
+                readOnlyHint: boolean;
+                destructiveHint: boolean;
+                openWorldHint: boolean;
+            };
+            tool: (params: {
+                spaceId: string;
+                environmentId: string;
+                releaseId?: string | undefined;
+                limit?: number | undefined;
+                statusIn?: string | undefined;
+                statusNin?: string | undefined;
+            }, extra?: _modelcontextprotocol_sdk_shared_protocol_js.RequestHandlerExtra<_modelcontextprotocol_sdk_types_js.ServerRequest, _modelcontextprotocol_sdk_types_js.ServerNotification>) => Promise<ToolResponse>;
+        };
     };
     /**
      * Get tag tools

package/dist/index.js

@@ -393,7 +393,8 @@ var RESOURCE_DISPLAY_NAME = {
   experienceTemplate: "experience template",
   dataAssembly: "data assembly",
   designToken: "design token",
-  release: "release"
+  release: "release",
+  scheduledAction: "scheduled action"
 };
 function buildConfirmationPreview(resource, id, details, confirmToken) {
   const displayName = RESOURCE_DISPLAY_NAME[resource];
@@ -9192,6 +9193,276 @@ function listReleaseActionsTool(config) {
   return withErrorHandling(tool2, "Error listing release actions");
 }
 
+// src/tools/releases/scheduleReleasePublish.ts
+import { z as z139 } from "zod";
+var SchedulePublishReleaseToolParams = BaseToolSchema.extend({
+  releaseId: z139.string().describe("The ID of the release to schedule for publish"),
+  datetime: z139.string().datetime({ offset: true }).describe("The ISO 8601 datetime at which the release should publish"),
+  timezone: z139.string().refine((timezone) => {
+    try {
+      Intl.DateTimeFormat("en-US", { timeZone: timezone }).format(0);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Must be a valid IANA timezone identifier").optional().describe("A valid IANA timezone identifier (e.g. Asia/Kolkata)"),
+  scheduledActionId: z139.string().optional().describe(
+    "Provide to reschedule an existing scheduled action instead of creating a new one"
+  )
+});
+function schedulePublishReleaseTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    if (args.scheduledActionId) {
+      const existing = await contentfulClient.scheduledActions.get({
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        scheduledActionId: args.scheduledActionId
+      });
+      if (existing.action !== "publish") {
+        throw new Error(
+          `Scheduled action '${args.scheduledActionId}' is a '${existing.action}' action, not 'publish'.`
+        );
+      }
+      if (existing.entity.sys.id !== args.releaseId) {
+        throw new Error(
+          `Scheduled action '${args.scheduledActionId}' targets release '${existing.entity.sys.id}', not '${args.releaseId}'.`
+        );
+      }
+      const scheduledAction2 = await contentfulClient.scheduledActions.update(
+        {
+          spaceId: args.spaceId,
+          scheduledActionId: args.scheduledActionId,
+          version: existing.sys.version
+        },
+        {
+          action: "publish",
+          entity: existing.entity,
+          environment: existing.environment,
+          scheduledFor: {
+            datetime: args.datetime,
+            timezone: args.timezone
+          }
+        }
+      );
+      return createSuccessResponse(
+        "Scheduled release publish rescheduled successfully",
+        { scheduledAction: scheduledAction2 }
+      );
+    }
+    const scheduledAction = await contentfulClient.scheduledActions.create(
+      { spaceId: args.spaceId },
+      {
+        entity: {
+          sys: { type: "Link", linkType: "Release", id: args.releaseId }
+        },
+        environment: {
+          sys: {
+            type: "Link",
+            linkType: "Environment",
+            id: args.environmentId
+          }
+        },
+        action: "publish",
+        scheduledFor: {
+          datetime: args.datetime,
+          timezone: args.timezone
+        }
+      }
+    );
+    return createSuccessResponse("Release publish scheduled successfully", {
+      scheduledAction
+    });
+  }
+  return withErrorHandling(tool2, "Error scheduling release publish");
+}
+
+// src/tools/releases/scheduleReleaseUnpublish.ts
+import { z as z140 } from "zod";
+var ScheduleUnpublishReleaseToolParams = BaseToolSchema.extend({
+  releaseId: z140.string().describe("The ID of the release to schedule for unpublish"),
+  datetime: z140.string().datetime({ offset: true }).describe("The ISO 8601 datetime at which the release should unpublish"),
+  timezone: z140.string().refine((timezone) => {
+    try {
+      Intl.DateTimeFormat("en-US", { timeZone: timezone }).format(0);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Must be a valid IANA timezone identifier").optional().describe("A valid IANA timezone identifier (e.g. Asia/Kolkata)"),
+  scheduledActionId: z140.string().optional().describe(
+    "Provide to reschedule an existing scheduled action instead of creating a new one"
+  )
+});
+function scheduleUnpublishReleaseTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    if (args.scheduledActionId) {
+      const existing = await contentfulClient.scheduledActions.get({
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        scheduledActionId: args.scheduledActionId
+      });
+      if (existing.action !== "unpublish") {
+        throw new Error(
+          `Scheduled action '${args.scheduledActionId}' is a '${existing.action}' action, not 'unpublish'.`
+        );
+      }
+      if (existing.entity.sys.id !== args.releaseId) {
+        throw new Error(
+          `Scheduled action '${args.scheduledActionId}' targets release '${existing.entity.sys.id}', not '${args.releaseId}'.`
+        );
+      }
+      const scheduledAction2 = await contentfulClient.scheduledActions.update(
+        {
+          spaceId: args.spaceId,
+          scheduledActionId: args.scheduledActionId,
+          version: existing.sys.version
+        },
+        {
+          action: "unpublish",
+          entity: existing.entity,
+          environment: existing.environment,
+          scheduledFor: {
+            datetime: args.datetime,
+            timezone: args.timezone
+          }
+        }
+      );
+      return createSuccessResponse(
+        "Scheduled release unpublish rescheduled successfully",
+        { scheduledAction: scheduledAction2 }
+      );
+    }
+    const scheduledAction = await contentfulClient.scheduledActions.create(
+      { spaceId: args.spaceId },
+      {
+        entity: {
+          sys: { type: "Link", linkType: "Release", id: args.releaseId }
+        },
+        environment: {
+          sys: {
+            type: "Link",
+            linkType: "Environment",
+            id: args.environmentId
+          }
+        },
+        action: "unpublish",
+        scheduledFor: {
+          datetime: args.datetime,
+          timezone: args.timezone
+        }
+      }
+    );
+    return createSuccessResponse("Release unpublish scheduled successfully", {
+      scheduledAction
+    });
+  }
+  return withErrorHandling(tool2, "Error scheduling release unpublish");
+}
+
+// src/tools/releases/cancelScheduledRelease.ts
+import { z as z141 } from "zod";
+var CancelScheduledReleaseToolParams = BaseToolSchema.extend({
+  releaseId: z141.string().describe("The ID of the release the scheduled action belongs to"),
+  scheduledActionId: z141.string().describe("The ID of the scheduled action to cancel"),
+  confirm: z141.boolean().optional().describe(
+    "Set to true on the second call to actually cancel the scheduled action. Required together with confirmToken."
+  ),
+  confirmToken: z141.string().optional().describe(
+    "Token returned by the preview call; must be supplied with confirm: true."
+  )
+});
+function cancelScheduledReleaseTool(config) {
+  async function tool2(args) {
+    assertEnvironmentNotProtected(
+      args.environmentId,
+      config.protectedEnvironments
+    );
+    const contentfulClient = createToolClient(config, args);
+    const scheduledAction = await contentfulClient.scheduledActions.get({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      scheduledActionId: args.scheduledActionId
+    });
+    if (scheduledAction.entity.sys.id !== args.releaseId) {
+      throw new Error(
+        `Scheduled action '${args.scheduledActionId}' targets release '${scheduledAction.entity.sys.id}', not '${args.releaseId}'.`
+      );
+    }
+    const expectedToken = buildConfirmToken(
+      "scheduledAction",
+      args.scheduledActionId,
+      scheduledAction.sys.version
+    );
+    if (args.confirm !== true || args.confirmToken !== expectedToken) {
+      const preview = buildConfirmationPreview(
+        "scheduledAction",
+        args.scheduledActionId,
+        { scheduledAction },
+        expectedToken
+      );
+      return createSuccessResponse(
+        `${CONFIRMATION_MESSAGE_PREFIX} scheduled action`,
+        preview
+      );
+    }
+    await contentfulClient.scheduledActions.delete({
+      spaceId: args.spaceId,
+      environmentId: args.environmentId,
+      scheduledActionId: args.scheduledActionId
+    });
+    return createSuccessResponse(
+      "Scheduled release action canceled successfully",
+      { scheduledAction }
+    );
+  }
+  return withErrorHandling(tool2, "Error canceling scheduled release action");
+}
+
+// src/tools/releases/listScheduledActions.ts
+import { z as z142 } from "zod";
+var MAX_ITEMS3 = 10;
+var ListScheduledActionsToolParams = BaseToolSchema.extend({
+  releaseId: z142.string().optional().describe("Filter by the release this scheduled action targets"),
+  statusIn: z142.string().optional().describe(
+    "Comma-separated list of statuses to include (scheduled, inProgress, succeeded, failed, canceled)"
+  ),
+  statusNin: z142.string().optional().describe("Comma-separated list of statuses to exclude"),
+  limit: z142.number().optional().describe("Maximum number of scheduled actions to return (max 10)")
+});
+function listScheduledActionsTool(config) {
+  async function tool2(args) {
+    const contentfulClient = createToolClient(config, args);
+    const scheduledActions = await contentfulClient.scheduledActions.getMany({
+      spaceId: args.spaceId,
+      query: {
+        "environment.sys.id": args.environmentId,
+        limit: Math.max(1, Math.min(args.limit ?? MAX_ITEMS3, MAX_ITEMS3)),
+        ...args.releaseId && { "entity.sys.id": args.releaseId },
+        ...args.statusIn && { "sys.status[in]": args.statusIn },
+        ...args.statusNin && { "sys.status[nin]": args.statusNin }
+      }
+    });
+    const summarized = summarizeData(scheduledActions, {
+      maxItems: MAX_ITEMS3,
+      remainingMessage: "To see more scheduled actions, narrow your filters or ask for a smaller limit."
+    });
+    return createSuccessResponse("Scheduled actions retrieved successfully", {
+      scheduledActions: summarized
+    });
+  }
+  return withErrorHandling(tool2, "Error listing scheduled actions");
+}
+
 // src/tools/releases/register.ts
 function createReleaseTools(config) {
   const listReleases = listReleasesTool(config);
@@ -9204,6 +9475,10 @@ function createReleaseTools(config) {
   const validateRelease = validateReleaseTool(config);
   const getReleaseAction = getReleaseActionTool(config);
   const listReleaseActions = listReleaseActionsTool(config);
+  const schedulePublishRelease = schedulePublishReleaseTool(config);
+  const scheduleUnpublishRelease = scheduleUnpublishReleaseTool(config);
+  const cancelScheduledRelease = cancelScheduledReleaseTool(config);
+  const listScheduledActions = listScheduledActionsTool(config);
   return {
     listReleases: {
       title: "list_releases",
@@ -9320,6 +9595,53 @@ function createReleaseTools(config) {
         openWorldHint: false
       },
       tool: listReleaseActions
+    },
+    schedulePublishRelease: {
+      title: "schedule_publish_release",
+      description: "Schedule a release to publish at a future datetime, or reschedule an existing scheduled publish action by providing scheduledActionId.",
+      inputParams: SchedulePublishReleaseToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: schedulePublishRelease
+    },
+    scheduleUnpublishRelease: {
+      title: "schedule_unpublish_release",
+      description: "Schedule a release to unpublish at a future datetime, or reschedule an existing scheduled unpublish action by providing scheduledActionId.",
+      inputParams: ScheduleUnpublishReleaseToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: scheduleUnpublishRelease
+    },
+    cancelScheduledRelease: {
+      title: "cancel_scheduled_release",
+      description: "Cancel a scheduled release action. This is a two-phase operation: the first call (without confirm/confirmToken) returns a preview of the scheduled action and a confirmToken. To complete the cancellation, call this tool again with the same scheduledActionId, confirm: true, and the confirmToken from the preview response.",
+      inputParams: CancelScheduledReleaseToolParams.shape,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      tool: cancelScheduledRelease
+    },
+    listScheduledActions: {
+      title: "list_scheduled_actions",
+      description: "List scheduled actions in a space/environment. Returns a maximum of 10 items per request. Optionally filter by release ID or status.",
+      inputParams: ListScheduledActionsToolParams.shape,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      tool: listScheduledActions
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/mcp-tools",
-  "version": "0.12.14",
+  "version": "0.12.15",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",