@bytebase/dbhub 0.14.0 → 0.15.0

package/README.md

@@ -30,7 +30,7 @@
                  MCP Clients           MCP Server             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:
+DBHub is a zero-dependency, 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:
 
 - **Token Efficient**: Just two general MCP tools (execute_sql, search_objects) to minimize context window usage, plus support for custom tools
 - **Multi-Database**: Single interface for PostgreSQL, MySQL, MariaDB, SQL Server, and SQLite
@@ -50,6 +50,12 @@ DBHub implements MCP tools for database operations:
 - **[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
 
+## Workbench
+
+DBHub includes a [built-in web interface](https://dbhub.ai/workbench/overview) for interacting with your database tools. It provides a visual way to execute queries, run custom tools, and view request traces without requiring an MCP client.
+
+![workbench](https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/workbench/workbench.webp)
+
 ## Installation
 
 See the full [Installation Guide](https://dbhub.ai/installation) for detailed instructions.
@@ -80,13 +86,13 @@ npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:p
 npx @bytebase/dbhub@latest --transport http --port 8080 --demo
 ```
 
-See [Server Options](https://dbhub.ai/config/server-options) for all available parameters.
+See [Command-Line Options](https://dbhub.ai/config/command-line) for all available parameters.
 
 ### Multi-Database Setup
 
 Connect to multiple databases simultaneously using TOML configuration files. Perfect for managing production, staging, and development databases from a single DBHub instance.
 
-See [Multi-Database Configuration](https://dbhub.ai/config/multi-database) for complete setup instructions.
+See [Multi-Database Configuration](https://dbhub.ai/config/toml) for complete setup instructions.
 
 ## Development
 

package/dist/{chunk-WGDSRFBW.js → chunk-TPHNNFR5.js}

@@ -1237,11 +1237,6 @@ function validateToolsConfig(tools, sources, configPath) {
           `Configuration file ${configPath}: custom tool '${tool.name}' must have 'description' and 'statement' fields`
         );
       }
-      if (tool.readonly !== void 0 || tool.max_rows !== void 0) {
-        throw new Error(
-          `Configuration file ${configPath}: custom tool '${tool.name}' cannot have readonly or max_rows fields (these are only valid for ${BUILTIN_TOOL_EXECUTE_SQL} tool)`
-        );
-      }
     }
     if (tool.max_rows !== void 0) {
       if (typeof tool.max_rows !== "number" || tool.max_rows <= 0) {
@@ -1250,6 +1245,11 @@ function validateToolsConfig(tools, sources, configPath) {
         );
       }
     }
+    if (tool.readonly !== void 0 && typeof tool.readonly !== "boolean") {
+      throw new Error(
+        `Configuration file ${configPath}: tool '${tool.name}' has invalid readonly. Must be a boolean (true or false).`
+      );
+    }
   }
 }
 function validateSourceConfig(source, configPath) {
@@ -1339,6 +1339,16 @@ function validateSourceConfig(source, configPath) {
       );
     }
   }
+  if (source.readonly !== void 0) {
+    throw new Error(
+      `Configuration file ${configPath}: source '${source.id}' has 'readonly' field, but readonly must be configured per-tool, not per-source. Move 'readonly' to [[tools]] configuration instead.`
+    );
+  }
+  if (source.max_rows !== void 0) {
+    throw new Error(
+      `Configuration file ${configPath}: source '${source.id}' has 'max_rows' field, but max_rows must be configured per-tool, not per-source. Move 'max_rows' to [[tools]] configuration instead.`
+    );
+  }
 }
 function processSourceConfigs(sources, configPath) {
   return sources.map((source) => {
@@ -1446,7 +1456,6 @@ var ConnectorManager = class {
     // 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 = [];
@@ -1533,14 +1542,6 @@ var ConnectorManager = class {
     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);
   }
   /**
    * Close all database connections
@@ -1563,7 +1564,6 @@ var ConnectorManager = class {
     }
     this.connectors.clear();
     this.sshTunnels.clear();
-    this.executeOptions.clear();
     this.sourceConfigs.clear();
     this.sourceIds = [];
   }
@@ -1608,25 +1608,6 @@ var ConnectorManager = class {
     }
     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
    */

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   resolveSourceConfigs,
   resolveTransport,
   stripCommentsAndStrings
-} from "./chunk-WGDSRFBW.js";
+} from "./chunk-TPHNNFR5.js";
 
 // src/connectors/postgres/index.ts
 import pg from "pg";
@@ -477,22 +477,26 @@ 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);
+        let result;
         if (parameters && parameters.length > 0) {
           try {
-            return await client.query(processedStatement, parameters);
+            result = 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;
           }
+        } else {
+          result = await client.query(processedStatement);
         }
-        return await client.query(processedStatement);
+        return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
       } else {
         if (parameters && parameters.length > 0) {
           throw new Error("Parameters are not supported for multi-statement queries in PostgreSQL");
         }
         let allRows = [];
+        let totalRowCount = 0;
         await client.query("BEGIN");
         try {
           for (let statement of statements) {
@@ -501,13 +505,16 @@ var PostgresConnector = class _PostgresConnector {
             if (result.rows && result.rows.length > 0) {
               allRows.push(...result.rows);
             }
+            if (result.rowCount) {
+              totalRowCount += result.rowCount;
+            }
           }
           await client.query("COMMIT");
         } catch (error) {
           await client.query("ROLLBACK");
           throw error;
         }
-        return { rows: allRows };
+        return { rows: allRows, rowCount: totalRowCount };
       }
     } finally {
       client.release();
@@ -929,9 +936,6 @@ var SQLServerConnector = class _SQLServerConnector {
       }
       return {
         rows: result.recordset || [],
-        fields: result.recordset && result.recordset.length > 0 ? Object.keys(result.recordset[0]).map((key) => ({
-          name: key
-        })) : [],
         rowCount: result.rowsAffected[0] || 0
       };
     } catch (error) {
@@ -1215,7 +1219,7 @@ var SQLiteConnector = class _SQLiteConnector {
           if (parameters && parameters.length > 0) {
             try {
               const rows = this.db.prepare(processedStatement).all(...parameters);
-              return { rows };
+              return { rows, rowCount: rows.length };
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
               console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
@@ -1224,12 +1228,13 @@ var SQLiteConnector = class _SQLiteConnector {
             }
           } else {
             const rows = this.db.prepare(processedStatement).all();
-            return { rows };
+            return { rows, rowCount: rows.length };
           }
         } else {
+          let result;
           if (parameters && parameters.length > 0) {
             try {
-              this.db.prepare(processedStatement).run(...parameters);
+              result = this.db.prepare(processedStatement).run(...parameters);
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
               console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
@@ -1237,9 +1242,9 @@ var SQLiteConnector = class _SQLiteConnector {
               throw error;
             }
           } else {
-            this.db.prepare(processedStatement).run();
+            result = this.db.prepare(processedStatement).run();
           }
-          return { rows: [] };
+          return { rows: [], rowCount: result.changes };
         }
       } else {
         if (parameters && parameters.length > 0) {
@@ -1255,8 +1260,10 @@ var SQLiteConnector = class _SQLiteConnector {
             writeStatements.push(statement);
           }
         }
-        if (writeStatements.length > 0) {
-          this.db.exec(writeStatements.join("; "));
+        let totalChanges = 0;
+        for (const statement of writeStatements) {
+          const result = this.db.prepare(statement).run();
+          totalChanges += result.changes;
         }
         let allRows = [];
         for (let statement of readStatements) {
@@ -1264,7 +1271,7 @@ var SQLiteConnector = class _SQLiteConnector {
           const result = this.db.prepare(statement).all();
           allRows.push(...result);
         }
-        return { rows: allRows };
+        return { rows: allRows, rowCount: totalChanges + allRows.length };
       }
     } catch (error) {
       throw error;
@@ -1303,6 +1310,26 @@ function extractRowsFromMultiStatement(results) {
   }
   return allRows;
 }
+function extractAffectedRows(results) {
+  if (isMetadataObject(results)) {
+    return results.affectedRows || 0;
+  }
+  if (!Array.isArray(results)) {
+    return 0;
+  }
+  if (isMultiStatementResult(results)) {
+    let totalAffected = 0;
+    for (const result of results) {
+      if (isMetadataObject(result)) {
+        totalAffected += result.affectedRows || 0;
+      } else if (Array.isArray(result)) {
+        totalAffected += result.length;
+      }
+    }
+    return totalAffected;
+  }
+  return results.length;
+}
 function parseQueryResults(results) {
   if (!Array.isArray(results)) {
     return [];
@@ -1716,7 +1743,8 @@ var MySQLConnector = class _MySQLConnector {
       }
       const [firstResult] = results;
       const rows = parseQueryResults(firstResult);
-      return { rows };
+      const rowCount = extractAffectedRows(firstResult);
+      return { rows, rowCount };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;
@@ -2127,7 +2155,8 @@ var MariaDBConnector = class _MariaDBConnector {
         results = await conn.query(processedSQL);
       }
       const rows = parseQueryResults(results);
-      return { rows };
+      const rowCount = extractAffectedRows(results);
+      return { rows, rowCount };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;
@@ -2274,6 +2303,27 @@ function getClientIdentifier(extra) {
   return "stdio";
 }
 
+// src/utils/tool-handler-helpers.ts
+function getEffectiveSourceId(sourceId) {
+  return sourceId || "default";
+}
+function createReadonlyViolationMessage(toolName, sourceId, connectorType) {
+  return `Tool '${toolName}' cannot execute in readonly mode for source '${sourceId}'. Only read-only SQL operations are allowed: ${allowedKeywords[connectorType]?.join(", ") || "none"}`;
+}
+function trackToolRequest(metadata, startTime, extra, success, error) {
+  requestStore.add({
+    id: crypto.randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceId: metadata.sourceId,
+    toolName: metadata.toolName,
+    sql: metadata.sql,
+    durationMs: Date.now() - startTime,
+    client: getClientIdentifier(extra),
+    success,
+    error
+  });
+}
+
 // src/tools/execute-sql.ts
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
@@ -2289,7 +2339,7 @@ function createExecuteSqlToolHandler(sourceId) {
   return async (args, extra) => {
     const { sql: sql2 } = args;
     const startTime = Date.now();
-    const effectiveSourceId = sourceId || "default";
+    const effectiveSourceId = getEffectiveSourceId(sourceId);
     let success = true;
     let errorMessage;
     let result;
@@ -2300,18 +2350,18 @@ function createExecuteSqlToolHandler(sourceId) {
       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"}`;
+        errorMessage = `Read-only mode is enabled. 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
+        readonly: toolConfig?.readonly,
+        maxRows: toolConfig?.max_rows
       };
       result = await connector.executeSQL(sql2, executeOptions);
       const responseData = {
         rows: result.rows,
-        count: result.rows.length,
+        count: result.rowCount,
         source_id: effectiveSourceId
       };
       return createToolSuccessResponse(responseData);
@@ -2320,17 +2370,17 @@ function createExecuteSqlToolHandler(sourceId) {
       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),
+      trackToolRequest(
+        {
+          sourceId: effectiveSourceId,
+          toolName: effectiveSourceId === "default" ? "execute_sql" : `execute_sql_${effectiveSourceId}`,
+          sql: sql2
+        },
+        startTime,
+        extra,
         success,
-        error: errorMessage
-      });
+        errorMessage
+      );
     }
   };
 }
@@ -2617,7 +2667,7 @@ async function searchIndexes(connector, pattern, schemaFilter, tableFilter, deta
   return results;
 }
 function createSearchDatabaseObjectsToolHandler(sourceId) {
-  return async (args, _extra) => {
+  return async (args, extra) => {
     const {
       object_type,
       pattern = "%",
@@ -2626,29 +2676,30 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
       detail_level = "names",
       limit = 100
     } = args;
+    const startTime = Date.now();
+    const effectiveSourceId = getEffectiveSourceId(sourceId);
+    let success = true;
+    let errorMessage;
     try {
       const connector = ConnectorManager.getCurrentConnector(sourceId);
       if (table) {
         if (!schema) {
-          return createToolErrorResponse(
-            "The 'table' parameter requires 'schema' to be specified",
-            "SCHEMA_REQUIRED"
-          );
+          success = false;
+          errorMessage = "The 'table' parameter requires 'schema' to be specified";
+          return createToolErrorResponse(errorMessage, "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"
-          );
+          success = false;
+          errorMessage = `The 'table' parameter only applies to object_type 'column' or 'index', not '${object_type}'`;
+          return createToolErrorResponse(errorMessage, "INVALID_TABLE_FILTER");
         }
       }
       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"
-          );
+          success = false;
+          errorMessage = `Schema '${schema}' does not exist. Available schemas: ${schemas.join(", ")}`;
+          return createToolErrorResponse(errorMessage, "SCHEMA_NOT_FOUND");
         }
       }
       let results = [];
@@ -2669,10 +2720,9 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
           results = await searchIndexes(connector, pattern, schema, table, detail_level, limit);
           break;
         default:
-          return createToolErrorResponse(
-            `Unsupported object_type: ${object_type}`,
-            "INVALID_OBJECT_TYPE"
-          );
+          success = false;
+          errorMessage = `Unsupported object_type: ${object_type}`;
+          return createToolErrorResponse(errorMessage, "INVALID_OBJECT_TYPE");
       }
       return createToolSuccessResponse({
         object_type,
@@ -2685,10 +2735,24 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
         truncated: results.length === limit
       });
     } catch (error) {
+      success = false;
+      errorMessage = error.message;
       return createToolErrorResponse(
-        `Error searching database objects: ${error.message}`,
+        `Error searching database objects: ${errorMessage}`,
         "SEARCH_ERROR"
       );
+    } finally {
+      trackToolRequest(
+        {
+          sourceId: effectiveSourceId,
+          toolName: effectiveSourceId === "default" ? "search_objects" : `search_objects_${effectiveSourceId}`,
+          sql: `search_objects(object_type=${object_type}, pattern=${pattern}, schema=${schema || "all"}, table=${table || "all"}, detail_level=${detail_level})`
+        },
+        startTime,
+        extra,
+        success,
+        errorMessage
+      );
     }
   };
 }
@@ -2731,9 +2795,14 @@ function zodToParameters(schema) {
 function getExecuteSqlMetadata(sourceId) {
   const sourceIds = ConnectorManager.getAvailableSourceIds();
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
-  const executeOptions = ConnectorManager.getCurrentExecuteOptions(sourceId);
   const dbType = sourceConfig.type;
   const isSingleSource = sourceIds.length === 1;
+  const registry = getToolRegistry();
+  const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, sourceId);
+  const executeOptions = {
+    readonly: toolConfig?.readonly,
+    maxRows: toolConfig?.max_rows
+  };
   const toolName = isSingleSource ? "execute_sql" : `execute_sql_${normalizeSourceId(sourceId)}`;
   const title = isSingleSource ? `Execute SQL (${dbType})` : `Execute SQL on ${sourceId} (${dbType})`;
   const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
@@ -2783,13 +2852,17 @@ function customParamsToToolParams(params) {
     description: param.description
   }));
 }
-function buildExecuteSqlTool(sourceId) {
+function buildExecuteSqlTool(sourceId, toolConfig) {
   const executeSqlMetadata = getExecuteSqlMetadata(sourceId);
   const executeSqlParameters = zodToParameters(executeSqlMetadata.schema);
+  const readonly = toolConfig && "readonly" in toolConfig ? toolConfig.readonly : void 0;
+  const max_rows = toolConfig && "max_rows" in toolConfig ? toolConfig.max_rows : void 0;
   return {
     name: executeSqlMetadata.name,
     description: executeSqlMetadata.description,
-    parameters: executeSqlParameters
+    parameters: executeSqlParameters,
+    readonly,
+    max_rows
   };
 }
 function buildSearchObjectsTool(sourceId) {
@@ -2834,14 +2907,19 @@ function buildSearchObjectsTool(sourceId) {
         required: false,
         description: "Max results (default: 100, max: 1000)"
       }
-    ]
+    ],
+    readonly: true
+    // search_objects is always readonly
   };
 }
 function buildCustomTool(toolConfig) {
   return {
     name: toolConfig.name,
     description: toolConfig.description,
-    parameters: customParamsToToolParams(toolConfig.parameters)
+    parameters: customParamsToToolParams(toolConfig.parameters),
+    statement: toolConfig.statement,
+    readonly: toolConfig.readonly,
+    max_rows: toolConfig.max_rows
   };
 }
 function getToolsForSource(sourceId) {
@@ -2849,7 +2927,7 @@ function getToolsForSource(sourceId) {
   const enabledToolConfigs = registry.getEnabledToolConfigs(sourceId);
   return enabledToolConfigs.map((toolConfig) => {
     if (toolConfig.name === "execute_sql") {
-      return buildExecuteSqlTool(sourceId);
+      return buildExecuteSqlTool(sourceId, toolConfig);
     } else if (toolConfig.name === "search_objects") {
       return buildSearchObjectsTool(sourceId);
     } else {
@@ -2916,12 +2994,13 @@ function createCustomToolHandler(toolConfig) {
     try {
       const validatedArgs = zodSchema.parse(args);
       const connector = ConnectorManager.getCurrentConnector(toolConfig.source);
-      const executeOptions = ConnectorManager.getCurrentExecuteOptions(
-        toolConfig.source
-      );
+      const executeOptions = {
+        readonly: toolConfig.readonly,
+        maxRows: toolConfig.max_rows
+      };
       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"}`;
+        errorMessage = createReadonlyViolationMessage(toolConfig.name, toolConfig.source, connector.id);
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
@@ -2936,7 +3015,7 @@ function createCustomToolHandler(toolConfig) {
       );
       const responseData = {
         rows: result.rows,
-        count: result.rows.length,
+        count: result.rowCount,
         source_id: toolConfig.source
       };
       return createToolSuccessResponse(responseData);
@@ -2954,17 +3033,17 @@ 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),
+      trackToolRequest(
+        {
+          sourceId: toolConfig.source,
+          toolName: toolConfig.name,
+          sql: toolConfig.statement
+        },
+        startTime,
+        extra,
         success,
-        error: errorMessage
-      });
+        errorMessage
+      );
     }
   };
 }
