@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

package/compareEngine.js

@@ -0,0 +1,132 @@
+import { createTwoFilesPatch } from 'diff';
+import sourceAdapter from './sourceAdapter.js';
+import fileOps from './fileOps.js';
+
+/**
+ * compareEngine — Comparaison d'un même fichier (ou de fichiers équivalents à
+ * des emplacements différents) sur plusieurs sources.
+ * Détecte les "drifts" de configuration entre serveurs (et localhost).
+ *
+ * Regroupe les sources par hash : chaque groupe = ensemble de sources ayant
+ * un contenu identique. Plus d'un groupe → drift détecté.
+ *
+ * Chaque source peut porter :
+ *   - un path différent d'une source à l'autre (ex: .bashrc ici, .zshrc là)
+ *   - un label personnalisé (source.label) pour un affichage clair
+ * Quand un drift est détecté, on peut générer le DIFF réel entre la version
+ * de référence (groupe majoritaire) et chaque version divergente.
+ */
+
+export default {
+    /**
+     * Compare le contenu d'un fichier sur plusieurs sources.
+     * sources = [{ type, path, alias?, label? }, ...] (min 2, local et/ou remote)
+     * options = { includeContent: bool (défaut false), includeDiff: bool (défaut true) }
+     *
+     * Retourne :
+     *   {
+     *     drift: bool,                 // true si plus d'une version distincte
+     *     reference: { label, sources } | null,  // groupe majoritaire (référence)
+     *     groups: [{ hash, size, sources:[{server,path,label}], content?, isReference }],
+     *     drifts: [{ from, to, added, removed, diff }],  // diff référence → chaque divergence
+     *     errors: [{ source:{server,path,label}, error }],
+     *     stats: { totalSources, successfulReads, uniqueVersions, unreadable }
+     *   }
+     */
+    async compareSources(sources, options = {}) {
+        const includeContent = options.includeContent === true;
+        const includeDiff = options.includeDiff !== false; // défaut true
+        const results = [];
+        const errors = [];
+
+        // Lecture de chaque source (séquentiel : simple et robuste ; le pool gère le reste)
+        for (const source of sources) {
+            const origin = sourceAdapter.describe(source);
+            try {
+                const file = await fileOps.readFile(source);
+                results.push({ origin, hash: file.hash, size: file.size, content: file.content });
+            } catch (e) {
+                errors.push({ source: origin, error: e.message });
+            }
+        }
+
+        // Regroupement par hash (on garde le contenu en interne pour le diff)
+        const groupsMap = new Map();
+        for (const r of results) {
+            if (!groupsMap.has(r.hash)) {
+                groupsMap.set(r.hash, {
+                    hash: r.hash,
+                    size: r.size,
+                    sources: [],
+                    _content: r.content // interne, retiré à la fin si includeContent=false
+                });
+            }
+            groupsMap.get(r.hash).sources.push(r.origin);
+        }
+
+        const groups = Array.from(groupsMap.values())
+            // le groupe le plus répandu en premier (majorité = référence probable)
+            .sort((a, b) => b.sources.length - a.sources.length);
+
+        const drift = groups.length > 1;
+
+        // Marque le groupe de référence (majoritaire)
+        groups.forEach((g, i) => { g.isReference = i === 0; });
+        const reference = groups.length > 0
+            ? { label: groups[0].sources[0].label, sources: groups[0].sources }
+            : null;
+
+        // Génère les diffs référence → chaque groupe divergent
+        const drifts = [];
+        if (drift && includeDiff) {
+            const ref = groups[0];
+            const refLabel = ref.sources[0].label;
+            for (let i = 1; i < groups.length; i++) {
+                const g = groups[i];
+                const gLabel = g.sources[0].label;
+                try {
+                    const patch = createTwoFilesPatch(
+                        refLabel, gLabel,
+                        ref._content, g._content,
+                        'référence', 'divergent'
+                    );
+                    let added = 0, removed = 0;
+                    for (const line of patch.split('\n')) {
+                        if (line.startsWith('+') && !line.startsWith('+++')) added++;
+                        else if (line.startsWith('-') && !line.startsWith('---')) removed++;
+                    }
+                    drifts.push({
+                        from: refLabel,
+                        to: gLabel,
+                        affectedSources: g.sources.map(s => s.label),
+                        added,
+                        removed,
+                        diff: patch
+                    });
+                } catch (e) {
+                    drifts.push({ from: refLabel, to: gLabel, note: 'diff indisponible (binaire ?)' });
+                }
+            }
+        }
+
+        // Nettoie le contenu interne (ou l'expose si demandé)
+        for (const g of groups) {
+            if (includeContent) g.content = g._content;
+            delete g._content;
+        }
+
+        return {
+            drift,
+            reference,
+            groups,
+            drifts,
+            errors,
+            stats: {
+                totalSources: sources.length,
+                successfulReads: results.length,
+                uniqueVersions: groups.length,
+                unreadable: errors.length
+            }
+        };
+    }
+};

