@usebruno/js 0.39.0 → 0.41.0

package/src/sandbox/mixins/typed-arrays.js

@@ -0,0 +1,15 @@
+exports.mixinTypedArrays = (obj) => {
+  Object.assign(obj, {
+    Int8Array: Int8Array,
+    Uint8Array: Uint8Array,
+    Uint8ClampedArray: Uint8ClampedArray,
+    Int16Array: Int16Array,
+    Uint16Array: Uint16Array,
+    Int32Array: Int32Array,
+    Uint32Array: Uint32Array,
+    Float32Array: Float32Array,
+    Float64Array: Float64Array,
+    BigInt64Array: BigInt64Array,
+    BigUint64Array: BigUint64Array
+  });
+};

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

@@ -4,6 +4,7 @@ const path = require('node:path');
 const { get } = require('lodash');
 const lodash = require('lodash');
 const { cleanJson } = require('../../utils');
+const { mixinTypedArrays } = require('../mixins/typed-arrays');
 
 class ScriptError extends Error {
   constructor(error, script) {
@@ -60,6 +61,8 @@ async function runScriptInNodeVm({
       clearImmediate: global.clearImmediate
     };
 
+    mixinTypedArrays(scriptContext);
+
     // Create shared cache for local modules
     const localModuleCache = new Map();
 

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

@@ -9,6 +9,7 @@ const addBrunoRequestShimToContext = (vm, req) => {
   const body = marshallToVm(req.getBody(), vm);
   const timeout = marshallToVm(req.getTimeout(), vm);
   const name = marshallToVm(req.getName(), vm);
+  const tags = marshallToVm(req.getTags(), vm);
 
   vm.setProp(reqObject, 'url', url);
   vm.setProp(reqObject, 'method', method);
@@ -16,6 +17,7 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'body', body);
   vm.setProp(reqObject, 'timeout', timeout);
   vm.setProp(reqObject, 'name', name);
+  vm.setProp(reqObject, 'tags', tags);
 
   url.dispose();
   method.dispose();
@@ -23,6 +25,7 @@ const addBrunoRequestShimToContext = (vm, req) => {
   body.dispose();
   timeout.dispose();
   name.dispose();
+  tags.dispose();
 
   let getUrl = vm.newFunction('getUrl', function () {
     return marshallToVm(req.getUrl(), vm);
@@ -84,14 +87,15 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'setHeader', setHeader);
   setHeader.dispose();
 
-  let getBody = vm.newFunction('getBody', function () {
-    return marshallToVm(req.getBody(), vm);
+  let getBody = vm.newFunction('getBody', function (options = {}) {
+    return marshallToVm(req.getBody(vm.dump(options)), vm);
   });
+
   vm.setProp(reqObject, 'getBody', getBody);
   getBody.dispose();
 
-  let setBody = vm.newFunction('setBody', function (data) {
-    req.setBody(vm.dump(data));
+  let setBody = vm.newFunction('setBody', function (data, options = {}) {
+    req.setBody(vm.dump(data), vm.dump(options));
   });
   vm.setProp(reqObject, 'setBody', setBody);
   setBody.dispose();
@@ -126,6 +130,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
   vm.setProp(reqObject, 'getExecutionMode', getExecutionMode);
   getExecutionMode.dispose();
 
+  let getTags = vm.newFunction('getTags', function () {
+    return marshallToVm(req.getTags(), vm);
+  });
+  vm.setProp(reqObject, 'getTags', getTags);
+  getTags.dispose();
+
   vm.setProp(vm.global, 'req', reqObject);
   reqObject.dispose();
 };

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

@@ -2,12 +2,14 @@ const addAxiosShimToContext = require('./axios');
 const addNanoidShimToContext = require('./nanoid');
 const addPathShimToContext = require('./path');
 const addUuidShimToContext = require('./uuid');
+const addJwtShimToContext = require('./jwt');
 
 const addLibraryShimsToContext = async (vm) => {
   await addNanoidShimToContext(vm);
   await addAxiosShimToContext(vm);
   await addUuidShimToContext(vm);
   await addPathShimToContext(vm);
+  await addJwtShimToContext(vm);
 };
 
 module.exports = addLibraryShimsToContext;

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

@@ -0,0 +1,181 @@
+const jwt = require('jsonwebtoken');
+const { marshallToVm, invokeFunction } = require('../../utils');
+
+const addJwtShimToContext = async (vm) => {
+  // --- sign ---
+  const _jwtSign = vm.newFunction('sign', function (payload, secret, options, callback) {
+    const nativePayload = vm.dump(payload);
+    const nativeSecret = vm.dump(secret);
+
+    let nativeOptions;
+    let callbackHandle = callback;
+    const optionsType = options === undefined ? 'undefined' : vm.typeof(options);
+    if (optionsType === 'function') {
+      callbackHandle = options;
+      nativeOptions = undefined;
+    } else if (optionsType === 'object' && options !== null) {
+      nativeOptions = vm.dump(options);
+    }
+
+    // If a callback is provided
+    if (callbackHandle && vm.typeof(callbackHandle) === 'function') {
+      let tokenResult;
+      let hostError;
+      try {
+        tokenResult = nativeOptions
+          ? jwt.sign(nativePayload, nativeSecret, nativeOptions)
+          : jwt.sign(nativePayload, nativeSecret);
+      } catch (err) {
+        hostError = err;
+      }
+
+      try {
+        if (hostError) {
+          const errVm = vm.newError(hostError.message || String(hostError));
+          invokeFunction(vm, callbackHandle, [errVm, vm.undefined])
+            .catch((e) => {
+              console.warn('[JWT SHIM][sign.cb] callback invocation error:', e);
+            })
+            .finally(() => {
+              errVm.dispose();
+              callbackHandle.dispose();
+            });
+        } else {
+          const tokenVm = marshallToVm(String(tokenResult), vm);
+          invokeFunction(vm, callbackHandle, [vm.null, tokenVm])
+            .catch((e) => {
+              console.warn('[JWT SHIM][sign.cb] callback invocation error:', e);
+            })
+            .finally(() => {
+              tokenVm.dispose();
+              callbackHandle.dispose();
+            });
+        }
+      } catch (e) {
+        console.warn('[JWT SHIM][sign.cb] unexpected error:', e);
+        callbackHandle.dispose();
+      }
+
+      return vm.undefined;
+    }
+
+    try {
+      const token = nativeOptions
+        ? jwt.sign(nativePayload, nativeSecret, nativeOptions)
+        : jwt.sign(nativePayload, nativeSecret);
+      return marshallToVm(token, vm);
+    } catch (err) {
+      throw vm.newError(err.message || String(err));
+    }
+  });
+
+  vm.setProp(vm.global, '__bruno__jwt__sign', _jwtSign);
+  _jwtSign.dispose();
+
+  // --- verify ---
+  const _jwtVerify = vm.newFunction('verify', function (token, secret, options, callback) {
+    const nativeToken = vm.dump(token);
+    const nativeSecret = vm.dump(secret);
+
+    let nativeOptions;
+    let actualCallback = callback;
+
+    const optionsType = options === undefined ? 'undefined' : vm.typeof(options);
+    if (optionsType === 'function') {
+      actualCallback = options;
+      nativeOptions = undefined;
+    } else if (optionsType === 'object' && options !== null) {
+      nativeOptions = vm.dump(options);
+    }
+
+    if (actualCallback && vm.typeof(actualCallback) === 'function') {
+      let decodedResult;
+      let hostError;
+      try {
+        decodedResult = nativeOptions
+          ? jwt.verify(nativeToken, nativeSecret, nativeOptions)
+          : jwt.verify(nativeToken, nativeSecret);
+      } catch (err) {
+        hostError = err;
+      }
+
+      try {
+        if (hostError) {
+          const vmErr = vm.newError(hostError.message || String(hostError));
+          invokeFunction(vm, actualCallback, [vmErr, vm.undefined])
+            .catch((e) => {
+              console.warn('[JWT SHIM][verify.cb] callback invocation error:', e);
+            })
+            .finally(() => {
+              vmErr.dispose();
+              actualCallback.dispose();
+            });
+        } else {
+          const vmNull = vm.null;
+          const vmDecoded = marshallToVm(decodedResult, vm);
+          invokeFunction(vm, actualCallback, [vmNull, vmDecoded])
+            .catch((e) => {
+              console.warn('[JWT SHIM][verify.cb] callback invocation error:', e);
+            })
+            .finally(() => {
+              vmDecoded.dispose();
+              actualCallback.dispose();
+            });
+        }
+      } catch (e) {
+        console.warn('[JWT SHIM][verify.cb] unexpected error:', e);
+        actualCallback.dispose();
+      }
+
+      return vm.undefined;
+    }
+
+    try {
+      const decoded = nativeOptions
+        ? jwt.verify(nativeToken, nativeSecret, nativeOptions)
+        : jwt.verify(nativeToken, nativeSecret);
+      return marshallToVm(decoded, vm);
+    } catch (err) {
+      throw vm.newError(err.message || String(err));
+    }
+  });
+
+  vm.setProp(vm.global, '__bruno__jwt__verify', _jwtVerify);
+  _jwtVerify.dispose();
+
+  // --- decode ---
+  const _jwtDecode = vm.newFunction('decode', function (token, options) {
+    const nativeToken = vm.dump(token);
+
+    let nativeOptions;
+    const optionsType = options === undefined ? 'undefined' : vm.typeof(options);
+    if (optionsType === 'object' && options !== null) {
+      nativeOptions = vm.dump(options);
+    }
+
+    try {
+      const decoded = nativeOptions
+        ? jwt.decode(nativeToken, nativeOptions)
+        : jwt.decode(nativeToken);
+      return marshallToVm(decoded, vm);
+    } catch (err) {
+      throw vm.newError(err.message || String(err));
+    }
+  });
+
+  vm.setProp(vm.global, '__bruno__jwt__decode', _jwtDecode);
+  _jwtDecode.dispose();
+
+  vm.evalCode(`
+    globalThis.jwt = {};
+    globalThis.jwt.sign = globalThis.__bruno__jwt__sign;
+    globalThis.jwt.verify = globalThis.__bruno__jwt__verify;
+    globalThis.jwt.decode = globalThis.__bruno__jwt__decode;
+    globalThis.requireObject = {
+      ...globalThis.requireObject,
+      'jsonwebtoken': globalThis.jwt,
+    };
+  `);
+};
+
+module.exports = addJwtShimToContext;

package/src/sandbox/quickjs/utils/index.js

@@ -30,6 +30,54 @@ const marshallToVm = (value, vm) => {
   }
 };
 
+/**
+ * Invokes a QuickJS function handle.
+ * - Returns a Promise
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {QuickJSHandle} quickFn - A QuickJS function handle
+ * @param {Array} args - Arguments to pass to the function
+ * @returns {Promise<any>} - The result as a Promise
+ */
+async function invokeFunction(vm, quickFn, args = []) {
+  if (vm.typeof(quickFn) !== 'function') {
+    throw new TypeError('Target is not a QuickJS function');
+  }
+
+  const result = vm.callFunction(quickFn, vm.global, ...args);
+
+  if (result.error) {
+    const error = vm.dump(result.error);
+    result.error.dispose();
+    throw error;
+  }
+
+  // Check if the result is a QuickJS Promise handle (async functions)
+  if (vm.typeof(result.value) === 'object' && result.value.constructor && vm.typeof(result.value.constructor) === 'function') {
+    try {
+      const promiseHandle = vm.unwrapResult(result);
+      const resolvedResult = await vm.resolvePromise(promiseHandle);
+      promiseHandle.dispose();
+      const resolvedHandle = vm.unwrapResult(resolvedResult);
+      const value = vm.dump(resolvedHandle);
+      resolvedHandle.dispose();
+      return Promise.resolve(value);
+    } catch (promiseError) {
+      // If it's not a valid Promise, throw an error
+      result.value.dispose();
+      throw new Error(`Invalid Promise handle: ${promiseError.message}`);
+    }
+  }
+
+  const value = vm.dump(result.value);
+  result.value.dispose();
+
+  return (value && typeof value.then === 'function')
+    ? value
+    : Promise.resolve(value);
+}
+
 module.exports = {
-  marshallToVm
+  marshallToVm,
+  invokeFunction
 };

package/src/utils.js

@@ -137,10 +137,58 @@ const createResponseParser = (response = {}) => {
  *    Remove the cleanJson fix and execute the below post response script
  *    bru.setVar("a", {b:3});
  * Todo: Find a better fix
+ *
+ * serializes typedArrays by using Buffer to handle most binary cases
+ * // TODO: reaper, replace with `devalue` after evaluating all cases, current setup is
+ * more of a hotfix
  */
 const cleanJson = (data) => {
+  const typedArrays = [
+    // Baseline typed arrays
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array,
+
+    // Baseline 2025 Newly available
+    'Float16Array' in globalThis ? globalThis['Float16Array'] : null
+  ].filter(Boolean);
+  const binaryNames = typedArrays.map((d) => d.name);
+
+  const replacer = (key, value) => {
+    const isBinary = typedArrays.find((d) => value instanceof d);
+    if (isBinary) {
+      return {
+        __cleanJSONType: isBinary.name,
+        __cleanJSONValue: Buffer.from(value.buffer).toJSON()
+      };
+    }
+    return value;
+  };
+
+  const reviver = (key, value) => {
+    if (typeof value !== 'object' || value === null) {
+      return value;
+    }
+    if ('__cleanJSONType' in value && '__cleanJSONValue' in value) {
+      const matchedName = binaryNames.find((d) => value.__cleanJSONType === d);
+      if (!matchedName) return value;
+      const binConstructor = typedArrays.find((d) => d.name === matchedName);
+
+      return binConstructor.from(Buffer.from(value.__cleanJSONValue));
+    }
+    return value;
+  };
+
   try {
-    return JSON.parse(JSON.stringify(data));
+    return JSON.parse(JSON.stringify(data, replacer), reviver);
   } catch (e) {
     return data;
   }