@bytebase/dbhub 0.11.10 → 0.13.0

package/dist/index.js

@@ -1,205 +1,33 @@
 #!/usr/bin/env node
+import {
+  getToolRegistry
+} from "./chunk-VWZF5OAJ.js";
+import {
+  ConnectorManager,
+  ConnectorRegistry,
+  SafeURL,
+  buildDSNFromSource,
+  customToolRegistry,
+  getDatabaseTypeFromDSN,
+  getDefaultPortForType,
+  isDemoMode,
+  mapArgumentsToArray,
+  obfuscateDSNPassword,
+  parseConnectionInfoFromDSN,
+  redactDSN,
+  resolvePort,
+  resolveSourceConfigs,
+  resolveTransport,
+  stripCommentsAndStrings
+} from "./chunk-WSLDVMBA.js";
+import {
+  BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_SEARCH_OBJECTS
+} from "./chunk-D23WQQY7.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 obfuscateDSNPassword(dsn) {
-  if (!dsn) {
-    return dsn;
-  }
-  try {
-    const protocolMatch = dsn.match(/^([^:]+):/);
-    if (!protocolMatch) {
-      return dsn;
-    }
-    const protocol = protocolMatch[1];
-    if (protocol === "sqlite") {
-      return dsn;
-    }
-    const protocolPart = dsn.split("://")[1];
-    if (!protocolPart) {
-      return dsn;
-    }
-    const lastAtIndex = protocolPart.lastIndexOf("@");
-    if (lastAtIndex === -1) {
-      return dsn;
-    }
-    const credentialsPart = protocolPart.substring(0, lastAtIndex);
-    const hostPart = protocolPart.substring(lastAtIndex + 1);
-    const colonIndex = credentialsPart.indexOf(":");
-    if (colonIndex === -1) {
-      return dsn;
-    }
-    const username = credentialsPart.substring(0, colonIndex);
-    const password = credentialsPart.substring(colonIndex + 1);
-    const obfuscatedPassword = "*".repeat(Math.min(password.length, 8));
-    return `${protocol}://${username}:${obfuscatedPassword}@${hostPart}`;
-  } catch (error) {
-    return dsn;
-  }
-}
-function getDatabaseTypeFromDSN(dsn) {
-  if (!dsn) {
-    return void 0;
-  }
-  const protocol = dsn.split(":")[0];
-  const protocolToType = {
-    "postgres": "postgres",
-    "postgresql": "postgres",
-    "mysql": "mysql",
-    "mariadb": "mariadb",
-    "sqlserver": "sqlserver",
-    "sqlite": "sqlite"
-  };
-  return protocolToType[protocol];
-}
-
 // src/utils/sql-row-limiter.ts
 var SQLRowLimiter = class {
   /**
@@ -211,34 +39,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);
     }
@@ -271,13 +107,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);
   }
   /**
@@ -353,6 +210,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();
@@ -360,9 +222,11 @@ var PostgresConnector = class _PostgresConnector {
   async connect(dsn, initScript, config) {
     try {
       const poolConfig = await this.dsnParser.parse(dsn, config);
+      if (config?.readonly) {
+        poolConfig.options = (poolConfig.options || "") + " -c default_transaction_read_only=on";
+      }
       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);
@@ -607,7 +471,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");
     }
@@ -616,8 +480,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 {
@@ -740,6 +617,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();
@@ -982,16 +864,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) => ({
@@ -1009,6 +924,38 @@ ConnectorRegistry.register(sqlServerConnector);
 
 // src/connectors/sqlite/index.ts
 import Database from "better-sqlite3";
+
+// src/utils/identifier-quoter.ts
+function quoteIdentifier(identifier, dbType) {
+  if (/[\0\x08\x09\x1a\n\r]/.test(identifier)) {
+    throw new Error(`Invalid identifier: contains control characters: ${identifier}`);
+  }
+  if (!identifier) {
+    throw new Error("Identifier cannot be empty");
+  }
+  switch (dbType) {
+    case "postgres":
+    case "sqlite":
+      return `"${identifier.replace(/"/g, '""')}"`;
+    case "mysql":
+    case "mariadb":
+      return `\`${identifier.replace(/`/g, "``")}\``;
+    case "sqlserver":
+      return `[${identifier.replace(/]/g, "]]")}]`;
+    default:
+      return `"${identifier.replace(/"/g, '""')}"`;
+  }
+}
+function quoteQualifiedIdentifier(tableName, schemaName, dbType) {
+  const quotedTable = quoteIdentifier(tableName, dbType);
+  if (schemaName) {
+    const quotedSchema = quoteIdentifier(schemaName, dbType);
+    return `${quotedSchema}.${quotedTable}`;
+  }
+  return quotedTable;
+}
+
+// src/connectors/sqlite/index.ts
 var SQLiteDSNParser = class {
   async parse(dsn, config) {
     if (!this.isValidDSN(dsn)) {
@@ -1059,8 +1006,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();
   }
@@ -1073,11 +1025,13 @@ var SQLiteConnector = class _SQLiteConnector {
     const parsedConfig = await this.dsnParser.parse(dsn, config);
     this.dbPath = parsedConfig.dbPath;
     try {
-      this.db = new Database(this.dbPath);
-      console.error("Successfully connected to SQLite database");
+      const dbOptions = {};
+      if (config?.readonly && this.dbPath !== ":memory:") {
+        dbOptions.readonly = true;
+      }
+      this.db = new Database(this.dbPath, dbOptions);
       if (initScript) {
         this.db.exec(initScript);
-        console.error("Successfully initialized database with script");
       }
     } catch (error) {
       console.error("Failed to connect to SQLite database:", error);
@@ -1158,16 +1112,18 @@ var SQLiteConnector = class _SQLiteConnector {
         AND tbl_name = ?
       `
       ).all(tableName);
-      const indexListRows = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
+      const quotedTableName = quoteIdentifier(tableName, "sqlite");
+      const indexListRows = this.db.prepare(`PRAGMA index_list(${quotedTableName})`).all();
       const indexUniqueMap = /* @__PURE__ */ new Map();
       for (const indexListRow of indexListRows) {
         indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
       }
-      const tableInfo = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const tableInfo = this.db.prepare(`PRAGMA table_info(${quotedTableName})`).all();
       const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
       const results = [];
       for (const indexInfo of indexInfoRows) {
-        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${indexInfo.index_name})`).all();
+        const quotedIndexName = quoteIdentifier(indexInfo.index_name, "sqlite");
+        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${quotedIndexName})`).all();
         const columnNames = indexDetailRows.map((row) => row.name);
         results.push({
           index_name: indexInfo.index_name,
@@ -1194,7 +1150,8 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const rows = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const quotedTableName = quoteIdentifier(tableName, "sqlite");
+      const rows = this.db.prepare(`PRAGMA table_info(${quotedTableName})`).all();
       const columns = rows.map((row) => ({
         column_name: row.name,
         data_type: row.type,
@@ -1221,7 +1178,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");
     }
@@ -1235,13 +1192,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) {
@@ -1373,6 +1356,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();
@@ -1382,7 +1370,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;
@@ -1664,7 +1651,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");
     }
@@ -1681,7 +1668,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 };
@@ -1760,6 +1759,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();
@@ -1768,9 +1772,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;
@@ -2052,7 +2054,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");
     }
@@ -2069,7 +2071,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) {
@@ -2084,1909 +2098,866 @@ 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/client-identifier.ts
+function getClientIdentifier(extra) {
+  const userAgent = extra?.requestInfo?.headers?.["user-agent"];
+  if (userAgent) {
+    return userAgent;
+  }
+  return "stdio";
+}
 
-// 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;
+// 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 fileExists(filePath) {
-  try {
-    return existsSync(expandTilde(filePath));
-  } catch {
-    return false;
-  }
+function areAllStatementsReadOnly(sql2, connectorType) {
+  const statements = splitSQLStatements(sql2);
+  return statements.every((statement) => isReadOnlySQL(statement, connectorType));
 }
-function findDefaultSSHKey() {
-  for (const keyPath of DEFAULT_SSH_KEYS) {
-    if (fileExists(keyPath)) {
-      return expandTilde(keyPath);
+function createExecuteSqlToolHandler(sourceId) {
+  return async (args, extra) => {
+    const { sql: sql2 } = args;
+    const startTime = Date.now();
+    const effectiveSourceId = sourceId || "default";
+    let success = true;
+    let errorMessage;
+    let result;
+    try {
+      const connector = ConnectorManager.getCurrentConnector(sourceId);
+      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 '${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,
+        count: result.rows.length,
+        source_id: effectiveSourceId
+      };
+      return createToolSuccessResponse(responseData);
+    } catch (error) {
+      success = false;
+      errorMessage = error.message;
+      return createToolErrorResponse(errorMessage, "EXECUTION_ERROR");
+    } finally {
+      requestStore.add({
+        id: crypto.randomUUID(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceId: effectiveSourceId,
+        toolName: effectiveSourceId === "default" ? "execute_sql" : `execute_sql_${effectiveSourceId}`,
+        sql: sql2,
+        durationMs: Date.now() - startTime,
+        client: getClientIdentifier(extra),
+        success,
+        error: errorMessage
+      });
     }
-  }
-  return void 0;
+  };
 }
-function parseSSHConfig(hostAlias, configPath) {
-  const sshConfigPath = configPath;
-  if (!existsSync(sshConfigPath)) {
-    return null;
-  }
+
+// src/tools/search-objects.ts
+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"),
+  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)")
+};
+function likePatternToRegex(pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+async function getTableRowCount(connector, tableName, schemaName) {
   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");
+    const qualifiedTable = quoteQualifiedIdentifier(tableName, schemaName, connector.id);
+    const countQuery = `SELECT COUNT(*) as count FROM ${qualifiedTable}`;
+    const result = await connector.executeSQL(countQuery, { maxRows: 1 });
+    if (result.rows && result.rows.length > 0) {
+      return Number(result.rows[0].count || result.rows[0].COUNT || 0);
     }
-    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;
   }
+  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;
+async function searchSchemas(connector, pattern, detailLevel, limit) {
+  const schemas = await connector.getSchemas();
+  const regex = likePatternToRegex(pattern);
+  const matched = schemas.filter((schema) => regex.test(schema)).slice(0, limit);
+  if (detailLevel === "names") {
+    return matched.map((name) => ({ name }));
   }
-  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":
+  const results = await Promise.all(
+    matched.map(async (schemaName) => {
+      try {
+        const tables = await connector.getTables(schemaName);
         return {
-          dsn: `sqlite:///${dbName}`,
-          source: "individual environment variables"
+          name: schemaName,
+          table_count: tables.length
+        };
+      } catch (error) {
+        return {
+          name: schemaName,
+          table_count: 0
         };
-      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) {
-      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 source = {
-      id: "default",
-      type: dbType,
-      dsn: dsnResult.dsn
-    };
-    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))}`;
-    }
-    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 || (source.type === "postgres" ? 5432 : source.type === "mysql" || source.type === "mariadb" ? 3306 : source.type === "sqlserver" ? 1433 : void 0);
-  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;
-    }
-    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) {
-    if (dsn.startsWith("postgres://") || dsn.startsWith("postgresql://")) {
-      return 5432;
-    } else if (dsn.startsWith("mysql://")) {
-      return 3306;
-    } else if (dsn.startsWith("mariadb://")) {
-      return 3306;
-    } else if (dsn.startsWith("sqlserver://")) {
-      return 1433;
-    }
-    return 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/tools/execute-sql.ts
-var executeSqlSchema = {
-  sql: z.string().describe("SQL query or multiple SQL statements to execute (separated by semicolons)"),
-  source_id: z.string().optional().describe("Database source ID to execute the query against (optional, defaults to first configured source)")
-};
-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);
-}
-function areAllStatementsReadOnly(sql2, connectorType) {
-  const statements = splitSQLStatements(sql2);
-  return statements.every((statement) => isReadOnlySQL(statement, connectorType));
-}
-async function executeSqlToolHandler({ sql: sql2, source_id }, _extra) {
-  try {
-    const connector = ConnectorManager.getCurrentConnector(source_id);
-    const executeOptions = ConnectorManager.getCurrentExecuteOptions(source_id);
-    if (isReadOnlyMode() && !areAllStatementsReadOnly(sql2, connector.id)) {
-      return createToolErrorResponse(
-        `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`,
-        "READONLY_VIOLATION"
-      );
-    }
-    const result = await connector.executeSQL(sql2, executeOptions);
-    const responseData = {
-      rows: result.rows,
-      count: result.rows.length,
-      source_id: source_id || "(default)"
-      // Include source_id in response for clarity
-    };
-    return createToolSuccessResponse(responseData);
-  } catch (error) {
-    return createToolErrorResponse(error.message, "EXECUTION_ERROR");
-  }
-}
-
-// src/tools/index.ts
-function registerTools(server, id) {
-  const toolName = id ? `execute_sql_${id}` : "execute_sql";
-  server.tool(
-    toolName,
-    "Execute a SQL query on the current database",
-    executeSqlSchema,
-    executeSqlToolHandler
-  );
-}
-
-// src/prompts/sql-generator.ts
-import { z as z2 } from "zod";
-var sqlGeneratorSchema = {
-  description: z2.string().describe("Natural language description of the SQL query to generate"),
-  schema: z2.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";
-        break;
-      case "sqlite":
-        sqlDialect = "sqlite";
-        break;
-      case "mysql":
-        sqlDialect = "mysql";
-        break;
-      case "sqlserver":
-        sqlDialect = "mssql";
-        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"
-        );
       }
-    }
+    })
+  );
+  return results;
+}
+async function searchTables(connector, pattern, schemaFilter, detailLevel, limit) {
+  const regex = likePatternToRegex(pattern);
+  const results = [];
+  let schemasToSearch;
+  if (schemaFilter) {
+    schemasToSearch = [schemaFilter];
+  } else {
+    schemasToSearch = await connector.getSchemas();
+  }
+  for (const schemaName of schemasToSearch) {
+    if (results.length >= limit) break;
     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) => {
+      const tables = await connector.getTables(schemaName);
+      const matched = tables.filter((table) => regex.test(table));
+      for (const tableName of matched) {
+        if (results.length >= limit) break;
+        if (detailLevel === "names") {
+          results.push({
+            name: tableName,
+            schema: schemaName
+          });
+        } else if (detailLevel === "summary") {
+          try {
+            const columns = await connector.getTableSchema(tableName, schemaName);
+            const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            results.push({
+              name: tableName,
+              schema: schemaName,
+              column_count: columns.length,
+              row_count: rowCount
+            });
+          } catch (error) {
+            results.push({
+              name: tableName,
+              schema: schemaName,
+              column_count: null,
+              row_count: null
+            });
+          }
+        } else {
           try {
-            const columns = await connector.getTableSchema(table, schema);
-            return {
-              table,
+            const columns = await connector.getTableSchema(tableName, schemaName);
+            const indexes = await connector.getTableIndexes(tableName, schemaName);
+            const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            results.push({
+              name: tableName,
+              schema: schemaName,
+              column_count: columns.length,
+              row_count: rowCount,
               columns: columns.map((col) => ({
                 name: col.column_name,
-                type: col.data_type
+                type: col.data_type,
+                nullable: col.is_nullable === "YES",
+                default: col.column_default
+              })),
+              indexes: indexes.map((idx) => ({
+                name: idx.index_name,
+                columns: idx.column_names,
+                unique: idx.is_unique,
+                primary: idx.is_primary
               }))
-            };
+            });
           } catch (error) {
-            return null;
+            results.push({
+              name: tableName,
+              schema: schemaName,
+              error: `Unable to fetch full details: ${error.message}`
+            });
           }
-        })
-      );
-      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"
-      );
+      continue;
     }
-  } catch (error) {
-    return formatPromptErrorResponse(
-      `Failed to generate SQL: ${error.message}`,
-      "SQL_GENERATION_ERROR"
-    );
   }
+  return results;
 }
-
-// src/prompts/db-explainer.ts
-import { z as z3 } from "zod";
-var dbExplainerSchema = {
-  schema: z3.string().optional().describe("Optional database schema to use"),
-  table: z3.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"
-        );
+async function searchColumns(connector, pattern, schemaFilter, detailLevel, limit) {
+  const regex = likePatternToRegex(pattern);
+  const results = [];
+  let schemasToSearch;
+  if (schemaFilter) {
+    schemasToSearch = [schemaFilter];
+  } else {
+    schemasToSearch = await connector.getSchemas();
+  }
+  for (const schemaName of schemasToSearch) {
+    if (results.length >= limit) break;
+    try {
+      const tables = await connector.getTables(schemaName);
+      for (const tableName of tables) {
+        if (results.length >= limit) break;
+        try {
+          const columns = await connector.getTableSchema(tableName, schemaName);
+          const matchedColumns = columns.filter((col) => regex.test(col.column_name));
+          for (const column of matchedColumns) {
+            if (results.length >= limit) break;
+            if (detailLevel === "names") {
+              results.push({
+                name: column.column_name,
+                table: tableName,
+                schema: schemaName
+              });
+            } else {
+              results.push({
+                name: column.column_name,
+                table: tableName,
+                schema: schemaName,
+                type: column.data_type,
+                nullable: column.is_nullable === "YES",
+                default: column.column_default
+              });
+            }
+          }
+        } catch (error) {
+          continue;
+        }
       }
+    } catch (error) {
+      continue;
     }
-    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"
-          );
+  }
+  return results;
+}
+async function searchProcedures(connector, pattern, schemaFilter, detailLevel, limit) {
+  const regex = likePatternToRegex(pattern);
+  const results = [];
+  let schemasToSearch;
+  if (schemaFilter) {
+    schemasToSearch = [schemaFilter];
+  } else {
+    schemasToSearch = await connector.getSchemas();
+  }
+  for (const schemaName of schemasToSearch) {
+    if (results.length >= limit) break;
+    try {
+      const procedures = await connector.getStoredProcedures(schemaName);
+      const matched = procedures.filter((proc) => regex.test(proc));
+      for (const procName of matched) {
+        if (results.length >= limit) break;
+        if (detailLevel === "names") {
+          results.push({
+            name: procName,
+            schema: schemaName
+          });
+        } else {
+          try {
+            const details = await connector.getStoredProcedureDetail(procName, schemaName);
+            results.push({
+              name: procName,
+              schema: schemaName,
+              type: details.procedure_type,
+              language: details.language,
+              parameters: detailLevel === "full" ? details.parameter_list : void 0,
+              return_type: details.return_type,
+              definition: detailLevel === "full" ? details.definition : void 0
+            });
+          } catch (error) {
+            results.push({
+              name: procName,
+              schema: schemaName,
+              error: `Unable to fetch details: ${error.message}`
+            });
+          }
         }
-        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"
-        );
       }
+    } catch (error) {
+      continue;
     }
-    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"
-        );
+  }
+  return results;
+}
+async function searchIndexes(connector, pattern, schemaFilter, detailLevel, limit) {
+  const regex = likePatternToRegex(pattern);
+  const results = [];
+  let schemasToSearch;
+  if (schemaFilter) {
+    schemasToSearch = [schemaFilter];
+  } else {
+    schemasToSearch = await connector.getSchemas();
+  }
+  for (const schemaName of schemasToSearch) {
+    if (results.length >= limit) break;
+    try {
+      const tables = await connector.getTables(schemaName);
+      for (const tableName of tables) {
+        if (results.length >= limit) break;
+        try {
+          const indexes = await connector.getTableIndexes(tableName, schemaName);
+          const matchedIndexes = indexes.filter((idx) => regex.test(idx.index_name));
+          for (const index of matchedIndexes) {
+            if (results.length >= limit) break;
+            if (detailLevel === "names") {
+              results.push({
+                name: index.index_name,
+                table: tableName,
+                schema: schemaName
+              });
+            } else {
+              results.push({
+                name: index.index_name,
+                table: tableName,
+                schema: schemaName,
+                columns: index.column_names,
+                unique: index.is_unique,
+                primary: index.is_primary
+              });
+            }
+          }
+        } catch (error) {
+          continue;
+        }
       }
-      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"}
-
-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) {
+      continue;
+    }
+  }
+  return results;
+}
+function createSearchDatabaseObjectsToolHandler(sourceId) {
+  return async (args, _extra) => {
+    const {
+      object_type,
+      pattern = "%",
+      schema,
+      detail_level = "names",
+      limit = 100
+    } = args;
+    try {
+      const connector = ConnectorManager.getCurrentConnector(sourceId);
+      if (schema) {
+        const schemas = await connector.getSchemas();
+        if (!schemas.includes(schema)) {
+          return createToolErrorResponse(
+            `Schema '${schema}' does not exist. Available schemas: ${schemas.join(", ")}`,
+            "SCHEMA_NOT_FOUND"
           );
         }
-      } catch (error) {
-        return formatPromptErrorResponse(
-          `Error accessing table schema: ${error.message}`,
-          "SCHEMA_ACCESS_ERROR"
-        );
       }
+      let results = [];
+      switch (object_type) {
+        case "schema":
+          results = await searchSchemas(connector, pattern, detail_level, limit);
+          break;
+        case "table":
+          results = await searchTables(connector, pattern, schema, detail_level, limit);
+          break;
+        case "column":
+          results = await searchColumns(connector, pattern, schema, 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);
+          break;
+        default:
+          return createToolErrorResponse(
+            `Unsupported object_type: ${object_type}`,
+            "INVALID_OBJECT_TYPE"
+          );
+      }
+      return createToolSuccessResponse({
+        object_type,
+        pattern,
+        schema,
+        detail_level,
+        count: results.length,
+        results,
+        truncated: results.length === limit
+      });
+    } catch (error) {
+      return createToolErrorResponse(
+        `Error searching database objects: ${error.message}`,
+        "SEARCH_ERROR"
+      );
     }
-    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")}
+// src/utils/tool-metadata.ts
+import { z as z3 } from "zod";
+
+// src/utils/normalize-id.ts
+function normalizeSourceId(id) {
+  return id.replace(/[^a-zA-Z0-9]/g, "_");
+}
 
-This database ${describeDatabasePurpose(tables)}`;
-      return formatPromptSuccessResponse(dbOverview);
+// src/utils/tool-metadata.ts
+function zodToParameters(schema) {
+  const parameters = [];
+  for (const [key, zodType] of Object.entries(schema)) {
+    const description = zodType.description || "";
+    const required = !(zodType instanceof z3.ZodOptional);
+    let type = "string";
+    if (zodType instanceof z3.ZodString) {
+      type = "string";
+    } else if (zodType instanceof z3.ZodNumber) {
+      type = "number";
+    } else if (zodType instanceof z3.ZodBoolean) {
+      type = "boolean";
+    } else if (zodType instanceof z3.ZodArray) {
+      type = "array";
+    } else if (zodType instanceof z3.ZodObject) {
+      type = "object";
+    }
+    parameters.push({
+      name: key,
+      type,
+      required,
+      description
+    });
+  }
+  return parameters;
+}
+function getExecuteSqlMetadata(sourceId) {
+  const sourceIds = ConnectorManager.getAvailableSourceIds();
+  const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+  const executeOptions = ConnectorManager.getCurrentExecuteOptions(sourceId);
+  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})`;
+  const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
+  const maxRowsNote = executeOptions.maxRows ? ` (limited to ${executeOptions.maxRows} rows)` : "";
+  const description = `Execute SQL queries on the '${sourceId}' ${dbType} database${isDefault ? " (default)" : ""}${readonlyNote}${maxRowsNote}`;
+  const isReadonly = executeOptions.readonly === true;
+  const annotations = {
+    title,
+    readOnlyHint: isReadonly,
+    destructiveHint: !isReadonly,
+    // Can be destructive if not readonly
+    // 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
+  };
+  return {
+    name: toolName,
+    description,
+    schema: executeSqlSchema,
+    annotations
+  };
+}
+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
+  };
+}
+function customParamsToToolParams(params) {
+  if (!params || params.length === 0) {
+    return [];
+  }
+  return params.map((param) => ({
+    name: param.name,
+    type: param.type,
+    required: param.required !== false && param.default === void 0,
+    description: param.description
+  }));
+}
+function getToolsForSource(sourceId) {
+  const tools = [];
+  const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+  const dbType = sourceConfig.type;
+  const sourceIds = ConnectorManager.getAvailableSourceIds();
+  const isDefault = sourceIds[0] === sourceId;
+  const executeSqlMetadata = getExecuteSqlMetadata(sourceId);
+  const executeSqlParameters = zodToParameters(executeSqlMetadata.schema);
+  tools.push({
+    name: executeSqlMetadata.name,
+    description: executeSqlMetadata.description,
+    parameters: executeSqlParameters
+  });
+  const searchMetadata = getSearchObjectsMetadata(sourceId, dbType, isDefault);
+  tools.push({
+    name: searchMetadata.name,
+    description: searchMetadata.description,
+    parameters: [
+      {
+        name: "object_type",
+        type: "string",
+        required: true,
+        description: "Type of database object to search for (schema, table, column, procedure, index)"
+      },
+      {
+        name: "pattern",
+        type: "string",
+        required: false,
+        description: "Search pattern (SQL LIKE syntax: % for wildcard, _ for single char). Case-insensitive. Defaults to '%' (match all)."
+      },
+      {
+        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)"
+      }
+    ]
+  });
+  if (customToolRegistry.isInitialized()) {
+    const customTools = customToolRegistry.getTools();
+    const sourceCustomTools = customTools.filter((tool) => tool.source === sourceId);
+    for (const customTool of sourceCustomTools) {
+      tools.push({
+        name: customTool.name,
+        description: customTool.description,
+        parameters: customParamsToToolParams(customTool.parameters)
+      });
     }
-    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?
+  }
+  return tools;
+}
 
-${possibleTableMatches.join("\n")}`
-        );
+// src/tools/custom-tool-handler.ts
+import { z as z4 } from "zod";
+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 "float":
+        fieldSchema = z4.number().describe(param.description);
+        break;
+      case "boolean":
+        fieldSchema = z4.boolean().describe(param.description);
+        break;
+      case "array":
+        fieldSchema = z4.array(z4.unknown()).describe(param.description);
+        break;
+      default:
+        throw new Error(`Unsupported parameter type: ${param.type}`);
+    }
+    if (param.allowed_values && param.allowed_values.length > 0) {
+      if (param.type === "string") {
+        fieldSchema = z4.enum(param.allowed_values).describe(param.description);
       } 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"
+        fieldSchema = fieldSchema.refine(
+          (val) => param.allowed_values.includes(val),
+          {
+            message: `Value must be one of: ${param.allowed_values.join(", ")}`
+          }
         );
       }
     }
-  } 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";
+    if (param.default !== void 0 || param.required === false) {
+      fieldSchema = fieldSchema.optional();
+    }
+    schemaShape[param.name] = fieldSchema;
   }
