mcp-state-machine-test-framework 1.2.6 → 1.2.8

package/bin/init.js

@@ -35,9 +35,25 @@ async function init() {
 
     // 4. Crear Templates
     const templates = {
-        'maps/template_map.json': { nodos: { HOME: { transiciones: { IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Login\" }" } } }, LOGIN: { transiciones: { VOLVER: { destino: "HOME", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Back\" }" } } } } },
-        'test_cases/template_case.json': { name: "Template Case", steps: [ { name: "Ir a Login", action: "IR_A_LOGIN" } ] },
-        'suites/template_suite.json': { name: "Template Suite", state_map: "template_map.json", tests: ["template_case"] }
+        'maps/template_map.json': { 
+            nodos: { 
+                HOME: { 
+                    fingerprint: { selectors: ["~Login_Button"] },
+                    transiciones: { IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element {\"selector\":\"~Login_Button\"}" } } 
+                }, 
+                LOGIN: { 
+                    fingerprint: { selectors: ["~Back_Button", "id:login_title"] },
+                    transiciones: { VOLVER: { destino: "HOME", accion: "mcp:wdio-mcp/click_element {\"selector\":\"~Back_Button\"}" } } 
+                } 
+            } 
+        },
+        'test_cases/template_case.json': { 
+            name: "TC_Template", 
+            steps: [ 
+                { name: "Navegar a Login", action: "transicion:IR_A_LOGIN", assert: "sh:echo 'Validación de UI exitosa'" } 
+            ] 
+        },
+        'suites/template_suite.json': { name: "Suite_Template", state_map: "template_map.json", tests: ["TC_Template"] }
     };
 
     for (const [relPath, content] of Object.entries(templates)) {

package/index.js

@@ -1,727 +1,300 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { z } from "zod";
-import fs from "fs/promises";
-import fsSync from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { exec } from "child_process";
-import { promisify } from "util";
-
-const execAsync = promisify(exec);
-
-async function log(msg) {
-    const time = new Date().toISOString();
-    const line = `[${time}] ${msg}\n`;
-    await fs.appendFile("sms_server.log", line);
-}
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const DB_FILE = path.join(__dirname, "maquina_db.json");
-const SUITES_DIR = path.join(__dirname, "suites");
-const CASOS_DIR = path.join(__dirname, "test_cases");
-const REPORTS_ROOT = path.join(__dirname, "reports");
-const CONFIG_FILE = path.join(__dirname, "mcp_config.json");
-
-export class MaquinaDeEstados {
-    constructor() {
-        this.nodos = new Map();
-        this.casosPrueba = new Map();
-        this.suites = new Map();
-        this.mcpClients = new Map();
-    }
-
-    async cargar() {
-        for (const dir of [CASOS_DIR, SUITES_DIR]) {
-            if (!fsSync.existsSync(dir)) await fs.mkdir(dir, { recursive: true });
-            const files = await fs.readdir(dir);
-            for (const f of files) {
-                if (f.endsWith(".json")) {
-                    const content = JSON.parse(await fs.readFile(path.join(dir, f), "utf-8"));
-                    if (dir === CASOS_DIR) this.casosPrueba.set(content.name, content);
-                    else this.suites.set(content.name, content);
-                }
-            }
-        }
-    }
-
-    async getMcpClient(serverName) {
-        if (this.mcpClients.has(serverName)) return this.mcpClients.get(serverName);
-        const configRaw = await fs.readFile(CONFIG_FILE, "utf-8");
-        const config = JSON.parse(configRaw).mcpServers[serverName];
-        if (!config) throw new Error(`Configuración no encontrada para ${serverName}`);
-        const transport = new StdioClientTransport({
-            command: config.command,
-            args: config.args || [],
-            env: { ...process.env, ...config.env }
-        });
-        const client = new Client({ name: "SMS-Client", version: "11.1.0" }, { capabilities: {} });
-        await client.connect(transport);
-        const data = { client, transport };
-        this.mcpClients.set(serverName, data);
-        return data;
-    }
-
-    interpolate(text, data) {
-        if (!data) return text;
-        let result = text;
-        for (const key in data) {
-            result = result.replace(new RegExp(`{{${key}}}`, 'g'), data[key]);
-        }
-        return result;
-    }
-
-    async loadExternalData(dataPath) {
-        const fullPath = path.isAbsolute(dataPath) ? dataPath : path.join(__dirname, dataPath);
-        if (!fsSync.existsSync(fullPath)) return null;
-
-        const content = await fs.readFile(fullPath, "utf-8");
-        if (fullPath.endsWith(".json")) return JSON.parse(content);
-
-        if (fullPath.endsWith(".csv")) {
-            const lines = content.split("\n").map(l => l.trim()).filter(l => l.length > 0);
-            if (lines.length < 2) return [];
-            const headers = lines[0].split(",").map(h => h.trim().replace(/^["']|["']$/g, ""));
-            return lines.slice(1).map(line => {
-                const values = line.split(",");
-                const obj = {};
-                headers.forEach((h, i) => {
-                    let val = values[i] ? values[i].trim() : "";
-                    // Quitar comillas si existen
-                    val = val.replace(/^["']|["']$/g, "");
-                    obj[h] = val;
-                });
-                return obj;
-            });
-        }
-        return null;
-    }
-
-    async ejecutarSuite(suiteName) {
-        const suite = this.suites.get(suiteName);
-        if (!suite) throw new Error(`Suite '${suiteName}' no encontrada.`);
-
-        if (suite.state_map) {
-            process.stderr.write(`\n📍 [V12.3] Pre-flight Integrity Check for: ${suite.state_map}\n`);
-            // Simplified validation: Ensure the file exists and has the required structure
-            const mapPath = path.join(__dirname, 'maps', suite.state_map);
-            try {
-                await fs.access(mapPath);
-                const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
-                const nodes = mapData.nodos || mapData;
-                process.stderr.write(`✅ Map validated (${Object.keys(nodes).length} nodes found).\n`);
-            } catch (e) {
-                process.stderr.write(`❌ CRITICAL: State Map '${suite.state_map}' not found or invalid!\n`);
-                throw new Error(`Integrity Check Failed: ${e.message}`);
-            }
-        }
-
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const reportDir = path.join(REPORTS_ROOT, `exec_${suiteName}_${timestamp}`);
-        await fs.mkdir(reportDir, { recursive: true });
-        const results = { suiteName, timestamp, cases: [], hooks: { beforeSuite: [], afterSuite: [] } };
-
-        const maskSecrets = (text) => {
-            if (typeof text !== "string") return text;
-            // Enmascarar tokens de seguridad y JWTs
-            return text.replace(/("securityToken"\s*:\s*")[^"]+(")/g, '$1********$2')
-                .replace(/("token"\s*:\s*")[^"]+(")/g, '$1********$2')
-                .replace(/eyJhbGciOi[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*/g, '********[JWT_MASKED]********');
-        };
-
-        const runActions = async (actions, targetRes, data) => {
-            if (!actions) return;
-            for (const action of actions) {
-                const maskedAction = maskSecrets(action);
-                process.stderr.write(`[EXEC] Running action: ${maskedAction}\n`);
-                const actionRes = { action: maskedAction, status: "passed" };
-                targetRes.push(actionRes);
-                try {
-                    let lastResult = null;
-                    const executeAction = async (act) => {
-                        const subRes = (act === action) ? actionRes : { action: act, status: "passed" };
-                        if (act !== action) targetRes.push(subRes);
-
-                        let finalAction = act;
-                        try {
-                            if (act.startsWith("transicion:")) {
-                                const transName = act.replace("transicion:", "").trim();
-                                const mapPath = path.join(__dirname, 'maps', suite.state_map);
-                                const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
-                                const nodes = mapData.nodos || mapData;
-
-                                let foundAction = null;
-                                let destNodeName = null;
-                                for (const [nodeName, node] of Object.entries(nodes)) {
-                                    if (node.transiciones && node.transiciones[transName]) {
-                                        foundAction = node.transiciones[transName].accion;
-                                        destNodeName = node.transiciones[transName].destino;
-                                        break;
-                                    }
-                                }
-                                if (!foundAction) throw new Error(`Transición '${transName}' no encontrada en el mapa '${suite.state_map}'`);
-                                
-                                // Ejecutar la acción de la transición
-                                await executeAction(foundAction);
-
-                                // --- VERIFICACIÓN DE IDENTIDAD (FINGERPRINT) ---
-                                const destNode = nodes[destNodeName];
-                                if (destNode && destNode.fingerprint) {
-                                    const fp = destNode.fingerprint;
-                                    const selectors = fp.selectors || (fp.selector ? [fp.selector] : []);
-                                    
-                                    if (selectors.length > 0) {
-                                        process.stderr.write(`[AUTH] Verificando identidad múltiple del nodo: ${destNodeName} (${selectors.length} vectores)\n`);
-                                        const { client } = await this.getMcpClient("wdio-mcp");
-                                        
-                                        for (const sel of selectors) {
-                                            const verifyRes = await client.callTool({ 
-                                                name: "wait_for_element", 
-                                                arguments: { selector: sel, timeout: fp.timeout || 5000 } 
-                                            }, undefined, { timeout: 10000 });
-
-                                            if (verifyRes.isError) {
-                                                throw new Error(`Error de Identidad: No se encontró el vector '${sel}' para el nodo '${destNodeName}'.`);
-                                            }
-                                        }
-                                        subRes.output = (subRes.output || "") + `\n✅ Identidad Multivectorial confirmada para '${destNodeName}'.`;
-                                    }
-                                }
-                                return;
-                            }
-
-                            if (Array.isArray(finalAction)) {
-                                for (const subAct of finalAction) {
-                                    await executeAction(subAct);
-                                }
-                                return;
-                            }
-
-                            const interpolatedAction = this.interpolate(finalAction, data);
-
-                            if (interpolatedAction.startsWith("sh:")) {
-                                const shCmd = interpolatedAction.replace("sh:", "").trim();
-                                process.stderr.write(`[SH] Ejecutando: ${shCmd}\n`);
-                                const { stdout, stderr } = await execAsync(shCmd);
-                                subRes.output = (subRes.output || "") + "\n" + stdout + (stderr ? "\nERR: " + stderr : "");
-                            } else if (interpolatedAction.startsWith("mcp:")) {
-                                const raw = interpolatedAction.replace("mcp:", "").trim();
-                                const slashIndex = raw.indexOf("/");
-                                const serverName = raw.substring(0, slashIndex);
-                                const rest = raw.substring(slashIndex + 1);
-                                const spaceIndex = rest.indexOf(" ");
-                                const toolName = spaceIndex === -1 ? rest : rest.substring(0, spaceIndex);
-                                const toolArgs = JSON.parse(spaceIndex === -1 ? "{}" : rest.substring(spaceIndex + 1));
-
-                                const { client } = await this.getMcpClient(serverName);
-                                lastResult = await client.callTool({ name: toolName, arguments: toolArgs }, undefined, { timeout: 600000 });
-
-                                if (lastResult.isError && toolName !== "close_session") {
-                                    throw new Error(lastResult.content?.[0]?.text || "Error desconocido en herramienta MCP");
-                                }
-
-                                if (lastResult.content) {
-                                    for (const item of lastResult.content) {
-                                        if (item.text) {
-                                            subRes.output = (subRes.output || "") + "\n" + maskSecrets(item.text);
-                                        }
-                                        if (item.type === "image") {
-                                            subRes.image = item.data.startsWith("data:") ? item.data : `data:image/png;base64,${item.data}`;
-                                        }
-                                    }
-                                }
-                            }
-                        } catch (e) {
-                            subRes.status = "failed";
-                            subRes.error = e.message;
-                            throw e;
-                        }
-                    };
-
-                    await executeAction(action);
-                } catch (e) {
-                    actionRes.status = "failed";
-                    actionRes.error = e.message;
-                    throw e;
-                }
-            }
-        };
-
-        try {
-            await runActions(suite.beforeSuite, results.hooks.beforeSuite);
-            for (const caseName of suite.tests) {
-                const testCase = this.casosPrueba.get(caseName);
-                if (!testCase) continue;
-
-                let dataRows = [null];
-                if (testCase.data) {
-                    if (Array.isArray(testCase.data)) dataRows = testCase.data;
-                    else if (typeof testCase.data === "string") dataRows = await this.loadExternalData(testCase.data) || [null];
-                }
-
-                for (let i = 0; i < dataRows.length; i++) {
-                    const row = dataRows[i];
-                    const suffix = row ? ` [Iteration ${i + 1}]` : "";
-                    const caseRes = { name: testCase.name + suffix, steps: [], status: "passed", hooks: { beforeCase: [], afterCase: [] } };
-                    results.cases.push(caseRes);
-
-                    try {
-                        await runActions(suite.beforeCase, caseRes.hooks.beforeCase, row);
-                        for (const step of testCase.steps) {
-                            const stepRes = { name: step.name, actions: [], status: "passed" };
-                            caseRes.steps.push(stepRes);
-                            try {
-                                // Hooks de paso
-                                await runActions(suite.beforeStep, stepRes.actions, row);
-                                
-                                // Acción Principal (puede ser 'action' o 'actions')
-                                const mainActions = step.actions || (step.action ? [step.action] : []);
-                                await runActions(mainActions, stepRes.actions, row);
-
-                                // --- VALIDACIÓN TÉCNICA (ASSERT) ---
-                                if (step.assert) {
-                                    const actionRes = { action: `[ASSERT] ${step.assert}`, status: "passed" };
-                                    stepRes.actions.push(actionRes);
-                                    try {
-                                        // Re-utilizamos runActions para procesar el assert (puede ser mcp: o sh:)
-                                        await runActions([step.assert], stepRes.actions, row);
-                                    } catch (e) {
-                                        actionRes.status = "failed";
-                                        actionRes.error = e.message;
-                                        throw new Error(`Assert Fallido: ${e.message}`);
-                                    }
-                                }
-                            } catch (e) {
-                                stepRes.status = "failed";
-                                stepRes.error = e.message;
-                                throw e;
-                            } finally {
-                                await runActions(suite.afterStep, stepRes.actions, row);
-                            }
-                        }
-                        await runActions(suite.afterCase, caseRes.hooks.afterCase, row);
-                    } catch (e) { caseRes.status = "failed"; caseRes.error = e.message; }
-                }
-            }
-            await runActions(suite.afterSuite, results.hooks.afterSuite);
-        } finally {
-            for (const { transport } of this.mcpClients.values()) await transport.close();
-            this.mcpClients.clear();
-            await this.finalizarReporte(reportDir, results);
-        }
-        return reportDir;
-    }
-
-    async finalizarReporte(dir, data) {
-        const renderActions = (actions) => actions.map(a => {
-            const isAssert = a.action.startsWith("[ASSERT]");
-            const isIdentity = a.output && a.output.includes("Identidad confirmada");
-            
-            return `
-            <div class="action-card" style="border-left: 4px solid ${a.status === 'passed' ? (isAssert ? '#10b981' : '#3b82f6') : '#ef4444'}; background: ${isAssert ? 'rgba(16, 185, 129, 0.05)' : 'rgba(15, 23, 42, 0.8)'}; padding: 20px; border-radius: 12px; margin-bottom: 15px; border: 1px solid #1e293b;">
-                <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom: 10px;">
-                    <span style="font-weight: 600; font-size: 0.9em; color: ${isAssert ? '#10b981' : '#94a3b8'};">
-                        ${isAssert ? '🛡️ VALIDACIÓN (ASSERT)' : '⚙️ ACCIÓN'}
-                    </span>
-                    <span class="status-badge" style="background:${a.status === 'passed' ? '#065f46' : '#991b1b'};">${a.status}</span>
-                </div>
-                <div style="font-family: 'JetBrains Mono', monospace; font-size: 0.95em; color: #f8fafc; margin-bottom: 10px;">
-                    ${isAssert ? a.action.replace("[ASSERT]", "").trim() : a.action}
-                </div>
-                ${isIdentity ? `<div style="background: rgba(16, 185, 129, 0.2); color: #34d399; padding: 8px 12px; border-radius: 6px; font-size: 0.85em; margin-bottom: 10px; border: 1px solid rgba(16, 185, 129, 0.3);">🔍 <b>Identidad:</b> ${a.output.includes("Multivectorial") ? "Sincronización Multivectorial Exitosa" : "Confirmada"}</div>` : ""}
-                ${a.image ? `<div style="margin-top:15px; text-align:center;"><img src="${a.image}" style="max-width:100%; border-radius:8px; border: 1px solid #334155; cursor: pointer;" onclick="window.open(this.src)"></div>` : ""}
-                ${a.output && !isIdentity ? `
-                    <details style="margin-top:10px;">
-                        <summary style="cursor:pointer; color:#64748b; font-size:0.8em;">Ver logs técnicos</summary>
-                        <pre style="background:#020617; padding:12px; border-radius:6px; font-size:0.8em; color:#10b981; margin-top:8px; border:1px solid #1e293b; overflow-x:auto;">${a.output}</pre>
-                    </details>` : ""}
-                ${a.error ? `<pre style="background:#450a0a; padding:12px; border-radius:6px; font-size:0.8em; color:#fca5a5; margin-top:8px;">${a.error}</pre>` : ""}
-            </div>
-        `}).join("");
-
-        const html = `<!DOCTYPE html><html lang="es"><head><meta charset="UTF-8"><title>SMS Dashboard V11.1 CSV-Ready</title>
-            <style>
-                @import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;800&display=swap');
-                body { font-family: 'Outfit', sans-serif; background: #020617; color: #f8fafc; padding: 60px; line-height: 1.6; }
-                .container { max-width: 1000px; margin: 0 auto; }
-                .card { background: #0f172a; border: 1px solid #1e293b; border-radius: 20px; padding: 40px; margin-bottom: 30px; box-shadow: 0 20px 50px rgba(0,0,0,0.3); }
-                .hook-label { background: #3b82f6; color: white; font-size: 0.7em; font-weight: 800; padding: 5px 12px; border-radius: 50px; text-transform: uppercase; margin-bottom: 15px; display: inline-block; letter-spacing: 1px; }
-                h1 { font-size: 3.5em; font-weight: 800; background: linear-gradient(to right, #60a5fa, #a855f7); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 0.2em; }
-                .step { border-left: 3px solid #3b82f6; padding-left: 30px; margin: 40px 0; }
-                h2 { font-size: 2em; margin-bottom: 1em; color: #f1f5f9; }
-                h3 { color: #94a3b8; font-weight: 400; text-transform: uppercase; font-size: 0.9em; letter-spacing: 2px; }
-            </style></head>
-        <body><div class="container">
-            <h1>SMS Dashboard</h1>
-            <p style="color: #64748b; font-size: 1.1em; margin-bottom: 40px;">Universal Data-Driven Framework • V11.2</p>
-            ${data.hooks.beforeSuite.length ? `<div class="card"><span class="hook-label">Global Setup</span>${renderActions(data.hooks.beforeSuite)}</div>` : ""}
-            ${data.cases.map(c => `
-                <div class="card">
-                    <h3 style="color:#60a5fa; margin-bottom:10px;">TEST CASE EXECUTION</h3>
-                    <h2>${c.name}</h2>
-                    ${c.hooks.beforeCase.length ? `<div><span class="hook-label">Pre-Condition</span>${renderActions(c.hooks.beforeCase)}</div>` : ""}
-                    ${c.steps.map(s => `<div class="step"><h3>STEP: ${s.name}</h3>${renderActions(s.actions)}</div>`).join("")}
-                    ${c.hooks.afterCase.length ? `<div><span class="hook-label">Post-Condition</span>${renderActions(c.hooks.afterCase)}</div>` : ""}
-                </div>
-            `).join("")}
-            ${data.hooks.afterSuite.length ? `<div class="card"><span class="hook-label">Global Teardown</span>${renderActions(data.hooks.afterSuite)}</div>` : ""}
-        </div></body></html>`;
-        await fs.writeFile(path.join(dir, "index.html"), html);
-        await fs.writeFile(path.join(dir, "results.json"), JSON.stringify(data, null, 2));
-    }
-}
-
-const maquina = new MaquinaDeEstados();
-const server = new McpServer({ name: "demo-state-machine", version: "11.1.0" });
-server.tool("execute_suite", "Ejecución de Suite Completa", {
-    name: z.string().describe("Nombre de la suite a ejecutar (ej: 'Suite_Login'). Buscará el archivo en /suites.")
-}, async ({ name }) => {
-    await maquina.cargar();
-    const dir = await maquina.ejecutarSuite(name);
-    return { content: [{ type: "text", text: `Reporte: ${dir}` }] };
-});
-
-server.tool("upsert_node", "Añadir o actualizar un nodo en el mapa de estados.", {
-    mapName: z.string().describe("Nombre del archivo del mapa (ej: 'home_map.json'). El servidor lo buscará en la carpeta /maps."),
-    nodeName: z.string().describe("Identificador único del nodo (ej: 'LOGIN_PAGE', 'HOME')."),
-    nodeData: z.object({
-        transiciones: z.any().optional().describe("Objeto que define las salidas del nodo. Ej: { 'IR_A_LOGIN': { 'destino': 'LOGIN_PAGE', 'accion': 'mcp:wdio-mcp/click_element ...' } }")
-    }).passthrough().describe("Datos completos del nodo, incluyendo transiciones y metadatos.")
-}, async ({ mapName, nodeName, nodeData }) => {
-    const mapPath = path.join(__dirname, 'maps', mapName);
-    let map = { nodos: {} };
-    try {
-        const content = await fs.readFile(mapPath, 'utf8');
-        map = JSON.parse(content);
-        if (!map.nodos) map = { nodos: map };
-    } catch (e) { }
-
-    map.nodos[nodeName] = nodeData;
-    await fs.mkdir(path.dirname(mapPath), { recursive: true });
-    await fs.writeFile(mapPath, JSON.stringify(map, null, 2));
-
-    // Generar/Actualizar Diagrama Mermaid
-    try {
-        let mermaid = "graph TD\n";
-        for (const [name, node] of Object.entries(map.nodos)) {
-            if (node.transiciones) {
-                for (const [transName, trans] of Object.entries(node.transiciones)) {
-                    mermaid += `  ${name} -- "${transName}" --> ${trans.destino}\n`;
-                }
-            }
-        }
-        const mermaidPath = mapPath.replace('.json', '.md');
-        await fs.writeFile(mermaidPath, `# 🗺️ Diagrama de Estados: ${mapName}\n\n\`\`\`mermaid\n${mermaid}\`\`\``);
-    } catch (me) {
-        process.stderr.write(`[WARN] Error generando Mermaid: ${me.message}\n`);
-    }
-
-    return { content: [{ type: "text", text: `Nodo '${nodeName}' actualizado. Diagrama visual regenerado en maps/${mapName.replace('.json', '.md')}` }] };
-});
-
-server.tool("inspect_framework", "Inspeccionar integridad y listar entidades del framework", {
-    filter: z.optional(z.string())
-}, async () => {
-    const entities = { maps: [], test_cases: [], suites: [], health: [] };
-    const getFiles = async (dir) => {
-        try { return (await fs.readdir(path.join(__dirname, dir))).filter(f => f.endsWith('.json')); }
-        catch (e) { return []; }
-    };
-
-    entities.maps = await getFiles('maps');
-    entities.test_cases = await getFiles('test_cases');
-    entities.suites = await getFiles('suites');
-
-    // Validación de integridad simple
-    for (const suiteFile of entities.suites) {
-        try {
-            const suite = JSON.parse(await fs.readFile(path.join(__dirname, 'suites', suiteFile), 'utf8'));
-            if (!entities.maps.includes(suite.state_map)) {
-                entities.health.push(`❌ Suite '${suiteFile}' referencia a mapa inexistente: ${suite.state_map}`);
-            }
-            for (const tc of suite.tests) {
-                if (!entities.test_cases.includes(`${tc}.json`) && !entities.test_cases.includes(tc)) {
-                    entities.health.push(`❌ Suite '${suiteFile}' referencia a test case inexistente: ${tc}`);
-                }
-            }
-        } catch (e) { entities.health.push(`❌ Error leyendo suite '${suiteFile}': ${e.message}`); }
-    }
-
-    if (entities.health.length === 0) entities.health.push("✅ Estructura íntegra. Todos los vínculos son correctos.");
-
-    // Validación de integridad de Grafos (Nodos Huérfanos)
-    for (const mapFile of entities.maps) {
-        try {
-            const mapData = JSON.parse(await fs.readFile(path.join(__dirname, 'maps', mapFile), 'utf8'));
-            const nodos = mapData.nodos || mapData;
-            if (nodos && nodos["HOME"]) {
-                const reachable = new Set(["HOME"]);
-                const stack = ["HOME"];
-                while (stack.length > 0) {
-                    const current = stack.pop();
-                    const node = nodos[current];
-                    if (node && node.transiciones) {
-                        for (const t of Object.values(node.transiciones)) {
-                            if (t.destino && nodos[t.destino] && !reachable.has(t.destino)) {
-                                reachable.add(t.destino);
-                                stack.push(t.destino);
-                            }
-                        }
-                    }
-                }
-                const totalNodes = Object.keys(nodos);
-                const unreachable = totalNodes.filter(n => !reachable.has(n));
-                if (unreachable.length > 0) {
-                    entities.health.push(`⚠️ Mapa '${mapFile}': Nodos inalcanzables desde HOME: ${unreachable.join(', ')}`);
-                }
-            } else if (nodos && !nodos["HOME"]) {
-                entities.health.push(`⚠️ Mapa '${mapFile}': No tiene un nodo 'HOME' (inicio), no se puede validar el grafo.`);
-            }
-        } catch (e) { entities.health.push(`❌ Error validando grafo de '${mapFile}': ${e.message}`); }
-    }
-
-    return { content: [{ type: "text", text: JSON.stringify(entities, null, 2) }] };
-});
-
-server.tool("save_test_case", "Crear o actualizar un caso de prueba.", {
-    name: z.string().describe("Nombre identificador del test (ej: 'TC_Login_Exitoso')."),
-    steps: z.array(z.object({
-        name: z.string().optional().describe("Descripción amigable del paso (ej: 'Ingresar Usuario')."),
-        action: z.string().optional().describe("Acción a realizar. Puede ser un nombre de transición del mapa o un comando mcp:wdio-mcp/...")
-    }).passthrough()).describe("Lista ordenada de pasos lógicos a ejecutar.")
-}, async ({ name, steps }) => {
-    const fileName = name.endsWith('.json') ? name : `${name}.json`;
-    const filePath = path.join(__dirname, 'test_cases', fileName);
-    const testCase = { name: name.replace('.json', ''), steps };
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(testCase, null, 2));
-    return { content: [{ type: "text", text: `Caso de prueba '${name}' guardado correctamente.` }] };
-});
-
-server.tool("save_suite", "Crear o actualizar una suite de pruebas.", {
-    name: z.string().describe("Nombre de la suite (ej: 'Suite_E2E_Sanity')."),
-    state_map: z.string().describe("Archivo del mapa de estados a usar (ej: 'mob_perfecto_map.json')."),
-    tests: z.array(z.string()).describe("Lista de nombres de casos de prueba a incluir en la suite."),
-    beforeSuite: z.array(z.string()).optional().default([]).describe("Acciones globales antes de la suite (ej: iniciar sesión)."),
-    afterSuite: z.array(z.string()).optional().default([]).describe("Acciones globales tras la suite (ej: cerrar sesión).")
-}, async ({ name, state_map, tests, beforeSuite, afterSuite }) => {
-    const fileName = name.endsWith('.json') ? name : `${name}.json`;
-    const filePath = path.join(__dirname, 'suites', fileName);
-    const suite = { name: name.replace('.json', ''), state_map, tests, beforeSuite, afterSuite };
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(suite, null, 2));
-    return { content: [{ type: "text", text: `Suite '${name}' guardada correctamente.` }] };
-});
-
-server.tool("design_wizard", "Asistente paso a paso para diseñar la máquina de estados", {
-    action: z.enum(["start", "add_node", "add_transition", "save"]),
-    data: z.record(z.any()).optional().describe("Datos según la fase: { mapName }, { nodeName }, { label, destino, accion }")
-}, async ({ action, data }) => {
-    const contextPath = path.join(__dirname, 'data', '.design_context.json');
-    let context = { step: "IDLE", mapName: "", nodeName: "", transitions: {} };
-
-    try { context = JSON.parse(await fs.readFile(contextPath, 'utf8')); } catch (e) { }
-
-    if (action === "start") {
-        context = { step: "SELECT_NODE", mapName: data.mapName || "default_map.json", nodeName: "", transitions: {} };
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🧙‍♂️ Wizard Iniciado: Trabajando en '${context.mapName}'.\n\nPASO 1: ¿Qué nombre le damos al nodo? (Usa action: 'add_node')` }] };
-    }
-
-    if (action === "add_node" && context.step === "SELECT_NODE") {
-        context.nodeName = data.nodeName;
-        context.step = "DEFINE_FINGERPRINT";
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `📍 Nodo '${context.nodeName}' identificado.\n\nPASO 2: ¿Cuál es la Huella Digital (Fingerprint) de esta pantalla? (Usa action: 'add_fingerprint' con { selector }).` }] };
-    }
-
-    if (action === "add_fingerprint" && context.step === "DEFINE_FINGERPRINT") {
-        if (!context.fingerprint) context.fingerprint = { selectors: [] };
-        context.fingerprint.selectors.push(data.selector);
-        context.fingerprint.timeout = data.timeout || 5000;
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🧬 Vector añadido: ${data.selector}.\n\n¿Quieres añadir otro detector para este nodo? (Usa 'add_fingerprint') o finaliza la identidad con 'done_fingerprint'.` }] };
-    }
-
-    if (action === "done_fingerprint" && context.step === "DEFINE_FINGERPRINT") {
-        context.step = "ADD_TRANSITIONS";
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `✅ Identidad Multivectorial configurada.\n\nPASO 3: Define una transición. (Usa action: 'add_transition' con { label, destino, accion }).` }] };
-    }
-
-    if (action === "add_transition" && context.step === "ADD_TRANSITIONS") {
-        context.transitions[data.label] = { destino: data.destino, accion: data.accion };
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🔄 Transición '${data.label}' añadida.\n\n¿Quieres añadir otra o guardar? (Usa action: 'save' para finalizar)` }] };
-    }
-
-    if (action === "save" && context.step === "ADD_TRANSITIONS") {
-        const result = await server.callTool("upsert_node", {
-            mapName: context.mapName,
-            nodeName: context.nodeName,
-            nodeData: { 
-                fingerprint: context.fingerprint,
-                transiciones: context.transitions 
-            }
-        });
-        await fs.unlink(contextPath); // Reset wizard
-        return result;
-    }
-
-    return { content: [{ type: "text", text: `❌ Acción no permitida en el estado actual (${context.step}).` }] };
-});
-
-server.tool("begin_design", "Iniciar una sesión de diseño guiado para una aplicación", {
-    appName: z.string().describe("Nombre de la aplicación a diseñar (ej: 'AdvantageShopping').")
-}, async ({ appName }) => {
-    const rules = `
-🎭 HAS ENTRADO EN MODO DISEÑO (SMS ARCHITECT) 🎭
-Estás diseñando la estructura para: ${appName}
-
-REGLAS CRÍTICAS DE SUPERVIVENCIA:
-1. ❌ PROHIBIDO editar archivos JSON manualmente.
-2. ❌ PROHIBIDO usar los campos 'nodes' o 'edges'. NO SOMOS UNA LIBRERÍA DE GRÁFICOS.
-3. ✅ USA EXCLUSIVAMENTE 'upsert_node' para crear o actualizar estados.
-4. ✅ ESTRUCTURA OBLIGATORIA: { "nodos": { "NOMBRE_NODO": { "transiciones": {} } } }
-5. 🔄 FLUJO: Primero propón el diseño en texto -> Pide confirmación -> Usa la herramienta.
-
-Dime qué pantalla o flujo quieres empezar a mapear para ${appName}.
-    `;
-    return { content: [{ type: "text", text: rules }] };
-});
-
-server.tool("init_project", "Inicializa el proyecto con carpetas y archivos de plantilla", {
-    force: z.optional(z.boolean()).default(false)
-}, async ({ force }) => {
-    await ensureDirectories();
-
-    const templates = {
-        'maps/template_map.json': {
-            nodos: {
-                HOME: {
-                    fingerprint: { selector: "~Login", timeout: 5000 },
-                    transiciones: {
-                        IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Login\" }" }
-                    }
-                },
-                LOGIN: {
-                    fingerprint: { selector: "~Back", timeout: 5000 },
-                    transiciones: {
-                        VOLVER: { destino: "HOME", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Back\" }" }
-                    }
-                }
-            }
-        },
-        'test_cases/template_case.json': {
-            name: "Template Case",
-            steps: [
-                { name: "Ir a Login", action: "IR_A_LOGIN" },
-                { name: "Verificar Pantalla", action: "mcp:wdio-mcp/get_screenshot {}" }
-            ]
-        },
-        'suites/template_suite.json': {
-            name: "Template Suite",
-            state_map: "template_map.json",
-            tests: ["template_case"],
-            beforeSuite: ["mcp:wdio-mcp/start_session { \"platform\": \"android\", \"provider\": \"perfecto\" }"],
-            afterSuite: ["mcp:wdio-mcp/close_session {}"]
-        }
-    };
-
-    for (const [relPath, content] of Object.entries(templates)) {
-        const fullPath = path.join(__dirname, relPath);
-        try {
-            if (!force) {
-                try {
-                    await fs.access(fullPath);
-                    continue; // Skip if exists
-                } catch (e) { }
-            }
-            await fs.writeFile(fullPath, JSON.stringify(content, null, 2));
-        } catch (e) {
-            process.stderr.write(`[WARN] Error creando template ${relPath}: ${e.message}\n`);
-        }
-    }
-
-    return {
-        content: [{
-            type: "text",
-            text: "✅ Instalación completada con éxito.\n\nComo este es un proyecto nuevo, el siguiente paso es definir tu aplicación. Por favor, llama a la herramienta `begin_design` para empezar a mapear tus primeros estados."
-        }]
-    };
-});
-
-server.tool("framework_menu", "Panel de control para elegir entre Modo Diseño o Modo Ejecución", {}, async () => {
-    return {
-        content: [{
-            type: "text",
-            text: "🎮 **Framework Control Panel**\n\n¿Qué deseas hacer ahora?\n1. 🎨 **Modo Diseño**: Añadir o modificar nodos y mapas (Usa `begin_design`).\n2. 🚀 **Modo Ejecución**: Lanzar suites de pruebas existentes (Usa `execute_suite`).\n3. 🔍 **Auditoría**: Revisar la integridad del sistema (Usa `inspect_framework`)."
-        }]
-    };
-});
-
-async function ensureDirectories() {
-    const dirs = ['maps', 'suites', 'test_cases', 'reports', 'data'];
-    for (const dir of dirs) {
-        const dirPath = path.join(__dirname, dir);
-        try {
-            await fs.mkdir(dirPath, { recursive: true });
-        } catch (e) {
-            process.stderr.write(`[WARN] Error creando directorio ${dir}: ${e.message}\n`);
-        }
-    }
-}
-
-async function test_wizard(action, data) {
-    const contextPath = path.join(__dirname, '.test_wizard_context.json');
-    let context = { step: "START", steps: [] };
-    
-    try {
-        if (await fs.stat(contextPath)) {
-            context = JSON.parse(await fs.readFile(contextPath, 'utf8'));
-        }
-    } catch (e) {}
-
-    if (action === "start") {
-        context = { step: "STEP_BASIC", testName: data.testName, steps: [] };
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `📝 Creando Test Case: '${data.testName}'.\n\nPASO 1: Define el nombre y acción del primer paso. (Usa action: 'add_step' con { name, action }).` }] };
-    }
-
-    if (action === "add_step" && context.step === "STEP_BASIC") {
-        context.currentStep = { name: data.name, action: data.action };
-        context.step = "STEP_ASSERT";
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `✅ Paso '${data.name}' añadido.\n\nPASO 2 (Opcional): ¿Quieres añadir una validación (assert) técnica? (Usa action: 'add_assert' con { assert } o 'add_step' para el siguiente sin assert).` }] };
-    }
-
-    if (action === "add_assert" && context.step === "STEP_ASSERT") {
-        context.currentStep.assert = data.assert;
-        context.steps.push(context.currentStep);
-        context.step = "STEP_BASIC";
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🛡️ Assert añadido al paso.\n\n¿Siguiente paso? (Usa 'add_step') o finaliza con 'save'.` }] };
-    }
-
-    if (action === "save") {
-        if (context.currentStep && context.step === "STEP_ASSERT") context.steps.push(context.currentStep);
-        const result = await server.callTool("save_test_case", {
-            name: context.testName,
-            steps: context.steps
-        });
-        await fs.unlink(contextPath);
-        return result;
-    }
-}
-
-async function main() {
-    await ensureDirectories();
-    await maquina.cargar();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch(console.error);
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { z } from "zod";
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SUITES_DIR = path.join(__dirname, "suites");
+const CASOS_DIR = path.join(__dirname, "test_cases");
+const REPORTS_ROOT = path.join(__dirname, "reports");
+const CONFIG_FILE = path.join(__dirname, "mcp_config.json");
+
+export class MaquinaDeEstados {
+    constructor() {
+        this.nodos = new Map();
+        this.casosPrueba = new Map();
+        this.suites = new Map();
+        this.mcpClients = new Map();
+    }
+
+    async cargar() {
+        for (const dir of [CASOS_DIR, SUITES_DIR]) {
+            if (!fsSync.existsSync(dir)) await fs.mkdir(dir, { recursive: true });
+            const files = await fs.readdir(dir);
+            for (const f of files) {
+                if (f.endsWith(".json")) {
+                    const content = JSON.parse(await fs.readFile(path.join(dir, f), "utf-8"));
+                    if (dir === CASOS_DIR) this.casosPrueba.set(content.name, content);
+                    else this.suites.set(content.name, content);
+                }
+            }
+        }
+    }
+
+    async getMcpClient(serverName) {
+        if (this.mcpClients.has(serverName)) return this.mcpClients.get(serverName);
+        const configRaw = await fs.readFile(CONFIG_FILE, "utf-8");
+        const config = JSON.parse(configRaw).mcpServers[serverName];
+        const transport = new StdioClientTransport({
+            command: config.command,
+            args: config.args || [],
+            env: { ...process.env, ...config.env }
+        });
+        const client = new Client({ name: "SMS-Client", version: "12.5.0" }, { capabilities: {} });
+        await client.connect(transport);
+        const data = { client, transport };
+        this.mcpClients.set(serverName, data);
+        return data;
+    }
+
+    interpolate(text, data) {
+        if (!data) return text;
+        let result = text;
+        for (const key in data) { result = result.replace(new RegExp(`{{${key}}}`, 'g'), data[key]); }
+        return result;
+    }
+
+    async ejecutarSuite(suiteName) {
+        const suite = this.suites.get(suiteName);
+        if (!suite) throw new Error(`Suite '${suiteName}' no encontrada.`);
+        
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const reportDir = path.join(REPORTS_ROOT, `exec_${suiteName}_${timestamp}`);
+        await fs.mkdir(reportDir, { recursive: true });
+        const results = { suiteName, timestamp, cases: [], hooks: { beforeSuite: [], afterSuite: [] } };
+
+        const runActions = async (actions, targetRes, data) => {
+            if (!actions) return;
+            for (const action of actions) {
+                const actionRes = { action, status: "passed" };
+                targetRes.push(actionRes);
+                try {
+                    const executeAction = async (act) => {
+                        const subRes = (act === action) ? actionRes : { action: act, status: "passed" };
+                        if (act !== action) targetRes.push(subRes);
+                        
+                        if (act.startsWith("transicion:")) {
+                            const transName = act.replace("transicion:", "").trim();
+                            const mapPath = path.join(__dirname, 'maps', suite.state_map);
+                            const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
+                            const nodes = mapData.nodos || mapData;
+                            
+                            let foundAction, destNodeName;
+                            for (const [nodeName, node] of Object.entries(nodes)) {
+                                if (node.transiciones && node.transiciones[transName]) {
+                                    foundAction = node.transiciones[transName].accion;
+                                    destNodeName = node.transiciones[transName].destino;
+                                    break;
+                                }
+                            }
+                            if (!foundAction) throw new Error(`Transición '${transName}' no encontrada.`);
+                            await executeAction(foundAction);
+
+                            // Identidad
+                            const destNode = nodes[destNodeName];
+                            if (destNode && destNode.fingerprint) {
+                                const selectors = destNode.fingerprint.selectors || [destNode.fingerprint.selector];
+                                const { client } = await this.getMcpClient("wdio-mcp");
+                                for (const sel of selectors) {
+                                    const vRes = await client.callTool({ name: "wait_for_element", arguments: { selector: sel, timeout: 5000 } });
+                                    if (vRes.isError) throw new Error(`Identidad fallida: ${sel}`);
+                                }
+                                subRes.output = (subRes.output || "") + "\n✅ Identidad Multivectorial confirmada.";
+                            }
+                            return;
+                        }
+
+                        const interpolated = this.interpolate(act, data);
+                        if (interpolated.startsWith("sh:")) {
+                            const { stdout, stderr } = await execAsync(interpolated.replace("sh:", "").trim());
+                            subRes.output = (subRes.output || "") + "\n" + stdout + (stderr ? "\nERR: " + stderr : "");
+                        } else if (interpolated.startsWith("mcp:")) {
+                            const raw = interpolated.replace("mcp:", "").trim();
+                            const slash = raw.indexOf("/");
+                            const space = raw.indexOf(" ", slash);
+                            const srv = raw.substring(0, slash);
+                            const tool = space === -1 ? raw.substring(slash + 1) : raw.substring(slash + 1, space);
+                            const args = JSON.parse(space === -1 ? "{}" : raw.substring(space + 1));
+                            const { client } = await this.getMcpClient(srv);
+                            const res = await client.callTool({ name: tool, arguments: args });
+                            if (res.content) {
+                                for (const item of res.content) {
+                                    if (item.text) subRes.output = (subRes.output || "") + "\n" + item.text;
+                                    if (item.type === "image") subRes.image = item.data.startsWith("data:") ? item.data : `data:image/png;base64,${item.data}`;
+                                }
+                            }
+                        }
+                    };
+                    await executeAction(action);
+                } catch (e) {
+                    actionRes.status = "failed";
+                    actionRes.error = e.message;
+                    throw e;
+                }
+            }
+        };
+
+        try {
+            for (const caseName of suite.tests) {
+                const testCase = this.casosPrueba.get(caseName);
+                if (!testCase) continue;
+                const caseRes = { name: testCase.name, steps: [], status: "passed" };
+                results.cases.push(caseRes);
+                for (const step of testCase.steps) {
+                    const stepRes = { name: step.name, actions: [], status: "passed" };
+                    caseRes.steps.push(stepRes);
+                    try {
+                        await runActions(step.actions || [step.action], stepRes.actions);
+                        if (step.assert) {
+                            const aRes = { action: `[ASSERT] ${step.assert}`, status: "passed" };
+                            stepRes.actions.push(aRes);
+                            await runActions([step.assert], stepRes.actions);
+                        }
+                    } catch (e) { stepRes.status = "failed"; throw e; }
+                }
+            }
+        } finally {
+            for (const { transport } of this.mcpClients.values()) await transport.close();
+            this.mcpClients.clear();
+            await this.finalizarReporte(reportDir, results);
+        }
+        return reportDir;
+    }
+
+    async finalizarReporte(dir, data) {
+        const renderActions = (actions) => actions.map(a => {
+            const isAssert = a.action.startsWith("[ASSERT]");
+            const isIdentity = a.output && a.output.includes("Identidad");
+            return `
+            <div style="border-left: 4px solid ${a.status === 'passed' ? (isAssert ? '#10b981' : '#3b82f6') : '#ef4444'}; background: rgba(15, 23, 42, 0.8); padding: 20px; border-radius: 12px; margin-bottom: 15px; border: 1px solid #1e293b;">
+                <div style="display:flex; justify-content:space-between; margin-bottom: 10px;">
+                    <span style="font-weight: 600; color: ${isAssert ? '#10b981' : '#94a3b8'};">${isAssert ? '🛡️ VALIDACIÓN' : '⚙️ ACCIÓN'}</span>
+                    <span style="background:${a.status === 'passed' ? '#065f46' : '#991b1b'}; padding: 2px 8px; border-radius: 4px; font-size: 0.8em;">${a.status}</span>
+                </div>
+                <div style="color: #f8fafc; margin-bottom: 10px;">${isAssert ? a.action.replace("[ASSERT]", "").trim() : a.action}</div>
+                ${isIdentity ? `<div style="color: #34d399; font-size: 0.85em;">🔍 Identidad Multivectorial Confirmada</div>` : ""}
+                ${a.image ? `<div style="margin-top:10px; text-align:center;"><img src="${a.image}" style="max-width:100%; border-radius:8px;"></div>` : ""}
+                ${a.error ? `<pre style="color:#fca5a5; font-size:0.8em;">${a.error}</pre>` : ""}
+            </div>`;
+        }).join("");
+
+        const html = `<html><body style="background:#020617; color:#f8fafc; font-family:sans-serif; padding:50px;">
+            <h1 style="color:#60a5fa;">SMS Framework V12.5</h1>
+            ${data.cases.map(c => `
+                <div style="background:#0f172a; padding:30px; border-radius:20px; margin-bottom:30px; border:1px solid #1e293b;">
+                    <h2>CASE: ${c.name}</h2>
+                    ${c.steps.map(s => `<div><h3>STEP: ${s.name}</h3>${renderActions(s.actions)}</div>`).join("")}
+                </div>`).join("")}
+        </body></html>`;
+        await fs.writeFile(path.join(dir, "index.html"), html);
+    }
+}
+
+const maquina = new MaquinaDeEstados();
+const server = new McpServer({ name: "demo-state-machine", version: "12.5.0" });
+
+server.tool("init_project", "Instalación Inicial. Crea carpetas y archivos de plantilla.", {}, async () => {
+    const templates = {
+        'maps/template_map.json': { nodos: { HOME: { fingerprint: { selectors: ["~Login"] }, transiciones: { IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element {\"selector\":\"~Login\"}" } } } } },
+        'test_cases/template_case.json': { name: "TC_Ejemplo", steps: [{ name: "Ir a Login", action: "transicion:IR_A_LOGIN", assert: "sh:ls" }] },
+        'suites/template_suite.json': { name: "Suite_Ejemplo", state_map: "template_map.json", tests: ["TC_Ejemplo"] }
+    };
+    for (const [f, c] of Object.entries(templates)) {
+        const p = path.join(__dirname, f);
+        if (!fsSync.existsSync(p)) { await fs.mkdir(path.dirname(p), { recursive: true }); await fs.writeFile(p, JSON.stringify(c, null, 2)); }
+    }
+    return { content: [{ type: "text", text: "✨ Entorno Inicializado. Usa 'sms_builder' para empezar el diseño." }] };
+});
+
+server.tool("sms_builder", "Diseño Guiado: Nodos -> Tests -> Suite.", {
+    action: z.enum(["start", "add_node", "add_fingerprint", "done_node", "add_test", "add_step", "add_assert", "save_test", "assemble_suite"]),
+    data: z.record(z.any())
+}, async ({ action, data }) => {
+    const ctxPath = path.join(__dirname, '.sms_builder_context.json');
+    let ctx = { step: "IDLE", nodes: {}, tests: [] };
+    try { ctx = JSON.parse(fsSync.readFileSync(ctxPath, 'utf8')); } catch (e) {}
+
+    switch (action) {
+        case "start":
+            ctx = { step: "DESIGN", mapName: data.mapName, nodes: {}, tests: [] };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🏗️ Diseñando Mapa: ${data.mapName}. Añade un nodo (action: 'add_node' { nodeName }).` }] };
+        
+        case "add_node":
+            ctx.currentNode = { name: data.nodeName, transiciones: {}, fingerprint: null };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `📍 Nodo '${data.nodeName}'. MANDATORIO: Añade huella (action: 'add_fingerprint' { selector }).` }] };
+        
+        case "add_fingerprint":
+            if (!ctx.currentNode.fingerprint) ctx.currentNode.fingerprint = { selectors: [] };
+            ctx.currentNode.fingerprint.selectors.push(data.selector);
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🧬 Vector añadido. ¿Otro o 'done_node'?` }] };
+        
+        case "done_node":
+            ctx.nodes[ctx.currentNode.name] = { fingerprint: ctx.currentNode.fingerprint, transiciones: ctx.currentNode.transiciones };
+            await fs.writeFile(path.join(__dirname, 'maps', `${ctx.mapName}.json`), JSON.stringify({ nodos: ctx.nodes }, null, 2));
+            delete ctx.currentNode;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Nodo guardado. ¿Otro ('add_node') o Tests ('add_test')?` }] };
+
+        case "add_test":
+            ctx.currentTest = { name: data.testName, steps: [] };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🧪 Test '${data.testName}'. Añade pasos (action: 'add_step' { name, action }).` }] };
+        
+        case "add_step":
+            ctx.currentStep = { name: data.name, action: data.action };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Paso añadido. ¿Assert? (action: 'add_assert' { assert }) o siguiente ('add_step').` }] };
+        
+        case "add_assert":
+            ctx.currentStep.assert = data.assert;
+            ctx.currentTest.steps.push(ctx.currentStep);
+            delete ctx.currentStep;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🛡️ Assert añadido. ¿Siguiente paso ('add_step') o guardar ('save_test')?` }] };
+        
+        case "save_test":
+            if (ctx.currentStep) ctx.currentTest.steps.push(ctx.currentStep);
+            await fs.writeFile(path.join(__dirname, 'test_cases', `${ctx.currentTest.name}.json`), JSON.stringify(ctx.currentTest, null, 2));
+            ctx.tests.push(ctx.currentTest.name);
+            delete ctx.currentTest;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Test guardado. ¿Otro ('add_test') o Suite ('assemble_suite')?` }] };
+        
+        case "assemble_suite":
+            const suite = { name: data.suiteName, state_map: `${ctx.mapName}.json`, tests: ctx.tests };
+            await fs.writeFile(path.join(__dirname, 'suites', `${data.suiteName}.json`), JSON.stringify(suite, null, 2));
+            fsSync.unlinkSync(ctxPath);
+            return { content: [{ type: "text", text: `🎊 Suite '${data.suiteName}' lista. Corre con 'sms_executor'.` }] };
+    }
+});
+
+server.tool("sms_executor", "Corre una suite y genera reporte.", { suiteName: z.string() }, async ({ suiteName }) => {
+    await maquina.cargar();
+    const dir = await maquina.ejecutarSuite(suiteName);
+    return { content: [{ type: "text", text: `🚀 Reporte: ${dir}` }] };
+});
+
+async function main() {
+    for (const d of ['maps', 'suites', 'test_cases', 'reports']) {
+        const p = path.join(__dirname, d);
+        if (!fsSync.existsSync(p)) await fs.mkdir(p, { recursive: true });
+    }
+    await maquina.cargar();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-state-machine-test-framework",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "High-fidelity State Machine MCP Server for autonomous E2E testing orchestration.",
   "main": "index.js",
   "type": "module",