ai-evaluate 2.1.8 → 2.2.0

package/src/type-guards.ts

@@ -1,323 +0,0 @@
-/**
- * Runtime type guards for JSON response validation
- */
-
-import type { EvaluateResult, LogEntry, TestResults, TestResult } from './types.js'
-
-/**
- * Check if a value is a valid LogEntry
- */
-function isLogEntry(value: unknown): value is LogEntry {
-  if (typeof value !== 'object' || value === null) {
-    return false
-  }
-
-  const obj = value as Record<string, unknown>
-
-  // Check level is one of the allowed values
-  const validLevels = ['log', 'warn', 'error', 'info', 'debug']
-  if (typeof obj.level !== 'string' || !validLevels.includes(obj.level)) {
-    return false
-  }
-
-  // Check message is a string
-  if (typeof obj.message !== 'string') {
-    return false
-  }
-
-  // Check timestamp is a number
-  if (typeof obj.timestamp !== 'number') {
-    return false
-  }
-
-  return true
-}
-
-/**
- * Check if a value is a valid TestResult
- */
-function isTestResult(value: unknown): value is TestResult {
-  if (typeof value !== 'object' || value === null) {
-    return false
-  }
-
-  const obj = value as Record<string, unknown>
-
-  // Check required fields
-  if (typeof obj.name !== 'string') {
-    return false
-  }
-
-  if (typeof obj.passed !== 'boolean') {
-    return false
-  }
-
-  if (typeof obj.duration !== 'number') {
-    return false
-  }
-
-  // Check optional error field
-  if (obj.error !== undefined && typeof obj.error !== 'string') {
-    return false
-  }
-
-  return true
-}
-
-/**
- * Check if a value is a valid TestResults
- */
-function isTestResults(value: unknown): value is TestResults {
-  if (typeof value !== 'object' || value === null) {
-    return false
-  }
-
-  const obj = value as Record<string, unknown>
-
-  // Check required numeric fields
-  if (typeof obj.total !== 'number') {
-    return false
-  }
-
-  if (typeof obj.passed !== 'number') {
-    return false
-  }
-
-  if (typeof obj.failed !== 'number') {
-    return false
-  }
-
-  if (typeof obj.skipped !== 'number') {
-    return false
-  }
-
-  if (typeof obj.duration !== 'number') {
-    return false
-  }
-
-  // Check tests array
-  if (!Array.isArray(obj.tests)) {
-    return false
-  }
-
-  for (const test of obj.tests) {
-    if (!isTestResult(test)) {
-      return false
-    }
-  }
-
-  return true
-}
-
-/**
- * Type guard to check if a value is a valid EvaluateResult
- *
- * Validates all required fields: success, duration, logs
- *
- * @param value - The value to check
- * @returns True if the value is a valid EvaluateResult
- */
-export function isEvaluateResult(value: unknown): value is EvaluateResult {
-  if (typeof value !== 'object' || value === null) {
-    return false
-  }
-
-  const obj = value as Record<string, unknown>
-
-  // Check required fields
-  if (typeof obj.success !== 'boolean') {
-    return false
-  }
-
-  if (typeof obj.duration !== 'number') {
-    return false
-  }
-
-  // Check logs is an array of valid LogEntry objects
-  if (!Array.isArray(obj.logs)) {
-    return false
-  }
-
-  for (const log of obj.logs) {
-    if (!isLogEntry(log)) {
-      return false
-    }
-  }
-
-  // Check optional fields have correct types if present
-  if (obj.error !== undefined && typeof obj.error !== 'string') {
-    return false
-  }
-
-  if (obj.testResults !== undefined && !isTestResults(obj.testResults)) {
-    return false
-  }
-
-  // value can be any type, so no validation needed for it
-
-  return true
-}
-
-/**
- * Assertion function that throws a descriptive error if the value is not a valid EvaluateResult
- *
- * @param value - The value to validate
- * @throws Error with descriptive message if validation fails
- */
-export function assertEvaluateResult(value: unknown): asserts value is EvaluateResult {
-  if (typeof value !== 'object' || value === null) {
-    throw new Error(
-      `Invalid EvaluateResult: expected object, got ${value === null ? 'null' : typeof value}`
-    )
-  }
-
-  const obj = value as Record<string, unknown>
-
-  // Validate required field: success
-  if (typeof obj.success !== 'boolean') {
-    throw new Error(
-      `Invalid EvaluateResult: 'success' must be a boolean, got ${typeof obj.success}`
-    )
-  }
-
-  // Validate required field: duration
-  if (typeof obj.duration !== 'number') {
-    throw new Error(
-      `Invalid EvaluateResult: 'duration' must be a number, got ${typeof obj.duration}`
-    )
-  }
-
-  // Validate required field: logs
-  if (!Array.isArray(obj.logs)) {
-    throw new Error(`Invalid EvaluateResult: 'logs' must be an array, got ${typeof obj.logs}`)
-  }
-
-  // Validate each log entry
-  for (let i = 0; i < obj.logs.length; i++) {
-    const log = obj.logs[i]
-    if (typeof log !== 'object' || log === null) {
-      throw new Error(
-        `Invalid EvaluateResult: logs[${i}] must be an object, got ${
-          log === null ? 'null' : typeof log
-        }`
-      )
-    }
-
-    const logObj = log as Record<string, unknown>
-    const validLevels = ['log', 'warn', 'error', 'info', 'debug']
-
-    if (typeof logObj.level !== 'string' || !validLevels.includes(logObj.level)) {
-      throw new Error(
-        `Invalid EvaluateResult: logs[${i}].level must be one of ${validLevels.join(', ')}, got '${
-          logObj.level
-        }'`
-      )
-    }
-
-    if (typeof logObj.message !== 'string') {
-      throw new Error(
-        `Invalid EvaluateResult: logs[${i}].message must be a string, got ${typeof logObj.message}`
-      )
-    }
-
-    if (typeof logObj.timestamp !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: logs[${i}].timestamp must be a number, got ${typeof logObj.timestamp}`
-      )
-    }
-  }
-
-  // Validate optional field: error
-  if (obj.error !== undefined && typeof obj.error !== 'string') {
-    throw new Error(
-      `Invalid EvaluateResult: 'error' must be a string if present, got ${typeof obj.error}`
-    )
-  }
-
-  // Validate optional field: testResults
-  if (obj.testResults !== undefined) {
-    if (typeof obj.testResults !== 'object' || obj.testResults === null) {
-      throw new Error(
-        `Invalid EvaluateResult: 'testResults' must be an object if present, got ${
-          obj.testResults === null ? 'null' : typeof obj.testResults
-        }`
-      )
-    }
-
-    const testResults = obj.testResults as Record<string, unknown>
-
-    if (typeof testResults.total !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.total must be a number, got ${typeof testResults.total}`
-      )
-    }
-
-    if (typeof testResults.passed !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.passed must be a number, got ${typeof testResults.passed}`
-      )
-    }
-
-    if (typeof testResults.failed !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.failed must be a number, got ${typeof testResults.failed}`
-      )
-    }
-
-    if (typeof testResults.skipped !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.skipped must be a number, got ${typeof testResults.skipped}`
-      )
-    }
-
-    if (typeof testResults.duration !== 'number') {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.duration must be a number, got ${typeof testResults.duration}`
-      )
-    }
-
-    if (!Array.isArray(testResults.tests)) {
-      throw new Error(
-        `Invalid EvaluateResult: testResults.tests must be an array, got ${typeof testResults.tests}`
-      )
-    }
-
-    // Validate each test result
-    for (let i = 0; i < testResults.tests.length; i++) {
-      const test = testResults.tests[i]
-      if (typeof test !== 'object' || test === null) {
-        throw new Error(
-          `Invalid EvaluateResult: testResults.tests[${i}] must be an object, got ${
-            test === null ? 'null' : typeof test
-          }`
-        )
-      }
-
-      const testObj = test as Record<string, unknown>
-
-      if (typeof testObj.name !== 'string') {
-        throw new Error(
-          `Invalid EvaluateResult: testResults.tests[${i}].name must be a string, got ${typeof testObj.name}`
-        )
-      }
-
-      if (typeof testObj.passed !== 'boolean') {
-        throw new Error(
-          `Invalid EvaluateResult: testResults.tests[${i}].passed must be a boolean, got ${typeof testObj.passed}`
-        )
-      }
-
-      if (typeof testObj.duration !== 'number') {
-        throw new Error(
-          `Invalid EvaluateResult: testResults.tests[${i}].duration must be a number, got ${typeof testObj.duration}`
-        )
-      }
-
-      if (testObj.error !== undefined && typeof testObj.error !== 'string') {
-        throw new Error(
-          `Invalid EvaluateResult: testResults.tests[${i}].error must be a string if present, got ${typeof testObj.error}`
-        )
-      }
-    }
-  }
-}

