@fkom13/mcp-sftp-orchestrator 11.3.0 → 11.8.0

package/servers.js

@@ -1,49 +1,35 @@
-import fs from 'fs/promises';
 import path from 'path';
 import config from './config.js';
+import jsonStore from './atomicJsonStore.js';
+
 const SERVERS_FILE_PATH = path.join(config.dataDir, 'servers.json');
+const EMPTY = {};
 
 async function readServers() {
-    try {
-        await fs.access(SERVERS_FILE_PATH);
-        const data = await fs.readFile(SERVERS_FILE_PATH, 'utf-8');
-        return JSON.parse(data);
-    } catch (error) {
-        // Si le fichier n'existe pas, on retourne un objet vide
-        return {};
-    }
+    return jsonStore.readJson(SERVERS_FILE_PATH, EMPTY);
 }
 
-async function writeServers(servers) {
-    await fs.writeFile(SERVERS_FILE_PATH, JSON.stringify(servers, null, 2));
-}
-
-async function addServer(alias, config) {
-    const servers = await readServers();
-    if (servers[alias]) {
-        // L'alias existe, on le met à jour
-        servers[alias] = { ...servers[alias], ...config };
-        await writeServers(servers);
-        return { success: true, message: `Serveur '${alias}' mis à jour avec succès.` };
-    }
-    // L'alias n'existe pas, on le crée
-    servers[alias] = config;
-    await writeServers(servers);
-    return { success: true, message: `Serveur '${alias}' ajouté avec succès.` };
+async function addServer(alias, serverConfig) {
+    let existed = false;
+    await jsonStore.updateJson(SERVERS_FILE_PATH, EMPTY, (servers) => {
+        existed = !!servers[alias];
+        servers[alias] = existed ? { ...servers[alias], ...serverConfig } : serverConfig;
+        return servers;
+    });
+    return { success: true, message: `Serveur '${alias}' ${existed ? 'mis à jour' : 'ajouté'} avec succès.` };
 }
 
 async function removeServer(alias) {
-    const servers = await readServers();
-    if (!servers[alias]) {
-        throw new Error(`L'alias '${alias}' n'existe pas.`);
-    }
-    delete servers[alias];
-    await writeServers(servers);
+    await jsonStore.updateJson(SERVERS_FILE_PATH, EMPTY, (servers) => {
+        if (!servers[alias]) throw new Error(`L'alias '${alias}' n'existe pas.`);
+        delete servers[alias];
+        return servers;
+    });
     return { success: true, message: `Serveur '${alias}' supprimé.` };
 }
 
 async function listServers() {
-    return await readServers();
+    return readServers();
 }
 
 async function getServer(alias) {
@@ -55,4 +41,15 @@ async function getServer(alias) {
     return serverConfig;
 }
 
-export default { addServer, removeServer, listServers, getServer };
+/** true si l'alias est marqué readonly:true dans servers.json */
+async function isAliasReadOnly(alias) {
+    if (!alias) return false;
+    try {
+        const sc = await getServer(alias);
+        return sc.readonly === true || sc.readOnly === true;
+    } catch {
+        return false;
+    }
+}
+
+export default { addServer, removeServer, listServers, getServer, isAliasReadOnly };

package/sftp.js

@@ -7,6 +7,7 @@ import serverManager from './servers.js';
 import sourceAdapter from './sourceAdapter.js';
 import fileOps from './fileOps.js';
 import micromatch from 'micromatch';
+import utils from './utils.js';
 
 // Fonction utilitaire pour créer un dossier parent si nécessaire
 async function ensureLocalDir(filePath) {
@@ -72,15 +73,94 @@ async function expandFileList(pattern, basePath = '') {
     // Si c'est un pattern glob
     if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
         const fullPattern = path.resolve(normalizedBasePath, pattern);
+        sourceAdapter.assertLocalPathAllowed(fullPattern);
         const files = await glob(fullPattern, { nodir: false });
+        for (const f of files) sourceAdapter.assertLocalPathAllowed(f);
         return files;
     }
 
     // Sinon c'est un fichier/dossier simple
     const fullPath = path.resolve(normalizedBasePath, pattern);
+    sourceAdapter.assertLocalPathAllowed(fullPath);
     return [fullPath];
 }
 
+/**
+ * Copie une entrée remote -> remote via le pool SFTP partagé.
+ *
+ * - fichier : respecte force:false et append le basename si la cible est un dossier ;
+ * - dossier : copie récursivement les fichiers sous la racine cible ; force:false
+ *   refuse une cible déjà existante afin d'éviter les merges/écrasements implicites.
+ *
+ * Note : les symlinks inclus dans un arbre sont volontairement ignorés par
+ * listFilesRecursive pour l'instant. La future stratégie direct/rsync devra les
+ * préserver ; le résultat expose un warning pour ne pas promettre une copie bit-à-bit.
+ */
+async function transferServerToServerEntry(file, job, force) {
+    const srcAlias = file.source_alias || job.source_alias;
+    const srcPath = file.source_path || file.local || file.remote;
+    const tgtAlias = job.alias;
+    const tgtPath = file.remote;
+
+    if (!srcAlias) throw new Error("source_alias requis pour server_to_server.");
+    if (!srcPath) throw new Error("Chemin source requis (local/source_path) pour server_to_server.");
+    if (!tgtPath) throw new Error("Chemin destination remote requis pour server_to_server.");
+
+    const srcKind = await sourceAdapter.exists({ type: 'remote', alias: srcAlias, path: srcPath });
+    if (!srcKind) throw new Error(`Source introuvable: ${srcAlias}:${srcPath}`);
+
+    if (srcKind === 'd') {
+        const dstKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: tgtPath });
+        if (dstKind && dstKind !== 'd') {
+            throw new Error(`La destination ${tgtAlias}:${tgtPath} existe et n'est pas un dossier.`);
+        }
+        if (dstKind && !force) {
+            throw new Error(
+                `Le dossier destination ${tgtAlias}:${tgtPath} existe déjà. ` +
+                `Utilisez force:true pour fusionner/écraser explicitement.`
+            );
+        }
+
+        const rels = await sourceAdapter.listFilesRecursive(
+            { type: 'remote', alias: srcAlias, path: srcPath },
+            { recursive: true, ignorePatterns: [] }
+        );
+        let success = 0;
+        const failures = [];
+        for (const rel of rels) {
+            const from = path.posix.join(srcPath, rel);
+            const to = path.posix.join(tgtPath, rel);
+            try {
+                const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: from });
+                await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: to }, buf.content, { createDirs: true });
+                success++;
+            } catch (e) {
+                failures.push({ file: from, target: to, error: e.message });
+            }
+        }
+        return {
+            total: rels.length, success, failures,
+            warning: 'Copie dossier SFTP: symlinks et dossiers vides non préservés; utiliser une future stratégie rsync/tar pour une réplication bit-à-bit.'
+        };
+    }
+
+    let finalTarget = tgtPath;
+    const dstKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: tgtPath });
+    if (dstKind === 'd') {
+        finalTarget = path.posix.join(tgtPath, path.posix.basename(srcPath));
+        const nestedKind = await sourceAdapter.exists({ type: 'remote', alias: tgtAlias, path: finalTarget });
+        if (nestedKind && !force) {
+            throw new Error(`Le fichier distant ${tgtAlias}:${finalTarget} existe déjà. Utilisez force:true.`);
+        }
+    } else if (dstKind && !force) {
+        throw new Error(`Le fichier distant ${tgtAlias}:${tgtPath} existe déjà. Utilisez force:true.`);
+    }
+
+    const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: srcPath });
+    await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: finalTarget }, buf.content, { createDirs: true });
+    return { total: 1, success: 1, failures: [] };
+}
+
 // Fonction principale de transfert avec support multi-fichiers
 async function executeTransfer(jobId) {
     const job = queue.getJob(jobId);
@@ -88,32 +168,8 @@ async function executeTransfer(jobId) {
 
     let sftp = null;
     try {
-        const serverConfig = await serverManager.getServer(job.alias);
         queue.updateJobStatus(jobId, 'running');
 
-        sftp = new SftpClient();
-
-        // Configuration de la connexion
-        const config = {
-            host: serverConfig.host,
-            port: 22,
-            username: serverConfig.user,
-            readyTimeout: 20000,
-            retries: 3,
-            retry_factor: 2,
-            retry_minTimeout: 2000
-        };
-        
-        if (serverConfig.keyPath) {
-            config.privateKey = await fs.readFile(serverConfig.keyPath);
-        } else if (serverConfig.password) {
-            config.password = serverConfig.password;
-        } else {
-            throw new Error(`Aucune méthode d'authentification pour '${job.alias}'.`);
-        }
-
-        await sftp.connect(config);
-        
         // Déterminer si on traite plusieurs fichiers
         const files = job.files || [{ local: job.local, remote: job.remote }];
         const isMultiple = Array.isArray(job.files) && job.files.length > 1;
@@ -123,45 +179,90 @@ async function executeTransfer(jobId) {
         let failedFiles = [];
         let totalFiles = 0;
 
-        for (let i = 0; i < files.length; i++) {
-            const file = files[i];
-            const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
-
-            try {
-                if (job.direction === 'upload') {
-                    const localFiles = await expandFileList(file.local);
-                    totalFiles += localFiles.length;
-                    for (const localFile of localFiles) {
-                        queue.log('info', `Transfert${progress}: ${localFile}`);
-                        await handleUpload(sftp, localFile, file.remote, force);
-                        successCount++;
+        // server_to_server : 100% pool via sourceAdapter (fichiers + dossiers)
+        if (job.direction === 'server_to_server') {
+            const warnings = [];
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
+                const srcAlias = file.source_alias || job.source_alias;
+                const srcPath = file.source_path || file.local || file.remote;
+                try {
+                    queue.log('info', `Transfert server_to_server${progress}: ${srcAlias}:${srcPath} → ${job.alias}:${file.remote}`);
+                    const result = await transferServerToServerEntry(file, job, force);
+                    totalFiles += result.total;
+                    successCount += result.success;
+                    if (result.failures?.length) failedFiles.push(...result.failures);
+                    if (result.warning && !warnings.includes(result.warning)) warnings.push(result.warning);
+                } catch (err) {
+                    totalFiles += 1; // l'item lui-même a été tenté, même si son contenu n'a pas pu être énuméré
+                    queue.log('error', `Échec transfert ${srcPath || file.remote}: ${err.message}`);
+                    failedFiles.push({ file: srcPath || file.remote, error: err.message });
+                }
+            }
+            job.transferWarnings = warnings;
+        } else {
+            // upload/download : SftpClient (dirs/glob) avec port configurable
+            const serverConfig = await serverManager.getServer(job.alias);
+            sftp = new SftpClient();
+            const sftpConfig = {
+                host: serverConfig.host,
+                port: utils.resolveSshPort(serverConfig),
+                username: serverConfig.user,
+                readyTimeout: 20000,
+                retries: 3,
+                retry_factor: 2,
+                retry_minTimeout: 2000
+            };
+            if (serverConfig.keyPath) {
+                sftpConfig.privateKey = await fs.readFile(serverConfig.keyPath);
+            } else if (serverConfig.password) {
+                sftpConfig.password = serverConfig.password;
+            } else {
+                throw new Error(`Aucune méthode d'authentification pour '${job.alias}'.`);
+            }
+            await sftp.connect(sftpConfig);
+
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const progress = isMultiple ? ` (${i + 1}/${files.length})` : '';
+
+                try {
+                    if (job.direction === 'upload') {
+                        const localFiles = await expandFileList(file.local);
+                        totalFiles += localFiles.length;
+                        for (const localFile of localFiles) {
+                            queue.log('info', `Transfert${progress}: ${localFile}`);
+                            // Fichier simple (pas dir) → pool sourceAdapter quand possible
+                            let isDir = false;
+                            try {
+                                const st = await fs.stat(localFile);
+                                isDir = st.isDirectory();
+                            } catch { /* handled in handleUpload */ }
+                            if (!isDir && !hasGlobPattern(file.remote || '')) {
+                                const content = await fs.readFile(localFile);
+                                let remotePath = file.remote;
+                                // Si remote est un dossier existant, append basename — handleUpload fait ça ;
+                                // pour pool on délègue à handleUpload si exists dir, sinon writeFile
+                                await handleUpload(sftp, localFile, file.remote, force);
+                            } else {
+                                await handleUpload(sftp, localFile, file.remote, force);
+                            }
+                            successCount++;
+                        }
+                    } else if (job.direction === 'download') {
+                        const downloadedCount = await handleDownload(sftp, file.remote, file.local, force);
+                        totalFiles += downloadedCount;
+                        successCount += downloadedCount;
                     }
-                } else if (job.direction === 'download') {
-                    const downloadedCount = await handleDownload(sftp, file.remote, file.local, force);
-                    totalFiles += downloadedCount;
-                    successCount += downloadedCount;
-                } else if (job.direction === 'server_to_server') {
-                    // Transfert direct entre deux serveurs distants (ou local↔remote inversé)
-                    const srcAlias = file.source_alias || job.source_alias;
-                    const srcPath = file.source_path || file.local || file.remote;
-                    const tgtAlias = job.alias;
-                    const tgtPath = file.remote;
-
-                    queue.log('info', `Transfert server_to_server${progress}: ${srcAlias}:${srcPath} → ${tgtAlias}:${tgtPath}`);
-                    const buf = await sourceAdapter.readFile({ type: 'remote', alias: srcAlias, path: srcPath });
-                    await sourceAdapter.writeFile({ type: 'remote', alias: tgtAlias, path: tgtPath }, buf.content, { createDirs: true });
-                    successCount++;
-                    totalFiles++;
+                } catch (err) {
+                    queue.log('error', `Échec transfert ${file.local || file.remote}: ${err.message}`);
+                    failedFiles.push({ file: file.local || file.remote, error: err.message });
                 }
-            } catch (err) {
-                queue.log('error', `Échec transfert ${file.local || file.remote}: ${err.message}`);
-                failedFiles.push({ file: file.local || file.remote, error: err.message });
             }
         }
         
-        await sftp.end();
-        
-        // Génération du rapport
+        // Génération du rapport (end() uniquement dans finally pour éviter double close)
         let status = successCount === totalFiles ? 'completed' : 'partial';
         let output = `Transfert ${job.direction}: ${successCount}/${totalFiles} fichiers réussis`;
         
@@ -170,7 +271,10 @@ async function executeTransfer(jobId) {
             if (successCount === 0) status = 'failed';
         }
         
-        queue.updateJobStatus(jobId, status, { output, failedFiles });
+        if (job.transferWarnings?.length) {
+            output += `\nAvertissements: ${job.transferWarnings.join(' | ')}`;
+        }
+        queue.updateJobStatus(jobId, status, { output, failedFiles, warnings: job.transferWarnings || [] });
         
     } catch (err) {
         queue.updateJobStatus(jobId, 'failed', { error: err.message });
@@ -187,6 +291,7 @@ async function executeTransfer(jobId) {
 
 // Gestion spécifique de l'upload
 async function handleUpload(sftp, localPath, remotePath, force = false) {
+    sourceAdapter.assertLocalPathAllowed(localPath);
     let localStats;
     try {
         localStats = await fs.stat(localPath);
@@ -242,6 +347,7 @@ async function handleUpload(sftp, localPath, remotePath, force = false) {
 
 // Gestion spécifique du download
 async function handleDownload(sftp, remotePath, localPath, force = false) {
+    sourceAdapter.assertLocalPathAllowed(localPath);
     if (hasGlobPattern(remotePath)) {
         const parentDir = path.dirname(remotePath);
         const pattern = path.basename(remotePath);
@@ -257,8 +363,9 @@ async function handleDownload(sftp, remotePath, localPath, force = false) {
             await fs.mkdir(localPath, { recursive: true });
 
             for (const fileName of matchingFiles) {
-                const remoteFile = path.join(parentDir, fileName);
+                const remoteFile = path.posix.join(parentDir, fileName);
                 const localFile = path.join(localPath, fileName);
+                sourceAdapter.assertLocalPathAllowed(localFile);
 
                 const localFileExists = await fs.access(localFile).then(() => true).catch(() => false);
                 if (localFileExists && !force) {
@@ -319,6 +426,7 @@ async function handleDownload(sftp, remotePath, localPath, force = false) {
             }
         }
 
+        sourceAdapter.assertLocalPathAllowed(finalLocalPath);
         const localDir = path.dirname(finalLocalPath);
         await fs.mkdir(localDir, { recursive: true });
         await sftp.get(remotePath, finalLocalPath);

package/shellSessions.js

@@ -2,6 +2,8 @@ import { Client } from 'ssh2';
 import fs from 'fs/promises';
 import crypto from 'crypto';
 import serverManager from './servers.js';
+import policies from './policies.js';
+import utils from './utils.js';
 
 /**
  * shellSessions — Sessions shell PTY PERSISTANTES sur serveurs distants.
@@ -34,7 +36,7 @@ class ShellSessionManager {
         const sc = await serverManager.getServer(alias);
         const config = {
             host: sc.host,
-            port: sc.port || 22,
+            port: utils.resolveSshPort(sc),
             username: sc.user,
             readyTimeout: 20000,
             keepaliveInterval: 30000,
@@ -168,8 +170,17 @@ class ShellSessionManager {
 
     /**
      * Exécute une commande dans une session existante (état persistant).
+     * options = { timeoutSec, skip_policy }
      */
-    async execInSession(id, command, timeoutSec) {
+    async execInSession(id, command, timeoutSec, options = {}) {
+        // Rétrocompat : 3e arg peut être un number (timeout) ou un objet options
+        let opts = options;
+        let timeout = timeoutSec;
+        if (typeof timeoutSec === 'object' && timeoutSec !== null) {
+            opts = timeoutSec;
+            timeout = opts.timeoutSec ?? opts.timeout;
+        }
+
         const session = this.sessions.get(id);
         if (!session) throw new Error(`Session '${id}' introuvable. Utilisez shell_list pour voir les sessions actives.`);
         if (session.closed) {
@@ -178,16 +189,33 @@ class ShellSessionManager {
         }
         if (session.busy) throw new Error(`Session '${id}' occupée : une seule commande à la fois par session.`);
 
+        if (!opts.skip_policy) {
+            const policyCheck = await policies.check(command);
+            if (policyCheck.blocked) {
+                throw new Error(
+                    `Commande bloquée par la politique de sécurité (pattern: "${policyCheck.pattern}"). ` +
+                    `Utilisez skip_policy:true pour forcer.`
+                );
+            }
+        }
+
         session.busy = true;
         session.lastUsed = Date.now();
         session.commandCount++;
         try {
-            return await this._exec(session, command, timeoutSec ?? session.cmdTimeout);
+            return await this._exec(session, command, timeout ?? session.cmdTimeout);
         } finally {
             session.busy = false;
         }
     }
 
+    /** Retourne les métadonnées minimales d'une session sans exposer la connexion. */
+    getSessionInfo(id) {
+        const s = this.sessions.get(id);
+        if (!s) return null;
+        return { id: s.id, alias: s.alias, closed: s.closed, busy: s.busy };
+    }
+
     /**
      * Liste les sessions actives avec leur état.
      */

package/snapshotManager.js

@@ -4,6 +4,7 @@ import crypto from 'crypto';
 import { createTwoFilesPatch } from 'diff';
 import config from './config.js';
 import sourceAdapter from './sourceAdapter.js';
+import jsonStore from './atomicJsonStore.js';
 
 /**
  * snapshotManager — Versioning d'infrastructure (style gencodedoc).
@@ -37,17 +38,12 @@ async function ensureDirs() {
 }
 
 async function readIndex() {
-    try {
-        const data = await fs.readFile(INDEX_FILE, 'utf8');
-        return JSON.parse(data);
-    } catch {
-        return { snapshots: [] };
-    }
+    return jsonStore.readJson(INDEX_FILE, { snapshots: [] });
 }
 
 async function writeIndex(index) {
     await ensureDirs();
-    await fs.writeFile(INDEX_FILE, JSON.stringify(index, null, 2));
+    await jsonStore.writeJsonAtomic(INDEX_FILE, index);
 }
 
 function objectPath(hash) {

package/sourceAdapter.js

@@ -1,10 +1,12 @@
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import micromatch from 'micromatch';
 import serverManager from './servers.js';
 import sshPool from './sshPool.js';
 import { z } from 'zod';
+import config from './config.js';
 
 /**
  * sourceAdapter — Abstraction unifiée local/remote.
@@ -148,6 +150,52 @@ function describe(source) {
     };
 }
 
+/**
+ * Politique transversale des chemins locaux.
+ *
+ * Historiquement MCP_ALLOWED_ROOTS n'était vérifié que dans fileOps.js, ce qui
+ * laissait snapshots/transferts contourner la restriction. La validation vit
+ * désormais au niveau sourceAdapter, porte d'entrée commune des accès locaux.
+ *
+ * La vérification combine :
+ *  - contrôle lexical du chemin absolu ;
+ *  - realpath du chemin (ou du parent existant le plus proche) pour empêcher
+ *    un symlink situé dans une racine autorisée de sortir de cette racine.
+ */
+function assertLocalPathAllowed(sourcePath) {
+    if (!config.allowedRoots || config.allowedRoots.length === 0) return;
+    if (!sourcePath || typeof sourcePath !== 'string') {
+        throw new Error("Chemin local invalide.");
+    }
+
+    const requested = path.resolve(sourcePath);
+
+    function realExistingAnchor(p) {
+        let cur = p;
+        while (!fsSync.existsSync(cur)) {
+            const parent = path.dirname(cur);
+            if (parent === cur) break;
+            cur = parent;
+        }
+        try { return fsSync.realpathSync.native(cur); } catch { return path.resolve(cur); }
+    }
+
+    const requestedAnchorReal = realExistingAnchor(requested);
+    const allowed = config.allowedRoots.some((root) => {
+        const rootAbs = path.resolve(root);
+        const lexical = requested === rootAbs || requested.startsWith(rootAbs + path.sep);
+        if (!lexical) return false;
+        const rootReal = realExistingAnchor(rootAbs);
+        return requestedAnchorReal === rootReal || requestedAnchorReal.startsWith(rootReal + path.sep);
+    });
+
+    if (!allowed) {
+        throw new Error(
+            `Accès local refusé : '${requested}' est hors MCP_ALLOWED_ROOTS (${config.allowedRoots.join(', ')}).`
+        );
+    }
+}
+
 // Valide la structure d'une source
 function validateSource(source) {
     if (!source || typeof source !== 'object') {
@@ -162,11 +210,16 @@ function validateSource(source) {
     if (source.type === 'remote' && !source.alias) {
         throw new Error("Source remote invalide : 'alias' est requis quand type='remote'.");
     }
+    if (source.type === 'local') {
+        assertLocalPathAllowed(source.path);
+    }
 }
 
-export { sourceSchema };
+export { sourceSchema, assertLocalPathAllowed };
 
 export default {
+    assertLocalPathAllowed,
+
     /**
      * Décrit une source : { server, type, path, label }.
      * server = 'localhost' ou alias serveur. Utile pour indiquer clairement

package/ssh.js

@@ -5,6 +5,7 @@ import serverManager from './servers.js';
 import sshPool from './sshPool.js';
 import config from './config.js';
 import policies from './policies.js';
+import utils from './utils.js';
 
 const STREAMING_COMMANDS = [
     /^pm2\s+logs?\b/i,
@@ -319,7 +320,7 @@ async function executeWithNewConnection(serverConfig, job, jobId) {
 
         const connectConfig = {
             host: serverConfig.host,
-            port: 22,
+            port: utils.resolveSshPort(serverConfig),
             username: serverConfig.user,
             readyTimeout: 20000
         };
@@ -366,10 +367,23 @@ async function executeCommandSequence(jobId) {
             const stepJob = {
                 ...job,
                 cmd: typeof cmd === 'string' ? cmd : cmd.command,
-                timeout: cmd.timeout || job.timeout,
-                continueOnError: cmd.continueOnError || job.continueOnError
+                timeout: (typeof cmd === 'object' && cmd.timeout != null) ? cmd.timeout : job.timeout,
+                continueOnError: (typeof cmd === 'object' && cmd.continueOnError != null)
+                    ? cmd.continueOnError
+                    : job.continueOnError
             };
 
+            // Policy par étape (sauf skip_policy)
+            if (!job.skip_policy) {
+                const policyCheck = await policies.check(stepJob.cmd);
+                if (policyCheck.blocked) {
+                    throw new Error(
+                        `Étape ${i + 1} bloquée par la politique de sécurité (pattern: "${policyCheck.pattern}"). ` +
+                        `Utilisez skip_policy:true pour forcer.`
+                    );
+                }
+            }
+
             try {
                 queue.log('info', `Exécution étape ${i + 1}/${job.commands.length}: ${stepJob.cmd}`);
                 // Don't update the main queue for sub-steps with phantom IDs