@usebruno/js 0.45.1 → 0.46.0

package/src/sandbox/node-vm/index.js

@@ -2,10 +2,12 @@ const vm = require('node:vm');
 const path = require('node:path');
 const { get } = require('lodash');
 const lodash = require('lodash');
-const { ScriptError } = require('./utils');
+const { wrapConsoleWithSerializers } = require('./console');
+const { ScriptError, resolveVmFilename } = require('./utils');
 const { createCustomRequire } = require('./cjs-loader');
 const { safeGlobals } = require('./constants');
 const { mixinTypedArrays } = require('../mixins/typed-arrays');
+const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
 /**
  * Executes a script in a Node.js VM context with enhanced security and module loading
@@ -15,10 +17,17 @@ const { mixinTypedArrays } = require('../mixins/typed-arrays');
  * @param {Object} options.context - The execution context with Bruno objects
  * @param {string} options.collectionPath - Path to the collection directory
  * @param {Object} options.scriptingConfig - Scripting configuration options
- * @returns {Promise<void>}
+ * @param {string} [options.scriptPath] - Path to the source file for accurate stack traces
+ * @returns {Promise<Object>} Execution results including variables and test results
  * @throws {ScriptError} When script execution fails
  */
-async function runScriptInNodeVm({ script, context, collectionPath, scriptingConfig }) {
+async function runScriptInNodeVm({
+  script,
+  context,
+  collectionPath,
+  scriptingConfig,
+  scriptPath
+}) {
   if (script.trim().length === 0) {
     return;
   }
@@ -57,13 +66,61 @@ async function runScriptInNodeVm({ script, context, collectionPath, scriptingCon
       additionalContextRootsAbsolute
     });
 
+    const vmFilename = resolveVmFilename(scriptPath, collectionPath);
+
     // Execute the script in the isolated context
-    const wrappedScript = `(async function(){ ${script} \n})();`;
-    const compiledScript = new vm.Script(wrappedScript, {
-      filename: path.join(collectionPath, 'script.js')
-    });
+    const wrappedScript = wrapScriptInClosure(script, SANDBOX.NODEVM);
+    let compiledScript;
+    try {
+      compiledScript = new vm.Script(wrappedScript, {
+        filename: vmFilename
+      });
+    } catch (error) {
+      // V8 puts "filename:line" as the first line of syntax error stacks.
+      // Parse it so the error formatter can map to the correct source location.
+      const firstLine = error.stack?.split('\n')[0];
+      const match = firstLine?.match(/^(.+):(\d+)$/);
+      if (match && match[1] === vmFilename) {
+        error.__callSites = [{
+          filePath: vmFilename,
+          line: parseInt(match[2], 10),
+          column: null,
+          functionName: null
+        }];
+      }
+      throw error;
+    }
+
+    // Capture structured call sites for error-formatter line mapping
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (error, callSites) => {
+      error.__callSites = callSites
+        .filter((site) => site.getFileName() === vmFilename)
+        .map((site) => ({
+          filePath: site.getFileName(),
+          line: site.getLineNumber(),
+          column: site.getColumnNumber(),
+          functionName: site.getFunctionName() || null
+        }));
 
-    await compiledScript.runInContext(isolatedContext);
+      return error.toString() + '\n' + callSites
+        .map((site) => `    at ${site}`)
+        .join('\n');
+    };
+
+    try {
+      await compiledScript.runInContext(isolatedContext, {
+        displayErrors: true
+      });
+    } catch (error) {
+      // V8 invokes prepareStackTrace lazily on first .stack access.
+      // Reading .stack here so custom handler runs and populates error.__callSites
+      // (used later by the error formatter to map stack frames to the .bru/.yml script)
+      void error.stack;
+      throw error;
+    } finally {
+      Error.prepareStackTrace = originalPrepareStackTrace;
+    }
   } catch (error) {
     throw new ScriptError(error, script);
   }
@@ -79,6 +136,9 @@ function buildScriptContext(context, scriptingConfig) {
   const scriptContext = {
     ...context,
 
+    // Bruno context (wrap console with Set/Map support)
+    console: wrapConsoleWithSerializers(context.console),
+
     // Configuration for nested module loading
     scriptingConfig: scriptingConfig,
 

package/src/sandbox/node-vm/utils.js

@@ -25,6 +25,19 @@ function isPathWithinAllowedRoots(normalizedPath, additionalContextRootsAbsolute
   });
 }
 
+/**
+ * Resolve the VM filename for the script
+ * @param {string|null} scriptPath - Path to the source file
+ * @param {string} collectionPath - Path to the collection directory
+ * @returns {string} Absolute path to use as the VM filename
+ */
+function resolveVmFilename(scriptPath, collectionPath) {
+  if (scriptPath) {
+    return path.isAbsolute(scriptPath) ? scriptPath : path.join(collectionPath, scriptPath);
+  }
+  return path.join(collectionPath, 'script.js');
+}
+
 class ScriptError extends Error {
   constructor(error, script) {
     super(error.message);
@@ -32,11 +45,13 @@ class ScriptError extends Error {
     this.originalError = error;
     this.script = script;
     this.stack = error.stack;
+    this.__callSites = error.__callSites || null;
   }
 }
 
 module.exports = {
   isBuiltinModule,
   isPathWithinAllowedRoots,
+  resolveVmFilename,
   ScriptError
 };

package/src/sandbox/quickjs/index.js

@@ -12,6 +12,7 @@ const getBundledCode = require('../bundle-browser-rollup');
 const addPathShimToContext = require('./shims/lib/path');
 const { marshallToVm } = require('./utils');
 const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
+const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
 let QuickJSSyncContext;
 const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
@@ -89,7 +90,7 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
   }
 };
 
