@flowgram.ai/runtime-js 0.1.0-alpha.29 → 0.1.0-alpha.30

package/dist/esm/index.js

@@ -1450,6 +1450,7 @@ var ConditionExecutor = class {
 };
 
 // src/nodes/code/index.ts
+import { getQuickJS, shouldInterruptAfterDeadline } from "quickjs-emscripten";
 var CodeExecutor = class {
   constructor() {
     this.type = FlowGramNode.Code;
@@ -1478,35 +1479,53 @@ var CodeExecutor = class {
   }
   async javascript(inputs) {
     const { params = {}, script } = inputs;
+    const serializedParams = JSON.stringify(params);
+    const QuickJS = await getQuickJS();
+    const context = QuickJS.newContext();
     try {
-      const executeCode = new Function(
-        "params",
-        `
-        'use strict';
+      const runtime = context.runtime;
+      runtime.setMemoryLimit(32 * 1024 * 1024);
+      runtime.setMaxStackSize(512 * 1024);
+      runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + 6e4));
+      const wrappedCode = `
+'use strict';
 
-        ${script.content}
+${script.content}
 
-        // Ensure main function exists
-        if (typeof main !== 'function') {
-          throw new Error('main function is required in the script');
-        }
+if (typeof main !== 'function') {
+  throw new Error('main function is required in the script');
+}
 
-        // Execute main function with params
-        return main({ params });
-        `
-      );
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error("Code execution timeout: exceeded 1 minute"));
-        }, 1e3 * 60);
-      });
-      const result = await Promise.race([executeCode(params), timeoutPromise]);
-      const outputs = result && typeof result === "object" && !Array.isArray(result) ? result : { result };
-      return {
-        outputs
-      };
+const __params__ = ${serializedParams};
+main({ params: __params__ });
+`;
+      const evalResult = context.evalCode(wrappedCode);
+      const resultHandle = context.unwrapResult(evalResult);
+      let rawResult;
+      try {
+        const promiseState = context.getPromiseState(resultHandle);
+        if (promiseState.type === "fulfilled") {
+          rawResult = context.dump(promiseState.value);
+          promiseState.value.dispose();
+        } else if (promiseState.type === "rejected") {
+          const errMsg = context.dump(promiseState.error);
+          promiseState.error.dispose();
+          throw new Error(typeof errMsg === "string" ? errMsg : JSON.stringify(errMsg));
+        } else {
+          const resolvedResult = await context.resolvePromise(resultHandle);
+          const resolvedHandle = context.unwrapResult(resolvedResult);
+          rawResult = context.dump(resolvedHandle);
+          resolvedHandle.dispose();
+        }
+      } finally {
+        resultHandle.dispose();
+      }
+      const outputs = rawResult && typeof rawResult === "object" && !Array.isArray(rawResult) ? rawResult : { result: rawResult };
+      return { outputs };
     } catch (error) {
       throw new Error(`Code execution failed: ${error.message}`);
+    } finally {
+      context.dispose();
     }
   }
 };