@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

package/servers.js

@@ -1,49 +1,35 @@
-import fs from 'fs/promises';
 import path from 'path';
 import config from './config.js';
+import jsonStore from './atomicJsonStore.js';
+
 const SERVERS_FILE_PATH = path.join(config.dataDir, 'servers.json');
+const EMPTY = {};
 
 async function readServers() {
-    try {
-        await fs.access(SERVERS_FILE_PATH);
-        const data = await fs.readFile(SERVERS_FILE_PATH, 'utf-8');
-        return JSON.parse(data);
-    } catch (error) {
-        // Si le fichier n'existe pas, on retourne un objet vide
-        return {};
-    }
+    return jsonStore.readJson(SERVERS_FILE_PATH, EMPTY);
 }
 
-async function writeServers(servers) {
-    await fs.writeFile(SERVERS_FILE_PATH, JSON.stringify(servers, null, 2));
-}
-
-async function addServer(alias, config) {
-    const servers = await readServers();
-    if (servers[alias]) {
-        // L'alias existe, on le met à jour
-        servers[alias] = { ...servers[alias], ...config };
-        await writeServers(servers);
-        return { success: true, message: `Serveur '${alias}' mis à jour avec succès.` };
-    }
-    // L'alias n'existe pas, on le crée
-    servers[alias] = config;
-    await writeServers(servers);
-    return { success: true, message: `Serveur '${alias}' ajouté avec succès.` };
+async function addServer(alias, serverConfig) {
+    let existed = false;
+    await jsonStore.updateJson(SERVERS_FILE_PATH, EMPTY, (servers) => {
+        existed = !!servers[alias];
+        servers[alias] = existed ? { ...servers[alias], ...serverConfig } : serverConfig;
+        return servers;
+    });
+    return { success: true, message: `Serveur '${alias}' ${existed ? 'mis à jour' : 'ajouté'} avec succès.` };
 }
 
 async function removeServer(alias) {
-    const servers = await readServers();
-    if (!servers[alias]) {
-        throw new Error(`L'alias '${alias}' n'existe pas.`);
-    }
-    delete servers[alias];
-    await writeServers(servers);
+    await jsonStore.updateJson(SERVERS_FILE_PATH, EMPTY, (servers) => {
+        if (!servers[alias]) throw new Error(`L'alias '${alias}' n'existe pas.`);
+        delete servers[alias];
+        return servers;
+    });
     return { success: true, message: `Serveur '${alias}' supprimé.` };
 }
 
 async function listServers() {
-    return await readServers();
+    return readServers();
 }
 
 async function getServer(alias) {
@@ -55,4 +41,15 @@ async function getServer(alias) {
     return serverConfig;
 }
 
-export default { addServer, removeServer, listServers, getServer };
+/** true si l'alias est marqué readonly:true dans servers.json */
+async function isAliasReadOnly(alias) {
+    if (!alias) return false;
+    try {
+        const sc = await getServer(alias);
+        return sc.readonly === true || sc.readOnly === true;
+    } catch {
+        return false;
+    }
+}
+
+export default { addServer, removeServer, listServers, getServer, isAliasReadOnly };

package/sftp.js

@@ -4,7 +4,10 @@ import path from 'path';
 import { glob } from 'glob';
 import queue from './queue.js';
 import serverManager from './servers.js';
+import sourceAdapter from './sourceAdapter.js';
+import fileOps from './fileOps.js';
 import micromatch from 'micromatch';
+import utils from './utils.js';
 
 // Fonction utilitaire pour créer un dossier parent si nécessaire
 async function ensureLocalDir(filePath) {
@@ -17,20 +20,31 @@ async function ensureLocalDir(filePath) {
     }
 }
 
+function hasGlobPattern(str) {
+    return /[*?[\]]/.test(str);
+}
+
 // Fonction pour créer un dossier distant si nécessaire
 async function ensureRemoteDir(sftp, filePath) {
-    const dir = path.dirname(filePath);
+    const dir = path.posix.dirname(filePath); // Utiliser posix pour les chemins distants
+    
+    if (dir === '/' || dir === '.') {
+        return; // Pas besoin de créer la racine
+    }
+    
     try {
         const exists = await sftp.exists(dir);
         if (!exists) {
-            await sftp.mkdir(dir, true);
+            await sftp.mkdir(dir, true); // true pour créer récursivement
             queue.log('info', `Dossier distant créé: ${dir}`);
         }
     } catch (err) {
-        // Si le dossier existe déjà, on ignore l'erreur
-        if (!err.message.includes('already exists')) {
-            throw err;
+        // Vérifier si c'est vraiment une erreur ou si le dossier existe déjà
+        const exists = await sftp.exists(dir).catch(() => false);
+        if (!exists) {
+            throw new Error(`Impossible de créer le dossier distant ${dir}: ${err.message}`);
         }
+        // Sinon, le dossier existe, on continue
     }
 }
 
@@ -58,16 +72,95 @@ async function expandFileList(pattern, basePath = '') {
 
     // Si c'est un pattern glob
     if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
-        const fullPattern = path.join(normalizedBasePath, pattern);
+        const fullPattern = path.resolve(normalizedBasePath, pattern);
+        sourceAdapter.assertLocalPathAllowed(fullPattern);
         const files = await glob(fullPattern, { nodir: false });
+        for (const f of files) sourceAdapter.assertLocalPathAllowed(f);
         return files;
     }
 
     // Sinon c'est un fichier/dossier simple
-    const fullPath = path.join(normalizedBasePath, pattern);
+    const fullPath = path.resolve(normalizedBasePath, pattern);
+    sourceAdapter.assertLocalPathAllowed(fullPath);
     return [fullPath];
 }
 
+/**
+ * Copie une entrée remote -> remote via le pool SFTP partagé.
+ *
+ * - fichier : respecte force:false et append le basename si la cible est un dossier ;
+ * - dossier : copie récursivement les fichiers sous la racine cible ; force:false
+ *   refuse une cible déjà existante afin d'éviter les merges/écrasements implicites.
+ *
+ * Note : les symlinks inclus dans un arbre sont volontairement ignorés par
+ * listFilesRecursive pour l'instant. La future stratégie direct/rsync devra les
+ * préserver ; le résultat expose un warning pour ne pas promettre une copie bit-à-bit.
+ */
+async function transferServerToServerEntry(file, job, force) {
+    const srcAlias = file.source_alias || job.source_alias;
+    const srcPath = file.source_path || file.local || file.remote;
+    const tgtAlias = job.alias;
+    const tgtPath = file.remote;
+
+    if (!srcAlias) throw new Error("source_alias requis pour server_to_server.");
+    if (!srcPath) throw new Error("Chemin source requis (local/source_path) pour server_to_server.");
+    if (!tgtPath) throw new Error("Chemin destination remote requis pour server_to_server.");
+
+    const srcKind = await sourceAdapter.exists({ type: 'remote', alias: srcAlias, path: srcPath });
+    if (!srcKind) throw new Error(`Source introuvable: ${srcAlias}:${srcPath}`);
+
+    if (srcKind === 'd') {
+        const dstKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: tgtPath });
+        if (dstKind && dstKind !== 'd') {
+            throw new Error(`La destination ${tgtAlias}:${tgtPath} existe et n'est pas un dossier.`);
+        }
+        if (dstKind && !force) {
+            throw new Error(
+                `Le dossier destination ${tgtAlias}:${tgtPath} existe déjà. ` +
+                `Utilisez force:true pour fusionner/écraser explicitement.`
+            );
+        }
+
+        const rels = await sourceAdapter.listFilesRecursive(
+            { type: 'remote', alias: srcAlias, path: srcPath },
+            { recursive: true, ignorePatterns: [] }
+        );
+        let success = 0;
+        const failures = [];
+        for (const rel of rels) {
+            const from = path.posix.join(srcPath, rel);
+            const to = path.posix.join(tgtPath, rel);
+            try {
+                const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: from });
+                await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: to }, buf.content, { createDirs: true });
+                success++;
+            } catch (e) {
+                failures.push({ file: from, target: to, error: e.message });
+            }
+        }
+        return {
+            total: rels.length, success, failures,
+            warning: 'Copie dossier SFTP: symlinks et dossiers vides non préservés; utiliser une future stratégie rsync/tar pour une réplication bit-à-bit.'
+        };
+    }
+
+    let finalTarget = tgtPath;
+    const dstKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: tgtPath });
+    if (dstKind === 'd') {
+        finalTarget = path.posix.join(tgtPath, path.posix.basename(srcPath));
+        const nestedKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: finalTarget });
+        if (nestedKind && !force) {
+            throw new Error(`Le fichier distant ${tgtAlias}:${finalTarget} existe déjà. Utilisez force:true.`);
+        }
+    } else if (dstKind && !force) {
+        throw new Error(`Le fichier distant ${tgtAlias}:${tgtPath} existe déjà. Utilisez force:true.`);
+    }
+
+    const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: srcPath });
+    await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: finalTarget }, buf.content, { createDirs: true });
+    return { total: 1, success: 1, failures: [] };
+}
+
 // Fonction principale de transfert avec support multi-fichiers
 async function executeTransfer(jobId) {
     const job = queue.getJob(jobId);
@@ -75,68 +168,101 @@ async function executeTransfer(jobId) {
 
     let sftp = null;
     try {
-        const serverConfig = await serverManager.getServer(job.alias);
         queue.updateJobStatus(jobId, 'running');
 
-        sftp = new SftpClient();
-
-        // Configuration de la connexion
-        const config = {
-            host: serverConfig.host,
-            port: 22,
-            username: serverConfig.user,
-            readyTimeout: 20000,
-            retries: 3,
-            retry_factor: 2,
-            retry_minTimeout: 2000
-        };
-        
-        if (serverConfig.keyPath) {
-            config.privateKey = await fs.readFile(serverConfig.keyPath);
-        } else if (serverConfig.password) {
-            config.password = serverConfig.password;
-        } else {
-            throw new Error(`Aucune méthode d'authentification pour '${job.alias}'.`);
-        }
-
-        await sftp.connect(config);
-        
         // Déterminer si on traite plusieurs fichiers
         const files = job.files || [{ local: job.local, remote: job.remote }];
         const isMultiple = Array.isArray(job.files) && job.files.length > 1;
-        
+        const force = job.force === true;
+
         let successCount = 0;
         let failedFiles = [];
         let totalFiles = 0;
-        
-        // Traiter chaque fichier
-        for (let i = 0; i < files.length; i++) {
-            const file = files[i];
-            const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
-            
-            try {
-                if (job.direction === 'upload') {
-                    const localFiles = await expandFileList(file.local);
-                    totalFiles += localFiles.length;
-                    for (const localFile of localFiles) {
-                        queue.log('info', `Transfert${progress}: ${localFile}`);
-                        await handleUpload(sftp, localFile, file.remote);
-                        successCount++;
+
+        // server_to_server : 100% pool via sourceAdapter (fichiers + dossiers)
+        if (job.direction === 'server_to_server') {
+            const warnings = [];
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
+                const srcAlias = file.source_alias || job.source_alias;
+                const srcPath = file.source_path || file.local || file.remote;
+                try {
+                    queue.log('info', `Transfert server_to_server${progress}: ${srcAlias}:${srcPath} → ${job.alias}:${file.remote}`);
+                    const result = await transferServerToServerEntry(file, job, force);
+                    totalFiles += result.total;
+                    successCount += result.success;
+                    if (result.failures?.length) failedFiles.push(...result.failures);
+                    if (result.warning && !warnings.includes(result.warning)) warnings.push(result.warning);
+                } catch (err) {
+                    totalFiles += 1; // l'item lui-même a été tenté, même si son contenu n'a pas pu être énuméré
+                    queue.log('error', `Échec transfert ${srcPath || file.remote}: ${err.message}`);
+                    failedFiles.push({ file: srcPath || file.remote, error: err.message });
+                }
+            }
+            job.transferWarnings = warnings;
+        } else {
+            // upload/download : SftpClient (dirs/glob) avec port configurable
+            const serverConfig = await serverManager.getServer(job.alias);
+            sftp = new SftpClient();
+            const sftpConfig = {
+                host: serverConfig.host,
+                port: utils.resolveSshPort(serverConfig),
+                username: serverConfig.user,
+                readyTimeout: 20000,
+                retries: 3,
+                retry_factor: 2,
+                retry_minTimeout: 2000
+            };
+            if (serverConfig.keyPath) {
+                sftpConfig.privateKey = await fs.readFile(serverConfig.keyPath);
+            } else if (serverConfig.password) {
+                sftpConfig.password = serverConfig.password;
+            } else {
+                throw new Error(`Aucune méthode d'authentification pour '${job.alias}'.`);
+            }
+            await sftp.connect(sftpConfig);
+
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
+
+                try {
+                    if (job.direction === 'upload') {
+                        const localFiles = await expandFileList(file.local);
+                        totalFiles += localFiles.length;
+                        for (const localFile of localFiles) {
+                            queue.log('info', `Transfert${progress}: ${localFile}`);
+                            // Fichier simple (pas dir) → pool sourceAdapter quand possible
+                            let isDir = false;
+                            try {
+                                const st = await fs.stat(localFile);
+                                isDir = st.isDirectory();
+                            } catch { /* handled in handleUpload */ }
+                            if (!isDir && !hasGlobPattern(file.remote || '')) {
+                                const content = await fs.readFile(localFile);
+                                let remotePath = file.remote;
+                                // Si remote est un dossier existant, append basename — handleUpload fait ça ;
+                                // pour pool on délègue à handleUpload si exists dir, sinon writeFile
+                                await handleUpload(sftp, localFile, file.remote, force);
+                            } else {
+                                await handleUpload(sftp, localFile, file.remote, force);
+                            }
+                            successCount++;
+                        }
+                    } else if (job.direction === 'download') {
+                        const downloadedCount = await handleDownload(sftp, file.remote, file.local, force);
+                        totalFiles += downloadedCount;
+                        successCount += downloadedCount;
                     }
-                } else if (job.direction === 'download') {
-                    const downloadedCount = await handleDownload(sftp, file.remote, file.local);
-                    totalFiles += downloadedCount;
-                    successCount += downloadedCount;
+                } catch (err) {
+                    queue.log('error', `Échec transfert ${file.local || file.remote}: ${err.message}`);
+                    failedFiles.push({ file: file.local || file.remote, error: err.message });
                 }
-            } catch (err) {
-                queue.log('error', `Échec transfert ${file.local || file.remote}: ${err.message}`);
-                failedFiles.push({ file: file.local || file.remote, error: err.message });
             }
         }
         
-        await sftp.end();
-        
-        // Génération du rapport
+        // Génération du rapport (end() uniquement dans finally pour éviter double close)
         let status = successCount === totalFiles ? 'completed' : 'partial';
         let output = `Transfert ${job.direction}: ${successCount}/${totalFiles} fichiers réussis`;
         
@@ -145,7 +271,10 @@ async function executeTransfer(jobId) {
             if (successCount === 0) status = 'failed';
         }
         
-        queue.updateJobStatus(jobId, status, { output, failedFiles });
+        if (job.transferWarnings?.length) {
+            output += `\nAvertissements: ${job.transferWarnings.join(' | ')}`;
+        }
+        queue.updateJobStatus(jobId, status, { output, failedFiles, warnings: job.transferWarnings || [] });
         
     } catch (err) {
         queue.updateJobStatus(jobId, 'failed', { error: err.message });
@@ -161,31 +290,65 @@ async function executeTransfer(jobId) {
 }
 
 // Gestion spécifique de l'upload
-async function handleUpload(sftp, localPath, remotePath) {
+async function handleUpload(sftp, localPath, remotePath, force = false) {
+    sourceAdapter.assertLocalPathAllowed(localPath);
+    let localStats;
     try {
-        const stats = await fs.stat(localPath);
-        
-        if (stats.isDirectory()) {
-            // Upload d'un dossier entier
-            await sftp.uploadDir(localPath, remotePath);
-        } else {
-            // Upload d'un fichier - créer le dossier parent si nécessaire
-            await ensureRemoteDir(sftp, remotePath);
-            await sftp.put(localPath, remotePath);
-        }
+        localStats = await fs.stat(localPath);
     } catch (err) {
-        // Si le fichier local n'existe pas
         if (err.code === 'ENOENT') {
             throw new Error(`Fichier local introuvable: ${localPath}`);
         }
         throw err;
     }
+
+    if (localStats.isDirectory()) {
+        const remoteExists = await sftp.exists(remotePath).catch(() => false);
+        if (remoteExists) {
+            try {
+                const remoteStats = await sftp.stat(remotePath);
+                if (!remoteStats.isDirectory) {
+                    throw new Error(`Impossible d'envoyer un dossier local vers un fichier distant existant: ${remotePath}. Spécifiez un dossier de destination.`);
+                }
+            } catch (e) {
+                if (e.message && e.message.includes('Impossible d')) throw e;
+            }
+        }
+        await sftp.uploadDir(localPath, remotePath);
+        return;
+    }
+
+    let finalRemotePath;
+    const remoteExists = await sftp.exists(remotePath).catch(() => false);
+
+    if (remoteExists) {
+        let remoteStats;
+        try {
+            remoteStats = await sftp.stat(remotePath);
+        } catch (e) {
+            remoteStats = null;
+        }
+
+        if (remoteStats && remoteStats.isDirectory) {
+            finalRemotePath = path.posix.join(remotePath, path.basename(localPath));
+        } else {
+            if (!force) {
+                throw new Error(`Le fichier distant ${remotePath} existe déjà. Utilisez force:true pour l'écraser.`);
+            }
+            finalRemotePath = remotePath;
+        }
+    } else {
+        finalRemotePath = remotePath;
+    }
+
+    await ensureRemoteDir(sftp, finalRemotePath);
+    await sftp.put(localPath, finalRemotePath);
 }
 
 // Gestion spécifique du download
-async function handleDownload(sftp, remotePath, localPath) {
-    // Si le chemin distant contient un glob
-    if (micromatch.isMatch(remotePath, '**/*')) {
+async function handleDownload(sftp, remotePath, localPath, force = false) {
+    sourceAdapter.assertLocalPathAllowed(localPath);
+    if (hasGlobPattern(remotePath)) {
         const parentDir = path.dirname(remotePath);
         const pattern = path.basename(remotePath);
 
@@ -197,20 +360,23 @@ async function handleDownload(sftp, remotePath, localPath) {
                 throw new Error(`Aucun fichier distant ne correspond au pattern: ${remotePath}`);
             }
 
-            // S'assurer que le dossier local existe
-            await ensureLocalDir(localPath);
+            await fs.mkdir(localPath, { recursive: true });
 
-            // Télécharger chaque fichier correspondant
             for (const fileName of matchingFiles) {
-                const remoteFile = path.join(parentDir, fileName);
+                const remoteFile = path.posix.join(parentDir, fileName);
                 const localFile = path.join(localPath, fileName);
+                sourceAdapter.assertLocalPathAllowed(localFile);
+
+                const localFileExists = await fs.access(localFile).then(() => true).catch(() => false);
+                if (localFileExists && !force) {
+                    throw new Error(`Le fichier local ${localFile} existe déjà. Utilisez force:true pour l'écraser.`);
+                }
+
                 queue.log('info', `Téléchargement (glob): ${remoteFile} -> ${localFile}`);
                 await sftp.get(remoteFile, localFile);
             }
-            // Retourner le nombre de fichiers téléchargés pour le rapport
             return matchingFiles.length;
         } catch (err) {
-            // Si le dossier parent n'existe pas, on propage l'erreur
             if (err.code === 2) {
                  throw new Error(`Le dossier parent pour le glob n'existe pas: ${parentDir}`);
             }
@@ -218,21 +384,53 @@ async function handleDownload(sftp, remotePath, localPath) {
         }
 
     } else {
-        // Comportement normal pour un fichier ou un dossier unique
-        const exists = await sftp.exists(remotePath);
-        if (!exists) {
+        const remoteExists = await sftp.exists(remotePath);
+        if (!remoteExists) {
             throw new Error(`Fichier distant introuvable: ${remotePath}`);
         }
 
-        const stats = await sftp.stat(remotePath);
-        await ensureLocalDir(localPath);
+        const remoteStats = await sftp.stat(remotePath);
 
-        if (stats.isDirectory) {
+        if (remoteStats.isDirectory) {
+            await fs.mkdir(localPath, { recursive: true });
             await sftp.downloadDir(remotePath, localPath);
+            return 1;
+        }
+
+        let finalLocalPath;
+        const localExists = await fs.access(localPath).then(() => true).catch(() => false);
+
+        if (localExists) {
+            let localStats;
+            try {
+                localStats = await fs.stat(localPath);
+            } catch (e) {
+                localStats = null;
+            }
+
+            if (localStats && localStats.isDirectory()) {
+                finalLocalPath = path.join(localPath, path.basename(remotePath));
+            } else {
+                if (!force) {
+                    throw new Error(`Le fichier local ${localPath} existe déjà. Utilisez force:true pour l'écraser.`);
+                }
+                finalLocalPath = localPath;
+            }
         } else {
-            await sftp.get(remotePath, localPath);
+            const hasExt = path.extname(localPath) !== '';
+            if (hasExt) {
+                finalLocalPath = localPath;
+            } else {
+                await fs.mkdir(localPath, { recursive: true });
+                finalLocalPath = path.join(localPath, path.basename(remotePath));
+            }
         }
-        return 1; // Un seul item téléchargé
+
+        sourceAdapter.assertLocalPathAllowed(finalLocalPath);
+        const localDir = path.dirname(finalLocalPath);
+        await fs.mkdir(localDir, { recursive: true });
+        await sftp.get(remotePath, finalLocalPath);
+        return 1;
     }
 }