feat: initial wasi p1 implementation

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

Cargo.lock

@@ -8,7 +8,7 @@ publish = false
 [workspace]
 resolver = "3"
 members = ["crates/*"]
-default-members = [".", "crates/parser", "crates/tinywasm", "crates/types"]
+default-members = [".", "crates/parser", "crates/tinywasm", "crates/types", "crates/wasi"]
 
 [workspace.package]
 version = "0.11.0-pre.0"
@@ -23,6 +23,7 @@ categories = ["compilers", "embedded", "no-std", "virtualization", "wasm"]
 tinywasm = { path = "crates/tinywasm", version = "0.11.0-pre.0", default-features = false }
 tinywasm-parser = { path = "crates/parser", version = "0.11.0-pre.0", default-features = false }
 tinywasm-types = { path = "crates/types", version = "0.11.0-pre.0", default-features = false }
+tinywasm-wasi = { path = "crates/wasi", version = "0.11.0-pre.0" }
 
 anyhow = "1.0"
 log = "0.4"
@@ -37,6 +38,12 @@ wat = "1.259"
 
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support", "rayon"] }
 
+[workspace.lints.cargo]
+unused_dependencies = "allow"  # false-positive on libm
+
+[workspace.lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ["cfg(rust_analyzer)"] }
+
 [[example]]
 name = "rust"
 test = false
@@ -61,12 +68,13 @@ name = "tinywasm_modes"
 anyhow.workspace = true
 criterion.workspace = true
 pretty_env_logger.workspace = true
-tinywasm = { path = "crates/tinywasm" }
+tinywasm = { path = "crates/tinywasm", features = ["state"] }
 tinywasm-parser.workspace = true
+tinywasm-wasi.workspace = true
 wat.workspace = true
 
-[lints.cargo]
-unused_dependencies = "allow"  # false-positive on libm
+[lints]
+workspace = true
 
 [profile.bench]
 opt-level = 3

Cargo.toml

@@ -38,6 +38,7 @@ tinywasm = { workspace = true, features = [
   "log",
   "std",
 ] }
+tinywasm-wasi.workspace = true
 wasm-testsuite = { workspace = true, optional = true }
 wast = { workspace = true, optional = true }
 wat = { workspace = true, optional = true }
@@ -52,3 +53,6 @@ default = ["wast", "wat"]
 tests = ["dep:serde", "dep:serde_json", "dep:wasm-testsuite", "wast"]
 wast = ["dep:wast"]
 wat = ["dep:wat"]
+
+[lints]
+workspace = true

crates/cli/Cargo.toml

