@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

package/ssh.js

@@ -4,6 +4,8 @@ import queue from './queue.js';
 import serverManager from './servers.js';
 import sshPool from './sshPool.js';
 import config from './config.js';
+import policies from './policies.js';
+import utils from './utils.js';
 
 const STREAMING_COMMANDS = [
     /^pm2\s+logs?\b/i,
@@ -25,32 +27,56 @@ function isStreamingCommand(cmd) {
 
 // Configuration des réponses automatiques pour les prompts interactifs
 const INTERACTIVE_RESPONSES = {
-    // Patterns courants et leurs réponses
     'continue connecting': 'yes',
     'Are you sure': 'yes',
-    'password:': null, // Sera géré séparément
-    'Password:': null,
     'Do you want to continue': 'y',
+    '[y/n]': 'y',
+    '(yes/no)': 'yes',
+    '(y/N)': 'y',
+    '(Y/n)': 'y',
     'Overwrite': 'y',
-    'Save': 'y'
+    'Save': 'y',
+    'accept': 'yes',
+    'confirm': 'yes',
+    'password:': 'PASSWORD_REQUIRED',
+    'Password:': 'PASSWORD_REQUIRED',
+    'sudo': 'PASSWORD_REQUIRED'
 };
 
 // Détecte si une sortie contient un prompt interactif
-function detectInteractivePrompt(output) {
+function detectInteractivePrompt(output, customResponses = {}) {
     const lastLine = output.split('\n').pop().toLowerCase();
-    
+    const lastLines = output.split('\n').slice(-5).join('\n').toLowerCase();
+
+    // 1. Check custom responses first (supporte regex)
+    for (const [pattern, response] of Object.entries(customResponses)) {
+        try {
+            const regex = new RegExp(pattern, 'i');
+            if (regex.test(lastLines)) {
+                return { pattern, response, needsInput: true };
+            }
+        } catch (e) {
+            if (lastLines.includes(pattern.toLowerCase())) {
+                return { pattern, response, needsInput: true };
+            }
+        }
+    }
+
+    // 2. Check built-in patterns
     for (const [pattern, response] of Object.entries(INTERACTIVE_RESPONSES)) {
-        if (lastLine.includes(pattern.toLowerCase())) {
+        if (lastLines.includes(pattern.toLowerCase())) {
             return { pattern, response, needsInput: true };
         }
     }
-    
-    // Vérifier les patterns qui attendent une entrée
-    if (lastLine.endsWith(':') || lastLine.endsWith('?') || 
-        lastLine.includes('[y/n]') || lastLine.includes('(yes/no)')) {
+
+    // 3. Generic prompt detection
+    if (lastLine.endsWith(':') || lastLine.endsWith('?') ||
+        lastLine.includes('[y/n]') || lastLine.includes('(yes/no)') ||
+        lastLine.match(/^\s*\[\d+\]/) || lastLine.match(/^\s*\d+[.)]\s/) ||
+        lastLine.match(/choose|select|pick|enter|input/i)) {
         return { pattern: 'generic', response: null, needsInput: true };
     }
-    
+
     return { needsInput: false };
 }
 
@@ -60,14 +86,23 @@ async function executeCommand(jobId) {
     if (!job) return queue.log('error', `Tâche introuvable: ${jobId}`);
 
     let connection = null;
-    
+
     try {
         const serverConfig = await serverManager.getServer(job.alias);
+
+        if (!job.skip_policy) {
+            const policyCheck = await policies.check(job.cmd);
+            if (policyCheck.blocked) {
+                queue.updateJobStatus(jobId, 'failed', { error: `Commande bloquée par la politique de sécurité (pattern: "${policyCheck.pattern}"). Utilisez skip_policy:true pour forcer.` });
+                return;
+            }
+        }
+
         queue.updateJobStatus(jobId, 'running');
 
         // Utiliser le pool de connexions si pas de mode interactif
         const usePool = !job.interactive && job.persistent !== false;
-        
+
         if (usePool) {
             // Obtenir une connexion du pool
             connection = await sshPool.getConnection(job.alias, serverConfig);
@@ -76,9 +111,10 @@ async function executeCommand(jobId) {
             // Créer une connexion dédiée pour les commandes interactives
             await executeWithNewConnection(serverConfig, job, jobId);
         }
-        
+
     } catch (err) {
-        queue.updateJobStatus(jobId, 'failed', { error: err.message });
+        const existing = queue.getJob(jobId) || {};
+        queue.updateJobStatus(jobId, 'failed', { ...existing, error: err.message });
     } finally {
         // Libérer la connexion si elle vient du pool
         if (connection) {
@@ -88,7 +124,7 @@ async function executeCommand(jobId) {
 }
 
 // Exécution avec une connexion du pool
-async function executeWithPooledConnection(connection, job, jobId) {
+async function executeWithPooledConnection(connection, job, jobId, updateQueue = true) {
     return new Promise((resolve, reject) => {
         const { client } = connection;
 
@@ -119,38 +155,45 @@ async function executeWithPooledConnection(connection, job, jobId) {
                 reject(err);
                 return;
             }
-            
+
             let output = '';
             let stderr = '';
             let lineCount = 0;
             const startTime = Date.now();
             const maxLines = job.maxLines || 1000;
-            const timeout = job.timeout || config.defaultCommandTimeout;
-            
-            const timeoutId = setTimeout(() => {
-                stream.write('\x03'); // Envoyer Ctrl+C
-                setTimeout(() => {
-                    stream.close();
-                    const duration = Date.now() - startTime;
-                    const result = { output: output.trim(), stderr: stderr.trim(), exitCode: 124, duration, lineCount, timedOut: true };
-                    queue.updateJobStatus(jobId, 'completed', result);
-                    resolve(result);
-                }, 500);
-            }, timeout);
-            
+            const userTimeout = job.timeout; // en secondes, 0 = infini
+            const timeoutMs = userTimeout === 0 ? 0 : (userTimeout ? userTimeout * 1000 : config.defaultCommandTimeout);
+
+            let timeoutId = null;
+            if (timeoutMs > 0) {
+                timeoutId = setTimeout(() => {
+                    stream.write('\x03');
+                    setTimeout(() => {
+                        stream.close();
+                        const duration = Date.now() - startTime;
+                        const result = { output: output.trim(), stderr: stderr.trim(), exitCode: 124, duration, lineCount, timedOut: true };
+                        if (updateQueue) queue.updateJobStatus(jobId, 'completed', result);
+                        resolve(result);
+                    }, 500);
+                }, timeoutMs);
+            }
+
             stream.on('close', (code, signal) => {
-                clearTimeout(timeoutId);
+                if (timeoutId) clearTimeout(timeoutId);
                 const duration = Date.now() - startTime;
                 const result = { output: output.trim(), stderr: stderr.trim(), exitCode: code, signal, duration, lineCount };
+
+                // Important: clear any other timeouts if they exist (though timeoutId is the main one here)
+
                 if (code === 0 || code === 124) {
-                    queue.updateJobStatus(jobId, 'completed', result);
+                    if (updateQueue) queue.updateJobStatus(jobId, 'completed', result);
                     resolve(result);
                 } else {
-                    queue.updateJobStatus(jobId, 'failed', { ...result, error: `Commande terminée avec code ${code}` });
+                    if (updateQueue) queue.updateJobStatus(jobId, 'failed', { ...result, error: `Commande terminée avec code ${code}` });
                     reject(new Error(`Exit code: ${code}`));
                 }
             });
-            
+
             stream.on('data', (data) => {
                 const chunk = data.toString();
                 output += chunk;
@@ -160,14 +203,14 @@ async function executeWithPooledConnection(connection, job, jobId) {
                     setTimeout(() => stream.close(), 500);
                 }
                 if (job.autoRespond) {
-                    const prompt = detectInteractivePrompt(output);
-                    if (prompt.needsInput && prompt.response) {
+                    const prompt = detectInteractivePrompt(output, job.responses || {});
+                    if (prompt.needsInput && prompt.response && prompt.response !== 'PASSWORD_REQUIRED') {
                         stream.write(prompt.response + '\n');
                         queue.log('info', `Réponse automatique au prompt: ${prompt.pattern}`);
                     }
                 }
             });
-            
+
             stream.stderr.on('data', (data) => {
                 stderr += data.toString();
             });
@@ -193,22 +236,27 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
                 let responseSent = false;
 
                 const cleanupAndResolve = (status = 'completed') => {
-                    clearTimeout(jobTimeout);
+                    if (jobTimeout) clearTimeout(jobTimeout);
                     output = output.replace(END_MARKER, '').trim();
                     const result = { output, exitCode: 0 };
                     queue.updateJobStatus(jobId, status, result);
                     try {
                         stream.end();
                         conn.end();
-                    } catch(e) {/* ignore */}
+                    } catch (e) {/* ignore */ }
                     resolve(result);
                 };
 
-                const jobTimeout = setTimeout(() => {
-                    cleanupAndResolve('failed');
-                }, (job.timeout ? job.timeout * 1000 : config.interactiveCommandTimeout));
+                const timeoutMs = job.timeout === 0 ? 0 : (job.timeout ? job.timeout * 1000 : config.interactiveCommandTimeout);
+                let jobTimeout = null;
+                if (timeoutMs > 0) {
+                    jobTimeout = setTimeout(() => {
+                        cleanupAndResolve('failed');
+                    }, timeoutMs);
+                }
 
                 stream.on('close', () => {
+                    if (jobTimeout) clearTimeout(jobTimeout);
                     if (!output.includes(END_MARKER)) {
                         cleanupAndResolve('failed');
                     }
@@ -226,7 +274,7 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
                     if (!responseSent && job.autoRespond) {
                         const lowerChunk = chunk.toLowerCase();
                         let responseToSend = null;
-                        
+
                         // Chercher une réponse personnalisée
                         for (const [pattern, response] of Object.entries(responses)) {
                             if (lowerChunk.includes(pattern.toLowerCase())) {
@@ -235,7 +283,7 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
                                 break;
                             }
                         }
-                        
+
                         // Sinon, chercher une réponse par défaut
                         if (!responseToSend) {
                             for (const [pattern, response] of Object.entries(INTERACTIVE_RESPONSES)) {
@@ -270,11 +318,11 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
             reject(err);
         });
 
-        const connectConfig = { 
-            host: serverConfig.host, 
-            port: 22, 
-            username: serverConfig.user, 
-            readyTimeout: 20000 
+        const connectConfig = {
+            host: serverConfig.host,
+            port: utils.resolveSshPort(serverConfig),
+            username: serverConfig.user,
+            readyTimeout: 20000
         };
 
         (async () => {
@@ -302,56 +350,70 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
 async function executeCommandSequence(jobId) {
     const job = queue.getJob(jobId);
     if (!job) return queue.log('error', `Tâche introuvable: ${jobId}`);
-    
+
     const results = [];
     let connection = null;
-    
+
     try {
         const serverConfig = await serverManager.getServer(job.alias);
         queue.updateJobStatus(jobId, 'running');
-        
+
         // Obtenir une connexion du pool
         connection = await sshPool.getConnection(job.alias, serverConfig);
-        
+
         // Exécuter chaque commande en séquence
         for (let i = 0; i < job.commands.length; i++) {
             const cmd = job.commands[i];
             const stepJob = {
                 ...job,
                 cmd: typeof cmd === 'string' ? cmd : cmd.command,
-                timeout: cmd.timeout || job.timeout,
-                continueOnError: cmd.continueOnError || job.continueOnError
+                timeout: (typeof cmd === 'object' && cmd.timeout != null) ? cmd.timeout : job.timeout,
+                continueOnError: (typeof cmd === 'object' && cmd.continueOnError != null)
+                    ? cmd.continueOnError
+                    : job.continueOnError
             };
-            
+
+            // Policy par étape (sauf skip_policy)
+            if (!job.skip_policy) {
+                const policyCheck = await policies.check(stepJob.cmd);
+                if (policyCheck.blocked) {
+                    throw new Error(
+                        `Étape ${i + 1} bloquée par la politique de sécurité (pattern: "${policyCheck.pattern}"). ` +
+                        `Utilisez skip_policy:true pour forcer.`
+                    );
+                }
+            }
+
             try {
-                queue.log('info', `Exécution étape ${i+1}/${job.commands.length}: ${stepJob.cmd}`);
-                const result = await executeWithPooledConnection(connection, stepJob, `${jobId}_step_${i}`);
-                results.push({ 
-                    step: i + 1, 
-                    command: stepJob.cmd, 
-                    success: true, 
-                    ...result 
+                queue.log('info', `Exécution étape ${i + 1}/${job.commands.length}: ${stepJob.cmd}`);
+                // Don't update the main queue for sub-steps with phantom IDs
+                const result = await executeWithPooledConnection(connection, stepJob, `${jobId}_step_${i}`, false);
+                results.push({
+                    step: i + 1,
+                    command: stepJob.cmd,
+                    success: true,
+                    ...result
                 });
             } catch (err) {
-                results.push({ 
-                    step: i + 1, 
-                    command: stepJob.cmd, 
-                    success: false, 
-                    error: err.message 
+                results.push({
+                    step: i + 1,
+                    command: stepJob.cmd,
+                    success: false,
+                    error: err.message
                 });
-                
+
                 if (!stepJob.continueOnError) {
-                    throw new Error(`Échec à l'étape ${i+1}: ${err.message}`);
+                    throw new Error(`Échec à l'étape ${i + 1}: ${err.message}`);
                 }
             }
         }
-        
+
         queue.updateJobStatus(jobId, 'completed', { results });
-        
+
     } catch (err) {
-        queue.updateJobStatus(jobId, 'failed', { 
-            error: err.message, 
-            results 
+        queue.updateJobStatus(jobId, 'failed', {
+            error: err.message,
+            results
         });
     } finally {
         if (connection) {
@@ -419,7 +481,7 @@ function parseServicesStatus(output) {
 
     try {
         const sections = output.split(/---DOCKER---|---PM2---/);
-        const systemdRaw = sections[0] || '';
+        const systemdRaw = (sections[0] || '').replace(/^---SYSTEMD---\s*/, '');
         const dockerRaw = sections[1] || '';
         const pm2Raw = sections[2] || '';
 
@@ -467,26 +529,62 @@ function parseServicesStatus(output) {
 }
 
 function parseApiHealth(output) {
+    if (!output || typeof output !== 'string') {
+        return {
+            status: 'ERROR',
+            http_code: 0,
+            response_time_ms: 0,
+            error: 'Sortie invalide ou vide'
+        };
+    }
+
     try {
-        const [codeStr, timeStr] = output.split(':');
+        const parts = output.trim().split(':');
+        if (parts.length !== 2) {
+            return {
+                status: 'ERROR',
+                http_code: 0,
+                response_time_ms: 0,
+                error: 'Format de réponse invalide',
+                raw_output: output
+            };
+        }
+
+        const [codeStr, timeStr] = parts;
         const http_code = parseInt(codeStr, 10);
         const response_time_ms = parseFloat(timeStr) * 1000;
 
+        if (isNaN(http_code) || isNaN(response_time_ms)) {
+            return {
+                status: 'ERROR',
+                http_code: 0,
+                response_time_ms: 0,
+                error: 'Valeurs non numériques',
+                raw_output: output
+            };
+        }
+
         return {
             status: http_code >= 200 && http_code < 300 ? 'UP' : 'DOWN',
             http_code: http_code,
             response_time_ms: Math.round(response_time_ms)
         };
     } catch (e) {
-        return { status: 'ERROR', http_code: 0, response_time_ms: 0, parsing_error: e.message, raw_output: output };
+        return {
+            status: 'ERROR',
+            http_code: 0,
+            response_time_ms: 0,
+            error: e.message,
+            raw_output: output
+        };
     }
 }
 
-export default { 
-    executeCommand, 
-    executeCommandSequence, 
-    getPoolStats, 
-    parseSystemResources, 
-    parseServicesStatus, 
-    parseApiHealth 
+export default {
+    executeCommand,
+    executeCommandSequence,
+    getPoolStats,
+    parseSystemResources,
+    parseServicesStatus,
+    parseApiHealth
 };