@softtechai/quickmcp 1.0.8

package/dist/generators/database/sqlite-manager.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteManager = void 0;
+var better_sqlite3_1 = require("better-sqlite3");
+var path_1 = require("path");
+var fs_1 = require("fs");
+var SQLiteManager = /** @class */ (function () {
+    function SQLiteManager() {
+        // Create database directory if it doesn't exist
+        var dbDir = path_1.default.join(process.cwd(), 'data');
+        if (!fs_1.default.existsSync(dbDir)) {
+            fs_1.default.mkdirSync(dbDir, { recursive: true });
+        }
+        this.dbPath = path_1.default.join(dbDir, 'quickmcp.sqlite');
+        this.db = new better_sqlite3_1.default(this.dbPath);
+        this.initializeTables();
+    }
+    SQLiteManager.prototype.initializeTables = function () {
+        // Servers table
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS servers (\n        id TEXT PRIMARY KEY,\n        name TEXT NOT NULL,\n        db_config TEXT NOT NULL,\n        created_at TEXT NOT NULL,\n        updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP\n      )\n    ");
+        // Tools table
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS tools (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        server_id TEXT NOT NULL,\n        name TEXT NOT NULL,\n        description TEXT NOT NULL,\n        input_schema TEXT NOT NULL,\n        sql_query TEXT NOT NULL,\n        operation TEXT NOT NULL CHECK (operation IN ('SELECT', 'INSERT', 'UPDATE', 'DELETE')),\n        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,\n        FOREIGN KEY (server_id) REFERENCES servers (id) ON DELETE CASCADE,\n        UNIQUE(server_id, name)\n      )\n    ");
+        // Resources table
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS resources (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        server_id TEXT NOT NULL,\n        name TEXT NOT NULL,\n        description TEXT NOT NULL,\n        uri_template TEXT NOT NULL,\n        sql_query TEXT NOT NULL,\n        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,\n        FOREIGN KEY (server_id) REFERENCES servers (id) ON DELETE CASCADE,\n        UNIQUE(server_id, name)\n      )\n    ");
+        console.error('✅ SQLite database initialized:', this.dbPath);
+    };
+    // Server operations
+    SQLiteManager.prototype.saveServer = function (server) {
+        var stmt = this.db.prepare("\n      INSERT OR REPLACE INTO servers (id, name, db_config, created_at, updated_at)\n      VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)\n    ");
+        stmt.run(server.id, server.name, JSON.stringify(server.dbConfig), server.createdAt);
+    };
+    SQLiteManager.prototype.getServer = function (serverId) {
+        var stmt = this.db.prepare('SELECT * FROM servers WHERE id = ?');
+        var row = stmt.get(serverId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            dbConfig: JSON.parse(row.db_config),
+            createdAt: row.created_at
+        };
+    };
+    SQLiteManager.prototype.getAllServers = function () {
+        var stmt = this.db.prepare('SELECT * FROM servers ORDER BY created_at DESC');
+        var rows = stmt.all();
+        return rows.map(function (row) { return ({
+            id: row.id,
+            name: row.name,
+            dbConfig: JSON.parse(row.db_config),
+            createdAt: row.created_at
+        }); });
+    };
+    SQLiteManager.prototype.deleteServer = function (serverId) {
+        var stmt = this.db.prepare('DELETE FROM servers WHERE id = ?');
+        stmt.run(serverId);
+    };
+    // Tool operations
+    SQLiteManager.prototype.saveTools = function (tools) {
+        var stmt = this.db.prepare("\n      INSERT OR REPLACE INTO tools (server_id, name, description, input_schema, sql_query, operation)\n      VALUES (?, ?, ?, ?, ?, ?)\n    ");
+        var transaction = this.db.transaction(function (tools) {
+            for (var _i = 0, tools_1 = tools; _i < tools_1.length; _i++) {
+                var tool = tools_1[_i];
+                stmt.run(tool.server_id, tool.name, tool.description, JSON.stringify(tool.inputSchema), tool.sqlQuery, tool.operation);
+            }
+        });
+        transaction(tools);
+    };
+    SQLiteManager.prototype.getToolsForServer = function (serverId) {
+        var stmt = this.db.prepare('SELECT * FROM tools WHERE server_id = ?');
+        var rows = stmt.all(serverId);
+        return rows.map(function (row) { return ({
+            server_id: row.server_id,
+            name: row.name,
+            description: row.description,
+            inputSchema: JSON.parse(row.input_schema),
+            sqlQuery: row.sql_query,
+            operation: row.operation
+        }); });
+    };
+    SQLiteManager.prototype.getAllTools = function () {
+        var stmt = this.db.prepare('SELECT * FROM tools ORDER BY server_id, name');
+        var rows = stmt.all();
+        return rows.map(function (row) { return ({
+            server_id: row.server_id,
+            name: row.name,
+            description: row.description,
+            inputSchema: JSON.parse(row.input_schema),
+            sqlQuery: row.sql_query,
+            operation: row.operation
+        }); });
+    };
+    // Resource operations
+    SQLiteManager.prototype.saveResources = function (resources) {
+        var stmt = this.db.prepare("\n      INSERT OR REPLACE INTO resources (server_id, name, description, uri_template, sql_query)\n      VALUES (?, ?, ?, ?, ?)\n    ");
+        var transaction = this.db.transaction(function (resources) {
+            for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
+                var resource = resources_1[_i];
+                stmt.run(resource.server_id, resource.name, resource.description, resource.uri_template, resource.sqlQuery);
+            }
+        });
+        transaction(resources);
+    };
+    SQLiteManager.prototype.getResourcesForServer = function (serverId) {
+        var stmt = this.db.prepare('SELECT * FROM resources WHERE server_id = ?');
+        var rows = stmt.all(serverId);
+        return rows.map(function (row) { return ({
+            server_id: row.server_id,
+            name: row.name,
+            description: row.description,
+            uri_template: row.uri_template,
+            sqlQuery: row.sql_query
+        }); });
+    };
+    SQLiteManager.prototype.getAllResources = function () {
+        var stmt = this.db.prepare('SELECT * FROM resources ORDER BY server_id, name');
+        var rows = stmt.all();
+        return rows.map(function (row) { return ({
+            server_id: row.server_id,
+            name: row.name,
+            description: row.description,
+            uri_template: row.uri_template,
+            sqlQuery: row.sql_query
+        }); });
+    };
+    // Cleanup
+    SQLiteManager.prototype.close = function () {
+        this.db.close();
+    };
+    // Statistics
+    SQLiteManager.prototype.getStats = function () {
+        var serversCount = this.db.prepare('SELECT COUNT(*) as count FROM servers').get();
+        var toolsCount = this.db.prepare('SELECT COUNT(*) as count FROM tools').get();
+        var resourcesCount = this.db.prepare('SELECT COUNT(*) as count FROM resources').get();
+        return {
+            servers: serversCount.count,
+            tools: toolsCount.count,
+            resources: resourcesCount.count
+        };
+    };
+    return SQLiteManager;
+}());
+exports.SQLiteManager = SQLiteManager;

