@cmd233/mcp-database-server 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ExecuteAutomation
+
+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/dist/src/db/adapter.js

@@ -0,0 +1,29 @@
+// Import adapters using dynamic imports
+import { SqliteAdapter } from './sqlite-adapter.js';
+import { SqlServerAdapter } from './sqlserver-adapter.js';
+import { PostgresqlAdapter } from './postgresql-adapter.js';
+import { MysqlAdapter } from './mysql-adapter.js';
+/**
+ * Factory function to create the appropriate database adapter
+ */
+export function createDbAdapter(type, connectionInfo) {
+    switch (type.toLowerCase()) {
+        case 'sqlite':
+            // For SQLite, if connectionInfo is a string, use it directly as path
+            if (typeof connectionInfo === 'string') {
+                return new SqliteAdapter(connectionInfo);
+            }
+            else {
+                return new SqliteAdapter(connectionInfo.path);
+            }
+        case 'sqlserver':
+            return new SqlServerAdapter(connectionInfo);
+        case 'postgresql':
+        case 'postgres':
+            return new PostgresqlAdapter(connectionInfo);
+        case 'mysql':
+            return new MysqlAdapter(connectionInfo);
+        default:
+            throw new Error(`Unsupported database type: ${type}`);
+    }
+}

package/dist/src/db/index.js

