@paroicms/mcp-plugin 0.2.0

package/README.md

@@ -0,0 +1,58 @@
+# ParoiCMS MCP Plugin (`@paroicms/mcp-plugin`)
+
+MCP (Model Context Protocol) plugin for ParoiCMS. Enables AI assistants to search content in ParoiCMS sites. It contains:
+
+1. A backend plugin that exposes an HTTP API protected by Personal Access Tokens.
+2. A CLI tool that acts as an MCP server bridge between the AI agent and the remote backend.
+
+This package is part of [ParoiCMS](https://www.npmjs.com/package/@paroicms/server).
+
+## Installation of the backend plugin
+
+Install it:
+
+```sh
+npm i @paroicms/mcp-plugin
+```
+
+Enable it in your `site-schema.json`:
+
+```json
+{
+  "plugins": [
+    // ...
+    "@paroicms/mcp-plugin"
+  ]
+}
+```
+
+## Configuration of the MCP agent with the CLI tool
+
+### 1. Create a Personal Access Token
+
+1. Go to your ParoiCMS Admin UI
+2. Navigate to User Settings → Personal Access Tokens
+3. Copy the token (it will only be shown once)
+
+### 2. Configure your agent
+
+Add to your configuration in `.vscode/mcp.json` (VS Code):
+
+```json
+{
+  "servers": {
+    "paroicms-yoursite": {
+      "command": "npx",
+      "args": ["paroicms-mcp"],
+      "env": {
+        "PAROICMS_SITE_URL": "https://your-site.example.com",
+        "PAROICMS_PAT": "your-personal-access-token"
+      }
+    }
+  }
+}
+```
+
+## License
+
+Released under the [MIT license](https://gitlab.com/paroi/opensource/paroicms/-/blob/main/LICENSE.md).

package/backend/dist/api-handler.js

@@ -0,0 +1,76 @@
+import { messageOf } from "@paroicms/public-anywhere-lib";
+import { ApiError, } from "@paroicms/public-server-lib";
+import { McpApiRequestAT } from "./api-request-types.js";
+export async function handleApiRequest(service, httpContext, relativePath) {
+    const { req, res } = httpContext;
+    if (relativePath !== "")
+        throw new ApiError(404);
+    if (req.method !== "POST")
+        throw new ApiError(405);
+    const pat = extractBearerToken(req);
+    try {
+        const request = McpApiRequestAT.assert(req.body);
+        const connector = service.getSiteConnector({ pat });
+        const result = await executeAction(connector, request);
+        res.send({ success: true, data: result });
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            res.status(error.status).send({
+                success: false,
+                error: error.message,
+                code: error.status,
+            });
+        }
+        else {
+            service.logger.error("MCP API error:", error);
+            res.status(500).send({
+                success: false,
+                error: messageOf(error),
+            });
+        }
+    }
+}
+async function executeAction(connector, request) {
+    switch (request.action) {
+        case "searchDocuments":
+            return await handleSearchDocuments(connector, request.payload);
+        case "deleteDocument":
+            await connector.deleteDocument(request.payload.documentId);
+            return { success: true };
+        case "publishDocument":
+            await connector.publishDocument(request.payload.documentId, request.payload.publishDate);
+            return { success: true };
+        case "unpublishDocument":
+            await connector.unpublishDocument(request.payload.documentId);
+            return { success: true };
+        case "getDocument":
+            return await connector.getDocument(request.payload.documentId);
+        case "updateDocument":
+            await connector.updateDocument(request.payload.documentId, request.payload.values);
+            return { success: true };
+        case "updateFields":
+            await connector.updateFields(request.payload.lNodeId, request.payload.values);
+            return { success: true };
+        case "createDocument": {
+            const result = await connector.createDocument(request.payload);
+            return { lNodeId: result.documentId };
+        }
+        case "createPart": {
+            const result = await connector.createPart(request.payload);
+            return { lNodeId: result.partId };
+        }
+        case "getSiteInfo":
+            return await connector.getSiteInfo();
+    }
+}
+async function handleSearchDocuments(connector, payload) {
+    return await connector.searchDocuments(payload);
+}
+function extractBearerToken(req) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader?.startsWith("Bearer ")) {
+        throw new ApiError("Missing or invalid Authorization header", 401);
+    }
+    return authHeader.slice(7);
+}

