@usebruno/js 0.51.0 → 0.52.0

package/src/sandbox/quickjs/index.js

@@ -2,11 +2,28 @@ const addBruShimToContext = require('./shims/bru');
 const addBrunoRequestShimToContext = require('./shims/bruno-request');
 const addConsoleShimToContext = require('./shims/console');
 const addBrunoResponseShimToContext = require('./shims/bruno-response');
+const addBrunoGrpcShimToContext = require('./shims/bruno-grpc');
 const addTestShimToContext = require('./shims/test');
 const addLibraryShimsToContext = require('./shims/lib');
 const addLocalModuleLoaderShimToContext = require('./shims/local-module');
 const { getRequireCode } = require('./shims/require');
-const { newQuickJSWASMModule, memoizePromiseFactory } = require('quickjs-emscripten');
+const { newQuickJSWASMModuleFromVariant, newVariant, RELEASE_SYNC } = require('quickjs-emscripten');
+
+// The engine prints its dispose-abort assertion to stderr on its own. Swallow
+// that line on the CLI, where stderr is the user's screen and a handled trap
+// would read as a crash; keep it in the app, whose console is not user facing.
+const isElectronHost = Boolean(process.versions.electron);
+const isContainedAbortLine = (line) =>
+  String(line).includes('list_empty(&rt->gc_obj_list)') && String(line).includes('JS_FreeRuntime');
+const quietEngineVariant = newVariant(RELEASE_SYNC, {
+  emscriptenModule: {
+    printErr: (line) => {
+      if (isElectronHost || !isContainedAbortLine(line)) {
+        console.error(line);
+      }
+    }
+  }
+});
 
 // execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
 const getBundledCode = require('../bundle-browser-rollup');
@@ -16,8 +33,54 @@ const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
 const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
 let QuickJSModule;
-const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
-loader().then((mod) => (QuickJSModule = mod));
+let quickJSModulePromise;
+let quickJSModuleLoading = false;
+let quickJSModuleRecycleCount = 0;
+
+// Memoized WASM module for sync + async. reload swaps with no gap; failed
+// reload restores the old memo, failed initial load clears it.
+const loader = ({ reload = false } = {}) => {
+  if (!quickJSModulePromise || (reload && !quickJSModuleLoading)) {
+    const previousPromise = quickJSModulePromise;
+    quickJSModuleLoading = true;
+    quickJSModulePromise = newQuickJSWASMModuleFromVariant(quietEngineVariant)
+      .then((mod) => {
+        QuickJSModule = mod;
+        return mod;
+      })
+      .catch((loadError) => {
+        console.error(reload ? 'QuickJS module reload failed' : 'QuickJS module load failed', loadError);
+        quickJSModulePromise = reload ? previousPromise : null;
+        if (quickJSModulePromise) {
+          return quickJSModulePromise;
+        }
+        throw loadError;
+      })
+      .finally(() => {
+        quickJSModuleLoading = false;
+      });
+  }
+  return quickJSModulePromise;
+};
+loader().catch(() => {});
+
+// On dispose WASM trap, recycle the module (old one keeps serving until ready).
+const recycleQuickJSModuleOnAbort = (teardownError, ownerModule) => {
+  if (!(teardownError instanceof WebAssembly.RuntimeError)) {
+    return false;
+  }
+  // Skip if this module was already replaced.
+  if (!ownerModule || ownerModule === QuickJSModule) {
+    quickJSModuleRecycleCount += 1;
+    console.warn(
+      quickJSModuleRecycleCount === 1
+        ? 'QuickJS engine crashed during cleanup and was replaced; the run was not affected'
+        : `QuickJS engine replaced again (${quickJSModuleRecycleCount} this session)`
+    );
+    loader({ reload: true }).catch(() => {});
+  }
+  return true;
+};
 
 const toNumber = (value) => {
   const num = Number(value);
@@ -57,8 +120,9 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
     externalScript = removeQuotes(externalScript);
   }
   let managedQuickJsContext;
+  const quickJsModule = QuickJSModule;
   try {
-    managedQuickJsContext = createManagedQuickJsContext(QuickJSModule);
+    managedQuickJsContext = createManagedQuickJsContext(quickJsModule);
     const vm = managedQuickJsContext.vm;
     const { bru, req, res, ...variables } = externalContext;
 
@@ -88,7 +152,13 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
   } catch (error) {
     console.error('Error executing the script!', error);
   } finally {
-    managedQuickJsContext?.dispose();
+    try {
+      managedQuickJsContext?.dispose();
+    } catch (teardownError) {
+      if (!recycleQuickJSModuleOnAbort(teardownError, quickJsModule)) {
+        console.error('Error disposing QuickJS context', teardownError);
+      }
+    }
   }
 };
 
