Add support for setting initialization-time script location (#278)

This adds an `--init-location` CLI arg that can be used to set a location for use during wizening. This is meant to enable working around issues with libraries that use `globalThis.location` during top-level evaluation.

An example of a library that does this, and is used as a dependency in a number of projects, is [cfworker](https://github.com/cfworker/cfworker/blob/b9a093a54ba81ef58960cb43574169df021ecc70/packages/json-schema/src/dereference.ts#L68-L75).

The location will not be used for anything runtime-internal. Specifically, it'll not be used to resolve relative paths for module loading purposes or file handling in general.

This also adds some needed test infrastructure and two tests: one for trying to use `globalThis.location` in top-level code without using `--init-location`, and another for successfully using it with the arg.

Author: tschneidereit

builtins/web/worker-location.cpp

@@ -12,14 +12,35 @@ namespace builtins::web::worker_location {
 
 JS::PersistentRooted<JSObject *> WorkerLocation::url;
 
+namespace {
+DEF_ERR(LocationNotSetError, JSEXN_TYPEERR, "{0} can only be used during request handling, "
+                                            "or if an initialization-time location was set "
+                                            "using `--init-location`", 1)
+bool ensure_location_access(JSContext *cx, const char *name) {
+  auto *engine = api::Engine::get(cx);
+
+  if (engine->state() == api::EngineState::Initialized) {
+    return true;
+  }
+
+  if (engine->state() == api::EngineState::ScriptPreInitializing && WorkerLocation::url.get()) {
+    return true;
+  }
+
+  return api::throw_error(cx, LocationNotSetError, name);
+}
+} // namespace
+
 #define WorkerLocation_ACCESSOR_GET(field)                                                         \
   bool field##_get(JSContext *cx, unsigned argc, JS::Value *vp) {                                  \
     auto result = WorkerLocation::MethodHeaderWithName(0, cx, argc, vp, __func__);                 \
     if (result.isErr()) {                                                                          \
       return false;                                                                                \
     }                                                                                              \
     auto [args, self] = result.unwrap();                                                           \
-    REQUEST_HANDLER_ONLY("location." #field)                                                       \
+    if (!ensure_location_access(cx, "location." #field)) {                                         \
+      return false;                                                                                \
+    }                                                                                              \
     return url::URL::field(cx, WorkerLocation::url, args.rval());                                  \
   }
 
@@ -80,7 +101,28 @@ bool WorkerLocation::init_class(JSContext *cx, JS::HandleObject global) {
 }
 
 bool install(api::Engine *engine) {
-  return WorkerLocation::init_class(engine->cx(), engine->global());
+  if (!WorkerLocation::init_class(engine->cx(), engine->global())) {
+    return false;
+  }
+
+  const auto &init_location = engine->init_location();
+  if (init_location) {
+    // Set the URL for `globalThis.location` to the configured value.
+    JSContext *cx = engine->cx();
+    JS::RootedObject url_instance(
+        cx, JS_NewObjectWithGivenProto(cx, &url::URL::class_, url::URL::proto_obj));
+    if (!url_instance) {
+      return false;
+    }
+
+    auto *uri_bytes = new uint8_t[init_location->size() + 1];
+    std::copy(init_location->begin(), init_location->end(), uri_bytes);
+    jsurl::SpecString spec(uri_bytes, init_location->size(), init_location->size());
+
+    WorkerLocation::url = url::URL::create(cx, url_instance, spec);
+  }
+
+  return true;
 }
 
 } // namespace builtins::web::worker_location

componentize.sh.in

@@ -17,6 +17,7 @@ usage() {
   echo "       Specifying '--strip-path-prefix' will cause the provided prefix to be stripped from paths in stack traces and the debugger"
   echo "       Specifying '--legacy-script' causes evaluation as a legacy JS script instead of a module"
   echo "       Specifying '--wpt-mode' enables WPT compatibility mode"
+  echo "       Specifying '--init-location url' allows setting the URL to use for 'globalThis.location' during initialization"
   exit 1
 }
 
@@ -55,6 +56,10 @@ do
             STARLING_ARGS="$STARLING_ARGS $1 $2"
             shift 2
             ;;
+          --init-location)
+            STARLING_ARGS="$STARLING_ARGS $1 $2"
+            shift 2
+            ;;
         -v|--verbose)
             STARLING_ARGS="$1 $STARLING_ARGS"
             VERBOSE=1

include/config-parser.h

@@ -99,6 +99,11 @@ class ConfigParser {
         }
       } else if (args[i] == "--wpt-mode") {
         config_->wpt_mode = true;
+      } else if (args[i] == "--init-location") {
+        if (i + 1 < args.size()) {
+          config_->init_location = mozilla::Some(args[i + 1]);
+          i++;
+        }
       } else if (args[i].starts_with("--")) {
         std::cerr << "Unknown option: " << args[i] << std::endl;
         exit(1);

include/extension-api.h

@@ -32,6 +32,7 @@ struct EngineConfig {
   mozilla::Maybe<std::string> content_script_path = mozilla::Nothing();
   mozilla::Maybe<std::string> content_script = mozilla::Nothing();
   mozilla::Maybe<std::string> path_prefix = mozilla::Nothing();
+  mozilla::Maybe<std::string> init_location = mozilla::Nothing();
   bool module_mode = true;
 
   /**
@@ -84,6 +85,7 @@ class Engine {
   EngineState state();
   bool debugging_enabled();
   bool wpt_mode();
+  const mozilla::Maybe<std::string> &init_location() const;
 
   void finish_pre_initialization();
 

runtime/engine.cpp

@@ -520,6 +520,9 @@ bool Engine::debugging_enabled() {
   return config_->debugging;
 }
 bool Engine::wpt_mode() { return config_->wpt_mode; }
+const mozilla::Maybe<std::string> &Engine::init_location() const {
+  return config_->init_location;
+}
 
 void Engine::finish_pre_initialization() {
   MOZ_ASSERT(state_ == EngineState::ScriptPreInitializing);

tests/e2e/init-location/expect_serve_stdout.txt

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

tests/e2e/init-location/expect_wizer_stdout.txt

@@ -0,0 +1,2 @@
+Componentizing e2e/init-location/init-location.js into e2e/init-location/init-location.wasm
+Log: http://foo.bar/

tests/e2e/init-location/init-location.js

@@ -0,0 +1,6 @@
+console.log(self.location.href);
+
+addEventListener("fetch", (event) => {
+  console.log(self.location.hostname);
+  event.respondWith(new Response("ok"));
+});

tests/e2e/init-location/runtime-args

@@ -0,0 +1 @@
+--init-location http://foo.bar/