-  return "data related to " + tableName;
+  return schemaShape;
 }
-function determineRelationships(tableName, columns) {
-  const potentialRelationships = [];
-  const idColumns = columns.filter(
-    (c) => c.column_name.toLowerCase().endsWith("_id") && !c.column_name.toLowerCase().startsWith(tableName.toLowerCase())
-  );
-  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})`
+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
       );
-    });
-  }
-  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";
+      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");
+      }
+      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}
+
+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
+      });
+    }
+  };
 }
-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";
+
+// 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.getToolsForSource(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 {
+        registerCustomTool(server, toolConfig, dbType);
+      }
+    }
   }
-  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";
+function registerExecuteSqlTool(server, sourceId, dbType) {
+  const metadata = getExecuteSqlMetadata(sourceId);
+  server.registerTool(
+    metadata.name,
+    {
+      description: metadata.description,
+      inputSchema: metadata.schema,
+      annotations: metadata.annotations
+    },
+    createExecuteSqlToolHandler(sourceId)
+  );
 }
-
-// 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: true
+      }
+    },
+    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
@@ -4036,6 +3007,7 @@ function transformSourceConfig(source, isDefault) {
     }
     dataSource.ssh_tunnel = sshTunnel;
   }
+  dataSource.tools = getToolsForSource(source.id);
   return dataSource;
 }
 function listSources(req, res) {
@@ -4079,11 +3051,144 @@ function getSource(req, res) {
   }
 }
 
+// src/api/requests.ts
+function listRequests(req, res) {
+  try {
+    const sourceId = req.query.source_id;
+    const requests = requestStore.getAll(sourceId);
+    res.json({
+      requests,
+      total: requests.length
+    });
+  } catch (error) {
+    console.error("Error listing requests:", error);
+    res.status(500).json({
+      error: error instanceof Error ? error.message : "Internal server error"
+    });
+  }
+}
+
+// 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 = []) {
@@ -4101,12 +3206,10 @@ v${version}${modeText} - Universal Database MCP Server
 }
 async function main() {
   try {
-    const idData = resolveId();
-    const id = idData?.id;
     const sourceConfigsData = await resolveSourceConfigs();
     if (!sourceConfigsData) {
       const samples = ConnectorRegistry.getAllSampleDSNs();
-      const sampleFormats = Object.entries(samples).map(([id2, dsn]) => `  - ${id2}: ${dsn}`).join("\n");
+      const sampleFormats = Object.entries(samples).map(([id, dsn]) => `  - ${id}: ${dsn}`).join("\n");
       console.error(`
 ERROR: Database connection configuration is required.
 Please provide configuration in one of these ways (in order of priority):