@@ -99,9 +169,11 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
   externalScript = externalScript?.trim();
 
   let managedQuickJsContext;
+  let scriptError;
+  let quickJsModule;
   try {
-    const module = await loader();
-    managedQuickJsContext = createManagedQuickJsContext(module);
+    quickJsModule = await loader();
+    managedQuickJsContext = createManagedQuickJsContext(quickJsModule);
     const vm = managedQuickJsContext.vm;
 
     // add crypto utilities required by the crypto-js library in bundledCode
@@ -120,6 +192,7 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
     consoleFn && addConsoleShimToContext(vm, consoleFn);
     bru && addBruShimToContext(vm, bru);
+    bru?.grpc && addBrunoGrpcShimToContext(vm, bru.grpc);
     req && addBrunoRequestShimToContext(vm, req);
     res && addBrunoResponseShimToContext(vm, res);
     addLocalModuleLoaderShimToContext(vm, collectionPath);
@@ -137,22 +210,33 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
     promiseHandle.dispose();
     const resolvedHandle = vm.unwrapResult(resolvedResult);
     resolvedHandle.dispose();
-    return;
   } catch (error) {
     error.__isQuickJS = true;
-    throw error;
-  } finally {
-    // Wait for any in-flight async work (sendRequest, axios, cookie jar, timers,
-    // un-awaited promises) to settle before tearing down the VM. Disposing while
-    // a deferred is still pending lets its later host callback touch a freed
-    // context, throwing `QuickJSUseAfterFree`.
+    scriptError = error;
+  }
+
+  // The run waits for every pending deferred before returning: un-awaited
+  // async work is the user's choice, and the run is not done until it is.
+  // The wait is unbounded by design; cancelling the request is the way out.
+  if (managedQuickJsContext) {
+    // No try/catch: every awaited settle promise is pre-caught at creation
+    // (trackPendingDeferreds), so this await cannot reject and skip dispose.
+    await managedQuickJsContext.waitForPendingDeferreds();
     try {
-      await managedQuickJsContext?.waitForPendingDeferreds?.();
-      managedQuickJsContext?.dispose();
+      managedQuickJsContext.dispose();
     } catch (teardownError) {
-      throw teardownError;
+      const recycled = recycleQuickJSModuleOnAbort(teardownError, quickJsModule);
+      if (!scriptError && !recycled) {
+        scriptError = teardownError;
+      } else if (!recycled) {
+        console.error('Error disposing QuickJS context', teardownError);
+      }
     }
   }
