@fkom13/mcp-sftp-orchestrator 11.3.0 → 11.8.0

package/policies.js

@@ -1,76 +1,8 @@
-import fs from 'fs/promises';
 import path from 'path';
 import config from './config.js';
-
-const POLICIES_PATH = path.join(config.dataDir, 'policies.json');
-
-const DEFAULT_POLICIES = {
-    command_blocklist: [
-        "rm -rf /",
-        "rm -rf /*",
-        "mkfs*",
-        ":(){:|:&};:",
-        "dd if=/dev/zero",
-        "> /dev/sda",
-        "chmod -R 000 /",
-        "mv / /dev/null",
-        "wget -O- http://* | sh",
-        "curl http://* | sh",
-        "eval $(curl",
-        "eval $(wget",
-        "git clone http://* | sh"
-    ]
-};
-
-async function loadPolicies() {
-    try {
-        await fs.access(POLICIES_PATH);
-        const data = await fs.readFile(POLICIES_PATH, 'utf-8');
-        return JSON.parse(data);
-    } catch {
-        await fs.writeFile(POLICIES_PATH, JSON.stringify(DEFAULT_POLICIES, null, 2));
-        return { ...DEFAULT_POLICIES };
-    }
-}
-
-async function savePolicies(policies) {
-    await fs.writeFile(POLICIES_PATH, JSON.stringify(policies, null, 2));
-}
-
-function checkCommand(cmd, blocklist) {
-    const cmdTrimmed = cmd.trim();
-    for (const pattern of blocklist) {
-        const regex = pattern.includes('*')
-            ? new RegExp('^' + pattern.replace(/\*/g, '.*') + '$', 'i')
-            : new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
-        if (regex.test(cmdTrimmed)) {
-            return { blocked: true, pattern };
-        }
-    }
-    return { blocked: false };
-}
-
-export default {
-    async list() {
-        return await loadPolicies();
-    },
-    async add(pattern) {
-        const policies = await loadPolicies();
-        if (!policies.command_blocklist.includes(pattern)) {
-            policies.command_blocklist.push(pattern);
-            await savePolicies(policies);
-        }
-        return policies;
-    },
-    async remove(pattern) {
-        const policies = await loadPolicies();
-        policies.command_blocklist = policies.command_blocklist.filter(p => p !== pattern);
-        await savePolicies(policies);
-        return policies;
-    },
-    async check(cmd) {
-        const policies = await loadPolicies();
-        return checkCommand(cmd, policies.command_blocklist);
-    },
-    checkCommand
-};
+import jsonStore from './atomicJsonStore.js';
+const POLICIES_PATH=path.join(config.dataDir,'policies.json');
+const DEFAULT_POLICIES={command_blocklist:["rm -rf /","rm -rf /*","mkfs*",":(){:|:&};:","dd if=/dev/zero","> /dev/sda","chmod -R 000 /","mv / /dev/null","wget -O- http://* | sh","curl http://* | sh","eval $(curl","eval $(wget","git clone http://* | sh"]};
+const loadPolicies=()=>jsonStore.readJson(POLICIES_PATH,DEFAULT_POLICIES);
+function checkCommand(cmd,blocklist){ const c=(cmd||'').trim(); if(!c)return{blocked:false}; for(const pattern of blocklist){ if(!pattern)continue; if(pattern.includes('*')){const r=new RegExp('^'+pattern.replace(/[.+^${}()|[\]\\]/g,'\\$&').replace(/\*/g,'.*')+'$','i'); if(r.test(c))return{blocked:true,pattern}; continue;} const e=pattern.replace(/[.*+?^${}()|[\]\\]/g,'\\$&'); const r=/\/$/.test(pattern)?new RegExp(e+'(?=$|\\s|\\*)','i'):new RegExp(e,'i'); if(r.test(c))return{blocked:true,pattern}; } return{blocked:false}; }
+export default { async list(){return loadPolicies();}, async add(pattern){return jsonStore.updateJson(POLICIES_PATH,DEFAULT_POLICIES,p=>{if(!p.command_blocklist.includes(pattern))p.command_blocklist.push(pattern);return p;});}, async remove(pattern){return jsonStore.updateJson(POLICIES_PATH,DEFAULT_POLICIES,p=>{p.command_blocklist=p.command_blocklist.filter(x=>x!==pattern);return p;});}, async check(cmd){const p=await loadPolicies();return checkCommand(cmd,p.command_blocklist);}, checkCommand };

package/projects.js

