Add an --adapt flag to automatically adapt core wasm before running

cli/src/main.rs

@@ -271,6 +271,7 @@ async fn create_execution_context(
         args.wasi_modules(),
         guest_profile_path,
         args.unknown_import_behavior(),
+        args.adapt(),
     )?
     .with_log_stderr(args.log_stderr())
     .with_log_stdout(args.log_stdout());

cli/src/opts.rs

@@ -111,6 +111,10 @@ pub struct SharedArgs {
     /// effect if you set RUST_LOG to a value before starting Viceroy
     #[arg(short = 'v', action = clap::ArgAction::Count)]
     verbosity: u8,
+    /// Whether or not to automatically adapt core-wasm modules to
+    /// components before running them.
+    #[arg(long = "adapt")]
+    adapt: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -213,6 +217,10 @@ impl SharedArgs {
     pub fn verbosity(&self) -> u8 {
         self.verbosity
     }
+
+    pub fn adapt(&self) -> bool {
+        self.adapt
+    }
 }
 
 #[derive(Args, Debug, Clone)]

cli/tests/integration/common.rs

@@ -276,12 +276,14 @@ impl Test {
             self.backends.start_servers().await;
         }
 
+        let adapt_core_wasm = false;
         let ctx = ExecuteCtx::new(
             &self.module_path,
             ProfilingStrategy::None,
             HashSet::new(),
             None,
             self.unknown_import_behavior,
+            adapt_core_wasm,
         )?
         .with_backends(self.backends.backend_configs().await)
         .with_dictionaries(self.dictionaries.clone())

cli/tests/trap-test/src/main.rs

@@ -16,12 +16,14 @@ pub type TestResult = Result<(), Error>;
 #[tokio::test(flavor = "multi_thread")]
 async fn fatal_error_traps() -> TestResult {
     let module_path = format!("{RUST_FIXTURE_PATH}/response.wasm");
+    let adapt_core_wasm = false;
     let ctx = ExecuteCtx::new(
         module_path,
         ProfilingStrategy::None,
         HashSet::new(),
         None,
         viceroy_lib::config::UnknownImportBehavior::LinkError,
+        adapt_core_wasm,
     )?;
     let req = Request::get("http://127.0.0.1:7676/").body(Body::from(""))?;
     let resp = ctx

crates/adapter/src/lib.rs

@@ -11,6 +11,8 @@ use core::slice;
 use poll::Pollable;
 use wasi::*;
 
+// test
+
 #[macro_use]
 mod macros;
 

lib/src/execute.rs

@@ -8,6 +8,7 @@ use crate::config::UnknownImportBehavior;
 
 use {
     crate::{
+        adapt,
         body::Body,
         component as compute,
         config::{Backends, DeviceDetection, Dictionaries, ExperimentalModule, Geolocation},
@@ -106,6 +107,7 @@ impl ExecuteCtx {
         wasi_modules: HashSet<ExperimentalModule>,
         guest_profile_path: Option<PathBuf>,
         unknown_import_behavior: UnknownImportBehavior,
+        adapt_components: bool,
     ) -> Result<Self, Error> {
         let input = fs::read(&module_path)?;
 
@@ -126,6 +128,22 @@ impl ExecuteCtx {
             })
         );
 
+        // When the input wasn't a component, but we're automatically adapting,
+        // apply the component adapter.
+        let (is_component, input) = if !is_component && adapt_components {
+            // It's not possible to adapt a component from WAT, we can't continue at this point.
+            if is_wat {
+                return Err(Error::Other(anyhow::anyhow!(
+                    "Wasm components may only be adapted from binary wasm components, not wat"
+                )));
+            }
+
+            let input = adapt::adapt_bytes(&input)?;
+            (true, input)
+        } else {
+            (is_component, input)
+        };
+
         let config = &configure_wasmtime(is_component, profiling_strategy);
         let engine = Engine::new(config)?;
         let instance_pre = if is_component {
@@ -323,7 +341,8 @@ impl ExecuteCtx {
     /// # use viceroy_lib::{Error, ExecuteCtx, ProfilingStrategy, ViceroyService};
     /// # async fn f() -> Result<(), Error> {
     /// # let req = Request::new(Body::from(""));
-    /// let ctx = ExecuteCtx::new("path/to/a/file.wasm", ProfilingStrategy::None, HashSet::new(), None, Default::default())?;
+    /// let adapt_core_wasm = false;
+    /// let ctx = ExecuteCtx::new("path/to/a/file.wasm", ProfilingStrategy::None, HashSet::new(), None, Default::default(), adapt_core_wasm)?;
     /// let resp = ctx.handle_request(req, "127.0.0.1".parse().unwrap()).await?;
     /// # Ok(())
     /// # }

lib/src/service.rs

@@ -43,7 +43,8 @@ impl ViceroyService {
     /// # use std::collections::HashSet;
     /// use viceroy_lib::{Error, ExecuteCtx, ProfilingStrategy, ViceroyService};
     /// # fn f() -> Result<(), Error> {
-    /// let ctx = ExecuteCtx::new("path/to/a/file.wasm", ProfilingStrategy::None, HashSet::new(), None, Default::default())?;
+    /// let adapt_core_wasm = false;
+    /// let ctx = ExecuteCtx::new("path/to/a/file.wasm", ProfilingStrategy::None, HashSet::new(), None, Default::default(), adapt_core_wasm)?;
     /// let svc = ViceroyService::new(ctx);
     /// # Ok(())
     /// # }