xampp-mcp 0.1.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dony-aep
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,42 +2,16 @@
 
 MCP server para administrar XAMPP y MySQL en Windows desde clientes MCP por `stdio` (VS Code, Copilot agents, etc.).
 
-## Alcance v1
-
-- Windows + XAMPP local.
-- Transporte MCP: `stdio`.
-- Estado de Apache/MySQL y recomendación de arranque manual desde XAMPP.
-- Administración de base de datos (crear DB, tablas, usuarios, grants, import/export).
-- Consultas SQL de solo lectura y ejecución general con confirmación explícita.
-- Inspección de estado de base de datos (resumen y detalle de tablas).
-
 ## Requisitos
 
-- Node.js 20+.
-- XAMPP instalado (por defecto en `C:\xampp`).
-- Permisos de sistema suficientes para las acciones de servicio si usas modo `service`.
+- Windows
+- Node.js 20+
+- XAMPP instalado (por defecto en `C:\xampp`)
 
-## Configuración
+## Instalación
 
-Variables opcionales de entorno:
-
-- `XAMPP_DIR` (default `C:\xampp`)
-- `XAMPP_DEFAULT_MODE` (`console` | `service`, default `console`)
-- `XAMPP_APACHE_SERVICE` (default `Apache2.4`)
-- `XAMPP_MYSQL_SERVICE` (default `mysql`)
-- `MYSQL_HOST` (default `127.0.0.1`)
-- `MYSQL_PORT` (default `3306`)
-- `MYSQL_USER` (default `root`)
-- `MYSQL_PASSWORD` (sin default)
-
-## Scripts
-
-- `npm run dev`: ejecución directa TypeScript.
-- `npm run build`: compila a `dist`.
-- `npm run start`: ejecuta servidor compilado.
-- `npm run lint`: typecheck.
-
-## Uso como paquete npm
+Paquete npm:
+- https://www.npmjs.com/package/xampp-mcp
 
 Instalación global:
 
