Debugging: add the debug-main world.

This PR "draws the rest of the owl" for the debug-main
world (bytecodealliance/rfcs#45). This includes a WIT world that hosts
debug components that have access to "host debug powers" via a
debugging API, and the ability to load such a debug-component and give
it control of the main program as a debuggee when using `wasmtime
run`.

The WIT is namespaced to `bytecodealliance:wasmtime` and is slightly
aspirational in places: for example, the host does not yet implement
injection of early return values or exception-throws. I intend to fill
out a series of TODO issues once this all lands to track followup
("post-MVP") work.

This PR does not include any debug components. I separately have a
gdbstub component, with which I tested and co-developed this host-side
implementation. My plan is to land it in a followup PR as a component
that will be embedded in/shipped with the Wasmtime CLI and available
under an easy-to-use CLI option. Once we have that gdbstub component,
we can also implement end-to-end integration tests that boot up LLDB
and run through an expected interaction. (Separately, those
integration tests will require a release of wasi-sdk to ship an LLDB
binary that we can use.) As such, there are no real tests in this PR:
interesting behaviors only really occur with a full end-to-end flow.

The integration with the CLI is a little awkward (we internally build
another `wasmtime run` command that invokes the debug component, and
tie it together with the debuggee via a special `invoke_debugger` API;
this seemed less bad than reworking all of the WASI setup to be more
reusable). Happy to take more ideas here.

Author: cfallin

Cargo.lock

@@ -60,6 +60,7 @@ wasmtime-wasi-threads = { workspace = true, optional = true }
 wasmtime-wasi-http = { workspace = true, optional = true }
 wasmtime-unwinder = { workspace = true }
 wasmtime-wizer = { workspace = true, optional = true, features = ['clap', 'wasmtime'] }
+wasmtime-debugger = { workspace = true, optional = true }
 clap = { workspace = true }
 clap_complete = { workspace = true, optional = true }
 target-lexicon = { workspace = true }
@@ -591,6 +592,7 @@ run = [
   "dep:tokio",
   "wasmtime-cli-flags/async",
   "wasmtime-wasi-http?/p2",
+  "dep:wasmtime-debugger",
 ]
 completion = ["dep:clap_complete"]
 objdump = [

Cargo.toml

@@ -273,6 +273,13 @@ wasmtime_option_group! {
         pub log_to_files: Option<bool>,
         /// Enable coredump generation to this file after a WebAssembly trap.
         pub coredump: Option<String>,
+        /// Load the given debugger component and attach it to the
+        /// main module or component.
+        pub debugger: Option<PathBuf>,
+        /// Pass the given command-line arguments to the debugger
+        /// component. May be specified multiple times.
+        #[serde(default)]
+        pub debugger_arg: Vec<String>,
     }
 
     enum Debug {
@@ -491,6 +498,9 @@ wasmtime_option_group! {
         ///
         /// This option can be further overwritten with `--env` flags.
         pub inherit_env: Option<bool>,
+        /// Inherit stdin/stdout from the parent process. On by
+        /// default.
+        pub inherit_stdin_stdout: Option<bool>,
         /// Pass a wasi config variable to the program.
         #[serde(skip)]
         pub config_var: Vec<KeyValuePair>,

crates/cli-flags/src/lib.rs

@@ -9,6 +9,8 @@ use crate::{KeyValuePair, WasiNnGraph};
 use clap::builder::{StringValueParser, TypedValueParser, ValueParserFactory};
 use clap::error::{Error, ErrorKind};
 use serde::de::{self, Visitor};
+use std::path::PathBuf;
+use std::str::FromStr;
 use std::time::Duration;
 use std::{fmt, marker};
 use wasmtime::{Result, bail};
@@ -344,6 +346,20 @@ impl WasmtimeOptionValue for String {
     }
 }
 
+impl WasmtimeOptionValue for PathBuf {
+    const VAL_HELP: &'static str = "=path";
+    fn parse(val: Option<&str>) -> Result<Self> {
+        match val {
+            Some(val) => Ok(PathBuf::from_str(val)?),
+            None => bail!("value must be specified with key=val syntax"),
+        }
+    }
+
+    fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
 impl WasmtimeOptionValue for u32 {
     const VAL_HELP: &'static str = "=N";
     fn parse(val: Option<&str>) -> Result<Self> {

crates/cli-flags/src/opt.rs

@@ -12,9 +12,12 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
-wasmtime = { workspace = true, features = ["debug", "std", "async"] }
+wasmtime = { workspace = true, features = ["debug", "std", "async", "component-model", "gc", "gc-drc"] }
+wasmtime-wasi = { workspace = true }
+wasmtime-wasi-io = { workspace = true }
 tokio = { workspace = true, features = ["rt", "sync", "macros"] }
 log = { workspace = true }
+async-trait = { workspace = true }
 
 [dev-dependencies]
 # Depend on `wasmtime` again to get `cranelift` and `wat` so we can