@cmd233/mcp-database-server 1.1.1

package/dist/src/db/sqlserver-adapter.js

@@ -0,0 +1,186 @@
+import sql from 'mssql';
+/**
+ * SQL Server database adapter implementation
+ */
+export class SqlServerAdapter {
+    constructor(connectionInfo) {
+        this.pool = null;
+        this.server = connectionInfo.server;
+        this.database = connectionInfo.database;
+        // Create SQL Server connection config
+        this.config = {
+            server: connectionInfo.server,
+            database: connectionInfo.database,
+            port: connectionInfo.port || 1433,
+            options: {
+                trustServerCertificate: connectionInfo.trustServerCertificate ?? true,
+                ...connectionInfo.options
+            }
+        };
+        // Add authentication options
+        if (connectionInfo.user && connectionInfo.password) {
+            this.config.user = connectionInfo.user;
+            this.config.password = connectionInfo.password;
+        }
+        else {
+            // Use Windows authentication if no username/password provided
+            this.config.options.trustedConnection = true;
+            this.config.options.enableArithAbort = true;
+        }
+    }
+    /**
+     * Initialize SQL Server connection
+     */
+    async init() {
+        try {
+            console.error(`[INFO] Connecting to SQL Server: ${this.server}, Database: ${this.database}`);
+            this.pool = await new sql.ConnectionPool(this.config).connect();
+            console.error(`[INFO] SQL Server connection established successfully`);
+        }
+        catch (err) {
+            console.error(`[ERROR] SQL Server connection error: ${err.message}`);
+            throw new Error(`Failed to connect to SQL Server: ${err.message}`);
+        }
+    }
+    /**
+     * Execute a SQL query and get all results
+     * @param query SQL query to execute
+     * @param params Query parameters
+     * @returns Promise with query results
+     */
+    async all(query, params = []) {
+        if (!this.pool) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            const request = this.pool.request();
+            // Add parameters to the request
+            params.forEach((param, index) => {
+                request.input(`param${index}`, param);
+            });
+            // Replace ? with named parameters
+            const preparedQuery = query.replace(/\?/g, (_, i) => `@param${i}`);
+            const result = await request.query(preparedQuery);
+            return result.recordset;
+        }
+        catch (err) {
+            throw new Error(`SQL Server query error: ${err.message}`);
+        }
+    }
+    /**
+     * Execute a SQL query that modifies data
+     * @param query SQL query to execute
+     * @param params Query parameters
+     * @returns Promise with result info
+     */
+    async run(query, params = []) {
+        if (!this.pool) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            const request = this.pool.request();
+            // Add parameters to the request
+            params.forEach((param, index) => {
+                request.input(`param${index}`, param);
+            });
+            // Replace ? with named parameters
+            const preparedQuery = query.replace(/\?/g, (_, i) => `@param${i}`);
+            // Add output parameter for identity value if it's an INSERT
+            let lastID = 0;
+            if (query.trim().toUpperCase().startsWith('INSERT')) {
+                request.output('insertedId', sql.Int, 0);
+                const updatedQuery = `${preparedQuery}; SELECT @insertedId = SCOPE_IDENTITY();`;
+                const result = await request.query(updatedQuery);
+                lastID = result.output.insertedId || 0;
+            }
+            else {
+                const result = await request.query(preparedQuery);
+                lastID = 0;
+            }
+            return {
+                changes: this.getAffectedRows(query, lastID),
+                lastID: lastID
+            };
+        }
+        catch (err) {
+            throw new Error(`SQL Server query error: ${err.message}`);
+        }
+    }
+    /**
+     * Execute multiple SQL statements
+     * @param query SQL statements to execute
+     * @returns Promise that resolves when execution completes
+     */
+    async exec(query) {
+        if (!this.pool) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            const request = this.pool.request();
+            await request.batch(query);
+        }
+        catch (err) {
+            throw new Error(`SQL Server batch error: ${err.message}`);
+        }
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        if (this.pool) {
+            await this.pool.close();
+            this.pool = null;
+        }
+    }
+    /**
+     * Get database metadata
+     */
+    getMetadata() {
+        return {
+            name: "SQL Server",
+            type: "sqlserver",
+            server: this.server,
+            database: this.database
+        };
+    }
+    /**
+     * Get database-specific query for listing tables
+     */
+    getListTablesQuery() {
+        return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME";
+    }
+    /**
+     * Get database-specific query for describing a table
+     * @param tableName Table name
+     */
+    getDescribeTableQuery(tableName) {
+        return `
+      SELECT 
+        c.COLUMN_NAME as name,
+        c.DATA_TYPE as type,
+        CASE WHEN c.IS_NULLABLE = 'NO' THEN 1 ELSE 0 END as notnull,
+        CASE WHEN pk.CONSTRAINT_TYPE = 'PRIMARY KEY' THEN 1 ELSE 0 END as pk,
+        c.COLUMN_DEFAULT as dflt_value
+      FROM 
+        INFORMATION_SCHEMA.COLUMNS c
+      LEFT JOIN 
+        INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu ON c.TABLE_NAME = kcu.TABLE_NAME AND c.COLUMN_NAME = kcu.COLUMN_NAME
+      LEFT JOIN 
+        INFORMATION_SCHEMA.TABLE_CONSTRAINTS pk ON kcu.CONSTRAINT_NAME = pk.CONSTRAINT_NAME AND pk.CONSTRAINT_TYPE = 'PRIMARY KEY'
+      WHERE 
+        c.TABLE_NAME = '${tableName}'
+      ORDER BY 
+        c.ORDINAL_POSITION
+    `;
+    }
+    /**
+     * Helper to get the number of affected rows based on query type
+     */
+    getAffectedRows(query, lastID) {
+        const queryType = query.trim().split(' ')[0].toUpperCase();
+        if (queryType === 'INSERT' && lastID > 0) {
+            return 1;
+        }
+        return 0; // For SELECT, unknown for UPDATE/DELETE without additional query
+    }
+}

