@softtechai/quickmcp 1.0.8

package/dist/web/generators/MCPServerGenerator.js

@@ -0,0 +1,566 @@
+"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, selectedTables) {
+        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, selectedTables);
+                    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, selectedTables) {
+        var _this = this;
+        var tools = [];
+        console.log('🔍 generateToolsForData called with selectedTables:', selectedTables);
+        var _loop_1 = function (tableName, rows) {
+            if (!rows || rows.length === 0)
+                return "continue";
+            // Find table configuration in selectedTables
+            var tableIndex = Object.keys(parsedData).indexOf(tableName);
+            var tableConfig = selectedTables === null || selectedTables === void 0 ? void 0 : selectedTables.find(function (config) { return config.index === tableIndex; });
+            // Skip table if not selected
+            if (selectedTables && selectedTables.length > 0 && !tableConfig) {
+                console.log("\uD83D\uDD0D Skipping table ".concat(tableName, " - not selected"));
+                return "continue";
+            }
+            console.log("\uD83D\uDD0D Processing table ".concat(tableName, " with config:"), tableConfig === null || tableConfig === void 0 ? void 0 : tableConfig.tools);
+            var columns = this_1.analyzeColumns(rows);
+            var cleanTableName = this_1.sanitizeName(tableName);
+            // Get tools configuration (default all true if no config)
+            var toolsConfig = (tableConfig === null || tableConfig === void 0 ? void 0 : tableConfig.tools) || {
+                get: true, create: true, update: true, delete: true, count: true,
+                min: true, max: true, sum: true, avg: true
+            };
+            // GET tool
+            if (toolsConfig.get) {
+                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_1.generateFilterProperties(columns)),
+                        required: []
+                    },
+                    sqlQuery: this_1.generateSelectQuery(tableName, columns, dbConfig.type),
+                    operation: 'SELECT'
+                });
+            }
+            // CREATE tool
+            if (toolsConfig.create && columns.length > 0) {
+                tools.push({
+                    server_id: serverId,
+                    name: "create_".concat(cleanTableName),
+                    description: "Create a new record in ".concat(tableName, " table"),
+                    inputSchema: {
+                        type: 'object',
+                        properties: this_1.generateInputProperties(columns, true),
+                        required: columns.filter(function (col) { return !col.nullable && col.name.toLowerCase() !== 'id'; }).map(function (col) { return col.name; })
+                    },
+                    sqlQuery: this_1.generateInsertQuery(tableName, columns, dbConfig.type),
+                    operation: 'INSERT'
+                });
+            }
+            // UPDATE tool
+            if (toolsConfig.update && 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_1.generateInputProperties(columns, false)),
+                        required: ['id']
+                    },
+                    sqlQuery: this_1.generateUpdateQuery(tableName, columns, dbConfig.type),
+                    operation: 'UPDATE'
+                });
+            }
+            // DELETE tool
+            if (toolsConfig.delete && columns.some(function (col) { return col.name.toLowerCase() === 'id'; })) {
+                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_1.generateDeleteQuery(tableName, dbConfig.type),
+                    operation: 'DELETE'
+                });
+            }
+            // COUNT tool
+            if (toolsConfig.count) {
+                tools.push({
+                    server_id: serverId,
+                    name: "count_".concat(cleanTableName),
+                    description: "Get total count of records in ".concat(tableName, " table"),
+                    inputSchema: {
+                        type: 'object',
+                        properties: this_1.generateFilterProperties(columns),
+                        required: []
+                    },
+                    sqlQuery: this_1.generateCountQuery(tableName, columns, dbConfig.type),
+                    operation: 'SELECT'
+                });
+            }
+            // Get numeric columns for aggregate functions
+            //console.log(`🔍 Table ${tableName} columns:`, columns.map(col => ({ name: col.name, type: col.type })));
+            var numericColumns = columns.filter(function (col) {
+                var type = col.type.toLowerCase();
+                return type.includes('int') || type.includes('float') || type.includes('decimal') ||
+                    type.includes('numeric') || type.includes('real') || type.includes('double') ||
+                    type === 'number';
+            });
+            //console.log(`🔍 Numeric columns found in ${tableName}:`, numericColumns.map(col => ({ name: col.name, type: col.type })));
+            if (numericColumns.length > 0) {
+                // MIN tools for each numeric column
+                if (toolsConfig.min) {
+                    numericColumns.forEach(function (col) {
+                        var toolName = "min_".concat(cleanTableName, "_").concat(_this.sanitizeName(col.name));
+                        console.log("\uD83D\uDD0D Creating MIN tool: ".concat(toolName, " for column ").concat(col.name));
+                        tools.push({
+                            server_id: serverId,
+                            name: toolName,
+                            description: "Get minimum value of ".concat(col.name, " in ").concat(tableName, " table"),
+                            inputSchema: {
+                                type: 'object',
+                                properties: _this.generateFilterProperties(columns),
+                                required: []
+                            },
+                            sqlQuery: _this.generateMinQuery(tableName, col.name, columns, dbConfig.type),
+                            operation: 'SELECT'
+                        });
+                    });
+                }
+                // MAX tools for each numeric column
+                if (toolsConfig.max) {
+                    numericColumns.forEach(function (col) {
+                        var toolName = "max_".concat(cleanTableName, "_").concat(_this.sanitizeName(col.name));
+                        tools.push({
+                            server_id: serverId,
+                            name: toolName,
+                            description: "Get maximum value of ".concat(col.name, " in ").concat(tableName, " table"),
+                            inputSchema: {
+                                type: 'object',
+                                properties: _this.generateFilterProperties(columns),
+                                required: []
+                            },
+                            sqlQuery: _this.generateMaxQuery(tableName, col.name, columns, dbConfig.type),
+                            operation: 'SELECT'
+                        });
+                    });
+                }
+                // SUM tools for each numeric column
+                if (toolsConfig.sum) {
+                    numericColumns.forEach(function (col) {
+                        var toolName = "sum_".concat(cleanTableName, "_").concat(_this.sanitizeName(col.name));
+                        tools.push({
+                            server_id: serverId,
+                            name: toolName,
+                            description: "Get sum of all values of ".concat(col.name, " in ").concat(tableName, " table"),
+                            inputSchema: {
+                                type: 'object',
+                                properties: _this.generateFilterProperties(columns),
+                                required: []
+                            },
+                            sqlQuery: _this.generateSumQuery(tableName, col.name, columns, dbConfig.type),
+                            operation: 'SELECT'
+                        });
+                    });
+                }
+                // AVG tools for each numeric column
+                if (toolsConfig.avg) {
+                    numericColumns.forEach(function (col) {
+                        var toolName = "avg_".concat(cleanTableName, "_").concat(_this.sanitizeName(col.name));
+                        tools.push({
+                            server_id: serverId,
+                            name: toolName,
+                            description: "Get average value of ".concat(col.name, " in ").concat(tableName, " table"),
+                            inputSchema: {
+                                type: 'object',
+                                properties: _this.generateFilterProperties(columns),
+                                required: []
+                            },
+                            sqlQuery: _this.generateAvgQuery(tableName, col.name, columns, dbConfig.type),
+                            operation: 'SELECT'
+                        });
+                    });
+                }
+            }
+        };
+        var this_1 = this;
+        for (var _i = 0, _a = Object.entries(parsedData); _i < _a.length; _i++) {
+            var _b = _a[_i], tableName = _b[0], rows = _b[1];
+            _loop_1(tableName, rows);
+        }
+        //console.log(`🔍 Total tools created: ${tools.length}`);
+        //console.log(`🔍 Tool names:`, tools.map(tool => tool.name));
+        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_2 = 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_2(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.generateMinQuery = function (tableName, columnName, columns, dbType) {
+        var query = "SELECT MIN([".concat(columnName, "]) as min_value FROM [").concat(tableName, "]");
+        var filterableColumns = columns.filter(function (col) {
+            if (dbType === 'mssql') {
+                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.generateMaxQuery = function (tableName, columnName, columns, dbType) {
+        var query = "SELECT MAX([".concat(columnName, "]) as max_value FROM [").concat(tableName, "]");
+        var filterableColumns = columns.filter(function (col) {
+            if (dbType === 'mssql') {
+                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.generateSumQuery = function (tableName, columnName, columns, dbType) {
+        var query = "SELECT SUM([".concat(columnName, "]) as sum_value FROM [").concat(tableName, "]");
+        var filterableColumns = columns.filter(function (col) {
+            if (dbType === 'mssql') {
+                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.generateAvgQuery = function (tableName, columnName, columns, dbType) {
+        var query = "SELECT AVG(CAST([".concat(columnName, "] AS FLOAT)) as avg_value FROM [").concat(tableName, "]");
+        var filterableColumns = columns.filter(function (col) {
+            if (dbType === 'mssql') {
+                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;