keystone-cli 0.3.2 → 0.4.0

package/src/utils/sandbox.test.ts

@@ -3,22 +3,30 @@ import { SafeSandbox } from './sandbox';
 
 describe('SafeSandbox', () => {
   it('should execute basic arithmetic', async () => {
-    const result = await SafeSandbox.execute('1 + 2');
+    const result = await SafeSandbox.execute('1 + 2', {}, { allowInsecureFallback: true });
     expect(result).toBe(3);
   });
 
   it('should have access to context variables', async () => {
-    const result = await SafeSandbox.execute('a + b', { a: 10, b: 20 });
+    const result = await SafeSandbox.execute(
+      'a + b',
+      { a: 10, b: 20 },
+      { allowInsecureFallback: true }
+    );
     expect(result).toBe(30);
   });
 
   it('should not have access to Node.js globals', async () => {
-    const result = await SafeSandbox.execute('typeof process');
+    const result = await SafeSandbox.execute('typeof process', {}, { allowInsecureFallback: true });
     expect(result).toBe('undefined');
   });
 
   it('should handle object results', async () => {
-    const result = await SafeSandbox.execute('({ x: 1, y: 2 })');
+    const result = await SafeSandbox.execute(
+      '({ x: 1, y: 2 })',
+      {},
+      { allowInsecureFallback: true }
+    );
     expect(result).toEqual({ x: 1, y: 2 });
   });
 

package/src/utils/sandbox.ts

@@ -1,61 +1,81 @@
 import * as vm from 'node:vm';
 
 export interface SandboxOptions {
-    timeout?: number;
-    memoryLimit?: number;
+  timeout?: number;
+  memoryLimit?: number;
+  allowInsecureFallback?: boolean;
 }
 
 export class SafeSandbox {
-    /**
-     * Execute a script in a secure sandbox
-     */
-    static async execute(
-        code: string,
-        context: Record<string, unknown> = {},
-        options: SandboxOptions = {}
-    ): Promise<unknown> {
+  /**
+   * Execute a script in a secure sandbox
+   */
+  static async execute(
+    code: string,
+    context: Record<string, unknown> = {},
+    options: SandboxOptions = {}
+  ): Promise<unknown> {
+    try {
+      // Try to use isolated-vm if available (dynamic import)
+      // Note: This will likely fail on Bun as it expects V8 host symbols
+      const ivm = await import('isolated-vm').then((m) => m.default || m).catch(() => null);
+
+      if (ivm && typeof ivm.Isolate === 'function') {
+        const isolate = new ivm.Isolate({ memoryLimit: options.memoryLimit || 128 });
         try {
-            // Try to use isolated-vm if available (dynamic import)
-            // Note: This will likely fail on Bun as it expects V8 host symbols
-            const ivm = await import('isolated-vm').then((m) => m.default || m).catch(() => null);
-
-            if (ivm && typeof ivm.Isolate === 'function') {
-                const isolate = new ivm.Isolate({ memoryLimit: options.memoryLimit || 128 });
-                try {
-                    const contextInstance = await isolate.createContext();
-                    const jail = contextInstance.global;
-
-                    // Set up global context
-                    await jail.set('global', jail.derefInto());
-
-                    // Inject context variables
-                    for (const [key, value] of Object.entries(context)) {
-                        // Only copy non-undefined values
-                        if (value !== undefined) {
-                            await jail.set(key, new ivm.ExternalCopy(value).copyInto());
-                        }
-                    }
-
-                    const script = await isolate.compileScript(code);
-                    const result = await script.run(contextInstance, { timeout: options.timeout || 5000 });
-
-                    if (result && typeof result === 'object' && result instanceof ivm.Reference) {
-                        return await result.copy();
-                    }
-                    return result;
-                } finally {
-                    isolate.dispose();
-                }
+          const contextInstance = await isolate.createContext();
+          const jail = contextInstance.global;
+
+          // Set up global context
+          await jail.set('global', jail.derefInto());
+
+          // Inject context variables
+          for (const [key, value] of Object.entries(context)) {
+            // Only copy non-undefined values
+            if (value !== undefined) {
+              await jail.set(key, new ivm.ExternalCopy(value).copyInto());
             }
-        } catch (e) {
-            // Fallback to node:vm if isolated-vm fails to load or run
+          }
+
+          const script = await isolate.compileScript(code);
+          const result = await script.run(contextInstance, { timeout: options.timeout || 5000 });
+
+          if (result && typeof result === 'object' && result instanceof ivm.Reference) {
+            return await result.copy();
+          }
+          return result;
+        } finally {
+          isolate.dispose();
         }
+      }
+    } catch (e) {
+      // If isolated-vm failed during execution (not just loading), log it if we're debugging
+    }
+
+    // Fallback implementation using node:vm (built-in)
+    // ONLY allowed if explicitly opted in via options
+    if (!options.allowInsecureFallback) {
+      throw new Error(
+        'Execution in secure sandbox failed (isolated-vm not available) and insecure fallback is disabled.\n' +
+          'To allow insecure execution, set allowInsecureFallback: true in sandbox options.\n' +
+          'Note: Insecure execution is NOT recommended for untrusted code.'
+      );
+    }
 
-        // Fallback implementation using node:vm (built-in)
-        const sandbox = { ...context };
-        return vm.runInNewContext(code, sandbox, {
-            timeout: options.timeout || 5000,
-            displayErrors: true,
-        });
+    if (!SafeSandbox.warned) {
+      const isBun = typeof Bun !== 'undefined';
+      console.warn(
+        `\n⚠️  SECURITY WARNING: Using ${isBun ? 'Bun' : 'Node.js'} built-in VM for script execution.\n   This sandbox is NOT secure against malicious code.\n   Only run workflows from trusted sources.\n`
+      );
+      SafeSandbox.warned = true;
     }
+
+    const sandbox = { ...context };
+    return vm.runInNewContext(code, sandbox, {
+      timeout: options.timeout || 5000,
+      displayErrors: true,
+    });
+  }
+
+  private static warned = false;
 }