@imenam/database-mcp 1.0.9

package/dist/index.js

@@ -0,0 +1,133 @@
+#!/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 path from 'path';
+import { fileURLToPath } from 'url';
+import { GuiLauncher, setupLogging } from '@imenam/mcp-gui-interface';
+import { TOOLS, ExecuteQuerySchema, DescribeTableSchema, ExecuteWriteSchema } from './tools.js';
+import { executeQuery, listTables, describeTable, isProxyMode } from './db.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+setupLogging({ processLabel: 'MASTER', logDir: process.env.MCP_LOG_DIR });
+const DEFAULT_MAX_ROWS = parseInt(process.env.MYSQL_MCP_DEFAULT_MAX_ROWS ?? '10');
+const DEFAULT_MAX_CELL_LENGTH = parseInt(process.env.MYSQL_MCP_DEFAULT_MAX_CELL_LENGTH ?? '50');
+const READ_ONLY_PREFIXES = ['SELECT', 'SHOW', 'DESCRIBE', 'EXPLAIN', 'WITH'];
+function applyLimits(rows, maxRows, maxCellLength) {
+    const limited = rows.slice(0, maxRows);
+    const truncated = limited.map(row => {
+        const newRow = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (typeof value === 'string' && value.length > maxCellLength) {
+                newRow[key] = value.slice(0, maxCellLength) + ' [truncated]';
+            }
+            else {
+                newRow[key] = value;
+            }
+        }
+        return newRow;
+    });
+    return {
+        rows: truncated,
+        meta: {
+            total_returned: truncated.length,
+            was_row_limited: rows.length > maxRows,
+        },
+    };
+}
+function isReadOnly(sql) {
+    const normalized = sql.trim().toUpperCase();
+    return READ_ONLY_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+const launcher = new GuiLauncher({
+    guiPath: path.join(__dirname, 'gui.js'),
+    onMessage: (msg) => {
+        if (msg.type === 'STOP')
+            process.exit(0);
+    },
+});
+const server = new Server({
+    name: 'mysql-mcp',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'list_tables': {
+                const tables = await listTables();
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }],
+                };
+            }
+            case 'describe_table': {
+                const { table_name } = DescribeTableSchema.parse(args);
+                const schema = await describeTable(table_name);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(schema, null, 2) }],
+                };
+            }
+            case 'execute_query': {
+                const { sql, max_rows, max_cell_length } = ExecuteQuerySchema.parse(args);
+                if (!isReadOnly(sql)) {
+                    throw new Error('Only read-only SELECT statements are allowed with execute_query. Use execute_write for write operations.');
+                }
+                const rows = await executeQuery(sql);
+                const result = applyLimits(rows, max_rows ?? DEFAULT_MAX_ROWS, max_cell_length ?? DEFAULT_MAX_CELL_LENGTH);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'execute_write': {
+                if (isProxyMode()) {
+                    throw new Error('execute_write est désactivé en mode proxy HTTP (API en lecture seule).');
+                }
+                if (process.env.MYSQL_MCP_ALLOW_WRITE?.trim().toLowerCase() !== 'true') {
+                    throw new Error('Write operations are disabled: set MYSQL_MCP_ALLOW_WRITE=true in the MCP environment configuration to enable them.');
+                }
+                const { sql, max_rows, max_cell_length } = ExecuteWriteSchema.parse(args);
+                if (isReadOnly(sql)) {
+                    throw new Error('Use execute_query for SELECT statements, not execute_write.');
+                }
+                const rawResult = await executeQuery(sql);
+                const result = Array.isArray(rawResult)
+                    ? applyLimits(rawResult, max_rows ?? DEFAULT_MAX_ROWS, max_cell_length ?? DEFAULT_MAX_CELL_LENGTH)
+                    : rawResult;
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'An unknown error occurred';
+        return {
+            isError: true,
+            content: [{ type: 'text', text: message }],
+        };
+    }
+});
+async function main() {
+    if (!process.env.PROXY_URL) {
+        console.error('[MASTER] PROXY_URL non défini — GUI désactivée.');
+    }
+    else {
+        launcher.start();
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    const dbType = process.env.MYSQL_MCP_DB_TYPE ?? 'mysql';
+    console.error(`DB MCP server running on stdio (db_type: ${dbType})`);
+}
+main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    process.exit(1);
+});

