@bytebase/dbhub 0.11.5 → 0.11.7

package/dist/index.js

@@ -184,6 +184,21 @@ function obfuscateDSNPassword(dsn) {
     return dsn;
   }
 }
+function getDatabaseTypeFromDSN(dsn) {
+  if (!dsn) {
+    return void 0;
+  }
+  const protocol = dsn.split(":")[0];
+  const protocolToType = {
+    "postgres": "postgres",
+    "postgresql": "postgres",
+    "mysql": "mysql",
+    "mariadb": "mariadb",
+    "sqlserver": "sqlserver",
+    "sqlite": "sqlite"
+  };
+  return protocolToType[protocol];
+}
 
 // src/utils/sql-row-limiter.ts
 var SQLRowLimiter = class {
@@ -279,7 +294,8 @@ var SQLRowLimiter = class {
 // src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
-  async parse(dsn) {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -291,7 +307,7 @@ Expected: ${expectedFormat}`
     }
     try {
       const url = new SafeURL(dsn);
-      const config = {
+      const config2 = {
         host: url.hostname,
         port: url.port ? parseInt(url.port) : 5432,
         database: url.pathname ? url.pathname.substring(1) : "",
@@ -302,15 +318,18 @@ Expected: ${expectedFormat}`
       url.forEachSearchParam((value, key) => {
         if (key === "sslmode") {
           if (value === "disable") {
-            config.ssl = false;
+            config2.ssl = false;
           } else if (value === "require") {
-            config.ssl = { rejectUnauthorized: false };
+            config2.ssl = { rejectUnauthorized: false };
           } else {
-            config.ssl = true;
+            config2.ssl = true;
           }
         }
       });
-      return config;
+      if (connectionTimeoutSeconds !== void 0) {
+        config2.connectionTimeoutMillis = connectionTimeoutSeconds * 1e3;
+      }
+      return config2;
     } catch (error) {
       throw new Error(
         `Failed to parse PostgreSQL DSN: ${error instanceof Error ? error.message : String(error)}`
@@ -328,17 +347,20 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var PostgresConnector = class {
+var PostgresConnector = class _PostgresConnector {
   constructor() {
     this.id = "postgres";
     this.name = "PostgreSQL";
     this.dsnParser = new PostgresDSNParser();
     this.pool = null;
   }
-  async connect(dsn) {
+  clone() {
+    return new _PostgresConnector();
+  }
+  async connect(dsn, initScript, config) {
     try {
-      const config = await this.dsnParser.parse(dsn);
-      this.pool = new Pool(config);
+      const poolConfig = await this.dsnParser.parse(dsn, config);
+      this.pool = new Pool(poolConfig);
       const client = await this.pool.connect();
       console.error("Successfully connected to PostgreSQL database");
       client.release();
@@ -625,7 +647,9 @@ ConnectorRegistry.register(postgresConnector);
 import sql from "mssql";
 import { DefaultAzureCredential } from "@azure/identity";
 var SQLServerDSNParser = class {
-  async parse(dsn) {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
+    const requestTimeoutSeconds = config?.requestTimeoutSeconds;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -639,14 +663,12 @@ Expected: ${expectedFormat}`
       const url = new SafeURL(dsn);
       const options = {};
       url.forEachSearchParam((value, key) => {
-        if (key === "connectTimeout") {
-          options.connectTimeout = parseInt(value, 10);
-        } else if (key === "requestTimeout") {
-          options.requestTimeout = parseInt(value, 10);
-        } else if (key === "authentication") {
+        if (key === "authentication") {
           options.authentication = value;
         } else if (key === "sslmode") {
           options.sslmode = value;
+        } else if (key === "instanceName") {
+          options.instanceName = value;
         }
       });
       if (options.sslmode) {
@@ -658,7 +680,7 @@ Expected: ${expectedFormat}`
           options.trustServerCertificate = true;
         }
       }
-      const config = {
+      const config2 = {
         user: url.username,
         password: url.password,
         server: url.hostname,
@@ -670,15 +692,21 @@ Expected: ${expectedFormat}`
           encrypt: options.encrypt ?? false,
           // Default to unencrypted for development
           trustServerCertificate: options.trustServerCertificate ?? false,
-          connectTimeout: options.connectTimeout ?? 15e3,
-          requestTimeout: options.requestTimeout ?? 15e3
+          ...connectionTimeoutSeconds !== void 0 && {
+            connectTimeout: connectionTimeoutSeconds * 1e3
+          },
+          ...requestTimeoutSeconds !== void 0 && {
+            requestTimeout: requestTimeoutSeconds * 1e3
+          },
+          instanceName: options.instanceName
+          // Add named instance support
         }
       };
       if (options.authentication === "azure-active-directory-access-token") {
         try {
           const credential = new DefaultAzureCredential();
           const token = await credential.getToken("https://database.windows.net/");
-          config.authentication = {
+          config2.authentication = {
             type: "azure-active-directory-access-token",
             options: {
               token: token.token
@@ -689,7 +717,7 @@ Expected: ${expectedFormat}`
           throw new Error(`Failed to get Azure AD token: ${errorMessage}`);
         }
       }
-      return config;
+      return config2;
     } catch (error) {
       throw new Error(
         `Failed to parse SQL Server DSN: ${error instanceof Error ? error.message : String(error)}`
@@ -697,7 +725,7 @@ Expected: ${expectedFormat}`
     }
   }
   getSampleDSN() {
-    return "sqlserver://username:password@localhost:1433/database?sslmode=disable";
+    return "sqlserver://username:password@localhost:1433/database?sslmode=disable&instanceName=INSTANCE1";
   }
   isValidDSN(dsn) {
     try {
@@ -707,15 +735,18 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var SQLServerConnector = class {
+var SQLServerConnector = class _SQLServerConnector {
   constructor() {
     this.id = "sqlserver";
     this.name = "SQL Server";
     this.dsnParser = new SQLServerDSNParser();
   }
-  async connect(dsn) {
+  clone() {
+    return new _SQLServerConnector();
+  }
+  async connect(dsn, initScript, config) {
     try {
-      this.config = await this.dsnParser.parse(dsn);
+      this.config = await this.dsnParser.parse(dsn, config);
       if (!this.config.options) {
         this.config.options = {};
       }
@@ -979,7 +1010,7 @@ ConnectorRegistry.register(sqlServerConnector);
 // src/connectors/sqlite/index.ts
 import Database from "better-sqlite3";
 var SQLiteDSNParser = class {
-  async parse(dsn) {
+  async parse(dsn, config) {
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -1019,7 +1050,7 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var SQLiteConnector = class {
+var SQLiteConnector = class _SQLiteConnector {
   constructor() {
     this.id = "sqlite";
     this.name = "SQLite";
@@ -1028,9 +1059,17 @@ var SQLiteConnector = class {
     this.dbPath = ":memory:";
   }
   // Default to in-memory database
-  async connect(dsn, initScript) {
-    const config = await this.dsnParser.parse(dsn);
-    this.dbPath = config.dbPath;
+  clone() {
+    return new _SQLiteConnector();
+  }
+  /**
+   * Connect to SQLite database
+   * Note: SQLite does not support connection timeouts as it's a local file-based database.
+   * The config parameter is accepted for interface compliance but ignored.
+   */
+  async connect(dsn, initScript, config) {
+    const parsedConfig = await this.dsnParser.parse(dsn, config);
+    this.dbPath = parsedConfig.dbPath;
     try {
       this.db = new Database(this.dbPath);
       console.error("Successfully connected to SQLite database");
@@ -1232,8 +1271,47 @@ ConnectorRegistry.register(sqliteConnector);
 
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
+
+// src/utils/multi-statement-result-parser.ts
+function isMetadataObject(element) {
+  if (!element || typeof element !== "object" || Array.isArray(element)) {
+    return false;
+  }
+  return "affectedRows" in element || "insertId" in element || "fieldCount" in element || "warningStatus" in element;
+}
+function isMultiStatementResult(results) {
+  if (!Array.isArray(results) || results.length === 0) {
+    return false;
+  }
+  const firstElement = results[0];
+  return isMetadataObject(firstElement) || Array.isArray(firstElement);
+}
+function extractRowsFromMultiStatement(results) {
+  if (!Array.isArray(results)) {
+    return [];
+  }
+  const allRows = [];
+  for (const result of results) {
+    if (Array.isArray(result)) {
+      allRows.push(...result);
+    }
+  }
+  return allRows;
+}
+function parseQueryResults(results) {
+  if (!Array.isArray(results)) {
+    return [];
+  }
+  if (isMultiStatementResult(results)) {
+    return extractRowsFromMultiStatement(results);
+  }
+  return results;
+}
+
+// src/connectors/mysql/index.ts
 var MySQLDSNParser = class {
-  async parse(dsn) {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -1245,7 +1323,7 @@ Expected: ${expectedFormat}`
     }
     try {
       const url = new SafeURL(dsn);
-      const config = {
+      const config2 = {
         host: url.hostname,
         port: url.port ? parseInt(url.port) : 3306,
         database: url.pathname ? url.pathname.substring(1) : "",
@@ -1258,15 +1336,18 @@ Expected: ${expectedFormat}`
       url.forEachSearchParam((value, key) => {
         if (key === "sslmode") {
           if (value === "disable") {
-            config.ssl = void 0;
+            config2.ssl = void 0;
           } else if (value === "require") {
-            config.ssl = { rejectUnauthorized: false };
+            config2.ssl = { rejectUnauthorized: false };
           } else {
-            config.ssl = {};
+            config2.ssl = {};
           }
         }
       });
-      return config;
+      if (connectionTimeoutSeconds !== void 0) {
+        config2.connectTimeout = connectionTimeoutSeconds * 1e3;
+      }
+      return config2;
     } catch (error) {
       throw new Error(
         `Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`
@@ -1284,17 +1365,20 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var MySQLConnector = class {
+var MySQLConnector = class _MySQLConnector {
   constructor() {
     this.id = "mysql";
     this.name = "MySQL";
     this.dsnParser = new MySQLDSNParser();
     this.pool = null;
   }
-  async connect(dsn) {
+  clone() {
+    return new _MySQLConnector();
+  }
+  async connect(dsn, initScript, config) {
     try {
-      const config = await this.dsnParser.parse(dsn);
-      this.pool = mysql.createPool(config);
+      const connectionOptions = await this.dsnParser.parse(dsn, config);
+      this.pool = mysql.createPool(connectionOptions);
       const [rows] = await this.pool.query("SELECT 1");
       console.error("Successfully connected to MySQL database");
     } catch (err) {
@@ -1582,6 +1666,7 @@ var MySQLConnector = class {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
+    const conn = await this.pool.getConnection();
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
@@ -1594,22 +1679,15 @@ var MySQLConnector = class {
           processedSQL += ";";
         }
       }
-      const results = await this.pool.query(processedSQL);
+      const results = await conn.query(processedSQL);
       const [firstResult] = results;
-      if (Array.isArray(firstResult) && firstResult.length > 0 && Array.isArray(firstResult[0])) {
-        let allRows = [];
-        for (const result of firstResult) {
-          if (Array.isArray(result)) {
-            allRows.push(...result);
-          }
-        }
-        return { rows: allRows };
-      } else {
-        return { rows: Array.isArray(firstResult) ? firstResult : [] };
-      }
+      const rows = parseQueryResults(firstResult);
+      return { rows };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;
+    } finally {
+      conn.release();
     }
   }
 };
@@ -1619,7 +1697,8 @@ ConnectorRegistry.register(mysqlConnector);
 // src/connectors/mariadb/index.ts
 import mariadb from "mariadb";
 var MariadbDSNParser = class {
-  async parse(dsn) {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -1631,7 +1710,7 @@ Expected: ${expectedFormat}`
     }
     try {
       const url = new SafeURL(dsn);
-      const config = {
+      const config2 = {
         host: url.hostname,
         port: url.port ? parseInt(url.port) : 3306,
         database: url.pathname ? url.pathname.substring(1) : "",
@@ -1640,21 +1719,22 @@ Expected: ${expectedFormat}`
         password: url.password,
         multipleStatements: true,
         // Enable native multi-statement support
-        connectTimeout: 5e3
-        // 5 second timeout for connections
+        ...connectionTimeoutSeconds !== void 0 && {
+          connectTimeout: connectionTimeoutSeconds * 1e3
+        }
       };
       url.forEachSearchParam((value, key) => {
         if (key === "sslmode") {
           if (value === "disable") {
-            config.ssl = void 0;
+            config2.ssl = void 0;
           } else if (value === "require") {
-            config.ssl = { rejectUnauthorized: false };
+            config2.ssl = { rejectUnauthorized: false };
           } else {
-            config.ssl = {};
+            config2.ssl = {};
           }
         }
       });
-      return config;
+      return config2;
     } catch (error) {
       throw new Error(
         `Failed to parse MariaDB DSN: ${error instanceof Error ? error.message : String(error)}`
@@ -1672,17 +1752,20 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var MariaDBConnector = class {
+var MariaDBConnector = class _MariaDBConnector {
   constructor() {
     this.id = "mariadb";
     this.name = "MariaDB";
     this.dsnParser = new MariadbDSNParser();
     this.pool = null;
   }
-  async connect(dsn) {
+  clone() {
+    return new _MariaDBConnector();
+  }
+  async connect(dsn, initScript, config) {
     try {
-      const config = await this.dsnParser.parse(dsn);
-      this.pool = mariadb.createPool(config);
+      const connectionConfig = await this.dsnParser.parse(dsn, config);
+      this.pool = mariadb.createPool(connectionConfig);
       console.error("Testing connection to MariaDB...");
       await this.pool.query("SELECT 1");
       console.error("Successfully connected to MariaDB database");
@@ -1971,6 +2054,7 @@ var MariaDBConnector = class {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
+    const conn = await this.pool.getConnection();
     try {
       let processedSQL = sql2;
       if (options.maxRows) {
@@ -1983,25 +2067,14 @@ var MariaDBConnector = class {
           processedSQL += ";";
         }
       }
-      const results = await this.pool.query(processedSQL);
-      if (Array.isArray(results)) {
-        if (results.length > 0 && Array.isArray(results[0]) && results[0].length > 0) {
-          let allRows = [];
-          for (const result of results) {
-            if (Array.isArray(result)) {
-              allRows.push(...result);
-            }
-          }
-          return { rows: allRows };
-        } else {
-          return { rows: results };
-        }
-      } else {
-        return { rows: [] };
-      }
+      const results = await conn.query(processedSQL);
+      const rows = parseQueryResults(results);
+      return { rows };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;
+    } finally {
+      conn.release();
     }
   }
 };
@@ -2015,7 +2088,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import express from "express";
 import path3 from "path";
 import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/utils/ssh-tunnel.ts
 import { Client } from "ssh2";
@@ -2159,6 +2232,12 @@ var SSHTunnel = class {
   }
 };
 
+// src/config/toml-loader.ts
+import fs2 from "fs";
+import path2 from "path";
+import { homedir as homedir3 } from "os";
+import toml from "@iarna/toml";
+
 // src/config/env.ts
 import dotenv from "dotenv";
 import path from "path";
@@ -2544,96 +2623,398 @@ function resolveSSHConfig() {
     source: sources.join(", ")
   };
 }
+async function resolveSourceConfigs() {
+  const tomlConfig = loadTomlConfig();
+  if (tomlConfig) {
+    return tomlConfig;
+  }
+  const dsnResult = resolveDSN();
+  if (dsnResult) {
+    let dsnUrl;
+    try {
+      dsnUrl = new URL(dsnResult.dsn);
+    } catch (error) {
+      throw new Error(
+        `Invalid DSN format: ${dsnResult.dsn}. Expected format: protocol://[user[:password]@]host[:port]/database`
+      );
+    }
+    const protocol = dsnUrl.protocol.replace(":", "");
+    let dbType;
+    if (protocol === "postgresql" || protocol === "postgres") {
+      dbType = "postgres";
+    } else if (protocol === "mysql") {
+      dbType = "mysql";
+    } else if (protocol === "mariadb") {
+      dbType = "mariadb";
+    } else if (protocol === "sqlserver") {
+      dbType = "sqlserver";
+    } else if (protocol === "sqlite") {
+      dbType = "sqlite";
+    } else {
+      throw new Error(`Unsupported database type in DSN: ${protocol}`);
+    }
+    const source = {
+      id: "default",
+      type: dbType,
+      dsn: dsnResult.dsn
+    };
+    const sshResult = resolveSSHConfig();
+    if (sshResult) {
+      source.ssh_host = sshResult.config.host;
+      source.ssh_port = sshResult.config.port;
+      source.ssh_user = sshResult.config.username;
+      source.ssh_password = sshResult.config.password;
+      source.ssh_key = sshResult.config.privateKey;
+      source.ssh_passphrase = sshResult.config.passphrase;
+    }
+    source.readonly = isReadOnlyMode();
+    const maxRowsResult = resolveMaxRows();
+    if (maxRowsResult) {
+      source.max_rows = maxRowsResult.maxRows;
+    }
+    if (dsnResult.isDemo) {
+      const { getSqliteInMemorySetupSql } = await import("./demo-loader-EOVFD32T.js");
+      source.init_script = getSqliteInMemorySetupSql();
+    }
+    return {
+      sources: [source],
+      source: dsnResult.isDemo ? "demo mode" : dsnResult.source
+    };
+  }
+  return null;
+}
+
+// src/config/toml-loader.ts
+function loadTomlConfig() {
+  const configPath = resolveTomlConfigPath();
+  if (!configPath) {
+    return null;
+  }
+  try {
+    const fileContent = fs2.readFileSync(configPath, "utf-8");
+    const parsedToml = toml.parse(fileContent);
+    validateTomlConfig(parsedToml, configPath);
+    const sources = processSourceConfigs(parsedToml.sources, configPath);
+    return {
+      sources,
+      source: path2.basename(configPath)
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(
+        `Failed to load TOML configuration from ${configPath}: ${error.message}`
+      );
+    }
+    throw error;
+  }
+}
+function resolveTomlConfigPath() {
+  const args = parseCommandLineArgs();
+  if (args.config) {
+    const configPath = expandHomeDir(args.config);
+    if (!fs2.existsSync(configPath)) {
+      throw new Error(
+        `Configuration file specified by --config flag not found: ${configPath}`
+      );
+    }
+    return configPath;
+  }
+  const defaultConfigPath = path2.join(process.cwd(), "dbhub.toml");
+  if (fs2.existsSync(defaultConfigPath)) {
+    return defaultConfigPath;
+  }
+  return null;
+}
+function validateTomlConfig(config, configPath) {
+  if (!config.sources) {
+    throw new Error(
+      `Configuration file ${configPath} must contain a [[sources]] array. Example:
+
+[[sources]]
+id = "my_db"
+dsn = "postgres://..."`
+    );
+  }
+  if (!Array.isArray(config.sources)) {
+    throw new Error(
+      `Configuration file ${configPath}: 'sources' must be an array. Use [[sources]] syntax for array of tables in TOML.`
+    );
+  }
+  if (config.sources.length === 0) {
+    throw new Error(
+      `Configuration file ${configPath}: sources array cannot be empty. Please define at least one source with [[sources]].`
+    );
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  for (const source of config.sources) {
+    if (!source.id) {
+      throw new Error(
+        `Configuration file ${configPath}: each source must have an 'id' field. Example: [[sources]]
+id = "my_db"`
+      );
+    }
+    if (ids.has(source.id)) {
+      duplicates.push(source.id);
+    } else {
+      ids.add(source.id);
+    }
+  }
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Configuration file ${configPath}: duplicate source IDs found: ${duplicates.join(", ")}. Each source must have a unique 'id' field.`
+    );
+  }
+  for (const source of config.sources) {
+    validateSourceConfig(source, configPath);
+  }
+}
+function validateSourceConfig(source, configPath) {
+  const hasConnectionParams = source.type && (source.type === "sqlite" ? source.database : source.host);
+  if (!source.dsn && !hasConnectionParams) {
+    throw new Error(
+      `Configuration file ${configPath}: source '${source.id}' must have either:
+  - 'dsn' field (e.g., dsn = "postgres://user:pass@host:5432/dbname")
+  - OR connection parameters (type, host, database, user, password)
+  - For SQLite: type = "sqlite" and database path`
+    );
+  }
+  if (source.type) {
+    const validTypes = ["postgres", "mysql", "mariadb", "sqlserver", "sqlite"];
+    if (!validTypes.includes(source.type)) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid type '${source.type}'. Valid types: ${validTypes.join(", ")}`
+      );
+    }
+  }
+  if (source.max_rows !== void 0) {
+    if (typeof source.max_rows !== "number" || source.max_rows <= 0) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid max_rows. Must be a positive integer.`
+      );
+    }
+  }
+  if (source.connection_timeout !== void 0) {
+    if (typeof source.connection_timeout !== "number" || source.connection_timeout <= 0) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid connection_timeout. Must be a positive number (in seconds).`
+      );
+    }
+  }
+  if (source.request_timeout !== void 0) {
+    if (typeof source.request_timeout !== "number" || source.request_timeout <= 0) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid request_timeout. Must be a positive number (in seconds).`
+      );
+    }
+  }
+  if (source.ssh_port !== void 0) {
+    if (typeof source.ssh_port !== "number" || source.ssh_port <= 0 || source.ssh_port > 65535) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid ssh_port. Must be between 1 and 65535.`
+      );
+    }
+  }
+}
+function processSourceConfigs(sources, configPath) {
+  return sources.map((source) => {
+    const processed = { ...source };
+    if (processed.ssh_key) {
+      processed.ssh_key = expandHomeDir(processed.ssh_key);
+    }
+    if (processed.type === "sqlite" && processed.database) {
+      processed.database = expandHomeDir(processed.database);
+    }
+    if (processed.dsn && processed.dsn.startsWith("sqlite:///~")) {
+      processed.dsn = `sqlite:///${expandHomeDir(processed.dsn.substring(11))}`;
+    }
+    return processed;
+  });
+}
+function expandHomeDir(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path2.join(homedir3(), filePath.substring(2));
+  }
+  return filePath;
+}
+function buildDSNFromSource(source) {
+  if (source.dsn) {
+    return source.dsn;
+  }
+  if (!source.type) {
+    throw new Error(
+      `Source '${source.id}': 'type' field is required when 'dsn' is not provided`
+    );
+  }
+  if (source.type === "sqlite") {
+    if (!source.database) {
+      throw new Error(
+        `Source '${source.id}': 'database' field is required for SQLite`
+      );
+    }
+    return `sqlite:///${source.database}`;
+  }
+  if (!source.host || !source.user || !source.password || !source.database) {
+    throw new Error(
+      `Source '${source.id}': missing required connection parameters. Required: type, host, user, password, database`
+    );
+  }
+  const port = source.port || (source.type === "postgres" ? 5432 : source.type === "mysql" || source.type === "mariadb" ? 3306 : source.type === "sqlserver" ? 1433 : void 0);
+  if (!port) {
+    throw new Error(`Source '${source.id}': unable to determine port`);
+  }
+  const encodedUser = encodeURIComponent(source.user);
+  const encodedPassword = encodeURIComponent(source.password);
+  const encodedDatabase = encodeURIComponent(source.database);
+  let dsn = `${source.type}://${encodedUser}:${encodedPassword}@${source.host}:${port}/${encodedDatabase}`;
+  if (source.type === "sqlserver" && source.instanceName) {
+    dsn += `?instanceName=${encodeURIComponent(source.instanceName)}`;
+  }
+  return dsn;
+}
 
 // src/connectors/manager.ts
 var managerInstance = null;
 var ConnectorManager = class {
+  // Ordered list of source IDs (first is default)
   constructor() {
-    this.activeConnector = null;
-    this.connected = false;
-    this.sshTunnel = null;
-    this.originalDSN = null;
-    this.maxRows = null;
+    // Maps for multi-source support
+    this.connectors = /* @__PURE__ */ new Map();
+    this.sshTunnels = /* @__PURE__ */ new Map();
+    this.executeOptions = /* @__PURE__ */ new Map();
+    this.sourceConfigs = /* @__PURE__ */ new Map();
+    // Store original source configs
+    this.sourceIds = [];
     if (!managerInstance) {
       managerInstance = this;
     }
-    const maxRowsData = resolveMaxRows();
-    if (maxRowsData) {
-      this.maxRows = maxRowsData.maxRows;
-      console.error(`Max rows limit: ${this.maxRows} (from ${maxRowsData.source})`);
+  }
+  /**
+   * Initialize and connect to multiple databases using source configurations
+   * This is the new multi-source connection method
+   */
+  async connectWithSources(sources) {
+    if (sources.length === 0) {
+      throw new Error("No sources provided");
+    }
+    for (const source of sources) {
+      await this.connectSource(source);
     }
+    console.error(`Successfully connected to ${sources.length} database source(s)`);
   }
   /**
-   * Initialize and connect to the database using a DSN
+   * Connect to a single source (helper for connectWithSources)
    */
-  async connectWithDSN(dsn, initScript) {
-    this.originalDSN = dsn;
-    const sshConfig = resolveSSHConfig();
+  async connectSource(source) {
+    const sourceId = source.id;
+    console.error(`Connecting to source '${sourceId || "(default)"}' ...`);
+    const dsn = buildDSNFromSource(source);
     let actualDSN = dsn;
-    if (sshConfig) {
-      console.error(`SSH tunnel configuration loaded from ${sshConfig.source}`);
+    if (source.ssh_host) {
+      if (!source.ssh_user) {
+        throw new Error(
+          `Source '${sourceId}': SSH tunnel requires ssh_user`
+        );
+      }
+      const sshConfig = {
+        host: source.ssh_host,
+        port: source.ssh_port || 22,
+        username: source.ssh_user,
+        password: source.ssh_password,
+        privateKey: source.ssh_key,
+        passphrase: source.ssh_passphrase
+      };
+      if (!sshConfig.password && !sshConfig.privateKey) {
+        throw new Error(
+          `Source '${sourceId}': SSH tunnel requires either ssh_password or ssh_key`
+        );
+      }
       const url = new URL(dsn);
       const targetHost = url.hostname;
       const targetPort = parseInt(url.port) || this.getDefaultPort(dsn);
-      this.sshTunnel = new SSHTunnel();
-      const tunnelInfo = await this.sshTunnel.establish(sshConfig.config, {
+      const tunnel = new SSHTunnel();
+      const tunnelInfo = await tunnel.establish(sshConfig, {
         targetHost,
         targetPort
       });
       url.hostname = "127.0.0.1";
       url.port = tunnelInfo.localPort.toString();
       actualDSN = url.toString();
-      console.error(`Database connection will use SSH tunnel through localhost:${tunnelInfo.localPort}`);
+      this.sshTunnels.set(sourceId, tunnel);
+      console.error(
+        `  SSH tunnel established through localhost:${tunnelInfo.localPort}`
+      );
     }
-    let connector = ConnectorRegistry.getConnectorForDSN(actualDSN);
-    if (!connector) {
-      throw new Error(`No connector found that can handle the DSN: ${actualDSN}`);
+    const connectorPrototype = ConnectorRegistry.getConnectorForDSN(actualDSN);
+    if (!connectorPrototype) {
+      throw new Error(
+        `Source '${sourceId}': No connector found for DSN: ${actualDSN}`
+      );
     }
-    this.activeConnector = connector;
-    await this.activeConnector.connect(actualDSN, initScript);
-    this.connected = true;
-  }
-  /**
-   * Initialize and connect to the database using a specific connector type
-   */
-  async connectWithType(connectorType, dsn) {
-    const connector = ConnectorRegistry.getConnector(connectorType);
-    if (!connector) {
-      throw new Error(`Connector "${connectorType}" not found`);
+    const connector = connectorPrototype.clone();
+    const config = {};
+    if (source.connection_timeout !== void 0) {
+      config.connectionTimeoutSeconds = source.connection_timeout;
+    }
+    if (connector.id === "sqlserver" && source.request_timeout !== void 0) {
+      config.requestTimeoutSeconds = source.request_timeout;
     }
-    this.activeConnector = connector;
-    const connectionString = dsn || connector.dsnParser.getSampleDSN();
-    await this.activeConnector.connect(connectionString);
-    this.connected = true;
+    await connector.connect(actualDSN, source.init_script, config);
+    this.connectors.set(sourceId, connector);
+    this.sourceIds.push(sourceId);
+    this.sourceConfigs.set(sourceId, source);
+    const options = {};
+    if (source.max_rows !== void 0) {
+      options.maxRows = source.max_rows;
+    }
+    if (source.readonly !== void 0) {
+      options.readonly = source.readonly;
+    }
+    this.executeOptions.set(sourceId, options);
+    console.error(`  Connected successfully`);
   }
   /**
-   * Close the database connection
+   * Close all database connections
    */
   async disconnect() {
-    if (this.activeConnector && this.connected) {
-      await this.activeConnector.disconnect();
-      this.connected = false;
+    for (const [sourceId, connector] of this.connectors.entries()) {
+      try {
+        await connector.disconnect();
+        console.error(`Disconnected from source '${sourceId || "(default)"}'`);
+      } catch (error) {
+        console.error(`Error disconnecting from source '${sourceId}':`, error);
+      }
     }
-    if (this.sshTunnel) {
-      await this.sshTunnel.close();
-      this.sshTunnel = null;
+    for (const [sourceId, tunnel] of this.sshTunnels.entries()) {
+      try {
+        await tunnel.close();
+      } catch (error) {
+        console.error(`Error closing SSH tunnel for source '${sourceId}':`, error);
+      }
     }
-    this.originalDSN = null;
+    this.connectors.clear();
+    this.sshTunnels.clear();
+    this.executeOptions.clear();
+    this.sourceConfigs.clear();
+    this.sourceIds = [];
   }
   /**
-   * Get the active connector
+   * Get a connector by source ID
+   * If sourceId is not provided, returns the default (first) connector
    */
-  getConnector() {
-    if (!this.activeConnector) {
-      throw new Error("No active connector. Call connectWithDSN() or connectWithType() first.");
+  getConnector(sourceId) {
+    const id = sourceId || this.sourceIds[0];
+    const connector = this.connectors.get(id);
+    if (!connector) {
+      if (sourceId) {
+        throw new Error(
+          `Source '${sourceId}' not found. Available sources: ${this.sourceIds.join(", ")}`
+        );
+      } else {
+        throw new Error("No sources connected. Call connectWithSources() first.");
+      }
     }
-    return this.activeConnector;
-  }
-  /**
-   * Check if there's an active connection
-   */
-  isConnected() {
-    return this.connected;
+    return connector;
   }
   /**
    * Get all available connector types
@@ -2650,32 +3031,80 @@ var ConnectorManager = class {
   /**
    * Get the current active connector instance
    * This is used by resource and tool handlers
+   * @param sourceId - Optional source ID. If not provided, returns default (first) connector
    */
-  static getCurrentConnector() {
+  static getCurrentConnector(sourceId) {
     if (!managerInstance) {
       throw new Error("ConnectorManager not initialized");
     }
-    return managerInstance.getConnector();
+    return managerInstance.getConnector(sourceId);
   }
   /**
    * Get execute options for SQL execution
+   * @param sourceId - Optional source ID. If not provided, returns default options
    */
-  getExecuteOptions() {
-    const options = {};
-    if (this.maxRows !== null) {
-      options.maxRows = this.maxRows;
-    }
-    return options;
+  getExecuteOptions(sourceId) {
+    const id = sourceId || this.sourceIds[0];
+    return this.executeOptions.get(id) || {};
   }
   /**
    * Get the current execute options
    * This is used by tool handlers
+   * @param sourceId - Optional source ID. If not provided, returns default options
+   */
+  static getCurrentExecuteOptions(sourceId) {
+    if (!managerInstance) {
+      throw new Error("ConnectorManager not initialized");
+    }
+    return managerInstance.getExecuteOptions(sourceId);
+  }
+  /**
+   * Get all available source IDs
+   */
+  getSourceIds() {
+    return [...this.sourceIds];
+  }
+  /** Get all available source IDs */
+  static getAvailableSourceIds() {
+    if (!managerInstance) {
+      throw new Error("ConnectorManager not initialized");
+    }
+    return managerInstance.getSourceIds();
+  }
+  /**
+   * Get source configuration by ID
+   * @param sourceId - Source ID. If not provided, returns default (first) source config
+   */
+  getSourceConfig(sourceId) {
+    if (this.connectors.size === 0) {
+      return null;
+    }
+    const id = sourceId || this.sourceIds[0];
+    return this.sourceConfigs.get(id) || null;
+  }
+  /**
+   * Get all source configurations
+   */
+  getAllSourceConfigs() {
+    return this.sourceIds.map((id) => this.sourceConfigs.get(id));
+  }
+  /**
+   * Get source configuration by ID (static method for external access)
    */
-  static getCurrentExecuteOptions() {
+  static getSourceConfig(sourceId) {
     if (!managerInstance) {
       throw new Error("ConnectorManager not initialized");
     }
-    return managerInstance.getExecuteOptions();
+    return managerInstance.getSourceConfig(sourceId);
+  }
+  /**
+   * Get all source configurations (static method for external access)
+   */
+  static getAllSourceConfigs() {
+    if (!managerInstance) {
+      throw new Error("ConnectorManager not initialized");
+    }
+    return managerInstance.getAllSourceConfigs();
   }
   /**
    * Get default port for a database based on DSN protocol
@@ -2694,45 +3123,6 @@ var ConnectorManager = class {
   }
 };
 
-// src/config/demo-loader.ts
-import fs2 from "fs";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var DEMO_DATA_DIR;
-var projectRootPath = path2.join(__dirname2, "..", "..", "..");
-var projectResourcesPath = path2.join(projectRootPath, "resources", "employee-sqlite");
-var distPath = path2.join(__dirname2, "resources", "employee-sqlite");
-if (fs2.existsSync(projectResourcesPath)) {
-  DEMO_DATA_DIR = projectResourcesPath;
-} else if (fs2.existsSync(distPath)) {
-  DEMO_DATA_DIR = distPath;
-} else {
-  DEMO_DATA_DIR = path2.join(process.cwd(), "resources", "employee-sqlite");
-  if (!fs2.existsSync(DEMO_DATA_DIR)) {
-    throw new Error(`Could not find employee-sqlite resources in any of the expected locations: 
-      - ${projectResourcesPath}
-      - ${distPath}
-      - ${DEMO_DATA_DIR}`);
-  }
-}
-function loadSqlFile(fileName) {
-  const filePath = path2.join(DEMO_DATA_DIR, fileName);
-  return fs2.readFileSync(filePath, "utf8");
-}
-function getSqliteInMemorySetupSql() {
-  let sql2 = loadSqlFile("employee.sql");
-  const readRegex = /\.read\s+([a-zA-Z0-9_]+\.sql)/g;
-  let match;
-  while ((match = readRegex.exec(sql2)) !== null) {
-    const includePath = match[1];
-    const includeContent = loadSqlFile(includePath);
-    sql2 = sql2.replace(match[0], includeContent);
-  }
-  return sql2;
-}
-
 // src/resources/index.ts
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -3091,7 +3481,8 @@ var allowedKeywords = {
 
 // src/tools/execute-sql.ts
 var executeSqlSchema = {
-  sql: z.string().describe("SQL query or multiple SQL statements to execute (separated by semicolons)")
+  sql: z.string().describe("SQL query or multiple SQL statements to execute (separated by semicolons)"),
+  source_id: z.string().optional().describe("Database source ID to execute the query against (optional, defaults to first configured source)")
 };
 function splitSQLStatements(sql2) {
   return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
@@ -3117,10 +3508,10 @@ function areAllStatementsReadOnly(sql2, connectorType) {
   const statements = splitSQLStatements(sql2);
   return statements.every((statement) => isReadOnlySQL(statement, connectorType));
 }
-async function executeSqlToolHandler({ sql: sql2 }, _extra) {
-  const connector = ConnectorManager.getCurrentConnector();
-  const executeOptions = ConnectorManager.getCurrentExecuteOptions();
+async function executeSqlToolHandler({ sql: sql2, source_id }, _extra) {
   try {
+    const connector = ConnectorManager.getCurrentConnector(source_id);
+    const executeOptions = ConnectorManager.getCurrentExecuteOptions(source_id);
     if (isReadOnlyMode() && !areAllStatementsReadOnly(sql2, connector.id)) {
       return createToolErrorResponse(
         `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`,
@@ -3130,7 +3521,9 @@ async function executeSqlToolHandler({ sql: sql2 }, _extra) {
     const result = await connector.executeSQL(sql2, executeOptions);
     const responseData = {
       rows: result.rows,
-      count: result.rows.length
+      count: result.rows.length,
+      source_id: source_id || "(default)"
+      // Include source_id in response for clarity
     };
     return createToolSuccessResponse(responseData);
   } catch (error) {
@@ -3564,10 +3957,100 @@ function registerPrompts(server) {
   );
 }
 
+// src/api/sources.ts
+function transformSourceConfig(source, isDefault) {
+  if (!source.type && source.dsn) {
+    const inferredType = getDatabaseTypeFromDSN(source.dsn);
+    if (inferredType) {
+      source.type = inferredType;
+    }
+  }
+  if (!source.type) {
+    throw new Error(`Source ${source.id} is missing required type field`);
+  }
+  const dataSource = {
+    id: source.id,
+    type: source.type,
+    is_default: isDefault
+  };
+  if (source.host) {
+    dataSource.host = source.host;
+  }
+  if (source.port !== void 0) {
+    dataSource.port = source.port;
+  }
+  if (source.database) {
+    dataSource.database = source.database;
+  }
+  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,
+      ssh_host: source.ssh_host
+    };
+    if (source.ssh_port !== void 0) {
+      sshTunnel.ssh_port = source.ssh_port;
+    }
+    if (source.ssh_user) {
+      sshTunnel.ssh_user = source.ssh_user;
+    }
+    dataSource.ssh_tunnel = sshTunnel;
+  }
+  return dataSource;
+}
+function listSources(req, res) {
+  try {
+    const sourceConfigs = ConnectorManager.getAllSourceConfigs();
+    const sources = sourceConfigs.map((config, index) => {
+      const isDefault = index === 0;
+      return transformSourceConfig(config, isDefault);
+    });
+    res.json(sources);
+  } catch (error) {
+    console.error("Error listing sources:", error);
+    const errorResponse = {
+      error: error instanceof Error ? error.message : "Internal server error"
+    };
+    res.status(500).json(errorResponse);
+  }
+}
+function getSource(req, res) {
+  try {
+    const sourceId = req.params.sourceId;
+    const sourceIds = ConnectorManager.getAvailableSourceIds();
+    const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
+    if (!sourceConfig) {
+      const errorResponse = {
+        error: "Source not found",
+        source_id: sourceId
+      };
+      res.status(404).json(errorResponse);
+      return;
+    }
+    const isDefault = sourceIds[0] === sourceId;
+    const dataSource = transformSourceConfig(sourceConfig, isDefault);
+    res.json(dataSource);
+  } catch (error) {
+    console.error(`Error getting source ${req.params.sourceId}:`, error);
+    const errorResponse = {
+      error: error instanceof Error ? error.message : "Internal server error"
+    };
+    res.status(500).json(errorResponse);
+  }
+}
+
 // src/server.ts
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path3.dirname(__filename3);
-var packageJsonPath = path3.join(__dirname3, "..", "package.json");
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var packageJsonPath = path3.join(__dirname2, "..", "package.json");
 var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
@@ -3588,22 +4071,28 @@ async function main() {
   try {
     const idData = resolveId();
     const id = idData?.id;
-    const dsnData = resolveDSN();
-    if (!dsnData) {
+    const sourceConfigsData = await resolveSourceConfigs();
+    if (!sourceConfigsData) {
       const samples = ConnectorRegistry.getAllSampleDSNs();
       const sampleFormats = Object.entries(samples).map(([id2, dsn]) => `  - ${id2}: ${dsn}`).join("\n");
       console.error(`
-ERROR: Database connection string (DSN) is required.
-Please provide the DSN in one of these ways (in order of priority):
+ERROR: Database connection configuration is required.
+Please provide configuration in one of these ways (in order of priority):
 
 1. Use demo mode: --demo (uses in-memory SQLite with sample employee database)
-2. Command line argument: --dsn="your-connection-string"
-3. Environment variable: export DSN="your-connection-string"
-4. .env file: DSN=your-connection-string
+2. TOML config file: --config=path/to/dbhub.toml or ./dbhub.toml
+3. Command line argument: --dsn="your-connection-string"
+4. Environment variable: export DSN="your-connection-string"
+5. .env file: DSN=your-connection-string
 
-Example formats:
+Example DSN formats:
 ${sampleFormats}
 
+Example TOML config (dbhub.toml):
+  [[sources]]
+  id = "my_db"
+  dsn = "postgres://user:pass@localhost:5432/dbname"
+
 See documentation for more details on configuring database connections.
 `);
       process.exit(1);
@@ -3619,24 +4108,28 @@ See documentation for more details on configuring database connections.
       return server;
     };
     const connectorManager = new ConnectorManager();
-    console.error(`Connecting with DSN: ${redactDSN(dsnData.dsn)}`);
-    console.error(`DSN source: ${dsnData.source}`);
+    const sources = sourceConfigsData.sources;
+    console.error(`Configuration source: ${sourceConfigsData.source}`);
     if (idData) {
       console.error(`ID: ${idData.id} (from ${idData.source})`);
     }
-    if (dsnData.isDemo) {
-      const initScript = getSqliteInMemorySetupSql();
-      await connectorManager.connectWithDSN(dsnData.dsn, initScript);
-    } else {
-      await connectorManager.connectWithDSN(dsnData.dsn);
+    console.error(`Connecting to ${sources.length} database source(s)...`);
+    for (const source of sources) {
+      const dsn = source.dsn || buildDSNFromSource(source);
+      console.error(`  - ${source.id}: ${redactDSN(dsn)}`);
     }
+    await connectorManager.connectWithSources(sources);
     const transportData = resolveTransport();
-    console.error(`Using transport: ${transportData.type}`);
+    console.error(`MCP transport: ${transportData.type}`);
     console.error(`Transport source: ${transportData.source}`);
+    const portData = resolvePort();
+    const port = portData.port;
+    console.error(`HTTP server port: ${port} (source: ${portData.source})`);
     const readonly = isReadOnlyMode();
     const activeModes = [];
     const modeDescriptions = [];
-    if (dsnData.isDemo) {
+    const isDemo = isDemoMode();
+    if (isDemo) {
       activeModes.push("DEMO");
       modeDescriptions.push("using sample employee database");
     }
@@ -3644,31 +4137,38 @@ See documentation for more details on configuring database connections.
       activeModes.push("READ-ONLY");
       modeDescriptions.push("only read only queries allowed");
     }
+    if (sources.length > 1) {
+      console.error(`Multi-source mode: ${sources.length} databases configured`);
+    }
     if (activeModes.length > 0) {
       console.error(`Running in ${activeModes.join(" and ")} mode - ${modeDescriptions.join(", ")}`);
     }
     console.error(generateBanner(SERVER_VERSION, activeModes));
+    const app = express();
+    app.use(express.json());
+    app.use((req, res, next) => {
+      const origin = req.headers.origin;
+      if (origin && !origin.startsWith("http://localhost") && !origin.startsWith("https://localhost")) {
+        return res.status(403).json({ error: "Forbidden origin" });
+      }
+      res.header("Access-Control-Allow-Origin", origin || "http://localhost");
+      res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+      res.header("Access-Control-Allow-Credentials", "true");
+      if (req.method === "OPTIONS") {
+        return res.sendStatus(200);
+      }
+      next();
+    });
+    const frontendPath = path3.join(__dirname2, "..", "frontend", "dist");
+    app.use(express.static(frontendPath));
+    app.get("/healthz", (req, res) => {
+      res.status(200).send("OK");
+    });
+    app.get("/api/sources", listSources);
+    app.get("/api/sources/:sourceId", getSource);
     if (transportData.type === "http") {
-      const app = express();
-      app.use(express.json());
-      app.use((req, res, next) => {
-        const origin = req.headers.origin;
-        if (origin && !origin.startsWith("http://localhost") && !origin.startsWith("https://localhost")) {
-          return res.status(403).json({ error: "Forbidden origin" });
-        }
-        res.header("Access-Control-Allow-Origin", origin || "http://localhost");
-        res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
-        res.header("Access-Control-Allow-Credentials", "true");
-        if (req.method === "OPTIONS") {
-          return res.sendStatus(200);
-        }
-        next();
-      });
-      app.get("/healthz", (req, res) => {
-        res.status(200).send("OK");
-      });
-      app.post("/message", async (req, res) => {
+      app.post("/mcp", async (req, res) => {
         try {
           const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: void 0,
@@ -3686,17 +4186,29 @@ See documentation for more details on configuring database connections.
           }
         }
       });
-      const portData = resolvePort();
-      const port = portData.port;
-      console.error(`Port source: ${portData.source}`);
-      app.listen(port, "0.0.0.0", () => {
-        console.error(`DBHub server listening at http://0.0.0.0:${port}`);
-        console.error(`Connect to MCP server at http://0.0.0.0:${port}/message`);
-      });
-    } else {
+    }
+    app.get("*", (req, res) => {
+      res.sendFile(path3.join(frontendPath, "index.html"));
+    });
+    app.listen(port, "0.0.0.0", () => {
+      console.error(`DBHub HTTP server listening at http://0.0.0.0:${port}`);
+      if (process.env.NODE_ENV === "development") {
+        console.error("");
+        console.error("\u{1F680} Development mode detected!");
+        console.error("   Frontend dev server (with HMR): http://localhost:5173");
+        console.error("   Backend API: http://localhost:8080");
+        console.error("");
+      } else {
+        console.error(`Frontend accessible at http://0.0.0.0:${port}/`);
+      }
+      if (transportData.type === "http") {
+        console.error(`MCP server endpoint at http://0.0.0.0:${port}/mcp`);
+      }
+    });
+    if (transportData.type === "stdio") {
       const server = createServer2();
       const transport = new StdioServerTransport();
-      console.error("Starting with STDIO transport");
+      console.error("Starting MCP with STDIO transport");
       await server.connect(transport);
       process.on("SIGINT", async () => {
         console.error("Shutting down...");