spindb 0.37.2 → 0.38.0

package/dist/engines/ferretdb/binary-manager.js

@@ -0,0 +1,765 @@
+/**
+ * FerretDB Composite Binary Manager
+ *
+ * Handles downloading and managing FerretDB binaries:
+ *
+ * v2 (default): Two binaries required:
+ *   1. ferretdb - The MongoDB-compatible Go proxy
+ *   2. postgresql-documentdb - PostgreSQL 17 with DocumentDB extension
+ *
+ * v1: Two binaries, but backend is shared:
+ *   1. ferretdb - The MongoDB-compatible Go proxy
+ *   2. Plain PostgreSQL - Managed by postgresqlBinaryManager (shared with standalone PG containers)
+ *
+ * This is a composite manager that coordinates the installation of both
+ * binaries, which are required for FerretDB to function.
+ */
+import { createWriteStream, existsSync } from 'fs';
+import { mkdir, readdir, rm, chmod, rename, cp } from 'fs/promises';
+import { join } from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { paths } from '../../config/paths.js';
+import { spawnAsync, extractWindowsArchive } from '../../core/spawn-utils.js';
+import { isRenameFallbackError } from '../../core/fs-error-utils.js';
+import { logDebug } from '../../core/error-handler.js';
+import { fetchWithRegistryFallback } from '../../core/hostdb-client.js';
+import { Engine, Platform, isValidPlatform, isValidArch, } from '../../types/index.js';
+import { normalizeVersion, normalizeDocumentDBVersion, DEFAULT_DOCUMENTDB_VERSION, DEFAULT_V1_POSTGRESQL_VERSION, isV1, } from './version-maps.js';
+import { isPlatformSupported, getFerretDBBinaryUrl, getDocumentDBBinaryUrl, } from './binary-urls.js';
+import { postgresqlBinaryManager } from '../postgresql/binary-manager.js';
+const DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * FerretDB Composite Binary Manager
+ *
+ * Manages the installation of both required binaries for FerretDB.
+ */
+class FerretDBCompositeBinaryManager {
+    /**
+     * Check if the current platform supports FerretDB
+     * @param version - Optional version to check platform support for (v1 supports Windows, v2 does not)
+     */
+    isPlatformSupported(platform, arch, version) {
+        return isPlatformSupported(platform, arch, version);
+    }
+    /**
+     * Get the full version string for a FerretDB version
+     */
+    getFullVersion(version) {
+        return normalizeVersion(version);
+    }
+    /**
+     * Get the full version string for a postgresql-documentdb version
+     */
+    getFullDocumentDBVersion(version) {
+        return normalizeDocumentDBVersion(version);
+    }
+    /**
+     * Check if FerretDB binaries are installed for a specific version
+     */
+    async isInstalled(version, platform, arch, backendVersion = DEFAULT_DOCUMENTDB_VERSION) {
+        const fullVersion = this.getFullVersion(version);
+        // Check FerretDB proxy
+        const ferretdbPath = this.getFerretDBBinaryPath(fullVersion, platform, arch);
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const ferretdbBinary = join(ferretdbPath, 'bin', `ferretdb${ext}`);
+        if (!existsSync(ferretdbBinary)) {
+            return false;
+        }
+        // Check backend
+        if (isV1(version)) {
+            // v1: check plain PostgreSQL via postgresqlBinaryManager
+            return postgresqlBinaryManager.isInstalled(DEFAULT_V1_POSTGRESQL_VERSION, platform, arch);
+        }
+        // v2: check postgresql-documentdb
+        const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion);
+        const documentdbPath = this.getDocumentDBBinaryPath(fullBackendVersion, platform, arch);
+        const pgCtlExt = platform === Platform.Win32 ? '.exe' : '';
+        const pgCtl = join(documentdbPath, 'bin', `pg_ctl${pgCtlExt}`);
+        if (!existsSync(pgCtl)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get the path where FerretDB binaries would be installed
+     * @param version - Full normalized version (e.g., "2.7.0", not "2" or "2.7")
+     * @param platform - Operating system
+     * @param arch - Architecture
+     */
+    getFerretDBBinaryPath(version, platform, arch) {
+        return join(paths.bin, `ferretdb-${version}-${platform}-${arch}`);
+    }
+    /**
+     * Get the path where postgresql-documentdb binaries would be installed
+     * @param version - Full normalized version (e.g., "17-0.107.0", not "17")
+     * @param platform - Operating system
+     * @param arch - Architecture
+     */
+    getDocumentDBBinaryPath(version, platform, arch) {
+        return join(paths.bin, `postgresql-documentdb-${version}-${platform}-${arch}`);
+    }
+    /**
+     * Get environment variables needed to run postgresql-documentdb binaries
+     *
+     * On Linux, the bundled binaries need LD_LIBRARY_PATH set to find libpq.so
+     * and other shared libraries in the lib/ directory.
+     *
+     * On macOS, the binaries use @loader_path which doesn't need env vars.
+     * On Windows, DLLs are found via PATH or same directory.
+     *
+     * @param version - Full normalized version (e.g., "17-0.107.0", not "17")
+     * @param platform - Operating system
+     * @param arch - Architecture
+     */
+    getDocumentDBSpawnEnv(version, platform, arch) {
+        // Only Linux needs LD_LIBRARY_PATH
+        if (platform !== Platform.Linux) {
+            return undefined;
+        }
+        const documentdbPath = this.getDocumentDBBinaryPath(version, platform, arch);
+        const libPath = join(documentdbPath, 'lib');
+        // Prepend our lib path to any existing LD_LIBRARY_PATH
+        const existingLdPath = process.env['LD_LIBRARY_PATH'] || '';
+        const newLdPath = existingLdPath ? `${libPath}:${existingLdPath}` : libPath;
+        return {
+            LD_LIBRARY_PATH: newLdPath,
+        };
+    }
+    /**
+     * Get the backend binary directory path for a FerretDB version.
+     * For v1: returns the plain PostgreSQL binary path
+     * For v2: returns the postgresql-documentdb binary path
+     *
+     * @param ferretdbVersion - FerretDB version (e.g., "1.24.2" or "2.7.0")
+     * @param backendVersion - Backend version (PostgreSQL version for v1, DocumentDB version for v2)
+     * @param platform - Operating system
+     * @param arch - Architecture
+     */
+    getBackendBinaryPath(ferretdbVersion, backendVersion, platform, arch) {
+        if (isV1(ferretdbVersion)) {
+            const pgFullVersion = postgresqlBinaryManager.getFullVersion(backendVersion || DEFAULT_V1_POSTGRESQL_VERSION);
+            return paths.getBinaryPath({
+                engine: 'postgresql',
+                version: pgFullVersion,
+                platform,
+                arch,
+            });
+        }
+        const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion || DEFAULT_DOCUMENTDB_VERSION);
+        return this.getDocumentDBBinaryPath(fullBackendVersion, platform, arch);
+    }
+    /**
+     * Get environment variables needed to run backend binaries.
+     * For v1: delegates to PostgreSQL's standard env (usually none needed)
+     * For v2: delegates to getDocumentDBSpawnEnv
+     *
+     * @param ferretdbVersion - FerretDB version
+     * @param backendVersion - Backend version
+     * @param platform - Operating system
+     * @param arch - Architecture
+     */
+    getBackendSpawnEnv(ferretdbVersion, backendVersion, platform, arch) {
+        if (isV1(ferretdbVersion)) {
+            // Plain PostgreSQL doesn't need special env vars on most platforms
+            // Linux may need LD_LIBRARY_PATH
+            if (platform !== Platform.Linux) {
+                return undefined;
+            }
+            const pgPath = this.getBackendBinaryPath(ferretdbVersion, backendVersion, platform, arch);
+            const libPath = join(pgPath, 'lib');
+            const existingLdPath = process.env['LD_LIBRARY_PATH'] || '';
+            const newLdPath = existingLdPath
+                ? `${libPath}:${existingLdPath}`
+                : libPath;
+            return { LD_LIBRARY_PATH: newLdPath };
+        }
+        const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion || DEFAULT_DOCUMENTDB_VERSION);
+        return this.getDocumentDBSpawnEnv(fullBackendVersion, platform, arch);
+    }
+    /**
+     * List all installed FerretDB versions
+     */
+    async listInstalled() {
+        const binDir = paths.bin;
+        if (!existsSync(binDir)) {
+            return [];
+        }
+        const entries = await readdir(binDir, { withFileTypes: true });
+        const installed = [];
+        const prefix = 'ferretdb-';
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (!entry.name.startsWith(prefix))
+                continue;
+            // Split from end to handle versions with dashes
+            // Format: ferretdb-{version}-{platform}-{arch}
+            const rest = entry.name.slice(prefix.length);
+            const parts = rest.split('-');
+            if (parts.length < 3)
+                continue;
+            const arch = parts.pop();
+            const platform = parts.pop();
+            const version = parts.join('-');
+            if (version && isValidPlatform(platform) && isValidArch(arch)) {
+                installed.push({
+                    engine: Engine.FerretDB,
+                    version,
+                    platform,
+                    arch,
+                });
+            }
+        }
+        return installed;
+    }
+    /**
+     * Ensure both FerretDB binaries are installed
+     *
+     * @param version - FerretDB version
+     * @param platform - Operating system
+     * @param arch - Architecture
+     * @param onProgress - Progress callback
+     * @param backendVersion - Backend version (postgresql-documentdb for v2, PostgreSQL major for v1)
+     * @returns Paths to both binary directories
+     */
+    async ensureInstalled(version, platform, arch, onProgress, backendVersion) {
+        const fullVersion = this.getFullVersion(version);
+        const v1 = isV1(version);
+        const effectiveBackendVersion = backendVersion ||
+            (v1 ? DEFAULT_V1_POSTGRESQL_VERSION : DEFAULT_DOCUMENTDB_VERSION);
+        // Check if already installed
+        if (await this.isInstalled(version, platform, arch, effectiveBackendVersion)) {
+            onProgress?.({
+                stage: 'cached',
+                message: 'Using cached FerretDB binaries',
+            });
+            return {
+                ferretdbPath: this.getFerretDBBinaryPath(fullVersion, platform, arch),
+                backendPath: this.getBackendBinaryPath(fullVersion, effectiveBackendVersion, platform, arch),
+            };
+        }
+        if (v1) {
+            return this.ensureInstalledV1(version, platform, arch, onProgress, effectiveBackendVersion);
+        }
+        return this.ensureInstalledV2(version, platform, arch, onProgress, effectiveBackendVersion);
+    }
+    /**
+     * Ensure v1 FerretDB binaries are installed (proxy + plain PostgreSQL)
+     */
+    async ensureInstalledV1(version, platform, arch, onProgress, backendVersion = DEFAULT_V1_POSTGRESQL_VERSION) {
+        // Download FerretDB v1 proxy
+        const ferretdbPath = await this.downloadFerretDB(version, platform, arch, onProgress);
+        // Ensure plain PostgreSQL is installed via postgresqlBinaryManager
+        onProgress?.({
+            stage: 'downloading',
+            message: 'Ensuring PostgreSQL backend is available...',
+        });
+        const backendPath = await postgresqlBinaryManager.ensureInstalled(backendVersion, platform, arch, onProgress);
+        return { ferretdbPath, backendPath };
+    }
+    /**
+     * Ensure v2 FerretDB binaries are installed (proxy + postgresql-documentdb)
+     */
+    async ensureInstalledV2(version, platform, arch, onProgress, backendVersion = DEFAULT_DOCUMENTDB_VERSION) {
+        const fullVersion = this.getFullVersion(version);
+        // Check if FerretDB is already installed (DocumentDB might be missing)
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const ferretdbBinaryPath = this.getFerretDBBinaryPath(fullVersion, platform, arch);
+        const ferretdbBinary = join(ferretdbBinaryPath, 'bin', `ferretdb${ext}`);
+        const ferretdbAlreadyInstalled = existsSync(ferretdbBinary);
+        // Download both binaries - ensure atomicity by cleaning up FerretDB if DocumentDB fails
+        // (only if FerretDB was newly downloaded in this call)
+        const ferretdbPath = await this.downloadFerretDB(version, platform, arch, onProgress);
+        let backendPath;
+        try {
+            backendPath = await this.downloadDocumentDB(backendVersion, platform, arch, onProgress);
+        }
+        catch (error) {
+            // Only clean up FerretDB if it was newly downloaded (not pre-existing)
+            if (!ferretdbAlreadyInstalled) {
+                onProgress?.({
+                    stage: 'error',
+                    message: 'postgresql-documentdb download failed, cleaning up FerretDB...',
+                });
+                await rm(ferretdbPath, { recursive: true, force: true }).catch(() => { });
+            }
+            throw error;
+        }
+        return { ferretdbPath, backendPath };
+    }
+    /**
+     * Download FerretDB proxy binary
+     */
+    async downloadFerretDB(version, platform, arch, onProgress) {
+        const fullVersion = this.getFullVersion(version);
+        const binPath = this.getFerretDBBinaryPath(fullVersion, platform, arch);
+        // Check if FerretDB is already installed
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const ferretdbBinary = join(binPath, 'bin', `ferretdb${ext}`);
+        if (existsSync(ferretdbBinary)) {
+            onProgress?.({
+                stage: 'cached',
+                message: 'FerretDB proxy already installed',
+            });
+            return binPath;
+        }
+        const url = getFerretDBBinaryUrl(version, platform, arch);
+        const tempDir = join(paths.bin, `temp-ferretdb-${fullVersion}-${platform}-${arch}`);
+        const archiveExt = platform === Platform.Win32 ? 'zip' : 'tar.gz';
+        const archiveFile = join(tempDir, `ferretdb.${archiveExt}`);
+        // Clean up any partial installation
+        if (existsSync(binPath)) {
+            await rm(binPath, { recursive: true, force: true });
+        }
+        // Ensure directories exist
+        await mkdir(paths.bin, { recursive: true });
+        await mkdir(tempDir, { recursive: true });
+        await mkdir(binPath, { recursive: true });
+        let success = false;
+        try {
+            onProgress?.({
+                stage: 'downloading',
+                message: 'Downloading FerretDB proxy...',
+            });
+            await this.downloadArchive(url, archiveFile, 'FerretDB');
+            if (platform === Platform.Win32) {
+                await this.extractWindowsBinaries(archiveFile, binPath, tempDir, onProgress);
+            }
+            else {
+                await this.extractUnixBinaries(archiveFile, binPath, tempDir, onProgress);
+            }
+            // Make binaries executable (Unix only)
+            if (platform !== Platform.Win32) {
+                const binDir = join(binPath, 'bin');
+                if (existsSync(binDir)) {
+                    const binaries = await readdir(binDir);
+                    for (const binary of binaries) {
+                        await chmod(join(binDir, binary), 0o755);
+                    }
+                }
+            }
+            // On macOS, re-sign binaries to fix code signature issues
+            if (platform === Platform.Darwin) {
+                onProgress?.({
+                    stage: 'signing',
+                    message: 'Re-signing FerretDB binaries for macOS...',
+                });
+                await this.resignMacOSBinaries(binPath);
+            }
+            // Verify the installation
+            onProgress?.({ stage: 'verifying', message: 'Verifying FerretDB...' });
+            await this.verifyFerretDB(fullVersion, platform, arch);
+            success = true;
+            return binPath;
+        }
+        finally {
+            // Clean up temp directory
+            await rm(tempDir, { recursive: true, force: true });
+            // Clean up binPath on failure
+            if (!success) {
+                await rm(binPath, { recursive: true, force: true });
+            }
+        }
+    }
+    /**
+     * Download postgresql-documentdb backend binary
+     */
+    async downloadDocumentDB(version, platform, arch, onProgress) {
+        const fullVersion = this.getFullDocumentDBVersion(version);
+        const binPath = this.getDocumentDBBinaryPath(fullVersion, platform, arch);
+        // Check if postgresql-documentdb is already installed
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const pgCtl = join(binPath, 'bin', `pg_ctl${ext}`);
+        if (existsSync(pgCtl)) {
+            onProgress?.({
+                stage: 'cached',
+                message: 'postgresql-documentdb already installed',
+            });
+            return binPath;
+        }
+        const url = getDocumentDBBinaryUrl(version, platform, arch);
+        const tempDir = join(paths.bin, `temp-postgresql-documentdb-${fullVersion}-${platform}-${arch}`);
+        const archiveFile = join(tempDir, 'postgresql-documentdb.tar.gz');
+        // Clean up any partial installation
+        if (existsSync(binPath)) {
+            await rm(binPath, { recursive: true, force: true });
+        }
+        // Ensure directories exist
+        await mkdir(paths.bin, { recursive: true });
+        await mkdir(tempDir, { recursive: true });
+        await mkdir(binPath, { recursive: true });
+        let success = false;
+        try {
+            onProgress?.({
+                stage: 'downloading',
+                message: 'Downloading postgresql-documentdb backend...',
+            });
+            await this.downloadArchive(url, archiveFile, 'postgresql-documentdb');
+            await this.extractUnixBinaries(archiveFile, binPath, tempDir, onProgress);
+            // Make binaries executable
+            const binaryDir = join(binPath, 'bin');
+            if (existsSync(binaryDir)) {
+                const binaries = await readdir(binaryDir);
+                for (const binary of binaries) {
+                    await chmod(join(binaryDir, binary), 0o755);
+                }
+            }
+            // On macOS, re-sign binaries and libraries to fix code signature issues
+            // (signatures become invalid after download due to quarantine/Gatekeeper)
+            if (platform === Platform.Darwin) {
+                onProgress?.({
+                    stage: 'signing',
+                    message: 'Re-signing binaries for macOS...',
+                });
+                await this.resignMacOSBinaries(binPath);
+            }
+            // Verify the installation
+            onProgress?.({
+                stage: 'verifying',
+                message: 'Verifying postgresql-documentdb...',
+            });
+            await this.verifyDocumentDB(fullVersion, platform, arch);
+            success = true;
+            return binPath;
+        }
+        finally {
+            // Clean up temp directory
+            await rm(tempDir, { recursive: true, force: true });
+            // Clean up binPath on failure
+            if (!success) {
+                await rm(binPath, { recursive: true, force: true });
+            }
+        }
+    }
+    /**
+     * Download an archive file
+     */
+    async downloadArchive(url, archiveFile, displayName) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+        try {
+            const response = await fetchWithRegistryFallback(url, {
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error(`${displayName} binaries not found (404). ` +
+                        'This version may have been removed from hostdb. ' +
+                        'Try a different version or check https://registry.layerbase.host');
+                }
+                throw new Error(`Failed to download ${displayName} binaries: ${response.status} ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error(`Download failed: response has no body (status ${response.status})`);
+            }
+            const fileStream = createWriteStream(archiveFile);
+            try {
+                const nodeStream = Readable.fromWeb(response.body);
+                await pipeline(nodeStream, fileStream);
+            }
+            catch (pipelineError) {
+                fileStream.destroy();
+                throw pipelineError;
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.name === 'AbortError') {
+                throw new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS / 1000 / 60} minutes. ` +
+                    'Check your network connection and try again.');
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Extract Unix binaries from tar.gz file
+     */
+    async extractUnixBinaries(tarFile, binPath, tempDir, onProgress) {
+        onProgress?.({
+            stage: 'extracting',
+            message: 'Extracting binaries...',
+        });
+        const extractDir = join(tempDir, 'extract');
+        await mkdir(extractDir, { recursive: true });
+        try {
+            await spawnAsync('tar', ['-xzf', tarFile, '-C', extractDir]);
+        }
+        catch (error) {
+            const err = error;
+            // Check if extraction actually succeeded despite the error
+            const entries = await readdir(extractDir);
+            if (entries.length === 0) {
+                throw new Error(`Extraction failed: ${err.message}${err.code ? ` (code: ${err.code})` : ''}`);
+            }
+            logDebug('FerretDB extraction recovered from tar error', {
+                tarFile,
+                entriesExtracted: entries.length,
+                errorMessage: err.message,
+                errorCode: err.code,
+            });
+        }
+        await this.moveExtractedEntries(extractDir, binPath);
+    }
+    /**
+     * Extract Windows binaries from ZIP file
+     *
+     * FerretDB v1 supports Windows. v2 does not (postgresql-documentdb startup issues).
+     */
+    async extractWindowsBinaries(zipFile, binPath, tempDir, onProgress) {
+        onProgress?.({
+            stage: 'extracting',
+            message: 'Extracting binaries...',
+        });
+        const extractDir = join(tempDir, 'extract');
+        await mkdir(extractDir, { recursive: true });
+        await extractWindowsArchive(zipFile, extractDir);
+        await this.moveExtractedEntries(extractDir, binPath);
+    }
+    /**
+     * Move extracted entries from extractDir to binPath
+     */
+    async moveExtractedEntries(extractDir, binPath) {
+        const entries = await readdir(extractDir, { withFileTypes: true });
+        // Look for engine directory (ferretdb-* or postgresql-documentdb-*)
+        const engineDir = entries.find((e) => e.isDirectory() &&
+            (e.name === 'ferretdb' ||
+                e.name.startsWith('ferretdb-') ||
+                e.name === 'postgresql-documentdb' ||
+                e.name.startsWith('postgresql-documentdb-')));
+        const sourceDir = engineDir ? join(extractDir, engineDir.name) : extractDir;
+        const sourceEntries = engineDir
+            ? await readdir(sourceDir, { withFileTypes: true })
+            : entries;
+        for (const entry of sourceEntries) {
+            const sourcePath = join(sourceDir, entry.name);
+            const destPath = join(binPath, entry.name);
+            try {
+                await rename(sourcePath, destPath);
+            }
+            catch (error) {
+                if (isRenameFallbackError(error)) {
+                    await cp(sourcePath, destPath, { recursive: true });
+                    await rm(sourcePath, { recursive: true, force: true });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    /**
+     * Verify FerretDB binary installation
+     */
+    async verifyFerretDB(version, platform, arch) {
+        const binPath = this.getFerretDBBinaryPath(version, platform, arch);
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const ferretdbBinary = join(binPath, 'bin', `ferretdb${ext}`);
+        if (!existsSync(ferretdbBinary)) {
+            throw new Error(`FerretDB binary not found at ${binPath}/bin/`);
+        }
+        // FerretDB v1 hostdb builds panic on --version due to missing version.txt
+        // at build time. For v1, just verify the binary exists (checked above).
+        if (isV1(version)) {
+            return;
+        }
+        try {
+            const { stdout } = await spawnAsync(ferretdbBinary, ['--version']);
+            const match = stdout.match(/(?:ferretdb\s+)?(?:version\s+)?v?(\d+\.\d+\.\d+)/);
+            if (!match) {
+                throw new Error(`Could not parse FerretDB version from: ${stdout.trim()}`);
+            }
+            const reportedVersion = match[1];
+            const expectedMajor = version.split('.')[0];
+            const reportedMajor = reportedVersion.split('.')[0];
+            if (expectedMajor !== reportedMajor) {
+                throw new Error(`Version mismatch: expected ${version}, got ${reportedVersion}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw new Error(`Failed to verify FerretDB binary: ${err.message}`);
+        }
+    }
+    /**
+     * Verify postgresql-documentdb binary installation
+     * Tests both pg_ctl and initdb since initdb is used during container creation
+     */
+    async verifyDocumentDB(version, platform, arch) {
+        const binPath = this.getDocumentDBBinaryPath(version, platform, arch);
+        const ext = platform === Platform.Win32 ? '.exe' : '';
+        const pgCtl = join(binPath, 'bin', `pg_ctl${ext}`);
+        const initdb = join(binPath, 'bin', `initdb${ext}`);
+        if (!existsSync(pgCtl)) {
+            throw new Error(`postgresql-documentdb binary not found at ${binPath}/bin/`);
+        }
+        if (!existsSync(initdb)) {
+            throw new Error(`initdb not found at ${binPath}/bin/ - required for container initialization`);
+        }
+        // Get spawn env for Linux (LD_LIBRARY_PATH)
+        const spawnEnv = this.getDocumentDBSpawnEnv(version, platform, arch);
+        // Verify pg_ctl works
+        try {
+            const { stdout } = await spawnAsync(pgCtl, ['--version'], {
+                env: spawnEnv,
+            });
+            // Expected output: "pg_ctl (PostgreSQL) 17.x.x"
+            const match = stdout.match(/PostgreSQL[)\s]+(\d+)/);
+            if (!match) {
+                throw new Error(`Could not parse PostgreSQL version from: ${stdout.trim()}`);
+            }
+            // version is like "17-0.107.0", extract PostgreSQL major version
+            const expectedPgMajor = version.split('-')[0];
+            const reportedPgMajor = match[1];
+            if (expectedPgMajor !== reportedPgMajor) {
+                throw new Error(`PostgreSQL version mismatch: expected ${expectedPgMajor}, got ${reportedPgMajor}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            // Check for library loading issues (common on macOS/Linux with hostdb binaries)
+            if (!err.code ||
+                err.code === 'ENOENT' ||
+                err.message.includes('dyld') ||
+                err.message.includes('GLIBC')) {
+                throw new Error(`postgresql-documentdb pg_ctl failed to execute. This is likely due to missing or incompatible libraries.\n` +
+                    `The hostdb binaries may need to be rebuilt with proper rpath settings.\n` +
+                    `See: https://github.com/robertjbass/hostdb/issues\n` +
+                    `Original error: ${err.message || 'Process killed (library loading failed)'}`);
+            }
+            throw new Error(`Failed to verify postgresql-documentdb pg_ctl: ${err.message}`);
+        }
+        // Verify initdb works (critical for container creation)
+        try {
+            const { stdout } = await spawnAsync(initdb, ['--version'], {
+                env: spawnEnv,
+            });
+            // Expected output: "initdb (PostgreSQL) 17.x.x"
+            const match = stdout.match(/PostgreSQL[)\s]+(\d+)/);
+            if (!match) {
+                throw new Error(`Could not parse initdb version from: ${stdout.trim()}`);
+            }
+            logDebug(`initdb verified: ${stdout.trim()}`);
+        }
+        catch (error) {
+            const err = error;
+            // Check for library loading issues
+            if (!err.code ||
+                err.code === 'ENOENT' ||
+                err.message.includes('dyld') ||
+                err.message.includes('GLIBC')) {
+                throw new Error(`postgresql-documentdb initdb failed to execute. This is likely due to missing or incompatible libraries.\n` +
+                    `initdb is required for FerretDB container initialization.\n` +
+                    `The hostdb binaries may need to be rebuilt with proper rpath settings.\n` +
+                    `See: https://github.com/robertjbass/hostdb/issues\n` +
+                    `Original error: ${err.message || 'Process killed (library loading failed)'}`);
+            }
+            throw new Error(`Failed to verify postgresql-documentdb initdb: ${err.message}`);
+        }
+    }
+    /**
+     * Delete installed binaries for a specific version
+     *
+     * For v1: Only deletes the FerretDB proxy. Plain PostgreSQL binaries are shared
+     * with standalone PostgreSQL containers and should NOT be deleted.
+     *
+     * For v2: Deletes both FerretDB proxy and postgresql-documentdb backend.
+     */
+    async delete(version, platform, arch, backendVersion = DEFAULT_DOCUMENTDB_VERSION) {
+        const fullVersion = this.getFullVersion(version);
+        const ferretdbPath = this.getFerretDBBinaryPath(fullVersion, platform, arch);
+        if (existsSync(ferretdbPath)) {
+            await rm(ferretdbPath, { recursive: true, force: true });
+        }
+        // v1: Don't delete shared PostgreSQL binaries (cascadeDelete: false)
+        if (isV1(version)) {
+            logDebug('Skipping PostgreSQL backend deletion for FerretDB v1 (shared with standalone PG containers)');
+            return;
+        }
+        // v2: Delete postgresql-documentdb backend
+        const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion);
+        const documentdbPath = this.getDocumentDBBinaryPath(fullBackendVersion, platform, arch);
+        if (existsSync(documentdbPath)) {
+            await rm(documentdbPath, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Re-sign macOS binaries with ad-hoc signature
+     *
+     * Downloaded binaries may have invalid signatures due to Gatekeeper quarantine.
+     * Re-signing with ad-hoc signature (-s -) allows them to run without issues.
+     */
+    async resignMacOSBinaries(binPath) {
+        // Sign all dylibs first (binaries depend on them)
+        const libDir = join(binPath, 'lib');
+        if (existsSync(libDir)) {
+            const libs = await readdir(libDir);
+            for (const lib of libs) {
+                if (lib.endsWith('.dylib')) {
+                    const libPath = join(libDir, lib);
+                    try {
+                        await spawnAsync('codesign', [
+                            '--force',
+                            '--deep',
+                            '-s',
+                            '-',
+                            libPath,
+                        ]);
+                    }
+                    catch {
+                        // Ignore signing errors for individual libs
+                        logDebug(`Failed to sign ${lib}, continuing...`);
+                    }
+                }
+            }
+            // Also sign libs in postgresql/ subdirectory if it exists
+            const pgLibDir = join(libDir, 'postgresql');
+            if (existsSync(pgLibDir)) {
+                const pgLibs = await readdir(pgLibDir);
+                for (const lib of pgLibs) {
+                    if (lib.endsWith('.dylib')) {
+                        const libPath = join(pgLibDir, lib);
+                        try {
+                            await spawnAsync('codesign', [
+                                '--force',
+                                '--deep',
+                                '-s',
+                                '-',
+                                libPath,
+                            ]);
+                        }
+                        catch {
+                            logDebug(`Failed to sign ${lib}, continuing...`);
+                        }
+                    }
+                }
+            }
+        }
+        // Sign all binaries
+        const binDir = join(binPath, 'bin');
+        if (existsSync(binDir)) {
+            const binaries = await readdir(binDir);
+            for (const binary of binaries) {
+                const binaryPath = join(binDir, binary);
+                try {
+                    await spawnAsync('codesign', [
+                        '--force',
+                        '--deep',
+                        '-s',
+                        '-',
+                        binaryPath,
+                    ]);
+                }
+                catch {
+                    // Ignore signing errors for individual binaries
+                    logDebug(`Failed to sign ${binary}, continuing...`);
+                }
+            }
+        }
+    }
+}
+export const ferretdbBinaryManager = new FerretDBCompositeBinaryManager();
+//# sourceMappingURL=binary-manager.js.map