Sausage: host, broker, commit-on-close filesystem, cargo actor, console, agent

Imported from the spike branch, with:
- a library crate (Host API) for the CLI and the tests
- JSON test scenarios for candidates
- commit on close only for new or truncated files
- a Nix flake: nix run -- init, nix run -- run

cli/src/lib.rs

@@ -0,0 +1,62 @@
+//! Sausage: grow a system of WASI actors by talking to it.
+//!
+//! The host runs the broker, the native actors (`broker`, `cargo`, and the
+//! console), and one supervisor per WASM actor. See `PROTOCOL.md`.
+
+pub mod broker;
+pub mod candidate;
+pub mod cargo_actor;
+pub mod console;
+pub mod fs;
+pub mod runtime;
+pub mod world;
+
+use std::path::Path;
+use std::sync::Arc;
+
+use anyhow::{Result, bail};
+use tokio::sync::mpsc;
+
+pub use broker::{Broker, Envelope};
+pub use world::World;
+
+/// A running world.
+pub struct Host {
+    pub world: World,
+    pub broker: Arc<Broker>,
+    _lock: std::fs::File,
+}
+
+impl Host {
+    /// Start the broker, `cargo`, and every registered actor of the world at
+    /// `root`. Only one host can run a world at a time.
+    pub async fn start(root: &Path) -> Result<Host> {
+        let world = World::new(std::path::absolute(root)?);
+        if !world.exists() {
+            bail!("{} is not a Sausage world. Create one with: sausage init", root.display());
+        }
+        let lock = std::fs::File::create(world.root.join(".lock"))?;
+        if lock.try_lock().is_err() {
+            bail!("another sausage process runs {}", root.display());
+        }
+        let broker = Broker::new(world.clone(), runtime::Runtime::new()?)?;
+
+        let rx = broker.open_mailbox("broker");
+        tokio::spawn(broker.clone().run_actor(rx));
+        let rx = broker.open_mailbox(cargo_actor::ID);
+        tokio::spawn(Arc::new(cargo_actor::Cargo::new(world.clone())).run_actor(broker.clone(), rx));
+
+        broker.start_all();
+        Ok(Host { world, broker, _lock: lock })
+    }
+
+    /// Register a native actor with the ID `id` and return its mailbox.
+    pub fn mailbox(&self, id: &str) -> mpsc::Receiver<Envelope> {
+        self.broker.open_mailbox(id)
+    }
+
+    /// Stop every actor gracefully.
+    pub async fn stop(self) {
+        self.broker.shutdown_all().await;
+    }
+}