host: wasip1 processes, wasi:http, identity, stdio options, services (T12)

- Core modules run on the host-side preview1 over the shared VFS (D41).
- wasi:http default handler in the linker; anonymous HTTPS git clone works.
  Sockets stay denied until P2.
- Each process carries the conversation (from Exec, inherited by children,
  shown in /proc/processes) and a host-assigned SAUSAGE_PID.
- Spawn requests choose pipe, inherit or null per stream.
- /config/services.yaml supervisor: live edits, restarts, crash limit 5/10 s,
  graceful stop (stdin EOF, then kill after 5 s) (D44).
- Compile caches keyed by content; PATH=/usr/local/bin:/bin.

world.rs also carries T13's optional read-only /bin mount (D43).

host/src/process/services.rs

@@ -0,0 +1,169 @@
+//! Supervises the world's services list, live edits, crash limits, and graceful stops.
+use super::{GroupGuard, Request, Runtime, Started, Stdio};
+use serde::Deserialize;
+use std::{
+    collections::{BTreeMap, VecDeque},
+    sync::Arc,
+    time::Duration,
+};
+use tokio::time::Instant;
+
+#[derive(Clone, Deserialize, PartialEq, Eq)]
+struct Spec {
+    name: String,
+    argv: Vec<String>,
+    #[serde(default = "root")]
+    cwd: String,
+    #[serde(default)]
+    env: BTreeMap<String, String>,
+}
+fn root() -> String {
+    "/".into()
+}
+struct Live {
+    child: Started,
+    _guard: GroupGuard,
+}
+struct Service {
+    spec: Spec,
+    live: Option<Live>,
+    crashes: VecDeque<Instant>,
+    stopped: bool,
+}
+impl Service {
+    async fn start(&mut self, runtime: &Arc<Runtime>) {
+        match runtime
+            .start(
+                Request {
+                    program: self.spec.argv.first().cloned().unwrap_or_default(),
+                    argv: self.spec.argv.clone(),
+                    cwd: self.spec.cwd.clone(),
+                    env: self
+                        .spec
+                        .env
+                        .iter()
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect(),
+                    group: None,
+                    stdin: Stdio::Pipe,
+                    stdout: Stdio::Null,
+                    stderr: Stdio::Null,
+                },
+                0,
+                0,
+                0,
+                None,
+                None,
+            )
+            .await
+        {
+            Ok(child) => {
+                let guard = GroupGuard {
+                    runtime: runtime.clone(),
+                    group: child.pid,
+                };
+                self.live = Some(Live {
+                    child,
+                    _guard: guard,
+                });
+            }
+            Err(_) => self.crashed(),
+        }
+    }
+    fn crashed(&mut self) {
+        let now = Instant::now();
+        while self
+            .crashes
+            .front()
+            .is_some_and(|t| now.duration_since(*t) >= Duration::from_secs(10))
+        {
+            self.crashes.pop_front();
+        }
+        self.crashes.push_back(now);
+        self.stopped = self.crashes.len() > 5;
+    }
+    async fn stop(&mut self) {
+        if let Some(mut live) = self.live.take() {
+            drop(live.child.input.take());
+            let _ = tokio::time::timeout(Duration::from_secs(5), async {
+                loop {
+                    if live.child.code.borrow().is_some() {
+                        break;
+                    }
+                    if live.child.code.changed().await.is_err() {
+                        break;
+                    }
+                }
+            })
+            .await;
+            // The guard stops remaining descendants, or the process after its grace period.
+        }
+    }
+}
+/// Start the supervisor. Aborting its task stops its service processes.
+/// The YAML file contains name, argv, optional cwd, and an optional map of environment variables.
+pub fn supervise(runtime: Arc<Runtime>) -> tokio::task::JoinHandle<()> {
+    tokio::spawn(async move {
+        let mut services: BTreeMap<String, Service> = BTreeMap::new();
+        let mut previous = Vec::new();
+        let mut interval = tokio::time::interval(Duration::from_millis(100));
+        loop {
+            interval.tick().await;
+            let content = match runtime
+                .world
+                .root
+                .open("/config/services.yaml", Default::default())
+                .await
+            {
+                Ok(file) => match file.stat().await {
+                    Ok(stat) => file.read(0, stat.size as usize).await.ok(),
+                    Err(_) => None,
+                },
+                Err(e) if e.kind() == std::io::ErrorKind::NotFound => Some(b"[]".to_vec()),
+                Err(_) => None,
+            };
+            if let Some(content) = content.filter(|c| *c != previous)
+                && let Ok(specs) = serde_yaml_ng::from_slice::<Vec<Spec>>(&content)
+            {
+                let specs: BTreeMap<_, _> =
+                    specs.into_iter().map(|s| (s.name.clone(), s)).collect();
+                let removed: Vec<_> = services
+                    .keys()
+                    .filter(|name| !specs.contains_key(*name))
+                    .cloned()
+                    .collect();
+                for name in removed {
+                    services.remove(&name).unwrap().stop().await;
+                }
+                for (name, spec) in specs {
+                    let service = services.entry(name).or_insert_with(|| Service {
+                        spec: spec.clone(),
+                        live: None,
+                        crashes: VecDeque::new(),
+                        stopped: false,
+                    });
+                    if service.spec != spec {
+                        service.stop().await;
+                    }
+                    service.spec = spec;
+                    service.crashes.clear();
+                    service.stopped = false;
+                }
+                previous = content;
+            }
+            for service in services.values_mut() {
+                if service
+                    .live
+                    .as_ref()
+                    .is_some_and(|live| live.child.code.borrow().is_some())
+                {
+                    service.live = None;
+                    service.crashed();
+                }
+                if service.live.is_none() && !service.stopped {
+                    service.start(&runtime).await;
+                }
+            }
+        }
+    })
+}