@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

package/queue.js

@@ -5,8 +5,11 @@ import config from './config.js';
 
 const QUEUE_FILE = path.join(config.dataDir, 'queue.json');
 const QUEUE_BACKUP = path.join(config.dataDir, 'queue.backup.json');
-const SAVE_INTERVAL = 5000; // Sauvegarder toutes les 5 secondes
-const MAX_QUEUE_SIZE = 1000; // Limite de tâches en mémoire
+const SAVE_INTERVAL = config.saveInterval || 5000;
+const MAX_QUEUE_SIZE = config.maxQueueSize || 1000;
+
+// ✅ Mode silencieux par défaut (logs désactivés sauf si MCP_DEBUG=true)
+const SILENT_MODE = process.env.MCP_DEBUG !== 'true';
 
 const jobQueue = {};
 const logHistory = [];
@@ -14,37 +17,39 @@ const MAX_LOGS = 500;
 
 let saveTimer = null;
 let isDirty = false;
+let dirtyRevision = 0;
+
+function markDirty() {
+    isDirty = true;
+    dirtyRevision++;
+}
 
 // Charger la queue au démarrage
 async function loadQueue() {
     try {
         const data = await fs.readFile(QUEUE_FILE, 'utf-8');
         const savedQueue = JSON.parse(data);
-        
-        // Restaurer les tâches non terminées
+
         for (const [id, job] of Object.entries(savedQueue)) {
-            // Convertir les dates string en objets Date
             if (job.createdAt) job.createdAt = new Date(job.createdAt);
             if (job.updatedAt) job.updatedAt = new Date(job.updatedAt);
             if (job.reminderAt) job.reminderAt = new Date(job.reminderAt);
-            
-            // Marquer les tâches running comme crashed
+
             if (job.status === 'running') {
                 job.status = 'crashed';
                 job.crashedAt = new Date();
                 job.canRetry = true;
                 log('warn', `Tâche ${id} marquée comme crashed (reprise après redémarrage)`);
             }
-            
+
             jobQueue[id] = job;
         }
-        
+
         log('info', `${Object.keys(jobQueue).length} tâches restaurées depuis la sauvegarde`);
     } catch (err) {
         if (err.code !== 'ENOENT') {
             log('error', `Erreur lors du chargement de la queue: ${err.message}`);
-            
-            // Essayer de charger la sauvegarde de secours
+
             try {
                 const backupData = await fs.readFile(QUEUE_BACKUP, 'utf-8');
                 const backupQueue = JSON.parse(backupData);
@@ -59,58 +64,73 @@ async function loadQueue() {
 
 let isSaving = false;
 
-// Sauvegarder la queue
+let saveLock = null;
+
 async function saveQueue() {
-    if (!isDirty || isSaving) return;
-    
-    isSaving = true;
-    try {
-        // Créer une sauvegarde de l'ancienne queue
+    if (!isDirty) return;
+
+    // Attendre le save précédent puis revalider : il a peut-être déjà persisté
+    // toutes les mutations connues au moment de cet appel.
+    if (saveLock) {
+        await saveLock;
+        if (!isDirty) return;
+    }
+
+    saveLock = (async () => {
+        isSaving = true;
+        let tmpPath = null;
+        const revisionAtStart = dirtyRevision;
         try {
-            await fs.copyFile(QUEUE_FILE, QUEUE_BACKUP);
-        } catch (e) {
-            // Ignorer si le fichier n'existe pas encore
-        }
-        
-        // Filtrer les tâches terminées anciennes (garder 24h)
-        const now = Date.now();
-        const filteredQueue = {};
-        
-        for (const [id, job] of Object.entries(jobQueue)) {
-            const age = now - new Date(job.createdAt).getTime();
-            const isRecent = age < 86400000; // 24 heures
-            const isActive = ['pending', 'running', 'crashed'].includes(job.status);
-            
-            if (isActive || isRecent) {
-                filteredQueue[id] = job;
+            try {
+                await fs.copyFile(QUEUE_FILE, QUEUE_BACKUP);
+            } catch (e) {
+                // Ignorer si le fichier n'existe pas
+            }
+
+            const now = Date.now();
+            const filteredQueue = {};
+
+            for (const [id, job] of Object.entries(jobQueue)) {
+                const age = now - new Date(job.createdAt).getTime();
+                const isRecent = age < 86400000;
+                const isActive = ['pending', 'running', 'crashed'].includes(job.status);
+
+                if (isActive || isRecent) {
+                    filteredQueue[id] = job;
+                }
             }
+
+            // Écriture atomique : un crash ne peut plus laisser queue.json tronqué.
+            tmpPath = `${QUEUE_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+            await fs.writeFile(tmpPath, JSON.stringify(filteredQueue, null, 2));
+            await fs.rename(tmpPath, QUEUE_FILE);
+            tmpPath = null;
+
+            // Une mutation a pu arriver pendant les awaits ci-dessus. Ne jamais
+            // effacer son dirty flag : le prochain tick la persistera.
+            isDirty = dirtyRevision !== revisionAtStart;
+            log('debug', `Queue sauvegardée (${Object.keys(filteredQueue).length} tâches, dirty=${isDirty})`);
+        } catch (err) {
+            isDirty = true;
+            if (tmpPath) await fs.rm(tmpPath, { force: true }).catch(() => {});
+            log('error', `Erreur lors de la sauvegarde de la queue: ${err.message}`);
+        } finally {
+            isSaving = false;
+            saveLock = null;
         }
-        
-        // Sauvegarder la queue filtrée
-        await fs.writeFile(
-            QUEUE_FILE, 
-            JSON.stringify(filteredQueue, null, 2)
-        );
-        
-        isDirty = false;
-        log('debug', `Queue sauvegardée (${Object.keys(filteredQueue).length} tâches)`);
-    } catch (err) {
-        log('error', `Erreur lors de la sauvegarde de la queue: ${err.message}`);
-    } finally {
-        isSaving = false;
-    }
+    })();
+
+    return saveLock;
 }
 
-// Démarrer la sauvegarde automatique
 function startAutoSave() {
     if (saveTimer) clearInterval(saveTimer);
-    
+
     saveTimer = setInterval(() => {
         saveQueue();
     }, SAVE_INTERVAL);
 }
 
-// Arrêter la sauvegarde automatique
 function stopAutoSave() {
     if (saveTimer) {
         clearInterval(saveTimer);
@@ -124,31 +144,30 @@ function log(level, message) {
     if (logHistory.length > MAX_LOGS) {
         logHistory.shift();
     }
-    
-    // Afficher les logs importants
-    if (['error', 'warn', 'info'].includes(level)) {
+
+    // ✅ N'afficher les logs que si MCP_DEBUG=true
+    if (!SILENT_MODE && ['error', 'warn', 'info'].includes(level)) {
         const prefix = {
             error: '[❌ ERROR]',
             warn: '[⚠️  WARN]',
             info: '[ℹ️  INFO]',
             debug: '[🔧 DEBUG]'
         }[level] || `[${level.toUpperCase()}]`;
-        
-        console.log(`${prefix} ${new Date().toISOString().split('T')[1].split('.')[0]} - ${message}`);
+
+        // ✅ TOUJOURS utiliser stderr (pas stdout)
+        console.error(`${prefix} ${new Date().toISOString().split('T')[1].split('.')[0]} - ${message}`);
     }
 }
 
 function addJob(details) {
-    // Vérifier la taille de la queue
     if (Object.keys(jobQueue).length >= MAX_QUEUE_SIZE) {
-        // Nettoyer les vieilles tâches terminées
         cleanOldJobs();
-        
+
         if (Object.keys(jobQueue).length >= MAX_QUEUE_SIZE) {
             throw new Error(`Queue pleine (${MAX_QUEUE_SIZE} tâches max)`);
         }
     }
-    
+
     const id = uuidv4().split('-')[0];
     const job = {
         id,
@@ -164,7 +183,7 @@ function addJob(details) {
     }
 
     jobQueue[id] = job;
-    isDirty = true;
+    markDirty();
     log('info', `Nouvelle tâche ${id} (${job.type}) ajoutée.`);
     return jobQueue[id];
 }
@@ -174,8 +193,7 @@ function updateJobStatus(id, status, data = {}) {
         const oldStatus = jobQueue[id].status;
         jobQueue[id].status = status;
         jobQueue[id].updatedAt = new Date();
-        
-        // Copier toutes les données supplémentaires
+
         Object.assign(jobQueue[id], data);
 
         if (data.error) {
@@ -186,12 +204,12 @@ function updateJobStatus(id, status, data = {}) {
             jobQueue[id].completedAt = new Date();
             const duration = jobQueue[id].completedAt - jobQueue[id].createdAt;
             jobQueue[id].duration = duration;
-            log('info', `Tâche ${id} terminée en ${(duration/1000).toFixed(2)}s`);
+            log('info', `Tâche ${id} terminée en ${(duration / 1000).toFixed(2)}s`);
         } else {
             log('info', `Tâche ${id}: ${oldStatus} -> ${status}`);
         }
 
-        isDirty = true;
+        markDirty();
     }
 }
 
@@ -207,7 +225,7 @@ function getLogs(filter = {}) {
     if (!filter || Object.keys(filter).length === 0) {
         return logHistory;
     }
-    
+
     return logHistory.filter(log => {
         if (filter.level && log.level !== filter.level) return false;
         if (filter.since && new Date(log.timestamp) < new Date(filter.since)) return false;
@@ -216,47 +234,57 @@ function getLogs(filter = {}) {
     });
 }
 
-// Nettoyer les vieilles tâches terminées
 function cleanOldJobs() {
     const now = Date.now();
     const toDelete = [];
-    
+    const MAX_AGE = 86400000;
+
     for (const [id, job] of Object.entries(jobQueue)) {
-        const age = now - new Date(job.createdAt).getTime();
-        const isOld = age > 86400000; // Plus de 24h
+        const createdAt = job.createdAt ? new Date(job.createdAt).getTime() : now;
+        if (isNaN(createdAt)) {
+            log('warn', `Tâche ${id} a une date de création invalide, conservation`);
+            continue;
+        }
+
+        const age = now - createdAt;
+
+        if (age < 0) {
+            log('warn', `Tâche ${id} a une date dans le futur, conservation`);
+            continue;
+        }
+
+        const isOld = age > MAX_AGE;
         const isCompleted = ['completed', 'failed'].includes(job.status);
-        
+
         if (isOld && isCompleted) {
             toDelete.push(id);
         }
     }
-    
+
     for (const id of toDelete) {
         delete jobQueue[id];
     }
-    
+
     if (toDelete.length > 0) {
         log('info', `${toDelete.length} vieilles tâches supprimées de la queue`);
-        isDirty = true;
+        markDirty();
     }
 }
 
-// Réessayer une tâche échouée ou crashed
 async function retryJob(id) {
     const job = jobQueue[id];
     if (!job) {
         throw new Error(`Tâche ${id} introuvable`);
     }
-    
+
     if (!['failed', 'crashed'].includes(job.status)) {
         throw new Error(`La tâche ${id} ne peut pas être réessayée (statut: ${job.status})`);
     }
-    
+
     if (job.retryCount >= job.maxRetries) {
         throw new Error(`La tâche ${id} a atteint le nombre max de tentatives (${job.maxRetries})`);
     }
-    
-    // Créer une nouvelle tâche basée sur l'ancienne
+
     const newJob = {
         ...job,
         id: uuidv4().split('-')[0],
@@ -268,29 +296,77 @@ async function retryJob(id) {
         error: null,
         output: null
     };
-    
+
     delete newJob.failedAt;
     delete newJob.crashedAt;
     delete newJob.completedAt;
-    
+
     jobQueue[newJob.id] = newJob;
-    isDirty = true;
-    
+    markDirty();
+
     log('info', `Tâche ${id} réessayée -> nouvelle tâche ${newJob.id} (tentative ${newJob.retryCount}/${newJob.maxRetries})`);
-    
+
     return newJob;
 }
 
-// Obtenir les tâches crashées qui peuvent être reprises
 function getCrashedJobs() {
-    return Object.values(jobQueue).filter(job => 
-        job.status === 'crashed' && 
+    return Object.values(jobQueue).filter(job =>
+        job.status === 'crashed' &&
         job.canRetry &&
         job.retryCount < job.maxRetries
     );
 }
 
-// Statistiques de la queue
+function getRetryableJobs(statusFilter = null) {
+    return Object.values(jobQueue).filter(job => {
+        if (!['failed', 'crashed'].includes(job.status)) return false;
+        if (statusFilter && job.status !== statusFilter) return false;
+        if ((job.retryCount || 0) >= (job.maxRetries || 3)) return false;
+        return true;
+    });
+}
+
+/**
+ * Purge des jobs terminés/crashés.
+ * options = { status?: 'crashed'|'failed'|'completed'|'all_terminal', olderThanDays?: number, dryRun?: bool }
+ */
+function purgeJobs(options = {}) {
+    const olderThanDays = options.olderThanDays ?? 0;
+    const dryRun = options.dryRun === true;
+    const status = options.status || 'crashed';
+    const now = Date.now();
+    const maxAge = olderThanDays > 0 ? olderThanDays * 86400000 : 0;
+
+    const terminal = new Set(['completed', 'failed', 'crashed', 'partial']);
+    const toDelete = [];
+
+    for (const [id, job] of Object.entries(jobQueue)) {
+        let match = false;
+        if (status === 'all_terminal') {
+            match = terminal.has(job.status);
+        } else {
+            match = job.status === status;
+        }
+        if (!match) continue;
+
+        if (maxAge > 0) {
+            const created = job.createdAt ? new Date(job.createdAt).getTime() : now;
+            if (now - created < maxAge) continue;
+        }
+        toDelete.push(id);
+    }
+
+    if (!dryRun) {
+        for (const id of toDelete) delete jobQueue[id];
+        if (toDelete.length) {
+            markDirty();
+            log('info', `Purge: ${toDelete.length} tâche(s) supprimée(s) (status=${status})`);
+        }
+    }
+
+    return { purged: toDelete.length, ids: toDelete, dryRun };
+}
+
 function getStats() {
     const stats = {
         total: Object.keys(jobQueue).length,
@@ -299,79 +375,58 @@ function getStats() {
         avgDuration: 0,
         successRate: 0
     };
-    
+
     let totalDuration = 0;
     let completedCount = 0;
-    
+
     for (const job of Object.values(jobQueue)) {
-        // Par statut
         stats.byStatus[job.status] = (stats.byStatus[job.status] || 0) + 1;
-        
-        // Par type
         stats.byType[job.type] = (stats.byType[job.type] || 0) + 1;
-        
-        // Durée moyenne
+
         if (job.duration) {
             totalDuration += job.duration;
             completedCount++;
         }
     }
-    
+
     if (completedCount > 0) {
         stats.avgDuration = Math.round(totalDuration / completedCount);
     }
-    
+
     const totalFinished = (stats.byStatus.completed || 0) + (stats.byStatus.failed || 0);
     if (totalFinished > 0) {
         stats.successRate = Math.round((stats.byStatus.completed || 0) / totalFinished * 100);
     }
-    
+
     return stats;
 }
 
-// Initialiser le module
 async function init() {
     await loadQueue();
     startAutoSave();
-    
-    // Nettoyer périodiquement
-    setInterval(cleanOldJobs, 3600000); // Toutes les heures
+    setInterval(cleanOldJobs, 3600000);
 }
 
-// Arrêter proprement
 async function shutdown() {
     log('info', 'Arrêt du gestionnaire de queue...');
     stopAutoSave();
     await saveQueue();
 }
 
-// Gérer l'arrêt du processus
-process.on('SIGINT', async () => {
-    await shutdown();
-    process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-    await shutdown();
-    process.exit(0);
-});
-
-// Démarrer automatiquement
-init().catch(err => {
-    console.error('Erreur lors de l\'initialisation de la queue:', err);
-});
-
-export default { 
-    addJob, 
-    updateJobStatus, 
-    getJob, 
-    getQueue, 
-    getLogs, 
+export default {
+    addJob,
+    updateJobStatus,
+    getJob,
+    getQueue,
+    getLogs,
     log,
     retryJob,
     getCrashedJobs,
+    getRetryableJobs,
+    purgeJobs,
     getStats,
     cleanOldJobs,
     saveQueue,
-    shutdown
+    shutdown,
+    init
 };