@@ -3039,7 +3118,6 @@ function registerCustomTool(server, sourceId, toolConfig) {
     },
     createCustomToolHandler(toolConfig)
   );
-  console.error(`  - ${toolConfig.name} \u2192 ${toolConfig.source} (${dbType})`);
 }
 
 // src/api/sources.ts
@@ -3069,12 +3147,6 @@ function transformSourceConfig(source) {
   if (source.user) {
     dataSource.user = source.user;
   }
-  if (source.readonly !== void 0) {
-    dataSource.readonly = source.readonly;
-  }
-  if (source.max_rows !== void 0) {
-    dataSource.max_rows = source.max_rows;
-  }
   if (source.ssh_host) {
     const sshTunnel = {
       enabled: true,
@@ -3314,7 +3386,7 @@ 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-FVGT25UH.js");
+    const { initializeToolRegistry } = await import("./registry-XXEL5IXH.js");
     initializeToolRegistry({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -3343,7 +3415,7 @@ See documentation for more details on configuring database connections.
     console.error(generateBanner(SERVER_VERSION, activeModes));
     const sourceDisplayInfos = buildSourceDisplayInfo(
       sources,
-      (sourceId) => getToolsForSource(sourceId).map((t) => t.name),
+      (sourceId) => getToolsForSource(sourceId).map((t) => t.readonly ? `\u{1F512} ${t.name}` : t.name),
       isDemo
     );
     console.error(generateStartupTable(sourceDisplayInfos));
@@ -3404,11 +3476,11 @@ See documentation for more details on configuring database connections.
       app.listen(port, "0.0.0.0", () => {
         if (process.env.NODE_ENV === "development") {
           console.error("Development mode detected!");
-          console.error("   Admin console dev server (with HMR): http://localhost:5173");
+          console.error("   Workbench dev server (with HMR): http://localhost:5173");
           console.error("   Backend API: http://localhost:8080");
           console.error("");
         } else {
-          console.error(`Admin console at http://localhost:${port}/`);
+          console.error(`Workbench at http://localhost:${port}/`);
         }
         console.error(`MCP server endpoint at http://localhost:${port}/mcp`);
       });