@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

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

package/fleet.js

@@ -0,0 +1,170 @@
+/**
+ * fleet.js — Diagnostic parallèle du parc (ping SSH + ressources légères).
+ */
+import queue from './queue.js';
+import servers from './servers.js';
+import sshPool from './sshPool.js';
+import utils from './utils.js';
+
+const PROBE_CMD = `echo OK; date -u +%Y-%m-%dT%H:%M:%SZ; uptime; free -h 2>/dev/null | head -2; df -h / 2>/dev/null | tail -1`;
+
+/**
+ * Probe un serveur : latence handshake + commande légère.
+ * Retourne { alias, ok, latencyMs, host, user, output?, error?, resources? }
+ */
+async function probeServer(alias, timeoutMs = 15000) {
+    const started = Date.now();
+    let connection = null;
+
+    try {
+        const serverConfig = await servers.getServer(alias);
+        // Vérifier que la clé existe (fail rapide)
+        if (serverConfig.keyPath) {
+            const fs = await import('fs/promises');
+            try {
+                await fs.access(serverConfig.keyPath);
+            } catch {
+                return {
+                    alias,
+                    ok: false,
+                    latencyMs: Date.now() - started,
+                    host: serverConfig.host,
+                    user: serverConfig.user,
+                    port: utils.resolveSshPort(serverConfig),
+                    error: `Clé SSH introuvable: ${serverConfig.keyPath}`
+                };
+            }
+        }
+
+        connection = await Promise.race([
+            sshPool.getConnection(alias, serverConfig),
+            new Promise((_, reject) =>
+                setTimeout(() => reject(new Error(`Timeout connexion ${timeoutMs}ms`)), timeoutMs)
+            )
+        ]);
+
+        const latencyMs = Date.now() - started;
+        const output = await execOnClient(connection.client, PROBE_CMD, Math.max(5000, timeoutMs - latencyMs));
+
+        return {
+            alias,
+            ok: true,
+            latencyMs,
+            host: serverConfig.host,
+            user: serverConfig.user,
+            port: utils.resolveSshPort(serverConfig),
+            output: (output || '').trim().slice(0, 800),
+            resources: parseLightResources(output)
+        };
+    } catch (err) {
+        let host = null, user = null, port = 22;
+        try {
+            const sc = await servers.getServer(alias);
+            host = sc.host; user = sc.user; port = utils.resolveSshPort(sc);
+        } catch { /* alias inconnu */ }
+
+        return {
+            alias,
+            ok: false,
+            latencyMs: Date.now() - started,
+            host,
+            user,
+            port,
+            error: err.message
+        };
+    } finally {
+        if (connection) {
+            try { sshPool.releaseConnection(connection.id); } catch { /* ignore */ }
+        }
+    }
+}
+
+function execOnClient(client, cmd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                reject(new Error(`Timeout exec ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+
+        client.exec(cmd, (err, stream) => {
+            if (err) {
+                clearTimeout(timer);
+                if (!settled) { settled = true; reject(err); }
+                return;
+            }
+            let out = '';
+            stream.on('data', d => { out += d.toString(); });
+            stream.stderr.on('data', d => { out += d.toString(); });
+            stream.on('close', (code) => {
+                clearTimeout(timer);
+                if (settled) return;
+                settled = true;
+                if (code !== 0 && code !== null) {
+                    // Certaines distros n'ont pas free -h : on accepte quand même si OK en tête
+                    if (out.includes('OK')) resolve(out);
+                    else reject(new Error(`exit ${code}: ${out.slice(0, 200)}`));
+                } else {
+                    resolve(out);
+                }
+            });
+        });
+    });
+}
+
+function parseLightResources(output) {
+    if (!output) return null;
+    const resources = { load: null, disk_use: null, mem_line: null };
+    try {
+        const loadMatch = output.match(/load average:\s*([0-9.,\s]+)/i);
+        if (loadMatch) resources.load = loadMatch[1].trim();
+        const lines = output.split('\n');
+        const mem = lines.find(l => /^\s*Mem:/i.test(l));
+        if (mem) resources.mem_line = mem.trim();
+        const disk = lines.find(l => /\/\s*$/.test(l.trim()) || l.includes('%'));
+        // dernière ligne df souvent "… 42% /"
+        const df = [...lines].reverse().find(l => /\d+%/.test(l) && l.includes('/'));
+        if (df) {
+            const m = df.match(/(\d+%)/);
+            if (m) resources.disk_use = m[1];
+        }
+    } catch { /* ignore */ }
+    return resources;
+}
+
+/**
+ * Status de tout le parc (ou d'une liste d'alias).
+ * options = { aliases?: string[], timeoutMs?: number }
+ */
+async function fleetStatus(options = {}) {
+    const all = await servers.listServers();
+    let aliases = options.aliases;
+
+    if (!aliases || aliases.length === 0) {
+        aliases = Object.keys(all);
+    }
+
+    // Résolution group: / all déjà faite en amont idéalement
+    const timeoutMs = options.timeoutMs || 15000;
+    queue.log('info', `fleet_status: probe de ${aliases.length} serveur(s)...`);
+
+    const results = await Promise.all(
+        aliases.map(alias => probeServer(alias, timeoutMs))
+    );
+
+    const ok = results.filter(r => r.ok).length;
+    const failed = results.filter(r => !r.ok);
+
+    return {
+        total: results.length,
+        online: ok,
+        offline: failed.length,
+        results: results.sort((a, b) => a.alias.localeCompare(b.alias)),
+        failed_aliases: failed.map(r => r.alias),
+        timestamp: new Date().toISOString()
+    };
+}
+
+export default { probeServer, fleetStatus };

package/groups.js

@@ -0,0 +1,25 @@
+/** Groupes d'alias serveurs. Stockage atomique: <dataDir>/server_groups.json */
+import path from 'path';
+import config from './config.js';
+import servers from './servers.js';
+import jsonStore from './atomicJsonStore.js';
+const GROUPS_PATH = path.join(config.dataDir, 'server_groups.json');
+const DEFAULT_GROUPS = { oci:['fkomprodmini1_prod','fkomprodmini2_prod','fkomprodmini2_vpn'], contabo:['vps_contabo'], vpsparfait:['vpsparfait_fkomp','vpsparfait2_fkomp'], local:['pc1_tailscale'] };
+const loadGroups = () => jsonStore.readJson(GROUPS_PATH, DEFAULT_GROUPS);
+async function listGroups(){ return loadGroups(); }
+async function setGroup(name, aliases){
+ if(!name || !/^[a-zA-Z0-9_-]+$/.test(name)) throw new Error("Nom de groupe invalide (alphanumérique, _ ou -).");
+ if(!Array.isArray(aliases)||!aliases.length) throw new Error("aliases doit être un tableau non vide d'alias serveurs.");
+ const all=await servers.listServers(); const unknown=aliases.filter(a=>!all[a]); if(unknown.length) throw new Error(`Alias inconnus: ${unknown.join(', ')}. Utilisez server_list.`);
+ const unique=[...new Set(aliases)]; await jsonStore.updateJson(GROUPS_PATH,DEFAULT_GROUPS,g=>{g[name]=unique;return g;}); return {success:true,group:name,aliases:unique};
+}
+async function removeGroup(name){ await jsonStore.updateJson(GROUPS_PATH,DEFAULT_GROUPS,g=>{if(!g[name]) throw new Error(`Groupe '${name}' introuvable.`); delete g[name]; return g;}); return {success:true,message:`Groupe '${name}' supprimé.`}; }
+async function resolveAliases(aliasInput){
+ const allServers=await servers.listServers(), allKeys=Object.keys(allServers); if(aliasInput==null||aliasInput==='') throw new Error("Alias requis.");
+ if(Array.isArray(aliasInput)){ const expanded=[]; for(const a of aliasInput){ if(String(a).startsWith('group:')) expanded.push(...await expandGroup(String(a).slice(6))); else {if(!allServers[a]) throw new Error(`Alias inconnu: ${a}`); expanded.push(a);} } return [...new Set(expanded)]; }
+ if(aliasInput==='all') return allKeys; if(String(aliasInput).startsWith('group:')) return expandGroup(String(aliasInput).slice(6));
+ if(!allServers[aliasInput]){ const groups=await loadGroups(); if(groups[aliasInput]) return expandGroup(aliasInput); throw new Error(`Alias de serveur '${aliasInput}' est inconnu. Utilisez server_list ou group:<nom>.`); }
+ return [aliasInput];
+}
+async function expandGroup(name){ const groups=await loadGroups(); if(!groups[name]) throw new Error(`Groupe '${name}' introuvable. Groupes: ${Object.keys(groups).join(', ') || '(aucun)'}`); const all=await servers.listServers(); const aliases=groups[name].filter(a=>all[a]); if(!aliases.length) throw new Error(`Groupe '${name}' ne contient aucun alias valide actuellement.`); return aliases; }
+export default {listGroups,setGroup,removeGroup,resolveAliases,expandGroup};