package/dist/tools.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export const ExecuteQuerySchema = z.object({
+    sql: z
+        .string()
+        .min(1)
+        .describe('The SQL SELECT query to execute. Only SELECT statements are allowed.'),
+    max_rows: z.number().int().positive().optional(),
+    max_cell_length: z.number().int().positive().optional(),
+});
+export const DescribeTableSchema = z.object({
+    table_name: z.string().min(1).describe('The name of the table to describe.'),
+});
+export const ExecuteWriteSchema = z.object({
+    sql: z
+        .string()
+        .min(1)
+        .describe('The SQL write statement to execute (INSERT, UPDATE, DELETE, CREATE, DROP, ALTER). Use with caution.'),
+    max_rows: z.number().int().positive().optional(),
+    max_cell_length: z.number().int().positive().optional(),
+});
+export const TOOLS = [
+    {
+        name: 'list_tables',
+        description: 'List all tables available in the connected database.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'describe_table',
+        description: 'Describe the schema of a specific table: column names, types, nullability, keys, and defaults.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table_name: {
+                    type: 'string',
+                    description: 'The name of the table to describe.',
+                },
+            },
+            required: ['table_name'],
+        },
+    },
+    {
+        name: 'execute_query',
+        description: 'Execute a read-only SQL SELECT query against the connected database and return the results. Results are limited by default to avoid polluting the model context. Only increase max_rows or max_cell_length if you explicitly need more data.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'The SQL SELECT query to execute. Only SELECT statements are allowed.',
+                },
+                max_rows: {
+                    type: 'integer',
+                    description: 'Maximum number of rows to return. Defaults to 10. Only increase if you explicitly need more results.',
+                },
+                max_cell_length: {
+                    type: 'integer',
+                    description: 'Maximum character length per cell value. Content exceeding this limit is truncated with "[truncated]". Defaults to 50.',
+                },
+            },
+            required: ['sql'],
+        },
+    },
+    {
+        name: 'execute_write',
+        description: 'Execute a write SQL statement (INSERT, UPDATE, DELETE, CREATE, DROP, ALTER) against the connected database. This action is irreversible — always confirm with the user before calling this tool. Requires MYSQL_MCP_ALLOW_WRITE=true to be set in the environment, otherwise the tool will return an error. If the statement returns rows, results are limited by default to avoid polluting the model context.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'The SQL write statement to execute. Use with caution as this modifies data.',
+                },
+                max_rows: {
+                    type: 'integer',
+                    description: 'Maximum number of rows to return (if the statement returns rows). Defaults to 10. Only increase if you explicitly need more results.',
+                },
+                max_cell_length: {
+                    type: 'integer',
+                    description: 'Maximum character length per cell value. Content exceeding this limit is truncated with "[truncated]". Defaults to 50.',
+                },
+            },
+            required: ['sql'],
+        },
+    },
+];

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@imenam/database-mcp",
+  "version": "1.0.9",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc && npm run build:gui",
+    "build:gui": "cd public && npx vite build",
+    "start": "node dist/index.js",
+    "dev": "concurrently -n server,gui -c blue,green \"npm run dev:server\" \"npm run dev:gui\"",
+    "dev:server": "tsx src/index.ts",
+    "dev:gui": "cd public && npx vite",
+    "release": "npm run build && npm version patch && npm publish --access public && git push origin master --follow-tags"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mysql",
+    "database",
+    "ai",
+    "agent",
+    "cursor"
+  ],
+  "author": "",
+  "files": [
+    "dist",
+    "public/dist",
+    "README.md"
+  ],
+  "license": "ISC",
+  "description": "A Model Context Protocol server to interact with a MySQL database",
+  "dependencies": {
+    "@codemirror/autocomplete": "^6.20.1",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/language": "^6.12.2",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.40.0",
+    "@imenam/mcp-gui-interface": "^1.0.5",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^12.8.0",
+    "body-parser": "^2.2.2",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "mysql2": "^3.18.2",
+    "pg": "^8.20.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/body-parser": "^1.19.6",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.3.3",
+    "@types/pg": "^8.18.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "concurrently": "^9.2.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^8.0.0"
+  },
+  "type": "module",
+  "bin": {
+    "databaseMcp": "./dist/index.js"
+  }
+}