-const executeQuickJsVmAsync = async ({ script: externalScript, context: externalContext, collectionPath }) => {
+const executeQuickJsVmAsync = async ({ script: externalScript, context: externalContext, collectionPath, scriptPath }) => {
   if (!externalScript?.length || typeof externalScript !== 'string') {
     return externalScript;
   }
@@ -157,25 +158,9 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
     test && __brunoTestResults && addTestShimToContext(vm, __brunoTestResults);
 
-    const script = `
-      (async () => {
-        const setTimeout = async(fn, timer) => {
-          v = await bru.sleep(timer);
-          fn.apply();
-        }
-        await bru.sleep(0);
-        try {
-          ${externalScript}
-        }
-        catch(error) {
-          console?.debug?.('quick-js:execution-end:with-error', error?.message);
-          throw new Error(error?.message);
-        }
-        return 'done';
-      })()
-    `;
+    const script = wrapScriptInClosure(externalScript, SANDBOX.QUICKJS);
 
-    const result = vm.evalCode(script);
+    const result = vm.evalCode(script, scriptPath);
     const promiseHandle = vm.unwrapResult(result);
     const resolvedResult = await vm.resolvePromise(promiseHandle);
     promiseHandle.dispose();
@@ -184,8 +169,8 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
     // vm.dispose();
     return;
   } catch (error) {
-    console.error('Error executing the script!', error);
-    throw new Error(error);
+    error.__isQuickJS = true;
+    throw error;
   }
 };
 

package/src/sandbox/quickjs/shims/bru.js

