xampp-mcp 0.1.0

package/dist/tools/dbExport.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { exportDatabase } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getOptionalString, getString } from "../runtime/validators.js";
+import { assertDatabaseIdentifier, requireConfirmation } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+function defaultExportPath(database) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return path.join(process.cwd(), `${database}-${timestamp}.sql`);
+}
+export function createDbExportTool(environment) {
+    return {
+        name: "db_export",
+        description: "Exports a MySQL database to a SQL file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                outputPath: { type: "string" },
+                includeCreateDatabase: { type: "boolean" },
+                addDropTable: { type: "boolean" },
+                confirmed: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database", "confirmed"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Database Export",
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            const outputPath = getOptionalString(args.outputPath, "outputPath") ?? defaultExportPath(database);
+            const includeCreateDatabase = getBoolean(args.includeCreateDatabase, "includeCreateDatabase", true);
+            const addDropTable = getBoolean(args.addDropTable, "addDropTable", true);
+            const confirmed = getBoolean(args.confirmed, "confirmed");
+            requireConfirmation(confirmed, "db_export");
+            assertDatabaseIdentifier(database, "database");
+            await exportDatabase(environment, {
+                ...mysqlConnectionFromArgs(args),
+                database,
+                outputPath,
+                includeCreateDatabase,
+                addDropTable,
+            });
+            return toToolTextResult(`Database ${database} exported to ${outputPath}`, {
+                database,
+                outputPath,
+            });
+        },
+    };
+}

package/dist/tools/dbImport.js

@@ -0,0 +1,46 @@
+import { importDatabase } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getString } from "../runtime/validators.js";
+import { assertDatabaseIdentifier, requireConfirmation } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+export function createDbImportTool(environment) {
+    return {
+        name: "db_import",
+        description: "Imports SQL file into a MySQL database",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                inputPath: { type: "string" },
+                confirmed: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database", "inputPath", "confirmed"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Database Import",
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            const inputPath = getString(args.inputPath, "inputPath");
+            const confirmed = getBoolean(args.confirmed, "confirmed");
+            requireConfirmation(confirmed, "db_import");
+            assertDatabaseIdentifier(database, "database");
+            await importDatabase(environment, {
+                ...mysqlConnectionFromArgs(args),
+                database,
+                inputPath,
+            });
+            return toToolTextResult(`Imported ${inputPath} into ${database}`, {
+                database,
+                inputPath,
+            });
+        },
+    };
+}

package/dist/tools/dbInspect.js

@@ -0,0 +1,89 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getString } from "../runtime/validators.js";
+import { assertDatabaseIdentifier, escapeSqlLiteral } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+export function createDbInspectTool(environment) {
+    return {
+        name: "db_inspect",
+        description: "Shows database status summary with table-level information",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Inspect Database",
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            assertDatabaseIdentifier(database, "database");
+            const connection = mysqlConnectionFromArgs(args);
+            const literalDb = escapeSqlLiteral(database);
+            const schemaResult = await executeMysqlSql(environment, {
+                ...connection,
+                sql: `
+SELECT
+  SCHEMA_NAME AS database_name,
+  DEFAULT_CHARACTER_SET_NAME AS charset_name,
+  DEFAULT_COLLATION_NAME AS collation_name
+FROM information_schema.SCHEMATA
+WHERE SCHEMA_NAME = ${literalDb}
+        `,
+            });
+            const summaryResult = await executeMysqlSql(environment, {
+                ...connection,
+                sql: `
+SELECT
+  COUNT(*) AS table_count,
+  COALESCE(ROUND(SUM(TABLE_ROWS), 0), 0) AS estimated_rows,
+  COALESCE(ROUND(SUM(DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2), 0) AS total_size_mb
+FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = ${literalDb}
+        `,
+            });
+            const tablesResult = await executeMysqlSql(environment, {
+                ...connection,
+                sql: `
+SELECT
+  TABLE_NAME,
+  ENGINE,
+  TABLE_ROWS,
+  ROUND((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2) AS size_mb,
+  CREATE_TIME,
+  UPDATE_TIME
+FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = ${literalDb}
+ORDER BY TABLE_NAME
+        `,
+            });
+            const text = [
+                `Database inspection: ${database}`,
+                "",
+                "Schema:",
+                schemaResult.stdout || "No schema metadata found",
+                "",
+                "Summary:",
+                summaryResult.stdout || "No summary available",
+                "",
+                "Tables:",
+                tablesResult.stdout || "No tables found",
+            ].join("\n");
+            return toToolTextResult(text, {
+                database,
+                schema: schemaResult.stdout,
+                summary: summaryResult.stdout,
+                tables: tablesResult.stdout,
+            });
+        },
+    };
+}

