mcp-db-analyzer 0.2.0 → 0.2.3

package/build/db-mysql.js

@@ -1,4 +1,5 @@
 import mysql from "mysql2/promise";
+import { getConnectionTimeoutMs } from "./db.js";
 function wrapConnectionError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     const sanitized = msg.replace(/\/\/[^@]+@/g, "//****:****@");
@@ -11,9 +12,10 @@ export function createMysqlAdapter() {
     let pool = null;
     function getPool() {
         if (!pool) {
+            const timeoutMs = getConnectionTimeoutMs();
             const uri = process.env.DATABASE_URL;
             if (uri) {
-                pool = mysql.createPool(uri);
+                pool = mysql.createPool({ uri, connectTimeout: timeoutMs });
             }
             else {
                 pool = mysql.createPool({
@@ -22,6 +24,7 @@ export function createMysqlAdapter() {
                     database: process.env.MYSQL_DATABASE || process.env.DB_NAME,
                     user: process.env.MYSQL_USER || process.env.DB_USER,
                     password: process.env.MYSQL_PASSWORD || process.env.DB_PASSWORD,
+                    connectTimeout: timeoutMs,
                 });
             }
         }

package/build/db-postgres.js

@@ -1,4 +1,5 @@
 import pg from "pg";
+import { getConnectionTimeoutMs } from "./db.js";
 const { Pool } = pg;
 function wrapConnectionError(err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -12,9 +13,14 @@ export function createPostgresAdapter() {
     let pool = null;
     function getPool() {
         if (!pool) {
+            const timeoutMs = getConnectionTimeoutMs();
             const connectionString = process.env.DATABASE_URL;
             if (connectionString) {
-                pool = new Pool({ connectionString });
+                pool = new Pool({
+                    connectionString,
+                    connectionTimeoutMillis: timeoutMs,
+                    query_timeout: timeoutMs,
+                });
             }
             else {
                 pool = new Pool({
@@ -23,6 +29,8 @@ export function createPostgresAdapter() {
                     database: process.env.PGDATABASE || "postgres",
                     user: process.env.PGUSER,
                     password: process.env.PGPASSWORD,
+                    connectionTimeoutMillis: timeoutMs,
+                    query_timeout: timeoutMs,
                 });
             }
         }

package/build/db.js

@@ -1,8 +1,15 @@
 let adapter = null;
 let driverType = "postgres";
+let connectionTimeoutMs = 30000;
 export function getDriverType() {
     return driverType;
 }
+export function getConnectionTimeoutMs() {
+    return connectionTimeoutMs;
+}
+export function setConnectionTimeoutMs(ms) {
+    connectionTimeoutMs = ms;
+}
 export function setAdapter(a) {
     adapter = a;
     driverType = a.driver;

package/build/index.js

@@ -11,11 +11,8 @@ import { analyzeSlowQueries } from "./analyzers/slow-queries.js";
 import { analyzeConnections } from "./analyzers/connections.js";
 import { analyzeTableRelationships } from "./analyzers/relationships.js";
 import { analyzeVacuum } from "./analyzers/vacuum.js";
-import { closePool, initDriver } from "./db.js";
+import { closePool, initDriver, setConnectionTimeoutMs } from "./db.js";
 import { formatToolError } from "./errors.js";
-import { validateLicense, formatUpgradePrompt } from "./license.js";
-// License check (reads MCP_LICENSE_KEY env var once at startup)
-const license = validateLicense(process.env.MCP_LICENSE_KEY, "db-analyzer");
 // Handle --help
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
     console.log(`mcp-db-analyzer v0.1.0 — MCP server for database analysis
@@ -73,6 +70,15 @@ const server = new McpServer({
     name: "mcp-db-analyzer",
     version: "0.1.0",
 });
+// Shared Zod parameter for connection timeout
+const timeoutParam = z
+    .number()
+    .optional()
+    .default(30000)
+    .describe("Connection timeout in milliseconds (default: 30000). Increase for slow or remote databases.");
+function applyTimeout(timeout_ms) {
+    setConnectionTimeoutMs(timeout_ms);
+}
 // --- Tool: inspect_schema ---
 server.tool("inspect_schema", "List all tables in a schema with row counts and sizes, or inspect a specific table's columns, types, constraints, and foreign keys.", {
     table: z
@@ -83,7 +89,9 @@ server.tool("inspect_schema", "List all tables in a schema with row counts and s
         .string()
         .default("public")
         .describe("Database schema to inspect (default: public)"),
-}, async ({ table, schema }) => {
+    timeout_ms: timeoutParam,
+}, async ({ table, schema, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = table
             ? await inspectTable(table, schema)
@@ -111,7 +119,9 @@ server.tool("analyze_indexes", "Analyze index usage statistics to find unused in
         .enum(["usage", "missing", "all"])
         .default("all")
         .describe("Analysis mode: 'usage' for unused index detection, 'missing' for missing index suggestions, 'all' for both"),
-}, async ({ schema, mode }) => {
+    timeout_ms: timeoutParam,
+}, async ({ schema, mode, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const parts = [];
         if (mode === "usage" || mode === "all") {
@@ -140,7 +150,9 @@ server.tool("explain_query", "Run EXPLAIN on a SQL query and return a formatted
         .boolean()
         .default(false)
         .describe("Run EXPLAIN ANALYZE to get actual execution times (executes the query). Only allowed for SELECT queries."),
-}, async ({ sql, analyze }) => {
+    timeout_ms: timeoutParam,
+}, async ({ sql, analyze, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await explainQuery(sql, analyze);
         return { content: [{ type: "text", text: result }] };
@@ -162,7 +174,9 @@ server.tool("analyze_table_bloat", "Analyze table bloat by checking dead tuple r
         .string()
         .default("public")
         .describe("Database schema to analyze (default: public)"),
-}, async ({ schema }) => {
+    timeout_ms: timeoutParam,
+}, async ({ schema, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await analyzeTableBloat(schema);
         return { content: [{ type: "text", text: result }] };
@@ -184,18 +198,9 @@ server.tool("suggest_missing_indexes", "Find tables with high sequential scan co
         .string()
         .default("public")
         .describe("Database schema to analyze (default: public)"),
-}, async ({ schema }) => {
-    if (!license.isPro) {
-        return {
-            content: [{
-                    type: "text",
-                    text: formatUpgradePrompt("suggest_missing_indexes", "Actionable index recommendations with:\n" +
-                        "- Tables with high sequential scan counts\n" +
-                        "- Cross-referenced unused indexes wasting space\n" +
-                        "- Ready-to-run CREATE INDEX and DROP INDEX statements"),
-                }],
-        };
-    }
+    timeout_ms: timeoutParam,
+}, async ({ schema, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await suggestMissingIndexes(schema);
         return { content: [{ type: "text", text: result }] };
@@ -221,18 +226,9 @@ server.tool("analyze_slow_queries", "Find the slowest queries using pg_stat_stat
         .number()
         .default(10)
         .describe("Number of slow queries to return (default: 10)"),
-}, async ({ schema, limit }) => {
-    if (!license.isPro) {
-        return {
-            content: [{
-                    type: "text",
-                    text: formatUpgradePrompt("analyze_slow_queries", "Slow query analysis with:\n" +
-                        "- Top queries ranked by total execution time\n" +
-                        "- Call counts, mean/max times, rows returned\n" +
-                        "- Optimization recommendations"),
-                }],
-        };
-    }
+    timeout_ms: timeoutParam,
+}, async ({ schema, limit, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await analyzeSlowQueries(schema, limit);
         return { content: [{ type: "text", text: result }] };
@@ -249,19 +245,10 @@ server.tool("analyze_slow_queries", "Find the slowest queries using pg_stat_stat
     }
 });
 // Tool 7: analyze_connections
-server.tool("analyze_connections", "Analyze active database connections. Detects idle-in-transaction sessions, long-running queries, lock contention, and connection pool utilization. PostgreSQL and MySQL only.", {}, async () => {
-    if (!license.isPro) {
-        return {
-            content: [{
-                    type: "text",
-                    text: formatUpgradePrompt("analyze_connections", "Connection analysis with:\n" +
-                        "- Idle-in-transaction session detection\n" +
-                        "- Long-running query identification\n" +
-                        "- Lock contention analysis\n" +
-                        "- Connection pool utilization metrics"),
-                }],
-        };
-    }
+server.tool("analyze_connections", "Analyze active database connections. Detects idle-in-transaction sessions, long-running queries, lock contention, and connection pool utilization. PostgreSQL and MySQL only.", {
+    timeout_ms: timeoutParam,
+}, async ({ timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await analyzeConnections();
         return { content: [{ type: "text", text: result }] };
@@ -283,19 +270,9 @@ server.tool("analyze_table_relationships", "Analyze foreign key relationships be
         .string()
         .default("public")
         .describe("Database schema to analyze (default: public)"),
-}, async ({ schema }) => {
-    if (!license.isPro) {
-        return {
-            content: [{
-                    type: "text",
-                    text: formatUpgradePrompt("analyze_table_relationships", "Table relationship analysis with:\n" +
-                        "- Foreign key dependency graph\n" +
-                        "- Orphan table detection\n" +
-                        "- Cascading delete chain analysis\n" +
-                        "- Hub entity identification"),
-                }],
-        };
-    }
+    timeout_ms: timeoutParam,
+}, async ({ schema, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await analyzeTableRelationships(schema);
         return { content: [{ type: "text", text: result }] };
@@ -317,7 +294,9 @@ server.tool("analyze_vacuum", "Analyze PostgreSQL VACUUM maintenance status. Che
         .string()
         .default("public")
         .describe("Database schema to analyze (default: public)"),
-}, async ({ schema }) => {
+    timeout_ms: timeoutParam,
+}, async ({ schema, timeout_ms }) => {
+    applyTimeout(timeout_ms);
     try {
         const result = await analyzeVacuum(schema);
         return { content: [{ type: "text", text: result }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-db-analyzer",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "MCP server for PostgreSQL, MySQL, and SQLite schema analysis, index optimization, and query plan inspection",
   "author": "Dmytro Lisnichenko",
   "type": "module",
@@ -24,16 +24,22 @@
   ],
   "keywords": [
     "mcp",
+    "mcp-server",
     "model-context-protocol",
+    "ai",
+    "claude",
+    "anthropic",
+    "database",
+    "sql",
+    "schema",
+    "database-analyzer",
+    "database-diagnostics",
     "postgresql",
     "mysql",
     "sqlite",
-    "database",
     "schema-analyzer",
     "index-optimization",
-    "query-plan",
-    "ai",
-    "claude"
+    "query-plan"
   ],
   "license": "MIT",
   "engines": {

package/build/license.js

@@ -1,114 +0,0 @@
-/**
- * License validation for MCP Migration Advisor (Pro features).
- *
- * Validates license keys offline using HMAC-SHA256.
- * Missing or invalid keys gracefully degrade to free mode — never errors.
- *
- * Key format: MCPJBS-XXXXX-XXXXX-XXXXX-XXXXX
- * Payload (12 bytes = 20 base32 chars):
- *   [0]     product mask (8 bits)
- *   [1-2]   expiry days since 2026-01-01 (16 bits)
- *   [3-5]   customer ID (24 bits)
- *   [6-11]  HMAC-SHA256 truncated (48 bits)
- */
-import { createHmac } from "node:crypto";
-const KEY_PREFIX = "MCPJBS-";
-const EPOCH = new Date("2026-01-01T00:00:00Z");
-const BASE32_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-const HMAC_SECRET = "mcp-java-backend-suite-license-v1";
-const PRODUCTS = {
-    "db-analyzer": 0,
-    "jvm-diagnostics": 1,
-    "migration-advisor": 2,
-    "spring-boot-actuator": 3,
-    "redis-diagnostics": 4,
-};
-export function validateLicense(key, product) {
-    const FREE = {
-        isPro: false,
-        expiresAt: null,
-        customerId: null,
-        reason: "No license key provided",
-    };
-    if (!key || key.trim().length === 0)
-        return FREE;
-    const trimmed = key.trim().toUpperCase();
-    if (!trimmed.startsWith(KEY_PREFIX)) {
-        return { ...FREE, reason: "Invalid key format: missing MCPJBS- prefix" };
-    }
-    const body = trimmed.slice(KEY_PREFIX.length).replace(/-/g, "");
-    if (body.length < 20) {
-        return { ...FREE, reason: "Invalid key format: too short" };
-    }
-    let decoded;
-    try {
-        decoded = base32Decode(body.slice(0, 20));
-    }
-    catch {
-        return { ...FREE, reason: "Invalid key format: bad base32 encoding" };
-    }
-    if (decoded.length < 12) {
-        return { ...FREE, reason: "Invalid key format: decoded data too short" };
-    }
-    const payload = decoded.subarray(0, 6);
-    const providedSignature = decoded.subarray(6, 12);
-    const expectedHmac = createHmac("sha256", HMAC_SECRET)
-        .update(payload)
-        .digest();
-    const expectedSignature = expectedHmac.subarray(0, 6);
-    if (!providedSignature.equals(expectedSignature)) {
-        return { ...FREE, reason: "Invalid license key: signature mismatch" };
-    }
-    const productMask = payload[0];
-    const daysSinceEpoch = (payload[1] << 8) | payload[2];
-    const customerId = (payload[3] << 16) | (payload[4] << 8) | payload[5];
-    const productBit = PRODUCTS[product];
-    if (productBit === undefined) {
-        return { ...FREE, reason: `Unknown product: ${product}` };
-    }
-    if ((productMask & (1 << productBit)) === 0) {
-        return { ...FREE, customerId, reason: `License does not include ${product}` };
-    }
-    const expiresAt = new Date(EPOCH.getTime() + daysSinceEpoch * 24 * 60 * 60 * 1000);
-    if (new Date() > expiresAt) {
-        return {
-            isPro: false,
-            expiresAt,
-            customerId,
-            reason: `License expired on ${expiresAt.toISOString().slice(0, 10)}`,
-        };
-    }
-    return { isPro: true, expiresAt, customerId, reason: "Valid Pro license" };
-}
-export function formatUpgradePrompt(toolName, featureDescription) {
-    return [
-        `## ${toolName} (Pro Feature)`,
-        "",
-        "This analysis is available with MCP Java Backend Suite Pro.",
-        "",
-        `**What you'll get:**`,
-        featureDescription,
-        "",
-        "**Upgrade**: https://mcpjbs.dev/pricing",
-        "**Price**: $19/month or $190/year",
-        "",
-        "> Already have a key? Set `MCP_LICENSE_KEY` in your Claude Desktop config.",
-    ].join("\n");
-}
-function base32Decode(encoded) {
-    const bytes = [];
-    let bits = 0;
-    let value = 0;
-    for (const char of encoded) {
-        const idx = BASE32_CHARS.indexOf(char);
-        if (idx === -1)
-            throw new Error(`Invalid base32 character: ${char}`);
-        value = (value << 5) | idx;
-        bits += 5;
-        if (bits >= 8) {
-            bits -= 8;
-            bytes.push((value >> bits) & 0xff);
-        }
-    }
-    return Buffer.from(bytes);
-}