spindb 0.37.2 → 0.38.0

package/dist/engines/influxdb/index.js

@@ -0,0 +1,962 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { mkdir, writeFile, readFile, unlink } 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, isWindows } from '../../core/platform-service.js';
+import { configManager } from '../../core/config-manager.js';
+import { logDebug, logWarning } from '../../core/error-handler.js';
+import { processManager } from '../../core/process-manager.js';
+import { portManager } from '../../core/port-manager.js';
+import { influxdbBinaryManager } from './binary-manager.js';
+import { getBinaryUrl } from './binary-urls.js';
+import { normalizeVersion, SUPPORTED_MAJOR_VERSIONS } from './version-maps.js';
+import { fetchAvailableVersions as fetchHostdbVersions } from './hostdb-releases.js';
+import { detectBackupFormat as detectBackupFormatImpl, restoreBackup, } from './restore.js';
+import { createBackup } from './backup.js';
+import { influxdbApiRequest } from './api-client.js';
+import { parseRESTAPIResult } from '../../core/query-parser.js';
+const ENGINE = 'influxdb';
+const engineDef = getEngineDefaults(ENGINE);
+/**
+ * Initial delay before checking if InfluxDB is ready after spawning.
+ * Windows requires a longer delay as process startup is slower.
+ */
+const START_CHECK_DELAY_MS = isWindows() ? 2000 : 500;
+/**
+ * Parse an InfluxDB connection string
+ * Supported formats:
+ * - http://host:port
+ * - https://host:port
+ * - influxdb://host:port (converted to http)
+ */
+function parseInfluxDBConnectionString(connectionString) {
+    let url;
+    let scheme = 'http';
+    // Handle influxdb:// scheme by converting to http://
+    let normalized = connectionString.trim();
+    if (normalized.startsWith('influxdb://')) {
+        normalized = normalized.replace('influxdb://', 'http://');
+    }
+    // Ensure scheme is present
+    if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
+        normalized = `http://${normalized}`;
+    }
+    try {
+        url = new URL(normalized);
+        scheme = url.protocol.replace(':', '');
+    }
+    catch {
+        throw new Error(`Invalid InfluxDB connection string: ${connectionString}\n` +
+            'Expected format: http://host:port or influxdb://host:port');
+    }
+    // Extract token if provided
+    const token = url.searchParams.get('token');
+    const database = url.searchParams.get('db') || undefined;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    // Construct base URL without query params
+    const port = url.port || '8086';
+    const baseUrl = `${scheme}://${url.hostname}:${port}`;
+    return { baseUrl, headers, database };
+}
+/**
+ * Make an HTTP request to a remote InfluxDB server
+ */
+async function remoteInfluxDBRequest(baseUrl, method, path, headers, body, timeoutMs = 30000) {
+    const url = `${baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const options = {
+        method,
+        headers,
+        signal: controller.signal,
+    };
+    if (body) {
+        options.body = JSON.stringify(body);
+    }
+    try {
+        const response = await fetch(url, options);
+        let data;
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            data = await response.json();
+        }
+        else {
+            data = await response.text();
+        }
+        return { status: response.status, data };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Remote InfluxDB request timed out after ${timeoutMs / 1000}s: ${method} ${path}`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export class InfluxDBEngine extends BaseEngine {
+    name = ENGINE;
+    displayName = 'InfluxDB';
+    defaultPort = engineDef.defaultPort;
+    supportedVersions = SUPPORTED_MAJOR_VERSIONS;
+    // Get platform info for binary operations
+    getPlatformInfo() {
+        return platformService.getPlatformInfo();
+    }
+    // Fetch available versions from hostdb
+    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., '3' -> '3.8.0')
+    resolveFullVersion(version) {
+        return normalizeVersion(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: 'influxdb',
+            version: fullVersion,
+            platform: p,
+            arch: a,
+        });
+    }
+    // Verify that InfluxDB binaries are available
+    async verifyBinary(binPath) {
+        const ext = platformService.getExecutableExtension();
+        const serverPath = join(binPath, 'bin', `influxdb3${ext}`);
+        return existsSync(serverPath);
+    }
+    // Check if a specific InfluxDB version is installed
+    async isBinaryInstalled(version) {
+        const { platform, arch } = this.getPlatformInfo();
+        return influxdbBinaryManager.isInstalled(version, platform, arch);
+    }
+    /**
+     * Ensure InfluxDB binaries are available for a specific version
+     * Downloads from hostdb if not already installed
+     * Returns the path to the bin directory
+     */
+    async ensureBinaries(version, onProgress) {
+        const { platform, arch } = this.getPlatformInfo();
+        const binPath = await influxdbBinaryManager.ensureInstalled(version, platform, arch, onProgress);
+        // Register binaries in config
+        const ext = platformService.getExecutableExtension();
+        const tools = ['influxdb3'];
+        for (const tool of tools) {
+            const toolPath = join(binPath, 'bin', `${tool}${ext}`);
+            if (existsSync(toolPath)) {
+                await configManager.setBinaryPath(tool, toolPath, 'bundled');
+            }
+        }
+        return binPath;
+    }
+    /**
+     * Initialize a new InfluxDB data directory
+     */
+    async initDataDir(containerName, _version, _options = {}) {
+        const dataDir = paths.getContainerDataPath(containerName, {
+            engine: ENGINE,
+        });
+        const containerDir = paths.getContainerPath(containerName, {
+            engine: ENGINE,
+        });
+        // Create container directory if it doesn't exist
+        if (!existsSync(containerDir)) {
+            await mkdir(containerDir, { recursive: true });
+        }
+        // Create data directory if it doesn't exist
+        if (!existsSync(dataDir)) {
+            await mkdir(dataDir, { recursive: true });
+            logDebug(`Created InfluxDB data directory: ${dataDir}`);
+        }
+        return dataDir;
+    }
+    // Get the path to influxdb3 server for a version
+    async getInfluxDBServerPath(version) {
+        const { platform, arch } = this.getPlatformInfo();
+        const fullVersion = normalizeVersion(version);
+        const binPath = paths.getBinaryPath({
+            engine: 'influxdb',
+            version: fullVersion,
+            platform,
+            arch,
+        });
+        const ext = platformService.getExecutableExtension();
+        const serverPath = join(binPath, 'bin', `influxdb3${ext}`);
+        if (existsSync(serverPath)) {
+            return serverPath;
+        }
+        throw new Error(`InfluxDB ${version} is not installed. Run: spindb engines download influxdb ${version}`);
+    }
+    // Get the path to influxdb3 binary
+    async getInfluxDBPath(version) {
+        // Check config cache first
+        const cached = await configManager.getBinaryPath('influxdb3');
+        if (cached && existsSync(cached)) {
+            return cached;
+        }
+        // If version provided, use downloaded binary
+        if (version) {
+            const { platform, arch } = this.getPlatformInfo();
+            const fullVersion = normalizeVersion(version);
+            const binPath = paths.getBinaryPath({
+                engine: 'influxdb',
+                version: fullVersion,
+                platform,
+                arch,
+            });
+            const ext = platformService.getExecutableExtension();
+            const influxdbPath = join(binPath, 'bin', `influxdb3${ext}`);
+            if (existsSync(influxdbPath)) {
+                return influxdbPath;
+            }
+        }
+        throw new Error('influxdb3 not found. Run: spindb engines download influxdb <version>');
+    }
+    /**
+     * Start InfluxDB server
+     * CLI: influxdb3 serve --data-dir /path/to/data --http-bind 127.0.0.1:PORT
+     */
+    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),
+            };
+        }
+        // Use stored binary path if available
+        let influxdbServer = null;
+        if (binaryPath && existsSync(binaryPath)) {
+            const ext = platformService.getExecutableExtension();
+            const serverPath = join(binaryPath, 'bin', `influxdb3${ext}`);
+            if (existsSync(serverPath)) {
+                influxdbServer = serverPath;
+                logDebug(`Using stored binary path: ${influxdbServer}`);
+            }
+        }
+        // Fall back to normal path
+        if (!influxdbServer) {
+            try {
+                influxdbServer = await this.getInfluxDBServerPath(version);
+            }
+            catch (error) {
+                const originalMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`InfluxDB ${version} is not installed. Run: spindb engines download influxdb ${version}\n` +
+                    `  Original error: ${originalMessage}`);
+            }
+        }
+        logDebug(`Using influxdb3 for version ${version}: ${influxdbServer}`);
+        const containerDir = paths.getContainerPath(name, { engine: ENGINE });
+        const dataDir = paths.getContainerDataPath(name, { engine: ENGINE });
+        const logFile = paths.getContainerLogPath(name, { engine: ENGINE });
+        const pidFile = join(containerDir, 'influxdb.pid');
+        // On Windows, wait longer for ports to be released
+        const portWaitTimeout = isWindows() ? 60000 : 0;
+        const portCheckStart = Date.now();
+        const portCheckInterval = 1000;
+        // Check if HTTP port is available
+        while (!(await portManager.isPortAvailable(port))) {
+            if (Date.now() - portCheckStart >= portWaitTimeout) {
+                throw new Error(`HTTP port ${port} is already in use.`);
+            }
+            logDebug(`Waiting for HTTP port ${port} to become available...`);
+            await new Promise((resolve) => setTimeout(resolve, portCheckInterval));
+        }
+        onProgress?.({ stage: 'starting', message: 'Starting InfluxDB...' });
+        // Build command arguments
+        // InfluxDB 3.x uses 'serve' subcommand with required --node-id
+        // Use fixed node-id so data persists across container renames
+        const args = [
+            'serve',
+            '--node-id',
+            'spindb',
+            '--object-store',
+            'file',
+            '--data-dir',
+            dataDir,
+            '--http-bind',
+            `127.0.0.1:${port}`,
+            '--without-auth',
+        ];
+        logDebug(`Starting influxdb3 with args: ${args.join(' ')}`);
+        /**
+         * Check log file for startup errors
+         */
+        const checkLogForError = async () => {
+            try {
+                const logContent = await readFile(logFile, 'utf-8');
+                const recentLog = logContent.slice(-2000); // Last 2KB
+                if (recentLog.includes('Address already in use') ||
+                    recentLog.includes('bind: Address already in use')) {
+                    return `Port ${port} is already in use`;
+                }
+                if (recentLog.includes('Failed to bind')) {
+                    return `Port ${port} is already in use`;
+                }
+            }
+            catch {
+                // Log file might not exist yet
+            }
+            return null;
+        };
+        // InfluxDB runs in foreground, so we need to spawn detached
+        if (isWindows()) {
+            return new Promise((resolve, reject) => {
+                const spawnOpts = {
+                    cwd: containerDir,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    detached: true,
+                    windowsHide: true,
+                };
+                const proc = spawn(influxdbServer, args, spawnOpts);
+                let settled = false;
+                let stderrOutput = '';
+                let stdoutOutput = '';
+                proc.on('error', (err) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    reject(new Error(`Failed to spawn InfluxDB server: ${err.message}`));
+                });
+                proc.on('exit', (code, signal) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const reason = signal ? `signal ${signal}` : `code ${code}`;
+                    reject(new Error(`InfluxDB process exited unexpectedly (${reason}).\n` +
+                        `Stderr: ${stderrOutput || '(none)'}\n` +
+                        `Stdout: ${stdoutOutput || '(none)'}`));
+                });
+                proc.stdout?.on('data', (data) => {
+                    const str = data.toString();
+                    stdoutOutput += str;
+                    logDebug(`influxdb3 stdout: ${str}`);
+                });
+                proc.stderr?.on('data', (data) => {
+                    const str = data.toString();
+                    stderrOutput += str;
+                    logDebug(`influxdb3 stderr: ${str}`);
+                });
+                proc.unref();
+                setTimeout(async () => {
+                    if (settled)
+                        return;
+                    if (!proc.pid) {
+                        settled = true;
+                        reject(new Error('InfluxDB server process failed to start (no PID)'));
+                        return;
+                    }
+                    try {
+                        await writeFile(pidFile, String(proc.pid));
+                    }
+                    catch {
+                        // Non-fatal
+                    }
+                    const ready = await this.waitForReady(port);
+                    if (settled)
+                        return;
+                    if (ready) {
+                        settled = true;
+                        resolve({
+                            port,
+                            connectionString: this.getConnectionString(container),
+                        });
+                    }
+                    else {
+                        settled = true;
+                        // Clean up the orphaned detached process before rejecting
+                        if (proc.pid && platformService.isProcessRunning(proc.pid)) {
+                            try {
+                                await platformService.terminateProcess(proc.pid, true);
+                            }
+                            catch {
+                                // Ignore cleanup errors
+                            }
+                        }
+                        const portError = await checkLogForError();
+                        const errorDetails = [
+                            portError || 'InfluxDB failed to start within timeout.',
+                            `Binary: ${influxdbServer}`,
+                            `Log file: ${logFile}`,
+                            stderrOutput ? `Stderr:\n${stderrOutput}` : '',
+                            stdoutOutput ? `Stdout:\n${stdoutOutput}` : '',
+                        ]
+                            .filter(Boolean)
+                            .join('\n');
+                        reject(new Error(errorDetails));
+                    }
+                }, START_CHECK_DELAY_MS);
+            });
+        }
+        // macOS/Linux: spawn with ignored stdio so Node.js can exit cleanly
+        const proc = spawn(influxdbServer, args, {
+            cwd: containerDir,
+            stdio: ['ignore', 'ignore', 'ignore'],
+            detached: true,
+        });
+        proc.unref();
+        if (!proc.pid) {
+            throw new Error('InfluxDB server process failed to start (no PID)');
+        }
+        try {
+            await writeFile(pidFile, String(proc.pid));
+        }
+        catch {
+            // Non-fatal
+        }
+        // Wait for InfluxDB to be ready
+        const ready = await this.waitForReady(port);
+        if (ready) {
+            return {
+                port,
+                connectionString: this.getConnectionString(container),
+            };
+        }
+        // Clean up the orphaned detached process before throwing
+        if (proc.pid) {
+            try {
+                process.kill(-proc.pid, 'SIGTERM');
+                logDebug(`Killed process group ${proc.pid}`);
+            }
+            catch {
+                try {
+                    process.kill(proc.pid, 'SIGTERM');
+                    logDebug(`Killed process ${proc.pid}`);
+                }
+                catch {
+                    // Ignore - process may have already exited
+                }
+            }
+        }
+        // Clean up PID file
+        if (existsSync(pidFile)) {
+            try {
+                await unlink(pidFile);
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        const portError = await checkLogForError();
+        const errorDetails = [
+            portError || 'InfluxDB failed to start within timeout.',
+            `Binary: ${influxdbServer}`,
+            `Log file: ${logFile}`,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        throw new Error(errorDetails);
+    }
+    // Wait for InfluxDB to be ready to accept connections
+    async waitForReady(port, timeoutMs = 30000) {
+        const startTime = Date.now();
+        const checkInterval = 500;
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                // InfluxDB 3.x health check endpoint
+                const response = await influxdbApiRequest(port, 'GET', '/health');
+                if (response.status === 200) {
+                    logDebug(`InfluxDB ready on port ${port}`);
+                    return true;
+                }
+            }
+            catch {
+                // Connection failed, wait and retry
+            }
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        }
+        logDebug(`InfluxDB did not become ready within ${timeoutMs}ms`);
+        return false;
+    }
+    /**
+     * Stop InfluxDB server
+     */
+    async stop(container) {
+        const { name, port } = container;
+        const containerDir = paths.getContainerPath(name, { engine: ENGINE });
+        const pidFile = join(containerDir, 'influxdb.pid');
+        logDebug(`Stopping InfluxDB container "${name}" on port ${port}`);
+        // Get PID and terminate
+        let pid = null;
+        if (existsSync(pidFile)) {
+            try {
+                const content = await readFile(pidFile, 'utf8');
+                pid = parseInt(content.trim(), 10);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // Kill process if running
+        if (pid && platformService.isProcessRunning(pid)) {
+            logDebug(`Killing InfluxDB process ${pid}`);
+            try {
+                if (isWindows()) {
+                    await platformService.terminateProcess(pid, true);
+                }
+                else {
+                    await platformService.terminateProcess(pid, false);
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    if (platformService.isProcessRunning(pid)) {
+                        logWarning(`Graceful termination failed, force killing ${pid}`);
+                        await platformService.terminateProcess(pid, true);
+                    }
+                }
+            }
+            catch (error) {
+                logDebug(`Process termination error: ${error}`);
+            }
+        }
+        // Wait for process to fully terminate
+        if (isWindows()) {
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+        // Kill any processes still listening on the port
+        const portPids = await platformService.findProcessByPort(port);
+        for (const portPid of portPids) {
+            if (platformService.isProcessRunning(portPid)) {
+                logDebug(`Killing process ${portPid} still on port ${port}`);
+                try {
+                    await platformService.terminateProcess(portPid, true);
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        // On Windows, wait again after killing port processes
+        if (isWindows() && portPids.length > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        // Cleanup PID file
+        if (existsSync(pidFile)) {
+            try {
+                await unlink(pidFile);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // On Windows, wait for ports to be released
+        if (isWindows()) {
+            logDebug(`Waiting for port ${port} to be released...`);
+            const portWaitStart = Date.now();
+            const portWaitTimeout = 30000;
+            const checkInterval = 500;
+            while (Date.now() - portWaitStart < portWaitTimeout) {
+                const httpAvailable = await portManager.isPortAvailable(port);
+                if (httpAvailable) {
+                    logDebug('Port released successfully');
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+        }
+        logDebug('InfluxDB stopped');
+    }
+    // Get InfluxDB server status
+    async status(container) {
+        const { name, port } = container;
+        const containerDir = paths.getContainerPath(name, { engine: ENGINE });
+        const pidFile = join(containerDir, 'influxdb.pid');
+        // Try health check via REST API
+        try {
+            const response = await influxdbApiRequest(port, 'GET', '/health');
+            if (response.status === 200) {
+                return { running: true, message: 'InfluxDB is running' };
+            }
+        }
+        catch {
+            // Not responding, check PID
+        }
+        // Check PID file
+        if (existsSync(pidFile)) {
+            try {
+                const content = await readFile(pidFile, 'utf8');
+                const pid = parseInt(content.trim(), 10);
+                if (!isNaN(pid) && pid > 0 && platformService.isProcessRunning(pid)) {
+                    return {
+                        running: true,
+                        message: `InfluxDB is running (PID: ${pid})`,
+                    };
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return { running: false, message: 'InfluxDB is not running' };
+    }
+    // Detect backup format
+    async detectBackupFormat(filePath) {
+        return detectBackupFormatImpl(filePath);
+    }
+    /**
+     * Restore a backup
+     * InfluxDB can be running during SQL restore (via REST API)
+     */
+    async restore(container, backupPath, _options = {}) {
+        const { name, port } = container;
+        const database = _options.database || container.database;
+        return restoreBackup(backupPath, {
+            containerName: name,
+            port,
+            database,
+        });
+    }
+    /**
+     * Get connection string
+     * Format: http://127.0.0.1:PORT
+     */
+    getConnectionString(container, _database) {
+        const { port } = container;
+        return `http://127.0.0.1:${port}`;
+    }
+    // Open HTTP API (InfluxDB uses REST API)
+    async connect(container, _database) {
+        const { port } = container;
+        const url = `http://127.0.0.1:${port}`;
+        console.log(`InfluxDB REST API available at: ${url}`);
+        console.log('');
+        console.log('Example commands:');
+        console.log(`  curl ${url}/health`);
+        console.log(`  curl -X POST ${url}/api/v3/query_sql -H "Content-Type: application/json" -d '{"db":"mydb","q":"SELECT 1"}'`);
+    }
+    /**
+     * Create a new database
+     * InfluxDB 3.x creates databases implicitly on first write,
+     * but we can verify the server is running
+     */
+    async createDatabase(container, database) {
+        const { port } = container;
+        // InfluxDB 3.x creates databases implicitly when data is written
+        // Verify server is accessible and write a test record to create the database
+        const response = await influxdbApiRequest(port, 'POST', `/api/v3/write_lp?db=${encodeURIComponent(database)}`, undefined);
+        // A 204 or 200 means success, but we might also get a 2xx with empty body
+        // which is fine - database will be created on first write
+        if (response.status >= 400) {
+            logDebug(`Database creation note: ${JSON.stringify(response.data)}. Database will be created on first write.`);
+        }
+        logDebug(`InfluxDB database "${database}" ready (created on first write)`);
+    }
+    /**
+     * Drop a database
+     * InfluxDB 3.x doesn't have a direct DROP DATABASE command via REST
+     */
+    async dropDatabase(container, database) {
+        const { port } = container;
+        // Try to delete tables in the database
+        const tablesResponse = await influxdbApiRequest(port, 'POST', '/api/v3/query_sql', {
+            db: database,
+            q: 'SHOW TABLES',
+            format: 'json',
+        });
+        if (tablesResponse.status === 200) {
+            const tables = tablesResponse.data;
+            if (Array.isArray(tables)) {
+                for (const row of tables) {
+                    // Only drop user tables (iox schema), skip system/information_schema
+                    const schema = row.table_schema;
+                    if (schema && schema !== 'iox')
+                        continue;
+                    const tableName = row.table_name ||
+                        row.name ||
+                        Object.values(row)[0];
+                    if (tableName) {
+                        await influxdbApiRequest(port, 'POST', '/api/v3/query_sql', {
+                            db: database,
+                            q: `DROP TABLE "${tableName}"`,
+                            format: 'json',
+                        });
+                    }
+                }
+            }
+        }
+        logDebug(`Dropped tables in InfluxDB database: ${database}`);
+    }
+    /**
+     * Get the storage size of the InfluxDB instance
+     */
+    async getDatabaseSize(_container) {
+        // InfluxDB 3.x doesn't have a direct size endpoint
+        // Return null to use filesystem-based calculation
+        return null;
+    }
+    /**
+     * Dump from a remote InfluxDB connection
+     * Uses InfluxDB's REST API to query tables and export data as SQL
+     */
+    async dumpFromConnectionString(connectionString, outputPath) {
+        const { baseUrl, headers, database } = parseInfluxDBConnectionString(connectionString);
+        logDebug(`Connecting to remote InfluxDB at ${baseUrl}`);
+        // Check connectivity
+        const healthResponse = await remoteInfluxDBRequest(baseUrl, 'GET', '/health', headers);
+        if (healthResponse.status !== 200) {
+            throw new Error(`Failed to connect to InfluxDB at ${baseUrl}: ${JSON.stringify(healthResponse.data)}`);
+        }
+        const db = database || 'mydb';
+        const warnings = [];
+        // Get list of tables
+        const tablesResponse = await remoteInfluxDBRequest(baseUrl, 'POST', '/api/v3/query_sql', headers, { db, q: 'SHOW TABLES', format: 'json' });
+        const tablesData = tablesResponse.data;
+        const tables = [];
+        if (Array.isArray(tablesData)) {
+            for (const row of tablesData) {
+                const schema = row.table_schema;
+                if (schema && schema !== 'iox')
+                    continue;
+                const tableName = row.table_name ||
+                    row.name ||
+                    Object.values(row)[0];
+                if (tableName)
+                    tables.push(tableName);
+            }
+        }
+        logDebug(`Found ${tables.length} tables on remote server`);
+        if (tables.length === 0) {
+            warnings.push(`Remote InfluxDB instance has no tables in database "${db}"`);
+        }
+        // Build SQL dump (same format as local backup)
+        let sqlContent = `-- InfluxDB SQL Backup\n`;
+        sqlContent += `-- Database: ${db}\n`;
+        sqlContent += `-- Source: ${baseUrl}\n`;
+        sqlContent += `-- Created: ${new Date().toISOString()}\n\n`;
+        for (const table of tables) {
+            // Query column metadata for tag identification
+            const tagColumns = [];
+            try {
+                const colResponse = await remoteInfluxDBRequest(baseUrl, 'POST', '/api/v3/query_sql', headers, {
+                    db,
+                    q: `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '${table.replace(/'/g, "''")}'`,
+                    format: 'json',
+                });
+                if (colResponse.status === 200 && Array.isArray(colResponse.data)) {
+                    for (const col of colResponse.data) {
+                        if (String(col.data_type || '').includes('Dictionary')) {
+                            tagColumns.push(String(col.column_name));
+                        }
+                    }
+                }
+            }
+            catch {
+                logDebug(`Warning: Could not query column metadata for ${table}`);
+            }
+            // Query all data from the table
+            const dataResponse = await remoteInfluxDBRequest(baseUrl, 'POST', '/api/v3/query_sql', headers, {
+                db,
+                q: `SELECT * FROM "${table.replace(/"/g, '""')}"`,
+                format: 'json',
+            });
+            if (dataResponse.status !== 200) {
+                const msg = `Failed to export table ${table}: ${JSON.stringify(dataResponse.data)}`;
+                logDebug(`Warning: ${msg}`);
+                warnings.push(msg);
+                continue;
+            }
+            const rows = dataResponse.data;
+            if (Array.isArray(rows) && rows.length > 0) {
+                sqlContent += `-- Table: ${table}\n`;
+                if (tagColumns.length > 0) {
+                    sqlContent += `-- Tags: ${tagColumns.join(', ')}\n`;
+                }
+                for (const row of rows) {
+                    const columns = Object.keys(row);
+                    const values = columns.map((col) => {
+                        const val = row[col];
+                        if (val === null || val === undefined)
+                            return 'NULL';
+                        if (typeof val === 'number')
+                            return String(val);
+                        if (typeof val === 'boolean')
+                            return val ? 'true' : 'false';
+                        return `'${String(val).replace(/'/g, "''")}'`;
+                    });
+                    sqlContent += `INSERT INTO "${table.replace(/"/g, '""')}" (${columns.map((c) => `"${c.replace(/"/g, '""')}"`).join(', ')}) VALUES (${values.join(', ')});\n`;
+                }
+                sqlContent += '\n';
+            }
+        }
+        // Write SQL content to file
+        await writeFile(outputPath, sqlContent, 'utf-8');
+        return {
+            filePath: outputPath,
+            warnings,
+        };
+    }
+    // Create a backup
+    async backup(container, outputPath, options) {
+        return createBackup(container, outputPath, options);
+    }
+    // Run a command - InfluxDB uses REST API with SQL
+    async runScript(container, options) {
+        const { port } = container;
+        const database = options.database || container.database;
+        if (options.file) {
+            const content = await readFile(options.file, 'utf-8');
+            // Ensure the database exists (InfluxDB creates DBs implicitly on write,
+            // but SQL queries fail if the DB doesn't exist yet)
+            const createDbResp = await influxdbApiRequest(port, 'POST', '/api/v3/configure/database', { db: database });
+            if (createDbResp.status >= 400) {
+                throw new Error(`Failed to create database "${database}": HTTP ${createDbResp.status} — ${JSON.stringify(createDbResp.data)}`);
+            }
+            // Line protocol files (.lp) → write via /api/v3/write_lp
+            if (options.file.endsWith('.lp')) {
+                const lines = content
+                    .split('\n')
+                    .filter((line) => line.trim().length > 0 && !line.startsWith('#'))
+                    .join('\n');
+                const response = await influxdbApiRequest(port, 'POST', `/api/v3/write_lp?db=${encodeURIComponent(database)}`, lines);
+                if (response.status >= 400) {
+                    throw new Error(`Write error: ${JSON.stringify(response.data)}`);
+                }
+                return;
+            }
+            // SQL files → execute via /api/v3/query_sql
+            const statements = content
+                .split('\n')
+                .filter((line) => !line.startsWith('--') && line.trim().length > 0)
+                .join('\n')
+                .split(';')
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+            for (const sql of statements) {
+                const response = await influxdbApiRequest(port, 'POST', '/api/v3/query_sql', {
+                    db: database,
+                    q: sql,
+                    format: 'json',
+                });
+                if (response.status >= 400) {
+                    throw new Error(`SQL error: ${JSON.stringify(response.data)}\nStatement: ${sql}`);
+                }
+            }
+            return;
+        }
+        if (options.sql) {
+            // Ensure database exists for inline SQL too
+            const createDbResp2 = await influxdbApiRequest(port, 'POST', '/api/v3/configure/database', { db: database });
+            if (createDbResp2.status >= 400) {
+                throw new Error(`Failed to create database "${database}": HTTP ${createDbResp2.status} — ${JSON.stringify(createDbResp2.data)}`);
+            }
+            const response = await influxdbApiRequest(port, 'POST', '/api/v3/query_sql', {
+                db: database,
+                q: options.sql,
+                format: 'json',
+            });
+            if (response.status >= 400) {
+                throw new Error(`SQL error: ${JSON.stringify(response.data)}`);
+            }
+            if (response.data) {
+                console.log(JSON.stringify(response.data, null, 2));
+            }
+            return;
+        }
+        throw new Error('Either file or sql option must be provided');
+    }
+    /**
+     * Execute a query via REST API
+     *
+     * Query format: SQL statement or METHOD /path [JSON body]
+     * Examples:
+     *   SELECT * FROM cpu
+     *   GET /health
+     *   POST /api/v3/query_sql {"db": "mydb", "q": "SELECT 1"}
+     */
+    async executeQuery(container, query, options) {
+        const { port } = container;
+        const database = options?.database || container.database;
+        const trimmed = query.trim();
+        // Check if this is a REST API-style query (starts with HTTP method)
+        const httpMethods = ['GET', 'POST', 'PUT', 'DELETE'];
+        const firstWord = trimmed.split(/\s+/)[0].toUpperCase();
+        if (httpMethods.includes(firstWord)) {
+            // Parse as REST API query: METHOD /path [body]
+            const spaceIdx = trimmed.indexOf(' ');
+            const method = (options?.method || firstWord);
+            const rest = trimmed.substring(spaceIdx + 1).trim();
+            let path;
+            let body = options?.body;
+            const bodyStart = rest.indexOf('{');
+            if (bodyStart !== -1) {
+                path = rest.substring(0, bodyStart).trim();
+                if (!body) {
+                    try {
+                        body = JSON.parse(rest.substring(bodyStart));
+                    }
+                    catch {
+                        throw new Error('Invalid JSON body in query');
+                    }
+                }
+            }
+            else {
+                path = rest;
+            }
+            if (!path.startsWith('/')) {
+                path = '/' + path;
+            }
+            const response = await influxdbApiRequest(port, method, path, body);
+            if (response.status >= 400) {
+                throw new Error(`InfluxDB API error (${response.status}): ${JSON.stringify(response.data)}`);
+            }
+            return parseRESTAPIResult(JSON.stringify(response.data));
+        }
+        // Default: treat as SQL query
+        const response = await influxdbApiRequest(port, 'POST', '/api/v3/query_sql', {
+            db: database,
+            q: trimmed,
+            format: 'json',
+        });
+        if (response.status >= 400) {
+            throw new Error(`InfluxDB SQL error (${response.status}): ${JSON.stringify(response.data)}`);
+        }
+        return parseRESTAPIResult(JSON.stringify(response.data));
+    }
+    /**
+     * List databases for InfluxDB.
+     * InfluxDB 3.x uses GET /api/v3/configure/database?format=json
+     */
+    async listDatabases(container) {
+        const { port } = container;
+        try {
+            const response = await influxdbApiRequest(port, 'GET', '/api/v3/configure/database?format=json');
+            if (response.status === 200 && response.data) {
+                const data = response.data;
+                if (Array.isArray(data)) {
+                    const databases = data
+                        .map((row) => {
+                        return (row['iox::database'] ||
+                            row.name ||
+                            Object.values(row)[0]);
+                    })
+                        .filter(Boolean);
+                    return databases.length > 0 ? databases : [container.database];
+                }
+            }
+            return [container.database];
+        }
+        catch {
+            return [container.database];
+        }
+    }
+}
+export const influxdbEngine = new InfluxDBEngine();
+//# sourceMappingURL=index.js.map