package/dist/tools/grantManage.js

@@ -0,0 +1,75 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getString } from "../runtime/validators.js";
+import { assertHost, assertDatabaseIdentifier, assertUsername, escapeSqlIdentifier, escapeSqlLiteral, requireConfirmation, } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+function normalizePrivileges(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error("privileges cannot be empty");
+    }
+    if (trimmed === "*") {
+        return "ALL PRIVILEGES";
+    }
+    return trimmed
+        .split(",")
+        .map((item) => item.trim().toUpperCase())
+        .join(", ");
+}
+export function createGrantManageTool(environment) {
+    return {
+        name: "grant_manage",
+        description: "Grants privileges to a MySQL user on a database",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: { type: "string" },
+                username: { type: "string" },
+                hostScope: { type: "string" },
+                privileges: { type: "string", description: "Comma-separated list or * for all" },
+                withGrantOption: { type: "boolean" },
+                confirmed: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["database", "username", "privileges", "confirmed"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Grant Privileges",
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const database = getString(args.database, "database");
+            const username = getString(args.username, "username");
+            const hostScope = getString(args.hostScope, "hostScope", { optional: true }) || "%";
+            const privileges = normalizePrivileges(getString(args.privileges, "privileges"));
+            const withGrantOption = getBoolean(args.withGrantOption, "withGrantOption", false);
+            const confirmed = getBoolean(args.confirmed, "confirmed");
+            requireConfirmation(confirmed, "grant_manage");
+            assertDatabaseIdentifier(database, "database");
+            assertUsername(username);
+            assertHost(hostScope);
+            const sql = [
+                `GRANT ${privileges} ON ${escapeSqlIdentifier(database)}.* TO ${escapeSqlLiteral(username)}@${escapeSqlLiteral(hostScope)}`,
+                withGrantOption ? "WITH GRANT OPTION" : "",
+            ]
+                .filter((part) => part.length > 0)
+                .join(" ");
+            await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                sql,
+            });
+            return toToolTextResult(`Granted ${privileges} on ${database} to ${username}@${hostScope}`, {
+                database,
+                username,
+                hostScope,
+                privileges,
+                withGrantOption,
+            });
+        },
+    };
+}

package/dist/tools/phpCliRun.js

@@ -0,0 +1,41 @@
+import { runCommand } from "../runtime/commandRunner.js";
+import { toToolTextResult, ToolExecutionError } from "../runtime/errors.js";
+import { getOptionalString, getString } from "../runtime/validators.js";
+export function createPhpCliRunTool(environment) {
+    return {
+        name: "php_cli_run",
+        description: "Executes a PHP script using XAMPP PHP CLI",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scriptPath: { type: "string" },
+                args: { type: "string", description: "Arguments as a single string" },
+            },
+            required: ["scriptPath"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "PHP CLI Run",
+            openWorldHint: false,
+            destructiveHint: false,
+        },
+        handler: async (args) => {
+            const scriptPath = getString(args.scriptPath, "scriptPath");
+            const rawArgs = getOptionalString(args.args, "args");
+            const cliArgs = [scriptPath, ...(rawArgs ? rawArgs.split(" ").filter((item) => item.length > 0) : [])];
+            const result = await runCommand({
+                command: environment.paths.phpExe,
+                args: cliArgs,
+                timeoutMs: 60_000,
+            });
+            if (result.exitCode !== 0) {
+                throw new ToolExecutionError(result.stderr || result.stdout || "PHP CLI failed", "PHP_CLI_FAILED");
+            }
+            const text = result.stdout.length > 0 ? result.stdout : "PHP script executed successfully";
+            return toToolTextResult(text, {
+                stdout: result.stdout,
+                stderr: result.stderr,
+            });
+        },
+    };
+}

package/dist/tools/preflightCheck.js

