Add support for running initialization scripts before content (#222)

This adds the ability to run  a script in a separate global before content gets run. This code has access to additional abilities, notably including the `defineBuiltinModule` function.

Building on this will allow us to change ComponentizeJS to support content using imports from `wasi:package-name` module names without rewriting the code first. That in turn will enable support for non-bundled content code.

Author: tschneidereit

componentize.sh.in

@@ -9,9 +9,11 @@ aot=@AOT@
 preopen_dir="${PREOPEN_DIR:-}"
 
 usage() {
-  echo "Usage: $(basename "$0")  [--verbose] [--legacy-script] [input.js] [-o output.wasm]"
+  echo "Usage: $(basename "$0")  [--verbose] [-i,--initializer-script-path] [--legacy-script] [input.js] [-o output.wasm]"
   echo "       Providing an input file but no output uses the input base name with a .wasm extension"
   echo "       Providing an output file but no input creates a component without running any top-level script"
+  echo "       Specifying '--verbose' causes the detailed output during initialization and execution"
+  echo "       Specifying '-i' or '--initializer-script-path' allows specifying an initializer script"
   echo "       Specifying '--legacy-script' causes evaluation as a legacy JS script instead of a module"
   exit 1
 }
@@ -24,6 +26,7 @@ fi
 IN_FILE=""
 OUT_FILE=""
 LEGACY_SCRIPT_PARAM=""
+STARLING_ARGS=""
 VERBOSE=0
 
 while [ $# -gt 0 ]
@@ -38,7 +41,12 @@ do
             OUT_FILE="$2"
             shift 2
             ;;
+        -i|--initializer-script-path)
+            STARLING_ARGS="$STARLING_ARGS $1 $2"
+            shift 2
+            ;;
         -v|--verbose)
+            STARLING_ARGS="$1 $STARLING_ARGS"
             VERBOSE=1
             shift
             ;;
@@ -76,9 +84,8 @@ if [[ -n "$IN_FILE" ]]; then
   fi
   echo "Componentizing $IN_FILE into $OUT_FILE"
 
-  STARLING_ARGS="$LEGACY_SCRIPT_PARAM$IN_FILE"
+  STARLING_ARGS="$STARLING_ARGS $LEGACY_SCRIPT_PARAM$IN_FILE"
   if [[ $VERBOSE -ne 0 ]]; then
-      STARLING_ARGS="--verbose $STARLING_ARGS"
       echo "Componentizing with args $STARLING_ARGS"
   fi
 

include/config-parser.h

@@ -77,6 +77,12 @@ class ConfigParser {
           config_->content_script_path.reset();
           i++;
         }
