Allow users to provide custom imports

Cargo.toml

@@ -32,7 +32,7 @@ wasm-bindgen = { version = "0.2" }
 wasm-bindgen-derive = "0.2.1"
 wasm-bindgen-futures = "0.4"
 wasm-bindgen-test = "0.3.37"
-wasmer = { version = "4.2.5", default-features = false, features = ["js", "js-default", "tracing", "wasm-types-polyfill", "enable-serde"] }
+wasmer = { version = "4.2.5", default-features = false, features = ["js", "js-default", "wasm-types-polyfill"] }
 wasmer-wasix = { version = "0.18", default-features = false, features = ["js", "js-default"] }
 webc = "5.3.0"
 
@@ -95,10 +95,10 @@ dwarf-debug-info = false
 wasm-opt = ["--enable-threads", "--enable-bulk-memory", "-Oz"]
 
 [patch.crates-io]
-virtual-net = { git = "https://github.com/wasmerio/wasmer", branch = "master" }
-virtual-fs = { git = "https://github.com/wasmerio/wasmer", branch = "master" }
-wasmer-wasix = { git = "https://github.com/wasmerio/wasmer", branch = "master" }
-wasmer = { git = "https://github.com/wasmerio/wasmer", branch = "master" }
+virtual-net = { git = "https://github.com/wasmerio/wasmer", branch = "wasi-runner-custom-imports" }
+virtual-fs = { git = "https://github.com/wasmerio/wasmer", branch = "wasi-runner-custom-imports" }
+wasmer-wasix = { git = "https://github.com/wasmerio/wasmer", branch = "wasi-runner-custom-imports" }
+wasmer = { git = "https://github.com/wasmerio/wasmer", branch = "wasi-runner-custom-imports" }
 # virtual-net = { path = "../wasmer/lib/virtual-net" }
 # virtual-fs = { path = "../wasmer/lib/virtual-fs" }
 # wasmer-wasix = { path = "../wasmer/lib/wasix" }

src/options.rs

@@ -4,6 +4,7 @@ use anyhow::Context;
 use js_sys::Array;
 use virtual_fs::TmpFileSystem;
 use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue, UnwrapThrowExt};
+use wasmer::{Extern, Imports};
 use wasmer_wasix::WasiEnvBuilder;
 
 use crate::{runtime::Runtime, utils::Error, Directory, DirectoryInit, JsRuntime, StringOrBytes};
@@ -41,6 +42,10 @@ type CommonOptions = {
      * files.
      */
     mount?: Record<string, DirectoryInit | Directory>;
+    /**
+     * Additional items that may be imported by the WebAssembly instance.
+     */
+    imports?: Record<string, Record<string, any>>;
 };
 
 /**
@@ -82,6 +87,9 @@ extern "C" {
     #[wasm_bindgen(method, getter)]
     fn env(this: &CommonOptions) -> JsValue;
 
+    #[wasm_bindgen(method, getter)]
+    fn imports(this: &CommonOptions) -> JsValue;
+
     #[wasm_bindgen(method, getter)]
     fn stdin(this: &CommonOptions) -> Option<StringOrBytes>;
 
@@ -139,6 +147,31 @@ impl CommonOptions {
 
         Ok(mounted_directories)
     }
+
+    pub(crate) fn load_imports(&self) -> Result<Imports, Error> {
+        let mut imports = Imports::default();
+
+        if let Ok(obj) = self.imports().dyn_into() {
+            for (namespace, ns) in crate::utils::object_entries(&obj)? {
+                let namespace = String::from(namespace);
+                let ns = ns
+                    .dyn_ref::<js_sys::Object>()
+                    .context("Expected a record of records")?;
+
+                for (name, value) in crate::utils::object_entries(&ns)? {
+                    let name = String::from(name);
+                    let extern_value = interpret_import(value).ok_or_else(|| {
+                        Error::js(js_sys::TypeError::new(&format!(
+                            "Invalid type for {namespace}/{name}"
+                        )))
+                    })?;
+                    imports.define(&namespace, &name, extern_value);
+                }
+            }
+        }
+
+        Ok(Imports::default())
+    }
 }
 
 impl Default for CommonOptions {
@@ -150,6 +183,10 @@ impl Default for CommonOptions {
     }
 }
 
+fn interpret_import(_value: JsValue) -> Option<Extern> {
+    todo!()
+}
+
 #[wasm_bindgen]
 extern "C" {
     #[wasm_bindgen(typescript_type = "RunOptions", extends = CommonOptions)]

src/run.rs

@@ -37,6 +37,9 @@ async fn run_wasix_inner(wasm_module: WasmModule, config: RunOptions) -> Result<
     let mut builder = WasiEnvBuilder::new(program_name).runtime(runtime.clone());
     let (stdin, stdout, stderr) = config.configure_builder(&mut builder)?;
 
+    let imports = config.load_imports()?;
+    builder.add_imports(&imports);
+
     let (exit_code_tx, exit_code_rx) = oneshot::channel();
 
     let module: wasmer::Module = wasm_module.to_module(&*runtime).await?;

src/wasmer.rs

@@ -216,23 +216,26 @@ pub(crate) async fn configure_runner(
     Error,
 > {
     let args = options.parse_args()?;
-    runner.set_args(args);
+    runner.with_args(args);
 
     let env = options.parse_env()?;
-    runner.set_envs(env);
+    runner.with_envs(env);
+
+    let imports = options.load_imports()?;
+    runner.with_imports(&imports);
 
     for (dest, dir) in options.mounted_directories()? {
-        runner.mount(dest, Arc::new(dir));
+        runner.with_mount(dest, Arc::new(dir));
     }
 
     if let Some(uses) = options.uses() {
         let uses = crate::utils::js_string_array(uses)?;
         let packages = load_injected_packages(uses, runtime).await?;
-        runner.add_injected_packages(packages);
+        runner.with_injected_packages(packages);
     }
 
     let (stderr_pipe, stderr_stream) = crate::streams::output_pipe();
-    runner.set_stderr(Box::new(stderr_pipe));
+    runner.with_stderr(Box::new(stderr_pipe));
 
     let tty_options = runtime.tty_options().clone();
     match setup_tty(options, tty_options) {
@@ -243,16 +246,16 @@ pub(crate) async fn configure_runner(
             stdin_stream,
         } => {
             tracing::debug!("Setting up interactive TTY");
-            runner.set_stdin(Box::new(stdin_pipe));
-            runner.set_stdout(Box::new(stdout_pipe));
+            runner.with_stdin(Box::new(stdin_pipe));
+            runner.with_stdout(Box::new(stdout_pipe));
             runtime.set_connected_to_tty(true);
             Ok((Some(stdin_stream), stdout_stream, stderr_stream))
         }
         TerminalMode::NonInteractive { stdin } => {
             tracing::debug!("Setting up non-interactive TTY");
             let (stdout_pipe, stdout_stream) = crate::streams::output_pipe();
-            runner.set_stdin(Box::new(stdin));
-            runner.set_stdout(Box::new(stdout_pipe));
+            runner.with_stdin(Box::new(stdin));
+            runner.with_stdout(Box::new(stdout_pipe));
 
             // HACK: Make sure we don't report stdin as interactive.  This
             // doesn't belong here because now it'll affect every other