package/dist/generators/generators/MCPServerGenerator.d.ts

@@ -0,0 +1,37 @@
+import { ServerConfig, ToolDefinition, ResourceDefinition } from '../database/sqlite-manager.js';
+interface ParsedData {
+    [tableName: string]: any[];
+}
+export declare class MCPServerGenerator {
+    private sqliteManager;
+    constructor();
+    generateServer(serverId: string, serverName: string, parsedData: ParsedData, dbConfig: any): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    private generateToolsForData;
+    private generateResourcesForData;
+    private analyzeColumns;
+    private generateFilterProperties;
+    private generateInputProperties;
+    private generateSelectQuery;
+    private generateInsertQuery;
+    private generateUpdateQuery;
+    private generateDeleteQuery;
+    private generateCountQuery;
+    private sanitizeName;
+    getAllServers(): ServerConfig[];
+    getServer(serverId: string): ServerConfig | null;
+    deleteServer(serverId: string): void;
+    getAllTools(): ToolDefinition[];
+    getToolsForServer(serverId: string): ToolDefinition[];
+    getAllResources(): ResourceDefinition[];
+    getResourcesForServer(serverId: string): ResourceDefinition[];
+    getStats(): {
+        servers: number;
+        tools: number;
+        resources: number;
+    };
+    close(): void;
+}
+export {};

