elementor-mcp-agent 1.1.0 → 1.3.0

package/dist/server.js

@@ -2122,7 +2122,7 @@ var checkElementorVersionsTool = defineTool({
 });
 
 // src/tools/widgets.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 init_wp_rest();
 
 // src/elementor/widget-ops.ts
@@ -2213,6 +2213,78 @@ init_backup();
 init_css_flush();
 init_policies();
 init_confirmation();
+
+// src/elementor/verify.ts
+init_wp_rest();
+import { z as z8 } from "zod";
+var VerificationSchema = z8.object({
+  /** Plain-English description of what we re-read and compared. */
+  method: z8.string(),
+  /** Whether a canonical re-read of the page succeeded. */
+  reread_ok: z8.boolean(),
+  /** Op-specific: did the change we requested actually persist? */
+  matches_requested: z8.boolean(),
+  /** Op-specific extra data (e.g. the actual persisted widget settings). */
+  persisted: z8.record(z8.any()).optional(),
+  /** Free-text notes / explanation when matches_requested is false. */
+  notes: z8.string().optional()
+});
+async function verifyWrite(args) {
+  try {
+    const page = await wpRequest(
+      `/wp/v2/pages/${args.pageId}?context=edit&_fields=meta`,
+      { siteId: args.siteId }
+    );
+    const v = page.meta?._elementor_data;
+    const raw = typeof v === "string" ? v : JSON.stringify(v ?? []);
+    const data = parseElementorData(raw);
+    const result = args.predicate(data);
+    return {
+      method: args.description,
+      reread_ok: true,
+      matches_requested: result.ok,
+      persisted: result.persisted,
+      notes: result.notes
+    };
+  } catch (err) {
+    return {
+      method: args.description,
+      reread_ok: false,
+      matches_requested: false,
+      notes: `Canonical re-read failed: ${err.message}`
+    };
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((x, i) => deepEqual(x, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    return ka.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
+// src/tools/widgets.ts
+var MutationResponseShape = {
+  mode: z9.enum(["dry_run", "applied"]),
+  page_id: z9.number(),
+  confirmation_token: z9.string().optional(),
+  backup_meta_key: z9.string().optional(),
+  css_flush: z9.string().optional(),
+  mutated: z9.boolean().optional(),
+  warnings: z9.array(z9.string()).optional(),
+  verification: VerificationSchema.optional()
+};
 async function fetchData(siteId, pageId) {
   const page = await wpRequest(
     `/wp/v2/pages/${pageId}?context=edit&_fields=meta`,
@@ -2234,20 +2306,20 @@ async function writeData(siteId, pageId, data) {
     body: { meta: { _elementor_data: ser } }
   });
   const flush = await flushCSS(siteId, pageId);
-  return { method: flush.method };
+  return { method: flush.method, serialized: ser };
 }
 var readWidgetTool = defineTool({
   name: "read_widget",
   description: "Fetch a single widget's full settings by id. Use list_widgets_in_page to find the id first.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1)
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1)
   }),
-  outputSchema: z8.object({
-    widget_id: z8.string(),
-    widget_type: z8.string().optional(),
-    settings: z8.record(z8.any())
+  outputSchema: z9.object({
+    widget_id: z9.string(),
+    widget_type: z9.string().optional(),
+    settings: z9.record(z9.any())
   }),
   annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
   async handler(input) {
@@ -2259,22 +2331,18 @@ var readWidgetTool = defineTool({
 });
 var updateWidgetSettingsTool = defineTool({
   name: "update_widget_settings",
-  description: "Shallow-merge a partial settings object into one widget. Backs up the page first; validates the result; auto-flushes CSS. Two-call confirmation flow.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1),
-    settings_patch: z8.record(z8.any()),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    widget_id: z8.string(),
-    keys_changed: z8.array(z8.string()),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Shallow-merge a partial settings object into one widget. Backs up the page first, validates the result, auto-flushes CSS, then re-reads the page and verifies the patch persisted (matches_requested in the response). Two-call confirmation.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1),
+    settings_patch: z9.record(z9.any()),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    widget_id: z9.string(),
+    keys_changed: z9.array(z9.string())
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2290,38 +2358,56 @@ var updateWidgetSettingsTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "update_widget_settings");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     if (!updateWidgetSettings(data, input.widget_id, input.settings_patch)) {
       throw new Error(`Widget ${input.widget_id} not found`);
     }
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and check widget ${input.widget_id} settings include the requested patch`,
+      predicate: (canonical) => {
+        const widget = findElementById(canonical, input.widget_id);
+        if (!widget) return { ok: false, notes: "Widget no longer present after write" };
+        const persisted = widget.settings;
+        const mismatches = [];
+        for (const [k, want] of Object.entries(input.settings_patch)) {
+          if (!deepEqual(persisted[k], want)) mismatches.push(k);
+        }
+        return {
+          ok: mismatches.length === 0,
+          persisted,
+          notes: mismatches.length === 0 ? void 0 : `Persisted state diverges from requested patch on key(s): ${mismatches.join(", ")}`
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       widget_id: input.widget_id,
       keys_changed: Object.keys(input.settings_patch),
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 var deleteWidgetTool = defineTool({
   name: "delete_widget",
-  description: "Remove a widget from a page by id. Two-call confirmation. Backs up before deleting.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    widget_id: z8.string(),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Remove a widget from a page by id. Two-call confirmation. Backs up before deleting; re-reads to confirm the widget is gone.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    widget_id: z9.string()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2331,36 +2417,47 @@ var deleteWidgetTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "delete_widget");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     if (!deleteWidget(data, input.widget_id)) throw new Error(`Widget ${input.widget_id} not found`);
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and assert widget ${input.widget_id} is gone`,
+      predicate: (canonical) => {
+        const found = findElementById(canonical, input.widget_id);
+        return {
+          ok: found === null,
+          notes: found ? "Widget still present in canonical re-read \u2014 delete did not persist" : void 0
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       widget_id: input.widget_id,
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 var duplicateWidgetTool = defineTool({
   name: "duplicate_widget",
-  description: "Duplicate a widget in place (right after the original). The clone gets a new id. Two-call confirmation.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    source_widget_id: z8.string(),
-    new_widget_id: z8.string().optional(),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Duplicate a widget in place (right after the original). The clone gets a new id. Re-reads to confirm the clone persisted. Two-call confirmation.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    source_widget_id: z9.string(),
+    new_widget_id: z9.string().optional()
   }),
   annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2370,40 +2467,53 @@ var duplicateWidgetTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "duplicate_widget");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     const r = duplicateWidget(data, input.widget_id);
-    if (!r.ok) throw new Error(`Widget ${input.widget_id} not found`);
+    if (!r.ok || !r.new_widget_id) throw new Error(`Widget ${input.widget_id} not found`);
+    const newId = r.new_widget_id;
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and assert the clone (${newId}) exists alongside the source`,
+      predicate: (canonical) => {
+        const source = findElementById(canonical, input.widget_id);
+        const clone = findElementById(canonical, newId);
+        return {
+          ok: source !== null && clone !== null,
+          notes: !clone ? "Clone not present in canonical re-read" : !source ? "Original is missing after duplicate" : void 0
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       source_widget_id: input.widget_id,
-      new_widget_id: r.new_widget_id,
+      new_widget_id: newId,
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 var swapWidgetTypeTool = defineTool({
   name: "swap_widget_type",
-  description: "Replace a widget's type (e.g., heading \u2192 button) while preserving its position. Provide full new_settings \u2014 the old settings are NOT carried over (different widget types have incompatible schemas). Two-call confirmation.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1),
-    new_widget_type: z8.string().min(1),
-    new_settings: z8.record(z8.any()).default({}),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    widget_id: z8.string(),
-    new_widget_type: z8.string(),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Replace a widget's type (e.g., heading \u2192 button) while preserving its id and position. Provide full new_settings \u2014 the old settings are NOT carried over (different widget types have incompatible schemas). Re-reads to confirm. Two-call confirmation.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1),
+    new_widget_type: z9.string().min(1),
+    new_settings: z9.record(z9.any()).default({}),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    widget_id: z9.string(),
+    new_widget_type: z9.string()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2413,42 +2523,55 @@ var swapWidgetTypeTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "swap_widget_type");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     if (!swapWidgetType(data, input.widget_id, input.new_widget_type, input.new_settings)) {
       throw new Error(`Widget ${input.widget_id} not found`);
     }
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and assert widget ${input.widget_id} now has widgetType="${input.new_widget_type}"`,
+      predicate: (canonical) => {
+        const widget = findElementById(canonical, input.widget_id);
+        if (!widget) return { ok: false, notes: "Widget missing after swap" };
+        return {
+          ok: widget.widgetType === input.new_widget_type,
+          persisted: { widgetType: widget.widgetType, settings: widget.settings },
+          notes: widget.widgetType === input.new_widget_type ? void 0 : `Expected widgetType="${input.new_widget_type}", canonical state has "${widget.widgetType}"`
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       widget_id: input.widget_id,
       new_widget_type: input.new_widget_type,
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 var addWidgetTool = defineTool({
   name: "add_widget",
-  description: "Append a new widget to a parent container (section, column, or container) on a page. Two-call confirmation.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    parent_id: z8.string().min(1).describe("Id of the section/column/container that will receive the widget."),
-    widget_type: z8.string().min(1).describe("e.g., 'heading', 'text-editor', 'button', 'image'."),
-    settings: z8.record(z8.any()).default({}),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    parent_id: z8.string(),
-    widget_type: z8.string(),
-    new_widget_id: z8.string().optional(),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Append a new widget to a parent container (section, column, or container) on a page. Re-reads to confirm the new widget exists under the parent. Two-call confirmation.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    parent_id: z9.string().min(1).describe("Id of the section/column/container that will receive the widget."),
+    widget_type: z9.string().min(1).describe("e.g., 'heading', 'text-editor', 'button', 'image'."),
+    settings: z9.record(z9.any()).default({}),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    parent_id: z9.string(),
+    widget_type: z9.string(),
+    new_widget_id: z9.string().optional()
   }),
   annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2458,41 +2581,56 @@ var addWidgetTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "add_widget");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     const r = addWidget(data, input.parent_id, input.widget_type, input.settings);
-    if (!r.ok) throw new Error(`Parent ${input.parent_id} not found`);
+    if (!r.ok || !r.new_widget_id) throw new Error(`Parent ${input.parent_id} not found`);
+    const newId = r.new_widget_id;
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and assert new widget ${newId} exists under parent ${input.parent_id} with widgetType="${input.widget_type}"`,
+      predicate: (canonical) => {
+        const widget = findElementById(canonical, newId);
+        if (!widget) return { ok: false, notes: "New widget not found after add" };
+        const parent = findElementById(canonical, input.parent_id);
+        const isUnderParent = parent?.elements?.some((e) => e.id === newId) === true;
+        return {
+          ok: widget.widgetType === input.widget_type && isUnderParent,
+          notes: !isUnderParent ? `Widget exists but is not under expected parent ${input.parent_id}` : widget.widgetType !== input.widget_type ? `Widget exists with wrong widgetType "${widget.widgetType}"` : void 0
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       parent_id: input.parent_id,
       widget_type: input.widget_type,
-      new_widget_id: r.new_widget_id,
+      new_widget_id: newId,
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 var moveWidgetTool = defineTool({
   name: "move_widget",
-  description: "Move a widget to a different parent (or different position in the same parent). Two-call confirmation.",
-  inputSchema: z8.object({
-    site_id: z8.string().optional(),
-    page_id: z8.number().int().positive(),
-    widget_id: z8.string().min(1),
-    new_parent_id: z8.string().min(1),
-    position: z8.number().int().default(-1).describe("0-based position in the new parent. -1 = append."),
-    confirmation: z8.string().optional()
-  }),
-  outputSchema: z8.object({
-    mode: z8.enum(["dry_run", "applied"]),
-    page_id: z8.number(),
-    widget_id: z8.string(),
-    new_parent_id: z8.string(),
-    confirmation_token: z8.string().optional(),
-    backup_meta_key: z8.string().optional(),
-    css_flush: z8.string().optional()
+  description: "Move a widget to a different parent (or different position in the same parent). Re-reads to confirm new parent. Two-call confirmation.",
+  inputSchema: z9.object({
+    site_id: z9.string().optional(),
+    page_id: z9.number().int().positive(),
+    widget_id: z9.string().min(1),
+    new_parent_id: z9.string().min(1),
+    position: z9.number().int().default(-1).describe("0-based position in the new parent. -1 = append."),
+    confirmation: z9.string().optional()
+  }),
+  outputSchema: z9.object({
+    ...MutationResponseShape,
+    widget_id: z9.string(),
+    new_parent_id: z9.string()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2502,25 +2640,41 @@ var moveWidgetTool = defineTool({
     }
     const conf = consumeConfirmation(input.confirmation, "move_widget");
     if (!conf) throw new Error("Invalid or expired confirmation token");
-    const { data } = await fetchData(input.site_id, input.page_id);
+    const { raw: rawBefore, data } = await fetchData(input.site_id, input.page_id);
     if (!moveWidget(data, input.widget_id, input.new_parent_id, input.position)) {
       throw new Error(`Widget or parent not found`);
     }
     const backup = await fullBackup(input.site_id, input.page_id);
     const w = await writeData(input.site_id, input.page_id, data);
+    const verification = await verifyWrite({
+      siteId: input.site_id,
+      pageId: input.page_id,
+      description: `Re-read /wp/v2/pages/${input.page_id} and assert widget ${input.widget_id} is now a direct child of ${input.new_parent_id}`,
+      predicate: (canonical) => {
+        const parent = findElementById(canonical, input.new_parent_id);
+        const isUnderNewParent = parent?.elements?.some((e) => e.id === input.widget_id) === true;
+        return {
+          ok: isUnderNewParent,
+          notes: isUnderNewParent ? void 0 : `Widget ${input.widget_id} not found under ${input.new_parent_id} after move`
+        };
+      }
+    });
     return {
       mode: "applied",
       page_id: input.page_id,
       widget_id: input.widget_id,
       new_parent_id: input.new_parent_id,
       backup_meta_key: backup.meta_key,
-      css_flush: w.method
+      css_flush: w.method,
+      mutated: rawBefore !== w.serialized,
+      warnings: [],
+      verification
     };
   }
 });
 
 // src/tools/bulk.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 init_wp_rest();
 init_config();
 init_backup();
@@ -2553,33 +2707,33 @@ async function listElementorPageIds(siteId) {
 var bulkFindReplaceSiteTool = defineTool({
   name: "bulk_find_replace_site",
   description: "Find/replace plain text in every Elementor page on a single site. TWO-CALL FLOW: dry-run returns per-page match_count + total + confirmation_token. Apply iterates each page (auto-backup + validate + flush per page). Slower than wp_search_replace but works without SSH and gives per-page granularity.",
-  inputSchema: z9.object({
-    site_id: z9.string().optional(),
-    find: z9.string().min(1),
-    replace: z9.string(),
-    widget_type: z9.string().optional(),
-    case_sensitive: z9.boolean().default(false),
-    confirmation: z9.string().optional()
-  }),
-  outputSchema: z9.object({
-    mode: z9.enum(["dry_run", "applied"]),
-    site_id: z9.string(),
-    pages_scanned: z9.number(),
-    total_match_count: z9.number(),
-    pages_with_matches: z9.array(z9.object({
-      page_id: z9.number(),
-      title: z9.string(),
-      match_count: z9.number()
+  inputSchema: z10.object({
+    site_id: z10.string().optional(),
+    find: z10.string().min(1),
+    replace: z10.string(),
+    widget_type: z10.string().optional(),
+    case_sensitive: z10.boolean().default(false),
+    confirmation: z10.string().optional()
+  }),
+  outputSchema: z10.object({
+    mode: z10.enum(["dry_run", "applied"]),
+    site_id: z10.string(),
+    pages_scanned: z10.number(),
+    total_match_count: z10.number(),
+    pages_with_matches: z10.array(z10.object({
+      page_id: z10.number(),
+      title: z10.string(),
+      match_count: z10.number()
     })),
-    pages_applied: z9.array(z9.object({
-      page_id: z9.number(),
-      backup_meta_key: z9.string().optional(),
-      css_flush: z9.string().optional(),
-      mode: z9.enum(["applied", "rolled_back", "skipped"]),
-      error: z9.string().optional()
+    pages_applied: z10.array(z10.object({
+      page_id: z10.number(),
+      backup_meta_key: z10.string().optional(),
+      css_flush: z10.string().optional(),
+      mode: z10.enum(["applied", "rolled_back", "skipped"]),
+      error: z10.string().optional()
     })).optional(),
-    confirmation_token: z9.string().optional(),
-    expires_in_seconds: z9.number().optional()
+    confirmation_token: z10.string().optional(),
+    expires_in_seconds: z10.number().optional()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2662,27 +2816,27 @@ var bulkFindReplaceSiteTool = defineTool({
 var fleetFindReplaceTool = defineTool({
   name: "fleet_find_replace",
   description: "Find/replace plain text across every Elementor page of every site in the pool. Same flow as bulk_find_replace_site but iterates across sites. Returns per-site + grand-total summary. Dry-run first; second call applies. Use sparingly \u2014 this is the nuclear option.",
-  inputSchema: z9.object({
-    find: z9.string().min(1),
-    replace: z9.string(),
-    site_ids: z9.array(z9.string()).optional().describe("Subset of sites to hit. Defaults to all."),
-    widget_type: z9.string().optional(),
-    case_sensitive: z9.boolean().default(false),
-    confirmation: z9.string().optional()
-  }),
-  outputSchema: z9.object({
-    mode: z9.enum(["dry_run", "applied"]),
-    sites_scanned: z9.number(),
-    total_match_count: z9.number(),
-    by_site: z9.array(z9.object({
-      site_id: z9.string(),
-      url: z9.string(),
-      pages_scanned: z9.number(),
-      matches: z9.number(),
-      error: z9.string().optional()
+  inputSchema: z10.object({
+    find: z10.string().min(1),
+    replace: z10.string(),
+    site_ids: z10.array(z10.string()).optional().describe("Subset of sites to hit. Defaults to all."),
+    widget_type: z10.string().optional(),
+    case_sensitive: z10.boolean().default(false),
+    confirmation: z10.string().optional()
+  }),
+  outputSchema: z10.object({
+    mode: z10.enum(["dry_run", "applied"]),
+    sites_scanned: z10.number(),
+    total_match_count: z10.number(),
+    by_site: z10.array(z10.object({
+      site_id: z10.string(),
+      url: z10.string(),
+      pages_scanned: z10.number(),
+      matches: z10.number(),
+      error: z10.string().optional()
     })),
-    confirmation_token: z9.string().optional(),
-    expires_in_seconds: z9.number().optional()
+    confirmation_token: z10.string().optional(),
+    expires_in_seconds: z10.number().optional()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2770,20 +2924,20 @@ var fleetFindReplaceTool = defineTool({
 var restoreFromFileTool = defineTool({
   name: "restore_from_file",
   description: "Restore a page from a JSON backup file (created by ANY earlier op with backup_to_file=true or by direct fullBackup with to_file). Requires the file_path returned by that backup. Two-call confirmation.",
-  inputSchema: z9.object({
-    site_id: z9.string().optional(),
-    page_id: z9.number().int().positive(),
-    file_path: z9.string().min(1),
-    confirmation: z9.string().optional()
-  }),
-  outputSchema: z9.object({
-    mode: z9.enum(["dry_run", "restored"]),
-    page_id: z9.number(),
-    file_path: z9.string(),
-    method: z9.enum(["wp-cli", "rest"]).optional(),
-    pre_restore_backup_meta_key: z9.string().optional(),
-    css_flush: z9.string().optional(),
-    confirmation_token: z9.string().optional()
+  inputSchema: z10.object({
+    site_id: z10.string().optional(),
+    page_id: z10.number().int().positive(),
+    file_path: z10.string().min(1),
+    confirmation: z10.string().optional()
+  }),
+  outputSchema: z10.object({
+    mode: z10.enum(["dry_run", "restored"]),
+    page_id: z10.number(),
+    file_path: z10.string(),
+    method: z10.enum(["wp-cli", "rest"]).optional(),
+    pre_restore_backup_meta_key: z10.string().optional(),
+    css_flush: z10.string().optional(),
+    confirmation_token: z10.string().optional()
   }),
   annotations: { destructiveHint: true, idempotentHint: false, openWorldHint: true },
   async handler(input) {
@@ -2955,6 +3109,16 @@ ${msg}` }],
   const transport = new StdioServerTransport();
   await server.connect(transport);
   logger.info({ tools: tools.length }, `${pkg.name} v${pkg.version} ready`);
+  if (!process.env["SUPPRESS_BANNER"] && !process.env["CI"]) {
+    process.stderr.write(
+      `
+  \u25B8 ${pkg.name} v${pkg.version} \u2014 ${tools.length} tools ready.
+    if this helps you, a \u2B50 on github.com/Mogacode-ma/elementor-mcp-agent
+    is the best thanks. (set SUPPRESS_BANNER=1 to silence this)
+
+`
+    );
+  }
 }
 main().catch((e) => {
   logger.error(e.message);