Lot 24 : moteur de l'image tenu par la façade (LOKI_ENGINE_IMAGE=rust)

Port de web_engine.go, web_engine_reco.go et backend_engine_oci.go
(rust/loki-rs/src/engineimg) : statut du moteur (build, source, variante,
versions installées, avis, version recommandée, version précédente,
relevé du rendu), dernier build publié, plan (dernière ou recommandée,
risque de rendu du raisonnement au défaut de b10763), mise à jour depuis
le registre officiel (couches du sommet, liens, runtime ignoré, essai à
blanc, REASONING_PRESERVE=off dans le preset actif ou la configuration,
ménage, vérification du rendu avant/après par la sonde de gabarit),
bascules, suppression et retour à la version précédente.

Tenu seulement avec LOKI_BACKENDS=rust : la mise à jour est un job des
moteurs. La sonde est celle de la conversation quand la façade la tient.
/api/engine/cmdline reste au Go, qui relaie les routes du tunnel.

Parité : parity_engineimg_test.go tire du Go un journal (faux registre
OCI, faux moteur local pour la sonde) rejoué par tests/engineimg.rs ;
TestFacadeMoteurImage côté Go. Les aides de fichiers des rejeux passent
dans tests/common/parity.rs. Mutations : 71 tuées sur 74, trois
équivalentes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016tcGfJWefW5kUGoC2wL8cv

rust/loki-rs/tests/common/fakego.rs

