Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-harness/src/wasm/sealed_wasi.rs

Raw
//! 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<T: 'static>(state: &mut PluginHostState) -> Resource<T> {
    super::composition::mint_sealed_handle(state);
    Resource::new_own(SEALED)
}

impl poll::HostPollable for PluginHostState {
    fn ready(&mut self, _pollable: Resource<Pollable>) -> bool {
        true
    }

    fn block(&mut self, _pollable: Resource<Pollable>) {}

    fn drop(&mut self, _pollable: Resource<Pollable>) -> wasmtime::Result<()> {
        super::composition::drop_sealed_handle(self);
        Ok(())
    }
}

impl poll::Host for PluginHostState {
    fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Vec<u32> {
        (0..u32::try_from(pollables.len()).unwrap_or(u32::MAX)).collect()
    }
}

impl error::HostError for PluginHostState {
    fn to_debug_string(&mut self, _error: Resource<Error>) -> String {
        String::new()
    }

    fn drop(&mut self, _error: Resource<Error>) -> wasmtime::Result<()> {
        Ok(())
    }
}

impl error::Host for PluginHostState {}

impl streams::HostInputStream for PluginHostState {
    fn read(&mut self, _stream: Resource<InputStream>, _len: u64) -> Result<Vec<u8>, StreamError> {
        Err(StreamError::Closed)
    }

    fn blocking_read(
        &mut self,
        _stream: Resource<InputStream>,
        _len: u64,
    ) -> Result<Vec<u8>, StreamError> {
        Err(StreamError::Closed)
    }

    fn skip(&mut self, _stream: Resource<InputStream>, _len: u64) -> Result<u64, StreamError> {
        Err(StreamError::Closed)
    }

    fn blocking_skip(
        &mut self,
        _stream: Resource<InputStream>,
        _len: u64,
    ) -> Result<u64, StreamError> {
        Err(StreamError::Closed)
    }

    fn subscribe(&mut self, _stream: Resource<InputStream>) -> Resource<Pollable> {
        sealed(self)
    }

    fn drop(&mut self, _stream: Resource<InputStream>) -> wasmtime::Result<()> {
        super::composition::drop_sealed_handle(self);
        Ok(())
    }
}

impl streams::HostOutputStream for PluginHostState {
    fn check_write(&mut self, _stream: Resource<OutputStream>) -> Result<u64, StreamError> {
        Ok(WRITE_BUDGET)
    }

    fn write(
        &mut self,
        _stream: Resource<OutputStream>,
        _contents: Vec<u8>,
    ) -> Result<(), StreamError> {
        Ok(())
    }

    fn blocking_write_and_flush(
        &mut self,
        _stream: Resource<OutputStream>,
        _contents: Vec<u8>,
    ) -> Result<(), StreamError> {
        Ok(())
    }

    fn flush(&mut self, _stream: Resource<OutputStream>) -> Result<(), StreamError> {
        Ok(())
    }

    fn blocking_flush(&mut self, _stream: Resource<OutputStream>) -> Result<(), StreamError> {
        Ok(())
    }

    fn subscribe(&mut self, _stream: Resource<OutputStream>) -> Resource<Pollable> {
        sealed(self)
    }

    fn write_zeroes(
        &mut self,
        _stream: Resource<OutputStream>,
        _len: u64,
    ) -> Result<(), StreamError> {
        Ok(())
    }

    fn blocking_write_zeroes_and_flush(
        &mut self,
        _stream: Resource<OutputStream>,
        _len: u64,
    ) -> Result<(), StreamError> {
        Ok(())
    }

    fn splice(
        &mut self,
        _stream: Resource<OutputStream>,
        _source: Resource<InputStream>,
        _len: u64,
    ) -> Result<u64, StreamError> {
        Err(StreamError::Closed)
    }

    fn blocking_splice(
        &mut self,
        _stream: Resource<OutputStream>,
        _source: Resource<InputStream>,
        _len: u64,
    ) -> Result<u64, StreamError> {
        Err(StreamError::Closed)
    }

