spindb 0.37.2 → 0.38.0

package/dist/cli/helpers.js

@@ -0,0 +1,1120 @@
+import { existsSync } from 'fs';
+import { readdir, lstat } from 'fs/promises';
+import { join } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { paths } from '../config/paths.js';
+import { platformService } from '../core/platform-service.js';
+import { getEngineConfig } from '../config/engines-registry.js';
+const execFileAsync = promisify(execFile);
+export async function getEngineMetadata(engine) {
+    const config = await getEngineConfig(engine);
+    return {
+        queryLanguage: config.queryLanguage,
+        runtime: config.runtime,
+        connectionScheme: config.connectionScheme,
+    };
+}
+// Parse engine directory name into components
+// Format: {engine}-{version}-{platform}-{arch}
+// Handles versions with dashes (e.g., 17.0.0-rc1) by splitting from the end
+function parseEngineDirectory(entryName, enginePrefix, binDir) {
+    const rest = entryName.slice(enginePrefix.length);
+    const parts = rest.split('-');
+    if (parts.length < 3)
+        return null;
+    const arch = parts.pop();
+    const platform = parts.pop();
+    const version = parts.join('-');
+    if (!version || !platform || !arch)
+        return null;
+    return {
+        version,
+        platform,
+        arch,
+        path: join(binDir, entryName),
+    };
+}
+// Calculate the total size of all files in a directory (recursive)
+async function calculateDirectorySize(dirPath) {
+    let sizeBytes = 0;
+    try {
+        const files = await readdir(dirPath, { recursive: true });
+        for (const file of files) {
+            try {
+                const filePath = join(dirPath, file.toString());
+                const fileStat = await lstat(filePath);
+                if (fileStat.isFile()) {
+                    sizeBytes += fileStat.size;
+                }
+            }
+            catch {
+                // Skip files we can't stat
+            }
+        }
+    }
+    catch {
+        // Skip directories we can't read
+    }
+    return sizeBytes;
+}
+async function getPostgresVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const postgresPath = join(binPath, 'bin', `postgres${ext}`);
+    if (!existsSync(postgresPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(postgresPath, ['--version']);
+        const match = stdout.match(/\(PostgreSQL\)\s+([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getInstalledPostgresEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('postgresql-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'postgresql-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getPostgresVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'postgresql',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+async function getMariadbVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    // Try mariadbd first, then mysqld
+    let serverPath = join(binPath, 'bin', `mariadbd${ext}`);
+    if (!existsSync(serverPath)) {
+        serverPath = join(binPath, 'bin', `mysqld${ext}`);
+    }
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(serverPath, ['--version']);
+        // Parse output like "mariadbd  Ver 11.8.5-MariaDB"
+        const match = stdout.match(/Ver\s+([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getInstalledMariadbEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('mariadb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'mariadb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getMariadbVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'mariadb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+async function getMysqlVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const serverPath = join(binPath, 'bin', `mysqld${ext}`);
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(serverPath, ['--version']);
+        // Parse output like "mysqld  Ver 8.0.40 for Linux on x86_64"
+        const match = stdout.match(/Ver\s+([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed MySQL engines from downloaded binaries
+async function getInstalledMysqlEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('mysql-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'mysql-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getMysqlVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'mysql',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get SQLite version from binary path
+async function getSqliteVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const sqlite3Path = join(binPath, 'bin', `sqlite3${ext}`);
+    if (!existsSync(sqlite3Path)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(sqlite3Path, ['--version']);
+        // sqlite3 --version outputs: "3.51.2 2025-01-08 12:00:00 ..."
+        const match = stdout.match(/^(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed SQLite engines from downloaded binaries
+async function getInstalledSqliteEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('sqlite-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'sqlite-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getSqliteVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'sqlite',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get DuckDB version from binary path
+async function getDuckDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const duckdbPath = join(binPath, 'bin', `duckdb${ext}`);
+    if (!existsSync(duckdbPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(duckdbPath, ['--version']);
+        // duckdb --version outputs: "v1.4.3 abcdef123" or just "1.4.3"
+        const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed DuckDB engines from downloaded binaries
+async function getInstalledDuckDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('duckdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'duckdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getDuckDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'duckdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get MongoDB version from binary path
+async function getMongodbVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const serverPath = join(binPath, 'bin', `mongod${ext}`);
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(serverPath, ['--version']);
+        // Parse output like "db version v7.0.28"
+        const match = stdout.match(/v([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed MongoDB engines from downloaded binaries
+async function getInstalledMongodbEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('mongodb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'mongodb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getMongodbVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'mongodb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get Redis version from binary path
+async function getRedisVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const serverPath = join(binPath, 'bin', `redis-server${ext}`);
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(serverPath, ['--version']);
+        // Parse output like "Redis server v=7.4.7 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=..."
+        const match = stdout.match(/v=([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed Redis engines from downloaded binaries
+async function getInstalledRedisEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('redis-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'redis-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getRedisVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'redis',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get Valkey version from binary path
+async function getValkeyVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const serverPath = join(binPath, 'bin', `valkey-server${ext}`);
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(serverPath, ['--version']);
+        // Parse output like "Valkey server v=8.0.6 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=..."
+        const match = stdout.match(/v=([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed Valkey engines from downloaded binaries
+async function getInstalledValkeyEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('valkey-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'valkey-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getValkeyVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'valkey',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get ClickHouse version from binary path
+async function getClickHouseVersion(binPath) {
+    const clickhousePath = join(binPath, 'bin', 'clickhouse');
+    if (!existsSync(clickhousePath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(clickhousePath, [
+            'client',
+            '--version',
+        ]);
+        // Parse output like "ClickHouse client version 25.12.3.21 (official build)"
+        const match = stdout.match(/version\s+([\d.]+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed ClickHouse engines from downloaded binaries
+async function getInstalledClickHouseEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('clickhouse-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'clickhouse-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getClickHouseVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'clickhouse',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get Qdrant version from binary path
+async function getQdrantVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const qdrantPath = join(binPath, 'bin', `qdrant${ext}`);
+    if (!existsSync(qdrantPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(qdrantPath, ['--version']);
+        // Parse output like "qdrant 1.16.3" or "v1.16.3"
+        const match = stdout.match(/(?:qdrant\s+)?v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed Qdrant engines from downloaded binaries
+async function getInstalledQdrantEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('qdrant-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'qdrant-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getQdrantVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'qdrant',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get Meilisearch version from binary path
+async function getMeilisearchVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const meilisearchPath = join(binPath, 'bin', `meilisearch${ext}`);
+    if (!existsSync(meilisearchPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(meilisearchPath, ['--version']);
+        // Parse output like "meilisearch 1.33.1" or "v1.33.1"
+        const match = stdout.match(/(?:meilisearch\s+)?v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed Meilisearch engines from downloaded binaries
+async function getInstalledMeilisearchEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('meilisearch-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'meilisearch-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getMeilisearchVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'meilisearch',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get CouchDB version from binary path
+// Note: CouchDB doesn't support --version flag, so we just verify the binary exists
+// and return null to use the version from the directory name
+async function getCouchDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const couchdbPath = join(binPath, 'bin', `couchdb${ext}`);
+    if (!existsSync(couchdbPath)) {
+        return null;
+    }
+    // CouchDB is an Erlang app that tries to start when run with any args
+    // Just return null to use directory-parsed version
+    return null;
+}
+// Get installed CouchDB engines from downloaded binaries
+async function getInstalledCouchDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('couchdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'couchdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getCouchDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'couchdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get CockroachDB version from binary path
+async function getCockroachDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const cockroachPath = join(binPath, 'bin', `cockroach${ext}`);
+    if (!existsSync(cockroachPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(cockroachPath, ['version']);
+        // Parse output like "Build Tag:        v25.4.2" or "CockroachDB CCL v25.4.2"
+        const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed CockroachDB engines from downloaded binaries
+async function getInstalledCockroachDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('cockroachdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'cockroachdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getCockroachDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'cockroachdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get SurrealDB version from binary path
+async function getSurrealDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const surrealPath = join(binPath, 'bin', `surreal${ext}`);
+    if (!existsSync(surrealPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(surrealPath, ['version']);
+        // Parse output like "surreal 2.3.2 for linux on x86_64" or "2.3.2"
+        const match = stdout.match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed SurrealDB engines from downloaded binaries
+async function getInstalledSurrealDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('surrealdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'surrealdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getSurrealDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'surrealdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get QuestDB version from directory path
+// QuestDB doesn't have a simple --version flag, extract from directory name
+async function getQuestDBVersion(binPath) {
+    const platform = platformService.getPlatformInfo().platform;
+    // Check for questdb startup script
+    if (platform === 'win32') {
+        if (!existsSync(join(binPath, 'questdb.exe'))) {
+            return null;
+        }
+    }
+    else {
+        if (!existsSync(join(binPath, 'questdb.sh'))) {
+            return null;
+        }
+    }
+    // Version is embedded in directory name, return null to use directory-parsed version
+    return null;
+}
+// Get installed QuestDB engines from downloaded binaries
+async function getInstalledQuestDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('questdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'questdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getQuestDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'questdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get TypeDB version from binary path
+// TypeDB is a Rust binary but uses a launcher script. Check for server binary existence.
+async function getTypeDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const serverPath = join(binPath, 'bin', 'server', `typedb_server_bin${ext}`);
+    if (!existsSync(serverPath)) {
+        return null;
+    }
+    // TypeDB server binary doesn't have a simple --version flag
+    // Return null to use directory-parsed version
+    return null;
+}
+// Get installed TypeDB engines from downloaded binaries
+async function getInstalledTypeDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('typedb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'typedb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getTypeDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'typedb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get InfluxDB version from binary path
+async function getInfluxDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const influxdbPath = join(binPath, 'bin', `influxdb3${ext}`);
+    if (!existsSync(influxdbPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(influxdbPath, ['--version']);
+        const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed InfluxDB engines from downloaded binaries
+async function getInstalledInfluxDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('influxdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'influxdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getInfluxDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'influxdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get FerretDB version from binary path
+async function getFerretDBVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const ferretdbPath = join(binPath, 'bin', `ferretdb${ext}`);
+    if (!existsSync(ferretdbPath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(ferretdbPath, ['--version']);
+        // Parse output like "ferretdb version 2.7.0" or "v2.7.0"
+        const match = stdout.match(/(?:ferretdb\s+)?(?:version\s+)?v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed FerretDB engines from downloaded binaries
+async function getInstalledFerretDBEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('ferretdb-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'ferretdb-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getFerretDBVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'ferretdb',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get Weaviate version from binary path
+async function getWeaviateVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const weaviatePath = join(binPath, 'bin', `weaviate${ext}`);
+    if (!existsSync(weaviatePath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(weaviatePath, ['--version']);
+        // Parse output like "weaviate v1.35.7" or "1.35.7"
+        const match = stdout.match(/(?:weaviate\s+)?v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed Weaviate engines from downloaded binaries
+async function getInstalledWeaviateEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('weaviate-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'weaviate-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getWeaviateVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'weaviate',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+// Get TigerBeetle version from binary path
+async function getTigerBeetleVersion(binPath) {
+    const ext = platformService.getExecutableExtension();
+    const tigerbeetlePath = join(binPath, 'bin', `tigerbeetle${ext}`);
+    if (!existsSync(tigerbeetlePath)) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync(tigerbeetlePath, ['version']);
+        // Parse output like "TigerBeetle v0.16.70" or "0.16.70"
+        const match = stdout.match(/(?:TigerBeetle\s+)?v?(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get installed TigerBeetle engines from downloaded binaries
+async function getInstalledTigerBeetleEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return [];
+    }
+    const entries = await readdir(binDir, { withFileTypes: true });
+    const engines = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('tigerbeetle-'))
+            continue;
+        const parsed = parseEngineDirectory(entry.name, 'tigerbeetle-', binDir);
+        if (!parsed)
+            continue;
+        const actualVersion = (await getTigerBeetleVersion(parsed.path)) || parsed.version;
+        const sizeBytes = await calculateDirectorySize(parsed.path);
+        engines.push({
+            engine: 'tigerbeetle',
+            version: actualVersion,
+            platform: parsed.platform,
+            arch: parsed.arch,
+            path: parsed.path,
+            sizeBytes,
+            source: 'downloaded',
+        });
+    }
+    engines.sort((a, b) => compareVersions(b.version, a.version));
+    return engines;
+}
+export function compareVersions(a, b) {
+    const partsA = a.split('.').map((p) => parseInt(p, 10) || 0);
+    const partsB = b.split('.').map((p) => parseInt(p, 10) || 0);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] || 0;
+        const numB = partsB[i] || 0;
+        if (numA !== numB)
+            return numA - numB;
+    }
+    return 0;
+}
+/**
+ * Known engine directory prefixes in the bin directory.
+ * Directory names follow the pattern: {engine}-{version}-{platform}-{arch}
+ */
+const ENGINE_PREFIXES = [
+    'postgresql-',
+    'mysql-',
+    'mariadb-',
+    'sqlite-',
+    'duckdb-',
+    'mongodb-',
+    'ferretdb-',
+    'postgresql-documentdb-',
+    'redis-',
+    'valkey-',
+    'clickhouse-',
+    'qdrant-',
+    'meilisearch-',
+    'couchdb-',
+    'cockroachdb-',
+    'surrealdb-',
+    'questdb-',
+    'typedb-',
+    'influxdb-',
+    'weaviate-',
+    'tigerbeetle-',
+];
+/**
+ * Lightweight check to see if any engines are installed.
+ * Only reads the bin directory - no subprocess spawning or size calculations.
+ * Use this for UI decisions where you only need to know if engines exist.
+ * Validates directory names against known engine prefixes to avoid false positives.
+ */
+export async function hasAnyInstalledEngines() {
+    const binDir = paths.bin;
+    if (!existsSync(binDir)) {
+        return false;
+    }
+    try {
+        const entries = await readdir(binDir, { withFileTypes: true });
+        return entries.some((entry) => entry.isDirectory() &&
+            !entry.name.startsWith('.') &&
+            ENGINE_PREFIXES.some((prefix) => entry.name.startsWith(prefix)));
+    }
+    catch {
+        return false;
+    }
+}
+export async function getInstalledEngines() {
+    // Parallelize all engine checks for faster startup
+    const [pgEngines, mariadbEngines, mysqlEngines, sqliteEngines, duckdbEngines, mongodbEngines, ferretdbEngines, redisEngines, valkeyEngines, clickhouseEngines, qdrantEngines, meilisearchEngines, couchdbEngines, cockroachdbEngines, surrealdbEngines, questdbEngines, typedbEngines, influxdbEngines, weaviateEngines, tigerbeetleEngines,] = await Promise.all([
+        getInstalledPostgresEngines(),
+        getInstalledMariadbEngines(),
+        getInstalledMysqlEngines(),
+        getInstalledSqliteEngines(),
+        getInstalledDuckDBEngines(),
+        getInstalledMongodbEngines(),
+        getInstalledFerretDBEngines(),
+        getInstalledRedisEngines(),
+        getInstalledValkeyEngines(),
+        getInstalledClickHouseEngines(),
+        getInstalledQdrantEngines(),
+        getInstalledMeilisearchEngines(),
+        getInstalledCouchDBEngines(),
+        getInstalledCockroachDBEngines(),
+        getInstalledSurrealDBEngines(),
+        getInstalledQuestDBEngines(),
+        getInstalledTypeDBEngines(),
+        getInstalledInfluxDBEngines(),
+        getInstalledWeaviateEngines(),
+        getInstalledTigerBeetleEngines(),
+    ]);
+    return [
+        ...pgEngines,
+        ...mariadbEngines,
+        ...mysqlEngines,
+        ...sqliteEngines,
+        ...duckdbEngines,
+        ...mongodbEngines,
+        ...ferretdbEngines,
+        ...redisEngines,
+        ...valkeyEngines,
+        ...clickhouseEngines,
+        ...qdrantEngines,
+        ...meilisearchEngines,
+        ...couchdbEngines,
+        ...cockroachdbEngines,
+        ...surrealdbEngines,
+        ...questdbEngines,
+        ...typedbEngines,
+        ...influxdbEngines,
+        ...weaviateEngines,
+        ...tigerbeetleEngines,
+    ];
+}
+// Export individual engine detection functions for use in other modules
+export { getInstalledMysqlEngines, getInstalledSqliteEngines, getInstalledDuckDBEngines, getInstalledMongodbEngines, getInstalledFerretDBEngines, getInstalledRedisEngines, getInstalledValkeyEngines, getInstalledClickHouseEngines, getInstalledQdrantEngines, getInstalledMeilisearchEngines, getInstalledCouchDBEngines, getInstalledCockroachDBEngines, getInstalledSurrealDBEngines, getInstalledQuestDBEngines, getInstalledTypeDBEngines, getInstalledInfluxDBEngines, getInstalledWeaviateEngines, getInstalledTigerBeetleEngines, };
+//# sourceMappingURL=helpers.js.map