//! Sealed WASI: Smith's own synchronous implementations of the WASI imports //! that guest std runtimes pull in (`SMH-SPEC-WASM0001`, no ambient WASI). //! //! Sealed by default: empty environment and arguments, empty stdin, stdout //! and stderr writes discarded, no terminals, `exit` traps, the monotonic //! clock reads a host-injected value, and every pollable is ready. //! //! No host state backs a stream or pollable, so resources are bare handles //! with no table entry; ownership counts bound composed roots across suspended stores. use super::PluginHostState; use super::bindings::wasi::cli::{ environment, exit, stderr, stdin, stdout, terminal_input, terminal_output, terminal_stderr, terminal_stdin, terminal_stdout, }; use super::bindings::wasi::clocks::monotonic_clock; use super::bindings::wasi::io::error::{self, Error}; use super::bindings::wasi::io::poll::{self, Pollable}; use super::bindings::wasi::io::streams::{self, InputStream, OutputStream, StreamError}; use wasmtime::component::Resource; /// The only handle value ever minted; no handle carries host state. const SEALED: u32 = 0; /// Bytes a sealed output stream accepts per write; writes are discarded. const WRITE_BUDGET: u64 = 4096; fn sealed(state: &mut PluginHostState) -> Resource { super::composition::mint_sealed_handle(state); Resource::new_own(SEALED) } impl poll::HostPollable for PluginHostState { fn ready(&mut self, _pollable: Resource) -> bool { true } fn block(&mut self, _pollable: Resource) {} fn drop(&mut self, _pollable: Resource) -> wasmtime::Result<()> { super::composition::drop_sealed_handle(self); Ok(()) } } impl poll::Host for PluginHostState { fn poll(&mut self, pollables: Vec>) -> Vec { (0..u32::try_from(pollables.len()).unwrap_or(u32::MAX)).collect() } } impl error::HostError for PluginHostState { fn to_debug_string(&mut self, _error: Resource) -> String { String::new() } fn drop(&mut self, _error: Resource) -> wasmtime::Result<()> { Ok(()) } } impl error::Host for PluginHostState {} impl streams::HostInputStream for PluginHostState { fn read(&mut self, _stream: Resource, _len: u64) -> Result, StreamError> { Err(StreamError::Closed) } fn blocking_read( &mut self, _stream: Resource, _len: u64, ) -> Result, StreamError> { Err(StreamError::Closed) } fn skip(&mut self, _stream: Resource, _len: u64) -> Result { Err(StreamError::Closed) } fn blocking_skip( &mut self, _stream: Resource, _len: u64, ) -> Result { Err(StreamError::Closed) } fn subscribe(&mut self, _stream: Resource) -> Resource { sealed(self) } fn drop(&mut self, _stream: Resource) -> wasmtime::Result<()> { super::composition::drop_sealed_handle(self); Ok(()) } } impl streams::HostOutputStream for PluginHostState { fn check_write(&mut self, _stream: Resource) -> Result { Ok(WRITE_BUDGET) } fn write( &mut self, _stream: Resource, _contents: Vec, ) -> Result<(), StreamError> { Ok(()) } fn blocking_write_and_flush( &mut self, _stream: Resource, _contents: Vec, ) -> Result<(), StreamError> { Ok(()) } fn flush(&mut self, _stream: Resource) -> Result<(), StreamError> { Ok(()) } fn blocking_flush(&mut self, _stream: Resource) -> Result<(), StreamError> { Ok(()) } fn subscribe(&mut self, _stream: Resource) -> Resource { sealed(self) } fn write_zeroes( &mut self, _stream: Resource, _len: u64, ) -> Result<(), StreamError> { Ok(()) } fn blocking_write_zeroes_and_flush( &mut self, _stream: Resource, _len: u64, ) -> Result<(), StreamError> { Ok(()) } fn splice( &mut self, _stream: Resource, _source: Resource, _len: u64, ) -> Result { Err(StreamError::Closed) } fn blocking_splice( &mut self, _stream: Resource, _source: Resource, _len: u64, ) -> Result { Err(StreamError::Closed) } fn drop(&mut self, _stream: Resource) -> wasmtime::Result<()> { super::composition::drop_sealed_handle(self); Ok(()) } } impl streams::Host for PluginHostState {} impl monotonic_clock::Host for PluginHostState { fn now(&mut self) -> monotonic_clock::Instant { self.monotonic_now } fn resolution(&mut self) -> monotonic_clock::Duration { 1 } fn subscribe_instant(&mut self, _when: monotonic_clock::Instant) -> Resource { sealed(self) } fn subscribe_duration(&mut self, _when: monotonic_clock::Duration) -> Resource { sealed(self) } } impl environment::Host for PluginHostState { fn get_environment(&mut self) -> Vec<(String, String)> { Vec::new() } fn get_arguments(&mut self) -> Vec { Vec::new() } fn initial_cwd(&mut self) -> Option { None } } impl exit::Host for PluginHostState { fn exit(&mut self, status: Result<(), ()>) -> wasmtime::Result<()> { Err(wasmtime::format_err!("guest exited: {status:?}")) } fn exit_with_code(&mut self, status_code: u8) -> wasmtime::Result<()> { Err(wasmtime::format_err!( "guest exited with code {status_code}" )) } } impl stdin::Host for PluginHostState { fn get_stdin(&mut self) -> Resource { sealed(self) } } impl stdout::Host for PluginHostState { fn get_stdout(&mut self) -> Resource { sealed(self) } } impl stderr::Host for PluginHostState { fn get_stderr(&mut self) -> Resource { sealed(self) } } impl terminal_input::HostTerminalInput for PluginHostState { fn drop(&mut self, _terminal: Resource) -> wasmtime::Result<()> { Ok(()) } } impl terminal_input::Host for PluginHostState {} impl terminal_output::HostTerminalOutput for PluginHostState { fn drop( &mut self, _terminal: Resource, ) -> wasmtime::Result<()> { Ok(()) } } impl terminal_output::Host for PluginHostState {} impl terminal_stdin::Host for PluginHostState { fn get_terminal_stdin(&mut self) -> Option> { None } } impl terminal_stdout::Host for PluginHostState { fn get_terminal_stdout(&mut self) -> Option> { None } } impl terminal_stderr::Host for PluginHostState { fn get_terminal_stderr(&mut self) -> Option> { None } } // Shadow every data-bearing or handle-producing sealed import. Canonical lifting // runs before this wrapper, bounded by Store hostcall fuel; the entry checkpoint // observes that allocation before any further guest execution or host effect. pub(super) fn link( linker: &mut wasmtime::component::Linker, ) -> wasmtime::Result<()> { use super::composition::{wasi_effect, wasi_resource}; linker.allow_shadowing(true); let mut poll = linker.instance("wasi:io/poll@0.2.12")?; poll.func_wrap("poll", |store, (items,): (Vec>,)| { wasi_effect(store, items.len().saturating_mul(8), |state| { (poll::Host::poll(state, items),) }) })?; let mut streams = linker.instance("wasi:io/streams@0.2.12")?; streams.func_wrap( "[method]output-stream.write", |store, (stream, bytes): (Resource, Vec)| { wasi_effect(store, bytes.len(), |state| { (streams::HostOutputStream::write(state, stream, bytes),) }) }, )?; streams.func_wrap( "[method]output-stream.blocking-write-and-flush", |store, (stream, bytes): (Resource, Vec)| { wasi_effect(store, bytes.len(), |state| { (streams::HostOutputStream::blocking_write_and_flush( state, stream, bytes, ),) }) }, )?; streams.func_wrap( "[method]output-stream.subscribe", |store, (stream,): (Resource,)| { wasi_resource(store, 16, |state| { (streams::HostOutputStream::subscribe(state, stream),) }) }, )?; streams.func_wrap( "[method]input-stream.subscribe", |store, (stream,): (Resource,)| { wasi_resource(store, 16, |state| { (streams::HostInputStream::subscribe(state, stream),) }) }, )?; linker.instance("wasi:io/error@0.2.12")?.func_wrap( "[method]error.to-debug-string", |store, (error,): (Resource,)| { wasi_effect(store, 16, |state| { (error::HostError::to_debug_string(state, error),) }) }, )?; linker .instance("wasi:cli/stdin@0.2.12")? .func_wrap("get-stdin", |store, ()| { wasi_resource(store, 16, |state| (stdin::Host::get_stdin(state),)) })?; linker .instance("wasi:cli/stdout@0.2.12")? .func_wrap("get-stdout", |store, ()| { wasi_resource(store, 16, |state| (stdout::Host::get_stdout(state),)) })?; linker .instance("wasi:cli/stderr@0.2.12")? .func_wrap("get-stderr", |store, ()| { wasi_resource(store, 16, |state| (stderr::Host::get_stderr(state),)) })?; let mut clock = linker.instance("wasi:clocks/monotonic-clock@0.2.12")?; clock.func_wrap("subscribe-instant", |store, (when,): (u64,)| { wasi_resource(store, 16, |state| { (monotonic_clock::Host::subscribe_instant(state, when),) }) })?; clock.func_wrap("subscribe-duration", |store, (when,): (u64,)| { wasi_resource(store, 16, |state| { (monotonic_clock::Host::subscribe_duration(state, when),) }) })?; link_scalars(linker) } #[expect( clippy::too_many_lines, reason = "one exhaustive sealed import table applies the same terminal checkpoint to scalar and resource operations" )] fn link_scalars(linker: &mut wasmtime::component::Linker) -> wasmtime::Result<()> { use super::composition::wasi_effect; macro_rules! scalar { ($interface:literal, $name:literal, ($($argument:ident: $kind:ty),*), $owner:path, $method:ident) => { linker.instance($interface)?.func_wrap($name, |store, ($($argument,)*): ($($kind,)*)| { wasi_effect(store, 16, |state| (::$method(state, $($argument),*),)) })?; }; } macro_rules! resource_drop { ($interface:literal, $name:literal, $kind:ty, $owner:path) => { linker.instance($interface)?.func_wrap( $name, |store, (resource,): (Resource<$kind>,)| { wasi_effect(store, 4, |state| { ::drop(state, resource) })? }, )?; }; } scalar!("wasi:io/poll@0.2.12", "[method]pollable.ready", (resource: Resource), poll::HostPollable, ready); linker.instance("wasi:io/poll@0.2.12")?.func_wrap( "[method]pollable.block", |store, (resource,): (Resource,)| { wasi_effect(store, 4, |state| poll::HostPollable::block(state, resource)) }, )?; resource_drop!( "wasi:io/poll@0.2.12", "[resource-drop]pollable", Pollable, poll::HostPollable ); resource_drop!( "wasi:io/error@0.2.12", "[resource-drop]error", Error, error::HostError ); resource_drop!( "wasi:io/streams@0.2.12", "[resource-drop]input-stream", InputStream, streams::HostInputStream ); resource_drop!( "wasi:io/streams@0.2.12", "[resource-drop]output-stream", OutputStream, streams::HostOutputStream ); scalar!("wasi:io/streams@0.2.12", "[method]input-stream.read", (stream: Resource, length: u64), streams::HostInputStream, read); scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-read", (stream: Resource, length: u64), streams::HostInputStream, blocking_read); scalar!("wasi:io/streams@0.2.12", "[method]input-stream.skip", (stream: Resource, length: u64), streams::HostInputStream, skip); scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-skip", (stream: Resource, length: u64), streams::HostInputStream, blocking_skip); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.check-write", (stream: Resource), streams::HostOutputStream, check_write); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.flush", (stream: Resource), streams::HostOutputStream, flush); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-flush", (stream: Resource), streams::HostOutputStream, blocking_flush); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.write-zeroes", (stream: Resource, length: u64), streams::HostOutputStream, write_zeroes); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-write-zeroes-and-flush", (stream: Resource, length: u64), streams::HostOutputStream, blocking_write_zeroes_and_flush); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.splice", (stream: Resource, source: Resource, length: u64), streams::HostOutputStream, splice); scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-splice", (stream: Resource, source: Resource, length: u64), streams::HostOutputStream, blocking_splice); scalar!( "wasi:clocks/monotonic-clock@0.2.12", "now", (), monotonic_clock::Host, now ); scalar!( "wasi:clocks/monotonic-clock@0.2.12", "resolution", (), monotonic_clock::Host, resolution ); scalar!( "wasi:cli/environment@0.2.12", "get-environment", (), environment::Host, get_environment ); scalar!( "wasi:cli/environment@0.2.12", "get-arguments", (), environment::Host, get_arguments ); scalar!( "wasi:cli/environment@0.2.12", "initial-cwd", (), environment::Host, initial_cwd ); scalar!( "wasi:cli/terminal-stdin@0.2.12", "get-terminal-stdin", (), terminal_stdin::Host, get_terminal_stdin ); scalar!( "wasi:cli/terminal-stdout@0.2.12", "get-terminal-stdout", (), terminal_stdout::Host, get_terminal_stdout ); scalar!( "wasi:cli/terminal-stderr@0.2.12", "get-terminal-stderr", (), terminal_stderr::Host, get_terminal_stderr ); resource_drop!( "wasi:cli/terminal-input@0.2.12", "[resource-drop]terminal-input", terminal_input::TerminalInput, terminal_input::HostTerminalInput ); resource_drop!( "wasi:cli/terminal-output@0.2.12", "[resource-drop]terminal-output", terminal_output::TerminalOutput, terminal_output::HostTerminalOutput ); Ok(()) } #[cfg(test)] mod tests { use super::*; use crate::wasm::PluginCeilings; use poll::Host as _; use streams::{HostInputStream as _, HostOutputStream as _}; fn state() -> PluginHostState { PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 42, ceilings: PluginCeilings::default(), grants: 0, effects_enabled: false, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: crate::wasm::WorkspaceEffects::default(), fatal_recording_failure: std::cell::Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, } } #[test] fn sealed_handle_bookkeeping_does_not_allocate_or_retain_dropped_ownership() { let mut host = state(); let (_, allocation) = smith_alloc::measure_current_thread(smith_alloc::Scope::KernelCall, || { for _ in 0..1024 { let resource = stdout::Host::get_stdout(&mut host); assert_eq!(host.sealed_handles, 1); streams::HostOutputStream::drop(&mut host, resource).unwrap(); assert_eq!(host.sealed_handles, 0); } }); assert_eq!(allocation.allocations, 0); assert_eq!(allocation.bytes, 0); } #[test] fn poll_reports_every_pollable_ready() { let mut host = state(); assert_eq!( host.poll(vec![ Resource::new_own(SEALED), Resource::new_own(SEALED), Resource::new_own(SEALED) ]), [0, 1, 2] ); assert!(host.poll(Vec::new()).is_empty()); } #[test] fn stdin_is_closed_and_stdout_discards() { let mut host = state(); assert!(matches!( host.read(Resource::new_own(SEALED), 16), Err(StreamError::Closed) )); assert_eq!( host.check_write(Resource::new_own(SEALED)).unwrap(), WRITE_BUDGET ); assert!( host.write(Resource::new_own(SEALED), b"dropped".to_vec()) .is_ok() ); } #[test] fn clock_is_host_injected_and_exit_traps() { let mut host = state(); assert_eq!(monotonic_clock::Host::now(&mut host), 42); assert!(exit::Host::exit(&mut host, Ok(())).is_err()); assert!(exit::Host::exit_with_code(&mut host, 0).is_err()); } #[test] fn environment_is_empty() { let mut host = state(); assert!(environment::Host::get_environment(&mut host).is_empty()); assert!(environment::Host::get_arguments(&mut host).is_empty()); assert!(environment::Host::initial_cwd(&mut host).is_none()); } }