+      }
+      if (args[i] == "-i" || args[i] == "--initializer-script-path") {
+        if (i + 1 < args.size()) {
+          config_->initializer_script_path = mozilla::Some(args[i + 1]);
+          i++;
+        }
       } else if (args[i] == "-v" || args[i] == "--verbose") {
         config_->verbose = true;
       } else if (args[i] == "-d" || args[i] == "--enable-script-debugging") {

include/extension-api.h

@@ -35,10 +35,19 @@ namespace api {
 class AsyncTask;
 
 struct EngineConfig {
-  mozilla::Maybe<std::string> content_script_path;
-  mozilla::Maybe<std::string> content_script;
+  mozilla::Maybe<std::string> content_script_path = mozilla::Nothing();
+  mozilla::Maybe<std::string> content_script = mozilla::Nothing();
   bool module_mode = true;
 
+  /**
+   * Path to the script to evaluate before the content script.
+   *
+   * This script is evaluated in a separate global and has access to functions not
+   * available to content. It can be used to set up the environment for the content
+   * script, e.g. by registering builtin modules or adding global properties.
+   */
+  mozilla::Maybe<std::string> initializer_script_path = mozilla::Nothing();
+
   /**
    * Whether to evaluate the top-level script in pre-initialization mode or not.
    *
@@ -102,6 +111,15 @@ class Engine {
   bool eval_toplevel(JS::SourceText<mozilla::Utf8Unit> &source, const char *path,
                      MutableHandleValue result);
 
+  /**
+   * Run the script set using the `-i | --initializer-script-path` option.
+   *
+   * This script runs in a separate global, and has access to functions not
+   * available to content. Notably, that includes the ability to define
+   * builtin modules, using the `defineBuiltinModule` function.
+   */
+  bool run_initialization_script();
+
   /**
    * Run the async event loop as long as there's interest registered in keeping it running.
    *

runtime/debugger.cpp

@@ -35,7 +35,7 @@ static bool print_location(JSContext *cx, FILE *fp = stdout) {
   return true;
 }
 
-static bool dbg_print(JSContext *cx, unsigned argc, Value *vp) {
+bool content_debugger::dbg_print(JSContext *cx, unsigned argc, Value *vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   if (!print_location(cx)) {
@@ -231,7 +231,7 @@ bool initialize_debugger(JSContext *cx, uint16_t port, bool content_already_init
   }
 
   if (!JS_DefineFunction(cx, global, "setContentPath", dbg_set_content_path, 1, 0) ||
-      !JS_DefineFunction(cx, global, "print", dbg_print, 1, 0) ||
+      !JS_DefineFunction(cx, global, "print", content_debugger::dbg_print, 1, 0) ||
       !JS_DefineFunction(cx, global, "assert", dbg_assert, 1, 0)) {
     return false;
   }

runtime/debugger.h

@@ -24,6 +24,8 @@ namespace content_debugger {
    * @return the path to the replacement script, if any
    */
   mozilla::Maybe<std::string_view> replacement_script_path();
+
+  bool dbg_print(JSContext *cx, unsigned argc, Value *vp);
 } // namespace content_debugger
 
 #endif // DEBUGGER_H

runtime/engine.cpp

@@ -425,6 +425,12 @@ Engine::Engine(std::unique_ptr<EngineConfig> config) {
   }
 #endif
 
+  if (config_->initializer_script_path) {
+    if (!run_initialization_script()) {
+      abort("running initialization script");
+    }
+  }
+
   TRACE("Module mode: " << config_->module_mode);
   scriptLoader->enable_module_mode(config_->module_mode);
 
@@ -493,9 +499,67 @@ void Engine::abort(const char *reason) {
 }
 
 bool Engine::define_builtin_module(const char* id, HandleValue builtin) {
+  TRACE("Defining builtin module '" << id << "'");
   return scriptLoader->define_builtin_module(id, builtin);
 }
 
+static bool define_builtin_module(JSContext *cx, unsigned argc, Value *vp) {
+  CallArgs args = CallArgsFromVp(argc, vp);
+  auto name = core::encode(cx, args.get(0));
+  if (!name) {
+    return false;
+  }
+  if (!args.get(1).isObject()) {
+    JS_ReportErrorUTF8(cx, "Second argument to defineBuiltinModule must be an object");
+    return false;
+  }
+  if (!Engine::get(cx)->define_builtin_module(name.ptr.get(), args.get(1))) {
+    return false;
+  }
+
+  args.rval().setUndefined();
+  return true;
+}
+
+bool Engine::run_initialization_script() {
+  auto cx = this->cx();
+
+  JS::RealmOptions options;
+  options.creationOptions()
+      .setStreamsEnabled(true)
+      .setExistingCompartment(this->global());
+
+  static JSClass global_class = {"global", JSCLASS_GLOBAL_FLAGS, &JS::DefaultGlobalClassOps};
+  RootedObject global(cx);
+  global = JS_NewGlobalObject(cx, &global_class, nullptr, JS::DontFireOnNewGlobalHook, options);
+  if (!global) {
+    return false;
+  }
+
+  JSAutoRealm ar(cx, global);
+
+  if (!JS_DefineFunction(cx, global, "defineBuiltinModule", ::define_builtin_module, 2, 0) ||
+      !JS_DefineFunction(cx, global, "print", content_debugger::dbg_print, 1, 0)) {
+    return false;
+  }
+
+  auto path = config_->initializer_script_path.value();
+  TRACE("Running initialization script from file " << path);
+  JS::SourceText<mozilla::Utf8Unit> source;
+  if (!scriptLoader->load_resolved_script(CONTEXT, path.c_str(), path.c_str(), source)) {
+    return false;
+  }
+  auto opts = new JS::CompileOptions(cx);
+  opts->setDiscardSource();
+  opts->setFile(path.c_str());
+  JS::RootedScript script(cx, Compile(cx, *opts, source));
+  if (!script) {
+    return false;
+  }
+  RootedValue result(cx);
+  return JS_ExecuteScript(cx, script, &result);
+}
+
 bool Engine::eval_toplevel(JS::SourceText<mozilla::Utf8Unit> &source, const char *path,
                            MutableHandleValue result) {
   MOZ_ASSERT(state() > EngineState::EngineInitializing, "Engine must be done initializing");

runtime/script_loader.cpp

@@ -132,9 +132,6 @@ static const char* resolve_path(const char* path, const char* base, size_t base_
   return resolve_extension(resolved_path);
 }
 
-static bool load_script(JSContext *cx, const char *script_path, const char* resolved_path,
-                        JS::SourceText<mozilla::Utf8Unit> &script);
-
 static JSObject* get_module(JSContext* cx, JS::SourceText<mozilla::Utf8Unit> &source,
                             const char* resolved_path, const JS::CompileOptions &opts) {
   RootedObject module(cx, JS::CompileModule(cx, opts, source));
@@ -185,7 +182,7 @@ static JSObject* get_module(JSContext* cx, const char* specifier, const char* re
   }
 
   JS::SourceText<mozilla::Utf8Unit> source;
-  if (!load_script(cx, specifier, resolved_path, source)) {
+  if (!SCRIPT_LOADER->load_resolved_script(cx, specifier, resolved_path, source)) {
     return nullptr;
   }
 
@@ -387,8 +384,9 @@ void ScriptLoader::enable_module_mode(bool enable) {
   MODULE_MODE = enable;
 }
 
-static bool load_script(JSContext *cx, const char *specifier, const char* resolved_path,
-                               JS::SourceText<mozilla::Utf8Unit> &script) {
+bool ScriptLoader::load_resolved_script(JSContext *cx, const char *specifier,
+                                        const char* resolved_path,
+                                        JS::SourceText<mozilla::Utf8Unit> &script) {
   FILE *file = fopen(resolved_path, "r");
   if (!file) {
     std::cerr << "Error opening file " << specifier << " (resolved to " << resolved_path << "): "
@@ -442,7 +440,7 @@ bool ScriptLoader::load_script(JSContext *cx, const char *script_path,
     resolved_path = resolve_path(script_path, BASE_PATH, strlen(BASE_PATH));
   }
 
-  return ::load_script(cx, script_path, resolved_path, script);
+  return load_resolved_script(cx, script_path, resolved_path, script);
 }
 
 bool ScriptLoader::eval_top_level_script(const char *path, JS::SourceText<mozilla::Utf8Unit> &source,

runtime/script_loader.h

@@ -22,6 +22,15 @@ class ScriptLoader {
   bool eval_top_level_script(const char *path, JS::SourceText<mozilla::Utf8Unit> &source,
                              MutableHandleValue result, MutableHandleValue tla_promise);
   bool load_script(JSContext* cx, const char *script_path, JS::SourceText<mozilla::Utf8Unit> &script);
+
+  /**
+   * Load a script without attempting to resolve its path relative to a base path.
+   *
+   * This is useful for loading ancillary scripts without interfering with, or depending on,
+   * the script loader's state as determined by loading and running content scripts.
+   */
+  bool load_resolved_script(JSContext *cx, const char *specifier, const char *resolved_path,
+                            JS::SourceText<mozilla::Utf8Unit> &script);
 };
 
 #endif //SCRIPTLOADER_H

tests/e2e/init-script/expect_serve_stdout.txt

@@ -0,0 +1 @@
+stdout [0] :: Log: foo

tests/e2e/init-script/init-script.js

@@ -0,0 +1,8 @@
+import { func } from "builtinMod";
+async function handle(event) {
+  console.log(func());
+  return new Response(func());
+}
+
+//@ts-ignore
+addEventListener('fetch', (event) => { event.respondWith(handle(event)) });