package/src/types.ts

@@ -1,196 +0,0 @@
-/**
- * Types for ai-sandbox
- */
-
-/**
- * SDK configuration for the sandbox environment
- */
-export interface SDKConfig {
-  /** Execution context: local (in-memory) or remote (RPC) */
-  context?: 'local' | 'remote'
-  /** RPC endpoint URL for all services (default: https://rpc.do) */
-  rpcUrl?: string
-  /** Database RPC URL (default: https://db.do/rpc) */
-  dbUrl?: string
-  /** AI RPC URL (default: https://ai.do/rpc) */
-  aiUrl?: string
-  /** Authentication token */
-  token?: string
-  /** Default namespace for database operations */
-  ns?: string
-  /** Cloudflare AI Gateway URL (e.g., https://gateway.ai.cloudflare.com/v1/{account}/{gateway}) */
-  aiGatewayUrl?: string
-  /** Cloudflare AI Gateway authentication token */
-  aiGatewayToken?: string
-}
-
-/**
- * Network access configuration
- *
- * @example
- * fetch: true           // allow all (default)
- * fetch: false          // block all
- * fetch: null           // block all (backwards compat)
- * fetch: ['api.example.com', '*.trusted.com']  // allowlist with wildcards
- */
-export type FetchConfig = boolean | null | string[]
-
-/**
- * Options for evaluate()
- */
-export interface EvaluateOptions {
-  /** Module code with exports */
-  module?: string | undefined
-  /** Test code using vitest (describe, expect, it in global scope) */
-  tests?: string | undefined
-  /** Script code to run immediately (module exports in scope) */
-  script?: string | undefined
-  /** Timeout in milliseconds (default: 5000) */
-  timeout?: number | undefined
-  /** Environment variables to pass to the sandbox */
-  env?: Record<string, string> | undefined
-  /**
-   * Network access control
-   * - true: allow all (default)
-   * - false/null: block all
-   * - string[]: allowlist of domains (wildcards: '*.example.com')
-   */
-  fetch?: FetchConfig
-  /** RPC services to expose via capnweb (URL -> handler) */
-  rpc?: Record<string, unknown> | undefined
-  /** Outbound RPC interceptor - intercepts fetch calls to RPC URLs */
-  outboundRpc?: ((url: string, request: Request) => Promise<Response> | Response | null) | undefined
-  /** SDK configuration - enables $, db, ai, api, on, send globals */
-  sdk?: SDKConfig | boolean | undefined
-  /** Top-level imports to hoist (for MDX test files with external imports) */
-  imports?: string[] | undefined
-}
-
-/**
- * Result from evaluate()
- */
-export interface EvaluateResult {
-  /** Whether execution succeeded */
-  success: boolean
-  /** Return value from script (if any) */
-  value?: unknown
-  /** Console output */
-  logs: LogEntry[]
-  /** Test results (if tests were provided) */
-  testResults?: TestResults
-  /** Error message if execution failed */
-  error?: string
-  /** Execution time in milliseconds */
-  duration: number
-}
-
-/**
- * A log entry from console.log/warn/error
- */
-export interface LogEntry {
-  level: 'log' | 'warn' | 'error' | 'info' | 'debug'
-  message: string
-  timestamp: number
-}
-
-/**
- * Test results from vitest-style tests
- */
-export interface TestResults {
-  /** Total number of tests */
-  total: number
-  /** Number of passed tests */
-  passed: number
-  /** Number of failed tests */
-  failed: number
-  /** Number of skipped tests */
-  skipped: number
-  /** Individual test results */
-  tests: TestResult[]
-  /** Total duration in milliseconds */
-  duration: number
-}
-
-/**
- * Individual test result
- */
-export interface TestResult {
-  /** Test name (describe > it) */
-  name: string
-  /** Whether the test passed */
-  passed: boolean
-  /** Error message if failed */
-  error?: string
-  /** Test duration in milliseconds */
-  duration: number
-}
-
-/**
- * Worker loader binding type (Cloudflare)
- */
-export interface WorkerLoader {
-  get(id: string, loader: () => Promise<WorkerCode>): WorkerStub
-}
-
-/**
- * Worker code configuration
- */
-export interface WorkerCode {
-  mainModule: string
-  modules: Record<string, string | { js?: string; cjs?: string; text?: string; json?: unknown }>
-  compatibilityDate?: string
-  env?: Record<string, unknown>
-  globalOutbound?: null | unknown
-}
-
-/**
- * Worker entrypoint with fetch method
- */
-export interface WorkerEntrypoint {
-  fetch(request: Request): Promise<Response>
-}
-
-/**
- * Worker stub returned by loader
- */
-export interface WorkerStub {
-  getEntrypoint(): WorkerEntrypoint
-}
-
-/**
- * Test service core - returned by connect() (from ai-tests)
- */
-export interface TestServiceCore {
-  expect(value: unknown, message?: string): unknown
-  should(value: unknown): unknown
-  assert: unknown
-  describe(name: string, fn: () => void): void
-  it(name: string, fn: () => void | Promise<void>): void
-  test(name: string, fn: () => void | Promise<void>): void
-  skip(name: string, fn?: () => void | Promise<void>): void
-  only(name: string, fn: () => void | Promise<void>): void
-  beforeEach(fn: () => void | Promise<void>): void
-  afterEach(fn: () => void | Promise<void>): void
-  beforeAll(fn: () => void | Promise<void>): void
-  afterAll(fn: () => void | Promise<void>): void
-  run(): Promise<TestResults>
-  reset(): void
-}
-
-/**
- * Test service binding type - WorkerEntrypoint (from ai-tests)
- */
-export interface TestServiceBinding {
-  /** Get a test service instance via RPC */
-  connect(): Promise<TestServiceCore>
-}
-
-/**
- * Environment with worker loader binding
- */
-export interface SandboxEnv {
-  loader?: WorkerLoader
-  LOADER?: WorkerLoader // Legacy - prefer lowercase
-  test?: TestServiceBinding
-  TEST?: TestServiceBinding // Legacy - prefer lowercase
-}

