@bytebase/dbhub 0.9.0 → 0.11.0

package/dist/index.js

@@ -159,6 +159,9 @@ function obfuscateDSNPassword(dsn) {
       return dsn;
     }
     const protocol = protocolMatch[1];
+    if (protocol === "sqlite") {
+      return dsn;
+    }
     const protocolPart = dsn.split("://")[1];
     if (!protocolPart) {
       return dsn;
@@ -876,6 +879,246 @@ var SQLServerConnector = class {
 var sqlServerConnector = new SQLServerConnector();
 ConnectorRegistry.register(sqlServerConnector);
 
+// src/connectors/sqlite/index.ts
+import Database from "better-sqlite3";
+var SQLiteDSNParser = class {
+  async parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid SQLite DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(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 {
+      return dsn.startsWith("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 = await 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 getSchemas() {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return ["main"];
+  }
+  async getTables(schema) {
+    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, schema) {
+    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 getTableIndexes(tableName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const indexInfoRows = this.db.prepare(
+        `
+        SELECT 
+          name as index_name,
+          0 as is_unique
+        FROM sqlite_master 
+        WHERE type = 'index' 
+        AND tbl_name = ?
+      `
+      ).all(tableName);
+      const indexListRows = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
+      const indexUniqueMap = /* @__PURE__ */ new Map();
+      for (const indexListRow of indexListRows) {
+        indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
+      }
+      const tableInfo = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
+      const results = [];
+      for (const indexInfo of indexInfoRows) {
+        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${indexInfo.index_name})`).all();
+        const columnNames = indexDetailRows.map((row) => row.name);
+        results.push({
+          index_name: indexInfo.index_name,
+          column_names: columnNames,
+          is_unique: indexUniqueMap.get(indexInfo.index_name) || false,
+          is_primary: false
+        });
+      }
+      if (pkColumns.length > 0) {
+        results.push({
+          index_name: "PRIMARY",
+          column_names: pkColumns,
+          is_unique: true,
+          is_primary: true
+        });
+      }
+      return results;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    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,
+        // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
+        is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
+        column_default: row.dflt_value
+      }));
+      return columns;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getStoredProcedures(schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return [];
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    throw new Error(
+      "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
+    );
+  }
+  async executeSQL(sql2) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      if (statements.length === 1) {
+        const trimmedStatement = statements[0].toLowerCase().trim();
+        const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+        if (isReadStatement) {
+          const rows = this.db.prepare(statements[0]).all();
+          return { rows };
+        } else {
+          this.db.prepare(statements[0]).run();
+          return { rows: [] };
+        }
+      } else {
+        const readStatements = [];
+        const writeStatements = [];
+        for (const statement of statements) {
+          const trimmedStatement = statement.toLowerCase().trim();
+          if (trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"))) {
+            readStatements.push(statement);
+          } else {
+            writeStatements.push(statement);
+          }
+        }
+        if (writeStatements.length > 0) {
+          this.db.exec(writeStatements.join("; "));
+        }
+        let allRows = [];
+        for (const statement of readStatements) {
+          const result = this.db.prepare(statement).all();
+          allRows.push(...result);
+        }
+        return { rows: allRows };
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+var sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);
+
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
@@ -1637,90 +1880,149 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import express from "express";
-import path2 from "path";
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path3 from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
-// src/connectors/manager.ts
-var managerInstance = null;
-var ConnectorManager = class {
+// src/utils/ssh-tunnel.ts
+import { Client } from "ssh2";
+import { readFileSync } from "fs";
+import { createServer } from "net";
+var SSHTunnel = class {
   constructor() {
-    this.activeConnector = null;
-    this.connected = false;
-    if (!managerInstance) {
-      managerInstance = this;
-    }
+    this.sshClient = null;
+    this.localServer = null;
+    this.tunnelInfo = null;
+    this.isConnected = false;
   }
   /**
-   * Initialize and connect to the database using a DSN
+   * Establish an SSH tunnel
+   * @param config SSH connection configuration
+   * @param options Tunnel options including target host and port
+   * @returns Promise resolving to tunnel information including local port
    */
-  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;
+  async establish(config, options) {
+    if (this.isConnected) {
+      throw new Error("SSH tunnel is already established");
+    }
+    return new Promise((resolve, reject) => {
+      this.sshClient = new Client();
+      const sshConfig = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username
+      };
+      if (config.password) {
+        sshConfig.password = config.password;
+      } else if (config.privateKey) {
+        try {
+          const privateKey = readFileSync(config.privateKey);
+          sshConfig.privateKey = privateKey;
+          if (config.passphrase) {
+            sshConfig.passphrase = config.passphrase;
+          }
+        } catch (error) {
+          reject(new Error(`Failed to read private key file: ${error instanceof Error ? error.message : String(error)}`));
+          return;
+        }
+      } else {
+        reject(new Error("Either password or privateKey must be provided for SSH authentication"));
+        return;
+      }
+      this.sshClient.on("error", (err) => {
+        this.cleanup();
+        reject(new Error(`SSH connection error: ${err.message}`));
+      });
+      this.sshClient.on("ready", () => {
+        console.error("SSH connection established");
+        this.localServer = createServer((localSocket) => {
+          this.sshClient.forwardOut(
+            "127.0.0.1",
+            0,
+            options.targetHost,
+            options.targetPort,
+            (err, stream) => {
+              if (err) {
+                console.error("SSH forward error:", err);
+                localSocket.end();
+                return;
+              }
+              localSocket.pipe(stream).pipe(localSocket);
+              stream.on("error", (err2) => {
+                console.error("SSH stream error:", err2);
+                localSocket.end();
+              });
+              localSocket.on("error", (err2) => {
+                console.error("Local socket error:", err2);
+                stream.end();
+              });
+            }
+          );
+        });
+        const localPort = options.localPort || 0;
+        this.localServer.listen(localPort, "127.0.0.1", () => {
+          const address = this.localServer.address();
+          if (!address || typeof address === "string") {
+            this.cleanup();
+            reject(new Error("Failed to get local server address"));
+            return;
+          }
+          this.tunnelInfo = {
+            localPort: address.port,
+            targetHost: options.targetHost,
+            targetPort: options.targetPort
+          };
+          this.isConnected = true;
+          console.error(`SSH tunnel established: localhost:${address.port} -> ${options.targetHost}:${options.targetPort}`);
+          resolve(this.tunnelInfo);
+        });
+        this.localServer.on("error", (err) => {
+          this.cleanup();
+          reject(new Error(`Local server error: ${err.message}`));
+        });
+      });
+      this.sshClient.connect(sshConfig);
+    });
   }
   /**
-   * Initialize and connect to the database using a specific connector type
+   * Close the SSH tunnel and clean up resources
    */
-  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;
+  async close() {
+    if (!this.isConnected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.cleanup();
+      this.isConnected = false;
+      console.error("SSH tunnel closed");
+      resolve();
+    });
   }
   /**
-   * Close the database connection
+   * Clean up resources
    */
-  async disconnect() {
-    if (this.activeConnector && this.connected) {
-      await this.activeConnector.disconnect();
-      this.connected = false;
+  cleanup() {
+    if (this.localServer) {
+      this.localServer.close();
+      this.localServer = null;
     }
-  }
-  /**
-   * Get the active connector
-   */
-  getConnector() {
-    if (!this.activeConnector) {
-      throw new Error("No active connector. Call connectWithDSN() or connectWithType() first.");
+    if (this.sshClient) {
+      this.sshClient.end();
+      this.sshClient = null;
     }
-    return this.activeConnector;
-  }
-  /**
-   * Check if there's an active connection
-   */
-  isConnected() {
-    return this.connected;
+    this.tunnelInfo = null;
   }
   /**
-   * Get all available connector types
+   * Get current tunnel information
    */
-  static getAvailableConnectors() {
-    return ConnectorRegistry.getAvailableConnectors();
+  getTunnelInfo() {
+    return this.tunnelInfo;
   }
   /**
-   * Get sample DSNs for all available connectors
+   * Check if tunnel is connected
    */
-  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();
+  getIsConnected() {
+    return this.isConnected;
   }
 };
 
@@ -1773,6 +2075,10 @@ function loadEnvFiles() {
   }
   return null;
 }
+function isDemoMode() {
+  const args = parseCommandLineArgs();
+  return args.demo === "true";
+}
 function isReadOnlyMode() {
   const args = parseCommandLineArgs();
   if (args.readonly !== void 0) {
@@ -1785,6 +2091,13 @@ function isReadOnlyMode() {
 }
 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" };
   }
@@ -1832,6 +2145,235 @@ function redactDSN(dsn) {
     return dsn.replace(/\/\/([^:]+):([^@]+)@/, "//$1:***@");
   }
 }
+function resolveSSHConfig() {
+  const args = parseCommandLineArgs();
+  const hasSSHArgs = args["ssh-host"] || process.env.SSH_HOST;
+  if (!hasSSHArgs) {
+    return null;
+  }
+  const config = {};
+  let sources = [];
+  if (args["ssh-host"]) {
+    config.host = args["ssh-host"];
+    sources.push("ssh-host from command line");
+  } else if (process.env.SSH_HOST) {
+    config.host = process.env.SSH_HOST;
+    sources.push("SSH_HOST from environment");
+  }
+  if (args["ssh-port"]) {
+    config.port = parseInt(args["ssh-port"], 10);
+    sources.push("ssh-port from command line");
+  } else if (process.env.SSH_PORT) {
+    config.port = parseInt(process.env.SSH_PORT, 10);
+    sources.push("SSH_PORT from environment");
+  }
+  if (args["ssh-user"]) {
+    config.username = args["ssh-user"];
+    sources.push("ssh-user from command line");
+  } else if (process.env.SSH_USER) {
+    config.username = process.env.SSH_USER;
+    sources.push("SSH_USER from environment");
+  }
+  if (args["ssh-password"]) {
+    config.password = args["ssh-password"];
+    sources.push("ssh-password from command line");
+  } else if (process.env.SSH_PASSWORD) {
+    config.password = process.env.SSH_PASSWORD;
+    sources.push("SSH_PASSWORD from environment");
+  }
+  if (args["ssh-key"]) {
+    config.privateKey = args["ssh-key"];
+    if (config.privateKey.startsWith("~/")) {
+      config.privateKey = path.join(process.env.HOME || "", config.privateKey.substring(2));
+    }
+    sources.push("ssh-key from command line");
+  } else if (process.env.SSH_KEY) {
+    config.privateKey = process.env.SSH_KEY;
+    if (config.privateKey.startsWith("~/")) {
+      config.privateKey = path.join(process.env.HOME || "", config.privateKey.substring(2));
+    }
+    sources.push("SSH_KEY from environment");
+  }
+  if (args["ssh-passphrase"]) {
+    config.passphrase = args["ssh-passphrase"];
+    sources.push("ssh-passphrase from command line");
+  } else if (process.env.SSH_PASSPHRASE) {
+    config.passphrase = process.env.SSH_PASSPHRASE;
+    sources.push("SSH_PASSPHRASE from environment");
+  }
+  if (!config.host || !config.username) {
+    throw new Error("SSH tunnel configuration requires at least --ssh-host and --ssh-user");
+  }
+  if (!config.password && !config.privateKey) {
+    throw new Error("SSH tunnel configuration requires either --ssh-password or --ssh-key for authentication");
+  }
+  return {
+    config,
+    source: sources.join(", ")
+  };
+}
+
+// src/connectors/manager.ts
+var managerInstance = null;
+var ConnectorManager = class {
+  constructor() {
+    this.activeConnector = null;
+    this.connected = false;
+    this.sshTunnel = null;
+    this.originalDSN = null;
+    if (!managerInstance) {
+      managerInstance = this;
+    }
+  }
+  /**
+   * Initialize and connect to the database using a DSN
+   */
+  async connectWithDSN(dsn, initScript) {
+    this.originalDSN = dsn;
+    const sshConfig = resolveSSHConfig();
+    let actualDSN = dsn;
+    if (sshConfig) {
+      console.error(`SSH tunnel configuration loaded from ${sshConfig.source}`);
+      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, {
+        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}`);
+    }
+    let connector = ConnectorRegistry.getConnectorForDSN(actualDSN);
+    if (!connector) {
+      throw new Error(`No connector found that can handle the 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`);
+    }
+    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;
+    }
+    if (this.sshTunnel) {
+      await this.sshTunnel.close();
+      this.sshTunnel = null;
+    }
+    this.originalDSN = null;
+  }
+  /**
+   * 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();
+  }
+  /**
+   * Get default port for a database based on DSN protocol
+   */
+  getDefaultPort(dsn) {
+    if (dsn.startsWith("postgres://") || dsn.startsWith("postgresql://")) {
+      return 5432;
+    } else if (dsn.startsWith("mysql://")) {
+      return 3306;
+    } else if (dsn.startsWith("mariadb://")) {
+      return 3306;
+    } else if (dsn.startsWith("sqlserver://")) {
+      return 1433;
+    }
+    return 0;
+  }
+};
+
+// 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";
@@ -2185,6 +2727,7 @@ var allowedKeywords = {
   postgres: ["select", "with", "explain", "analyze", "show"],
   mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
   mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
+  sqlite: ["select", "with", "explain", "analyze", "pragma"],
   sqlserver: ["select", "with", "explain", "showplan"]
 };
 
@@ -2252,6 +2795,9 @@ async function sqlGeneratorPromptHandler({
       case "postgres":
         sqlDialect = "postgres";
         break;
+      case "sqlite":
+        sqlDialect = "sqlite";
+        break;
       case "mysql":
         sqlDialect = "mysql";
         break;
@@ -2312,6 +2858,11 @@ ${accessibleSchemas.map(
           "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)"
+        ],
         mysql: [
           "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",
@@ -2643,10 +3194,10 @@ function registerPrompts(server) {
 }
 
 // src/server.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var packageJsonPath = path2.join(__dirname2, "..", "package.json");
-var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+var packageJsonPath = path3.join(__dirname3, "..", "package.json");
+var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
 function generateBanner(version, modes = []) {
@@ -2672,7 +3223,8 @@ async function main() {
 ERROR: Database connection string (DSN) is required.
 Please provide the DSN in one of these ways (in order of priority):
 
-1. Command line argument: --dsn="your-connection-string"
+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
 
@@ -2683,7 +3235,7 @@ See documentation for more details on configuring database connections.
 `);
       process.exit(1);
     }
-    const createServer = () => {
+    const createServer2 = () => {
       const server = new McpServer2({
         name: SERVER_NAME,
         version: SERVER_VERSION
@@ -2696,13 +3248,22 @@ See documentation for more details on configuring database connections.
     const connectorManager = new ConnectorManager();
     console.error(`Connecting with DSN: ${redactDSN(dsnData.dsn)}`);
     console.error(`DSN source: ${dsnData.source}`);
-    await connectorManager.connectWithDSN(dsnData.dsn);
+    if (dsnData.isDemo) {
+      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}`);
     const readonly = isReadOnlyMode();
     const activeModes = [];
     const modeDescriptions = [];
+    if (dsnData.isDemo) {
+      activeModes.push("DEMO");
+      modeDescriptions.push("using sample employee database");
+    }
     if (readonly) {
       activeModes.push("READ-ONLY");
       modeDescriptions.push("only read only queries allowed");
@@ -2728,6 +3289,9 @@ See documentation for more details on configuring database connections.
         }
         next();
       });
+      app.get("/healthz", (req, res) => {
+        res.status(200).send("OK");
+      });
       app.post("/message", async (req, res) => {
         try {
           const transport = new StreamableHTTPServerTransport({
@@ -2736,7 +3300,7 @@ See documentation for more details on configuring database connections.
             enableJsonResponse: false
             // Use SSE streaming
           });
-          const server = createServer();
+          const server = createServer2();
           await server.connect(transport);
           await transport.handleRequest(req, res, req.body);
         } catch (error) {
@@ -2754,7 +3318,7 @@ See documentation for more details on configuring database connections.
         console.error(`Connect to MCP server at http://0.0.0.0:${port}/message`);
       });
     } else {
-      const server = createServer();
+      const server = createServer2();
       const transport = new StdioServerTransport();
       console.error("Starting with STDIO transport");
       await server.connect(transport);