@@ -0,0 +1,51 @@
+import { getPathAvailability } from "../config/env.js";
+import { runCommand } from "../runtime/commandRunner.js";
+import { toToolTextResult } from "../runtime/errors.js";
+async function checkPort(port) {
+    const result = await runCommand({
+        command: "netstat.exe",
+        args: ["-ano"],
+        timeoutMs: 10_000,
+    });
+    const pattern = new RegExp(`[:.]${port}\\s+`, "m");
+    return pattern.test(result.stdout);
+}
+export function createPreflightCheckTool(environment) {
+    return {
+        name: "preflight_check",
+        description: "Checks XAMPP binaries/scripts and common ports before operations",
+        inputSchema: {
+            type: "object",
+            properties: {
+                apachePort: { type: "number", default: 80 },
+                mysqlPort: { type: "number", default: 3306 },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Preflight Check",
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const apachePort = typeof args.apachePort === "number" ? args.apachePort : 80;
+            const mysqlPort = typeof args.mysqlPort === "number" ? args.mysqlPort : 3306;
+            const [apacheBusy, mysqlBusy] = await Promise.all([checkPort(apachePort), checkPort(mysqlPort)]);
+            const paths = getPathAvailability(environment);
+            const allPathsAvailable = Object.values(paths).every((item) => item.exists);
+            const summary = [
+                `Path checks: ${allPathsAvailable ? "ok" : "missing files"}`,
+                `Apache port ${apachePort}: ${apacheBusy ? "in use" : "free"}`,
+                `MySQL port ${mysqlPort}: ${mysqlBusy ? "in use" : "free"}`,
+            ].join("\n");
+            return toToolTextResult(summary, {
+                allPathsAvailable,
+                ports: {
+                    apache: { port: apachePort, inUse: apacheBusy },
+                    mysql: { port: mysqlPort, inUse: mysqlBusy },
+                },
+                paths,
+            });
+        },
+    };
+}

package/dist/tools/queryExecute.js

@@ -0,0 +1,46 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getBoolean, getOptionalString, getString } from "../runtime/validators.js";
+import { requireConfirmation } from "../security/policy.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+export function createQueryExecuteTool(environment) {
+    return {
+        name: "query_execute",
+        description: "Runs SQL query with write capability (INSERT/UPDATE/DELETE/DDL)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sql: { type: "string" },
+                database: { type: "string" },
+                confirmed: { type: "boolean" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["sql", "confirmed"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Execute Query",
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const sql = getString(args.sql, "sql");
+            const database = getOptionalString(args.database, "database");
+            const confirmed = getBoolean(args.confirmed, "confirmed");
+            requireConfirmation(confirmed, "query_execute");
+            const result = await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                database,
+                sql,
+            });
+            const text = result.stdout || "Query executed successfully";
+            return toToolTextResult(text, {
+                database,
+                stdout: result.stdout,
+            });
+        },
+    };
+}

package/dist/tools/queryReadonly.js

@@ -0,0 +1,50 @@
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { toToolTextResult } from "../runtime/errors.js";
+import { getOptionalString, getString } from "../runtime/validators.js";
+import { mysqlConnectionFromArgs } from "./shared.js";
+const READ_ONLY_PREFIXES = ["SELECT", "SHOW", "DESCRIBE", "EXPLAIN"];
+function assertReadonlyQuery(sql) {
+    const normalized = sql.trim().replace(/\s+/g, " ").toUpperCase();
+    if (READ_ONLY_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+        return;
+    }
+    throw new Error("query_readonly only accepts SELECT/SHOW/DESCRIBE/EXPLAIN statements");
+}
+export function createQueryReadonlyTool(environment) {
+    return {
+        name: "query_readonly",
+        description: "Runs read-only SQL query for diagnostics",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sql: { type: "string" },
+                database: { type: "string" },
+                host: { type: "string" },
+                port: { type: "number" },
+                user: { type: "string" },
+                password: { type: "string" },
+            },
+            required: ["sql"],
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Read-only Query",
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const sql = getString(args.sql, "sql");
+            const database = getOptionalString(args.database, "database");
+            assertReadonlyQuery(sql);
+            const result = await executeMysqlSql(environment, {
+                ...mysqlConnectionFromArgs(args),
+                database,
+                sql,
+            });
+            const text = result.stdout || "Query executed successfully (no rows in output)";
+            return toToolTextResult(text, {
+                stdout: result.stdout,
+            });
+        },
+    };
+}

package/dist/tools/registry.js

@@ -0,0 +1,36 @@
+import { createDbCreateTool } from "./dbCreate.js";
+import { createDbExportTool } from "./dbExport.js";
+import { createDbImportTool } from "./dbImport.js";
+import { createDbInspectTool } from "./dbInspect.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 = [
+        createPreflightCheckTool(environment),
+        createStackStatusTool(environment),
+        createQueryReadonlyTool(environment),
+        createQueryExecuteTool(environment),
+        createDbInspectTool(environment),
+        createDbCreateTool(environment),
+        createTableCreateTool(environment),
+        createUserCreateTool(environment),
+        createGrantManageTool(environment),
+        createDbExportTool(environment),
+        createDbImportTool(environment),
+        createPhpCliRunTool(environment),
+    ];
+    const toolMap = new Map();
+    for (const tool of tools) {
+        toolMap.set(tool.name, tool);
+    }
+    return {
+        list: () => tools,
+        get: (name) => toolMap.get(name),
+    };
+}