@@ -61,11 +61,23 @@ const addBruShimToContext = (vm, bru) => {
   setEnvVar.dispose();
 
   let deleteEnvVar = vm.newFunction('deleteEnvVar', function (key) {
-    return marshallToVm(bru.deleteEnvVar(vm.dump(key)), vm);
+    bru.deleteEnvVar(vm.dump(key));
   });
   vm.setProp(bruObject, 'deleteEnvVar', deleteEnvVar);
   deleteEnvVar.dispose();
 
+  let getAllEnvVars = vm.newFunction('getAllEnvVars', function () {
+    return marshallToVm(bru.getAllEnvVars(), vm);
+  });
+  vm.setProp(bruObject, 'getAllEnvVars', getAllEnvVars);
+  getAllEnvVars.dispose();
+
+  let deleteAllEnvVars = vm.newFunction('deleteAllEnvVars', function () {
+    bru.deleteAllEnvVars();
+  });
+  vm.setProp(bruObject, 'deleteAllEnvVars', deleteAllEnvVars);
+  deleteAllEnvVars.dispose();
+
   let getGlobalEnvVar = vm.newFunction('getGlobalEnvVar', function (key) {
     return marshallToVm(bru.getGlobalEnvVar(vm.dump(key)), vm);
   });
@@ -78,12 +90,40 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'getOauth2CredentialVar', getOauth2CredentialVar);
   getOauth2CredentialVar.dispose();
 
+  let resetOauth2Credential = vm.newFunction('resetOauth2Credential', function (credentialId) {
+    bru.resetOauth2Credential(vm.dump(credentialId));
+  });
+  vm.setProp(bruObject, 'resetOauth2Credential', resetOauth2Credential);
+  resetOauth2Credential.dispose();
+
   let setGlobalEnvVar = vm.newFunction('setGlobalEnvVar', function (key, value) {
     bru.setGlobalEnvVar(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruObject, 'setGlobalEnvVar', setGlobalEnvVar);
   setGlobalEnvVar.dispose();
 
+  // TODO: deleteGlobalEnvVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let deleteGlobalEnvVar = vm.newFunction('deleteGlobalEnvVar', function (key) {
+  //   bru.deleteGlobalEnvVar(vm.dump(key));
+  // });
+  // vm.setProp(bruObject, 'deleteGlobalEnvVar', deleteGlobalEnvVar);
+  // deleteGlobalEnvVar.dispose();
+
+  let getAllGlobalEnvVars = vm.newFunction('getAllGlobalEnvVars', function () {
+    return marshallToVm(bru.getAllGlobalEnvVars(), vm);
+  });
+  vm.setProp(bruObject, 'getAllGlobalEnvVars', getAllGlobalEnvVars);
+  getAllGlobalEnvVars.dispose();
+
+  // TODO: deleteAllGlobalEnvVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let deleteAllGlobalEnvVars = vm.newFunction('deleteAllGlobalEnvVars', function () {
+  //   bru.deleteAllGlobalEnvVars();
+  // });
+  // vm.setProp(bruObject, 'deleteAllGlobalEnvVars', deleteAllGlobalEnvVars);
+  // deleteAllGlobalEnvVars.dispose();
+
   let hasVar = vm.newFunction('hasVar', function (key) {
     return marshallToVm(bru.hasVar(vm.dump(key)), vm);
   });
@@ -114,6 +154,12 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'deleteAllVars', deleteAllVars);
   deleteAllVars.dispose();
 
+  let getAllVars = vm.newFunction('getAllVars', function () {
+    return marshallToVm(bru.getAllVars(), vm);
+  });
+  vm.setProp(bruObject, 'getAllVars', getAllVars);
+  getAllVars.dispose();
+
   let setNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
     bru.setNextRequest(vm.dump(nextRequest));
   });
@@ -212,6 +258,44 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'getCollectionVar', getCollectionVar);
   getCollectionVar.dispose();
 
