@content-island/mcp 0.2.2 → 0.3.1

package/README.md

@@ -16,14 +16,20 @@ A Model Context Protocol (MCP) server that enables seamless integration between
 
 ### Available Tools
 
-| Tool                                | Description                                                              | Token required    |
-| ----------------------------------- | ------------------------------------------------------------------------ | ----------------- |
-| `get-content-island-project`        | Get project details (languages, content types, fields)                   | Read **or** Write |
-| `list-content-island-contents`      | List content entries with filters, sort and pagination (returns hasMore) | Read **or** Write |
-| `create-content-island-content`     | Create a new content entry with fields per language                      | **Write**         |
-| `update-content-island-field-value` | Update or insert a field value identified by `(fieldName, language)`     | **Write**         |
-| `publish-content-island-content`    | Promote a content's current draft to the live state (preflight-gated)    | **Write**         |
-| `upload-content-island-media`       | Upload a media file from a local path or URL                             | **Write**         |
+| Tool                                | Description                                                                                                         | Token required    |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ----------------- |
+| `get-content-island-project`        | Get project details (languages, content types, fields)                                                              | Read **or** Write |
+| `list-content-island-contents`      | List content entries with filters, sort and pagination (returns hasMore)                                            | Read **or** Write |
+| `create-content-island-content`     | Create a new content entry with fields per language                                                                 | **Write**         |
+| `update-content-island-field-value` | Update or insert a field value identified by `(fieldName, language)`                                                | **Write**         |
+| `publish-content-island-content`    | Promote a content's current draft to the live state (preflight-gated)                                               | **Write**         |
+| `upload-content-island-media`       | Upload a media file from a local path or URL                                                                        | **Write**         |
+| `create-content-island-model`       | Create an Entity (content type) with a structured field list                                                        | **Write**         |
+| `update-content-island-model`       | Edit an Entity with declarative ops (rename / add / update / remove fields); destructive removals are dry-run-gated | **Write**         |
+| `delete-content-island-model`       | Delete an Entity (dry-run by default; `confirm: true` to apply; 409 if referenced)                                  | **Write**         |
+| `create-content-island-enum`        | Create an Enum (a closed list of string values)                                                                     | **Write**         |
+| `update-content-island-enum`        | Edit an Enum with declarative ops (rename / add / rename / remove values); destructive removals are dry-run-gated   | **Write**         |
+| `delete-content-island-enum`        | Delete an Enum (dry-run by default; `confirm: true` to apply; 409 if referenced)                                    | **Write**         |
 
 > **Note**: A **read token** is sufficient for read-only tools. Tools that create or upload data require a **write token**. A write token also works for read-only tools.
 

package/dist/index.js

