@bytebase/dbhub 0.12.0 → 0.13.1

package/dist/index.js

@@ -1,262 +1,28 @@
 #!/usr/bin/env node
+import {
+  BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_SEARCH_OBJECTS,
+  ConnectorManager,
+  ConnectorRegistry,
+  SafeURL,
+  buildDSNFromSource,
+  getDatabaseTypeFromDSN,
+  getDefaultPortForType,
+  getToolRegistry,
+  isDemoMode,
+  mapArgumentsToArray,
+  obfuscateDSNPassword,
+  parseConnectionInfoFromDSN,
+  redactDSN,
+  resolvePort,
+  resolveSourceConfigs,
+  resolveTransport,
+  stripCommentsAndStrings
+} from "./chunk-KBVJEDZF.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
 
-// src/connectors/interface.ts
-var _ConnectorRegistry = class _ConnectorRegistry {
-  /**
-   * Register a new connector
-   */
-  static register(connector) {
-    _ConnectorRegistry.connectors.set(connector.id, connector);
-  }
-  /**
-   * Get a connector by ID
-   */
-  static getConnector(id) {
-    return _ConnectorRegistry.connectors.get(id) || null;
-  }
-  /**
-   * Get connector for a DSN string
-   * Tries to find a connector that can handle the given DSN format
-   */
-  static getConnectorForDSN(dsn) {
-    for (const connector of _ConnectorRegistry.connectors.values()) {
-      if (connector.dsnParser.isValidDSN(dsn)) {
-        return connector;
-      }
-    }
-    return null;
-  }
-  /**
-   * Get all available connector IDs
-   */
-  static getAvailableConnectors() {
-    return Array.from(_ConnectorRegistry.connectors.keys());
-  }
-  /**
-   * Get sample DSN for a specific connector
-   */
-  static getSampleDSN(connectorType) {
-    const connector = _ConnectorRegistry.getConnector(connectorType);
-    if (!connector) return null;
-    return connector.dsnParser.getSampleDSN();
-  }
-  /**
-   * Get all available sample DSNs
-   */
-  static getAllSampleDSNs() {
-    const samples = {};
-    for (const [id, connector] of _ConnectorRegistry.connectors.entries()) {
-      samples[id] = connector.dsnParser.getSampleDSN();
-    }
-    return samples;
-  }
-};
-_ConnectorRegistry.connectors = /* @__PURE__ */ new Map();
-var ConnectorRegistry = _ConnectorRegistry;
-
-// src/utils/safe-url.ts
-var SafeURL = class {
-  /**
-   * Parse a URL and handle special characters in passwords
-   * This is a safe alternative to the URL constructor
-   * 
-   * @param urlString - The DSN string to parse
-   */
-  constructor(urlString) {
-    this.protocol = "";
-    this.hostname = "";
-    this.port = "";
-    this.pathname = "";
-    this.username = "";
-    this.password = "";
-    this.searchParams = /* @__PURE__ */ new Map();
-    if (!urlString || urlString.trim() === "") {
-      throw new Error("URL string cannot be empty");
-    }
-    try {
-      const protocolSeparator = urlString.indexOf("://");
-      if (protocolSeparator !== -1) {
-        this.protocol = urlString.substring(0, protocolSeparator + 1);
-        urlString = urlString.substring(protocolSeparator + 3);
-      } else {
-        throw new Error('Invalid URL format: missing protocol (e.g., "mysql://")');
-      }
-      const questionMarkIndex = urlString.indexOf("?");
-      let queryParams = "";
-      if (questionMarkIndex !== -1) {
-        queryParams = urlString.substring(questionMarkIndex + 1);
-        urlString = urlString.substring(0, questionMarkIndex);
-        queryParams.split("&").forEach((pair) => {
-          const parts = pair.split("=");
-          if (parts.length === 2 && parts[0] && parts[1]) {
-            this.searchParams.set(parts[0], decodeURIComponent(parts[1]));
-          }
-        });
-      }
-      const atIndex = urlString.indexOf("@");
-      if (atIndex !== -1) {
-        const auth = urlString.substring(0, atIndex);
-        urlString = urlString.substring(atIndex + 1);
-        const colonIndex2 = auth.indexOf(":");
-        if (colonIndex2 !== -1) {
-          this.username = auth.substring(0, colonIndex2);
-          this.password = auth.substring(colonIndex2 + 1);
-          this.username = decodeURIComponent(this.username);
-          this.password = decodeURIComponent(this.password);
-        } else {
-          this.username = auth;
-        }
-      }
-      const pathSeparatorIndex = urlString.indexOf("/");
-      if (pathSeparatorIndex !== -1) {
-        this.pathname = urlString.substring(pathSeparatorIndex);
-        urlString = urlString.substring(0, pathSeparatorIndex);
-      }
-      const colonIndex = urlString.indexOf(":");
-      if (colonIndex !== -1) {
-        this.hostname = urlString.substring(0, colonIndex);
-        this.port = urlString.substring(colonIndex + 1);
-      } else {
-        this.hostname = urlString;
-      }
-      if (this.protocol === "") {
-        throw new Error("Invalid URL: protocol is required");
-      }
-    } catch (error) {
-      throw new Error(`Failed to parse URL: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  /**
-   * Helper method to safely get a parameter from query string
-   * 
-   * @param name - The parameter name to retrieve
-   * @returns The parameter value or null if not found
-   */
-  getSearchParam(name) {
-    return this.searchParams.has(name) ? this.searchParams.get(name) : null;
-  }
-  /**
-   * Helper method to iterate over all parameters
-   * 
-   * @param callback - Function to call for each parameter
-   */
-  forEachSearchParam(callback) {
-    this.searchParams.forEach((value, key) => callback(value, key));
-  }
-};
-
-// src/utils/dsn-obfuscate.ts
-function parseConnectionInfoFromDSN(dsn) {
-  if (!dsn) {
-    return null;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (typeof type === "undefined") {
-      return null;
-    }
-    if (type === "sqlite") {
-      const prefix = "sqlite:///";
-      if (dsn.length > prefix.length) {
-        const rawPath = dsn.substring(prefix.length);
-        const firstChar = rawPath[0];
-        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
-        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
-        return {
-          type,
-          database: isSpecialPath ? rawPath : "/" + rawPath
-        };
-      }
-      return { type };
-    }
-    const url = new SafeURL(dsn);
-    const info = { type };
-    if (url.hostname) {
-      info.host = url.hostname;
-    }
-    if (url.port) {
-      info.port = parseInt(url.port, 10);
-    }
-    if (url.pathname && url.pathname.length > 1) {
-      info.database = url.pathname.substring(1);
-    }
-    if (url.username) {
-      info.user = url.username;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function obfuscateDSNPassword(dsn) {
-  if (!dsn) {
-    return dsn;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (type === "sqlite") {
-      return dsn;
-    }
-    const url = new SafeURL(dsn);
-    if (!url.password) {
-      return dsn;
-    }
-    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
-    const protocol = dsn.split(":")[0];
-    let result;
-    if (url.username) {
-      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
-    } else {
-      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
-    }
-    if (url.port) {
-      result += `:${url.port}`;
-    }
-    result += url.pathname;
-    if (url.searchParams.size > 0) {
-      const params = [];
-      url.forEachSearchParam((value, key) => {
-        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-      });
-      result += `?${params.join("&")}`;
-    }
-    return result;
-  } catch {
-    return dsn;
-  }
-}
-function getDatabaseTypeFromDSN(dsn) {
-  if (!dsn) {
-    return void 0;
-  }
-  const protocol = dsn.split(":")[0];
-  return protocolToConnectorType(protocol);
-}
-function protocolToConnectorType(protocol) {
-  const mapping = {
-    "postgres": "postgres",
-    "postgresql": "postgres",
-    "mysql": "mysql",
-    "mariadb": "mariadb",
-    "sqlserver": "sqlserver",
-    "sqlite": "sqlite"
-  };
-  return mapping[protocol];
-}
-function getDefaultPortForType(type) {
-  const ports = {
-    "postgres": 5432,
-    "mysql": 3306,
-    "mariadb": 3306,
-    "sqlserver": 1433,
-    "sqlite": void 0
-  };
-  return ports[type];
-}
-
 // src/utils/sql-row-limiter.ts
 var SQLRowLimiter = class {
   /**
@@ -268,34 +34,42 @@ var SQLRowLimiter = class {
     return trimmed.startsWith("select");
   }
   /**
-   * Check if a SQL statement already has a LIMIT clause
+   * Check if a SQL statement already has a LIMIT clause.
+   * Strips comments and string literals first to avoid false positives.
    */
   static hasLimitClause(sql2) {
-    const limitRegex = /\blimit\s+\d+/i;
-    return limitRegex.test(sql2);
+    const cleanedSQL = stripCommentsAndStrings(sql2);
+    const limitRegex = /\blimit\s+(?:\d+|\$\d+|\?|@p\d+)/i;
+    return limitRegex.test(cleanedSQL);
   }
   /**
-   * Check if a SQL statement already has a TOP clause (SQL Server)
+   * Check if a SQL statement already has a TOP clause (SQL Server).
+   * Strips comments and string literals first to avoid false positives.
    */
   static hasTopClause(sql2) {
+    const cleanedSQL = stripCommentsAndStrings(sql2);
     const topRegex = /\bselect\s+top\s+\d+/i;
-    return topRegex.test(sql2);
+    return topRegex.test(cleanedSQL);
   }
   /**
-   * Extract existing LIMIT value from SQL if present
+   * Extract existing LIMIT value from SQL if present.
+   * Strips comments and string literals first to avoid false positives.
    */
   static extractLimitValue(sql2) {
-    const limitMatch = sql2.match(/\blimit\s+(\d+)/i);
+    const cleanedSQL = stripCommentsAndStrings(sql2);
+    const limitMatch = cleanedSQL.match(/\blimit\s+(\d+)/i);
     if (limitMatch) {
       return parseInt(limitMatch[1], 10);
     }
     return null;
   }
   /**
-   * Extract existing TOP value from SQL if present (SQL Server)
+   * Extract existing TOP value from SQL if present (SQL Server).
+   * Strips comments and string literals first to avoid false positives.
    */
   static extractTopValue(sql2) {
-    const topMatch = sql2.match(/\bselect\s+top\s+(\d+)/i);
+    const cleanedSQL = stripCommentsAndStrings(sql2);
+    const topMatch = cleanedSQL.match(/\bselect\s+top\s+(\d+)/i);
     if (topMatch) {
       return parseInt(topMatch[1], 10);
     }
@@ -328,13 +102,34 @@ var SQLRowLimiter = class {
       return sql2.replace(/\bselect\s+/i, `SELECT TOP ${maxRows} `);
     }
   }
+  /**
+   * Check if a LIMIT clause uses a parameter placeholder (not a literal number).
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static hasParameterizedLimit(sql2) {
+    const cleanedSQL = stripCommentsAndStrings(sql2);
+    const parameterizedLimitRegex = /\blimit\s+(?:\$\d+|\?|@p\d+)/i;
+    return parameterizedLimitRegex.test(cleanedSQL);
+  }
   /**
    * Apply maxRows limit to a SELECT query only
+   *
+   * This method is used by PostgreSQL, MySQL, MariaDB, and SQLite connectors which all support
+   * the LIMIT clause syntax. SQL Server uses applyMaxRowsForSQLServer() instead with TOP syntax.
+   *
+   * For parameterized LIMIT clauses (e.g., LIMIT $1 or LIMIT ?), we wrap the query in a subquery
+   * to enforce max_rows as a hard cap, since the parameter value is not known until runtime.
    */
   static applyMaxRows(sql2, maxRows) {
     if (!maxRows || !this.isSelectQuery(sql2)) {
       return sql2;
     }
+    if (this.hasParameterizedLimit(sql2)) {
+      const trimmed = sql2.trim();
+      const hasSemicolon = trimmed.endsWith(";");
+      const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
+      return `SELECT * FROM (${sqlWithoutSemicolon}) AS subq LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+    }
     return this.applyLimitToQuery(sql2, maxRows);
   }
   /**
@@ -410,6 +205,11 @@ var PostgresConnector = class _PostgresConnector {
     this.name = "PostgreSQL";
     this.dsnParser = new PostgresDSNParser();
     this.pool = null;
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
   }
   clone() {
     return new _PostgresConnector();
@@ -422,7 +222,6 @@ var PostgresConnector = class _PostgresConnector {
       }
       this.pool = new Pool(poolConfig);
       const client = await this.pool.connect();
-      console.error("Successfully connected to PostgreSQL database");
       client.release();
     } catch (err) {
       console.error("Failed to connect to PostgreSQL database:", err);
@@ -667,7 +466,7 @@ var PostgresConnector = class _PostgresConnector {
       client.release();
     }
   }
-  async executeSQL(sql2, options) {
+  async executeSQL(sql2, options, parameters) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
@@ -676,8 +475,21 @@ var PostgresConnector = class _PostgresConnector {
       const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
       if (statements.length === 1) {
         const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
+        if (parameters && parameters.length > 0) {
+          try {
+            return await client.query(processedStatement, parameters);
+          } catch (error) {
+            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
+            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
+            console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+            throw error;
+          }
+        }
         return await client.query(processedStatement);
       } else {
+        if (parameters && parameters.length > 0) {
+          throw new Error("Parameters are not supported for multi-statement queries in PostgreSQL");
+        }
         let allRows = [];
         await client.query("BEGIN");
         try {
@@ -800,6 +612,11 @@ var SQLServerConnector = class _SQLServerConnector {
     this.id = "sqlserver";
     this.name = "SQL Server";
     this.dsnParser = new SQLServerDSNParser();
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
   }
   clone() {
     return new _SQLServerConnector();
@@ -1042,16 +859,49 @@ var SQLServerConnector = class _SQLServerConnector {
       throw new Error(`Failed to get stored procedure details: ${error.message}`);
     }
   }
-  async executeSQL(sql2, options) {
+  async executeSQL(sqlQuery, options, parameters) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
-      let processedSQL = sql2;
+      let processedSQL = sqlQuery;
       if (options.maxRows) {
-        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sql2, options.maxRows);
+        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
+      }
+      const request = this.connection.request();
+      if (parameters && parameters.length > 0) {
+        parameters.forEach((param, index) => {
+          const paramName = `p${index + 1}`;
+          if (typeof param === "string") {
+            request.input(paramName, sql.VarChar, param);
+          } else if (typeof param === "number") {
+            if (Number.isInteger(param)) {
+              request.input(paramName, sql.Int, param);
+            } else {
+              request.input(paramName, sql.Float, param);
+            }
+          } else if (typeof param === "boolean") {
+            request.input(paramName, sql.Bit, param);
+          } else if (param === null || param === void 0) {
+            request.input(paramName, sql.VarChar, param);
+          } else if (Array.isArray(param)) {
+            request.input(paramName, sql.VarChar, JSON.stringify(param));
+          } else {
+            request.input(paramName, sql.VarChar, JSON.stringify(param));
+          }
+        });
+      }
+      let result;
+      try {
+        result = await request.query(processedSQL);
+      } catch (error) {
+        if (parameters && parameters.length > 0) {
+          console.error(`[SQL Server executeSQL] ERROR: ${error.message}`);
+          console.error(`[SQL Server executeSQL] SQL: ${processedSQL}`);
+          console.error(`[SQL Server executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+        }
+        throw error;
       }
-      const result = await this.connection.request().query(processedSQL);
       return {
         rows: result.recordset || [],
         fields: result.recordset && result.recordset.length > 0 ? Object.keys(result.recordset[0]).map((key) => ({
@@ -1151,8 +1001,13 @@ var SQLiteConnector = class _SQLiteConnector {
     this.dsnParser = new SQLiteDSNParser();
     this.db = null;
     this.dbPath = ":memory:";
+    // Default to in-memory database
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
   }
-  // Default to in-memory database
   clone() {
     return new _SQLiteConnector();
   }
@@ -1170,10 +1025,8 @@ var SQLiteConnector = class _SQLiteConnector {
         dbOptions.readonly = true;
       }
       this.db = new Database(this.dbPath, dbOptions);
-      console.error("Successfully connected to SQLite database");
       if (initScript) {
         this.db.exec(initScript);
-        console.error("Successfully initialized database with script");
       }
     } catch (error) {
       console.error("Failed to connect to SQLite database:", error);
@@ -1320,7 +1173,7 @@ var SQLiteConnector = class _SQLiteConnector {
       "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
     );
   }
-  async executeSQL(sql2, options) {
+  async executeSQL(sql2, options, parameters) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -1334,13 +1187,39 @@ var SQLiteConnector = class _SQLiteConnector {
           processedStatement = SQLRowLimiter.applyMaxRows(processedStatement, options.maxRows);
         }
         if (isReadStatement) {
-          const rows = this.db.prepare(processedStatement).all();
-          return { rows };
+          if (parameters && parameters.length > 0) {
+            try {
+              const rows = this.db.prepare(processedStatement).all(...parameters);
+              return { rows };
+            } catch (error) {
+              console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
+              console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
+              console.error(`[SQLite executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+              throw error;
+            }
+          } else {
+            const rows = this.db.prepare(processedStatement).all();
+            return { rows };
+          }
         } else {
-          this.db.prepare(processedStatement).run();
+          if (parameters && parameters.length > 0) {
+            try {
+              this.db.prepare(processedStatement).run(...parameters);
+            } catch (error) {
+              console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
+              console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
+              console.error(`[SQLite executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+              throw error;
+            }
+          } else {
+            this.db.prepare(processedStatement).run();
+          }
           return { rows: [] };
         }
       } else {
+        if (parameters && parameters.length > 0) {
+          throw new Error("Parameters are not supported for multi-statement queries in SQLite");
+        }
         const readStatements = [];
         const writeStatements = [];
         for (const statement of statements) {
@@ -1472,6 +1351,11 @@ var MySQLConnector = class _MySQLConnector {
     this.name = "MySQL";
     this.dsnParser = new MySQLDSNParser();
     this.pool = null;
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
   }
   clone() {
     return new _MySQLConnector();
@@ -1481,7 +1365,6 @@ var MySQLConnector = class _MySQLConnector {
       const connectionOptions = await this.dsnParser.parse(dsn, config);
       this.pool = mysql.createPool(connectionOptions);
       const [rows] = await this.pool.query("SELECT 1");
-      console.error("Successfully connected to MySQL database");
     } catch (err) {
       console.error("Failed to connect to MySQL database:", err);
       throw err;
@@ -1763,7 +1646,7 @@ var MySQLConnector = class _MySQLConnector {
     const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeSQL(sql2, options) {
+  async executeSQL(sql2, options, parameters) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
@@ -1780,7 +1663,19 @@ var MySQLConnector = class _MySQLConnector {
           processedSQL += ";";
         }
       }
-      const results = await conn.query(processedSQL);
+      let results;
+      if (parameters && parameters.length > 0) {
+        try {
+          results = await conn.query(processedSQL, parameters);
+        } catch (error) {
+          console.error(`[MySQL executeSQL] ERROR: ${error.message}`);
+          console.error(`[MySQL executeSQL] SQL: ${processedSQL}`);
+          console.error(`[MySQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+          throw error;
+        }
+      } else {
+        results = await conn.query(processedSQL);
+      }
       const [firstResult] = results;
       const rows = parseQueryResults(firstResult);
       return { rows };
@@ -1859,6 +1754,11 @@ var MariaDBConnector = class _MariaDBConnector {
     this.name = "MariaDB";
     this.dsnParser = new MariadbDSNParser();
     this.pool = null;
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
   }
   clone() {
     return new _MariaDBConnector();
@@ -1867,9 +1767,7 @@ var MariaDBConnector = class _MariaDBConnector {
     try {
       const connectionConfig = await this.dsnParser.parse(dsn, config);
       this.pool = mariadb.createPool(connectionConfig);
-      console.error("Testing connection to MariaDB...");
       await this.pool.query("SELECT 1");
-      console.error("Successfully connected to MariaDB database");
     } catch (err) {
       console.error("Failed to connect to MariaDB database:", err);
       throw err;
@@ -2151,7 +2049,7 @@ var MariaDBConnector = class _MariaDBConnector {
     const rows = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeSQL(sql2, options) {
+  async executeSQL(sql2, options, parameters) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
@@ -2168,7 +2066,19 @@ var MariaDBConnector = class _MariaDBConnector {
           processedSQL += ";";
         }
       }
-      const results = await conn.query(processedSQL);
+      let results;
+      if (parameters && parameters.length > 0) {
+        try {
+          results = await conn.query(processedSQL, parameters);
+        } catch (error) {
+          console.error(`[MariaDB executeSQL] ERROR: ${error.message}`);
+          console.error(`[MariaDB executeSQL] SQL: ${processedSQL}`);
+          console.error(`[MariaDB executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+          throw error;
+        }
+      } else {
+        results = await conn.query(processedSQL);
+      }
       const rows = parseQueryResults(results);
       return { rows };
     } catch (error) {
@@ -2183,1530 +2093,132 @@ var mariadbConnector = new MariaDBConnector();
 ConnectorRegistry.register(mariadbConnector);
 
 // src/server.ts
-import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import express from "express";
-import path3 from "path";
-import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/utils/ssh-tunnel.ts
-import { Client } from "ssh2";
+import path from "path";
 import { readFileSync } from "fs";
-import { createServer } from "net";
-var SSHTunnel = class {
-  constructor() {
-    this.sshClient = null;
-    this.localServer = null;
-    this.tunnelInfo = null;
-    this.isConnected = false;
+import { fileURLToPath } from "url";
+
+// src/tools/execute-sql.ts
+import { z } from "zod";
+
+// src/utils/response-formatter.ts
+function bigIntReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
   }
-  /**
-   * Establish an SSH tunnel
-   * @param config SSH connection configuration
-   * @param options Tunnel options including target host and port
-   * @returns Promise resolving to tunnel information including local port
-   */
-  async establish(config, options) {
-    if (this.isConnected) {
-      throw new Error("SSH tunnel is already established");
-    }
-    return new Promise((resolve, reject) => {
-      this.sshClient = new Client();
-      const sshConfig = {
-        host: config.host,
-        port: config.port || 22,
-        username: config.username
-      };
-      if (config.password) {
-        sshConfig.password = config.password;
-      } else if (config.privateKey) {
-        try {
-          const privateKey = readFileSync(config.privateKey);
-          sshConfig.privateKey = privateKey;
-          if (config.passphrase) {
-            sshConfig.passphrase = config.passphrase;
-          }
-        } catch (error) {
-          reject(new Error(`Failed to read private key file: ${error instanceof Error ? error.message : String(error)}`));
-          return;
-        }
-      } else {
-        reject(new Error("Either password or privateKey must be provided for SSH authentication"));
-        return;
+  return value;
+}
+function formatSuccessResponse(data, meta = {}) {
+  return {
+    success: true,
+    data,
+    ...Object.keys(meta).length > 0 ? { meta } : {}
+  };
+}
+function formatErrorResponse(error, code = "ERROR", details) {
+  return {
+    success: false,
+    error,
+    code,
+    ...details ? { details } : {}
+  };
+}
+function createToolErrorResponse(error, code = "ERROR", details) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(formatErrorResponse(error, code, details), bigIntReplacer, 2),
+        mimeType: "application/json"
       }
-      this.sshClient.on("error", (err) => {
-        this.cleanup();
-        reject(new Error(`SSH connection error: ${err.message}`));
-      });
-      this.sshClient.on("ready", () => {
-        console.error("SSH connection established");
-        this.localServer = createServer((localSocket) => {
-          this.sshClient.forwardOut(
-            "127.0.0.1",
-            0,
-            options.targetHost,
-            options.targetPort,
-            (err, stream) => {
-              if (err) {
-                console.error("SSH forward error:", err);
-                localSocket.end();
-                return;
-              }
-              localSocket.pipe(stream).pipe(localSocket);
-              stream.on("error", (err2) => {
-                console.error("SSH stream error:", err2);
-                localSocket.end();
-              });
-              localSocket.on("error", (err2) => {
-                console.error("Local socket error:", err2);
-                stream.end();
-              });
-            }
-          );
-        });
-        const localPort = options.localPort || 0;
-        this.localServer.listen(localPort, "127.0.0.1", () => {
-          const address = this.localServer.address();
-          if (!address || typeof address === "string") {
-            this.cleanup();
-            reject(new Error("Failed to get local server address"));
-            return;
-          }
-          this.tunnelInfo = {
-            localPort: address.port,
-            targetHost: options.targetHost,
-            targetPort: options.targetPort
-          };
-          this.isConnected = true;
-          console.error(`SSH tunnel established: localhost:${address.port} -> ${options.targetHost}:${options.targetPort}`);
-          resolve(this.tunnelInfo);
-        });
-        this.localServer.on("error", (err) => {
-          this.cleanup();
-          reject(new Error(`Local server error: ${err.message}`));
-        });
-      });
-      this.sshClient.connect(sshConfig);
-    });
+    ],
+    isError: true
+  };
+}
+function createToolSuccessResponse(data, meta = {}) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(formatSuccessResponse(data, meta), bigIntReplacer, 2),
+        mimeType: "application/json"
+      }
+    ]
+  };
+}
+
+// src/utils/allowed-keywords.ts
+var allowedKeywords = {
+  postgres: ["select", "with", "explain", "analyze", "show"],
+  mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
+  mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
+  sqlite: ["select", "with", "explain", "analyze", "pragma"],
+  sqlserver: ["select", "with", "explain", "showplan"]
+};
+function isReadOnlySQL(sql2, connectorType) {
+  const cleanedSQL = stripCommentsAndStrings(sql2).trim().toLowerCase();
+  if (!cleanedSQL) {
+    return true;
+  }
+  const firstWord = cleanedSQL.split(/\s+/)[0];
+  const keywordList = allowedKeywords[connectorType] || [];
+  return keywordList.includes(firstWord);
+}
+
+// src/requests/store.ts
+var RequestStore = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.maxPerSource = 100;
   }
   /**
-   * Close the SSH tunnel and clean up resources
+   * Add a request to the store
+   * Evicts oldest entry if at capacity
    */