+  // TODO: setCollectionVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let setCollectionVar = vm.newFunction('setCollectionVar', function (key, value) {
+  //   bru.setCollectionVar(vm.dump(key), vm.dump(value));
+  // });
+  // vm.setProp(bruObject, 'setCollectionVar', setCollectionVar);
+  // setCollectionVar.dispose();
+
+  let hasCollectionVar = vm.newFunction('hasCollectionVar', function (key) {
+    return marshallToVm(bru.hasCollectionVar(vm.dump(key)), vm);
+  });
+  vm.setProp(bruObject, 'hasCollectionVar', hasCollectionVar);
+  hasCollectionVar.dispose();
+
+  // TODO: deleteCollectionVar works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let deleteCollectionVar = vm.newFunction('deleteCollectionVar', function (key) {
+  //   bru.deleteCollectionVar(vm.dump(key));
+  // });
+  // vm.setProp(bruObject, 'deleteCollectionVar', deleteCollectionVar);
+  // deleteCollectionVar.dispose();
+
+  // TODO: deleteAllCollectionVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let deleteAllCollectionVars = vm.newFunction('deleteAllCollectionVars', function () {
+  //   bru.deleteAllCollectionVars();
+  // });
+  // vm.setProp(bruObject, 'deleteAllCollectionVars', deleteAllCollectionVars);
+  // deleteAllCollectionVars.dispose();
+
+  // TODO: getAllCollectionVars works in the request lifecycle but does not update the UI.
+  // Re-enable once the UI sync issue is resolved.
+  // let getAllCollectionVars = vm.newFunction('getAllCollectionVars', function () {
+  //   return marshallToVm(bru.getAllCollectionVars(), vm);
+  // });
+  // vm.setProp(bruObject, 'getAllCollectionVars', getAllCollectionVars);
+  // getAllCollectionVars.dispose();
+
   let getTestResults = vm.newFunction('getTestResults', () => {
     const promise = vm.newPromise();
     bru
@@ -432,6 +516,20 @@ const addBruShimToContext = (vm, bru) => {
     });
     _deleteCookieFn.consume((handle) => vm.setProp(jarObj, '_deleteCookie', handle));
 
+    const _hasCookieFn = vm.newFunction('_hasCookie', (url, cookieName) => {
+      const promise = vm.newPromise();
+      nativeJar.hasCookie(vm.dump(url), vm.dump(cookieName), (err, exists) => {
+        if (err) {
+          promise.reject(marshallToVm(cleanJson(err), vm));
+        } else {
+          promise.resolve(marshallToVm(exists, vm));
+        }
+      });
+      promise.settled.then(vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    _hasCookieFn.consume((handle) => vm.setProp(jarObj, '_hasCookie', handle));
+
     return jarObj;
   });
   _jarFn.consume((handle) => vm.setProp(bruCookiesObject, '_jar', handle));
@@ -446,20 +544,26 @@ const addBruShimToContext = (vm, bru) => {
   bruObject.dispose();
 
   vm.evalCode(`
+    // sendRequest with callback: normalize error.status (axios uses error.response.status) so
+    // tests like expect(error.status).to.eql(404) pass in safe sandbox; return response after
+    // success callback for consistent promise resolution.
     globalThis.bru.sendRequest = async (requestConfig, callback) => {
       if (!callback) return await globalThis.bru._sendRequest(requestConfig);
       try {
         const response = await globalThis.bru._sendRequest(requestConfig);
         try {
           await callback(null, response);
+          return response;
         }
         catch(error) {
           return Promise.reject(error);
         }
       }
       catch(error) {
+        const errObj = JSON.parse(JSON.stringify(error));
+        if (errObj && errObj.response && typeof errObj.response.status === 'number') errObj.status = errObj.response.status;
         try {
-          await callback(JSON.parse(JSON.stringify(error)), null);
+          await callback(errObj, null);
         }
         catch(err) {
           return Promise.reject(err);
@@ -497,7 +601,8 @@ const addBruShimToContext = (vm, bru) => {
         setCookies: (url, cookiesArray, cb) => callWithCallback(() => _jar._setCookies(url, cookiesArray), cb),
         clear: (cb) => callWithCallback(() => _jar._clear(), cb),
         deleteCookies: (url, cb) => callWithCallback(() => _jar._deleteCookies(url), cb),
-        deleteCookie: (url, name, cb) => callWithCallback(() => _jar._deleteCookie(url, name), cb)
+        deleteCookie: (url, name, cb) => callWithCallback(() => _jar._deleteCookie(url, name), cb),
+        hasCookie: (url, name, cb) => callWithCallback(() => _jar._hasCookie(url, name), cb)
       };
     };
   `);

package/src/sandbox/quickjs/shims/bruno-request.js

@@ -102,6 +102,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'setHeaders', setHeaders);
   setHeaders.dispose();
 
+  let deleteHeaders = vm.newFunction('deleteHeaders', function (headers) {
+    req.deleteHeaders(vm.dump(headers));
+  });
+  vm.setProp(reqObject, 'deleteHeaders', deleteHeaders);
+  deleteHeaders.dispose();
+
   let getHeader = vm.newFunction('getHeader', function (name) {
     return marshallToVm(req.getHeader(vm.dump(name)), vm);
   });
@@ -114,6 +120,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'setHeader', setHeader);
   setHeader.dispose();
 
+  let deleteHeader = vm.newFunction('deleteHeader', function (header) {
+    req.deleteHeader(vm.dump(header));
+  });
+  vm.setProp(reqObject, 'deleteHeader', deleteHeader);
+  deleteHeader.dispose();
+
   let getBody = vm.newFunction('getBody', function (options = {}) {
     return marshallToVm(req.getBody(vm.dump(options)), vm);
   });

package/src/sandbox/quickjs/shims/console.js

@@ -1,30 +1,122 @@
 const addConsoleShimToContext = (vm, console) => {
   if (!console) return;
 
+  // Helper function to convert QuickJS values to native values with Set/Map support
+  const dumpWithSerializers = (arg) => {
+    // Track all handles for centralized disposal
+    let nameProp, constructorProp, constructorNameProp, toStringFn, toStringResult;
+    let arrayFn, fromFn, arrayResult;
+
+    try {
+      const argType = vm.typeof(arg);
+
+      // Early return for primitives (string, number, boolean, undefined, null)
+      if (arg == null || arg === vm.null || arg === vm.undefined) {
+        return vm.dump(arg);
+      }
+
+      if (argType !== 'object' && argType !== 'function') {
+        return vm.dump(arg);
+      }
+
+      // Handle functions - show clean wrapper
+      if (argType === 'function') {
+        nameProp = vm.getProp(arg, 'name');
+        const name = nameProp ? vm.dump(nameProp) || 'anonymous' : 'anonymous';
+        return `function ${name}() {\n    [native code]\n}`;
+      }
+
+      // Try to get the constructor name to detect Set/Map
+      constructorProp = vm.getProp(arg, 'constructor');
+      if (!constructorProp) {
+        return vm.dump(arg);
+      }
+
+      let constructorName = null;
+      constructorNameProp = vm.getProp(constructorProp, 'name');
+      if (constructorNameProp) {
+        constructorName = vm.dump(constructorNameProp);
+      }
+
+      // Handle Date, RegExp, Error - call toString()
+      if (constructorName === 'Date' || constructorName === 'RegExp' || constructorName?.endsWith?.('Error')) {
+        toStringFn = vm.getProp(arg, 'toString');
+        if (toStringFn) {
+          toStringResult = vm.callFunction(toStringFn, arg);
+          if (toStringResult.error) {
+            return vm.dump(arg);
+          }
+          return vm.dump(toStringResult.value);
+        }
+      }
+
+      // If not a Set or Map, use standard dump
+      if (constructorName !== 'Set' && constructorName !== 'Map') {
+        return vm.dump(arg);
+      }
+
+      // Convert Set or Map to array via Array.from
+      arrayFn = vm.getProp(vm.global, 'Array');
+      if (!arrayFn) {
+        return vm.dump(arg);
+      }
+
+      fromFn = vm.getProp(arrayFn, 'from');
+      if (!fromFn) {
+        return vm.dump(arg);
+      }
+
+      arrayResult = vm.callFunction(fromFn, arrayFn, arg);
+      if (arrayResult.error) {
+        return vm.dump(arg);
+      }
+
+      return {
+        __brunoType: constructorName,
+        __brunoValue: vm.dump(arrayResult.value)
+      };
+    } catch (e) {
+      // Fallback to normal dump
+      return vm.dump(arg);
+    } finally {
+      // Centralized handle disposal - dispose all handles regardless of success or error
+      nameProp?.dispose();
+      constructorProp?.dispose();
+      constructorNameProp?.dispose();
+      toStringFn?.dispose();
+      toStringResult?.value?.dispose();
+      toStringResult?.error?.dispose();
+      arrayFn?.dispose();
+      fromFn?.dispose();
+      arrayResult?.value?.dispose();
+      arrayResult?.error?.dispose();
+    }
+  };
+
   const consoleHandle = vm.newObject();
 
   const logHandle = vm.newFunction('log', (...args) => {
-    const nativeArgs = args.map(vm.dump);
+    const nativeArgs = args.map(dumpWithSerializers);
     console?.log?.(...nativeArgs);
   });
 
   const debugHandle = vm.newFunction('debug', (...args) => {
-    const nativeArgs = args.map(vm.dump);
+    const nativeArgs = args.map(dumpWithSerializers);
     console?.debug?.(...nativeArgs);
   });
 
   const infoHandle = vm.newFunction('info', (...args) => {
-    const nativeArgs = args.map(vm.dump);
+    const nativeArgs = args.map(dumpWithSerializers);
     console?.info?.(...nativeArgs);
   });
 
   const warnHandle = vm.newFunction('warn', (...args) => {
-    const nativeArgs = args.map(vm.dump);
+    const nativeArgs = args.map(dumpWithSerializers);
     console?.warn?.(...nativeArgs);
   });
 
   const errorHandle = vm.newFunction('error', (...args) => {
-    const nativeArgs = args.map(vm.dump);
+    const nativeArgs = args.map(dumpWithSerializers);
     console?.error?.(...nativeArgs);
   });
 

package/src/sandbox/quickjs/shims/lib/axios.js

@@ -4,6 +4,30 @@ const { marshallToVm } = require('../../utils');
 
 const methods = ['get', 'post', 'put', 'patch', 'delete'];
 
+const buildAxiosErrorData = (err) => {
+  return {
+    message: err.message,
+    code: err.code,
+    isAxiosError: err.isAxiosError,
+    ...(err.response && {
+      response: {
+        status: err.response.status,
+        statusText: err.response.statusText,
+        headers: err.response.headers,
+        data: err.response.data
+      }
+    }),
+    ...(err.config && {
+      config: {
+        url: err.config.url,
+        method: err.config.method,
+        headers: err.config.headers,
+        data: err.config.data
+      }
+    })
+  };
+};
+
 const addAxiosShimToContext = async (vm) => {
   methods?.forEach((method) => {
     const axiosHandle = vm.newFunction(method, (...args) => {
@@ -15,14 +39,7 @@ const addAxiosShimToContext = async (vm) => {
           promise.resolve(marshallToVm(cleanJson({ status, headers, data }), vm));
         })
         .catch((err) => {
-          promise.resolve(
-            marshallToVm(
-              cleanJson({
-                message: err.message
-              }),
-              vm
-            )
-          );
+          promise.reject(marshallToVm(cleanJson(buildAxiosErrorData(err)), vm));
         });
       promise.settled.then(vm.runtime.executePendingJobs);
       return promise.handle;
@@ -39,14 +56,7 @@ const addAxiosShimToContext = async (vm) => {
         promise.resolve(marshallToVm(cleanJson({ status, headers, data }), vm));
       })
       .catch((err) => {
-        promise.resolve(
-          marshallToVm(
-            cleanJson({
-              message: err.message
-            }),
-            vm
-          )
-        );
+        promise.reject(marshallToVm(cleanJson(buildAxiosErrorData(err)), vm));
       });
     promise.settled.then(vm.runtime.executePendingJobs);
     return promise.handle;