@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.3.0

package/snapshotManager.js

@@ -0,0 +1,324 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { createTwoFilesPatch } from 'diff';
+import config from './config.js';
+import sourceAdapter from './sourceAdapter.js';
+
+/**
+ * snapshotManager — Versioning d'infrastructure (style gencodedoc).
+ *
+ * Capture l'état de fichiers/dossiers (local OU remote via sourceAdapter),
+ * avec DÉDUPLICATION par contenu : stockage content-addressable façon git
+ * (chaque contenu est stocké une seule fois, nommé par son hash SHA-256).
+ *
+ * Choix technique : PAS de better-sqlite3 (module natif fragile sur Node v24).
+ * Stockage 100% fichiers JSON + blobs → robuste, inspectable, zéro dépendance native.
+ *
+ *   <dataDir>/infra_snapshots/
+ *     ├── objects/<hash[0:2]>/<hash[2:]>   ← blobs dédupliqués
+ *     └── index.json                        ← métadonnées des snapshots
+ *
+ * Le stockage est TOUJOURS local (sur l'hôte du MCP), que la source soit
+ * local ou remote. Un snapshot remote peut être restauré vers local (backup)
+ * et inversement (déploiement).
+ */
+
+const SNAP_DIR = path.join(config.dataDir, 'infra_snapshots');
+const OBJECTS_DIR = path.join(SNAP_DIR, 'objects');
+const INDEX_FILE = path.join(SNAP_DIR, 'index.json');
+
+function sha256(buffer) {
+    return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+async function ensureDirs() {
+    await fs.mkdir(OBJECTS_DIR, { recursive: true });
+}
+
+async function readIndex() {
+    try {
+        const data = await fs.readFile(INDEX_FILE, 'utf8');
+        return JSON.parse(data);
+    } catch {
+        return { snapshots: [] };
+    }
+}
+
+async function writeIndex(index) {
+    await ensureDirs();
+    await fs.writeFile(INDEX_FILE, JSON.stringify(index, null, 2));
+}
+
+function objectPath(hash) {
+    return path.join(OBJECTS_DIR, hash.slice(0, 2), hash.slice(2));
+}
+
+async function objectExists(hash) {
+    try {
+        await fs.access(objectPath(hash));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+// Stocke un blob s'il n'existe pas déjà (déduplication). Retourne true si nouveau.
+async function storeObject(hash, buffer) {
+    if (await objectExists(hash)) return false;
+    const p = objectPath(hash);
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, buffer);
+    return true;
+}
+
+async function readObject(hash) {
+    return fs.readFile(objectPath(hash));
+}
+
+export default {
+    /**
+     * Crée un snapshot. Capture les fichiers listés (fichiers ou dossiers).
+     * source  = { type:'local'|'remote', path? (ignoré), alias? }
+     * paths   = liste de chemins ABSOLUS à capturer (fichiers ou dossiers)
+     * options = { tag, message, recursive (défaut true), ignorePatterns }
+     * Retourne { snapshotId, filesCount, totalBytes, newObjects, dedupedObjects }.
+     */
+    async createSnapshot(source, paths, options = {}) {
+        await ensureDirs();
+        const recursive = options.recursive !== false;
+        const ignorePatterns = options.ignorePatterns || [];
+        const origin = sourceAdapter.describe(source);
+
+        // 1. Résout la liste complète des fichiers absolus à capturer
+        const fileAbsPaths = [];
+        for (const p of paths) {
+            const kind = await sourceAdapter.exists({ ...source, path: p });
+            if (!kind) throw new Error(`Chemin introuvable sur ${origin.server} : ${p}`);
+            if (kind === 'd') {
+                const rels = await sourceAdapter.listFilesRecursive(
+                    { ...source, path: p }, { recursive, ignorePatterns }
+                );
+                const sep = source.type === 'local' ? path.sep : '/';
+                for (const rel of rels) {
+                    fileAbsPaths.push(p.replace(/\/+$/, '') + sep + rel);
+                }
+            } else {
+                fileAbsPaths.push(p);
+            }
+        }
+
+        // 2. Lit chaque fichier, stocke le blob (dedup), construit la file map
+        const fileMap = [];
+        let totalBytes = 0, newObjects = 0, dedupedObjects = 0;
+        for (const absPath of fileAbsPaths) {
+            const { content, mtime, size } = await sourceAdapter.readFile({ ...source, path: absPath });
+            const hash = sha256(content);
+            const isNew = await storeObject(hash, content);
+            if (isNew) newObjects++; else dedupedObjects++;
+            totalBytes += size;
+            fileMap.push({ path: absPath, hash, size, mtime });
+        }
+
+        // 3. Enregistre le snapshot dans l'index
+        const snapshotId = `snap_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
+        const index = await readIndex();
+        index.snapshots.push({
+            id: snapshotId,
+            sourceType: source.type,
+            sourceAlias: source.type === 'remote' ? source.alias : null,
+            server: origin.server,
+            timestamp: Date.now(),
+            tag: options.tag || null,
+            message: options.message || null,
+            paths,
+            files: fileMap
+        });
+        await writeIndex(index);
+
+        return {
+            snapshotId,
+            server: origin.server,
+            filesCount: fileMap.length,
+            totalBytes,
+            newObjects,
+            dedupedObjects,
+            tag: options.tag || null
+        };
+    },
+
+    /**
+     * Liste les snapshots. filter = { sourceType, sourceAlias, tag, limit }
+     */
+    async listSnapshots(filter = {}) {
+        const index = await readIndex();
+        let snaps = index.snapshots.slice().reverse(); // plus récents d'abord
+
+        if (filter.sourceType) snaps = snaps.filter(s => s.sourceType === filter.sourceType);
+        if (filter.sourceAlias) snaps = snaps.filter(s => s.sourceAlias === filter.sourceAlias);
+        if (filter.tag) snaps = snaps.filter(s => s.tag === filter.tag);
+        if (filter.limit) snaps = snaps.slice(0, filter.limit);
+
+        // Résumé léger (sans la file map complète)
+        return snaps.map(s => ({
+            id: s.id,
+            server: s.server,
+            sourceType: s.sourceType,
+            tag: s.tag,
+            message: s.message,
+            timestamp: s.timestamp,
+            date: new Date(s.timestamp).toISOString(),
+            paths: s.paths,
+            filesCount: s.files.length
+        }));
+    },
+
+    async _getSnapshot(id) {
+        const index = await readIndex();
+        const snap = index.snapshots.find(s => s.id === id || s.tag === id);
+        if (!snap) throw new Error(`Snapshot '${id}' introuvable. Utilisez snapshot_list.`);
+        return snap;
+    },
+
+    /**
+     * Détails complets d'un snapshot (avec file map).
+     */
+    async getSnapshotDetails(id) {
+        const snap = await this._getSnapshot(id);
+        return snap;
+    },
+
+    /**
+     * Compare deux snapshots (par chemin de fichier). Fonctionne même entre
+     * un snapshot local et un snapshot remote.
+     * options = { includeDiff }
+     * Retourne { added[], removed[], modified[{path, hash1, hash2, added, removed, diff?}], identical, stats }.
+     */
+    async diffSnapshots(id1, id2, options = {}) {
+        const includeDiff = options.includeDiff === true;
+        const s1 = await this._getSnapshot(id1);
+        const s2 = await this._getSnapshot(id2);
+
+        const map1 = new Map(s1.files.map(f => [f.path, f]));
+        const map2 = new Map(s2.files.map(f => [f.path, f]));
+
+        const added = [];    // dans s2, pas dans s1
+        const removed = [];  // dans s1, pas dans s2
+        const modified = [];
+        let identical = 0;
+
+        for (const [p, f1] of map1) {
+            if (!map2.has(p)) { removed.push(p); continue; }
+            const f2 = map2.get(p);
+            if (f1.hash === f2.hash) { identical++; continue; }
+            const entry = { path: p, hash1: f1.hash, hash2: f2.hash };
+            try {
+                const c1 = (await readObject(f1.hash)).toString('utf8');
+                const c2 = (await readObject(f2.hash)).toString('utf8');
+                const patch = createTwoFilesPatch(`${id1}:${p}`, `${id2}:${p}`, c1, c2, 'snap1', 'snap2');
+                let a = 0, r = 0;
+                for (const line of patch.split('\n')) {
+                    if (line.startsWith('+') && !line.startsWith('+++')) a++;
+                    else if (line.startsWith('-') && !line.startsWith('---')) r++;
+                }
+                entry.added = a; entry.removed = r;
+                if (includeDiff) entry.diff = patch;
+            } catch {
+                entry.note = 'diff indisponible (binaire ?)';
+            }
+            modified.push(entry);
+        }
+        for (const p of map2.keys()) {
+            if (!map1.has(p)) added.push(p);
+        }
+
+        return {
+            snapshot1: { id: s1.id, server: s1.server, date: new Date(s1.timestamp).toISOString() },
+            snapshot2: { id: s2.id, server: s2.server, date: new Date(s2.timestamp).toISOString() },
+            added, removed, modified,
+            stats: {
+                added: added.length,
+                removed: removed.length,
+                modified: modified.length,
+                identical
+            }
+        };
+    },
+
+    /**
+     * Restaure un snapshot vers une cible (local ou remote).
+     * target  = { type, alias? }
+     * options = { paths (filtre préfixe), dryRun (défaut true), force }
+     * Retourne { dryRun, restored[], skipped[], errors[] }.
+     */
+    async restoreSnapshot(id, target, options = {}) {
+        const dryRun = options.dryRun !== false;
+        const snap = await this._getSnapshot(id);
+        const targetOrigin = sourceAdapter.describe({ ...target, path: '/' });
+
+        let files = snap.files;
+        if (options.paths && options.paths.length > 0) {
+            files = files.filter(f => options.paths.some(p => f.path === p || f.path.startsWith(p.replace(/\/+$/, '') + '/')));
+        }
+
+        const restored = [], skipped = [], errors = [];
+        for (const f of files) {
+            if (dryRun) {
+                restored.push({ path: f.path, size: f.size });
+                continue;
+            }
+            try {
+                const buffer = await readObject(f.hash);
+                await sourceAdapter.writeFile({ ...target, path: f.path }, buffer, { createDirs: true });
+                restored.push({ path: f.path, size: f.size });
+            } catch (e) {
+                errors.push({ path: f.path, error: e.message });
+            }
+        }
+
+        return {
+            dryRun,
+            target: targetOrigin.server,
+            snapshotId: snap.id,
+            restored,
+            skipped,
+            errors,
+            stats: { total: files.length, restored: restored.length, errors: errors.length }
+        };
+    },
+
+    /**
+     * Supprime un snapshot et nettoie les blobs orphelins (dedup-aware).
+     * Retourne { deleted, freedObjects, freedBytes }.
+     */
+    async deleteSnapshot(id) {
+        const index = await readIndex();
+        const idx = index.snapshots.findIndex(s => s.id === id || s.tag === id);
+        if (idx === -1) throw new Error(`Snapshot '${id}' introuvable.`);
+
+        const removed = index.snapshots.splice(idx, 1)[0];
+        await writeIndex(index);
+
+        // Collecte les hash encore référencés par les snapshots restants
+        const stillUsed = new Set();
+        for (const s of index.snapshots) {
+            for (const f of s.files) stillUsed.add(f.hash);
+        }
+
+        // Supprime les blobs devenus orphelins
+        let freedObjects = 0, freedBytes = 0;
+        const uniqueHashes = new Set(removed.files.map(f => f.hash));
+        for (const hash of uniqueHashes) {
+            if (!stillUsed.has(hash)) {
+                try {
+                    const stat = await fs.stat(objectPath(hash));
+                    freedBytes += stat.size;
+                    await fs.unlink(objectPath(hash));
+                    freedObjects++;
+                } catch { /* déjà absent */ }
+            }
+        }
+
+        return { deleted: true, snapshotId: removed.id, freedObjects, freedBytes };
+    }
+};

package/sourceAdapter.js

@@ -0,0 +1,357 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import micromatch from 'micromatch';
+import serverManager from './servers.js';
+import sshPool from './sshPool.js';
+import { z } from 'zod';
+
+/**
+ * sourceAdapter — Abstraction unifiée local/remote.
+ *
+ * Une "source" est un objet : { type: 'local'|'remote', path, alias? }
+ *  - type 'local'  → utilise fs directement (ZÉRO SSH, sur le PC hôte du MCP)
+ *  - type 'remote' → réutilise une connexion du POOL SSH (sshPool) et ouvre un
+ *                    canal SFTP dessus (pas de reconnexion TCP/handshake par op).
+ *
+ * v10.2.0 : le transport remote passe par le pool SSH partagé (perf : plus de
+ * reconnexion à chaque opération). Un wrapper promisifié reproduit fidèlement
+ * l'API de ssh2-sftp-client précédemment utilisée (get/put/stat/exists/list/mkdir),
+ * pour zéro régression sur les couches supérieures (fileOps, diffEngine, snapshots).
+ *
+ * Toutes les opérations fichiers de haut niveau s'appuient sur ce module.
+ */
+
+// Schéma Zod partagé pour une "source" (local ou remote). Défini ici pour
+// cohabiter avec le traitement (sourceAdapter) et être importé par server.js.
+const sourceSchema = z.object({
+    type: z.enum(['local', 'remote']).describe("'local' = PC hôte du MCP (sans SSH), 'remote' = serveur distant (SFTP)"),
+    path: z.string().describe("Chemin absolu du fichier"),
+    alias: z.string().optional().describe("Alias du serveur (requis si type='remote')"),
+    label: z.string().optional().describe("Nom lisible optionnel pour cette source (ex: 'nginx-prod'). Utile pour comparer des fichiers à des emplacements différents.")
+});
+
+// Enrobe le sous-système SFTP brut de ssh2 en une API Promise identique à
+// celle de ssh2-sftp-client (sous-ensemble utilisé ici).
+function promisifySftp(rawSftp) {
+    return {
+        // Lit un fichier → Buffer
+        get(remotePath) {
+            return new Promise((resolve, reject) => {
+                rawSftp.readFile(remotePath, (err, data) => err ? reject(err) : resolve(data));
+            });
+        },
+        // Écrit un Buffer
+        put(buffer, remotePath) {
+            return new Promise((resolve, reject) => {
+                rawSftp.writeFile(remotePath, buffer, (err) => err ? reject(err) : resolve());
+            });
+        },
+        // stat → { size, modifyTime(ms), accessTime(ms), isDirectory, isFile, mode }
+        stat(remotePath) {
+            return new Promise((resolve, reject) => {
+                rawSftp.stat(remotePath, (err, s) => {
+                    if (err) return reject(err);
+                    resolve({
+                        size: s.size,
+                        modifyTime: (s.mtime || 0) * 1000, // ssh2 = secondes → ms
+                        accessTime: (s.atime || 0) * 1000,
+                        isDirectory: s.isDirectory(),
+                        isFile: s.isFile(),
+                        mode: s.mode
+                    });
+                });
+            });
+        },
+        // exists → false | 'd' | 'l' | '-'
+        exists(remotePath) {
+            return new Promise((resolve) => {
+                rawSftp.lstat(remotePath, (err, s) => {
+                    if (err) return resolve(false);
+                    if (s.isDirectory()) return resolve('d');
+                    if (typeof s.isSymbolicLink === 'function' && s.isSymbolicLink()) return resolve('l');
+                    return resolve('-');
+                });
+            });
+        },
+        // list → [{ name, type:'d'|'l'|'-' }]
+        list(remotePath) {
+            return new Promise((resolve, reject) => {
+                rawSftp.readdir(remotePath, (err, entries) => {
+                    if (err) return reject(err);
+                    resolve(entries.map(e => {
+                        let type = '-';
+                        const a = e.attrs;
+                        if (a && typeof a.isDirectory === 'function') {
+                            if (a.isDirectory()) type = 'd';
+                            else if (typeof a.isSymbolicLink === 'function' && a.isSymbolicLink()) type = 'l';
+                        } else if (e.longname && e.longname[0] === 'd') {
+                            type = 'd';
+                        } else if (e.longname && e.longname[0] === 'l') {
+                            type = 'l';
+                        }
+                        return { name: e.filename, type };
+                    }));
+                });
+            });
+        },
+        // mkdir(dir, recursive) — recursive implémenté (ssh2 brut ne le fait pas)
+        async mkdir(dir, recursive) {
+            const makeOne = (p) => new Promise((resolve, reject) => {
+                rawSftp.mkdir(p, (err) => {
+                    // ignore "existe déjà" (Failure générique de SFTP)
+                    if (err && !/failure|exist/i.test(err.message || '')) return reject(err);
+                    resolve();
+                });
+            });
+            if (!recursive) return makeOne(dir);
+            const parts = dir.split('/').filter(Boolean);
+            let cur = dir.startsWith('/') ? '' : '.';
+            for (const part of parts) {
+                cur = cur === '' ? '/' + part : cur + '/' + part;
+                await makeOne(cur).catch(() => { /* niveau intermédiaire déjà présent */ });
+            }
+        }
+    };
+}
+
+// Réutilise une connexion du pool SSH, ouvre un canal SFTP dessus, exécute fn,
+// ferme le canal (PAS la connexion) et rend la connexion au pool.
+async function withSftp(alias, fn) {
+    const serverConfig = await serverManager.getServer(alias);
+    const conn = await sshPool.getConnection(alias, serverConfig);
+    let rawSftp = null;
+    try {
+        rawSftp = await new Promise((resolve, reject) => {
+            conn.client.sftp((err, sftp) => err ? reject(err) : resolve(sftp));
+        });
+        return await fn(promisifySftp(rawSftp));
+    } finally {
+        try { if (rawSftp) rawSftp.end(); } catch (e) { /* canal déjà fermé */ }
+        sshPool.releaseConnection(conn.id);
+    }
+}
+
+// Décrit une source de façon claire (évite que l'IA se perde entre serveurs)
+// Retourne { server, type, path, label }
+//   server : 'localhost' (local) ou l'alias du serveur (remote)
+//   label  : label personnalisé si fourni (source.label), sinon "server:path"
+//            Utile quand on compare des fichiers à des emplacements différents
+//            (ex: .bashrc sur un VPS vs .zshrc sur un autre → labels "shell-vps1"/"shell-vps2")
+function describe(source) {
+    const server = source.type === 'local' ? 'localhost' : source.alias;
+    return {
+        server,
+        type: source.type,
+        path: source.path,
+        label: source.label || `${server}:${source.path}`
+    };
+}
+
+// Valide la structure d'une source
+function validateSource(source) {
+    if (!source || typeof source !== 'object') {
+        throw new Error("Source invalide : objet attendu { type, path, alias? }");
+    }
+    if (source.type !== 'local' && source.type !== 'remote') {
+        throw new Error(`Type de source invalide : '${source.type}'. Attendu 'local' ou 'remote'.`);
+    }
+    if (!source.path) {
+        throw new Error("Source invalide : 'path' est requis.");
+    }
+    if (source.type === 'remote' && !source.alias) {
+        throw new Error("Source remote invalide : 'alias' est requis quand type='remote'.");
+    }
+}
+
+export { sourceSchema };
+
+export default {
+    /**
+     * Décrit une source : { server, type, path, label }.
+     * server = 'localhost' ou alias serveur. Utile pour indiquer clairement
+     * l'origine d'un fichier lu (évite la confusion entre serveurs).
+     */
+    describe,
+
+    /**
+     * Lit un fichier. Retourne { content: Buffer, mtime, size }.
+     */
+    async readFile(source) {
+        validateSource(source);
+        if (source.type === 'local') {
+            const content = await fs.readFile(source.path);
+            const stat = await fs.stat(source.path);
+            return { content, mtime: stat.mtimeMs, size: stat.size };
+        }
+        return withSftp(source.alias, async (sftp) => {
+            const content = await sftp.get(source.path); // Buffer
+            const stat = await sftp.stat(source.path);
+            return { content, mtime: stat.modifyTime, size: stat.size };
+        });
+    },
+
+    /**
+     * Écrit un fichier. contentBuffer doit être un Buffer.
+     * options = { createDirs: bool (défaut true) }
+     * Retourne { size }.
+     */
+    async writeFile(source, contentBuffer, options = {}) {
+        validateSource(source);
+        const createDirs = options.createDirs !== false;
+
+        if (source.type === 'local') {
+            if (createDirs) {
+                await fs.mkdir(path.dirname(source.path), { recursive: true });
+            }
+            await fs.writeFile(source.path, contentBuffer);
+            const stat = await fs.stat(source.path);
+            return { size: stat.size };
+        }
+
+        return withSftp(source.alias, async (sftp) => {
+            if (createDirs) {
+                const dir = path.posix.dirname(source.path);
+                if (dir && dir !== '/' && dir !== '.') {
+                    const exists = await sftp.exists(dir);
+                    if (!exists) await sftp.mkdir(dir, true);
+                }
+            }
+            await sftp.put(contentBuffer, source.path);
+            const stat = await sftp.stat(source.path);
+            return { size: stat.size };
+        });
+    },
+
+    /**
+     * Retourne les stats d'un fichier/dossier (format brut fs ou sftp).
+     */
+    async stat(source) {
+        validateSource(source);
+        if (source.type === 'local') {
+            return fs.stat(source.path);
+        }
+        return withSftp(source.alias, async (sftp) => sftp.stat(source.path));
+    },
+
+    /**
+     * Vérifie l'existence d'un chemin. Retourne false, 'd', '-', 'l'.
+     */
+    async exists(source) {
+        validateSource(source);
+        if (source.type === 'local') {
+            try {
+                const stat = await fs.stat(source.path);
+                return stat.isDirectory() ? 'd' : '-';
+            } catch {
+                return false;
+            }
+        }
+        return withSftp(source.alias, async (sftp) => sftp.exists(source.path));
+    },
+
+    /**
+     * Liste le contenu d'un dossier. Retourne [{ name, type }].
+     * type: 'd' (dossier), '-' (fichier), 'l' (lien).
+     */
+    async listDir(source) {
+        validateSource(source);
+        if (source.type === 'local') {
+            const entries = await fs.readdir(source.path, { withFileTypes: true });
+            return entries.map(e => ({
+                name: e.name,
+                type: e.isDirectory() ? 'd' : e.isSymbolicLink() ? 'l' : '-'
+            }));
+        }
+        return withSftp(source.alias, async (sftp) => {
+            const list = await sftp.list(source.path);
+            return list.map(e => ({ name: e.name, type: e.type }));
+        });
+    },
+
+    /**
+     * Liste récursivement tous les FICHIERS d'un dossier.
+     * Retourne un tableau de chemins RELATIFS (posix, ex: "conf/nginx.conf").
+     * options = { recursive: bool (défaut true), ignorePatterns: string[] }
+     * ignorePatterns : motifs glob (micromatch) testés contre chaque chemin relatif
+     *   ET chaque segment (ex: 'node_modules' ignore tout le dossier).
+     *
+     * Pour remote : tout le parcours se fait dans UNE SEULE connexion SFTP.
+     */
+    async listFilesRecursive(source, options = {}) {
+        validateSource(source);
+        const recursive = options.recursive !== false;
+        const ignore = options.ignorePatterns || [];
+
+        const shouldIgnore = (relPath) => {
+            if (ignore.length === 0) return false;
+            const segments = relPath.split('/');
+            // ignore si le chemin complet matche, ou si un segment matche
+            return micromatch.isMatch(relPath, ignore) ||
+                segments.some(seg => micromatch.isMatch(seg, ignore));
+        };
+
+        if (source.type === 'local') {
+            const results = [];
+            const walk = async (absDir, relDir) => {
+                const entries = await fs.readdir(absDir, { withFileTypes: true });
+                for (const e of entries) {
+                    const relPath = relDir ? `${relDir}/${e.name}` : e.name;
+                    if (shouldIgnore(relPath)) continue;
+                    if (e.isDirectory()) {
+                        if (recursive) await walk(path.join(absDir, e.name), relPath);
+                    } else if (e.isFile()) {
+                        results.push(relPath);
+                    }
+                }
+            };
+            await walk(source.path, '');
+            return results.sort();
+        }
+
+        // Remote : une seule connexion SFTP pour tout le walk
+        return withSftp(source.alias, async (sftp) => {
+            const results = [];
+            const walk = async (absDir, relDir) => {
+                const list = await sftp.list(absDir);
+                for (const e of list) {
+                    const relPath = relDir ? `${relDir}/${e.name}` : e.name;
+                    if (shouldIgnore(relPath)) continue;
+                    if (e.type === 'd') {
+                        if (recursive) await walk(path.posix.join(absDir, e.name), relPath);
+                    } else if (e.type === '-') {
+                        results.push(relPath);
+                    }
+                }
+            };
+            await walk(source.path, '');
+            return results.sort();
+        });
+    },
+
+    /**
+     * Lit plusieurs fichiers d'un dossier remote dans UNE connexion SFTP.
+     * relPaths : chemins relatifs à basePath. Retourne Map<relPath, {content:Buffer, hash}>.
+     * Pour local, lit simplement via fs (pas de coût connexion).
+     */
+    async readManyHashes(source, basePath, relPaths) {
+        validateSource(source);
+        const result = new Map();
+
+        if (source.type === 'local') {
+            for (const rel of relPaths) {
+                const buf = await fs.readFile(path.join(basePath, rel));
+                result.set(rel, { content: buf, hash: crypto.createHash('sha256').update(buf).digest('hex') });
+            }
+            return result;
+        }
+
+        return withSftp(source.alias, async (sftp) => {
+            for (const rel of relPaths) {
+                const buf = await sftp.get(path.posix.join(basePath, rel));
+                result.set(rel, { content: buf, hash: crypto.createHash('sha256').update(buf).digest('hex') });
+            }
+            return result;
+        });
+    }
+};