@bytebase/dbhub 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,16 +1,1492 @@
 #!/usr/bin/env node
-// Import connector modules to register them
-import './connectors/postgres/index.js'; // Register PostgreSQL connector
-import './connectors/sqlserver/index.js'; // Register SQL Server connector
-import './connectors/sqlite/index.js'; // SQLite connector
-import './connectors/mysql/index.js'; // MySQL connector
-// Import main function from server.ts
-import { main } from './server.js';
-/**
- * Entry point for the DBHub MCP Server
- * Handles top-level exceptions and starts the server
- */
-main().catch(error => {
-    console.error("Fatal error:", error);
+
+// src/connectors/postgres/index.ts
+import pg from "pg";
+
+// src/connectors/interface.ts
+var _ConnectorRegistry = class _ConnectorRegistry {
+  /**
+   * Register a new connector
+   */
+  static register(connector) {
+    _ConnectorRegistry.connectors.set(connector.id, connector);
+  }
+  /**
+   * Get a connector by ID
+   */
+  static getConnector(id) {
+    return _ConnectorRegistry.connectors.get(id) || null;
+  }
+  /**
+   * Get connector for a DSN string
+   * Tries to find a connector that can handle the given DSN format
+   */
+  static getConnectorForDSN(dsn) {
+    for (const connector of _ConnectorRegistry.connectors.values()) {
+      if (connector.dsnParser.isValidDSN(dsn)) {
+        return connector;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all available connector IDs
+   */
+  static getAvailableConnectors() {
+    return Array.from(_ConnectorRegistry.connectors.keys());
+  }
+  /**
+   * Get sample DSN for a specific connector
+   */
+  static getSampleDSN(connectorId) {
+    const connector = _ConnectorRegistry.getConnector(connectorId);
+    if (!connector) return null;
+    return connector.dsnParser.getSampleDSN();
+  }
+  /**
+   * Get all available sample DSNs
+   */
+  static getAllSampleDSNs() {
+    const samples = {};
+    for (const [id, connector] of _ConnectorRegistry.connectors.entries()) {
+      samples[id] = connector.dsnParser.getSampleDSN();
+    }
+    return samples;
+  }
+};
+_ConnectorRegistry.connectors = /* @__PURE__ */ new Map();
+var ConnectorRegistry = _ConnectorRegistry;
+
+// src/connectors/postgres/index.ts
+var { Pool } = pg;
+var PostgresDSNParser = class {
+  parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      throw new Error(`Invalid PostgreSQL DSN: ${dsn}`);
+    }
+    try {
+      const url = new URL(dsn);
+      const config = {
+        host: url.hostname,
+        port: url.port ? parseInt(url.port) : 5432,
+        database: url.pathname.substring(1),
+        // Remove leading '/'
+        user: url.username,
+        password: url.password
+      };
+      url.searchParams.forEach((value, key) => {
+        if (key === "sslmode") {
+          config.ssl = value !== "disable";
+        }
+      });
+      return config;
+    } catch (error) {
+      throw new Error(`Failed to parse PostgreSQL DSN: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getSampleDSN() {
+    return "postgres://postgres:password@localhost:5432/postgres?sslmode=disable";
+  }
+  isValidDSN(dsn) {
+    try {
+      const url = new URL(dsn);
+      return url.protocol === "postgres:" || url.protocol === "postgresql:";
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var PostgresConnector = class {
+  constructor() {
+    this.id = "postgres";
+    this.name = "PostgreSQL";
+    this.dsnParser = new PostgresDSNParser();
+    this.pool = null;
+  }
+  async connect(dsn) {
+    try {
+      const config = this.dsnParser.parse(dsn);
+      this.pool = new Pool(config);
+      const client = await this.pool.connect();
+      console.error("Successfully connected to PostgreSQL database");
+      client.release();
+    } catch (err) {
+      console.error("Failed to connect to PostgreSQL database:", err);
+      throw err;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getTables() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        ORDER BY table_name
+      `);
+      return result.rows.map((row) => row.table_name);
+    } finally {
+      client.release();
+    }
+  }
+  async tableExists(tableName) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
+        SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        )
+      `, [tableName]);
+      return result.rows[0].exists;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableSchema(tableName) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
+        SELECT 
+          column_name, 
+          data_type, 
+          is_nullable,
+          column_default
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        AND table_name = $1
+        ORDER BY ordinal_position
+      `, [tableName]);
+      return result.rows;
+    } finally {
+      client.release();
+    }
+  }
+  async executeQuery(query) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const safetyCheck = this.validateQuery(query);
+    if (!safetyCheck.isValid) {
+      throw new Error(safetyCheck.message || "Query validation failed");
+    }
+    const client = await this.pool.connect();
+    try {
+      return await client.query(query);
+    } finally {
+      client.release();
+    }
+  }
+  validateQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery.startsWith("select")) {
+      return {
+        isValid: false,
+        message: "Only SELECT queries are allowed for security reasons."
+      };
+    }
+    return { isValid: true };
+  }
+};
+var postgresConnector = new PostgresConnector();
+ConnectorRegistry.register(postgresConnector);
+
+// src/connectors/sqlserver/index.ts
+import sql from "mssql";
+var SQLServerDSNParser = class {
+  parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      throw new Error("Invalid SQL Server DSN format. Expected: sqlserver://username:password@host:port/database");
+    }
+    const url = new URL(dsn);
+    const host = url.hostname;
+    const port = url.port ? parseInt(url.port, 10) : 1433;
+    const database = url.pathname.substring(1);
+    const user = url.username;
+    const password = url.password;
+    const options = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      if (key === "encrypt") {
+        options.encrypt = value;
+      } else if (key === "trustServerCertificate") {
+        options.trustServerCertificate = value === "true";
+      } else if (key === "connectTimeout") {
+        options.connectTimeout = parseInt(value, 10);
+      } else if (key === "requestTimeout") {
+        options.requestTimeout = parseInt(value, 10);
+      }
+    }
+    return {
+      user,
+      password,
+      server: host,
+      port,
+      database,
+      options: {
+        encrypt: options.encrypt ?? true,
+        // Default to encrypted connection
+        trustServerCertificate: options.trustServerCertificate === true,
+        // Need explicit conversion to boolean
+        connectTimeout: options.connectTimeout ?? 15e3,
+        requestTimeout: options.requestTimeout ?? 15e3
+      }
+    };
+  }
+  getSampleDSN() {
+    return "sqlserver://username:password@localhost:1433/database?encrypt=true";
+  }
+  isValidDSN(dsn) {
+    try {
+      const url = new URL(dsn);
+      return url.protocol === "sqlserver:";
+    } catch (e) {
+      return false;
+    }
+  }
+};
+var SQLServerConnector = class {
+  constructor() {
+    this.id = "sqlserver";
+    this.name = "SQL Server";
+    this.dsnParser = new SQLServerDSNParser();
+  }
+  async connect(dsn) {
+    try {
+      this.config = this.dsnParser.parse(dsn);
+      if (!this.config.options) {
+        this.config.options = {};
+      }
+      this.connection = await new sql.ConnectionPool(this.config).connect();
+    } catch (error) {
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.close();
+      this.connection = void 0;
+    }
+  }
+  async getTables() {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const result = await this.connection.request().query(`
+        SELECT TABLE_NAME 
+        FROM INFORMATION_SCHEMA.TABLES 
+        ORDER BY TABLE_NAME
+      `);
+      return result.recordset.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get tables: ${error.message}`);
+    }
+  }
+  async tableExists(tableName) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const result = await this.connection.request().input("tableName", sql.VarChar, tableName).query(`
+          SELECT COUNT(*) as count
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_NAME = @tableName
+        `);
+      return result.recordset[0].count > 0;
+    } catch (error) {
+      throw new Error(`Failed to check if table exists: ${error.message}`);
+    }
+  }
+  async getTableSchema(tableName) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const result = await this.connection.request().input("tableName", sql.VarChar, tableName).query(`
+          SELECT 
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_NAME = @tableName
+          ORDER BY ORDINAL_POSITION
+        `);
+      return result.recordset;
+    } catch (error) {
+      throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
+    }
+  }
+  async executeQuery(query) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    const safetyCheck = this.validateQuery(query);
+    if (!safetyCheck.isValid) {
+      throw new Error(safetyCheck.message || "Query validation failed");
+    }
+    try {
+      const result = await this.connection.request().query(query);
+      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) {
+      throw new Error(`Failed to execute query: ${error.message}`);
+    }
+  }
+  validateQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery.startsWith("select")) {
+      return {
+        isValid: false,
+        message: "Only SELECT queries are allowed for security reasons."
+      };
+    }
+    return { isValid: true };
+  }
+};
+var sqlServerConnector = new SQLServerConnector();
+ConnectorRegistry.register(sqlServerConnector);
+
+// src/connectors/sqlite/index.ts
+import Database from "better-sqlite3";
+var SQLiteDSNParser = class {
+  parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      throw new Error(`Invalid SQLite DSN: ${dsn}`);
+    }
+    try {
+      const url = new URL(dsn);
+      let dbPath;
+      if (url.hostname === "" && url.pathname === ":memory:") {
+        dbPath = ":memory:";
+      } else {
+        if (url.pathname.startsWith("//")) {
+          dbPath = url.pathname.substring(2);
+        } else {
+          dbPath = url.pathname;
+        }
+      }
+      return { dbPath };
+    } catch (error) {
+      throw new Error(`Failed to parse SQLite DSN: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getSampleDSN() {
+    return "sqlite:///path/to/database.db";
+  }
+  isValidDSN(dsn) {
+    try {
+      const url = new URL(dsn);
+      return url.protocol === "sqlite:";
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var SQLiteConnector = class {
+  constructor() {
+    this.id = "sqlite";
+    this.name = "SQLite";
+    this.dsnParser = new SQLiteDSNParser();
+    this.db = null;
+    this.dbPath = ":memory:";
+  }
+  // Default to in-memory database
+  async connect(dsn, initScript) {
+    const config = this.dsnParser.parse(dsn);
+    this.dbPath = config.dbPath;
+    try {
+      this.db = new Database(this.dbPath);
+      console.error("Successfully connected to SQLite database");
+      if (initScript) {
+        this.db.exec(initScript);
+        console.error("Successfully initialized database with script");
+      }
+    } catch (error) {
+      console.error("Failed to connect to SQLite database:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.db) {
+      try {
+        this.db.close();
+        this.db = null;
+      } catch (error) {
+        throw error;
+      }
+    }
+    return Promise.resolve();
+  }
+  async getTables() {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const rows = this.db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `).all();
+      return rows.map((row) => row.name);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async tableExists(tableName) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const row = this.db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name = ?
+      `).get(tableName);
+      return !!row;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableSchema(tableName) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const rows = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const columns = rows.map((row) => ({
+        column_name: row.name,
+        data_type: row.type,
+        is_nullable: row.notnull === 0 ? "YES" : "NO",
+        // In SQLite, 0 means nullable
+        column_default: row.dflt_value
+      }));
+      return columns;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async executeQuery(query) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    const safetyCheck = this.validateQuery(query);
+    if (!safetyCheck.isValid) {
+      throw new Error(safetyCheck.message || "Query validation failed");
+    }
+    try {
+      const rows = this.db.prepare(query).all();
+      return { rows };
+    } catch (error) {
+      throw error;
+    }
+  }
+  validateQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery.startsWith("select")) {
+      return {
+        isValid: false,
+        message: "Only SELECT queries are allowed for security reasons."
+      };
+    }
+    return { isValid: true };
+  }
+};
+var sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);
+
+// src/connectors/mysql/index.ts
+import mysql from "mysql2/promise";
+var MySQLDSNParser = class {
+  parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      throw new Error(`Invalid MySQL DSN: ${dsn}`);
+    }
+    try {
+      const url = new URL(dsn);
+      const config = {
+        host: url.hostname,
+        port: url.port ? parseInt(url.port) : 3306,
+        database: url.pathname.substring(1),
+        // Remove leading '/'
+        user: url.username,
+        password: url.password
+      };
+      url.searchParams.forEach((value, key) => {
+        if (key === "ssl") {
+          config.ssl = value === "true" ? {} : void 0;
+        }
+      });
+      return config;
+    } catch (error) {
+      throw new Error(`Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getSampleDSN() {
+    return "mysql://root:password@localhost:3306/mysql";
+  }
+  isValidDSN(dsn) {
+    try {
+      const url = new URL(dsn);
+      return url.protocol === "mysql:";
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var MySQLConnector = class {
+  constructor() {
+    this.id = "mysql";
+    this.name = "MySQL";
+    this.dsnParser = new MySQLDSNParser();
+    this.pool = null;
+  }
+  async connect(dsn) {
+    try {
+      const config = this.dsnParser.parse(dsn);
+      this.pool = mysql.createPool(config);
+      const [rows] = await this.pool.query("SELECT 1");
+      console.error("Successfully connected to MySQL database");
+    } catch (err) {
+      console.error("Failed to connect to MySQL database:", err);
+      throw err;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getTables() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const [rows] = await this.pool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE()
+        ORDER BY table_name
+      `);
+      return rows.map((row) => row.table_name);
+    } catch (error) {
+      console.error("Error getting tables:", error);
+      throw error;
+    }
+  }
+  async tableExists(tableName) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const [rows] = await this.pool.query(`
+        SELECT COUNT(*) as count
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE() 
+        AND table_name = ?
+      `, [tableName]);
+      return rows[0].count > 0;
+    } catch (error) {
+      console.error("Error checking if table exists:", error);
+      throw error;
+    }
+  }
+  async getTableSchema(tableName) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const [rows] = await this.pool.query(`
+        SELECT 
+          column_name, 
+          data_type, 
+          is_nullable,
+          column_default
+        FROM information_schema.columns
+        WHERE table_schema = DATABASE()
+        AND table_name = ?
+        ORDER BY ordinal_position
+      `, [tableName]);
+      return rows;
+    } catch (error) {
+      console.error("Error getting table schema:", error);
+      throw error;
+    }
+  }
+  async executeQuery(query) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const safetyCheck = this.validateQuery(query);
+    if (!safetyCheck.isValid) {
+      throw new Error(safetyCheck.message || "Query validation failed");
+    }
+    try {
+      const [rows, fields] = await this.pool.query(query);
+      return { rows, fields };
+    } catch (error) {
+      console.error("Error executing query:", error);
+      throw error;
+    }
+  }
+  validateQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery.startsWith("select")) {
+      return {
+        isValid: false,
+        message: "Only SELECT queries are allowed for security reasons."
+      };
+    }
+    return { isValid: true };
+  }
+};
+var mysqlConnector = new MySQLConnector();
+ConnectorRegistry.register(mysqlConnector);
+
+// src/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import express from "express";
+import path3 from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/connectors/manager.ts
+var managerInstance = null;
+var ConnectorManager = class {
+  constructor() {
+    this.activeConnector = null;
+    this.connected = false;
+    if (!managerInstance) {
+      managerInstance = this;
+    }
+  }
+  /**
+   * Initialize and connect to the database using a DSN
+   */
+  async connectWithDSN(dsn, initScript) {
+    let connector = ConnectorRegistry.getConnectorForDSN(dsn);
+    if (!connector) {
+      throw new Error(`No connector found that can handle the DSN: ${dsn}`);
+    }
+    this.activeConnector = connector;
+    await this.activeConnector.connect(dsn, 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`);
+    }
+    this.activeConnector = connector;
+    const connectionString = dsn || connector.dsnParser.getSampleDSN();
+    await this.activeConnector.connect(connectionString);
+    this.connected = true;
+  }
+  /**
+   * Close the database connection
+   */
+  async disconnect() {
+    if (this.activeConnector && this.connected) {
+      await this.activeConnector.disconnect();
+      this.connected = false;
+    }
+  }
+  /**
+   * Get the active connector
+   */
+  getConnector() {
+    if (!this.activeConnector) {
+      throw new Error("No active connector. Call connectWithDSN() or connectWithType() first.");
+    }
+    return this.activeConnector;
+  }
+  /**
+   * Check if there's an active connection
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get all available connector types
+   */
+  static getAvailableConnectors() {
+    return ConnectorRegistry.getAvailableConnectors();
+  }
+  /**
+   * Get sample DSNs for all available connectors
+   */
+  static getAllSampleDSNs() {
+    return ConnectorRegistry.getAllSampleDSNs();
+  }
+  /**
+   * Get the current active connector instance
+   * This is used by resource and tool handlers
+   */
+  static getCurrentConnector() {
+    if (!managerInstance) {
+      throw new Error("ConnectorManager not initialized");
+    }
+    return managerInstance.getConnector();
+  }
+};
+
+// src/config/env.ts
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function parseCommandLineArgs() {
+  const args = process.argv.slice(2);
+  const parsedManually = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.substring(2).split("=");
+      if (value) {
+        parsedManually[key] = value;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        parsedManually[key] = args[i + 1];
+        i++;
+      } else {
+        parsedManually[key] = "true";
+      }
+    }
+  }
+  return parsedManually;
+}
+function loadEnvFiles() {
+  const isDevelopment = process.env.NODE_ENV === "development" || process.argv[1]?.includes("tsx");
+  const envFileNames = isDevelopment ? [".env.local", ".env"] : [".env"];
+  const envPaths = [];
+  for (const fileName of envFileNames) {
+    envPaths.push(
+      fileName,
+      // Current working directory
+      path.join(__dirname, "..", "..", fileName),
+      // Two levels up (src/config -> src -> root)
+      path.join(process.cwd(), fileName)
+      // Explicit current working directory
+    );
+  }
+  for (const envPath of envPaths) {
+    console.error(`Checking for env file: ${envPath}`);
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath });
+      return path.basename(envPath);
+    }
+  }
+  return null;
+}
+function isDemoMode() {
+  const args = parseCommandLineArgs();
+  return args.demo === "true";
+}
+function resolveDSN() {
+  const args = parseCommandLineArgs();
+  if (isDemoMode()) {
+    return {
+      dsn: "sqlite::memory:",
+      source: "demo mode",
+      isDemo: true
+    };
+  }
+  if (args.dsn) {
+    return { dsn: args.dsn, source: "command line argument" };
+  }
+  if (process.env.DSN) {
+    return { dsn: process.env.DSN, source: "environment variable" };
+  }
+  const loadedEnvFile = loadEnvFiles();
+  if (loadedEnvFile && process.env.DSN) {
+    return { dsn: process.env.DSN, source: `${loadedEnvFile} file` };
+  }
+  return null;
+}
+function resolveTransport() {
+  const args = parseCommandLineArgs();
+  if (args.transport) {
+    const type = args.transport === "sse" ? "sse" : "stdio";
+    return { type, source: "command line argument" };
+  }
+  if (process.env.TRANSPORT) {
+    const type = process.env.TRANSPORT === "sse" ? "sse" : "stdio";
+    return { type, source: "environment variable" };
+  }
+  return { type: "stdio", source: "default" };
+}
+function resolvePort() {
+  const args = parseCommandLineArgs();
+  if (args.port) {
+    const port = parseInt(args.port, 10);
+    return { port, source: "command line argument" };
+  }
+  if (process.env.PORT) {
+    const port = parseInt(process.env.PORT, 10);
+    return { port, source: "environment variable" };
+  }
+  return { port: 8080, source: "default" };
+}
+
+// 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";
+
+// src/utils/response-formatter.ts
+function formatSuccessResponse(data, meta = {}) {
+  return {
+    success: true,
+    data,
+    ...Object.keys(meta).length > 0 ? { meta } : {}
+  };
+}
+function formatErrorResponse(error, code = "ERROR", details) {
+  return {
+    success: false,
+    error,
+    code,
+    ...details ? { details } : {}
+  };
+}
+function createToolErrorResponse(error, code = "ERROR", details) {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(formatErrorResponse(error, code, details), null, 2),
+      mimeType: "application/json"
+    }],
+    isError: true
+  };
+}
+function createToolSuccessResponse(data, meta = {}) {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(formatSuccessResponse(data, meta), null, 2),
+      mimeType: "application/json"
+    }]
+  };
+}
+function createResourceErrorResponse(uri, error, code = "ERROR", details) {
+  return {
+    contents: [{
+      uri,
+      text: JSON.stringify(formatErrorResponse(error, code, details), null, 2),
+      mimeType: "application/json"
+    }]
+  };
+}
+function createResourceSuccessResponse(uri, data, meta = {}) {
+  return {
+    contents: [{
+      uri,
+      text: JSON.stringify(formatSuccessResponse(data, meta), null, 2),
+      mimeType: "application/json"
+    }]
+  };
+}
+function formatPromptSuccessResponse(text, references = []) {
+  return {
+    messages: [
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text
+        }
+      }
+    ],
+    ...references.length > 0 ? { references } : {}
+  };
+}
+function formatPromptErrorResponse(error, code = "ERROR") {
+  return {
+    messages: [
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: `Error: ${error}`
+        }
+      }
+    ],
+    error,
+    code
+  };
+}
+
+// src/resources/tables.ts
+async function tablesResourceHandler(uri, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  const tableNames = await connector.getTables();
+  const responseData = {
+    tables: tableNames,
+    count: tableNames.length
+  };
+  return createResourceSuccessResponse(uri.href, responseData);
+}
+
+// src/resources/schema.ts
+async function schemaResourceHandler(uri, variables, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  const tableName = Array.isArray(variables.tableName) ? variables.tableName[0] : variables.tableName;
+  try {
+    const columns = await connector.getTableSchema(tableName);
+    const formattedColumns = columns.map((col) => ({
+      name: col.column_name,
+      type: col.data_type,
+      nullable: col.is_nullable === "YES",
+      default: col.column_default
+    }));
+    const responseData = {
+      table: tableName,
+      columns: formattedColumns,
+      count: formattedColumns.length
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Table '${tableName}' does not exist or cannot be accessed`,
+      "TABLE_NOT_FOUND"
+    );
+  }
+}
+
+// src/resources/index.ts
+function registerResources(server) {
+  server.resource(
+    "tables",
+    "db://tables",
+    tablesResourceHandler
+  );
+  server.resource(
+    "schema",
+    new ResourceTemplate("db://schema/{tableName}", { list: void 0 }),
+    schemaResourceHandler
+  );
+}
+
+// src/tools/run-query.ts
+import { z } from "zod";
+var runQuerySchema = {
+  query: z.string().describe("SQL query to execute (SELECT only)")
+};
+async function runQueryToolHandler({ query }, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  try {
+    const validationResult = connector.validateQuery(query);
+    if (!validationResult.isValid) {
+      return createToolErrorResponse(
+        validationResult.message ?? "Unknown validation error",
+        "VALIDATION_ERROR"
+      );
+    }
+    const result = await connector.executeQuery(query);
+    const responseData = {
+      rows: result.rows,
+      count: result.rows.length
+    };
+    return createToolSuccessResponse(responseData);
+  } catch (error) {
+    return createToolErrorResponse(
+      error.message,
+      "EXECUTION_ERROR"
+    );
+  }
+}
+
+// src/tools/list-connectors.ts
+async function listConnectorsToolHandler(_args, _extra) {
+  const connectors = ConnectorManager.getAvailableConnectors();
+  const samples = ConnectorRegistry.getAllSampleDSNs();
+  let activeConnectorId = null;
+  try {
+    const activeConnector = ConnectorManager.getCurrentConnector();
+    activeConnectorId = activeConnector.id;
+  } catch (error) {
+  }
+  const isDemo = isDemoMode();
+  if (isDemo && !activeConnectorId) {
+    activeConnectorId = "sqlite";
+  }
+  const sampleObjects = Object.entries(samples).map(([id, dsn]) => ({
+    id,
+    dsn,
+    active: id === activeConnectorId
+  }));
+  const responseData = {
+    connectors: sampleObjects,
+    count: sampleObjects.length,
+    activeConnector: activeConnectorId,
+    demoMode: isDemo
+  };
+  return createToolSuccessResponse(responseData);
+}
+
+// src/tools/index.ts
+function registerTools(server) {
+  server.tool(
+    "run_query",
+    runQuerySchema,
+    runQueryToolHandler
+  );
+  server.tool(
+    "list_connectors",
+    {},
+    listConnectorsToolHandler
+  );
+}
+
+// src/prompts/sql-generator.ts
+import { z as z2 } from "zod";
+var sqlGeneratorSchema = {
+  description: z2.string().describe("Natural language description of the SQL query to generate"),
+  dialect: z2.enum(["postgres", "sqlite"]).optional().describe("SQL dialect to use (optional)")
+};
+async function sqlGeneratorPromptHandler({ description, dialect }, _extra) {
+  try {
+    const connector = ConnectorManager.getCurrentConnector();
+    const sqlDialect = dialect || (connector.id === "postgres" ? "postgres" : connector.id === "sqlite" ? "sqlite" : "postgres");
+    const tables = await connector.getTables();
+    const tableSchemas = await Promise.all(
+      tables.map(async (table) => {
+        try {
+          const columns = await connector.getTableSchema(table);
+          return {
+            table,
+            columns: columns.map((col) => ({
+              name: col.column_name,
+              type: col.data_type
+            }))
+          };
+        } catch (error) {
+          return null;
+        }
+      })
+    );
+    const accessibleSchemas = tableSchemas.filter((schema) => schema !== null);
+    const schemaContext = accessibleSchemas.length > 0 ? `Available tables and their columns:
+${accessibleSchemas.map(
+      (schema) => `- ${schema.table}: ${schema.columns.map(
+        (col) => `${col.name} (${col.type})`
+      ).join(", ")}`
+    ).join("\n")}` : "No schema information available.";
+    const dialectExamples = {
+      postgres: [
+        "SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'",
+        "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+        "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+      ],
+      sqlite: [
+        "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
+        "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+        "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+      ]
+    };
+    const prompt = `
+Generate a ${sqlDialect} SQL query based on this description: "${description}"
+
+${schemaContext}
+
+The query should:
+1. Be written for ${sqlDialect} dialect
+2. Use only the available tables and columns
+3. Prioritize readability
+4. Include appropriate comments
+5. Be compatible with ${sqlDialect} syntax
+`;
+    let generatedSQL;
+    if (description.toLowerCase().includes("count")) {
+      generatedSQL = `-- Count query generated from: "${description}"
+SELECT COUNT(*) AS count 
+FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name"};`;
+    } else if (description.toLowerCase().includes("average") || description.toLowerCase().includes("avg")) {
+      const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
+      const numericColumn = accessibleSchemas.length > 0 ? accessibleSchemas[0].columns.find((col) => ["int", "numeric", "decimal", "float", "real", "double"].some((t) => col.type.includes(t)))?.name || "numeric_column" : "numeric_column";
+      generatedSQL = `-- Average query generated from: "${description}"
+SELECT AVG(${numericColumn}) AS average
+FROM ${table};`;
+    } else if (description.toLowerCase().includes("join")) {
+      generatedSQL = `-- Join query generated from: "${description}"
+SELECT t1.*, t2.*
+FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"} t1
+JOIN ${accessibleSchemas.length > 1 ? accessibleSchemas[1]?.table : "table2"} t2
+  ON t1.id = t2.${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"}_id;`;
+    } else {
+      const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
+      generatedSQL = `-- Query generated from: "${description}"
+SELECT * 
+FROM ${table}
+LIMIT 10;`;
+    }
+    return formatPromptSuccessResponse(
+      generatedSQL,
+      // Add references to example queries that could help
+      dialectExamples[sqlDialect]
+    );
+  } catch (error) {
+    return formatPromptErrorResponse(
+      `Failed to generate SQL: ${error.message}`,
+      "SQL_GENERATION_ERROR"
+    );
+  }
+}
+
+// src/prompts/db-explainer.ts
+import { z as z3 } from "zod";
+var dbExplainerSchema = {
+  target: z3.string().describe("Name of the table, column, or database to explain")
+};
+async function dbExplainerPromptHandler({ target }, _extra) {
+  try {
+    const connector = ConnectorManager.getCurrentConnector();
+    const tables = await connector.getTables();
+    const normalizedTarget = target.toLowerCase();
+    const matchingTable = tables.find((t) => t.toLowerCase() === normalizedTarget);
+    if (matchingTable) {
+      const columns = await connector.getTableSchema(matchingTable);
+      const tableDescription = `Table: ${matchingTable}
+      
+Structure:
+${columns.map((col) => `- ${col.column_name} (${col.data_type})${col.is_nullable === "YES" ? ", nullable" : ""}${col.column_default ? `, default: ${col.column_default}` : ""}`).join("\n")}
+
+Purpose:
+This table appears to store ${determineTablePurpose(matchingTable, columns)}
+
+Relationships:
+${determineRelationships(matchingTable, columns)}`;
+      return formatPromptSuccessResponse(tableDescription);
+    }
+    if (target.includes(".")) {
+      const [tableName, columnName] = target.split(".");
+      if (tables.find((t) => t.toLowerCase() === tableName.toLowerCase())) {
+        const columns = await connector.getTableSchema(tableName);
+        const column = columns.find((c) => c.column_name.toLowerCase() === columnName.toLowerCase());
+        if (column) {
+          const columnDescription = `Column: ${tableName}.${column.column_name}
+          
+Type: ${column.data_type}
+Nullable: ${column.is_nullable === "YES" ? "Yes" : "No"}
+Default: ${column.column_default || "None"}
+
+Purpose:
+${determineColumnPurpose(column.column_name, column.data_type)}`;
+          return formatPromptSuccessResponse(columnDescription);
+        }
+      }
+    }
+    if (["database", "db", "schema", "overview", "all"].includes(normalizedTarget)) {
+      let dbOverview = `Database Overview
+
+Tables: ${tables.length}
+${tables.map((t) => `- ${t}`).join("\n")}
+
+This database ${describeDatabasePurpose(tables)}`;
+      return formatPromptSuccessResponse(dbOverview);
+    }
+    const possibleTableMatches = tables.filter(
+      (t) => t.toLowerCase().includes(normalizedTarget) || normalizedTarget.includes(t.toLowerCase())
+    );
+    if (possibleTableMatches.length > 0) {
+      return formatPromptSuccessResponse(
+        `Could not find exact match for "${target}". Did you mean one of these tables?
+
+${possibleTableMatches.join("\n")}`
+      );
+    }
+    return formatPromptErrorResponse(
+      `Could not find a table, column, or database feature matching "${target}"`,
+      "NOT_FOUND"
+    );
+  } catch (error) {
+    return formatPromptErrorResponse(
+      `Error explaining database: ${error.message}`,
+      "EXPLANATION_ERROR"
+    );
+  }
+}
+function determineTablePurpose(tableName, columns) {
+  const lowerTableName = tableName.toLowerCase();
+  const columnNames = columns.map((c) => c.column_name.toLowerCase());
+  if (lowerTableName.includes("user") || columnNames.includes("username") || columnNames.includes("email")) {
+    return "user information and profiles";
+  }
+  if (lowerTableName.includes("order") || lowerTableName.includes("purchase")) {
+    return "order or purchase transactions";
+  }
+  if (lowerTableName.includes("product") || lowerTableName.includes("item")) {
+    return "product or item information";
+  }
+  if (lowerTableName.includes("log") || columnNames.includes("timestamp")) {
+    return "event or activity logs";
+  }
+  if (columnNames.includes("created_at") && columnNames.includes("updated_at")) {
+    return "tracking timestamped data records";
+  }
+  return "data related to " + tableName;
+}
+function determineRelationships(tableName, columns) {
+  const potentialRelationships = [];
+  const idColumns = columns.filter(
+    (c) => c.column_name.toLowerCase().endsWith("_id") && !c.column_name.toLowerCase().startsWith(tableName.toLowerCase())
+  );
+  if (idColumns.length > 0) {
+    idColumns.forEach((col) => {
+      const referencedTable = col.column_name.toLowerCase().replace("_id", "");
+      potentialRelationships.push(`May have a relationship with the "${referencedTable}" table (via ${col.column_name})`);
+    });
+  }
+  if (columns.some((c) => c.column_name.toLowerCase() === "id")) {
+    potentialRelationships.push(`May be referenced by other tables as "${tableName.toLowerCase()}_id"`);
+  }
+  return potentialRelationships.length > 0 ? potentialRelationships.join("\n") : "No obvious relationships identified based on column names";
+}
+function determineColumnPurpose(columnName, dataType) {
+  const lowerColumnName = columnName.toLowerCase();
+  if (lowerColumnName === "id") {
+    return "Primary identifier for records in this table";
+  }
+  if (lowerColumnName.endsWith("_id")) {
+    const referencedTable = lowerColumnName.replace("_id", "");
+    return `Foreign key reference to the "${referencedTable}" table`;
+  }
+  if (lowerColumnName.includes("name")) {
+    return "Stores name information";
+  }
+  if (lowerColumnName.includes("email")) {
+    return "Stores email address information";
+  }
+  if (lowerColumnName.includes("password") || lowerColumnName.includes("hash")) {
+    return "Stores security credential information (likely hashed)";
+  }
+  if (lowerColumnName === "created_at" || lowerColumnName === "created_on") {
+    return "Timestamp for when the record was created";
+  }
+  if (lowerColumnName === "updated_at" || lowerColumnName === "modified_at") {
+    return "Timestamp for when the record was last updated";
+  }
+  if (lowerColumnName.includes("date") || lowerColumnName.includes("time")) {
+    return "Stores date or time information";
+  }
+  if (lowerColumnName.includes("price") || lowerColumnName.includes("cost") || lowerColumnName.includes("amount")) {
+    return "Stores monetary value information";
+  }
+  if (dataType.includes("boolean")) {
+    return "Stores a true/false flag";
+  }
+  if (dataType.includes("json")) {
+    return "Stores structured JSON data";
+  }
+  if (dataType.includes("text") || dataType.includes("varchar") || dataType.includes("char")) {
+    return "Stores text information";
+  }
+  return `Stores ${dataType} data`;
+}
+function describeDatabasePurpose(tables) {
+  const tableNames = tables.map((t) => t.toLowerCase());
+  if (tableNames.some((t) => t.includes("user")) && tableNames.some((t) => t.includes("order"))) {
+    return "appears to be an e-commerce or customer order management system";
+  }
+  if (tableNames.some((t) => t.includes("patient")) || tableNames.some((t) => t.includes("medical"))) {
+    return "appears to be related to healthcare or medical record management";
+  }
+  if (tableNames.some((t) => t.includes("student")) || tableNames.some((t) => t.includes("course"))) {
+    return "appears to be related to education or student management";
+  }
+  if (tableNames.some((t) => t.includes("employee")) || tableNames.some((t) => t.includes("payroll"))) {
+    return "appears to be related to HR or employee management";
+  }
+  if (tableNames.some((t) => t.includes("inventory")) || tableNames.some((t) => t.includes("stock"))) {
+    return "appears to be related to inventory or stock management";
+  }
+  return "contains multiple tables that store related information";
+}
+
+// src/prompts/index.ts
+function registerPrompts(server) {
+  server.prompt(
+    "generate_sql",
+    "Generate SQL queries from natural language descriptions",
+    sqlGeneratorSchema,
+    sqlGeneratorPromptHandler
+  );
+  server.prompt(
+    "explain_db",
+    "Get explanations about database tables, columns, and structures",
+    dbExplainerSchema,
+    dbExplainerPromptHandler
+  );
+}
+
+// src/server.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+var packageJsonPath = path3.join(__dirname3, "..", "package.json");
+var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+var SERVER_NAME = "DBHub MCP Server";
+var SERVER_VERSION = packageJson.version;
+function generateBanner(version, isDemo = false) {
+  const demoText = isDemo ? " [DEMO MODE]" : "";
+  return `
+ _____  ____  _   _       _     
+|  __ \\|  _ \\| | | |     | |    
+| |  | | |_) | |_| |_   _| |__  
+| |  | |  _ <|  _  | | | | '_ \\ 
+| |__| | |_) | | | | |_| | |_) |
+|_____/|____/|_| |_|\\__,_|_.__/ 
+                                
+v${version}${demoText} - Universal Database MCP Server
+`;
+}
+async function main() {
+  try {
+    const dsnData = resolveDSN();
+    if (!dsnData) {
+      const samples = ConnectorRegistry.getAllSampleDSNs();
+      const sampleFormats = Object.entries(samples).map(([id, dsn]) => `  - ${id}: ${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):
+
+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
+
+Example formats:
+${sampleFormats}
+
+See documentation for more details on configuring database connections.
+`);
+      process.exit(1);
+    }
+    const server = new McpServer2({
+      name: SERVER_NAME,
+      version: SERVER_VERSION
+    });
+    registerResources(server);
+    registerTools(server);
+    registerPrompts(server);
+    const connectorManager = new ConnectorManager();
+    console.error(`Connecting with DSN: ${dsnData.dsn}`);
+    console.error(`DSN source: ${dsnData.source}`);
+    if (dsnData.isDemo) {
+      console.error("Running in demo mode with sample employee database");
+      const initScript = getSqliteInMemorySetupSql();
+      await connectorManager.connectWithDSN(dsnData.dsn, initScript);
+    } else {
+      await connectorManager.connectWithDSN(dsnData.dsn);
+    }
+    const transportData = resolveTransport();
+    console.error(`Using transport: ${transportData.type}`);
+    console.error(`Transport source: ${transportData.source}`);
+    console.error(generateBanner(SERVER_VERSION, dsnData.isDemo));
+    if (transportData.type === "sse") {
+      const app = express();
+      let transport;
+      app.get("/sse", async (req, res) => {
+        transport = new SSEServerTransport("/message", res);
+        console.error("Client connected", transport?.["_sessionId"]);
+        await server.connect(transport);
+        res.on("close", () => {
+          console.error("Client Disconnected", transport?.["_sessionId"]);
+        });
+      });
+      app.post("/message", async (req, res) => {
+        console.error("Client Message", transport?.["_sessionId"]);
+        await transport.handlePostMessage(req, res, req.body);
+      });
+      const portData = resolvePort();
+      const port = portData.port;
+      console.error(`Port source: ${portData.source}`);
+      app.listen(port, () => {
+        console.error(`DBHub server listening at http://localhost:${port}`);
+        console.error(`Connect to MCP server at http://localhost:${port}/sse`);
+      });
+    } else {
+      const transport = new StdioServerTransport();
+      console.error("Starting with STDIO transport");
+      await server.connect(transport);
+      process.on("SIGINT", async () => {
+        console.error("Shutting down...");
+        await transport.close();
+        process.exit(0);
+      });
+    }
+  } catch (err) {
+    console.error("Fatal error:", err);
     process.exit(1);
+  }
+}
+
+// src/index.ts
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
 });