@lynkow/mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,2041 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+
+// src/index.ts
+var DEFAULT_API_URL = "https://api.lynkow.com";
+var configSchema = z.object({
+  apiUrl: z.string().url().default(DEFAULT_API_URL),
+  apiToken: z.string().min(1, "LYNKOW_API_TOKEN is required"),
+  locale: z.string().default("fr"),
+  timeout: z.coerce.number().default(3e4),
+  debug: z.coerce.boolean().default(false)
+});
+function loadConfig() {
+  return configSchema.parse({
+    apiUrl: process.env.LYNKOW_API_URL || DEFAULT_API_URL,
+    apiToken: process.env.LYNKOW_API_TOKEN,
+    locale: process.env.LYNKOW_LOCALE,
+    timeout: process.env.LYNKOW_TIMEOUT,
+    debug: process.env.LYNKOW_DEBUG
+  });
+}
+
+// src/client/api-client.ts
+var LynkowApiClient = class {
+  baseUrl;
+  token;
+  timeout;
+  debug;
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/$/, "");
+    this.token = config.apiToken;
+    this.timeout = config.timeout;
+    this.debug = config.debug;
+  }
+  async get(path, params) {
+    const url = new URL(`/v1${path}`, this.baseUrl);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+      }
+    }
+    return this.request("GET", url);
+  }
+  async post(path, body) {
+    const url = new URL(`/v1${path}`, this.baseUrl);
+    return this.request("POST", url, body);
+  }
+  async put(path, body) {
+    const url = new URL(`/v1${path}`, this.baseUrl);
+    return this.request("PUT", url, body);
+  }
+  async delete(path, params) {
+    const url = new URL(`/v1${path}`, this.baseUrl);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+      }
+    }
+    return this.request("DELETE", url);
+  }
+  async request(method, url, body) {
+    if (this.debug) {
+      console.error(`[lynkow-mcp] ${method} ${url.pathname}${url.search}`);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new ApiError(
+          response.status,
+          error.error || response.statusText,
+          error
+        );
+      }
+      if (response.status === 204) return {};
+      return response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var ApiError = class extends Error {
+  constructor(status, message, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.name = "ApiError";
+  }
+};
+function handleApiError(error) {
+  if (error instanceof ApiError) {
+    switch (error.status) {
+      case 400:
+        throw new McpError(ErrorCode.InvalidParams, error.message);
+      case 401:
+        throw new McpError(ErrorCode.InvalidRequest, "Invalid or expired API token");
+      case 403:
+        throw new McpError(
+          ErrorCode.InvalidRequest,
+          `Permission denied: ${error.message}. Check your API token permissions.`
+        );
+      case 404:
+        throw new McpError(ErrorCode.InvalidParams, `Not found: ${error.message}`);
+      case 422:
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `Validation error: ${JSON.stringify(error.details)}`
+        );
+      case 429:
+        throw new McpError(ErrorCode.InvalidRequest, "Rate limit exceeded. Please wait.");
+      default:
+        throw new McpError(ErrorCode.InternalError, `API error ${error.status}: ${error.message}`);
+    }
+  }
+  throw new McpError(
+    ErrorCode.InternalError,
+    error instanceof Error ? error.message : "Unknown error"
+  );
+}
+
+// src/utils/formatting.ts
+function jsonResponse(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// src/tools/contents.ts
+function registerContentTools(server, client) {
+  server.tool(
+    "list_contents",
+    "List content items (blog posts, articles) with filtering, search, and pagination",
+    {
+      page: z.number().optional().describe("Page number (default: 1)"),
+      perPage: z.number().optional().describe("Items per page (default: 15)"),
+      status: z.enum(["draft", "published", "archived", "scheduled"]).optional(),
+      type: z.string().optional().describe("Content type filter"),
+      search: z.string().optional().describe("Search in title and content"),
+      locale: z.string().optional().describe("Filter by locale"),
+      category: z.string().optional().describe("Category ID filter"),
+      tag: z.string().optional().describe("Tag ID filter"),
+      sort: z.string().optional().describe('Sort field (e.g., "created_at", "title")'),
+      order: z.enum(["asc", "desc"]).optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/contents", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_content",
+    "Get a single content item by ID with full details",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/contents/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "search_contents",
+    "Full-text search across all content",
+    {
+      q: z.string().describe("Search query"),
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      locale: z.string().optional()
+    },
+    async ({ q, ...params }) => {
+      try {
+        return jsonResponse(await client.get("/contents/search", { q, ...params }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_content",
+    "Create a new content item (blog post, article, etc.)",
+    {
+      title: z.string().describe("Content title"),
+      slug: z.string().optional().describe("URL slug (auto-generated if omitted)"),
+      type: z.string().optional().describe('Content type (default: "post")'),
+      excerpt: z.string().optional().describe("Short excerpt/summary"),
+      body: z.any().optional().describe("Content body (rich text blocks)"),
+      status: z.enum(["draft", "published"]).optional().describe("Initial status (default: draft)"),
+      locale: z.string().optional().describe("Content locale"),
+      categoryIds: z.array(z.number()).optional().describe("Category IDs to assign"),
+      tagIds: z.array(z.number()).optional().describe("Tag IDs to assign"),
+      meta: z.record(z.any()).optional().describe("SEO and custom fields")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/contents", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_content",
+    "Update an existing content item",
+    {
+      id: z.number().describe("Content ID"),
+      title: z.string().optional(),
+      slug: z.string().optional(),
+      excerpt: z.string().optional(),
+      body: z.any().optional(),
+      status: z.string().optional(),
+      meta: z.record(z.any()).optional(),
+      categoryIds: z.array(z.number()).optional(),
+      tagIds: z.array(z.number()).optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/contents/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_content",
+    "Delete a content item permanently",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/contents/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "publish_content",
+    "Publish a draft content item, making it visible on the site",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.post(`/contents/${id}/publish`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "archive_content",
+    "Archive a content item (removes from public view but keeps data)",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.post(`/contents/${id}/archive`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "duplicate_content",
+    "Create a copy of a content item as a new draft",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.post(`/contents/${id}/duplicate`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_publish_contents",
+    "Publish multiple content items at once",
+    { ids: z.array(z.number()).describe("Array of content IDs to publish") },
+    async ({ ids }) => {
+      try {
+        return jsonResponse(await client.post("/contents/bulk/publish", { ids }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_archive_contents",
+    "Archive multiple content items at once",
+    { ids: z.array(z.number()).describe("Array of content IDs to archive") },
+    async ({ ids }) => {
+      try {
+        return jsonResponse(await client.post("/contents/bulk/archive", { ids }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_delete_contents",
+    "Delete multiple content items at once",
+    { ids: z.array(z.number()).describe("Array of content IDs to delete") },
+    async ({ ids }) => {
+      try {
+        return jsonResponse(await client.post("/contents/bulk/delete", { ids }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_content_revisions",
+    "Get version history of a content item",
+    {
+      id: z.number().describe("Content ID"),
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async ({ id, ...params }) => {
+      try {
+        return jsonResponse(await client.get(`/contents/${id}/revisions`, params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerSiteBlockTools(server, client) {
+  server.tool(
+    "list_site_blocks",
+    "List all site blocks (pages and global blocks) with optional filtering",
+    {
+      type: z.enum(["block", "page"]).optional(),
+      tag: z.string().optional(),
+      locale: z.string().optional(),
+      status: z.string().optional(),
+      search: z.string().optional(),
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/site-blocks", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_site_block",
+    "Get a site block by its slug",
+    {
+      slug: z.string().describe("Site block slug"),
+      locale: z.string().optional()
+    },
+    async ({ slug, ...params }) => {
+      try {
+        return jsonResponse(await client.get(`/site-blocks/${slug}`, params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_site_block",
+    "Create a new site block (page or global block) with schema and optional data",
+    {
+      name: z.string().describe("Block name"),
+      slug: z.string().describe("URL slug"),
+      type: z.enum(["block", "page"]).describe("Block type"),
+      schema: z.any().describe("Field schema: { fields: [...] }"),
+      data: z.any().optional().describe("Initial content data"),
+      path: z.string().optional().describe("URL path (for pages)"),
+      tags: z.array(z.string()).optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/site-blocks", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_site_block_schema",
+    "Update the field schema of a site block (affects all translations)",
+    {
+      slug: z.string().describe("Site block slug"),
+      schema: z.any().describe("New field schema")
+    },
+    async ({ slug, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/site-blocks/${slug}/schema`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_site_block_data",
+    "Update the content data of a site block for a specific locale",
+    {
+      slug: z.string().describe("Site block slug"),
+      data: z.any().describe("Content data object"),
+      locale: z.string().optional()
+    },
+    async ({ slug, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/site-blocks/${slug}/data`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_site_block",
+    "Delete a site block. Use locale param to delete only a translation.",
+    {
+      slug: z.string().describe("Site block slug"),
+      locale: z.string().optional().describe("Delete only this locale translation")
+    },
+    async ({ slug, locale }) => {
+      try {
+        return jsonResponse(await client.delete(`/site-blocks/${slug}`, locale ? { locale } : void 0));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "publish_site_block",
+    "Publish a site block, making it live on the website",
+    {
+      slug: z.string().describe("Site block slug"),
+      locale: z.string().optional()
+    },
+    async ({ slug, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/site-blocks/${slug}/publish`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "unpublish_site_block",
+    "Unpublish a site block, reverting it to draft",
+    {
+      slug: z.string().describe("Site block slug"),
+      locale: z.string().optional()
+    },
+    async ({ slug, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/site-blocks/${slug}/unpublish`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_site_block_revisions",
+    "Get version history of a site block",
+    {
+      slug: z.string().describe("Site block slug"),
+      locale: z.string().optional(),
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async ({ slug, ...params }) => {
+      try {
+        return jsonResponse(await client.get(`/site-blocks/${slug}/revisions`, params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "restore_site_block_revision",
+    "Restore a previous version of a site block",
+    {
+      slug: z.string().describe("Site block slug"),
+      revisionId: z.number().describe("Revision ID to restore"),
+      locale: z.string().optional()
+    },
+    async ({ slug, revisionId, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/site-blocks/${slug}/revisions/${revisionId}/restore`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerCategoryTools(server, client) {
+  server.tool(
+    "list_categories",
+    "List categories with pagination",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      search: z.string().optional(),
+      locale: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/categories", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_categories_tree",
+    "Get the full category hierarchy as a tree structure",
+    { locale: z.string().optional() },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/categories/tree", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_category",
+    "Get a single category by ID",
+    { id: z.number().describe("Category ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/categories/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_category",
+    "Create a new category",
+    {
+      name: z.string().describe("Category name"),
+      slug: z.string().optional(),
+      description: z.string().optional(),
+      parentId: z.number().optional().describe("Parent category ID for nesting"),
+      image: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/categories", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_category",
+    "Update an existing category",
+    {
+      id: z.number().describe("Category ID"),
+      name: z.string().optional(),
+      slug: z.string().optional(),
+      description: z.string().optional(),
+      parentId: z.number().optional(),
+      image: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/categories/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_category",
+    "Delete a category",
+    { id: z.number().describe("Category ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/categories/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "copy_category_to_locale",
+    "Copy a category to another language. Automatically resolves parent in target locale.",
+    {
+      id: z.number().describe("Category ID"),
+      targetLocale: z.string().describe('Target locale code (e.g., "en", "es")')
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/categories/${id}/copy-to-locale`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerTagTools(server, client) {
+  server.tool(
+    "list_tags",
+    "List tags with pagination",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      search: z.string().optional(),
+      locale: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/tags", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_tag",
+    "Get a single tag by ID",
+    { id: z.number().describe("Tag ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/tags/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_tag",
+    "Create a new tag",
+    {
+      name: z.string().describe("Tag name"),
+      slug: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/tags", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_tag",
+    "Update an existing tag",
+    {
+      id: z.number().describe("Tag ID"),
+      name: z.string().optional(),
+      slug: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/tags/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_tag",
+    "Delete a tag",
+    { id: z.number().describe("Tag ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/tags/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_tag_translations",
+    "Get translation status for a tag across all enabled locales",
+    { id: z.number().describe("Tag ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/tags/${id}/translations`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "copy_tag_to_locale",
+    "Copy a tag to another language",
+    {
+      id: z.number().describe("Tag ID"),
+      targetLocale: z.string().describe('Target locale code (e.g., "en", "es")')
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/tags/${id}/copy-to-locale`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerVariableTools(server, client) {
+  server.tool(
+    "list_variables",
+    "List all site variables (reusable key-value pairs like company name, phone, etc.)",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      search: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/variables", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_variable",
+    "Get a single variable by ID",
+    { id: z.number().describe("Variable ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/variables/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_variable",
+    "Create a new site variable",
+    {
+      key: z.string().describe("Variable key"),
+      value: z.string().describe("Variable value"),
+      description: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/variables", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_variable",
+    "Update a variable value or description",
+    {
+      id: z.number().describe("Variable ID"),
+      key: z.string().optional(),
+      value: z.string().optional(),
+      description: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/variables/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_variable",
+    "Delete a variable",
+    { id: z.number().describe("Variable ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/variables/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_variable_translations",
+    "Get translation status for a variable",
+    { id: z.number().describe("Variable ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/variables/${id}/translations`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "copy_variable_to_locale",
+    "Copy a variable to another language",
+    {
+      id: z.number().describe("Variable ID"),
+      targetLocale: z.string().describe('Target locale code (e.g., "en", "es")')
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/variables/${id}/copy-to-locale`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerMediaTools(server, client) {
+  server.tool(
+    "list_media",
+    "List media files with optional folder filtering",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      search: z.string().optional(),
+      type: z.enum(["image", "video", "document"]).optional(),
+      folderId: z.number().optional().describe("Filter by folder ID")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/media", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_media",
+    "Get a single media file details (URL, dimensions, metadata)",
+    { id: z.number().describe("Media ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/media/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "upload_media",
+    "Upload a media file from a URL. The file is downloaded by the server.",
+    {
+      url: z.string().url().describe("URL of the file to upload"),
+      name: z.string().optional(),
+      alt: z.string().optional().describe("Alt text for accessibility"),
+      folderId: z.number().optional().describe("Target folder ID")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/media", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_media",
+    "Update media metadata (name, alt text, description)",
+    {
+      id: z.number().describe("Media ID"),
+      name: z.string().optional(),
+      alt: z.string().optional(),
+      description: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/media/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_media",
+    "Move a media file to trash",
+    { id: z.number().describe("Media ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/media/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_media_references",
+    "Find all content items that use this media file",
+    { id: z.number().describe("Media ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/media/${id}/references`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "list_media_folders",
+    "List media folders (root or children of a parent folder)",
+    { parentId: z.number().optional().describe("Parent folder ID (omit for root)") },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/media-folders", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_media_folder_tree",
+    "Get the complete folder hierarchy as a tree",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/media-folders/tree"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_media_folder",
+    "Create a new media folder (max 3 levels deep)",
+    {
+      name: z.string().describe("Folder name"),
+      parentId: z.number().optional().describe("Parent folder ID")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/media-folders", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "rename_media_folder",
+    "Rename a media folder",
+    {
+      id: z.number().describe("Folder ID"),
+      name: z.string().describe("New folder name")
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/media-folders/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_media_folder",
+    "Delete a media folder. Choose whether to delete files or move them to root.",
+    {
+      id: z.number().describe("Folder ID"),
+      action: z.enum(["delete_files", "move_to_root"]).describe("What to do with files inside")
+    },
+    async ({ id, action }) => {
+      try {
+        return jsonResponse(await client.delete(`/media-folders/${id}`, { action }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "move_media_to_folder",
+    "Move one or more media files into a folder (or back to root with null folderId)",
+    {
+      mediaIds: z.array(z.number()).describe("Array of media IDs to move"),
+      folderId: z.number().nullable().describe("Target folder ID (null for root)")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/media-folders/move-media", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerFormTools(server, client) {
+  server.tool(
+    "list_forms",
+    "List all forms (contact, newsletter, etc.)",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      status: z.string().optional(),
+      search: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/forms", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_form",
+    "Get a form with its schema definition",
+    { id: z.number().describe("Form ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/forms/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_form",
+    "Create a new form with field schema",
+    {
+      name: z.string().describe("Form name"),
+      slug: z.string().optional(),
+      schema: z.any().describe("Form field schema"),
+      settings: z.record(z.any()).optional(),
+      status: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/forms", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_form",
+    "Update a form schema or settings",
+    {
+      id: z.number().describe("Form ID"),
+      name: z.string().optional(),
+      schema: z.any().optional(),
+      settings: z.record(z.any()).optional(),
+      status: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/forms/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_form",
+    "Delete a form and all its submissions",
+    { id: z.number().describe("Form ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/forms/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "list_form_submissions",
+    "List submissions for a specific form",
+    {
+      id: z.number().describe("Form ID"),
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      status: z.enum(["new", "read", "archived", "spam"]).optional()
+    },
+    async ({ id, ...params }) => {
+      try {
+        return jsonResponse(await client.get(`/forms/${id}/submissions`, params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_form_submission",
+    "Get a single submission with all submitted data",
+    {
+      id: z.number().describe("Form ID"),
+      submissionId: z.number().describe("Submission ID")
+    },
+    async ({ id, submissionId }) => {
+      try {
+        return jsonResponse(await client.get(`/forms/${id}/submissions/${submissionId}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_submission_status",
+    "Change the status of a form submission (mark as read, archive, spam)",
+    {
+      id: z.number().describe("Form ID"),
+      submissionId: z.number().describe("Submission ID"),
+      status: z.enum(["new", "read", "archived", "spam"]).describe("New status")
+    },
+    async ({ id, submissionId, status }) => {
+      try {
+        return jsonResponse(await client.put(`/forms/${id}/submissions/${submissionId}/status`, { status }));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_form_submission",
+    "Delete a form submission",
+    {
+      id: z.number().describe("Form ID"),
+      submissionId: z.number().describe("Submission ID")
+    },
+    async ({ id, submissionId }) => {
+      try {
+        return jsonResponse(await client.delete(`/forms/${id}/submissions/${submissionId}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "export_form_submissions",
+    "Export all submissions for a form as CSV",
+    { id: z.number().describe("Form ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/forms/${id}/submissions/export`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerReviewTools(server, client) {
+  server.tool(
+    "list_reviews",
+    "List customer reviews with filtering",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      status: z.enum(["pending", "approved", "rejected"]).optional(),
+      rating: z.number().optional(),
+      search: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/reviews", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_review",
+    "Get a single review with all details",
+    { id: z.number().describe("Review ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/reviews/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_review",
+    "Create a new review manually",
+    {
+      authorName: z.string().describe("Reviewer name"),
+      content: z.string().describe("Review text"),
+      rating: z.number().min(1).max(5).describe("Rating (1-5)"),
+      email: z.string().optional(),
+      status: z.enum(["pending", "approved", "rejected"]).optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/reviews", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_review",
+    "Update a review (content, rating, status)",
+    {
+      id: z.number().describe("Review ID"),
+      content: z.string().optional(),
+      rating: z.number().min(1).max(5).optional(),
+      status: z.enum(["pending", "approved", "rejected"]).optional(),
+      response: z.string().optional().describe("Owner response to the review")
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/reviews/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_review",
+    "Delete a review",
+    { id: z.number().describe("Review ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/reviews/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_review_stats",
+    "Get review statistics (average rating, count by status, distribution)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/reviews/stats"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_moderate_reviews",
+    "Approve or reject multiple reviews at once",
+    {
+      ids: z.array(z.number()).describe("Array of review IDs"),
+      status: z.enum(["pending", "approved", "rejected"]).describe("New status")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/reviews/bulk-status", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_delete_reviews",
+    "Delete multiple reviews at once",
+    { ids: z.array(z.number()).describe("Array of review IDs") },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/reviews/bulk-delete", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_review_settings",
+    "Get review moderation settings (auto-approve, require rating, etc.)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/reviews/settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_review_settings",
+    "Update review moderation settings",
+    {
+      autoApprove: z.boolean().optional(),
+      requireModeration: z.boolean().optional(),
+      allowAnonymous: z.boolean().optional(),
+      ratingRequired: z.boolean().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/reviews/settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerSeoTools(server, client) {
+  server.tool(
+    "get_seo_settings",
+    "Get global SEO settings (default meta, robots.txt config)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/seo/settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_seo_settings",
+    "Update global SEO settings",
+    {
+      defaultTitle: z.string().optional(),
+      defaultDescription: z.string().optional(),
+      robotsTxt: z.string().optional(),
+      indexNowEnabled: z.boolean().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/seo/settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_seo_sitemap_json",
+    "Get the generated sitemap as JSON (for analysis/review)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/seo/sitemap.json"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "test_indexnow",
+    "Test IndexNow submission for a specific URL",
+    { url: z.string().describe("URL to submit to IndexNow") },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/seo/indexnow/test", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_indexnow_logs",
+    "Get logs of IndexNow submissions to search engines",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/seo/indexnow/logs", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_indexnow_stats",
+    "Get IndexNow submission statistics (success/error counts)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/seo/indexnow/stats"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerSitemapTools(server, client) {
+  server.tool(
+    "list_sitemap_entries",
+    "List custom sitemap entries",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/sitemap/entries", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_sitemap_entry",
+    "Add a custom entry to the sitemap",
+    {
+      loc: z.string().describe("URL path"),
+      changefreq: z.string().optional().describe("Change frequency (daily, weekly, monthly, etc.)"),
+      priority: z.number().optional().describe("Priority (0.0 to 1.0)")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/sitemap/entries", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_sitemap_entry",
+    "Update a sitemap entry",
+    {
+      id: z.number().describe("Entry ID"),
+      loc: z.string().optional(),
+      changefreq: z.string().optional(),
+      priority: z.number().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/sitemap/entries/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_sitemap_entry",
+    "Remove a custom entry from the sitemap",
+    { id: z.number().describe("Entry ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/sitemap/entries/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "preview_sitemap",
+    "Preview the generated sitemap XML",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/sitemap/preview"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "export_sitemap_entries",
+    "Export all sitemap entries as CSV",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/sitemap/entries/export"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "import_sitemap_entries",
+    "Import sitemap entries from JSON",
+    {
+      entries: z.array(z.object({
+        loc: z.string(),
+        changefreq: z.string().optional(),
+        priority: z.number().optional()
+      })).describe("Array of sitemap entries to import")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/sitemap/entries/import", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerRedirectTools(server, client) {
+  server.tool(
+    "list_redirects",
+    "List all URL redirections",
+    {
+      page: z.number().optional(),
+      perPage: z.number().optional(),
+      search: z.string().optional(),
+      statusCode: z.number().optional().describe("Filter by status code (301, 302, 307, 308)"),
+      isActive: z.boolean().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/redirects", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_redirect",
+    "Get a single redirect rule",
+    { id: z.number().describe("Redirect ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/redirects/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_redirect",
+    "Create a new URL redirection rule",
+    {
+      sourcePath: z.string().describe("Source path to redirect from"),
+      targetPath: z.string().describe("Target path to redirect to"),
+      statusCode: z.number().optional().describe("HTTP status code (default: 301)"),
+      isRegex: z.boolean().optional().describe("Treat sourcePath as regex"),
+      preserveQueryString: z.boolean().optional(),
+      note: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/redirects", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_redirect",
+    "Update a redirect rule",
+    {
+      id: z.number().describe("Redirect ID"),
+      sourcePath: z.string().optional(),
+      targetPath: z.string().optional(),
+      statusCode: z.number().optional(),
+      isActive: z.boolean().optional(),
+      note: z.string().optional()
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.put(`/redirects/${id}`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_redirect",
+    "Delete a redirect rule",
+    { id: z.number().describe("Redirect ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.delete(`/redirects/${id}`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "bulk_delete_redirects",
+    "Delete multiple redirect rules at once",
+    { ids: z.array(z.number()).describe("Array of redirect IDs") },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/redirects/bulk-delete", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "import_redirects",
+    "Import redirect rules from JSON",
+    {
+      redirects: z.array(z.object({
+        sourcePath: z.string(),
+        targetPath: z.string(),
+        statusCode: z.number().optional(),
+        isRegex: z.boolean().optional(),
+        preserveQueryString: z.boolean().optional()
+      })).describe("Array of redirect rules to import")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.post("/redirects/import", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "export_redirects",
+    "Export all redirect rules as CSV",
+    { isActive: z.boolean().optional() },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/redirects/export", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerAnalyticsTools(server, client) {
+  server.tool(
+    "get_analytics_overview",
+    "Get analytics overview (visitors, pageviews, bounce rate, top pages)",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+      endDate: z.string().optional().describe("End date (YYYY-MM-DD)")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/overview", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_pages",
+    "Get page-level analytics (views, avg time, bounce rate per page)",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      startDate: z.string().optional(),
+      endDate: z.string().optional(),
+      page: z.number().optional(),
+      perPage: z.number().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/pages", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_sources",
+    "Get traffic sources (referrers, search engines, social, direct)",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      startDate: z.string().optional(),
+      endDate: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/referrers", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_realtime",
+    "Get real-time analytics snapshot (active visitors, current pages)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/analytics/realtime"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_engagement",
+    "Get engagement metrics (avg time on page, scroll depth, bounce rate)",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      startDate: z.string().optional(),
+      endDate: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/engagement", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_funnels",
+    "Get conversion funnel data",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      funnelId: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/funnels", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_analytics_settings",
+    "Get analytics tracking configuration",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/analytics/settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_analytics_settings",
+    "Update analytics tracking configuration",
+    {
+      trackingEnabled: z.boolean().optional(),
+      anonymizeIp: z.boolean().optional(),
+      sessionTimeout: z.number().optional(),
+      botFiltering: z.boolean().optional(),
+      excludedPaths: z.array(z.string()).optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/analytics/settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "export_analytics",
+    "Export analytics data as CSV",
+    {
+      period: z.enum(["7d", "30d", "90d"]).optional(),
+      startDate: z.string().optional(),
+      endDate: z.string().optional(),
+      type: z.enum(["overview", "pages", "sources"]).optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.get("/analytics/export", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerSettingsTools(server, client) {
+  server.tool(
+    "get_site_info",
+    "Get basic site information (name, domain, locales, timezone)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/site/info"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_site_settings",
+    "Get all site settings",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/site/settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_site_settings",
+    "Update general site settings (name, domain, timezone, etc.)",
+    {
+      name: z.string().optional(),
+      domain: z.string().optional(),
+      description: z.string().optional(),
+      timezone: z.string().optional(),
+      dateFormat: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/site/settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_language_settings",
+    "Get multi-language configuration (enabled locales, default locale)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/site/settings/language"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_language_settings",
+    "Enable/disable multi-language, add/remove locales, change default locale",
+    {
+      defaultLocale: z.string().describe('Default locale code (e.g., "fr")'),
+      enabledLocales: z.array(z.string()).describe("Array of enabled locale codes"),
+      multiLanguageEnabled: z.boolean().describe("Whether multi-language is enabled")
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/site/settings/language", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_spam_settings",
+    "Get anti-spam protection settings (honeypot, reCAPTCHA)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/spam-settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_spam_settings",
+    "Update anti-spam configuration",
+    {
+      protectionMethod: z.string().optional(),
+      honeypotEnabled: z.boolean().optional(),
+      minSubmissionTimeMs: z.number().optional(),
+      recaptchaEnabled: z.boolean().optional(),
+      recaptchaSiteKey: z.string().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/spam-settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_cookie_consent_settings",
+    "Get cookie consent banner configuration",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/cookie-consent/settings"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_cookie_consent_settings",
+    "Update cookie consent banner configuration",
+    {
+      enabled: z.boolean().optional(),
+      position: z.string().optional(),
+      theme: z.string().optional(),
+      categories: z.any().optional()
+    },
+    async (params) => {
+      try {
+        return jsonResponse(await client.put("/cookie-consent/settings", params));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_notification_settings",
+    "Get email notification settings (form submissions, reviews, etc.)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/settings/notifications"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+function registerTranslationTools(server, client) {
+  server.tool(
+    "get_content_translations",
+    "Get translation status for a content item across all enabled locales",
+    { id: z.number().describe("Content ID") },
+    async ({ id }) => {
+      try {
+        return jsonResponse(await client.get(`/contents/${id}/translations`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "copy_content_to_locale",
+    "Copy a content item to another language, creating a linked translation",
+    {
+      id: z.number().describe("Content ID"),
+      targetLocale: z.string().describe('Target locale code (e.g., "en", "es")')
+    },
+    async ({ id, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/contents/${id}/copy-to-locale`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_site_block_translations",
+    "Get translation status for a site block (page/global block)",
+    { slug: z.string().describe("Site block slug") },
+    async ({ slug }) => {
+      try {
+        return jsonResponse(await client.get(`/site-blocks/${slug}/translations`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "copy_site_block_to_locale",
+    "Copy a site block to another language",
+    {
+      slug: z.string().describe("Site block slug"),
+      targetLocale: z.string().describe('Target locale code (e.g., "en", "es")')
+    },
+    async ({ slug, ...body }) => {
+      try {
+        return jsonResponse(await client.post(`/site-blocks/${slug}/copy-to-locale`, body));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_available_locales",
+    "Get all available locales with labels and flags (reference data)",
+    {},
+    async () => {
+      try {
+        return jsonResponse(await client.get("/site/settings/locales"));
+      } catch (error) {
+        handleApiError(error);
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, client, _config) {
+  registerContentTools(server, client);
+  registerSiteBlockTools(server, client);
+  registerCategoryTools(server, client);
+  registerTagTools(server, client);
+  registerVariableTools(server, client);
+  registerMediaTools(server, client);
+  registerFormTools(server, client);
+  registerReviewTools(server, client);
+  registerSeoTools(server, client);
+  registerSitemapTools(server, client);
+  registerRedirectTools(server, client);
+  registerAnalyticsTools(server, client);
+  registerSettingsTools(server, client);
+  registerTranslationTools(server, client);
+}
+
+// src/resources/site.ts
+function registerSiteResources(server, client) {
+  server.resource(
+    "site-info",
+    "lynkow://site/info",
+    {
+      description: "Basic info about the connected Lynkow site (name, domain, locales)",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const data = await client.get("/site/info");
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(data, null, 2)
+        }]
+      };
+    }
+  );
+  server.resource(
+    "language-settings",
+    "lynkow://site/languages",
+    {
+      description: "Multi-language configuration: enabled locales, default locale",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const data = await client.get("/site/settings/language");
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(data, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerAllResources(server, client) {
+  registerSiteResources(server, client);
+}
+
+// src/index.ts
+async function startServer() {
+  const config = loadConfig();
+  const client = new LynkowApiClient(config);
+  const server = new McpServer({
+    name: "lynkow",
+    version: "1.0.0"
+  });
+  registerAllTools(server, client);
+  registerAllResources(server, client);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  if (config.debug) {
+    console.error("[lynkow-mcp] Server started successfully");
+  }
+}
+
+export { LynkowApiClient, startServer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map