@@ -11,6 +11,7 @@ The crate also exposes reusable helpers such as `tinywasm_cli::wast_runner::Wast
 $ cargo install tinywasm-cli --version 0.9.0 --bin tinywasm
 $ tinywasm --help
 $ tinywasm ./module.wasm
+$ tinywasm run --env MODE=test ./command.wasm first second
 $ tinywasm run --invoke add ./module.wasm 1 2
 $ tinywasm compile ./module.wat -o ./module.twasm
 $ tinywasm dump ./module.twasm
@@ -23,6 +24,11 @@ Notes:
 - `run`, `dump`, and `inspect` accept `.wasm`, `.wat`, and `.twasm` inputs.
 - Use `-` as the input path to read a module from stdin.
 - Without `--invoke`, `tinywasm` expects the module to have a start function or `_start` export.
+- WASI Preview 1 imports are provided automatically. Arguments after the module path become guest
+  arguments, while repeatable `--env NAME=VALUE` options configure the guest environment.
+- WASI commands inherit stdin, stdout, and stderr. Filesystem access and host environment inheritance
+  are not enabled.
+- `proc_exit` determines the CLI process status without being printed as a trap.
 - `compile` writes TinyWasm's `twasm` archive format.
 - Function invocation arguments are parsed from the export signature, so `tinywasm run --invoke add ./module.wasm 1 2` works without repeating Wasm types on the command line.
 - `inspect` uses ANSI colors automatically when writing to a terminal; set `NO_COLOR=1` to disable them.

crates/cli/README.md

@@ -1,9 +1,18 @@
-use anyhow::Result;
 use clap::Parser;
-use tinywasm_cli::{Cli, run_cli};
+use std::process::ExitCode;
+use tinywasm_cli::{Cli, WasiExit, run_cli};
 
-fn main() -> Result<()> {
+fn main() -> ExitCode {
     let cli = Cli::parse();
     pretty_env_logger::formatted_builder().filter_level(cli.log_level.into()).init();
-    run_cli(cli)
+    match run_cli(cli) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(error) => match error.downcast_ref::<WasiExit>() {
+            Some(exit) => std::process::exit(exit.0 as i32),
+            None => {
+                eprintln!("Error: {error:?}");
+                ExitCode::FAILURE
+            }
+        },
+    }
 }

crates/cli/src/bin.rs

@@ -61,10 +61,18 @@ pub struct RunArgs {
     #[arg(long)]
     pub invoke: Option<String>,
 
+    /// Add a WASI environment variable
+    #[arg(long = "env", value_name = "NAME=VALUE")]
+    pub env: Vec<String>,
+
+    /// Preopen a host directory for WASI as HOST or HOST::GUEST
+    #[arg(long = "dir", value_name = "HOST[::GUEST]")]
+    pub dirs: Vec<String>,
+
     #[command(flatten)]
     pub engine: EngineFlags,
 
-    /// Arguments passed to the invoked Wasm function
+    /// Arguments passed to the WASI command or invoked Wasm function
     #[arg(trailing_var_arg = true)]
     pub args: Vec<String>,
 }

crates/cli/src/cli.rs

@@ -1,7 +1,10 @@
 use anyhow::Result;
+use std::path::Path;
 use tinywasm::types::ExportType;
 use tinywasm::{ModuleInstance, Store};
+use tinywasm_wasi::p1::WasiCtx;
 
+use crate::WasiExit;
 use crate::cli::RunArgs;
 use crate::load::load_module;
 use crate::output::print_results;
@@ -10,15 +13,45 @@ use crate::value_parse::parse_invocation_args;
 pub fn run(args: RunArgs) -> Result<()> {
     let module_path = args.module.as_deref().ok_or_else(|| anyhow::anyhow!("missing module path"))?;
     let loaded = load_module(module_path)?;
-    let mut store = Store::new(args.engine.build_engine()?);
-    let instance = ModuleInstance::instantiate_no_start(&mut store, &loaded.module, None)?;
+    let argv0 = Path::new(module_path).file_name().and_then(|name| name.to_str()).unwrap_or(module_path);
+    let guest_args = if args.invoke.is_none() {
+        std::iter::once(argv0.to_owned()).chain(args.args.iter().cloned()).collect()
+    } else {
+        vec![argv0.to_owned()]
+    };
+    let env = args
+        .env
+        .iter()
+        .map(|value| {
+            value
+                .split_once('=')
+                .filter(|(name, _)| !name.is_empty())
+                .map(|(name, value)| (name.to_owned(), value.to_owned()))
+                .ok_or_else(|| anyhow::anyhow!("invalid --env value `{value}`, expected NAME=VALUE"))
+        })
+        .collect::<Result<Vec<_>>>()?;
+    let mut wasi = WasiCtx::new().with_args(guest_args)?.with_env(env)?.inherit_stdio();
+    for mapping in &args.dirs {
+        let (host, guest) = mapping.split_once("::").unwrap_or((mapping, mapping));
+        if host.is_empty() || guest.is_empty() {
+            return Err(anyhow::anyhow!("invalid --dir value `{mapping}`, expected HOST or HOST::GUEST"));
+        }
+        wasi = wasi.preopen_dir(host, guest)?;
+    }
+    let mut store = Store::new(args.engine.build_engine()?).with_state(wasi);
+    let imports = tinywasm_wasi::p1::imports();
+    let instance = ModuleInstance::instantiate_no_start(&mut store, &loaded.module, Some(&imports))?;
+
+    let ran_core_start = if loaded.module.start_func.is_some() {
+        let result = instance.start(&mut store);
+        finish_wasi_call(result, &mut store)?;
+        true
+    } else {
+        false
+    };
 
     match args.invoke.as_deref() {
         Some(export) => {
-            if loaded.module.start_func.is_some() {
-                let _ = instance.start(&mut store)?;
-            }
-
             let func_ty = loaded
                 .module
                 .exports()
@@ -30,23 +63,38 @@ pub fn run(args: RunArgs) -> Result<()> {
             let func = instance.func_untyped(&store, export)?;
             let params = parse_invocation_args(func_ty, &args.args)?;
             let mut results = vec![tinywasm::WasmValue::I32(0); func.ty(&store)?.results().len()];
-            func.call(&mut store, &params, &mut results)?;
+            let result = func.call(&mut store, &params, &mut results);
+            finish_wasi_call(result, &mut store)?;
             print_results(&results);
             Ok(())
         }
         None => {
-            if instance.start_func(&store)?.is_some() {
-                let _ = instance.start(&mut store)?;
-                return Ok(());
-            }
-
-            let start = instance.func_untyped(&store, "_start").map_err(|_| {
-                anyhow::anyhow!(
-                    "module has no start function or `_start` export. Use `tinywasm inspect {module_path}` or `tinywasm run --invoke <export> {module_path}`"
-                )
-            })?;
-            start.call(&mut store, &[], &mut [])?;
+            let start = match instance.func_untyped(&store, "_start") {
+                Ok(start) => start,
+                Err(_) if ran_core_start => return Ok(()),
+                Err(_) => {
+                    return Err(anyhow::anyhow!(
+                        "module has no start function or `_start` export. Use `tinywasm inspect {module_path}` or `tinywasm run --invoke <export> {module_path}`"
+                    ));
+                }
+            };
+            let result = start.call(&mut store, &[], &mut []);
+            finish_wasi_call(result, &mut store)?;
             Ok(())
         }
     }
 }
+
+fn finish_wasi_call<T>(result: tinywasm::Result<T>, store: &mut Store) -> Result<T> {
+    match result {
+        Ok(value) => Ok(value),
+        Err(error) => {
+            if let Some(wasi) = store.state_mut::<WasiCtx>()
+                && let Some(status) = wasi.take_exit_status()
+            {
+                return Err(WasiExit(status).into());
+            }
+            Err(error.into())
+        }
+    }
+}

crates/cli/src/cmd/run.rs

@@ -11,9 +11,22 @@ pub mod wast_runner;
 
 use anyhow::Result;
 use clap::CommandFactory;
+use std::fmt::{Display, Formatter};
 
 pub use cli::{Cli, Commands};
 
+/// A WASI command exit requested through `proc_exit`.
+#[derive(Debug)]
+pub struct WasiExit(pub u32);
+
+impl Display for WasiExit {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "WASI command exited with status {}", self.0)
+    }
+}
+
+impl std::error::Error for WasiExit {}
+
 pub fn run_cli(cli: Cli) -> Result<()> {
     match cli.command {
         Some(Commands::Run(args)) => cmd::run::run(args),

crates/cli/src/lib.rs

@@ -72,6 +72,116 @@ fn bare_run_requires_default_entrypoint() {
         .stderr(predicate::str::contains("no start function or `_start` export"));
 }
 
+#[test]
+fn run_supplies_wasi_arguments() {
+    let dir = tempdir().unwrap();
+    let module = write_module(
+        &dir,
+        "args.wat",
+        r#"(module
+            (import "wasi_snapshot_preview1" "args_sizes_get" (func $args_sizes_get (param i32 i32) (result i32)))
+            (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
+            (memory (export "memory") 1)
+            (func (export "_start")
+                i32.const 0
+                i32.const 4
+                call $args_sizes_get
+                drop
+                i32.const 0
+                i32.load
+                call $proc_exit))"#,
+    );
+
+    Command::cargo_bin("tinywasm").unwrap().args(["run", &module, "one", "two"]).assert().code(3).stderr("");
+}
+
+#[test]
+fn run_supplies_explicit_wasi_environment() {
+    let dir = tempdir().unwrap();
+    let module = write_module(
+        &dir,
+        "env.wat",
+        r#"(module
+            (import "wasi_snapshot_preview1" "environ_sizes_get" (func $environ_sizes_get (param i32 i32) (result i32)))
+            (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
+            (memory (export "memory") 1)
+            (func (export "_start")
+                i32.const 0
+                i32.const 4
+                call $environ_sizes_get
+                drop
+                i32.const 0
+                i32.load
+                call $proc_exit))"#,
+    );
+
+    Command::cargo_bin("tinywasm")
+        .unwrap()
+        .args(["run", "--env", "MODE=test", "--env", "COLOR=off", &module])
+        .assert()
+        .code(2)
+        .stderr("");
+}
+
+#[test]
+fn run_inherits_wasi_stdout() {
+    let dir = tempdir().unwrap();
+    let module = write_module(
+        &dir,
+        "stdout.wat",
+        r#"(module
+            (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
+            (memory (export "memory") 1)
+            (data (i32.const 16) "hello wasi\n")
+            (func (export "_start")
+                i32.const 0 i32.const 16 i32.store
+                i32.const 4 i32.const 11 i32.store
+                i32.const 1 i32.const 0 i32.const 1 i32.const 8
+                call $fd_write
+                drop))"#,
+    );
+
+    Command::cargo_bin("tinywasm").unwrap().args(["run", &module]).assert().success().stdout("hello wasi\n");
+}
+
+#[test]
+fn run_preopens_wasi_directory() {
+    let dir = tempdir().unwrap();
+    let module = write_module(
+        &dir,
+        "preopen.wat",
+        r#"(module
+            (import "wasi_snapshot_preview1" "fd_prestat_get" (func $prestat (param i32 i32) (result i32)))
+            (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
+            (memory (export "memory") 1)
+            (func (export "_start")
+                i32.const 3
+                i32.const 0
+                call $prestat
+                call $proc_exit))"#,
+    );
+    let mapping = format!("{}::/data", dir.path().display());
+
+    Command::cargo_bin("tinywasm").unwrap().args(["run", "--dir", &mapping, &module]).assert().success().stderr("");
+}
+
+#[test]
+fn run_executes_core_start_before_wasi_start() {
+    let dir = tempdir().unwrap();
+    let module = write_module(
+        &dir,
+        "start-order.wat",
+        r#"(module
+            (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
+            (global $status (mut i32) (i32.const 1))
+            (func $initialize i32.const 7 global.set $status)
+            (start $initialize)
+            (func (export "_start") global.get $status call $proc_exit))"#,
+    );
+
+    Command::cargo_bin("tinywasm").unwrap().args(["run", &module]).assert().code(7).stderr("");
+}
+
 #[test]
 fn inspect_lists_exports() {
     let dir = tempdir().unwrap();

crates/cli/tests/cli.rs

@@ -32,5 +32,5 @@ std = ["tinywasm-types/std", "wasmparser/std"]
 # validate WebAssembly while parsing
 validate = ["wasmparser/features", "wasmparser/validate"]
 
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ["cfg(rust_analyzer)"] }
+[lints]
+workspace = true