package/config.js

@@ -21,13 +21,49 @@ const args = process.argv.slice(2).reduce((acc, arg) => {
 }, {});
 
 const config = {
-    // La hiérarchie reste la même : les arguments en ligne de commande écrasent le .env, qui écrase le défaut.
+    version: '11.8.0',
     dataDir: args['data-dir'] || process.env.MCP_DATA_DIR || path.join(os.homedir(), '.config', 'mcp-orchestrator'),
-    syncTimeout: parseInt(args['sync-timeout'] || process.env.MCP_SYNC_TIMEOUT_S || '10', 10) * 1000,
-    defaultCommandTimeout: parseInt(process.env.MCP_DEFAULT_CMD_TIMEOUT_MS || '300000', 10),
-    interactiveCommandTimeout: parseInt(process.env.MCP_INTERACTIVE_CMD_TIMEOUT_MS || '120000', 10)
+    
+    // Timeouts en millisecondes (plus cohérent)
+    syncTimeout: parseInt(args['sync-timeout'] || process.env.MCP_SYNC_TIMEOUT_S || '120', 10) * 1000,
+    defaultCommandTimeout: parseInt(process.env.MCP_DEFAULT_CMD_TIMEOUT_S || '600', 10) * 1000,
+    interactiveCommandTimeout: parseInt(process.env.MCP_INTERACTIVE_CMD_TIMEOUT_S || '300', 10) * 1000,
+    maxWaitTimeout: parseInt(process.env.MCP_MAX_WAIT_TIMEOUT_S || '600', 10) * 1000,
+    
+    // Configuration Pool SSH
+    maxConnectionsPerServer: parseInt(process.env.MAX_CONNECTIONS_PER_SERVER || '5', 10),
+    minConnectionsPerServer: parseInt(process.env.MIN_CONNECTIONS_PER_SERVER || '1', 10),
+    idleTimeout: parseInt(process.env.IDLE_TIMEOUT || '300000', 10),
+    keepAliveInterval: parseInt(process.env.KEEP_ALIVE_INTERVAL || '30000', 10),
+    
+    // Sécurité
+    allowedRoots: (process.env.MCP_ALLOWED_ROOTS || '').split(',').map(s => s.trim()).filter(Boolean),
+    // Mode lecture seule : refuse écritures / exec mutantes (exploration safe)
+    readOnly: process.env.MCP_READONLY === 'true' || process.env.MCP_READONLY === '1',
+    // Réponses compactes (moins de tokens agent)
+    compact: process.env.MCP_COMPACT === 'true' || process.env.MCP_COMPACT === '1',
+    
+    // Configuration Queue
+    maxQueueSize: parseInt(process.env.MAX_QUEUE_SIZE || '1000', 10),
+    saveInterval: parseInt(process.env.SAVE_INTERVAL || '5000', 10),
+    historyRetention: parseInt(process.env.HISTORY_RETENTION || '2678400000', 10), // 31 jours
 };
 
+// Validation
+if (config.syncTimeout < 1000) {
+    if (process.env.MCP_DEBUG === 'true') {
+        console.error('⚠️ syncTimeout trop court, minimum 1000ms');
+    }
+    config.syncTimeout = 1000;
+}
+
+if (config.maxConnectionsPerServer < config.minConnectionsPerServer) {
+    if (process.env.MCP_DEBUG === 'true') {
+        console.error('⚠️ maxConnections < minConnections, ajustement automatique');
+    }
+    config.maxConnectionsPerServer = config.minConnectionsPerServer;
+}
+
 // Créer le dossier de données s'il n'existe pas
 fs.mkdirSync(config.dataDir, { recursive: true });
 