package/dist/tools/shared.js

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs";
+import { executeMysqlSql } from "../runtime/mysqlClient.js";
+import { getOptionalNumber, getOptionalString } from "../runtime/validators.js";
+export function getMode(args, environment) {
+    const mode = getOptionalString(args.mode, "mode");
+    if (mode === undefined) {
+        return environment.defaultMode;
+    }
+    return mode === "service" ? "service" : "console";
+}
+export function ensurePathExists(filePath, label) {
+    if (!existsSync(filePath)) {
+        throw new Error(`${label} not found: ${filePath}`);
+    }
+}
+export function mysqlConnectionFromArgs(args) {
+    return {
+        host: getOptionalString(args.host, "host"),
+        port: getOptionalNumber(args.port, "port"),
+        user: getOptionalString(args.user, "user"),
+        password: getOptionalString(args.password, "password"),
+    };
+}
+export async function runMysqlStatement(environment, args, sql, database) {
+    const connection = mysqlConnectionFromArgs(args);
+    await executeMysqlSql(environment, {
+        ...connection,
+        database,
+        sql,
+    });
+}

package/dist/tools/stackStatus.js

@@ -0,0 +1,84 @@
+import { getPathAvailability } from "../config/env.js";
+import { runCommand } from "../runtime/commandRunner.js";
+import { toToolTextResult } from "../runtime/errors.js";
+async function isProcessRunning(imageName) {
+    const result = await runCommand({
+        command: "tasklist.exe",
+        args: ["/FI", `IMAGENAME eq ${imageName}`],
+        timeoutMs: 5_000,
+    });
+    return result.stdout.toLowerCase().includes(imageName.toLowerCase());
+}
+async function getServiceState(serviceName) {
+    const result = await runCommand({
+        command: "sc.exe",
+        args: ["query", serviceName],
+        timeoutMs: 5_000,
+    });
+    if (result.exitCode !== 0) {
+        return "not-found-or-no-access";
+    }
+    const lines = result.stdout.split(/\r?\n/);
+    const stateLine = lines.find((line) => line.includes("STATE"));
+    if (!stateLine) {
+        return "unknown";
+    }
+    return stateLine.split(":").at(-1)?.trim() ?? "unknown";
+}
+export function createStackStatusTool(environment) {
+    return {
+        name: "stack_status",
+        description: "Shows XAMPP path checks and Apache/MySQL process or service state",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+        annotations: {
+            title: "Stack Status",
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async () => {
+            const [apacheRunning, mysqlRunning, apacheServiceState, mysqlServiceState] = await Promise.all([
+                isProcessRunning("httpd.exe"),
+                isProcessRunning("mysqld.exe"),
+                getServiceState(environment.apacheServiceName),
+                getServiceState(environment.mysqlServiceName),
+            ]);
+            const availability = getPathAvailability(environment);
+            const adviceLines = [];
+            if (!apacheRunning) {
+                adviceLines.push("Apache is stopped. Ask the user to start Apache from XAMPP Control Panel and confirm when ready before continuing. Do not run apache_start.bat automatically.");
+            }
+            if (!mysqlRunning) {
+                adviceLines.push("MySQL is stopped. Ask the user to start MySQL from XAMPP Control Panel and confirm when ready before continuing. Do not run mysql_start.bat automatically.");
+            }
+            const adviceText = adviceLines.length > 0 ? `\n\nAdvice:\n${adviceLines.join("\n")}` : "";
+            const summary = [
+                `XAMPP dir: ${environment.xamppDir}`,
+                `Apache process: ${apacheRunning ? "running" : "stopped"}`,
+                `MySQL process: ${mysqlRunning ? "running" : "stopped"}`,
+                `Apache service (${environment.apacheServiceName}): ${apacheServiceState}`,
+                `MySQL service (${environment.mysqlServiceName}): ${mysqlServiceState}`,
+            ].join("\n") + adviceText;
+            return toToolTextResult(summary, {
+                xamppDir: environment.xamppDir,
+                paths: availability,
+                processes: {
+                    apache: apacheRunning,
+                    mysql: mysqlRunning,
+                },
+                services: {
+                    apache: apacheServiceState,
+                    mysql: mysqlServiceState,
+                },
+                requiresUserAction: adviceLines.length > 0,
+                nextStep: adviceLines.length > 0
+                    ? "Wait for user confirmation after modules are started in XAMPP Control Panel, then retry the requested tool."
+                    : "No action needed.",
+                advice: adviceLines,
+            });
+        },
+    };
+}

package/dist/tools/tableCreate.js

@@ -0,0 +1,61 @@
+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,
+            });
+        },
+    };
+}