@@ -45,86 +19,68 @@ Instalación global:
 npm install -g xampp-mcp
 ```
 
-Ejecución directa:
-
-```powershell
-xampp-mcp
-```
-
 Sin instalación global:
 
 ```powershell
 npx -y xampp-mcp
 ```
 
-Ejemplo de configuración MCP en VS Code:
+## Configuración en VS Code
+
+Ejemplo recomendado en `.vscode/mcp.json`:
 
 ```jsonc
 {
-	"servers": {
-		"xamppMcp": {
-			"type": "stdio",
-			"command": "xampp-mcp",
-			"env": {
-				"XAMPP_DIR": "C:\\xampp",
-				"XAMPP_DEFAULT_MODE": "console"
-			}
-		}
-	}
+  "servers": {
+    "xamppMcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "xampp-mcp"],
+      "env": {
+        "XAMPP_DIR": "C:\\xampp",
+        "XAMPP_DEFAULT_MODE": "console"
+      }
+    }
+  }
 }
 ```
 
-Si usas `npx` en vez de instalación global:
+Variables opcionales:
 
-```jsonc
-{
-	"servers": {
-		"xamppMcp": {
-			"type": "stdio",
-			"command": "npx",
-			"args": ["-y", "xampp-mcp"],
-			"env": {
-				"XAMPP_DIR": "C:\\xampp",
-				"XAMPP_DEFAULT_MODE": "console"
-			}
-		}
-	}
-}
-```
+- `XAMPP_DIR` (default `C:\xampp`)
+- `XAMPP_DEFAULT_MODE` (`console` | `service`, default `console`)
+- `XAMPP_APACHE_SERVICE` (default `Apache2.4`)
+- `XAMPP_MYSQL_SERVICE` (default `mysql`)
+- `MYSQL_HOST` (default `127.0.0.1`)
+- `MYSQL_PORT` (default `3306`)
+- `MYSQL_USER` (default `root`)
+- `MYSQL_PASSWORD` (sin default)
 
-## Publicación npm
+## Notas de uso importantes
 
-```powershell
-npm login
-npm version patch
-npm publish
-```
+- Si Apache/MySQL están apagados, primero debes iniciarlos manualmente desde XAMPP Control Panel.
+- Para nombres de base/tabla usa `snake_case` (`_`) y evita `-`.
+- El MCP usa UTF-8 (`utf8mb4`) para preservar tildes y caracteres especiales.
+
+## Diagramas ER (flujo recomendado)
 
-## Seguridad
+Cuando pidas un diagrama de base de datos en VS Code chat:
 
-- No hay tool de shell genérico.
-- Operaciones sensibles requieren `confirmed: true`.
-- Validación estricta de identificadores para evitar inyección SQL en DDL común.
-- En v1 el transporte es local `stdio`; no se incluye HTTP/OAuth.
-- El control de arranque/parada de Apache/MySQL se mantiene fuera del catálogo activo; el usuario debe operarlo manualmente desde XAMPP.
-- Si MySQL/Apache están apagados, las tools deben pedir activación manual en XAMPP Control Panel y esperar confirmación del usuario antes de reintentar.
+1. Ejecutar `mcp_xamppmcp_diagram_er` para obtener Mermaid desde el esquema real.
+2. Previsualizar en chat con `renderMermaidDiagram` usando `structuredContent.previewRequest.args.markup`.
+3. Si el usuario confirma SVG, ejecutar `mcp_xamppmcp_diagram_render` con `structuredContent.renderRequest.args`.
 
-## Reglas de nombres
+### Salida SVG por defecto
 
-- Usar `snake_case` para nombres de base, tablas y demás identificadores.
-- Regla: empezar por letra o `_`, y luego usar solo letras, números y `_`.
-- No usar `-` (guion medio); el MCP devuelve sugerencia automática reemplazando `-` por `_`.
-- Ejemplo recomendado: `database-example-2026` → `database_example_2026`.
+- Si no se envía `outputPath`, el SVG se guarda en `diagrams/<database>.svg` en la raíz del proyecto.
+- Para compatibilidad con clientes estrictos, `diagram_er` entrega un `renderRequest` mínimo (`code`) y `diagram_render` infiere la base desde el hint Mermaid `%% database: <db>`.
 
-## Codificación de texto
+Lista completa de tools:
+- [docs/tools.md](docs/tools.md)
 
-- Política única: usar UTF-8 (`utf8mb4`) para español e inglés.
-- No hace falta cambiar encoding según idioma o contexto; se conserva el texto original (con o sin tildes).
-- `db_create` crea bases con `utf8mb4` / `utf8mb4_unicode_ci` para evitar problemas con acentos y caracteres especiales.
-- En ejecución SQL, el MCP fuerza `SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci` por sesión para evitar conversiones `cp850` en Windows.
+Historial de cambios:
+- [CHANGELOG.md](CHANGELOG.md)
 
-## Próximos pasos sugeridos
+## Licencia
 
-- Agregar tareas asíncronas para imports/exports largos.
-- Añadir control de logs (`apache/error.log`, `mysql/error.log`) como tools read-only.
-- Extender a transporte HTTP con OAuth 2.1 para escenarios remotos.
+Este proyecto está bajo licencia MIT. Consulta [LICENSE](LICENSE).

package/dist/server.js

@@ -10,7 +10,7 @@ async function main() {
     const toolRegistry = createToolRegistry(environment);
     const server = new Server({
         name: "xampp-mcp",
-        version: "0.1.0",
+        version: "1.0.0",
     }, {
         capabilities: {
             tools: {},

package/dist/tools/diagramEr.js

@@ -0,0 +1,273 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { ToolExecutionError, toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getOptionalString, getString } from "../runtime/validators.js";
+import { assertDatabaseIdentifier, assertIdentifier, escapeSqlLiteral, } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+function valueOrEmpty(row, key) {
+    return (row[key] ?? "").trim();
+}
+function parseTabularOutput(stdout) {
+    const lines = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+    if (lines.length < 2) {
+        return [];
+    }
+    const header = lines[0];
+    if (!header) {
+        return [];
+    }
+    const headers = header.split("\t").map((item) => item.trim());
+    if (headers.length === 0) {
+        return [];
+    }
+    const rows = [];
+    for (const line of lines.slice(1)) {
+        const cells = line.split("\t");
+        const row = {};
+        for (let index = 0; index < headers.length; index += 1) {
+            const key = headers[index];
+            if (!key) {
+                continue;
+            }
+            row[key] = (cells[index] ?? "").trim();
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function parseTableRows(stdout) {
+    const rows = parseTabularOutput(stdout);
+    return rows
+        .map((row) => ({
+        TABLE_NAME: valueOrEmpty(row, "TABLE_NAME"),
+    }))
+        .filter((row) => row.TABLE_NAME.length > 0);
+}
+function parseColumnRows(stdout) {
+    const rows = parseTabularOutput(stdout);
+    return rows
+        .map((row) => ({
+        TABLE_NAME: valueOrEmpty(row, "TABLE_NAME"),
+        COLUMN_NAME: valueOrEmpty(row, "COLUMN_NAME"),
+        COLUMN_TYPE: valueOrEmpty(row, "COLUMN_TYPE"),
+        IS_NULLABLE: valueOrEmpty(row, "IS_NULLABLE"),
+        COLUMN_KEY: valueOrEmpty(row, "COLUMN_KEY"),
+    }))
+        .filter((row) => row.TABLE_NAME.length > 0 && row.COLUMN_NAME.length > 0);
+}
+function parseForeignKeyRows(stdout) {
+    const rows = parseTabularOutput(stdout);
+    return rows
+        .map((row) => ({
+        TABLE_NAME: valueOrEmpty(row, "TABLE_NAME"),
+        COLUMN_NAME: valueOrEmpty(row, "COLUMN_NAME"),
+        REFERENCED_TABLE_NAME: valueOrEmpty(row, "REFERENCED_TABLE_NAME"),
+        REFERENCED_COLUMN_NAME: valueOrEmpty(row, "REFERENCED_COLUMN_NAME"),
+    }))
+        .filter((row) => row.TABLE_NAME.length > 0 &&
+        row.COLUMN_NAME.length > 0 &&
+        row.REFERENCED_TABLE_NAME.length > 0 &&
+        row.REFERENCED_COLUMN_NAME.length > 0);
+}
+function parseTableFilter(tablesCsv) {
+    if (!tablesCsv) {
+        return [];
+    }
+    const parsed = tablesCsv
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    for (const table of parsed) {
+        assertIdentifier(table, "tables");
+    }
+    return Array.from(new Set(parsed));
+}
+function buildInClause(column, values) {
+    if (values.length === 0) {
+        return "";
+    }
+    const literals = values.map((value) => escapeSqlLiteral(value)).join(", ");
+    return ` AND ${column} IN (${literals})`;
+}
+function normalizeType(columnType) {
+    const normalized = columnType.trim();
+    if (normalized.length === 0) {
+        return "string";
+    }
+    const firstToken = normalized.split(/\s+/)[0] ?? "";
+    const safeToken = firstToken.replace(/[^A-Za-z0-9_]/g, "").toLowerCase();
+    return safeToken.length > 0 ? safeToken : "string";
+}
+function relationCardinality(isNullable) {
+    return isNullable.toUpperCase() === "YES" ? "|o--o{" : "||--o{";
+}
+export function createDiagramErTool(environment) {
+    return {
+        name: "diagram_er",
+        description: "Generates a Mermaid ER diagram from the real MySQL schema",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                tables: { type: "string", description: "Optional comma-separated table filter" },
+                show_columns: { type: "boolean" },
+                show_types: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Generate ER Diagram",
+            readOnlyHint: true,
+            openWorldHint: true,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            const tablesCsv = getOptionalString(args.tables, "tables");
+            const showColumns = getBoolean(args.show_columns, "show_columns", true);
+            const showTypes = getBoolean(args.show_types, "show_types", true);
+            assertDatabaseIdentifier(database, "database");
+            const selectedTables = parseTableFilter(tablesCsv);
+            const schemaLiteral = escapeSqlLiteral(database);
+            const tableFilterForTables = buildInClause("TABLE_NAME", selectedTables);
+            const tablesResult = await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                sql: `
+SELECT TABLE_NAME
+FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = ${schemaLiteral}
+  AND TABLE_TYPE = 'BASE TABLE'${tableFilterForTables}
+ORDER BY TABLE_NAME
+        `,
+            });
+            const tableRows = parseTableRows(tablesResult.stdout);
+            const tableNames = tableRows
+                .map((row) => row.TABLE_NAME)
+                .filter((value) => typeof value === "string" && value.length > 0);
+            if (tableNames.length === 0) {
+                throw new ToolExecutionError(`No tables found in database ${database}`, "NOT_FOUND");
+            }
+            const tableFilterForColumns = buildInClause("TABLE_NAME", tableNames);
+            const columnsResult = await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                sql: `
+SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY
+FROM information_schema.COLUMNS
+WHERE TABLE_SCHEMA = ${schemaLiteral}${tableFilterForColumns}
+ORDER BY TABLE_NAME, ORDINAL_POSITION
+        `,
+            });
+            const fkFilter = buildInClause("kcu.TABLE_NAME", tableNames);
+            const foreignKeysResult = await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                sql: `
+SELECT
+  kcu.TABLE_NAME,
+  kcu.COLUMN_NAME,
+  kcu.REFERENCED_TABLE_NAME,
+  kcu.REFERENCED_COLUMN_NAME
+FROM information_schema.KEY_COLUMN_USAGE kcu
+WHERE kcu.TABLE_SCHEMA = ${schemaLiteral}
+  AND kcu.REFERENCED_TABLE_NAME IS NOT NULL${fkFilter}
+ORDER BY kcu.TABLE_NAME, kcu.COLUMN_NAME
+        `,
+            });
+            const columnRows = parseColumnRows(columnsResult.stdout);
+            const foreignKeyRows = parseForeignKeyRows(foreignKeysResult.stdout);
+            const columnsByTable = new Map();
+            const fkColumns = new Set();
+            const nullableByColumn = new Map();
+            for (const column of columnRows) {
+                const tableName = column.TABLE_NAME;
+                const columnName = column.COLUMN_NAME;
+                if (!tableName || !columnName) {
+                    continue;
+                }
+                const current = columnsByTable.get(tableName) ?? [];
+                current.push(column);
+                columnsByTable.set(tableName, current);
+                nullableByColumn.set(`${tableName}.${columnName}`, column.IS_NULLABLE || "NO");
+            }
+            for (const fk of foreignKeyRows) {
+                if (!fk.TABLE_NAME || !fk.COLUMN_NAME) {
+                    continue;
+                }
+                fkColumns.add(`${fk.TABLE_NAME}.${fk.COLUMN_NAME}`);
+            }
+            const diagramLines = ["erDiagram"];
+            if (showColumns) {
+                for (const tableName of tableNames) {
+                    diagramLines.push(`    ${tableName} {`);
+                    const columns = columnsByTable.get(tableName) ?? [];
+                    for (const column of columns) {
+                        const columnName = column.COLUMN_NAME;
+                        if (!columnName) {
+                            continue;
+                        }
+                        const flags = [];
+                        if ((column.COLUMN_KEY ?? "").toUpperCase() === "PRI") {
+                            flags.push("PK");
+                        }
+                        if (fkColumns.has(`${tableName}.${columnName}`)) {
+                            flags.push("FK");
+                        }
+                        const typeToken = showTypes ? normalizeType(column.COLUMN_TYPE ?? "") : "string";
+                        const suffix = flags.length > 0 ? ` ${flags.join(" ")}` : "";
+                        diagramLines.push(`        ${typeToken} ${columnName}${suffix}`);
+                    }
+                    diagramLines.push("    }");
+                }
+            }
+            for (const fk of foreignKeyRows) {
+                const childTable = fk.TABLE_NAME;
+                const childColumn = fk.COLUMN_NAME;
+                const parentTable = fk.REFERENCED_TABLE_NAME;
+                if (!childTable || !childColumn || !parentTable) {
+                    continue;
+                }
+                const nullable = nullableByColumn.get(`${childTable}.${childColumn}`) ?? "NO";
+                const cardinality = relationCardinality(nullable);
+                diagramLines.push(`    ${parentTable} ${cardinality} ${childTable} : \"${childColumn}\"`);
+            }
+            const mermaid = [`%% database: ${database}`, ...diagramLines].join("\n");
+            const text = [
+                `ER diagram generated for database: ${database}`,
+                "Suggested flow: first preview with renderMermaidDiagram using structuredContent.previewRequest.args.markup.",
+                "After preview, ask the user in the current conversation language whether SVG output is needed.",
+                "",
+                "```mermaid",
+                mermaid,
+                "```",
+            ].join("\n");
+            const structured = {
+                database,
+                tables: tableNames,
+                tableCount: tableNames.length,
+                relationshipCount: foreignKeyRows.length,
+                mermaid,
+                previewRequest: {
+                    tool: "renderMermaidDiagram",
+                    args: {
+                        title: `ER Preview - ${database}`,
+                        markup: mermaid,
+                    },
+                },
+                renderRequest: {
+                    tool: "diagram_render",
+                    args: {
+                        code: mermaid,
+                    },
+                },
+            };
+            return toToolTextResult(text, {
+                ...structured,
+            });
+        },
+    };
+}