package/dist/src/handlers/resourceHandlers.js

@@ -0,0 +1,71 @@
+import { dbAll, getListTablesQuery, getDescribeTableQuery, getDatabaseMetadata } from '../db/index.js';
+/**
+ * Handle listing resources request
+ * @returns List of available resources
+ */
+export async function handleListResources() {
+    try {
+        const dbInfo = getDatabaseMetadata();
+        const dbType = dbInfo.type;
+        let resourceBaseUrl;
+        // Create appropriate URL based on database type
+        if (dbType === 'sqlite' && dbInfo.path) {
+            resourceBaseUrl = new URL(`sqlite:///${dbInfo.path}`);
+        }
+        else if (dbType === 'sqlserver' && dbInfo.server && dbInfo.database) {
+            resourceBaseUrl = new URL(`sqlserver://${dbInfo.server}/${dbInfo.database}`);
+        }
+        else {
+            resourceBaseUrl = new URL(`db:///database`);
+        }
+        const SCHEMA_PATH = "schema";
+        // Use adapter-specific query to list tables
+        const query = getListTablesQuery();
+        const result = await dbAll(query);
+        return {
+            resources: result.map((row) => ({
+                uri: new URL(`${row.name}/${SCHEMA_PATH}`, resourceBaseUrl).href,
+                mimeType: "application/json",
+                name: `"${row.name}" database schema`,
+            })),
+        };
+    }
+    catch (error) {
+        throw new Error(`Error listing resources: ${error.message}`);
+    }
+}
+/**
+ * Handle reading a specific resource
+ * @param uri URI of the resource to read
+ * @returns Resource contents
+ */
+export async function handleReadResource(uri) {
+    try {
+        const resourceUrl = new URL(uri);
+        const SCHEMA_PATH = "schema";
+        const pathComponents = resourceUrl.pathname.split("/");
+        const schema = pathComponents.pop();
+        const tableName = pathComponents.pop();
+        if (schema !== SCHEMA_PATH) {
+            throw new Error("Invalid resource URI");
+        }
+        // Use adapter-specific query to describe the table
+        const query = getDescribeTableQuery(tableName);
+        const result = await dbAll(query);
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(result.map((column) => ({
+                        column_name: column.name,
+                        data_type: column.type
+                    })), null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Error reading resource: ${error.message}`);
+    }
+}

package/dist/src/handlers/toolHandlers.js

@@ -0,0 +1,158 @@
+import { formatErrorResponse } from '../utils/formatUtils.js';
+// Import all tool implementations
+import { readQuery, writeQuery, exportQuery } from '../tools/queryTools.js';
+import { createTable, alterTable, dropTable, listTables, describeTable } from '../tools/schemaTools.js';
+import { appendInsight, listInsights } from '../tools/insightTools.js';
+/**
+ * Handle listing available tools
+ * @returns List of available tools
+ */
+export function handleListTools() {
+    return {
+        tools: [
+            {
+                name: "read_query",
+                description: "Execute SELECT queries to read data from the database",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "write_query",
+                description: "Execute INSERT, UPDATE, or DELETE queries",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "create_table",
+                description: "Create new tables in the database",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "alter_table",
+                description: "Modify existing table schema (add columns, rename tables, etc.)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "drop_table",
+                description: "Remove a table from the database with safety confirmation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        table_name: { type: "string" },
+                        confirm: { type: "boolean" },
+                    },
+                    required: ["table_name", "confirm"],
+                },
+            },
+            {
+                name: "export_query",
+                description: "Export query results to various formats (CSV, JSON)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        format: { type: "string", enum: ["csv", "json"] },
+                    },
+                    required: ["query", "format"],
+                },
+            },
+            {
+                name: "list_tables",
+                description: "Get a list of all tables in the database",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "describe_table",
+                description: "View schema information for a specific table",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        table_name: { type: "string" },
+                    },
+                    required: ["table_name"],
+                },
+            },
+            {
+                name: "append_insight",
+                description: "Add a business insight to the memo",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        insight: { type: "string" },
+                    },
+                    required: ["insight"],
+                },
+            },
+            {
+                name: "list_insights",
+                description: "List all business insights in the memo",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+}
+/**
+ * Handle tool call requests
+ * @param name Name of the tool to call
+ * @param args Arguments for the tool
+ * @returns Tool execution result
+ */
+export async function handleToolCall(name, args) {
+    try {
+        switch (name) {
+            case "read_query":
+                return await readQuery(args.query);
+            case "write_query":
+                return await writeQuery(args.query);
+            case "create_table":
+                return await createTable(args.query);
+            case "alter_table":
+                return await alterTable(args.query);
+            case "drop_table":
+                return await dropTable(args.table_name, args.confirm);
+            case "export_query":
+                return await exportQuery(args.query, args.format);
+            case "list_tables":
+                return await listTables();
+            case "describe_table":
+                return await describeTable(args.table_name);
+            case "append_insight":
+                return await appendInsight(args.insight);
+            case "list_insights":
+                return await listInsights();
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return formatErrorResponse(error);
+    }
+}

package/dist/src/index.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Import database utils
+import { initDatabase, closeDatabase, getDatabaseMetadata } from './db/index.js';
+// Import handlers
+import { handleListResources, handleReadResource } from './handlers/resourceHandlers.js';
+import { handleListTools, handleToolCall } from './handlers/toolHandlers.js';
+// Setup a logger that uses stderr instead of stdout to avoid interfering with MCP communications
+const logger = {
+    log: (...args) => console.error('[INFO]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    warn: (...args) => console.error('[WARN]', ...args),
+    info: (...args) => console.error('[INFO]', ...args),
+};
+// Configure the server
+const server = new Server({
+    name: "executeautomation/database-server",
+    version: "1.1.0",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// Parse command line arguments
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    logger.error("Please provide database connection information");
+    logger.error("Usage for SQLite: node index.js <database_file_path>");
+    logger.error("Usage for SQL Server: node index.js --sqlserver --server <server> --database <database> [--user <user> --password <password>]");
+    logger.error("Usage for PostgreSQL: node index.js --postgresql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
+    logger.error("Usage for MySQL: node index.js --mysql --host <host> --database <database> [--user <user> --password <password> --port <port>]");
+    logger.error("Usage for MySQL with AWS IAM: node index.js --mysql --aws-iam-auth --host <rds-endpoint> --database <database> --user <aws-username> --aws-region <region>");
+    process.exit(1);
+}
+// Parse arguments to determine database type and connection info
+let dbType = 'sqlite';
+let connectionInfo = null;
+// Check if using SQL Server
+if (args.includes('--sqlserver')) {
+    dbType = 'sqlserver';
+    connectionInfo = {
+        server: '',
+        database: '',
+        user: undefined,
+        password: undefined
+    };
+    // Parse SQL Server connection parameters
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--server' && i + 1 < args.length) {
+            connectionInfo.server = args[i + 1];
+        }
+        else if (args[i] === '--database' && i + 1 < args.length) {
+            connectionInfo.database = args[i + 1];
+        }
+        else if (args[i] === '--user' && i + 1 < args.length) {
+            connectionInfo.user = args[i + 1];
+        }
+        else if (args[i] === '--password' && i + 1 < args.length) {
+            connectionInfo.password = args[i + 1];
+        }
+        else if (args[i] === '--port' && i + 1 < args.length) {
+            connectionInfo.port = parseInt(args[i + 1], 10);
+        }
+    }
+    // Validate SQL Server connection info
+    if (!connectionInfo.server || !connectionInfo.database) {
+        logger.error("Error: SQL Server requires --server and --database parameters");
+        process.exit(1);
+    }
+}
+// Check if using PostgreSQL
+else if (args.includes('--postgresql') || args.includes('--postgres')) {
+    dbType = 'postgresql';
+    connectionInfo = {
+        host: '',
+        database: '',
+        user: undefined,
+        password: undefined,
+        port: undefined,
+        ssl: undefined,
+        connectionTimeout: undefined
+    };
+    // Parse PostgreSQL connection parameters
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--host' && i + 1 < args.length) {
+            connectionInfo.host = args[i + 1];
+        }
+        else if (args[i] === '--database' && i + 1 < args.length) {
+            connectionInfo.database = args[i + 1];
+        }
+        else if (args[i] === '--user' && i + 1 < args.length) {
+            connectionInfo.user = args[i + 1];
+        }
+        else if (args[i] === '--password' && i + 1 < args.length) {
+            connectionInfo.password = args[i + 1];
+        }
+        else if (args[i] === '--port' && i + 1 < args.length) {
+            connectionInfo.port = parseInt(args[i + 1], 10);
+        }
+        else if (args[i] === '--ssl' && i + 1 < args.length) {
+            connectionInfo.ssl = args[i + 1] === 'true';
+        }
+        else if (args[i] === '--connection-timeout' && i + 1 < args.length) {
+            connectionInfo.connectionTimeout = parseInt(args[i + 1], 10);
+        }
+    }
+    // Validate PostgreSQL connection info
+    if (!connectionInfo.host || !connectionInfo.database) {
+        logger.error("Error: PostgreSQL requires --host and --database parameters");
+        process.exit(1);
+    }
+}
+// Check if using MySQL
+else if (args.includes('--mysql')) {
+    dbType = 'mysql';
+    connectionInfo = {
+        host: '',
+        database: '',
+        user: undefined,
+        password: undefined,
+        port: undefined,
+        ssl: undefined,
+        connectionTimeout: undefined,
+        awsIamAuth: false,
+        awsRegion: undefined
+    };
+    // Parse MySQL connection parameters
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--host' && i + 1 < args.length) {
+            connectionInfo.host = args[i + 1];
+        }
+        else if (args[i] === '--database' && i + 1 < args.length) {
+            connectionInfo.database = args[i + 1];
+        }
+        else if (args[i] === '--user' && i + 1 < args.length) {
+            connectionInfo.user = args[i + 1];
+        }
+        else if (args[i] === '--password' && i + 1 < args.length) {
+            connectionInfo.password = args[i + 1];
+        }
+        else if (args[i] === '--port' && i + 1 < args.length) {
+            connectionInfo.port = parseInt(args[i + 1], 10);
+        }
+        else if (args[i] === '--ssl' && i + 1 < args.length) {
+            const sslVal = args[i + 1];
+            if (sslVal === 'true')
+                connectionInfo.ssl = true;
+            else if (sslVal === 'false')
+                connectionInfo.ssl = false;
+            else
+                connectionInfo.ssl = sslVal;
+        }
+        else if (args[i] === '--connection-timeout' && i + 1 < args.length) {
+            connectionInfo.connectionTimeout = parseInt(args[i + 1], 10);
+        }
+        else if (args[i] === '--aws-iam-auth') {
+            connectionInfo.awsIamAuth = true;
+        }
+        else if (args[i] === '--aws-region' && i + 1 < args.length) {
+            connectionInfo.awsRegion = args[i + 1];
+        }
+    }
+    // Validate MySQL connection info
+    if (!connectionInfo.host || !connectionInfo.database) {
+        logger.error("Error: MySQL requires --host and --database parameters");
+        process.exit(1);
+    }
+    // Additional validation for AWS IAM authentication
+    if (connectionInfo.awsIamAuth) {
+        if (!connectionInfo.user) {
+            logger.error("Error: AWS IAM authentication requires --user parameter");
+            process.exit(1);
+        }
+        if (!connectionInfo.awsRegion) {
+            logger.error("Error: AWS IAM authentication requires --aws-region parameter");
+            process.exit(1);
+        }
+        // Automatically enable SSL for AWS IAM authentication (required)
+        connectionInfo.ssl = true;
+        logger.info("AWS IAM authentication enabled - SSL automatically configured");
+    }
+}
+else {
+    // SQLite mode (default)
+    dbType = 'sqlite';
+    connectionInfo = args[0]; // First argument is the SQLite file path
+    logger.info(`Using SQLite database at path: ${connectionInfo}`);
+}
+// Set up request handlers
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return await handleListResources();
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    return await handleReadResource(request.params.uri);
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return handleListTools();
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return await handleToolCall(request.params.name, request.params.arguments);
+});
+// Handle shutdown gracefully
+process.on('SIGINT', async () => {
+    logger.info('Shutting down gracefully...');
+    await closeDatabase();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    logger.info('Shutting down gracefully...');
+    await closeDatabase();
+    process.exit(0);
+});
+// Add global error handler
+process.on('uncaughtException', (error) => {
+    logger.error('Uncaught exception:', error);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+/**
+ * Start the server
+ */
+async function runServer() {
+    try {
+        logger.info(`Initializing ${dbType} database...`);
+        if (dbType === 'sqlite') {
+            logger.info(`Database path: ${connectionInfo}`);
+        }
+        else if (dbType === 'sqlserver') {
+            logger.info(`Server: ${connectionInfo.server}, Database: ${connectionInfo.database}`);
+        }
+        else if (dbType === 'postgresql') {
+            logger.info(`Host: ${connectionInfo.host}, Database: ${connectionInfo.database}`);
+        }
+        else if (dbType === 'mysql') {
+            logger.info(`Host: ${connectionInfo.host}, Database: ${connectionInfo.database}`);
+        }
+        // Initialize the database
+        await initDatabase(connectionInfo, dbType);
+        const dbInfo = getDatabaseMetadata();
+        logger.info(`Connected to ${dbInfo.name} database`);
+        logger.info('Starting MCP server...');
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        logger.info('Server running. Press Ctrl+C to exit.');
+    }
+    catch (error) {
+        logger.error("Failed to initialize:", error);
+        process.exit(1);
+    }
+}
+// Start the server
+runServer().catch(error => {
+    logger.error("Server initialization failed:", error);
+    process.exit(1);
+});