+
+  if (scriptError) {
+    throw scriptError;
+  }
 };
 
 module.exports = {

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

@@ -0,0 +1,29 @@
+const addBrunoGrpcRequestShimToContext = require('./grpc/bruno-grpc-request');
+const addBrunoGrpcResponseShimToContext = require('./grpc/bruno-grpc-response');
+
+/**
+ * Installs `bru.grpc` onto the `bru` object the bru shim has already put on the global, so it has
+ * to run after it.
+ */
+const addBrunoGrpcShimToContext = (vm, grpc) => {
+  const bruObject = vm.getProp(vm.global, 'bru');
+  const grpcObject = vm.newObject();
+
+  const { evalCode: requestEvalCode } = addBrunoGrpcRequestShimToContext(vm, grpc.request, grpcObject);
+  // `response` is absent in `beforeCallStart`, which has no response yet.
+  const { evalCode: responseEvalCode } = grpc.response
+    ? addBrunoGrpcResponseShimToContext(vm, grpc.response, grpcObject)
+    : { evalCode: [] };
+
+  vm.setProp(bruObject, 'grpc', grpcObject);
+  grpcObject.dispose();
+  bruObject.dispose();
+
+  // The list code reaches its target through `globalThis.bru.grpc`, so it can only run now that
+  // `grpc` is on `bru`. Each block is braced on its own — every bridge declares the same consts.
+  for (const code of [...requestEvalCode, ...responseEvalCode].filter(Boolean)) {
+    vm.evalCode(`{ ${code} }`);
+  }
+};
+
+module.exports = addBrunoGrpcShimToContext;

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

@@ -0,0 +1,47 @@
+const { marshallToVm } = require('../../utils');
+const addGrpcMetadataListShimToContext = require('./grpc-metadata-list');
+const addGrpcMessageListShimToContext = require('./grpc-message-list');
+
+// Keep this in step with BrunoGrpcRequest.
+const addBrunoGrpcRequestShimToContext = (vm, request, grpcObject) => {
+  const requestObject = vm.newObject();
+
+  const scalars = ['url', 'method', 'methodType', 'authMode', 'protoPath', 'name'];
+
+  for (const property of scalars) {
+    const value = marshallToVm(request[property], vm);
+    vm.setProp(requestObject, property, value);
+    value.dispose();
+  }
+
+  // request.metadata — writable in `beforeCallStart`, read-only in `afterCallEnd`
+  const metadataEvalCode = addGrpcMetadataListShimToContext(
+    vm,
+    request.metadata,
+    requestObject,
+    'metadata',
+    'globalThis.bru.grpc.request'
+  );
+
+  // request.messages — the messages the call sent, read-only, and empty until it has sent any
+  const messagesEvalCode = addGrpcMessageListShimToContext(
+    vm,
+    request.messages,
+    requestObject,
+    'globalThis.bru.grpc.request'
+  );
+
+  // request.message — present only in `beforeMessageSend`.
+  if (request.message) {
+    const message = marshallToVm(request.message, vm);
+    vm.setProp(requestObject, 'message', message);
+    message.dispose();
+  }
+
+  vm.setProp(grpcObject, 'request', requestObject);
+  requestObject.dispose();
+
+  return { evalCode: [metadataEvalCode, messagesEvalCode] };
+};
+
+module.exports = addBrunoGrpcRequestShimToContext;

package/src/sandbox/quickjs/shims/grpc/bruno-grpc-response.js

@@ -0,0 +1,40 @@
+const { marshallToVm } = require('../../utils');
+const addGrpcMetadataListShimToContext = require('./grpc-metadata-list');
+const addGrpcMessageListShimToContext = require('./grpc-message-list');
+
+// Keep this in step with BrunoGrpcResponse.
+const addBrunoGrpcResponseShimToContext = (vm, response, grpcObject) => {
+  const responseObject = vm.newObject();
+
+  // Marshalled once, as on the request: the call is over, so no scalar can change mid-hook.
+  const scalars = ['statusCode', 'statusText', 'duration'];
+
+  for (const property of scalars) {
+    const value = marshallToVm(response?.[property], vm);
+    vm.setProp(responseObject, property, value);
+    value.dispose();
+  }
+
+  // response.metadata / .trailers / .messages — the same lists `bru.grpc.request` gets, read-only here
+  const listEvalCode = ['metadata', 'trailers'].map((property) =>
+    addGrpcMetadataListShimToContext(vm, response[property], responseObject, property, 'globalThis.bru.grpc.response')
+  );
+
+  listEvalCode.push(
+    addGrpcMessageListShimToContext(vm, response.messages, responseObject, 'globalThis.bru.grpc.response')
+  );
+
+  // response.message — present only in `afterMessageReceive`
+  if (response.message) {
+    const message = marshallToVm(response.message, vm);
+    vm.setProp(responseObject, 'message', message);
+    message.dispose();
+  }
+
+  vm.setProp(grpcObject, 'response', responseObject);
+  responseObject.dispose();
+
+  return { evalCode: listEvalCode };
+};
+
+module.exports = addBrunoGrpcResponseShimToContext;

package/src/sandbox/quickjs/shims/grpc/grpc-message-list.js

@@ -0,0 +1,29 @@
+const { createPropertyListBridge } = require('../../utils/property-list-bridge');
+
+/**
+ * Bridges a GrpcMessageList — `bru.grpc.request.messages`, `bru.grpc.response.messages`
+ * — onto a VM object. Keep in sync with GrpcMessageList
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} list - The native GrpcMessageList
+ * @param {Object} targetObject - VM object handle the list is attached to
+ * @param {string} objectPath - Path to `targetObject` in the VM, e.g. `globalThis.bru.grpc.request`
+ * @returns {string} Code the caller must eval once `objectPath` resolves
+ */
+const addGrpcMessageListShimToContext = (vm, list, targetObject, objectPath) => {
+  const listObject = vm.newObject();
+
+  const { evalCode } = createPropertyListBridge(vm, list, listObject, {
+    globalPath: `${objectPath}.messages`,
+    syncReadMethods: ['count'],
+    syncReadObjectMethods: ['get', 'all', 'toJSON'],
+    withIterators: true
+  });
+
+  vm.setProp(targetObject, 'messages', listObject);
+  listObject.dispose();
+
+  return evalCode;
+};
+
+module.exports = addGrpcMessageListShimToContext;

package/src/sandbox/quickjs/shims/grpc/grpc-metadata-list.js

@@ -0,0 +1,31 @@
+const { createPropertyListBridge } = require('../../utils/property-list-bridge');
+
+/**
+ * Bridges a GrpcMetadataList — `bru.grpc.request.metadata`, `bru.grpc.response.metadata`,
+ * `bru.grpc.response.trailers` — onto a VM object. Keep in sync with GrpcMetadataList
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} list - The native GrpcMetadataList
+ * @param {Object} targetObject - VM object handle the list is attached to
+ * @param {string} property - Property name on `targetObject`
+ * @param {string} objectPath - Path to `targetObject` in the VM, e.g. `globalThis.bru.grpc.request`
+ * @returns {string} Code the caller must eval once `objectPath` resolves
+ */
+const addGrpcMetadataListShimToContext = (vm, list, targetObject, property, objectPath) => {
+  const listObject = vm.newObject();
+
+  const { evalCode } = createPropertyListBridge(vm, list, listObject, {
+    globalPath: `${objectPath}.${property}`,
+    syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+    syncReadObjectMethods: ['one', 'all', 'toJSON'],
+    syncWriteMethods: ['upsert', 'add', 'remove', 'clear'],
+    withIterators: true
+  });
+
+  vm.setProp(targetObject, property, listObject);
+  listObject.dispose();
+
+  return evalCode;
+};
+
+module.exports = addGrpcMetadataListShimToContext;

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

@@ -8,7 +8,7 @@ const createManagedQuickJsContext = (module) => {
   const vm = module.newContext();
   const disposeTracked = trackQuickJsContext(vm);
   const evalCodeRetained = vm.evalCode.bind(vm);
-  const waitForPendingDeferreds = trackPendingDeferreds(vm);
+  const { waitForPendingDeferreds, disposePendingDeferreds } = trackPendingDeferreds(vm);
 
   vm.evalCode = (code, filename = 'eval.js') => {
     const result = evalCodeRetained(code, filename);
@@ -25,7 +25,7 @@ const createManagedQuickJsContext = (module) => {
   return {
     vm,
     waitForPendingDeferreds,
-    dispose: () => disposeQuickJsContext(vm, disposeTracked)
+    dispose: () => disposeQuickJsContext(vm, disposeTracked, disposePendingDeferreds)
   };
 };
 
@@ -38,27 +38,41 @@ const createManagedQuickJsContext = (module) => {
  * `QuickJSUseAfterFree`. Each `.settled` resolves once the deferred is
  * resolved/rejected, so awaiting them keeps the context alive long enough.
  *
- * The hook is installed now (at context creation) so it captures promises as
- * the script runs. Returns a function that drains the captured deferreds at
- * teardown; new deferreds can be created while we wait (a chained timer), so it
- * drains in place until none remain.
+ * The hook installs at context creation. `waitForPendingDeferreds` drains in
+ * place (waiting can chain new deferreds) with no timeout; `disposePendingDeferreds`
+ * frees unsettled resolve/reject handles, which left alive abort JS_FreeRuntime.
  */
-
 const trackPendingDeferreds = (vm) => {
-  const pendingDeferreds = [];
+  const pendingSettles = [];
+  const deferreds = [];
   const originalNewPromise = vm.newPromise.bind(vm);
   vm.newPromise = (...args) => {
     const deferred = originalNewPromise(...args);
-    pendingDeferreds.push(deferred.settled.catch(() => { }));
+    deferreds.push(deferred);
+    pendingSettles.push(deferred.settled.catch(() => { }));
     return deferred;
   };
 
-  return async () => {
-    while (pendingDeferreds.length) {
-      const batch = pendingDeferreds.splice(0);
+  const waitForPendingDeferreds = async () => {
+    while (pendingSettles.length) {
+      const batch = pendingSettles.splice(0);
       await Promise.all(batch);
     }
   };
+
+  const disposePendingDeferreds = () => {
+    while (deferreds.length) {
+      const deferred = deferreds.pop();
+      if (deferred.alive) {
+        deferred.dispose();
+      }
+    }
+  };
+
+  return {
+    waitForPendingDeferreds,
+    disposePendingDeferreds
+  };
 };
 
 /**
@@ -98,22 +112,18 @@ const trackQuickJsContext = (vm) => {
 };
 
 /**
- * Clears shim globals, drains pending QuickJS jobs, and disposes the context.
- * Pass disposeTracked from trackQuickJsContext() to free shim handles first.
+ * Drains pending QuickJS jobs, frees leftover deferreds and tracked handles,
+ * and disposes the context. Jobs are drained BEFORE the handle flush: a job
+ * can call allocating shims or start new async work, and anything it creates
+ * must still be freed or JS_FreeRuntime aborts on the leftover GC objects.
  */
-const disposeQuickJsContext = (vm, disposeTracked) => {
+const disposeQuickJsContext = (vm, disposeTracked, disposePendingDeferreds) => {
   if (!vm?.alive) {
     return;
   }
 
-  if (typeof disposeTracked === 'function') {
-    disposeTracked();
-  }
-
-  // Drain the runtime's pending job queue (resolved/rejected promise callbacks)
-  // before disposing. Executing a job can schedule more jobs (chained `.then()`s),
-  // so we keep going until `hasPendingJob()` reports the queue is empty or a job
-  // throws.
+  // Executing a job can schedule more jobs (chained `.then()`s), so keep going
+  // until `hasPendingJob()` reports the queue is empty or a job throws.
   while (vm.runtime?.hasPendingJob?.()) {
     const result = vm.runtime.executePendingJobs();
     // On error, dispose the error handle and stop draining.
@@ -122,6 +132,15 @@ const disposeQuickJsContext = (vm, disposeTracked) => {
       break;
     }
   }
+
+  if (typeof disposePendingDeferreds === 'function') {
+    disposePendingDeferreds();
+  }
+
+  if (typeof disposeTracked === 'function') {
+    disposeTracked();
+  }
+
   vm.dispose();
 };
 

package/src/utils/error-formatter.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const YAML = require('yaml');
+const { SCRIPT_TYPES } = require('@usebruno/common');
 const { NODEVM_SCRIPT_WRAPPER_OFFSET, QUICKJS_SCRIPT_WRAPPER_OFFSET } = require('./sandbox');
 
 const posixifyPath = (p) => (p ? p.replace(/\\/g, '/') : p);
@@ -11,17 +12,15 @@ const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml'];
 const isAllowedSourceFile = (filePath) =>
   typeof filePath === 'string' && ALLOWED_SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 
-const SCRIPT_TYPES = Object.freeze({
-  PRE_REQUEST: 'pre-request',
-  POST_RESPONSE: 'post-response',
-  TEST: 'test'
-});
-
 // Bruno script types → OpenCollection YAML script types
 const SCRIPT_TYPE_TO_YML = {
   [SCRIPT_TYPES.PRE_REQUEST]: 'before-request',
   [SCRIPT_TYPES.POST_RESPONSE]: 'after-response',
-  [SCRIPT_TYPES.TEST]: 'tests'
+  [SCRIPT_TYPES.TEST]: 'tests',
+  [SCRIPT_TYPES.BEFORE_CALL_START]: 'grpc:before-call-start',
+  [SCRIPT_TYPES.BEFORE_MESSAGE_SEND]: 'grpc:before-message-send',
+  [SCRIPT_TYPES.AFTER_MESSAGE_RECEIVE]: 'grpc:after-message-receive',
+  [SCRIPT_TYPES.AFTER_CALL_END]: 'grpc:after-call-end'
 };
 
 const readFile = (filePath, cache = null) => {
@@ -38,7 +37,11 @@ const readFile = (filePath, cache = null) => {
 const BLOCK_PATTERNS = {
   [SCRIPT_TYPES.PRE_REQUEST]: /^script:pre-request\s*\{/,
   [SCRIPT_TYPES.POST_RESPONSE]: /^script:post-response\s*\{/,
-  [SCRIPT_TYPES.TEST]: /^tests\s*\{/
+  [SCRIPT_TYPES.TEST]: /^tests\s*\{/,
+  [SCRIPT_TYPES.BEFORE_CALL_START]: /^script:grpc:before-call-start\s*\{/,
+  [SCRIPT_TYPES.BEFORE_MESSAGE_SEND]: /^script:grpc:before-message-send\s*\{/,
+  [SCRIPT_TYPES.AFTER_MESSAGE_RECEIVE]: /^script:grpc:after-message-receive\s*\{/,
+  [SCRIPT_TYPES.AFTER_CALL_END]: /^script:grpc:after-call-end\s*\{/
 };
 
 /** Find the 1-indexed line where a script block's content starts in a .bru file */
@@ -747,5 +750,6 @@ module.exports = {
   findYmlScriptBlockStartLine,
   findYmlScriptBlockEndLine,
   adjustStackTrace,
-  getErrorTypeName
+  getErrorTypeName,
+  posixifyPath
 };