Function runCodeInIVM

src/server/utils/vm/index.ts:65–139

(
  _code: string,
  globals: Record<string, any> = {}
)

 * Only run code with isolated-vm
 */
export async function runCodeInIVM(
  _code: string,
  globals: Record<string, any> = {}
): Promise<IVMExecutionResult> {
  const start = Date.now();
  // const transformedCode = await transformTypescriptCode(_code);
  let sourceCode = _code;

  if (env.enableFunctionWorkerTypescriptSupport) {
    sourceCode = await transformTypescriptCode(sourceCode);
  }

  // avoid end comment with line break
  const code = `${environmentScript}

${sourceCode}`;

  const isolate = new ivm.Isolate({ memoryLimit: env.sandbox.memoryLimit });
  const logger: any[][] = [];

  let res: any;
  let err: any;
  let context: ivm.Context | undefined;
  let script: ivm.Script | undefined;

  try {
    context = await isolate.createContext();
    script = await isolate.compileScript(code);

    buildSandbox(context, {
      globals,
      console: {
        log: (...args: any[]) => {
          logger.push(['log', Date.now(), ...args]);
        },
        warn: (...args: any[]) => {
          logger.push(['warn', Date.now(), ...args]);
        },
        error: (...args: any[]) => {
          logger.push(['error', Date.now(), ...args]);
        },
      },
    });

    try {
      res = await script.run(context, {
        promise: true,
        copy: true,
      });
    } catch (e) {
      console.trace(e);
      err = e;
    }

    const cpuTime = Number(isolate.cpuTime); // unit: ns
    const memoryUsage = await isolate.getHeapStatistics(); // unit: bytes

    return {