package/src/validation.ts

@@ -1,120 +0,0 @@
-/**
- * Input validation for EvaluateOptions
- *
- * Validates options to prevent resource exhaustion and provide clear error messages.
- */
-
-import type { EvaluateOptions } from './types.js'
-
-/**
- * Validation limits for EvaluateOptions
- */
-export const MAX_SCRIPT_SIZE = 1024 * 1024 // 1MB
-export const MAX_IMPORTS = 100
-export const MAX_TIMEOUT = 60000 // 60 seconds
-export const DEFAULT_TIMEOUT = 5000 // 5 seconds
-
-/**
- * Validation error thrown when options fail validation
- */
-export class ValidationError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'ValidationError'
-  }
-}
-
-/**
- * Validate a URL string
- */
-function isValidUrl(urlString: string): boolean {
-  try {
-    const url = new URL(urlString)
-    return url.protocol === 'http:' || url.protocol === 'https:'
-  } catch {
-    return false
-  }
-}
-
-/**
- * Validate EvaluateOptions
- *
- * @throws ValidationError if any validation fails
- */
-export function validateOptions(options: EvaluateOptions): void {
-  // Validate timeout
-  if (options.timeout !== undefined) {
-    if (typeof options.timeout !== 'number') {
-      throw new ValidationError('timeout must be a number')
-    }
-    if (!Number.isFinite(options.timeout)) {
-      throw new ValidationError('timeout must be a finite number')
-    }
-    if (options.timeout <= 0) {
-      throw new ValidationError('timeout must be a positive number')
-    }
-    if (options.timeout > MAX_TIMEOUT) {
-      throw new ValidationError(`timeout exceeds maximum allowed value of ${MAX_TIMEOUT}ms`)
-    }
-  }
-
-  // Validate script length
-  if (options.script !== undefined && options.script !== null) {
-    if (typeof options.script !== 'string') {
-      throw new ValidationError('script must be a string')
-    }
-    const scriptBytes = new TextEncoder().encode(options.script).length
-    if (scriptBytes > MAX_SCRIPT_SIZE) {
-      throw new ValidationError(
-        `script size (${scriptBytes} bytes) exceeds maximum allowed size of ${MAX_SCRIPT_SIZE} bytes (1MB)`
-      )
-    }
-  }
-
-  // Validate module length
-  if (options.module !== undefined && options.module !== null) {
-    if (typeof options.module !== 'string') {
-      throw new ValidationError('module must be a string')
-    }
-    const moduleBytes = new TextEncoder().encode(options.module).length
-    if (moduleBytes > MAX_SCRIPT_SIZE) {
-      throw new ValidationError(
-        `module size (${moduleBytes} bytes) exceeds maximum allowed size of ${MAX_SCRIPT_SIZE} bytes (1MB)`
-      )
-    }
-  }
-
-  // Validate tests length
-  if (options.tests !== undefined && options.tests !== null) {
-    if (typeof options.tests !== 'string') {
-      throw new ValidationError('tests must be a string')
-    }
-    const testsBytes = new TextEncoder().encode(options.tests).length
-    if (testsBytes > MAX_SCRIPT_SIZE) {
-      throw new ValidationError(
-        `tests size (${testsBytes} bytes) exceeds maximum allowed size of ${MAX_SCRIPT_SIZE} bytes (1MB)`
-      )
-    }
-  }
-
-  // Validate imports
-  if (options.imports !== undefined && options.imports !== null) {
-    if (!Array.isArray(options.imports)) {
-      throw new ValidationError('imports must be an array')
-    }
-    if (options.imports.length > MAX_IMPORTS) {
-      throw new ValidationError(
-        `imports count (${options.imports.length}) exceeds maximum allowed count of ${MAX_IMPORTS}`
-      )
-    }
-    for (let i = 0; i < options.imports.length; i++) {
-      const importUrl = options.imports[i]
-      if (typeof importUrl !== 'string') {
-        throw new ValidationError(`imports[${i}] must be a string`)
-      }
-      if (!isValidUrl(importUrl)) {
-        throw new ValidationError(`imports[${i}] is not a valid URL: ${importUrl}`)
-      }
-    }
-  }
-}

