elementor-mcp-agent 0.1.0

package/dist/server.js

@@ -0,0 +1,951 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { z } from "zod";
+var SiteSchema = z.object({
+  id: z.string().min(1, "site id required"),
+  url: z.string().url("invalid site url"),
+  username: z.string().min(1),
+  application_password: z.string().min(20, "WP application password should be ~24 chars"),
+  ssh: z.object({
+    host: z.string(),
+    user: z.string(),
+    port: z.coerce.number().int().min(1).max(65535).default(22),
+    path: z.string().describe("WP root path on remote, e.g. ~/sites/example.com"),
+    key_path: z.string().optional().describe("absolute path to private key")
+  }).optional()
+});
+var ConfigSchema = z.object({
+  sites: z.array(SiteSchema).min(1, "at least one site is required"),
+  default_site_id: z.string().optional(),
+  rate_limit_per_minute: z.coerce.number().int().min(1).max(600).default(60),
+  confirmation_ttl_seconds: z.coerce.number().int().min(10).max(600).default(60),
+  log_level: z.enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"]).default("info")
+});
+var cached = null;
+function loadConfig() {
+  if (cached) return cached;
+  let raw;
+  if (process.env.ELEMENTOR_MCP_SITES) {
+    try {
+      raw = { sites: JSON.parse(process.env.ELEMENTOR_MCP_SITES) };
+    } catch (e) {
+      throw new Error("ELEMENTOR_MCP_SITES must be valid JSON: " + e.message);
+    }
+  } else if (process.env.ELEMENTOR_MCP_CONFIG_PATH) {
+    try {
+      raw = JSON.parse(readFileSync(process.env.ELEMENTOR_MCP_CONFIG_PATH, "utf8"));
+    } catch (e) {
+      throw new Error("Cannot read ELEMENTOR_MCP_CONFIG_PATH: " + e.message);
+    }
+  } else {
+    throw new Error(
+      [
+        "No site configuration provided.",
+        "",
+        "How to set it up:",
+        "  \u2022 Easiest: set ELEMENTOR_MCP_SITES to a JSON array of sites. Example:",
+        `    ELEMENTOR_MCP_SITES='[{"id":"my-site","url":"https://example.com",`,
+        `      "username":"admin","application_password":"xxxx xxxx xxxx xxxx xxxx xxxx"}]'`,
+        "",
+        "  \u2022 Or: set ELEMENTOR_MCP_CONFIG_PATH to a JSON file with the same structure.",
+        "",
+        "Get a WordPress Application Password at:",
+        "  https://{your-site}/wp-admin/profile.php#application-passwords-section",
+        "",
+        "Full docs: https://github.com/Mogacode-ma/elementor-mcp-agent#configure"
+      ].join("\n")
+    );
+  }
+  const r = raw;
+  const merged = {
+    sites: r.sites ?? [],
+    default_site_id: r.default_site_id ?? process.env.ELEMENTOR_MCP_DEFAULT_SITE_ID,
+    rate_limit_per_minute: r.rate_limit_per_minute ?? process.env.ELEMENTOR_MCP_RATE_LIMIT ?? void 0,
+    confirmation_ttl_seconds: r.confirmation_ttl_seconds ?? process.env.ELEMENTOR_MCP_CONFIRMATION_TTL ?? void 0,
+    log_level: r.log_level ?? process.env.LOG_LEVEL ?? void 0
+  };
+  const parsed = ConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(
+      [
+        "Invalid configuration \u2014 required values missing or malformed:",
+        issues,
+        "",
+        "See https://github.com/Mogacode-ma/elementor-mcp-agent#configure"
+      ].join("\n")
+    );
+  }
+  cached = parsed.data;
+  return cached;
+}
+function getSite(siteId) {
+  const cfg = loadConfig();
+  if (!siteId) {
+    const def = cfg.default_site_id ?? cfg.sites[0]?.id;
+    if (!def) throw new Error("No site configured");
+    const s2 = cfg.sites.find((x) => x.id === def);
+    if (!s2) throw new Error(`Default site '${def}' not found in sites list`);
+    return s2;
+  }
+  const s = cfg.sites.find((x) => x.id === siteId);
+  if (!s) {
+    const available = cfg.sites.map((x) => x.id).join(", ");
+    throw new Error(`Site '${siteId}' not found. Available: ${available}`);
+  }
+  return s;
+}
+
+// src/tools/sites.ts
+import { z as z2 } from "zod";
+
+// src/types/tool.ts
+function defineTool(def) {
+  return def;
+}
+
+// src/throttle/token-bucket.ts
+var TokenBucket = class {
+  constructor(capacityPerMinute) {
+    this.capacityPerMinute = capacityPerMinute;
+    this.tokens = capacityPerMinute;
+    this.refillPerMs = capacityPerMinute / 6e4;
+  }
+  capacityPerMinute;
+  tokens;
+  lastRefill = Date.now();
+  refillPerMs;
+  async acquire() {
+    while (this.tokens < 1) {
+      this.refill();
+      if (this.tokens < 1) await new Promise((r) => setTimeout(r, 80));
+    }
+    this.tokens -= 1;
+  }
+  refill() {
+    const now = Date.now();
+    this.tokens = Math.min(
+      this.capacityPerMinute,
+      this.tokens + (now - this.lastRefill) * this.refillPerMs
+    );
+    this.lastRefill = now;
+  }
+  get available() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+};
+var buckets = /* @__PURE__ */ new Map();
+function bucketFor(siteId, perMinute) {
+  let b = buckets.get(siteId);
+  if (!b) {
+    b = new TokenBucket(perMinute);
+    buckets.set(siteId, b);
+  }
+  return b;
+}
+
+// src/api/errors.ts
+var WPError = class extends Error {
+  constructor(kind, code, message, raw) {
+    super(message);
+    this.kind = kind;
+    this.code = code;
+    this.raw = raw;
+    this.name = "WPError";
+  }
+  kind;
+  code;
+  raw;
+};
+function fromHttp(status, body, fallback = "WordPress API error") {
+  const raw = body;
+  const code = raw?.code ?? `http_${status}`;
+  const msg = raw?.message ?? fallback;
+  let kind = "unknown";
+  if (status === 401 || status === 403) kind = "auth";
+  else if (status === 404) kind = "not_found";
+  else if (status === 422 || status === 400) kind = "validation";
+  else if (status === 429) kind = "rate_limited";
+  else if (status >= 500) kind = "server";
+  return new WPError(kind, code, msg, body);
+}
+
+// src/utils/logger.ts
+import pino from "pino";
+var logger = pino(
+  {
+    level: process.env.LOG_LEVEL ?? "info",
+    base: { name: "elementor-mcp-agent" }
+  },
+  // Critical: stdout is reserved for MCP JSON-RPC. All logs MUST go to stderr.
+  pino.destination(2)
+);
+
+// src/api/wp-rest.ts
+function authHeader(site) {
+  const encoded = Buffer.from(`${site.username}:${site.application_password}`).toString("base64");
+  return `Basic ${encoded}`;
+}
+async function wpRequest(path, opts = {}) {
+  const cfg = loadConfig();
+  const site = getSite(opts.siteId);
+  await bucketFor(site.id, cfg.rate_limit_per_minute).acquire();
+  const url = new URL(path.startsWith("http") ? path : `${site.url.replace(/\/$/, "")}/wp-json${path.startsWith("/") ? "" : "/"}${path}`);
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) {
+      if (v !== void 0) url.searchParams.set(k, String(v));
+    }
+  }
+  const method = opts.method ?? (opts.body ? "POST" : "GET");
+  const headers = {
+    Authorization: authHeader(site),
+    Accept: "application/json",
+    "User-Agent": "elementor-mcp-agent",
+    ...opts.headers ?? {}
+  };
+  if (opts.body && !headers["Content-Type"]) headers["Content-Type"] = "application/json";
+  logger.debug({ method, url: url.toString(), site_id: site.id }, "wp request");
+  let res;
+  try {
+    res = await fetch(url.toString(), {
+      method,
+      headers,
+      body: opts.body ? JSON.stringify(opts.body) : void 0
+    });
+  } catch (e) {
+    throw new WPError("network", "fetch_failed", `Network error: ${e.message}`, e);
+  }
+  const text = await res.text();
+  let parsed = text;
+  if (text && (res.headers.get("content-type") ?? "").includes("application/json")) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    throw fromHttp(res.status, parsed);
+  }
+  return parsed;
+}
+
+// src/tools/sites.ts
+var listSitesTool = defineTool({
+  name: "list_sites",
+  description: "List every WordPress site configured in this MCP server's pool. Best called first in a session to discover available sites.",
+  inputSchema: z2.object({}),
+  outputSchema: z2.object({
+    total: z2.number(),
+    default_site_id: z2.string().optional(),
+    sites: z2.array(
+      z2.object({
+        id: z2.string(),
+        url: z2.string(),
+        username: z2.string(),
+        has_ssh: z2.boolean()
+      })
+    )
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+  async handler() {
+    const cfg = loadConfig();
+    return {
+      total: cfg.sites.length,
+      default_site_id: cfg.default_site_id ?? cfg.sites[0]?.id,
+      sites: cfg.sites.map((s) => ({
+        id: s.id,
+        url: s.url,
+        username: s.username,
+        has_ssh: !!s.ssh
+      }))
+    };
+  }
+});
+var pingSiteTool = defineTool({
+  name: "ping_site",
+  description: "Verify connectivity + authentication to a WordPress site. Calls /wp-json/wp/v2/users/me to validate credentials and returns the WP version + Elementor version if detected.",
+  inputSchema: z2.object({
+    site_id: z2.string().optional().describe("Site id from list_sites. Defaults to the default site.")
+  }),
+  outputSchema: z2.object({
+    ok: z2.boolean(),
+    site_id: z2.string(),
+    url: z2.string(),
+    wp_version: z2.string().optional(),
+    elementor_version: z2.string().optional(),
+    elementor_pro_version: z2.string().optional(),
+    user: z2.object({ id: z2.number(), name: z2.string(), roles: z2.array(z2.string()).optional() }).optional(),
+    error: z2.string().optional()
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const site = getSite(input.site_id);
+    try {
+      const me = await wpRequest(
+        "/wp/v2/users/me?context=edit",
+        { siteId: site.id }
+      );
+      let wp_version;
+      try {
+        const health = await wpRequest(
+          "/wp-site-health/v1/info",
+          { siteId: site.id }
+        );
+        wp_version = health.wordpress?.version;
+      } catch {
+      }
+      let elementor_version;
+      let elementor_pro_version;
+      try {
+        const plugins = await wpRequest(
+          "/wp/v2/plugins",
+          { siteId: site.id }
+        );
+        for (const p of plugins) {
+          if (p.plugin.startsWith("elementor/") && p.plugin.endsWith("/elementor.php"))
+            elementor_version = p.version;
+          if (p.plugin.startsWith("elementor-pro/")) elementor_pro_version = p.version;
+        }
+      } catch {
+      }
+      return {
+        ok: true,
+        site_id: site.id,
+        url: site.url,
+        wp_version,
+        elementor_version,
+        elementor_pro_version,
+        user: { id: me.id, name: me.name, roles: me.roles }
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        site_id: site.id,
+        url: site.url,
+        error: e.message
+      };
+    }
+  }
+});
+
+// src/tools/pages.ts
+import { z as z3 } from "zod";
+
+// src/elementor/data-parser.ts
+function parseElementorData(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (!raw || raw === "[]") return [];
+  try {
+    const decoded = JSON.parse(raw);
+    if (!Array.isArray(decoded)) throw new Error("not an array");
+    return decoded;
+  } catch (e) {
+    throw new Error(`Failed to parse _elementor_data JSON: ${e.message}`);
+  }
+}
+function serializeElementorData(data) {
+  return JSON.stringify(data);
+}
+function* walkElements(data, path = [], depth = 0) {
+  for (const el of data) {
+    const here = [...path, el.id];
+    yield { element: el, path: here, depth };
+    if (el.elements && el.elements.length > 0) {
+      yield* walkElements(el.elements, here, depth + 1);
+    }
+  }
+}
+function findReplaceInWidgets(data, find, replace, options = {}) {
+  let count = 0;
+  const flags = options.caseSensitive ? "g" : "gi";
+  const pattern = new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+  function replaceInValue(value) {
+    if (typeof value === "string") {
+      const next = value.replace(pattern, () => {
+        count++;
+        return replace;
+      });
+      return next;
+    }
+    if (Array.isArray(value)) return value.map(replaceInValue);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) out[k] = replaceInValue(v);
+      return out;
+    }
+    return value;
+  }
+  for (const { element } of walkElements(data)) {
+    if (element.elType !== "widget") continue;
+    if (options.widgetType && element.widgetType !== options.widgetType) continue;
+    element.settings = replaceInValue(element.settings);
+  }
+  return { data, replacementCount: count };
+}
+function summarize(data) {
+  let totalElements = 0;
+  let sections = 0;
+  let containers = 0;
+  let columns = 0;
+  let widgets = 0;
+  let maxDepth = 0;
+  const byWidgetType = {};
+  for (const { element, depth } of walkElements(data)) {
+    totalElements++;
+    maxDepth = Math.max(maxDepth, depth);
+    if (element.elType === "section") sections++;
+    else if (element.elType === "container") containers++;
+    else if (element.elType === "column") columns++;
+    else if (element.elType === "widget") {
+      widgets++;
+      const w = element.widgetType ?? "unknown";
+      byWidgetType[w] = (byWidgetType[w] ?? 0) + 1;
+    }
+  }
+  return { totalElements, sections, containers, columns, widgets, byWidgetType, maxDepth };
+}
+
+// src/elementor/safety.ts
+async function backupElementorData(siteId, postId) {
+  const current = await wpRequest(`/wp/v2/pages/${postId}?context=edit&_fields=meta`, { siteId });
+  const raw = current.meta?._elementor_data ?? "[]";
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const meta_key = `_elementor_data_backup_${ts}`;
+  await wpRequest(`/wp/v2/pages/${postId}`, {
+    siteId,
+    method: "PUT",
+    body: { meta: { [meta_key]: raw } }
+  });
+  return { meta_key, size_bytes: raw.length };
+}
+async function flushElementorCSS(siteId, postId) {
+  try {
+    await wpRequest(`/elementor/v1/css?id=${postId}&action=regenerate`, { siteId, method: "POST" });
+    return { method: "rest" };
+  } catch {
+    await wpRequest(`/wp/v2/pages/${postId}`, {
+      siteId,
+      method: "PUT",
+      body: { date: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    return { method: "resave" };
+  }
+}
+
+// src/utils/confirmation.ts
+import { randomBytes } from "crypto";
+var pending = /* @__PURE__ */ new Map();
+function issueConfirmation(intent, payload, ttlSeconds) {
+  const token = randomBytes(8).toString("hex");
+  pending.set(token, {
+    token,
+    intent,
+    payload,
+    expiresAt: Date.now() + ttlSeconds * 1e3
+  });
+  return token;
+}
+function consumeConfirmation(token, expectedIntent) {
+  const c = pending.get(token);
+  if (!c) return null;
+  pending.delete(token);
+  if (c.expiresAt < Date.now()) return null;
+  if (c.intent !== expectedIntent) return null;
+  return c;
+}
+
+// src/tools/pages.ts
+var listElementorPagesTool = defineTool({
+  name: "list_elementor_pages",
+  description: "List pages on a site that are built with Elementor (i.e. have _elementor_edit_mode = 'builder'). Returns id, title, slug, status, modified date.",
+  inputSchema: z3.object({
+    site_id: z3.string().optional(),
+    per_page: z3.number().int().min(1).max(100).default(25),
+    search: z3.string().optional()
+  }),
+  outputSchema: z3.object({
+    total: z3.number(),
+    pages: z3.array(
+      z3.object({
+        id: z3.number(),
+        title: z3.string(),
+        slug: z3.string(),
+        status: z3.string(),
+        link: z3.string(),
+        modified: z3.string()
+      })
+    )
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const pages = await wpRequest("/wp/v2/pages", {
+      siteId: input.site_id,
+      query: {
+        per_page: input.per_page,
+        search: input.search,
+        meta_key: "_elementor_edit_mode",
+        meta_value: "builder",
+        context: "edit",
+        _fields: "id,title,slug,status,link,modified"
+      }
+    });
+    return {
+      total: pages.length,
+      pages: pages.map((p) => ({
+        id: p.id,
+        title: p.title.rendered,
+        slug: p.slug,
+        status: p.status,
+        link: p.link,
+        modified: p.modified
+      }))
+    };
+  }
+});
+var readPageElementorTool = defineTool({
+  name: "read_page_elementor",
+  description: "Fetch the raw _elementor_data of a page and return a structured summary (counts by widget type, depth, total elements). Optionally returns the full parsed tree (verbose=true) which may be very large.",
+  inputSchema: z3.object({
+    site_id: z3.string().optional(),
+    page_id: z3.number().int().positive(),
+    verbose: z3.boolean().default(false).describe("If true, return the entire parsed Elementor data tree (can be MBs).")
+  }),
+  outputSchema: z3.object({
+    page_id: z3.number(),
+    title: z3.string(),
+    summary: z3.object({
+      totalElements: z3.number(),
+      sections: z3.number(),
+      containers: z3.number(),
+      columns: z3.number(),
+      widgets: z3.number(),
+      maxDepth: z3.number(),
+      byWidgetType: z3.record(z3.number())
+    }),
+    data: z3.array(z3.any()).optional()
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const page = await wpRequest(
+      `/wp/v2/pages/${input.page_id}?context=edit`,
+      { siteId: input.site_id }
+    );
+    const raw = page.meta?._elementor_data ?? "[]";
+    const data = parseElementorData(raw);
+    const summary = summarize(data);
+    return {
+      page_id: page.id,
+      title: page.title.rendered,
+      summary,
+      data: input.verbose ? data : void 0
+    };
+  }
+});
+var findReplaceTool = defineTool({
+  name: "elementor_find_replace",
+  description: "Find/replace plain text in every widget's settings on a single page. TWO-CALL DESTRUCTIVE FLOW: first call without `confirmation` performs a dry-run and returns a confirmation token + match count. Second call with the token actually applies the change after backing up the page's elementor data.",
+  inputSchema: z3.object({
+    site_id: z3.string().optional(),
+    page_id: z3.number().int().positive(),
+    find: z3.string().min(1),
+    replace: z3.string(),
+    widget_type: z3.string().optional().describe("Restrict to one widget type, e.g. 'heading'."),
+    case_sensitive: z3.boolean().default(false),
+    confirmation: z3.string().optional().describe("Token returned from the dry-run call.")
+  }),
+  outputSchema: z3.object({
+    mode: z3.enum(["dry_run", "applied"]),
+    page_id: z3.number(),
+    match_count: z3.number(),
+    confirmation_token: z3.string().optional(),
+    expires_in_seconds: z3.number().optional(),
+    backup_meta_key: z3.string().optional(),
+    css_flush: z3.string().optional()
+  }),
+  annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
+  async handler(input) {
+    const cfg = loadConfig();
+    const page = await wpRequest(
+      `/wp/v2/pages/${input.page_id}?context=edit`,
+      { siteId: input.site_id }
+    );
+    const raw = page.meta?._elementor_data ?? "[]";
+    const data = parseElementorData(raw);
+    const dry = findReplaceInWidgets(JSON.parse(JSON.stringify(data)), input.find, input.replace, {
+      widgetType: input.widget_type,
+      caseSensitive: input.case_sensitive
+    });
+    if (!input.confirmation) {
+      if (dry.replacementCount === 0) {
+        return { mode: "dry_run", page_id: input.page_id, match_count: 0 };
+      }
+      const token = issueConfirmation(
+        "elementor_find_replace",
+        { page_id: input.page_id, find: input.find, replace: input.replace },
+        cfg.confirmation_ttl_seconds
+      );
+      return {
+        mode: "dry_run",
+        page_id: input.page_id,
+        match_count: dry.replacementCount,
+        confirmation_token: token,
+        expires_in_seconds: cfg.confirmation_ttl_seconds
+      };
+    }
+    const conf = consumeConfirmation(input.confirmation, "elementor_find_replace");
+    if (!conf) throw new Error("Invalid or expired confirmation token");
+    const original = conf.payload;
+    if (original.page_id !== input.page_id || original.find !== input.find || original.replace !== input.replace) {
+      throw new Error("Confirmation parameters don't match the original dry-run");
+    }
+    const backup = await backupElementorData(input.site_id, input.page_id);
+    const applied = findReplaceInWidgets(parseElementorData(raw), input.find, input.replace, {
+      widgetType: input.widget_type,
+      caseSensitive: input.case_sensitive
+    });
+    await wpRequest(`/wp/v2/pages/${input.page_id}`, {
+      siteId: input.site_id,
+      method: "PUT",
+      body: { meta: { _elementor_data: serializeElementorData(applied.data) } }
+    });
+    const flush = await flushElementorCSS(input.site_id, input.page_id);
+    return {
+      mode: "applied",
+      page_id: input.page_id,
+      match_count: applied.replacementCount,
+      backup_meta_key: backup.meta_key,
+      css_flush: flush.method
+    };
+  }
+});
+
+// src/tools/templates.ts
+import { z as z4 } from "zod";
+var listTemplatesTool = defineTool({
+  name: "list_elementor_templates",
+  description: "List Elementor library templates on a site (saved sections, pages, popups). Type can be filtered: 'section', 'page', 'popup', 'header', 'footer'.",
+  inputSchema: z4.object({
+    site_id: z4.string().optional(),
+    type: z4.enum(["section", "page", "popup", "header", "footer", "any"]).default("any"),
+    per_page: z4.number().int().min(1).max(100).default(50)
+  }),
+  outputSchema: z4.object({
+    total: z4.number(),
+    templates: z4.array(
+      z4.object({
+        id: z4.number(),
+        title: z4.string(),
+        type: z4.string(),
+        modified: z4.string()
+      })
+    )
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const query = {
+      per_page: input.per_page,
+      context: "edit",
+      _fields: "id,title,modified,meta"
+    };
+    if (input.type !== "any") {
+      query.meta_key = "_elementor_template_type";
+      query.meta_value = input.type;
+    }
+    const items = await wpRequest("/wp/v2/elementor_library", {
+      siteId: input.site_id,
+      query
+    });
+    return {
+      total: items.length,
+      templates: items.map((t) => ({
+        id: t.id,
+        title: t.title.rendered,
+        type: t.meta?._elementor_template_type ?? "unknown",
+        modified: t.modified
+      }))
+    };
+  }
+});
+var exportTemplateTool = defineTool({
+  name: "export_elementor_template",
+  description: "Export an Elementor template as a portable JSON object. Output is the same structure Elementor expects on import. Use it to copy sections between sites.",
+  inputSchema: z4.object({
+    site_id: z4.string().optional(),
+    template_id: z4.number().int().positive()
+  }),
+  outputSchema: z4.object({
+    template_id: z4.number(),
+    title: z4.string(),
+    type: z4.string(),
+    summary: z4.object({
+      totalElements: z4.number(),
+      widgets: z4.number(),
+      sections: z4.number()
+    }),
+    portable_json: z4.string().describe("JSON-stringified payload ready to import via import_elementor_template.")
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const tpl = await wpRequest(`/wp/v2/elementor_library/${input.template_id}?context=edit`, {
+      siteId: input.site_id
+    });
+    const data = parseElementorData(tpl.meta?._elementor_data ?? "[]");
+    const sum = summarize(data);
+    const portable = {
+      version: "0.4",
+      title: tpl.title.rendered,
+      type: tpl.meta?._elementor_template_type ?? "page",
+      content: data
+    };
+    return {
+      template_id: tpl.id,
+      title: tpl.title.rendered,
+      type: tpl.meta?._elementor_template_type ?? "unknown",
+      summary: { totalElements: sum.totalElements, widgets: sum.widgets, sections: sum.sections },
+      portable_json: JSON.stringify(portable)
+    };
+  }
+});
+var importTemplateTool = defineTool({
+  name: "import_elementor_template",
+  description: "Import an Elementor template (output of export_elementor_template) into a target site as a new template entry. Useful for syncing reusable sections across an agency's site fleet.",
+  inputSchema: z4.object({
+    site_id: z4.string().optional().describe("Target site id."),
+    portable_json: z4.string().describe("JSON-stringified payload from export_elementor_template."),
+    override_title: z4.string().optional()
+  }),
+  outputSchema: z4.object({
+    new_template_id: z4.number(),
+    title: z4.string(),
+    type: z4.string(),
+    url: z4.string()
+  }),
+  annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true },
+  async handler(input) {
+    let payload;
+    try {
+      payload = JSON.parse(input.portable_json);
+    } catch (e) {
+      throw new Error("portable_json is not valid JSON: " + e.message);
+    }
+    const title = input.override_title ?? payload.title;
+    const data = Array.isArray(payload.content) ? payload.content : parseElementorData(payload.content);
+    const res = await wpRequest(`/wp/v2/elementor_library`, {
+      siteId: input.site_id,
+      method: "POST",
+      body: {
+        title,
+        status: "publish",
+        meta: {
+          _elementor_template_type: payload.type,
+          _elementor_data: serializeElementorData(data),
+          _elementor_edit_mode: "builder"
+        }
+      }
+    });
+    return {
+      new_template_id: res.id,
+      title,
+      type: payload.type,
+      url: res.link
+    };
+  }
+});
+
+// src/tools/updates.ts
+import { z as z5 } from "zod";
+async function fetchLatestElementor() {
+  const free = await fetch("https://api.wordpress.org/plugins/info/1.0/elementor.json").then((r) => r.json()).catch(() => null);
+  return { free: free?.version ?? "unknown" };
+}
+var checkElementorVersionsTool = defineTool({
+  name: "check_elementor_versions",
+  description: "For every configured site, fetch the installed Elementor / Elementor Pro version and compare against the latest available on wordpress.org. Returns a per-site row with 'outdated' flag.",
+  inputSchema: z5.object({
+    site_ids: z5.array(z5.string()).optional().describe("Subset of sites to check. Defaults to all.")
+  }),
+  outputSchema: z5.object({
+    checked: z5.number(),
+    latest_elementor_free: z5.string(),
+    sites: z5.array(
+      z5.object({
+        site_id: z5.string(),
+        url: z5.string(),
+        elementor_version: z5.string().optional(),
+        elementor_pro_version: z5.string().optional(),
+        outdated_free: z5.boolean(),
+        error: z5.string().optional()
+      })
+    )
+  }),
+  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+  async handler(input) {
+    const cfg = loadConfig();
+    const latest = await fetchLatestElementor();
+    const targets = input.site_ids ? cfg.sites.filter((s) => input.site_ids?.includes(s.id)) : cfg.sites;
+    const rows = [];
+    for (const site of targets) {
+      try {
+        const plugins = await wpRequest("/wp/v2/plugins", { siteId: site.id });
+        let elementor_version;
+        let elementor_pro_version;
+        for (const p of plugins) {
+          if (p.plugin.startsWith("elementor/") && p.plugin.endsWith("/elementor.php"))
+            elementor_version = p.version;
+          if (p.plugin.startsWith("elementor-pro/")) elementor_pro_version = p.version;
+        }
+        rows.push({
+          site_id: site.id,
+          url: site.url,
+          elementor_version,
+          elementor_pro_version,
+          outdated_free: !!elementor_version && elementor_version !== latest.free && latest.free !== "unknown"
+        });
+      } catch (e) {
+        rows.push({
+          site_id: site.id,
+          url: site.url,
+          outdated_free: false,
+          error: e.message
+        });
+      }
+    }
+    return {
+      checked: rows.length,
+      latest_elementor_free: latest.free,
+      sites: rows
+    };
+  }
+});
+
+// src/tools/index.ts
+var tools = [
+  listSitesTool,
+  pingSiteTool,
+  listElementorPagesTool,
+  readPageElementorTool,
+  findReplaceTool,
+  listTemplatesTool,
+  exportTemplateTool,
+  importTemplateTool,
+  checkElementorVersionsTool
+];
+
+// src/resources/index.ts
+import { readFileSync as readFileSync2, existsSync, readdirSync } from "fs";
+import { dirname, resolve, join, basename } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var DOCS_DIR = resolve(__dirname, "../resources/elementor-docs");
+async function listResources() {
+  if (!existsSync(DOCS_DIR)) return [];
+  const files = readdirSync(DOCS_DIR).filter((f) => f.endsWith(".md"));
+  return files.map((f) => ({
+    uri: `elementor-docs://${f}`,
+    name: basename(f, ".md"),
+    description: `Elementor documentation snippet (scraped from developer.elementor.com)`,
+    mimeType: "text/markdown"
+  }));
+}
+async function readResource(uri) {
+  if (!uri.startsWith("elementor-docs://")) {
+    throw new Error(`Unknown resource URI: ${uri}`);
+  }
+  const filename = uri.replace("elementor-docs://", "");
+  const path = join(DOCS_DIR, filename);
+  if (!existsSync(path)) throw new Error(`Resource not found: ${filename}`);
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/markdown",
+        text: readFileSync2(path, "utf8")
+      }
+    ]
+  };
+}
+
+// src/server.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var pkg = JSON.parse(readFileSync3(resolve2(__dirname2, "../package.json"), "utf8"));
+function toMcpInputSchema(zod) {
+  return zodToJsonSchema(zod, { target: "jsonSchema7", $refStrategy: "none" });
+}
+async function main() {
+  try {
+    loadConfig();
+  } catch (e) {
+    logger.error(e.message);
+    process.stderr.write("\n" + e.message + "\n");
+    process.exit(1);
+  }
+  const server = new Server(
+    { name: pkg.name, version: pkg.version },
+    { capabilities: { tools: {}, resources: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: toMcpInputSchema(t.inputSchema),
+      outputSchema: t.outputSchema ? toMcpInputSchema(t.outputSchema) : void 0,
+      annotations: t.annotations
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = tools.find((t) => t.name === req.params.name);
+    if (!tool) throw new Error(`Unknown tool: ${req.params.name}`);
+    const args = req.params.arguments ?? {};
+    const parsed = tool.inputSchema.safeParse(args);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+      return {
+        content: [{ type: "text", text: `Invalid arguments for ${tool.name}:
+${msg}` }],
+        isError: true
+      };
+    }
+    try {
+      const result = await tool.handler(parsed.data);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (e) {
+      logger.error({ tool: tool.name, err: e.message }, "tool error");
+      return {
+        content: [{ type: "text", text: `${tool.name} failed: ${e.message}` }],
+        isError: true
+      };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: await listResources()
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (req) => readResource(req.params.uri));
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info({ tools: tools.length }, `${pkg.name} v${pkg.version} ready`);
+}
+main().catch((e) => {
+  logger.error(e.message);
+  process.stderr.write("\n" + e.message + "\n");
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map