@@ -0,0 +1,108 @@
+/**
+ * projects.js — Registre sémantique projet ↔ serveur(s) ↔ paths local/remote.
+ * Stockage atomique: <dataDir>/projects.json
+ */
+import path from 'path';
+import config from './config.js';
+import servers from './servers.js';
+import jsonStore from './atomicJsonStore.js';
+
+const PROJECTS_PATH = path.join(config.dataDir, 'projects.json');
+const EMPTY = {};
+
+const load = () => jsonStore.readJson(PROJECTS_PATH, EMPTY);
+
+function validateName(name) {
+    if (!name || !/^[a-zA-Z0-9_./-]+$/.test(name)) {
+        throw new Error("Nom de projet invalide (alphanumérique, _ . / -).");
+    }
+}
+
+export default {
+    async list() {
+        return load();
+    },
+
+    async get(name) {
+        const all = await load();
+        if (!all[name]) throw new Error(`Projet '${name}' introuvable. project_list pour voir.`);
+        return { name, ...all[name] };
+    },
+
+    async set(name, fields = {}) {
+        validateName(name);
+
+        // Valider d'abord les aliases hors verrou projets afin de ne pas garder
+        // le lock pendant une I/O vers le registre serveurs.
+        let known = null;
+        if (fields.servers !== undefined) known = await servers.listServers();
+
+        let merged;
+        await jsonStore.updateJson(PROJECTS_PATH, EMPTY, async (all) => {
+            const existing = all[name] || {};
+            merged = { ...existing };
+            for (const key of ['description', 'ignore', 'local', 'servers', 'tags', 'network']) {
+                if (fields[key] !== undefined) merged[key] = fields[key];
+            }
+
+            if (merged.servers && typeof merged.servers === 'object') {
+                const serverMap = known || await servers.listServers();
+                for (const [role, cfg] of Object.entries(merged.servers)) {
+                    if (!cfg || !cfg.alias) throw new Error(`servers.${role}: 'alias' requis`);
+                    if (!serverMap[cfg.alias]) throw new Error(`servers.${role}: alias '${cfg.alias}' inconnu (server_list)`);
+                    if (!cfg.path) throw new Error(`servers.${role}: 'path' requis`);
+                }
+            }
+
+            merged.updatedAt = new Date().toISOString();
+            all[name] = merged;
+            return all;
+        });
+        return { name, ...merged };
+    },
+
+    async remove(name) {
+        await jsonStore.updateJson(PROJECTS_PATH, EMPTY, (all) => {
+            if (!all[name]) throw new Error(`Projet '${name}' introuvable.`);
+            delete all[name];
+            return all;
+        });
+        return { success: true, message: `Projet '${name}' supprimé.` };
+    },
+
+    async resolve(name, role = null) {
+        const project = await this.get(name);
+        const ignore = project.ignore || ['node_modules', '.git', 'dist', 'coverage', '.env'];
+        let remote = null;
+        let runtime = null;
+        let url = null;
+        const serverEntries = project.servers || {};
+        const roles = Object.keys(serverEntries);
+
+        if (roles.length) {
+            const useRole = role || (serverEntries.prod ? 'prod' : roles[0]);
+            const cfg = serverEntries[useRole];
+            if (!cfg) throw new Error(`Rôle '${useRole}' absent. Rôles: ${roles.join(', ')}`);
+            remote = { type: 'remote', alias: cfg.alias, path: cfg.path, label: `${name}:${useRole}` };
+            runtime = cfg.runtime || null;
+            url = cfg.url || null;
+        }
+
+        const local = project.local?.path
+            ? { type: 'local', path: project.local.path, label: `${name}:local` }
+            : null;
+
+        return {
+            name,
+            role: role || (serverEntries.prod ? 'prod' : roles[0] || null),
+            local,
+            remote,
+            ignore,
+            runtime,
+            url,
+            description: project.description || null,
+            network: project.network || null,
+            project
+        };
+    }
+};

package/queue.js

@@ -5,8 +5,8 @@ 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;
-const MAX_QUEUE_SIZE = 1000;
+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';
@@ -17,6 +17,12 @@ 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() {
@@ -63,11 +69,17 @@ let saveLock = null;
 async function saveQueue() {
     if (!isDirty) return;
 
-    // Attendre le verrou précédent
-    if (saveLock) await saveLock;
+    // 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 {
             try {
                 await fs.copyFile(QUEUE_FILE, QUEUE_BACKUP);
@@ -88,14 +100,19 @@ async function saveQueue() {
                 }
             }
 
-            await fs.writeFile(
-                QUEUE_FILE,
-                JSON.stringify(filteredQueue, null, 2)
-            );
+            // É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;
 
-            isDirty = false;
-            log('debug', `Queue sauvegardée (${Object.keys(filteredQueue).length} tâches)`);
+            // 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;
@@ -166,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];
 }
@@ -192,7 +209,7 @@ function updateJobStatus(id, status, data = {}) {
             log('info', `Tâche ${id}: ${oldStatus} -> ${status}`);
         }
 
-        isDirty = true;
+        markDirty();
     }
 }
 
@@ -250,7 +267,7 @@ function cleanOldJobs() {
 
     if (toDelete.length > 0) {
         log('info', `${toDelete.length} vieilles tâches supprimées de la queue`);
-        isDirty = true;
+        markDirty();
     }
 }
 
@@ -285,7 +302,7 @@ async function retryJob(id) {
     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})`);
 
@@ -300,6 +317,56 @@ function getCrashedJobs() {
     );
 }
 
+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,
@@ -355,6 +422,8 @@ export default {
     log,
     retryJob,
     getCrashedJobs,
+    getRetryableJobs,
+    purgeJobs,
     getStats,
     cleanOldJobs,
     saveQueue,