@bytebase/dbhub 0.16.1 → 0.18.0

package/dist/index.js

@@ -8,15 +8,19 @@ import {
   getDatabaseTypeFromDSN,
   getDefaultPortForType,
   getToolRegistry,
+  initializeToolRegistry,
   isDemoMode,
+  loadTomlConfig,
   mapArgumentsToArray,
   obfuscateDSNPassword,
   parseConnectionInfoFromDSN,
   resolvePort,
   resolveSourceConfigs,
+  resolveTomlConfigPath,
   resolveTransport,
+  splitSQLStatements,
   stripCommentsAndStrings
-} from "./chunk-IBBG4PSO.js";
+} from "./chunk-WCXOWHL3.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
@@ -141,6 +145,36 @@ var SQLRowLimiter = class {
   }
 };
 
+// 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/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
@@ -209,6 +243,8 @@ var PostgresConnector = class _PostgresConnector {
     this.pool = null;
     // Source ID is set by ConnectorManager after cloning
     this.sourceId = "default";
+    // Default schema for discovery methods (first entry from search_path, or "public")
+    this.defaultSchema = "public";
   }
   getId() {
     return this.sourceId;
@@ -217,11 +253,21 @@ var PostgresConnector = class _PostgresConnector {
     return new _PostgresConnector();
   }
   async connect(dsn, initScript, config) {
+    this.defaultSchema = "public";
     try {
       const poolConfig = await this.dsnParser.parse(dsn, config);
       if (config?.readonly) {
         poolConfig.options = (poolConfig.options || "") + " -c default_transaction_read_only=on";
       }
+      if (config?.searchPath) {
+        const schemas = config.searchPath.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        if (schemas.length > 0) {
+          this.defaultSchema = schemas[0];
+          const quotedSchemas = schemas.map((s) => quoteIdentifier(s, "postgres"));
+          const optionsValue = quotedSchemas.join(",").replace(/\\/g, "\\\\").replace(/ /g, "\\ ");
+          poolConfig.options = (poolConfig.options || "") + ` -c search_path=${optionsValue}`;
+        }
+      }
       this.pool = new Pool(poolConfig);
       const client = await this.pool.connect();
       client.release();
@@ -259,7 +305,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT table_name 
@@ -280,7 +326,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT EXISTS (
@@ -302,7 +348,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT 
@@ -350,18 +396,27 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        ORDER BY ordinal_position
+        SELECT
+          c.column_name,
+          c.data_type,
+          c.is_nullable,
+          c.column_default,
+          pgd.description
+        FROM information_schema.columns c
+        LEFT JOIN pg_catalog.pg_namespace nsp
+          ON nsp.nspname = c.table_schema
+        LEFT JOIN pg_catalog.pg_class cls
+          ON cls.relnamespace = nsp.oid
+          AND cls.relname = c.table_name
+        LEFT JOIN pg_catalog.pg_description pgd
+          ON pgd.objoid = cls.oid
+          AND pgd.objsubid = c.ordinal_position
+        WHERE c.table_schema = $1
+        AND c.table_name = $2
+        ORDER BY c.ordinal_position
       `,
         [schemaToUse, tableName]
       );
@@ -370,22 +425,82 @@ var PostgresConnector = class _PostgresConnector {
       client.release();
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableRowCount(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
+        SELECT c.reltuples::bigint as count
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        const count = Number(result.rows[0].count);
+        return count >= 0 ? count : null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT obj_description(c.oid) as table_comment
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        return result.rows[0].table_comment || null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const params = [schemaToUse];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND routine_type = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND routine_type = 'PROCEDURE'";
+      }
+      const result = await client.query(
+        `
+        SELECT
           routine_name
         FROM information_schema.routines
-        WHERE routine_schema = $1
+        WHERE routine_schema = $1${typeFilter}
         ORDER BY routine_name
       `,
-        [schemaToUse]
+        params
       );
       return result.rows.map((row) => row.routine_name);
     } finally {
@@ -398,7 +513,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const schemaToUse = schema || "public";
+      const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
         SELECT 
@@ -474,7 +589,7 @@ var PostgresConnector = class _PostgresConnector {
     }
     const client = await this.pool.connect();
     try {
-      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      const statements = splitSQLStatements(sql2, "postgres");
       if (statements.length === 1) {
         const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
         let result;
@@ -789,33 +904,78 @@ var SQLServerConnector = class _SQLServerConnector {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
       const query = `
-          SELECT COLUMN_NAME as    column_name,
-                 DATA_TYPE as      data_type,
-                 IS_NULLABLE as    is_nullable,
-                 COLUMN_DEFAULT as column_default
-          FROM INFORMATION_SCHEMA.COLUMNS
-          WHERE TABLE_NAME = @tableName
-            AND TABLE_SCHEMA = @schema
-          ORDER BY ORDINAL_POSITION
+          SELECT c.COLUMN_NAME as    column_name,
+                 c.DATA_TYPE as      data_type,
+                 c.IS_NULLABLE as    is_nullable,
+                 c.COLUMN_DEFAULT as column_default,
+                 ep.value as         description
+          FROM INFORMATION_SCHEMA.COLUMNS c
+          LEFT JOIN sys.columns sc
+            ON sc.name = c.COLUMN_NAME
+            AND sc.object_id = OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME))
+          LEFT JOIN sys.extended_properties ep
+            ON ep.major_id = sc.object_id
+            AND ep.minor_id = sc.column_id
+            AND ep.name = 'MS_Description'
+          WHERE c.TABLE_NAME = @tableName
+            AND c.TABLE_SCHEMA = @schema
+          ORDER BY c.ORDINAL_POSITION
       `;
       const result = await request.query(query);
-      return result.recordset;
+      return result.recordset.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT ep.value as table_comment
+          FROM sys.extended_properties ep
+          JOIN sys.tables t ON ep.major_id = t.object_id
+          JOIN sys.schemas s ON t.schema_id = s.schema_id
+          WHERE ep.minor_id = 0
+            AND ep.name = 'MS_Description'
+            AND t.name = @tableName
+            AND s.name = @schema
+      `;
+      const result = await request.query(query);
+      if (result.recordset.length > 0) {
+        return result.recordset[0].table_comment || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      let typeFilter;
+      if (routineType === "function") {
+        typeFilter = "AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = "AND ROUTINE_TYPE = 'PROCEDURE'";
+      } else {
+        typeFilter = "AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')";
+      }
       const query = `
           SELECT ROUTINE_NAME
           FROM INFORMATION_SCHEMA.ROUTINES
           WHERE ROUTINE_SCHEMA = @schema
-            AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')
+            ${typeFilter}
           ORDER BY ROUTINE_NAME
       `;
       const result = await request.query(query);
@@ -948,38 +1108,6 @@ 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)) {
@@ -1181,14 +1309,15 @@ var SQLiteConnector = class _SQLiteConnector {
         data_type: row.type,
         // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
         is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
-        column_default: row.dflt_value
+        column_default: row.dflt_value,
+        description: null
       }));
       return columns;
     } catch (error) {
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getStoredProcedures(schema, routineType) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -1207,7 +1336,7 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      const statements = splitSQLStatements(sql2, "sqlite");
       if (statements.length === 1) {
         let processedStatement = statements[0];
         const trimmedStatement = statements[0].toLowerCase().trim();
@@ -1566,11 +1695,12 @@ var MySQLConnector = class _MySQLConnector {
       const queryParams = schema ? [schema, tableName] : [tableName];
       const [rows] = await this.pool.query(
         `
-        SELECT 
-          COLUMN_NAME as column_name, 
-          DATA_TYPE as data_type, 
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
           IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
+          COLUMN_DEFAULT as column_default,
+          COLUMN_COMMENT as description
         FROM INFORMATION_SCHEMA.COLUMNS
         ${schemaClause}
         AND TABLE_NAME = ?
@@ -1578,24 +1708,57 @@ var MySQLConnector = class _MySQLConnector {
       `,
         queryParams
       );
-      return rows;
+      return rows.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       console.error("Error getting table schema:", error);
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT TABLE_COMMENT
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length > 0) {
+        return rows[0].TABLE_COMMENT || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
       const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND ROUTINE_TYPE = 'PROCEDURE'";
+      }
       const [rows] = await this.pool.query(
         `
         SELECT ROUTINE_NAME
         FROM INFORMATION_SCHEMA.ROUTINES
-        ${schemaClause}
+        ${schemaClause}${typeFilter}
         ORDER BY ROUTINE_NAME
       `,
         queryParams
@@ -1719,7 +1882,7 @@ var MySQLConnector = class _MySQLConnector {
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
-        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const statements = splitSQLStatements(sql2, "mysql");
         const processedStatements = statements.map(
           (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
         );
@@ -1979,11 +2142,12 @@ var MariaDBConnector = class _MariaDBConnector {
       const queryParams = schema ? [schema, tableName] : [tableName];
       const rows = await this.pool.query(
         `
-        SELECT 
-          COLUMN_NAME as column_name, 
-          DATA_TYPE as data_type, 
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
           IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
+          COLUMN_DEFAULT as column_default,
+          COLUMN_COMMENT as description
         FROM INFORMATION_SCHEMA.COLUMNS
         ${schemaClause}
         AND TABLE_NAME = ?
@@ -1991,24 +2155,57 @@ var MariaDBConnector = class _MariaDBConnector {
       `,
         queryParams
       );
-      return rows;
+      return rows.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
     } catch (error) {
       console.error("Error getting table schema:", error);
       throw error;
     }
   }
-  async getStoredProcedures(schema) {
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const rows = await this.pool.query(
+        `
+        SELECT TABLE_COMMENT
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length > 0) {
+        return rows[0].TABLE_COMMENT || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
       const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND ROUTINE_TYPE = 'PROCEDURE'";
+      }
       const rows = await this.pool.query(
         `
         SELECT ROUTINE_NAME
         FROM INFORMATION_SCHEMA.ROUTINES
-        ${schemaClause}
+        ${schemaClause}${typeFilter}
         ORDER BY ROUTINE_NAME
       `,
         queryParams
@@ -2132,7 +2329,7 @@ var MariaDBConnector = class _MariaDBConnector {
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
-        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const statements = splitSQLStatements(sql2, "mariadb");
         const processedStatements = statements.map(
           (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
         );
@@ -2235,7 +2432,7 @@ var allowedKeywords = {
   sqlserver: ["select", "with", "explain", "showplan"]
 };
 function isReadOnlySQL(sql2, connectorType) {
-  const cleanedSQL = stripCommentsAndStrings(sql2).trim().toLowerCase();
+  const cleanedSQL = stripCommentsAndStrings(sql2, connectorType).trim().toLowerCase();
   if (!cleanedSQL) {
     return true;
   }
@@ -2328,11 +2525,8 @@ function trackToolRequest(metadata, startTime, extra, success, error) {
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
 };
-function splitSQLStatements(sql2) {
-  return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
-}
 function areAllStatementsReadOnly(sql2, connectorType) {
-  const statements = splitSQLStatements(sql2);
+  const statements = splitSQLStatements(sql2, connectorType);
   return statements.every((statement) => isReadOnlySQL(statement, connectorType));
 }
 function createExecuteSqlToolHandler(sourceId) {
@@ -2389,7 +2583,7 @@ function createExecuteSqlToolHandler(sourceId) {
 // src/tools/search-objects.ts
 import { z as z2 } from "zod";
 var searchDatabaseObjectsSchema = {
-  object_type: z2.enum(["schema", "table", "column", "procedure", "index"]).describe("Object type to search"),
+  object_type: z2.enum(["schema", "table", "column", "procedure", "function", "index"]).describe("Object type to search"),
   pattern: z2.string().optional().default("%").describe("LIKE pattern (% = any chars, _ = one char). Default: %"),
   schema: z2.string().optional().describe("Filter to schema"),
   table: z2.string().optional().describe("Filter to table (requires schema; column/index only)"),
@@ -2402,6 +2596,9 @@ function likePatternToRegex(pattern) {
 }
 async function getTableRowCount(connector, tableName, schemaName) {
   try {
+    if (connector.getTableRowCount) {
+      return await connector.getTableRowCount(tableName, schemaName);
+    }
     const qualifiedTable = quoteQualifiedIdentifier(tableName, schemaName, connector.id);
     const countQuery = `SELECT COUNT(*) as count FROM ${qualifiedTable}`;
     const result = await connector.executeSQL(countQuery, { maxRows: 1 });
@@ -2413,6 +2610,16 @@ async function getTableRowCount(connector, tableName, schemaName) {
   }
   return null;
 }
+async function getTableComment(connector, tableName, schemaName) {
+  try {
+    if (connector.getTableComment) {
+      return await connector.getTableComment(tableName, schemaName);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
 async function searchSchemas(connector, pattern, detailLevel, limit) {
   const schemas = await connector.getSchemas();
   const regex = likePatternToRegex(pattern);
@@ -2463,11 +2670,13 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
           try {
             const columns = await connector.getTableSchema(tableName, schemaName);
             const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            const comment = await getTableComment(connector, tableName, schemaName);
             results.push({
               name: tableName,
               schema: schemaName,
               column_count: columns.length,
-              row_count: rowCount
+              row_count: rowCount,
+              ...comment ? { comment } : {}
             });
           } catch (error) {
             results.push({
@@ -2482,16 +2691,19 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
             const columns = await connector.getTableSchema(tableName, schemaName);
             const indexes = await connector.getTableIndexes(tableName, schemaName);
             const rowCount = await getTableRowCount(connector, tableName, schemaName);
+            const comment = await getTableComment(connector, tableName, schemaName);
             results.push({
               name: tableName,
               schema: schemaName,
               column_count: columns.length,
               row_count: rowCount,
+              ...comment ? { comment } : {},
               columns: columns.map((col) => ({
                 name: col.column_name,
                 type: col.data_type,
                 nullable: col.is_nullable === "YES",
-                default: col.column_default
+                default: col.column_default,
+                ...col.description ? { description: col.description } : {}
               })),
               indexes: indexes.map((idx) => ({
                 name: idx.index_name,
@@ -2553,7 +2765,8 @@ async function searchColumns(connector, pattern, schemaFilter, tableFilter, deta
                 schema: schemaName,
                 type: column.data_type,
                 nullable: column.is_nullable === "YES",
-                default: column.column_default
+                default: column.column_default,
+                ...column.description ? { description: column.description } : {}
               });
             }
           }
@@ -2567,7 +2780,7 @@ async function searchColumns(connector, pattern, schemaFilter, tableFilter, deta
   }
   return results;
 }
-async function searchProcedures(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchProcedures(connector, pattern, schemaFilter, detailLevel, limit, routineType) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -2579,7 +2792,7 @@ async function searchProcedures(connector, pattern, schemaFilter, detailLevel, l
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const procedures = await connector.getStoredProcedures(schemaName);
+      const procedures = await connector.getStoredProcedures(schemaName, routineType);
       const matched = procedures.filter((proc) => regex.test(proc));
       for (const procName of matched) {
         if (results.length >= limit) break;
@@ -2716,7 +2929,10 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
           results = await searchColumns(connector, pattern, schema, table, detail_level, limit);
           break;
         case "procedure":
-          results = await searchProcedures(connector, pattern, schema, detail_level, limit);
+          results = await searchProcedures(connector, pattern, schema, detail_level, limit, "procedure");
+          break;
+        case "function":
+          results = await searchProcedures(connector, pattern, schema, detail_level, limit, "function");
           break;
         case "index":
           results = await searchIndexes(connector, pattern, schema, table, detail_level, limit);
@@ -2836,7 +3052,7 @@ function getSearchObjectsMetadata(sourceId) {
   const isSingleSource = sourceIds.length === 1;
   const toolName = isSingleSource ? "search_objects" : `search_objects_${normalizeSourceId(sourceId)}`;
   const title = isSingleSource ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
-  const description = isSingleSource ? `Search and list database objects (schemas, tables, columns, procedures, indexes) on the ${dbType} database` : `Search and list database objects (schemas, tables, columns, procedures, indexes) on the '${sourceId}' ${dbType} database`;
+  const description = isSingleSource ? `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the ${dbType} database` : `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the '${sourceId}' ${dbType} database`;
   return {
     name: toolName,
     description,
@@ -3340,6 +3556,95 @@ function buildSourceDisplayInfo(sourceConfigs, getToolsForSource2, isDemo) {
   });
 }
 
+// src/utils/config-watcher.ts
+import fs from "fs";
+var DEBOUNCE_MS = 500;
+function startConfigWatcher(options) {
+  const { connectorManager, initialTools } = options;
+  const configPath = resolveTomlConfigPath();
+  if (!configPath) {
+    return null;
+  }
+  let debounceTimer = null;
+  let isReloading = false;
+  let reloadPending = false;
+  let lastGoodSources = connectorManager.getAllSourceConfigs();
+  let lastGoodTools = initialTools;
+  const scheduleReload = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(reload, DEBOUNCE_MS);
+  };
+  const reload = async () => {
+    if (isReloading) {
+      reloadPending = true;
+      return;
+    }
+    isReloading = true;
+    reloadPending = false;
+    try {
+      console.error(`
+Detected change in ${configPath}, reloading configuration...`);
+      const newConfig = loadTomlConfig();
+      if (!newConfig) {
+        console.error("Config reload: failed to load TOML config, keeping existing connections.");
+        return;
+      }
+      const oldSources = lastGoodSources;
+      const oldTools = lastGoodTools;
+      await connectorManager.disconnect();
+      try {
+        await connectorManager.connectWithSources(newConfig.sources);
+        initializeToolRegistry({
+          sources: newConfig.sources,
+          tools: newConfig.tools
+        });
+        lastGoodSources = newConfig.sources;
+        lastGoodTools = newConfig.tools;
+        console.error("Configuration reloaded successfully.");
+      } catch (connectError) {
+        console.error("Failed to connect with new config, rolling back:", connectError);
+        try {
+          await connectorManager.disconnect();
+        } catch {
+        }
+        try {
+          await connectorManager.connectWithSources(oldSources);
+          initializeToolRegistry({ sources: oldSources, tools: oldTools });
+          console.error("Rolled back to previous configuration.");
+        } catch (rollbackError) {
+          console.error("Rollback also failed, server has no active connections:", rollbackError);
+        }
+      }
+    } catch (error) {
+      console.error("Config reload failed, keeping existing connections:", error);
+    } finally {
+      isReloading = false;
+      if (reloadPending) {
+        reloadPending = false;
+        scheduleReload();
+      }
+    }
+  };
+  const watcher = fs.watch(configPath, (eventType) => {
+    if (eventType === "change") {
+      scheduleReload();
+    }
+  });
+  watcher.unref?.();
+  watcher.on("error", (err) => {
+    console.error("Config file watcher error:", err);
+  });
+  console.error(`Watching ${configPath} for changes (hot reload enabled)`);
+  return () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    watcher.close();
+  };
+}
+
 // src/server.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
@@ -3392,12 +3697,16 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry } = await import("./registry-D77Y4CIA.js");
-    initializeToolRegistry({
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-NTKAVQCA.js");
+    initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
     });
     console.error("Tool registry initialized");
+    const stopConfigWatcher = startConfigWatcher({
+      connectorManager,
+      initialTools: sourceConfigsData.tools
+    });
     const createServer = () => {
       const server = new McpServer({
         name: SERVER_NAME,
@@ -3425,6 +3734,9 @@ See documentation for more details on configuring database connections.
       isDemo
     );
     console.error(generateStartupTable(sourceDisplayInfos));
+    process.on("exit", () => {
+      stopConfigWatcher?.();
+    });
     if (transportData.type === "http") {
       const app = express();
       app.use(express.json());