@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.3.0

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();
+    }
+};

package/fileOps.js

@@ -0,0 +1,275 @@
+import crypto from 'crypto';
+import pathModule from 'path';
+import { createTwoFilesPatch } from 'diff';
+import sourceAdapter from './sourceAdapter.js';
+import config from './config.js';
+
+/**
+ * fileOps — Opérations fichiers de haut niveau (local ET remote via sourceAdapter).
+ *
+ * Ajoute par-dessus sourceAdapter :
+ *  - calcul de hash SHA-256 (protection contre modifications concurrentes)
+ *  - génération de diff unifié
+ *  - édition sécurisée (read → vérif hash → diff → write)
+ *
+ * Gère texte (utf8) et binaire (base64).
+ */
+
+function sha256(buffer) {
+    return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+// E — Détection binaire (heuristique git) : un octet nul dans les 8000 premiers
+// octets = contenu binaire. Rapide et fiable pour éviter la corruption utf8.
+function looksBinary(buffer) {
+    const len = Math.min(buffer.length, 8000);
+    for (let i = 0; i < len; i++) {
+        if (buffer[i] === 0) return true;
+    }
+    return false;
+}
+
+function resolvePath(sourcePath) {
+    // Nettoie les traversées de répertoire
+    const normalized = pathModule.normalize(sourcePath).replace(/\/$/, '');
+    return normalized;
+}
+
+function validatePath(sourcePath) {
+    if (!config.allowedRoots || config.allowedRoots.length === 0) {
+        return; // Aucune restriction configurée
+    }
+
+    const resolved = resolvePath(sourcePath);
+    const allowed = config.allowedRoots.some(root => {
+        const normalRoot = pathModule.normalize(root).replace(/\/$/, '');
+        return resolved === normalRoot || resolved.startsWith(normalRoot + '/');
+    });
+
+    if (!allowed) {
+        const roots = config.allowedRoots.join(', ');
+        throw new Error(`Accès refusé : '${resolved}' n'est pas dans les racines autorisées. Ajoutez le chemin à MCP_ALLOWED_ROOTS ou modifiez allowedRoots. Racines: ${roots}`);
+    }
+}
+
+export default {
+    /**
+     * Lit un fichier et retourne { content, hash, mtime, size, encoding, ... }.
+     * encoding 'utf8' → content est une string ; 'base64' → content encodé base64.
+     *
+     * E — Détection binaire auto : si encoding='utf8' mais le contenu est binaire
+     *   (octet nul détecté), bascule automatiquement en base64 et signale via
+     *   binaryDetected:true (évite la corruption silencieuse d'un .png/.gz lu en utf8).
+     *   Désactivable avec options.autoDetect=false.
+     *
+     * options = { offset, limit, autoDetect } :
+     *   - offset : ligne de départ (1-indexée) — lecture partielle PAR LIGNES (utf8)
+     *   - limit  : nombre de lignes à retourner
+     *   Mode consultation pour gros fichiers. Le HASH reste TOUJOURS celui du
+     *   fichier COMPLET, pour que file_edit fonctionne (il relit le fichier entier).
+     */
+    async readFile(source, encoding = 'utf8', options = {}) {
+        if (source.path) validatePath(source.path);
+        const { content, mtime, size } = await sourceAdapter.readFile(source);
+        // content est un Buffer ; le hash est TOUJOURS calculé sur le fichier complet
+        const hash = sha256(content);
+        // origin : d'où vient le fichier (serveur + chemin) — évite la confusion
+        const origin = sourceAdapter.describe(source);
+
+        // E — bascule auto utf8 → base64 si contenu binaire détecté
+        const autoDetect = options.autoDetect !== false;
+        let binaryDetected = false;
+        let effectiveEncoding = encoding;
+        if (encoding === 'utf8' && autoDetect && looksBinary(content)) {
+            effectiveEncoding = 'base64';
+            binaryDetected = true;
+        }
+
+        if (effectiveEncoding === 'base64') {
+            // offset/limit n'ont pas de sens sur du binaire
+            return {
+                origin, content: content.toString('base64'), hash, mtime, size,
+                encoding: 'base64',
+                ...(binaryDetected ? { binaryDetected: true, note: "Contenu binaire détecté (octet nul) — retourné en base64 automatiquement." } : {})
+            };
+        }
+
+        const full = content.toString('utf8');
+        const { offset, limit } = options;
+
+        // Lecture complète (défaut) → edit-safe
+        if (offset === undefined && limit === undefined) {
+            return { origin, content: full, hash, mtime, size, encoding: 'utf8' };
+        }
+
+        // Lecture partielle par lignes (mode consultation)
+        const lines = full.split('\n');
+        const totalLines = lines.length;
+        const start = offset && offset > 0 ? offset - 1 : 0; // offset 1-indexé
+        const end = limit ? start + limit : totalLines;
+        const slice = lines.slice(start, end).join('\n');
+
+        return {
+            origin,
+            content: slice,
+            hash,          // hash du fichier COMPLET (protection file_edit)
+            mtime,
+            size,
+            encoding,
+            isPartial: true,
+            offset: start + 1,
+            limit: limit ?? (totalLines - start),
+            totalLines,
+            returnedLines: Math.min(end, totalLines) - start
+        };
+    },
+
+    /**
+     * Écrit un fichier. content est une string (utf8 ou base64 selon encoding).
+     * options = { createDirs }
+     * Retourne { hash, size }.
+     */
+    async writeFile(source, content, encoding = 'utf8', options = {}) {
+        if (source.path) validatePath(source.path);
+        const buffer = encoding === 'base64'
+            ? Buffer.from(content, 'base64')
+            : Buffer.from(content, 'utf8');
+        const newHash = sha256(buffer);
+        const origin = sourceAdapter.describe(source);
+
+        // B — dryRun : montre ce qui serait écrit (diff vs existant) sans écrire
+        if (options.dryRun) {
+            let existed = false;
+            let oldContent = '';
+            try {
+                const cur = await sourceAdapter.readFile(source);
+                existed = true;
+                oldContent = cur.content.toString('utf8');
+            } catch { /* fichier inexistant → création */ }
+            const patch = encoding === 'base64'
+                ? '(binaire — diff non affiché)'
+                : createTwoFilesPatch(origin.label, origin.label, oldContent, content, existed ? 'avant' : '(nouveau)', 'après');
+            return { origin, dryRun: true, wouldWrite: true, existed, hash: newHash, size: buffer.length, diff: patch };
+        }
+
+        // C — backup auto avant écriture
+        let backup = null;
+        if (options.backup) backup = await this._backup(source, options.backupMessage);
+
+        const result = await sourceAdapter.writeFile(source, buffer, options);
+        return { origin, hash: newHash, size: result.size, ...(backup ? { backup } : {}) };
+    },
+
+    /**
+     * C — Crée un snapshot du fichier avant modification (filet de sécurité).
+     * Import dynamique de snapshotManager pour éviter tout couplage au chargement.
+     * Retourne { snapshotId, tag } ou null si le fichier n'existe pas encore.
+     */
+    async _backup(source, message) {
+        const exists = await sourceAdapter.exists(source);
+        if (!exists) return null; // rien à sauvegarder (nouveau fichier)
+        const { default: snapshotManager } = await import('./snapshotManager.js');
+        const snapSource = source.type === 'local'
+            ? { type: 'local' }
+            : { type: 'remote', alias: source.alias };
+        const tag = `auto-backup-${Date.now()}`;
+        const res = await snapshotManager.createSnapshot(snapSource, [source.path], {
+            tag,
+            message: message || `Backup auto avant modification de ${source.path}`
+        });
+        return { snapshotId: res.snapshotId, tag };
+    },
+
+    /**
+     * Édite un fichier avec protection par hash. DEUX MODES :
+     *
+     *  A) Chirurgical : { oldString, newString, replaceAll? }
+     *     Remplace un bout précis. Sûr : erreur si oldString absent (OLDSTRING_NOT_FOUND)
+     *     ou présent plusieurs fois sans replaceAll (MULTIPLE_MATCHES).
+     *     Économe en tokens (pas besoin de renvoyer tout le fichier).
+     *
+     *  B) Complet : { newContent }  → remplace tout le contenu.
+     *
+     * Options communes : { expectedHash, encoding, dryRun, backup, backupMessage }
+     *  - expectedHash : protège contre modification concurrente (HASH_MISMATCH)
+     *  - dryRun       : retourne le diff sans écrire
+     *  - backup       : snapshot du fichier avant écriture (undo via snapshot_restore)
+     *
+     * Retourne { origin, hash, diff, applied, added, removed, size, backup? }.
+     */
+    async editFile(source, params = {}, legacyExpectedHash, legacyEncoding) {
+        // Rétrocompat : ancienne signature editFile(source, newContent, expectedHash, encoding)
+        if (typeof params === 'string') {
+            params = { newContent: params, expectedHash: legacyExpectedHash, encoding: legacyEncoding };
+        }
+        const encoding = params.encoding || 'utf8';
+        const current = await this.readFile(source, encoding);
+
+        // Protection hash (optionnelle mais recommandée)
+        if (params.expectedHash && current.hash !== params.expectedHash) {
+            const err = new Error(
+                `Le fichier a été modifié depuis la dernière lecture (hash attendu: ${params.expectedHash}, actuel: ${current.hash}).`
+            );
+            err.code = 'HASH_MISMATCH';
+            err.current = current;
+            throw err;
+        }
+
+        // Détermine le nouveau contenu selon le mode
+        let newContent;
+        if (params.oldString !== undefined) {
+            // Mode A — chirurgical
+            const occurrences = current.content.split(params.oldString).length - 1;
+            if (occurrences === 0) {
+                const err = new Error(`oldString introuvable dans le fichier. Vérifiez le texte exact (espaces/indentation inclus).`);
+                err.code = 'OLDSTRING_NOT_FOUND';
+                throw err;
+            }
+            if (occurrences > 1 && !params.replaceAll) {
+                const err = new Error(`oldString présent ${occurrences} fois. Précisez plus de contexte pour un match unique, ou utilisez replaceAll:true.`);
+                err.code = 'MULTIPLE_MATCHES';
+                err.occurrences = occurrences;
+                throw err;
+            }
+            newContent = params.replaceAll
+                ? current.content.split(params.oldString).join(params.newString ?? '')
+                : current.content.replace(params.oldString, params.newString ?? '');
+        } else if (params.newContent !== undefined) {
+            // Mode B — remplacement complet
+            newContent = params.newContent;
+        } else {
+            throw new Error("Aucune modification fournie : utilisez { oldString, newString } (chirurgical) ou { newContent } (complet).");
+        }
+
+        // Diff lisible
+        const origin = sourceAdapter.describe(source);
+        const patch = createTwoFilesPatch(origin.label, origin.label, current.content, newContent, 'avant', 'après');
+        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++;
+        }
+
+        // B — dryRun : preview sans écrire
+        if (params.dryRun) {
+            return { origin, dryRun: true, applied: false, diff: patch, added, removed };
+        }
+
+        // C — backup avant écriture
+        let backup = null;
+        if (params.backup) backup = await this._backup(source, params.backupMessage);
+
+        const writeResult = await this.writeFile(source, newContent, encoding);
+
+        return {
+            origin,
+            hash: writeResult.hash,
+            diff: patch,
+            applied: true,
+            added,
+            removed,
+            size: writeResult.size,
+            ...(backup ? { backup } : {})
+        };
+    }
+};