package/dist/generators/generators/MCPServerGenerator.js

@@ -0,0 +1,396 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServerGenerator = void 0;
+var sqlite_manager_js_1 = require("../database/sqlite-manager.js");
+var MCPServerGenerator = /** @class */ (function () {
+    function MCPServerGenerator() {
+        this.sqliteManager = new sqlite_manager_js_1.SQLiteManager();
+    }
+    MCPServerGenerator.prototype.generateServer = function (serverId, serverName, parsedData, dbConfig) {
+        return __awaiter(this, void 0, void 0, function () {
+            var serverConfig, tools, resources;
+            return __generator(this, function (_a) {
+                try {
+                    console.log("\uD83D\uDE80 Generating virtual MCP server: ".concat(serverId));
+                    // Create server config
+                    console.log("\uD83D\uDCDD Creating server config with serverId: \"".concat(serverId, "\", serverName: \"").concat(serverName, "\""));
+                    serverConfig = {
+                        id: serverId,
+                        name: serverName,
+                        dbConfig: dbConfig,
+                        createdAt: new Date().toISOString()
+                    };
+                    console.log('📄 Server config created:', JSON.stringify(serverConfig, null, 2));
+                    // Save server to SQLite database only
+                    this.sqliteManager.saveServer(serverConfig);
+                    console.log("\u2705 Server config saved to SQLite database: ".concat(serverId));
+                    tools = this.generateToolsForData(serverId, parsedData, dbConfig);
+                    if (tools.length > 0) {
+                        this.sqliteManager.saveTools(tools);
+                        console.log("\u2705 Generated ".concat(tools.length, " tools for server ").concat(serverId));
+                    }
+                    resources = this.generateResourcesForData(serverId, parsedData, dbConfig);
+                    if (resources.length > 0) {
+                        this.sqliteManager.saveResources(resources);
+                        console.log("\u2705 Generated ".concat(resources.length, " resources for server ").concat(serverId));
+                    }
+                    return [2 /*return*/, {
+                            success: true,
+                            message: "Virtual MCP server '".concat(serverId, "' created successfully with ").concat(tools.length, " tools and ").concat(resources.length, " resources")
+                        }];
+                }
+                catch (error) {
+                    console.error("\u274C Error generating server ".concat(serverId, ":"), error);
+                    return [2 /*return*/, {
+                            success: false,
+                            message: "Failed to generate server: ".concat(error instanceof Error ? error.message : 'Unknown error')
+                        }];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    MCPServerGenerator.prototype.generateToolsForData = function (serverId, parsedData, dbConfig) {
+        var tools = [];
+        for (var _i = 0, _a = Object.entries(parsedData); _i < _a.length; _i++) {
+            var _b = _a[_i], tableName = _b[0], rows = _b[1];
+            if (!rows || rows.length === 0)
+                continue;
+            var columns = this.analyzeColumns(rows);
+            var cleanTableName = this.sanitizeName(tableName);
+            // GET tool
+            tools.push({
+                server_id: serverId,
+                name: "get_".concat(cleanTableName),
+                description: "Get records from ".concat(tableName, " table"),
+                inputSchema: {
+                    type: 'object',
+                    properties: __assign({ limit: {
+                            type: 'number',
+                            description: 'Maximum number of records to return',
+                            default: 100,
+                            minimum: 1,
+                            maximum: 1000
+                        }, offset: {
+                            type: 'number',
+                            description: 'Number of records to skip',
+                            default: 0,
+                            minimum: 0
+                        } }, this.generateFilterProperties(columns)),
+                    required: []
+                },
+                sqlQuery: this.generateSelectQuery(tableName, columns, dbConfig.type),
+                operation: 'SELECT'
+            });
+            // CREATE tool
+            tools.push({
+                server_id: serverId,
+                name: "create_".concat(cleanTableName),
+                description: "Create a new record in ".concat(tableName, " table"),
+                inputSchema: {
+                    type: 'object',
+                    properties: this.generateInputProperties(columns, true),
+                    required: columns.filter(function (col) { return !col.nullable && col.name.toLowerCase() !== 'id'; }).map(function (col) { return col.name; })
+                },
+                sqlQuery: this.generateInsertQuery(tableName, columns, dbConfig.type),
+                operation: 'INSERT'
+            });
+            // UPDATE tool
+            if (columns.some(function (col) { return col.name.toLowerCase() === 'id'; })) {
+                tools.push({
+                    server_id: serverId,
+                    name: "update_".concat(cleanTableName),
+                    description: "Update a record in ".concat(tableName, " table"),
+                    inputSchema: {
+                        type: 'object',
+                        properties: __assign({ id: {
+                                type: ['string', 'number'],
+                                description: 'ID of the record to update'
+                            } }, this.generateInputProperties(columns, false)),
+                        required: ['id']
+                    },
+                    sqlQuery: this.generateUpdateQuery(tableName, columns, dbConfig.type),
+                    operation: 'UPDATE'
+                });
+                // DELETE tool
+                tools.push({
+                    server_id: serverId,
+                    name: "delete_".concat(cleanTableName),
+                    description: "Delete a record from ".concat(tableName, " table"),
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: ['string', 'number'],
+                                description: 'ID of the record to delete'
+                            }
+                        },
+                        required: ['id']
+                    },
+                    sqlQuery: this.generateDeleteQuery(tableName, dbConfig.type),
+                    operation: 'DELETE'
+                });
+            }
+            // COUNT tool
+            tools.push({
+                server_id: serverId,
+                name: "count_".concat(cleanTableName),
+                description: "Get total count of records in ".concat(tableName, " table"),
+                inputSchema: {
+                    type: 'object',
+                    properties: this.generateFilterProperties(columns),
+                    required: []
+                },
+                sqlQuery: this.generateCountQuery(tableName, columns, dbConfig.type),
+                operation: 'SELECT'
+            });
+        }
+        return tools;
+    };
+    MCPServerGenerator.prototype.generateResourcesForData = function (serverId, parsedData, dbConfig) {
+        var resources = [];
+        for (var _i = 0, _a = Object.entries(parsedData); _i < _a.length; _i++) {
+            var _b = _a[_i], tableName = _b[0], rows = _b[1];
+            if (!rows || rows.length === 0)
+                continue;
+            var cleanTableName = this.sanitizeName(tableName);
+            resources.push({
+                server_id: serverId,
+                name: "".concat(cleanTableName, "_list"),
+                description: "List all records from ".concat(tableName, " table"),
+                uri_template: "".concat(cleanTableName, "://list"),
+                sqlQuery: this.generateSelectQuery(tableName, this.analyzeColumns(rows), dbConfig.type, false)
+            });
+        }
+        return resources;
+    };
+    MCPServerGenerator.prototype.analyzeColumns = function (rows) {
+        if (!rows || rows.length === 0)
+            return [];
+        var firstRow = rows[0];
+        var columns = [];
+        var _loop_1 = function (key, value) {
+            var type = 'string';
+            if (typeof value === 'number') {
+                type = Number.isInteger(value) ? 'integer' : 'number';
+            }
+            else if (typeof value === 'boolean') {
+                type = 'boolean';
+            }
+            else if (value instanceof Date) {
+                type = 'string'; // Dates are handled as strings in JSON
+            }
+            else if (value === null || value === undefined) {
+                // Check other rows to determine type
+                for (var i = 1; i < Math.min(rows.length, 10); i++) {
+                    var otherValue = rows[i][key];
+                    if (otherValue !== null && otherValue !== undefined) {
+                        if (typeof otherValue === 'number') {
+                            type = Number.isInteger(otherValue) ? 'integer' : 'number';
+                        }
+                        else if (typeof otherValue === 'boolean') {
+                            type = 'boolean';
+                        }
+                        break;
+                    }
+                }
+            }
+            columns.push({
+                name: key,
+                type: type,
+                nullable: rows.some(function (row) { return row[key] === null || row[key] === undefined; })
+            });
+        };
+        for (var _i = 0, _a = Object.entries(firstRow); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], value = _b[1];
+            _loop_1(key, value);
+        }
+        return columns;
+    };
+    MCPServerGenerator.prototype.generateFilterProperties = function (columns) {
+        var properties = {};
+        for (var _i = 0, columns_1 = columns; _i < columns_1.length; _i++) {
+            var column = columns_1[_i];
+            var baseType = column.type === 'integer' ? 'number' : column.type;
+            properties["filter_".concat(column.name)] = {
+                type: baseType,
+                description: "Filter by ".concat(column.name)
+            };
+        }
+        return properties;
+    };
+    MCPServerGenerator.prototype.generateInputProperties = function (columns, isCreate) {
+        var properties = {};
+        for (var _i = 0, columns_2 = columns; _i < columns_2.length; _i++) {
+            var column = columns_2[_i];
+            // Skip ID field for create operations
+            if (isCreate && column.name.toLowerCase() === 'id')
+                continue;
+            var baseType = column.type === 'integer' ? 'number' : column.type;
+            properties[column.name] = {
+                type: baseType,
+                description: "".concat(column.name, " field")
+            };
+            // For nullable fields, make them not required instead of using union types
+            if (column.nullable && !isCreate) {
+                // Optional field - will not be added to required array
+            }
+        }
+        return properties;
+    };
+    MCPServerGenerator.prototype.generateSelectQuery = function (tableName, columns, dbType, withParams) {
+        if (withParams === void 0) { withParams = true; }
+        var columnList = columns.map(function (col) { return "[".concat(col.name, "]"); }).join(', ');
+        var query = "SELECT ".concat(columnList, " FROM [").concat(tableName, "]");
+        if (withParams) {
+            // Filter out problematic columns for WHERE clause (e.g., ntext columns in SQL Server)
+            var filterableColumns = columns.filter(function (col) {
+                // For SQL Server, exclude large text columns that can't be compared
+                if (dbType === 'mssql') {
+                    // Skip columns that might be ntext, text, or image types
+                    // These are typically identified by their string type and large content
+                    return true; // We'll handle this at parameter level instead
+                }
+                return true;
+            });
+            var whereConditions = filterableColumns.map(function (col) {
+                return "(@filter_".concat(col.name, " IS NULL OR [").concat(col.name, "] = @filter_").concat(col.name, ")");
+            }).join(' AND ');
+            query += " WHERE ".concat(whereConditions);
+            // Add ORDER BY clause for consistent pagination
+            // Find the first suitable column for ordering (prefer id, created_at, or first column)
+            var orderColumn = columns.find(function (col) {
+                return col.name.toLowerCase() === 'id' ||
+                    col.name.toLowerCase().includes('created') ||
+                    col.name.toLowerCase().includes('timestamp');
+            }) || columns[0];
+            if (orderColumn) {
+                query += " ORDER BY [".concat(orderColumn.name, "]");
+            }
+            if (dbType === 'mssql') {
+                // Use OFFSET/FETCH for proper pagination with ORDER BY
+                query += ' OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY';
+            }
+            else {
+                query += ' LIMIT @limit OFFSET @offset';
+            }
+        }
+        return query;
+    };
+    MCPServerGenerator.prototype.generateInsertQuery = function (tableName, columns, dbType) {
+        var insertColumns = columns.filter(function (col) { return col.name.toLowerCase() !== 'id'; });
+        var columnNames = insertColumns.map(function (col) { return "[".concat(col.name, "]"); }).join(', ');
+        var paramNames = insertColumns.map(function (col) { return "@".concat(col.name); }).join(', ');
+        return "INSERT INTO [".concat(tableName, "] (").concat(columnNames, ") VALUES (").concat(paramNames, ")");
+    };
+    MCPServerGenerator.prototype.generateUpdateQuery = function (tableName, columns, dbType) {
+        var updateColumns = columns.filter(function (col) { return col.name.toLowerCase() !== 'id'; });
+        var setClause = updateColumns.map(function (col) { return "[".concat(col.name, "] = @").concat(col.name); }).join(', ');
+        return "UPDATE [".concat(tableName, "] SET ").concat(setClause, " WHERE [Id] = @id");
+    };
+    MCPServerGenerator.prototype.generateDeleteQuery = function (tableName, dbType) {
+        return "DELETE FROM [".concat(tableName, "] WHERE [Id] = @id");
+    };
+    MCPServerGenerator.prototype.generateCountQuery = function (tableName, columns, dbType) {
+        var query = "SELECT COUNT(*) as total_count FROM [".concat(tableName, "]");
+        // Filter out problematic columns for WHERE clause (e.g., ntext columns in SQL Server)
+        var filterableColumns = columns.filter(function (col) {
+            // For SQL Server, exclude large text columns that can't be compared
+            if (dbType === 'mssql') {
+                // Skip columns that might be ntext, text, or image types
+                // These are typically identified by their string type and large content
+                return true; // We'll handle this at parameter level instead
+            }
+            return true;
+        });
+        var whereConditions = filterableColumns.map(function (col) {
+            return "(@filter_".concat(col.name, " IS NULL OR [").concat(col.name, "] = @filter_").concat(col.name, ")");
+        }).join(' AND ');
+        query += " WHERE ".concat(whereConditions);
+        return query;
+    };
+    MCPServerGenerator.prototype.sanitizeName = function (name) {
+        return name.toLowerCase()
+            .replace(/[^a-z0-9]/g, '_')
+            .replace(/_{2,}/g, '_')
+            .replace(/^_|_$/g, '');
+    };
+    // Public methods for management
+    MCPServerGenerator.prototype.getAllServers = function () {
+        return this.sqliteManager.getAllServers();
+    };
+    MCPServerGenerator.prototype.getServer = function (serverId) {
+        return this.sqliteManager.getServer(serverId);
+    };
+    MCPServerGenerator.prototype.deleteServer = function (serverId) {
+        this.sqliteManager.deleteServer(serverId);
+        console.log("\uD83D\uDDD1\uFE0F Deleted server from SQLite database: ".concat(serverId));
+    };
+    MCPServerGenerator.prototype.getAllTools = function () {
+        return this.sqliteManager.getAllTools();
+    };
+    MCPServerGenerator.prototype.getToolsForServer = function (serverId) {
+        return this.sqliteManager.getToolsForServer(serverId);
+    };
+    MCPServerGenerator.prototype.getAllResources = function () {
+        return this.sqliteManager.getAllResources();
+    };
+    MCPServerGenerator.prototype.getResourcesForServer = function (serverId) {
+        return this.sqliteManager.getResourcesForServer(serverId);
+    };
+    MCPServerGenerator.prototype.getStats = function () {
+        return this.sqliteManager.getStats();
+    };
+    MCPServerGenerator.prototype.close = function () {
+        this.sqliteManager.close();
+    };
+    return MCPServerGenerator;
+}());
+exports.MCPServerGenerator = MCPServerGenerator;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import './web/server';
+export * from './types';
+export * from './parsers';
+export * from './generators/MCPServerGenerator';
+export * from './client/MCPClient';
+export * from './client/MCPTestRunner';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,iCAAiC,CAAC;AAChD,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./web/server");
+__exportStar(require("./types"), exports);
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./generators/MCPServerGenerator"), exports);
+__exportStar(require("./client/MCPClient"), exports);
+__exportStar(require("./client/MCPTestRunner"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wBAAsB;AAEtB,0CAAwB;AACxB,4CAA0B;AAC1B,kEAAgD;AAChD,qDAAmC;AACnC,yDAAuC"}

package/dist/integrated-mcp-server-new.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export declare class IntegratedMCPServer {
+    private server;
+    private app;
+    private executor;
+    constructor();
+    private setupHandlers;
+    private setupWebRoutes;
+    start(port?: number): Promise<void>;
+    private cleanup;
+}
+//# sourceMappingURL=integrated-mcp-server-new.d.ts.map

package/dist/integrated-mcp-server-new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrated-mcp-server-new.d.ts","sourceRoot":"","sources":["../src/integrated-mcp-server-new.ts"],"names":[],"mappings":";AAgBA,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,GAAG,CAAsB;IACjC,OAAO,CAAC,QAAQ,CAAqB;;IAiBrC,OAAO,CAAC,aAAa;IAkFrB,OAAO,CAAC,cAAc;IA8IhB,KAAK,CAAC,IAAI,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;YA6BjC,OAAO;CAStB"}