@bytebase/dbhub 0.13.0 → 0.13.1

package/README.md

@@ -30,11 +30,12 @@
                  MCP Clients           MCP Server             Databases
 ```
 
-DBHub is a Universal Database MCP Server implementing the Model Context Protocol (MCP) server interface. This gateway allows MCP-compatible clients to connect to and explore different databases:
+DBHub is a Minimal Database MCP Server implementing the Model Context Protocol (MCP) server interface. This lightweight gateway allows MCP-compatible clients to connect to and explore different databases:
 
-- **Universal Gateway**: Single interface for PostgreSQL, MySQL, MariaDB, SQL Server, and SQLite
+- **Minimal Design**: Just two general MCP tools (execute_sql, search_objects) for token-efficient operations, plus support for custom tools
+- **Multi-Database Support**: Single interface for PostgreSQL, MySQL, MariaDB, SQL Server, and SQLite
 - **Secure Access**: Read-only mode, SSH tunneling, and SSL/TLS encryption support
-- **Multi-Database**: Connect to multiple databases simultaneously with TOML configuration
+- **Multiple Connections**: Connect to multiple databases simultaneously with TOML configuration
 - **Production-Ready**: Row limiting, lock timeout control, and connection pooling
 - **MCP Native**: Full implementation of Model Context Protocol with comprehensive tools
 

package/dist/{chunk-WSLDVMBA.js → chunk-KBVJEDZF.js}

@@ -1,7 +1,10 @@
-import {
-  BUILTIN_TOOLS,
-  BUILTIN_TOOL_EXECUTE_SQL
-} from "./chunk-D23WQQY7.js";
+// src/tools/builtin-tools.ts
+var BUILTIN_TOOL_EXECUTE_SQL = "execute_sql";
+var BUILTIN_TOOL_SEARCH_OBJECTS = "search_objects";
+var BUILTIN_TOOLS = [
+  BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_SEARCH_OBJECTS
+];
 
 // src/connectors/interface.ts
 var _ConnectorRegistry = class _ConnectorRegistry {
@@ -1588,37 +1591,64 @@ function mapArgumentsToArray(parameters, args) {
   });
 }
 
-// src/tools/custom-tool-registry.ts
-var CustomToolRegistry = class {
-  constructor() {
-    this.tools = [];
-    this.initialized = false;
+// src/tools/registry.ts
+var ToolRegistry = class {
+  constructor(config) {
+    this.toolsBySource = this.buildRegistry(config);
   }
   /**
-   * Initialize the registry with tool definitions from TOML
-   * @param toolConfigs Tool definitions from TOML config
-   * @throws Error if validation fails
+   * Check if a tool name is a built-in tool
    */
-  initialize(toolConfigs) {
-    if (this.initialized) {
-      throw new Error("CustomToolRegistry already initialized");
+  isBuiltinTool(toolName) {
+    return BUILTIN_TOOLS.includes(toolName);
+  }
+  /**
+   * Validate a custom tool parameter definition
+   */
+  validateParameter(toolName, param) {
+    if (!param.name || param.name.trim() === "") {
+      throw new Error(`Tool '${toolName}' has parameter missing 'name' field`);
     }
-    this.tools = [];
-    if (!toolConfigs || toolConfigs.length === 0) {
-      this.initialized = true;
-      return;
+    if (!param.type) {
+      throw new Error(
+        `Tool '${toolName}', parameter '${param.name}' missing 'type' field`
+      );
     }
-    for (const toolConfig of toolConfigs) {
-      this.validateAndRegister(toolConfig);
+    const validTypes = ["string", "integer", "float", "boolean", "array"];
+    if (!validTypes.includes(param.type)) {
+      throw new Error(
+        `Tool '${toolName}', parameter '${param.name}' has invalid type '${param.type}'. Valid types: ${validTypes.join(", ")}`
+      );
+    }
+    if (!param.description || param.description.trim() === "") {
+      throw new Error(
+        `Tool '${toolName}', parameter '${param.name}' missing 'description' field`
+      );
+    }
+    if (param.allowed_values) {
+      if (!Array.isArray(param.allowed_values)) {
+        throw new Error(
+          `Tool '${toolName}', parameter '${param.name}': allowed_values must be an array`
+        );
+      }
+      if (param.allowed_values.length === 0) {
+        throw new Error(
+          `Tool '${toolName}', parameter '${param.name}': allowed_values cannot be empty`
+        );
+      }
+    }
+    if (param.default !== void 0 && param.allowed_values) {
+      if (!param.allowed_values.includes(param.default)) {
+        throw new Error(
+          `Tool '${toolName}', parameter '${param.name}': default value '${param.default}' is not in allowed_values: ${param.allowed_values.join(", ")}`
+        );
+      }
     }
-    this.initialized = true;
   }
   /**
-   * Validate a tool configuration and add it to the registry
-   * @param toolConfig Tool configuration to validate
-   * @throws Error if validation fails
+   * Validate a custom tool configuration
    */
-  validateAndRegister(toolConfig) {
+  validateCustomTool(toolConfig, availableSources) {
     if (!toolConfig.name || toolConfig.name.trim() === "") {
       throw new Error("Tool definition missing required field: name");
     }
@@ -1637,7 +1667,6 @@ var CustomToolRegistry = class {
         `Tool '${toolConfig.name}' missing required field: statement`
       );
     }
-    const availableSources = ConnectorManager.getAvailableSourceIds();
     if (!availableSources.includes(toolConfig.source)) {
       throw new Error(
         `Tool '${toolConfig.name}' references unknown source '${toolConfig.source}'. Available sources: ${availableSources.join(", ")}`
@@ -1650,11 +1679,6 @@ var CustomToolRegistry = class {
         );
       }
     }
-    if (this.tools.some((t) => t.name === toolConfig.name)) {
-      throw new Error(
-        `Duplicate tool name '${toolConfig.name}'. Tool names must be unique.`
-      );
-    }
     const sourceConfig = ConnectorManager.getSourceConfig(toolConfig.source);
     const connectorType = sourceConfig.type;
     try {
@@ -1673,85 +1697,109 @@ var CustomToolRegistry = class {
         this.validateParameter(toolConfig.name, param);
       }
     }
-    this.tools.push(toolConfig);
   }
   /**
-   * Validate a parameter definition
-   * @param toolName Name of the tool (for error messages)
-   * @param param Parameter configuration to validate
-   * @throws Error if validation fails
+   * Build the internal registry mapping sources to their enabled tools
    */
-  validateParameter(toolName, param) {
-    if (!param.name || param.name.trim() === "") {
-      throw new Error(`Tool '${toolName}' has parameter missing 'name' field`);
-    }
-    if (!param.type) {
-      throw new Error(
-        `Tool '${toolName}', parameter '${param.name}' missing 'type' field`
-      );
-    }
-    const validTypes = ["string", "integer", "float", "boolean", "array"];
-    if (!validTypes.includes(param.type)) {
-      throw new Error(
-        `Tool '${toolName}', parameter '${param.name}' has invalid type '${param.type}'. Valid types: ${validTypes.join(", ")}`
-      );
-    }
-    if (!param.description || param.description.trim() === "") {
-      throw new Error(
-        `Tool '${toolName}', parameter '${param.name}' missing 'description' field`
-      );
-    }
-    if (param.allowed_values) {
-      if (!Array.isArray(param.allowed_values)) {
-        throw new Error(
-          `Tool '${toolName}', parameter '${param.name}': allowed_values must be an array`
-        );
-      }
-      if (param.allowed_values.length === 0) {
-        throw new Error(
-          `Tool '${toolName}', parameter '${param.name}': allowed_values cannot be empty`
-        );
+  buildRegistry(config) {
+    const registry = /* @__PURE__ */ new Map();
+    const availableSources = config.sources.map((s) => s.id);
+    const customToolNames = /* @__PURE__ */ new Set();
+    for (const tool of config.tools || []) {
+      if (!this.isBuiltinTool(tool.name)) {
+        this.validateCustomTool(tool, availableSources);
+        if (customToolNames.has(tool.name)) {
+          throw new Error(
+            `Duplicate tool name '${tool.name}'. Tool names must be unique.`
+          );
+        }
+        customToolNames.add(tool.name);
       }
-    }
-    if (param.default !== void 0 && param.allowed_values) {
-      if (!param.allowed_values.includes(param.default)) {
-        throw new Error(
-          `Tool '${toolName}', parameter '${param.name}': default value '${param.default}' is not in allowed_values: ${param.allowed_values.join(", ")}`
-        );
+      const existing = registry.get(tool.source) || [];
+      existing.push(tool);
+      registry.set(tool.source, existing);
+    }
+    for (const source of config.sources) {
+      if (!registry.has(source.id)) {
+        const defaultTools = BUILTIN_TOOLS.map((name) => {
+          if (name === "execute_sql") {
+            return { name: "execute_sql", source: source.id };
+          } else {
+            return { name: "search_objects", source: source.id };
+          }
+        });
+        registry.set(source.id, defaultTools);
       }
     }
+    return registry;
   }
   /**
-   * Get all registered custom tools
-   * @returns Array of tool configurations
+   * Get all enabled tool configs for a specific source
    */
-  getTools() {
-    return [...this.tools];
+  getEnabledToolConfigs(sourceId) {
+    return this.toolsBySource.get(sourceId) || [];
   }
   /**
-   * Get a specific tool by name
-   * @param name Tool name
-   * @returns Tool configuration or undefined if not found
+   * Get built-in tool configuration for a specific source
+   * Returns undefined if tool is not enabled or not a built-in
    */
-  getTool(name) {
-    return this.tools.find((t) => t.name === name);
+  getBuiltinToolConfig(toolName, sourceId) {
+    if (!this.isBuiltinTool(toolName)) {
+      return void 0;
+    }
+    const tools = this.getEnabledToolConfigs(sourceId);
+    return tools.find((t) => t.name === toolName);
   }
   /**
-   * Check if the registry has been initialized
-   * @returns True if initialized
+   * Get all unique tools across all sources (for tools/list response)
+   * Returns the union of all enabled tools
    */
-  isInitialized() {
-    return this.initialized;
+  getAllTools() {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const tools of this.toolsBySource.values()) {
+      for (const tool of tools) {
+        if (!seen.has(tool.name)) {
+          seen.add(tool.name);
+          result.push(tool);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all custom tools (non-builtin) across all sources
+   */
+  getCustomTools() {
+    return this.getAllTools().filter((tool) => !this.isBuiltinTool(tool.name));
   }
   /**
-   * Reset the registry (primarily for testing)
+   * Get all built-in tool names that are enabled across any source
    */
-  reset() {
-    this.tools = [];
-    this.initialized = false;
+  getEnabledBuiltinToolNames() {
+    const enabledBuiltins = /* @__PURE__ */ new Set();
+    for (const tools of this.toolsBySource.values()) {
+      for (const tool of tools) {
+        if (this.isBuiltinTool(tool.name)) {
+          enabledBuiltins.add(tool.name);
+        }
+      }
+    }
+    return Array.from(enabledBuiltins);
   }
 };
-var customToolRegistry = new CustomToolRegistry();
+var globalRegistry = null;
+function initializeToolRegistry(config) {
+  globalRegistry = new ToolRegistry(config);
+}
+function getToolRegistry() {
+  if (!globalRegistry) {
+    throw new Error(
+      "Tool registry not initialized. Call initializeToolRegistry first."
+    );
+  }
+  return globalRegistry;
+}
 
 export {
   ConnectorRegistry,
@@ -1766,8 +1814,12 @@ export {
   resolvePort,
   redactDSN,
   resolveSourceConfigs,
+  BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_SEARCH_OBJECTS,
   buildDSNFromSource,
   ConnectorManager,
   mapArgumentsToArray,
-  customToolRegistry
+  ToolRegistry,
+  initializeToolRegistry,
+  getToolRegistry
 };

package/dist/index.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 import {
-  getToolRegistry
-} from "./chunk-VWZF5OAJ.js";
-import {
+  BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_SEARCH_OBJECTS,
   ConnectorManager,
   ConnectorRegistry,
   SafeURL,
   buildDSNFromSource,
-  customToolRegistry,
   getDatabaseTypeFromDSN,
   getDefaultPortForType,
+  getToolRegistry,
   isDemoMode,
   mapArgumentsToArray,
   obfuscateDSNPassword,
@@ -19,11 +18,7 @@ import {
   resolveSourceConfigs,
   resolveTransport,
   stripCommentsAndStrings
-} from "./chunk-WSLDVMBA.js";
-import {
-  BUILTIN_TOOL_EXECUTE_SQL,
-  BUILTIN_TOOL_SEARCH_OBJECTS
-} from "./chunk-D23WQQY7.js";
+} from "./chunk-KBVJEDZF.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
@@ -2298,7 +2293,8 @@ import { z as z2 } from "zod";
 var searchDatabaseObjectsSchema = {
   object_type: z2.enum(["schema", "table", "column", "procedure", "index"]).describe("Type of database object to search for"),
   pattern: z2.string().optional().default("%").describe("Search pattern (SQL LIKE syntax: % for wildcard, _ for single char). Case-insensitive. Defaults to '%' (match all)."),
-  schema: z2.string().optional().describe("Filter results to a specific schema/database"),
+  schema: z2.string().optional().describe("Filter results to a specific schema/database (exact match)"),
+  table: z2.string().optional().describe("Filter to a specific table (exact match). Requires schema parameter. Only applies to columns and indexes."),
   detail_level: z2.enum(["names", "summary", "full"]).default("names").describe("Level of detail to return: names (minimal), summary (with metadata), full (complete structure)"),
   limit: z2.number().int().positive().max(1e3).default(100).describe("Maximum number of results to return (default: 100, max: 1000)")
 };
@@ -2421,7 +2417,7 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
   }
   return results;
 }
-async function searchColumns(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchColumns(connector, pattern, schemaFilter, tableFilter, detailLevel, limit) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -2433,8 +2429,13 @@ async function searchColumns(connector, pattern, schemaFilter, detailLevel, limi
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const tables = await connector.getTables(schemaName);
-      for (const tableName of tables) {
+      let tablesToSearch;
+      if (tableFilter) {
+        tablesToSearch = [tableFilter];
+      } else {
+        tablesToSearch = await connector.getTables(schemaName);
+      }
+      for (const tableName of tablesToSearch) {
         if (results.length >= limit) break;
         try {
           const columns = await connector.getTableSchema(tableName, schemaName);
@@ -2516,7 +2517,7 @@ async function searchProcedures(connector, pattern, schemaFilter, detailLevel, l
   }
   return results;
 }
-async function searchIndexes(connector, pattern, schemaFilter, detailLevel, limit) {
+async function searchIndexes(connector, pattern, schemaFilter, tableFilter, detailLevel, limit) {
   const regex = likePatternToRegex(pattern);
   const results = [];
   let schemasToSearch;
@@ -2528,8 +2529,13 @@ async function searchIndexes(connector, pattern, schemaFilter, detailLevel, limi
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
     try {
-      const tables = await connector.getTables(schemaName);
-      for (const tableName of tables) {
+      let tablesToSearch;
+      if (tableFilter) {
+        tablesToSearch = [tableFilter];
+      } else {
+        tablesToSearch = await connector.getTables(schemaName);
+      }
+      for (const tableName of tablesToSearch) {
         if (results.length >= limit) break;
         try {
           const indexes = await connector.getTableIndexes(tableName, schemaName);
@@ -2569,11 +2575,26 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
       object_type,
       pattern = "%",
       schema,
+      table,
       detail_level = "names",
       limit = 100
     } = args;
     try {
       const connector = ConnectorManager.getCurrentConnector(sourceId);
+      if (table) {
+        if (!schema) {
+          return createToolErrorResponse(
+            "The 'table' parameter requires 'schema' to be specified",
+            "SCHEMA_REQUIRED"
+          );
+        }
+        if (!["column", "index"].includes(object_type)) {
+          return createToolErrorResponse(
+            `The 'table' parameter only applies to object_type 'column' or 'index', not '${object_type}'`,
+            "INVALID_TABLE_FILTER"
+          );
+        }
+      }
       if (schema) {
         const schemas = await connector.getSchemas();
         if (!schemas.includes(schema)) {
@@ -2592,13 +2613,13 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
           results = await searchTables(connector, pattern, schema, detail_level, limit);
           break;
         case "column":
-          results = await searchColumns(connector, pattern, schema, detail_level, limit);
+          results = await searchColumns(connector, pattern, schema, table, detail_level, limit);
           break;
         case "procedure":
           results = await searchProcedures(connector, pattern, schema, detail_level, limit);
           break;
         case "index":
-          results = await searchIndexes(connector, pattern, schema, detail_level, limit);
+          results = await searchIndexes(connector, pattern, schema, table, detail_level, limit);
           break;
         default:
           return createToolErrorResponse(
@@ -2610,6 +2631,7 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
         object_type,
         pattern,
         schema,
+        table,
         detail_level,
         count: results.length,
         results,
@@ -2679,9 +2701,8 @@ function getExecuteSqlMetadata(sourceId) {
     // In readonly mode, queries are more predictable (though still not strictly idempotent due to data changes)
     // In write mode, queries are definitely not idempotent
     idempotentHint: false,
-    // In readonly mode, it's safer to operate on arbitrary tables (just reading)
-    // In write mode, operating on arbitrary tables is more dangerous
-    openWorldHint: isReadonly
+    // Database operations are always against internal/closed systems, not open-world
+    openWorldHint: false
   };
   return {
     name: toolName,
@@ -2711,21 +2732,22 @@ function customParamsToToolParams(params) {
     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;
+function buildExecuteSqlTool(sourceId) {
   const executeSqlMetadata = getExecuteSqlMetadata(sourceId);
   const executeSqlParameters = zodToParameters(executeSqlMetadata.schema);
-  tools.push({
+  return {
     name: executeSqlMetadata.name,
     description: executeSqlMetadata.description,
     parameters: executeSqlParameters
-  });
+  };
+}
+function buildSearchObjectsTool(sourceId) {
+  const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+  const dbType = sourceConfig.type;
+  const sourceIds = ConnectorManager.getAvailableSourceIds();
+  const isDefault = sourceIds[0] === sourceId;
   const searchMetadata = getSearchObjectsMetadata(sourceId, dbType, isDefault);
-  tools.push({
+  return {
     name: searchMetadata.name,
     description: searchMetadata.description,
     parameters: [
@@ -2760,19 +2782,27 @@ function getToolsForSource(sourceId) {
         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)
-      });
+  };
+}
+function buildCustomTool(toolConfig) {
+  return {
+    name: toolConfig.name,
+    description: toolConfig.description,
+    parameters: customParamsToToolParams(toolConfig.parameters)
+  };
+}
+function getToolsForSource(sourceId) {
+  const registry = getToolRegistry();
+  const enabledToolConfigs = registry.getEnabledToolConfigs(sourceId);
+  return enabledToolConfigs.map((toolConfig) => {
+    if (toolConfig.name === "execute_sql") {
+      return buildExecuteSqlTool(sourceId);
+    } else if (toolConfig.name === "search_objects") {
+      return buildSearchObjectsTool(sourceId);
+    } else {
+      return buildCustomTool(toolConfig);
     }
-  }
-  return tools;
+  });
 }
 
 // src/tools/custom-tool-handler.ts
@@ -2894,7 +2924,7 @@ function registerTools(server) {
   }
   const registry = getToolRegistry();
   for (const sourceId of sourceIds) {
-    const enabledTools = registry.getToolsForSource(sourceId);
+    const enabledTools = registry.getEnabledToolConfigs(sourceId);
     const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
     const dbType = sourceConfig.type;
     const isDefault = sourceIds[0] === sourceId;
@@ -2933,7 +2963,7 @@ function registerSearchObjectsTool(server, sourceId, dbType, isDefault) {
         readOnlyHint: true,
         destructiveHint: false,
         idempotentHint: true,
-        openWorldHint: true
+        openWorldHint: false
       }
     },
     createSearchDatabaseObjectsToolHandler(sourceId)
@@ -3201,7 +3231,7 @@ function generateBanner(version, modes = []) {
 | |__| | |_) | | | | |_| | |_) |
 |_____/|____/|_| |_|\\__,_|_.__/ 
                                 
-v${version}${modeText} - Universal Database MCP Server
+v${version}${modeText} - Minimal Database MCP Server
 `;
 }
 async function main() {
@@ -3241,25 +3271,12 @@ See documentation for more details on configuring database connections.
       console.error(`  - ${source.id}: ${redactDSN(dsn)}`);
     }
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry } = await import("./registry-GJGPWR3I.js");
+    const { initializeToolRegistry } = await import("./registry-AWAIN6WO.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 createServer = () => {
       const server = new McpServer({
         name: SERVER_NAME,

package/dist/public/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>DBHub - Universal Database MCP Server</title>
+    <title>DBHub - Minimal Database MCP Server</title>
     <script type="module" crossorigin src="/assets/index-hd88eD9m.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-gVrYRID4.css">
   </head>

package/dist/{registry-GJGPWR3I.js → registry-AWAIN6WO.js}

@@ -2,8 +2,7 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-VWZF5OAJ.js";
-import "./chunk-D23WQQY7.js";
+} from "./chunk-KBVJEDZF.js";
 export {
   ToolRegistry,
   getToolRegistry,

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.13.0",
-  "description": "Universal Database MCP Server",
+  "version": "0.13.1",
+  "mcpName": "io.github.bytebase/dbhub",
+  "description": "Minimal Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
     "type": "git",
     "url": "https://github.com/bytebase/dbhub.git"
@@ -16,6 +17,21 @@
     "LICENSE",
     "README.md"
   ],
+  "scripts": {
+    "build": "pnpm run generate:api-types && tsup && cd frontend && pnpm run build",
+    "build:backend": "pnpm run generate:api-types && tsup",
+    "build:frontend": "cd frontend && pnpm run build",
+    "start": "node dist/index.js",
+    "dev": "concurrently --kill-others \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
+    "dev:backend": "NODE_ENV=development tsx src/index.ts --transport=http",
+    "dev:frontend": "cd frontend && pnpm run dev",
+    "crossdev": "cross-env NODE_ENV=development tsx src/index.ts",
+    "generate:api-types": "openapi-typescript src/api/openapi.yaml -o src/api/openapi.d.ts",
+    "test": "vitest run",
+    "test:unit": "vitest run --project unit",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --project integration"
+  },
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -67,20 +83,5 @@
   },
   "include": [
     "src/**/*"
-  ],
-  "scripts": {
-    "build": "pnpm run generate:api-types && tsup && cd frontend && pnpm run build",
-    "build:backend": "pnpm run generate:api-types && tsup",
-    "build:frontend": "cd frontend && pnpm run build",
-    "start": "node dist/index.js",
-    "dev": "concurrently --kill-others \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
-    "dev:backend": "NODE_ENV=development tsx src/index.ts --transport=http",
-    "dev:frontend": "cd frontend && pnpm run dev",
-    "crossdev": "cross-env NODE_ENV=development tsx src/index.ts",
-    "generate:api-types": "openapi-typescript src/api/openapi.yaml -o src/api/openapi.d.ts",
-    "test": "vitest run",
-    "test:unit": "vitest run --project unit",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --project integration"
-  }
-}
+  ]
+}