@@ -0,0 +1,95 @@
+import { createDbAdapter } from './adapter.js';
+// Store the active database adapter
+let dbAdapter = null;
+/**
+ * Initialize the database connection
+ * @param connectionInfo Connection information object or SQLite path string
+ * @param dbType Database type ('sqlite' or 'sqlserver')
+ */
+export async function initDatabase(connectionInfo, dbType = 'sqlite') {
+    try {
+        // If connectionInfo is a string, assume it's a SQLite path
+        if (typeof connectionInfo === 'string') {
+            connectionInfo = { path: connectionInfo };
+        }
+        // Create appropriate adapter based on database type
+        dbAdapter = createDbAdapter(dbType, connectionInfo);
+        // Initialize the connection
+        await dbAdapter.init();
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize database: ${error.message}`);
+    }
+}
+/**
+ * Execute a SQL query and get all results
+ * @param query SQL query to execute
+ * @param params Query parameters
+ * @returns Promise with query results
+ */
+export function dbAll(query, params = []) {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.all(query, params);
+}
+/**
+ * Execute a SQL query that modifies data
+ * @param query SQL query to execute
+ * @param params Query parameters
+ * @returns Promise with result info
+ */
+export function dbRun(query, params = []) {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.run(query, params);
+}
+/**
+ * Execute multiple SQL statements
+ * @param query SQL statements to execute
+ * @returns Promise that resolves when execution completes
+ */
+export function dbExec(query) {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.exec(query);
+}
+/**
+ * Close the database connection
+ */
+export function closeDatabase() {
+    if (!dbAdapter) {
+        return Promise.resolve();
+    }
+    return dbAdapter.close();
+}
+/**
+ * Get database metadata
+ */
+export function getDatabaseMetadata() {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.getMetadata();
+}
+/**
+ * Get database-specific query for listing tables
+ */
+export function getListTablesQuery() {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.getListTablesQuery();
+}
+/**
+ * Get database-specific query for describing a table
+ * @param tableName Table name
+ */
+export function getDescribeTableQuery(tableName) {
+    if (!dbAdapter) {
+        throw new Error("Database not initialized");
+    }
+    return dbAdapter.getDescribeTableQuery(tableName);
+}

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

@@ -0,0 +1,205 @@
+import mysql from "mysql2/promise";
+import { Signer } from "@aws-sdk/rds-signer";
+/**
+ * MySQL database adapter implementation
+ */
+export class MysqlAdapter {
+    constructor(connectionInfo) {
+        this.connection = null;
+        this.host = connectionInfo.host;
+        this.database = connectionInfo.database;
+        this.awsIamAuth = connectionInfo.awsIamAuth || false;
+        this.awsRegion = connectionInfo.awsRegion;
+        this.config = {
+            host: connectionInfo.host,
+            database: connectionInfo.database,
+            port: connectionInfo.port || 3306,
+            user: connectionInfo.user,
+            password: connectionInfo.password,
+            connectTimeout: connectionInfo.connectionTimeout || 30000,
+            multipleStatements: true,
+        };
+        if (typeof connectionInfo.ssl === 'object' || typeof connectionInfo.ssl === 'string') {
+            this.config.ssl = connectionInfo.ssl;
+        }
+        else if (connectionInfo.ssl === true) {
+            // For AWS IAM authentication, configure SSL appropriately for RDS
+            if (this.awsIamAuth) {
+                this.config.ssl = {
+                    rejectUnauthorized: false // AWS RDS handles certificate validation
+                };
+            }
+            else {
+                this.config.ssl = {};
+            }
+        }
+        // Validate port
+        if (connectionInfo.port && typeof connectionInfo.port !== 'number') {
+            const parsedPort = parseInt(connectionInfo.port, 10);
+            if (isNaN(parsedPort)) {
+                throw new Error(`Invalid port value for MySQL: ${connectionInfo.port}`);
+            }
+            this.config.port = parsedPort;
+        }
+        // Log the port for debugging
+        console.error(`[DEBUG] MySQL connection will use port: ${this.config.port}`);
+    }
+    /**
+     * Generate AWS RDS authentication token
+     */
+    async generateAwsAuthToken() {
+        if (!this.awsRegion) {
+            throw new Error("AWS region is required for IAM authentication");
+        }
+        if (!this.config.user) {
+            throw new Error("AWS username is required for IAM authentication");
+        }
+        try {
+            console.info(`[INFO] Generating AWS auth token for region: ${this.awsRegion}, host: ${this.host}, user: ${this.config.user}`);
+            const signer = new Signer({
+                region: this.awsRegion,
+                hostname: this.host,
+                port: this.config.port || 3306,
+                username: this.config.user,
+            });
+            const token = await signer.getAuthToken();
+            console.info(`[INFO] AWS auth token generated successfully`);
+            return token;
+        }
+        catch (err) {
+            console.error(`[ERROR] Failed to generate AWS auth token: ${err.message}`);
+            throw new Error(`AWS IAM authentication failed: ${err.message}. Please check your AWS credentials and IAM permissions.`);
+        }
+    }
+    /**
+     * Initialize MySQL connection
+     */
+    async init() {
+        try {
+            console.info(`[INFO] Connecting to MySQL: ${this.host}, Database: ${this.database}`);
+            // Handle AWS IAM authentication
+            if (this.awsIamAuth) {
+                console.info(`[INFO] Using AWS IAM authentication for user: ${this.config.user}`);
+                try {
+                    const authToken = await this.generateAwsAuthToken();
+                    // Create a new config with the generated token as password
+                    const awsConfig = {
+                        ...this.config,
+                        password: authToken
+                    };
+                    this.connection = await mysql.createConnection(awsConfig);
+                }
+                catch (err) {
+                    console.error(`[ERROR] AWS IAM authentication failed: ${err.message}`);
+                    throw new Error(`AWS IAM authentication failed: ${err.message}`);
+                }
+            }
+            else {
+                this.connection = await mysql.createConnection(this.config);
+            }
+            console.info(`[INFO] MySQL connection established successfully`);
+        }
+        catch (err) {
+            console.error(`[ERROR] MySQL connection error: ${err.message}`);
+            if (this.awsIamAuth) {
+                throw new Error(`Failed to connect to MySQL with AWS IAM authentication: ${err.message}. Please verify your AWS credentials, IAM permissions, and RDS configuration.`);
+            }
+            else {
+                throw new Error(`Failed to connect to MySQL: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Execute a SQL query and get all results
+     */
+    async all(query, params = []) {
+        if (!this.connection) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            const [rows] = await this.connection.execute(query, params);
+            return Array.isArray(rows) ? rows : [];
+        }
+        catch (err) {
+            throw new Error(`MySQL query error: ${err.message}`);
+        }
+    }
+    /**
+     * Execute a SQL query that modifies data
+     */
+    async run(query, params = []) {
+        if (!this.connection) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            const [result] = await this.connection.execute(query, params);
+            const changes = result.affectedRows || 0;
+            const lastID = result.insertId || 0;
+            return { changes, lastID };
+        }
+        catch (err) {
+            throw new Error(`MySQL query error: ${err.message}`);
+        }
+    }
+    /**
+     * Execute multiple SQL statements
+     */
+    async exec(query) {
+        if (!this.connection) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            await this.connection.query(query);
+        }
+        catch (err) {
+            throw new Error(`MySQL batch error: ${err.message}`);
+        }
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        if (this.connection) {
+            await this.connection.end();
+            this.connection = null;
+        }
+    }
+    /**
+     * Get database metadata
+     */
+    getMetadata() {
+        return {
+            name: "MySQL",
+            type: "mysql",
+            server: this.host,
+            database: this.database,
+        };
+    }
+    /**
+     * Get database-specific query for listing tables
+     */
+    getListTablesQuery() {
+        return `SELECT table_name AS name FROM information_schema.tables WHERE table_schema = '${this.database}'`;
+    }
+    /**
+     * Get database-specific query for describing a table
+     */
+    getDescribeTableQuery(tableName) {
+        // MySQL DESCRIBE returns columns with different names, so we use a query that matches the expected format
+        return `
+      SELECT
+        COLUMN_NAME as name,
+        DATA_TYPE as type,
+        CASE WHEN IS_NULLABLE = 'NO' THEN 1 ELSE 0 END as notnull,
+        CASE WHEN COLUMN_KEY = 'PRI' THEN 1 ELSE 0 END as pk,
+        COLUMN_DEFAULT as dflt_value
+      FROM
+        INFORMATION_SCHEMA.COLUMNS
+      WHERE
+        TABLE_NAME = '${tableName}'
+        AND TABLE_SCHEMA = '${this.database}'
+      ORDER BY
+        ORDINAL_POSITION
+    `;
+    }
+}

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

