@softtechai/quickmcp 1.0.8

package/dist/web/client/MCPTestRunner.js

@@ -0,0 +1,317 @@
+"use strict";
+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.MCPTestRunner = void 0;
+var MCPClient_1 = require("./MCPClient");
+var MCPTestRunner = /** @class */ (function () {
+    function MCPTestRunner() {
+        this.client = new MCPClient_1.MCPClient();
+    }
+    MCPTestRunner.prototype.runTestSuite = function (serverPath, testSuite) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, results, _i, _a, testCase, result, duration, passedTests, failedTests;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        startTime = Date.now();
+                        results = [];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 7, 9]);
+                        return [4 /*yield*/, this.client.connect(serverPath)];
+                    case 2:
+                        _b.sent();
+                        _i = 0, _a = testSuite.tests;
+                        _b.label = 3;
+                    case 3:
+                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                        testCase = _a[_i];
+                        return [4 /*yield*/, this.runTestCase(testCase)];
+                    case 4:
+                        result = _b.sent();
+                        results.push(result);
+                        _b.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7: return [4 /*yield*/, this.client.disconnect()];
+                    case 8:
+                        _b.sent();
+                        return [7 /*endfinally*/];
+                    case 9:
+                        duration = Date.now() - startTime;
+                        passedTests = results.filter(function (r) { return r.passed; }).length;
+                        failedTests = results.length - passedTests;
+                        return [2 /*return*/, {
+                                testSuite: testSuite,
+                                results: results,
+                                totalTests: results.length,
+                                passedTests: passedTests,
+                                failedTests: failedTests,
+                                duration: duration
+                            }];
+                }
+            });
+        });
+    };
+    MCPTestRunner.prototype.runTestCase = function (testCase) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, response, duration, passed, error_1, duration;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.testRequest(testCase.request)];
+                    case 2:
+                        response = _a.sent();
+                        duration = Date.now() - startTime;
+                        passed = this.evaluateTestResult(testCase, response);
+                        return [2 /*return*/, {
+                                testCase: testCase,
+                                response: response,
+                                passed: passed,
+                                duration: duration
+                            }];
+                    case 3:
+                        error_1 = _a.sent();
+                        duration = Date.now() - startTime;
+                        return [2 /*return*/, {
+                                testCase: testCase,
+                                response: {
+                                    success: false,
+                                    error: error_1 instanceof Error ? error_1.message : 'Unknown error'
+                                },
+                                passed: false,
+                                duration: duration,
+                                error: error_1 instanceof Error ? error_1.message : 'Unknown error'
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MCPTestRunner.prototype.generateTestSuite = function (serverPath, suiteName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tools, resources, prompts, tests, _i, tools_1, tool, _a, resources_1, resource, _b, prompts_1, prompt_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.client.connect(serverPath)];
+                    case 1:
+                        _c.sent();
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, , 6, 8]);
+                        return [4 /*yield*/, this.client.listTools()];
+                    case 3:
+                        tools = _c.sent();
+                        return [4 /*yield*/, this.client.listResources()];
+                    case 4:
+                        resources = _c.sent();
+                        return [4 /*yield*/, this.client.listPrompts()];
+                    case 5:
+                        prompts = _c.sent();
+                        tests = [];
+                        // Generate tool tests
+                        for (_i = 0, tools_1 = tools; _i < tools_1.length; _i++) {
+                            tool = tools_1[_i];
+                            tests.push({
+                                name: "Test tool: ".concat(tool.name),
+                                description: "Test the ".concat(tool.name, " tool with sample parameters"),
+                                request: {
+                                    serverId: suiteName,
+                                    method: 'tool',
+                                    name: tool.name,
+                                    params: this.generateSampleParams(tool.inputSchema)
+                                },
+                                expectedSuccess: true
+                            });
+                        }
+                        // Generate resource tests
+                        for (_a = 0, resources_1 = resources; _a < resources_1.length; _a++) {
+                            resource = resources_1[_a];
+                            tests.push({
+                                name: "Test resource: ".concat(resource.name),
+                                description: "Test reading the ".concat(resource.name, " resource"),
+                                request: {
+                                    serverId: suiteName,
+                                    method: 'resource',
+                                    name: resource.uri,
+                                },
+                                expectedSuccess: true
+                            });
+                        }
+                        // Generate prompt tests
+                        for (_b = 0, prompts_1 = prompts; _b < prompts_1.length; _b++) {
+                            prompt_1 = prompts_1[_b];
+                            tests.push({
+                                name: "Test prompt: ".concat(prompt_1.name),
+                                description: "Test the ".concat(prompt_1.name, " prompt with sample arguments"),
+                                request: {
+                                    serverId: suiteName,
+                                    method: 'prompt',
+                                    name: prompt_1.name,
+                                    params: this.generateSamplePromptArgs(prompt_1.arguments)
+                                },
+                                expectedSuccess: true
+                            });
+                        }
+                        return [2 /*return*/, {
+                                name: suiteName,
+                                description: "Auto-generated test suite for ".concat(suiteName, " MCP server"),
+                                tests: tests
+                            }];
+                    case 6: return [4 /*yield*/, this.client.disconnect()];
+                    case 7:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MCPTestRunner.prototype.evaluateTestResult = function (testCase, response) {
+        // Check expected success
+        if (testCase.expectedSuccess !== undefined && response.success !== testCase.expectedSuccess) {
+            return false;
+        }
+        // Check expected data contains
+        if (testCase.expectedDataContains && response.data) {
+            return this.dataContains(response.data, testCase.expectedDataContains);
+        }
+        // Default: test passes if no error occurred
+        return response.success;
+    };
+    MCPTestRunner.prototype.dataContains = function (actual, expected) {
+        if (typeof expected === 'string') {
+            return JSON.stringify(actual).includes(expected);
+        }
+        if (typeof expected === 'object' && expected !== null) {
+            for (var _i = 0, _a = Object.entries(expected); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], value = _b[1];
+                if (!(key in actual) || !this.dataContains(actual[key], value)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return actual === expected;
+    };
+    MCPTestRunner.prototype.generateSampleParams = function (schema) {
+        if (!schema || !schema.properties) {
+            return {};
+        }
+        var params = {};
+        for (var _i = 0, _a = Object.entries(schema.properties); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], prop = _b[1];
+            params[key] = this.generateSampleValue(prop);
+        }
+        return params;
+    };
+    MCPTestRunner.prototype.generateSamplePromptArgs = function (argumentsSchema) {
+        var args = {};
+        for (var _i = 0, _a = argumentsSchema || []; _i < _a.length; _i++) {
+            var arg = _a[_i];
+            if (arg.name) {
+                args[arg.name] = this.generateSampleValueFromDescription(arg.description);
+            }
+        }
+        return args;
+    };
+    MCPTestRunner.prototype.generateSampleValue = function (schema) {
+        var _a, _b;
+        switch (schema.type) {
+            case 'string':
+                return ((_a = schema.description) === null || _a === void 0 ? void 0 : _a.includes('query')) ? 'test query' :
+                    ((_b = schema.description) === null || _b === void 0 ? void 0 : _b.includes('name')) ? 'sample name' :
+                        'sample string';
+            case 'number':
+            case 'integer':
+                return schema.default !== undefined ? schema.default : 10;
+            case 'boolean':
+                return schema.default !== undefined ? schema.default : true;
+            case 'array':
+                return [];
+            case 'object':
+                return {};
+            default:
+                return 'sample value';
+        }
+    };
+    MCPTestRunner.prototype.generateSampleValueFromDescription = function (description) {
+        if (!description)
+            return 'sample value';
+        var lower = description.toLowerCase();
+        if (lower.includes('query') || lower.includes('search'))
+            return 'test query';
+        if (lower.includes('name'))
+            return 'sample name';
+        if (lower.includes('focus'))
+            return 'data patterns';
+        if (lower.includes('number') || lower.includes('count'))
+            return 10;
+        if (lower.includes('boolean') || lower.includes('flag'))
+            return true;
+        return 'sample value';
+    };
+    MCPTestRunner.prototype.formatTestResults = function (result) {
+        var output = "\n=== Test Suite: ".concat(result.testSuite.name, " ===\n");
+        output += "Description: ".concat(result.testSuite.description, "\n");
+        output += "Duration: ".concat(result.duration, "ms\n");
+        output += "Results: ".concat(result.passedTests, "/").concat(result.totalTests, " tests passed\n\n");
+        for (var _i = 0, _a = result.results; _i < _a.length; _i++) {
+            var testResult = _a[_i];
+            var status_1 = testResult.passed ? '✅ PASS' : '❌ FAIL';
+            output += "".concat(status_1, " ").concat(testResult.testCase.name, " (").concat(testResult.duration, "ms)\n");
+            if (!testResult.passed) {
+                output += "   Error: ".concat(testResult.error || testResult.response.error || 'Test assertion failed', "\n");
+            }
+            if (testResult.response.data) {
+                var dataPreview = JSON.stringify(testResult.response.data, null, 2).slice(0, 200);
+                output += "   Response: ".concat(dataPreview).concat(dataPreview.length >= 200 ? '...' : '', "\n");
+            }
+            output += '\n';
+        }
+        return output;
+    };
+    return MCPTestRunner;
+}());
+exports.MCPTestRunner = MCPTestRunner;

