feat: add WASM hook system and a dummy plugin

Cargo.toml

@@ -12,9 +12,23 @@ env_logger = "0.9.0"
 strum = "0.24.0"
 strum_macros = "0.24.0"
 anyhow = "1.0.57"
+wasmer = "3.0.0-rc.2"
+wasmer-wasi = "3.0.0-rc.2"
+prost = "0.11.2"
+bytes = "1.2.1"
 
 [dev-dependencies]
 assert_cmd = "2.0.4"
 assert_fs = "1.0.7"
 predicates = "2.1.1"
 trycmd = "0.14.0"
+
+[build-dependencies]
+prost-build = "0.11.2"
+
+[workspace]
+
+members = [
+    "hook",
+    ".",
+]

build.rs

@@ -0,0 +1,5 @@
+extern crate prost_build;
+
+fn main() {
+    prost_build::compile_protos(&["proto/hook.proto"], &["proto"]).unwrap();
+}

hook/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-wasi"

hook/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "hook"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+prost = "0.11.2"
+bytes = "1.2.1"
+
+[build-dependencies]
+prost-build = "0.11.2"

hook/build.rs

@@ -0,0 +1,5 @@
+extern crate prost_build;
+
+fn main() {
+    prost_build::compile_protos(&["../proto/hook.proto"], &["../proto"]).unwrap();
+}

hook/src/main.rs

@@ -0,0 +1,27 @@
+use prost::Message;
+use std::io;
+use std::io::prelude::*;
+use std::io::Cursor;
+
+pub mod hook {
+    include!(concat!(env!("OUT_DIR"), "/hook.rs"));
+}
+
+fn main() {
+    let mut stdin = io::stdin().lock();
+    let input = stdin.fill_buf().unwrap();
+
+    let req = hook::Req::decode(&mut Cursor::new(input)).unwrap();
+    for (key, value) in std::env::vars() {
+        eprintln!("{key}: {value}");
+    }
+
+    let mut resp = hook::Resp::default();
+    resp.bar = req.foo;
+
+    let mut output = Vec::new();
+    output.reserve(resp.encoded_len());
+    resp.encode(&mut output).unwrap();
+
+    io::stdout().write_all(&output).unwrap();
+}

proto/hook.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package hook;
+
+message Req {
+  string foo = 1;
+}
+
+message Resp {
+  string bar = 1;
+}

src/cli.rs

@@ -1,8 +1,16 @@
 use crate::data::{self, ObjectType, OID};
-use anyhow::Context;
+use anyhow::{Context, Ok};
 use clap::{Parser, Subcommand};
 use clap_verbosity_flag::Verbosity;
+use prost::Message;
+use std::io::{Cursor, Read, Write};
 use std::{env, fs, path::PathBuf};
+use wasmer::{Instance, Module, Store};
+use wasmer_wasi::{WasiBidirectionalSharedPipePair, WasiState};
+
+pub mod hook {
+    include!(concat!(env!("OUT_DIR"), "/hook.rs"));
+}
 
 #[derive(Parser, Debug)]
 #[command(about = "A bad git clone, in Rust", long_about = None)]
@@ -81,25 +89,69 @@ fn hash_object(context: &data::Context, path: PathBuf) -> anyhow::Result<()> {
     context.ensure_init()?;
     let data = fs::read(&path).context(format!("could not read '{}'", path.display()))?;
     println!("{}", context.hash_object(data, ObjectType::Blob)?);
+    hook()?;
     Ok(())
 }
 
 fn cat_file(context: &data::Context, object: String) -> anyhow::Result<()> {
     context.ensure_init()?;
     let data = context.get_object(OID(object), &[ObjectType::Blob])?;
     println!("{}", String::from_utf8_lossy(&data));
+    hook()?;
     Ok(())
 }
 
 fn write_tree(context: &data::Context) -> anyhow::Result<()> {
     context.ensure_init()?;
     println!("{}", context.write_tree(&context.work_dir)?);
+    hook()?;
     Ok(())
 }
 
 fn read_tree(context: &data::Context, object: String) -> anyhow::Result<()> {
     context.ensure_init()?;
-    context.read_tree(OID(object), &context.work_dir)
+    context.read_tree(OID(object), &context.work_dir)?;
+    hook()?;
+    Ok(())
+}
+
+fn hook() -> anyhow::Result<()> {
+    let mut store = Store::default();
+    let module = Module::from_file(&store, "target/wasm32-wasi/debug/hook.wasm")?;
+    let mut input = WasiBidirectionalSharedPipePair::new().with_blocking(false);
+    let mut output = WasiBidirectionalSharedPipePair::new().with_blocking(false);
+    let wasi_env = WasiState::new("hello")
+        .stdin(Box::new(input.clone()))
+        .stdout(Box::new(output.clone()))
+        .finalize(&mut store)?;
+
+    let import_object = wasi_env.import_object(&mut store, &module)?;
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let memory = instance.exports.get_memory("memory")?;
+    wasi_env.data_mut(&mut store).set_memory(memory.clone());
+
+    let mut req = hook::Req::default();
+    req.foo = String::from("Hello world");
+
+    let mut req_b = Vec::new();
+    req_b.reserve(req.encoded_len());
+    req.encode(&mut req_b).unwrap();
+    input.write_all(&req_b)?;
+
+    instance
+        .exports
+        .get_function("_start")?
+        .call(&mut store, &[])?;
+
+    let mut resp_b = Vec::new();
+    output.read_to_end(&mut resp_b)?;
+
+    let resp = hook::Resp::decode(&mut Cursor::new(resp_b)).unwrap();
+
+    println!("Read \"{:?}\" from the WASI stdout!", resp);
+
+    Ok(())
 }
 
 #[test]