xampp-mcp 0.1.0

package/README.md

@@ -0,0 +1,130 @@
+# xampp-mcp
+
+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`.
+
+## Configuració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
+
+Instalación global:
+
+```powershell
+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:
+
+```jsonc
+{
+	"servers": {
+		"xamppMcp": {
+			"type": "stdio",
+			"command": "xampp-mcp",
+			"env": {
+				"XAMPP_DIR": "C:\\xampp",
+				"XAMPP_DEFAULT_MODE": "console"
+			}
+		}
+	}
+}
+```
+
+Si usas `npx` en vez de instalación global:
+
+```jsonc
+{
+	"servers": {
+		"xamppMcp": {
+			"type": "stdio",
+			"command": "npx",
+			"args": ["-y", "xampp-mcp"],
+			"env": {
+				"XAMPP_DIR": "C:\\xampp",
+				"XAMPP_DEFAULT_MODE": "console"
+			}
+		}
+	}
+}
+```
+
+## Publicación npm
+
+```powershell
+npm login
+npm version patch
+npm publish
+```
+
+## Seguridad
+
+- 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.
+
+## Reglas de nombres
+
+- 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`.
+
+## Codificación de texto
+
+- 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.
+
+## Próximos pasos sugeridos
+
+- 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.

package/dist/config/env.js

@@ -0,0 +1,89 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function env(name) {
+    const value = process.env[name];
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    const startsWithDouble = trimmed.startsWith("\"") && trimmed.endsWith("\"");
+    const startsWithSingle = trimmed.startsWith("'") && trimmed.endsWith("'");
+    if ((startsWithDouble || startsWithSingle) && trimmed.length >= 2) {
+        const unwrapped = trimmed.slice(1, -1).trim();
+        return unwrapped.length > 0 ? unwrapped : undefined;
+    }
+    return trimmed;
+}
+function normalizePathValue(value) {
+    if (!value.toLowerCase().startsWith("file://")) {
+        return value;
+    }
+    try {
+        return fileURLToPath(value);
+    }
+    catch {
+        return value;
+    }
+}
+function resolveXamppPath(xamppDir, ...segments) {
+    return path.join(xamppDir, ...segments);
+}
+function parseMode(value) {
+    if (value === "service") {
+        return "service";
+    }
+    return "console";
+}
+function parsePort(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed) && parsed > 0 && parsed <= 65535) {
+        return parsed;
+    }
+    return fallback;
+}
+export function loadEnvironment() {
+    const xamppDir = normalizePathValue(env("XAMPP_DIR") ?? "C:\\xampp");
+    return {
+        xamppDir,
+        defaultMode: parseMode(env("XAMPP_DEFAULT_MODE")),
+        apacheServiceName: env("XAMPP_APACHE_SERVICE") ?? "Apache2.4",
+        mysqlServiceName: env("XAMPP_MYSQL_SERVICE") ?? "mysql",
+        mysqlDefaultHost: env("MYSQL_HOST") ?? "127.0.0.1",
+        mysqlDefaultPort: parsePort(env("MYSQL_PORT"), 3306),
+        mysqlDefaultUser: env("MYSQL_USER") ?? "root",
+        mysqlDefaultPassword: env("MYSQL_PASSWORD"),
+        paths: {
+            apacheStart: resolveXamppPath(xamppDir, "apache_start.bat"),
+            apacheStop: resolveXamppPath(xamppDir, "apache_stop.bat"),
+            apacheExe: resolveXamppPath(xamppDir, "apache", "bin", "httpd.exe"),
+            mysqlStart: resolveXamppPath(xamppDir, "mysql_start.bat"),
+            mysqlStop: resolveXamppPath(xamppDir, "mysql_stop.bat"),
+            mysqldExe: resolveXamppPath(xamppDir, "mysql", "bin", "mysqld.exe"),
+            mysqlIni: resolveXamppPath(xamppDir, "mysql", "bin", "my.ini"),
+            mysqlExe: resolveXamppPath(xamppDir, "mysql", "bin", "mysql.exe"),
+            mysqldumpExe: resolveXamppPath(xamppDir, "mysql", "bin", "mysqldump.exe"),
+            phpExe: resolveXamppPath(xamppDir, "php", "php.exe"),
+        },
+    };
+}
+export function getPathAvailability(environment) {
+    return {
+        apacheStart: { path: environment.paths.apacheStart, exists: existsSync(environment.paths.apacheStart) },
+        apacheStop: { path: environment.paths.apacheStop, exists: existsSync(environment.paths.apacheStop) },
+        apacheExe: { path: environment.paths.apacheExe, exists: existsSync(environment.paths.apacheExe) },
+        mysqlStart: { path: environment.paths.mysqlStart, exists: existsSync(environment.paths.mysqlStart) },
+        mysqlStop: { path: environment.paths.mysqlStop, exists: existsSync(environment.paths.mysqlStop) },
+        mysqldExe: { path: environment.paths.mysqldExe, exists: existsSync(environment.paths.mysqldExe) },
+        mysqlIni: { path: environment.paths.mysqlIni, exists: existsSync(environment.paths.mysqlIni) },
+        mysqlExe: { path: environment.paths.mysqlExe, exists: existsSync(environment.paths.mysqlExe) },
+        mysqldumpExe: { path: environment.paths.mysqldumpExe, exists: existsSync(environment.paths.mysqldumpExe) },
+        phpExe: { path: environment.paths.phpExe, exists: existsSync(environment.paths.phpExe) },
+    };
+}

package/dist/runtime/commandRunner.js

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function unwrapQuoted(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2) {
+        return trimmed;
+    }
+    const startsWithDouble = trimmed.startsWith("\"") && trimmed.endsWith("\"");
+    const startsWithSingle = trimmed.startsWith("'") && trimmed.endsWith("'");
+    if (startsWithDouble || startsWithSingle) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function normalizeFileUri(value) {
+    if (!value.toLowerCase().startsWith("file://")) {
+        return value;
+    }
+    try {
+        return fileURLToPath(value);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeCommandValue(value) {
+    return normalizeFileUri(unwrapQuoted(value));
+}
+function quoteForCmd(value) {
+    if (value.length === 0) {
+        return "\"\"";
+    }
+    const escaped = value.replace(/([\^&|<>()%!\"])|\r|\n/g, "^$1");
+    return `"${escaped}"`;
+}
+function isBatchScript(filePath) {
+    const extension = path.extname(normalizeCommandValue(filePath)).toLowerCase();
+    return extension === ".bat" || extension === ".cmd";
+}
+function toSpawnSpec(command, args) {
+    const normalizedCommand = normalizeCommandValue(command);
+    if (!isBatchScript(normalizedCommand)) {
+        return { file: normalizedCommand, args };
+    }
+    return {
+        file: "cmd.exe",
+        args: ["/d", "/c", "call", normalizedCommand, ...args],
+    };
+}
+export async function runCommand(options) {
+    const { command, args = [], cwd, env, timeoutMs = 30_000, stdin, } = options;
+    const start = Date.now();
+    const normalizedCommand = normalizeCommandValue(command);
+    const spawnSpec = toSpawnSpec(normalizedCommand, args);
+    return await new Promise((resolve, reject) => {
+        const child = spawn(spawnSpec.file, spawnSpec.args, {
+            cwd,
+            env,
+            windowsHide: true,
+            stdio: "pipe",
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                command: normalizedCommand,
+                args,
+                exitCode,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                timedOut,
+                durationMs: Date.now() - start,
+            });
+        });
+        if (stdin !== undefined) {
+            child.stdin.write(stdin);
+        }
+        child.stdin.end();
+    });
+}
+export function runDetachedCommand(options) {
+    const { command, args = [], cwd, env, } = options;
+    const normalizedCommand = normalizeCommandValue(command);
+    const spawnSpec = toSpawnSpec(normalizedCommand, args);
+    const child = spawn(spawnSpec.file, spawnSpec.args, {
+        cwd,
+        env,
+        windowsHide: true,
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return {
+        command: normalizedCommand,
+        args,
+        pid: child.pid,
+    };
+}

package/dist/runtime/errors.js

@@ -0,0 +1,39 @@
+export class ToolExecutionError extends Error {
+    code;
+    constructor(message, code = "TOOL_EXECUTION_ERROR") {
+        super(message);
+        this.name = "ToolExecutionError";
+        this.code = code;
+    }
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "Unexpected error";
+}
+export function toToolErrorResult(error) {
+    return {
+        isError: true,
+        content: [
+            {
+                type: "text",
+                text: normalizeError(error),
+            },
+        ],
+    };
+}
+export function toToolTextResult(text, structuredContent) {
+    return {
+        content: [
+            {
+                type: "text",
+                text,
+            },
+        ],
+        structuredContent,
+    };
+}

package/dist/runtime/mysqlClient.js

@@ -0,0 +1,111 @@
+import { promises as fs } from "node:fs";
+import { runCommand } from "./commandRunner.js";
+import { ToolExecutionError } from "./errors.js";
+const MYSQL_CHARACTER_SET = "utf8mb4";
+const MYSQL_COLLATION = "utf8mb4_unicode_ci";
+function isMysqlUnavailable(detail) {
+    const normalized = detail.toLowerCase();
+    return (normalized.includes("can't connect to mysql server") ||
+        normalized.includes("cannot connect to mysql server") ||
+        normalized.includes("connection refused") ||
+        normalized.includes("actively refused") ||
+        normalized.includes("error 2002") ||
+        normalized.includes("errno 2002"));
+}
+function resolveConnection(environment, options) {
+    return {
+        host: options.host ?? environment.mysqlDefaultHost,
+        port: options.port ?? environment.mysqlDefaultPort,
+        user: options.user ?? environment.mysqlDefaultUser,
+        password: options.password ?? environment.mysqlDefaultPassword ?? "",
+    };
+}
+function baseMysqlArgs(connection) {
+    const args = [
+        "--protocol=tcp",
+        `--default-character-set=${MYSQL_CHARACTER_SET}`,
+        "--host",
+        connection.host,
+        "--port",
+        String(connection.port),
+        "--user",
+        connection.user,
+    ];
+    if (connection.password.length > 0) {
+        args.push(`--password=${connection.password}`);
+    }
+    return args;
+}
+function assertSuccess(result, context, connection) {
+    if (result.timedOut) {
+        throw new ToolExecutionError(`${context} timed out after ${result.durationMs}ms`, "COMMAND_TIMEOUT");
+    }
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.length > 0 ? result.stderr : result.stdout;
+        if (connection && isMysqlUnavailable(detail)) {
+            throw new ToolExecutionError(`MySQL is not reachable at ${connection.host}:${connection.port}. Ask the user to open XAMPP Control Panel, start MySQL, and confirm when done before retrying this operation. Do not run mysql_start.bat automatically.`, "MYSQL_UNREACHABLE");
+        }
+        throw new ToolExecutionError(`${context} failed (${result.exitCode ?? "unknown"}): ${detail}`, "COMMAND_FAILED");
+    }
+}
+export async function executeMysqlSql(environment, options) {
+    const connection = resolveConnection(environment, options);
+    const args = baseMysqlArgs(connection);
+    if (options.database) {
+        args.push(options.database);
+    }
+    const sessionHeader = `SET NAMES ${MYSQL_CHARACTER_SET} COLLATE ${MYSQL_COLLATION};`;
+    const sqlStatement = options.sql.endsWith(";") ? options.sql : `${options.sql};`;
+    const result = await runCommand({
+        command: environment.paths.mysqlExe,
+        args,
+        stdin: `${sessionHeader}\n${sqlStatement}\n`,
+        timeoutMs: options.timeoutMs ?? 30_000,
+    });
+    assertSuccess(result, "MySQL query", connection);
+    return result;
+}
+export async function exportDatabase(environment, options) {
+    const connection = resolveConnection(environment, options);
+    const args = [
+        "--protocol=tcp",
+        `--default-character-set=${MYSQL_CHARACTER_SET}`,
+        "--host",
+        connection.host,
+        "--port",
+        String(connection.port),
+        "--user",
+        connection.user,
+    ];
+    if (connection.password.length > 0) {
+        args.push(`--password=${connection.password}`);
+    }
+    if (options.includeCreateDatabase) {
+        args.push("--databases");
+    }
+    if (options.addDropTable) {
+        args.push("--add-drop-table");
+    }
+    args.push(options.database);
+    const result = await runCommand({
+        command: environment.paths.mysqldumpExe,
+        args,
+        timeoutMs: options.timeoutMs ?? 120_000,
+    });
+    assertSuccess(result, "MySQL export", connection);
+    await fs.writeFile(options.outputPath, `${result.stdout}\n`, "utf8");
+    return result;
+}
+export async function importDatabase(environment, options) {
+    const sql = await fs.readFile(options.inputPath, "utf8");
+    const result = await executeMysqlSql(environment, {
+        host: options.host,
+        port: options.port,
+        user: options.user,
+        password: options.password,
+        database: options.database,
+        sql,
+        timeoutMs: options.timeoutMs ?? 180_000,
+    });
+    return result;
+}

package/dist/runtime/validators.js

@@ -0,0 +1,60 @@
+import { ToolExecutionError } from "./errors.js";
+export function getString(value, fieldName, options) {
+    if (value === undefined || value === null) {
+        if (options?.optional) {
+            return "";
+        }
+        throw new ToolExecutionError(`${fieldName} is required`, "INVALID_INPUT");
+    }
+    if (typeof value !== "string") {
+        throw new ToolExecutionError(`${fieldName} must be a string`, "INVALID_INPUT");
+    }
+    const trimmed = value.trim();
+    if (!options?.optional && trimmed.length === 0) {
+        throw new ToolExecutionError(`${fieldName} cannot be empty`, "INVALID_INPUT");
+    }
+    return trimmed;
+}
+export function getOptionalString(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new ToolExecutionError(`${fieldName} must be a string`, "INVALID_INPUT");
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function getBoolean(value, fieldName, fallback = false) {
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    if (typeof value !== "boolean") {
+        throw new ToolExecutionError(`${fieldName} must be a boolean`, "INVALID_INPUT");
+    }
+    return value;
+}
+export function getOptionalNumber(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new ToolExecutionError(`${fieldName} must be a number`, "INVALID_INPUT");
+    }
+    return value;
+}
+export function getEnum(value, fieldName, accepted, fallback) {
+    if (value === undefined || value === null) {
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        throw new ToolExecutionError(`${fieldName} is required`, "INVALID_INPUT");
+    }
+    if (typeof value !== "string") {
+        throw new ToolExecutionError(`${fieldName} must be a string`, "INVALID_INPUT");
+    }
+    if (accepted.includes(value)) {
+        return value;
+    }
+    throw new ToolExecutionError(`${fieldName} must be one of: ${accepted.join(", ")}`, "INVALID_INPUT");
+}

package/dist/security/policy.js

@@ -0,0 +1,44 @@
+import { ToolExecutionError } from "../runtime/errors.js";
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const USERNAME_PATTERN = /^[A-Za-z0-9._$-]+$/;
+const HOST_PATTERN = /^[A-Za-z0-9.%_-]+$/;
+function buildIdentifierErrorMessage(value, fieldName) {
+    const base = `Invalid ${fieldName}. Use snake_case with letters, numbers and underscore only; it must start with a letter or underscore.`;
+    if (!value.includes("-")) {
+        return base;
+    }
+    const suggested = value.replace(/-/g, "_");
+    return `${base} Hyphen (-) is not allowed by policy. Suggested ${fieldName}: "${suggested}".`;
+}
+export function requireConfirmation(confirmed, action) {
+    if (confirmed) {
+        return;
+    }
+    throw new ToolExecutionError(`${action} requires explicit confirmation. Set "confirmed": true to proceed.`, "CONFIRMATION_REQUIRED");
+}
+export function assertIdentifier(value, fieldName) {
+    if (!IDENTIFIER_PATTERN.test(value)) {
+        throw new ToolExecutionError(buildIdentifierErrorMessage(value, fieldName), "INVALID_IDENTIFIER");
+    }
+}
+export function assertDatabaseIdentifier(value, fieldName) {
+    if (!IDENTIFIER_PATTERN.test(value)) {
+        throw new ToolExecutionError(buildIdentifierErrorMessage(value, fieldName), "INVALID_IDENTIFIER");
+    }
+}
+export function assertUsername(value) {
+    if (!USERNAME_PATTERN.test(value)) {
+        throw new ToolExecutionError("Invalid username. Allowed chars: letters, numbers, . _ $ -", "INVALID_USERNAME");
+    }
+}
+export function assertHost(value) {
+    if (!HOST_PATTERN.test(value)) {
+        throw new ToolExecutionError("Invalid host. Allowed chars: letters, numbers, %, ., _, -", "INVALID_HOST");
+    }
+}
+export function escapeSqlIdentifier(identifier) {
+    return `\`${identifier.replace(/`/g, "``")}\``;
+}
+export function escapeSqlLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}

