@adevguide/mcp-database-server 1.0.2

package/dist/index.js

@@ -0,0 +1,2406 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import dotenv from "dotenv";
+import { parseArgs } from "util";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/config.ts
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, resolve, join } from "path";
+
+// src/types.ts
+import { z } from "zod";
+var ConnectionPoolSchema = z.object({
+  min: z.number().min(0).optional(),
+  max: z.number().min(1).optional(),
+  idleTimeoutMillis: z.number().min(0).optional(),
+  connectionTimeoutMillis: z.number().min(0).optional()
+});
+var IntrospectionOptionsSchema = z.object({
+  includeViews: z.boolean().optional().default(true),
+  includeRoutines: z.boolean().optional().default(false),
+  maxTables: z.number().min(1).optional(),
+  excludeSchemas: z.array(z.string()).optional(),
+  includeSchemas: z.array(z.string()).optional()
+});
+var DatabaseConfigSchema = z.object({
+  id: z.string().min(1),
+  type: z.enum(["postgres", "mysql", "mssql", "sqlite", "oracle"]),
+  url: z.string().optional(),
+  path: z.string().optional(),
+  readOnly: z.boolean().optional().default(true),
+  pool: ConnectionPoolSchema.optional(),
+  introspection: IntrospectionOptionsSchema.optional(),
+  eagerConnect: z.boolean().optional().default(false)
+});
+var ServerConfigSchema = z.object({
+  databases: z.array(DatabaseConfigSchema).min(1),
+  cache: z.object({
+    directory: z.string().optional().default(".sql-mcp-cache"),
+    ttlMinutes: z.number().min(0).optional().default(10)
+  }).optional().default({ directory: ".sql-mcp-cache", ttlMinutes: 10 }),
+  security: z.object({
+    allowWrite: z.boolean().optional().default(false),
+    allowedWriteOperations: z.array(z.string()).optional(),
+    disableDangerousOperations: z.boolean().optional().default(true),
+    redactSecrets: z.boolean().optional().default(true)
+  }).optional().default({ allowWrite: false, disableDangerousOperations: true, redactSecrets: true }),
+  logging: z.object({
+    level: z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("info"),
+    pretty: z.boolean().optional().default(false)
+  }).optional().default({ level: "info", pretty: false })
+});
+var DatabaseError = class extends Error {
+  constructor(message, _code, _dbId, _originalError) {
+    super(message);
+    this._code = _code;
+    this._dbId = _dbId;
+    this._originalError = _originalError;
+    this.name = "DatabaseError";
+  }
+};
+var ConfigError = class extends Error {
+  constructor(message, _details) {
+    super(message);
+    this._details = _details;
+    this.name = "ConfigError";
+  }
+};
+var CacheError = class extends Error {
+  constructor(message, _originalError) {
+    super(message);
+    this._originalError = _originalError;
+    this.name = "CacheError";
+  }
+};
+
+// src/utils.ts
+import crypto from "crypto";
+import { URL } from "url";
+function redactUrl(url) {
+  try {
+    if (url.includes("://")) {
+      const urlObj = new URL(url);
+      if (urlObj.password) {
+        urlObj.password = "***";
+      }
+      if (urlObj.username && urlObj.password) {
+        return urlObj.toString();
+      }
+    }
+    if (url.includes("Password=")) {
+      return url.replace(/(Password=)[^;]+/gi, "$1***");
+    }
+    if (url.includes("/") && url.includes("@")) {
+      return url.replace(/\/[^@]+@/, "/***@");
+    }
+    return url;
+  } catch {
+    return url.replace(/:\/\/[^@]*@/, "://***@");
+  }
+}
+function interpolateEnv(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] || "";
+  });
+}
+function generateSchemaVersion(schema) {
+  const hash = crypto.createHash("sha256");
+  const schemaData = {
+    dbType: schema.dbType,
+    schemas: schema.schemas.map((s) => ({
+      name: s.name,
+      tables: s.tables.sort((a, b) => a.name.localeCompare(b.name)).map((t) => ({
+        name: t.name,
+        type: t.type,
+        columns: t.columns.sort((a, b) => a.name.localeCompare(b.name)).map((c) => ({
+          name: c.name,
+          dataType: c.dataType,
+          nullable: c.nullable
+        })),
+        foreignKeys: t.foreignKeys.sort((a, b) => a.name.localeCompare(b.name))
+      }))
+    }))
+  };
+  hash.update(JSON.stringify(schemaData));
+  return hash.digest("hex").substring(0, 16);
+}
+function inferRelationships(schema) {
+  const relationships = [];
+  const tableLookup = /* @__PURE__ */ new Map();
+  for (const schemaObj of schema.schemas) {
+    for (const table of schemaObj.tables) {
+      const fullName = `${schemaObj.name}.${table.name}`;
+      const pk = table.primaryKey?.columns || [];
+      tableLookup.set(table.name.toLowerCase(), { schema: schemaObj.name, pk });
+      tableLookup.set(fullName.toLowerCase(), { schema: schemaObj.name, pk });
+    }
+  }
+  for (const schemaObj of schema.schemas) {
+    for (const table of schemaObj.tables) {
+      for (const column of table.columns) {
+        const columnName = column.name.toLowerCase();
+        const patterns = [
+          /^(.+?)_id$/,
+          /^(.+?)id$/i
+        ];
+        for (const pattern of patterns) {
+          const match = columnName.match(pattern);
+          if (match) {
+            const referencedTableName = match[1].toLowerCase();
+            const referencedTable = tableLookup.get(referencedTableName);
+            if (referencedTable && referencedTable.pk.length > 0) {
+              relationships.push({
+                fromSchema: schemaObj.name,
+                fromTable: table.name,
+                fromColumns: [column.name],
+                toSchema: referencedTable.schema,
+                toTable: referencedTableName,
+                toColumns: referencedTable.pk,
+                type: "inferred",
+                confidence: 0.7
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return relationships;
+}
+function extractTableNames(sql) {
+  const tables = /* @__PURE__ */ new Set();
+  const patterns = [
+    /(?:FROM|JOIN|INTO|UPDATE)\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)?)/gi,
+    /DELETE\s+FROM\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)?)/gi
+  ];
+  for (const pattern of patterns) {
+    const matches = sql.matchAll(pattern);
+    for (const match of matches) {
+      if (match[1]) {
+        tables.add(match[1].toLowerCase());
+      }
+    }
+  }
+  return Array.from(tables);
+}
+function isWriteOperation(sql) {
+  const upperSql = sql.trim().toUpperCase();
+  const writeKeywords = [
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "CREATE",
+    "ALTER",
+    "DROP",
+    "TRUNCATE",
+    "REPLACE",
+    "MERGE"
+  ];
+  for (const keyword of writeKeywords) {
+    if (upperSql.startsWith(keyword)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findJoinPaths(tables, relationships, maxDepth = 3) {
+  if (tables.length < 2) {
+    return [];
+  }
+  const paths = [];
+  const graph = /* @__PURE__ */ new Map();
+  for (const rel of relationships) {
+    const fromKey = `${rel.fromSchema}.${rel.fromTable}`.toLowerCase();
+    const toKey = `${rel.toSchema}.${rel.toTable}`.toLowerCase();
+    if (!graph.has(fromKey)) {
+      graph.set(fromKey, []);
+    }
+    graph.get(fromKey).push(rel);
+    const reverseRel = {
+      ...rel,
+      fromSchema: rel.toSchema,
+      fromTable: rel.toTable,
+      fromColumns: rel.toColumns,
+      toSchema: rel.fromSchema,
+      toTable: rel.fromTable,
+      toColumns: rel.fromColumns
+    };
+    if (!graph.has(toKey)) {
+      graph.set(toKey, []);
+    }
+    graph.get(toKey).push(reverseRel);
+  }
+  const start = tables[0].toLowerCase();
+  const end = tables[1].toLowerCase();
+  const queue = [{ current: start, path: [] }];
+  const visited = /* @__PURE__ */ new Set([start]);
+  while (queue.length > 0) {
+    const { current, path: path2 } = queue.shift();
+    if (path2.length >= maxDepth) {
+      continue;
+    }
+    const neighbors = graph.get(current) || [];
+    for (const rel of neighbors) {
+      const next = `${rel.toSchema}.${rel.toTable}`.toLowerCase();
+      if (next === end) {
+        paths.push({
+          tables: [start, ...path2.map((r) => `${r.toSchema}.${r.toTable}`), end],
+          joins: [...path2, rel]
+        });
+        continue;
+      }
+      if (!visited.has(next)) {
+        visited.add(next);
+        queue.push({ current: next, path: [...path2, rel] });
+      }
+    }
+  }
+  return paths;
+}
+
+// src/config.ts
+function findConfigFile(fileName, startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    const configPath = join(currentDir, fileName);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    const interpolatedConfig = interpolateConfigValues(rawConfig);
+    const config = ServerConfigSchema.parse(interpolatedConfig);
+    validateDatabaseConfigs(config);
+    return config;
+  } catch (error) {
+    if (error.name === "ZodError") {
+      throw new ConfigError("Configuration validation failed", error.errors);
+    }
+    throw new ConfigError(`Failed to load config from ${configPath}: ${error.message}`);
+  }
+}
+function interpolateConfigValues(obj) {
+  if (typeof obj === "string") {
+    return interpolateEnv(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(interpolateConfigValues);
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateConfigValues(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function validateDatabaseConfigs(config) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const db of config.databases) {
+    if (ids.has(db.id)) {
+      throw new ConfigError(`Duplicate database ID: ${db.id}`);
+    }
+    ids.add(db.id);
+    if (db.type === "sqlite") {
+      if (!db.path && !db.url) {
+        throw new ConfigError(`SQLite database ${db.id} requires 'path' or 'url'`);
+      }
+    } else {
+      if (!db.url) {
+        throw new ConfigError(`Database ${db.id} requires 'url'`);
+      }
+    }
+  }
+}
+
+// src/adapters/postgres.ts
+import pg from "pg";
+
+// src/logger.ts
+import pino from "pino";
+var logger;
+function initLogger(level = "info", pretty = false) {
+  logger = pino({
+    level,
+    transport: pretty ? {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "pid,hostname"
+      }
+    } : void 0
+  });
+  return logger;
+}
+function getLogger() {
+  if (!logger) {
+    logger = initLogger();
+  }
+  return logger;
+}
+
+// src/adapters/base.ts
+var BaseAdapter = class {
+  constructor(_config) {
+    this._config = _config;
+  }
+  logger = getLogger();
+  connected = false;
+  ensureConnected() {
+    if (!this.connected) {
+      throw new DatabaseError(
+        "Database not connected",
+        "NOT_CONNECTED",
+        this._config.id
+      );
+    }
+  }
+  handleError(error, operation) {
+    this.logger.error({ error, dbId: this._config.id, operation }, "Database operation failed");
+    throw new DatabaseError(
+      `${operation} failed: ${error.message}`,
+      error.code || "UNKNOWN_ERROR",
+      this._config.id,
+      error
+    );
+  }
+};
+
+// src/adapters/postgres.ts
+var { Pool } = pg;
+var PostgresAdapter = class extends BaseAdapter {
+  pool;
+  async connect() {
+    try {
+      this.pool = new Pool({
+        connectionString: this._config.url,
+        min: this._config.pool?.min || 2,
+        max: this._config.pool?.max || 10,
+        idleTimeoutMillis: this._config.pool?.idleTimeoutMillis || 3e4,
+        connectionTimeoutMillis: this._config.pool?.connectionTimeoutMillis || 1e4
+      });
+      const client = await this.pool.connect();
+      client.release();
+      this.connected = true;
+      this.logger.info({ dbId: this._config.id }, "PostgreSQL connected");
+    } catch (error) {
+      this.handleError(error, "connect");
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = void 0;
+      this.connected = false;
+      this.logger.info({ dbId: this._config.id }, "PostgreSQL disconnected");
+    }
+  }
+  async introspect(options) {
+    this.ensureConnected();
+    try {
+      const schemas = await this.getSchemas(options);
+      const dbSchema = {
+        dbId: this._config.id,
+        dbType: "postgres",
+        schemas,
+        introspectedAt: /* @__PURE__ */ new Date(),
+        version: ""
+      };
+      dbSchema.version = generateSchemaVersion(dbSchema);
+      return dbSchema;
+    } catch (error) {
+      this.handleError(error, "introspect");
+    }
+  }
+  async getSchemas(options) {
+    const result = [];
+    const schemasQuery = `
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+      ORDER BY schema_name
+    `;
+    const schemasResult = await this.pool.query(schemasQuery);
+    let schemaNames = schemasResult.rows.map((r) => r.schema_name);
+    if (options?.includeSchemas && options.includeSchemas.length > 0) {
+      schemaNames = schemaNames.filter((s) => options.includeSchemas.includes(s));
+    }
+    if (options?.excludeSchemas && options.excludeSchemas.length > 0) {
+      schemaNames = schemaNames.filter((s) => !options.excludeSchemas.includes(s));
+    }
+    for (const schemaName of schemaNames) {
+      const tables = await this.getTables(schemaName, options);
+      result.push({
+        name: schemaName,
+        tables
+      });
+    }
+    return result;
+  }
+  async getTables(schemaName, options) {
+    const result = [];
+    let tableTypes = "'BASE TABLE'";
+    if (options?.includeViews) {
+      tableTypes += ",'VIEW'";
+    }
+    const tablesQuery = `
+      SELECT table_name, table_type
+      FROM information_schema.tables
+      WHERE table_schema = $1 AND table_type IN (${tableTypes})
+      ORDER BY table_name
+      ${options?.maxTables ? `LIMIT ${options.maxTables}` : ""}
+    `;
+    const tablesResult = await this.pool.query(tablesQuery, [schemaName]);
+    for (const row of tablesResult.rows) {
+      const columns = await this.getColumns(schemaName, row.table_name);
+      const indexes = await this.getIndexes(schemaName, row.table_name);
+      const foreignKeys = await this.getForeignKeys(schemaName, row.table_name);
+      const primaryKey = indexes.find((idx) => idx.isPrimary);
+      result.push({
+        schema: schemaName,
+        name: row.table_name,
+        type: row.table_type === "VIEW" ? "view" : "table",
+        columns,
+        primaryKey,
+        indexes: indexes.filter((idx) => !idx.isPrimary),
+        foreignKeys
+      });
+    }
+    return result;
+  }
+  async getColumns(schemaName, tableName) {
+    const query = `
+      SELECT
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale,
+        is_identity
+      FROM information_schema.columns
+      WHERE table_schema = $1 AND table_name = $2
+      ORDER BY ordinal_position
+    `;
+    const result = await this.pool.query(query, [schemaName, tableName]);
+    return result.rows.map((row) => ({
+      name: row.column_name,
+      dataType: row.data_type,
+      nullable: row.is_nullable === "YES",
+      defaultValue: row.column_default,
+      maxLength: row.character_maximum_length,
+      precision: row.numeric_precision,
+      scale: row.numeric_scale,
+      isAutoIncrement: row.is_identity === "YES"
+    }));
+  }
+  async getIndexes(schemaName, tableName) {
+    const query = `
+      SELECT
+        i.relname AS index_name,
+        ix.indisunique AS is_unique,
+        ix.indisprimary AS is_primary,
+        array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) AS column_names
+      FROM pg_class t
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      WHERE n.nspname = $1 AND t.relname = $2
+      GROUP BY i.relname, ix.indisunique, ix.indisprimary
+    `;
+    const result = await this.pool.query(query, [schemaName, tableName]);
+    return result.rows.map((row) => ({
+      name: row.index_name,
+      columns: row.column_names,
+      isUnique: row.is_unique,
+      isPrimary: row.is_primary
+    }));
+  }
+  async getForeignKeys(schemaName, tableName) {
+    const query = `
+      SELECT
+        tc.constraint_name,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS column_names,
+        ccu.table_schema AS referenced_schema,
+        ccu.table_name AS referenced_table,
+        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) AS referenced_columns,
+        rc.update_rule,
+        rc.delete_rule
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints AS rc
+        ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = $1
+        AND tc.table_name = $2
+      GROUP BY tc.constraint_name, ccu.table_schema, ccu.table_name, rc.update_rule, rc.delete_rule
+    `;
+    const result = await this.pool.query(query, [schemaName, tableName]);
+    return result.rows.map((row) => ({
+      name: row.constraint_name,
+      columns: row.column_names,
+      referencedSchema: row.referenced_schema,
+      referencedTable: row.referenced_table,
+      referencedColumns: row.referenced_columns,
+      onUpdate: row.update_rule,
+      onDelete: row.delete_rule
+    }));
+  }
+  async query(sql, params = [], timeoutMs) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    try {
+      const queryConfig = {
+        text: sql,
+        values: params
+      };
+      if (timeoutMs) {
+        queryConfig.statement_timeout = timeoutMs;
+      }
+      const result = await this.pool.query(queryConfig);
+      const executionTimeMs = Date.now() - startTime;
+      return {
+        rows: result.rows,
+        columns: result.fields.map((f) => f.name),
+        rowCount: result.rowCount || 0,
+        executionTimeMs,
+        affectedRows: result.rowCount || 0
+      };
+    } catch (error) {
+      this.handleError(error, "query");
+    }
+  }
+  async explain(sql, params = []) {
+    this.ensureConnected();
+    try {
+      const explainSql = `EXPLAIN (FORMAT JSON, ANALYZE, BUFFERS) ${sql}`;
+      const result = await this.pool.query(explainSql, params);
+      return {
+        plan: result.rows[0]["QUERY PLAN"],
+        formattedPlan: JSON.stringify(result.rows[0]["QUERY PLAN"], null, 2)
+      };
+    } catch (error) {
+      this.handleError(error, "explain");
+    }
+  }
+  async testConnection() {
+    try {
+      if (!this.pool) return false;
+      const client = await this.pool.connect();
+      client.release();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    this.ensureConnected();
+    try {
+      const result = await this.pool.query("SELECT version()");
+      return result.rows[0].version;
+    } catch (error) {
+      this.handleError(error, "getVersion");
+    }
+  }
+};
+
+// src/adapters/mysql.ts
+import mysql from "mysql2/promise";
+var MySQLAdapter = class extends BaseAdapter {
+  pool;
+  database;
+  async connect() {
+    try {
+      this.pool = mysql.createPool({
+        uri: this._config.url,
+        waitForConnections: true,
+        connectionLimit: this._config.pool?.max || 10,
+        queueLimit: 0,
+        connectTimeout: this._config.pool?.connectionTimeoutMillis || 1e4
+      });
+      const connection = await this.pool.getConnection();
+      const [rows] = await connection.query("SELECT DATABASE() as db");
+      this.database = rows[0].db;
+      connection.release();
+      this.connected = true;
+      this.logger.info({ dbId: this._config.id }, "MySQL connected");
+    } catch (error) {
+      this.handleError(error, "connect");
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = void 0;
+      this.connected = false;
+      this.logger.info({ dbId: this._config.id }, "MySQL disconnected");
+    }
+  }
+  async introspect(options) {
+    this.ensureConnected();
+    try {
+      const schemas = await this.getSchemas(options);
+      const dbSchema = {
+        dbId: this._config.id,
+        dbType: "mysql",
+        schemas,
+        introspectedAt: /* @__PURE__ */ new Date(),
+        version: ""
+      };
+      dbSchema.version = generateSchemaVersion(dbSchema);
+      return dbSchema;
+    } catch (error) {
+      this.handleError(error, "introspect");
+    }
+  }
+  async getSchemas(options) {
+    const tables = await this.getTables(this.database, options);
+    return [
+      {
+        name: this.database,
+        tables
+      }
+    ];
+  }
+  async getTables(schemaName, options) {
+    const result = [];
+    let tableTypes = "'BASE TABLE'";
+    if (options?.includeViews) {
+      tableTypes += ",'VIEW'";
+    }
+    const tablesQuery = `
+      SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = ? AND TABLE_TYPE IN (${tableTypes})
+      ORDER BY TABLE_NAME
+      ${options?.maxTables ? `LIMIT ${options.maxTables}` : ""}
+    `;
+    const [rows] = await this.pool.query(tablesQuery, [schemaName]);
+    for (const row of rows) {
+      const columns = await this.getColumns(schemaName, row.TABLE_NAME);
+      const indexes = await this.getIndexes(schemaName, row.TABLE_NAME);
+      const foreignKeys = await this.getForeignKeys(schemaName, row.TABLE_NAME);
+      const primaryKey = indexes.find((idx) => idx.isPrimary);
+      result.push({
+        schema: schemaName,
+        name: row.TABLE_NAME,
+        type: row.TABLE_TYPE === "VIEW" ? "view" : "table",
+        columns,
+        primaryKey,
+        indexes: indexes.filter((idx) => !idx.isPrimary),
+        foreignKeys,
+        comment: row.TABLE_COMMENT
+      });
+    }
+    return result;
+  }
+  async getColumns(schemaName, tableName) {
+    const query = `
+      SELECT
+        COLUMN_NAME,
+        DATA_TYPE,
+        IS_NULLABLE,
+        COLUMN_DEFAULT,
+        CHARACTER_MAXIMUM_LENGTH,
+        NUMERIC_PRECISION,
+        NUMERIC_SCALE,
+        EXTRA,
+        COLUMN_COMMENT
+      FROM information_schema.COLUMNS
+      WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+      ORDER BY ORDINAL_POSITION
+    `;
+    const [rows] = await this.pool.query(query, [schemaName, tableName]);
+    return rows.map((row) => ({
+      name: row.COLUMN_NAME,
+      dataType: row.DATA_TYPE,
+      nullable: row.IS_NULLABLE === "YES",
+      defaultValue: row.COLUMN_DEFAULT,
+      maxLength: row.CHARACTER_MAXIMUM_LENGTH,
+      precision: row.NUMERIC_PRECISION,
+      scale: row.NUMERIC_SCALE,
+      isAutoIncrement: row.EXTRA.includes("auto_increment"),
+      comment: row.COLUMN_COMMENT
+    }));
+  }
+  async getIndexes(schemaName, tableName) {
+    const query = `
+      SELECT
+        INDEX_NAME,
+        NON_UNIQUE,
+        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS column_names
+      FROM information_schema.STATISTICS
+      WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+      GROUP BY INDEX_NAME, NON_UNIQUE
+    `;
+    const [rows] = await this.pool.query(query, [schemaName, tableName]);
+    return rows.map((row) => ({
+      name: row.INDEX_NAME,
+      columns: row.column_names.split(","),
+      isUnique: row.NON_UNIQUE === 0,
+      isPrimary: row.INDEX_NAME === "PRIMARY"
+    }));
+  }
+  async getForeignKeys(schemaName, tableName) {
+    const query = `
+      SELECT
+        kcu.CONSTRAINT_NAME,
+        GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) AS column_names,
+        kcu.REFERENCED_TABLE_SCHEMA,
+        kcu.REFERENCED_TABLE_NAME,
+        GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) AS referenced_columns,
+        rc.UPDATE_RULE,
+        rc.DELETE_RULE
+      FROM information_schema.KEY_COLUMN_USAGE AS kcu
+      JOIN information_schema.REFERENTIAL_CONSTRAINTS AS rc
+        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+        AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+      WHERE kcu.TABLE_SCHEMA = ? AND kcu.TABLE_NAME = ?
+        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+      GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_SCHEMA,
+               kcu.REFERENCED_TABLE_NAME, rc.UPDATE_RULE, rc.DELETE_RULE
+    `;
+    const [rows] = await this.pool.query(query, [schemaName, tableName]);
+    return rows.map((row) => ({
+      name: row.CONSTRAINT_NAME,
+      columns: row.column_names.split(","),
+      referencedSchema: row.REFERENCED_TABLE_SCHEMA,
+      referencedTable: row.REFERENCED_TABLE_NAME,
+      referencedColumns: row.referenced_columns.split(","),
+      onUpdate: row.UPDATE_RULE,
+      onDelete: row.DELETE_RULE
+    }));
+  }
+  async query(sql, params = [], timeoutMs) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    try {
+      const connection = await this.pool.getConnection();
+      if (timeoutMs) {
+        await connection.query(`SET SESSION max_execution_time=${timeoutMs}`);
+      }
+      const [rows, fields] = await connection.query(sql, params);
+      connection.release();
+      const executionTimeMs = Date.now() - startTime;
+      return {
+        rows: Array.isArray(rows) ? rows : [],
+        columns: Array.isArray(fields) ? fields.map((f) => f.name) : [],
+        rowCount: Array.isArray(rows) ? rows.length : 0,
+        executionTimeMs,
+        affectedRows: rows.affectedRows
+      };
+    } catch (error) {
+      this.handleError(error, "query");
+    }
+  }
+  async explain(sql, params = []) {
+    this.ensureConnected();
+    try {
+      const explainSql = `EXPLAIN FORMAT=JSON ${sql}`;
+      const [rows] = await this.pool.query(explainSql, params);
+      return {
+        plan: rows[0].EXPLAIN,
+        formattedPlan: JSON.stringify(rows[0].EXPLAIN, null, 2)
+      };
+    } catch (error) {
+      this.handleError(error, "explain");
+    }
+  }
+  async testConnection() {
+    try {
+      if (!this.pool) return false;
+      const connection = await this.pool.getConnection();
+      connection.release();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    this.ensureConnected();
+    try {
+      const [rows] = await this.pool.query("SELECT VERSION() as version");
+      return rows[0].version;
+    } catch (error) {
+      this.handleError(error, "getVersion");
+    }
+  }
+};
+
+// src/adapters/sqlite.ts
+import Database from "better-sqlite3";
+var SQLiteAdapter = class extends BaseAdapter {
+  db;
+  async connect() {
+    try {
+      const dbPath = this._config.path || this._config.url;
+      if (!dbPath) {
+        throw new Error("SQLite requires path or url configuration");
+      }
+      this.db = new Database(dbPath, {
+        readonly: this._config.readOnly,
+        fileMustExist: false
+      });
+      this.db.pragma("foreign_keys = ON");
+      this.connected = true;
+      this.logger.info({ dbId: this._config.id, path: dbPath }, "SQLite connected");
+    } catch (error) {
+      this.handleError(error, "connect");
+    }
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = void 0;
+      this.connected = false;
+      this.logger.info({ dbId: this._config.id }, "SQLite disconnected");
+    }
+  }
+  async introspect(options) {
+    this.ensureConnected();
+    try {
+      const schemas = await this.getSchemas(options);
+      const dbSchema = {
+        dbId: this._config.id,
+        dbType: "sqlite",
+        schemas,
+        introspectedAt: /* @__PURE__ */ new Date(),
+        version: ""
+      };
+      dbSchema.version = generateSchemaVersion(dbSchema);
+      return dbSchema;
+    } catch (error) {
+      this.handleError(error, "introspect");
+    }
+  }
+  async getSchemas(options) {
+    const tables = await this.getTables("main", options);
+    return [
+      {
+        name: "main",
+        tables
+      }
+    ];
+  }
+  async getTables(schemaName, options) {
+    const result = [];
+    let query = `
+      SELECT name, type
+      FROM sqlite_master
+      WHERE type IN ('table', 'view')
+        AND name NOT LIKE 'sqlite_%'
+      ORDER BY name
+    `;
+    if (options?.maxTables) {
+      query += ` LIMIT ${options.maxTables}`;
+    }
+    const tables = this.db.prepare(query).all();
+    for (const table of tables) {
+      if (table.type === "view" && !options?.includeViews) {
+        continue;
+      }
+      const columns = await this.getColumns(table.name);
+      const indexes = await this.getIndexes(table.name);
+      const foreignKeys = await this.getForeignKeys(table.name);
+      const primaryKey = indexes.find((idx) => idx.isPrimary);
+      result.push({
+        schema: schemaName,
+        name: table.name,
+        type: table.type === "view" ? "view" : "table",
+        columns,
+        primaryKey,
+        indexes: indexes.filter((idx) => !idx.isPrimary),
+        foreignKeys
+      });
+    }
+    return result;
+  }
+  async getColumns(tableName) {
+    const pragma = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+    return pragma.map((col) => ({
+      name: col.name,
+      dataType: col.type || "TEXT",
+      nullable: col.notnull === 0,
+      defaultValue: col.dflt_value || void 0,
+      isAutoIncrement: col.pk === 1 && col.type.toUpperCase() === "INTEGER"
+    }));
+  }
+  async getIndexes(tableName) {
+    const result = [];
+    const indexes = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
+    for (const index of indexes) {
+      const indexInfo = this.db.prepare(`PRAGMA index_info(${index.name})`).all();
+      result.push({
+        name: index.name,
+        columns: indexInfo.map((info) => info.name),
+        isUnique: index.unique === 1,
+        isPrimary: index.origin === "pk"
+      });
+    }
+    return result;
+  }
+  async getForeignKeys(tableName) {
+    const foreignKeys = this.db.prepare(`PRAGMA foreign_key_list(${tableName})`).all();
+    const grouped = /* @__PURE__ */ new Map();
+    for (const fk of foreignKeys) {
+      if (!grouped.has(fk.id)) {
+        grouped.set(fk.id, []);
+      }
+      grouped.get(fk.id).push(fk);
+    }
+    return Array.from(grouped.values()).map((fks) => ({
+      name: `fk_${tableName}_${fks[0].id}`,
+      columns: fks.map((fk) => fk.from),
+      referencedSchema: "main",
+      referencedTable: fks[0].table,
+      referencedColumns: fks.map((fk) => fk.to),
+      onUpdate: fks[0].on_update,
+      onDelete: fks[0].on_delete
+    }));
+  }
+  async query(sql, params = [], timeoutMs) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    try {
+      if (timeoutMs) {
+        this.db.pragma(`busy_timeout = ${timeoutMs}`);
+      }
+      const stmt = this.db.prepare(sql);
+      const isSelect = sql.trim().toUpperCase().startsWith("SELECT");
+      let rows;
+      let affectedRows = 0;
+      if (isSelect) {
+        rows = stmt.all(...params);
+      } else {
+        const result = stmt.run(...params);
+        rows = [];
+        affectedRows = result.changes;
+      }
+      const executionTimeMs = Date.now() - startTime;
+      const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+      return {
+        rows,
+        columns,
+        rowCount: rows.length,
+        executionTimeMs,
+        affectedRows
+      };
+    } catch (error) {
+      this.handleError(error, "query");
+    }
+  }
+  async explain(sql, params = []) {
+    this.ensureConnected();
+    try {
+      const explainSql = `EXPLAIN QUERY PLAN ${sql}`;
+      const stmt = this.db.prepare(explainSql);
+      const plan = stmt.all(...params);
+      return {
+        plan,
+        formattedPlan: JSON.stringify(plan, null, 2)
+      };
+    } catch (error) {
+      this.handleError(error, "explain");
+    }
+  }
+  async testConnection() {
+    try {
+      if (!this.db) return false;
+      this.db.prepare("SELECT 1").get();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    this.ensureConnected();
+    try {
+      const result = this.db.prepare("SELECT sqlite_version() as version").get();
+      return `SQLite ${result.version}`;
+    } catch (error) {
+      this.handleError(error, "getVersion");
+    }
+  }
+};
+
+// src/adapters/mssql.ts
+import { Connection, Request } from "tedious";
+var MSSQLAdapter = class extends BaseAdapter {
+  connection;
+  async connect() {
+    return new Promise((resolve2, reject) => {
+      try {
+        const config = this.parseConnectionString(this._config.url);
+        this.connection = new Connection(config);
+        this.connection.on("connect", (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            this.connected = true;
+            this.logger.info({ dbId: this._config.id }, "SQL Server connected");
+            resolve2();
+          }
+        });
+        this.connection.connect();
+      } catch (error) {
+        this.handleError(error, "connect");
+      }
+    });
+  }
+  parseConnectionString(connStr) {
+    const config = {
+      options: {
+        encrypt: true,
+        trustServerCertificate: true,
+        enableArithAbort: true
+      }
+    };
+    const parts = connStr.split(";").filter((p) => p.trim());
+    for (const part of parts) {
+      const [key, value] = part.split("=").map((s) => s.trim());
+      const lowerKey = key.toLowerCase();
+      if (lowerKey === "server") {
+        const [host, port] = value.split(",");
+        config.server = host;
+        if (port) config.options.port = parseInt(port);
+      } else if (lowerKey === "database") {
+        config.options.database = value;
+      } else if (lowerKey === "user id") {
+        config.authentication = {
+          type: "default",
+          options: { userName: value, password: "" }
+        };
+      } else if (lowerKey === "password") {
+        if (config.authentication) {
+          config.authentication.options.password = value;
+        }
+      } else if (lowerKey === "encrypt") {
+        config.options.encrypt = value.toLowerCase() === "true";
+      } else if (lowerKey === "trustservercertificate") {
+        config.options.trustServerCertificate = value.toLowerCase() === "true";
+      }
+    }
+    return config;
+  }
+  async disconnect() {
+    if (this.connection) {
+      this.connection.close();
+      this.connection = void 0;
+      this.connected = false;
+      this.logger.info({ dbId: this._config.id }, "SQL Server disconnected");
+    }
+  }
+  executeQuery(sql, _params = []) {
+    return new Promise((resolve2, reject) => {
+      const rows = [];
+      const request = new Request(sql, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2(rows);
+        }
+      });
+      request.on("row", (columns) => {
+        const row = {};
+        columns.forEach((col) => {
+          row[col.metadata.colName] = col.value;
+        });
+        rows.push(row);
+      });
+      this.connection.execSql(request);
+    });
+  }
+  async introspect(options) {
+    this.ensureConnected();
+    try {
+      const schemas = await this.getSchemas(options);
+      const dbSchema = {
+        dbId: this._config.id,
+        dbType: "mssql",
+        schemas,
+        introspectedAt: /* @__PURE__ */ new Date(),
+        version: ""
+      };
+      dbSchema.version = generateSchemaVersion(dbSchema);
+      return dbSchema;
+    } catch (error) {
+      this.handleError(error, "introspect");
+    }
+  }
+  async getSchemas(options) {
+    const result = [];
+    const schemasQuery = `
+      SELECT SCHEMA_NAME
+      FROM INFORMATION_SCHEMA.SCHEMATA
+      WHERE SCHEMA_NAME NOT IN ('sys', 'INFORMATION_SCHEMA', 'guest')
+      ORDER BY SCHEMA_NAME
+    `;
+    const schemasResult = await this.executeQuery(schemasQuery);
+    let schemaNames = schemasResult.map((r) => r.SCHEMA_NAME);
+    if (options?.includeSchemas && options.includeSchemas.length > 0) {
+      schemaNames = schemaNames.filter((s) => options.includeSchemas.includes(s));
+    }
+    if (options?.excludeSchemas && options.excludeSchemas.length > 0) {
+      schemaNames = schemaNames.filter((s) => !options.excludeSchemas.includes(s));
+    }
+    for (const schemaName of schemaNames) {
+      const tables = await this.getTables(schemaName, options);
+      result.push({
+        name: schemaName,
+        tables
+      });
+    }
+    return result;
+  }
+  async getTables(schemaName, options) {
+    const result = [];
+    let tableTypes = "'BASE TABLE'";
+    if (options?.includeViews) {
+      tableTypes += ",'VIEW'";
+    }
+    const tablesQuery = `
+      SELECT TABLE_NAME, TABLE_TYPE
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_TYPE IN (${tableTypes})
+      ORDER BY TABLE_NAME
+      ${options?.maxTables ? `OFFSET 0 ROWS FETCH NEXT ${options.maxTables} ROWS ONLY` : ""}
+    `;
+    const tablesResult = await this.executeQuery(tablesQuery);
+    for (const row of tablesResult) {
+      const columns = await this.getColumns(schemaName, row.TABLE_NAME);
+      const indexes = await this.getIndexes(schemaName, row.TABLE_NAME);
+      const foreignKeys = await this.getForeignKeys(schemaName, row.TABLE_NAME);
+      const primaryKey = indexes.find((idx) => idx.isPrimary);
+      result.push({
+        schema: schemaName,
+        name: row.TABLE_NAME,
+        type: row.TABLE_TYPE === "VIEW" ? "view" : "table",
+        columns,
+        primaryKey,
+        indexes: indexes.filter((idx) => !idx.isPrimary),
+        foreignKeys
+      });
+    }
+    return result;
+  }
+  async getColumns(schemaName, tableName) {
+    const query = `
+      SELECT
+        COLUMN_NAME,
+        DATA_TYPE,
+        IS_NULLABLE,
+        COLUMN_DEFAULT,
+        CHARACTER_MAXIMUM_LENGTH,
+        NUMERIC_PRECISION,
+        NUMERIC_SCALE,
+        COLUMNPROPERTY(OBJECT_ID(TABLE_SCHEMA + '.' + TABLE_NAME), COLUMN_NAME, 'IsIdentity') AS IS_IDENTITY
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}'
+      ORDER BY ORDINAL_POSITION
+    `;
+    const result = await this.executeQuery(query);
+    return result.map((row) => ({
+      name: row.COLUMN_NAME,
+      dataType: row.DATA_TYPE,
+      nullable: row.IS_NULLABLE === "YES",
+      defaultValue: row.COLUMN_DEFAULT,
+      maxLength: row.CHARACTER_MAXIMUM_LENGTH,
+      precision: row.NUMERIC_PRECISION,
+      scale: row.NUMERIC_SCALE,
+      isAutoIncrement: row.IS_IDENTITY === 1
+    }));
+  }
+  async getIndexes(schemaName, tableName) {
+    const query = `
+      SELECT
+        i.name AS index_name,
+        i.is_unique,
+        i.is_primary_key,
+        STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY ic.key_ordinal) AS column_names
+      FROM sys.indexes i
+      INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      INNER JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+      INNER JOIN sys.tables t ON i.object_id = t.object_id
+      INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = '${schemaName}' AND t.name = '${tableName}'
+      GROUP BY i.name, i.is_unique, i.is_primary_key
+    `;
+    const result = await this.executeQuery(query);
+    return result.map((row) => ({
+      name: row.index_name,
+      columns: row.column_names.split(","),
+      isUnique: row.is_unique,
+      isPrimary: row.is_primary_key
+    }));
+  }
+  async getForeignKeys(schemaName, tableName) {
+    const query = `
+      SELECT
+        fk.name AS constraint_name,
+        STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) AS column_names,
+        rs.name AS referenced_schema,
+        rt.name AS referenced_table,
+        STRING_AGG(rc.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) AS referenced_columns,
+        fk.update_referential_action_desc,
+        fk.delete_referential_action_desc
+      FROM sys.foreign_keys fk
+      INNER JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+      INNER JOIN sys.columns c ON fkc.parent_object_id = c.object_id AND fkc.parent_column_id = c.column_id
+      INNER JOIN sys.columns rc ON fkc.referenced_object_id = rc.object_id AND fkc.referenced_column_id = rc.column_id
+      INNER JOIN sys.tables t ON fk.parent_object_id = t.object_id
+      INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+      INNER JOIN sys.tables rt ON fk.referenced_object_id = rt.object_id
+      INNER JOIN sys.schemas rs ON rt.schema_id = rs.schema_id
+      WHERE s.name = '${schemaName}' AND t.name = '${tableName}'
+      GROUP BY fk.name, rs.name, rt.name, fk.update_referential_action_desc, fk.delete_referential_action_desc
+    `;
+    const result = await this.executeQuery(query);
+    return result.map((row) => ({
+      name: row.constraint_name,
+      columns: row.column_names.split(","),
+      referencedSchema: row.referenced_schema,
+      referencedTable: row.referenced_table,
+      referencedColumns: row.referenced_columns.split(","),
+      onUpdate: row.update_referential_action_desc,
+      onDelete: row.delete_referential_action_desc
+    }));
+  }
+  async query(sql, params = [], _timeoutMs) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    try {
+      const rows = await this.executeQuery(sql, params);
+      const executionTimeMs = Date.now() - startTime;
+      const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+      return {
+        rows,
+        columns,
+        rowCount: rows.length,
+        executionTimeMs
+      };
+    } catch (error) {
+      this.handleError(error, "query");
+    }
+  }
+  async explain(sql, params = []) {
+    this.ensureConnected();
+    try {
+      const explainSql = `SET SHOWPLAN_TEXT ON; ${sql}; SET SHOWPLAN_TEXT OFF;`;
+      const plan = await this.executeQuery(explainSql, params);
+      return {
+        plan,
+        formattedPlan: JSON.stringify(plan, null, 2)
+      };
+    } catch (error) {
+      this.handleError(error, "explain");
+    }
+  }
+  async testConnection() {
+    try {
+      if (!this.connection) return false;
+      await this.executeQuery("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    this.ensureConnected();
+    try {
+      const result = await this.executeQuery("SELECT @@VERSION as version");
+      return result[0].version;
+    } catch (error) {
+      this.handleError(error, "getVersion");
+    }
+  }
+};
+
+// src/adapters/oracle.ts
+var OracleAdapter = class extends BaseAdapter {
+  connection;
+  async connect() {
+    this.logger.warn(
+      { dbId: this._config.id },
+      "Oracle adapter is not fully implemented. Requires Oracle Instant Client and oracledb package."
+    );
+    throw new Error(
+      "Oracle adapter not implemented. Please install Oracle Instant Client and implement OracleAdapter methods."
+    );
+  }
+  async disconnect() {
+    if (this.connection) {
+      this.connection = void 0;
+      this.connected = false;
+    }
+  }
+  async introspect(_options) {
+    this.ensureConnected();
+    throw new Error("Oracle introspection not implemented");
+  }
+  async query(_sql, _params = [], _timeoutMs) {
+    this.ensureConnected();
+    throw new Error("Oracle query not implemented");
+  }
+  async explain(_sql, _params = []) {
+    this.ensureConnected();
+    throw new Error("Oracle explain not implemented");
+  }
+  async testConnection() {
+    return false;
+  }
+  async getVersion() {
+    return "Oracle (not implemented)";
+  }
+};
+
+// src/adapters/index.ts
+function createAdapter(config) {
+  switch (config.type) {
+    case "postgres":
+      return new PostgresAdapter(config);
+    case "mysql":
+      return new MySQLAdapter(config);
+    case "sqlite":
+      return new SQLiteAdapter(config);
+    case "mssql":
+      return new MSSQLAdapter(config);
+    case "oracle":
+      return new OracleAdapter(config);
+    default:
+      throw new Error(`Unsupported database type: ${config.type}`);
+  }
+}
+
+// src/cache.ts
+import fs2 from "fs/promises";
+import path from "path";
+var SchemaCache = class {
+  constructor(_cacheDir, _defaultTtlMinutes) {
+    this._cacheDir = _cacheDir;
+    this._defaultTtlMinutes = _defaultTtlMinutes;
+  }
+  logger = getLogger();
+  cache = /* @__PURE__ */ new Map();
+  introspectionLocks = /* @__PURE__ */ new Map();
+  async init() {
+    try {
+      await fs2.mkdir(this._cacheDir, { recursive: true });
+      this.logger.info({ cacheDir: this._cacheDir }, "Schema cache initialized");
+    } catch (error) {
+      throw new CacheError("Failed to initialize cache directory", error);
+    }
+  }
+  /**
+   * Get cached schema if valid, otherwise return null
+   */
+  async get(dbId) {
+    const memEntry = this.cache.get(dbId);
+    if (memEntry && !this.isExpired(memEntry)) {
+      return memEntry;
+    }
+    try {
+      const diskEntry = await this.loadFromDisk(dbId);
+      if (diskEntry && !this.isExpired(diskEntry)) {
+        this.cache.set(dbId, diskEntry);
+        return diskEntry;
+      }
+    } catch (error) {
+      this.logger.warn({ dbId, error }, "Failed to load cache from disk");
+    }
+    return null;
+  }
+  /**
+   * Set or update cache entry
+   */
+  async set(dbId, schema, ttlMinutes) {
+    const entry = {
+      schema,
+      relationships: this.buildRelationships(schema),
+      cachedAt: /* @__PURE__ */ new Date(),
+      ttlMinutes: ttlMinutes || this._defaultTtlMinutes
+    };
+    this.cache.set(dbId, entry);
+    this.saveToDisk(dbId, entry).catch((error) => {
+      this.logger.error({ dbId, error }, "Failed to save cache to disk");
+    });
+  }
+  /**
+   * Clear cache for a specific database or all databases
+   */
+  async clear(dbId) {
+    if (dbId) {
+      this.cache.delete(dbId);
+      try {
+        const filePath = this.getCacheFilePath(dbId);
+        await fs2.unlink(filePath);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          this.logger.warn({ dbId, error }, "Failed to delete cache file");
+        }
+      }
+      this.logger.info({ dbId }, "Cache cleared");
+    } else {
+      this.cache.clear();
+      try {
+        const files = await fs2.readdir(this._cacheDir);
+        await Promise.all(
+          files.filter((f) => f.endsWith(".json")).map((f) => fs2.unlink(path.join(this._cacheDir, f)))
+        );
+      } catch (error) {
+        this.logger.warn({ error }, "Failed to clear cache directory");
+      }
+      this.logger.info("All caches cleared");
+    }
+  }
+  /**
+   * Get cache status
+   */
+  async getStatus(dbId) {
+    const statuses = [];
+    if (dbId) {
+      const status = await this.getStatusForDb(dbId);
+      statuses.push(status);
+    } else {
+      const dbIds = /* @__PURE__ */ new Set([
+        ...this.cache.keys(),
+        ...await this.getPersistedDbIds()
+      ]);
+      for (const id of dbIds) {
+        const status = await this.getStatusForDb(id);
+        statuses.push(status);
+      }
+    }
+    return statuses;
+  }
+  async getStatusForDb(dbId) {
+    const entry = await this.get(dbId);
+    if (!entry) {
+      return {
+        dbId,
+        exists: false
+      };
+    }
+    const age = Date.now() - new Date(entry.cachedAt).getTime();
+    const expired = this.isExpired(entry);
+    return {
+      dbId,
+      exists: true,
+      age,
+      ttlMinutes: entry.ttlMinutes,
+      expired,
+      version: entry.schema.version,
+      tableCount: entry.schema.schemas.reduce((sum, s) => sum + s.tables.length, 0),
+      relationshipCount: entry.relationships.length
+    };
+  }
+  /**
+   * Acquire lock for introspection to prevent concurrent introspection
+   */
+  async acquireIntrospectionLock(dbId) {
+    const existingLock = this.introspectionLocks.get(dbId);
+    if (existingLock) {
+      await existingLock;
+    }
+    let releaseLock;
+    const lockPromise = new Promise((resolve2) => {
+      releaseLock = resolve2;
+    });
+    this.introspectionLocks.set(dbId, lockPromise);
+    return () => {
+      releaseLock();
+      this.introspectionLocks.delete(dbId);
+    };
+  }
+  isExpired(entry) {
+    const age = Date.now() - new Date(entry.cachedAt).getTime();
+    const ttlMs = entry.ttlMinutes * 60 * 1e3;
+    return age > ttlMs;
+  }
+  buildRelationships(schema) {
+    const relationships = [];
+    for (const schemaObj of schema.schemas) {
+      for (const table of schemaObj.tables) {
+        for (const fk of table.foreignKeys) {
+          relationships.push({
+            fromSchema: schemaObj.name,
+            fromTable: table.name,
+            fromColumns: fk.columns,
+            toSchema: fk.referencedSchema,
+            toTable: fk.referencedTable,
+            toColumns: fk.referencedColumns,
+            type: "foreign_key"
+          });
+        }
+      }
+    }
+    const inferred = inferRelationships(schema);
+    const relationshipKeys = new Set(
+      relationships.map((r) => this.getRelationshipKey(r))
+    );
+    for (const rel of inferred) {
+      const key = this.getRelationshipKey(rel);
+      if (!relationshipKeys.has(key)) {
+        relationships.push(rel);
+        relationshipKeys.add(key);
+      }
+    }
+    return relationships;
+  }
+  getRelationshipKey(rel) {
+    return `${rel.fromSchema}.${rel.fromTable}.${rel.fromColumns.join(",")}\u2192${rel.toSchema}.${rel.toTable}.${rel.toColumns.join(",")}`;
+  }
+  getCacheFilePath(dbId) {
+    return path.join(this._cacheDir, `${dbId}.json`);
+  }
+  async loadFromDisk(dbId) {
+    try {
+      const filePath = this.getCacheFilePath(dbId);
+      const data = await fs2.readFile(filePath, "utf-8");
+      const entry = JSON.parse(data);
+      entry.cachedAt = new Date(entry.cachedAt);
+      entry.schema.introspectedAt = new Date(entry.schema.introspectedAt);
+      return entry;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async saveToDisk(dbId, entry) {
+    const filePath = this.getCacheFilePath(dbId);
+    const data = JSON.stringify(entry, null, 2);
+    await fs2.writeFile(filePath, data, "utf-8");
+  }
+  async getPersistedDbIds() {
+    try {
+      const files = await fs2.readdir(this._cacheDir);
+      return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/query-tracker.ts
+var QueryTracker = class {
+  history = /* @__PURE__ */ new Map();
+  maxHistoryPerDb = 100;
+  track(dbId, sql, executionTimeMs, rowCount, error) {
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      sql,
+      tables: extractTableNames(sql),
+      executionTimeMs,
+      rowCount,
+      error
+    };
+    if (!this.history.has(dbId)) {
+      this.history.set(dbId, []);
+    }
+    const dbHistory = this.history.get(dbId);
+    dbHistory.push(entry);
+    if (dbHistory.length > this.maxHistoryPerDb) {
+      dbHistory.shift();
+    }
+  }
+  getHistory(dbId, limit) {
+    const dbHistory = this.history.get(dbId) || [];
+    if (limit) {
+      return dbHistory.slice(-limit);
+    }
+    return [...dbHistory];
+  }
+  getStats(dbId) {
+    const dbHistory = this.history.get(dbId) || [];
+    const stats = {
+      totalQueries: dbHistory.length,
+      avgExecutionTime: 0,
+      errorCount: 0,
+      tableUsage: {}
+    };
+    if (dbHistory.length === 0) {
+      return stats;
+    }
+    let totalTime = 0;
+    for (const entry of dbHistory) {
+      totalTime += entry.executionTimeMs;
+      if (entry.error) {
+        stats.errorCount++;
+      }
+      for (const table of entry.tables) {
+        stats.tableUsage[table] = (stats.tableUsage[table] || 0) + 1;
+      }
+    }
+    stats.avgExecutionTime = totalTime / dbHistory.length;
+    return stats;
+  }
+  clear(dbId) {
+    if (dbId) {
+      this.history.delete(dbId);
+    } else {
+      this.history.clear();
+    }
+  }
+};
+
+// src/database-manager.ts
+var DatabaseManager = class {
+  constructor(_configs, options) {
+    this._configs = _configs;
+    this.options = options;
+    this.cache = new SchemaCache(options.cacheDir, options.cacheTtlMinutes);
+  }
+  logger = getLogger();
+  adapters = /* @__PURE__ */ new Map();
+  cache;
+  queryTracker = new QueryTracker();
+  async init() {
+    await this.cache.init();
+    for (const config of this._configs) {
+      const adapter = createAdapter(config);
+      this.adapters.set(config.id, adapter);
+      if (config.eagerConnect) {
+        try {
+          await this.connect(config.id);
+        } catch (error) {
+          this.logger.error({ dbId: config.id, error }, "Failed to eager connect");
+        }
+      }
+    }
+    this.logger.info({ databases: this._configs.length }, "Database manager initialized");
+  }
+  async shutdown() {
+    for (const [dbId, adapter] of this.adapters) {
+      try {
+        await adapter.disconnect();
+      } catch (error) {
+        this.logger.error({ dbId, error }, "Failed to disconnect");
+      }
+    }
+    this.logger.info("Database manager shut down");
+  }
+  getConfigs() {
+    return this._configs;
+  }
+  getConfig(dbId) {
+    return this._configs.find((c) => c.id === dbId);
+  }
+  getAdapter(dbId) {
+    const adapter = this.adapters.get(dbId);
+    if (!adapter) {
+      throw new Error(`Database not found: ${dbId}`);
+    }
+    return adapter;
+  }
+  async connect(dbId) {
+    const adapter = this.getAdapter(dbId);
+    await adapter.connect();
+  }
+  async ensureConnected(dbId) {
+    const adapter = this.getAdapter(dbId);
+    const connected = await adapter.testConnection();
+    if (!connected) {
+      await this.connect(dbId);
+    }
+  }
+  async testConnection(dbId) {
+    const adapter = this.getAdapter(dbId);
+    return adapter.testConnection();
+  }
+  async getVersion(dbId) {
+    await this.ensureConnected(dbId);
+    const adapter = this.getAdapter(dbId);
+    return adapter.getVersion();
+  }
+  async introspectSchema(dbId, forceRefresh = false, options) {
+    if (!forceRefresh) {
+      const cached = await this.cache.get(dbId);
+      if (cached) {
+        this.logger.debug({ dbId }, "Using cached schema");
+        return cached;
+      }
+    }
+    const releaseLock = await this.cache.acquireIntrospectionLock(dbId);
+    try {
+      if (!forceRefresh) {
+        const cached = await this.cache.get(dbId);
+        if (cached) {
+          return cached;
+        }
+      }
+      this.logger.info({ dbId, forceRefresh }, "Introspecting schema");
+      await this.ensureConnected(dbId);
+      const adapter = this.getAdapter(dbId);
+      const schema = await adapter.introspect(options);
+      const config = this.getConfig(dbId);
+      await this.cache.set(dbId, schema, config?.introspection?.maxTables);
+      const entry = await this.cache.get(dbId);
+      return entry;
+    } finally {
+      releaseLock();
+    }
+  }
+  async getSchema(dbId) {
+    return this.introspectSchema(dbId, false);
+  }
+  async runQuery(dbId, sql, params = [], timeoutMs) {
+    const config = this.getConfig(dbId);
+    if (isWriteOperation(sql)) {
+      if (!this.options.allowWrite && !config?.readOnly === false) {
+        throw new Error("Write operations are not allowed. Set allowWrite in config.");
+      }
+      if (this.options.disableDangerousOperations) {
+        const operation = sql.trim().split(/\s+/)[0].toUpperCase();
+        const dangerousOps = ["DELETE", "TRUNCATE", "DROP"];
+        if (dangerousOps.includes(operation)) {
+          throw new Error(`Dangerous operation ${operation} is disabled. Set disableDangerousOperations: false in security config to allow.`);
+        }
+      }
+      if (this.options.allowedWriteOperations && this.options.allowedWriteOperations.length > 0) {
+        const operation = sql.trim().split(/\s+/)[0].toUpperCase();
+        if (!this.options.allowedWriteOperations.includes(operation)) {
+          throw new Error(`Write operation ${operation} is not allowed.`);
+        }
+      }
+    }
+    await this.introspectSchema(dbId, false);
+    await this.ensureConnected(dbId);
+    const adapter = this.getAdapter(dbId);
+    try {
+      const result = await adapter.query(sql, params, timeoutMs);
+      this.queryTracker.track(dbId, sql, result.executionTimeMs, result.rowCount);
+      return result;
+    } catch (error) {
+      this.queryTracker.track(dbId, sql, 0, 0, error.message);
+      throw error;
+    }
+  }
+  async explainQuery(dbId, sql, params = []) {
+    await this.ensureConnected(dbId);
+    const adapter = this.getAdapter(dbId);
+    return adapter.explain(sql, params);
+  }
+  async suggestJoins(dbId, tables) {
+    const cacheEntry = await this.getSchema(dbId);
+    return findJoinPaths(tables, cacheEntry.relationships);
+  }
+  async clearCache(dbId) {
+    await this.cache.clear(dbId);
+    this.queryTracker.clear(dbId);
+  }
+  async getCacheStatus(dbId) {
+    return this.cache.getStatus(dbId);
+  }
+  getQueryStats(dbId) {
+    return this.queryTracker.getStats(dbId);
+  }
+  getQueryHistory(dbId, limit) {
+    return this.queryTracker.getHistory(dbId, limit);
+  }
+};
+
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var MCPServer = class {
+  constructor(_dbManager, _config) {
+    this._dbManager = _dbManager;
+    this._config = _config;
+    this.server = new Server(
+      {
+        name: "mcp-database-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  server;
+  logger = getLogger();
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "list_databases",
+          description: "List all configured databases with their status",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "introspect_schema",
+          description: "Introspect database schema and cache it",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID to introspect"
+              },
+              forceRefresh: {
+                type: "boolean",
+                description: "Force refresh even if cached",
+                default: false
+              },
+              schemaFilter: {
+                type: "object",
+                description: "Optional schema filtering options",
+                properties: {
+                  includeSchemas: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  excludeSchemas: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  includeViews: { type: "boolean" },
+                  maxTables: { type: "number" }
+                }
+              }
+            },
+            required: ["dbId"]
+          }
+        },
+        {
+          name: "get_schema",
+          description: "Get cached schema metadata",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              schema: {
+                type: "string",
+                description: "Optional schema name to filter"
+              },
+              table: {
+                type: "string",
+                description: "Optional table name to filter"
+              }
+            },
+            required: ["dbId"]
+          }
+        },
+        {
+          name: "run_query",
+          description: "Execute SQL query against a database",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              sql: {
+                type: "string",
+                description: "SQL query to execute"
+              },
+              params: {
+                type: "array",
+                description: "Query parameters",
+                items: {}
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of rows to return"
+              },
+              timeoutMs: {
+                type: "number",
+                description: "Query timeout in milliseconds"
+              }
+            },
+            required: ["dbId", "sql"]
+          }
+        },
+        {
+          name: "explain_query",
+          description: "Get query execution plan",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              sql: {
+                type: "string",
+                description: "SQL query to explain"
+              },
+              params: {
+                type: "array",
+                description: "Query parameters",
+                items: {}
+              }
+            },
+            required: ["dbId", "sql"]
+          }
+        },
+        {
+          name: "suggest_joins",
+          description: "Suggest join paths between tables based on relationships",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              tables: {
+                type: "array",
+                description: "List of table names to join",
+                items: { type: "string" },
+                minItems: 2
+              }
+            },
+            required: ["dbId", "tables"]
+          }
+        },
+        {
+          name: "clear_cache",
+          description: "Clear schema cache",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Optional database ID (clears all if omitted)"
+              }
+            }
+          }
+        },
+        {
+          name: "cache_status",
+          description: "Get cache status and statistics",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Optional database ID"
+              }
+            }
+          }
+        },
+        {
+          name: "health_check",
+          description: "Check database connectivity and get version info",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Optional database ID (checks all if omitted)"
+              }
+            }
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        switch (name) {
+          case "list_databases":
+            return await this.handleListDatabases();
+          case "introspect_schema":
+            return await this.handleIntrospectSchema(args);
+          case "get_schema":
+            return await this.handleGetSchema(args);
+          case "run_query":
+            return await this.handleRunQuery(args);
+          case "explain_query":
+            return await this.handleExplainQuery(args);
+          case "suggest_joins":
+            return await this.handleSuggestJoins(args);
+          case "clear_cache":
+            return await this.handleClearCache(args);
+          case "cache_status":
+            return await this.handleCacheStatus(args);
+          case "health_check":
+            return await this.handleHealthCheck(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        this.logger.error({ tool: name, error }, "Tool execution failed");
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: error.message,
+                code: error.code || "TOOL_ERROR"
+              })
+            }
+          ]
+        };
+      }
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      const statuses = await this._dbManager.getCacheStatus();
+      const resources = statuses.filter((s) => s.exists).map((s) => ({
+        uri: `schema://${s.dbId}`,
+        name: `Schema: ${s.dbId}`,
+        description: `Cached schema for ${s.dbId} (${s.tableCount} tables, ${s.relationshipCount} relationships)`,
+        mimeType: "application/json"
+      }));
+      return { resources };
+    });
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const match = uri.match(/^schema:\/\/(.+)$/);
+      if (!match) {
+        throw new Error(`Invalid resource URI: ${uri}`);
+      }
+      const dbId = match[1];
+      const cacheEntry = await this._dbManager.getSchema(dbId);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(cacheEntry, null, 2)
+          }
+        ]
+      };
+    });
+  }
+  async handleListDatabases() {
+    const configs = this._dbManager.getConfigs();
+    const statuses = await Promise.all(
+      configs.map(async (config) => {
+        const connected = await this._dbManager.testConnection(config.id);
+        const cacheStatus = (await this._dbManager.getCacheStatus(config.id))[0];
+        return {
+          id: config.id,
+          type: config.type,
+          url: this._config.security?.redactSecrets ? redactUrl(config.url || "") : config.url,
+          connected,
+          cached: cacheStatus?.exists || false,
+          cacheAge: cacheStatus?.age,
+          version: cacheStatus?.version
+        };
+      })
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(statuses, null, 2)
+        }
+      ]
+    };
+  }
+  async handleIntrospectSchema(args) {
+    const result = await this._dbManager.introspectSchema(
+      args.dbId,
+      args.forceRefresh || false,
+      args.schemaFilter
+    );
+    const summary = {
+      dbId: args.dbId,
+      version: result.schema.version,
+      introspectedAt: result.schema.introspectedAt,
+      schemas: result.schema.schemas.map((s) => ({
+        name: s.name,
+        tableCount: s.tables.length,
+        viewCount: s.tables.filter((t) => t.type === "view").length
+      })),
+      totalTables: result.schema.schemas.reduce((sum, s) => sum + s.tables.length, 0),
+      totalRelationships: result.relationships.length
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(summary, null, 2)
+        }
+      ]
+    };
+  }
+  async handleGetSchema(args) {
+    const cacheEntry = await this._dbManager.getSchema(args.dbId);
+    let result = cacheEntry.schema;
+    if (args.schema) {
+      result = {
+        ...result,
+        schemas: result.schemas.filter((s) => s.name === args.schema)
+      };
+    }
+    if (args.table) {
+      result = {
+        ...result,
+        schemas: result.schemas.map((s) => ({
+          ...s,
+          tables: s.tables.filter((t) => t.name === args.table)
+        }))
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  }
+  async handleRunQuery(args) {
+    let sql = args.sql;
+    if (args.limit && !sql.toUpperCase().includes("LIMIT")) {
+      sql += ` LIMIT ${args.limit}`;
+    }
+    const result = await this._dbManager.runQuery(args.dbId, sql, args.params, args.timeoutMs);
+    const cacheEntry = await this._dbManager.getSchema(args.dbId);
+    const queryStats = this._dbManager.getQueryStats(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              ...result,
+              metadata: {
+                relationships: cacheEntry.relationships.filter(
+                  (r) => result.columns.some(
+                    (col) => col.includes(r.fromTable) || col.includes(r.toTable)
+                  )
+                ),
+                queryStats
+              }
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  async handleExplainQuery(args) {
+    const result = await this._dbManager.explainQuery(args.dbId, args.sql, args.params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  }
+  async handleSuggestJoins(args) {
+    const joinPaths = await this._dbManager.suggestJoins(args.dbId, args.tables);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(joinPaths, null, 2)
+        }
+      ]
+    };
+  }
+  async handleClearCache(args) {
+    await this._dbManager.clearCache(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: args.dbId ? `Cache cleared for ${args.dbId}` : "All caches cleared"
+          })
+        }
+      ]
+    };
+  }
+  async handleCacheStatus(args) {
+    const statuses = await this._dbManager.getCacheStatus(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(statuses, null, 2)
+        }
+      ]
+    };
+  }
+  async handleHealthCheck(args) {
+    const configs = args.dbId ? [this._dbManager.getConfig(args.dbId)] : this._dbManager.getConfigs();
+    const results = await Promise.all(
+      configs.map(async (config) => {
+        try {
+          const connected = await this._dbManager.testConnection(config.id);
+          const version2 = connected ? await this._dbManager.getVersion(config.id) : "N/A";
+          return {
+            dbId: config.id,
+            healthy: connected,
+            version: version2
+          };
+        } catch (error) {
+          return {
+            dbId: config.id,
+            healthy: false,
+            error: error.message
+          };
+        }
+      })
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(results, null, 2)
+        }
+      ]
+    };
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    this.logger.info("MCP server started");
+  }
+};
+
+// src/index.ts
+dotenv.config();
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var packageJson = JSON.parse(
+  readFileSync(join2(__dirname2, "../package.json"), "utf-8")
+);
+var version = packageJson.version;
+async function main() {
+  try {
+    const { values } = parseArgs({
+      options: {
+        config: {
+          type: "string",
+          short: "c",
+          default: "./.mcp-database-server.config"
+        },
+        help: {
+          type: "boolean",
+          short: "h"
+        },
+        version: {
+          type: "boolean",
+          short: "v"
+        }
+      }
+    });
+    if (values.version) {
+      console.log(version);
+      process.exit(0);
+    }
+    if (values.help) {
+      console.log(`
+mcp-database-server - Model Context Protocol Server for SQL Databases
+
+Usage:
+  mcp-database-server [options]
+
+Options:
+  -c, --config <path>  Path to configuration file (default: ./.mcp-database-server.config)
+  -h, --help          Show this help message
+  -v, --version       Show version number
+
+Configuration:
+  The config file should be a JSON file with database configurations.
+  See mcp-database-server.config.example for reference.
+
+Environment Variables:
+  You can use environment variable interpolation in the config file:
+  Example: "url": "\${DB_URL_POSTGRES}"
+
+Examples:
+  mcp-database-server --config ./my-config.json
+  mcp-database-server -c ./config/production.json
+      `);
+      process.exit(0);
+    }
+    let configPath = values.config;
+    if (configPath === "./.mcp-database-server.config") {
+      const foundPath = findConfigFile(".mcp-database-server.config");
+      if (foundPath) {
+        configPath = foundPath;
+      } else {
+        console.error("Error: Config file .mcp-database-server.config not found");
+        console.error("Searched in current directory and all parent directories");
+        console.error("\nTo create a config file:");
+        console.error("  cp mcp-database-server.config.example .mcp-database-server.config");
+        console.error("\nOr specify a custom path:");
+        console.error("  mcp-database-server --config /path/to/config.json");
+        process.exit(1);
+      }
+    }
+    const config = await loadConfig(configPath);
+    initLogger(config.logging?.level || "info", config.logging?.pretty || false);
+    const logger2 = getLogger();
+    logger2.info({ configPath }, "Configuration loaded");
+    const dbManager = new DatabaseManager(config.databases, {
+      cacheDir: config.cache?.directory || ".sql-mcp-cache",
+      cacheTtlMinutes: config.cache?.ttlMinutes || 10,
+      allowWrite: config.security?.allowWrite || false,
+      allowedWriteOperations: config.security?.allowedWriteOperations,
+      disableDangerousOperations: config.security?.disableDangerousOperations ?? true
+    });
+    await dbManager.init();
+    const mcpServer = new MCPServer(dbManager, config);
+    await mcpServer.start();
+    const shutdown = async (signal) => {
+      logger2.info({ signal }, "Shutting down...");
+      await dbManager.shutdown();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+  } catch (error) {
+    console.error("Fatal error:", error.message);
+    if (error.details) {
+      console.error("Details:", JSON.stringify(error.details, null, 2));
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map