-  async close() {
-    if (!this.isConnected) {
-      return;
+  add(request) {
+    const requests = this.store.get(request.sourceId) ?? [];
+    requests.push(request);
+    if (requests.length > this.maxPerSource) {
+      requests.shift();
     }
-    return new Promise((resolve) => {
-      this.cleanup();
-      this.isConnected = false;
-      console.error("SSH tunnel closed");
-      resolve();
-    });
+    this.store.set(request.sourceId, requests);
   }
   /**
-   * Clean up resources
+   * Get requests, optionally filtered by source
+   * Returns newest first
    */
-  cleanup() {
-    if (this.localServer) {
-      this.localServer.close();
-      this.localServer = null;
-    }
-    if (this.sshClient) {
-      this.sshClient.end();
-      this.sshClient = null;
+  getAll(sourceId) {
+    let requests;
+    if (sourceId) {
+      requests = [...this.store.get(sourceId) ?? []];
+    } else {
+      requests = Array.from(this.store.values()).flat();
     }
-    this.tunnelInfo = null;
+    return requests.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
   }
   /**
-   * Get current tunnel information
+   * Get total count of requests across all sources
    */
-  getTunnelInfo() {
-    return this.tunnelInfo;
+  getTotal() {
+    return Array.from(this.store.values()).reduce((sum, arr) => sum + arr.length, 0);
   }
   /**
-   * Check if tunnel is connected
+   * Clear all requests (useful for testing)
    */
-  getIsConnected() {
-    return this.isConnected;
+  clear() {
+    this.store.clear();
   }
 };
 
-// src/config/toml-loader.ts
-import fs2 from "fs";
-import path2 from "path";
-import { homedir as homedir3 } from "os";
-import toml from "@iarna/toml";
+// src/requests/index.ts
+var requestStore = new RequestStore();
 
-// src/config/env.ts
-import dotenv from "dotenv";
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-import { homedir as homedir2 } from "os";
-
-// src/utils/ssh-config-parser.ts
-import { readFileSync as readFileSync2, existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import SSHConfig from "ssh-config";
-var DEFAULT_SSH_KEYS = [
-  "~/.ssh/id_rsa",
-  "~/.ssh/id_ed25519",
-  "~/.ssh/id_ecdsa",
-  "~/.ssh/id_dsa"
-];
-function expandTilde(filePath) {
-  if (filePath.startsWith("~/")) {
-    return join(homedir(), filePath.substring(2));
-  }
-  return filePath;
-}
-function fileExists(filePath) {
-  try {
-    return existsSync(expandTilde(filePath));
-  } catch {
-    return false;
-  }
-}
-function findDefaultSSHKey() {
-  for (const keyPath of DEFAULT_SSH_KEYS) {
-    if (fileExists(keyPath)) {
-      return expandTilde(keyPath);
-    }
-  }
-  return void 0;
-}
-function parseSSHConfig(hostAlias, configPath) {
-  const sshConfigPath = configPath;
-  if (!existsSync(sshConfigPath)) {
-    return null;
-  }
-  try {
-    const configContent = readFileSync2(sshConfigPath, "utf8");
-    const config = SSHConfig.parse(configContent);
-    const hostConfig = config.compute(hostAlias);
-    if (!hostConfig || !hostConfig.HostName && !hostConfig.User) {
-      return null;
-    }
-    const sshConfig = {};
-    if (hostConfig.HostName) {
-      sshConfig.host = hostConfig.HostName;
-    } else {
-      sshConfig.host = hostAlias;
-    }
-    if (hostConfig.Port) {
-      sshConfig.port = parseInt(hostConfig.Port, 10);
-    }
-    if (hostConfig.User) {
-      sshConfig.username = hostConfig.User;
-    }
-    if (hostConfig.IdentityFile) {
-      const identityFile = Array.isArray(hostConfig.IdentityFile) ? hostConfig.IdentityFile[0] : hostConfig.IdentityFile;
-      const expandedPath = expandTilde(identityFile);
-      if (fileExists(expandedPath)) {
-        sshConfig.privateKey = expandedPath;
-      }
-    }
-    if (!sshConfig.privateKey) {
-      const defaultKey = findDefaultSSHKey();
-      if (defaultKey) {
-        sshConfig.privateKey = defaultKey;
-      }
-    }
-    if (hostConfig.ProxyJump || hostConfig.ProxyCommand) {
-      console.error("Warning: ProxyJump/ProxyCommand in SSH config is not yet supported by DBHub");
-    }
-    if (!sshConfig.host || !sshConfig.username) {
-      return null;
-    }
-    return sshConfig;
-  } catch (error) {
-    console.error(`Error parsing SSH config: ${error instanceof Error ? error.message : String(error)}`);
-    return null;
-  }
-}
-function looksLikeSSHAlias(host) {
-  if (host.includes(".")) {
-    return false;
-  }
-  if (/^[\d:]+$/.test(host)) {
-    return false;
-  }
-  if (/^[0-9a-fA-F:]+$/.test(host) && host.includes(":")) {
-    return false;
-  }
-  return true;
-}
-
-// src/config/env.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-function parseCommandLineArgs() {
-  const args = process.argv.slice(2);
-  const parsedManually = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const [key, value] = arg.substring(2).split("=");
-      if (value) {
-        parsedManually[key] = value;
-      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
-        parsedManually[key] = args[i + 1];
-        i++;
-      } else {
-        parsedManually[key] = "true";
-      }
-    }
-  }
-  return parsedManually;
-}
-function loadEnvFiles() {
-  const isDevelopment = process.env.NODE_ENV === "development" || process.argv[1]?.includes("tsx");
-  const envFileNames = isDevelopment ? [".env.local", ".env"] : [".env"];
-  const envPaths = [];
-  for (const fileName of envFileNames) {
-    envPaths.push(
-      fileName,
-      // Current working directory
-      path.join(__dirname, "..", "..", fileName),
-      // Two levels up (src/config -> src -> root)
-      path.join(process.cwd(), fileName)
-      // Explicit current working directory
-    );
-  }
-  for (const envPath of envPaths) {
-    console.error(`Checking for env file: ${envPath}`);
-    if (fs.existsSync(envPath)) {
-      dotenv.config({ path: envPath });
-      return path.basename(envPath);
-    }
-  }
-  return null;
-}
-function isDemoMode() {
-  const args = parseCommandLineArgs();
-  return args.demo === "true";
-}
-function isReadOnlyMode() {
-  const args = parseCommandLineArgs();
-  if (args.readonly !== void 0) {
-    return args.readonly === "true";
-  }
-  if (process.env.READONLY !== void 0) {
-    return process.env.READONLY === "true";
-  }
-  return false;
-}
-function buildDSNFromEnvParams() {
-  const dbType = process.env.DB_TYPE;
-  const dbHost = process.env.DB_HOST;
-  const dbUser = process.env.DB_USER;
-  const dbPassword = process.env.DB_PASSWORD;
-  const dbName = process.env.DB_NAME;
-  const dbPort = process.env.DB_PORT;
-  if (dbType?.toLowerCase() === "sqlite") {
-    if (!dbName) {
-      return null;
-    }
-  } else {
-    if (!dbType || !dbHost || !dbUser || !dbPassword || !dbName) {
-      return null;
-    }
-  }
-  const supportedTypes = ["postgres", "postgresql", "mysql", "mariadb", "sqlserver", "sqlite"];
-  if (!supportedTypes.includes(dbType.toLowerCase())) {
-    throw new Error(`Unsupported DB_TYPE: ${dbType}. Supported types: ${supportedTypes.join(", ")}`);
-  }
-  let port = dbPort;
-  if (!port) {
-    switch (dbType.toLowerCase()) {
-      case "postgres":
-      case "postgresql":
-        port = "5432";
-        break;
-      case "mysql":
-      case "mariadb":
-        port = "3306";
-        break;
-      case "sqlserver":
-        port = "1433";
-        break;
-      case "sqlite":
-        return {
-          dsn: `sqlite:///${dbName}`,
-          source: "individual environment variables"
-        };
-      default:
-        throw new Error(`Unknown database type for port determination: ${dbType}`);
-    }
-  }
-  const user = dbUser;
-  const password = dbPassword;
-  const dbNameStr = dbName;
-  const encodedUser = encodeURIComponent(user);
-  const encodedPassword = encodeURIComponent(password);
-  const encodedDbName = encodeURIComponent(dbNameStr);
-  const protocol = dbType.toLowerCase() === "postgresql" ? "postgres" : dbType.toLowerCase();
-  const dsn = `${protocol}://${encodedUser}:${encodedPassword}@${dbHost}:${port}/${encodedDbName}`;
-  return {
-    dsn,
-    source: "individual environment variables"
-  };
-}
-function resolveDSN() {
-  const args = parseCommandLineArgs();
-  if (isDemoMode()) {
-    return {
-      dsn: "sqlite:///:memory:",
-      source: "demo mode",
-      isDemo: true
-    };
-  }
-  if (args.dsn) {
-    return { dsn: args.dsn, source: "command line argument" };
-  }
-  if (process.env.DSN) {
-    return { dsn: process.env.DSN, source: "environment variable" };
-  }
-  const envParamsResult = buildDSNFromEnvParams();
-  if (envParamsResult) {
-    return envParamsResult;
-  }
-  const loadedEnvFile = loadEnvFiles();
-  if (loadedEnvFile && process.env.DSN) {
-    return { dsn: process.env.DSN, source: `${loadedEnvFile} file` };
-  }
-  if (loadedEnvFile) {
-    const envFileParamsResult = buildDSNFromEnvParams();
-    if (envFileParamsResult) {
-      return {
-        dsn: envFileParamsResult.dsn,
-        source: `${loadedEnvFile} file (individual parameters)`
-      };
-    }
-  }
-  return null;
-}
-function resolveTransport() {
-  const args = parseCommandLineArgs();
-  if (args.transport) {
-    const type = args.transport === "http" ? "http" : "stdio";
-    return { type, source: "command line argument" };
-  }
-  if (process.env.TRANSPORT) {
-    const type = process.env.TRANSPORT === "http" ? "http" : "stdio";
-    return { type, source: "environment variable" };
-  }
-  return { type: "stdio", source: "default" };
-}
-function resolveMaxRows() {
-  const args = parseCommandLineArgs();
-  if (args["max-rows"]) {
-    const maxRows = parseInt(args["max-rows"], 10);
-    if (isNaN(maxRows) || maxRows <= 0) {
-      throw new Error(`Invalid --max-rows value: ${args["max-rows"]}. Must be a positive integer.`);
-    }
-    return { maxRows, source: "command line argument" };
-  }
-  return null;
-}
-function resolvePort() {
-  const args = parseCommandLineArgs();
-  if (args.port) {
-    const port = parseInt(args.port, 10);
-    return { port, source: "command line argument" };
-  }
-  if (process.env.PORT) {
-    const port = parseInt(process.env.PORT, 10);
-    return { port, source: "environment variable" };
-  }
-  return { port: 8080, source: "default" };
-}
-function redactDSN(dsn) {
-  try {
-    const url = new URL(dsn);
-    if (url.password) {
-      url.password = "*******";
-    }
-    return url.toString();
-  } catch (error) {
-    return dsn.replace(/\/\/([^:]+):([^@]+)@/, "//$1:***@");
-  }
-}
-function resolveId() {
-  const args = parseCommandLineArgs();
-  if (args.id) {
-    return { id: args.id, source: "command line argument" };
-  }
-  if (process.env.ID) {
-    return { id: process.env.ID, source: "environment variable" };
-  }
-  return null;
-}
-function resolveSSHConfig() {
-  const args = parseCommandLineArgs();
-  const hasSSHArgs = args["ssh-host"] || process.env.SSH_HOST;
-  if (!hasSSHArgs) {
-    return null;
-  }
-  let config = {};
-  let sources = [];
-  let sshConfigHost;
-  if (args["ssh-host"]) {
-    sshConfigHost = args["ssh-host"];
-    config.host = args["ssh-host"];
-    sources.push("ssh-host from command line");
-  } else if (process.env.SSH_HOST) {
-    sshConfigHost = process.env.SSH_HOST;
-    config.host = process.env.SSH_HOST;
-    sources.push("SSH_HOST from environment");
-  }
-  if (sshConfigHost && looksLikeSSHAlias(sshConfigHost)) {
-    const sshConfigPath = path.join(homedir2(), ".ssh", "config");
-    console.error(`Attempting to parse SSH config for host '${sshConfigHost}' from: ${sshConfigPath}`);
-    const sshConfigData = parseSSHConfig(sshConfigHost, sshConfigPath);
-    if (sshConfigData) {
-      config = { ...sshConfigData };
-      sources.push(`SSH config for host '${sshConfigHost}'`);
-    }
-  }
-  if (args["ssh-port"]) {
-    config.port = parseInt(args["ssh-port"], 10);
-    sources.push("ssh-port from command line");
-  } else if (process.env.SSH_PORT) {
-    config.port = parseInt(process.env.SSH_PORT, 10);
-    sources.push("SSH_PORT from environment");
-  }
-  if (args["ssh-user"]) {
-    config.username = args["ssh-user"];
-    sources.push("ssh-user from command line");
-  } else if (process.env.SSH_USER) {
-    config.username = process.env.SSH_USER;
-    sources.push("SSH_USER from environment");
-  }
-  if (args["ssh-password"]) {
-    config.password = args["ssh-password"];
-    sources.push("ssh-password from command line");
-  } else if (process.env.SSH_PASSWORD) {
-    config.password = process.env.SSH_PASSWORD;
-    sources.push("SSH_PASSWORD from environment");
-  }
-  if (args["ssh-key"]) {
-    config.privateKey = args["ssh-key"];
-    if (config.privateKey.startsWith("~/")) {
-      config.privateKey = path.join(process.env.HOME || "", config.privateKey.substring(2));
-    }
-    sources.push("ssh-key from command line");
-  } else if (process.env.SSH_KEY) {
-    config.privateKey = process.env.SSH_KEY;
-    if (config.privateKey.startsWith("~/")) {
-      config.privateKey = path.join(process.env.HOME || "", config.privateKey.substring(2));
-    }
-    sources.push("SSH_KEY from environment");
-  }
-  if (args["ssh-passphrase"]) {
-    config.passphrase = args["ssh-passphrase"];
-    sources.push("ssh-passphrase from command line");
-  } else if (process.env.SSH_PASSPHRASE) {
-    config.passphrase = process.env.SSH_PASSPHRASE;
-    sources.push("SSH_PASSPHRASE from environment");
-  }
-  if (!config.host || !config.username) {
-    throw new Error("SSH tunnel configuration requires at least --ssh-host and --ssh-user");
-  }
-  if (!config.password && !config.privateKey) {
-    throw new Error("SSH tunnel configuration requires either --ssh-password or --ssh-key for authentication");
-  }
-  return {
-    config,
-    source: sources.join(", ")
-  };
-}
-async function resolveSourceConfigs() {
-  if (!isDemoMode()) {
-    const tomlConfig = loadTomlConfig();
-    if (tomlConfig) {
-      const idData = resolveId();
-      if (idData) {
-        throw new Error(
-          "The --id flag cannot be used with TOML configuration. TOML config defines source IDs directly. Either remove the --id flag or use command-line DSN configuration instead."
-        );
-      }
-      if (isReadOnlyMode()) {
-        throw new Error(
-          "The --readonly flag cannot be used with TOML configuration. TOML config defines readonly mode per-source using 'readonly = true'. Either remove the --readonly flag or use command-line DSN configuration instead."
-        );
-      }
-      return tomlConfig;
-    }
-  }
-  const dsnResult = resolveDSN();
-  if (dsnResult) {
-    let dsnUrl;
-    try {
-      dsnUrl = new URL(dsnResult.dsn);
-    } catch (error) {
-      throw new Error(
-        `Invalid DSN format: ${dsnResult.dsn}. Expected format: protocol://[user[:password]@]host[:port]/database`
-      );
-    }
-    const protocol = dsnUrl.protocol.replace(":", "");
-    let dbType;
-    if (protocol === "postgresql" || protocol === "postgres") {
-      dbType = "postgres";
-    } else if (protocol === "mysql") {
-      dbType = "mysql";
-    } else if (protocol === "mariadb") {
-      dbType = "mariadb";
-    } else if (protocol === "sqlserver") {
-      dbType = "sqlserver";
-    } else if (protocol === "sqlite") {
-      dbType = "sqlite";
-    } else {
-      throw new Error(`Unsupported database type in DSN: ${protocol}`);
-    }
-    const idData = resolveId();
-    const sourceId = idData?.id || "default";
-    const source = {
-      id: sourceId,
-      type: dbType,
-      dsn: dsnResult.dsn
-    };
-    const connectionInfo = parseConnectionInfoFromDSN(dsnResult.dsn);
-    if (connectionInfo) {
-      if (connectionInfo.host) {
-        source.host = connectionInfo.host;
-      }
-      if (connectionInfo.port !== void 0) {
-        source.port = connectionInfo.port;
-      }
-      if (connectionInfo.database) {
-        source.database = connectionInfo.database;
-      }
-      if (connectionInfo.user) {
-        source.user = connectionInfo.user;
-      }
-    }
-    const sshResult = resolveSSHConfig();
-    if (sshResult) {
-      source.ssh_host = sshResult.config.host;
-      source.ssh_port = sshResult.config.port;
-      source.ssh_user = sshResult.config.username;
-      source.ssh_password = sshResult.config.password;
-      source.ssh_key = sshResult.config.privateKey;
-      source.ssh_passphrase = sshResult.config.passphrase;
-    }
-    source.readonly = isReadOnlyMode();
-    const maxRowsResult = resolveMaxRows();
-    if (maxRowsResult) {
-      source.max_rows = maxRowsResult.maxRows;
-    }
-    if (dsnResult.isDemo) {
-      const { getSqliteInMemorySetupSql } = await import("./demo-loader-PSMTLZ2T.js");
-      source.init_script = getSqliteInMemorySetupSql();
-    }
-    return {
-      sources: [source],
-      source: dsnResult.isDemo ? "demo mode" : dsnResult.source
-    };
-  }
-  return null;
-}
-
-// src/config/toml-loader.ts
-function loadTomlConfig() {
-  const configPath = resolveTomlConfigPath();
-  if (!configPath) {
-    return null;
-  }
-  try {
-    const fileContent = fs2.readFileSync(configPath, "utf-8");
-    const parsedToml = toml.parse(fileContent);
-    validateTomlConfig(parsedToml, configPath);
-    const sources = processSourceConfigs(parsedToml.sources, configPath);
-    return {
-      sources,
-      source: path2.basename(configPath)
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(
-        `Failed to load TOML configuration from ${configPath}: ${error.message}`
-      );
-    }
-    throw error;
-  }
-}
-function resolveTomlConfigPath() {
-  const args = parseCommandLineArgs();
-  if (args.config) {
-    const configPath = expandHomeDir(args.config);
-    if (!fs2.existsSync(configPath)) {
-      throw new Error(
-        `Configuration file specified by --config flag not found: ${configPath}`
-      );
-    }
-    return configPath;
-  }
-  const defaultConfigPath = path2.join(process.cwd(), "dbhub.toml");
-  if (fs2.existsSync(defaultConfigPath)) {
-    return defaultConfigPath;
-  }
-  return null;
-}
-function validateTomlConfig(config, configPath) {
-  if (!config.sources) {
-    throw new Error(
-      `Configuration file ${configPath} must contain a [[sources]] array. Example:
-
-[[sources]]
-id = "my_db"
-dsn = "postgres://..."`
-    );
-  }
-  if (!Array.isArray(config.sources)) {
-    throw new Error(
-      `Configuration file ${configPath}: 'sources' must be an array. Use [[sources]] syntax for array of tables in TOML.`
-    );
-  }
-  if (config.sources.length === 0) {
-    throw new Error(
-      `Configuration file ${configPath}: sources array cannot be empty. Please define at least one source with [[sources]].`
-    );
-  }
-  const ids = /* @__PURE__ */ new Set();
-  const duplicates = [];
-  for (const source of config.sources) {
-    if (!source.id) {
-      throw new Error(
-        `Configuration file ${configPath}: each source must have an 'id' field. Example: [[sources]]
-id = "my_db"`
-      );
-    }
-    if (ids.has(source.id)) {
-      duplicates.push(source.id);
-    } else {
-      ids.add(source.id);
-    }
-  }
-  if (duplicates.length > 0) {
-    throw new Error(
-      `Configuration file ${configPath}: duplicate source IDs found: ${duplicates.join(", ")}. Each source must have a unique 'id' field.`
-    );
-  }
-  for (const source of config.sources) {
-    validateSourceConfig(source, configPath);
-  }
-}
-function validateSourceConfig(source, configPath) {
-  const hasConnectionParams = source.type && (source.type === "sqlite" ? source.database : source.host);
-  if (!source.dsn && !hasConnectionParams) {
-    throw new Error(
-      `Configuration file ${configPath}: source '${source.id}' must have either:
-  - 'dsn' field (e.g., dsn = "postgres://user:pass@host:5432/dbname")
-  - OR connection parameters (type, host, database, user, password)
-  - For SQLite: type = "sqlite" and database path`
-    );
-  }
-  if (source.type) {
-    const validTypes = ["postgres", "mysql", "mariadb", "sqlserver", "sqlite"];
-    if (!validTypes.includes(source.type)) {
-      throw new Error(
-        `Configuration file ${configPath}: source '${source.id}' has invalid type '${source.type}'. Valid types: ${validTypes.join(", ")}`
-      );
-    }
-  }
-  if (source.max_rows !== void 0) {
-    if (typeof source.max_rows !== "number" || source.max_rows <= 0) {
-      throw new Error(
-        `Configuration file ${configPath}: source '${source.id}' has invalid max_rows. Must be a positive integer.`
-      );
-    }
-  }
-  if (source.connection_timeout !== void 0) {
-    if (typeof source.connection_timeout !== "number" || source.connection_timeout <= 0) {
-      throw new Error(
-        `Configuration file ${configPath}: source '${source.id}' has invalid connection_timeout. Must be a positive number (in seconds).`
-      );
-    }
-  }
-  if (source.request_timeout !== void 0) {
-    if (typeof source.request_timeout !== "number" || source.request_timeout <= 0) {
-      throw new Error(
-        `Configuration file ${configPath}: source '${source.id}' has invalid request_timeout. Must be a positive number (in seconds).`
-      );
-    }
-  }
-  if (source.ssh_port !== void 0) {
-    if (typeof source.ssh_port !== "number" || source.ssh_port <= 0 || source.ssh_port > 65535) {
-      throw new Error(
-        `Configuration file ${configPath}: source '${source.id}' has invalid ssh_port. Must be between 1 and 65535.`
-      );
-    }
-  }
-}
-function processSourceConfigs(sources, configPath) {
-  return sources.map((source) => {
-    const processed = { ...source };
-    if (processed.ssh_key) {
-      processed.ssh_key = expandHomeDir(processed.ssh_key);
-    }
-    if (processed.type === "sqlite" && processed.database) {
-      processed.database = expandHomeDir(processed.database);
-    }
-    if (processed.dsn && processed.dsn.startsWith("sqlite:///~")) {
-      processed.dsn = `sqlite:///${expandHomeDir(processed.dsn.substring(11))}`;
-    }
-    if (processed.dsn) {
-      const connectionInfo = parseConnectionInfoFromDSN(processed.dsn);
-      if (connectionInfo) {
-        if (!processed.type && connectionInfo.type) {
-          processed.type = connectionInfo.type;
-        }
-        if (!processed.host && connectionInfo.host) {
-          processed.host = connectionInfo.host;
-        }
-        if (processed.port === void 0 && connectionInfo.port !== void 0) {
-          processed.port = connectionInfo.port;
-        }
-        if (!processed.database && connectionInfo.database) {
-          processed.database = connectionInfo.database;
-        }
-        if (!processed.user && connectionInfo.user) {
-          processed.user = connectionInfo.user;
-        }
-      }
-    }
-    return processed;
-  });
-}
-function expandHomeDir(filePath) {
-  if (filePath.startsWith("~/")) {
-    return path2.join(homedir3(), filePath.substring(2));
-  }
-  return filePath;
-}
-function buildDSNFromSource(source) {
-  if (source.dsn) {
-    return source.dsn;
-  }
-  if (!source.type) {
-    throw new Error(
-      `Source '${source.id}': 'type' field is required when 'dsn' is not provided`
-    );
-  }
-  if (source.type === "sqlite") {
-    if (!source.database) {
-      throw new Error(
-        `Source '${source.id}': 'database' field is required for SQLite`
-      );
-    }
-    return `sqlite:///${source.database}`;
-  }
-  if (!source.host || !source.user || !source.password || !source.database) {
-    throw new Error(
-      `Source '${source.id}': missing required connection parameters. Required: type, host, user, password, database`
-    );
-  }
-  const port = source.port || getDefaultPortForType(source.type);
-  if (!port) {
-    throw new Error(`Source '${source.id}': unable to determine port`);
-  }
-  const encodedUser = encodeURIComponent(source.user);
-  const encodedPassword = encodeURIComponent(source.password);
-  const encodedDatabase = encodeURIComponent(source.database);
-  let dsn = `${source.type}://${encodedUser}:${encodedPassword}@${source.host}:${port}/${encodedDatabase}`;
-  if (source.type === "sqlserver" && source.instanceName) {
-    dsn += `?instanceName=${encodeURIComponent(source.instanceName)}`;
-  }
-  return dsn;
-}
-
-// src/connectors/manager.ts
-var managerInstance = null;
-var ConnectorManager = class {
-  // Ordered list of source IDs (first is default)
-  constructor() {
-    // Maps for multi-source support
-    this.connectors = /* @__PURE__ */ new Map();
-    this.sshTunnels = /* @__PURE__ */ new Map();
-    this.executeOptions = /* @__PURE__ */ new Map();
-    this.sourceConfigs = /* @__PURE__ */ new Map();
-    // Store original source configs
-    this.sourceIds = [];
-    if (!managerInstance) {
-      managerInstance = this;
-    }
-  }
-  /**
-   * Initialize and connect to multiple databases using source configurations
-   * This is the new multi-source connection method
-   */
-  async connectWithSources(sources) {
-    if (sources.length === 0) {
-      throw new Error("No sources provided");
-    }
-    for (const source of sources) {
-      await this.connectSource(source);
-    }
-    console.error(`Successfully connected to ${sources.length} database source(s)`);
-  }
-  /**
-   * Connect to a single source (helper for connectWithSources)
-   */
-  async connectSource(source) {
-    const sourceId = source.id;
-    console.error(`Connecting to source '${sourceId || "(default)"}' ...`);
-    const dsn = buildDSNFromSource(source);
-    let actualDSN = dsn;
-    if (source.ssh_host) {
-      if (!source.ssh_user) {
-        throw new Error(
-          `Source '${sourceId}': SSH tunnel requires ssh_user`
-        );
-      }
-      const sshConfig = {
-        host: source.ssh_host,
-        port: source.ssh_port || 22,
-        username: source.ssh_user,
-        password: source.ssh_password,
-        privateKey: source.ssh_key,
-        passphrase: source.ssh_passphrase
-      };
-      if (!sshConfig.password && !sshConfig.privateKey) {
-        throw new Error(
-          `Source '${sourceId}': SSH tunnel requires either ssh_password or ssh_key`
-        );
-      }
-      const url = new URL(dsn);
-      const targetHost = url.hostname;
-      const targetPort = parseInt(url.port) || this.getDefaultPort(dsn);
-      const tunnel = new SSHTunnel();
-      const tunnelInfo = await tunnel.establish(sshConfig, {
-        targetHost,
-        targetPort
-      });
-      url.hostname = "127.0.0.1";
-      url.port = tunnelInfo.localPort.toString();
-      actualDSN = url.toString();
-      this.sshTunnels.set(sourceId, tunnel);
-      console.error(
-        `  SSH tunnel established through localhost:${tunnelInfo.localPort}`
-      );
-    }
-    const connectorPrototype = ConnectorRegistry.getConnectorForDSN(actualDSN);
-    if (!connectorPrototype) {
-      throw new Error(
-        `Source '${sourceId}': No connector found for DSN: ${actualDSN}`
-      );
-    }
-    const connector = connectorPrototype.clone();
-    const config = {};
-    if (source.connection_timeout !== void 0) {
-      config.connectionTimeoutSeconds = source.connection_timeout;
-    }
-    if (connector.id === "sqlserver" && source.request_timeout !== void 0) {
-      config.requestTimeoutSeconds = source.request_timeout;
-    }
-    if (source.readonly !== void 0) {
-      config.readonly = source.readonly;
-    }
-    await connector.connect(actualDSN, source.init_script, config);
-    this.connectors.set(sourceId, connector);
-    this.sourceIds.push(sourceId);
-    this.sourceConfigs.set(sourceId, source);
-    const options = {};
-    if (source.max_rows !== void 0) {
-      options.maxRows = source.max_rows;
-    }
-    if (source.readonly !== void 0) {
-      options.readonly = source.readonly;
-    }
-    this.executeOptions.set(sourceId, options);
-    console.error(`  Connected successfully`);
-  }
-  /**
-   * Close all database connections
-   */
-  async disconnect() {
-    for (const [sourceId, connector] of this.connectors.entries()) {
-      try {
-        await connector.disconnect();
-        console.error(`Disconnected from source '${sourceId || "(default)"}'`);
-      } catch (error) {
-        console.error(`Error disconnecting from source '${sourceId}':`, error);
-      }
-    }
-    for (const [sourceId, tunnel] of this.sshTunnels.entries()) {
-      try {
-        await tunnel.close();
-      } catch (error) {
-        console.error(`Error closing SSH tunnel for source '${sourceId}':`, error);
-      }
-    }
-    this.connectors.clear();
-    this.sshTunnels.clear();
-    this.executeOptions.clear();
-    this.sourceConfigs.clear();
-    this.sourceIds = [];
-  }
-  /**
-   * Get a connector by source ID
-   * If sourceId is not provided, returns the default (first) connector
-   */
-  getConnector(sourceId) {
-    const id = sourceId || this.sourceIds[0];
-    const connector = this.connectors.get(id);
-    if (!connector) {
-      if (sourceId) {
-        throw new Error(
-          `Source '${sourceId}' not found. Available sources: ${this.sourceIds.join(", ")}`
-        );
-      } else {
-        throw new Error("No sources connected. Call connectWithSources() first.");
-      }
-    }
-    return connector;
-  }
-  /**
-   * Get all available connector types
-   */
-  static getAvailableConnectors() {
-    return ConnectorRegistry.getAvailableConnectors();
-  }
-  /**
-   * Get sample DSNs for all available connectors
-   */
-  static getAllSampleDSNs() {
-    return ConnectorRegistry.getAllSampleDSNs();
-  }
-  /**
-   * Get the current active connector instance
-   * This is used by resource and tool handlers
-   * @param sourceId - Optional source ID. If not provided, returns default (first) connector
-   */
-  static getCurrentConnector(sourceId) {
-    if (!managerInstance) {
-      throw new Error("ConnectorManager not initialized");
-    }
-    return managerInstance.getConnector(sourceId);
-  }
-  /**
-   * Get execute options for SQL execution
-   * @param sourceId - Optional source ID. If not provided, returns default options
-   */
-  getExecuteOptions(sourceId) {
-    const id = sourceId || this.sourceIds[0];
-    return this.executeOptions.get(id) || {};
-  }
-  /**
-   * Get the current execute options
-   * This is used by tool handlers
-   * @param sourceId - Optional source ID. If not provided, returns default options
-   */
-  static getCurrentExecuteOptions(sourceId) {
-    if (!managerInstance) {
-      throw new Error("ConnectorManager not initialized");
-    }
-    return managerInstance.getExecuteOptions(sourceId);
-  }
-  /**
-   * Get all available source IDs
-   */
-  getSourceIds() {
-    return [...this.sourceIds];
-  }
-  /** Get all available source IDs */
-  static getAvailableSourceIds() {
-    if (!managerInstance) {
-      throw new Error("ConnectorManager not initialized");
-    }
-    return managerInstance.getSourceIds();
-  }
-  /**
-   * Get source configuration by ID
-   * @param sourceId - Source ID. If not provided, returns default (first) source config
-   */
-  getSourceConfig(sourceId) {
-    if (this.connectors.size === 0) {
-      return null;
-    }
-    const id = sourceId || this.sourceIds[0];
-    return this.sourceConfigs.get(id) || null;
-  }
-  /**
-   * Get all source configurations
-   */
-  getAllSourceConfigs() {
-    return this.sourceIds.map((id) => this.sourceConfigs.get(id));
-  }
-  /**
-   * Get source configuration by ID (static method for external access)
-   */
-  static getSourceConfig(sourceId) {
-    if (!managerInstance) {
-      throw new Error("ConnectorManager not initialized");
-    }
-    return managerInstance.getSourceConfig(sourceId);
-  }
-  /**
-   * Get all source configurations (static method for external access)
-   */
-  static getAllSourceConfigs() {
-    if (!managerInstance) {
-      throw new Error("ConnectorManager not initialized");
-    }
-    return managerInstance.getAllSourceConfigs();
-  }
-  /**
-   * Get default port for a database based on DSN protocol
-   */
-  getDefaultPort(dsn) {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (!type) {
-      return 0;
-    }
-    return getDefaultPortForType(type) ?? 0;
-  }
-};
-
-// src/resources/index.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/utils/response-formatter.ts
-function bigIntReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
-}
-function formatSuccessResponse(data, meta = {}) {
-  return {
-    success: true,
-    data,
-    ...Object.keys(meta).length > 0 ? { meta } : {}
-  };
-}
-function formatErrorResponse(error, code = "ERROR", details) {
-  return {
-    success: false,
-    error,
-    code,
-    ...details ? { details } : {}
-  };
-}
-function createToolErrorResponse(error, code = "ERROR", details) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(formatErrorResponse(error, code, details), bigIntReplacer, 2),
-        mimeType: "application/json"
-      }
-    ],
-    isError: true
-  };
-}
-function createToolSuccessResponse(data, meta = {}) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(formatSuccessResponse(data, meta), bigIntReplacer, 2),
-        mimeType: "application/json"
-      }
-    ]
-  };
-}
-function createResourceErrorResponse(uri, error, code = "ERROR", details) {
-  return {
-    contents: [
-      {
-        uri,
-        text: JSON.stringify(formatErrorResponse(error, code, details), bigIntReplacer, 2),
-        mimeType: "application/json"
-      }
-    ]
-  };
-}
-function createResourceSuccessResponse(uri, data, meta = {}) {
-  return {
-    contents: [
-      {
-        uri,
-        text: JSON.stringify(formatSuccessResponse(data, meta), bigIntReplacer, 2),
-        mimeType: "application/json"
-      }
-    ]
-  };
-}
-function formatPromptSuccessResponse(text, references = []) {
-  return {
-    messages: [
-      {
-        role: "assistant",
-        content: {
-          type: "text",
-          text
-        }
-      }
-    ],
-    ...references.length > 0 ? { references } : {}
-  };
-}
-function formatPromptErrorResponse(error, code = "ERROR") {
-  return {
-    messages: [
-      {
-        role: "assistant",
-        content: {
-          type: "text",
-          text: `Error: ${error}`
-        }
-      }
-    ],
-    error,
-    code
-  };
-}
-
-// src/resources/tables.ts
-async function tablesResourceHandler(uri, variables, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
-  try {
-    if (schemaName) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schemaName)) {
-        return createResourceErrorResponse(
-          uri.href,
-          `Schema '${schemaName}' does not exist or cannot be accessed`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const tableNames = await connector.getTables(schemaName);
-    const responseData = {
-      tables: tableNames,
-      count: tableNames.length,
-      schema: schemaName
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving tables: ${error.message}`,
-      "TABLES_RETRIEVAL_ERROR"
-    );
-  }
-}
-
-// src/resources/schema.ts
-async function tableStructureResourceHandler(uri, variables, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const tableName = Array.isArray(variables.tableName) ? variables.tableName[0] : variables.tableName;
-  const schemaName = variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
-  try {
-    if (schemaName) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schemaName)) {
-        return createResourceErrorResponse(
-          uri.href,
-          `Schema '${schemaName}' does not exist or cannot be accessed`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const tableExists = await connector.tableExists(tableName, schemaName);
-    if (!tableExists) {
-      const schemaInfo = schemaName ? ` in schema '${schemaName}'` : "";
-      return createResourceErrorResponse(
-        uri.href,
-        `Table '${tableName}'${schemaInfo} does not exist or cannot be accessed`,
-        "TABLE_NOT_FOUND"
-      );
-    }
-    const columns = await connector.getTableSchema(tableName, schemaName);
-    const formattedColumns = columns.map((col) => ({
-      name: col.column_name,
-      type: col.data_type,
-      nullable: col.is_nullable === "YES",
-      default: col.column_default
-    }));
-    const responseData = {
-      table: tableName,
-      schema: schemaName,
-      columns: formattedColumns,
-      count: formattedColumns.length
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving schema: ${error.message}`,
-      "SCHEMA_RETRIEVAL_ERROR"
-    );
-  }
-}
-
-// src/resources/schemas.ts
-async function schemasResourceHandler(uri, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  try {
-    const schemas = await connector.getSchemas();
-    const responseData = {
-      schemas,
-      count: schemas.length
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving database schemas: ${error.message}`,
-      "SCHEMAS_RETRIEVAL_ERROR"
-    );
-  }
-}
-
-// src/resources/indexes.ts
-async function indexesResourceHandler(uri, variables, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
-  const tableName = variables && variables.tableName ? Array.isArray(variables.tableName) ? variables.tableName[0] : variables.tableName : void 0;
-  if (!tableName) {
-    return createResourceErrorResponse(uri.href, "Table name is required", "MISSING_TABLE_NAME");
-  }
-  try {
-    if (schemaName) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schemaName)) {
-        return createResourceErrorResponse(
-          uri.href,
-          `Schema '${schemaName}' does not exist or cannot be accessed`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const tableExists = await connector.tableExists(tableName, schemaName);
-    if (!tableExists) {
-      return createResourceErrorResponse(
-        uri.href,
-        `Table '${tableName}' does not exist in schema '${schemaName || "default"}'`,
-        "TABLE_NOT_FOUND"
-      );
-    }
-    const indexes = await connector.getTableIndexes(tableName, schemaName);
-    const responseData = {
-      table: tableName,
-      schema: schemaName,
-      indexes,
-      count: indexes.length
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving indexes: ${error.message}`,
-      "INDEXES_RETRIEVAL_ERROR"
-    );
-  }
-}
-
-// src/resources/procedures.ts
-async function proceduresResourceHandler(uri, variables, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
-  try {
-    if (schemaName) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schemaName)) {
-        return createResourceErrorResponse(
-          uri.href,
-          `Schema '${schemaName}' does not exist or cannot be accessed`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const procedureNames = await connector.getStoredProcedures(schemaName);
-    const responseData = {
-      procedures: procedureNames,
-      count: procedureNames.length,
-      schema: schemaName
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving stored procedures: ${error.message}`,
-      "PROCEDURES_RETRIEVAL_ERROR"
-    );
-  }
-}
-async function procedureDetailResourceHandler(uri, variables, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
-  const procedureName = variables && variables.procedureName ? Array.isArray(variables.procedureName) ? variables.procedureName[0] : variables.procedureName : void 0;
-  if (!procedureName) {
-    return createResourceErrorResponse(uri.href, "Procedure name is required", "MISSING_PARAMETER");
-  }
-  try {
-    if (schemaName) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schemaName)) {
-        return createResourceErrorResponse(
-          uri.href,
-          `Schema '${schemaName}' does not exist or cannot be accessed`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const procedureDetails = await connector.getStoredProcedureDetail(procedureName, schemaName);
-    const responseData = {
-      procedureName: procedureDetails.procedure_name,
-      procedureType: procedureDetails.procedure_type,
-      language: procedureDetails.language,
-      parameters: procedureDetails.parameter_list,
-      returnType: procedureDetails.return_type,
-      definition: procedureDetails.definition,
-      schema: schemaName
-    };
-    return createResourceSuccessResponse(uri.href, responseData);
-  } catch (error) {
-    return createResourceErrorResponse(
-      uri.href,
-      `Error retrieving procedure details: ${error.message}`,
-      "PROCEDURE_DETAILS_ERROR"
-    );
-  }
-}
-
-// src/resources/index.ts
-function registerResources(server) {
-  server.resource(
-    "schemas",
-    "db://schemas",
-    {
-      description: "List all schemas/databases available in the connected database",
-      mimeType: "application/json"
-    },
-    schemasResourceHandler
-  );
-  server.resource(
-    "tables_in_schema",
-    new ResourceTemplate("db://schemas/{schemaName}/tables", { list: void 0 }),
-    {
-      description: "List all tables within a specific schema",
-      mimeType: "application/json"
-    },
-    tablesResourceHandler
-  );
-  server.resource(
-    "table_structure_in_schema",
-    new ResourceTemplate("db://schemas/{schemaName}/tables/{tableName}", { list: void 0 }),
-    {
-      description: "Get detailed structure information for a specific table, including columns, data types, and constraints",
-      mimeType: "application/json"
-    },
-    tableStructureResourceHandler
-  );
-  server.resource(
-    "indexes_in_table",
-    new ResourceTemplate("db://schemas/{schemaName}/tables/{tableName}/indexes", {
-      list: void 0
-    }),
-    {
-      description: "List all indexes defined on a specific table",
-      mimeType: "application/json"
-    },
-    indexesResourceHandler
-  );
-  server.resource(
-    "procedures_in_schema",
-    new ResourceTemplate("db://schemas/{schemaName}/procedures", { list: void 0 }),
-    {
-      description: "List all stored procedures/functions in a schema (not supported by SQLite)",
-      mimeType: "application/json"
-    },
-    proceduresResourceHandler
-  );
-  server.resource(
-    "procedure_detail_in_schema",
-    new ResourceTemplate("db://schemas/{schemaName}/procedures/{procedureName}", {
-      list: void 0
-    }),
-    {
-      description: "Get detailed information about a specific stored procedure, including parameters and definition (not supported by SQLite)",
-      mimeType: "application/json"
-    },
-    procedureDetailResourceHandler
-  );
-}
-
-// src/tools/execute-sql.ts
-import { z } from "zod";
-
-// src/utils/allowed-keywords.ts
-var allowedKeywords = {
-  postgres: ["select", "with", "explain", "analyze", "show"],
-  mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
-  mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
-  sqlite: ["select", "with", "explain", "analyze", "pragma"],
-  sqlserver: ["select", "with", "explain", "showplan"]
-};
-
-// src/requests/store.ts
-var RequestStore = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-    this.maxPerSource = 100;
-  }
-  /**
-   * Add a request to the store
-   * Evicts oldest entry if at capacity
-   */
-  add(request) {
-    const requests = this.store.get(request.sourceId) ?? [];
-    requests.push(request);
-    if (requests.length > this.maxPerSource) {
-      requests.shift();
-    }
-    this.store.set(request.sourceId, requests);
-  }
-  /**
-   * Get requests, optionally filtered by source
-   * Returns newest first
-   */
-  getAll(sourceId) {
-    let requests;
-    if (sourceId) {
-      requests = [...this.store.get(sourceId) ?? []];
-    } else {
-      requests = Array.from(this.store.values()).flat();
-    }
-    return requests.sort(
-      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
-    );
-  }
-  /**
-   * Get total count of requests across all sources
-   */
-  getTotal() {
-    return Array.from(this.store.values()).reduce((sum, arr) => sum + arr.length, 0);
-  }
-  /**
-   * Clear all requests (useful for testing)
-   */
-  clear() {
-    this.store.clear();
-  }
-};
-
-// src/requests/index.ts
-var requestStore = new RequestStore();
-
-// src/tools/execute-sql.ts
+// src/utils/client-identifier.ts
 function getClientIdentifier(extra) {
   const userAgent = extra?.requestInfo?.headers?.["user-agent"];
   if (userAgent) {
@@ -3714,28 +2226,13 @@ function getClientIdentifier(extra) {
   }
   return "stdio";
 }
+
+// src/tools/execute-sql.ts
 var executeSqlSchema = {
-  sql: z.string().describe("SQL query or multiple SQL statements to execute (separated by semicolons)")
-};
-function splitSQLStatements(sql2) {
-  return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
-}
-function stripSQLComments(sql2) {
-  let cleaned = sql2.split("\n").map((line) => {
-    const commentIndex = line.indexOf("--");
-    return commentIndex >= 0 ? line.substring(0, commentIndex) : line;
-  }).join("\n");
-  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, " ");
-  return cleaned.trim();
-}
-function isReadOnlySQL(sql2, connectorType) {
-  const cleanedSQL = stripSQLComments(sql2).toLowerCase();
-  if (!cleanedSQL) {
-    return true;
-  }
-  const firstWord = cleanedSQL.split(/\s+/)[0];
-  const keywordList = allowedKeywords[connectorType] || allowedKeywords.default || [];
-  return keywordList.includes(firstWord);
+  sql: z.string().describe("SQL query or multiple SQL statements to execute (separated by semicolons)")
+};
+function splitSQLStatements(sql2) {
+  return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
 }
 function areAllStatementsReadOnly(sql2, connectorType) {
   const statements = splitSQLStatements(sql2);
@@ -3751,13 +2248,19 @@ function createExecuteSqlToolHandler(sourceId) {
     let result;
     try {
       const connector = ConnectorManager.getCurrentConnector(sourceId);
-      const executeOptions = ConnectorManager.getCurrentExecuteOptions(sourceId);
-      const isReadonly = executeOptions.readonly === true;
+      const actualSourceId = connector.getId();
+      const registry = getToolRegistry();
+      const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, actualSourceId);
+      const isReadonly = toolConfig?.readonly === true;
       if (isReadonly && !areAllStatementsReadOnly(sql2, connector.id)) {
-        errorMessage = `Read-only mode is enabled for source '${effectiveSourceId}'. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
+        errorMessage = `Read-only mode is enabled for source '${actualSourceId}'. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
+      const executeOptions = {
+        readonly: isReadonly,
+        max_rows: toolConfig?.max_rows
+      };
       result = await connector.executeSQL(sql2, executeOptions);
       const responseData = {
         rows: result.rows,
@@ -3790,7 +2293,8 @@ import { z as z2 } from "zod";
 var searchDatabaseObjectsSchema = {
   object_type: z2.enum(["schema", "table", "column", "procedure", "index"]).describe("Type of database object to search for"),
   pattern: z2.string().optional().default("%").describe("Search pattern (SQL LIKE syntax: % for wildcard, _ for single char). Case-insensitive. Defaults to '%' (match all)."),
-  schema: z2.string().optional().describe("Filter results to a specific schema/database"),
+  schema: z2.string().optional().describe("Filter results to a specific schema/database (exact match)"),
+  table: z2.string().optional().describe("Filter to a specific table (exact match). Requires schema parameter. Only applies to columns and indexes."),
   detail_level: z2.enum(["names", "summary", "full"]).default("names").describe("Level of detail to return: names (minimal), summary (with metadata), full (complete structure)"),
   limit: z2.number().int().positive().max(1e3).default(100).describe("Maximum number of results to return (default: 100, max: 1000)")
 };
@@ -3913,7 +2417,7 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
   }
   return results;
 }
-async function searchColumns(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchColumns(connector, pattern, schemaFilter, tableFilter, detailLevel, limit) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -3925,8 +2429,13 @@ async function searchColumns(connector, pattern, schemaFilter, detailLevel, limi
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const tables = await connector.getTables(schemaName);
-      for (const tableName of tables) {
+      let tablesToSearch;
+      if (tableFilter) {
+        tablesToSearch = [tableFilter];
+      } else {
+        tablesToSearch = await connector.getTables(schemaName);
+      }
+      for (const tableName of tablesToSearch) {
         if (results.length >= limit) break;
         try {
           const columns = await connector.getTableSchema(tableName, schemaName);
@@ -4008,7 +2517,7 @@ async function searchProcedures(connector, pattern, schemaFilter, detailLevel, l
   }
   return results;
 }
-async function searchIndexes(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchIndexes(connector, pattern, schemaFilter, tableFilter, detailLevel, limit) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -4020,8 +2529,13 @@ async function searchIndexes(connector, pattern, schemaFilter, detailLevel, limi
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const tables = await connector.getTables(schemaName);
-      for (const tableName of tables) {
+      let tablesToSearch;
+      if (tableFilter) {
+        tablesToSearch = [tableFilter];
+      } else {
+        tablesToSearch = await connector.getTables(schemaName);
+      }
+      for (const tableName of tablesToSearch) {
         if (results.length >= limit) break;
         try {
           const indexes = await connector.getTableIndexes(tableName, schemaName);
@@ -4061,11 +2575,26 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
       object_type,
       pattern = "%",
       schema,
+      table,
       detail_level = "names",
       limit = 100
     } = args;
     try {
       const connector = ConnectorManager.getCurrentConnector(sourceId);
+      if (table) {
+        if (!schema) {
+          return createToolErrorResponse(
+            "The 'table' parameter requires 'schema' to be specified",
+            "SCHEMA_REQUIRED"
+          );
+        }
+        if (!["column", "index"].includes(object_type)) {
+          return createToolErrorResponse(
+            `The 'table' parameter only applies to object_type 'column' or 'index', not '${object_type}'`,
+            "INVALID_TABLE_FILTER"
+          );
+        }
+      }
       if (schema) {
         const schemas = await connector.getSchemas();
         if (!schemas.includes(schema)) {
@@ -4084,13 +2613,13 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
           results = await searchTables(connector, pattern, schema, detail_level, limit);
           break;
         case "column":
-          results = await searchColumns(connector, pattern, schema, detail_level, limit);
+          results = await searchColumns(connector, pattern, schema, table, detail_level, limit);
           break;
         case "procedure":
           results = await searchProcedures(connector, pattern, schema, detail_level, limit);
           break;
         case "index":
-          results = await searchIndexes(connector, pattern, schema, detail_level, limit);
+          results = await searchIndexes(connector, pattern, schema, table, detail_level, limit);
           break;
         default:
           return createToolErrorResponse(
@@ -4102,6 +2631,7 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
         object_type,
         pattern,
         schema,
+        table,
         detail_level,
         count: results.length,
         results,
@@ -4151,11 +2681,11 @@ function zodToParameters(schema) {
   }
   return parameters;
 }
-function getToolMetadataForSource(sourceId) {
+function getExecuteSqlMetadata(sourceId) {
   const sourceIds = ConnectorManager.getAvailableSourceIds();
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
   const executeOptions = ConnectorManager.getCurrentExecuteOptions(sourceId);
-  const dbType = sourceConfig?.type || "database";
+  const dbType = sourceConfig.type;
   const toolName = sourceId === "default" ? "execute_sql" : `execute_sql_${normalizeSourceId(sourceId)}`;
   const isDefault = sourceIds[0] === sourceId;
   const title = isDefault ? `Execute SQL (${dbType})` : `Execute SQL on ${sourceId} (${dbType})`;
@@ -4171,9 +2701,8 @@ function getToolMetadataForSource(sourceId) {
     // In readonly mode, queries are more predictable (though still not strictly idempotent due to data changes)
     // In write mode, queries are definitely not idempotent
     idempotentHint: false,
-    // In readonly mode, it's safer to operate on arbitrary tables (just reading)
-    // In write mode, operating on arbitrary tables is more dangerous
-    openWorldHint: isReadonly
+    // Database operations are always against internal/closed systems, not open-world
+    openWorldHint: false
   };
   return {
     name: toolName,
@@ -4182,473 +2711,283 @@ function getToolMetadataForSource(sourceId) {
     annotations
   };
 }
-function getToolsForSource(sourceId) {
-  const metadata = getToolMetadataForSource(sourceId);
-  const parameters = zodToParameters(metadata.schema);
-  return [
-    {
-      name: metadata.name,
-      description: metadata.description,
-      parameters
-    }
-  ];
+function getSearchObjectsMetadata(sourceId, dbType, isDefault) {
+  const toolName = sourceId === "default" ? "search_objects" : `search_objects_${normalizeSourceId(sourceId)}`;
+  const title = isDefault ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
+  const description = `Search and list database objects (schemas, tables, columns, procedures, indexes) on the '${sourceId}' ${dbType} database${isDefault ? " (default)" : ""}. Supports SQL LIKE patterns (default: '%' for all), filtering, and token-efficient progressive disclosure.`;
+  return {
+    name: toolName,
+    description,
+    title
+  };
 }
-
-// src/tools/index.ts
-function registerTools(server) {
-  const sourceIds = ConnectorManager.getAvailableSourceIds();
-  if (sourceIds.length === 0) {
-    throw new Error("No database sources configured");
+function customParamsToToolParams(params) {
+  if (!params || params.length === 0) {
+    return [];
   }
-  for (const sourceId of sourceIds) {
-    const isDefault = sourceIds[0] === sourceId;
-    const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
-    const dbType = sourceConfig?.type || "database";
-    const executeSqlMetadata = getToolMetadataForSource(sourceId);
-    server.registerTool(
-      executeSqlMetadata.name,
+  return params.map((param) => ({
+    name: param.name,
+    type: param.type,
+    required: param.required !== false && param.default === void 0,
+    description: param.description
+  }));
+}
+function buildExecuteSqlTool(sourceId) {
+  const executeSqlMetadata = getExecuteSqlMetadata(sourceId);
+  const executeSqlParameters = zodToParameters(executeSqlMetadata.schema);
+  return {
+    name: executeSqlMetadata.name,
+    description: executeSqlMetadata.description,
+    parameters: executeSqlParameters
+  };
+}
+function buildSearchObjectsTool(sourceId) {
+  const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+  const dbType = sourceConfig.type;
+  const sourceIds = ConnectorManager.getAvailableSourceIds();
+  const isDefault = sourceIds[0] === sourceId;
+  const searchMetadata = getSearchObjectsMetadata(sourceId, dbType, isDefault);
+  return {
+    name: searchMetadata.name,
+    description: searchMetadata.description,
+    parameters: [
       {
-        description: executeSqlMetadata.description,
-        inputSchema: executeSqlMetadata.schema,
-        annotations: executeSqlMetadata.annotations
+        name: "object_type",
+        type: "string",
+        required: true,
+        description: "Type of database object to search for (schema, table, column, procedure, index)"
       },
-      createExecuteSqlToolHandler(sourceId)
-    );
-    const searchToolName = sourceId === "default" ? "search_objects" : `search_objects_${sourceId}`;
-    const searchToolTitle = isDefault ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
-    const searchToolDescription = `Search and list database objects (schemas, tables, columns, procedures, indexes) on the '${sourceId}' ${dbType} database${isDefault ? " (default)" : ""}. Supports SQL LIKE patterns (default: '%' for all), filtering, and token-efficient progressive disclosure.`;
-    server.registerTool(
-      searchToolName,
       {
-        description: searchToolDescription,
-        inputSchema: searchDatabaseObjectsSchema,
-        annotations: {
-          title: searchToolTitle,
-          readOnlyHint: true,
-          destructiveHint: false,
-          idempotentHint: true,
-          // Operation is read-only and idempotent
-          openWorldHint: true
-        }
+        name: "pattern",
+        type: "string",
+        required: false,
+        description: "Search pattern (SQL LIKE syntax: % for wildcard, _ for single char). Case-insensitive. Defaults to '%' (match all)."
       },
-      createSearchDatabaseObjectsToolHandler(sourceId)
-    );
-  }
+      {
+        name: "schema",
+        type: "string",
+        required: false,
+        description: "Filter results to a specific schema/database"
+      },
+      {
+        name: "detail_level",
+        type: "string",
+        required: false,
+        description: "Level of detail to return: names (minimal), summary (with metadata), full (complete structure). Defaults to 'names'."
+      },
+      {
+        name: "limit",
+        type: "integer",
+        required: false,
+        description: "Maximum number of results to return (default: 100, max: 1000)"
+      }
+    ]
+  };
+}
+function buildCustomTool(toolConfig) {
+  return {
+    name: toolConfig.name,
+    description: toolConfig.description,
+    parameters: customParamsToToolParams(toolConfig.parameters)
+  };
+}
+function getToolsForSource(sourceId) {
+  const registry = getToolRegistry();
+  const enabledToolConfigs = registry.getEnabledToolConfigs(sourceId);
+  return enabledToolConfigs.map((toolConfig) => {
+    if (toolConfig.name === "execute_sql") {
+      return buildExecuteSqlTool(sourceId);
+    } else if (toolConfig.name === "search_objects") {
+      return buildSearchObjectsTool(sourceId);
+    } else {
+      return buildCustomTool(toolConfig);
+    }
+  });
 }
 
-// src/prompts/sql-generator.ts
+// src/tools/custom-tool-handler.ts
 import { z as z4 } from "zod";
-var sqlGeneratorSchema = {
-  description: z4.string().describe("Natural language description of the SQL query to generate"),
-  schema: z4.string().optional().describe("Optional database schema to use")
-};
-async function sqlGeneratorPromptHandler({
-  description,
-  schema
-}, _extra) {
-  try {
-    const connector = ConnectorManager.getCurrentConnector();
-    let sqlDialect;
-    switch (connector.id) {
-      case "postgres":
-        sqlDialect = "postgres";
+function buildZodSchemaFromParameters(parameters) {
+  if (!parameters || parameters.length === 0) {
+    return {};
+  }
+  const schemaShape = {};
+  for (const param of parameters) {
+    let fieldSchema;
+    switch (param.type) {
+      case "string":
+        fieldSchema = z4.string().describe(param.description);
+        break;
+      case "integer":
+        fieldSchema = z4.number().int().describe(param.description);
         break;
-      case "sqlite":
-        sqlDialect = "sqlite";
+      case "float":
+        fieldSchema = z4.number().describe(param.description);
         break;
-      case "mysql":
-        sqlDialect = "mysql";
+      case "boolean":
+        fieldSchema = z4.boolean().describe(param.description);
         break;
-      case "sqlserver":
-        sqlDialect = "mssql";
+      case "array":
+        fieldSchema = z4.array(z4.unknown()).describe(param.description);
         break;
       default:
-        sqlDialect = "ansi";
-    }
-    if (schema) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schema)) {
-        return formatPromptErrorResponse(
-          `Schema '${schema}' does not exist or cannot be accessed. Available schemas: ${availableSchemas.join(", ")}`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
+        throw new Error(`Unsupported parameter type: ${param.type}`);
     }
-    try {
-      const tables = await connector.getTables(schema);
-      if (tables.length === 0) {
-        const schemaInfo2 = schema ? `in schema '${schema}'` : "in the database";
-        return formatPromptErrorResponse(
-          `No tables found ${schemaInfo2}. Please check your database connection or schema name.`,
-          "NO_TABLES_FOUND"
-        );
-      }
-      const tableSchemas = await Promise.all(
-        tables.map(async (table) => {
-          try {
-            const columns = await connector.getTableSchema(table, schema);
-            return {
-              table,
-              columns: columns.map((col) => ({
-                name: col.column_name,
-                type: col.data_type
-              }))
-            };
-          } catch (error) {
-            return null;
+    if (param.allowed_values && param.allowed_values.length > 0) {
+      if (param.type === "string") {
+        fieldSchema = z4.enum(param.allowed_values).describe(param.description);
+      } else {
+        fieldSchema = fieldSchema.refine(
+          (val) => param.allowed_values.includes(val),
+          {
+            message: `Value must be one of: ${param.allowed_values.join(", ")}`
           }
-        })
-      );
-      const accessibleSchemas = tableSchemas.filter((schema2) => schema2 !== null);
-      if (accessibleSchemas.length === 0) {
-        return formatPromptErrorResponse(
-          `No accessible tables found. You may not have sufficient permissions to access table schemas.`,
-          "NO_ACCESSIBLE_TABLES"
         );
       }
-      const schemaContext = accessibleSchemas.length > 0 ? `Available tables and their columns:
-${accessibleSchemas.map(
-        (schema2) => `- ${schema2.table}: ${schema2.columns.map((col) => `${col.name} (${col.type})`).join(", ")}`
-      ).join("\n")}` : "No schema information available.";
-      const dialectExamples = {
-        postgres: [
-          "SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ],
-        sqlite: [
-          "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ],
-        mysql: [
-          "SELECT * FROM users WHERE created_at > NOW() - INTERVAL 1 DAY",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ],
-        mssql: [
-          "SELECT * FROM users WHERE created_at > DATEADD(day, -1, GETDATE())",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ],
-        ansi: [
-          "SELECT * FROM users WHERE created_at > CURRENT_TIMESTAMP - INTERVAL '1' DAY",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ]
-      };
-      const schemaInfo = schema ? `in schema '${schema}'` : "across all schemas";
-      const prompt = `
-Generate a ${sqlDialect} SQL query based on this description: "${description}"
-
-${schemaContext}
-Working ${schemaInfo}
-
-The query should:
-1. Be written for ${sqlDialect} dialect
-2. Use only the available tables and columns
-3. Prioritize readability
-4. Include appropriate comments
-5. Be compatible with ${sqlDialect} syntax
-`;
-      let generatedSQL;
-      if (description.toLowerCase().includes("count")) {
-        const schemaPrefix = schema ? `-- Schema: ${schema}
-` : "";
-        generatedSQL = `${schemaPrefix}-- Count query generated from: "${description}"
-SELECT COUNT(*) AS count 
-FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name"};`;
-      } else if (description.toLowerCase().includes("average") || description.toLowerCase().includes("avg")) {
-        const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
-        const numericColumn = accessibleSchemas.length > 0 ? accessibleSchemas[0].columns.find(
-          (col) => ["int", "numeric", "decimal", "float", "real", "double"].some(
-            (t) => col.type.includes(t)
-          )
-        )?.name || "numeric_column" : "numeric_column";
-        const schemaPrefix = schema ? `-- Schema: ${schema}
-` : "";
-        generatedSQL = `${schemaPrefix}-- Average query generated from: "${description}"
-SELECT AVG(${numericColumn}) AS average
-FROM ${table};`;
-      } else if (description.toLowerCase().includes("join")) {
-        const schemaPrefix = schema ? `-- Schema: ${schema}
-` : "";
-        generatedSQL = `${schemaPrefix}-- Join query generated from: "${description}"
-SELECT t1.*, t2.*
-FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"} t1
-JOIN ${accessibleSchemas.length > 1 ? accessibleSchemas[1]?.table : "table2"} t2
-  ON t1.id = t2.${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"}_id;`;
-      } else {
-        const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
-        const schemaPrefix = schema ? `-- Schema: ${schema}
-` : "";
-        generatedSQL = `${schemaPrefix}-- Query generated from: "${description}"
-SELECT * 
-FROM ${table}
-LIMIT 10;`;
-      }
-      return formatPromptSuccessResponse(
-        generatedSQL,
-        // Add references to example queries that could help
-        dialectExamples[sqlDialect]
-      );
-    } catch (error) {
-      return formatPromptErrorResponse(
-        `Error generating SQL query schema information: ${error.message}`,
-        "SCHEMA_RETRIEVAL_ERROR"
-      );
     }
-  } catch (error) {
-    return formatPromptErrorResponse(
-      `Failed to generate SQL: ${error.message}`,
-      "SQL_GENERATION_ERROR"
-    );
+    if (param.default !== void 0 || param.required === false) {
+      fieldSchema = fieldSchema.optional();
+    }
+    schemaShape[param.name] = fieldSchema;
   }