package/dist/server.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadEnvironment } from "./config/env.js";
+import { createToolRegistry } from "./tools/registry.js";
+import { toToolErrorResult } from "./runtime/errors.js";
+async function main() {
+    const environment = loadEnvironment();
+    const toolRegistry = createToolRegistry(environment);
+    const server = new Server({
+        name: "xampp-mcp",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = toolRegistry.list().map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            annotations: tool.annotations,
+        }));
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const tool = toolRegistry.get(request.params.name);
+        if (!tool) {
+            return toToolErrorResult(`Unknown tool: ${request.params.name}`);
+        }
+        const rawArgs = request.params.arguments ?? {};
+        try {
+            return await tool.handler(rawArgs);
+        }
+        catch (error) {
+            return toToolErrorResult(error);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    process.stderr.write(`Fatal error: ${String(error)}\n`);
+    process.exit(1);
+});

package/dist/tools/dbCreate.js

@@ -0,0 +1,50 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getString } from "../runtime/validators.js";
+import { assertDatabaseIdentifier, escapeSqlIdentifier, requireConfirmation } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+const DEFAULT_DB_CHARACTER_SET = "utf8mb4";
+const DEFAULT_DB_COLLATION = "utf8mb4_unicode_ci";
+export function createDbCreateTool(environment) {
+    return {
+        name: "db_create",
+        description: "Creates a MySQL database",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                ifNotExists: { type: "boolean" },
+                confirmed: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database", "confirmed"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Create Database",
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            const confirmed = getBoolean(args.confirmed, "confirmed");
+            const ifNotExists = getBoolean(args.ifNotExists, "ifNotExists", true);
+            requireConfirmation(confirmed, "db_create");
+            assertDatabaseIdentifier(database, "database");
+            const sql = `CREATE DATABASE ${ifNotExists ? "IF NOT EXISTS " : ""}${escapeSqlIdentifier(database)} CHARACTER SET ${DEFAULT_DB_CHARACTER_SET} COLLATE ${DEFAULT_DB_COLLATION}`;
+            await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                sql,
+            });
+            return toToolTextResult(`Database ${database} created`, {
+                database,
+                ifNotExists,
+                characterSet: DEFAULT_DB_CHARACTER_SET,
+                collation: DEFAULT_DB_COLLATION,
+            });
+        },
+    };
+}