package/dist/web/database/json-manager.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONManager = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class JSONManager {
+    constructor() {
+        // Create database directory if it doesn't exist
+        const 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.json');
+        this.loadData();
+        console.error('✅ JSON database initialized:', this.dbPath);
+    }
+    loadData() {
+        if (fs_1.default.existsSync(this.dbPath)) {
+            try {
+                const jsonData = fs_1.default.readFileSync(this.dbPath, 'utf8');
+                this.data = JSON.parse(jsonData);
+            }
+            catch (error) {
+                console.error('❌ Error loading JSON database:', error);
+                this.initializeEmptyData();
+            }
+        }
+        else {
+            this.initializeEmptyData();
+        }
+    }
+    initializeEmptyData() {
+        this.data = {
+            servers: [],
+            tools: [],
+            resources: []
+        };
+        this.saveData();
+    }
+    saveData() {
+        try {
+            fs_1.default.writeFileSync(this.dbPath, JSON.stringify(this.data, null, 2));
+        }
+        catch (error) {
+            console.error('❌ Error saving JSON database:', error);
+            throw error;
+        }
+    }
+    // Server operations
+    saveServer(server) {
+        const existingIndex = this.data.servers.findIndex(s => s.id === server.id);
+        if (existingIndex >= 0) {
+            this.data.servers[existingIndex] = server;
+        }
+        else {
+            this.data.servers.push(server);
+        }
+        this.saveData();
+    }
+    getServer(serverId) {
+        return this.data.servers.find(s => s.id === serverId) || null;
+    }
+    getAllServers() {
+        return [...this.data.servers].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    deleteServer(serverId) {
+        this.data.servers = this.data.servers.filter(s => s.id !== serverId);
+        this.data.tools = this.data.tools.filter(t => t.server_id !== serverId);
+        this.data.resources = this.data.resources.filter(r => r.server_id !== serverId);
+        this.saveData();
+    }
+    // Tool operations
+    saveTools(tools) {
+        for (const tool of tools) {
+            const existingIndex = this.data.tools.findIndex(t => t.server_id === tool.server_id && t.name === tool.name);
+            if (existingIndex >= 0) {
+                this.data.tools[existingIndex] = tool;
+            }
+            else {
+                this.data.tools.push(tool);
+            }
+        }
+        this.saveData();
+    }
+    getToolsForServer(serverId) {
+        return this.data.tools.filter(t => t.server_id === serverId);
+    }
+    getAllTools() {
+        return [...this.data.tools];
+    }
+    // Resource operations
+    saveResources(resources) {
+        for (const resource of resources) {
+            const existingIndex = this.data.resources.findIndex(r => r.server_id === resource.server_id && r.name === resource.name);
+            if (existingIndex >= 0) {
+                this.data.resources[existingIndex] = resource;
+            }
+            else {
+                this.data.resources.push(resource);
+            }
+        }
+        this.saveData();
+    }
+    getResourcesForServer(serverId) {
+        return this.data.resources.filter(r => r.server_id === serverId);
+    }
+    getAllResources() {
+        return [...this.data.resources];
+    }
+    // Cleanup
+    close() {
+        // JSON manager doesn't need cleanup
+        console.error('📁 JSON manager closed');
+    }
+    // Statistics
+    getStats() {
+        return {
+            servers: this.data.servers.length,
+            tools: this.data.tools.length,
+            resources: this.data.resources.length
+        };
+    }
+}
+exports.JSONManager = JSONManager;

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

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteManager = void 0;
+var better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(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;