package/diagnose.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+console.error("🔍 Diagnostic MCP Orchestrator\n");
+
+// 1. Tester les imports
+console.error("1️⃣ Test des imports...");
+try {
+    await import("@modelcontextprotocol/sdk/server/mcp.js");
+    console.error("   ✅ @modelcontextprotocol/sdk");
+} catch (e) {
+    console.error("   ❌ @modelcontextprotocol/sdk:", e.message);
+    process.exit(1);
+}
+
+try {
+    await import("zod");
+    console.error("   ✅ zod");
+} catch (e) {
+    console.error("   ❌ zod:", e.message);
+    process.exit(1);
+}
+
+// 2. Tester config
+console.error("\n2️⃣ Test de config...");
+try {
+    const config = await import("./config.js");
+    console.error("   ✅ config.dataDir:", config.default.dataDir);
+    console.error("   ✅ config.syncTimeout:", config.default.syncTimeout);
+} catch (e) {
+    console.error("   ❌ config:", e.message);
+    process.exit(1);
+}
+
+// 3. Tester queue
+console.error("\n3️⃣ Test de queue...");
+try {
+    const queue = await import("./queue.js");
+    console.error("   ✅ queue importée");
+    const stats = queue.default.getStats();
+    console.error("   ✅ queue.getStats():", JSON.stringify(stats));
+} catch (e) {
+    console.error("   ❌ queue:", e.message);
+    console.error(e.stack);
+    process.exit(1);
+}
+
+// 4. Tester servers
+console.error("\n4️⃣ Test de servers...");
+try {
+    const servers = await import("./servers.js");
+    const list = await servers.default.listServers();
+    console.error("   ✅ servers.listServers():", Object.keys(list).length, "serveurs");
+} catch (e) {
+    console.error("   ❌ servers:", e.message);
+    process.exit(1);
+}
+
+// 5. Tester un simple serveur MCP
+console.error("\n5️⃣ Test d'un serveur MCP minimal...");
+try {
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { z } = await import("zod");
+
+    const server = new McpServer({
+        name: "test",
+        version: "1.0.0",
+        description: "Test"
+    });
+
+    server.registerTool(
+        "test",
+        {
+            title: "Test",
+            description: "Test",
+            inputSchema: z.object({})
+        },
+        async () => ({ content: [{ type: "text", text: "OK" }] })
+    );
+
+    console.error("   ✅ Serveur MCP minimal fonctionne");
+} catch (e) {
+    console.error("   ❌ Serveur MCP:", e.message);
+    console.error(e.stack);
+    process.exit(1);
+}
+
+console.error("\n✅ TOUS LES TESTS PASSENT");
+console.error("\n📋 Prochaine étape: vérifier server.js ligne par ligne");
+process.exit(0);

package/diffEngine.js

