@papicandela/mcx-core 0.2.6 → 0.2.7

package/dist/index.js

@@ -6488,13 +6488,62 @@ class BunWorkerSandbox {
         return arr.slice(0, n);
       };
 
+      /**
+       * Poll a function until condition is met or max iterations reached.
+       * @param fn - Async function to call. Return { done: true, value } to stop.
+       * @param opts - { interval: ms (default 1000), maxIterations: n (default 10) }
+       * @returns Array of all results, or last result if done:true was returned
+       */
+      globalThis.poll = async (fn, opts = {}) => {
+        const interval = opts.interval ?? 1000;
+        const maxIterations = opts.maxIterations ?? 10;
+        const results = [];
+
+        for (let i = 0; i < maxIterations; i++) {
+          const result = await fn(i);
+          results.push(result);
+
+          // Check for done signal
+          if (result && typeof result === 'object' && result.done) {
+            return result.value !== undefined ? result.value : results;
+          }
+
+          // Wait before next iteration (skip on last)
+          if (i < maxIterations - 1) {
+            await new Promise(r => setTimeout(r, interval));
+          }
+        }
+
+        return results;
+      };
+
+      /**
+       * Wait for a condition to become true.
+       * @param fn - Async function that returns truthy when done
+       * @param opts - { interval: ms (default 500), timeout: ms (default 10000) }
+       * @returns The truthy value returned by fn
+       */
+      globalThis.waitFor = async (fn, opts = {}) => {
+        const interval = opts.interval ?? 500;
+        const timeout = opts.timeout ?? 10000;
+        const start = Date.now();
+
+        while (Date.now() - start < timeout) {
+          const result = await fn();
+          if (result) return result;
+          await new Promise(r => setTimeout(r, interval));
+        }
+
+        throw new Error('waitFor timeout after ' + timeout + 'ms');
+      };
+
       // SECURITY: Reserved keys that must not be overwritten by user-provided variables/globals
       const RESERVED_KEYS = new Set([
         'onmessage', 'postMessage', 'close', 'terminate', 'self',
         'constructor', 'prototype', '__proto__',
         'pendingCalls', 'callId', 'logs', 'console', 'adapters',
         'fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource',
-        'pick', 'table', 'count', 'sum', 'first', 'safeStr'
+        'pick', 'table', 'count', 'sum', 'first', 'safeStr', 'poll', 'waitFor'
       ]);
 
       self.onmessage = async (event) => {
@@ -6538,6 +6587,12 @@ class BunWorkerSandbox {
             return matrix[b.length][a.length];
           };
 
+          // Convert camelCase to snake_case
+          const toSnakeCase = (str) => str
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            .toLowerCase();
+
           // Find similar method names
           const findSimilar = (name, methods, maxDist = 3) => {
             const normalized = name.toLowerCase().replace(/[-_]/g, '');
@@ -6549,6 +6604,22 @@ class BunWorkerSandbox {
               .map(x => x.method);
           };
 
+          // Find best auto-correctable match (distance ≤ 2 = safe to auto-correct)
+          const findAutoCorrect = (name, methods) => {
+            // Try exact snake_case conversion first
+            const snake = toSnakeCase(name);
+            if (methods.includes(snake)) return snake;
+
+            // Try normalized fuzzy match
+            const normalized = name.toLowerCase().replace(/[-_]/g, '');
+            const matches = methods
+              .map(m => ({ method: m, dist: levenshtein(normalized, m.toLowerCase().replace(/[-_]/g, '')) }))
+              .filter(x => x.dist <= 2) // Only auto-correct if very close
+              .sort((a, b) => a.dist - b.dist);
+
+            return matches.length > 0 ? matches[0].method : null;
+          };
+
           // Create adapter proxies with helpful error messages
           const adaptersObj = {};
           for (const [adapterName, methods] of Object.entries(adapterMethods)) {
@@ -6569,16 +6640,45 @@ class BunWorkerSandbox {
               };
             }
 
-            // Use Proxy to intercept undefined method calls
+            // Precompute auto-correct lookup (O(1) instead of O(n) per access)
+            const autoCorrectMap = new Map();
+            for (const m of methods) {
+              // Map snake_case variants: execute_sql -> execute_sql (identity)
+              autoCorrectMap.set(m, m);
+              // Map normalized: executesql -> execute_sql
+              autoCorrectMap.set(m.toLowerCase().replace(/[-_]/g, ''), m);
+            }
+
+            // Use Proxy to intercept undefined method calls with auto-correction
             const adapterProxy = new Proxy(methodsImpl, {
               get(target, prop) {
                 if (prop in target) return target[prop];
                 if (typeof prop === 'symbol') return undefined;
-                const similar = findSimilar(String(prop), methods);
+
+                const propStr = String(prop);
+
+                // Fast path: check precomputed map (O(1))
+                const snake = toSnakeCase(propStr);
+                if (autoCorrectMap.has(snake)) {
+                  return target[autoCorrectMap.get(snake)];
+                }
+                const normalized = propStr.toLowerCase().replace(/[-_]/g, '');
+                if (autoCorrectMap.has(normalized)) {
+                  return target[autoCorrectMap.get(normalized)];
+                }
+
+                // Slow path: fuzzy match for typos (only if fast path failed)
+                const corrected = findAutoCorrect(propStr, methods);
+                if (corrected && corrected in target) {
+                  return target[corrected];
+                }
+
+                // No auto-correct possible, throw with suggestions
+                const similar = findSimilar(propStr, methods);
                 const suggestion = similar.length > 0
                   ? '. Did you mean: ' + similar.join(', ') + '?'
                   : '. Available: ' + methods.slice(0, 5).join(', ') + (methods.length > 5 ? '...' : '');
-                throw new Error(adapterName + '.' + String(prop) + ' is not a function' + suggestion);
+                throw new Error(adapterName + '.' + propStr + ' is not a function' + suggestion);
               }
             });
 
@@ -6615,7 +6715,23 @@ class BunWorkerSandbox {
             const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
             const fn = new AsyncFunction(data.code);
             const result = await fn();
-            self.postMessage({ type: 'result', success: true, value: result, logs });
+
+            // SECURITY: Hard cap on output size to prevent OOM
+            const HARD_CAP_BYTES = 100 * 1024 * 1024; // 100MB
+            const serialized = safeStr(result);
+            if (serialized.length > HARD_CAP_BYTES) {
+              self.postMessage({
+                type: 'result',
+                success: false,
+                error: {
+                  name: 'OutputSizeError',
+                  message: 'Output exceeds 100MB limit. Use pagination or filtering.'
+                },
+                logs
+              });
+            } else {
+              self.postMessage({ type: 'result', success: true, value: result, logs });
+            }
           } catch (err) {
             // Truncate stack to 5 lines to prevent context bloat
             const stack = err.stack ? err.stack.split('\\n').slice(0, 5).join('\\n') : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papicandela/mcx-core",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "MCX Core - MCP Code Execution Framework",
   "author": "papicandela",
   "license": "MIT",

package/src/sandbox/bun-worker.ts

@@ -285,13 +285,62 @@ export class BunWorkerSandbox implements ISandbox {
         return arr.slice(0, n);
       };
 
+      /**
+       * Poll a function until condition is met or max iterations reached.
+       * @param fn - Async function to call. Return { done: true, value } to stop.
+       * @param opts - { interval: ms (default 1000), maxIterations: n (default 10) }
+       * @returns Array of all results, or last result if done:true was returned
+       */
+      globalThis.poll = async (fn, opts = {}) => {
+        const interval = opts.interval ?? 1000;
+        const maxIterations = opts.maxIterations ?? 10;
+        const results = [];
+
+        for (let i = 0; i < maxIterations; i++) {
+          const result = await fn(i);
+          results.push(result);
+
+          // Check for done signal
+          if (result && typeof result === 'object' && result.done) {
+            return result.value !== undefined ? result.value : results;
+          }
+
+          // Wait before next iteration (skip on last)
+          if (i < maxIterations - 1) {
+            await new Promise(r => setTimeout(r, interval));
+          }
+        }
+
+        return results;
+      };
+
+      /**
+       * Wait for a condition to become true.
+       * @param fn - Async function that returns truthy when done
+       * @param opts - { interval: ms (default 500), timeout: ms (default 10000) }
+       * @returns The truthy value returned by fn
+       */
+      globalThis.waitFor = async (fn, opts = {}) => {
+        const interval = opts.interval ?? 500;
+        const timeout = opts.timeout ?? 10000;
+        const start = Date.now();
+
+        while (Date.now() - start < timeout) {
+          const result = await fn();
+          if (result) return result;
+          await new Promise(r => setTimeout(r, interval));
+        }
+
+        throw new Error('waitFor timeout after ' + timeout + 'ms');
+      };
+
       // SECURITY: Reserved keys that must not be overwritten by user-provided variables/globals
       const RESERVED_KEYS = new Set([
         'onmessage', 'postMessage', 'close', 'terminate', 'self',
         'constructor', 'prototype', '__proto__',
         'pendingCalls', 'callId', 'logs', 'console', 'adapters',
         'fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource',
-        'pick', 'table', 'count', 'sum', 'first', 'safeStr'
+        'pick', 'table', 'count', 'sum', 'first', 'safeStr', 'poll', 'waitFor'
       ]);
 
       self.onmessage = async (event) => {
@@ -335,6 +384,12 @@ export class BunWorkerSandbox implements ISandbox {
             return matrix[b.length][a.length];
           };
 
+          // Convert camelCase to snake_case
+          const toSnakeCase = (str) => str
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            .toLowerCase();
+
           // Find similar method names
           const findSimilar = (name, methods, maxDist = 3) => {
             const normalized = name.toLowerCase().replace(/[-_]/g, '');
@@ -346,6 +401,22 @@ export class BunWorkerSandbox implements ISandbox {
               .map(x => x.method);
           };
 
+          // Find best auto-correctable match (distance ≤ 2 = safe to auto-correct)
+          const findAutoCorrect = (name, methods) => {
+            // Try exact snake_case conversion first
+            const snake = toSnakeCase(name);
+            if (methods.includes(snake)) return snake;
+
+            // Try normalized fuzzy match
+            const normalized = name.toLowerCase().replace(/[-_]/g, '');
+            const matches = methods
+              .map(m => ({ method: m, dist: levenshtein(normalized, m.toLowerCase().replace(/[-_]/g, '')) }))
+              .filter(x => x.dist <= 2) // Only auto-correct if very close
+              .sort((a, b) => a.dist - b.dist);
+
+            return matches.length > 0 ? matches[0].method : null;
+          };
+
           // Create adapter proxies with helpful error messages
           const adaptersObj = {};
           for (const [adapterName, methods] of Object.entries(adapterMethods)) {
@@ -366,16 +437,45 @@ export class BunWorkerSandbox implements ISandbox {
               };
             }
 
-            // Use Proxy to intercept undefined method calls
+            // Precompute auto-correct lookup (O(1) instead of O(n) per access)
+            const autoCorrectMap = new Map();
+            for (const m of methods) {
+              // Map snake_case variants: execute_sql -> execute_sql (identity)
+              autoCorrectMap.set(m, m);
+              // Map normalized: executesql -> execute_sql
+              autoCorrectMap.set(m.toLowerCase().replace(/[-_]/g, ''), m);
+            }
+
+            // Use Proxy to intercept undefined method calls with auto-correction
             const adapterProxy = new Proxy(methodsImpl, {
               get(target, prop) {
                 if (prop in target) return target[prop];
                 if (typeof prop === 'symbol') return undefined;
-                const similar = findSimilar(String(prop), methods);
+
+                const propStr = String(prop);
+
+                // Fast path: check precomputed map (O(1))
+                const snake = toSnakeCase(propStr);
+                if (autoCorrectMap.has(snake)) {
+                  return target[autoCorrectMap.get(snake)];
+                }
+                const normalized = propStr.toLowerCase().replace(/[-_]/g, '');
+                if (autoCorrectMap.has(normalized)) {
+                  return target[autoCorrectMap.get(normalized)];
+                }
+
+                // Slow path: fuzzy match for typos (only if fast path failed)
+                const corrected = findAutoCorrect(propStr, methods);
+                if (corrected && corrected in target) {
+                  return target[corrected];
+                }
+
+                // No auto-correct possible, throw with suggestions
+                const similar = findSimilar(propStr, methods);
                 const suggestion = similar.length > 0
                   ? '. Did you mean: ' + similar.join(', ') + '?'
                   : '. Available: ' + methods.slice(0, 5).join(', ') + (methods.length > 5 ? '...' : '');
-                throw new Error(adapterName + '.' + String(prop) + ' is not a function' + suggestion);
+                throw new Error(adapterName + '.' + propStr + ' is not a function' + suggestion);
               }
             });
 
@@ -412,7 +512,23 @@ export class BunWorkerSandbox implements ISandbox {
             const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
             const fn = new AsyncFunction(data.code);
             const result = await fn();
-            self.postMessage({ type: 'result', success: true, value: result, logs });
+
+            // SECURITY: Hard cap on output size to prevent OOM
+            const HARD_CAP_BYTES = 100 * 1024 * 1024; // 100MB
+            const serialized = safeStr(result);
+            if (serialized.length > HARD_CAP_BYTES) {
+              self.postMessage({
+                type: 'result',
+                success: false,
+                error: {
+                  name: 'OutputSizeError',
+                  message: 'Output exceeds 100MB limit. Use pagination or filtering.'
+                },
+                logs
+              });
+            } else {
+              self.postMessage({ type: 'result', success: true, value: result, logs });
+            }
           } catch (err) {
             // Truncate stack to 5 lines to prevent context bloat
             const stack = err.stack ? err.stack.split('\\n').slice(0, 5).join('\\n') : undefined;