spindb 0.34.5 → 0.35.3

package/engines/ferretdb/index.ts

@@ -11,7 +11,12 @@
  * - Stop: Stop FerretDB → Stop PostgreSQL
  */
 
-import { spawn, exec, type SpawnOptions } from 'child_process'
+import {
+  spawn,
+  exec,
+  type ChildProcess,
+  type SpawnOptions,
+} from 'child_process'
 import { promisify } from 'util'
 import { existsSync } from 'fs'
 import net from 'net'
@@ -43,8 +48,10 @@ import {
   SUPPORTED_MAJOR_VERSIONS,
   FALLBACK_VERSION_MAP,
   DEFAULT_DOCUMENTDB_VERSION,
+  DEFAULT_V1_POSTGRESQL_VERSION,
   normalizeVersion,
   normalizeDocumentDBVersion,
+  isV1,
 } from './version-maps'
 import { getBinaryUrls, isPlatformSupported } from './binary-urls'
 import {
@@ -157,6 +164,76 @@ function waitForPort(port: number, timeoutMs = 30000): Promise<boolean> {
   })
 }
 
+/**
+ * Spawn a process and pipe input to its stdin.
+ * Used for `postgres --single` which reads SQL from stdin.
+ */
+function spawnWithInput(
+  command: string,
+  args: string[],
+  input: string,
+  options?: { env?: Record<string, string>; timeout?: number },
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    let proc: ChildProcess
+    try {
+      proc = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: options?.env ? { ...process.env, ...options.env } : undefined,
+      })
+    } catch (error) {
+      reject(error)
+      return
+    }
+
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+
+    const timer = options?.timeout
+      ? setTimeout(() => {
+          timedOut = true
+          proc.kill('SIGKILL')
+          reject(
+            new Error(
+              `Command "${command}" timed out after ${options.timeout}ms`,
+            ),
+          )
+        }, options.timeout)
+      : undefined
+
+    proc.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString()
+    })
+    proc.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    proc.on('close', (code) => {
+      if (timer) clearTimeout(timer)
+      if (timedOut) return
+      if (code === 0) {
+        resolve({ stdout, stderr })
+      } else {
+        reject(
+          new Error(
+            `Command "${command}" failed with code ${code}: ${stderr || stdout}`,
+          ),
+        )
+      }
+    })
+
+    proc.on('error', (err) => {
+      if (timer) clearTimeout(timer)
+      if (timedOut) return
+      reject(err)
+    })
+
+    proc.stdin?.write(input)
+    proc.stdin?.end()
+  })
+}
+
 export class FerretDBEngine extends BaseEngine {
   name = ENGINE
   displayName = 'FerretDB'
@@ -170,10 +247,11 @@ export class FerretDBEngine extends BaseEngine {
 
   /**
    * Check if the current platform supports FerretDB
+   * @param version - Optional version to check (v1 supports Windows, v2 does not)
    */
-  isPlatformSupported(): boolean {
+  isPlatformSupported(version?: string): boolean {
     const { platform, arch } = this.getPlatformInfo()
-    return isPlatformSupported(platform, arch)
+    return isPlatformSupported(platform, arch, version)
   }
 
   /**
@@ -193,12 +271,10 @@ export class FerretDBEngine extends BaseEngine {
 
   // Get binary download URL from hostdb
   getBinaryUrl(version: string, platform: Platform, arch: Arch): string {
-    const urls = getBinaryUrls(
-      version,
-      DEFAULT_DOCUMENTDB_VERSION,
-      platform,
-      arch,
-    )
+    const backendVersion = isV1(version)
+      ? DEFAULT_V1_POSTGRESQL_VERSION
+      : DEFAULT_DOCUMENTDB_VERSION
+    const urls = getBinaryUrls(version, backendVersion, platform, arch)
     return urls.ferretdb
   }
 
@@ -224,12 +300,10 @@ export class FerretDBEngine extends BaseEngine {
     const { platform: p, arch: a } = this.getPlatformInfo()
 
     if (version) {
-      return ferretdbBinaryManager.isInstalled(
-        version,
-        p,
-        a,
-        DEFAULT_DOCUMENTDB_VERSION,
-      )
+      const backendVersion = isV1(version)
+        ? DEFAULT_V1_POSTGRESQL_VERSION
+        : DEFAULT_DOCUMENTDB_VERSION
+      return ferretdbBinaryManager.isInstalled(version, p, a, backendVersion)
     }
 
     // Fallback: extract version from directory name
@@ -237,11 +311,14 @@ export class FerretDBEngine extends BaseEngine {
     const match = dirName.match(/^ferretdb-([\d.]+)-/)
     if (match) {
       const extractedVersion = match[1]
+      const backendVersion = isV1(extractedVersion)
+        ? DEFAULT_V1_POSTGRESQL_VERSION
+        : DEFAULT_DOCUMENTDB_VERSION
       return ferretdbBinaryManager.isInstalled(
         extractedVersion,
         p,
         a,
-        DEFAULT_DOCUMENTDB_VERSION,
+        backendVersion,
       )
     }
 
@@ -254,11 +331,14 @@ export class FerretDBEngine extends BaseEngine {
   // Check if a specific FerretDB version is installed
   async isBinaryInstalled(version: string): Promise<boolean> {
     const { platform, arch } = this.getPlatformInfo()
+    const backendVersion = isV1(version)
+      ? DEFAULT_V1_POSTGRESQL_VERSION
+      : DEFAULT_DOCUMENTDB_VERSION
     return ferretdbBinaryManager.isInstalled(
       version,
       platform,
       arch,
-      DEFAULT_DOCUMENTDB_VERSION,
+      backendVersion,
     )
   }
 
@@ -270,14 +350,17 @@ export class FerretDBEngine extends BaseEngine {
     onProgress?: ProgressCallback,
   ): Promise<string> {
     const { platform, arch } = this.getPlatformInfo()
+    const backendVersion = isV1(version)
+      ? DEFAULT_V1_POSTGRESQL_VERSION
+      : DEFAULT_DOCUMENTDB_VERSION
 
-    // Download both binaries
+    // Download binaries (proxy + backend)
     const { ferretdbPath } = await ferretdbBinaryManager.ensureInstalled(
       version,
       platform,
       arch,
       onProgress,
-      DEFAULT_DOCUMENTDB_VERSION,
+      backendVersion,
     )
 
     // Register ferretdb binary in config
@@ -290,6 +373,41 @@ export class FerretDBEngine extends BaseEngine {
     return ferretdbPath
   }
 
+  /**
+   * Get backend binary paths and spawn environment for a container.
+   * Centralizes the v1/v2 branching logic for backend resolution.
+   */
+  private getBackendPaths(
+    version: string,
+    backendVersion: string,
+    platform: Platform,
+    arch: Arch,
+  ): { backendPath: string; pgSpawnEnv: Record<string, string> | undefined } {
+    const fullVersion = normalizeVersion(version)
+    const backendPath = ferretdbBinaryManager.getBackendBinaryPath(
+      fullVersion,
+      backendVersion,
+      platform,
+      arch,
+    )
+
+    const baseSpawnEnv = ferretdbBinaryManager.getBackendSpawnEnv(
+      fullVersion,
+      backendVersion,
+      platform,
+      arch,
+    )
+    const pgSpawnEnv =
+      platform === 'darwin'
+        ? {
+            ...baseSpawnEnv,
+            DYLD_FALLBACK_LIBRARY_PATH: join(backendPath, 'lib'),
+          }
+        : baseSpawnEnv
+
+    return { backendPath, pgSpawnEnv }
+  }
+
   /**
    * Initialize a new FerretDB container directory
    * Creates both the PostgreSQL data directory and FerretDB config
@@ -300,17 +418,16 @@ export class FerretDBEngine extends BaseEngine {
     options: Record<string, unknown> = {},
   ): Promise<string> {
     const { platform, arch } = this.getPlatformInfo()
+    const version = normalizeVersion(_version)
+    const v1 = isV1(version)
 
-    // Get binary paths
-    const backendVersion =
-      (options.backendVersion as string) || DEFAULT_DOCUMENTDB_VERSION
-    const fullBackendVersion = normalizeDocumentDBVersion(backendVersion)
+    // Get binary paths - resolve backend based on v1/v2
+    const backendVersion = v1
+      ? (options.backendVersion as string) || DEFAULT_V1_POSTGRESQL_VERSION
+      : (options.backendVersion as string) || DEFAULT_DOCUMENTDB_VERSION
 
-    const documentdbPath = ferretdbBinaryManager.getDocumentDBBinaryPath(
-      fullBackendVersion,
-      platform,
-      arch,
-    )
+    const { backendPath: documentdbPath, pgSpawnEnv: initSpawnEnv } =
+      this.getBackendPaths(version, backendVersion, platform, arch)
 
     // Container directory structure
     const containerDir = paths.getContainerPath(containerName, {
@@ -335,13 +452,6 @@ export class FerretDBEngine extends BaseEngine {
         throw new Error(`initdb not found at ${initdb}`)
       }
 
-      // Get spawn env for Linux (LD_LIBRARY_PATH)
-      const spawnEnv = ferretdbBinaryManager.getDocumentDBSpawnEnv(
-        fullBackendVersion,
-        platform,
-        arch,
-      )
-
       // Homebrew-derived x64 binaries have compiled-in absolute paths for
       // sharedir, pkglibdir ($libdir), and libdir that don't exist when running
       // from ~/.spindb/bin/. We fix this by:
@@ -355,10 +465,9 @@ export class FerretDBEngine extends BaseEngine {
           ? join(shareDirBase, 'postgresql')
           : shareDirBase
 
-      // Homebrew-derived binaries have compiled-in absolute paths that only
-      // need fixup on macOS. On Linux the paths are relative or handled by
-      // LD_LIBRARY_PATH, so skip the pg_config symlink fixups entirely.
-      if (platform === 'darwin') {
+      // v2 only: Homebrew-derived DocumentDB binaries need compiled-in path fixups
+      // v1 uses plain PostgreSQL which has correct relative paths
+      if (!v1 && platform === 'darwin') {
         const pgConfigBin = join(documentdbPath, 'bin', `pg_config${ext}`)
         if (existsSync(pgConfigBin)) {
           // Query all relevant compiled-in paths and create symlinks where needed
@@ -420,17 +529,15 @@ export class FerretDBEngine extends BaseEngine {
             }
           }
         }
-      } else {
+      } else if (!v1) {
         logDebug(
           'Skipping pg_config symlink fixups (not required on this platform)',
         )
       }
 
-      // On macOS, fix hardcoded Homebrew dylib paths in extension libraries.
-      // The x64 build may have extensions (e.g. pg_documentdb_core.dylib) that
-      // reference Homebrew libraries (e.g. libbson2.2.dylib from mongo-c-driver)
-      // via absolute paths that don't exist on the target machine.
-      if (platform === 'darwin') {
+      // v2 only: Fix hardcoded Homebrew dylib paths in DocumentDB extension libraries
+      // v1 uses plain PostgreSQL which doesn't have DocumentDB extensions
+      if (!v1 && platform === 'darwin') {
         const dylibMarker = join(documentdbPath, '.dylib_fix_done')
         if (!existsSync(dylibMarker)) {
           await this.fixDylibDependencies(documentdbPath)
@@ -442,16 +549,6 @@ export class FerretDBEngine extends BaseEngine {
         }
       }
 
-      // On macOS, set DYLD_FALLBACK_LIBRARY_PATH as additional library search path.
-      // Unlike DYLD_LIBRARY_PATH, this is NOT stripped by SIP.
-      const initdbEnv =
-        platform === 'darwin'
-          ? {
-              ...spawnEnv,
-              DYLD_FALLBACK_LIBRARY_PATH: join(documentdbPath, 'lib'),
-            }
-          : spawnEnv
-
       try {
         await spawnAsync(
           initdb,
@@ -465,7 +562,7 @@ export class FerretDBEngine extends BaseEngine {
             '-L',
             actualShareDir,
           ],
-          { env: initdbEnv, timeout: 60000 },
+          { env: initSpawnEnv, timeout: 60000 },
         )
         logDebug(`Initialized PostgreSQL data directory: ${pgDataDir}`)
       } catch (error) {
@@ -473,37 +570,40 @@ export class FerretDBEngine extends BaseEngine {
         throw new Error(`Failed to initialize PostgreSQL: ${err.message}`)
       }
 
-      // Copy the bundled postgresql.conf.sample to ensure shared_preload_libraries is set
+      // v2 only: Copy the bundled postgresql.conf.sample to ensure shared_preload_libraries is set
       // This is critical for DocumentDB extension to load properly
-      const bundledConf = existsSync(
-        join(shareDirBase, 'postgresql.conf.sample'),
-      )
-        ? join(shareDirBase, 'postgresql.conf.sample')
-        : join(shareDirBase, 'postgresql', 'postgresql.conf.sample')
-      const pgConf = join(pgDataDir, 'postgresql.conf')
-
-      if (existsSync(bundledConf)) {
-        try {
-          // Read the bundled config
-          let confContent = await readFile(bundledConf, 'utf8')
-
-          // Update cron.database_name to 'ferretdb' (required for pg_cron to work with DocumentDB)
-          confContent = confContent.replace(
-            /cron\.database_name\s*=\s*'[^']*'/,
-            "cron.database_name = 'ferretdb'",
-          )
+      // v1 uses initdb defaults (no DocumentDB extensions to preload)
+      if (!v1) {
+        const bundledConf = existsSync(
+          join(shareDirBase, 'postgresql.conf.sample'),
+        )
+          ? join(shareDirBase, 'postgresql.conf.sample')
+          : join(shareDirBase, 'postgresql', 'postgresql.conf.sample')
+        const pgConf = join(pgDataDir, 'postgresql.conf')
 
-          // Write the modified config
-          await writeFile(pgConf, confContent)
-          logDebug(`Copied and configured postgresql.conf to ${pgConf}`)
-        } catch (copyError) {
-          logDebug(
-            `Warning: Could not copy postgresql.conf.sample: ${copyError}`,
-          )
-          // Continue anyway - initdb creates a default config
+        if (existsSync(bundledConf)) {
+          try {
+            // Read the bundled config
+            let confContent = await readFile(bundledConf, 'utf8')
+
+            // Update cron.database_name to 'ferretdb' (required for pg_cron to work with DocumentDB)
+            confContent = confContent.replace(
+              /cron\.database_name\s*=\s*'[^']*'/,
+              "cron.database_name = 'ferretdb'",
+            )
+
+            // Write the modified config
+            await writeFile(pgConf, confContent)
+            logDebug(`Copied and configured postgresql.conf to ${pgConf}`)
+          } catch (copyError) {
+            logDebug(
+              `Warning: Could not copy postgresql.conf.sample: ${copyError}`,
+            )
+            // Continue anyway - initdb creates a default config
+          }
+        } else {
+          logDebug(`Bundled postgresql.conf.sample not found at ${bundledConf}`)
         }
-      } else {
-        logDebug(`Bundled postgresql.conf.sample not found at ${bundledConf}`)
       }
     }
 
@@ -545,42 +645,32 @@ export class FerretDBEngine extends BaseEngine {
 
     const { platform, arch } = this.getPlatformInfo()
     const fullVersion = normalizeVersion(version)
-    const fullBackendVersion = normalizeDocumentDBVersion(
-      backendVersion || DEFAULT_DOCUMENTDB_VERSION,
-    )
+    const v1 = isV1(version)
+    const effectiveBackendVersion = v1
+      ? backendVersion || DEFAULT_V1_POSTGRESQL_VERSION
+      : normalizeDocumentDBVersion(backendVersion || DEFAULT_DOCUMENTDB_VERSION)
 
-    // Get binary paths
+    // Get binary paths using version-aware helper
     const ferretdbPath = ferretdbBinaryManager.getFerretDBBinaryPath(
       fullVersion,
       platform,
       arch,
     )
-    const documentdbPath = ferretdbBinaryManager.getDocumentDBBinaryPath(
-      fullBackendVersion,
+    const { backendPath: documentdbPath, pgSpawnEnv } = this.getBackendPaths(
+      version,
+      effectiveBackendVersion,
       platform,
       arch,
     )
 
-    // Get spawn env for postgresql-documentdb binaries:
-    // - Linux: LD_LIBRARY_PATH for shared libraries
-    // - macOS: DYLD_FALLBACK_LIBRARY_PATH (not stripped by SIP)
-    const baseSpawnEnv = ferretdbBinaryManager.getDocumentDBSpawnEnv(
-      fullBackendVersion,
-      platform,
-      arch,
-    )
-    const pgSpawnEnv =
-      platform === 'darwin'
-        ? {
-            ...baseSpawnEnv,
-            DYLD_FALLBACK_LIBRARY_PATH: join(documentdbPath, 'lib'),
-          }
-        : baseSpawnEnv
-
     const ext = platformService.getExecutableExtension()
     const ferretdbBinary = join(ferretdbPath, 'bin', `ferretdb${ext}`)
     const pgCtl = join(documentdbPath, 'bin', `pg_ctl${ext}`)
-    const psql = join(documentdbPath, 'bin', `psql${ext}`)
+    // v1 backend may be a minimal PostgreSQL install (shared with DocumentDB) that
+    // lacks client tools. Use postgres --single as fallback for database creation.
+    const psqlCandidate = join(documentdbPath, 'bin', `psql${ext}`)
+    const psql = existsSync(psqlCandidate) ? psqlCandidate : null
+    const postgresBinary = join(documentdbPath, 'bin', `postgres${ext}`)
 
     // Verify binaries exist
     if (!existsSync(ferretdbBinary)) {
@@ -604,9 +694,10 @@ export class FerretDBEngine extends BaseEngine {
     // Allocate backend port
     const backendPort = existingBackendPort || (await allocateBackendPort())
 
-    // Fix hardcoded Homebrew dylib paths (darwin-x64 binaries)
+    // v2 only: Fix hardcoded Homebrew dylib paths (darwin-x64 binaries)
     // Skip if already completed (marker written by initDataDir or a previous start)
-    if (platform === 'darwin') {
+    // v1 uses plain PostgreSQL which doesn't have DocumentDB extensions
+    if (!v1 && platform === 'darwin') {
       const dylibMarker = join(documentdbPath, '.dylib_fix_done')
       if (!existsSync(dylibMarker)) {
         await this.fixDylibDependencies(documentdbPath)
@@ -642,13 +733,46 @@ export class FerretDBEngine extends BaseEngine {
         // Exit code != 0 means not running — proceed to start
       }
 
+      // v1 pre-start: Create ferretdb database using postgres --single mode
+      // when psql is unavailable (minimal PG install may lack client tools).
+      // postgres --single requires exclusive data dir access, so this MUST
+      // happen before pg_ctl start.
+      if (v1 && !psql && !pgAlreadyRunning) {
+        logDebug(
+          'psql not found in backend, using postgres --single to pre-create database',
+        )
+        try {
+          await spawnWithInput(
+            postgresBinary,
+            ['--single', '-D', pgDataDir, 'postgres'],
+            "CREATE DATABASE ferretdb ENCODING 'UTF8';\n",
+            { env: pgSpawnEnv, timeout: 30000 },
+          )
+          logDebug('Pre-created ferretdb database via postgres --single')
+        } catch {
+          // Database may already exist from a previous start — safe to ignore
+          logDebug(
+            'postgres --single CREATE DATABASE failed (may already exist)',
+          )
+        }
+      }
+
       if (!pgAlreadyRunning) {
         // Use pg_ctl to start PostgreSQL
-        // Add 60s timeout to prevent hanging if PostgreSQL fails to start (especially on Windows)
+        // On Windows, spawnAsync pipes stdout/stderr which get inherited by the
+        // PostgreSQL background process, preventing the 'close' event from firing
+        // until PG itself exits (causing a 60s timeout even though PG is ready).
+        // Use exec() on Windows (matches process-manager.ts approach) which runs
+        // through the shell and doesn't hold pipes open. On Unix, use -w (wait mode).
         try {
-          await spawnAsync(
-            pgCtl,
-            [
+          if (isWindows()) {
+            const cmd = `"${pgCtl}" start -D "${pgDataDir}" -l "${pgLogFile}" -o "-p ${backendPort} -h 127.0.0.1"`
+            await execAsync(cmd, {
+              env: { ...process.env, ...pgSpawnEnv },
+              timeout: 30000,
+            })
+          } else {
+            const pgCtlArgs = [
               'start',
               '-D',
               pgDataDir,
@@ -656,10 +780,13 @@ export class FerretDBEngine extends BaseEngine {
               pgLogFile,
               '-o',
               `-p ${backendPort} -h 127.0.0.1`,
-              '-w', // Wait for startup
-            ],
-            { env: pgSpawnEnv, timeout: 60000 },
-          )
+              '-w',
+            ]
+            await spawnAsync(pgCtl, pgCtlArgs, {
+              env: pgSpawnEnv,
+              timeout: 60000,
+            })
+          }
         } catch (pgError) {
           // Read PostgreSQL log for debugging
           let pgLog = ''
@@ -686,56 +813,60 @@ export class FerretDBEngine extends BaseEngine {
       }
 
       // 3. Create ferretdb database and extension (first start)
-      onProgress?.({
-        stage: 'starting',
-        message: 'Initializing FerretDB database...',
-      })
-      try {
-        // Create ferretdb database if it doesn't exist
-        // Add timeout to prevent hanging on Windows
-        await spawnAsync(
-          psql,
-          [
-            '-h',
-            '127.0.0.1',
-            '-p',
-            String(backendPort),
-            '-U',
-            'postgres',
-            '-c',
-            "CREATE DATABASE ferretdb WITH ENCODING 'UTF8';",
-          ],
-          { env: pgSpawnEnv, timeout: 30000 },
-        ).catch(() => {
-          // Ignore error if database already exists (error code 42P04)
+      // For v1 without psql, database was already created pre-start via postgres --single
+      if (psql) {
+        onProgress?.({
+          stage: 'starting',
+          message: 'Initializing FerretDB database...',
         })
+        try {
+          // Create ferretdb database if it doesn't exist
+          await spawnAsync(
+            psql,
+            [
+              '-h',
+              '127.0.0.1',
+              '-p',
+              String(backendPort),
+              '-U',
+              'postgres',
+              '-c',
+              "CREATE DATABASE ferretdb WITH ENCODING 'UTF8';",
+            ],
+            { env: pgSpawnEnv, timeout: 30000 },
+          ).catch(() => {
+            // Ignore error if database already exists (error code 42P04)
+          })
 
-        // Create DocumentDB extension
-        // Add timeout to prevent hanging on Windows
-        await spawnAsync(
-          psql,
-          [
-            '-h',
-            '127.0.0.1',
-            '-p',
-            String(backendPort),
-            '-U',
-            'postgres',
-            '-d',
-            'ferretdb',
-            '-c',
-            'CREATE EXTENSION IF NOT EXISTS documentdb CASCADE;',
-          ],
-          { env: pgSpawnEnv, timeout: 30000 },
-        ).catch((error) => {
-          logWarning(`Failed to create documentdb extension: ${error}`)
-          // Continue anyway - extension might already exist
-        })
+          // v2 only: Create DocumentDB extension
+          // v1 uses plain PostgreSQL without DocumentDB
+          if (!v1) {
+            await spawnAsync(
+              psql,
+              [
+                '-h',
+                '127.0.0.1',
+                '-p',
+                String(backendPort),
+                '-U',
+                'postgres',
+                '-d',
+                'ferretdb',
+                '-c',
+                'CREATE EXTENSION IF NOT EXISTS documentdb CASCADE;',
+              ],
+              { env: pgSpawnEnv, timeout: 30000 },
+            ).catch((error) => {
+              logWarning(`Failed to create documentdb extension: ${error}`)
+              // Continue anyway - extension might already exist
+            })
+          }
 
-        logDebug('FerretDB database initialized')
-      } catch (error) {
-        logDebug(`Database initialization warning: ${error}`)
-        // Continue - might already be initialized
+          logDebug('FerretDB database initialized')
+        } catch (error) {
+          logDebug(`Database initialization warning: ${error}`)
+          // Continue - might already be initialized
+        }
       }
 
       // 4. Start FerretDB proxy
@@ -773,14 +904,22 @@ export class FerretDBEngine extends BaseEngine {
 
       logDebug(`Using debug port ${debugPort} for FerretDB HTTP debug handler`)
 
+      // v1 uses plain PostgreSQL without TLS configured, so sslmode=disable is required
+      // v2 uses postgresql-documentdb which handles SSL negotiation internally
+      const pgUrl = isV1(version)
+        ? `postgres://postgres@127.0.0.1:${backendPort}/ferretdb?sslmode=disable`
+        : `postgres://postgres@127.0.0.1:${backendPort}/ferretdb`
+
       const ferretArgs = [
         '--listen-addr',
         `127.0.0.1:${port}`,
         '--postgresql-url',
-        `postgres://postgres@127.0.0.1:${backendPort}/ferretdb`,
+        pgUrl,
         '--state-dir',
         containerDir,
-        '--no-auth',
+        // v2 requires --no-auth to disable SCRAM authentication
+        // v1 has auth disabled by default (flag doesn't exist)
+        ...(isV1(version) ? [] : ['--no-auth']),
         '--debug-addr',
         `127.0.0.1:${debugPort}`,
       ]
@@ -853,32 +992,20 @@ export class FerretDBEngine extends BaseEngine {
    * Stop FerretDB (reverse order: FerretDB first, then PostgreSQL)
    */
   async stop(container: ContainerConfig): Promise<void> {
-    const { name, backendVersion } = container
+    const { name, version, backendVersion } = container
     const { platform, arch } = this.getPlatformInfo()
+    const v1 = isV1(version)
 
-    const fullBackendVersion = normalizeDocumentDBVersion(
-      backendVersion || DEFAULT_DOCUMENTDB_VERSION,
-    )
+    const effectiveBackendVersion = v1
+      ? backendVersion || DEFAULT_V1_POSTGRESQL_VERSION
+      : backendVersion || DEFAULT_DOCUMENTDB_VERSION
 
-    const documentdbPath = ferretdbBinaryManager.getDocumentDBBinaryPath(
-      fullBackendVersion,
-      platform,
-      arch,
-    )
-
-    // Get spawn env for postgresql-documentdb binaries
-    const baseStopEnv = ferretdbBinaryManager.getDocumentDBSpawnEnv(
-      fullBackendVersion,
+    const { backendPath: documentdbPath, pgSpawnEnv } = this.getBackendPaths(
+      version,
+      effectiveBackendVersion,
       platform,
       arch,
     )
-    const pgSpawnEnv =
-      platform === 'darwin'
-        ? {
-            ...baseStopEnv,
-            DYLD_FALLBACK_LIBRARY_PATH: join(documentdbPath, 'lib'),
-          }
-        : baseStopEnv
 
     const ext = platformService.getExecutableExtension()
     const pgCtl = join(documentdbPath, 'bin', `pg_ctl${ext}`)
@@ -1002,13 +1129,32 @@ export class FerretDBEngine extends BaseEngine {
     const pidFile = join(containerDir, 'ferretdb.pid')
 
     if (existsSync(pidFile)) {
+      let pid = NaN
       try {
         const pidContent = await readFile(pidFile, 'utf8')
-        const pid = parseInt(pidContent.trim(), 10)
+        pid = parseInt(pidContent.trim(), 10)
+      } catch {
+        // PID file unreadable — clean it up below
+      }
+
+      if (!isNaN(pid) && platformService.isProcessRunning(pid)) {
+        logDebug(`Killing FerretDB process ${pid}`)
 
-        if (!isNaN(pid) && platformService.isProcessRunning(pid)) {
-          logDebug(`Killing FerretDB process ${pid}`)
-          await platformService.terminateProcess(pid, false)
+        // On Windows, taskkill without /F sends WM_CLOSE which console/server
+        // processes ignore, causing an error. Use force kill directly.
+        if (isWindows()) {
+          try {
+            await platformService.terminateProcess(pid, true)
+          } catch {
+            logDebug(`Force kill of FerretDB process ${pid} failed`)
+          }
+        } else {
+          // Unix: try graceful SIGTERM first, then SIGKILL
+          try {
+            await platformService.terminateProcess(pid, false)
+          } catch {
+            // Graceful termination failed — force kill below
+          }
 
           // Poll until process exits or timeout (10 seconds)
           const maxWaitMs = 10000
@@ -1026,14 +1172,26 @@ export class FerretDBEngine extends BaseEngine {
           // Force kill if still running after timeout
           if (platformService.isProcessRunning(pid)) {
             logWarning(`Graceful termination timed out, force killing ${pid}`)
-            await platformService.terminateProcess(pid, true)
+            try {
+              await platformService.terminateProcess(pid, true)
+            } catch {
+              logDebug(`Force kill of FerretDB process ${pid} failed`)
+            }
           }
         }
 
-        await unlink(pidFile).catch(() => {})
-      } catch (error) {
-        logDebug(`Error stopping FerretDB: ${error}`)
+        // Wait briefly for process to fully exit after force kill
+        const exitWaitMs = isWindows() ? 3000 : 1000
+        const pollMs = 100
+        const exitStart = Date.now()
+        while (Date.now() - exitStart < exitWaitMs) {
+          if (!platformService.isProcessRunning(pid)) break
+          await new Promise((resolve) => setTimeout(resolve, pollMs))
+        }
       }
+
+      // Always clean up PID file
+      await unlink(pidFile).catch(() => {})
     }
   }
 
@@ -1045,24 +1203,45 @@ export class FerretDBEngine extends BaseEngine {
     pgDataDir: string,
     spawnEnv?: Record<string, string>,
   ): Promise<void> {
-    try {
-      // Add timeout to prevent hanging on Windows
-      await spawnAsync(pgCtl, ['stop', '-D', pgDataDir, '-m', 'fast', '-w'], {
-        env: spawnEnv,
-        timeout: 30000,
-      })
-      logDebug('PostgreSQL stopped')
-    } catch (error) {
-      logDebug(`pg_ctl stop error: ${error}`)
-      // Try immediate mode if fast fails
+    if (isWindows()) {
+      // On Windows, use exec() instead of spawnAsync() to avoid pipe-related
+      // hangs (same issue as pg_ctl start -w). pg_ctl stop -w can block when
+      // stdout/stderr pipes prevent the child process from exiting cleanly.
       try {
-        await spawnAsync(
-          pgCtl,
-          ['stop', '-D', pgDataDir, '-m', 'immediate', '-w'],
-          { env: spawnEnv, timeout: 15000 },
-        )
-      } catch {
-        logWarning('Failed to stop PostgreSQL gracefully')
+        await execAsync(`"${pgCtl}" stop -D "${pgDataDir}" -m fast -w`, {
+          timeout: 30000,
+          env: spawnEnv ? { ...process.env, ...spawnEnv } : undefined,
+        })
+        logDebug('PostgreSQL stopped')
+      } catch (error) {
+        logDebug(`pg_ctl stop error: ${error}`)
+        try {
+          await execAsync(`"${pgCtl}" stop -D "${pgDataDir}" -m immediate -w`, {
+            timeout: 15000,
+            env: spawnEnv ? { ...process.env, ...spawnEnv } : undefined,
+          })
+        } catch {
+          logWarning('Failed to stop PostgreSQL gracefully')
+        }
+      }
+    } else {
+      try {
+        await spawnAsync(pgCtl, ['stop', '-D', pgDataDir, '-m', 'fast', '-w'], {
+          env: spawnEnv,
+          timeout: 30000,
+        })
+        logDebug('PostgreSQL stopped')
+      } catch (error) {
+        logDebug(`pg_ctl stop error: ${error}`)
+        try {
+          await spawnAsync(
+            pgCtl,
+            ['stop', '-D', pgDataDir, '-m', 'immediate', '-w'],
+            { env: spawnEnv, timeout: 15000 },
+          )
+        } catch {
+          logWarning('Failed to stop PostgreSQL gracefully')
+        }
       }
     }
   }
@@ -1136,10 +1315,41 @@ export class FerretDBEngine extends BaseEngine {
     // Validate database name before restore (defense-in-depth)
     assertValidDatabaseName(database)
 
-    return restoreBackup(container, backupPath, {
+    const result = await restoreBackup(container, backupPath, {
       database,
       drop: options.drop !== false,
     })
+
+    // Restart FerretDB proxy so it picks up the restored data.
+    // pg_restore writes directly to PostgreSQL, but FerretDB's proxy
+    // caches schema/collection metadata in memory and won't see
+    // the restored collections until restarted.
+    const containerDir = paths.getContainerPath(container.name, {
+      engine: ENGINE,
+    })
+    try {
+      await this.stopFerretDBProcess(containerDir)
+      // start() detects PG is already running and only launches the proxy
+      await this.start(container)
+    } catch (error) {
+      const err = error as Error
+      logWarning(
+        `Failed to restart FerretDB proxy after restore: ${err.message}`,
+      )
+      // Retry once — transient issues (port race, slow PG) can resolve on second attempt
+      try {
+        await this.stopFerretDBProcess(containerDir).catch(() => {})
+        await this.start(container)
+      } catch {
+        throw new Error(
+          `Restore succeeded but FerretDB proxy failed to restart. ` +
+            `Data is safely in PostgreSQL. Run 'spindb start ${container.name}' to restart manually. ` +
+            `Original error: ${err.message}`,
+        )
+      }
+    }
+
+    return result
   }
 
   // Get connection string (MongoDB-compatible)
@@ -1280,7 +1490,8 @@ export class FerretDBEngine extends BaseEngine {
       const lastBrace = stdout.lastIndexOf('}')
       if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
         const stats = JSON.parse(stdout.substring(firstBrace, lastBrace + 1))
-        return stats?.dataSize || null
+        const dataSize = Number(stats?.dataSize)
+        return Number.isFinite(dataSize) && dataSize > 0 ? dataSize : null
       }
       return null
     } catch {