package/src/worker-template/code-transforms.ts

@@ -1,32 +0,0 @@
-/**
- * Module transformation and export detection utilities
- */
-
-/**
- * Transform module code to work in sandbox
- * Converts ES module exports to CommonJS-style for the sandbox
- */
-export function transformModuleCode(moduleCode: string): string {
-  let code = moduleCode
-
-  // Transform: export const foo = ... -> const foo = ...; exports.foo = foo;
-  code = code.replace(/export\s+(const|let|var)\s+(\w+)\s*=/g, '$1 $2 = exports.$2 =')
-
-  // Transform: export function foo(...) -> function foo(...) exports.foo = foo;
-  // Also handles async generators: export async function* foo
-  code = code.replace(/export\s+(async\s+)?function(\*?)\s+(\w+)/g, '$1function$2 $3')
-  // Add exports for functions after their definition
-  const funcNames = [...moduleCode.matchAll(/export\s+(?:async\s+)?function\*?\s+(\w+)/g)]
-  for (const [, name] of funcNames) {
-    code += `\nexports.${name} = ${name};`
-  }
-
-  // Transform: export class Foo -> class Foo; exports.Foo = Foo;
-  code = code.replace(/export\s+class\s+(\w+)/g, 'class $1')
-  const classNames = [...moduleCode.matchAll(/export\s+class\s+(\w+)/g)]
-  for (const [, name] of classNames) {
-    code += `\nexports.${name} = ${name};`
-  }
-
-  return code
-}