@@ -78,6 +78,9 @@ pub struct FakeGo {
     pub tune_busy: Mutex<Option<String>>,
     /// /internal/v1/preset/apply reçus : (chemin, mode).
     pub preset_applies: Mutex<Vec<(String, String)>>,
+    /// /internal/v1/preset/apply écrit-il le preset dans la configuration
+    /// (`applyPresetFile` : clés « appareil » et BIN de la machine gardés) ?
+    pub apply_presets: Mutex<bool>,
     /// /internal/v1/chat/generating : le Go écrit une réponse.
     pub generating: Mutex<bool>,
     /// /internal/v1/service/prestart reçus.
@@ -450,6 +453,21 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
             if mode == "refus" || path.ends_with("refus.env") {
                 return resp(500, r#"{"error":"application refusée"}"#);
             }
+            if *st.apply_presets.lock().unwrap() {
+                let text = std::fs::read_to_string(&path).unwrap_or_default();
+                let mut next = loki_rs::presets::parse_env(&text);
+                let mut store = st.store.lock().unwrap();
+                let cur = store.entry("config".into()).or_default();
+                for k in loki_rs::presets::PRESERVED_KEYS {
+                    if let Some(v) = cur.get(*k) {
+                        next.insert(k.to_string(), String::from_utf8_lossy(v).into_owned());
+                    }
+                }
+                if let Some(bin) = cur.get("BIN").filter(|v| !v.is_empty()) {
+                    next.insert("BIN".into(), String::from_utf8_lossy(bin).into_owned());
+                }
+                *cur = next.into_iter().map(|(k, v)| (k, v.into_bytes())).collect();
+            }
             st.preset_applies.lock().unwrap().push((path, mode));
             resp(204, "")
         }
@@ -642,6 +660,7 @@ pub struct Opts {
     pub mcp: Option<Arc<loki_rs::mcp::Mcp>>,
     pub update: bool,
     pub backends: Option<Arc<loki_rs::backends::Backends>>,
+    pub engineimg: Option<Arc<loki_rs::engineimg::EngineImg>>,
 }
 
 /// Comme [`start`], avec la conversation tenue par la façade
@@ -744,6 +763,7 @@ pub async fn start_with(
         mcp: opts.mcp,
         update: opts.update,
         backends: opts.backends,
+        engineimg: opts.engineimg,
     };
     tokio::spawn(loki_rs::proxy::serve(fl, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/common/mod.rs

@@ -3,6 +3,7 @@
 #![allow(dead_code)]
 
 pub mod fakego;
+pub mod parity;
 pub mod toolsfx;
 
 use bytes::Bytes;

rust/loki-rs/tests/common/parity.rs

@@ -0,0 +1,139 @@
+//! Aides des rejeux de parité qui posent des fichiers et lisent une
+//! arborescence (`parityApplyFiles`, `parityTarGz`, `parityTree` du Go).
+
+use std::path::Path;
+
+use serde_json::Value;
+
+fn s(v: &Value) -> &str {
+    v.as_str().unwrap_or("")
+}
+
+/// Une archive .tar.gz ; les noms sont écrits tels quels (« ../x » compris).
+pub fn tar_gz(entries: &[Value]) -> Vec<u8> {
+    let gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    let mut b = tar::Builder::new(gz);
+    for e in entries {
+        let mut h = tar::Header::new_ustar();
+        let name = s(&e["name"]).as_bytes();
+        h.as_old_mut().name[..name.len()].copy_from_slice(name);
+        let link = s(&e["link"]).as_bytes();
+        h.as_old_mut().linkname[..link.len()].copy_from_slice(link);
+        h.set_mtime(1_700_000_000);
+        h.set_mode(e["mode"].as_u64().unwrap_or(0) as u32);
+        let body = s(&e["body"]).as_bytes().to_vec();
+        match s(&e["type"]) {
+            "dir" => h.set_entry_type(tar::EntryType::Directory),
+            "symlink" => {
+                h.set_entry_type(tar::EntryType::Symlink);
+                h.set_mode(0o777);
+            }
+            "hardlink" => h.set_entry_type(tar::EntryType::Link),
+            _ => {
+                h.set_entry_type(tar::EntryType::Regular);
+                h.set_size(body.len() as u64);
+            }
+        }
+        if s(&e["type"]) != "file" {
+            h.set_size(0);
+        }
+        h.set_cksum();
+        let data: &[u8] = if s(&e["type"]) == "file" { &body } else { &[] };
+        b.append(&h, data).unwrap();
+    }
+    b.into_inner().unwrap().finish().unwrap()
+}
+
+pub fn write_file(p: &Path, content: &str, mode: u32) {
+    use std::os::unix::fs::OpenOptionsExt;
+    let _ = std::fs::remove_file(p);
+    let mut f = std::fs::OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .mode(mode)
+        .open(p)
+        .unwrap();
+    std::io::Write::write_all(&mut f, content.as_bytes()).unwrap();
+}
+
+pub fn remove_all(p: &Path) {
+    match std::fs::symlink_metadata(p) {
+        Ok(m) if m.is_dir() => std::fs::remove_dir_all(p).unwrap(),
+        Ok(_) => std::fs::remove_file(p).unwrap(),
+        Err(_) => {}
+    }
+}
+
+/// Les fichiers d'une étape (`parityApplyFiles`).
+pub fn apply_files(home: &Path, files: &Value) {
+    for (n, v) in files.as_object().into_iter().flatten() {
+        let v = s(v);
+        let p = home.join(n.trim_end_matches('/'));
+        match v {
+            "-" => {
+                remove_all(&p);
+                continue;
+            }
+            "/" => {
+                std::fs::create_dir_all(&p).unwrap();
+                continue;
+            }
+            _ => {}
+        }
+        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+        if let Some(target) = v.strip_prefix("-> ") {
+            let _ = std::fs::remove_file(&p);
+            std::os::unix::fs::symlink(target, &p).unwrap();
+            continue;
+        }
+        write_file(&p, v, if v.starts_with("#!") { 0o755 } else { 0o644 });
+    }
+}
+
+/// `info.Mode().Perm().String()`.
+pub fn perm_string(mode: u32) -> String {
+    let mut out = String::from("-");
+    for shift in [6, 3, 0] {
+        let b = (mode >> shift) & 7;
+        out.push(if b & 4 != 0 { 'r' } else { '-' });
+        out.push(if b & 2 != 0 { 'w' } else { '-' });
+        out.push(if b & 1 != 0 { 'x' } else { '-' });
+    }
+    out
+}
+
+/// `parityTree`.
+pub fn tree(home: &Path) -> Vec<String> {
+    use std::os::unix::fs::PermissionsExt;
+    fn walk(home: &Path, p: &Path, out: &mut Vec<String>) {
+        let Ok(m) = std::fs::symlink_metadata(p) else {
+            return;
+        };
+        let rel = p.strip_prefix(home).unwrap().to_string_lossy().into_owned();
+        if rel.contains("/.git/") || rel.ends_with("/.git") {
+            return;
+        }
+        if m.file_type().is_symlink() {
+            let t = std::fs::read_link(p).unwrap();
+            out.push(format!("l {rel} -> {}", t.to_string_lossy()));
+        } else if m.is_dir() {
+            out.push(format!("d {rel}"));
+            for e in std::fs::read_dir(p).unwrap().flatten() {
+                walk(home, &e.path(), out);
+            }
+        } else {
+            let b = std::fs::read(p).unwrap();
+            out.push(format!(
+                "f {rel} {} {}",
+                perm_string(m.permissions().mode() & 0o777),
+                String::from_utf8_lossy(&b)
+            ));
+        }
+    }
+    let mut out = Vec::new();
+    for root in ["backends", "engine"] {
+        walk(home, &home.join(root), &mut out);
+    }
+    out.sort();
+    out
+}