Lot 11 : fichiers de la discussion tenus par la façade (LOKI_FILES=rust)

La façade sert le dépôt des pièces jointes (morceaux base64, 1 Gio au
plus, espace disque vérifié), le panneau Fichiers, la suppression, le
téléchargement (fiche, tranches base64 pour le tunnel E2E, brut avec
plage d'octets), l'affichage des images (type reniflé, CSP fermée,
vignette redressée et réduite par moyennage) et l'archive .zip, quand
LOKI_FILES=rust (expérimental ; le Go reste le défaut).

Côté Go : la nouvelle route /internal/v1/conv/workspace donne le dossier
de la discussion active (le Go la connaît toujours), facade_files.go
remet ces routes à la façade quand elles arrivent par le tunnel, et les
.part d'envois ne sont plus vidés par le Go au démarrage.

Parité : parity_files_test.go tire du Go les noms, slugs, en-têtes EXIF,
orientations et réductions (pixel pour pixel), reniflages, puis 42 appels
de route sur une arborescence fixe, rejoués par tests/convfiles.rs.

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

rust/loki-rs/src/api.rs

@@ -34,6 +34,8 @@ pub struct Ctx {
     pub dictate: Option<std::sync::Arc<crate::dictate::Dictation>>,
     /// Réglages partagés tenus par la façade (`LOKI_SETTINGS=rust`).
     pub settings: bool,
+    /// Fichiers de la discussion tenus par la façade (`LOKI_FILES=rust`).
+    pub files: Option<std::sync::Arc<crate::convfiles::ConvFiles>>,
     /// Jeton de l'API interne : une requête qui le porte vient du Go.
     pub internal_token: String,
 }
@@ -42,7 +44,11 @@ impl Ctx {
     /// La façade tient-elle au moins un lot (le Go lui remet alors le trafic
     /// de ce lot qui lui arrive par le tunnel) ?
     pub fn holds_any(&self) -> bool {
-        self.chat.is_some() || self.models.is_some() || self.dictate.is_some() || self.settings
+        self.chat.is_some()
+            || self.models.is_some()
+            || self.dictate.is_some()
+            || self.settings
+            || self.files.is_some()
     }
 
     /// La requête vient du Go (jeton interne valide) : déjà authentifiée par

rust/loki-rs/src/lib.rs

@@ -15,6 +15,7 @@ pub mod auth;
 pub mod chat;
 pub mod chatapi;
 pub mod child;
+pub mod convfiles;
 pub mod dictate;
 pub mod downloads;
 pub mod engine;

rust/loki-rs/src/main.rs

@@ -127,6 +127,9 @@ fn serve() -> ExitCode {
         // LOKI_SETTINGS=rust : les réglages partagés (préférences, prompt
         // système, intensité du raisonnement, adresse publique).
         let settings_rust = held_by_facade("LOKI_SETTINGS");
+        // LOKI_FILES=rust : les fichiers de la discussion (dépôt, panneau
+        // Fichiers, archive, téléchargement, images).
+        let files_rust = held_by_facade("LOKI_FILES");
         let mut env = vec![(auth::INTERNAL_ENV.to_string(), token.clone())];
         if chat_rust {
             env.push(("LOKI_CHAT".into(), "rust".into()));
@@ -140,7 +143,10 @@ fn serve() -> ExitCode {
         if settings_rust {
             env.push(("LOKI_SETTINGS".into(), "rust".into()));
         }
-        if chat_rust || models_rust || dictate_rust || settings_rust {
+        if files_rust {
+            env.push(("LOKI_FILES".into(), "rust".into()));
+        }
+        if chat_rust || models_rust || dictate_rust || settings_rust || files_rust {
             env.push(("LOKI_FACADE_ADDR".into(), format!("127.0.0.1:{web_port}")));
         }
         let sup = child::Supervisor::spawn(go_bin, go_port, env);
@@ -184,6 +190,12 @@ fn serve() -> ExitCode {
             std::sync::Arc::new(loki_rs::dictate::Dictation::new(&engine_paths.home))
         });
 
+        let files = if files_rust {
+            Some(start_files(backend, &token).await)
+        } else {
+            None
+        };
+
         let addr = SocketAddr::from(([0, 0, 0, 0], web_port));
         let listener = match tokio::net::TcpListener::bind(addr).await {
             Ok(l) => l,
@@ -203,6 +215,7 @@ fn serve() -> ExitCode {
             models,
             dictate,
             settings: settings_rust,
+            files,
         };
         let res = proxy::serve(listener, cfg, shutdown_signal()).await;
         eprintln!("[loki-rs] arrêt demandé — arrêt du serveur Go");
@@ -258,6 +271,33 @@ async fn start_models(
     std::sync::Arc::new(loki_rs::models::Models::new())
 }
 
+/// Les envois interrompus (process arrêté en plein dépôt) ne reprendront
+/// jamais : leurs `.part` sont vidés au démarrage (le Go ne le fait plus quand
+/// la façade tient les fichiers).
+async fn start_files(
+    backend: SocketAddr,
+    token: &str,
+) -> std::sync::Arc<loki_rs::convfiles::ConvFiles> {
+    let st = loki_rs::store::Store::new(backend, token.to_string());
+    let root = st
+        .internal_json(
+            hyper::Method::POST,
+            "/internal/v1/conv/workspace",
+            Some(&serde_json::json!({})),
+        )
+        .await
+        .ok()
+        .and_then(|v| v.get("root").and_then(|r| r.as_str()).map(str::to_string));
+    if let Some(root) = root {
+        let _ = tokio::task::spawn_blocking(move || {
+            loki_rs::convfiles::clean_stale_upload_parts(&root)
+        })
+        .await;
+    }
+    eprintln!("[loki-rs] fichiers de la discussion tenus par la façade (LOKI_FILES=rust)");
+    std::sync::Arc::new(loki_rs::convfiles::ConvFiles::default())
+}
+
 /// Le Go garde-t-il la conversation ? (quelques essais : il vient de démarrer)
 async fn go_keeps_chat(backend: SocketAddr, token: &str) -> Result<Option<String>, String> {
     let store = loki_rs::store::Store::new(backend, token.to_string());

rust/loki-rs/src/proxy.rs

@@ -71,6 +71,8 @@ pub struct Config {
     pub dictate: Option<Arc<crate::dictate::Dictation>>,
     /// Réglages partagés tenus par la façade (`LOKI_SETTINGS=rust`).
     pub settings: bool,
+    /// Fichiers de la discussion tenus par la façade (`LOKI_FILES=rust`).
+    pub files: Option<Arc<crate::convfiles::ConvFiles>>,
 }
 
 struct Proxy {
@@ -101,6 +103,7 @@ pub async fn serve(
             models: cfg.models,
             dictate: cfg.dictate,
             settings: cfg.settings,
+            files: cfg.files,
             internal_token: cfg.internal_token.clone(),
         },
     });
@@ -182,6 +185,11 @@ impl Proxy {
         {
             return chatapi::serve(&self.ctx, chat, req, from_go).await;
         }
+        if let Some(f) = &self.ctx.files
+            && crate::convfiles::handles(path)
+        {
+            return crate::convfiles::serve(&self.ctx, f, req, from_go).await;
+        }
         if self.ctx.settings && crate::settings::handles(path) {
             return crate::settings::serve(&self.ctx, req, from_go).await;
         }