@@ -4129,35 +3232,44 @@ 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, id);
-      registerPrompts(server);
-      return server;
-    };
     const connectorManager = new ConnectorManager();
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
-    if (idData) {
-      console.error(`ID: ${idData.id} (from ${idData.source})`);
-    }
     console.error(`Connecting to ${sources.length} database source(s)...`);
     for (const source of sources) {
       const dsn = source.dsn || buildDSNFromSource(source);
       console.error(`  - ${source.id}: ${redactDSN(dsn)}`);
     }
     await connectorManager.connectWithSources(sources);
-    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 { initializeToolRegistry } = await import("./registry-GJGPWR3I.js");
+    initializeToolRegistry({
+      sources: sourceConfigsData.sources,
+      tools: sourceConfigsData.tools
+    });
+    console.error("Tool registry initialized");
+    if (sourceConfigsData.tools && sourceConfigsData.tools.length > 0) {
+      const { customToolRegistry: customToolRegistry2 } = await import("./custom-tool-registry-EW3KOBGC.js");
+      const { BUILTIN_TOOLS } = await import("./builtin-tools-SVENYBIA.js");
+      if (!customToolRegistry2.isInitialized()) {
+        const customTools = sourceConfigsData.tools.filter(
+          (tool) => !BUILTIN_TOOLS.includes(tool.name)
+        );
+        if (customTools.length > 0) {
+          customToolRegistry2.initialize(customTools);
+          console.error(`Custom tool registry initialized with ${customTools.length} tool(s)`);
+        }
+      }
     }
-    const readonly = isReadOnlyMode();
+    const createServer = () => {
+      const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION
+      });
+      registerTools(server);
+      return server;
+    };
+    const transportData = resolveTransport();
+    const port = transportData.type === "http" ? resolvePort().port : null;
     const activeModes = [];
     const modeDescriptions = [];
     const isDemo = isDemoMode();
@@ -4165,19 +3277,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) => {
@@ -4194,13 +3304,14 @@ 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");
       });
       app.get("/api/sources", listSources);
       app.get("/api/sources/:sourceId", getSource);
+      app.get("/api/requests", listRequests);
       app.get("/mcp", (req, res) => {
         res.status(405).json({
           error: "Method Not Allowed",
@@ -4215,7 +3326,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) {
@@ -4227,7 +3338,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", () => {
@@ -4242,7 +3353,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");