@fkom13/mcp-sftp-orchestrator 6.0.0

package/sshPool.js

@@ -0,0 +1,272 @@
+import { Client } from 'ssh2';
+import fs from 'fs/promises';
+import queue from './queue.js';
+
+class SSHConnectionPool {
+    constructor() {
+        this.pools = new Map(); // Map<serverAlias, Connection[]>
+        this.activeConnections = new Map(); // Map<connectionId, {conn, serverAlias, inUse, lastUsed}>
+        this.config = {
+            maxConnections: 5,      // Max connexions par serveur
+            minConnections: 1,      // Min connexions maintenues
+            idleTimeout: 300000,    // 5 minutes avant fermeture si inactif
+            keepAliveInterval: 30000, // Keep-alive toutes les 30s
+            connectionTimeout: 20000,
+            retryAttempts: 3
+        };
+        
+        // Nettoyage périodique des connexions inactives
+        this.startCleanupInterval();
+    }
+    
+    // Obtenir ou créer une connexion
+    async getConnection(serverAlias, serverConfig) {
+        // Chercher une connexion disponible
+        const pool = this.pools.get(serverAlias) || [];
+        
+        for (const connId of pool) {
+            const connInfo = this.activeConnections.get(connId);
+            if (connInfo && !connInfo.inUse && connInfo.conn.isReady) {
+                connInfo.inUse = true;
+                connInfo.lastUsed = Date.now();
+                queue.log('info', `Réutilisation connexion SSH existante pour ${serverAlias}`);
+                return { id: connId, client: connInfo.conn };
+            }
+        }
+        
+        // Si pas de connexion disponible, en créer une nouvelle
+        if (pool.length < this.config.maxConnections) {
+            const newConn = await this.createConnection(serverAlias, serverConfig);
+            return newConn;
+        }
+        
+        // Si pool plein, attendre qu'une connexion se libère
+        queue.log('warn', `Pool SSH saturé pour ${serverAlias}, attente...`);
+        return await this.waitForConnection(serverAlias, serverConfig);
+    }
+    
+    // Créer une nouvelle connexion
+    async createConnection(serverAlias, serverConfig) {
+        const conn = new Client();
+        const connId = `${serverAlias}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        
+        return new Promise((resolve, reject) => {
+            let retries = 0;
+            
+            const tryConnect = async () => {
+                try {
+                    const config = {
+                        host: serverConfig.host,
+                        port: 22,
+                        username: serverConfig.user,
+                        readyTimeout: this.config.connectionTimeout,
+                        keepaliveInterval: this.config.keepAliveInterval,
+                        keepaliveCountMax: 3
+                    };
+                    
+                    if (serverConfig.keyPath) {
+                        config.privateKey = await fs.readFile(serverConfig.keyPath);
+                    } else if (serverConfig.password) {
+                        config.password = serverConfig.password;
+                    }
+                    
+                    conn.on('ready', () => {
+                        queue.log('info', `Nouvelle connexion SSH établie pour ${serverAlias}`);
+                        
+                        // Ajouter au pool
+                        if (!this.pools.has(serverAlias)) {
+                            this.pools.set(serverAlias, []);
+                        }
+                        this.pools.get(serverAlias).push(connId);
+                        
+                        // Enregistrer la connexion
+                        this.activeConnections.set(connId, {
+                            conn,
+                            serverAlias,
+                            inUse: true,
+                            lastUsed: Date.now(),
+                            config: serverConfig
+                        });
+                        
+                        // Ajouter un flag pour vérifier si la connexion est prête
+                        conn.isReady = true;
+                        
+                        resolve({ id: connId, client: conn });
+                    });
+                    
+                    conn.on('error', (err) => {
+                        conn.isReady = false;
+                        if (retries < this.config.retryAttempts) {
+                            retries++;
+                            queue.log('warn', `Tentative ${retries}/${this.config.retryAttempts} de connexion à ${serverAlias}`);
+                            setTimeout(tryConnect, 2000 * retries);
+                        } else {
+                            this.removeConnection(connId);
+                            reject(new Error(`Impossible de se connecter à ${serverAlias}: ${err.message}`));
+                        }
+                    });
+                    
+                    conn.on('close', () => {
+                        conn.isReady = false;
+                        this.removeConnection(connId);
+                        queue.log('info', `Connexion SSH fermée pour ${serverAlias}`);
+                    });
+                    
+                    conn.connect(config);
+                } catch (err) {
+                    reject(err);
+                }
+            };
+            
+            tryConnect();
+        });
+    }
+    
+    // Libérer une connexion
+    releaseConnection(connId) {
+        const connInfo = this.activeConnections.get(connId);
+        if (connInfo) {
+            connInfo.inUse = false;
+            connInfo.lastUsed = Date.now();
+            queue.log('debug', `Connexion ${connId} libérée`);
+        }
+    }
+    
+    // Fermer une connexion spécifique
+    closeConnection(connId) {
+        const connInfo = this.activeConnections.get(connId);
+        if (connInfo) {
+            try {
+                connInfo.conn.end();
+            } catch (e) {
+                // Ignorer les erreurs de fermeture
+            }
+            this.removeConnection(connId);
+        }
+    }
+    
+    // Retirer une connexion du pool
+    removeConnection(connId) {
+        const connInfo = this.activeConnections.get(connId);
+        if (connInfo) {
+            const pool = this.pools.get(connInfo.serverAlias);
+            if (pool) {
+                const index = pool.indexOf(connId);
+                if (index > -1) {
+                    pool.splice(index, 1);
+                }
+                if (pool.length === 0) {
+                    this.pools.delete(connInfo.serverAlias);
+                }
+            }
+            this.activeConnections.delete(connId);
+        }
+    }
+    
+    // Attendre qu'une connexion se libère
+    async waitForConnection(serverAlias, serverConfig, timeout = 30000) {
+        const startTime = Date.now();
+        
+        return new Promise((resolve, reject) => {
+            const checkInterval = setInterval(async () => {
+                // Vérifier le timeout
+                if (Date.now() - startTime > timeout) {
+                    clearInterval(checkInterval);
+                    reject(new Error(`Timeout en attendant une connexion pour ${serverAlias}`));
+                    return;
+                }
+                
+                // Essayer d'obtenir une connexion
+                const pool = this.pools.get(serverAlias) || [];
+                for (const connId of pool) {
+                    const connInfo = this.activeConnections.get(connId);
+                    if (connInfo && !connInfo.inUse && connInfo.conn.isReady) {
+                        clearInterval(checkInterval);
+                        connInfo.inUse = true;
+                        connInfo.lastUsed = Date.now();
+                        resolve({ id: connId, client: connInfo.conn });
+                        return;
+                    }
+                }
+            }, 500);
+        });
+    }
+    
+    // Nettoyer les connexions inactives
+    startCleanupInterval() {
+        setInterval(() => {
+            const now = Date.now();
+            
+            for (const [connId, connInfo] of this.activeConnections) {
+                // Fermer les connexions inactives depuis trop longtemps
+                if (!connInfo.inUse && (now - connInfo.lastUsed) > this.config.idleTimeout) {
+                    const pool = this.pools.get(connInfo.serverAlias) || [];
+                    
+                    // Garder au moins minConnections
+                    if (pool.length > this.config.minConnections) {
+                        queue.log('info', `Fermeture connexion inactive: ${connId}`);
+                        this.closeConnection(connId);
+                    }
+                }
+                
+                // Vérifier que la connexion est toujours vivante
+                if (!connInfo.conn.isReady && !connInfo.inUse) {
+                    this.removeConnection(connId);
+                }
+            }
+        }, 60000); // Vérifier toutes les minutes
+    }
+    
+    // Obtenir les statistiques du pool
+    getStats() {
+        const stats = {
+            totalConnections: this.activeConnections.size,
+            byServer: {}
+        };
+        
+        for (const [serverAlias, pool] of this.pools) {
+            const connections = pool.map(connId => {
+                const info = this.activeConnections.get(connId);
+                return {
+                    id: connId,
+                    inUse: info?.inUse || false,
+                    ready: info?.conn?.isReady || false,
+                    lastUsed: info?.lastUsed
+                };
+            });
+            
+            stats.byServer[serverAlias] = {
+                total: connections.length,
+                inUse: connections.filter(c => c.inUse).length,
+                available: connections.filter(c => !c.inUse && c.ready).length,
+                connections
+            };
+        }
+        
+        return stats;
+    }
+    
+    // Fermer toutes les connexions
+    closeAll() {
+        queue.log('info', 'Fermeture de toutes les connexions SSH...');
+        for (const connId of this.activeConnections.keys()) {
+            this.closeConnection(connId);
+        }
+    }
+}
+
+// Instance singleton
+const sshPool = new SSHConnectionPool();
+
+// Nettoyer à la fermeture du processus
+process.on('SIGINT', () => {
+    sshPool.closeAll();
+    process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+    sshPool.closeAll();
+    process.exit(0);
+});
+
+export default sshPool;

package/test_features.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import queue from './queue.js';
+import sshPool from './sshPool.js';
+import { glob } from 'glob';
+import path from 'path';
+
+console.log('🧪 Test des fonctionnalités MCP Orchestrator v6.0\n');
+
+// Test 1: Queue persistante
+console.log('✅ Test Queue:');
+const testJob = queue.addJob({
+    type: 'test',
+    alias: 'test_server',
+    cmd: 'echo "Test"',
+    status: 'pending'
+});
+console.log(`  - Tâche créée: ${testJob.id}`);
+console.log(`  - Stats queue:`, queue.getStats());
+
+// Test 2: Pool de connexions
+console.log('\n✅ Test Pool SSH:');
+const poolStats = sshPool.getStats();
+console.log(`  - Connexions totales: ${poolStats.totalConnections}`);
+console.log(`  - Serveurs actifs: ${Object.keys(poolStats.byServer).length}`);
+
+// Test 3: Patterns Glob
+console.log('\n✅ Test Patterns Glob:');
+async function testGlob() {
+    const patterns = ['*.js', '*.json'];
+    for (const pattern of patterns) {
+        const files = await glob(pattern, { cwd: process.cwd() });
+        console.log(`  - Pattern "${pattern}": ${files.length} fichiers trouvés`);
+    }
+}
+
+// Test 4: Détection de prompts interactifs
+console.log('\n✅ Test Détection Prompts:');
+const testPrompts = [
+    'Are you sure you want to continue? (yes/no)',
+    'Password:',
+    'Do you want to continue [Y/n]?',
+    'Save configuration?'
+];
+
+function detectPrompt(text) {
+    const patterns = {
+        'continue': /continue.*\?/i,
+        'password': /password:/i,
+        'yes/no': /\(yes\/no\)/i,
+        'y/n': /\[y\/n\]/i,
+        'save': /save.*\?/i
+    };
+    
+    for (const [name, regex] of Object.entries(patterns)) {
+        if (regex.test(text)) {
+            return name;
+        }
+    }
+    return null;
+}
+
+testPrompts.forEach(prompt => {
+    const detected = detectPrompt(prompt);
+    console.log(`  - "${prompt.substring(0, 30)}..." → ${detected || 'non détecté'}`);
+});
+
+// Test 5: Logs système
+console.log('\n✅ Test Logs:');
+queue.log('info', 'Test log info');
+queue.log('warn', 'Test log warning');
+queue.log('error', 'Test log error');
+const logs = queue.getLogs({ limit: 3 });
+console.log(`  - ${logs.length} logs récupérés`);
+
+// Test 6: Gestion des tâches crashées
+console.log('\n✅ Test Gestion Crashes:');
+const crashedJob = queue.addJob({
+    type: 'test_crash',
+    alias: 'test',
+    status: 'running'
+});
+queue.updateJobStatus(crashedJob.id, 'crashed', { 
+    canRetry: true,
+    crashedAt: new Date()
+});
+const crashed = queue.getCrashedJobs();
+console.log(`  - Tâches crashées: ${crashed.length}`);
+if (crashed.length > 0) {
+    console.log(`  - Peut être relancée: ${crashed[0].canRetry}`);
+}
+
+// Test 7: Statistiques
+console.log('\n✅ Résumé des Statistiques:');
+const finalStats = queue.getStats();
+console.log(`  - Total tâches: ${finalStats.total}`);
+console.log(`  - Par statut:`, finalStats.byStatus);
+console.log(`  - Par type:`, finalStats.byType);
+console.log(`  - Taux de succès: ${finalStats.successRate}%`);
+
+// Exécuter les tests asynchrones
+testGlob().then(() => {
+    console.log('\n✨ Tous les tests sont passés avec succès!');
+    console.log('📝 Note: Ce sont des tests unitaires, pas des tests de connexion réelle.');
+    
+    // Nettoyer
+    queue.cleanOldJobs();
+    process.exit(0);
+}).catch(err => {
+    console.error('❌ Erreur lors des tests:', err);
+    process.exit(1);
+});