@fkom13/mcp-sftp-orchestrator 11.3.0 → 11.8.0

package/tunnels.js

@@ -5,6 +5,8 @@ import config from './config.js';
 import queue from './queue.js';
 import history from './history.js';
 import ssh from './ssh.js';
+import utils from './utils.js';
+import jsonStore from './atomicJsonStore.js';
 
 
 const TUNNELS_PATH = path.join(config.dataDir, 'tunnels.json');
@@ -15,27 +17,38 @@ const DEFAULT_ALLOWLIST = [80, 443, 3000, 8080, 8443, 9090, 3002, 3100, 3102, 45
 const LOCAL_TUNNELS = new Map();
 
 async function loadJson(p, def) {
-    try { await fs.access(p); return JSON.parse(await fs.readFile(p, 'utf-8')); }
-    catch { return def; }
+    return jsonStore.readJson(p, def);
 }
 async function saveJson(p, data) {
-    await fs.writeFile(p, JSON.stringify(data, null, 2));
+    await jsonStore.writeJsonAtomic(p, data);
 }
 
 async function loadAllowlist() {
-    return await loadJson(ALLOWLIST_PATH, DEFAULT_ALLOWLIST);
+    return loadJson(ALLOWLIST_PATH, DEFAULT_ALLOWLIST);
 }
 async function saveAllowlist(list) {
     await saveJson(ALLOWLIST_PATH, list);
 }
 
 async function loadRegistry() {
-    return await loadJson(TUNNELS_PATH, {});
+    return loadJson(TUNNELS_PATH, {});
 }
 async function saveRegistry(reg) {
     await saveJson(TUNNELS_PATH, reg);
 }
 
+const tunnelLocks = new Map();
+async function withTunnelLock(name, fn) {
+    const prev = tunnelLocks.get(name) || Promise.resolve();
+    let release;
+    const gate = new Promise(r => { release = r; });
+    const tail = prev.catch(() => {}).then(() => gate);
+    tunnelLocks.set(name, tail);
+    await prev.catch(() => {});
+    try { return await fn(); }
+    finally { release(); if (tunnelLocks.get(name) === tail) tunnelLocks.delete(name); }
+}
+
 async function getSshTarget(alias, serverManager) {
     const cfg = await serverManager.getServer(alias);
     return { host: cfg.host, port: cfg.port || 22, user: cfg.user, keyPath: cfg.keyPath };
@@ -67,6 +80,7 @@ function buildArgs(type, listenPort, target, via, remoteKeyPath) {
 
 export default {
     async create(params, serverManager) {
+        return withTunnelLock(params.name, async () => {
         const { name, type, listen_port, target, via, source, key_path } = params;
         if (!name) throw new Error("Le paramètre 'name' est requis.");
         if (!['local', 'remote', 'socks'].includes(type)) throw new Error("type doit être 'local', 'remote' ou 'socks'");
@@ -99,8 +113,8 @@ export default {
         }
 
         const sessionName = `tunnel-${name}`;
-        const sshCmd = 'ssh ' + args.join(' ');
-        const createCmd = `sh -c "tmux new-session -d -s ${sessionName} '${sshCmd}'"`;
+        const sshCmd = ['ssh', ...args].map(utils.escapeShellArg).join(' ');
+        const createCmd = `tmux new-session -d -s ${utils.escapeShellArg(sessionName)} -- sh -lc ${utils.escapeShellArg(sshCmd)}`;
 
         const job = queue.addJob({ type: 'ssh', alias: source, cmd: createCmd, pty: true, timeout: 20, skip_policy: true, status: 'pending' });
         history.logTask(job);
@@ -130,6 +144,12 @@ export default {
             ? `Proxy SOCKS5 sur ${source}:${listen_port} (via ${via})`
             : `${source}:${listen_port} → ${via}:${target}`;
         return `Tunnel '${name}' créé sur ${source} (session tmux: ${sessionName}). ${desc}\n✅ Persistant (survit au redémarrage du MCP).`;
+        });
+    },
+
+    async get(name) {
+        const registry = await loadRegistry();
+        return registry[name] || null;
     },
 
     async list() {
@@ -142,7 +162,7 @@ export default {
                 const local = LOCAL_TUNNELS.get(name);
                 status = local && local.process && !local.process.killed ? 'actif' : 'mort (MCP relancé, relancez le tunnel)';
             } else {
-                const ckJob = queue.addJob({ type: 'ssh', alias: info.source, cmd: `tmux has-session -t ${info.tmux_session} 2>/dev/null && echo actif || echo mort`, timeout: 10, skip_policy: true, streaming: false, status: 'pending' });
+                const ckJob = queue.addJob({ type: 'ssh', alias: info.source, cmd: `tmux has-session -t ${utils.escapeShellArg(info.tmux_session)} 2>/dev/null && echo actif || echo mort`, timeout: 10, skip_policy: true, streaming: false, status: 'pending' });
                 ssh.executeCommand(ckJob.id);
                 await new Promise(r => { const p = () => { const j = queue.getJob(ckJob.id); if (!j || j.status === 'completed' || j.status === 'failed') r(j); else setTimeout(p, 200); }; p(); });
                 const j = queue.getJob(ckJob.id);
@@ -156,6 +176,7 @@ export default {
     },
 
     async close(name, serverManager) {
+        return withTunnelLock(name, async () => {
         const registry = await loadRegistry();
         const info = registry[name];
         if (!info) throw new Error(`Tunnel '${name}' introuvable.`);
@@ -168,13 +189,14 @@ export default {
             }
             LOCAL_TUNNELS.delete(name);
         } else {
-            const killJob = queue.addJob({ type: 'ssh', alias: info.source, cmd: `tmux kill-session -t ${info.tmux_session} 2>/dev/null; echo OK`, timeout: 10, skip_policy: true, streaming: false, status: 'pending' });
+            const killJob = queue.addJob({ type: 'ssh', alias: info.source, cmd: `tmux kill-session -t ${utils.escapeShellArg(info.tmux_session)} 2>/dev/null; echo OK`, timeout: 10, skip_policy: true, streaming: false, status: 'pending' });
             ssh.executeCommand(killJob.id);
         }
 
         delete registry[name];
         await saveRegistry(registry);
         return `Tunnel '${name}' fermé.`;
+        });
     },
 
     async allowlistList() {
@@ -182,17 +204,14 @@ export default {
     },
 
     async allowlistAdd(port) {
-        const list = await loadAllowlist();
-        if (!list.includes(port)) list.push(port);
-        await saveAllowlist(list);
-        return list;
+        return jsonStore.updateJson(ALLOWLIST_PATH, DEFAULT_ALLOWLIST, list => {
+            if (!list.includes(port)) list.push(port);
+            return list;
+        });
     },
 
     async allowlistRemove(port) {
-        const list = await loadAllowlist();
-        const filtered = list.filter(p => p !== port);
-        await saveAllowlist(filtered);
-        return filtered;
+        return jsonStore.updateJson(ALLOWLIST_PATH, DEFAULT_ALLOWLIST, list => list.filter(p => p !== port));
     },
 
     async restore(servers) {

package/utils.js

@@ -1,6 +1,215 @@
+/**
+ * Utilitaires partagés (échappement shell, masquage secrets, timeouts, statuts).
+ * Extrait pour tests unitaires sans charger le serveur MCP.
+ */
+
+const SENSITIVE_KEYS = new Set([
+    'password',
+    'pass',
+    'api_key',
+    'apikey',
+    'apiKey',
+    'htpasswd_pass',
+    'htpasswdPass',
+    'secret',
+    'token',
+    'access_token',
+    'privateKey',
+    'private_key',
+    'authorization'
+]);
+
 function escapeShellArg(arg) {
     if (typeof arg !== 'string') return String(arg);
     return "'" + arg.replace(/'/g, "'\\''") + "'";
 }
 
-export default { escapeShellArg };
+/**
+ * Masque un secret : garde les `visible` derniers caractères.
+ * null/undefined/non-string → inchangé.
+ */
+function maskSecret(value, visible = 4) {
+    if (value == null) return value;
+    const s = String(value);
+    if (s.length === 0) return s;
+    if (s.length <= visible) return '***';
+    return '***' + s.slice(-visible);
+}
+
+/**
+ * Clone profond léger et masque les champs sensibles (récursif).
+ * Ne mute pas l'objet d'origine.
+ */
+function redactSensitiveObject(obj, options = {}) {
+    const visible = options.visible ?? 4;
+    const extraKeys = options.extraKeys || [];
+    const keys = new Set([...SENSITIVE_KEYS, ...extraKeys.map(k => k.toLowerCase())]);
+
+    function walk(value, keyName) {
+        if (value == null) return value;
+        if (Array.isArray(value)) return value.map(v => walk(v, null));
+        if (typeof value === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(value)) {
+                const lower = k.toLowerCase();
+                if (keys.has(lower) || keys.has(k)) {
+                    out[k] = typeof v === 'string' || typeof v === 'number'
+                        ? maskSecret(v, visible)
+                        : (v == null ? v : '***');
+                } else {
+                    out[k] = walk(v, k);
+                }
+            }
+            return out;
+        }
+        return value;
+    }
+
+    return walk(obj, null);
+}
+
+/**
+ * Convertit un timeout "secondes utilisateur" en ms pour waitForJobCompletion.
+ * - undefined/null → fallbackMs (déjà en ms, ex: config.syncTimeout)
+ * - 0 → 0 (attente infinie côté wait)
+ * - n > 0 → n * 1000
+ */
+function toWaitTimeoutMs(timeoutSeconds, fallbackMs) {
+    if (timeoutSeconds === 0) return 0;
+    if (timeoutSeconds == null || timeoutSeconds === undefined || timeoutSeconds === '') {
+        return fallbackMs;
+    }
+    const n = Number(timeoutSeconds);
+    if (!Number.isFinite(n) || n < 0) return fallbackMs;
+    return n * 1000;
+}
+
+/** Statuts pour lesquels un job n'évoluera plus (fin d'attente hybride). */
+function isTerminalJobStatus(status) {
+    return status === 'completed'
+        || status === 'failed'
+        || status === 'partial'
+        || status === 'crashed';
+}
+
+/**
+ * Résout le port SSH depuis une config serveur.
+ */
+function resolveSshPort(serverConfig) {
+    if (!serverConfig) return 22;
+    const p = serverConfig.port;
+    if (p == null || p === '') return 22;
+    const n = Number(p);
+    return Number.isFinite(n) && n > 0 && n <= 65535 ? n : 22;
+}
+
+/** Patterns heuristiques de commandes destructives (avertissement / dry-run). */
+const DESTRUCTIVE_PATTERNS = [
+    /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)\b/i,
+    /\brm\s+-rf\b/i,
+    /\bmkfs\b/i,
+    /\bdd\s+if=/i,
+    /\bdrop\s+(database|table)\b/i,
+    /\btruncate\s+table\b/i,
+    /\bshutdown\b/i,
+    /\breboot\b/i,
+    /\buserdel\b/i,
+    /\bpasswd\b/i,
+    /\bchmod\s+-R\s+000\b/i,
+    /\b>\s*\/dev\/sd/i,
+    /\biptables\s+-F\b/i,
+    /\bsystemctl\s+(stop|disable|mask)\b/i,
+    /\bdocker\s+(system\s+prune|rmi|rm\s+-f)\b/i,
+    /\bpm2\s+(delete|del|kill)\b/i
+];
+
+function isDestructiveCommand(cmd) {
+    if (!cmd || typeof cmd !== 'string') return false;
+    return DESTRUCTIVE_PATTERNS.some(re => re.test(cmd));
+}
+
+/**
+ * Refuse l'opération si MCP_READONLY=true.
+ * @throws Error
+ */
+function assertWritable(actionLabel = 'cette opération') {
+    // Lazy import-free: caller passes config.readOnly or we read env
+    const ro = process.env.MCP_READONLY === 'true' || process.env.MCP_READONLY === '1';
+    if (ro) {
+        throw new Error(
+            `Mode lecture seule (MCP_READONLY=1) : ${actionLabel} est refusé. ` +
+            `Relancez le MCP sans MCP_READONLY pour écrire.`
+        );
+    }
+}
+
+/**
+ * Compacte un objet pour l'agent (tronque gros champs).
+ * options = { maxString=500, maxArray=30, dropKeys=[] }
+ */
+function compactResult(obj, options = {}) {
+    const maxString = options.maxString ?? 500;
+    const maxArray = options.maxArray ?? 30;
+    const dropKeys = new Set(options.dropKeys || ['diff', 'raw_output', 'content']);
+
+    function walk(v, key) {
+        if (v == null) return v;
+        if (typeof v === 'string') {
+            if (dropKeys.has(key)) return v.length > 80 ? `[omitted ${v.length} chars]` : v;
+            return v.length > maxString ? v.slice(0, maxString) + `…[+${v.length - maxString}]` : v;
+        }
+        if (Array.isArray(v)) {
+            const sliced = v.slice(0, maxArray).map((item) => walk(item, null));
+            if (v.length > maxArray) sliced.push(`…+${v.length - maxArray} items`);
+            return sliced;
+        }
+        if (typeof v === 'object') {
+            const out = {};
+            for (const [k, val] of Object.entries(v)) {
+                if (dropKeys.has(k) && typeof val === 'string' && val.length > 100) {
+                    out[k] = `[omitted ${val.length} chars]`;
+                } else {
+                    out[k] = walk(val, k);
+                }
+            }
+            return out;
+        }
+        return v;
+    }
+
+    return walk(obj, null);
+}
+
+function wantsCompact(params = {}) {
+    if (params && params.compact === true) return true;
+    if (params && params.compact === false) return false;
+    return process.env.MCP_COMPACT === 'true' || process.env.MCP_COMPACT === '1';
+}
+
+export {
+    escapeShellArg,
+    maskSecret,
+    redactSensitiveObject,
+    toWaitTimeoutMs,
+    isTerminalJobStatus,
+    resolveSshPort,
+    isDestructiveCommand,
+    assertWritable,
+    compactResult,
+    wantsCompact,
+    DESTRUCTIVE_PATTERNS,
+    SENSITIVE_KEYS
+};
+
+export default {
+    escapeShellArg,
+    maskSecret,
+    redactSensitiveObject,
+    toWaitTimeoutMs,
+    isTerminalJobStatus,
+    resolveSshPort,
+    isDestructiveCommand,
+    assertWritable,
+    compactResult,
+    wantsCompact
+};

package/workSession.js

@@ -0,0 +1,139 @@
+/**
+ * workSession.js — Sessions de travail (journal d'intervention).
+ * Stockage atomique: <dataDir>/work_sessions.json
+ */
+import path from 'path';
+import crypto from 'crypto';
+import config from './config.js';
+import notes from './notes.js';
+import snapshotManager from './snapshotManager.js';
+import jsonStore from './atomicJsonStore.js';
+
+const SESSIONS_PATH = path.join(config.dataDir, 'work_sessions.json');
+const EMPTY = { active: {}, history: [] };
+
+const load = () => jsonStore.readJson(SESSIONS_PATH, EMPTY);
+
+function trimHistory(data) {
+    data.active ||= {};
+    data.history ||= [];
+    if (data.history.length > 100) data.history = data.history.slice(-100);
+    return data;
+}
+
+export default {
+    async start({ alias = null, project = null, tag = null, message = null, snapshot = false, paths = [] } = {}) {
+        const id = `ws_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
+        const session = {
+            id,
+            alias,
+            project,
+            tag: tag || `work-${new Date().toISOString().slice(0, 10)}`,
+            message: message || null,
+            startedAt: new Date().toISOString(),
+            events: [],
+            snapshotId: null,
+            status: 'active'
+        };
+
+        // Effet externe avant publication de la session. S'il échoue, on garde
+        // l'information dans les events mais on ne laisse aucun état partiel.
+        if (snapshot && alias && paths.length) {
+            try {
+                const snap = await snapshotManager.createSnapshot(
+                    { type: 'remote', alias }, paths,
+                    { tag: session.tag, message: message || `work_start ${id}` }
+                );
+                session.snapshotId = snap.snapshotId;
+            } catch (e) {
+                session.events.push({ at: new Date().toISOString(), type: 'snapshot_error', detail: e.message });
+            }
+        }
+
+        await jsonStore.updateJson(SESSIONS_PATH, EMPTY, data => {
+            trimHistory(data);
+            data.active[id] = session;
+            return data;
+        });
+        return session;
+    },
+
+    async log(id, event) {
+        let count = 0;
+        await jsonStore.updateJson(SESSIONS_PATH, EMPTY, data => {
+            trimHistory(data);
+            const session = data.active[id];
+            if (!session) throw new Error(`Session '${id}' introuvable ou déjà fermée.`);
+            session.events.push({ at: new Date().toISOString(), ...event });
+            count = session.events.length;
+            return data;
+        });
+        return { id, events: count };
+    },
+
+    async get(id) {
+        const data = trimHistory(await load());
+        if (data.active[id]) return data.active[id];
+        const hist = data.history.find(s => s.id === id);
+        if (hist) return hist;
+        throw new Error(`Session '${id}' introuvable.`);
+    },
+
+    async list({ includeHistory = false } = {}) {
+        const data = trimHistory(await load());
+        const active = Object.values(data.active);
+        if (!includeHistory) return { active, historyCount: data.history.length };
+        return { active, history: data.history };
+    },
+
+    async end(id, { summary = null, note = true } = {}) {
+        let closed;
+        // Commit principal d'abord : une panne de notes ne doit jamais laisser
+        // la session active alors que l'appel end a été accepté.
+        await jsonStore.updateJson(SESSIONS_PATH, EMPTY, data => {
+            trimHistory(data);
+            const session = data.active[id];
+            if (!session) throw new Error(`Session '${id}' introuvable ou déjà fermée.`);
+
+            session.status = 'closed';
+            session.endedAt = new Date().toISOString();
+            session.summary = summary || session.message || `Session ${id} fermée`;
+            session.events.push({ at: session.endedAt, type: 'end', detail: session.summary });
+            if (note && session.alias) session.noteUpdated = null; // pending
+
+            delete data.active[id];
+            data.history.push(session);
+            trimHistory(data);
+            closed = structuredClone(session);
+            return data;
+        });
+
+        if (note && closed.alias) {
+            let noteUpdated = true;
+            let noteError = null;
+            try {
+                await notes.set(closed.alias, {
+                    intervention: `[${closed.tag}] ${closed.summary} (${closed.events.length} events)`
+                });
+            } catch (e) {
+                noteUpdated = false;
+                noteError = e.message;
+            }
+
+            // Compensation: enrichit l'historique sans rouvrir la session.
+            await jsonStore.updateJson(SESSIONS_PATH, EMPTY, data => {
+                trimHistory(data);
+                const hist = data.history.find(s => s.id === id);
+                if (hist) {
+                    hist.noteUpdated = noteUpdated;
+                    if (noteError) hist.noteError = noteError;
+                    else delete hist.noteError;
+                    closed = structuredClone(hist);
+                }
+                return data;
+            });
+        }
+
+        return closed;
+    }
+};

package/.gencodedoc.yaml

@@ -1,76 +0,0 @@
-project_name: sftp-mcp
-ignore:
-  dirs:
-  - node_modules
-  - venv
-  - .venv
-  - env
-  - __pycache__
-  - .git
-  - dist
-  - build
-  - .next
-  - coverage
-  - node_modules
-  - dist
-  - .next
-  - venv
-  - .venv
-  - __pycache__
-  - dist
-  - build
-  files:
-  - .DS_Store
-  - Thumbs.db
-  - package-lock.json
-  - yarn.lock
-  extensions:
-  - .log
-  - .pyc
-  - .pyo
-  - .exe
-  - .bin
-  - .jpg
-  - .png
-  - .gif
-  - .mp4
-  - .pdf
-  - .zip
-  - .pyc
-  - .pyo
-  - .pyd
-  patterns: []
-autosave:
-  enabled: false
-  mode: hybrid
-  timer:
-    interval: 300
-  diff_threshold:
-    threshold: 0.05
-    check_interval: 60
-    ignore_whitespace: true
-    ignore_comments: false
-  hybrid:
-    min_interval: 180
-    max_interval: 600
-    threshold: 0.03
-  retention:
-    max_autosaves: 50
-    compress_after_days: 7
-    delete_after_days: 30
-    keep_manual: true
-diff_format:
-  default: unified
-  unified_context: 3
-  json_include_content: true
-  ast_enabled: false
-output:
-  default_name: '{project}_doc_{date}.md'
-  include_tree: true
-  include_code: true
-  tree_full_code_select: false
-  language_detection: true
-  max_file_size: 1000000
-storage_path: .gencodedoc
-compression_enabled: true
-compression_level: 3

package/ROADMAP.md

@@ -1,21 +0,0 @@
-# Roadmap MCP Orchestrator
-
-## v11.2.0 (actuelle)
-- ✅ Command Blocklist (policies.js) — sécurité des commandes
-- ✅ Multi-host execution (alias array / "all")
-- ✅ tmux sessions persistantes (create/exec/read/list/kill)
-- ✅ Tunnels SSH (local/remote/SOCKS5) avec allowlist
-- ✅ Guide IA intégré (audit, security, cheatsheet)
-- ✅ Help avec schémas JSON des paramètres
-- ✅ Snapshots versionnés avec déduplication
-- ✅ File edit chirurgical avec protection hash
-- ✅ Diff multi-serveur (compare_all_sources)
-- ✅ get_services_status graceful fallback
-
-## v12.x (planifiée)
-- [ ] Tunnels auto-setup de clés entre serveurs
-- [ ] Webhook on tunnel up/down (n8n compatible)
-- [ ] Dashboard web statique pour l'état du parc
-- [ ] Mode "agent" : exécution planifiée (cron-like)
-- [ ] Intégration Vaultwarden pour les secrets
-- [ ] Tests automatisés CI/CD