@bytebase/dbhub 0.12.0 → 0.13.0

package/README.md

@@ -36,19 +36,19 @@ DBHub is a Universal Database MCP Server implementing the Model Context Protocol
 - **Secure Access**: Read-only mode, SSH tunneling, and SSL/TLS encryption support
 - **Multi-Database**: 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 resources, tools, and prompts
+- **MCP Native**: Full implementation of Model Context Protocol with comprehensive tools
 
 ## Supported Databases
 
 PostgreSQL, MySQL, SQL Server, MariaDB, and SQLite.
 
-## MCP Components
+## MCP Tools
 
-DBHub implements MCP Resources, Tools, and Prompts for database operations:
+DBHub implements MCP tools for database operations:
 
-- **[Resources](https://dbhub.ai/components/resources)**: Database schema exploration (schemas, tables, indexes, procedures)
-- **[Tools](https://dbhub.ai/components/tools)**: SQL execution with transaction support
-- **[Prompts](https://dbhub.ai/components/prompts)**: AI-assisted SQL generation and database explanation
+- **[execute_sql](https://dbhub.ai/tools/execute-sql)**: Execute SQL queries with transaction support and safety controls
+- **[search_objects](https://dbhub.ai/tools/search-objects)**: Search and explore database schemas, tables, columns, indexes, and procedures with progressive disclosure
+- **[Custom Tools](https://dbhub.ai/tools/custom-tools)**: Define reusable, parameterized SQL operations in your `dbhub.toml` configuration file
 
 ## Installation
 

package/dist/builtin-tools-SVENYBIA.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,13 @@
+// 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

@@ -0,0 +1,112 @@
+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
+};