@@ -0,0 +1,141 @@
+import { createTwoFilesPatch } from 'diff';
+import sourceAdapter from './sourceAdapter.js';
+import fileOps from './fileOps.js';
+
+/**
+ * diffEngine — Comparaison fichier à fichier et dossier à dossier.
+ * Fonctionne pour n'importe quelle combinaison local/remote via sourceAdapter.
+ * Chaque résultat indique clairement l'origine (serveur + chemin) des sources.
+ */
+
+function countAddRemove(patch) {
+    let added = 0, removed = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++')) added++;
+        else if (line.startsWith('-') && !line.startsWith('---')) removed++;
+    }
+    return { added, removed };
+}
+
+export default {
+    /**
+     * Compare deux fichiers. Retourne :
+     *   { identical, source1, source2, hash1, hash2, diff?, added?, removed? }
+     * source1/source2 = { server, path, label } (origine claire).
+     */
+    async diffFiles(s1, s2) {
+        const f1 = await fileOps.readFile(s1);
+        const f2 = await fileOps.readFile(s2);
+
+        const origin1 = sourceAdapter.describe(s1);
+        const origin2 = sourceAdapter.describe(s2);
+
+        if (f1.hash === f2.hash) {
+            return {
+                identical: true,
+                source1: origin1,
+                source2: origin2,
+                hash: f1.hash,
+                stats: { size1: f1.size, size2: f2.size }
+            };
+        }
+
+        const patch = createTwoFilesPatch(
+            origin1.label, origin2.label,
+            f1.content, f2.content,
+            'source1', 'source2'
+        );
+        const { added, removed } = countAddRemove(patch);
+
+        return {
+            identical: false,
+            source1: origin1,
+            source2: origin2,
+            hash1: f1.hash,
+            hash2: f2.hash,
+            added,
+            removed,
+            diff: patch,
+            stats: { size1: f1.size, size2: f2.size }
+        };
+    },
+
+    /**
+     * Compare deux dossiers (arborescences). Retourne :
+     *   { source1, source2, only_in_source1[], only_in_source2[],
+     *     identical[], modified[{path, hash1, hash2, added, removed, diff?}], stats }
+     * options = { recursive, compareContent, ignorePatterns, includeDiff }
+     *   - compareContent (défaut true) : compare le contenu des fichiers communs par hash
+     *   - includeDiff (défaut false)   : inclut le diff unifié pour chaque fichier modifié
+     */
+    async diffFolders(s1, s2, options = {}) {
+        const recursive = options.recursive !== false;
+        const compareContent = options.compareContent !== false;
+        const includeDiff = options.includeDiff === true;
+        const ignorePatterns = options.ignorePatterns || [];
+
+        const origin1 = sourceAdapter.describe(s1);
+        const origin2 = sourceAdapter.describe(s2);
+
+        const list1 = await sourceAdapter.listFilesRecursive(s1, { recursive, ignorePatterns });
+        const list2 = await sourceAdapter.listFilesRecursive(s2, { recursive, ignorePatterns });
+
+        const set2 = new Set(list2);
+        const set1 = new Set(list1);
+
+        const only_in_source1 = list1.filter(p => !set2.has(p));
+        const only_in_source2 = list2.filter(p => !set1.has(p));
+        const common = list1.filter(p => set2.has(p));
+
+        const identical = [];
+        const modified = [];
+
+        if (compareContent && common.length > 0) {
+            // Lit les fichiers communs des deux côtés (batch par source pour perf remote)
+            const hashes1 = await sourceAdapter.readManyHashes(s1, s1.path, common);
+            const hashes2 = await sourceAdapter.readManyHashes(s2, s2.path, common);
+
+            for (const rel of common) {
+                const h1 = hashes1.get(rel);
+                const h2 = hashes2.get(rel);
+                if (h1.hash === h2.hash) {
+                    identical.push(rel);
+                } else {
+                    const entry = { path: rel, hash1: h1.hash, hash2: h2.hash };
+                    // diff textuel (best-effort ; ignore si binaire)
+                    try {
+                        const patch = createTwoFilesPatch(
+                            `${origin1.label}/${rel}`, `${origin2.label}/${rel}`,
+                            h1.content.toString('utf8'), h2.content.toString('utf8'),
+                            'source1', 'source2'
+                        );
+                        const { added, removed } = countAddRemove(patch);
+                        entry.added = added;
+                        entry.removed = removed;
+                        if (includeDiff) entry.diff = patch;
+                    } catch (e) {
+                        entry.note = 'diff indisponible (binaire ?)';
+                    }
+                    modified.push(entry);
+                }
+            }
+        }
+
+        return {
+            source1: origin1,
+            source2: origin2,
+            only_in_source1,
+            only_in_source2,
+            identical,
+            modified,
+            stats: {
+                total1: list1.length,
+                total2: list2.length,
+                onlyIn1: only_in_source1.length,
+                onlyIn2: only_in_source2.length,
+                identical: identical.length,
+                modified: modified.length
+            }
+        };
+    }
+};

package/diffFormatter.js