    fn drop(&mut self, _stream: Resource<OutputStream>) -> 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<Pollable> {
        sealed(self)
    }

    fn subscribe_duration(&mut self, _when: monotonic_clock::Duration) -> Resource<Pollable> {
        sealed(self)
    }
}

impl environment::Host for PluginHostState {
    fn get_environment(&mut self) -> Vec<(String, String)> {
        Vec::new()
    }

    fn get_arguments(&mut self) -> Vec<String> {
        Vec::new()
    }

    fn initial_cwd(&mut self) -> Option<String> {
        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<InputStream> {
        sealed(self)
    }
}

impl stdout::Host for PluginHostState {
    fn get_stdout(&mut self) -> Resource<OutputStream> {
        sealed(self)
    }
}

impl stderr::Host for PluginHostState {
    fn get_stderr(&mut self) -> Resource<OutputStream> {
        sealed(self)
    }
}

impl terminal_input::HostTerminalInput for PluginHostState {
    fn drop(&mut self, _terminal: Resource<terminal_input::TerminalInput>) -> wasmtime::Result<()> {
        Ok(())
    }
}

impl terminal_input::Host for PluginHostState {}

impl terminal_output::HostTerminalOutput for PluginHostState {
    fn drop(
        &mut self,
        _terminal: Resource<terminal_output::TerminalOutput>,
    ) -> wasmtime::Result<()> {
        Ok(())
    }
}

impl terminal_output::Host for PluginHostState {}

impl terminal_stdin::Host for PluginHostState {
    fn get_terminal_stdin(&mut self) -> Option<Resource<terminal_input::TerminalInput>> {
        None
    }
}

impl terminal_stdout::Host for PluginHostState {
    fn get_terminal_stdout(&mut self) -> Option<Resource<terminal_output::TerminalOutput>> {
        None
    }
}

impl terminal_stderr::Host for PluginHostState {
    fn get_terminal_stderr(&mut self) -> Option<Resource<terminal_output::TerminalOutput>> {
        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<PluginHostState>,
) -> 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<Resource<Pollable>>,)| {
        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<OutputStream>, Vec<u8>)| {
            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<OutputStream>, Vec<u8>)| {
            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<OutputStream>,)| {
            wasi_resource(store, 16, |state| {
                (streams::HostOutputStream::subscribe(state, stream),)
            })
        },
    )?;
    streams.func_wrap(
        "[method]input-stream.subscribe",
        |store, (stream,): (Resource<InputStream>,)| {
            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<Error>,)| {
            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<PluginHostState>) -> 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| (<PluginHostState as $owner>::$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| {
                        <PluginHostState as $owner>::drop(state, resource)
                    })?
                },
            )?;
        };
    }
    scalar!("wasi:io/poll@0.2.12", "[method]pollable.ready", (resource: Resource<Pollable>), poll::HostPollable, ready);
    linker.instance("wasi:io/poll@0.2.12")?.func_wrap(
        "[method]pollable.block",
        |store, (resource,): (Resource<Pollable>,)| {
            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<InputStream>, length: u64), streams::HostInputStream, read);
    scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-read", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, blocking_read);
    scalar!("wasi:io/streams@0.2.12", "[method]input-stream.skip", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, skip);
    scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-skip", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, blocking_skip);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.check-write", (stream: Resource<OutputStream>), streams::HostOutputStream, check_write);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.flush", (stream: Resource<OutputStream>), streams::HostOutputStream, flush);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-flush", (stream: Resource<OutputStream>), streams::HostOutputStream, blocking_flush);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.write-zeroes", (stream: Resource<OutputStream>, length: u64), streams::HostOutputStream, write_zeroes);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-write-zeroes-and-flush", (stream: Resource<OutputStream>, length: u64), streams::HostOutputStream, blocking_write_zeroes_and_flush);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.splice", (stream: Resource<OutputStream>, source: Resource<InputStream>, length: u64), streams::HostOutputStream, splice);
    scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-splice", (stream: Resource<OutputStream>, source: Resource<InputStream>, 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());
    }
}