@tejasanik/postgres-mcp-server 2.1.0 → 2.2.0

package/dist/db-manager.js

@@ -1,25 +1,35 @@
 import { Pool } from "pg";
 import { v4 as uuidv4 } from "uuid";
 import { isReadOnlySql } from "./utils/validation.js";
+import { validateDatabaseName, validateSchemaName, } from "./db-manager/validation.js";
+import { TRANSACTION_CLEANUP_TIMEOUT_MS, TRANSACTION_CLEANUP_INTERVAL_MS, } from "./tools/sql/utils/constants.js";
 const DEFAULT_PORT = "5432";
 const DEFAULT_DATABASE = "postgres";
 const DEFAULT_SCHEMA = "public";
-const DEFAULT_QUERY_TIMEOUT_MS = 30000; // 30 seconds
+const DEFAULT_QUERY_TIMEOUT_MS = 200000; // 30 seconds
 const MAX_QUERY_TIMEOUT_MS = 300000; // 5 minutes
+// Pool cache configuration
+const MAX_CACHED_POOLS = 10; // Maximum number of cached pools for override connections
+const POOL_IDLE_TIMEOUT_MS = 300000; // 5 minutes - idle pools are closed after this time
+const POOL_CLEANUP_INTERVAL_MS = 60000; // 1 minute - interval for checking and cleaning up idle pools
+const MAX_POOL_SIZE_MAIN = 10; // Max connections for main pool
+const MAX_POOL_SIZE_CACHED = 5; // Max connections per cached pool
+const MAX_TOTAL_CONNECTIONS = 50; // Global limit across all pools
 /**
  * Converts the ServerConfig ssl option to pg Pool ssl config format.
+ * Returns undefined for disabled SSL, or an SSL config object for enabled SSL.
  */
 function getSslConfig(ssl) {
     if (ssl === undefined || ssl === false || ssl === "disable") {
         return undefined;
     }
-    if (ssl === true || ssl === "require") {
+    if (ssl === true ||
+        ssl === "require" ||
+        ssl === "prefer" ||
+        ssl === "allow") {
         // Most cloud providers need rejectUnauthorized: false for self-signed certs
         return { rejectUnauthorized: false };
     }
-    if (ssl === "prefer" || ssl === "allow") {
-        return { rejectUnauthorized: false };
-    }
     if (typeof ssl === "object") {
         return ssl;
     }
@@ -31,16 +41,14 @@ function getSslConfig(ssl) {
  */
 function getAccessModeFromEnv() {
     const mode = process.env.POSTGRES_ACCESS_MODE?.toLowerCase().trim();
-    if (mode === "readonly" || mode === "read-only" || mode === "ro") {
-        return true; // read-only mode
-    }
-    // Default is 'full' access (read-only = false)
-    return false;
+    return mode === "readonly" || mode === "read-only" || mode === "ro";
 }
 /**
  * Parses SSL configuration from environment variable string.
  * Accepts: "true", "false", "require", "prefer", "allow", "disable", or JSON object
+ * Note: Returns union type intentionally - this is a parser function
  */
+// eslint-disable-next-line sonarjs/function-return-type
 function parseSslFromEnv(sslValue) {
     if (!sslValue)
         return undefined;
@@ -150,6 +158,16 @@ export class DatabaseManager {
     readOnlyMode;
     queryTimeoutMs;
     activeTransactions = new Map();
+    // Pool cache for connection overrides (keyed by "serverName:database")
+    poolCache = new Map();
+    poolCleanupInterval = null;
+    transactionCleanupInterval = null;
+    // Track pool creation promises to prevent race conditions
+    // When multiple concurrent requests need the same pool, they all wait for the same Promise
+    poolCreationPromises = new Map();
+    // Track total active connections across all pools for global limit enforcement
+    totalActiveConnections = 0;
+    mainPoolActiveConnections = 0;
     constructor(readOnlyMode = true, queryTimeoutMs = DEFAULT_QUERY_TIMEOUT_MS) {
         this.serversConfig = this.loadServersConfig();
         this.connectionState = {
@@ -159,6 +177,154 @@ export class DatabaseManager {
         };
         this.readOnlyMode = readOnlyMode;
         this.queryTimeoutMs = Math.min(queryTimeoutMs, MAX_QUERY_TIMEOUT_MS);
+        // Start pool cleanup interval
+        this.startPoolCleanup();
+        // Start transaction cleanup interval
+        this.startTransactionCleanup();
+    }
+    /**
+     * Starts the periodic cleanup of idle cached pools
+     */
+    startPoolCleanup() {
+        if (this.poolCleanupInterval) {
+            return;
+        }
+        this.poolCleanupInterval = setInterval(() => {
+            this.cleanupIdlePools();
+        }, POOL_CLEANUP_INTERVAL_MS);
+        // Allow the process to exit even if the interval is running
+        if (this.poolCleanupInterval.unref) {
+            this.poolCleanupInterval.unref();
+        }
+    }
+    /**
+     * Cleans up pools that have been idle for too long
+     */
+    cleanupIdlePools() {
+        const now = Date.now();
+        const poolsToRemove = [];
+        for (const [key, cached] of this.poolCache.entries()) {
+            if (now - cached.lastUsed > POOL_IDLE_TIMEOUT_MS) {
+                poolsToRemove.push(key);
+            }
+        }
+        for (const key of poolsToRemove) {
+            const cached = this.poolCache.get(key);
+            if (cached) {
+                cached.pool.end().catch((err) => {
+                    console.error(`Error closing idle pool ${key}:`, err);
+                });
+                this.poolCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Starts the periodic cleanup of abandoned transactions.
+     * Transactions older than TRANSACTION_CLEANUP_TIMEOUT_MS (45 minutes) are
+     * automatically rolled back to prevent connection leaks.
+     */
+    startTransactionCleanup() {
+        if (this.transactionCleanupInterval) {
+            return;
+        }
+        this.transactionCleanupInterval = setInterval(() => {
+            this.cleanupAbandonedTransactions();
+        }, TRANSACTION_CLEANUP_INTERVAL_MS);
+        // Allow the process to exit even if the interval is running
+        if (this.transactionCleanupInterval.unref) {
+            this.transactionCleanupInterval.unref();
+        }
+    }
+    /**
+     * Cleans up transactions that have been open for too long.
+     * Rolls back and releases the client for any transaction older than
+     * TRANSACTION_CLEANUP_TIMEOUT_MS (45 minutes).
+     *
+     * @returns Array of cleaned up transaction IDs with their info
+     */
+    cleanupAbandonedTransactions() {
+        const now = Date.now();
+        const cleanedUp = [];
+        for (const [transactionId, transaction,] of this.activeTransactions.entries()) {
+            const age = now - transaction.info.startedAt.getTime();
+            if (age > TRANSACTION_CLEANUP_TIMEOUT_MS) {
+                const info = {
+                    transactionId,
+                    name: transaction.info.name,
+                    age,
+                };
+                // Roll back the transaction and release the client
+                transaction.client
+                    .query("ROLLBACK")
+                    .catch((err) => {
+                    console.error(`Error rolling back abandoned transaction ${transactionId}:`, err);
+                })
+                    .finally(() => {
+                    transaction.client.release();
+                });
+                this.activeTransactions.delete(transactionId);
+                cleanedUp.push(info);
+                console.error(`Cleaned up abandoned transaction: ${transactionId}` +
+                    (transaction.info.name ? ` (${transaction.info.name})` : "") +
+                    ` - age: ${Math.round(age / 60000)} minutes`);
+            }
+        }
+        return cleanedUp;
+    }
+    /**
+     * Gets the age of a transaction in milliseconds.
+     *
+     * @param transactionId - The transaction ID
+     * @returns Age in milliseconds or null if transaction not found
+     */
+    getTransactionAge(transactionId) {
+        const transaction = this.activeTransactions.get(transactionId);
+        if (!transaction)
+            return null;
+        return Date.now() - transaction.info.startedAt.getTime();
+    }
+    /**
+     * Gets the remaining time before a transaction is auto-cleaned in milliseconds.
+     *
+     * @param transactionId - The transaction ID
+     * @returns Remaining time in milliseconds or null if transaction not found
+     */
+    getTransactionTimeRemaining(transactionId) {
+        const age = this.getTransactionAge(transactionId);
+        if (age === null)
+            return null;
+        return Math.max(0, TRANSACTION_CLEANUP_TIMEOUT_MS - age);
+    }
+    /**
+     * Generates a cache key for a server/database combination
+     */
+    getPoolCacheKey(serverName, database) {
+        return `${serverName}:${database}`;
+    }
+    /**
+     * Evicts the least recently used pool when cache is full
+     */
+    evictLruPool() {
+        if (this.poolCache.size < MAX_CACHED_POOLS) {
+            return;
+        }
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, cached] of this.poolCache.entries()) {
+            if (cached.lastUsed < oldestTime) {
+                oldestTime = cached.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const cached = this.poolCache.get(oldestKey);
+            if (cached) {
+                cached.pool.end().catch((err) => {
+                    console.error(`Error closing evicted pool ${oldestKey}:`, err);
+                });
+                this.poolCache.delete(oldestKey);
+            }
+        }
     }
     loadServersConfig() {
         // Load from both sources - PG_* env vars take precedence over POSTGRES_SERVERS JSON
@@ -213,12 +379,8 @@ export class DatabaseManager {
         }
         // Use provided database, server's default, or system default
         const dbName = database || serverConfig.defaultDatabase || DEFAULT_DATABASE;
-        // Validate database name - allow alphanumeric, underscores, hyphens, but block SQL injection
-        // PostgreSQL allows hyphens in database names when quoted (pg library handles this)
-        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(dbName) ||
-            /--|;|'|"|`/.test(dbName)) {
-            throw new Error("Invalid database name. Allowed: letters, digits, underscores, hyphens. Cannot contain SQL characters (;, --, quotes).");
-        }
+        // Validate database name for SQL injection prevention
+        validateDatabaseName(dbName);
         const sslConfig = getSslConfig(serverConfig.ssl);
         this.currentPool = new Pool({
             host: serverConfig.host,
@@ -253,14 +415,14 @@ export class DatabaseManager {
         }
     }
     setCurrentSchema(schema) {
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schema)) {
-            throw new Error("Invalid schema name. Only alphanumeric characters and underscores are allowed.");
-        }
+        validateSchemaName(schema);
         this.connectionState.currentSchema = schema;
     }
     getConnectionInfo() {
         const currentServer = this.connectionState.currentServer;
-        const serverConfig = currentServer ? this.serversConfig[currentServer] : null;
+        const serverConfig = currentServer
+            ? this.serversConfig[currentServer]
+            : null;
         return {
             isConnected: this.isConnected(),
             server: currentServer,
@@ -335,7 +497,386 @@ export class DatabaseManager {
         }
         return this.currentPool.connect();
     }
+    /**
+     * Checks if we can acquire a new connection without exceeding global limits
+     */
+    canAcquireConnection() {
+        return this.totalActiveConnections < MAX_TOTAL_CONNECTIONS;
+    }
+    /**
+     * Acquires a client from the main pool with proper tracking
+     */
+    async acquireMainPoolClient() {
+        if (!this.currentPool) {
+            throw new Error("No database connection. Please switch to a server and database first.");
+        }
+        if (!this.canAcquireConnection()) {
+            throw new Error(`Connection limit reached (${MAX_TOTAL_CONNECTIONS} max). Please wait for existing operations to complete.`);
+        }
+        const client = await this.currentPool.connect();
+        this.totalActiveConnections++;
+        this.mainPoolActiveConnections++;
+        const release = () => {
+            this.totalActiveConnections = Math.max(0, this.totalActiveConnections - 1);
+            this.mainPoolActiveConnections = Math.max(0, this.mainPoolActiveConnections - 1);
+            client.release();
+        };
+        return { client, release };
+    }
+    /**
+     * Acquires a client from a cached pool with proper tracking
+     */
+    async acquireCachedPoolClient(cached) {
+        if (!this.canAcquireConnection()) {
+            throw new Error(`Connection limit reached (${MAX_TOTAL_CONNECTIONS} max). Please wait for existing operations to complete.`);
+        }
+        const client = await cached.pool.connect();
+        this.totalActiveConnections++;
+        cached.activeConnections++;
+        cached.lastUsed = Date.now();
+        const release = () => {
+            this.totalActiveConnections = Math.max(0, this.totalActiveConnections - 1);
+            cached.activeConnections = Math.max(0, cached.activeConnections - 1);
+            client.release();
+        };
+        return { client, release };
+    }
+    /**
+     * Creates a new cached pool. This method handles concurrent creation requests
+     * by storing the creation promise so multiple callers wait for the same pool.
+     */
+    async getOrCreateCachedPool(serverName, database, serverConfig) {
+        const cacheKey = this.getPoolCacheKey(serverName, database);
+        // Check if pool already exists
+        const existing = this.poolCache.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        // Check if pool creation is already in progress (handles concurrent requests)
+        const inProgress = this.poolCreationPromises.get(cacheKey);
+        if (inProgress) {
+            return inProgress;
+        }
+        // Create pool - wrap in promise and store it so concurrent requests wait
+        const creationPromise = (async () => {
+            try {
+                // Double-check after acquiring "lock" (in case another request completed)
+                const existingAfterLock = this.poolCache.get(cacheKey);
+                if (existingAfterLock) {
+                    return existingAfterLock;
+                }
+                // Evict LRU pool if cache is full
+                this.evictLruPool();
+                // Create new pool with smaller size for cached connections
+                const sslConfig = getSslConfig(serverConfig.ssl);
+                const pool = new Pool({
+                    host: serverConfig.host,
+                    port: parseInt(serverConfig.port || DEFAULT_PORT, 10),
+                    user: serverConfig.username,
+                    password: serverConfig.password,
+                    database,
+                    max: MAX_POOL_SIZE_CACHED,
+                    idleTimeoutMillis: 30000,
+                    connectionTimeoutMillis: 10000,
+                    statement_timeout: this.queryTimeoutMs,
+                    ...(sslConfig && { ssl: sslConfig }),
+                });
+                // Handle pool errors - remove from cache on critical errors
+                pool.on("error", (err) => {
+                    console.error(`Pool error for ${cacheKey}:`, err);
+                    this.poolCache.delete(cacheKey);
+                });
+                // Test connection before caching
+                const testClient = await pool.connect();
+                testClient.release();
+                const cached = {
+                    pool,
+                    serverName,
+                    database,
+                    lastUsed: Date.now(),
+                    createdAt: Date.now(),
+                    activeConnections: 0,
+                };
+                this.poolCache.set(cacheKey, cached);
+                return cached;
+            }
+            finally {
+                // Always remove the creation promise when done (success or failure)
+                this.poolCreationPromises.delete(cacheKey);
+            }
+        })();
+        // Store the promise so concurrent requests can wait for it
+        this.poolCreationPromises.set(cacheKey, creationPromise);
+        return creationPromise;
+    }
+    /**
+     * Gets a client with optional connection override for one-time execution.
+     * Handles concurrent calls efficiently by:
+     * - Reusing existing pools for the same server/database
+     * - Preventing duplicate pool creation through promise caching
+     * - Tracking active connections for resource management
+     * - Enforcing global connection limits
+     *
+     * @param override - Optional connection override parameters
+     * @returns Object containing the client, release function, and resolved connection info
+     * @throws Error if no connection and no override, or if override server not found
+     */
+    async getClientWithOverride(override) {
+        // If no override, use current connection
+        if (!override ||
+            (!override.server && !override.database && !override.schema)) {
+            if (!this.currentPool) {
+                throw new Error("No database connection. Please switch to a server and database first, or provide server/database/schema override parameters.");
+            }
+            const { client, release } = await this.acquireMainPoolClient();
+            const serverConfig = this.connectionState.currentServer
+                ? this.serversConfig[this.connectionState.currentServer]
+                : null;
+            // Set search_path to current schema
+            const schema = this.connectionState.currentSchema || DEFAULT_SCHEMA;
+            try {
+                await client.query(`SET search_path TO ${this.escapeIdentifier(schema)}`);
+            }
+            catch (error) {
+                release();
+                throw new Error(`Failed to set schema '${schema}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return {
+                client,
+                release,
+                server: this.connectionState.currentServer || "",
+                database: this.connectionState.currentDatabase || "",
+                schema,
+                context: serverConfig?.context,
+                isOverride: false,
+            };
+        }
+        // Resolve server - use override or current
+        const serverName = override.server || this.connectionState.currentServer;
+        if (!serverName) {
+            // Build a helpful error message describing what was provided vs what's needed
+            const providedParams = [];
+            if (override.database)
+                providedParams.push(`database='${override.database}'`);
+            if (override.schema)
+                providedParams.push(`schema='${override.schema}'`);
+            const providedStr = providedParams.length > 0
+                ? ` You provided ${providedParams.join(", ")} but no server.`
+                : "";
+            const availableServers = this.getServerNames();
+            const serversHint = availableServers.length > 0
+                ? ` Available servers: ${availableServers.join(", ")}.`
+                : " No servers are configured. Please set PG_* environment variables or POSTGRES_SERVERS.";
+            throw new Error(`No server specified and no current connection.${providedStr} ` +
+                `Provide 'server' parameter to specify target server, or use switch_server to connect first.${serversHint}`);
+        }
+        const serverConfig = this.getServerConfig(serverName);
+        if (!serverConfig) {
+            const availableServers = this.getServerNames();
+            throw new Error(`Server '${serverName}' not found. Available servers: ${availableServers.join(", ") || "none configured"}`);
+        }
+        // Resolve database - use override, or if same server use current, or use server default
+        let database;
+        if (override.database) {
+            database = override.database;
+        }
+        else if (serverName === this.connectionState.currentServer &&
+            this.connectionState.currentDatabase) {
+            database = this.connectionState.currentDatabase;
+        }
+        else {
+            database = serverConfig.defaultDatabase || DEFAULT_DATABASE;
+        }
+        // Validate database name for SQL injection prevention
+        validateDatabaseName(database);
+        // Resolve schema
+        let schema;
+        if (override.schema) {
+            schema = override.schema;
+        }
+        else if (serverName === this.connectionState.currentServer &&
+            this.connectionState.currentSchema) {
+            schema = this.connectionState.currentSchema;
+        }
+        else {
+            schema = serverConfig.defaultSchema || DEFAULT_SCHEMA;
+        }
+        // Validate schema name
+        validateSchemaName(schema);
+        // Check if this is the same as current connection (can use main pool)
+        const isSameAsMain = serverName === this.connectionState.currentServer &&
+            database === this.connectionState.currentDatabase;
+        if (isSameAsMain && this.currentPool) {
+            // Use main pool but with potentially different schema
+            const { client, release } = await this.acquireMainPoolClient();
+            try {
+                await client.query(`SET search_path TO ${this.escapeIdentifier(schema)}`);
+            }
+            catch (error) {
+                release();
+                throw new Error(`Failed to set schema '${schema}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return {
+                client,
+                release,
+                server: serverName,
+                database,
+                schema,
+                context: serverConfig.context,
+                isOverride: override.schema !== undefined &&
+                    override.schema !== this.connectionState.currentSchema,
+            };
+        }
+        // Get or create cached pool for the override connection
+        // This handles concurrent requests efficiently
+        const cached = await this.getOrCreateCachedPool(serverName, database, serverConfig);
+        const { client, release } = await this.acquireCachedPoolClient(cached);
+        try {
+            await client.query(`SET search_path TO ${this.escapeIdentifier(schema)}`);
+        }
+        catch (error) {
+            release();
+            throw new Error(`Failed to set schema '${schema}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            client,
+            release,
+            server: serverName,
+            database,
+            schema,
+            context: serverConfig.context,
+            isOverride: true,
+        };
+    }
+    /**
+     * Executes a query with optional connection override.
+     * Convenience method that handles client lifecycle automatically.
+     *
+     * @param sql - SQL query to execute
+     * @param params - Query parameters
+     * @param override - Optional connection override parameters
+     * @returns Query result with connection info
+     */
+    async queryWithOverride(sql, params, override) {
+        if (!sql || typeof sql !== "string") {
+            throw new Error("SQL query is required and must be a string");
+        }
+        // Check for read-only mode violations
+        if (this.readOnlyMode) {
+            const { isReadOnly, reason } = isReadOnlySql(sql);
+            if (!isReadOnly) {
+                throw new Error(`Read-only mode violation: ${reason}`);
+            }
+        }
+        const { client, release, server, database, schema } = await this.getClientWithOverride(override);
+        try {
+            const result = await client.query(sql, params);
+            return {
+                ...result,
+                connectionInfo: { server, database, schema },
+            };
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Escapes a PostgreSQL identifier to prevent SQL injection
+     */
+    escapeIdentifier(identifier) {
+        // Double any double quotes and wrap in double quotes
+        return `"${identifier.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Closes all cached pools and cleans up resources
+     */
+    async closeAllCachedPools() {
+        const closePromises = [];
+        for (const [key, cached] of this.poolCache.entries()) {
+            closePromises.push(cached.pool.end().catch((err) => {
+                console.error(`Error closing pool ${key}:`, err);
+            }));
+        }
+        await Promise.all(closePromises);
+        this.poolCache.clear();
+    }
+    /**
+     * Gets comprehensive statistics about all connection pools (for monitoring/debugging)
+     */
+    getConnectionStats() {
+        const now = Date.now();
+        const pools = Array.from(this.poolCache.entries()).map(([key, cached]) => ({
+            key,
+            serverName: cached.serverName,
+            database: cached.database,
+            activeConnections: cached.activeConnections,
+            maxSize: MAX_POOL_SIZE_CACHED,
+            lastUsed: new Date(cached.lastUsed),
+            createdAt: new Date(cached.createdAt),
+            idleTimeRemaining: Math.max(0, POOL_IDLE_TIMEOUT_MS - (now - cached.lastUsed)),
+        }));
+        const cachedPoolsTotalActive = Array.from(this.poolCache.values()).reduce((sum, cached) => sum + cached.activeConnections, 0);
+        return {
+            totalActiveConnections: this.totalActiveConnections,
+            maxTotalConnections: MAX_TOTAL_CONNECTIONS,
+            mainPool: {
+                activeConnections: this.mainPoolActiveConnections,
+                maxSize: MAX_POOL_SIZE_MAIN,
+                isConnected: this.currentPool !== null,
+            },
+            cachedPools: {
+                count: this.poolCache.size,
+                maxCount: MAX_CACHED_POOLS,
+                totalActiveConnections: cachedPoolsTotalActive,
+                pools,
+            },
+            pendingPoolCreations: this.poolCreationPromises.size,
+        };
+    }
+    /**
+     * @deprecated Use getConnectionStats() instead
+     * Gets statistics about cached pools (for monitoring/debugging)
+     */
+    getCachedPoolStats() {
+        const pools = Array.from(this.poolCache.entries()).map(([key, cached]) => ({
+            key,
+            serverName: cached.serverName,
+            database: cached.database,
+            lastUsed: new Date(cached.lastUsed),
+            createdAt: new Date(cached.createdAt),
+        }));
+        return {
+            count: this.poolCache.size,
+            maxSize: MAX_CACHED_POOLS,
+            pools,
+        };
+    }
     async close() {
+        // Stop cleanup intervals
+        if (this.poolCleanupInterval) {
+            clearInterval(this.poolCleanupInterval);
+            this.poolCleanupInterval = null;
+        }
+        if (this.transactionCleanupInterval) {
+            clearInterval(this.transactionCleanupInterval);
+            this.transactionCleanupInterval = null;
+        }
+        // Roll back and release all active transactions
+        for (const [transactionId, transaction,] of this.activeTransactions.entries()) {
+            try {
+                await transaction.client.query("ROLLBACK");
+            }
+            catch (err) {
+                console.error(`Error rolling back transaction ${transactionId} during close:`, err);
+            }
+            finally {
+                transaction.client.release();
+            }
+        }
+        this.activeTransactions.clear();
+        // Close all cached pools
+        await this.closeAllCachedPools();
+        // Close main pool
         if (this.currentPool) {
             await this.currentPool.end();
             this.currentPool = null;
@@ -413,6 +954,8 @@ export class DatabaseManager {
             "no connection to the server",
             "server conn crashed",
             "database removed",
+            "timed out",
+            "idle",
         ];
         // Check error codes
         const connectionErrorCodes = [
@@ -534,19 +1077,39 @@ export class DatabaseManager {
         return transaction.client.query(sql, params);
     }
     /**
-     * Gets information about an active transaction
+     * Gets information about an active transaction, including time remaining.
+     *
+     * @param transactionId - The transaction ID
+     * @returns Transaction info with age and time remaining, or null if not found
      */
     getTransactionInfo(transactionId) {
         const transaction = this.activeTransactions.get(transactionId);
-        return transaction ? { ...transaction.info } : null;
+        if (!transaction)
+            return null;
+        const ageMs = Date.now() - transaction.info.startedAt.getTime();
+        const timeRemainingMs = Math.max(0, TRANSACTION_CLEANUP_TIMEOUT_MS - ageMs);
+        return {
+            ...transaction.info,
+            ageMs,
+            timeRemainingMs,
+        };
     }
     /**
-     * Lists all active transactions
+     * Lists all active transactions with age and time remaining.
+     *
+     * @returns Array of transaction info objects with age and time remaining
      */
     listActiveTransactions() {
-        return Array.from(this.activeTransactions.values()).map((t) => ({
-            ...t.info,
-        }));
+        const now = Date.now();
+        return Array.from(this.activeTransactions.values()).map((t) => {
+            const ageMs = now - t.info.startedAt.getTime();
+            const timeRemainingMs = Math.max(0, TRANSACTION_CLEANUP_TIMEOUT_MS - ageMs);
+            return {
+                ...t.info,
+                ageMs,
+                timeRemainingMs,
+            };
+        });
     }
 }
 // Singleton instance