package/dist/tools/diagramRender.js

@@ -0,0 +1,211 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { request } from "node:https";
+import { ToolExecutionError, toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getOptionalString, getString } from "../runtime/validators.js";
+const SUPPORTED_DIAGRAM_TYPES = [
+    "erDiagram",
+    "flowchart",
+    "graph",
+    "sequenceDiagram",
+    "classDiagram",
+    "stateDiagram-v2",
+    "stateDiagram",
+    "journey",
+    "gantt",
+    "pie",
+    "gitGraph",
+    "gitgraph",
+    "mindmap",
+    "timeline",
+    "quadrantChart",
+    "sankey-beta",
+    "sankey",
+    "xychart-beta",
+    "xychart",
+    "block-beta",
+    "block",
+];
+function sanitizeFileName(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 120);
+}
+function resolveOutputPath(args) {
+    if (args.outputPath && args.outputPath.trim().length > 0) {
+        const normalized = args.outputPath.trim();
+        return normalized.toLowerCase().endsWith(".svg") ? normalized : `${normalized}.svg`;
+    }
+    const baseFromDatabase = args.database ? sanitizeFileName(args.database) : "";
+    const baseFromTitle = args.title ? sanitizeFileName(args.title) : "";
+    const fileBase = baseFromDatabase || baseFromTitle || "diagram";
+    return path.join(process.cwd(), "diagrams", `${fileBase}.svg`);
+}
+function extractDatabaseHint(code) {
+    const lines = code.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        const match = /^%%\s*database\s*:\s*([A-Za-z0-9_\-]+)\s*$/i.exec(line);
+        if (!match) {
+            continue;
+        }
+        const database = match[1]?.trim();
+        if (database && database.length > 0) {
+            return database;
+        }
+    }
+    return undefined;
+}
+function detectDiagramType(code) {
+    const firstNonEmptyLine = code
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0 && !line.startsWith("%%"));
+    if (!firstNonEmptyLine) {
+        throw new ToolExecutionError("code cannot be empty", "INVALID_INPUT");
+    }
+    const matched = SUPPORTED_DIAGRAM_TYPES.find((diagramType) => firstNonEmptyLine.toLowerCase().startsWith(diagramType.toLowerCase()));
+    if (!matched) {
+        throw new ToolExecutionError(`Unsupported Mermaid diagram type. Start your code with one of: ${SUPPORTED_DIAGRAM_TYPES.join(", ")}`, "INVALID_INPUT");
+    }
+    return matched;
+}
+export async function renderMermaidToSvg(code) {
+    return await new Promise((resolve, reject) => {
+        const req = request("https://kroki.io/mermaid/svg", {
+            method: "POST",
+            headers: {
+                "content-type": "text/plain; charset=utf-8",
+                accept: "image/svg+xml",
+                "content-length": Buffer.byteLength(code, "utf8"),
+            },
+        }, (response) => {
+            let payload = "";
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+                payload += chunk;
+            });
+            response.on("end", () => {
+                const statusCode = response.statusCode ?? 0;
+                if (statusCode < 200 || statusCode >= 300) {
+                    reject(new ToolExecutionError(`Remote Mermaid render failed (${statusCode})`, "RENDER_FAILED"));
+                    return;
+                }
+                if (!payload.toLowerCase().includes("<svg")) {
+                    reject(new ToolExecutionError("Renderer did not return valid SVG content", "RENDER_FAILED"));
+                    return;
+                }
+                resolve(payload);
+            });
+        });
+        req.on("error", (error) => {
+            reject(new ToolExecutionError(`Remote Mermaid render error: ${error.message}`, "RENDER_FAILED"));
+        });
+        req.write(code);
+        req.end();
+    });
+}
+export function createDiagramRenderTool(_environment) {
+    return {
+        name: "diagram_render",
+        description: "Validates Mermaid code and returns a rendered SVG image when possible",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: { type: "string", description: "Mermaid diagram source" },
+                title: { type: "string" },
+                database: { type: "string", description: "Database name for default output file naming" },
+                render_image: { type: "boolean", description: "Render remote SVG image (default true)" },
+                save_file: { type: "boolean", description: "Save SVG to disk (default true)" },
+                outputPath: { type: "string", description: "Optional absolute or relative SVG output path" },
+            },
+            required: ["code"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Render Mermaid Diagram",
+            readOnlyHint: false,
+            openWorldHint: true,
+        },
+        handler: async (args) => {
+            const code = getString(args.code, "code");
+            const title = getOptionalString(args.title, "title");
+            const database = getOptionalString(args.database, "database") ?? extractDatabaseHint(code);
+            const renderImage = getBoolean(args.render_image, "render_image", true);
+            const saveFile = getBoolean(args.save_file, "save_file", true);
+            const outputPathInput = getOptionalString(args.outputPath, "outputPath");
+            const diagramType = detectDiagramType(code);
+            const titleLine = title ? `Title: ${title}\n` : "";
+            const text = [
+                "Mermaid diagram ready.",
+                titleLine.length > 0 ? titleLine.trimEnd() : "",
+                `Type: ${diagramType}`,
+                "",
+                "```mermaid",
+                code,
+                "```",
+            ]
+                .filter((line) => line.length > 0)
+                .join("\n");
+            if (!renderImage) {
+                return toToolTextResult(text, {
+                    title,
+                    diagramType,
+                    mermaid: code,
+                    rendered: false,
+                });
+            }
+            try {
+                const svg = await renderMermaidToSvg(code);
+                const outputPath = resolveOutputPath({
+                    outputPath: outputPathInput,
+                    database,
+                    title,
+                });
+                if (saveFile) {
+                    const outputDir = path.dirname(outputPath);
+                    await fs.mkdir(outputDir, { recursive: true });
+                    await fs.writeFile(outputPath, svg, "utf8");
+                }
+                const imageBase64 = Buffer.from(svg, "utf8").toString("base64");
+                const savedLine = saveFile ? `\nSaved SVG: ${outputPath}` : "\nSVG file was not saved (save_file=false).";
+                const result = {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${text}${savedLine}`,
+                        },
+                        {
+                            type: "image",
+                            data: imageBase64,
+                            mimeType: "image/svg+xml",
+                        },
+                    ],
+                    structuredContent: {
+                        title,
+                        diagramType,
+                        mermaid: code,
+                        rendered: true,
+                        mimeType: "image/svg+xml",
+                        saved: saveFile,
+                        outputPath: saveFile ? outputPath : undefined,
+                    },
+                };
+                return result;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : "Unknown render error";
+                const fallbackText = `${text}\n\nSVG render fallback: ${reason}`;
+                return toToolTextResult(fallbackText, {
+                    title,
+                    diagramType,
+                    mermaid: code,
+                    rendered: false,
+                    renderError: reason,
+                });
+            }
+        },
+    };
+}

package/dist/tools/registry.js

@@ -2,13 +2,14 @@ import { createDbCreateTool } from "./dbCreate.js";
 import { createDbExportTool } from "./dbExport.js";
 import { createDbImportTool } from "./dbImport.js";
 import { createDbInspectTool } from "./dbInspect.js";
+import { createDiagramErTool } from "./diagramEr.js";
+import { createDiagramRenderTool } from "./diagramRender.js";
 import { createGrantManageTool } from "./grantManage.js";
 import { createPhpCliRunTool } from "./phpCliRun.js";
 import { createQueryExecuteTool } from "./queryExecute.js";
 import { createPreflightCheckTool } from "./preflightCheck.js";
 import { createQueryReadonlyTool } from "./queryReadonly.js";
 import { createStackStatusTool } from "./stackStatus.js";
-import { createTableCreateTool } from "./tableCreate.js";
 import { createUserCreateTool } from "./userCreate.js";
 export function createToolRegistry(environment) {
     const tools = [
@@ -18,12 +19,13 @@ export function createToolRegistry(environment) {
         createQueryExecuteTool(environment),
         createDbInspectTool(environment),
         createDbCreateTool(environment),
-        createTableCreateTool(environment),
         createUserCreateTool(environment),
         createGrantManageTool(environment),
         createDbExportTool(environment),
         createDbImportTool(environment),
         createPhpCliRunTool(environment),
+        createDiagramErTool(environment),
+        createDiagramRenderTool(environment),
     ];
     const toolMap = new Map();
     for (const tool of tools) {

package/docs/tools.md

@@ -46,10 +46,6 @@ Campos de **base de datos** (no aceptan `-`):
 - `db_export.database`
 - `db_import.database`
 - `grant_manage.database`
-- `table_create.database`
-
-Campos de **tabla** (no aceptan `-`):
-- `table_create.table`
 
 ### Ejemplo válido para `db_create`
 
@@ -85,17 +81,6 @@ Ejemplo recomendado de texto:
 - Español: `José Núñez - información pública`
 - Inglés: `John Smith - public information`
 
-### Ejemplo que falla en `table_create.table`
-
-```json
-{
-	"database": "mcp_test_2026",
-	"table": "items-test",
-	"createStatement": "CREATE TABLE `items-test` (id INT)",
-	"confirmed": true
-}
-```
-
 ## query_readonly
 Ejecuta solo consultas `SELECT`, `SHOW`, `DESCRIBE`, `EXPLAIN`.
 
@@ -141,23 +126,6 @@ Input:
 - `user?: string`
 - `password?: string`
 
-## table_create
-Crea una tabla con sentencia `CREATE TABLE`.
-
-Validaciones adicionales:
-- `createStatement` debe empezar con `CREATE TABLE`.
-- `createStatement` debe apuntar a la misma tabla indicada en `table`.
-
-Input:
-- `database: string`
-- `table: string`
-- `createStatement: string`
-- `confirmed: boolean`
-- `host?: string`
-- `port?: number`
-- `user?: string`
-- `password?: string`
-
 ## user_create
 Crea usuario MySQL.
 
@@ -219,3 +187,61 @@ Ejecuta script PHP con `php.exe` de XAMPP.
 Input:
 - `scriptPath: string`
 - `args?: string`
+
+## diagram_er
+Genera un diagrama ER en Mermaid a partir del esquema real de MySQL (`information_schema`).
+
+Input:
+- `database: string`
+- `tables?: string` (lista opcional separada por comas, p. ej. `users,orders`)
+- `show_columns?: boolean` (default `true`)
+- `show_types?: boolean` (default `true`)
+- `host?: string`
+- `port?: number`
+- `user?: string`
+- `password?: string`
+
+Salida:
+- Bloque de texto Mermaid (` ```mermaid ... ``` `)
+- `structuredContent.mermaid` con el código del diagrama
+- `structuredContent.previewRequest` para previsualizar primero con `renderMermaidDiagram`
+- `structuredContent.renderRequest` con payload sugerido para llamar `diagram_render`
+
+Notas:
+- `diagram_er` no genera SVG automáticamente; prioriza la previsualización rápida en chat.
+- Para SVG, usar `diagram_render` solo cuando el usuario lo solicite.
+
+Flujo recomendado en VS Code chat:
+1. Ejecutar `mcp_xamppmcp_diagram_er`.
+2. Llamar `renderMermaidDiagram` usando `structuredContent.previewRequest.args.markup` para previsualización rápida.
+3. Preguntar al usuario en el idioma actual de la conversación si también quiere el SVG.
+4. Si responde que sí, llamar `mcp_xamppmcp_diagram_render` con `structuredContent.renderRequest.args`.
+
+## diagram_render
+Valida Mermaid, renderiza SVG y opcionalmente guarda archivo en disco.
+
+Input:
+- `code: string` (código Mermaid)
+- `title?: string`
+- `database?: string` (para nombrar archivo por defecto)
+- `render_image?: boolean` (default `true`; si es `false`, solo valida y devuelve texto)
+- `save_file?: boolean` (default `true`)
+- `outputPath?: string` (ruta opcional de salida para el SVG)
+
+Tipos Mermaid soportados al inicio del código:
+- `erDiagram`, `flowchart`, `graph`, `sequenceDiagram`, `classDiagram`
+- `stateDiagram-v2`, `stateDiagram`, `journey`, `gantt`, `pie`
+- `gitGraph`, `gitgraph`, `mindmap`, `timeline`, `quadrantChart`
+- `sankey-beta`, `sankey`, `xychart-beta`, `xychart`, `block-beta`, `block`
+
+Salida:
+- Bloque de texto Mermaid validado
+- Bloque de imagen `image/svg+xml` cuando el render remoto está disponible
+- `structuredContent` con `diagramType`, `title`, `mermaid`, `rendered`, `saved`, `outputPath`
+
+Notas:
+- `diagram_render` usa render remoto (Kroki) para producir SVG, por eso tiene `openWorldHint: true`.
+- Si no hay conectividad o falla el render remoto, la tool devuelve fallback textual con el Mermaid.
+- Si `save_file=true` y no se envía `outputPath`, el archivo se guarda por defecto en `diagrams/<database>.svg` (o `diagrams/<title>.svg`) en la raíz del proyecto.
+- Si una llamada solo envía `code`, la tool también intenta inferir la base de datos desde un comentario Mermaid `%% database: <db>` para evitar guardar como `diagram.svg`.
+- `diagram_er` publica `renderRequest.args` con payload mínimo (`code`) para máxima compatibilidad con clientes que validan esquemas de tools de forma estricta (y evitan errores por propiedades adicionales).

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "xampp-mcp",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "MCP server for XAMPP and MySQL administration on Windows",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dony-aep/xampp-mcp.git"
+  },
+  "homepage": "https://github.com/dony-aep/xampp-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/dony-aep/xampp-mcp/issues"
+  },
   "type": "module",
   "main": "dist/server.js",
   "bin": {
@@ -10,6 +18,7 @@
   "files": [
     "dist",
     "README.md",
+    "LICENSE",
     "docs",
     "package.json"
   ],
@@ -31,7 +40,7 @@
     "mysql",
     "vscode"
   ],
-  "license": "UNLICENSED",
+  "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.22.0"
   },

package/dist/tools/tableCreate.js

@@ -1,61 +0,0 @@
-import { executeMysqlSql } from "../runtime/mysqlClient.js";
-import { toToolTextResult } from "../runtime/errors.js";
-import { getBoolean, getString } from "../runtime/validators.js";
-import { assertDatabaseIdentifier, assertIdentifier, requireConfirmation } from "../security/policy.js";
-import { mysqlConnectionFromArgs } from "./shared.js";
-function normalizeCreateStatement(statement, tableName) {
-    const compact = statement.trim();
-    const upper = compact.toUpperCase();
-    if (!upper.startsWith("CREATE TABLE")) {
-        throw new Error("createStatement must start with CREATE TABLE");
-    }
-    if (!upper.includes(tableName.toUpperCase())) {
-        throw new Error("createStatement must target the provided table");
-    }
-    return compact;
-}
-export function createTableCreateTool(environment) {
-    return {
-        name: "table_create",
-        description: "Creates a table using a CREATE TABLE statement",
-        inputSchema: {
-            type: "object",
-            properties: {
-                database: { type: "string" },
-                table: { type: "string" },
-                createStatement: { type: "string" },
-                confirmed: { type: "boolean" },
-                host: { type: "string" },
-                port: { type: "number" },
-                user: { type: "string" },
-                password: { type: "string" },
-            },
-            required: ["database", "table", "createStatement", "confirmed"],
-            additionalProperties: false,
-        },
-        annotations: {
-            title: "Create Table",
-            destructiveHint: true,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const database = getString(args.database, "database");
-            const table = getString(args.table, "table");
-            const createStatement = getString(args.createStatement, "createStatement");
-            const confirmed = getBoolean(args.confirmed, "confirmed");
-            requireConfirmation(confirmed, "table_create");
-            assertDatabaseIdentifier(database, "database");
-            assertIdentifier(table, "table");
-            const sql = normalizeCreateStatement(createStatement, table);
-            await executeMysqlSql(environment, {
-                ...mysqlConnectionFromArgs(args),
-                database,
-                sql,
-            });
-            return toToolTextResult(`Table ${database}.${table} created`, {
-                database,
-                table,
-            });
-        },
-    };
-}