mx-cloud 0.0.12 → 0.0.14

package/build/browserSide/scraper.js

@@ -360,18 +360,169 @@ function scrapableHeuristics(maxCountPerPage = 50, minArea = 20000, scrolls = 3,
     window.scrapeList = function (_a) {
         return __awaiter(this, arguments, void 0, function* ({ listSelector, fields, limit = 10 }) {
             // XPath evaluation functions
-            const evaluateXPath = (rootElement, xpath) => {
+            const queryInsideContext = (context, part) => {
                 try {
-                    const ownerDoc = rootElement.nodeType === Node.DOCUMENT_NODE
-                        ? rootElement
-                        : rootElement.ownerDocument;
-                    if (!ownerDoc)
-                        return null;
-                    const result = ownerDoc.evaluate(xpath, rootElement, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-                    return result.singleNodeValue;
+                    const { tagName, conditions } = parseXPathPart(part);
+                    const candidateElements = Array.from(context.querySelectorAll(tagName));
+                    if (candidateElements.length === 0) {
+                        return [];
+                    }
+                    const matchingElements = candidateElements.filter((el) => {
+                        return elementMatchesConditions(el, conditions);
+                    });
+                    return matchingElements;
                 }
-                catch (error) {
-                    console.warn("XPath evaluation failed:", xpath, error);
+                catch (err) {
+                    console.error("Error in queryInsideContext:", err);
+                    return [];
+                }
+            };
+            // Helper function to parse XPath part
+            const parseXPathPart = (part) => {
+                const tagMatch = part.match(/^([a-zA-Z0-9-]+)/);
+                const tagName = tagMatch ? tagMatch[1] : "*";
+                const conditionMatches = part.match(/\[([^\]]+)\]/g);
+                const conditions = conditionMatches
+                    ? conditionMatches.map((c) => c.slice(1, -1))
+                    : [];
+                return { tagName, conditions };
+            };
+            // Helper function to check if element matches all conditions
+            const elementMatchesConditions = (element, conditions) => {
+                for (const condition of conditions) {
+                    if (!elementMatchesCondition(element, condition)) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            // Helper function to check if element matches a single condition
+            const elementMatchesCondition = (element, condition) => {
+                var _a, _b;
+                condition = condition.trim();
+                if (/^\d+$/.test(condition)) {
+                    return true;
+                }
+                // Handle @attribute="value"
+                const attrMatch = condition.match(/^@([^=]+)=["']([^"']+)["']$/);
+                if (attrMatch) {
+                    const [, attr, value] = attrMatch;
+                    const elementValue = element.getAttribute(attr);
+                    return elementValue === value;
+                }
+                // Handle contains(@class, 'value')
+                const classContainsMatch = condition.match(/^contains\(@class,\s*["']([^"']+)["']\)$/);
+                if (classContainsMatch) {
+                    const className = classContainsMatch[1];
+                    return element.classList.contains(className);
+                }
+                // Handle contains(@attribute, 'value')
+                const attrContainsMatch = condition.match(/^contains\(@([^,]+),\s*["']([^"']+)["']\)$/);
+                if (attrContainsMatch) {
+                    const [, attr, value] = attrContainsMatch;
+                    const elementValue = element.getAttribute(attr) || "";
+                    return elementValue.includes(value);
+                }
+                // Handle text()="value"
+                const textMatch = condition.match(/^text\(\)=["']([^"']+)["']$/);
+                if (textMatch) {
+                    const expectedText = textMatch[1];
+                    const elementText = ((_a = element.textContent) === null || _a === void 0 ? void 0 : _a.trim()) || "";
+                    return elementText === expectedText;
+                }
+                // Handle contains(text(), 'value')
+                const textContainsMatch = condition.match(/^contains\(text\(\),\s*["']([^"']+)["']\)$/);
+                if (textContainsMatch) {
+                    const expectedText = textContainsMatch[1];
+                    const elementText = ((_b = element.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || "";
+                    return elementText.includes(expectedText);
+                }
+                // Handle count(*)=0 (element has no children)
+                if (condition === "count(*)=0") {
+                    return element.children.length === 0;
+                }
+                // Handle other count conditions
+                const countMatch = condition.match(/^count\(\*\)=(\d+)$/);
+                if (countMatch) {
+                    const expectedCount = parseInt(countMatch[1]);
+                    return element.children.length === expectedCount;
+                }
+                return true;
+            };
+            const evaluateXPath = (document, xpath, isShadow = false) => {
+                try {
+                    const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                    if (!isShadow) {
+                        if (result === null) {
+                            return null;
+                        }
+                        return result;
+                    }
+                    let cleanPath = xpath;
+                    let isIndexed = false;
+                    const indexedMatch = xpath.match(/^\((.*?)\)\[(\d+)\](.*)$/);
+                    if (indexedMatch) {
+                        cleanPath = indexedMatch[1] + indexedMatch[3];
+                        isIndexed = true;
+                    }
+                    const pathParts = cleanPath
+                        .replace(/^\/\//, "")
+                        .split("/")
+                        .map((p) => p.trim())
+                        .filter((p) => p.length > 0);
+                    let currentContexts = [document];
+                    for (let i = 0; i < pathParts.length; i++) {
+                        const part = pathParts[i];
+                        const nextContexts = [];
+                        for (const ctx of currentContexts) {
+                            const positionalMatch = part.match(/^([^[]+)\[(\d+)\]$/);
+                            let partWithoutPosition = part;
+                            let requestedPosition = null;
+                            if (positionalMatch) {
+                                partWithoutPosition = positionalMatch[1];
+                                requestedPosition = parseInt(positionalMatch[2]);
+                            }
+                            const matched = queryInsideContext(ctx, partWithoutPosition);
+                            let elementsToAdd = matched;
+                            if (requestedPosition !== null) {
+                                const index = requestedPosition - 1; // XPath is 1-based, arrays are 0-based
+                                if (index >= 0 && index < matched.length) {
+                                    elementsToAdd = [matched[index]];
+                                }
+                                else {
+                                    console.warn(`Position ${requestedPosition} out of range (${matched.length} elements found)`);
+                                    elementsToAdd = [];
+                                }
+                            }
+                            elementsToAdd.forEach((el) => {
+                                nextContexts.push(el);
+                                if (el.shadowRoot) {
+                                    nextContexts.push(el.shadowRoot);
+                                }
+                            });
+                        }
+                        if (nextContexts.length === 0) {
+                            return null;
+                        }
+                        currentContexts = nextContexts;
+                    }
+                    if (currentContexts.length > 0) {
+                        if (isIndexed && indexedMatch) {
+                            const requestedIndex = parseInt(indexedMatch[2]) - 1;
+                            if (requestedIndex >= 0 && requestedIndex < currentContexts.length) {
+                                return currentContexts[requestedIndex];
+                            }
+                            else {
+                                console.warn(`Requested index ${requestedIndex + 1} out of range (${currentContexts.length} elements found)`);
+                                return null;
+                            }
+                        }
+                        return currentContexts[0];
+                    }
+                    return null;
+                }
+                catch (err) {
+                    console.error("Critical XPath failure:", xpath, err);
                     return null;
                 }
             };
@@ -834,7 +985,7 @@ function scrapableHeuristics(maxCountPerPage = 50, minArea = 20000, scrolls = 3,
                         if (isXPathSelector(field.selector)) {
                             // Create indexed absolute XPath
                             const indexedSelector = createIndexedXPath(field.selector, listSelector, containerIndex + 1);
-                            element = evaluateXPath(document, indexedSelector);
+                            element = evaluateXPath(document, indexedSelector, field.isShadow);
                         }
                         else {
                             // Fallback for CSS selectors within XPath containers

package/build/interpret.d.ts

@@ -11,12 +11,14 @@ declare global {
             selector: string;
             tag: string;
             attribute: string;
+            listFallbackSelector?: string;
         }>) => Record<string, any>;
         scrapeList: (config: {
             listSelector: string;
             fields: any;
             limit?: number;
             pagination: any;
+            listFallbackSelector?: string;
         }) => Record<string, any>[];
         scrapeListAuto: (listSelector: string) => {
             selector: string;
@@ -95,6 +97,44 @@ export default class Interpreter extends EventEmitter {
     private generatePageNodeInformation;
     private detectElementChanges;
     private validateWorkflowAction;
+    /**
+     * Test if a selector is working on the current page
+     * @param {Page} page - Playwright page object
+     * @param {string} selector - Selector to test
+     * @param {boolean} isListSelector - Whether this should find multiple elements
+     * @returns {Promise<boolean>} - Whether the selector works
+     */
+    private testSelectorWorks;
+    /**
+     * Generate new selector from fallback selector
+     * @param {Page} page - Playwright page object
+     * @param {string} fallbackSelector - Fallback selector to use
+     * @param {boolean} isListSelector - Whether this is a list selector
+     * @param {string} listContext - List selector context for field selectors
+     * @returns {Promise<string|null>} - New selector or null if failed
+     */
+    private generateSelectorFromFallback;
+    /**
+     * Validate and fix scrapeList action selectors
+     * @param {Object} scrapeListConfig - ScrapeList configuration object
+     * @param {Page} page - Playwright page object
+     * @returns {Promise<boolean>} - Whether any changes were made
+     */
+    private validateScrapeListAction;
+    /**
+     * Validate and fix scrapeSchema action selectors
+     * @param {Object} scrapeSchemaConfig - ScrapeSchema configuration object
+     * @param {Page} page - Playwright page object
+     * @returns {Promise<boolean>} - Whether any changes were made
+     */
+    private validateScrapeSchemaAction;
+    /**
+     * Validate and fix selectors for a workflow action just before execution
+     * @param {Page} page - Playwright page object
+     * @param {WhereWhatPair} action - The action to validate
+     * @returns {Promise<WhereWhatPair>} - The potentially modified action
+     */
+    private validateAndFixSelectors;
     private runLoop;
     private ensureScriptsLoaded;
     /**

package/build/interpret.js

@@ -559,7 +559,43 @@ class Interpreter extends events_1.EventEmitter {
                 }
                 return false;
             };
-            // Enhanced button finder with retry mechanism
+            // Helper function to detect if a selector is XPath
+            const isXPathSelector = (selector) => {
+                return selector.startsWith('//') ||
+                    selector.startsWith('/') ||
+                    selector.startsWith('./') ||
+                    selector.includes('contains(@') ||
+                    selector.includes('[count(') ||
+                    selector.includes('@class=') ||
+                    selector.includes('@id=') ||
+                    selector.includes(' and ') ||
+                    selector.includes(' or ');
+            };
+            // Helper function to wait for selector (CSS or XPath)
+            const waitForSelectorUniversal = (selector_2, ...args_1) => __awaiter(this, [selector_2, ...args_1], void 0, function* (selector, options = {}) {
+                try {
+                    if (isXPathSelector(selector)) {
+                        // Use XPath locator
+                        const locator = page.locator(`xpath=${selector}`);
+                        yield locator.waitFor({
+                            state: 'attached',
+                            timeout: options.timeout || 10000
+                        });
+                        return yield locator.elementHandle();
+                    }
+                    else {
+                        // Use CSS selector
+                        return yield page.waitForSelector(selector, {
+                            state: 'attached',
+                            timeout: options.timeout || 10000
+                        });
+                    }
+                }
+                catch (error) {
+                    return null;
+                }
+            });
+            // Enhanced button finder with retry mechanism for both CSS and XPath selectors
             const findWorkingButton = (selectors) => __awaiter(this, void 0, void 0, function* () {
                 let updatedSelectors = [...selectors];
                 for (let i = 0; i < selectors.length; i++) {
@@ -568,10 +604,7 @@ class Interpreter extends events_1.EventEmitter {
                     let selectorSuccess = false;
                     while (retryCount < MAX_RETRIES && !selectorSuccess) {
                         try {
-                            const button = yield page.waitForSelector(selector, {
-                                state: 'attached',
-                                timeout: 10000
-                            });
+                            const button = yield waitForSelectorUniversal(selector, { timeout: 10000 });
                             if (button) {
                                 debugLog('Found working selector:', selector);
                                 return {
@@ -829,9 +862,9 @@ class Interpreter extends events_1.EventEmitter {
                             if (checkLimit())
                                 return allResults;
                             let loadMoreCounter = 0;
-                            let previousResultCount = allResults.length;
-                            let noNewItemsCounter = 0;
-                            const MAX_NO_NEW_ITEMS = 2;
+                            // let previousResultCount = allResults.length;
+                            // let noNewItemsCounter = 0;
+                            // const MAX_NO_NEW_ITEMS = 2;
                             while (true) {
                                 // Find working button with retry mechanism
                                 const { button: loadMoreButton, workingSelector, updatedSelectors } = yield findWorkingButton(availableSelectors);
@@ -888,20 +921,19 @@ class Interpreter extends events_1.EventEmitter {
                                 const heightChanged = currentHeight !== previousHeight;
                                 previousHeight = currentHeight;
                                 yield scrapeCurrentPage();
-                                const currentResultCount = allResults.length;
-                                const newItemsAdded = currentResultCount > previousResultCount;
-                                if (!newItemsAdded) {
-                                    noNewItemsCounter++;
-                                    debugLog(`No new items added after click (${noNewItemsCounter}/${MAX_NO_NEW_ITEMS})`);
-                                    if (noNewItemsCounter >= MAX_NO_NEW_ITEMS) {
-                                        debugLog(`Stopping after ${MAX_NO_NEW_ITEMS} clicks with no new items`);
-                                        return allResults;
-                                    }
-                                }
-                                else {
-                                    noNewItemsCounter = 0;
-                                    previousResultCount = currentResultCount;
-                                }
+                                // const currentResultCount = allResults.length;
+                                // const newItemsAdded = currentResultCount > previousResultCount;
+                                // if (!newItemsAdded) {
+                                //   noNewItemsCounter++;
+                                //   debugLog(`No new items added after click (${noNewItemsCounter}/${MAX_NO_NEW_ITEMS})`);
+                                //   if (noNewItemsCounter >= MAX_NO_NEW_ITEMS) {
+                                //     debugLog(`Stopping after ${MAX_NO_NEW_ITEMS} clicks with no new items`);
+                                //     return allResults;
+                                //   }
+                                // } else {
+                                //   noNewItemsCounter = 0;
+                                //   previousResultCount = currentResultCount;
+                                // }
                                 if (checkLimit())
                                     return allResults;
                                 if (!heightChanged) {
@@ -1564,6 +1596,266 @@ class Interpreter extends events_1.EventEmitter {
             return modifiedAction;
         });
     }
+    /**
+     * Test if a selector is working on the current page
+     * @param {Page} page - Playwright page object
+     * @param {string} selector - Selector to test
+     * @param {boolean} isListSelector - Whether this should find multiple elements
+     * @returns {Promise<boolean>} - Whether the selector works
+     */
+    testSelectorWorks(page_1, selector_2) {
+        return __awaiter(this, arguments, void 0, function* (page, selector, isListSelector = false) {
+            try {
+                if (!selector || selector.trim() === '') {
+                    return false;
+                }
+                const isXPath = selector.startsWith('//') ||
+                    selector.startsWith('/') ||
+                    selector.includes('contains(@') ||
+                    selector.includes('@class=') ||
+                    selector.includes('@id=');
+                let count = 0;
+                if (isXPath) {
+                    const locator = page.locator(`xpath=${selector}`);
+                    count = yield locator.count();
+                }
+                else {
+                    const elements = yield page.$$(selector);
+                    count = elements ? elements.length : 0;
+                }
+                // For list selectors, we need multiple elements
+                if (isListSelector) {
+                    return count >= 2;
+                }
+                // For field selectors, we need at least one element
+                return count >= 1;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    /**
+     * Generate new selector from fallback selector
+     * @param {Page} page - Playwright page object
+     * @param {string} fallbackSelector - Fallback selector to use
+     * @param {boolean} isListSelector - Whether this is a list selector
+     * @param {string} listContext - List selector context for field selectors
+     * @returns {Promise<string|null>} - New selector or null if failed
+     */
+    generateSelectorFromFallback(page_1, fallbackSelector_1) {
+        return __awaiter(this, arguments, void 0, function* (page, fallbackSelector, isListSelector = false, listContext = '', isPagination = false) {
+            var _a, _b;
+            try {
+                // First check if fallback selector works
+                const fallbackWorks = yield this.testSelectorWorks(page, fallbackSelector, isListSelector);
+                if (!fallbackWorks) {
+                    return null;
+                }
+                // Get element using fallback selector
+                const isXPath = fallbackSelector.startsWith('//') ||
+                    fallbackSelector.startsWith('/') ||
+                    fallbackSelector.includes('contains(@');
+                let element;
+                if (isXPath) {
+                    element = yield page.locator(`xpath=${fallbackSelector}`).first().elementHandle();
+                }
+                else {
+                    element = yield page.$(fallbackSelector);
+                }
+                if (!element) {
+                    return null;
+                }
+                // Generate new selectors
+                let newSelectors;
+                if (isListSelector) {
+                    return yield (0, selector_1.generateListSelectorFromFallback)(page, fallbackSelector);
+                }
+                else if (listContext) {
+                    return yield (0, selector_1.generateListFieldSelectorFromFallback)(page, fallbackSelector, listContext);
+                }
+                else {
+                    newSelectors = yield (0, selector_1.generateFieldSelectorFromFallback)(page, fallbackSelector);
+                    if (isPagination) {
+                        // For pagination, chain selectors in priority order
+                        let chainedSelectors = [
+                            (_a = newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.iframeSelector) === null || _a === void 0 ? void 0 : _a.full,
+                            (_b = newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.shadowSelector) === null || _b === void 0 ? void 0 : _b.full,
+                            newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.testIdSelector,
+                            newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.id,
+                            newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.hrefSelector,
+                            newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.accessibilitySelector,
+                            newSelectors === null || newSelectors === void 0 ? void 0 : newSelectors.attrSelector,
+                        ]
+                            .filter(selector => selector !== null && selector !== undefined)
+                            .join(',');
+                        return chainedSelectors;
+                    }
+                    else {
+                        // For non-pagination, use getBestSelector
+                        const tagName = yield element.evaluate(el => el.tagName.toLowerCase());
+                        return yield (0, utils_1.getBestSelector)({
+                            selectors: newSelectors,
+                            tagName: tagName
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to generate selector from fallback: ${error.message}`);
+                return null;
+            }
+        });
+    }
+    /**
+     * Validate and fix scrapeList action selectors
+     * @param {Object} scrapeListConfig - ScrapeList configuration object
+     * @param {Page} page - Playwright page object
+     * @returns {Promise<boolean>} - Whether any changes were made
+     */
+    validateScrapeListAction(scrapeListConfig, page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let hasChanges = false;
+            try {
+                // Validate listSelector
+                const listSelectorWorks = yield this.testSelectorWorks(page, scrapeListConfig.listSelector, true);
+                if (!listSelectorWorks && scrapeListConfig.listFallbackSelector) {
+                    console.log(`ListSelector "${scrapeListConfig.listSelector}" not working, trying fallback...`);
+                    const newListSelector = yield this.generateSelectorFromFallback(page, scrapeListConfig.listFallbackSelector, true);
+                    if (newListSelector) {
+                        console.log(`Updated listSelector: ${scrapeListConfig.listSelector} -> ${newListSelector}`);
+                        scrapeListConfig.listSelector = newListSelector;
+                        hasChanges = true;
+                    }
+                }
+                // Validate field selectors
+                if (scrapeListConfig.fields) {
+                    for (const [fieldName, fieldConfig] of Object.entries(scrapeListConfig.fields)) {
+                        const fieldSelectorWorks = yield this.testSelectorWorks(page, fieldConfig.selector, false);
+                        if (!fieldSelectorWorks && fieldConfig.fallbackSelector) {
+                            console.log(`Field selector "${fieldConfig.selector}" for ${fieldName} not working, trying fallback...`);
+                            const newFieldSelector = yield this.generateSelectorFromFallback(page, fieldConfig.fallbackSelector, false, scrapeListConfig.listSelector);
+                            if (newFieldSelector) {
+                                console.log(`Updated field selector for ${fieldName}: ${fieldConfig.selector} -> ${newFieldSelector}`);
+                                fieldConfig.selector = newFieldSelector;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                }
+                // Validate pagination selector if it exists and is not empty
+                if (scrapeListConfig.pagination &&
+                    scrapeListConfig.pagination.selector &&
+                    scrapeListConfig.pagination.selector.trim() !== '') {
+                    // Handle comma-separated pagination selectors
+                    const paginationSelectors = scrapeListConfig.pagination.selector.split(',').map(s => s.trim());
+                    let workingSelector = null;
+                    for (const selector of paginationSelectors) {
+                        const works = yield this.testSelectorWorks(page, selector, false);
+                        if (works) {
+                            workingSelector = selector;
+                            break;
+                        }
+                    }
+                    if (!workingSelector && scrapeListConfig.pagination.fallbackSelector) {
+                        console.log(`Pagination selector not working, trying fallback...`);
+                        const newPaginationSelector = yield this.generateSelectorFromFallback(page, scrapeListConfig.pagination.fallbackSelector, false, '', true);
+                        if (newPaginationSelector) {
+                            console.log(`Updated pagination selector: ${scrapeListConfig.pagination.selector} -> ${newPaginationSelector}`);
+                            scrapeListConfig.pagination.selector = newPaginationSelector;
+                            hasChanges = true;
+                        }
+                    }
+                    else if (workingSelector && workingSelector !== scrapeListConfig.pagination.selector) {
+                        scrapeListConfig.pagination.selector = workingSelector;
+                        hasChanges = true;
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error validating scrapeList action: ${error.message}`);
+            }
+            return hasChanges;
+        });
+    }
+    /**
+     * Validate and fix scrapeSchema action selectors
+     * @param {Object} scrapeSchemaConfig - ScrapeSchema configuration object
+     * @param {Page} page - Playwright page object
+     * @returns {Promise<boolean>} - Whether any changes were made
+     */
+    validateScrapeSchemaAction(scrapeSchemaConfig, page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let hasChanges = false;
+            try {
+                for (const [fieldName, fieldConfig] of Object.entries(scrapeSchemaConfig)) {
+                    if (fieldConfig.selector) {
+                        const selectorWorks = yield this.testSelectorWorks(page, fieldConfig.selector, false);
+                        if (!selectorWorks && fieldConfig.fallbackSelector) {
+                            console.log(`Schema field selector "${fieldConfig.selector}" for ${fieldName} not working, trying fallback...`);
+                            const newSelector = yield this.generateSelectorFromFallback(page, fieldConfig.fallbackSelector, false);
+                            if (newSelector) {
+                                console.log(`Updated schema field selector for ${fieldName}: ${fieldConfig.selector} -> ${newSelector}`);
+                                fieldConfig.selector = newSelector;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error validating scrapeSchema action: ${error.message}`);
+            }
+            return hasChanges;
+        });
+    }
+    /**
+     * Validate and fix selectors for a workflow action just before execution
+     * @param {Page} page - Playwright page object
+     * @param {WhereWhatPair} action - The action to validate
+     * @returns {Promise<WhereWhatPair>} - The potentially modified action
+     */
+    validateAndFixSelectors(page, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modifiedAction = JSON.parse(JSON.stringify(action));
+            let totalChanges = 0;
+            try {
+                // Process each action in the 'what' array
+                for (let i = 0; i < modifiedAction.what.length; i++) {
+                    const whatAction = modifiedAction.what[i];
+                    // Handle scrapeList actions
+                    if (whatAction.action === 'scrapeList' && whatAction.args && whatAction.args[0]) {
+                        console.log(`Validating scrapeList action...`);
+                        const hasChanges = yield this.validateScrapeListAction(whatAction.args[0], page);
+                        if (hasChanges) {
+                            totalChanges++;
+                            console.log(`Fixed scrapeList selectors`);
+                        }
+                    }
+                    // Handle scrapeSchema actions
+                    if (whatAction.action === 'scrapeSchema' && whatAction.args && whatAction.args[0]) {
+                        console.log(`Validating scrapeSchema action...`);
+                        const hasChanges = yield this.validateScrapeSchemaAction(whatAction.args[0], page);
+                        if (hasChanges) {
+                            totalChanges++;
+                            console.log(`Fixed scrapeSchema selectors`);
+                        }
+                    }
+                }
+                if (totalChanges > 0) {
+                    console.log(`Selector validation completed: ${totalChanges} actions modified`);
+                }
+                else {
+                    console.log(`Selector validation completed: No changes needed`);
+                }
+            }
+            catch (error) {
+                console.error(`Error in selector validation: ${error.message}`);
+                this.trackAutohealFailure(`Selector validation failed: ${error.message}`);
+            }
+            return modifiedAction;
+        });
+    }
     runLoop(p, workflow) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -1661,8 +1953,9 @@ class Interpreter extends events_1.EventEmitter {
                     }
                     lastAction = action;
                     try {
-                        console.log("Carrying out:", action.what);
-                        yield this.carryOutSteps(p, action.what);
+                        const validatedAction = yield this.validateAndFixSelectors(p, action);
+                        console.log("Carrying out:", validatedAction.what);
+                        yield this.carryOutSteps(p, validatedAction.what);
                         usedActions.push((_b = action.id) !== null && _b !== void 0 ? _b : 'undefined');
                         workflowCopy.splice(actionId, 1);
                         console.log(`Action with ID ${action.id} removed from the workflow copy.`);

package/build/preprocessor.js

@@ -47,7 +47,7 @@ class Preprocessor {
     */
     static getParams(workflow) {
         const getParamsRecurse = (object) => {
-            if (typeof object === 'object') {
+            if (typeof object === 'object' && object !== null) {
                 // Recursion base case
                 if (object.$param) {
                     return [object.$param];
@@ -123,13 +123,26 @@ class Preprocessor {
             const out = object;
             // for every key (child) of the object
             Object.keys(object).forEach((key) => {
-                // if the field has only one key, which is `k`
-                if (Object.keys(object[key]).length === 1 && object[key][k]) {
-                    // process the current special tag (init param, hydrate regex...)
-                    out[key] = f(object[key][k]);
+                const childValue = object[key];
+                // Skip if childValue is null, undefined, or not an object
+                if (!childValue || typeof childValue !== 'object') {
+                    return; // Continue to next iteration
                 }
-                else {
-                    initSpecialRecurse(object[key], k, f);
+                try {
+                    const childKeys = Object.keys(childValue);
+                    // if the field has only one key, which is `k`
+                    if (childKeys.length === 1 && childValue[k]) {
+                        // process the current special tag (init param, hydrate regex...)
+                        out[key] = f(childValue[k]);
+                    }
+                    else {
+                        // Recursively process the child object
+                        initSpecialRecurse(childValue, k, f);
+                    }
+                }
+                catch (error) {
+                    // If Object.keys fails or any other error, just continue
+                    console.warn(`Error processing key "${key}" in initSpecialRecurse:`, error);
                 }
             });
             return out;

package/build/selector.d.ts

@@ -29,4 +29,31 @@ interface SelectorResult {
  * @returns {Promise<Selectors|null|undefined>}
 */
 export declare const generateNonUniqueSelectors: (page: Page, elementHandle: ElementHandle, listSelector?: string) => Promise<SelectorResult>;
+/**
+ * Generate new list selector from fallback element (based on your reference implementation)
+ * @param page - Playwright page object
+ * @param fallbackSelector - Fallback selector to use
+ * @returns New list selector or null if failed
+ */
+export declare const generateListSelectorFromFallback: (page: Page, fallbackSelector: string) => Promise<string | null>;
+/**
+ * Generate new field selector from fallback selector (one field at a time)
+ * @param page - Playwright page object
+ * @param fallbackSelector - Fallback selector to use
+ * @param listSelector - The list selector context
+ * @returns New field selector or null if failed
+ */
+export declare const generateListFieldSelectorFromFallback: (page: Page, fallbackSelector: string, listSelector: string) => Promise<string | null>;
+export declare const generateFieldSelectorFromFallback: (page: Page, fallbackSelector: string) => Promise<{
+    id: string | null;
+    generalSelector: string | null;
+    attrSelector: string | null;
+    testIdSelector: string | null;
+    text: string;
+    href?: string;
+    hrefSelector: string | null;
+    accessibilitySelector: string | null;
+    formSelector: string | null;
+    relSelector: string | null;
+} | null>;
 export {};

package/build/selector.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateNonUniqueSelectors = exports.generateSelectors = void 0;
+exports.generateFieldSelectorFromFallback = exports.generateListFieldSelectorFromFallback = exports.generateListSelectorFromFallback = exports.generateNonUniqueSelectors = exports.generateSelectors = void 0;
 const generateSelectors = (page, elementHandle) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const selectors = yield elementHandle.evaluate((element) => {
@@ -848,3 +848,487 @@ const generateNonUniqueSelectors = (page_1, elementHandle_1, ...args_1) => __awa
     }
 });
 exports.generateNonUniqueSelectors = generateNonUniqueSelectors;
+/**
+ * Generate new list selector from fallback element (based on your reference implementation)
+ * @param page - Playwright page object
+ * @param fallbackSelector - Fallback selector to use
+ * @returns New list selector or null if failed
+ */
+const generateListSelectorFromFallback = (page, fallbackSelector) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Execute selector generation within the page context
+        const newSelector = yield page.evaluate((selector) => {
+            try {
+                // Check if selector is XPath
+                const isXPath = selector.startsWith('//') ||
+                    selector.startsWith('/') ||
+                    selector.includes('contains(@');
+                let elements;
+                if (isXPath) {
+                    // Use XPath evaluation
+                    const xpathResult = document.evaluate(selector, document, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
+                    elements = [];
+                    let node = xpathResult.iterateNext();
+                    while (node && elements.length < 5) { // Limit to 5 elements for performance
+                        if (node.nodeType === Node.ELEMENT_NODE) {
+                            elements.push(node);
+                        }
+                        node = xpathResult.iterateNext();
+                    }
+                }
+                else {
+                    // Use CSS selector
+                    const nodeList = document.querySelectorAll(selector);
+                    elements = Array.from(nodeList).slice(0, 5); // Limit to 5 elements
+                }
+                if (!elements || elements.length === 0) {
+                    return null;
+                }
+                // Extract element data for analysis
+                const elementData = elements.map((el) => ({
+                    tagName: el.tagName.toLowerCase(),
+                    className: el.getAttribute('class') || '',
+                    attributes: Array.from(el.attributes).reduce((attrs, attr) => {
+                        if (!['id', 'style', 'data-mx-id'].includes(attr.name)) {
+                            attrs[attr.name] = attr.value;
+                        }
+                        return attrs;
+                    }, {}),
+                    childrenCount: el.children.length
+                }));
+                if (elementData.length === 0) {
+                    return null;
+                }
+                const firstElement = elementData[0];
+                const tagName = firstElement.tagName;
+                // Check if all elements have the same tag name
+                const allSameTag = elementData.every((el) => el.tagName === tagName);
+                if (!allSameTag) {
+                    console.warn("Inconsistent tag names in group, using first element's tag");
+                }
+                // Start building XPath - ALWAYS generate primary XPath
+                let xpath = `//${tagName}`;
+                const predicates = [];
+                // Get common classes
+                const allClasses = elementData.map((el) => el.className.split(/\s+/).filter(Boolean));
+                if (allClasses.length > 0 && allClasses[0].length > 0) {
+                    // Find classes that appear in most elements (at least 60%)
+                    const classFrequency = new Map();
+                    allClasses.forEach((classes) => {
+                        classes.forEach((cls) => {
+                            classFrequency.set(cls, (classFrequency.get(cls) || 0) + 1);
+                        });
+                    });
+                    const minFrequency = Math.ceil(allClasses.length * 0.6);
+                    const commonClasses = Array.from(classFrequency.entries())
+                        .filter(([_, count]) => count >= minFrequency)
+                        .map(([cls, _]) => cls);
+                    if (commonClasses.length > 0) {
+                        predicates.push(...commonClasses.map((cls) => `contains(@class, '${cls}')`));
+                    }
+                }
+                // Get common attributes (excluding id, style, data-mx-id)
+                if (elementData.length > 1) {
+                    const commonAttributes = {};
+                    const firstAttrs = firstElement.attributes;
+                    for (const [attr, value] of Object.entries(firstAttrs)) {
+                        const isCommon = elementData.every((el) => el.attributes[attr] === value);
+                        if (isCommon) {
+                            commonAttributes[attr] = value;
+                        }
+                    }
+                    for (const [attr, value] of Object.entries(commonAttributes)) {
+                        predicates.push(`@${attr}='${value}'`);
+                    }
+                }
+                // Optional: Common child count (only if consistent across most elements)
+                const childCountFrequency = new Map();
+                elementData.forEach((el) => {
+                    childCountFrequency.set(el.childrenCount, (childCountFrequency.get(el.childrenCount) || 0) + 1);
+                });
+                const mostCommonChildCount = Array.from(childCountFrequency.entries())
+                    .sort((a, b) => b[1] - a[1])[0];
+                if (mostCommonChildCount && mostCommonChildCount[1] >= Math.ceil(elementData.length * 0.8)) {
+                    predicates.push(`count(*)=${mostCommonChildCount[0]}`);
+                }
+                // Build final XPath
+                if (predicates.length > 0) {
+                    xpath += `[${predicates.join(' and ')}]`;
+                }
+                console.log(`Generated list selector: ${xpath} from fallback: ${selector}`);
+                return xpath;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`Failed to generate list selector from fallback: ${errorMessage}`);
+                return null;
+            }
+        }, fallbackSelector);
+        return newSelector;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`Failed to execute selector generation: ${errorMessage}`);
+        return null;
+    }
+});
+exports.generateListSelectorFromFallback = generateListSelectorFromFallback;
+/**
+ * Generate new field selector from fallback selector (one field at a time)
+ * @param page - Playwright page object
+ * @param fallbackSelector - Fallback selector to use
+ * @param listSelector - The list selector context
+ * @returns New field selector or null if failed
+ */
+const generateListFieldSelectorFromFallback = (page, fallbackSelector, listSelector) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Execute field selector generation within the page context
+        const newSelector = yield page.evaluate(({ fallbackSel, listSel }) => {
+            // Helper function to check if selector is XPath
+            const isXPathSelector = (selector) => {
+                return selector.startsWith('//') ||
+                    selector.startsWith('/') ||
+                    selector.includes('contains(@') ||
+                    selector.includes('@class=') ||
+                    selector.includes('@id=');
+            };
+            // Helper function to evaluate XPath
+            const evaluateXPath = (xpath) => {
+                try {
+                    const result = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+                    const elements = [];
+                    for (let i = 0; i < result.snapshotLength; i++) {
+                        const node = result.snapshotItem(i);
+                        if (node && node.nodeType === Node.ELEMENT_NODE) {
+                            elements.push(node);
+                        }
+                    }
+                    return elements;
+                }
+                catch (error) {
+                    return [];
+                }
+            };
+            // Helper function to get sibling position
+            const getSiblingPosition = (element, parent) => {
+                const siblings = Array.from(parent.children || [])
+                    .filter((child) => child.tagName === element.tagName);
+                return siblings.indexOf(element) + 1;
+            };
+            // Generate optimized structural step
+            const generateOptimizedStructuralStep = (element, rootElement) => {
+                const tagName = element.tagName.toLowerCase();
+                const parent = element.parentElement;
+                if (!parent) {
+                    return tagName;
+                }
+                // Use classes first
+                const classes = Array.from(element.classList);
+                if (classes.length > 0) {
+                    const classSelector = classes
+                        .map((cls) => `contains(@class, '${cls}')`)
+                        .join(" and ");
+                    return `${tagName}[${classSelector}]`;
+                }
+                // Try meaningful attributes
+                const meaningfulAttrs = ["role", "type", "name", "src", "aria-label"];
+                for (const attrName of meaningfulAttrs) {
+                    if (element.hasAttribute(attrName)) {
+                        const value = element.getAttribute(attrName).replace(/'/g, "\\'");
+                        return `${tagName}[@${attrName}='${value}']`;
+                    }
+                }
+                // Try test ID
+                const testId = element.getAttribute("data-testid");
+                if (testId) {
+                    return `${tagName}[@data-testid='${testId}']`;
+                }
+                // Try ID
+                if (element.id && !element.id.match(/^\d/)) {
+                    return `${tagName}[@id='${element.id}']`;
+                }
+                // Try other data attributes
+                for (const attr of Array.from(element.attributes)) {
+                    if (attr.name.startsWith("data-") &&
+                        attr.name !== "data-testid" &&
+                        attr.name !== "data-mx-id" &&
+                        attr.value) {
+                        return `${tagName}[@${attr.name}='${attr.value}']`;
+                    }
+                }
+                // Fallback to position
+                const position = getSiblingPosition(element, parent);
+                return `${tagName}[${position}]`;
+            };
+            // Get optimized structural path
+            const getOptimizedStructuralPath = (targetElement, rootElement) => {
+                if (!rootElement.contains(targetElement) || targetElement === rootElement) {
+                    return null;
+                }
+                const pathParts = [];
+                let current = targetElement;
+                // Build path from target up to root
+                while (current && current !== rootElement) {
+                    const pathPart = generateOptimizedStructuralStep(current, rootElement);
+                    if (pathPart) {
+                        pathParts.unshift(pathPart);
+                    }
+                    current = current.parentElement;
+                    if (!current)
+                        break;
+                }
+                return pathParts.length > 0 ? "/" + pathParts.join("/") : null;
+            };
+            try {
+                // Get the first element from fallback selector
+                let targetElement = null;
+                if (isXPathSelector(fallbackSel)) {
+                    const elements = evaluateXPath(fallbackSel);
+                    targetElement = elements[0] || null;
+                }
+                else {
+                    targetElement = document.querySelector(fallbackSel);
+                }
+                if (!targetElement) {
+                    return null;
+                }
+                // Get the list container elements
+                const parentElements = evaluateXPath(listSel);
+                let containingParent = null;
+                for (const parent of parentElements) {
+                    if (parent.contains(targetElement)) {
+                        containingParent = parent;
+                        break;
+                    }
+                }
+                if (!containingParent) {
+                    return null;
+                }
+                // Build structural path
+                const structuralPath = getOptimizedStructuralPath(targetElement, containingParent);
+                if (!structuralPath) {
+                    return null;
+                }
+                // Combine list selector with structural path
+                const newSelector = listSel + structuralPath;
+                console.log(`Generated field selector: ${newSelector} from fallback: ${fallbackSel}`);
+                return newSelector;
+            }
+            catch (error) {
+                console.error("Error generating field selector:", error);
+                return null;
+            }
+        }, { fallbackSel: fallbackSelector, listSel: listSelector });
+        return newSelector;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`Failed to generate field selector: ${errorMessage}`);
+        return null;
+    }
+});
+exports.generateListFieldSelectorFromFallback = generateListFieldSelectorFromFallback;
+/* Generate all schema field selectors from fallback selector (CSS to CSS)
+* @param page - Playwright page object
+* @param fallbackSelector - CSS fallback selector to use
+* @returns Array of all generated CSS selectors or null if failed
+*/
+const generateFieldSelectorFromFallback = (page, fallbackSelector) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Execute schema field selector generation within the page context
+        const selectors = yield page.evaluate((fallbackSel) => {
+            // CSS escape function (simplified version from your reference)
+            function cssesc(string, options = {}) {
+                const { isIdentifier = false } = options;
+                let output = '';
+                for (let i = 0; i < string.length; i++) {
+                    const char = string.charAt(i);
+                    const code = char.charCodeAt(0);
+                    if (code < 0x20 || code > 0x7e) {
+                        output += '\\' + code.toString(16).toUpperCase() + ' ';
+                    }
+                    else if (/[\t\n\f\r\x0B]/.test(char)) {
+                        output += '\\' + code.toString(16).toUpperCase() + ' ';
+                    }
+                    else if (char === '\\' || (isIdentifier && /[ -,\.\/:-@\[\]\^`\{-~]/.test(char))) {
+                        output += '\\' + char;
+                    }
+                    else {
+                        output += char;
+                    }
+                }
+                if (isIdentifier && /\d/.test(string.charAt(0))) {
+                    output = '\\3' + string.charAt(0) + ' ' + output.slice(1);
+                }
+                return output;
+            }
+            // Main finder function (simplified version from your reference)
+            function finder(input, options = {}) {
+                if (input.nodeType !== Node.ELEMENT_NODE) {
+                    throw new Error("Can't generate CSS selector for non-element node type.");
+                }
+                if (input.tagName.toLowerCase() === 'html') {
+                    return 'html';
+                }
+                // If attr function is provided, use it to filter attributes
+                if (options.attr) {
+                    const attrs = Array.from(input.attributes).filter(attr => options.attr(attr.name) && attr.name !== 'data-mx-id');
+                    if (attrs.length > 0) {
+                        const attr = attrs[0];
+                        return `[${cssesc(attr.name, { isIdentifier: true })}="${cssesc(attr.value)}"]`;
+                    }
+                }
+                // Try ID first
+                const elementId = input.getAttribute('id');
+                if (elementId && !elementId.match(/^\d/)) {
+                    return '#' + cssesc(elementId, { isIdentifier: true });
+                }
+                // Try classes
+                const classes = Array.from(input.classList);
+                if (classes.length > 0) {
+                    const classSelector = classes.map(cls => '.' + cssesc(cls, { isIdentifier: true })).join('');
+                    const tagName = input.tagName.toLowerCase();
+                    return tagName + classSelector;
+                }
+                // Try attributes
+                const meaningfulAttrs = ['data-testid', 'data-test-id', 'data-testing', 'data-test', 'data-qa', 'data-cy', 'name', 'aria-label', 'alt', 'title', 'href', 'role', 'type'];
+                for (const attrName of meaningfulAttrs) {
+                    if (input.hasAttribute(attrName) && attrName !== 'data-mx-id') {
+                        const value = input.getAttribute(attrName);
+                        if (value) {
+                            return `[${cssesc(attrName, { isIdentifier: true })}="${cssesc(value)}"]`;
+                        }
+                    }
+                }
+                // Fallback to tag name with nth-child if needed
+                const tagName = input.tagName.toLowerCase();
+                const parent = input.parentElement;
+                if (parent) {
+                    const siblings = Array.from(parent.children).filter(child => child.tagName === input.tagName);
+                    if (siblings.length > 1) {
+                        const index = siblings.indexOf(input) + 1;
+                        return `${tagName}:nth-child(${index})`;
+                    }
+                }
+                return tagName;
+            }
+            // Generate selectors for attributes
+            function genSelectorForAttributes(element, attributes) {
+                try {
+                    for (const attr of attributes) {
+                        if (element.hasAttribute(attr)) {
+                            const value = element.getAttribute(attr);
+                            if (value && value.length > 0) {
+                                if (attr === 'rel') {
+                                    return `[rel="${value}"]`;
+                                }
+                                return `[${cssesc(attr, { isIdentifier: true })}="${cssesc(value)}"]`;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                catch (e) {
+                    return null;
+                }
+            }
+            // Check if character is number
+            function isCharacterNumber(char) {
+                return char && char.length === 1 && /[0-9]/.test(char);
+            }
+            // Generate attribute set
+            function genAttributeSet(element, attributes) {
+                return new Set(attributes.filter((attr) => {
+                    const attrValue = element.getAttribute(attr);
+                    return attrValue != null && attrValue.length > 0;
+                }));
+            }
+            // Check if attributes are defined
+            function isAttributesDefined(element, attributes) {
+                return genAttributeSet(element, attributes).size > 0;
+            }
+            // Generate valid attribute filter
+            function genValidAttributeFilter(element, attributes) {
+                const attrSet = genAttributeSet(element, attributes);
+                return (name) => attrSet.has(name);
+            }
+            // Main selector generation function (based on genSelectors from your reference)
+            function genSelectors(element) {
+                var _a;
+                const href = element.getAttribute('href');
+                let generalSelector = null;
+                try {
+                    generalSelector = finder(element);
+                }
+                catch (e) {
+                    console.warn('Error generating general selector:', e);
+                }
+                let attrSelector = null;
+                try {
+                    attrSelector = finder(element, { attr: () => true });
+                }
+                catch (e) {
+                    console.warn('Error generating attr selector:', e);
+                }
+                const relSelector = genSelectorForAttributes(element, ['rel']);
+                const hrefSelector = genSelectorForAttributes(element, ['href']);
+                const formSelector = genSelectorForAttributes(element, ['name', 'placeholder', 'for']);
+                const accessibilitySelector = genSelectorForAttributes(element, ['aria-label', 'alt', 'title']);
+                const testIdSelector = genSelectorForAttributes(element, [
+                    'data-testid', 'data-test-id', 'data-testing', 'data-test', 'data-qa', 'data-cy'
+                ]);
+                // We won't use an id selector if the id is invalid (starts with a number)
+                let idSelector = null;
+                try {
+                    idSelector = isAttributesDefined(element, ['id']) &&
+                        !isCharacterNumber((_a = element.id) === null || _a === void 0 ? void 0 : _a[0])
+                        ? finder(element, {
+                            attr: (name) => name === 'id',
+                        })
+                        : null;
+                }
+                catch (e) {
+                    console.warn('Error generating id selector:', e);
+                }
+                return {
+                    id: idSelector,
+                    generalSelector,
+                    attrSelector,
+                    testIdSelector,
+                    text: element.innerText,
+                    href: href !== null && href !== void 0 ? href : undefined,
+                    hrefSelector,
+                    accessibilitySelector,
+                    formSelector,
+                    relSelector,
+                };
+            }
+            try {
+                // Get the target element from CSS fallback selector
+                const targetElement = document.querySelector(fallbackSel);
+                if (!targetElement) {
+                    console.warn('Target element not found with CSS fallback selector:', fallbackSel);
+                    return null;
+                }
+                // Prioritize Link logic (from your reference)
+                const { parentElement } = targetElement;
+                const element = (parentElement === null || parentElement === void 0 ? void 0 : parentElement.tagName) === 'A' ? parentElement : targetElement;
+                // Generate all selectors using the same logic as your reference
+                const generatedSelectors = genSelectors(element);
+                console.log('Generated schema field CSS selectors:', generatedSelectors);
+                return generatedSelectors;
+            }
+            catch (error) {
+                console.error('Error in schema field CSS selector generation:', error);
+                return null;
+            }
+        }, fallbackSelector);
+        return selectors;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`Failed to generate schema field CSS selectors: ${errorMessage}`);
+        return null;
+    }
+});
+exports.generateFieldSelectorFromFallback = generateFieldSelectorFromFallback;

package/build/types/workflow.d.ts

@@ -83,6 +83,7 @@ export interface SchemaConfig {
     nodeInfo: SerializedNode;
     selector: string;
     attribute: string;
+    fallbackSelector?: string;
     coordinates: Coordinates;
     elementMetadata: {
         classList: string[];
@@ -93,6 +94,7 @@ export interface SchemaConfig {
 }
 export interface ScrapeListSchema {
     listSelector: string;
+    listFallbackSelector?: string;
     listSelectorInfo: {
         nodeInfo: SerializedNode;
         coordinates: Coordinates;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mx-cloud",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "mx cloud",
   "main": "build/index.js",
   "typings": "build/index.d.ts",