package/dist/builtin-tools-SVENYBIA.js

@@ -1,10 +0,0 @@
-import {
-  BUILTIN_TOOLS,
-  BUILTIN_TOOL_EXECUTE_SQL,
-  BUILTIN_TOOL_SEARCH_OBJECTS
-} from "./chunk-D23WQQY7.js";
-export {
-  BUILTIN_TOOLS,
-  BUILTIN_TOOL_EXECUTE_SQL,
-  BUILTIN_TOOL_SEARCH_OBJECTS
-};

package/dist/chunk-D23WQQY7.js

@@ -1,13 +0,0 @@
-// src/tools/builtin-tools.ts
-var BUILTIN_TOOL_EXECUTE_SQL = "execute_sql";
-var BUILTIN_TOOL_SEARCH_OBJECTS = "search_objects";
-var BUILTIN_TOOLS = [
-  BUILTIN_TOOL_EXECUTE_SQL,
-  BUILTIN_TOOL_SEARCH_OBJECTS
-];
-
-export {
-  BUILTIN_TOOL_EXECUTE_SQL,
-  BUILTIN_TOOL_SEARCH_OBJECTS,
-  BUILTIN_TOOLS
-};

package/dist/chunk-VWZF5OAJ.js

@@ -1,112 +0,0 @@
-import {
-  BUILTIN_TOOLS
-} from "./chunk-D23WQQY7.js";
-
-// src/tools/registry.ts
-var ToolRegistry = class {
-  constructor(config) {
-    this.toolsBySource = this.buildRegistry(config);
-  }
-  /**
-   * Check if a tool name is a built-in tool
-   */
-  isBuiltinTool(toolName) {
-    return BUILTIN_TOOLS.includes(toolName);
-  }
-  /**
-   * Build the internal registry mapping sources to their enabled tools
-   */
-  buildRegistry(config) {
-    const registry = /* @__PURE__ */ new Map();
-    for (const tool of config.tools || []) {
-      const existing = registry.get(tool.source) || [];
-      existing.push(tool);
-      registry.set(tool.source, existing);
-    }
-    for (const source of config.sources) {
-      if (!registry.has(source.id)) {
-        const defaultTools = BUILTIN_TOOLS.map((name) => {
-          if (name === "execute_sql") {
-            return { name: "execute_sql", source: source.id };
-          } else {
-            return { name: "search_objects", source: source.id };
-          }
-        });
-        registry.set(source.id, defaultTools);
-      }
-    }
-    return registry;
-  }
-  /**
-   * Get all tools enabled for a specific source
-   */
-  getToolsForSource(sourceId) {
-    return this.toolsBySource.get(sourceId) || [];
-  }
-  /**
-   * Get built-in tool configuration for a specific source
-   * Returns undefined if tool is not enabled or not a built-in
-   */
-  getBuiltinToolConfig(toolName, sourceId) {
-    if (!this.isBuiltinTool(toolName)) {
-      return void 0;
-    }
-    const tools = this.getToolsForSource(sourceId);
-    return tools.find((t) => t.name === toolName);
-  }
-  /**
-   * Get all unique tools across all sources (for tools/list response)
-   * Returns the union of all enabled tools
-   */
-  getAllTools() {
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const tools of this.toolsBySource.values()) {
-      for (const tool of tools) {
-        if (!seen.has(tool.name)) {
-          seen.add(tool.name);
-          result.push(tool);
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Get all custom tools (non-builtin) across all sources
-   */
-  getCustomTools() {
-    return this.getAllTools().filter((tool) => !this.isBuiltinTool(tool.name));
-  }
-  /**
-   * Get all built-in tool names that are enabled across any source
-   */
-  getEnabledBuiltinToolNames() {
-    const enabledBuiltins = /* @__PURE__ */ new Set();
-    for (const tools of this.toolsBySource.values()) {
-      for (const tool of tools) {
-        if (this.isBuiltinTool(tool.name)) {
-          enabledBuiltins.add(tool.name);
-        }
-      }
-    }
-    return Array.from(enabledBuiltins);
-  }
-};
-var globalRegistry = null;
-function initializeToolRegistry(config) {
-  globalRegistry = new ToolRegistry(config);
-}
-function getToolRegistry() {
-  if (!globalRegistry) {
-    throw new Error(
-      "Tool registry not initialized. Call initializeToolRegistry first."
-    );
-  }
-  return globalRegistry;
-}
-
-export {
-  ToolRegistry,
-  initializeToolRegistry,
-  getToolRegistry
-};

package/dist/custom-tool-registry-EW3KOBGC.js

@@ -1,7 +0,0 @@
-import {
-  customToolRegistry
-} from "./chunk-WSLDVMBA.js";
-import "./chunk-D23WQQY7.js";
-export {
-  customToolRegistry
-};