ai-evaluate 2.1.7 → 2.2.0

package/src/evaluate.js

@@ -1,187 +0,0 @@
-/**
- * Evaluate code in a sandboxed environment
- *
- * Uses Cloudflare worker_loaders in production,
- * Miniflare in development/Node.
- *
- * Requires ai-tests service binding (TEST) for assertions and test running.
- */
-import { generateWorkerCode, generateDevWorkerCode } from './worker-template.js';
-/**
- * Check if code contains JSX syntax that needs transformation
- */
-function containsJSX(code) {
-    if (!code)
-        return false;
-    // Look for JSX patterns
-    const jsxPattern = /<[A-Z][a-zA-Z0-9]*[\s/>]|<[a-z][a-z0-9-]*[\s/>]|<>|<\/>/;
-    const jsxReturnPattern = /return\s*\(\s*<|return\s+<[A-Za-z]/;
-    return jsxPattern.test(code) || jsxReturnPattern.test(code);
-}
-/**
- * Transform JSX in code using esbuild
- */
-async function transformJSX(code) {
-    if (!code || !containsJSX(code))
-        return code;
-    try {
-        const { transform } = await import('esbuild');
-        const result = await transform(code, {
-            loader: 'tsx',
-            jsxFactory: 'h',
-            jsxFragment: 'Fragment',
-            target: 'esnext',
-            format: 'esm',
-        });
-        return result.code;
-    }
-    catch (error) {
-        // If transform fails, return original code and let sandbox handle the error
-        console.error('JSX transform failed:', error);
-        return code;
-    }
-}
-/**
- * Evaluate code in a sandboxed worker
- *
- * @example
- * ```ts
- * import { evaluate } from 'ai-sandbox'
- *
- * // Run a simple script
- * const result = await evaluate({
- *   script: 'return 1 + 1'
- * })
- * // { success: true, value: 2, logs: [], duration: ... }
- *
- * // With a module and tests
- * const result = await evaluate({
- *   module: `
- *     exports.add = (a, b) => a + b;
- *     exports.multiply = (a, b) => a * b;
- *   `,
- *   tests: `
- *     describe('math', () => {
- *       it('adds numbers', () => {
- *         expect(add(2, 3)).toBe(5);
- *       });
- *       it('multiplies numbers', () => {
- *         expect(multiply(2, 3)).toBe(6);
- *       });
- *     });
- *   `,
- *   script: 'return add(10, 20)'
- * })
- * ```
- */
-export async function evaluate(options, env) {
-    const start = Date.now();
-    try {
-        // Transform JSX in module, tests, and script before evaluation
-        const transformedOptions = {
-            ...options,
-            module: options.module ? await transformJSX(options.module) : options.module,
-            tests: options.tests ? await transformJSX(options.tests) : options.tests,
-            script: options.script ? await transformJSX(options.script) : options.script,
-        };
-        // Use worker_loaders if available (Cloudflare Workers)
-        if (env?.LOADER && env?.TEST) {
-            return await evaluateWithWorkerLoader(transformedOptions, env.LOADER, env.TEST, start);
-        }
-        // Fall back to Miniflare with local TestService (Node.js)
-        return await evaluateWithMiniflare(transformedOptions, start);
-    }
-    catch (error) {
-        return {
-            success: false,
-            logs: [],
-            error: error instanceof Error ? error.message : String(error),
-            duration: Date.now() - start
-        };
-    }
-}
-/**
- * Evaluate using Cloudflare worker_loaders binding
- */
-async function evaluateWithWorkerLoader(options, loader, testService, start) {
-    const workerCode = generateWorkerCode({
-        module: options.module,
-        tests: options.tests,
-        script: options.script,
-        sdk: options.sdk,
-        imports: options.imports
-    });
-    const id = `sandbox-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const worker = loader.get(id, async () => ({
-        mainModule: 'worker.js',
-        modules: {
-            'worker.js': workerCode
-        },
-        compatibilityDate: '2024-01-01',
-        // Block network access only if fetch: null
-        globalOutbound: options.fetch === null ? null : undefined,
-        bindings: {
-            TEST: testService
-        }
-    }));
-    const response = await worker.fetch(new Request('http://sandbox/execute'));
-    const result = await response.json();
-    return {
-        ...result,
-        duration: Date.now() - start
-    };
-}
-/**
- * Evaluate using Miniflare (for Node.js/development)
- *
- * For local dev, we use generateDevWorkerCode which bundles the test
- * framework directly. In production, the sandbox worker uses RPC to
- * a deployed ai-tests worker.
- */
-async function evaluateWithMiniflare(options, start) {
-    // Dynamic import to avoid bundling in production
-    const { Miniflare } = await import('miniflare');
-    const workerCode = generateDevWorkerCode({
-        module: options.module,
-        tests: options.tests,
-        script: options.script,
-        sdk: options.sdk,
-        imports: options.imports
-    });
-    const mf = new Miniflare({
-        modules: true,
-        script: workerCode,
-        compatibilityDate: '2024-01-01'
-    });
-    try {
-        const response = await mf.dispatchFetch('http://sandbox/execute');
-        const result = await response.json();
-        return {
-            ...result,
-            duration: Date.now() - start
-        };
-    }
-    finally {
-        await mf.dispose();
-    }
-}
-/**
- * Create an evaluate function bound to a specific environment
- *
- * Useful for Cloudflare Workers where env is passed to fetch handler.
- *
- * @example
- * ```ts
- * // In a Cloudflare Worker
- * export default {
- *   async fetch(request, env) {
- *     const sandbox = createEvaluator(env)
- *     const result = await sandbox({ script: '1 + 1' })
- *     return Response.json(result)
- *   }
- * }
- * ```
- */
-export function createEvaluator(env) {
-    return (options) => evaluate(options, env);
-}

package/src/evaluate.ts

@@ -1,325 +0,0 @@
-/**
- * Evaluate code in a sandboxed environment
- *
- * Uses Cloudflare worker_loaders for secure code execution.
- * For Node.js/local development, import from 'ai-evaluate/node' instead.
- *
- * Requires:
- * - LOADER binding (worker_loaders)
- * - TEST binding (ai-tests service) - optional, only needed for test assertions
- */
-
-import type { EvaluateOptions, EvaluateResult, WorkerLoader, SandboxEnv } from './types.js'
-import { generateWorkerCode } from './worker-template.js'
-import { CAPNWEB_SOURCE } from './capnweb-bundle.js'
-
-/**
- * Compatibility date for dynamic workers (2026)
- */
-const COMPATIBILITY_DATE = '2026-01-01'
-
-/**
- * Generate a minimal worker for simple script execution
- * This doesn't require capnweb or TEST binding
- */
-function generateSimpleWorkerCode(options: {
-  module?: string
-  script?: string
-  imports?: string[]
-}): string {
-  const { module = '', script = '', imports = [] } = options
-
-  // Build import statements for pre-fetched external modules
-  // Modules are fetched by the host worker and included in the worker definition
-  const importStatements = imports
-    .map((url, i) => `import * as __import${i}__ from './__external_${i}__.js';`)
-    .join('\n')
-
-  // Make imports available as globals
-  const importGlobals = imports
-    .map((url, i) => {
-      // Extract package name from URL for variable naming
-      const match = url.match(/esm\.sh\/([^@/]+)/)
-      const pkgName = match ? match[1].replace(/-/g, '_') : `pkg${i}`
-      const varName = pkgName === 'lodash' ? '_' : pkgName
-      return `globalThis.${varName} = __import${i}__.default || __import${i}__;
-globalThis.pkg = __import${i}__.default || __import${i}__;`
-    })
-    .join('\n')
-
-  // Wrap script to capture return value (code is embedded at build time, no eval)
-  const wrappedScript = script
-    ? `const __executeScript__ = async () => { ${script} }; const __result__ = await __executeScript__();`
-    : 'const __result__ = undefined;'
-
-  return `
-// Simple Sandbox Worker
-${importStatements}
-
-const logs = [];
-
-// Capture console output
-const originalConsole = { ...console };
-const captureConsole = (level) => (...args) => {
-  logs.push({
-    level,
-    message: args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '),
-    timestamp: Date.now()
-  });
-  originalConsole[level](...args);
-};
-console.log = captureConsole('log');
-console.warn = captureConsole('warn');
-console.error = captureConsole('error');
-console.info = captureConsole('info');
-
-// Make imports available globally
-${importGlobals}
-
-// User module code (if any)
-${module}
-
-export default {
-  async fetch(request, env) {
-    try {
-      // Execute the script (embedded at generation time - no new Function())
-      ${wrappedScript}
-
-      return Response.json({
-        success: true,
-        value: __result__,
-        logs,
-        duration: 0
-      });
-    } catch (error) {
-      return Response.json({
-        success: false,
-        error: error.message || String(error),
-        logs,
-        duration: 0
-      });
-    }
-  }
-};
-`
-}
-
-/**
- * Evaluate code in a sandboxed worker
- *
- * @example
- * ```ts
- * import { evaluate } from 'ai-evaluate'
- *
- * // Run a simple script
- * const result = await evaluate({
- *   script: 'return 1 + 1'
- * }, env)
- * // { success: true, value: 2, logs: [], duration: ... }
- * ```
- */
-export async function evaluate(
-  options: EvaluateOptions,
-  env?: SandboxEnv
-): Promise<EvaluateResult> {
-  const start = Date.now()
-
-  try {
-    // Require worker_loaders binding (check lowercase first, then legacy uppercase)
-    const loader = env?.loader || env?.LOADER
-    if (!loader) {
-      return {
-        success: false,
-        logs: [],
-        error:
-          'Sandbox requires worker_loaders binding. Add to wrangler.toml: [[worker_loaders]] binding = "LOADER". For Node.js, use: import { evaluate } from "ai-evaluate/node"',
-        duration: Date.now() - start,
-      }
-    }
-
-    // Use simple worker for basic script execution (no tests, no SDK)
-    const useSimpleWorker = !options.tests && !options.sdk
-
-    if (useSimpleWorker) {
-      return await evaluateSimple(options, loader, start)
-    }
-
-    // Use full worker template for tests and SDK features
-    return await evaluateWithWorkerLoader(options, loader, env?.TEST, start)
-  } catch (error) {
-    return {
-      success: false,
-      logs: [],
-      error: error instanceof Error ? error.message : String(error),
-      duration: Date.now() - start,
-    }
-  }
-}
-
-/**
- * Pre-fetch external modules from URLs (e.g., esm.sh)
- * Returns a map of module name to source code
- *
- * Handles esm.sh's redirect-style modules by following the internal import paths.
- */
-async function prefetchModules(imports: string[]): Promise<Record<string, string>> {
-  const modules: Record<string, string> = {}
-
-  await Promise.all(
-    imports.map(async (url, i) => {
-      try {
-        // For esm.sh URLs, try to get the bundled version directly
-        let fetchUrl = url
-        if (url.includes('esm.sh/') && !url.includes('.mjs') && !url.includes('.js')) {
-          // Parse the esm.sh URL to construct the bundle path
-          // e.g., https://esm.sh/lodash@4.17.21 -> https://esm.sh/lodash@4.17.21/es2022/lodash.bundle.mjs
-          const urlObj = new URL(url)
-          const pathParts = urlObj.pathname.slice(1).split('/')
-          const pkgSpec = pathParts[0] // e.g., "lodash@4.17.21"
-          const pkgName = pkgSpec.split('@')[0]
-          fetchUrl = `${urlObj.origin}/${pkgSpec}/es2022/${pkgName}.bundle.mjs`
-        }
-
-        const response = await fetch(fetchUrl, { redirect: 'follow' })
-        if (!response.ok) {
-          // Fallback to original URL if bundle URL fails
-          const fallbackResponse = await fetch(url, { redirect: 'follow' })
-          if (!fallbackResponse.ok) {
-            throw new Error(`Failed to fetch ${url}: ${fallbackResponse.status}`)
-          }
-          const source = await fallbackResponse.text()
-          modules[`__external_${i}__.js`] = source
-          return
-        }
-        const source = await response.text()
-        // Use a simple module name that can be imported
-        const moduleName = `__external_${i}__.js`
-        modules[moduleName] = source
-      } catch (error) {
-        throw new Error(
-          `Failed to fetch import ${url}: ${error instanceof Error ? error.message : String(error)}`
-        )
-      }
-    })
-  )
-
-  return modules
-}
-
-/**
- * Simple evaluation without capnweb/TEST dependencies
- */
-async function evaluateSimple(
-  options: EvaluateOptions,
-  loader: WorkerLoader,
-  start: number
-): Promise<EvaluateResult> {
-  // Pre-fetch any external modules
-  let externalModules: Record<string, string> = {}
-  if (options.imports && options.imports.length > 0) {
-    try {
-      externalModules = await prefetchModules(options.imports)
-    } catch (error) {
-      return {
-        success: false,
-        logs: [],
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - start,
-      }
-    }
-  }
-
-  const workerCode = generateSimpleWorkerCode({
-    module: options.module,
-    script: options.script,
-    imports: options.imports,
-  })
-
-  const id = `sandbox-${Date.now()}-${Math.random().toString(36).slice(2)}`
-
-  const worker = loader.get(id, async () => ({
-    mainModule: 'worker.js',
-    modules: {
-      'worker.js': workerCode,
-      ...externalModules,
-    },
-    compatibilityDate: COMPATIBILITY_DATE,
-    // Block network access only if fetch: null
-    globalOutbound: options.fetch === null ? null : undefined,
-  }))
-
-  // Get the entrypoint and call fetch
-  const entrypoint = worker.getEntrypoint()
-  const response = await entrypoint.fetch(new Request('http://sandbox/execute'))
-  const result = (await response.json()) as EvaluateResult
-
-  return {
-    ...result,
-    duration: Date.now() - start,
-  }
-}
-
-/**
- * Evaluate using full worker template with capnweb and TEST binding
- */
-async function evaluateWithWorkerLoader(
-  options: EvaluateOptions,
-  loader: WorkerLoader,
-  testService: unknown,
-  start: number
-): Promise<EvaluateResult> {
-  const workerCode = generateWorkerCode({
-    module: options.module,
-    tests: options.tests,
-    script: options.script,
-    sdk: options.sdk,
-    imports: options.imports,
-  })
-  const id = `sandbox-${Date.now()}-${Math.random().toString(36).slice(2)}`
-
-  const worker = loader.get(id, async () => ({
-    mainModule: 'worker.js',
-    modules: {
-      'worker.js': workerCode,
-      // Include capnweb as a module so the worker can import it
-      'capnweb.js': CAPNWEB_SOURCE,
-    },
-    compatibilityDate: COMPATIBILITY_DATE,
-    // Block network access only if fetch: null
-    globalOutbound: options.fetch === null ? null : undefined,
-    bindings: {
-      TEST: testService,
-    },
-  }))
-
-  // Get the entrypoint and call fetch (required by Cloudflare worker_loaders API)
-  const entrypoint = worker.getEntrypoint()
-  const response = await entrypoint.fetch(new Request('http://sandbox/execute'))
-  const result = (await response.json()) as EvaluateResult
-
-  return {
-    ...result,
-    duration: Date.now() - start,
-  }
-}
-
-/**
- * Create an evaluate function bound to a specific environment
- *
- * Useful for Cloudflare Workers where env is passed to fetch handler.
- *
- * @example
- * ```ts
- * // In a Cloudflare Worker
- * export default {
- *   async fetch(request, env) {
- *     const sandbox = createEvaluator(env)
- *     const result = await sandbox({ script: '1 + 1' })
- *     return Response.json(result)
- *   }
- * }
- * ```
- */
-export function createEvaluator(env: SandboxEnv) {
-  return (options: EvaluateOptions) => evaluate(options, env)
-}

package/src/index.js

@@ -1,10 +0,0 @@
-/**
- * ai-sandbox - Secure code execution in sandboxed environments
- *
- * Provides evaluate() for running untrusted code safely using:
- * - Cloudflare worker_loaders in production
- * - Miniflare in development/Node.js
- *
- * @packageDocumentation
- */
-export { evaluate, createEvaluator } from './evaluate.js';

package/src/index.ts

@@ -1,21 +0,0 @@
-/**
- * ai-sandbox - Secure code execution in sandboxed environments
- *
- * Provides evaluate() for running untrusted code safely using:
- * - Cloudflare worker_loaders in production
- * - Miniflare in development/Node.js
- *
- * @packageDocumentation
- */
-
-export { evaluate, createEvaluator } from './evaluate.js'
-
-export type {
-  EvaluateOptions,
-  EvaluateResult,
-  LogEntry,
-  TestResults,
-  TestResult,
-  SandboxEnv,
-  SDKConfig
-} from './types.js'

package/src/node.d.ts

@@ -1,17 +0,0 @@
-/**
- * Evaluate code in a sandboxed environment (Node.js version)
- *
- * Uses Cloudflare worker_loaders when available, falls back to Miniflare for local dev.
- * For Workers-only builds, import from 'ai-evaluate' instead.
- */
-import type { EvaluateOptions, EvaluateResult, SandboxEnv } from './types.js';
-/**
- * Evaluate code in a sandboxed worker (Node.js version with Miniflare fallback)
- */
-export declare function evaluate(options: EvaluateOptions, env?: SandboxEnv): Promise<EvaluateResult>;
-/**
- * Create an evaluate function bound to a specific environment
- */
-export declare function createEvaluator(env?: SandboxEnv): (options: EvaluateOptions) => Promise<EvaluateResult>;
-export type { EvaluateOptions, EvaluateResult, SandboxEnv } from './types.js';
-//# sourceMappingURL=node.d.ts.map

package/src/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,YAAY,CAAA;AAmC3F;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,eAAe,EACxB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,cAAc,CAAC,CA+BzB;AA6GD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,CAAC,EAAE,UAAU,IACtC,SAAS,eAAe,6BACjC;AAGD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA"}