Switch everything to wasmtime-wasi (#911)

Author: jeffcharles

Cargo.lock

@@ -22,7 +22,6 @@ license = "Apache-2.0 WITH LLVM-exception"
 wizer = "8.0.0"
 wasmtime = "29"
 wasmtime-wasi = "29"
-wasi-common = "29"
 wasm-opt = "0.116.1"
 anyhow = "1.0"
 javy = { path = "crates/javy", version = "4.0.1-alpha.1" }

Cargo.toml

@@ -11,10 +11,10 @@ name = "javy"
 path = "src/main.rs"
 
 [dependencies]
-wasi-common = { workspace = true }
 wizer = { workspace = true }
 anyhow = { workspace = true }
 wasmtime = { workspace = true }
+wasmtime-wasi = { workspace = true }
 walrus = "0.23.3"
 wasm-opt = "0.116.1"
 tempfile = { workspace = true }

crates/cli/Cargo.toml

@@ -2,12 +2,12 @@ use anyhow::{anyhow, bail, Result};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use num_format::{Locale, ToFormattedString};
 use std::{fmt::Display, fs, path::Path, process::Command};
-use wasi_common::{
-    pipe::{ReadPipe, WritePipe},
-    sync::WasiCtxBuilder,
-    WasiCtx,
-};
 use wasmtime::{AsContextMut, Engine, Linker, Module, Store};
+use wasmtime_wasi::{
+    pipe::{MemoryInputPipe, MemoryOutputPipe},
+    preview1::WasiP1Ctx,
+    WasiCtxBuilder,
+};
 
 struct FunctionCase {
     name: String,
@@ -86,8 +86,8 @@ impl FunctionCase {
 
     pub fn run(
         &self,
-        linker: &mut Linker<WasiCtx>,
-        mut store: impl AsContextMut<Data = WasiCtx>,
+        linker: &mut Linker<WasiP1Ctx>,
+        mut store: impl AsContextMut<Data = WasiP1Ctx>,
     ) -> Result<()> {
         let js_module = match &self.precompiled_elf_bytes {
             Some(bytes) => unsafe { Module::deserialize(&self.engine, bytes) }?,
@@ -107,14 +107,14 @@ impl FunctionCase {
         Ok(())
     }
 
-    pub fn setup(&self) -> Result<(Linker<WasiCtx>, Store<WasiCtx>)> {
+    pub fn setup(&self) -> Result<(Linker<WasiP1Ctx>, Store<WasiP1Ctx>)> {
         let mut linker = Linker::new(&self.engine);
         let wasi = WasiCtxBuilder::new()
-            .stdin(Box::new(ReadPipe::from(&self.payload[..])))
-            .stdout(Box::new(WritePipe::new_in_memory()))
-            .stderr(Box::new(WritePipe::new_in_memory()))
-            .build();
-        wasi_common::sync::add_to_linker(&mut linker, |s| s).unwrap();
+            .stdin(MemoryInputPipe::new(self.payload.clone()))
+            .stdout(MemoryOutputPipe::new(usize::MAX))
+            .stderr(MemoryOutputPipe::new(usize::MAX))
+            .build_p1();
+        wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |s| s)?;
         let mut store = Store::new(&self.engine, wasi);
 
         if let Linking::Dynamic = self.linking {

crates/cli/benches/benchmark.rs

@@ -1,12 +1,8 @@
 use anyhow::Result;
 use serde::Deserialize;
-use std::{
-    collections::HashMap,
-    io::{Read, Seek},
-    str,
-};
-use wasi_common::{pipe::WritePipe, sync::WasiCtxBuilder};
+use std::{collections::HashMap, str};
 use wasmtime::{AsContextMut, Engine, Linker};
+use wasmtime_wasi::{pipe::MemoryOutputPipe, WasiCtxBuilder};
 
 use crate::{CliPlugin, PluginKind};
 
@@ -24,25 +20,19 @@ impl ConfigSchema {
                 let engine = Engine::default();
                 let module = wasmtime::Module::new(&engine, cli_plugin.as_plugin().as_bytes())?;
                 let mut linker = Linker::new(&engine);
-                wasi_common::sync::snapshots::preview_1::add_wasi_snapshot_preview1_to_linker(
-                    &mut linker,
-                    |s| s,
-                )?;
-                let stdout = WritePipe::new_in_memory();
+                wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |s| s)?;
+                let stdout = MemoryOutputPipe::new(usize::MAX);
                 let wasi = WasiCtxBuilder::new()
                     .inherit_stderr()
-                    .stdout(Box::new(stdout.clone()))
-                    .build();
+                    .stdout(stdout.clone())
+                    .build_p1();
                 let mut store = wasmtime::Store::new(&engine, wasi);
                 let instance = linker.instantiate(store.as_context_mut(), &module)?;
                 instance
                     .get_typed_func::<(), ()>(store.as_context_mut(), "config_schema")?
                     .call(store.as_context_mut(), ())?;
                 drop(store);
-                let mut config_json = vec![];
-                let mut cursor = stdout.try_into_inner().unwrap();
-                cursor.rewind()?;
-                cursor.read_to_end(&mut config_json)?;
+                let config_json = stdout.try_into_inner().unwrap().to_vec();
                 let config_schema = serde_json::from_slice::<ConfigSchema>(&config_json)?;
                 let mut configs = Vec::with_capacity(config_schema.supported_properties.len());
                 for config in config_schema.supported_properties {

crates/cli/src/js_config.rs

@@ -1,8 +1,8 @@
 use anyhow::{bail, Result};
 use javy_runner::{Builder, Plugin, Runner, RunnerError};
 use std::{path::PathBuf, process::Command, str};
-use wasi_common::sync::WasiCtxBuilder;
 use wasmtime::{AsContextMut, Engine, Linker, Module, Store};
+use wasmtime_wasi::WasiCtxBuilder;
 
 use javy_test_macros::javy_cli_test;
 
@@ -271,8 +271,8 @@ fn test_init_plugin() -> Result<()> {
     // `compile-src` on this module should succeed.
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
-    wasi_common::sync::add_to_linker(&mut linker, |s| s)?;
-    let wasi = WasiCtxBuilder::new().build();
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |s| s)?;
+    let wasi = WasiCtxBuilder::new().build_p1();
     let mut store = Store::new(&engine, wasi);
 
     let uninitialized_plugin = PathBuf::from(env!("CARGO_MANIFEST_DIR"))

crates/cli/tests/integration_test.rs

@@ -18,7 +18,6 @@ anyhow = { workspace = true }
 brotli = "7.0.0"
 wasmtime = { workspace = true }
 wasmtime-wasi = { workspace = true }
-wasi-common = { workspace = true }
 walrus = "0.23.3"
 swc_core = { version = "10.7.0", features = [
   "common_sourcemap",

crates/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Result};
-use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
 use wasmtime::{AsContextMut, Engine, Instance, Linker, Memory, Module, Store};
+use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub(crate) fn compile_source(plugin_bytes: &[u8], js_source_code: &[u8]) -> Result<Vec<u8>> {
     let (mut store, instance, memory) = create_wasm_env(plugin_bytes)?;
@@ -11,16 +11,13 @@ pub(crate) fn compile_source(plugin_bytes: &[u8], js_source_code: &[u8]) -> Resu
     Ok(bytecode)
 }
 
-fn create_wasm_env(plugin_bytes: &[u8]) -> Result<(Store<WasiCtx>, Instance, Memory)> {
+fn create_wasm_env(plugin_bytes: &[u8]) -> Result<(Store<WasiP1Ctx>, Instance, Memory)> {
     let engine = Engine::default();
     let module = Module::new(&engine, plugin_bytes)?;
     let mut linker = Linker::new(&engine);
-    wasi_common::sync::snapshots::preview_1::add_wasi_snapshot_preview1_to_linker(
-        &mut linker,
-        |s| s,
-    )?;
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |s| s)?;
     linker.define_unknown_imports_as_traps(&module)?;
-    let wasi = WasiCtxBuilder::new().inherit_stderr().build();
+    let wasi = WasiCtxBuilder::new().inherit_stderr().build_p1();
     let mut store = Store::new(&engine, wasi);
     let instance = linker.instantiate(store.as_context_mut(), &module)?;
     let memory = instance