+  return schemaShape;
 }
-
-// src/prompts/db-explainer.ts
-import { z as z5 } from "zod";
-var dbExplainerSchema = {
-  schema: z5.string().optional().describe("Optional database schema to use"),
-  table: z5.string().optional().describe("Optional specific table to explain")
-};
-async function dbExplainerPromptHandler({
-  schema,
-  table
-}, _extra) {
-  try {
-    const connector = ConnectorManager.getCurrentConnector();
-    if (schema) {
-      const availableSchemas = await connector.getSchemas();
-      if (!availableSchemas.includes(schema)) {
-        return formatPromptErrorResponse(
-          `Schema '${schema}' does not exist or cannot be accessed. Available schemas: ${availableSchemas.join(", ")}`,
-          "SCHEMA_NOT_FOUND"
-        );
-      }
-    }
-    const tables = await connector.getTables(schema);
-    const normalizedTable = table?.toLowerCase() || "";
-    const matchingTable = tables.find((t) => t.toLowerCase() === normalizedTable);
-    if (matchingTable && table) {
-      try {
-        const columns = await connector.getTableSchema(matchingTable, schema);
-        if (columns.length === 0) {
-          return formatPromptErrorResponse(
-            `Table '${matchingTable}' exists but has no columns or cannot be accessed.`,
-            "EMPTY_TABLE_SCHEMA"
-          );
-        }
-        const schemaInfo = schema ? ` in schema '${schema}'` : "";
-        const tableDescription = `Table: ${matchingTable}${schemaInfo}
-      
-Structure:
-${columns.map((col) => `- ${col.column_name} (${col.data_type})${col.is_nullable === "YES" ? ", nullable" : ""}${col.column_default ? `, default: ${col.column_default}` : ""}`).join("\n")}
-
-Purpose:
-This table appears to store ${determineTablePurpose(matchingTable, columns)}
-
-Relationships:
-${determineRelationships(matchingTable, columns)}`;
-        return formatPromptSuccessResponse(tableDescription);
-      } catch (error) {
-        return formatPromptErrorResponse(
-          `Error retrieving schema for table '${matchingTable}': ${error.message}`,
-          "TABLE_SCHEMA_ERROR"
-        );
-      }
-    }
-    if (table && table.includes(".")) {
-      const [tableName, columnName] = table.split(".");
-      const tableExists = tables.find((t) => t.toLowerCase() === tableName.toLowerCase());
-      if (!tableExists) {
-        return formatPromptErrorResponse(
-          `Table '${tableName}' does not exist in schema '${schema || "default"}'. Available tables: ${tables.slice(0, 10).join(", ")}${tables.length > 10 ? "..." : ""}`,
-          "TABLE_NOT_FOUND"
-        );
+function createCustomToolHandler(toolConfig) {
+  const zodSchemaShape = buildZodSchemaFromParameters(toolConfig.parameters);
+  const zodSchema = z4.object(zodSchemaShape);
+  return async (args, extra) => {
+    const startTime = Date.now();
+    let success = true;
+    let errorMessage;
+    let paramValues = [];
+    try {
+      const validatedArgs = zodSchema.parse(args);
+      const connector = ConnectorManager.getCurrentConnector(toolConfig.source);
+      const executeOptions = ConnectorManager.getCurrentExecuteOptions(
+        toolConfig.source
+      );
+      const isReadonly = executeOptions.readonly === true;
+      if (isReadonly && !isReadOnlySQL(toolConfig.statement, connector.id)) {
+        errorMessage = `Tool '${toolConfig.name}' cannot execute in readonly mode for source '${toolConfig.source}'. Only read-only SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
+        success = false;
+        return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
-      try {
-        const columns = await connector.getTableSchema(tableName, schema);
-        const column = columns.find(
-          (c) => c.column_name.toLowerCase() === columnName.toLowerCase()
-        );
-        if (column) {
-          const columnDescription = `Column: ${tableName}.${column.column_name}
-          
-Type: ${column.data_type}
-Nullable: ${column.is_nullable === "YES" ? "Yes" : "No"}
-Default: ${column.column_default || "None"}
+      paramValues = mapArgumentsToArray(
+        toolConfig.parameters,
+        validatedArgs
+      );
+      const result = await connector.executeSQL(
+        toolConfig.statement,
+        executeOptions,
+        paramValues
+      );
+      const responseData = {
+        rows: result.rows,
+        count: result.rows.length,
+        source_id: toolConfig.source
+      };
+      return createToolSuccessResponse(responseData);
+    } catch (error) {
+      success = false;
+      errorMessage = error.message;
+      if (error instanceof z4.ZodError) {
+        const issues = error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+        errorMessage = `Parameter validation failed: ${issues}`;
+      } else {
+        errorMessage = `${errorMessage}
 
-Purpose:
-${determineColumnPurpose(column.column_name, column.data_type)}`;
-          return formatPromptSuccessResponse(columnDescription);
-        } else {
-          return formatPromptErrorResponse(
-            `Column '${columnName}' does not exist in table '${tableName}'. Available columns: ${columns.map((c) => c.column_name).join(", ")}`,
-            "COLUMN_NOT_FOUND"
-          );
-        }
-      } catch (error) {
-        return formatPromptErrorResponse(
-          `Error accessing table schema: ${error.message}`,
-          "SCHEMA_ACCESS_ERROR"
-        );
+SQL: ${toolConfig.statement}
+Parameters: ${JSON.stringify(paramValues)}`;
       }
+      return createToolErrorResponse(errorMessage, "EXECUTION_ERROR");
+    } finally {
+      requestStore.add({
+        id: crypto.randomUUID(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceId: toolConfig.source,
+        toolName: toolConfig.name,
+        sql: toolConfig.statement,
+        durationMs: Date.now() - startTime,
+        client: getClientIdentifier(extra),
+        success,
+        error: errorMessage
+      });
     }
-    if (!table || ["database", "db", "schema", "overview", "all"].includes(normalizedTable)) {
-      const schemaInfo = schema ? `in schema '${schema}'` : "across all schemas";
-      let dbOverview = `Database Overview ${schemaInfo}
-
-Tables: ${tables.length}
-${tables.map((t) => `- ${t}`).join("\n")}
-
-This database ${describeDatabasePurpose(tables)}`;
-      return formatPromptSuccessResponse(dbOverview);
-    }
-    if (table && !normalizedTable.includes(".")) {
-      const possibleTableMatches = tables.filter(
-        (t) => t.toLowerCase().includes(normalizedTable) || normalizedTable.includes(t.toLowerCase())
-      );
-      if (possibleTableMatches.length > 0) {
-        return formatPromptSuccessResponse(
-          `Table "${table}" not found. Did you mean one of these tables?
+  };
+}
 
-${possibleTableMatches.join("\n")}`
-        );
+// src/tools/index.ts
+function registerTools(server) {
+  const sourceIds = ConnectorManager.getAvailableSourceIds();
+  if (sourceIds.length === 0) {
+    throw new Error("No database sources configured");
+  }
+  const registry = getToolRegistry();
+  for (const sourceId of sourceIds) {
+    const enabledTools = registry.getEnabledToolConfigs(sourceId);
+    const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+    const dbType = sourceConfig.type;
+    const isDefault = sourceIds[0] === sourceId;
+    for (const toolConfig of enabledTools) {
+      if (toolConfig.name === BUILTIN_TOOL_EXECUTE_SQL) {
+        registerExecuteSqlTool(server, sourceId, dbType);
+      } else if (toolConfig.name === BUILTIN_TOOL_SEARCH_OBJECTS) {
+        registerSearchObjectsTool(server, sourceId, dbType, isDefault);
       } else {
-        const schemaInfo = schema ? `in schema '${schema}'` : "in the database";
-        return formatPromptErrorResponse(
-          `Table "${table}" does not exist ${schemaInfo}. Available tables: ${tables.slice(0, 10).join(", ")}${tables.length > 10 ? "..." : ""}`,
-          "TABLE_NOT_FOUND"
-        );
+        registerCustomTool(server, toolConfig, dbType);
       }
     }
-  } catch (error) {
-    return formatPromptErrorResponse(
-      `Error explaining database: ${error.message}`,
-      "EXPLANATION_ERROR"
-    );
-  }
-  return formatPromptErrorResponse(
-    `Unable to process request for schema: ${schema}, table: ${table}`,
-    "UNHANDLED_REQUEST"
-  );
-}
-function determineTablePurpose(tableName, columns) {
-  const lowerTableName = tableName.toLowerCase();
-  const columnNames = columns.map((c) => c.column_name.toLowerCase());
-  if (lowerTableName.includes("user") || columnNames.includes("username") || columnNames.includes("email")) {
-    return "user information and profiles";
-  }
-  if (lowerTableName.includes("order") || lowerTableName.includes("purchase")) {
-    return "order or purchase transactions";
   }
-  if (lowerTableName.includes("product") || lowerTableName.includes("item")) {
-    return "product or item information";
-  }
-  if (lowerTableName.includes("log") || columnNames.includes("timestamp")) {
-    return "event or activity logs";
-  }
-  if (columnNames.includes("created_at") && columnNames.includes("updated_at")) {
-    return "tracking timestamped data records";
-  }
-  return "data related to " + tableName;
 }
-function determineRelationships(tableName, columns) {
-  const potentialRelationships = [];
-  const idColumns = columns.filter(
-    (c) => c.column_name.toLowerCase().endsWith("_id") && !c.column_name.toLowerCase().startsWith(tableName.toLowerCase())
+function registerExecuteSqlTool(server, sourceId, dbType) {
+  const metadata = getExecuteSqlMetadata(sourceId);
+  server.registerTool(
+    metadata.name,
+    {
+      description: metadata.description,
+      inputSchema: metadata.schema,
+      annotations: metadata.annotations
+    },
+    createExecuteSqlToolHandler(sourceId)
   );
-  if (idColumns.length > 0) {
-    idColumns.forEach((col) => {
-      const referencedTable = col.column_name.toLowerCase().replace("_id", "");
-      potentialRelationships.push(
-        `May have a relationship with the "${referencedTable}" table (via ${col.column_name})`
-      );
-    });
-  }
-  if (columns.some((c) => c.column_name.toLowerCase() === "id")) {
-    potentialRelationships.push(
-      `May be referenced by other tables as "${tableName.toLowerCase()}_id"`
-    );
-  }
-  return potentialRelationships.length > 0 ? potentialRelationships.join("\n") : "No obvious relationships identified based on column names";
-}
-function determineColumnPurpose(columnName, dataType) {
-  const lowerColumnName = columnName.toLowerCase();
-  if (lowerColumnName === "id") {
-    return "Primary identifier for records in this table";
-  }
-  if (lowerColumnName.endsWith("_id")) {
-    const referencedTable = lowerColumnName.replace("_id", "");
-    return `Foreign key reference to the "${referencedTable}" table`;
-  }
-  if (lowerColumnName.includes("name")) {
-    return "Stores name information";
-  }
-  if (lowerColumnName.includes("email")) {
-    return "Stores email address information";
-  }
-  if (lowerColumnName.includes("password") || lowerColumnName.includes("hash")) {
-    return "Stores security credential information (likely hashed)";
-  }
-  if (lowerColumnName === "created_at" || lowerColumnName === "created_on") {
-    return "Timestamp for when the record was created";
-  }
-  if (lowerColumnName === "updated_at" || lowerColumnName === "modified_at") {
-    return "Timestamp for when the record was last updated";
-  }
-  if (lowerColumnName.includes("date") || lowerColumnName.includes("time")) {
-    return "Stores date or time information";
-  }
-  if (lowerColumnName.includes("price") || lowerColumnName.includes("cost") || lowerColumnName.includes("amount")) {
-    return "Stores monetary value information";
-  }
-  if (dataType.includes("boolean")) {
-    return "Stores a true/false flag";
-  }
-  if (dataType.includes("json")) {
-    return "Stores structured JSON data";
-  }
-  if (dataType.includes("text") || dataType.includes("varchar") || dataType.includes("char")) {
-    return "Stores text information";
-  }
-  return `Stores ${dataType} data`;
 }
-function describeDatabasePurpose(tables) {
-  const tableNames = tables.map((t) => t.toLowerCase());
-  if (tableNames.some((t) => t.includes("user")) && tableNames.some((t) => t.includes("order"))) {
-    return "appears to be an e-commerce or customer order management system";
-  }
-  if (tableNames.some((t) => t.includes("patient")) || tableNames.some((t) => t.includes("medical"))) {
-    return "appears to be related to healthcare or medical record management";
-  }
-  if (tableNames.some((t) => t.includes("student")) || tableNames.some((t) => t.includes("course"))) {
-    return "appears to be related to education or student management";
-  }
-  if (tableNames.some((t) => t.includes("employee")) || tableNames.some((t) => t.includes("payroll"))) {
-    return "appears to be related to HR or employee management";
-  }
-  if (tableNames.some((t) => t.includes("inventory")) || tableNames.some((t) => t.includes("stock"))) {
-    return "appears to be related to inventory or stock management";
-  }
-  return "contains multiple tables that store related information";
-}
-
-// src/prompts/index.ts
-function registerPrompts(server) {
-  server.prompt(
-    "generate_sql",
-    "Generate SQL queries from natural language descriptions",
-    sqlGeneratorSchema,
-    sqlGeneratorPromptHandler
+function registerSearchObjectsTool(server, sourceId, dbType, isDefault) {
+  const metadata = getSearchObjectsMetadata(sourceId, dbType, isDefault);
+  server.registerTool(
+    metadata.name,
+    {
+      description: metadata.description,
+      inputSchema: searchDatabaseObjectsSchema,
+      annotations: {
+        title: metadata.title,
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    createSearchDatabaseObjectsToolHandler(sourceId)
   );
-  server.prompt(
-    "explain_db",
-    "Get explanations about database tables, columns, and structures",
-    dbExplainerSchema,
-    dbExplainerPromptHandler
+}
+function registerCustomTool(server, toolConfig, dbType) {
+  const isReadOnly = isReadOnlySQL(toolConfig.statement, dbType);
+  const zodSchema = buildZodSchemaFromParameters(toolConfig.parameters);
+  server.registerTool(
+    toolConfig.name,
+    {
+      description: toolConfig.description,
+      inputSchema: zodSchema,
+      annotations: {
+        title: `${toolConfig.name} (${dbType})`,
+        readOnlyHint: isReadOnly,
+        destructiveHint: !isReadOnly,
+        idempotentHint: isReadOnly,
+        openWorldHint: false
+      }
+    },
+    createCustomToolHandler(toolConfig)
   );
+  console.error(`  - ${toolConfig.name} \u2192 ${toolConfig.source} (${dbType})`);
 }
 
 // src/api/sources.ts
@@ -4759,11 +3098,127 @@ function listRequests(req, res) {
   }
 }
 
+// src/utils/startup-table.ts
+var BOX = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  leftT: "\u251C",
+  rightT: "\u2524",
+  bullet: "\u2022"
+};
+function parseHostAndDatabase(source) {
+  if (source.dsn) {
+    const parsed = parseConnectionInfoFromDSN(source.dsn);
+    if (parsed) {
+      if (parsed.type === "sqlite") {
+        return { host: "", database: parsed.database || ":memory:" };
+      }
+      if (!parsed.host) {
+        return { host: "", database: parsed.database || "" };
+      }
+      const port = parsed.port ?? getDefaultPortForType(parsed.type);
+      const host2 = port ? `${parsed.host}:${port}` : parsed.host;
+      return { host: host2, database: parsed.database || "" };
+    }
+    return { host: "unknown", database: "" };
+  }
+  const host = source.host ? source.port ? `${source.host}:${source.port}` : source.host : "";
+  const database = source.database || "";
+  return { host, database };
+}
+function horizontalLine(width, left, right) {
+  return left + BOX.horizontal.repeat(width - 2) + right;
+}
+function fitString(str, width) {
+  if (str.length > width) {
+    return str.slice(0, width - 1) + "\u2026";
+  }
+  return str.padEnd(width);
+}
+function formatHostDatabase(host, database) {
+  return host ? database ? `${host}/${database}` : host : database || "";
+}
+function generateStartupTable(sources) {
+  if (sources.length === 0) {
+    return "";
+  }
+  const idTypeWidth = Math.max(
+    20,
+    ...sources.map((s) => `${s.id} (${s.type})`.length)
+  );
+  const hostDbWidth = Math.max(
+    24,
+    ...sources.map((s) => formatHostDatabase(s.host, s.database).length)
+  );
+  const modeWidth = Math.max(
+    10,
+    ...sources.map((s) => {
+      const modes = [];
+      if (s.isDemo) modes.push("DEMO");
+      if (s.readonly) modes.push("READ-ONLY");
+      return modes.join(" ").length;
+    })
+  );
+  const totalWidth = 2 + idTypeWidth + 3 + hostDbWidth + 3 + modeWidth + 2;
+  const lines = [];
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    const isFirst = i === 0;
+    const isLast = i === sources.length - 1;
+    if (isFirst) {
+      lines.push(horizontalLine(totalWidth, BOX.topLeft, BOX.topRight));
+    }
+    const idType = fitString(`${source.id} (${source.type})`, idTypeWidth);
+    const hostDb = fitString(
+      formatHostDatabase(source.host, source.database),
+      hostDbWidth
+    );
+    const modes = [];
+    if (source.isDemo) modes.push("DEMO");
+    if (source.readonly) modes.push("READ-ONLY");
+    const modeStr = fitString(modes.join(" "), modeWidth);
+    lines.push(
+      `${BOX.vertical} ${idType} ${BOX.vertical} ${hostDb} ${BOX.vertical} ${modeStr} ${BOX.vertical}`
+    );
+    lines.push(horizontalLine(totalWidth, BOX.leftT, BOX.rightT));
+    for (const tool of source.tools) {
+      const toolLine = `  ${BOX.bullet} ${tool}`;
+      lines.push(
+        `${BOX.vertical} ${fitString(toolLine, totalWidth - 4)} ${BOX.vertical}`
+      );
+    }
+    if (isLast) {
+      lines.push(horizontalLine(totalWidth, BOX.bottomLeft, BOX.bottomRight));
+    } else {
+      lines.push(horizontalLine(totalWidth, BOX.leftT, BOX.rightT));
+    }
+  }
+  return lines.join("\n");
+}
+function buildSourceDisplayInfo(sourceConfigs, getToolsForSource2, isDemo) {
+  return sourceConfigs.map((source) => {
+    const { host, database } = parseHostAndDatabase(source);
+    return {
+      id: source.id,
+      type: source.type || "sqlite",
+      host,
+      database,
+      readonly: source.readonly || false,
+      isDemo,
+      tools: getToolsForSource2(source.id)
+    };
+  });
+}
+
 // src/server.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-var packageJsonPath = path3.join(__dirname2, "..", "package.json");
-var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var packageJsonPath = path.join(__dirname, "..", "package.json");
+var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
 function generateBanner(version, modes = []) {
@@ -4776,7 +3231,7 @@ function generateBanner(version, modes = []) {
 | |__| | |_) | | | | |_| | |_) |
 |_____/|____/|_| |_|\\__,_|_.__/ 
                                 
-v${version}${modeText} - Universal Database MCP Server
+v${version}${modeText} - Minimal Database MCP Server
 `;
 }
 async function main() {
@@ -4807,16 +3262,6 @@ See documentation for more details on configuring database connections.
 `);
       process.exit(1);
     }
-    const createServer2 = () => {
-      const server = new McpServer2({
-        name: SERVER_NAME,
-        version: SERVER_VERSION
-      });
-      registerResources(server);
-      registerTools(server);
-      registerPrompts(server);
-      return server;
-    };
     const connectorManager = new ConnectorManager();
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
@@ -4826,13 +3271,22 @@ See documentation for more details on configuring database connections.
       console.error(`  - ${source.id}: ${redactDSN(dsn)}`);
     }
     await connectorManager.connectWithSources(sources);
+    const { initializeToolRegistry } = await import("./registry-AWAIN6WO.js");
+    initializeToolRegistry({
+      sources: sourceConfigsData.sources,
+      tools: sourceConfigsData.tools
+    });
+    console.error("Tool registry initialized");
+    const createServer = () => {
+      const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION
+      });
+      registerTools(server);
+      return server;
+    };
     const transportData = resolveTransport();
-    console.error(`MCP transport: ${transportData.type}`);
-    const portData = transportData.type === "http" ? resolvePort() : null;
-    if (portData) {
-      console.error(`HTTP server port: ${portData.port} (source: ${portData.source})`);
-    }
-    const readonly = isReadOnlyMode();
+    const port = transportData.type === "http" ? resolvePort().port : null;
     const activeModes = [];
     const modeDescriptions = [];
     const isDemo = isDemoMode();
@@ -4840,19 +3294,17 @@ See documentation for more details on configuring database connections.
       activeModes.push("DEMO");
       modeDescriptions.push("using sample employee database");
     }
-    if (readonly) {
-      activeModes.push("READ-ONLY");
-      modeDescriptions.push("only read only queries allowed");
-    }
-    if (sources.length > 1) {
-      console.error(`Multi-source mode: ${sources.length} databases configured`);
-    }
     if (activeModes.length > 0) {
       console.error(`Running in ${activeModes.join(" and ")} mode - ${modeDescriptions.join(", ")}`);
     }
     console.error(generateBanner(SERVER_VERSION, activeModes));
+    const sourceDisplayInfos = buildSourceDisplayInfo(
+      sources,
+      (sourceId) => getToolsForSource(sourceId).map((t) => t.name),
+      isDemo
+    );
+    console.error(generateStartupTable(sourceDisplayInfos));
     if (transportData.type === "http") {
-      const port = portData.port;
       const app = express();
       app.use(express.json());
       app.use((req, res, next) => {
@@ -4869,7 +3321,7 @@ See documentation for more details on configuring database connections.
         }
         next();
       });
-      const frontendPath = path3.join(__dirname2, "public");
+      const frontendPath = path.join(__dirname, "public");
       app.use(express.static(frontendPath));
       app.get("/healthz", (req, res) => {
         res.status(200).send("OK");
@@ -4891,7 +3343,7 @@ See documentation for more details on configuring database connections.
             enableJsonResponse: true
             // Use JSON responses (SSE not supported in stateless mode)
           });
-          const server = createServer2();
+          const server = createServer();
           await server.connect(transport);
           await transport.handleRequest(req, res, req.body);
         } catch (error) {
@@ -4903,7 +3355,7 @@ See documentation for more details on configuring database connections.
       });
       if (process.env.NODE_ENV !== "development") {
         app.get("*", (req, res) => {
-          res.sendFile(path3.join(frontendPath, "index.html"));
+          res.sendFile(path.join(frontendPath, "index.html"));
         });
       }
       app.listen(port, "0.0.0.0", () => {
@@ -4918,7 +3370,7 @@ See documentation for more details on configuring database connections.
         console.error(`MCP server endpoint at http://0.0.0.0:${port}/mcp`);
       });
     } else {
-      const server = createServer2();
+      const server = createServer();
       const transport = new StdioServerTransport();
       await server.connect(transport);
       console.error("MCP server running on stdio");