spindb 0.37.2 → 0.38.0

package/dist/engines/questdb/index.js

@@ -0,0 +1,814 @@
+/**
+ * QuestDB Engine Implementation
+ *
+ * QuestDB is a high-performance time-series database with built-in support for
+ * SQL queries via PostgreSQL wire protocol.
+ *
+ * Key characteristics:
+ * - Default PostgreSQL wire protocol port: 8812
+ * - Default HTTP port: 9000 (REST API and Web Console)
+ * - Default ILP (InfluxDB Line Protocol) port: 9009
+ * - Java-based with bundled JRE (no Java installation required)
+ * - Startup script: questdb.sh (Unix) or questdb.exe (Windows)
+ * - Default database: qdb (root database)
+ * - Default user: admin (password: quest)
+ * - Query language: SQL (with time-series extensions)
+ * - Web Console at http://localhost:9000
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { mkdir, writeFile, readFile, unlink, readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { BaseEngine } from '../base-engine.js';
+import { paths } from '../../config/paths.js';
+import { getEngineDefaults } from '../../config/defaults.js';
+import { platformService } from '../../core/platform-service.js';
+import { configManager } from '../../core/config-manager.js';
+import { logDebug, logWarning } from '../../core/error-handler.js';
+import { findBinary } from '../../core/dependency-manager.js';
+import { processManager } from '../../core/process-manager.js';
+import { questdbBinaryManager } from './binary-manager.js';
+import { getBinaryUrl } from './binary-urls.js';
+import { normalizeVersion, SUPPORTED_MAJOR_VERSIONS, QUESTDB_VERSION_MAP, } from './version-maps.js';
+import { fetchAvailableVersions as fetchHostdbVersions } from './hostdb-releases.js';
+import { detectBackupFormat as detectBackupFormatImpl, restoreBackup, parseConnectionString, } from './restore.js';
+import { createBackup } from './backup.js';
+import { parseCSVToQueryResult } from '../../core/query-parser.js';
+const ENGINE = 'questdb';
+const engineDef = getEngineDefaults(ENGINE);
+export class QuestDBEngine extends BaseEngine {
+    name = ENGINE;
+    displayName = 'QuestDB';
+    defaultPort = engineDef.defaultPort;
+    supportedVersions = SUPPORTED_MAJOR_VERSIONS;
+    // Get platform info for binary operations
+    getPlatformInfo() {
+        return platformService.getPlatformInfo();
+    }
+    // Fetch available versions from hostdb (dynamically or from cache/fallback)
+    async fetchAvailableVersions() {
+        return fetchHostdbVersions();
+    }
+    // Get binary download URL from hostdb
+    getBinaryUrl(version, platform, arch) {
+        return getBinaryUrl(version, platform, arch);
+    }
+    // Resolves version string to full version (e.g., '9' -> '9.2.3')
+    resolveFullVersion(version) {
+        if (/^\d+\.\d+\.\d+$/.test(version)) {
+            return version;
+        }
+        return QUESTDB_VERSION_MAP[version] || version;
+    }
+    // Get the path where binaries for a version would be installed
+    getBinaryPath(version) {
+        const fullVersion = this.resolveFullVersion(version);
+        const { platform: p, arch: a } = this.getPlatformInfo();
+        return paths.getBinaryPath({
+            engine: 'questdb',
+            version: fullVersion,
+            platform: p,
+            arch: a,
+        });
+    }
+    // Verify that QuestDB binaries are available
+    async verifyBinary(binPath) {
+        // Check both root and bin/ subdirectory (structure differs by platform)
+        const { platform } = this.getPlatformInfo();
+        if (platform === 'win32') {
+            const exePathRoot = join(binPath, 'questdb.exe');
+            const exePathBin = join(binPath, 'bin', 'questdb.exe');
+            return existsSync(exePathRoot) || existsSync(exePathBin);
+        }
+        else {
+            const shPathRoot = join(binPath, 'questdb.sh');
+            const shPathBin = join(binPath, 'bin', 'questdb.sh');
+            return existsSync(shPathRoot) || existsSync(shPathBin);
+        }
+    }
+    // Check if a specific QuestDB version is installed (downloaded)
+    async isBinaryInstalled(version) {
+        const { platform, arch } = this.getPlatformInfo();
+        return questdbBinaryManager.isInstalled(version, platform, arch);
+    }
+    /**
+     * Ensure QuestDB binaries are available for a specific version
+     * Downloads from hostdb if not already installed
+     * Returns the path to the installation directory
+     */
+    async ensureBinaries(version, onProgress) {
+        const { platform, arch } = this.getPlatformInfo();
+        const binPath = await questdbBinaryManager.ensureInstalled(version, platform, arch, onProgress);
+        // Ensure startup script is executable
+        await questdbBinaryManager.postExtract(binPath, platform);
+        // Register the startup script in config
+        // Register the startup script in config - check both locations
+        if (platform === 'win32') {
+            const exePathRoot = join(binPath, 'questdb.exe');
+            const exePathBin = join(binPath, 'bin', 'questdb.exe');
+            const exePath = existsSync(exePathRoot) ? exePathRoot : exePathBin;
+            if (existsSync(exePath)) {
+                await configManager.setBinaryPath('questdb', exePath, 'bundled');
+            }
+        }
+        else {
+            const shPathRoot = join(binPath, 'questdb.sh');
+            const shPathBin = join(binPath, 'bin', 'questdb.sh');
+            const shPath = existsSync(shPathRoot) ? shPathRoot : shPathBin;
+            if (existsSync(shPath)) {
+                await configManager.setBinaryPath('questdb', shPath, 'bundled');
+            }
+        }
+        return binPath;
+    }
+    /**
+     * Initialize a new QuestDB data directory
+     */
+    async initDataDir(containerName, _version, _options = {}) {
+        const dataDir = paths.getContainerDataPath(containerName, {
+            engine: ENGINE,
+        });
+        // Create data directory
+        await mkdir(dataDir, { recursive: true });
+        logDebug(`Created QuestDB data directory: ${dataDir}`);
+        return dataDir;
+    }
+    // Get the path to QuestDB startup script for a version
+    async getQuestDBPath(version) {
+        const { platform, arch } = this.getPlatformInfo();
+        const fullVersion = normalizeVersion(version);
+        const binPath = paths.getBinaryPath({
+            engine: 'questdb',
+            version: fullVersion,
+            platform,
+            arch,
+        });
+        // Check both root and bin/ subdirectory (structure differs by platform)
+        if (platform === 'win32') {
+            const exePathRoot = join(binPath, 'questdb.exe');
+            const exePathBin = join(binPath, 'bin', 'questdb.exe');
+            if (existsSync(exePathRoot))
+                return exePathRoot;
+            if (existsSync(exePathBin))
+                return exePathBin;
+        }
+        else {
+            const shPathRoot = join(binPath, 'questdb.sh');
+            const shPathBin = join(binPath, 'bin', 'questdb.sh');
+            if (existsSync(shPathRoot))
+                return shPathRoot;
+            if (existsSync(shPathBin))
+                return shPathBin;
+        }
+        throw new Error(`QuestDB ${version} is not installed. Run: spindb engines download questdb ${version}`);
+    }
+    /**
+     * Start QuestDB server
+     */
+    async start(container, onProgress) {
+        const { name, port, version, binaryPath } = container;
+        // Check if already running
+        const alreadyRunning = await processManager.isRunning(name, {
+            engine: ENGINE,
+        });
+        if (alreadyRunning) {
+            return {
+                port,
+                connectionString: this.getConnectionString(container),
+            };
+        }
+        // Get QuestDB binary path - check both root and bin/ subdirectory
+        let questdbBinary = null;
+        const { platform } = this.getPlatformInfo();
+        if (binaryPath && existsSync(binaryPath)) {
+            if (platform === 'win32') {
+                const exePathRoot = join(binaryPath, 'questdb.exe');
+                const exePathBin = join(binaryPath, 'bin', 'questdb.exe');
+                if (existsSync(exePathRoot)) {
+                    questdbBinary = exePathRoot;
+                    logDebug(`Using stored binary path: ${questdbBinary}`);
+                }
+                else if (existsSync(exePathBin)) {
+                    questdbBinary = exePathBin;
+                    logDebug(`Using stored binary path (bin/): ${questdbBinary}`);
+                }
+            }
+            else {
+                const shPathRoot = join(binaryPath, 'questdb.sh');
+                const shPathBin = join(binaryPath, 'bin', 'questdb.sh');
+                if (existsSync(shPathRoot)) {
+                    questdbBinary = shPathRoot;
+                    logDebug(`Using stored binary path: ${questdbBinary}`);
+                }
+                else if (existsSync(shPathBin)) {
+                    questdbBinary = shPathBin;
+                    logDebug(`Using stored binary path (bin/): ${questdbBinary}`);
+                }
+            }
+        }
+        if (!questdbBinary) {
+            try {
+                questdbBinary = await this.getQuestDBPath(version);
+            }
+            catch (error) {
+                const originalMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`QuestDB ${version} is not installed. Run: spindb engines download questdb ${version}\n` +
+                    `  Original error: ${originalMessage}`);
+            }
+        }
+        const containerDir = paths.getContainerPath(name, { engine: ENGINE });
+        const dataDir = paths.getContainerDataPath(name, { engine: ENGINE });
+        const pidFile = join(containerDir, 'questdb.pid');
+        // Calculate HTTP port (default is PG port + 188, i.e., 8812 + 188 = 9000)
+        const httpPort = port + 188;
+        onProgress?.({ stage: 'starting', message: 'Starting QuestDB...' });
+        logDebug(`Starting QuestDB with data dir: ${dataDir}`);
+        const isWindows = platform === 'win32';
+        // QuestDB startup command
+        // Windows: questdb.exe doesn't support 'start' subcommand reliably (GitHub #1222)
+        //          Run without 'start' command - it starts in interactive/foreground mode
+        // Unix: questdb.sh start -d ... -t ... -n daemonizes properly
+        // -t tag: Unique process tag allows multiple QuestDB instances to run simultaneously
+        //         Without this, QuestDB detects other instances by process label and refuses to start
+        const args = isWindows
+            ? ['-d', dataDir, '-t', name] // Windows: no 'start' command, no '-n' flag
+            : ['start', '-d', dataDir, '-t', name, '-n']; // Unix: full daemon mode
+        // Environment variables for QuestDB configuration
+        // Note: Don't set QDB_LOG_W_FILE_LOCATION - QuestDB expects rolling log patterns with $
+        // Logs are written to dataDir/log/ by default
+        //
+        // Port offsets from base PostgreSQL port:
+        // - HTTP Server: +188 (default 9000)
+        // - HTTP Min Server: +191 (default 9003) - for health checks/metrics
+        // - ILP TCP: +197 (default 9009)
+        const env = {
+            ...process.env,
+            QDB_HTTP_BIND_TO: `0.0.0.0:${httpPort}`,
+            QDB_HTTP_MIN_NET_BIND_TO: `0.0.0.0:${port + 191}`, // HTTP Min Server (health/metrics)
+            QDB_PG_NET_BIND_TO: `0.0.0.0:${port}`,
+            QDB_LINE_TCP_NET_BIND_TO: `0.0.0.0:${port + 197}`, // ILP port
+        };
+        // IMPORTANT: Use 'ignore' for all stdio to prevent hanging
+        // QuestDB runs as a daemon and we don't want to keep file descriptors open
+        const spawnOptions = {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            detached: true,
+            cwd: containerDir,
+            env,
+            windowsHide: true,
+        };
+        logDebug(`Spawning QuestDB: ${questdbBinary} ${args.join(' ')}`);
+        const proc = spawn(questdbBinary, args, spawnOptions);
+        // Allow the process to detach immediately
+        // Note: We don't write the PID file here because questdb.sh forks the Java
+        // process and exits. The shell's PID becomes invalid immediately.
+        // QuestDB writes its own PID file to {dataDir}/questdb.pid which we'll
+        // read after waiting for the server to be ready.
+        proc.unref();
+        // Wait for server to be ready
+        const timeout = isWindows ? 90000 : 60000;
+        logDebug(`Waiting for QuestDB to be ready on port ${port}... (timeout: ${timeout}ms)`);
+        // Give QuestDB a moment to start before checking
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const ready = await this.waitForReady(port, version, timeout);
+        logDebug(`waitForReady returned: ${ready}`);
+        if (!ready) {
+            // Clean up on failure - try to find and kill the QuestDB process by port
+            try {
+                const pids = await platformService.findProcessByPort(port);
+                if (pids.length > 0) {
+                    logDebug(`Cleaning up failed QuestDB process (pid: ${pids[0]})`);
+                    await platformService.terminateProcess(pids[0], true);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw new Error(`QuestDB failed to start within timeout. Check logs at: ${dataDir}/log/`);
+        }
+        // QuestDB is ready - find the actual Java process PID by port
+        // QuestDB doesn't create a PID file in daemon mode, so we find the process by port
+        try {
+            const pids = await platformService.findProcessByPort(port);
+            if (pids.length > 0) {
+                const actualPid = pids[0];
+                await writeFile(pidFile, actualPid.toString(), 'utf-8');
+                logDebug(`Wrote PID file: ${pidFile} (pid: ${actualPid})`);
+            }
+            else {
+                logDebug('Could not find QuestDB process by port - PID file not created');
+            }
+        }
+        catch (err) {
+            logDebug(`Could not find QuestDB PID: ${err instanceof Error ? err.message : String(err)}`);
+            // Don't fail - QuestDB is running, we just can't track its PID
+        }
+        return {
+            port,
+            connectionString: this.getConnectionString(container),
+        };
+    }
+    // Wait for QuestDB to be ready using psql
+    async waitForReady(port, version, timeoutMs = 60000) {
+        logDebug(`waitForReady called for port ${port}`);
+        const startTime = Date.now();
+        const checkInterval = 500;
+        // Try to find psql for connection checking
+        let psqlPath = await configManager.getBinaryPath('psql');
+        if (!psqlPath) {
+            // Try system psql
+            try {
+                const result = await findBinary('psql');
+                if (result?.path) {
+                    psqlPath = result.path;
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // If no psql, try HTTP health check instead
+        if (!psqlPath) {
+            logDebug('psql not found, using HTTP health check');
+            return this.waitForReadyHttp(port + 188, timeoutMs);
+        }
+        let attempt = 0;
+        while (Date.now() - startTime < timeoutMs) {
+            attempt++;
+            logDebug(`Connection attempt ${attempt}...`);
+            try {
+                await new Promise((resolve, reject) => {
+                    const proc = spawn(psqlPath, [
+                        '-h',
+                        '127.0.0.1',
+                        '-p',
+                        String(port),
+                        '-U',
+                        'admin',
+                        '-d',
+                        'qdb',
+                        '-c',
+                        'SELECT 1;',
+                    ], {
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        env: { ...process.env, PGPASSWORD: 'quest' },
+                    });
+                    proc.on('close', (code) => {
+                        if (code === 0)
+                            resolve();
+                        else
+                            reject(new Error(`Exit code ${code}`));
+                    });
+                    proc.on('error', reject);
+                });
+                logDebug(`QuestDB ready on port ${port}`);
+                return true;
+            }
+            catch (err) {
+                logDebug(`Attempt ${attempt} failed: ${err}`);
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+        }
+        logWarning(`QuestDB did not become ready within ${timeoutMs}ms`);
+        return false;
+    }
+    // Fallback: wait using HTTP health check
+    async waitForReadyHttp(httpPort, timeoutMs) {
+        const startTime = Date.now();
+        const checkInterval = 500;
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                const response = await fetch(`http://127.0.0.1:${httpPort}/exec?query=SELECT%201`);
+                if (response.ok) {
+                    logDebug(`QuestDB HTTP ready on port ${httpPort}`);
+                    return true;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        }
+        return false;
+    }
+    /**
+     * Stop QuestDB server
+     */
+    async stop(container) {
+        const { name, port } = container;
+        const containerDir = paths.getContainerPath(name, { engine: ENGINE });
+        const pidFile = join(containerDir, 'questdb.pid');
+        logDebug(`Stopping QuestDB container "${name}" on port ${port}`);
+        // Try to find process by port first (most reliable)
+        // QuestDB doesn't create a PID file, so port lookup is primary
+        let pid = null;
+        try {
+            const pids = await platformService.findProcessByPort(port);
+            if (pids.length > 0) {
+                pid = pids[0];
+            }
+        }
+        catch {
+            // Fall back to our PID file
+            try {
+                const pidStr = await readFile(pidFile, 'utf-8');
+                const parsedPid = parseInt(pidStr.trim(), 10);
+                if (!isNaN(parsedPid)) {
+                    pid = parsedPid;
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // Kill process if found
+        if (pid && platformService.isProcessRunning(pid)) {
+            logDebug(`Killing QuestDB process ${pid}`);
+            const { platform } = this.getPlatformInfo();
+            const isWindows = platform === 'win32';
+            try {
+                await platformService.terminateProcess(pid, false);
+                // Wait for graceful termination - Windows needs more time for Java to release file locks
+                const gracefulWait = isWindows ? 5000 : 2000;
+                await new Promise((resolve) => setTimeout(resolve, gracefulWait));
+                if (platformService.isProcessRunning(pid)) {
+                    logWarning(`Graceful termination failed, force killing ${pid}`);
+                    await platformService.terminateProcess(pid, true);
+                    // Additional wait after force kill on Windows
+                    if (isWindows) {
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                    }
+                }
+            }
+            catch (error) {
+                logDebug(`Process termination error: ${error}`);
+            }
+        }
+        // Cleanup our PID file
+        if (existsSync(pidFile)) {
+            try {
+                await unlink(pidFile);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        logDebug('QuestDB stopped');
+    }
+    // Get QuestDB server status
+    async status(container) {
+        const { port } = container;
+        // Try HTTP health check first
+        const httpPort = port + 188;
+        try {
+            const response = await fetch(`http://127.0.0.1:${httpPort}/exec?query=SELECT%201`);
+            if (response.ok) {
+                return { running: true, message: 'QuestDB is running' };
+            }
+        }
+        catch {
+            // Not running or not responding
+        }
+        return { running: false, message: 'QuestDB is not running' };
+    }
+    // Detect backup format
+    async detectBackupFormat(filePath) {
+        return detectBackupFormatImpl(filePath);
+    }
+    /**
+     * Restore a backup
+     */
+    async restore(container, backupPath, options = {}) {
+        const { name, port, version } = container;
+        return restoreBackup(backupPath, {
+            containerName: name,
+            port,
+            database: options.database || container.database || 'qdb',
+            version,
+            clean: options.clean,
+        });
+    }
+    /**
+     * Get connection string
+     * Format: postgresql://admin:quest@127.0.0.1:PORT/DATABASE
+     */
+    getConnectionString(container, database) {
+        const { port } = container;
+        const db = database || container.database || 'qdb';
+        return `postgresql://admin:quest@127.0.0.1:${port}/${db}`;
+    }
+    // Open psql interactive shell
+    async connect(container, database) {
+        const { port } = container;
+        const db = database || container.database || 'qdb';
+        // Find psql
+        let psqlPath = await configManager.getBinaryPath('psql');
+        if (!psqlPath) {
+            const result = await findBinary('psql');
+            if (result?.path) {
+                psqlPath = result.path;
+            }
+            else {
+                throw new Error('psql not found. Install PostgreSQL client tools or use the Web Console at ' +
+                    `http://127.0.0.1:${port + 188}`);
+            }
+        }
+        const spawnOptions = {
+            stdio: 'inherit',
+            env: { ...process.env, PGPASSWORD: 'quest' },
+        };
+        return new Promise((resolve, reject) => {
+            const proc = spawn(psqlPath, ['-h', '127.0.0.1', '-p', String(port), '-U', 'admin', '-d', db], spawnOptions);
+            proc.on('error', reject);
+            proc.on('close', () => resolve());
+        });
+    }
+    /**
+     * Create a new database
+     * Note: QuestDB has a single-database model but supports schemas
+     */
+    async createDatabase(container, database) {
+        logDebug(`QuestDB uses a single-database model. Database "${database}" will be a schema.`);
+        // QuestDB doesn't have traditional CREATE DATABASE
+        // All tables exist in the default database
+    }
+    /**
+     * Drop a database (schema in QuestDB)
+     */
+    async dropDatabase(container, database) {
+        logDebug(`QuestDB uses a single-database model. Cannot drop database "${database}".`);
+    }
+    /**
+     * Get the database size
+     */
+    async getDatabaseSize(container) {
+        const dataDir = paths.getContainerDataPath(container.name, {
+            engine: ENGINE,
+        });
+        if (!existsSync(dataDir))
+            return null;
+        try {
+            let totalSize = 0;
+            const entries = await readdir(dataDir, {
+                withFileTypes: true,
+                recursive: true,
+            });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    const filePath = join(entry.parentPath ?? dataDir, entry.name);
+                    const stats = await stat(filePath);
+                    totalSize += stats.size;
+                }
+            }
+            return totalSize;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Dump from a remote QuestDB connection
+     */
+    async dumpFromConnectionString(connectionString, outputPath) {
+        const { host, port, database, user, password } = parseConnectionString(connectionString);
+        logDebug(`Connecting to remote QuestDB at ${host}:${port} (db: ${database})`);
+        // Find psql for remote operations
+        let psqlPath = await configManager.getBinaryPath('psql');
+        if (!psqlPath) {
+            const result = await findBinary('psql');
+            if (result?.path) {
+                psqlPath = result.path;
+            }
+            else {
+                throw new Error('psql not found. Install PostgreSQL client tools to dump from remote QuestDB.');
+            }
+        }
+        const lines = [];
+        lines.push('-- QuestDB backup generated by SpinDB');
+        lines.push(`-- Source: ${host}:${port}`);
+        lines.push(`-- Database: ${database}`);
+        lines.push(`-- Date: ${new Date().toISOString()}`);
+        lines.push('');
+        // Get list of tables
+        const tablesQuery = `SELECT table_name FROM tables() WHERE table_name NOT LIKE 'sys.%'`;
+        const tablesResult = await this.execRemoteQuery(psqlPath, host, port, user, password ?? '', database, tablesQuery);
+        const tables = tablesResult.split('\n').filter((t) => t.trim());
+        logDebug(`Found ${tables.length} tables`);
+        for (const table of tables) {
+            if (!table.trim())
+                continue;
+            lines.push(`-- Table: ${table}`);
+            lines.push('');
+            try {
+                const createQuery = `SHOW CREATE TABLE "${table}"`;
+                const createResult = await this.execRemoteQuery(psqlPath, host, port, user, password ?? '', database, createQuery);
+                if (createResult) {
+                    lines.push(createResult + ';');
+                    lines.push('');
+                }
+            }
+            catch (error) {
+                logWarning(`Could not get CREATE TABLE for ${table}: ${error}`);
+            }
+        }
+        const content = lines.join('\n');
+        await writeFile(outputPath, content, 'utf-8');
+        return {
+            filePath: outputPath,
+            warnings: tables.length === 0 ? ['No tables found in database'] : undefined,
+        };
+    }
+    async execRemoteQuery(psqlPath, host, port, user, password, database, query) {
+        return new Promise((resolve, reject) => {
+            const args = [
+                '-h',
+                host,
+                '-p',
+                String(port),
+                '-U',
+                user,
+                '-d',
+                database,
+                '-t',
+                '-A',
+                '-c',
+                query,
+            ];
+            const proc = spawn(psqlPath, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, PGPASSWORD: password },
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout.trim());
+                }
+                else {
+                    reject(new Error(stderr || `Exit code ${code}`));
+                }
+            });
+            proc.on('error', reject);
+        });
+    }
+    // Create a backup
+    async backup(container, outputPath, options) {
+        return createBackup(container, outputPath, options);
+    }
+    // Run a SQL file or inline SQL statement
+    async runScript(container, options) {
+        const { port } = container;
+        const db = options.database || container.database || 'qdb';
+        // Find psql
+        let psqlPath = await configManager.getBinaryPath('psql');
+        if (!psqlPath) {
+            const result = await findBinary('psql');
+            if (result?.path) {
+                psqlPath = result.path;
+            }
+            else {
+                throw new Error('psql not found. Install PostgreSQL client tools.');
+            }
+        }
+        if (options.file) {
+            // Run SQL file
+            const args = [
+                '-h',
+                '127.0.0.1',
+                '-p',
+                String(port),
+                '-U',
+                'admin',
+                '-d',
+                db,
+                '-f',
+                options.file,
+            ];
+            await new Promise((resolve, reject) => {
+                const proc = spawn(psqlPath, args, {
+                    stdio: 'inherit',
+                    env: { ...process.env, PGPASSWORD: 'quest' },
+                });
+                proc.on('error', reject);
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`psql exited with code ${code}`));
+                    }
+                });
+            });
+        }
+        else if (options.sql) {
+            // Run inline SQL
+            const args = [
+                '-h',
+                '127.0.0.1',
+                '-p',
+                String(port),
+                '-U',
+                'admin',
+                '-d',
+                db,
+                '-c',
+                options.sql,
+            ];
+            await new Promise((resolve, reject) => {
+                const proc = spawn(psqlPath, args, {
+                    stdio: 'inherit',
+                    env: { ...process.env, PGPASSWORD: 'quest' },
+                });
+                proc.on('error', reject);
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`psql exited with code ${code}`));
+                    }
+                });
+            });
+        }
+        else {
+            throw new Error('Either file or sql option must be provided');
+        }
+    }
+    /**
+     * Execute a SQL query and return structured results
+     * Uses PostgreSQL wire protocol via psql
+     */
+    async executeQuery(container, query, options) {
+        const { port } = container;
+        const db = options?.database || container.database || 'qdb';
+        // Find psql
+        let psqlPath = await configManager.getBinaryPath('psql');
+        if (!psqlPath) {
+            const result = await findBinary('psql');
+            if (result?.path) {
+                psqlPath = result.path;
+            }
+            else {
+                throw new Error('psql not found. Install PostgreSQL client tools or use the Web Console.');
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const args = [
+                '-X', // Skip ~/.psqlrc to ensure deterministic CSV output
+                '-h',
+                '127.0.0.1',
+                '-p',
+                String(port),
+                '-U',
+                'admin',
+                '-d',
+                db,
+                '--csv',
+                '-c',
+                query,
+            ];
+            const proc = spawn(psqlPath, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, PGPASSWORD: 'quest' },
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('error', reject);
+            proc.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(stderr || `psql exited with code ${code}`));
+                    return;
+                }
+                try {
+                    resolve(parseCSVToQueryResult(stdout));
+                }
+                catch (error) {
+                    reject(new Error(`Failed to parse query result: ${error instanceof Error ? error.message : error}`));
+                }
+            });
+        });
+    }
+    /**
+     * List databases for QuestDB.
+     * QuestDB has a single database 'qdb'. Returns the configured database.
+     */
+    async listDatabases(container) {
+        // QuestDB has a single database 'qdb'
+        // Return the container's configured database
+        return [container.database];
+    }
+}
+export const questdbEngine = new QuestDBEngine();
+//# sourceMappingURL=index.js.map