package/backend/dist/api-request-types.js

@@ -0,0 +1,105 @@
+import { type } from "arktype";
+const SearchDocumentsMcpApiRequestAT = type({
+    action: '"searchDocuments"',
+    payload: {
+        language: "string",
+        words: "string[]",
+        "limit?": "number|undefined",
+        "offset?": "number|undefined",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const DeleteDocumentMcpApiRequestAT = type({
+    action: '"deleteDocument"',
+    payload: {
+        documentId: "string",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const PublishDocumentMcpApiRequestAT = type({
+    action: '"publishDocument"',
+    payload: {
+        documentId: "string",
+        "publishDate?": "string|undefined",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const UnpublishDocumentMcpApiRequestAT = type({
+    action: '"unpublishDocument"',
+    payload: {
+        documentId: "string",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const GetDocumentMcpApiRequestAT = type({
+    action: '"getDocument"',
+    payload: {
+        documentId: "string",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const UpdateDocumentMcpApiRequestAT = type({
+    action: '"updateDocument"',
+    payload: {
+        documentId: "string",
+        values: {
+            "title?": "string|undefined",
+            "slug?": "string|undefined",
+            "metaDescription?": "string|undefined",
+            "metaKeywords?": "string|undefined",
+            "+": "reject",
+        },
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const UpdateFieldsMcpApiRequestAT = type({
+    action: '"updateFields"',
+    payload: {
+        lNodeId: "string",
+        values: "object",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const CreateDocumentMcpApiRequestAT = type({
+    action: '"createDocument"',
+    payload: {
+        parentLNodeId: "string",
+        typeName: "string",
+        "title?": "string|undefined",
+        "slug?": "string|undefined",
+        "featuredImagePath?": "string|undefined",
+        "values?": "object|undefined",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const CreatePartMcpApiRequestAT = type({
+    action: '"createPart"',
+    payload: {
+        parentLNodeId: "string",
+        typeName: "string",
+        "values?": "object|undefined",
+        "+": "reject",
+    },
+    "+": "reject",
+});
+const GetSiteInfoMcpApiRequestAT = type({
+    action: '"getSiteInfo"',
+    "+": "reject",
+});
+export const McpApiRequestAT = SearchDocumentsMcpApiRequestAT.or(DeleteDocumentMcpApiRequestAT)
+    .or(PublishDocumentMcpApiRequestAT)
+    .or(UnpublishDocumentMcpApiRequestAT)
+    .or(GetDocumentMcpApiRequestAT)
+    .or(UpdateDocumentMcpApiRequestAT)
+    .or(UpdateFieldsMcpApiRequestAT)
+    .or(CreateDocumentMcpApiRequestAT)
+    .or(CreatePartMcpApiRequestAT)
+    .or(GetSiteInfoMcpApiRequestAT);

package/backend/dist/index.js

@@ -0,0 +1,13 @@
+import { esmDirName, extractPackageNameAndVersionSync } from "@paroicms/script-lib";
+import { dirname } from "node:path";
+import { handleApiRequest } from "./api-handler.js";
+const projectDir = dirname(esmDirName(import.meta.url));
+const packageDir = dirname(projectDir);
+const { version } = extractPackageNameAndVersionSync(packageDir);
+const plugin = {
+    version,
+    siteInit(service) {
+        service.setPublicApiHandler(handleApiRequest);
+    },
+};
+export default plugin;

package/cli/dist/constants.js

@@ -0,0 +1,3 @@
+import { esmDirName } from "@paroicms/script-lib";
+import { dirname } from "node:path";
+export const packageDir = dirname(dirname(esmDirName(import.meta.url)));

package/cli/dist/http-client.js

@@ -0,0 +1,21 @@
+import { getPluginApiUrl } from "@paroicms/script-lib";
+const PLUGIN_NAME = "@paroicms/mcp-plugin";
+export async function callApi(config, action, payload) {
+    const url = `${config.siteUrl}${getPluginApiUrl(PLUGIN_NAME)}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${config.pat}`,
+        },
+        body: JSON.stringify({ action, payload }),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP error ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.success) {
+        throw new Error(data.error ?? "Unknown API error");
+    }
+    return data.data;
+}

package/cli/dist/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { startMcpServer } from "./mcp-server.js";
+startMcpServer().catch((error) => {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+});

package/cli/dist/mcp-server.js

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools/index.js";
+export async function startMcpServer() {
+    const siteUrl = process.env.PAROICMS_SITE_URL;
+    const pat = process.env.PAROICMS_PAT;
+    if (siteUrl === undefined) {
+        throw new Error("PAROICMS_SITE_URL environment variable is required");
+    }
+    if (pat === undefined) {
+        throw new Error("PAROICMS_PAT environment variable is required");
+    }
+    const server = new McpServer({
+        name: "paroicms-mcp",
+        version: "0.1.0",
+    });
+    registerTools(server, { siteUrl, pat });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/cli/dist/tools/create-document.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerCreateDocumentTool(server, config) {
+    server.registerTool("paroicms_create_document", {
+        description: "Create a new document in ParoiCMS",
+        inputSchema: {
+            parentLNodeId: z
+                .string()
+                .describe("The parent's localized node ID (format: nodeId:language, e.g., '123:en')"),
+            typeName: z.string().describe("The document type name (e.g., 'article', 'blogPost')"),
+            title: z.string().optional().describe("Document title"),
+            slug: z
+                .string()
+                .optional()
+                .describe("URL slug (auto-generated from title if not provided)"),
+            values: z.string().optional().describe("Optional JSON object with field values"),
+        },
+    }, async ({ parentLNodeId, typeName, title, slug, values: valuesJson }) => {
+        let values;
+        if (valuesJson) {
+            try {
+                values = JSON.parse(valuesJson);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: "Invalid JSON for values parameter." }],
+                    isError: true,
+                };
+            }
+        }
+        const result = await callApi(config, "createDocument", {
+            parentLNodeId,
+            typeName,
+            title,
+            slug,
+            values,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Document created successfully.\nID: ${result.lNodeId}`,
+                },
+            ],
+        };
+    });
+}

package/cli/dist/tools/create-part.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerCreatePartTool(server, config) {
+    server.registerTool("paroicms_create_part", {
+        description: "Create a new part (sub-section) within a document or another part in ParoiCMS",
+        inputSchema: {
+            parentLNodeId: z
+                .string()
+                .describe("The parent's localized node ID (format: nodeId:language, e.g., '123:en')"),
+            typeName: z.string().describe("The part type name (e.g., 'textBlock', 'imageGallery')"),
+            values: z.string().optional().describe("Optional JSON object with field values"),
+        },
+    }, async ({ parentLNodeId, typeName, values: valuesJson }) => {
+        let values;
+        if (valuesJson) {
+            try {
+                values = JSON.parse(valuesJson);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: "Invalid JSON for values parameter." }],
+                    isError: true,
+                };
+            }
+        }
+        const result = await callApi(config, "createPart", {
+            parentLNodeId,
+            typeName,
+            values,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Part created successfully.\nID: ${result.lNodeId}`,
+                },
+            ],
+        };
+    });
+}

package/cli/dist/tools/delete-document.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerDeleteDocumentTool(server, config) {
+    server.registerTool("paroicms_delete_document", {
+        description: "Delete a document from ParoiCMS (single language version)",
+        inputSchema: {
+            documentId: z.string().describe("The document ID"),
+        },
+    }, async ({ documentId }) => {
+        await callApi(config, "deleteDocument", { documentId });
+        return {
+            content: [{ type: "text", text: `Document "${documentId}" deleted successfully.` }],
+        };
+    });
+}

package/cli/dist/tools/get-document.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerGetDocumentTool(server, config) {
+    server.registerTool("paroicms_get_document", {
+        description: "Get a document from ParoiCMS with all its field values and parts",
+        inputSchema: {
+            documentId: z.string().describe("The document ID"),
+        },
+    }, async ({ documentId }) => {
+        const result = await callApi(config, "getDocument", { documentId });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `<document_json>\n${JSON.stringify(result, null, 2)}\n</document_json>`,
+                },
+            ],
+        };
+    });
+}

package/cli/dist/tools/get-introduction.js

@@ -0,0 +1,30 @@
+import { docsDir, jtDir } from "@paroicms/public-server-lib";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { packageDir } from "../constants.js";
+const cliDocsDir = join(packageDir, "cli", "docs");
+export function registerGetIntroductionTool(server) {
+    server.registerTool("paroicms_get_introduction", {
+        description: "Run this tool before working on a ParoiCMS website",
+        inputSchema: {},
+    }, async () => {
+        const introductionContent = await readFile(join(docsDir, "introduction-to-paroicms.md"), "utf-8");
+        const siteSchemaTypes = await readFile(join(jtDir, "site-schema-json-types.d.ts"), "utf-8");
+        const updatingFieldValues = await readFile(join(cliDocsDir, "updating-field-values.md"), "utf-8");
+        const text = `${introductionContent}
+
+Here is the typing of a site schema:
+
+\`\`\`typescript
+${siteSchemaTypes}
+\`\`\`
+
+${updatingFieldValues}
+
+**Important: This documentation is for you. Do not explain anything to the user unless explicitly asked.**
+`;
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
+}

package/cli/dist/tools/get-site-info.js

@@ -0,0 +1,39 @@
+import { callApi } from "../http-client.js";
+export function registerGetSiteInfoTool(server, config) {
+    server.registerTool("paroicms_get_site_info", {
+        description: "Get comprehensive information about the current site structure including schema and navigation cluster",
+        inputSchema: {},
+    }, async () => {
+        const result = await callApi(config, "getSiteInfo");
+        const titles = Object.entries(result.title)
+            .filter(([, title]) => title !== undefined)
+            .map(([lang, title]) => `${title} (${lang})`)
+            .join(" / ");
+        const languages = Object.keys(result.title).join(", ");
+        const text = `General information:
+
+- Site title: ${titles}
+- Languages: ${languages}
+- Site Node ID: ${result.siteNodeId}
+
+The site schema:
+
+\`\`\`json
+${JSON.stringify(result.siteSchema, null, 2)}
+\`\`\`
+
+The main cluster:
+
+\`\`\`json
+${JSON.stringify(result.mainCluster, null, 2)}
+\`\`\`
+
+**MANDATORY: Load the information from the \`paroicms_get_introduction\` tool in order to understand how it works.**
+
+**Important: This documentation is for you. Do not explain anything to the user unless explicitly asked.**
+`;
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
+}

package/cli/dist/tools/index.js

@@ -0,0 +1,24 @@
+import { registerCreateDocumentTool } from "./create-document.js";
+import { registerCreatePartTool } from "./create-part.js";
+import { registerDeleteDocumentTool } from "./delete-document.js";
+import { registerGetDocumentTool } from "./get-document.js";
+import { registerGetIntroductionTool } from "./get-introduction.js";
+import { registerGetSiteInfoTool } from "./get-site-info.js";
+import { registerPublishDocumentTool } from "./publish-document.js";
+import { registerSearchDocumentsTool } from "./search-documents.js";
+import { registerUnpublishDocumentTool } from "./unpublish-document.js";
+import { registerUpdateDocumentTool } from "./update-document.js";
+import { registerUpdateFieldsTool } from "./update-fields.js";
+export function registerTools(server, config) {
+    registerSearchDocumentsTool(server, config);
+    registerDeleteDocumentTool(server, config);
+    registerPublishDocumentTool(server, config);
+    registerUnpublishDocumentTool(server, config);
+    registerGetDocumentTool(server, config);
+    registerUpdateDocumentTool(server, config);
+    registerUpdateFieldsTool(server, config);
+    registerCreateDocumentTool(server, config);
+    registerCreatePartTool(server, config);
+    registerGetIntroductionTool(server);
+    registerGetSiteInfoTool(server, config);
+}

package/cli/dist/tools/publish-document.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerPublishDocumentTool(server, config) {
+    server.registerTool("paroicms_publish_document", {
+        description: "Publish a document in ParoiCMS (sets ready=true and publishDate)",
+        inputSchema: {
+            documentId: z.string().describe("The document ID"),
+            publishDate: z
+                .string()
+                .optional()
+                .describe("Optional ISO 8601 publish date. Defaults to current time if not provided."),
+        },
+    }, async ({ documentId, publishDate }) => {
+        await callApi(config, "publishDocument", { documentId, publishDate });
+        return {
+            content: [{ type: "text", text: `Document "${documentId}" published successfully.` }],
+        };
+    });
+}

package/cli/dist/tools/search-documents.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerSearchDocumentsTool(server, config) {
+    server.registerTool("paroicms_search_documents", {
+        description: "Search for documents in ParoiCMS by keywords",
+        inputSchema: {
+            language: z.string().describe("The language code (e.g., 'en', 'fr')"),
+            keywords: z.string().describe("Space-separated keywords to search for"),
+            limit: z.number().optional().describe("Maximum number of results (default: 20)"),
+            offset: z.number().optional().describe("Number of results to skip (for pagination)"),
+        },
+    }, async ({ language, keywords, limit, offset }) => {
+        const words = keywords
+            .split(/\s+/)
+            .map((w) => w.trim())
+            .filter((w) => w.length > 0);
+        if (words.length === 0) {
+            return {
+                content: [{ type: "text", text: "Error: No valid keywords provided" }],
+                isError: true,
+            };
+        }
+        const result = await callApi(config, "searchDocuments", {
+            language,
+            words,
+            limit,
+            offset,
+        });
+        const count = result.total ?? result.items.length;
+        const responseText = result.items.length > 0
+            ? `Found ${count} document${count !== 1 ? "s" : ""}:\n\n<documents_json>\n${JSON.stringify(result.items, null, 2)}\n</documents_json>`
+            : "No documents found matching your search.";
+        return {
+            content: [{ type: "text", text: responseText }],
+        };
+    });
+}

package/cli/dist/tools/unpublish-document.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerUnpublishDocumentTool(server, config) {
+    server.registerTool("paroicms_unpublish_document", {
+        description: "Unpublish a document in ParoiCMS (sets ready=false, keeps publishDate)",
+        inputSchema: {
+            documentId: z.string().describe("The document ID"),
+        },
+    }, async ({ documentId }) => {
+        await callApi(config, "unpublishDocument", { documentId });
+        return {
+            content: [{ type: "text", text: `Document "${documentId}" unpublished successfully.` }],
+        };
+    });
+}

package/cli/dist/tools/update-document.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerUpdateDocumentTool(server, config) {
+    server.registerTool("paroicms_update_document", {
+        description: "Update document metadata (title, slug, metaDescription, metaKeywords) in ParoiCMS",
+        inputSchema: {
+            documentId: z.string().describe("The document ID"),
+            title: z.string().optional().describe("New title for the document"),
+            slug: z.string().optional().describe("New slug for the document URL"),
+            metaDescription: z.string().optional().describe("Meta description for SEO"),
+            metaKeywords: z.string().optional().describe("Meta keywords for SEO"),
+        },
+    }, async ({ documentId, title, slug, metaDescription, metaKeywords }) => {
+        const values = {};
+        if (title !== undefined)
+            values.title = title;
+        if (slug !== undefined)
+            values.slug = slug;
+        if (metaDescription !== undefined)
+            values.metaDescription = metaDescription;
+        if (metaKeywords !== undefined)
+            values.metaKeywords = metaKeywords;
+        if (Object.keys(values).length === 0) {
+            return {
+                content: [{ type: "text", text: "No values provided to update." }],
+                isError: true,
+            };
+        }
+        await callApi(config, "updateDocument", { documentId, values });
+        return {
+            content: [{ type: "text", text: `Document "${documentId}" updated successfully.` }],
+        };
+    });
+}

package/cli/dist/tools/update-fields.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { callApi } from "../http-client.js";
+export function registerUpdateFieldsTool(server, config) {
+    server.registerTool("paroicms_update_fields", {
+        description: "Update field values on a document, part, or site node in ParoiCMS. Use null to clear a field.",
+        inputSchema: {
+            lNodeId: z
+                .string()
+                .describe("The localized node ID (format: nodeId:language, e.g., '123:en')"),
+            values: z
+                .string()
+                .describe('JSON object with field names as keys and values to set. Use null to clear a field. Example: {"leadParagraph": "New intro text", "htmlContent": null}'),
+        },
+    }, async ({ lNodeId, values: valuesJson }) => {
+        let values;
+        try {
+            values = JSON.parse(valuesJson);
+        }
+        catch {
+            return {
+                content: [{ type: "text", text: "Invalid JSON for values parameter." }],
+                isError: true,
+            };
+        }
+        if (typeof values !== "object" || values === null) {
+            return {
+                content: [{ type: "text", text: "Values must be a JSON object." }],
+                isError: true,
+            };
+        }
+        await callApi(config, "updateFields", { lNodeId, values });
+        return {
+            content: [{ type: "text", text: `Fields updated successfully on "${lNodeId}".` }],
+        };
+    });
+}

package/cli/docs/updating-field-values.md

@@ -0,0 +1,43 @@
+## Updating Field Values
+
+When using the `paroicms_update_fields` tool, different field types require different value formats:
+
+### Simple fields (string, number, boolean, date, time, dateTime)
+
+```json
+{"myField": "value"}
+```
+
+### Rich text fields (Tiptap or Quill editor plugins)
+
+Always send the content as **Markdown**:
+
+```json
+{"myRichTextField": "# Title\n\nParagraph text with **bold** and *italic*."}
+```
+
+### Labeling fields (taxonomy terms like tags, categories)
+
+Use the `{"t": [...]}` wrapper with an array of term node IDs:
+
+```json
+{"myLabelingField": {"t": ["16", "17"]}}
+```
+
+To clear all terms: `{"myLabelingField": {"t": []}}`
+
+### JSON fields
+
+Use the `{"j": ...}` wrapper:
+
+```json
+{"myJsonField": {"j": {"key": "value"}}}
+```
+
+### Clearing a field
+
+Use `null`:
+
+```json
+{"myField": null}
+```

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@paroicms/mcp-plugin",
+  "version": "0.2.0",
+  "description": "MCP (Model Context Protocol) plugin for ParoiCMS - enables AI assistants to search content",
+  "keywords": [
+    "paroicms",
+    "plugin",
+    "mcp",
+    "model-context-protocol",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/paroi/opensource/paroicms.git",
+    "directory": "plugins/mcp-plugin"
+  },
+  "author": "Paroi Team",
+  "license": "MIT",
+  "type": "module",
+  "main": "backend/dist/index.js",
+  "bin": {
+    "paroicms-mcp": "cli/dist/index.js"
+  },
+  "scripts": {
+    "build": "npm run build:backend && npm run build:cli",
+    "build:backend": "(cd backend && tsc)",
+    "build:backend:watch": "(cd backend && tsc --watch --preserveWatchOutput)",
+    "build:cli": "(cd cli && tsc)",
+    "build:cli:watch": "(cd cli && tsc --watch --preserveWatchOutput)",
+    "clear": "rimraf backend/dist/* cli/dist/*",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "~1.22.0",
+    "@paroicms/script-lib": "0.3.9",
+    "arktype": "~2.1.27",
+    "zod": "~3.25.76"
+  },
+  "peerDependencies": {
+    "@paroicms/public-anywhere-lib": "0",
+    "@paroicms/public-server-lib": "0"
+  },
+  "devDependencies": {
+    "@paroicms/public-anywhere-lib": "0.39.0",
+    "@paroicms/public-server-lib": "0.49.0",
+    "@types/node": "~24.10.1",
+    "rimraf": "~6.1.2",
+    "typescript": "~5.9.3",
+    "vitest": "~4.0.13"
+  },
+  "files": [
+    "backend/dist",
+    "cli/dist",
+    "cli/docs"
+  ]
+}