@easy-cms/plugin-mcp 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Kanawoot K.
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md ADDED
@@ -0,0 +1,22 @@
1
+ # @easy-cms/plugin-mcp
2
+
3
+ An MCP server for [Easy CMS](https://maritonx.github.io/easy-cms/): AI assistants such as Claude,
4
+ Cursor or VS Code read and write your content with an API key, only where the key allows.
5
+ Collections with drafts are always saved as drafts; publishing is a separate tool.
6
+
7
+ ```ts
8
+ import { mcpPlugin } from '@easy-cms/plugin-mcp'
9
+
10
+ export default defineConfig({
11
+ // …
12
+ apiKeys: true,
13
+ plugins: [mcpPlugin()],
14
+ })
15
+ ```
16
+
17
+ ```bash
18
+ claude mcp add --transport http easy-cms https://example.com/api/cms/mcp \
19
+ --header "Authorization: Bearer ecms_…"
20
+ ```
21
+
22
+ See [MCP](https://maritonx.github.io/easy-cms/guide/mcp).
@@ -0,0 +1,40 @@
1
+ import { EasyCMS, AuthUser, Plugin } from '@easy-cms/core';
2
+
3
+ /** A JSON Schema, as MCP tools describe their input. */
4
+ type JsonSchema = Record<string, unknown>;
5
+
6
+ type Data = Record<string, unknown>;
7
+ interface Tool {
8
+ readonly name: string;
9
+ readonly description: string;
10
+ readonly inputSchema: JsonSchema;
11
+ run(args: Data): Promise<unknown>;
12
+ }
13
+ interface ToolOptions {
14
+ /** Collections to offer (default: all the key may use). */
15
+ readonly collections?: readonly string[];
16
+ /** Globals to offer (default: all the key may use). */
17
+ readonly globals?: readonly string[];
18
+ }
19
+ /**
20
+ * The tools a user (normally an API key) may use: one per collection or global and operation,
21
+ * only where the key allows it. Access rules are applied again on every call.
22
+ */
23
+ declare function buildTools(cms: EasyCMS, user: AuthUser, options?: ToolOptions): Tool[];
24
+
25
+ interface McpPluginOptions extends ToolOptions {
26
+ /** Path under the REST API. Default `/mcp`, so the server is at `/api/cms/mcp`. */
27
+ readonly path?: string;
28
+ /** Name the assistant sees for this server. Default `easy-cms`. */
29
+ readonly name?: string;
30
+ /** Extra guidance for the assistant, e.g. your house style. Added to the built-in notes. */
31
+ readonly instructions?: string;
32
+ }
33
+ /**
34
+ * An MCP server (Streamable HTTP, stateless) for AI assistants such as Claude, Cursor or
35
+ * ChatGPT. Clients authenticate with an Easy CMS API key and get tools for exactly what the
36
+ * key allows. Needs `apiKeys: true`.
37
+ */
38
+ declare function mcpPlugin(options?: McpPluginOptions): Plugin;
39
+
40
+ export { type McpPluginOptions, type Tool, type ToolOptions, buildTools, mcpPlugin };
package/dist/index.js ADDED
@@ -0,0 +1,438 @@
1
+ // src/plugin.ts
2
+ import {
3
+ EasyCMSError,
4
+ ValidationError
5
+ } from "@easy-cms/core";
6
+ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
7
+ import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
8
+ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
9
+
10
+ // src/tools.ts
11
+ import {
12
+ INTERNAL_COLLECTIONS,
13
+ keyAllows
14
+ } from "@easy-cms/core";
15
+
16
+ // src/schema.ts
17
+ var text = (label2, extra = {}) => ({
18
+ type: "string",
19
+ ...label2 ? { description: label2 } : {},
20
+ ...extra
21
+ });
22
+ function describe(field) {
23
+ const label2 = field.label;
24
+ if (typeof label2 === "string") return label2;
25
+ return label2?.en ?? Object.values(label2 ?? {})[0];
26
+ }
27
+ var RICH_TEXT_HINT = 'Rich text: plain text (blank lines start new paragraphs) or a Tiptap JSON document { "type": "doc", "content": [...] }';
28
+ function fieldSchema(field) {
29
+ const label2 = describe(field);
30
+ const hint = (extra) => label2 ? `${label2}. ${extra}` : extra;
31
+ switch (field.type) {
32
+ case "text":
33
+ case "textarea":
34
+ return text(label2, {
35
+ ...field.minLength !== void 0 ? { minLength: field.minLength } : {},
36
+ ...field.maxLength !== void 0 ? { maxLength: field.maxLength } : {}
37
+ });
38
+ case "email":
39
+ return text(label2, { format: "email" });
40
+ case "slug":
41
+ return text(hint("URL slug; made from the title when left out"));
42
+ case "date":
43
+ return text(hint("ISO 8601 date and time"), { format: "date-time" });
44
+ case "number":
45
+ return {
46
+ type: "number",
47
+ ...label2 ? { description: label2 } : {},
48
+ ...field.min !== void 0 ? { minimum: field.min } : {},
49
+ ...field.max !== void 0 ? { maximum: field.max } : {}
50
+ };
51
+ case "boolean":
52
+ return { type: "boolean", ...label2 ? { description: label2 } : {} };
53
+ case "select": {
54
+ const values = field.options.map((o) => typeof o === "string" ? o : o.value);
55
+ const one = { type: "string", enum: values };
56
+ return field.hasMany ? { type: "array", items: one, ...label2 ? { description: label2 } : {} } : { ...one, ...label2 ? { description: label2 } : {} };
57
+ }
58
+ case "json":
59
+ return { ...label2 ? { description: label2 } : {} };
60
+ case "richText":
61
+ return { description: hint(RICH_TEXT_HINT) };
62
+ case "upload": {
63
+ const id2 = {
64
+ type: ["integer", "string"],
65
+ description: hint("id of a media document (see upload_media)")
66
+ };
67
+ return id2;
68
+ }
69
+ case "relationship": {
70
+ const id2 = { type: ["integer", "string"] };
71
+ const about = hint(`id of a document in "${field.to}"`);
72
+ return field.hasMany ? { type: "array", items: id2, description: about } : { ...id2, description: about };
73
+ }
74
+ case "group":
75
+ return { ...objectSchema(field.fields, false), ...label2 ? { description: label2 } : {} };
76
+ case "array":
77
+ return {
78
+ type: "array",
79
+ items: withRowId(objectSchema(field.fields, false)),
80
+ ...field.minRows !== void 0 ? { minItems: field.minRows } : {},
81
+ ...field.maxRows !== void 0 ? { maxItems: field.maxRows } : {},
82
+ ...label2 ? { description: label2 } : {}
83
+ };
84
+ case "blocks":
85
+ return {
86
+ type: "array",
87
+ description: hint("Rows of these kinds; set blockType on each"),
88
+ items: {
89
+ anyOf: field.blocks.map((block) => {
90
+ const schema = withRowId(objectSchema(block.fields, false));
91
+ return {
92
+ ...schema,
93
+ properties: { blockType: { const: block.slug }, ...schema.properties },
94
+ required: ["blockType", ...schema.required ?? []]
95
+ };
96
+ })
97
+ }
98
+ };
99
+ }
100
+ }
101
+ function objectSchema(fields, strict) {
102
+ const visible = fields.filter((f) => !f.hidden);
103
+ const required = strict ? visible.filter((f) => f.required && f.defaultValue === void 0 && f.type !== "slug").map((f) => f.name) : [];
104
+ return {
105
+ type: "object",
106
+ properties: Object.fromEntries(visible.map((f) => [f.name, fieldSchema(f)])),
107
+ ...required.length ? { required } : {},
108
+ additionalProperties: false
109
+ };
110
+ }
111
+ function withRowId(schema) {
112
+ return {
113
+ ...schema,
114
+ properties: {
115
+ id: { type: "string", description: "Row id; leave out for new rows" },
116
+ ...schema.properties
117
+ }
118
+ };
119
+ }
120
+ function prepareInput(fields, data) {
121
+ const out = { ...data };
122
+ for (const field of fields) {
123
+ const value = out[field.name];
124
+ if (value === void 0 || value === null) continue;
125
+ if (field.type === "richText" && typeof value === "string") out[field.name] = toDoc(value);
126
+ else if (field.type === "group" && typeof value === "object")
127
+ out[field.name] = prepareInput(field.fields, value);
128
+ else if (field.type === "array" && Array.isArray(value))
129
+ out[field.name] = value.map(
130
+ (row) => typeof row === "object" && row !== null ? prepareInput(field.fields, row) : row
131
+ );
132
+ else if (field.type === "blocks" && Array.isArray(value))
133
+ out[field.name] = value.map((row) => {
134
+ const block = field.blocks.find((b) => b.slug === row?.blockType);
135
+ return block && typeof row === "object" ? prepareInput(block.fields, row) : row;
136
+ });
137
+ }
138
+ return out;
139
+ }
140
+ function toDoc(text2) {
141
+ const paragraphs = text2.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
142
+ return {
143
+ type: "doc",
144
+ content: paragraphs.map((paragraph) => {
145
+ const lines = paragraph.split("\n");
146
+ return {
147
+ type: "paragraph",
148
+ content: lines.flatMap((line, i) => [
149
+ ...i > 0 ? [{ type: "hardBreak" }] : [],
150
+ ...line ? [{ type: "text", text: line }] : []
151
+ ])
152
+ };
153
+ })
154
+ };
155
+ }
156
+
157
+ // src/tools.ts
158
+ var NEVER = /* @__PURE__ */ new Set(["users", "api-keys"]);
159
+ var MAX_LIMIT = 100;
160
+ var id = { type: ["integer", "string"], description: "Document id" };
161
+ var localeProp = (cms) => cms.config.localization ? {
162
+ locale: {
163
+ type: "string",
164
+ enum: [...cms.config.localization.locales, "all"],
165
+ description: `Content language (default ${cms.config.localization.defaultLocale}); "all" returns every language`
166
+ }
167
+ } : {};
168
+ var obj = (properties, required = []) => ({
169
+ type: "object",
170
+ properties,
171
+ ...required.length ? { required } : {},
172
+ additionalProperties: false
173
+ });
174
+ function buildTools(cms, user, options = {}) {
175
+ const access = { user, overrideAccess: false };
176
+ const may = (target, op) => keyAllows(user, target, op);
177
+ const tools = [];
178
+ const locale = localeProp(cms);
179
+ const pickLocale = (args) => typeof args.locale === "string" ? { locale: args.locale } : {};
180
+ const collections = cms.config.collections.filter(
181
+ (c) => !NEVER.has(c.slug) && !INTERNAL_COLLECTIONS.has(c.slug) && (!options.collections || options.collections.includes(c.slug))
182
+ );
183
+ for (const c of collections) {
184
+ const slug = c.slug;
185
+ const target = { collection: slug };
186
+ const name = label(slug, c.labels?.plural);
187
+ const drafts = c.drafts === true;
188
+ if (may(target, "read")) {
189
+ tools.push({
190
+ name: `find_${slug}`,
191
+ description: `List ${name}. Filter with where, e.g. { "title": { "like": "news" } } (operators: equals, not_equals, in, not_in, gt, gte, lt, lte, like, exists; combine with and/or).${drafts ? " Includes drafts." : ""}`,
192
+ inputSchema: obj({
193
+ where: { type: "object", description: "Filter" },
194
+ sort: {
195
+ type: "string",
196
+ description: "Field to sort by; prefix with - for descending, e.g. -createdAt"
197
+ },
198
+ limit: { type: "integer", minimum: 1, maximum: MAX_LIMIT, description: "Default 10" },
199
+ page: { type: "integer", minimum: 1 },
200
+ ...locale
201
+ }),
202
+ run: async (args) => cms.find(slug, {
203
+ ...access,
204
+ draft: true,
205
+ depth: 0,
206
+ ...args.where ? { where: args.where } : {},
207
+ ...typeof args.sort === "string" ? { sort: args.sort } : {},
208
+ limit: Math.min(MAX_LIMIT, Math.max(1, Number(args.limit ?? 10))),
209
+ page: Math.max(1, Number(args.page ?? 1)),
210
+ ...pickLocale(args)
211
+ })
212
+ });
213
+ tools.push({
214
+ name: `get_${slug}`,
215
+ description: `Read one ${name} document by id, with its relationships.`,
216
+ inputSchema: obj({ id, ...locale }, ["id"]),
217
+ run: async (args) => {
218
+ const doc = await cms.findById(slug, args.id, {
219
+ ...access,
220
+ draft: true,
221
+ depth: 1,
222
+ ...pickLocale(args)
223
+ });
224
+ if (!doc) throw new Error(`No ${slug} document with id ${String(args.id)}`);
225
+ return doc;
226
+ }
227
+ });
228
+ }
229
+ if (slug !== "media" && may(target, "create")) {
230
+ tools.push({
231
+ name: `create_${slug}`,
232
+ description: `Create a ${name} document.${drafts ? ` It is saved as a draft; call publish_${slug} to put it live.` : ""}`,
233
+ inputSchema: obj({ data: objectSchema(c.fields, !drafts), ...locale }, ["data"]),
234
+ run: async (args) => cms.create(slug, asDraft(c, prepareInput(c.fields, args.data ?? {})), {
235
+ ...access,
236
+ depth: 0,
237
+ ...pickLocale(args)
238
+ })
239
+ });
240
+ }
241
+ if (may(target, "update")) {
242
+ tools.push({
243
+ name: `update_${slug}`,
244
+ description: `Change fields of a ${name} document; fields left out stay as they are.${drafts ? ` Changes are saved as a draft; call publish_${slug} to put them live.` : ""}`,
245
+ inputSchema: obj({ id, data: objectSchema(c.fields, false), ...locale }, ["id", "data"]),
246
+ run: async (args) => cms.update(
247
+ slug,
248
+ args.id,
249
+ asDraft(c, prepareInput(c.fields, args.data ?? {})),
250
+ { ...access, depth: 0, ...pickLocale(args) }
251
+ )
252
+ });
253
+ }
254
+ if (may(target, "delete")) {
255
+ tools.push({
256
+ name: `delete_${slug}`,
257
+ description: `Delete a ${name} document. This cannot be undone.`,
258
+ inputSchema: obj({ id }, ["id"]),
259
+ run: async (args) => cms.delete(slug, args.id, access)
260
+ });
261
+ }
262
+ if (drafts && may(target, "publish")) {
263
+ tools.push({
264
+ name: `publish_${slug}`,
265
+ description: `Publish a ${name} document (with its latest draft), so the site shows it.`,
266
+ inputSchema: obj({ id }, ["id"]),
267
+ run: async (args) => cms.update(slug, args.id, { status: "published" }, { ...access, depth: 0 })
268
+ });
269
+ tools.push({
270
+ name: `unpublish_${slug}`,
271
+ description: `Take a ${name} document off the site.`,
272
+ inputSchema: obj({ id }, ["id"]),
273
+ run: async (args) => cms.unpublish(slug, args.id, { ...access, depth: 0 })
274
+ });
275
+ if (c.schedule) {
276
+ tools.push({
277
+ name: `schedule_${slug}`,
278
+ description: `Publish or unpublish a ${name} document at a later time.`,
279
+ inputSchema: obj(
280
+ {
281
+ id,
282
+ action: { type: "string", enum: ["publish", "unpublish"] },
283
+ at: { type: "string", format: "date-time", description: "ISO 8601 time" }
284
+ },
285
+ ["id", "action", "at"]
286
+ ),
287
+ run: async (args) => cms.schedule(
288
+ slug,
289
+ args.id,
290
+ { action: args.action, at: String(args.at) },
291
+ access
292
+ )
293
+ });
294
+ }
295
+ }
296
+ }
297
+ if (cms.config.collections.some((c) => c.slug === "media") && (!options.collections || options.collections.includes("media")) && may({ collection: "media" }, "create")) {
298
+ tools.push({
299
+ name: "upload_media",
300
+ description: `Upload a file to the media library (at most ${cms.config.upload.maxFileSize} bytes). Returns the media document; use its id in upload fields.`,
301
+ inputSchema: obj(
302
+ {
303
+ filename: { type: "string", description: "e.g. cover.jpg" },
304
+ data: { type: "string", description: "The file, base64-encoded" },
305
+ alt: { type: "string", description: "Alternative text for images" }
306
+ },
307
+ ["filename", "data"]
308
+ ),
309
+ run: async (args) => {
310
+ const bytes = Buffer.from(String(args.data), "base64");
311
+ return cms.upload(
312
+ { data: new Uint8Array(bytes), name: String(args.filename) },
313
+ typeof args.alt === "string" ? { alt: args.alt } : {},
314
+ { ...access, depth: 0 }
315
+ );
316
+ }
317
+ });
318
+ }
319
+ for (const g of cms.config.globals) {
320
+ if (options.globals && !options.globals.includes(g.slug)) continue;
321
+ const slug = g.slug;
322
+ const target = { global: slug };
323
+ const name = label(slug, g.label);
324
+ const drafts = g.drafts === true;
325
+ if (may(target, "read")) {
326
+ tools.push({
327
+ name: `get_global_${slug}`,
328
+ description: `Read the ${name} settings.`,
329
+ inputSchema: obj({ ...locale }),
330
+ run: async (args) => cms.findGlobal(slug, { ...access, draft: true, depth: 1, ...pickLocale(args) })
331
+ });
332
+ }
333
+ if (may(target, "update")) {
334
+ tools.push({
335
+ name: `update_global_${slug}`,
336
+ description: `Change the ${name} settings; fields left out stay as they are.${drafts ? ` Saved as a draft; call publish_global_${slug} to put it live.` : ""}`,
337
+ inputSchema: obj({ data: objectSchema(g.fields, false), ...locale }, ["data"]),
338
+ run: async (args) => cms.updateGlobal(slug, asDraft(g, prepareInput(g.fields, args.data ?? {})), {
339
+ ...access,
340
+ depth: 0,
341
+ ...pickLocale(args)
342
+ })
343
+ });
344
+ }
345
+ if (drafts && may(target, "publish")) {
346
+ tools.push({
347
+ name: `publish_global_${slug}`,
348
+ description: `Publish the ${name} settings.`,
349
+ inputSchema: obj({}),
350
+ run: async () => cms.updateGlobal(slug, { status: "published" }, { ...access, depth: 0 })
351
+ });
352
+ }
353
+ }
354
+ return tools;
355
+ }
356
+ function asDraft(container, data) {
357
+ if (!container.drafts) return data;
358
+ const { status: _status, ...rest } = data;
359
+ return { ...rest, status: "draft" };
360
+ }
361
+ function label(slug, value) {
362
+ const text2 = typeof value === "string" ? value : value?.en;
363
+ return text2 ? `${text2} (${slug})` : `"${slug}"`;
364
+ }
365
+
366
+ // src/plugin.ts
367
+ var DEFAULT_INSTRUCTIONS = `Tools read and change the content of an Easy CMS site. Each collection has its own tools, named after it (find_posts, create_posts\u2026), and only what this API key allows is listed.
368
+ - Collections with drafts: create and update save drafts that visitors don't see. Only publish_<collection> puts a document live; ask before publishing unless you were told to.
369
+ - Relationship and upload fields take document ids: find the related document first, or upload a file with upload_media.
370
+ - Rich text fields accept plain text (blank lines separate paragraphs).
371
+ - Deleting cannot be undone.`;
372
+ function mcpPlugin(options = {}) {
373
+ return (config) => {
374
+ if (!config.apiKeys)
375
+ throw new Error("mcpPlugin: set `apiKeys: true`; assistants connect with an API key");
376
+ const endpoint = {
377
+ path: options.path ?? "/mcp",
378
+ method: "post",
379
+ handler: async ({ request, user, cms }) => {
380
+ if (!user?.apiKey) {
381
+ return Response.json(
382
+ { errors: [{ message: "Connect with an API key: Authorization: Bearer ecms_\u2026" }] },
383
+ { status: 401, headers: { "www-authenticate": "Bearer" } }
384
+ );
385
+ }
386
+ const tools = buildTools(cms, user, options);
387
+ const server = new Server(
388
+ { name: options.name ?? "easy-cms", version: "1.0.0" },
389
+ {
390
+ capabilities: { tools: {} },
391
+ instructions: options.instructions ? `${DEFAULT_INSTRUCTIONS}
392
+
393
+ ${options.instructions}` : DEFAULT_INSTRUCTIONS
394
+ }
395
+ );
396
+ server.setRequestHandler(ListToolsRequestSchema, async () => ({
397
+ tools: tools.map(({ name, description, inputSchema }) => ({
398
+ name,
399
+ description,
400
+ inputSchema
401
+ }))
402
+ }));
403
+ server.setRequestHandler(CallToolRequestSchema, async (call) => {
404
+ const tool = tools.find((t) => t.name === call.params.name);
405
+ if (!tool)
406
+ return failure(`Unknown tool "${call.params.name}", or this API key may not use it`);
407
+ try {
408
+ const result = await tool.run(call.params.arguments ?? {});
409
+ return { content: [{ type: "text", text: JSON.stringify(result ?? null, null, 2) }] };
410
+ } catch (error) {
411
+ return failure(describe2(error));
412
+ }
413
+ });
414
+ const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
415
+ await server.connect(transport);
416
+ try {
417
+ return await transport.handleRequest(request);
418
+ } finally {
419
+ await server.close();
420
+ }
421
+ }
422
+ };
423
+ return { ...config, endpoints: [...config.endpoints ?? [], endpoint] };
424
+ };
425
+ }
426
+ function failure(text2) {
427
+ return { isError: true, content: [{ type: "text", text: text2 }] };
428
+ }
429
+ function describe2(error) {
430
+ if (error instanceof ValidationError)
431
+ return `Invalid data: ${error.errors.map((e) => `${e.field}: ${e.message}`).join("; ")}`;
432
+ if (error instanceof EasyCMSError) return error.message;
433
+ return `Failed: ${error.message ?? String(error)}`;
434
+ }
435
+ export {
436
+ buildTools,
437
+ mcpPlugin
438
+ };
package/package.json ADDED
@@ -0,0 +1,51 @@
1
+ {
2
+ "name": "@easy-cms/plugin-mcp",
3
+ "version": "0.14.0",
4
+ "description": "MCP server for Easy CMS: let AI assistants read and write content with API keys",
5
+ "license": "MIT",
6
+ "type": "module",
7
+ "sideEffects": false,
8
+ "exports": {
9
+ ".": {
10
+ "types": "./dist/index.d.ts",
11
+ "default": "./dist/index.js"
12
+ },
13
+ "./package.json": "./package.json"
14
+ },
15
+ "files": [
16
+ "dist"
17
+ ],
18
+ "dependencies": {
19
+ "@modelcontextprotocol/sdk": "^1.30.1"
20
+ },
21
+ "peerDependencies": {
22
+ "@easy-cms/core": "^0.14.0"
23
+ },
24
+ "devDependencies": {
25
+ "@easy-cms/core": "^0.14.0",
26
+ "@easy-cms/db-sqlite": "^0.14.0"
27
+ },
28
+ "engines": {
29
+ "node": ">=22.12"
30
+ },
31
+ "publishConfig": {
32
+ "access": "public"
33
+ },
34
+ "repository": {
35
+ "type": "git",
36
+ "url": "git+https://github.com/maritonx/easy-cms.git",
37
+ "directory": "packages/plugin-mcp"
38
+ },
39
+ "keywords": [
40
+ "easy-cms",
41
+ "easy-cms-plugin",
42
+ "mcp",
43
+ "model-context-protocol",
44
+ "ai"
45
+ ],
46
+ "scripts": {
47
+ "build": "tsup",
48
+ "typecheck": "tsc --noEmit",
49
+ "test": "vitest run"
50
+ }
51
+ }