sausage core: modules per topic, journal writer thread with WAL and batches, hash cache by metadata, 49 tests per rule

Blank stdout lines give no warning. core.exit requests the exit in its
own handler.

cli/src/core.rs

@@ -0,0 +1,64 @@
+//! The native core methods and their JSON parameters.
+use crate::{Host, RpcResult, error};
+use serde_json::{Value, json};
+
+impl Host {
+    /// Execute a core method without starting a guest process.
+    pub(crate) async fn core(
+        &self,
+        caller: &str,
+        id: Option<Value>,
+        method: &str,
+        p: Value,
+    ) -> RpcResult {
+        match method {
+            "call" => {
+                self.route(
+                    caller.into(),
+                    id,
+                    required_str(&p, "method")?.into(),
+                    p.get("params").cloned().unwrap_or(json!({})),
+                    p["detach"].as_bool().unwrap_or(false),
+                )
+                .await
+            }
+            "notify" => {
+                self.notify(
+                    caller,
+                    required_str(&p, "name")?,
+                    p.get("params").cloned().unwrap_or(json!({})),
+                );
+                Ok(Value::Null)
+            }
+            "kill" => {
+                self.kill(required_str(&p, "pid")?);
+                Ok(json!({}))
+            }
+            "stop" => {
+                if let Some(mut n) = self.begin_stop(required_str(&p, "pid")?) {
+                    let _ = n.wait_for(|ended| *ended).await;
+                }
+                Ok(json!({}))
+            }
+            "lock" => {
+                self.lock(caller, required_str(&p, "path")?, p["wait"] != false)
+                    .await
+            }
+            "unlock" => {
+                self.unlock(caller, required_str(&p, "path")?);
+                Ok(Value::Null)
+            }
+            "log" => Ok(self.0.journal.query(p).await),
+            "exit" => {
+                self.0.exit.send_replace(true);
+                Ok(json!({}))
+            }
+            _ => Err(error(-32601, "method not found")),
+        }
+    }
+}
+fn required_str<'a>(params: &'a Value, name: &str) -> Result<&'a str, Value> {
+    params[name]
+        .as_str()
+        .ok_or_else(|| error(-32602, &format!("{name} must be a string")))
+}