Trim wasmtime serve's default world

ci/build-wasi-preview1-component-adapter.sh

@@ -26,3 +26,9 @@ $build_adapter --release
 $verify $release
 wasm-tools metadata add --name "wasi_preview1_component_adapter.reactor.adapter:${VERSION}" $release \
   -o target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.reactor.wasm
+
+# Release build, proxy
+$build_adapter --release --no-default-features --features proxy
+$verify $release
+wasm-tools metadata add --name "wasi_preview1_component_adapter.proxy.adapter:${VERSION}" $release \
+  -o target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.proxy.wasm

crates/test-programs/artifacts/build.rs

@@ -19,6 +19,11 @@ fn build_and_generate_tests() {
         "command",
         &["--no-default-features", "--features=command"],
     );
+    let proxy_adapter = build_adapter(
+        &out_dir,
+        "proxy",
+        &["--no-default-features", "--features=proxy"],
+    );
 
     println!("cargo:rerun-if-changed=../src");
 
@@ -62,6 +67,7 @@ fn build_and_generate_tests() {
 
         let adapter = match target.as_str() {
             "reactor" => &reactor_adapter,
+            s if s.starts_with("api_proxy") => &proxy_adapter,
             _ => &command_adapter,
         };
         let path = compile_component(&wasm, adapter);

crates/wasi-http/src/proxy.rs

@@ -25,10 +25,24 @@ pub fn add_to_linker<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Resul
 where
     T: WasiHttpView + preview2::WasiView + bindings::http::types::Host,
 {
-    // TODO: this shouldn't be required, but the adapter unconditionally pulls in all of these
-    // dependencies.
-    preview2::command::add_to_linker(l)?;
+    preview2::bindings::clocks::wall_clock::add_to_linker(l, |t| t)?;
+    preview2::bindings::clocks::monotonic_clock::add_to_linker(l, |t| t)?;
+    preview2::bindings::io::poll::add_to_linker(l, |t| t)?;
+    preview2::bindings::io::error::add_to_linker(l, |t| t)?;
+    preview2::bindings::io::streams::add_to_linker(l, |t| t)?;
+    preview2::bindings::cli::stdin::add_to_linker(l, |t| t)?;
+    preview2::bindings::cli::stdout::add_to_linker(l, |t| t)?;
+    preview2::bindings::cli::stderr::add_to_linker(l, |t| t)?;
+    preview2::bindings::random::random::add_to_linker(l, |t| t)?;
 
+    add_only_http_to_linker(l)
+}
+
+#[doc(hidden)]
+pub fn add_only_http_to_linker<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+where
+    T: WasiHttpView + preview2::WasiView + bindings::http::types::Host,
+{
     bindings::http::outgoing_handler::add_to_linker(l, |t| t)?;
     bindings::http::types::add_to_linker(l, |t| t)?;
 

crates/wasi-http/tests/all/async_.rs

@@ -13,7 +13,8 @@ async fn run(path: &str, server: &Server) -> Result<()> {
     let component = Component::from_file(&engine, path)?;
     let mut store = store(&engine, server);
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi_http::proxy::add_to_linker(&mut linker)?;
+    wasmtime_wasi::preview2::command::add_to_linker(&mut linker)?;
+    wasmtime_wasi_http::proxy::add_only_http_to_linker(&mut linker)?;
     let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
     let result = command.wasi_cli_run().call_run(&mut store).await?;
     result.map_err(|()| anyhow::anyhow!("run returned an error"))

crates/wasi-preview1-component-adapter/Cargo.toml

@@ -26,3 +26,4 @@ name = "wasi_snapshot_preview1"
 default = ["reactor"]
 reactor = []
 command = []
+proxy = []

crates/wasi-preview1-component-adapter/src/descriptors.rs

@@ -1,13 +1,15 @@
-use crate::bindings::wasi::cli::{
-    stderr, stdin, stdout, terminal_stderr, terminal_stdin, terminal_stdout,
-};
-use crate::bindings::wasi::filesystem::types as filesystem;
+use crate::bindings::wasi::cli::{stderr, stdin, stdout};
 use crate::bindings::wasi::io::streams::{InputStream, OutputStream};
-use crate::{BlockingMode, BumpArena, File, ImportAlloc, TrappingUnwrap, WasmStr};
+use crate::{BlockingMode, BumpArena, ImportAlloc, TrappingUnwrap, WasmStr};
 use core::cell::{Cell, OnceCell, UnsafeCell};
 use core::mem::MaybeUninit;
 use wasi::{Errno, Fd};
 
+#[cfg(not(feature = "proxy"))]
+use crate::bindings::wasi::filesystem::types as filesystem;
+#[cfg(not(feature = "proxy"))]
+use crate::File;
+
 pub const MAX_DESCRIPTORS: usize = 128;
 
 #[repr(C)]
@@ -43,12 +45,14 @@ impl Streams {
                 let input = match &self.type_ {
                     // For directories, preview 1 behavior was to return ERRNO_BADF on attempts to read
                     // or write.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(File {
                         descriptor_type: filesystem::DescriptorType::Directory,
                         ..
                     }) => return Err(wasi::ERRNO_BADF),
                     // For files, we may have adjusted the position for seeking, so
                     // create a new stream.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(file) => {
                         let input = file.fd.read_via_stream(file.position.get())?;
                         input
@@ -69,12 +73,14 @@ impl Streams {
                 let output = match &self.type_ {
                     // For directories, preview 1 behavior was to return ERRNO_BADF on attempts to read
                     // or write.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(File {
                         descriptor_type: filesystem::DescriptorType::Directory,
                         ..
                     }) => return Err(wasi::ERRNO_BADF),
                     // For files, we may have adjusted the position for seeking, so
                     // create a new stream.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(file) => {
                         let output = if file.append {
                             file.fd.append_via_stream()?
@@ -97,6 +103,7 @@ pub enum StreamType {
     Stdio(Stdio),
 
     /// Streaming data with a file.
+    #[cfg(not(feature = "proxy"))]
     File(File),
 }
 
@@ -108,11 +115,17 @@ pub enum Stdio {
 
 impl Stdio {
     pub fn filetype(&self) -> wasi::Filetype {
-        let is_terminal = match self {
-            Stdio::Stdin => terminal_stdin::get_terminal_stdin().is_some(),
-            Stdio::Stdout => terminal_stdout::get_terminal_stdout().is_some(),
-            Stdio::Stderr => terminal_stderr::get_terminal_stderr().is_some(),
+        #[cfg(not(feature = "proxy"))]
+        let is_terminal = {
+            use crate::bindings::wasi::cli;
+            match self {
+                Stdio::Stdin => cli::terminal_stdin::get_terminal_stdin().is_some(),
+                Stdio::Stdout => cli::terminal_stdout::get_terminal_stdout().is_some(),
+                Stdio::Stderr => cli::terminal_stderr::get_terminal_stderr().is_some(),
+            }
         };
+        #[cfg(feature = "proxy")]
+        let is_terminal = false;
         if is_terminal {
             wasi::FILETYPE_CHARACTER_DEVICE
         } else {
@@ -133,6 +146,7 @@ pub struct Descriptors {
 
     /// Preopened directories. Initialized lazily. Access with `State::get_preopens`
     /// to take care of initialization.
+    #[cfg(not(feature = "proxy"))]
     preopens: Cell<Option<&'static [Preopen]>>,
 }
 
@@ -142,6 +156,7 @@ impl Descriptors {
             table: UnsafeCell::new(MaybeUninit::uninit()),
             table_len: Cell::new(0),
             closed: None,
+            #[cfg(not(feature = "proxy"))]
             preopens: Cell::new(None),
         };
 
@@ -170,6 +185,13 @@ impl Descriptors {
         }))
         .trapping_unwrap();
 
+        #[cfg(not(feature = "proxy"))]
+        d.open_preopens(import_alloc, arena);
+        d
+    }
+
+    #[cfg(not(feature = "proxy"))]
+    fn open_preopens(&self, import_alloc: &ImportAlloc, arena: &BumpArena) {
         #[link(wasm_import_module = "wasi:filesystem/preopens@0.2.0-rc-2023-11-10")]
         #[allow(improper_ctypes)] // FIXME(bytecodealliance/wit-bindgen#684)
         extern "C" {
@@ -195,7 +217,7 @@ impl Descriptors {
             // Expectation is that the descriptor index is initialized with
             // stdio (0,1,2) and no others, so that preopens are 3..
             let descriptor_type = descriptor.get_type().trapping_unwrap();
-            d.push(Descriptor::Streams(Streams {
+            self.push(Descriptor::Streams(Streams {
                 input: OnceCell::new(),
                 output: OnceCell::new(),
                 type_: StreamType::File(File {
@@ -209,8 +231,7 @@ impl Descriptors {
             .trapping_unwrap();
         }
 
-        d.preopens.set(Some(preopens));
-        d
+        self.preopens.set(Some(preopens));
     }
 
     fn push(&self, desc: Descriptor) -> Result<Fd, Errno> {
@@ -276,6 +297,7 @@ impl Descriptors {
             .ok_or(wasi::ERRNO_BADF)
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_preopen(&self, fd: Fd) -> Option<&Preopen> {
         let preopens = self.preopens.get().trapping_unwrap();
         // Subtract 3 for the stdio indices to compute the preopen index.
@@ -340,6 +362,7 @@ impl Descriptors {
         }
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_file_with_error(&self, fd: Fd, error: Errno) -> Result<&File, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(Streams {
@@ -359,10 +382,12 @@ impl Descriptors {
         }
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_file(&self, fd: Fd) -> Result<&File, Errno> {
         self.get_file_with_error(fd, wasi::ERRNO_INVAL)
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_dir(&self, fd: Fd) -> Result<&File, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(Streams {
@@ -383,6 +408,7 @@ impl Descriptors {
         }
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_seekable_file(&self, fd: Fd) -> Result<&File, Errno> {
         self.get_file_with_error(fd, wasi::ERRNO_SPIPE)
     }
@@ -406,6 +432,7 @@ impl Descriptors {
     }
 }
 
+#[cfg(not(feature = "proxy"))]
 #[repr(C)]
 pub struct Preopen {
     /// This is `MaybeUninit` because we take ownership of the `Descriptor` to
@@ -414,6 +441,7 @@ pub struct Preopen {
     pub path: WasmStr,
 }
 
+#[cfg(not(feature = "proxy"))]
 #[repr(C)]
 pub struct PreopenList {
     pub base: *const Preopen,