spindb 0.9.3 → 0.10.0

package/engines/mysql/restore.ts

@@ -4,7 +4,7 @@
  * Handles detecting backup formats and restoring MySQL dumps.
  */
 
-import { spawn } from 'child_process'
+import { spawn, type SpawnOptions } from 'child_process'
 import { createReadStream } from 'fs'
 import { open } from 'fs/promises'
 import { createGunzip } from 'zlib'
@@ -202,12 +202,20 @@ export async function restoreBackup(
   // Restore using mysql client
   // CLI: mysql -h 127.0.0.1 -P {port} -u root {db} < {file}
   // For compressed files: gunzip -c {file} | mysql ...
+
+  // Use plain spawn (no shell) so the executable path can be quoted when
+  // it contains spaces (e.g., 'C:\Program Files\...'). Using shell:true
+  // previously caused quoting issues on Windows.
+  const spawnOptions: SpawnOptions = {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }
+
   return new Promise((resolve, reject) => {
     const args = ['-h', '127.0.0.1', '-P', String(port), '-u', user, database]
 
-    const proc = spawn(mysql, args, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
+    logDebug('Restoring backup with mysql', { mysql, args, spawnOptions })
+
+    const proc = spawn(mysql, args, spawnOptions)
 
     // Pipe backup file to stdin, decompressing if necessary
     const fileStream = createReadStream(backupPath)
@@ -215,6 +223,10 @@ export async function restoreBackup(
     if (format.format === 'compressed') {
       // Decompress gzipped file before piping to mysql
       const gunzip = createGunzip()
+      if (!proc.stdin) {
+        reject(new Error('MySQL process stdin is not available, cannot restore backup'))
+        return
+      }
       fileStream.pipe(gunzip).pipe(proc.stdin)
 
       // Handle gunzip errors
@@ -222,16 +234,20 @@ export async function restoreBackup(
         reject(new Error(`Failed to decompress backup file: ${err.message}`))
       })
     } else {
+      if (!proc.stdin) {
+        reject(new Error('MySQL process stdin is not available, cannot restore backup'))
+        return
+      }
       fileStream.pipe(proc.stdin)
     }
 
     let stdout = ''
     let stderr = ''
 
-    proc.stdout.on('data', (data: Buffer) => {
+    proc.stdout?.on('data', (data: Buffer) => {
       stdout += data.toString()
     })
-    proc.stderr.on('data', (data: Buffer) => {
+    proc.stderr?.on('data', (data: Buffer) => {
       stderr += data.toString()
     })
 

package/engines/postgresql/backup.ts

@@ -4,9 +4,10 @@
  * Creates database backups in SQL or custom (.dump) format using pg_dump.
  */
 
-import { spawn } from 'child_process'
+import { spawn, type SpawnOptions } from 'child_process'
 import { stat } from 'fs/promises'
 import { configManager } from '../../core/config-manager'
+import { getWindowsSpawnOptions } from '../../core/platform-service'
 import { defaults } from '../../config/defaults'
 import type { ContainerConfig, BackupOptions, BackupResult } from '../../types'
 
@@ -61,9 +62,12 @@ export async function createBackup(
       outputPath,
     ]
 
-    const proc = spawn(pgDumpPath, args, {
+    const spawnOptions: SpawnOptions = {
       stdio: ['pipe', 'pipe', 'pipe'],
-    })
+      ...getWindowsSpawnOptions(),
+    }
+
+    const proc = spawn(pgDumpPath, args, spawnOptions)
 
     let stderr = ''
 

package/engines/postgresql/binary-manager.ts

@@ -12,6 +12,7 @@ import {
 import { getEngineDependencies } from '../../config/os-dependencies'
 import { getPostgresHomebrewPackage } from '../../config/engine-defaults'
 import { logDebug } from '../../core/error-handler'
+import { isWindows, platformService } from '../../core/platform-service'
 
 const execAsync = promisify(exec)
 
@@ -112,7 +113,7 @@ export async function getPostgresVersion(
  */
 export async function findBinaryPath(binary: string): Promise<string | null> {
   try {
-    const command = process.platform === 'win32' ? 'where' : 'which'
+    const command = isWindows() ? 'where' : 'which'
     const { stdout } = await execAsync(`${command} ${binary}`)
     return stdout.trim().split('\n')[0] || null
   } catch (error) {
@@ -133,12 +134,18 @@ export async function findBinaryPathFresh(
   const path = await findBinaryPath(binary)
   if (path) return path
 
-  // If not found, try to refresh PATH cache (especially after package updates)
+  // Windows doesn't need shell refresh - PATH is always current
+  if (isWindows()) {
+    return null
+  }
+
+  // If not found on Unix, try to refresh PATH cache (especially after package updates)
   try {
     // Force shell to re-evaluate PATH
     const shell = process.env.SHELL || '/bin/bash'
+    const shellConfig = shell.endsWith('zsh') ? '.zshrc' : '.bashrc'
     const { stdout } = await execWithTimeout(
-      `${shell} -c 'source ~/.${shell.endsWith('zsh') ? 'zshrc' : 'bashrc'} && which ${binary}'`,
+      `${shell} -c 'source ~/${shellConfig} && which ${binary}'`,
     )
     return stdout.trim().split('\n')[0] || null
   } catch (error) {
@@ -171,7 +178,7 @@ async function execWithTimeout(
 
     // Additional timeout safety
     setTimeout(() => {
-      child.kill('SIGTERM')
+      child.kill() // Cross-platform process termination
       reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`))
     }, timeoutMs)
   })
@@ -179,36 +186,44 @@ async function execWithTimeout(
 
 /**
  * Parse dump file to get required PostgreSQL version
+ * Cross-platform: reads file header directly using Node.js
  */
 export async function getDumpRequiredVersion(
   dumpPath: string,
 ): Promise<string | null> {
   try {
-    // Try to read pg_dump custom format header
-    const { stdout } = await execAsync(`file "${dumpPath}"`)
-    if (stdout.includes('PostgreSQL custom database dump')) {
-      // For custom format, we need to check the version in the dump
-      try {
-        const { stdout: hexdump } = await execAsync(
-          `hexdump -C "${dumpPath}" | head -5`,
-        )
-        // Look for version info in the header (simplified approach)
-        const versionMatch = hexdump.match(/(\d+)\.(\d+)/)
-        if (versionMatch) {
-          // If it's a recent dump, assume it needs the latest PostgreSQL
-          const majorVersion = parseInt(versionMatch[1])
-          if (majorVersion >= 15) {
-            return '15.0' // Minimum version for recent dumps
-          }
-        }
-      } catch (error) {
-        // If hexdump fails, fall back to checking error patterns
-        logDebug(`hexdump failed for ${dumpPath}`, {
-          error: error instanceof Error ? error.message : String(error),
-        })
+    // Read first 32 bytes of the file to check for PostgreSQL custom dump format
+    // Custom dump magic: "PGDMP" followed by version info
+    const { open } = await import('fs/promises')
+    const fileHandle = await open(dumpPath, 'r')
+    const buffer = Buffer.alloc(32)
+    await fileHandle.read(buffer, 0, 32, 0)
+    await fileHandle.close()
+
+    // Check for PostgreSQL custom dump format magic bytes: "PGDMP"
+    const header = buffer.toString('ascii', 0, 5)
+    if (header === 'PGDMP') {
+      // Bytes 5-6 contain version info in custom format
+      // Byte 5: major version, Byte 6: minor version, Byte 7: revision
+      const dumpMajor = buffer[5]
+      const dumpMinor = buffer[6]
+
+      logDebug(`Detected pg_dump custom format version: ${dumpMajor}.${dumpMinor}`)
+
+      // pg_dump version typically maps to PostgreSQL version
+      // If it's a recent dump format, require a recent PostgreSQL
+      if (dumpMajor >= 1 && dumpMinor >= 14) {
+        return '15.0' // Modern dump format needs modern PostgreSQL
       }
     }
 
+    // For plain SQL dumps or older formats, check if file looks like SQL
+    const textHeader = buffer.toString('utf-8', 0, 20)
+    if (textHeader.includes('--') || textHeader.includes('pg_dump')) {
+      // Plain SQL dump - any PostgreSQL version should work
+      return null
+    }
+
     // Fallback: if we can't determine, assume it needs a recent version
     return '15.0'
   } catch (error) {
@@ -229,9 +244,8 @@ export function isVersionCompatible(
   const current = parseFloat(currentVersion)
   const required = parseFloat(requiredVersion)
 
-  // Current version should be >= required version
-  // But not too far ahead (major version compatibility)
-  return current >= required && Math.floor(current) === Math.floor(required)
+  // PostgreSQL is forward-compatible: newer pg_restore can restore older dumps
+  return current >= required
 }
 
 /**
@@ -264,8 +278,9 @@ export async function getBinaryInfo(
 
   // Try to detect which package manager installed this binary
   let packageManager: string | undefined
+  const { platform } = platformService.getPlatformInfo()
   try {
-    if (process.platform === 'darwin') {
+    if (platform === 'darwin') {
       // On macOS, check if it's from Homebrew
       const { stdout } = await execAsync(
         'brew list postgresql@* 2>/dev/null || brew list libpq 2>/dev/null || true',
@@ -273,7 +288,7 @@ export async function getBinaryInfo(
       if (stdout.includes('postgresql') || stdout.includes('libpq')) {
         packageManager = 'brew'
       }
-    } else {
+    } else if (platform === 'linux') {
       // On Linux, check common package managers
       try {
         await execAsync('dpkg -S $(which pg_restore) 2>/dev/null')
@@ -287,6 +302,7 @@ export async function getBinaryInfo(
         }
       }
     }
+    // On Windows (win32), we don't detect package managers - user installs via choco/scoop/winget
   } catch {
     // Could not determine package manager
   }

package/engines/postgresql/edb-binary-urls.ts

@@ -0,0 +1,123 @@
+/**
+ * EDB Binary URL Builder for Windows
+ *
+ * EnterpriseDB (EDB) provides official PostgreSQL binaries for Windows.
+ * Unlike zonky.io which uses predictable Maven URLs, EDB uses file IDs.
+ *
+ * Download page: https://www.enterprisedb.com/download-postgresql-binaries
+ */
+
+import {
+  POSTGRESQL_VERSION_MAP,
+  SUPPORTED_MAJOR_VERSIONS,
+} from './version-maps'
+
+/**
+ * Mapping of PostgreSQL versions to EDB file IDs
+ * These IDs are from the EDB download page and need to be updated when new versions are released.
+ *
+ * Format: 'version' -> 'fileId'
+ *
+ * IMPORTANT: When updating POSTGRESQL_VERSION_MAP in version-maps.ts,
+ * also update this map with the corresponding EDB file IDs.
+ */
+export const EDB_FILE_IDS: Record<string, string> = {
+  // PostgreSQL 17.x
+  '17.7.0': '1259911',
+  '17': '1259911', // Alias for latest 17.x
+
+  // PostgreSQL 16.x
+  '16.11.0': '1259906',
+  '16': '1259906', // Alias for latest 16.x
+
+  // PostgreSQL 15.x
+  '15.15.0': '1259903',
+  '15': '1259903', // Alias for latest 15.x
+
+  // PostgreSQL 14.x
+  '14.20.0': '1259900',
+  '14': '1259900', // Alias for latest 14.x
+}
+
+// Re-export for backwards compatibility
+export { SUPPORTED_MAJOR_VERSIONS as WINDOWS_SUPPORTED_VERSIONS }
+
+/**
+ * Get the EDB download URL for a PostgreSQL version on Windows
+ *
+ * @param version - PostgreSQL version (e.g., '17', '17.7.0')
+ * @returns Download URL for the Windows binary ZIP
+ * @throws Error if version is not supported
+ */
+export function getEDBBinaryUrl(version: string): string {
+  // Try direct lookup first
+  let fileId = EDB_FILE_IDS[version]
+
+  // If not found, try to normalize version
+  if (!fileId) {
+    // Try major version
+    const major = version.split('.')[0]
+    const fullVersion = POSTGRESQL_VERSION_MAP[major]
+    if (fullVersion) {
+      fileId = EDB_FILE_IDS[fullVersion]
+    }
+  }
+
+  if (!fileId) {
+    throw new Error(
+      `Unsupported PostgreSQL version for Windows: ${version}. ` +
+        `Supported versions: ${SUPPORTED_MAJOR_VERSIONS.join(', ')}`,
+    )
+  }
+
+  return `https://sbp.enterprisedb.com/getfile.jsp?fileid=${fileId}`
+}
+
+/**
+ * Get the full version string for a major version on Windows
+ *
+ * @param majorVersion - Major version (e.g., '17')
+ * @returns Full version string (e.g., '17.7.0') or null if not supported
+ */
+export function getWindowsFullVersion(majorVersion: string): string | null {
+  return POSTGRESQL_VERSION_MAP[majorVersion] || null
+}
+
+/**
+ * Check if a version is supported on Windows
+ *
+ * @param version - Version to check (major or full)
+ * @returns true if the version is supported AND has an EDB file ID
+ */
+export function isWindowsVersionSupported(version: string): boolean {
+  // Check if we have a file ID for this version directly
+  if (EDB_FILE_IDS[version]) {
+    return true
+  }
+
+  // Check if it's a major version that maps to a full version with a file ID
+  const major = version.split('.')[0]
+  const fullVersion = POSTGRESQL_VERSION_MAP[major]
+  if (fullVersion && EDB_FILE_IDS[fullVersion]) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Get available Windows versions (for display purposes)
+ *
+ * @returns Record of major versions to their full versions
+ */
+export function getAvailableWindowsVersions(): Record<string, string[]> {
+  const grouped: Record<string, string[]> = {}
+  for (const major of SUPPORTED_MAJOR_VERSIONS) {
+    const fullVersion = POSTGRESQL_VERSION_MAP[major]
+    // Only include if we have a file ID for it
+    if (fullVersion && EDB_FILE_IDS[fullVersion]) {
+      grouped[major] = [fullVersion]
+    }
+  }
+  return grouped
+}

package/engines/postgresql/index.ts

@@ -1,12 +1,17 @@
 import { join } from 'path'
-import { spawn, exec } from 'child_process'
+import { spawn, exec, type SpawnOptions } from 'child_process'
 import { promisify } from 'util'
+import { existsSync } from 'fs'
 import { readFile, writeFile } from 'fs/promises'
 import { BaseEngine } from '../base-engine'
 import { binaryManager } from '../../core/binary-manager'
 import { processManager } from '../../core/process-manager'
 import { configManager } from '../../core/config-manager'
-import { platformService } from '../../core/platform-service'
+import {
+  platformService,
+  isWindows,
+  getWindowsSpawnOptions,
+} from '../../core/platform-service'
 import { paths } from '../../config/paths'
 import { defaults, getEngineDefaults } from '../../config/defaults'
 import {
@@ -32,6 +37,34 @@ import type {
 
 const execAsync = promisify(exec)
 
+/**
+ * Build a Windows-safe psql command string for either a file or inline SQL.
+ * This is exported for unit testing.
+ */
+export function buildWindowsPsqlCommand(
+  psqlPath: string,
+  port: number,
+  user: string,
+  db: string,
+  options: { file?: string; sql?: string },
+): string {
+  if (!options.file && !options.sql) {
+    throw new Error('Either file or sql option must be provided')
+  }
+
+  let cmd = `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${user} -d ${db}`
+
+  if (options.file) {
+    cmd += ` -f "${options.file}"`
+  } else if (options.sql) {
+    // Escape double quotes in the SQL so the outer double quotes are preserved
+    const escaped = options.sql.replace(/"/g, '\\"')
+    cmd += ` -c "${escaped}"`
+  }
+
+  return cmd
+}
+
 export class PostgreSQLEngine extends BaseEngine {
   name = 'postgresql'
   displayName = 'PostgreSQL'
@@ -118,13 +151,27 @@ export class PostgreSQLEngine extends BaseEngine {
 
   /**
    * Ensure PostgreSQL binaries are available
+   * Also registers client tools (psql, pg_dump, etc.) in config after download
    */
   async ensureBinaries(
     version: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
     const { platform: p, arch: a } = this.getPlatformInfo()
-    return binaryManager.ensureInstalled(version, p, a, onProgress)
+    const binPath = await binaryManager.ensureInstalled(version, p, a, onProgress)
+
+    // Register client tools from downloaded binaries in config
+    // This ensures dependency checks find them without requiring system installation
+    const ext = platformService.getExecutableExtension()
+    const clientTools = ['psql', 'pg_dump', 'pg_restore', 'pg_basebackup'] as const
+    for (const tool of clientTools) {
+      const toolPath = join(binPath, 'bin', `${tool}${ext}`)
+      if (existsSync(toolPath)) {
+        await configManager.setBinaryPath(tool, toolPath, 'bundled')
+      }
+    }
+
+    return binPath
   }
 
   /**
@@ -144,7 +191,8 @@ export class PostgreSQLEngine extends BaseEngine {
     options: Record<string, unknown> = {},
   ): Promise<string> {
     const binPath = this.getBinaryPath(version)
-    const initdbPath = join(binPath, 'bin', 'initdb')
+    const ext = platformService.getExecutableExtension()
+    const initdbPath = join(binPath, 'bin', `initdb${ext}`)
     const dataDir = paths.getContainerDataPath(containerName, {
       engine: this.name,
     })
@@ -231,7 +279,8 @@ export class PostgreSQLEngine extends BaseEngine {
   ): Promise<{ port: number; connectionString: string }> {
     const { name, version, port } = container
     const binPath = this.getBinaryPath(version)
-    const pgCtlPath = join(binPath, 'bin', 'pg_ctl')
+    const ext = platformService.getExecutableExtension()
+    const pgCtlPath = join(binPath, 'bin', `pg_ctl${ext}`)
     const dataDir = paths.getContainerDataPath(name, { engine: this.name })
     const logFile = paths.getContainerLogPath(name, { engine: this.name })
 
@@ -254,7 +303,8 @@ export class PostgreSQLEngine extends BaseEngine {
   async stop(container: ContainerConfig): Promise<void> {
     const { name, version } = container
     const binPath = this.getBinaryPath(version)
-    const pgCtlPath = join(binPath, 'bin', 'pg_ctl')
+    const ext = platformService.getExecutableExtension()
+    const pgCtlPath = join(binPath, 'bin', `pg_ctl${ext}`)
     const dataDir = paths.getContainerDataPath(name, { engine: this.name })
 
     await processManager.stop(pgCtlPath, dataDir)
@@ -266,7 +316,8 @@ export class PostgreSQLEngine extends BaseEngine {
   async status(container: ContainerConfig): Promise<StatusResult> {
     const { name, version } = container
     const binPath = this.getBinaryPath(version)
-    const pgCtlPath = join(binPath, 'bin', 'pg_ctl')
+    const ext = platformService.getExecutableExtension()
+    const pgCtlPath = join(binPath, 'bin', `pg_ctl${ext}`)
     const dataDir = paths.getContainerDataPath(name, { engine: this.name })
 
     return processManager.status(pgCtlPath, dataDir)
@@ -370,6 +421,11 @@ export class PostgreSQLEngine extends BaseEngine {
     const db = database || 'postgres'
     const psqlPath = await this.getPsqlPath()
 
+    const spawnOptions: SpawnOptions = {
+      stdio: 'inherit',
+      ...getWindowsSpawnOptions(),
+    }
+
     return new Promise((resolve, reject) => {
       const proc = spawn(
         psqlPath,
@@ -383,7 +439,7 @@ export class PostgreSQLEngine extends BaseEngine {
           '-d',
           db,
         ],
-        { stdio: 'inherit' },
+        spawnOptions,
       )
 
       proc.on('error', (err: NodeJS.ErrnoException) => {
@@ -405,10 +461,14 @@ export class PostgreSQLEngine extends BaseEngine {
     const { port } = container
     const psqlPath = await this.getPsqlPath()
 
+    // On Windows, single quotes don't work in cmd.exe - use double quotes and escape inner quotes
+    const sql = `CREATE DATABASE "${database}"`
+    const cmd = isWindows()
+      ? `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c "${sql.replace(/"/g, '\\"')}"`
+      : `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c '${sql}'`
+
     try {
-      await execAsync(
-        `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c 'CREATE DATABASE "${database}"'`,
-      )
+      await execAsync(cmd)
     } catch (error) {
       const err = error as Error
       // Ignore "database already exists" error
@@ -429,10 +489,14 @@ export class PostgreSQLEngine extends BaseEngine {
     const { port } = container
     const psqlPath = await this.getPsqlPath()
 
+    // On Windows, single quotes don't work in cmd.exe - use double quotes and escape inner quotes
+    const sql = `DROP DATABASE IF EXISTS "${database}"`
+    const cmd = isWindows()
+      ? `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c "${sql.replace(/"/g, '\\"')}"`
+      : `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c '${sql}'`
+
     try {
-      await execAsync(
-        `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c 'DROP DATABASE IF EXISTS "${database}"'`,
-      )
+      await execAsync(cmd)
     } catch (error) {
       const err = error as Error
       // Ignore "database does not exist" error
@@ -457,9 +521,12 @@ export class PostgreSQLEngine extends BaseEngine {
     try {
       const psqlPath = await this.getPsqlPath()
       // Query pg_database_size for the specific database
-      const { stdout } = await execAsync(
-        `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -t -A -c "SELECT pg_database_size('${db}')"`,
-      )
+      // On Windows, use escaped double quotes; on Unix, use single quotes
+      const sql = `SELECT pg_database_size('${db}')`
+      const cmd = isWindows()
+        ? `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -t -A -c "${sql.replace(/'/g, "''")}"`
+        : `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -t -A -c "${sql}"`
+      const { stdout } = await execAsync(cmd)
       const size = parseInt(stdout.trim(), 10)
       return isNaN(size) ? null : size
     } catch {
@@ -480,13 +547,15 @@ export class PostgreSQLEngine extends BaseEngine {
   ): Promise<DumpResult> {
     const pgDumpPath = await this.getPgDumpPath()
 
+    const spawnOptions: SpawnOptions = {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...getWindowsSpawnOptions(),
+    }
+
     return new Promise((resolve, reject) => {
-      // Use custom format (-Fc) for best compatibility and compression
       const args = [connectionString, '-Fc', '-f', outputPath]
 
-      const proc = spawn(pgDumpPath, args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-      })
+      const proc = spawn(pgDumpPath, args, spawnOptions)
 
       let stdout = ''
       let stderr = ''
@@ -544,6 +613,20 @@ export class PostgreSQLEngine extends BaseEngine {
     const db = options.database || container.database || 'postgres'
     const psqlPath = await this.getPsqlPath()
 
+    // On Windows, build a single command string and use exec to avoid
+    // passing an args array with shell:true (DEP0190 and quoting issues).
+    if (isWindows()) {
+      const cmd = buildWindowsPsqlCommand(psqlPath, port, defaults.superuser, db, options)
+      try {
+        await execAsync(cmd)
+        return
+      } catch (error) {
+        const err = error as Error
+        throw new Error(`psql failed: ${err.message}`)
+      }
+    }
+
+    // Non-Windows: spawn directly with args (no shell)
     const args = [
       '-h',
       '127.0.0.1',
@@ -563,8 +646,12 @@ export class PostgreSQLEngine extends BaseEngine {
       throw new Error('Either file or sql option must be provided')
     }
 
+    const spawnOptions: SpawnOptions = {
+      stdio: 'inherit',
+    }
+
     return new Promise((resolve, reject) => {
-      const proc = spawn(psqlPath, args, { stdio: 'inherit' })
+      const proc = spawn(psqlPath, args, spawnOptions)
 
       proc.on('error', (err: NodeJS.ErrnoException) => {
         reject(err)

package/engines/postgresql/version-maps.ts

@@ -0,0 +1,63 @@
+/**
+ * PostgreSQL Version Maps
+ *
+ * Shared version mappings used by both zonky.io (macOS/Linux) and EDB (Windows).
+ * Both sources use the same PostgreSQL releases.
+ *
+ * When updating versions:
+ * 1. Check zonky.io Maven Central for new versions:
+ *    https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-darwin-arm64v8/
+ * 2. Check EDB download page for matching Windows versions:
+ *    https://www.enterprisedb.com/download-postgresql-binaries
+ * 3. Update POSTGRESQL_VERSION_MAP with new full versions
+ * 4. Update EDB_FILE_IDS in edb-binary-urls.ts with new file IDs
+ */
+
+/**
+ * Map of major PostgreSQL versions to their latest stable patch versions.
+ * Used for both zonky.io (macOS/Linux) and EDB (Windows) binaries.
+ */
+export const POSTGRESQL_VERSION_MAP: Record<string, string> = {
+  '14': '14.20.0',
+  '15': '15.15.0',
+  '16': '16.11.0',
+  '17': '17.7.0',
+}
+
+/**
+ * Supported major PostgreSQL versions.
+ * Derived from POSTGRESQL_VERSION_MAP keys.
+ */
+export const SUPPORTED_MAJOR_VERSIONS = Object.keys(POSTGRESQL_VERSION_MAP)
+
+/**
+ * Get the full version string for a major version.
+ *
+ * @param majorVersion - Major version (e.g., '17')
+ * @returns Full version string (e.g., '17.7.0') or null if not supported
+ */
+export function getFullVersion(majorVersion: string): string | null {
+  return POSTGRESQL_VERSION_MAP[majorVersion] || null
+}
+
+/**
+ * Normalize a version string to X.Y.Z format.
+ *
+ * @param version - Version string (e.g., '17', '17.7', '17.7.0')
+ * @returns Normalized version (e.g., '17.7.0')
+ */
+export function normalizeVersion(version: string): string {
+  // If it's a major version only, use the map
+  const fullVersion = POSTGRESQL_VERSION_MAP[version]
+  if (fullVersion) {
+    return fullVersion
+  }
+
+  // Normalize to X.Y.Z format
+  const parts = version.split('.')
+  if (parts.length === 2) {
+    return `${version}.0`
+  }
+
+  return version
+}