@contentful/mcp-server 1.0.0

package/build/tools/entries/getEntry.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const GetEntryToolParams = BaseToolSchema.extend({
+    entryId: z.string().describe('The ID of the entry to retrieve'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        entryId: args.entryId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get the entry
+    const entry = await contentfulClient.entry.get(params);
+    return createSuccessResponse('Entry retrieved successfully', { entry });
+}
+export const getEntryTool = withErrorHandling(tool, 'Error retrieving entry');

package/build/tools/entries/publishEntry.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createEntryVersionedLinks, createEntitiesCollection, waitForBulkActionCompletion, } from '../../utils/bulkOperations.js';
+export const PublishEntryToolParams = BaseToolSchema.extend({
+    entryId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the entry to publish (string) or an array of entry IDs (up to 100 entries)'),
+});
+async function tool(args) {
+    const baseParams = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Normalize input to always be an array
+    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+    // For single entry, use individual publish for simplicity
+    if (entryIds.length === 1) {
+        try {
+            const entryId = entryIds[0];
+            const params = {
+                ...baseParams,
+                entryId,
+            };
+            // Get the entry first
+            const entry = await contentfulClient.entry.get(params);
+            // Publish the entry
+            const publishedEntry = await contentfulClient.entry.publish(params, entry);
+            return createSuccessResponse('Entry published successfully', {
+                status: publishedEntry.sys.status,
+                entryId,
+            });
+        }
+        catch (error) {
+            return createSuccessResponse('Entry publish failed', {
+                status: error,
+                entryId: entryIds[0],
+            });
+        }
+    }
+    // For multiple entries, use bulk action API
+    // Get the current version of each entry
+    const entityVersions = await createEntryVersionedLinks(contentfulClient, baseParams, entryIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(entityVersions);
+    // Create the bulk action
+    const bulkAction = await contentfulClient.bulkAction.publish(baseParams, {
+        entities: entitiesCollection,
+    });
+    // Wait for the bulk action to complete
+    const action = await waitForBulkActionCompletion(contentfulClient, baseParams, bulkAction.sys.id);
+    return createSuccessResponse('Entry(s) published successfully', {
+        status: action.sys.status,
+        entryIds,
+    });
+}
+export const publishEntryTool = withErrorHandling(tool, 'Error publishing entry');

package/build/tools/entries/register.js

@@ -0,0 +1,16 @@
+import { searchEntriesTool, SearchEntriesToolParams } from './searchEntries.js';
+import { createEntryTool, CreateEntryToolParams } from './createEntry.js';
+import { deleteEntryTool, DeleteEntryToolParams } from './deleteEntry.js';
+import { updateEntryTool, UpdateEntryToolParams } from './updateEntry.js';
+import { getEntryTool, GetEntryToolParams } from './getEntry.js';
+import { publishEntryTool, PublishEntryToolParams } from './publishEntry.js';
+import { unpublishEntryTool, UnpublishEntryToolParams, } from './unpublishEntry.js';
+export function registerEntriesTools(server) {
+    server.tool('search_entries', 'Search for specific entries in your Contentful space', SearchEntriesToolParams.shape, searchEntriesTool);
+    server.tool('create_entry', "Create a new entry in Contentful. Before executing this function, you need to know the contentTypeId (not the content type NAME) and the fields of that contentType. You can get the fields definition by using the GET_CONTENT_TYPE tool. IMPORTANT: All field values MUST include a locale key (e.g., 'en-US') for each value, like: { title: { 'en-US': 'My Title' } }. Every field in Contentful requires a locale even for single-language content. TAGS: To add tags to an entry, include a metadata object with a tags array. Each tag should be an object with sys.type='Link', sys.linkType='Tag', and sys.id='tagId'. Example: { metadata: { tags: [{ sys: { type: 'Link', linkType: 'Tag', id: 'myTagId' } }] } }.", CreateEntryToolParams.shape, createEntryTool);
+    server.tool('get_entry', 'Retrieve an existing entry', GetEntryToolParams.shape, getEntryTool);
+    server.tool('update_entry', "Update an existing entry. The handler will merge your field updates with the existing entry fields, so you only need to provide the fields you want to change. However, for multiple-locale fields, all existing locales must be included in the update. IMPORTANT: All field values MUST include a locale key (e.g., 'en-US') for each value, like: { title: { 'en-US': 'My Updated Title' } }. Every field in Contentful requires a locale even for single-language content. When updating entries with multiple locales, always include all existing locales in the update to prevent overwriting with empty values. RICH TEXT FIELDS: When updating rich text fields, ALL text nodes MUST include a 'marks' property (can be empty array [] for no formatting). Text nodes with formatting need appropriate marks: { nodeType: 'text', value: 'Bold text', marks: [{ type: 'bold' }], data: {} }.", UpdateEntryToolParams.shape, updateEntryTool);
+    server.tool('delete_entry', 'Delete a specific content entry from your Contentful space', DeleteEntryToolParams.shape, deleteEntryTool);
+    server.tool('publish_entry', 'Publish an entry or multiple entries. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For a single entry, it uses the standard publish operation. For multiple entries, it automatically uses bulk publishing.', PublishEntryToolParams.shape, publishEntryTool);
+    server.tool('unpublish_entry', 'Unpublish an entry or multiple entries. Accepts either a single entryId (string) or an array of entryIds (up to 100 entries). For a single entry, it uses the standard unpublish operation. For multiple entries, it automatically uses bulk unpublishing.', UnpublishEntryToolParams.shape, unpublishEntryTool);
+}

package/build/tools/entries/searchEntries.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { summarizeData } from '../../utils/summarizer.js';
+export const SearchEntriesToolParams = BaseToolSchema.extend({
+    query: z.object({
+        content_type: z.string().optional().describe('Filter by content type'),
+        include: z
+            .number()
+            .optional()
+            .describe('Include this many levels of linked entries'),
+        select: z
+            .string()
+            .optional()
+            .describe('Comma-separated list of fields to return'),
+        links_to_entry: z
+            .string()
+            .optional()
+            .describe('Find entries that link to the specified entry ID'),
+        limit: z
+            .number()
+            .optional()
+            .describe('Maximum number of entries to return'),
+        skip: z.number().optional().describe('Skip this many entries'),
+        order: z.string().optional().describe('Order entries by this field'),
+    }),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    const entries = await contentfulClient.entry.getMany({
+        ...params,
+        query: {
+            ...args.query,
+            limit: Math.min(args.query.limit || 3, 3),
+            skip: args.query.skip || 0,
+        },
+    });
+    const summarized = summarizeData(entries, {
+        maxItems: 3,
+        remainingMessage: 'To see more entries, please ask me to retrieve the next page.',
+    });
+    return createSuccessResponse('Entries retrieved successfully', {
+        entries: summarized,
+    });
+}
+export const searchEntriesTool = withErrorHandling(tool, 'Error deleting dataset');

package/build/tools/entries/unpublishEntry.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { createEntryUnversionedLinks, createEntitiesCollection, waitForBulkActionCompletion, } from '../../utils/bulkOperations.js';
+export const UnpublishEntryToolParams = BaseToolSchema.extend({
+    entryId: z
+        .union([z.string(), z.array(z.string()).max(100)])
+        .describe('The ID of the entry to unpublish (string) or an array of entry IDs (up to 100 entries)'),
+});
+async function tool(args) {
+    const baseParams = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Normalize input to always be an array
+    const entryIds = Array.isArray(args.entryId) ? args.entryId : [args.entryId];
+    // For single entry, use individual publish for simplicity
+    if (entryIds.length === 1) {
+        try {
+            const entryId = entryIds[0];
+            const params = {
+                ...baseParams,
+                entryId,
+            };
+            // Get the entry first
+            const entry = await contentfulClient.entry.get(params);
+            // Unpublish the entry
+            const unpublishedEntry = await contentfulClient.entry.unpublish(params, entry);
+            return createSuccessResponse('Entry unpublished successfully', {
+                status: unpublishedEntry.sys.status,
+                entryId,
+            });
+        }
+        catch (error) {
+            return createSuccessResponse('Entry unpublish failed', {
+                status: error,
+                entryId: entryIds[0],
+            });
+        }
+    }
+    // For multiple entries, use bulk action API
+    // Get the unversioned links for each entry (unpublish doesn't need version info)
+    const entityLinks = await createEntryUnversionedLinks(contentfulClient, baseParams, entryIds);
+    // Create the collection object
+    const entitiesCollection = createEntitiesCollection(entityLinks);
+    // Create the bulk action
+    const bulkAction = await contentfulClient.bulkAction.unpublish(baseParams, {
+        entities: entitiesCollection,
+    });
+    // Wait for the bulk action to complete
+    const action = await waitForBulkActionCompletion(contentfulClient, baseParams, bulkAction.sys.id);
+    return createSuccessResponse('Entry(s) unpublished successfully', {
+        status: action.sys.status,
+        entryIds,
+    });
+}
+export const unpublishEntryTool = withErrorHandling(tool, 'Error unpublishing entry');

package/build/tools/entries/updateEntry.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UpdateEntryToolParams = BaseToolSchema.extend({
+    entryId: z.string().describe('The ID of the entry to update'),
+    fields: z
+        .record(z.any())
+        .describe('The field values to update. Keys should be field IDs and values should be the field content. Will be merged with existing fields.'),
+    metadata: z
+        .object({
+        tags: z.array(z.object({
+            sys: z.object({
+                type: z.literal('Link'),
+                linkType: z.literal('Tag'),
+                id: z.string(),
+            }),
+        })),
+    })
+        .optional(),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        entryId: args.entryId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the existing entry
+    const existingEntry = await contentfulClient.entry.get(params);
+    // Merge the provided fields with existing fields
+    const mergedFields = {
+        ...existingEntry.fields,
+        ...args.fields,
+    };
+    const allTags = [
+        ...(existingEntry.metadata?.tags || []),
+        ...(args.metadata?.tags || []),
+    ];
+    // Update the entry with merged fields
+    const updatedEntry = await contentfulClient.entry.update(params, {
+        ...existingEntry,
+        fields: mergedFields,
+        metadata: {
+            tags: allTags,
+        },
+    });
+    //return info about the entry that was updated
+    return createSuccessResponse('Entry updated successfully', { updatedEntry });
+}
+export const updateEntryTool = withErrorHandling(tool, 'Error updating entry');

package/build/tools/environments/createEnvironment.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const CreateEnvironmentToolParams = BaseToolSchema.extend({
+    environmentId: z.string().describe('The ID of the environment to create'),
+    name: z.string().describe('The name of the environment to create'),
+});
+async function tool(args) {
+    const contentfulClient = createToolClient(args);
+    // Create the environment
+    const environment = await contentfulClient.environment.createWithId({
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    }, {
+        name: args.name,
+    });
+    return createSuccessResponse('Environment created successfully', {
+        environment,
+    });
+}
+export const createEnvironmentTool = withErrorHandling(tool, 'Error creating environment');

package/build/tools/environments/deleteEnvironment.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const DeleteEnvironmentToolParams = BaseToolSchema.extend({
+    environmentId: z.string().describe('The ID of the environment to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Delete the environment
+    await contentfulClient.environment.delete(params);
+    return createSuccessResponse('Environment deleted successfully', {
+        environmentId: args.environmentId,
+    });
+}
+export const deleteEnvironmentTool = withErrorHandling(tool, 'Error deleting environment');

package/build/tools/environments/listEnvironments.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { summarizeData } from '../../utils/summarizer.js';
+// Extend BaseToolSchema but make environmentId optional since it's not needed for listing
+export const ListEnvironmentsToolParams = BaseToolSchema.extend({
+    environmentId: z
+        .string()
+        .optional()
+        .describe('The ID of the Contentful environment (not required for listing)'),
+    limit: z
+        .number()
+        .optional()
+        .describe('Maximum number of environments to return (max 10)'),
+    skip: z
+        .number()
+        .optional()
+        .describe('Skip this many environments for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    order: z.string().optional().describe('Order environments by this field'),
+});
+async function tool(args) {
+    // Provide a default environmentId if not specified
+    const clientArgs = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId || 'master',
+    };
+    const contentfulClient = createToolClient(clientArgs);
+    const environments = await contentfulClient.environment.getMany({
+        spaceId: args.spaceId,
+        query: {
+            limit: Math.min(args.limit || 10, 10),
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedEnvironments = environments.items.map((environment) => ({
+        id: environment.sys.id,
+        name: environment.name,
+        status: environment.sys.status?.sys?.id || 'unknown',
+        createdAt: environment.sys.createdAt,
+        updatedAt: environment.sys.updatedAt,
+    }));
+    const summarized = summarizeData({
+        ...environments,
+        items: summarizedEnvironments,
+    }, {
+        maxItems: 10,
+        remainingMessage: 'To see more environments, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Environments retrieved successfully', {
+        environments: summarized,
+        total: environments.total,
+        limit: environments.limit,
+        skip: environments.skip,
+    });
+}
+export const listEnvironmentsTool = withErrorHandling(tool, 'Error listing environments');

package/build/tools/environments/register.js

@@ -0,0 +1,8 @@
+import { createEnvironmentTool, CreateEnvironmentToolParams, } from './createEnvironment.js';
+import { listEnvironmentsTool, ListEnvironmentsToolParams, } from './listEnvironments.js';
+import { deleteEnvironmentTool, DeleteEnvironmentToolParams, } from './deleteEnvironment.js';
+export function registerEnvironmentTools(server) {
+    server.tool('create_environment', 'Create a new environment', CreateEnvironmentToolParams.shape, createEnvironmentTool);
+    server.tool('list_environments', 'List all environments in a space', ListEnvironmentsToolParams.shape, listEnvironmentsTool);
+    server.tool('delete_environment', 'Delete an environment', DeleteEnvironmentToolParams.shape, deleteEnvironmentTool);
+}

package/build/tools/locales/createLocale.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const CreateLocaleToolParams = BaseToolSchema.extend({
+    name: z.string().describe('The name of the locale'),
+    code: z.string().describe('The locale code (e.g., "en-US")'),
+    fallbackCode: z
+        .string()
+        .optional()
+        .describe('The locale code to fallback to when there is no content for the current locale'),
+    contentDeliveryApi: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If the content under this locale should be available on the CDA (for public reading)'),
+    contentManagementApi: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If the content under this locale should be available on the CMA (for editing)'),
+    default: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If this is the default locale'),
+    optional: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If the locale needs to be filled in on entries or not'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Create the locale
+    const newLocale = await contentfulClient.locale.create(params, {
+        name: args.name,
+        code: args.code,
+        fallbackCode: args.fallbackCode,
+        contentDeliveryApi: args.contentDeliveryApi,
+        contentManagementApi: args.contentManagementApi,
+        optional: args.optional,
+    });
+    return createSuccessResponse('Locale created successfully', { newLocale });
+}
+export const createLocaleTool = withErrorHandling(tool, 'Error creating locale');

package/build/tools/locales/deleteLocale.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const DeleteLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to delete'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the locale to check its current state
+    const locale = await contentfulClient.locale.get(params);
+    // Delete the locale
+    await contentfulClient.locale.delete(params);
+    // Return info about the locale that was deleted
+    return createSuccessResponse('Locale deleted successfully', { locale });
+}
+export const deleteLocaleTool = withErrorHandling(tool, 'Error deleting locale');

package/build/tools/locales/getLocale.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const GetLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to retrieve'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // Get the locale
+    const locale = await contentfulClient.locale.get(params);
+    return createSuccessResponse('Locale retrieved successfully', { locale });
+}
+export const getLocaleTool = withErrorHandling(tool, 'Error retrieving locale');

package/build/tools/locales/listLocales.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+import { summarizeData } from '../../utils/summarizer.js';
+export const ListLocaleToolParams = BaseToolSchema.extend({
+    limit: z.number().optional().describe('Maximum number of locales to return'),
+    skip: z.number().optional().describe('Skip this many locales for pagination'),
+    select: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of fields to return'),
+    include: z
+        .number()
+        .optional()
+        .describe('Include this many levels of linked entries'),
+    order: z.string().optional().describe('Order locales by this field'),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+    };
+    const contentfulClient = createToolClient(args);
+    const locales = await contentfulClient.locale.getMany({
+        ...params,
+        query: {
+            limit: args.limit || 100,
+            skip: args.skip || 0,
+            ...(args.select && { select: args.select }),
+            ...(args.include && { include: args.include }),
+            ...(args.order && { order: args.order }),
+        },
+    });
+    const summarizedLocales = locales.items.map((locale) => ({
+        id: locale.sys.id,
+        name: locale.name,
+        code: locale.code,
+        fallbackCode: locale.fallbackCode || null,
+        contentDeliveryApi: locale.contentDeliveryApi,
+        contentManagementApi: locale.contentManagementApi,
+        default: locale.default,
+        optional: locale.optional,
+        createdAt: locale.sys.createdAt,
+        updatedAt: locale.sys.updatedAt,
+        version: locale.sys.version,
+    }));
+    const summarized = summarizeData({
+        ...locales,
+        items: summarizedLocales,
+    }, {
+        maxItems: 10,
+        remainingMessage: 'To see more locales, please ask me to retrieve the next page using the skip parameter.',
+    });
+    return createSuccessResponse('Locales retrieved successfully', {
+        locales: summarized,
+        total: locales.total,
+        limit: locales.limit,
+        skip: locales.skip,
+    });
+}
+export const listLocaleTool = withErrorHandling(tool, 'Error listing locales');

package/build/tools/locales/register.js

@@ -0,0 +1,12 @@
+import { getLocaleTool, GetLocaleToolParams } from './getLocale.js';
+import { createLocaleTool, CreateLocaleToolParams } from './createLocale.js';
+import { listLocaleTool, ListLocaleToolParams } from './listLocales.js';
+import { updateLocaleTool, UpdateLocaleToolParams } from './updateLocale.js';
+import { deleteLocaleTool, DeleteLocaleToolParams } from './deleteLocale.js';
+export function registerLocaleTools(server) {
+    server.tool('get_locale', 'Retrieve a specific locale from your Contentful environment', GetLocaleToolParams.shape, getLocaleTool);
+    server.tool('create_locale', 'Create a new locale in your Contentful environment. A locale defines a language-region pair (e.g., "en-US" for English United States). You can specify fallback behavior, API availability settings, and whether the locale is optional for content editors. Note: setting \'default\' is currently not supported.', CreateLocaleToolParams.shape, createLocaleTool);
+    server.tool('list_locales', 'List all locales in your Contentful environment. Returns locale information including language codes, fallback settings, and API availability.', ListLocaleToolParams.shape, listLocaleTool);
+    server.tool('update_locale', 'Update an existing locale in your Contentful environment. You can modify the locale name, code, fallback behavior, API availability settings, and whether the locale is optional for content editors. Only provide the fields you want to change. IMPORTANT: internal_code cannot be updated.', UpdateLocaleToolParams.shape, updateLocaleTool);
+    server.tool('delete_locale', 'Delete a specific locale from your Contentful environment. This operation permanently removes the locale and cannot be undone.', DeleteLocaleToolParams.shape, deleteLocaleTool);
+}

package/build/tools/locales/updateLocale.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import { BaseToolSchema, createToolClient } from '../../utils/tools.js';
+export const UpdateLocaleToolParams = BaseToolSchema.extend({
+    localeId: z.string().describe('The ID of the locale to update'),
+    fields: z.object({
+        name: z.string().optional().describe('The name of the locale'),
+        // NOTE: internal_code changes are not allowed
+        code: z.string().optional().describe('The code of the locale'),
+        fallbackCode: z
+            .string()
+            .optional()
+            .describe('The locale code to fallback to when there is no content for the current locale'),
+        contentDeliveryApi: z
+            .boolean()
+            .optional()
+            .describe('If the content under this locale should be available on the CDA (for public reading)'),
+        contentManagementApi: z
+            .boolean()
+            .optional()
+            .describe('If the content under this locale should be available on the CMA (for editing)'),
+        optional: z
+            .boolean()
+            .optional()
+            .describe('If the locale needs to be filled in on entries or not'),
+    }),
+});
+async function tool(args) {
+    const params = {
+        spaceId: args.spaceId,
+        environmentId: args.environmentId,
+        localeId: args.localeId,
+    };
+    const contentfulClient = createToolClient(args);
+    // First, get the existing locale
+    const existingLocale = await contentfulClient.locale.get(params);
+    // Remove read-only fields (nternal_code cannot be updated)
+    delete existingLocale.internal_code;
+    // Build update data with only provided fields, merging with existing locale
+    const updateData = { ...existingLocale, ...args.fields };
+    // Update the locale with merged data
+    const updatedLocale = await contentfulClient.locale.update(params, updateData);
+    return createSuccessResponse('Locale updated successfully', {
+        updatedLocale,
+    });
+}
+export const updateLocaleTool = withErrorHandling(tool, 'Error updating locale');

package/build/tools/register.js

@@ -0,0 +1,20 @@
+import { registerContextTools } from './context/register.js';
+import { registerEntriesTools } from './entries/register.js';
+import { registerContentTypesTools } from './types/register.js';
+import { registerEnvironmentTools } from './environments/register.js';
+import { registerAssetTools } from './assets/register.js';
+import { registerSpaceTools } from './spaces/register.js';
+import { registerTagsTools } from './tags/register.js';
+import { registerAiActionsTools } from './ai-actions/register.js';
+import { registerLocaleTools } from './locales/register.js';
+export function registerAllTools(server) {
+    registerContextTools(server);
+    registerEntriesTools(server);
+    registerContentTypesTools(server);
+    registerEnvironmentTools(server);
+    registerAssetTools(server);
+    registerSpaceTools(server);
+    registerTagsTools(server);
+    registerAiActionsTools(server);
+    registerLocaleTools(server);
+}

package/build/tools/spaces/getSpace.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { createSuccessResponse, withErrorHandling, } from '../../utils/response.js';
+import ctfl from 'contentful-management';
+import { getDefaultClientConfig } from '../../config/contentful.js';
+export const GetSpaceToolParams = z.object({
+    spaceId: z.string().describe('The ID of the space to retrieve'),
+});
+async function tool(args) {
+    // Create a client without space-specific configuration
+    const clientConfig = getDefaultClientConfig();
+    // Remove space from config since we'll specify it in the get call
+    delete clientConfig.space;
+    const contentfulClient = ctfl.createClient(clientConfig, { type: 'plain' });
+    // Get the space
+    const space = await contentfulClient.space.get({
+        spaceId: args.spaceId,
+    });
+    return createSuccessResponse('Space retrieved successfully', { space });
+}
+export const getSpaceTool = withErrorHandling(tool, 'Error retrieving space');