@@ -1,38 +1,38 @@
-import { z as a } from "zod";
-import { McpServer as w } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { createClient as v, isApiClientError as R } from "@content-island/api-client";
-import { readFile as S } from "node:fs/promises";
-import { basename as A, extname as O } from "node:path";
-import { StdioServerTransport as x } from "@modelcontextprotocol/sdk/server/stdio.js";
-const f = {
+import { z as n } from "zod";
+import { McpServer as S } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createClient as L, isApiClientError as j, resolveFileExtension as k } from "@content-island/api-client";
+import { readFile as F } from "node:fs/promises";
+import { basename as C, extname as U } from "node:path";
+import { StdioServerTransport as D } from "@modelcontextprotocol/sdk/server/stdio.js";
+const E = {
   CONTENT_ISLAND_ACCESS_TOKEN: process.env.CONTENT_ISLAND_ACCESS_TOKEN,
   CONTENT_ISLAND_DOMAIN: process.env.CONTENT_ISLAND_DOMAIN,
   CONTENT_ISLAND_SECURE_PROTOCOL: process.env.CONTENT_ISLAND_SECURE_PROTOCOL !== "false",
   CONTENT_ISLAND_API_VERSION: process.env.CONTENT_ISLAND_API_VERSION
-}, T = "PREVIEW_", L = (e) => e.startsWith(T) ? e : `${T}${e}`, g = () => v({
-  accessToken: L(f.CONTENT_ISLAND_ACCESS_TOKEN),
-  domain: f.CONTENT_ISLAND_DOMAIN,
-  secureProtocol: f.CONTENT_ISLAND_SECURE_PROTOCOL,
-  apiVersion: f.CONTENT_ISLAND_API_VERSION
-}), k = "0.2.2", P = {
-  version: k
-}, u = new w({
+}, w = "PREVIEW_", M = (e) => e.startsWith(w) ? e : `${w}${e}`, h = () => L({
+  accessToken: M(E.CONTENT_ISLAND_ACCESS_TOKEN),
+  domain: E.CONTENT_ISLAND_DOMAIN,
+  secureProtocol: E.CONTENT_ISLAND_SECURE_PROTOCOL,
+  apiVersion: E.CONTENT_ISLAND_API_VERSION
+}), P = "0.3.1", V = {
+  version: P
+}, m = new S({
   name: "Content Island",
-  version: P.version
-}), j = () => {
-  u.prompt(
+  version: V.version
+}), $ = () => {
+  m.prompt(
     "create-content-island-project",
     "Professional MCP Server prompt for creating modern frontend projects integrated with Content Island CMS",
     {
-      framework: a.string().describe("Framework choice (Next.js, Astro, Nuxt, etc.)"),
-      pages: a.string().describe("Pages needed (Homepage, Blog, Contact, etc.)"),
-      location: a.string().describe("Project location (root directory or subfolder name)"),
-      styling: a.string().describe("Styling preference (Tailwind CSS or custom)"),
-      design: a.string().describe("Design assets (mockups, wireframes, or none)")
+      framework: n.string().describe("Framework choice (Next.js, Astro, Nuxt, etc.)"),
+      pages: n.string().describe("Pages needed (Homepage, Blog, Contact, etc.)"),
+      location: n.string().describe("Project location (root directory or subfolder name)"),
+      styling: n.string().describe("Styling preference (Tailwind CSS or custom)"),
+      design: n.string().describe("Design assets (mockups, wireframes, or none)")
     },
     async (e) => {
-      const { framework: t, pages: i, location: n, styling: o, design: r } = e;
-      return t && i && n && o && r ? {
+      const { framework: t, pages: i, location: a, styling: o, design: s } = e;
+      return t && i && a && o && s ? {
         description: "Content Island project generator",
         messages: [
           {
@@ -46,9 +46,9 @@ I'll create a professional ${t} application integrated with your Content Island
 **Configuration:**
 - Framework: **${t}**
 - Pages: ${i}
-- Location: ${n}
+- Location: ${a}
 - Styling: ${o}
-- Design: ${r}
+- Design: ${s}
 
 # CRITICAL IMPLEMENTATION INSTRUCTIONS - FOLLOW EXACTLY
 
@@ -58,7 +58,7 @@ You are a specialized web development assistant creating a ${t} application inte
 
 ### STEP 1: FRAMEWORK PROJECT INITIALIZATION (REQUIRED FIRST ACTION)
 - FIRST execute the appropriate framework CLI command to create the base project:
-${t === "Next.js" ? `  * Run: npx create-next-app@latest ${n !== "root directory" ? n : "."} --typescript --tailwind --eslint --app --src-dir --import-alias "@/*"` : t === "Nuxt" ? `  * Run: npx nuxi@latest init ${n !== "root directory" ? n : "."}` : t === "Astro" ? `  * Run: npm create astro@latest ${n !== "root directory" ? n : "."}` : t === "SvelteKit" ? `  * Run: npm create svelte@latest ${n !== "root directory" ? n : "."}` : t === "Vite" ? `  * Run: npm create vite@latest ${n !== "root directory" ? n : "."} -- --template react-ts` : `  * Run the appropriate CLI command for ${t} to create a new project in ${n !== "root directory" ? n : "current directory"}`}
+${t === "Next.js" ? `  * Run: npx create-next-app@latest ${a !== "root directory" ? a : "."} --typescript --tailwind --eslint --app --src-dir --import-alias "@/*"` : t === "Nuxt" ? `  * Run: npx nuxi@latest init ${a !== "root directory" ? a : "."}` : t === "Astro" ? `  * Run: npm create astro@latest ${a !== "root directory" ? a : "."}` : t === "SvelteKit" ? `  * Run: npm create svelte@latest ${a !== "root directory" ? a : "."}` : t === "Vite" ? `  * Run: npm create vite@latest ${a !== "root directory" ? a : "."} -- --template react-ts` : `  * Run the appropriate CLI command for ${t} to create a new project in ${a !== "root directory" ? a : "current directory"}`}
 - Navigate to the project directory if created in a subfolder
 - Wait for the framework setup to complete before proceeding
 - DO NOT skip this step - the framework base is required for all subsequent steps
@@ -140,10 +140,10 @@ ${t === "Nuxt" ? `
 
 ### STEP 6: PROJECT STRUCTURE GENERATION (FRAMEWORK-SPECIFIC)
 - Framework: ${t}
-- Location: ${n}
+- Location: ${a}
 - Pages requested: ${i}
 - Styling: ${o}
-- Design approach: ${r}
+- Design approach: ${s}
 
 #### FRAMEWORK-SPECIFIC REQUIREMENTS:
 ${t === "Next.js" ? `
@@ -319,23 +319,23 @@ Please provide all this information so I can create your project.`
       };
     }
   );
-}, U = () => {
-  j();
-}, D = {
+}, _ = () => {
+  $();
+}, q = {
   UNAUTHORIZED: "Invalid or expired token. Check your CONTENT_ISLAND_ACCESS_TOKEN configuration.",
   FORBIDDEN: "This token does not have write permissions. Configure a write token in CONTENT_ISLAND_ACCESS_TOKEN.",
   NOT_FOUND: "Resource not found. Verify that the content type, content ID, or project exists.",
   VALIDATION_ERROR: "Invalid input. See details below.",
   NETWORK_ERROR: "Could not reach Content Island. Check your network and the API endpoint configuration."
-}, F = (e) => D[e.code] ?? `API error: ${e.status} ${e.code}`, M = (e) => {
+}, W = (e) => q[e.code] ?? `API error: ${e.status} ${e.code}`, K = (e) => {
   const t = e.details?.fields;
   return Array.isArray(t) ? t.map((i) => `  - ${i.field}: ${i.message}`) : [];
-}, _ = (e) => {
-  const t = [F(e), e.message, ...M(e)];
+}, Y = (e) => {
+  const t = [W(e), e.message, ...K(e)];
   return e.requestId && t.push(`(requestId: ${e.requestId})`), t.join(`
 `);
-}, h = (e) => R(e) ? { content: [{ type: "text", text: _(e) }], isError: !0 } : { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: !0 }, $ = () => {
-  u.tool(
+}, p = (e) => j(e) ? { content: [{ type: "text", text: Y(e) }], isError: !0 } : { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: !0 }, B = () => {
+  m.tool(
     "create-content-island-content",
     `Create a new content entry in the Content Island project. Requires a write token.
 
@@ -386,21 +386,21 @@ If the user asks you to create content from a web URL, follow this workflow:
 4. Replace every original image URL in the extracted content with the "url" returned by upload-content-island-media. Never leave the original external URLs — they may become broken links if the source site removes them.
 5. Only then call this tool with the fully processed payload.`,
     {
-      contentType: a.string().describe(
+      contentType: n.string().describe(
         'The content type name (e.g. "post", "page"). Must match an existing content type name exactly. Use get-content-island-project to discover available content types.'
       ),
-      name: a.string().describe("Display name for the new content entry."),
-      content: a.array(
-        a.object({
-          language: a.string().optional().describe(
+      name: n.string().describe("Display name for the new content entry."),
+      content: n.array(
+        n.object({
+          language: n.string().optional().describe(
             `Language code (e.g. "en", "es"). Must be one of the languages from the project. Defaults to the project's first language if omitted.`
           ),
-          fields: a.array(
-            a.object({
-              name: a.string().describe(
+          fields: n.array(
+            n.object({
+              name: n.string().describe(
                 "Field name exactly as defined in the content type schema from get-content-island-project."
               ),
-              value: a.any().describe(
+              value: n.any().describe(
                 "Field value. Must match the type and constraints of the field as described in the tool description above."
               )
             })
@@ -412,17 +412,207 @@ If the user asks you to create content from a web URL, follow this workflow:
     },
     async ({ contentType: e, name: t, content: i }) => {
       try {
-        const n = g(), o = { contentType: e, name: t, content: i }, r = await n.createContent(o);
+        const a = h(), o = { contentType: e, name: t, content: i }, s = await a.createContent(o);
         return {
-          content: [{ type: "text", text: JSON.stringify(r, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(s, null, 2) }]
         };
-      } catch (n) {
-        return h(n);
+      } catch (a) {
+        return p(a);
       }
     }
   );
-}, V = () => {
-  u.tool(
+}, H = () => {
+  m.tool(
+    "create-content-island-enum",
+    `Create a new Enum model in the Content Island project schema. Requires a write token.
+
+An enum is a closed list of string values that entity fields (type "enum") can reference. The server generates an id for the enum and for each value.
+
+WORKFLOW:
+1. Call get-content-island-project to avoid duplicate model names.
+2. Call this tool with the enum name and its list of string values.`,
+    {
+      name: n.string().describe(
+        "Enum name. Non-empty, /^[a-zA-Z0-9_ -]+$/, max 128 chars, not a reserved field type, unique in the project."
+      ),
+      values: n.array(n.string()).min(1).describe("The enum values (plain strings), in order. At least one value is required.")
+    },
+    async ({ name: e, values: t }) => {
+      try {
+        const i = h(), a = { name: e, values: t.map((s) => ({ value: s })) }, o = await i.createEnum(a);
+        return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
+      } catch (i) {
+        return p(i);
+      }
+    }
+  );
+}, b = n.discriminatedUnion("name", [
+  n.object({ name: n.literal("required") }),
+  n.object({ name: n.literal("unique") }),
+  n.object({ name: n.literal("min-length"), customArgs: n.object({ length: n.number().int().positive() }) }),
+  n.object({ name: n.literal("max-length"), customArgs: n.object({ length: n.number().int().positive() }) }),
+  n.object({
+    name: n.literal("media-type"),
+    customArgs: n.object({
+      allowedExtensions: n.array(n.string()).min(1).describe('Allowed file extensions, e.g. ["png","jpg","pdf"] — with or without the leading dot.')
+    })
+  })
+]).describe(
+  'Field validation. required/unique take no args; min-length/max-length take { length }; media-type takes { allowedExtensions: ["png", ...] }.'
+), I = (e) => (e ?? []).map((t) => t.name === "media-type" ? {
+  name: "media-type",
+  customArgs: { allowedExtensions: t.customArgs.allowedExtensions.map(k) }
+} : "customArgs" in t ? { name: t.name, customArgs: t.customArgs } : { name: t.name }), G = (e) => {
+  const t = e.type, i = {
+    id: e.id,
+    name: e.name,
+    isArray: e.isArray ?? !1,
+    validations: e.validations ?? []
+  };
+  if (!t.includes("|"))
+    return { ...i, type: t };
+  const a = t.split("|")[0], o = (e.tsType ?? "").trim().startsWith("'") ? "enum" : "relation";
+  return { ...i, type: o, relatedModelId: a };
+}, J = (e) => ({
+  name: e.name,
+  type: e.type,
+  relatedModelId: e.relatedModelId,
+  isArray: e.isArray ?? !1,
+  validations: e.validations ?? []
+}), z = (e, t) => ({
+  id: e.id,
+  name: t.name ?? e.name,
+  type: t.type ?? e.type,
+  relatedModelId: t.relatedModelId ?? e.relatedModelId,
+  isArray: t.isArray ?? e.isArray,
+  validations: t.validations ?? e.validations
+}), X = (e, t) => {
+  const i = new Set(t.removeFieldIds ?? []), a = new Map((t.updateFields ?? []).map((r) => [r.id, r])), o = e.fields.filter((r) => !i.has(r.id)).map((r) => {
+    const d = G(r), l = a.get(r.id);
+    return l ? z(d, l) : d;
+  }), s = (t.addFields ?? []).map(J);
+  return {
+    name: t.rename ?? e.name,
+    fieldList: [...o, ...s]
+  };
+}, Q = (e, t) => {
+  const i = new Set(t.removeValueIds ?? []), a = new Map((t.renameValues ?? []).map((r) => [r.id, r.value])), o = e.values.filter((r) => !i.has(r.id)).map((r) => ({ id: r.id, value: a.get(r.id) ?? r.value })), s = (t.addValues ?? []).map((r) => ({ value: r }));
+  return {
+    name: t.rename ?? e.name,
+    values: [...o, ...s]
+  };
+}, Z = (e, t) => ({
+  wouldRemoveFieldIds: [...t.removeFieldIds ?? []]
+}), ee = (e, t) => ({
+  wouldRemoveValueIds: [...t.removeValueIds ?? []]
+}), te = (e) => (e.removeFieldIds ?? []).length > 0, ne = (e) => (e.removeValueIds ?? []).length > 0, R = (e, t) => (e ?? []).find((i) => i.type === "entity" && i.id === t), x = (e, t) => (e ?? []).find((i) => i.type === "enum" && i.id === t), ae = n.object({
+  name: n.string().describe("Field name. Must match /^[a-zA-Z0-9_ -]+$/ and be unique within the model."),
+  type: n.enum(["short-text", "long-text", "number", "date", "date-time", "media", "boolean", "color", "relation", "enum"]).describe(
+    'Field type. Use a primitive type for plain fields. Use "relation" to point at another entity (supply relatedModelId) and "enum" to point at an enum (supply relatedModelId). Never build a composite "modelId|Name" type string.'
+  ),
+  relatedModelId: n.string().optional().describe(
+    'For type "relation" or "enum": the 24-char id of the referenced model (an entity for "relation", an enum for "enum"). Discover ids via get-content-island-project. Omit for primitive types.'
+  ),
+  isArray: n.boolean().optional().describe("Whether the field stores a list of values. Defaults to false."),
+  validations: n.array(b).optional().describe("Optional field validations.")
+}), ie = () => {
+  m.tool(
+    "create-content-island-model",
+    `Create a new Entity model (content type) in the Content Island project schema. Requires a write token.
+
+The agent supplies a structured field list. For "relation"/"enum" fields, pass the referenced model's id as relatedModelId — the server resolves it and assembles the stored type. Never construct a "modelId|Name" string yourself.
+
+WORKFLOW:
+1. Call get-content-island-project to read existing models (so you can reference entities/enums by id and avoid duplicate names).
+2. Call this tool with the new model name and its fieldList.`,
+    {
+      name: n.string().describe(
+        "Model (entity) name. Non-empty, /^[a-zA-Z0-9_ -]+$/, max 128 chars, not a reserved field type, unique in the project."
+      ),
+      fieldList: n.array(ae).min(1).describe("The fields of the new entity, in order. At least one field is required.")
+    },
+    async ({ name: e, fieldList: t }) => {
+      try {
+        const i = h(), a = {
+          name: e,
+          fieldList: t.map((s) => ({
+            ...s,
+            validations: I(s.validations)
+          }))
+        }, o = await i.createModel(a);
+        return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
+      } catch (i) {
+        return p(i);
+      }
+    }
+  );
+}, oe = () => {
+  m.tool(
+    "delete-content-island-enum",
+    `Delete an Enum from the Content Island project schema. Requires a write token.
+
+DESTRUCTIVE: without confirm: true, this tool returns a DRY-RUN and does NOT mutate. To apply, do it in TWO steps: first call WITHOUT confirm to get the dry-run, then show the user that impact and re-invoke with confirm: true ONLY after the user explicitly approves. NEVER pass confirm: true on the first call or without the user's explicit go-ahead.
+
+If any entity field references this enum, the delete is rejected with a 409 CONFLICT and the enum is NOT deleted — there is no force override. Remove or repoint the referencing field first.`,
+    {
+      enumId: n.string().describe("The 24-char id of the enum to delete."),
+      confirm: n.boolean().optional().describe(
+        "Set to true to perform the deletion. Without it, returns a dry-run. Set it only AFTER the user has seen the dry-run and explicitly approved — never on the first call."
+      )
+    },
+    async ({ enumId: e, confirm: t }) => {
+      try {
+        const i = h(), a = await i.getProject(), o = x(a.contentTypes, e);
+        if (!o)
+          return p(new Error(`Enum "${e}" not found in the project schema.`));
+        if (!t) {
+          const s = {
+            dryRun: !0,
+            summary: `Deleting the enum "${o.name}" is destructive. Re-invoke with confirm: true to apply. (If an entity field references this enum, the deletion will be rejected with 409.)`
+          };
+          return { content: [{ type: "text", text: JSON.stringify(s, null, 2) }] };
+        }
+        return await i.deleteEnum(e), { content: [{ type: "text", text: `Enum "${o.name}" (${e}) deleted.` }] };
+      } catch (i) {
+        return p(i);
+      }
+    }
+  );
+}, re = () => {
+  m.tool(
+    "delete-content-island-model",
+    `Delete an Entity model from the Content Island project schema. Requires a write token.
+
+DESTRUCTIVE: deleting a model also deletes every content of that type. Without confirm: true, this tool returns a DRY-RUN reporting how many contents would be deleted and does NOT mutate. To apply, do it in TWO steps: first call WITHOUT confirm to get the dry-run, then show the user that impact and re-invoke with confirm: true ONLY after the user explicitly approves. NEVER pass confirm: true on the first call or without the user's explicit go-ahead.
+
+If the model is referenced by a field on another model, the delete is rejected with a 409 CONFLICT and the model is NOT deleted — there is no force override. Remove or repoint the referencing field first.`,
+    {
+      modelId: n.string().describe("The 24-char id of the entity to delete."),
+      confirm: n.boolean().optional().describe(
+        "Set to true to perform the deletion. Without it, returns a dry-run with the cascade impact. Set it only AFTER the user has seen the dry-run and explicitly approved — never on the first call."
+      )
+    },
+    async ({ modelId: e, confirm: t }) => {
+      try {
+        const i = h(), a = await i.getProject(), o = R(a.contentTypes, e);
+        if (!o)
+          return p(new Error(`Entity "${e}" not found in the project schema.`));
+        if (!t) {
+          const s = await i.getContentListSize({ contentType: o.name }), r = {
+            dryRun: !0,
+            wouldDeleteContentCount: s,
+            summary: `Deleting "${o.name}" would also delete ${s} content(s) of this type. Re-invoke with confirm: true to apply. (If another model references this one, the deletion will be rejected with 409.)`
+          };
+          return { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] };
+        }
+        return await i.deleteModel(e), { content: [{ type: "text", text: `Model "${o.name}" (${e}) deleted.` }] };
+      } catch (i) {
+        return p(i);
+      }
+    }
+  );
+}, se = () => {
+  m.tool(
     "get-content-island-project",
     `Get the user's Content Island project schema (languages and contentTypes).
 
@@ -439,14 +629,14 @@ Each entity field also carries a "validations" array (optional). Each entry is {
 
 The "languages" array at the project root lists every language the project supports. Field values are stored per language, so a single content entry may have one fieldValue per language. When writing, consider language coverage explicitly (see the write tools' descriptions).`,
     async () => {
-      const t = await g().getProject();
+      const t = await h().getProject();
       return {
         content: [{ type: "text", text: JSON.stringify(t, null, 2) }]
       };
     }
   );
-}, m = 25, y = 100, q = () => {
-  u.tool(
+}, T = 25, v = 100, le = () => {
+  m.tool(
     "list-content-island-contents",
     `List content entries of the Content Island project. Returns the raw content structure with all fieldValues (each one carries its fieldName, language and value), so you can inspect every translation in one call. Drafts and unpublished values are included.
 
@@ -454,7 +644,7 @@ IMPORTANT: Before calling this tool, you SHOULD call get-content-island-project
 
 Pagination:
 - The response always includes { items, skip, take, hasMore }.
-- Default take is ${m}, maximum allowed is ${y}.
+- Default take is ${T}, maximum allowed is ${v}.
 - If hasMore is true, call this tool again with skip = previous skip + previous take to fetch the next page. Repeat until hasMore is false (or items is empty).
 - hasMore is computed as items.length === take, so it can occasionally be a false positive when the total happens to be an exact multiple of take; in that case the next call returns an empty items array, which confirms the end of the list.
 
@@ -471,100 +661,100 @@ Sort (optional): object with any of:
 - contentType: "asc" | "desc"
 - lastUpdate: "asc" | "desc"`,
     {
-      contentType: a.string().optional().describe("Filter by content type name. Must match an existing content type from get-content-island-project."),
-      id: a.union([a.string(), a.array(a.string())]).optional().describe("A single content id, or an array of ids to fetch a specific subset of contents."),
-      language: a.string().optional().describe(
+      contentType: n.string().optional().describe("Filter by content type name. Must match an existing content type from get-content-island-project."),
+      id: n.union([n.string(), n.array(n.string())]).optional().describe("A single content id, or an array of ids to fetch a specific subset of contents."),
+      language: n.string().optional().describe(
         'Language code (e.g. "en", "es"). Restricts which fieldValues are included inside each content. Does not remove contents that lack a translation in the given language.'
       ),
-      status: a.union([a.enum(["draft", "changed", "published"]), a.array(a.enum(["draft", "changed", "published"]))]).optional().describe(
+      status: n.union([n.enum(["draft", "changed", "published"]), n.array(n.enum(["draft", "changed", "published"]))]).optional().describe(
         'Filter by publication state. Pass a single value (e.g. "draft") or an array (e.g. ["draft", "changed"]) to find contents with unpublished data.'
       ),
-      includeRelatedContent: a.boolean().optional().describe("When true, related content references are expanded inline in fieldValues."),
-      sort: a.object({
-        contentType: a.enum(["asc", "desc"]).optional(),
-        lastUpdate: a.enum(["asc", "desc"]).optional()
+      includeRelatedContent: n.boolean().optional().describe("When true, related content references are expanded inline in fieldValues."),
+      sort: n.object({
+        contentType: n.enum(["asc", "desc"]).optional(),
+        lastUpdate: n.enum(["asc", "desc"]).optional()
       }).optional().describe('Sort order. Each field is independently set to "asc" or "desc".'),
-      take: a.number().int().min(1).max(y).optional().describe(`Maximum number of items to return. Default ${m}, maximum ${y}.`),
-      skip: a.number().int().min(0).optional().describe("Number of items to skip from the start of the result set. Use for pagination.")
+      take: n.number().int().min(1).max(v).optional().describe(`Maximum number of items to return. Default ${T}, maximum ${v}.`),
+      skip: n.number().int().min(0).optional().describe("Number of items to skip from the start of the result set. Use for pagination.")
     },
-    async ({ contentType: e, id: t, language: i, status: n, includeRelatedContent: o, sort: r, take: s, skip: d }) => {
+    async ({ contentType: e, id: t, language: i, status: a, includeRelatedContent: o, sort: s, take: r, skip: d }) => {
       try {
-        const l = g(), c = s ?? m, E = d ?? 0, p = {
-          pagination: { take: c, skip: E }
+        const l = h(), c = r ?? T, f = d ?? 0, g = {
+          pagination: { take: c, skip: f }
         };
-        e !== void 0 && (p.contentType = e), t !== void 0 && (p.id = Array.isArray(t) ? { in: t } : t), i !== void 0 && (p.language = i), n !== void 0 && (p.status = Array.isArray(n) ? { in: n } : n), o !== void 0 && (p.includeRelatedContent = o), r !== void 0 && (p.sort = r);
-        const I = await l.getRawContentList(p), C = {
-          items: I,
-          skip: E,
+        e !== void 0 && (g.contentType = e), t !== void 0 && (g.id = Array.isArray(t) ? { in: t } : t), i !== void 0 && (g.language = i), a !== void 0 && (g.status = Array.isArray(a) ? { in: a } : a), o !== void 0 && (g.includeRelatedContent = o), s !== void 0 && (g.sort = s);
+        const u = await l.getRawContentList(g), y = {
+          items: u,
+          skip: f,
           take: c,
-          hasMore: I.length === c
+          hasMore: u.length === c
         };
         return {
-          content: [{ type: "text", text: JSON.stringify(C, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(y, null, 2) }]
         };
       } catch (l) {
-        return h(l);
+        return p(l);
       }
     }
   );
-}, K = (e) => e?.type === "entity", N = (e) => !!(e == null || typeof e == "string" && e === "" || Array.isArray(e) && e.length === 0), b = (e, t) => t && Array.isArray(e) || typeof e == "string" ? e.length : null, W = (e) => {
+}, ce = (e) => e?.type === "entity", N = (e) => !!(e == null || typeof e == "string" && e === "" || Array.isArray(e) && e.length === 0), A = (e, t) => t && Array.isArray(e) || typeof e == "string" ? e.length : null, de = (e) => {
   const t = e.lastIndexOf(".");
   return t === -1 ? null : e.slice(t);
-}, B = (e, t) => {
+}, ue = (e, t) => {
   const i = typeof e == "string" ? e : e?.url;
   if (typeof i != "string")
     return !1;
-  const n = W(i);
-  return n !== null && t.includes(n);
-}, H = (e, t, i) => {
+  const a = de(i);
+  return a !== null && t.includes(a);
+}, pe = (e, t, i) => {
   switch (e.name) {
     case "required":
     case "unique":
       return null;
     case "min-length": {
-      const n = b(t, i.isArray), o = e.customArgs?.length;
-      return n === null || typeof o != "number" ? null : n < o ? `expected min length ${o}, got ${n}` : null;
+      const a = A(t, i.isArray), o = e.customArgs?.length;
+      return a === null || typeof o != "number" ? null : a < o ? `expected min length ${o}, got ${a}` : null;
     }
     case "max-length": {
-      const n = b(t, i.isArray), o = e.customArgs?.length;
-      return n === null || typeof o != "number" ? null : n > o ? `expected max length ${o}, got ${n}` : null;
+      const a = A(t, i.isArray), o = e.customArgs?.length;
+      return a === null || typeof o != "number" ? null : a > o ? `expected max length ${o}, got ${a}` : null;
     }
     case "media-type": {
-      const n = (e.customArgs?.allowedExtensions ?? []).map((s) => s.name);
-      return n.length === 0 ? null : (i.isArray && Array.isArray(t) ? t : [t]).some((s) => !B(s, n)) ? `media file extension not in allowed list (${n.join(", ")})` : null;
+      const a = (e.customArgs?.allowedExtensions ?? []).map((r) => r.name);
+      return a.length === 0 ? null : (i.isArray && Array.isArray(t) ? t : [t]).some((r) => !ue(r, a)) ? `media file extension not in allowed list (${a.join(", ")})` : null;
     }
     default:
       return null;
   }
-}, Y = (e, t) => {
-  const i = (e.contentTypes ?? []).find((s) => K(s) && s.name === t.contentType.name);
+}, me = (e, t) => {
+  const i = (e.contentTypes ?? []).find((r) => ce(r) && r.name === t.contentType.name);
   if (!i)
     return {
       ok: !1,
       errors: [`content type "${t.contentType.name}" not found in project schema`]
     };
-  const n = [], o = e.languages ?? [], r = t.fields ?? [];
-  for (const s of i.fields)
-    if (s.isRequired)
+  const a = [], o = e.languages ?? [], s = t.fields ?? [];
+  for (const r of i.fields)
+    if (r.isRequired)
       for (const d of o) {
-        const l = r.find((c) => c.name === s.name && c.language === d);
-        (!l || N(l.value)) && n.push(`required field "${s.name}" is empty in language "${d}"`);
+        const l = s.find((c) => c.name === r.name && c.language === d);
+        (!l || N(l.value)) && a.push(`required field "${r.name}" is empty in language "${d}"`);
       }
-  for (const s of r) {
-    const d = i.fields.find((l) => l.name === s.name);
-    if (!(!d || N(s.value)))
+  for (const r of s) {
+    const d = i.fields.find((l) => l.name === r.name);
+    if (!(!d || N(r.value)))
       for (const l of d.validations ?? []) {
-        const c = H(l, s.value, d);
-        c && n.push(`field "${s.name}" [${s.language}]: ${c}`);
+        const c = pe(l, r.value, d);
+        c && a.push(`field "${r.name}" [${r.language}]: ${c}`);
       }
   }
-  return n.length === 0 ? { ok: !0 } : { ok: !1, errors: n };
-}, G = (e) => `Cannot publish content — preflight validation failed:
+  return a.length === 0 ? { ok: !0 } : { ok: !1, errors: a };
+}, he = (e) => `Cannot publish content — preflight validation failed:
 ${e.map((t) => `  - ${t}`).join(`
 `)}
 
-Fix the issues (e.g. via update-content-island-field-value) and retry. Use list-content-island-contents with the content id to inspect the current draft state.`, X = () => {
-  u.tool(
+Fix the issues (e.g. via update-content-island-field-value) and retry. Use list-content-island-contents with the content id to inspect the current draft state.`, ge = () => {
+  m.tool(
     "publish-content-island-content",
     `Publish an existing content in the Content Island project. This promotes the current draft state to the live state visible to consumers without the PREVIEW_ token prefix. Requires a write token.
 
@@ -592,30 +782,30 @@ Errors:
 - 404 if the contentId does not exist.
 - 401/403 if the configured token is not a write token.`,
     {
-      contentId: a.string().describe("The id of the existing content entry to publish.")
+      contentId: n.string().describe("The id of the existing content entry to publish.")
     },
     async ({ contentId: e }) => {
       try {
-        const t = g(), [i, n] = await Promise.all([t.getProject(), t.getRawContent({ id: e })]);
-        if (!n)
+        const t = h(), [i, a] = await Promise.all([t.getProject(), t.getRawContent({ id: e })]);
+        if (!a)
           return {
             content: [{ type: "text", text: `Content "${e}" not found.` }],
             isError: !0
           };
-        const o = Y(i, n);
+        const o = me(i, a);
         return o.ok === !1 ? {
-          content: [{ type: "text", text: G(o.errors) }],
+          content: [{ type: "text", text: he(o.errors) }],
           isError: !0
         } : (await t.publishContent(e), {
           content: [{ type: "text", text: JSON.stringify({ contentId: e, status: "published" }, null, 2) }]
         });
       } catch (t) {
-        return h(t);
+        return p(t);
       }
     }
   );
-}, z = () => {
-  u.tool(
+}, fe = () => {
+  m.tool(
     "update-content-island-field-value",
     `Update or add a single field value of an existing content in the Content Island project. Requires a write token.
 
@@ -657,26 +847,152 @@ Fields whose "type" contains "|" (e.g. "abc123|Foo") are either ENUMS or RELATIO
 
 The tool always identifies the field by its name within the content type. If the field is renamed in the schema between calls, this tool will return a 404; refresh the schema with get-content-island-project and retry.`,
     {
-      contentId: a.string().describe("The id of the existing content entry to update."),
-      fieldName: a.string().describe("Name of the field as defined in the content type schema (from get-content-island-project)."),
-      language: a.string().describe('Language code of the field value (e.g. "en", "es"). Must be one of the project languages.'),
-      value: a.any().describe(
+      contentId: n.string().describe("The id of the existing content entry to update."),
+      fieldName: n.string().describe("Name of the field as defined in the content type schema (from get-content-island-project)."),
+      language: n.string().describe('Language code of the field value (e.g. "en", "es"). Must be one of the project languages.'),
+      value: n.any().describe(
         "The new field value. Must match the type and isArray of the field as described in the tool description above."
       )
     },
-    async ({ contentId: e, fieldName: t, language: i, value: n }) => {
+    async ({ contentId: e, fieldName: t, language: i, value: a }) => {
       try {
-        return await g().updateContentFieldValue(e, { fieldName: t, language: i }, n), {
+        return await h().updateContentFieldValue(e, { fieldName: t, language: i }, a), {
           content: [
             { type: "text", text: JSON.stringify({ contentId: e, fieldName: t, language: i, status: "updated" }, null, 2) }
           ]
         };
       } catch (o) {
-        return h(o);
+        return p(o);
+      }
+    }
+  );
+}, ye = () => {
+  m.tool(
+    "update-content-island-enum",
+    `Edit an existing Enum using DECLARATIVE operations. The tool reads the current enum and applies your changes on top, preserving untouched values (and their ids) automatically.
+
+Operations (all optional, combine freely):
+- rename: new enum name.
+- addValues: new string values to append.
+- renameValues: change existing values by id ({ id, value }). Renaming propagates the new label into existing content.
+- removeValueIds: ids of values to delete.
+
+DESTRUCTIVE GUARD: removing a value also clears it from every existing content using it. If removeValueIds is non-empty and you do NOT pass confirm: true, the tool returns a DRY-RUN and does NOT mutate. To apply, do it in TWO steps: first call WITHOUT confirm to get the dry-run, then show the user that impact and re-invoke with confirm: true ONLY after the user explicitly approves. NEVER pass confirm: true on the first call or without the user's explicit go-ahead.`,
+    {
+      enumId: n.string().describe("The 24-char id of the enum to update."),
+      rename: n.string().optional().describe("New enum name."),
+      addValues: n.array(n.string()).optional().describe("Values to add (appended)."),
+      renameValues: n.array(n.object({ id: n.string(), value: n.string() })).optional().describe("Existing values to rename, keyed by id."),
+      removeValueIds: n.array(n.string()).optional().describe("Ids of values to remove. DESTRUCTIVE — requires confirm: true."),
+      confirm: n.boolean().optional().describe(
+        "Set to true to apply a destructive change (value removal). Without it, a destructive update returns a dry-run. Set it only AFTER the user has seen the dry-run and explicitly approved — never on the first call."
+      )
+    },
+    async ({ enumId: e, rename: t, addValues: i, renameValues: a, removeValueIds: o, confirm: s }) => {
+      try {
+        const r = h(), d = await r.getProject(), l = x(d.contentTypes, e);
+        if (!l)
+          return p(new Error(`Enum "${e}" not found in the project schema.`));
+        const c = {
+          rename: t,
+          addValues: i,
+          renameValues: a,
+          removeValueIds: o
+        };
+        if (ne(c) && !s) {
+          const u = ee(l, c), y = {
+            dryRun: !0,
+            wouldRemoveValueIds: u.wouldRemoveValueIds,
+            summary: `This update would remove ${u.wouldRemoveValueIds.length} value(s) from "${l.name}" and clear them from every existing content. Re-invoke with confirm: true to apply.`
+          };
+          return { content: [{ type: "text", text: JSON.stringify(y, null, 2) }] };
+        }
+        const f = Q(l, c), g = await r.updateEnum(e, f);
+        return { content: [{ type: "text", text: JSON.stringify(g, null, 2) }] };
+      } catch (r) {
+        return p(r);
+      }
+    }
+  );
+}, O = n.enum([
+  "short-text",
+  "long-text",
+  "number",
+  "date",
+  "date-time",
+  "media",
+  "boolean",
+  "color",
+  "relation",
+  "enum"
+]), Ee = n.object({
+  name: n.string(),
+  type: O,
+  relatedModelId: n.string().optional(),
+  isArray: n.boolean().optional(),
+  validations: n.array(b).optional()
+}), Te = n.object({
+  id: n.string().describe("The existing field id to modify (from get-content-island-project)."),
+  name: n.string().optional(),
+  type: O.optional(),
+  relatedModelId: n.string().optional(),
+  isArray: n.boolean().optional(),
+  validations: n.array(b).optional()
+}), ve = () => {
+  m.tool(
+    "update-content-island-model",
+    `Edit an existing Entity model using DECLARATIVE operations. The tool reads the current model and applies your changes on top, so you NEVER hand-build the full field list and untouched fields are preserved automatically.
+
+Operations (all optional, combine freely):
+- rename: new model name.
+- addFields: new fields to append.
+- updateFields: change existing fields by id (name/type/relatedModelId/isArray/validations).
+- removeFieldIds: ids of fields to delete.
+
+DESTRUCTIVE GUARD: removing a field also deletes its values from every existing content. If removeFieldIds is non-empty and you do NOT pass confirm: true, the tool returns a DRY-RUN describing the impact and does NOT mutate. To apply, do it in TWO steps: first call WITHOUT confirm to get the dry-run, then show the user that impact and re-invoke with confirm: true ONLY after the user explicitly approves. NEVER pass confirm: true on the first call or without the user's explicit go-ahead.`,
+    {
+      modelId: n.string().describe("The 24-char id of the entity to update."),
+      rename: n.string().optional().describe("New model name."),
+      addFields: n.array(Ee).optional().describe("Fields to add (appended after existing fields)."),
+      updateFields: n.array(Te).optional().describe("Existing fields to modify, keyed by id."),
+      removeFieldIds: n.array(n.string()).optional().describe("Ids of fields to remove. DESTRUCTIVE — requires confirm: true."),
+      confirm: n.boolean().optional().describe(
+        "Set to true to apply a destructive change (field removal). Without it, a destructive update returns a dry-run. Set it only AFTER the user has seen the dry-run and explicitly approved — never on the first call."
+      )
+    },
+    async ({ modelId: e, rename: t, addFields: i, updateFields: a, removeFieldIds: o, confirm: s }) => {
+      try {
+        const r = h(), d = await r.getProject(), l = R(d.contentTypes, e);
+        if (!l)
+          return p(new Error(`Entity "${e}" not found in the project schema.`));
+        const c = {
+          rename: t,
+          addFields: i?.map((u) => ({
+            ...u,
+            validations: I(u.validations)
+          })),
+          updateFields: a?.map((u) => ({
+            ...u,
+            validations: u.validations ? I(u.validations) : void 0
+          })),
+          removeFieldIds: o
+        };
+        if (te(c) && !s) {
+          const u = Z(l, c), y = {
+            dryRun: !0,
+            wouldRemoveFieldIds: u.wouldRemoveFieldIds,
+            summary: `This update would remove ${u.wouldRemoveFieldIds.length} field(s) from "${l.name}" and delete their values from every existing content. Re-invoke with confirm: true to apply.`
+          };
+          return { content: [{ type: "text", text: JSON.stringify(y, null, 2) }] };
+        }
+        const f = X(l, c), g = await r.updateModel(e, f);
+        return { content: [{ type: "text", text: JSON.stringify(g, null, 2) }] };
+      } catch (r) {
+        return p(r);
       }
     }
   );
-}, J = {
+}, Ie = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -690,42 +1006,42 @@ The tool always identifies the field by its name within the content type. If the
   ".mov": "video/quicktime",
   ".mp3": "audio/mpeg",
   ".wav": "audio/wav"
-}, Q = (e) => /^https?:\/\//i.test(e), Z = async (e) => {
+}, be = (e) => /^https?:\/\//i.test(e), we = async (e) => {
   const t = await fetch(e);
   if (!t.ok)
     throw new Error(`Failed to fetch ${e}: ${t.status} ${t.statusText}`);
-  const i = await t.blob(), n = new URL(e).pathname, o = A(n) || "download";
+  const i = await t.blob(), a = new URL(e).pathname, o = C(a) || "download";
   return { blob: i, fileName: o };
-}, ee = async (e) => {
-  const t = await S(e), i = O(e).toLowerCase(), n = J[i] ?? "application/octet-stream", o = new Blob([t], { type: n }), r = A(e);
-  return { blob: o, fileName: r };
-}, te = () => {
-  u.tool(
+}, Ne = async (e) => {
+  const t = await F(e), i = U(e).toLowerCase(), a = Ie[i] ?? "application/octet-stream", o = new Blob([t], { type: a }), s = C(e);
+  return { blob: o, fileName: s };
+}, Ae = () => {
+  m.tool(
     "upload-content-island-media",
     "Upload a media file to the Content Island project. Accepts a local file path or a URL (http/https). Requires a write token. Note: file attachments in the chat cannot be uploaded directly — provide the file path on disk or a public URL instead.",
     {
-      source: a.string().describe(
+      source: n.string().describe(
         'Path to a local file or a URL (http/https) pointing to the media to upload. Examples: "./assets/hero.png", "https://example.com/photo.jpg". File attachments in the conversation cannot be used directly — ask the user for the file path or URL.'
       ),
-      fileName: a.string().optional().describe(
+      fileName: n.string().optional().describe(
         "Override the file name used in Content Island. Defaults to the file name from the source path or URL."
       )
     },
     async ({ source: e, fileName: t }) => {
       try {
-        const { blob: i, fileName: n } = Q(e) ? await Z(e) : await ee(e), r = await g().uploadMedia({ file: i, fileName: t ?? n });
+        const { blob: i, fileName: a } = be(e) ? await we(e) : await Ne(e), s = await h().uploadMedia({ file: i, fileName: t ?? a });
         return {
-          content: [{ type: "text", text: JSON.stringify(r, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(s, null, 2) }]
         };
       } catch (i) {
-        return h(i);
+        return p(i);
       }
     }
   );
-}, ne = () => {
-  V(), q(), $(), z(), X(), te();
+}, Ce = () => {
+  se(), le(), B(), fe(), ge(), Ae(), ie(), H(), ve(), ye(), re(), oe();
 };
-U();
-ne();
-const ae = new x();
-await u.connect(ae);
+_();
+Ce();
+const Re = new D();
+await m.connect(Re);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-island/mcp",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "Content Island - MCP (Model Context Protocol) server",
   "private": false,
   "sideEffects": false,
@@ -30,10 +30,12 @@
   "scripts": {
     "build": "vite build",
     "debug": "npm run build && npx @modelcontextprotocol/inspector node ./dist/index",
-    "type-check": "tsc --noEmit --preserveWatchOutput"
+    "type-check": "tsc --noEmit --preserveWatchOutput",
+    "test": "vitest run -c ./config/test/config.ts",
+    "test:watch": "vitest -c ./config/test/config.ts"
   },
   "dependencies": {
-    "@content-island/api-client": "0.21.0",
+    "@content-island/api-client": "0.23.0",
     "@modelcontextprotocol/sdk": "1.13.3",
     "zod": "3.25.71"
   },