@@ -0,0 +1,114 @@
+/**
+ * diffFormatter — Rendu lisible des diffs pour les clients MCP.
+ *
+ * Les outils renvoient des métadonnées JSON (hash, applied, added/removed...)
+ * dont l'IA a besoin de façon fiable. Mais un diff unifié brut dans un champ
+ * JSON est illisible (\n échappés). Ce module produit :
+ *   - un bloc markdown ```diff (coloré dans les clients, "comme les vrais tools")
+ *   - un résumé concis (+X / -Y lignes)
+ *
+ * Convention de sortie des outils : content = [ blocMarkdown, blocJSON ].
+ */
+
+// Nettoie un patch unifié (createTwoFilesPatch) : retire le bruit d'en-tête
+// (Index:/===) tout en gardant ---/+++/@@ et le corps.
+function cleanPatch(patch) {
+    return patch
+        .split('\n')
+        .filter(line => !line.startsWith('Index: ') && !/^=+$/.test(line))
+        .join('\n')
+        .trim();
+}
+
+// Compte les lignes ajoutées/supprimées (hors en-têtes +++/---)
+function countAddRemove(patch) {
+    let added = 0, removed = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++')) added++;
+        else if (line.startsWith('-') && !line.startsWith('---')) removed++;
+    }
+    return { added, removed };
+}
+
+// Barre visuelle proportionnelle (ex: +++++-- )
+function bar(added, removed, width = 20) {
+    const total = added + removed;
+    if (total === 0) return '';
+    const plus = Math.round((added / total) * width);
+    const minus = width - plus;
+    return '+'.repeat(plus) + '-'.repeat(minus);
+}
+
+export default {
+    countAddRemove,
+
+    /**
+     * Formate un patch unifié en markdown.
+     * opts = { title }
+     * Retourne { markdown, summary, added, removed }.
+     */
+    format(patch, opts = {}) {
+        const cleaned = cleanPatch(patch);
+        const { added, removed } = countAddRemove(patch);
+        const summary = `+${added} / -${removed} ligne${(added + removed) > 1 ? 's' : ''}`;
+
+        let markdown = '';
+        if (opts.title) markdown += `### ${opts.title}\n`;
+        markdown += `**${summary}**  \`${bar(added, removed)}\`\n\n`;
+        markdown += '```diff\n' + cleaned + '\n```';
+
+        return { markdown, summary, added, removed };
+    },
+
+    /**
+     * Construit une réponse MCP à deux blocs : markdown lisible + JSON metadata.
+     * - markdown : string déjà formatée (via format())
+     * - meta     : objet metadata (sera JSON.stringify)
+     * Le champ 'diff' brut est retiré du JSON (déjà rendu en markdown) pour
+     * éviter la duplication et économiser des tokens.
+     */
+    response(markdown, meta) {
+        const clean = { ...meta };
+        delete clean.diff; // le diff est dans le bloc markdown
+        return {
+            content: [
+                { type: "text", text: markdown },
+                { type: "text", text: JSON.stringify(clean, null, 2) }
+            ]
+        };
+    },
+
+    /**
+     * Résumé d'un diff de dossiers/snapshots (listes de fichiers) en markdown.
+     * groups = { added:[], removed:[], modified:[{path, added, removed}], identical? }
+     */
+    formatFileList(groups, opts = {}) {
+        const lines = [];
+        if (opts.title) lines.push(`### ${opts.title}`);
+        const a = groups.added?.length || 0;
+        const r = groups.removed?.length || 0;
+        const m = groups.modified?.length || 0;
+        lines.push(`**${m} modifié(s), ${a} ajouté(s), ${r} supprimé(s)**\n`);
+
+        if (m > 0) {
+            lines.push('**Modifiés :**');
+            for (const f of groups.modified) {
+                const p = f.path || f;
+                const delta = (f.added !== undefined) ? ` (+${f.added}/-${f.removed})` : '';
+                lines.push(`- \`${p}\`${delta}`);
+            }
+            lines.push('');
+        }
+        if (a > 0) {
+            lines.push('**Ajoutés :**');
+            for (const p of groups.added) lines.push(`- \`${p}\``);
+            lines.push('');
+        }
+        if (r > 0) {
+            lines.push('**Supprimés :**');
+            for (const p of groups.removed) lines.push(`- \`${p}\``);
+            lines.push('');
+        }
+        return lines.join('\n').trim();
+    }
+};