@sweepypanda/wp-elementor-mcp 1.7.2 → 1.7.4

package/dist/tool-handlers.js

@@ -1,6 +1,7 @@
 import { ElementorDataHandler } from './elementor-handler.js';
 import { getServerConfig } from './server-config.js';
 import { ResponseHelpers, ElementorHelpers } from './helpers.js';
+import { TempFileManager } from './utils.js';
 import FormData from 'form-data';
 export class ToolHandlers {
     wordPressClient;
@@ -98,6 +99,30 @@ export class ToolHandlers {
                     return await this.rebuildPageStructure(args);
                 case 'validate_elementor_data':
                     return await this.validateElementorData(args);
+                // Elementor Kit Management
+                case 'get_elementor_kit':
+                    return await this.getElementorKit(args);
+                case 'update_elementor_kit':
+                    return await this.updateElementorKit(args);
+                case 'export_elementor_kit_to_file':
+                    return await this.exportElementorKitToFile(args);
+                case 'import_elementor_kit_data':
+                    return await this.importElementorKitData(args);
+                case 'get_elementor_global_colors':
+                    return await this.getElementorGlobalColors(args);
+                case 'get_elementor_global_fonts':
+                    return await this.getElementorGlobalFonts(args);
+                // Elementor Template Management
+                case 'list_elementor_templates':
+                    return await this.listElementorTemplates(args);
+                case 'create_elementor_template':
+                    return await this.createElementorTemplate(args);
+                case 'update_elementor_template':
+                    return await this.updateElementorTemplate(args);
+                case 'get_elementor_template':
+                    return await this.getElementorTemplate(args);
+                case 'delete_elementor_template':
+                    return await this.deleteElementorTemplate(args);
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }
@@ -1256,18 +1281,39 @@ export class ToolHandlers {
                 return ResponseHelpers.createErrorResponse(`Failed to get Elementor data for post/page ID ${args.post_id}: ${parsedResult.error || 'Unknown error'}`, 'ELEMENTOR_DATA_ERROR', 'DATA_ERROR', 'Could not retrieve or parse Elementor data for adding widget');
             }
             const elementorData = parsedResult.data;
-            let targetColumn = null;
+            let targetContainer = null;
             if (args.column_id) {
-                targetColumn = ElementorHelpers.findElementRecursive(elementorData, args.column_id);
+                targetContainer = ElementorHelpers.findElementRecursive(elementorData, args.column_id);
             }
             else if (args.section_id) {
                 const section = ElementorHelpers.findElementRecursive(elementorData, args.section_id);
-                if (section && section.elements && section.elements.length > 0) {
-                    targetColumn = section.elements[0]; // Use first column
+                if (section) {
+                    if (section.elType === 'container') {
+                        // Containers hold widgets directly
+                        targetContainer = section;
+                    }
+                    else if (section.elements && section.elements.length > 0) {
+                        // Traditional section — find first column child
+                        const firstChild = section.elements[0];
+                        if (firstChild.elType === 'column') {
+                            targetContainer = firstChild;
+                        }
+                        else {
+                            // Section has direct children (non-column), add directly
+                            targetContainer = section;
+                        }
+                    }
+                    else {
+                        // Empty section/container — add directly
+                        targetContainer = section;
+                        if (!targetContainer.elements) {
+                            targetContainer.elements = [];
+                        }
+                    }
                 }
             }
-            if (!targetColumn) {
-                return ResponseHelpers.createErrorResponse(`Target column not found. Please specify a valid section_id or column_id`, 'TARGET_COLUMN_NOT_FOUND', 'NOT_FOUND', 'Could not locate target column for widget placement');
+            if (!targetContainer) {
+                return ResponseHelpers.createErrorResponse(`Target section/container not found. Please specify a valid section_id or column_id`, 'TARGET_NOT_FOUND', 'NOT_FOUND', 'Could not locate target element for widget placement');
             }
             const newWidget = {
                 id: ElementorHelpers.generateElementorId(),
@@ -1277,11 +1323,11 @@ export class ToolHandlers {
                 elements: [],
                 widgetType: args.widget_type
             };
-            if (args.position !== undefined && args.position >= 0 && args.position < targetColumn.elements.length) {
-                targetColumn.elements.splice(args.position, 0, newWidget);
+            if (args.position !== undefined && args.position >= 0 && args.position < targetContainer.elements.length) {
+                targetContainer.elements.splice(args.position, 0, newWidget);
             }
             else {
-                targetColumn.elements.push(newWidget);
+                targetContainer.elements.push(newWidget);
             }
             await this.updateElementorData({
                 post_id: args.post_id,
@@ -1291,8 +1337,9 @@ export class ToolHandlers {
                 operation_type: "add_widget_to_section",
                 widget_id: newWidget.id,
                 widget_type: args.widget_type,
-                target_column_id: targetColumn.id,
-                position: args.position || targetColumn.elements.length - 1,
+                target_id: targetContainer.id,
+                target_type: targetContainer.elType,
+                position: args.position !== undefined ? args.position : targetContainer.elements.length - 1,
                 post_id: args.post_id,
                 widget_settings: args.widget_settings || {}
             }, `Widget ${args.widget_type} added successfully! Widget ID: ${newWidget.id}`);
@@ -1635,7 +1682,88 @@ export class ToolHandlers {
         const authCheck = this.wordPressClient.ensureAuthenticated();
         if (authCheck)
             return authCheck;
-        return ResponseHelpers.createErrorResponse('Rebuild page structure not yet implemented. Please use WordPress admin interface to rebuild page structure.', 'NOT_IMPLEMENTED', 'FEATURE_NOT_AVAILABLE', 'Use WordPress admin interface for page structure rebuilding');
+        try {
+            const parsedResult = await this.elementorHandler.safeGetElementorData(args.post_id);
+            if (!parsedResult.success || !parsedResult.data) {
+                return ResponseHelpers.createErrorResponse(`Failed to get Elementor data for post/page ID ${args.post_id}: ${parsedResult.error || 'Unknown error'}`, 'ELEMENTOR_DATA_ERROR', 'DATA_ERROR', 'Could not retrieve or parse Elementor data for rebuilding');
+            }
+            const elementorData = parsedResult.data;
+            const repairs = [];
+            let repairCount = 0;
+            const rebuildElement = (element, path) => {
+                // Fix missing ID
+                if (!element.id) {
+                    element.id = ElementorHelpers.generateElementorId();
+                    repairs.push(`Generated missing ID at ${path}: ${element.id}`);
+                    repairCount++;
+                }
+                // Fix missing elType
+                if (!element.elType) {
+                    if (element.widgetType) {
+                        element.elType = 'widget';
+                    }
+                    else if (element.elements && element.elements.length > 0) {
+                        element.elType = 'container';
+                    }
+                    else {
+                        element.elType = 'container';
+                    }
+                    repairs.push(`Set missing elType to '${element.elType}' at ${path}`);
+                    repairCount++;
+                }
+                // Ensure elements array exists for non-widget types
+                if (element.elType !== 'widget' && !element.elements) {
+                    element.elements = [];
+                    repairs.push(`Added missing elements array at ${path}`);
+                    repairCount++;
+                }
+                // Ensure settings object exists
+                if (!element.settings) {
+                    element.settings = {};
+                    repairs.push(`Added missing settings object at ${path}`);
+                    repairCount++;
+                }
+                // Ensure widgets have empty elements array
+                if (element.elType === 'widget' && !element.elements) {
+                    element.elements = [];
+                }
+                // Recursively rebuild children
+                if (element.elements && Array.isArray(element.elements)) {
+                    element.elements = element.elements
+                        .filter((child) => child && typeof child === 'object')
+                        .map((child, index) => rebuildElement(child, `${path}.elements[${index}]`));
+                }
+                return element;
+            };
+            // Remove any null/invalid top-level elements
+            const originalCount = elementorData.length;
+            const validData = elementorData.filter((el) => el && typeof el === 'object');
+            if (validData.length < originalCount) {
+                repairs.push(`Removed ${originalCount - validData.length} invalid top-level elements`);
+                repairCount += originalCount - validData.length;
+            }
+            // Rebuild each element
+            const rebuiltData = validData.map((element, index) => rebuildElement(element, `root[${index}]`));
+            // Save if repairs were made
+            if (repairCount > 0) {
+                await this.updateElementorData({
+                    post_id: args.post_id,
+                    elementor_data: JSON.stringify(rebuiltData)
+                });
+            }
+            return ResponseHelpers.createSuccessResponse({
+                post_id: args.post_id,
+                repairs_made: repairCount,
+                repairs,
+                total_elements: rebuiltData.length,
+                data_modified: repairCount > 0
+            }, repairCount > 0
+                ? `Page structure rebuilt with ${repairCount} repairs for post ID ${args.post_id}`
+                : `Page structure is clean — no repairs needed for post ID ${args.post_id}`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to rebuild page structure: ${error.message}`, 'REBUILD_ERROR', 'API_ERROR', `Rebuild process failed: ${error.message}`);
+        }
     }
     async validateElementorData(args) {
         const authCheck = this.wordPressClient.ensureAuthenticated();
@@ -1678,5 +1806,433 @@ export class ToolHandlers {
             return ResponseHelpers.createErrorResponse(`Failed to validate Elementor data: ${error.message}`, 'VALIDATION_ERROR', 'API_ERROR', `Validation process failed: ${error.message}`);
         }
     }
+    // ===== Elementor Kit Management Helpers =====
+    async getActiveKitId() {
+        const axios = this.wordPressClient.getAxiosInstance();
+        // Try to get the active kit ID from WordPress options
+        try {
+            const response = await axios.get('wp/v2/settings');
+            if (response.data && response.data.elementor_active_kit) {
+                return Number(response.data.elementor_active_kit);
+            }
+        }
+        catch (_) {
+            // Settings endpoint may not expose this option, fall through
+        }
+        // Fallback: query for kit-type posts in elementor_library
+        try {
+            const response = await axios.get('wp/v2/elementor_library', {
+                params: {
+                    type: 'kit',
+                    per_page: 1,
+                    context: 'edit',
+                },
+            });
+            if (response.data && Array.isArray(response.data) && response.data.length > 0) {
+                return response.data[0].id;
+            }
+        }
+        catch (_) {
+            // Fall through
+        }
+        // Last resort: try well-known option via custom endpoint or options
+        try {
+            const response = await axios.get('wp/v2/options/elementor_active_kit');
+            if (response.data && response.data.value) {
+                return Number(response.data.value);
+            }
+        }
+        catch (_) {
+            // Fall through
+        }
+        throw new Error('Could not determine the active Elementor kit ID. Ensure Elementor is installed and a kit is active.');
+    }
+    async getKitSettings(kitId) {
+        const axios = this.wordPressClient.getAxiosInstance();
+        const response = await axios.get(`wp/v2/elementor_library/${kitId}`, {
+            params: { context: 'edit' },
+        });
+        const post = response.data;
+        let settings = {};
+        // Extract settings from post meta
+        if (post.meta && post.meta._elementor_page_settings) {
+            settings = typeof post.meta._elementor_page_settings === 'string'
+                ? JSON.parse(post.meta._elementor_page_settings)
+                : post.meta._elementor_page_settings;
+        }
+        return { post, settings };
+    }
+    // ===== Elementor Kit Management Handlers =====
+    async getElementorKit(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const { post, settings } = await this.getKitSettings(kitId);
+            let filteredSettings = settings;
+            if (args.include_settings && args.include_settings.length > 0) {
+                filteredSettings = {};
+                const settingsMap = {
+                    colors: ['system_colors', 'custom_colors'],
+                    fonts: ['system_typography', 'custom_typography'],
+                    typography: ['default_generic_fonts', 'body_typography_typography', 'body_typography_font_family', 'body_typography_font_size', 'body_typography_font_weight', 'h1_typography_typography', 'h1_typography_font_family', 'h1_typography_font_size', 'h2_typography_typography', 'h2_typography_font_family', 'h2_typography_font_size', 'h3_typography_typography', 'h3_typography_font_family', 'h3_typography_font_size', 'h4_typography_typography', 'h4_typography_font_family', 'h4_typography_font_size', 'h5_typography_typography', 'h5_typography_font_family', 'h5_typography_font_size', 'h6_typography_typography', 'h6_typography_font_family', 'h6_typography_font_size'],
+                    buttons: ['button_typography_typography', 'button_typography_font_family', 'button_typography_font_size', 'button_typography_font_weight', 'button_text_color', 'button_background_color', 'button_border_radius', 'button_padding'],
+                };
+                for (const filter of args.include_settings) {
+                    const keys = settingsMap[filter.toLowerCase()];
+                    if (keys) {
+                        for (const key of keys) {
+                            if (settings[key] !== undefined) {
+                                filteredSettings[key] = settings[key];
+                            }
+                        }
+                    }
+                    else {
+                        // Direct key lookup
+                        if (settings[filter] !== undefined) {
+                            filteredSettings[filter] = settings[filter];
+                        }
+                    }
+                }
+            }
+            return ResponseHelpers.createSuccessResponse({
+                kit_id: kitId,
+                title: post.title?.rendered || post.title || 'Default Kit',
+                settings: filteredSettings,
+                total_settings_keys: Object.keys(settings).length,
+                filtered: !!(args.include_settings && args.include_settings.length > 0),
+            }, `Successfully retrieved Elementor kit settings (kit ID: ${kitId})`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to get Elementor kit: ${error.message}`, 'GET_KIT_ERROR', 'API_ERROR', `Kit retrieval failed: ${error.message}`);
+        }
+    }
+    async updateElementorKit(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const { settings: existingSettings } = await this.getKitSettings(kitId);
+            const mergedSettings = { ...existingSettings, ...args.settings };
+            const axios = this.wordPressClient.getAxiosInstance();
+            await axios.post(`wp/v2/elementor_library/${kitId}`, {
+                meta: {
+                    _elementor_page_settings: mergedSettings,
+                },
+            });
+            const updatedKeys = Object.keys(args.settings);
+            return ResponseHelpers.createSuccessResponse({
+                kit_id: kitId,
+                updated_keys: updatedKeys,
+                total_updated: updatedKeys.length,
+                settings: mergedSettings,
+            }, `Successfully updated ${updatedKeys.length} Elementor kit setting(s)`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to update Elementor kit: ${error.message}`, 'UPDATE_KIT_ERROR', 'API_ERROR', `Kit update failed: ${error.message}`);
+        }
+    }
+    async exportElementorKitToFile(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const { post, settings } = await this.getKitSettings(kitId);
+            const exportData = {
+                kit_id: kitId,
+                title: post.title?.rendered || post.title || 'Default Kit',
+                settings,
+                exported_at: new Date().toISOString(),
+            };
+            if (args.include_content) {
+                exportData.content = post.content;
+                if (post.meta && post.meta._elementor_data) {
+                    exportData.elementor_data = typeof post.meta._elementor_data === 'string'
+                        ? JSON.parse(post.meta._elementor_data)
+                        : post.meta._elementor_data;
+                }
+            }
+            const tempFileResult = TempFileManager.writeElementorDataToFile(kitId, exportData);
+            return ResponseHelpers.createSuccessResponse({
+                ...tempFileResult,
+                kit_id: kitId,
+                include_content: !!args.include_content,
+            }, `Elementor kit exported to file: ${tempFileResult.file_path}`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to export Elementor kit: ${error.message}`, 'EXPORT_KIT_ERROR', 'API_ERROR', `Kit export failed: ${error.message}`);
+        }
+    }
+    async importElementorKitData(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const merge = args.merge !== false; // default true
+            let finalSettings;
+            if (merge) {
+                const { settings: existingSettings } = await this.getKitSettings(kitId);
+                finalSettings = { ...existingSettings, ...args.kit_data };
+            }
+            else {
+                finalSettings = args.kit_data;
+            }
+            const axios = this.wordPressClient.getAxiosInstance();
+            await axios.post(`wp/v2/elementor_library/${kitId}`, {
+                meta: {
+                    _elementor_page_settings: finalSettings,
+                },
+            });
+            const importedKeys = Object.keys(args.kit_data);
+            return ResponseHelpers.createSuccessResponse({
+                kit_id: kitId,
+                merge,
+                imported_keys: importedKeys,
+                total_imported: importedKeys.length,
+                total_settings: Object.keys(finalSettings).length,
+            }, `Successfully imported ${importedKeys.length} setting(s) into Elementor kit (merge: ${merge})`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to import Elementor kit data: ${error.message}`, 'IMPORT_KIT_ERROR', 'API_ERROR', `Kit import failed: ${error.message}`);
+        }
+    }
+    async getElementorGlobalColors(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const { settings } = await this.getKitSettings(kitId);
+            return ResponseHelpers.createSuccessResponse({
+                kit_id: kitId,
+                system_colors: settings.system_colors || [],
+                custom_colors: settings.custom_colors || [],
+            }, `Retrieved global colors from Elementor kit (kit ID: ${kitId})`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to get global colors: ${error.message}`, 'GET_GLOBAL_COLORS_ERROR', 'API_ERROR', `Global colors retrieval failed: ${error.message}`);
+        }
+    }
+    async getElementorGlobalFonts(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const kitId = await this.getActiveKitId();
+            const { settings } = await this.getKitSettings(kitId);
+            return ResponseHelpers.createSuccessResponse({
+                kit_id: kitId,
+                system_typography: settings.system_typography || [],
+                custom_typography: settings.custom_typography || [],
+            }, `Retrieved global fonts/typography from Elementor kit (kit ID: ${kitId})`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to get global fonts: ${error.message}`, 'GET_GLOBAL_FONTS_ERROR', 'API_ERROR', `Global fonts retrieval failed: ${error.message}`);
+        }
+    }
+    // ===== Elementor Template Management Handlers =====
+    async listElementorTemplates(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const axios = this.wordPressClient.getAxiosInstance();
+            const params = {
+                per_page: args.per_page || 20,
+                page: args.page || 1,
+                context: 'edit',
+            };
+            if (args.status) {
+                params.status = args.status;
+            }
+            if (args.search) {
+                params.search = args.search;
+            }
+            const response = await axios.get('wp/v2/elementor_library', { params });
+            let templates = response.data;
+            // Filter by template type if specified (via meta)
+            if (args.template_type) {
+                templates = templates.filter((t) => t.meta?._elementor_template_type === args.template_type);
+            }
+            const templateSummaries = templates.map((template) => ({
+                id: template.id,
+                title: template.title?.rendered || template.title?.raw || '(No title)',
+                template_type: template.meta?._elementor_template_type || 'unknown',
+                status: template.status,
+                date_created: template.date,
+                date_modified: template.modified,
+                author: template.author,
+                has_elementor_data: !!template.meta?._elementor_data,
+                slug: template.slug,
+            }));
+            return ResponseHelpers.createSuccessResponse({
+                templates: templateSummaries,
+                count: templateSummaries.length,
+                page: args.page || 1,
+                per_page: args.per_page || 20,
+                filter_type: args.template_type || 'all',
+                total_in_response: response.data.length,
+            }, `Retrieved ${templateSummaries.length} Elementor template(s)${args.template_type ? ` of type '${args.template_type}'` : ''}`);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return ResponseHelpers.createErrorResponse('Elementor templates endpoint not found. Make sure Elementor is installed and the elementor_library post type is registered.', 'TEMPLATES_NOT_FOUND', 'NOT_FOUND', 'The wp/v2/elementor_library endpoint is not available');
+            }
+            return ResponseHelpers.createErrorResponse(`Failed to list Elementor templates: ${error.message}`, 'LIST_TEMPLATES_ERROR', 'API_ERROR', `HTTP ${error.response?.status}: ${error.response?.statusText}`);
+        }
+    }
+    async createElementorTemplate(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const axios = this.wordPressClient.getAxiosInstance();
+            const postData = {
+                title: args.title,
+                status: args.status || 'draft',
+                meta: {
+                    _elementor_template_type: args.template_type,
+                    _elementor_edit_mode: 'builder',
+                    _elementor_data: args.elementor_data || '[]',
+                },
+            };
+            if (args.page_settings) {
+                postData.meta._elementor_page_settings = args.page_settings;
+            }
+            const response = await axios.post('wp/v2/elementor_library', postData);
+            return ResponseHelpers.createSuccessResponse({
+                template_id: response.data.id,
+                title: response.data.title?.rendered || response.data.title?.raw || args.title,
+                template_type: args.template_type,
+                status: response.data.status,
+                date_created: response.data.date,
+                slug: response.data.slug,
+                has_elementor_data: !!args.elementor_data,
+                has_page_settings: !!args.page_settings,
+            }, `Elementor template created successfully! ID: ${response.data.id}, Type: ${args.template_type}, Status: ${response.data.status}`);
+        }
+        catch (error) {
+            return ResponseHelpers.createErrorResponse(`Failed to create Elementor template: ${error.response?.data?.message || error.message}`, 'CREATE_TEMPLATE_ERROR', 'API_ERROR', `HTTP ${error.response?.status}: ${error.response?.statusText}`);
+        }
+    }
+    async updateElementorTemplate(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const axios = this.wordPressClient.getAxiosInstance();
+            const updateData = {};
+            if (args.title) {
+                updateData.title = args.title;
+            }
+            if (args.status) {
+                updateData.status = args.status;
+            }
+            const meta = {};
+            if (args.template_type) {
+                meta._elementor_template_type = args.template_type;
+            }
+            if (args.elementor_data) {
+                meta._elementor_data = args.elementor_data;
+                meta._elementor_edit_mode = 'builder';
+            }
+            if (args.page_settings) {
+                meta._elementor_page_settings = args.page_settings;
+            }
+            if (Object.keys(meta).length > 0) {
+                updateData.meta = meta;
+            }
+            const response = await axios.post(`wp/v2/elementor_library/${args.template_id}`, updateData);
+            return ResponseHelpers.createSuccessResponse({
+                template_id: response.data.id,
+                title: response.data.title?.rendered || response.data.title?.raw,
+                template_type: response.data.meta?._elementor_template_type,
+                status: response.data.status,
+                date_modified: response.data.modified,
+                updated_fields: [
+                    ...(args.title ? ['title'] : []),
+                    ...(args.status ? ['status'] : []),
+                    ...(args.template_type ? ['template_type'] : []),
+                    ...(args.elementor_data ? ['elementor_data'] : []),
+                    ...(args.page_settings ? ['page_settings'] : []),
+                ],
+            }, `Elementor template ${args.template_id} updated successfully`);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return ResponseHelpers.createErrorResponse(`Template with ID ${args.template_id} not found`, 'TEMPLATE_NOT_FOUND', 'NOT_FOUND', `HTTP 404: Template ${args.template_id} does not exist`);
+            }
+            return ResponseHelpers.createErrorResponse(`Failed to update Elementor template: ${error.response?.data?.message || error.message}`, 'UPDATE_TEMPLATE_ERROR', 'API_ERROR', `HTTP ${error.response?.status}: ${error.response?.statusText}`);
+        }
+    }
+    async getElementorTemplate(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const axios = this.wordPressClient.getAxiosInstance();
+            const response = await axios.get(`wp/v2/elementor_library/${args.template_id}`, {
+                params: { context: 'edit' },
+            });
+            const template = response.data;
+            let elementorData = null;
+            if (template.meta?._elementor_data) {
+                try {
+                    elementorData = typeof template.meta._elementor_data === 'string'
+                        ? JSON.parse(template.meta._elementor_data)
+                        : template.meta._elementor_data;
+                }
+                catch {
+                    elementorData = template.meta._elementor_data;
+                }
+            }
+            return ResponseHelpers.createSuccessResponse({
+                template_id: template.id,
+                title: template.title?.rendered || template.title?.raw || '(No title)',
+                template_type: template.meta?._elementor_template_type || 'unknown',
+                status: template.status,
+                date_created: template.date,
+                date_modified: template.modified,
+                author: template.author,
+                slug: template.slug,
+                elementor_data: elementorData,
+                page_settings: template.meta?._elementor_page_settings || {},
+                element_count: Array.isArray(elementorData) ? elementorData.length : 0,
+            }, `Retrieved Elementor template ${args.template_id}: "${template.title?.rendered || template.title?.raw}"`);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return ResponseHelpers.createErrorResponse(`Template with ID ${args.template_id} not found`, 'TEMPLATE_NOT_FOUND', 'NOT_FOUND', `HTTP 404: Template ${args.template_id} does not exist`);
+            }
+            return ResponseHelpers.createErrorResponse(`Failed to get Elementor template: ${error.response?.data?.message || error.message}`, 'GET_TEMPLATE_ERROR', 'API_ERROR', `HTTP ${error.response?.status}: ${error.response?.statusText}`);
+        }
+    }
+    async deleteElementorTemplate(args) {
+        const authCheck = this.wordPressClient.ensureAuthenticated();
+        if (authCheck)
+            return authCheck;
+        try {
+            const axios = this.wordPressClient.getAxiosInstance();
+            const response = await axios.delete(`wp/v2/elementor_library/${args.template_id}`, {
+                params: { force: args.force || false },
+            });
+            return ResponseHelpers.createSuccessResponse({
+                template_id: args.template_id,
+                deleted: true,
+                force: args.force || false,
+                previous_status: response.data.status,
+            }, `Elementor template ${args.template_id} ${args.force ? 'permanently deleted' : 'moved to trash'}`);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return ResponseHelpers.createErrorResponse(`Template with ID ${args.template_id} not found`, 'TEMPLATE_NOT_FOUND', 'NOT_FOUND', `HTTP 404: Template ${args.template_id} does not exist`);
+            }
+            return ResponseHelpers.createErrorResponse(`Failed to delete Elementor template: ${error.response?.data?.message || error.message}`, 'DELETE_TEMPLATE_ERROR', 'API_ERROR', `HTTP ${error.response?.status}: ${error.response?.statusText}`);
+        }
+    }
 }
 //# sourceMappingURL=tool-handlers.js.map