@@ -0,0 +1,169 @@
+import pg from 'pg';
+/**
+ * PostgreSQL database adapter implementation
+ */
+export class PostgresqlAdapter {
+    constructor(connectionInfo) {
+        this.client = null;
+        this.host = connectionInfo.host;
+        this.database = connectionInfo.database;
+        // Create PostgreSQL connection config
+        this.config = {
+            host: connectionInfo.host,
+            database: connectionInfo.database,
+            port: connectionInfo.port || 5432,
+            user: connectionInfo.user,
+            password: connectionInfo.password,
+            ssl: connectionInfo.ssl,
+            // Add connection timeout if provided (in milliseconds)
+            connectionTimeoutMillis: connectionInfo.connectionTimeout || 30000,
+        };
+    }
+    /**
+     * Initialize PostgreSQL connection
+     */
+    async init() {
+        try {
+            console.error(`[INFO] Connecting to PostgreSQL: ${this.host}, Database: ${this.database}`);
+            console.error(`[DEBUG] Connection details:`, {
+                host: this.host,
+                database: this.database,
+                port: this.config.port,
+                user: this.config.user,
+                connectionTimeoutMillis: this.config.connectionTimeoutMillis,
+                ssl: !!this.config.ssl
+            });
+            this.client = new pg.Client(this.config);
+            await this.client.connect();
+            console.error(`[INFO] PostgreSQL connection established successfully`);
+        }
+        catch (err) {
+            console.error(`[ERROR] PostgreSQL connection error: ${err.message}`);
+            throw new Error(`Failed to connect to PostgreSQL: ${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.client) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            // PostgreSQL uses $1, $2, etc. for parameterized queries
+            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            const result = await this.client.query(preparedQuery, params);
+            return result.rows;
+        }
+        catch (err) {
+            throw new Error(`PostgreSQL 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.client) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            // Replace ? with numbered parameters
+            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            let lastID = 0;
+            let changes = 0;
+            // For INSERT queries, try to get the inserted ID
+            if (query.trim().toUpperCase().startsWith('INSERT')) {
+                // Add RETURNING clause to get the inserted ID if it doesn't already have one
+                const returningQuery = preparedQuery.includes('RETURNING')
+                    ? preparedQuery
+                    : `${preparedQuery} RETURNING id`;
+                const result = await this.client.query(returningQuery, params);
+                changes = result.rowCount || 0;
+                lastID = result.rows[0]?.id || 0;
+            }
+            else {
+                const result = await this.client.query(preparedQuery, params);
+                changes = result.rowCount || 0;
+            }
+            return { changes, lastID };
+        }
+        catch (err) {
+            throw new Error(`PostgreSQL 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.client) {
+            throw new Error("Database not initialized");
+        }
+        try {
+            await this.client.query(query);
+        }
+        catch (err) {
+            throw new Error(`PostgreSQL batch error: ${err.message}`);
+        }
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        if (this.client) {
+            await this.client.end();
+            this.client = null;
+        }
+    }
+    /**
+     * Get database metadata
+     */
+    getMetadata() {
+        return {
+            name: "PostgreSQL",
+            type: "postgresql",
+            server: this.host,
+            database: this.database
+        };
+    }
+    /**
+     * Get database-specific query for listing tables
+     */
+    getListTablesQuery() {
+        return "SELECT table_name as name FROM information_schema.tables WHERE table_schema = 'public' 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_name IS NOT NULL 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}'
+        AND c.table_schema = 'public'
+      ORDER BY 
+        c.ordinal_position
+    `;
+    }
+}

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

@@ -0,0 +1,134 @@
+import sqlite3 from "sqlite3";
+/**
+ * SQLite database adapter implementation
+ */
+export class SqliteAdapter {
+    constructor(dbPath) {
+        this.db = null;
+        this.dbPath = dbPath;
+    }
+    /**
+     * Initialize the SQLite database connection
+     */
+    async init() {
+        return new Promise((resolve, reject) => {
+            // Ensure the dbPath is accessible
+            console.error(`[INFO] Opening SQLite database at: ${this.dbPath}`);
+            this.db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, (err) => {
+                if (err) {
+                    console.error(`[ERROR] SQLite connection error: ${err.message}`);
+                    reject(err);
+                }
+                else {
+                    console.error("[INFO] SQLite database opened successfully");
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * 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.db) {
+            throw new Error("Database not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            this.db.all(query, params, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rows);
+                }
+            });
+        });
+    }
+    /**
+     * 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.db) {
+            throw new Error("Database not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            this.db.run(query, params, function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve({ changes: this.changes, lastID: this.lastID });
+                }
+            });
+        });
+    }
+    /**
+     * Execute multiple SQL statements
+     * @param query SQL statements to execute
+     * @returns Promise that resolves when execution completes
+     */
+    async exec(query) {
+        if (!this.db) {
+            throw new Error("Database not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            this.db.exec(query, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                resolve();
+                return;
+            }
+            this.db.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.db = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Get database metadata
+     */
+    getMetadata() {
+        return {
+            name: "SQLite",
+            type: "sqlite",
+            path: this.dbPath
+        };
+    }
+    /**
+     * Get database-specific query for listing tables
+     */
+    getListTablesQuery() {
+        return "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'";
+    }
+    /**
+     * Get database-specific query for describing a table
+     * @param tableName Table name
+     */
+    getDescribeTableQuery(tableName) {
+        return `PRAGMA table_info(${tableName})`;
+    }
+}