@papicandela/mcx-core 0.2.6 → 0.2.8

package/dist/index.js

@@ -6488,13 +6488,165 @@ 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');
+      };
+
+      /**
+       * Get lines around a specific line number (1-indexed).
+       * @param file - File object with .lines array
+       * @param line - Line number (1-indexed)
+       * @param ctx - Context lines before/after (default 10)
+       */
+      globalThis.around = (file, line, ctx = 10) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        if (line < 1 || line > lines.length) return [];
+        const idx = line - 1;
+        return lines.slice(Math.max(0, idx - ctx), Math.min(lines.length, idx + ctx + 1));
+      };
+
+      /**
+       * Extract code block containing a line (detects by indentation).
+       * @param file - File object with .lines array
+       * @param line - Line number (1-indexed)
+       */
+      globalThis.block = (file, line) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const idx = line - 1;
+        if (idx < 0 || idx >= lines.length) return [];
+
+        const targetIndent = lines[idx].search(/\\S/);
+        if (targetIndent < 0) return [lines[idx]];
+
+        // Find block start
+        let start = idx;
+        for (let i = idx - 1; i >= 0; i--) {
+          const lineIndent = lines[i].search(/\\S/);
+          if (lineIndent >= 0 && lineIndent < targetIndent) { start = i; break; }
+          if (lineIndent === 0 && lines[i].trim()) { start = i; break; }
+        }
+
+        // Find block end
+        const startIndent = lines[start].search(/\\S/);
+        let end = idx;
+        for (let i = idx + 1; i < lines.length; i++) {
+          const lineIndent = lines[i].search(/\\S/);
+          if (lineIndent >= 0 && lineIndent <= startIndent && lines[i].trim()) { end = i - 1; break; }
+          end = i;
+        }
+
+        return lines.slice(start, end + 1);
+      };
+
+      /**
+       * Grep with context lines.
+       * @param file - File object with .lines array
+       * @param pattern - String or regex pattern
+       * @param ctx - Context lines (default 3)
+       */
+      globalThis.grep = (file, pattern, ctx = 3) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const regex = typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern;
+        const results = [];
+
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push({
+              line: i + 1,
+              match: lines[i],
+              context: lines.slice(Math.max(0, i - ctx), i + ctx + 1)
+            });
+          }
+        }
+        return results;
+      };
+
+      /**
+       * Extract outline (function/class signatures).
+       * @param file - File object with .lines array
+       */
+      globalThis.outline = (file) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const signatures = [];
+        const patterns = [
+          /^(export\\s+)?(async\\s+)?function\\s+\\w+/,
+          /^(export\\s+)?(const|let|var)\\s+\\w+\\s*=\\s*(async\\s+)?\\(/,
+          /^(export\\s+)?(const|let|var)\\s+\\w+\\s*=\\s*(async\\s+)?function/,
+          /^(export\\s+)?class\\s+\\w+/,
+          /^(export\\s+)?interface\\s+\\w+/,
+          /^(export\\s+)?type\\s+\\w+/,
+          /^\\s+(async\\s+)?\\w+\\s*\\([^)]*\\)\\s*[:{]/,
+        ];
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          for (const pat of patterns) {
+            if (pat.test(line)) {
+              signatures.push((i + 1) + ': ' + line.trim().slice(0, 80));
+              break;
+            }
+          }
+        }
+        return signatures;
+      };
+
       // 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',
+        'around', 'block', 'grep', 'outline'
       ]);
 
       self.onmessage = async (event) => {
@@ -6538,6 +6690,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 +6707,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 +6743,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 +6818,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.8",
   "description": "MCX Core - MCP Code Execution Framework",
   "author": "papicandela",
   "license": "MIT",

package/src/sandbox/bun-worker.ts

@@ -285,13 +285,165 @@ 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');
+      };
+
+      /**
+       * Get lines around a specific line number (1-indexed).
+       * @param file - File object with .lines array
+       * @param line - Line number (1-indexed)
+       * @param ctx - Context lines before/after (default 10)
+       */
+      globalThis.around = (file, line, ctx = 10) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        if (line < 1 || line > lines.length) return [];
+        const idx = line - 1;
+        return lines.slice(Math.max(0, idx - ctx), Math.min(lines.length, idx + ctx + 1));
+      };
+
+      /**
+       * Extract code block containing a line (detects by indentation).
+       * @param file - File object with .lines array
+       * @param line - Line number (1-indexed)
+       */
+      globalThis.block = (file, line) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const idx = line - 1;
+        if (idx < 0 || idx >= lines.length) return [];
+
+        const targetIndent = lines[idx].search(/\\S/);
+        if (targetIndent < 0) return [lines[idx]];
+
+        // Find block start
+        let start = idx;
+        for (let i = idx - 1; i >= 0; i--) {
+          const lineIndent = lines[i].search(/\\S/);
+          if (lineIndent >= 0 && lineIndent < targetIndent) { start = i; break; }
+          if (lineIndent === 0 && lines[i].trim()) { start = i; break; }
+        }
+
+        // Find block end
+        const startIndent = lines[start].search(/\\S/);
+        let end = idx;
+        for (let i = idx + 1; i < lines.length; i++) {
+          const lineIndent = lines[i].search(/\\S/);
+          if (lineIndent >= 0 && lineIndent <= startIndent && lines[i].trim()) { end = i - 1; break; }
+          end = i;
+        }
+
+        return lines.slice(start, end + 1);
+      };
+
+      /**
+       * Grep with context lines.
+       * @param file - File object with .lines array
+       * @param pattern - String or regex pattern
+       * @param ctx - Context lines (default 3)
+       */
+      globalThis.grep = (file, pattern, ctx = 3) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const regex = typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern;
+        const results = [];
+
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push({
+              line: i + 1,
+              match: lines[i],
+              context: lines.slice(Math.max(0, i - ctx), i + ctx + 1)
+            });
+          }
+        }
+        return results;
+      };
+
+      /**
+       * Extract outline (function/class signatures).
+       * @param file - File object with .lines array
+       */
+      globalThis.outline = (file) => {
+        const lines = file?.lines;
+        if (!Array.isArray(lines)) return [];
+        const signatures = [];
+        const patterns = [
+          /^(export\\s+)?(async\\s+)?function\\s+\\w+/,
+          /^(export\\s+)?(const|let|var)\\s+\\w+\\s*=\\s*(async\\s+)?\\(/,
+          /^(export\\s+)?(const|let|var)\\s+\\w+\\s*=\\s*(async\\s+)?function/,
+          /^(export\\s+)?class\\s+\\w+/,
+          /^(export\\s+)?interface\\s+\\w+/,
+          /^(export\\s+)?type\\s+\\w+/,
+          /^\\s+(async\\s+)?\\w+\\s*\\([^)]*\\)\\s*[:{]/,
+        ];
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          for (const pat of patterns) {
+            if (pat.test(line)) {
+              signatures.push((i + 1) + ': ' + line.trim().slice(0, 80));
+              break;
+            }
+          }
+        }
+        return signatures;
+      };
+
       // 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',
+        'around', 'block', 'grep', 'outline'
       ]);
 
       self.onmessage = async (event) => {
@@ -335,6 +487,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 +504,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 +540,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 +615,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;