@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.3.0

package/sftp.js

@@ -4,6 +4,8 @@ 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';
 
 // Fonction utilitaire pour créer un dossier parent si nécessaire
@@ -17,20 +19,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,13 +71,13 @@ 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);
         const files = await glob(fullPattern, { nodir: false });
         return files;
     }
 
     // Sinon c'est un fichier/dossier simple
-    const fullPath = path.join(normalizedBasePath, pattern);
+    const fullPath = path.resolve(normalizedBasePath, pattern);
     return [fullPath];
 }
 
@@ -104,29 +117,41 @@ async function executeTransfer(jobId) {
         // 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);
+                        await handleUpload(sftp, localFile, file.remote, force);
                         successCount++;
                     }
                 } else if (job.direction === 'download') {
-                    const downloadedCount = await handleDownload(sftp, file.remote, file.local);
+                    const downloadedCount = await handleDownload(sftp, file.remote, file.local, force);
                     totalFiles += downloadedCount;
                     successCount += downloadedCount;
+                } else if (job.direction === 'server_to_server') {
+                    // Transfert direct entre deux serveurs distants (ou local↔remote inversé)
+                    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;
+
+                    queue.log('info', `Transfert server_to_server${progress}: ${srcAlias}:${srcPath} → ${tgtAlias}:${tgtPath}`);
+                    const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: srcPath });
+                    await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: tgtPath }, buf.content, { createDirs: true });
+                    successCount++;
+                    totalFiles++;
                 }
             } catch (err) {
                 queue.log('error', `Échec transfert ${file.local || file.remote}: ${err.message}`);
@@ -161,31 +186,63 @@ async function executeTransfer(jobId) {
 }
 
 // Gestion spécifique de l'upload
-async function handleUpload(sftp, localPath, remotePath) {
+async function handleUpload(sftp, localPath, remotePath, force = false) {
+    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) {
+    if (hasGlobPattern(remotePath)) {
         const parentDir = path.dirname(remotePath);
         const pattern = path.basename(remotePath);
 
@@ -197,20 +254,22 @@ 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 localFile = path.join(localPath, fileName);
+
+                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 +277,52 @@ 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é
+
+        const localDir = path.dirname(finalLocalPath);
+        await fs.mkdir(localDir, { recursive: true });
+        await sftp.get(remotePath, finalLocalPath);
+        return 1;
     }
 }
 

package/shellSessions.js

@@ -0,0 +1,237 @@
+import { Client } from 'ssh2';
+import fs from 'fs/promises';
+import crypto from 'crypto';
+import serverManager from './servers.js';
+
+/**
+ * shellSessions — Sessions shell PTY PERSISTANTES sur serveurs distants.
+ *
+ * Contrairement à task_exec (client.exec() = nouveau shell isolé à chaque appel),
+ * ici on ouvre un vrai shell interactif (client.shell()) maintenu ouvert. Ainsi
+ * `cd`, `export`, activations d'environnement, etc. PERSISTENT entre les commandes.
+ *
+ * === Détection de fin de commande (technique du marqueur echo-agnostique) ===
+ * Après chaque commande, on envoie : printf '%s:%s\n' "MARKER" "$?"
+ *   - La sortie RÉELLE du printf donne "MARKER:0" (exit code résolu en nombre).
+ *   - La ligne de commande ÉCHO (si echo actif) contient "MARKER:$?" (littéral).
+ *   - La regex /MARKER:(\d+)/ ne matche QUE la sortie réelle → jamais l'écho.
+ * De plus on désactive l'écho du PTY (stty -echo) dès l'ouverture pour un parsing net.
+ *
+ * Chaque session utilise une connexion SSH DÉDIÉE (pas le pool) car le shell
+ * monopolise le canal pour toute sa durée de vie.
+ */
+
+const DEFAULT_IDLE_TIMEOUT = 30 * 60 * 1000; // 30 min d'inactivité → fermeture auto
+const DEFAULT_CMD_TIMEOUT = 300;             // secondes
+
+class ShellSessionManager {
+    constructor() {
+        this.sessions = new Map(); // id → session
+        this._startCleanup();
+    }
+
+    async _buildConnectConfig(alias) {
+        const sc = await serverManager.getServer(alias);
+        const config = {
+            host: sc.host,
+            port: sc.port || 22,
+            username: sc.user,
+            readyTimeout: 20000,
+            keepaliveInterval: 30000,
+            keepaliveCountMax: 3
+        };
+        if (sc.keyPath) {
+            config.privateKey = await fs.readFile(sc.keyPath);
+        } else if (sc.password) {
+            config.password = sc.password;
+        } else {
+            throw new Error(`Aucune méthode d'authentification pour le serveur '${alias}'.`);
+        }
+        return config;
+    }
+
+    /**
+     * Crée une session shell persistante.
+     * options = { workdir, env: {K:V}, cmdTimeout }
+     * Retourne { id, alias, ready }.
+     */
+    async createSession(alias, options = {}) {
+        const config = await this._buildConnectConfig(alias);
+        const conn = new Client();
+
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            conn.on('ready', () => { if (!settled) { settled = true; resolve(); } });
+            conn.on('error', (err) => { if (!settled) { settled = true; reject(err); } });
+            conn.connect(config);
+        });
+
+        const stream = await new Promise((resolve, reject) => {
+            conn.shell({ term: 'xterm', modes: {} }, (err, s) => err ? reject(err) : resolve(s));
+        });
+
+        const id = `sh_${alias}_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
+        const session = {
+            id, alias, conn, stream,
+            buffer: '',
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+            commandCount: 0,
+            busy: false,
+            closed: false,
+            cmdTimeout: options.cmdTimeout || DEFAULT_CMD_TIMEOUT
+        };
+
+        stream.on('data', (d) => { session.buffer += d.toString('utf8'); });
+        stream.on('close', () => { session.closed = true; });
+        conn.on('error', () => { session.closed = true; });
+
+        this.sessions.set(id, session);
+
+        // Setup : désactive l'écho (parsing net) et vide le prompt
+        await this._exec(session, "stty -echo 2>/dev/null; export PS1=''; export PS2=''", 15);
+
+        // Répertoire de travail initial
+        if (options.workdir) {
+            const r = await this._exec(session, `cd ${this._shellQuote(options.workdir)}`, 15);
+            if (r.exitCode !== 0) {
+                this.closeSession(id);
+                throw new Error(`Impossible de cd vers '${options.workdir}': ${r.output}`);
+            }
+        }
+
+        // Variables d'environnement initiales
+        if (options.env && typeof options.env === 'object') {
+            for (const [k, v] of Object.entries(options.env)) {
+                await this._exec(session, `export ${k}=${this._shellQuote(String(v))}`, 15);
+            }
+        }
+
+        return { id, alias, ready: true };
+    }
+
+    _shellQuote(str) {
+        // Quote sûr pour bash : entoure de ' et échappe les ' internes
+        return `'${String(str).replace(/'/g, `'\\''`)}'`;
+    }
+
+    /**
+     * Exécute une commande dans la session et attend le marqueur de fin.
+     * Retourne { output, exitCode, timedOut }.
+     */
+    async _exec(session, command, timeoutSec) {
+        const marker = `__ORCH_${crypto.randomBytes(8).toString('hex')}__`;
+        const re = new RegExp(`${marker}:(-?\\d+)`);
+
+        // Vide le buffer juste avant d'écrire (les commandes sont sérialisées via busy)
+        session.buffer = '';
+
+        // Commande utilisateur, puis marqueur avec code de sortie de CETTE commande
+        session.stream.write(`${command}\n`);
+        session.stream.write(`printf '%s:%s\\n' "${marker}" "$?"\n`);
+
+        const timeoutMs = timeoutSec === 0 ? 0 : (timeoutSec || DEFAULT_CMD_TIMEOUT) * 1000;
+        const start = Date.now();
+
+        return new Promise((resolve) => {
+            const check = setInterval(() => {
+                const m = session.buffer.match(re);
+                if (m) {
+                    clearInterval(check);
+                    const exitCode = parseInt(m[1], 10);
+                    const raw = session.buffer.slice(0, m.index);
+                    resolve({ output: this._clean(raw, marker).trim(), exitCode, timedOut: false });
+                } else if (session.closed) {
+                    clearInterval(check);
+                    resolve({ output: this._clean(session.buffer, marker).trim(), exitCode: null, timedOut: false, closed: true });
+                } else if (timeoutMs > 0 && Date.now() - start > timeoutMs) {
+                    clearInterval(check);
+                    // Tente de débloquer la commande (Ctrl-C) sans tuer la session
+                    try { session.stream.write('\x03'); } catch (e) { /* ignore */ }
+                    resolve({ output: this._clean(session.buffer, marker).trim(), exitCode: null, timedOut: true });
+                }
+            }, 100);
+        });
+    }
+
+    // Nettoie la sortie : strip séquences ANSI (couleurs, bracketed-paste \x1b[?2004h/l),
+    // strip les \r du PTY, retire les lignes écho/marqueur.
+    _clean(output, marker) {
+        return output
+            // eslint-disable-next-line no-control-regex
+            .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '') // séquences CSI ANSI
+            .replace(/\r/g, '')
+            .split('\n')
+            .filter(line => !line.includes(marker) && !line.includes("printf '%s:%s"))
+            .join('\n');
+    }
+
+    /**
+     * Exécute une commande dans une session existante (état persistant).
+     */
+    async execInSession(id, command, timeoutSec) {
+        const session = this.sessions.get(id);
+        if (!session) throw new Error(`Session '${id}' introuvable. Utilisez shell_list pour voir les sessions actives.`);
+        if (session.closed) {
+            this.sessions.delete(id);
+            throw new Error(`Session '${id}' est fermée (connexion perdue). Créez-en une nouvelle avec shell_create.`);
+        }
+        if (session.busy) throw new Error(`Session '${id}' occupée : une seule commande à la fois par session.`);
+
+        session.busy = true;
+        session.lastUsed = Date.now();
+        session.commandCount++;
+        try {
+            return await this._exec(session, command, timeoutSec ?? session.cmdTimeout);
+        } finally {
+            session.busy = false;
+        }
+    }
+
+    /**
+     * Liste les sessions actives avec leur état.
+     */
+    listSessions() {
+        const now = Date.now();
+        return Array.from(this.sessions.values()).map(s => ({
+            id: s.id,
+            alias: s.alias,
+            ageSeconds: Math.round((now - s.createdAt) / 1000),
+            idleSeconds: Math.round((now - s.lastUsed) / 1000),
+            commandCount: s.commandCount,
+            busy: s.busy,
+            closed: s.closed
+        }));
+    }
+
+    /**
+     * Ferme proprement une session.
+     */
+    closeSession(id) {
+        const session = this.sessions.get(id);
+        if (!session) throw new Error(`Session '${id}' introuvable.`);
+        try { session.stream.end('exit\n'); } catch (e) { /* ignore */ }
+        try { session.conn.end(); } catch (e) { /* ignore */ }
+        this.sessions.delete(id);
+        return { closed: true, id };
+    }
+
+    _startCleanup() {
+        setInterval(() => {
+            const now = Date.now();
+            for (const [id, s] of this.sessions) {
+                if (s.closed || (!s.busy && (now - s.lastUsed) > DEFAULT_IDLE_TIMEOUT)) {
+                    try { this.closeSession(id); } catch (e) { /* ignore */ }
+                }
+            }
+        }, 60000);
+    }
+
+    closeAll() {
+        for (const id of [...this.sessions.keys()]) {
+            try { this.closeSession(id); } catch (e) { /* ignore */ }
+        }
+    }
+}
+
+export default new ShellSessionManager();